11662562960

Committed 29 Oct 2024 03:09PM UTC coverage: 67.508% (-0.08%) from 67.591%

Build # 11662562960

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #564 from SPF-OST/560-black-change-line-length-to-pep8-standard-of-79-and-check-ci-reaction

changed line length in black to 79

Run Details

1054 of 1475 new or added lines in 174 files covered. (71.46%)

150 existing lines in 74 files now uncovered.

10399 of 15404 relevant lines covered (67.51%)

0.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/trnsysGUI/setup.py

import dataclasses as _dc
import importlib.metadata as _imeta
import pathlib as _pl
import re as _re
import subprocess as _sp
import sys as _sys
import typing as _tp

import packaging.version as _pver

import pytrnsys.utils.result as _res

_BASE_DIRECTORY = _pl.Path(__file__).parents[1]


@_dc.dataclass(frozen=True, order=True)
class _VersionedPackage:
    name: str = _dc.field(compare=False)
    canonicalName: str
    version: str

    _VERSIONED_PACKAGE_REGEX = _re.compile(r"^([^#\s=]+)==([^#\s=]+)$")

    @classmethod
    def create(cls, serializedVersionedPackage: str) -> "_VersionedPackage":
        match = cls._VERSIONED_PACKAGE_REGEX.match(serializedVersionedPackage)
        if not match:
            raise ValueError(
                f'Not a package version specification: "{serializedVersionedPackage}"'
            )

        name = match.group(1)
        version = match.group(2)

        canonicalName = cls._getCanonicalPipPackageName(name)

        return _VersionedPackage(name, canonicalName, version)

    @staticmethod
    def _getCanonicalPipPackageName(name) -> str:
        return _re.sub(r"[\-_.]+", "_", name).lower()

    def __str__(self):
        return f"{self.name}=={self.version}"


def setup() -> _res.Result[None]:
    isDeveloperInstallResult = _isDeveloperInstall()
    if _res.isError(isDeveloperInstallResult):
        return _res.error(isDeveloperInstallResult)

    isDeveloperInstall = _res.value(isDeveloperInstallResult)
    if not isDeveloperInstall:
        return None

    requirementsResult = _checkRequirements()
    if _res.isError(requirementsResult):
        return _res.error(requirementsResult)

    _generateCodeFromQtCreatorUiFiles()

    return None


def _isDeveloperInstall() -> _res.Result[bool]:
    versionResult = _getPytrnsysVersion()
    if _res.isError(versionResult):
        return _res.error(versionResult)

    version = _res.value(versionResult)
    localVersionPart = version.local

    isDeveloperInstall = (
        localVersionPart.endswith("dev") if localVersionPart else False
    )

    return isDeveloperInstall


def _getPytrnsysVersion() -> _res.Result[_pver.Version]:
    serializedVersion = _imeta.version("pytrnsys-gui")
    try:
        return _pver.parse(serializedVersion)
    except _pver.InvalidVersion as invalidVersion:
        error = _res.error(
            f"Could not parse version of `pytrnsys-gui`:\n\t{invalidVersion}"
        )
        return error


def _checkRequirements() -> _res.Result[None]:
    release3rdPartyTxtFilePath = (
        _BASE_DIRECTORY / "requirements" / "release-3rd-party.txt"
    )

    requiredVersions = _getRequiredVersions(release3rdPartyTxtFilePath)

    result = _getInstalledNonEditableVersions()
    if _res.isError(result):
        return _res.error(result)
    installedVersions = _res.value(result)

    missingVersions = requiredVersions - installedVersions
    if missingVersions:
        formattedMissingVersions = "\n".join(
            f"\t{v}" for v in sorted(missingVersions)
        )
        errorMessage = f"""\
The following packages are required but not installed:
{formattedMissingVersions}

Probably the file {release3rdPartyTxtFilePath} was changed by
someone else on GitHub. Consider re-running (don't forget to
activate your virtual environment first)

    `python -m pip install requirements\\dev.txt`

(or

    `python -m piptools sync requirements\\dev.txt`

if you're using `pip-tools` [if you don't know what that means
use the command just above])

followed by

    `python setup.py egg_info -b dev`
"""
        return _res.Error(errorMessage)

    return None


def _getInstalledNonEditableVersions() -> (
    _res.Result[_tp.Set[_VersionedPackage]]
):
    args = [_sys.executable, "-m", "pip", "freeze", "--no-color"]
    completedPipFreezeProcess = _sp.run(
        args, capture_output=True, text=True, check=True
    )
    serializedInstalledVersions = completedPipFreezeProcess.stdout.split("\n")
    serializedNonEditableInstalledVersions = [
        v
        for v in serializedInstalledVersions
        if v.strip() and not v.startswith("-e")
    ]
    try:
        installedVersions = {
            _VersionedPackage.create(v)
            for v in serializedNonEditableInstalledVersions
        }
    except ValueError as valueError:
        errorMessage = f"""\
Could not parse `pip` freeze output:

    {valueError}

Please try updating `pip` from within your virtual environment like so:

    (venv) C:\\...\\pytrnsys_gui> python -m pip install --upgrade pip==22.3.1
"""
        return _res.Error(errorMessage)

    return installedVersions


def _getRequiredVersions(
    release3rdPartyTxtFilePath: _pl.Path,
) -> _tp.Set[_VersionedPackage]:
    lines = release3rdPartyTxtFilePath.read_text().split()

    requiredVersions = set()
    for line in lines:
        try:
            requiredVersion = _VersionedPackage.create(line)
        except ValueError:
            continue

        requiredVersions.add(requiredVersion)
    return requiredVersions


def _generateCodeFromQtCreatorUiFiles():
    uiGenerateFilePath = (
        _pl.Path(__file__).parent.parent
        / "dev-tools"
        / "generateGuiClassesFromQtCreatorStudioUiFiles.py"
    )
    cmd = [_sys.executable, uiGenerateFilePath]
    _sp.run(cmd, check=True)

1	import dataclasses as _dc	×
2	import importlib.metadata as _imeta	×
3	import pathlib as _pl	×
4	import re as _re	×
5	import subprocess as _sp	×
6	import sys as _sys	×
7	import typing as _tp	×
8
9	import packaging.version as _pver	×
10
11	import pytrnsys.utils.result as _res	×
12
13	_BASE_DIRECTORY = _pl.Path(__file__).parents[1]	×
14
15
16	@_dc.dataclass(frozen=True, order=True)	×
17	class _VersionedPackage:	×
18	name: str = _dc.field(compare=False)	×
19	canonicalName: str	×
20	version: str	×
21
22	_VERSIONED_PACKAGE_REGEX = _re.compile(r"^([^#\s=]+)==([^#\s=]+)$")	×
23
24	@classmethod	×
25	def create(cls, serializedVersionedPackage: str) -> "_VersionedPackage":	×
26	match = cls._VERSIONED_PACKAGE_REGEX.match(serializedVersionedPackage)	×
27	if not match:	×
NEW 28	raise ValueError(	×
29	f'Not a package version specification: "{serializedVersionedPackage}"'
30	)
31
32	name = match.group(1)	×
33	version = match.group(2)	×
34
35	canonicalName = cls._getCanonicalPipPackageName(name)	×
36
37	return _VersionedPackage(name, canonicalName, version)	×
38
39	@staticmethod	×
40	def _getCanonicalPipPackageName(name) -> str:	×
41	return _re.sub(r"[\-_.]+", "_", name).lower()	×
42
43	def __str__(self):	×
44	return f"{self.name}=={self.version}"	×
45
46
47	def setup() -> _res.Result[None]:	×
48	isDeveloperInstallResult = _isDeveloperInstall()	×
49	if _res.isError(isDeveloperInstallResult):	×
50	return _res.error(isDeveloperInstallResult)	×
51
52	isDeveloperInstall = _res.value(isDeveloperInstallResult)	×
53	if not isDeveloperInstall:	×
54	return None	×
55
56	requirementsResult = _checkRequirements()	×
57	if _res.isError(requirementsResult):	×
58	return _res.error(requirementsResult)	×
59
60	_generateCodeFromQtCreatorUiFiles()	×
61
62	return None	×
63
64
65	def _isDeveloperInstall() -> _res.Result[bool]:	×
66	versionResult = _getPytrnsysVersion()	×
67	if _res.isError(versionResult):	×
68	return _res.error(versionResult)	×
69
70	version = _res.value(versionResult)	×
71	localVersionPart = version.local	×
72
NEW 73	isDeveloperInstall = (	×
74	localVersionPart.endswith("dev") if localVersionPart else False
75	)
76
77	return isDeveloperInstall	×
78
79
80	def _getPytrnsysVersion() -> _res.Result[_pver.Version]:	×
81	serializedVersion = _imeta.version("pytrnsys-gui")	×
82	try:	×
83	return _pver.parse(serializedVersion)	×
84	except _pver.InvalidVersion as invalidVersion:	×
NEW 85	error = _res.error(	×
86	f"Could not parse version of `pytrnsys-gui`:\n\t{invalidVersion}"
87	)
UNCOV 88	return error	×
89
90
91	def _checkRequirements() -> _res.Result[None]:	×
NEW 92	release3rdPartyTxtFilePath = (	×
93	_BASE_DIRECTORY / "requirements" / "release-3rd-party.txt"
94	)
95
96	requiredVersions = _getRequiredVersions(release3rdPartyTxtFilePath)	×
97
98	result = _getInstalledNonEditableVersions()	×
99	if _res.isError(result):	×
100	return _res.error(result)	×
101	installedVersions = _res.value(result)	×
102
103	missingVersions = requiredVersions - installedVersions	×
104	if missingVersions:	×
NEW 105	formattedMissingVersions = "\n".join(	×
106	f"\t{v}" for v in sorted(missingVersions)
107	)
UNCOV 108	errorMessage = f"""\	×
109	The following packages are required but not installed:
110	{formattedMissingVersions}
111
112	Probably the file {release3rdPartyTxtFilePath} was changed by
113	someone else on GitHub. Consider re-running (don't forget to
114	activate your virtual environment first)
115
116	`python -m pip install requirements\\dev.txt`
117
118	(or
119
120	`python -m piptools sync requirements\\dev.txt`
121
122	if you're using `pip-tools` [if you don't know what that means
123	use the command just above])
124
125	followed by
126
127	`python setup.py egg_info -b dev`
128	"""
129	return _res.Error(errorMessage)	×
130
131	return None	×
132
133
NEW 134	def _getInstalledNonEditableVersions() -> (	×
135	_res.Result[_tp.Set[_VersionedPackage]]
136	):
137	args = [_sys.executable, "-m", "pip", "freeze", "--no-color"]	×
NEW 138	completedPipFreezeProcess = _sp.run(	×
139	args, capture_output=True, text=True, check=True
140	)
141	serializedInstalledVersions = completedPipFreezeProcess.stdout.split("\n")	×
142	serializedNonEditableInstalledVersions = [	×
143	v
144	for v in serializedInstalledVersions
145	if v.strip() and not v.startswith("-e")
146	]
147	try:	×
NEW 148	installedVersions = {	×
149	_VersionedPackage.create(v)
150	for v in serializedNonEditableInstalledVersions
151	}
152	except ValueError as valueError:	×
153	errorMessage = f"""\	×
154	Could not parse `pip` freeze output:
155
156	{valueError}
157
158	Please try updating `pip` from within your virtual environment like so:
159
160	(venv) C:\\...\\pytrnsys_gui> python -m pip install --upgrade pip==22.3.1
161	"""
162	return _res.Error(errorMessage)	×
163
164	return installedVersions	×
165
166
NEW 167	def _getRequiredVersions(	×
168	release3rdPartyTxtFilePath: _pl.Path,
169	) -> _tp.Set[_VersionedPackage]:
UNCOV 170	lines = release3rdPartyTxtFilePath.read_text().split()	×
171
172	requiredVersions = set()	×
173	for line in lines:	×
174	try:	×
175	requiredVersion = _VersionedPackage.create(line)	×
176	except ValueError:	×
177	continue	×
178
179	requiredVersions.add(requiredVersion)	×
180	return requiredVersions	×
181
182
183	def _generateCodeFromQtCreatorUiFiles():	×
184	uiGenerateFilePath = (	×
185	_pl.Path(__file__).parent.parent
186	/ "dev-tools"
187	/ "generateGuiClassesFromQtCreatorStudioUiFiles.py"
188	)
189	cmd = [_sys.executable, uiGenerateFilePath]	×
190	_sp.run(cmd, check=True)	×

SPF-OST / pytrnsys_gui / 11662562960

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous