Initial commit

Author: KOLANICH

.ci/pythonPackagesToInstallFromGit.txt

@@ -0,0 +1 @@
+https://github.com/prebuilder/AnyVer.py.git

.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+charset = utf-8
+indent_style = tab
+indent_size = 4
+insert_final_newline = true
+end_of_line = lf
+
+[*.{yml,yaml}]
+indent_style = space
+indent_size = 2

.github/.templateMarker

@@ -0,0 +1 @@
+KOLANICH/python_project_boilerplate.py

.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    allow:
+      - dependency-type: "all"

.github/workflows/CI.yml

@@ -0,0 +1,15 @@
+name: CI
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: typical python workflow
+        uses: KOLANICH-GHActions/typical-python-workflow@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -0,0 +1,17 @@
+__pycache__
+*.pyc
+*.pyo
+/*.egg-info
+/build
+/dist
+/.eggs
+*.sqlite3
+*.sqlite
+/.mypy_cache
+*.py,cover
+/.coverage
+/rspec.xml
+/monkeytype.sqlite3
+/*.srctrldb
+/*.srctrlbm
+/*.srctrlprj

.gitlab-ci.yml

@@ -0,0 +1,58 @@
+#image: pypy:latest
+image: registry.gitlab.com/kolanich-subgroups/docker-images/fixed_python:latest
+stages:
+  - dependencies
+  - build
+  - test
+  - trigger
+
+variables:
+  DOCKER_DRIVER: overlay2
+  SAST_ANALYZER_IMAGE_TAG: latest
+  SAST_DISABLE_DIND: "true"
+
+include:
+  - template: SAST.gitlab-ci.yml
+  #- template: DAST.gitlab-ci.yml
+  #- template: License-Management.gitlab-ci.yml
+  #- template: Container-Scanning.gitlab-ci.yml
+  #- template: Dependency-Scanning.gitlab-ci.yml
+  - template: Code-Quality.gitlab-ci.yml
+
+
+build:
+  tags:
+    - shared
+  stage: build
+  variables:
+    GIT_DEPTH: "1"
+    PYTHONUSERBASE: ${CI_PROJECT_DIR}/python_user_packages
+
+  before_script:
+    - export PYTHON_MODULES_DIR=${PYTHONUSERBASE}/lib/python3.8
+    - export EXECUTABLE_DEPENDENCIES_DIR=${PYTHONUSERBASE}/bin
+    - export PATH="$PATH:$EXECUTABLE_DEPENDENCIES_DIR" # don't move into `variables` any of them, it is unordered
+    - mkdir ./wheels
+    - pip install --upgrade --pre --user git+https://gitlab.com/KOLANICH/AnyVer.py.git
+
+  script:
+    - python3 ./setup.py bdist_wheel
+    - mv ./dist/*.whl ./wheels/PackageRef-0.CI_python-py3-none-any.whl
+    - pip3 install --upgrade --pre --user ./wheels/PackageRef-0.CI_python-py3-none-any.whl
+    - coverage run --source=PackageRef --branch -m pytest --junitxml=./rspec.xml ./tests/tests.py
+    - coverage report -m
+    - coverage xml
+
+  coverage: /^TOTAL\\s+.+?(\\d{1,3}%)$/
+
+  cache:
+    paths:
+      - $PYTHONUSERBASE
+
+  artifacts:
+    paths:
+      - wheels
+    reports:
+      junit: ./rspec.xml
+      cobertura: ./coverage.xml
+

Code_Of_Conduct.md

@@ -0,0 +1 @@
+No codes of conduct!

MANIFEST.in

@@ -0,0 +1,4 @@
+include UNLICENSE
+include *.md
+include tests
+include .editorconfig

PackageRef/__init__.py

@@ -0,0 +1,169 @@
+__all__ = ("PackageRef", "PackageRef", "VersionedPackageRef")
+import inspect
+import typing
+
+
+class IncompatibleVersionPostfix:
+	__slots__ = ()
+
+	def __call__(self, ver: "BasePackageRef"):
+		raise NotImplementedError
+
+
+class IncompatibleVersionPostfixDot(IncompatibleVersionPostfix):
+	__slots__ = ("count",)
+
+	def __init__(self, count: int) -> None:
+		self.count = count
+
+	def __call__(self, ver: "BasePackageRef") -> str:
+		return ".".join(map(str, ver[: self.count]))
+
+
+class IncompatibleVersionPostfixFormat(IncompatibleVersionPostfix):
+	__slots__ = ("format",)
+
+	def __init__(self, format: str) -> None:
+		self.format = format
+
+	def __call__(self, ver: "BasePackageRef") -> str:
+		return self.format.format(*ver)
+
+
+versionsPostfixesTypesMapping = {
+	int: IncompatibleVersionPostfixDot,
+	str: IncompatibleVersionPostfixFormat,
+}
+
+BasePackageRefT = typing.Type["BasePackageRef"]
+
+
+class BasePackageRef:
+	__slots__ = ("name", "arch", "versionPostfix")
+
+	def __init__(self, name: str, arch: str = "amd64", versionPostfix: typing.Union[str, int, callable, IncompatibleVersionPostfix] = None) -> None:
+		self.name = name
+		self.arch = arch
+
+		argType = type(versionPostfix)
+		if argType in versionsPostfixesTypesMapping:
+			versionPostfix = versionsPostfixesTypesMapping[argType](versionPostfix)
+		self.versionPostfix = versionPostfix
+
+	_reprOrder = ("name", "arch")
+
+	def _metadataInnerReprStr(self):
+		return ", ".join(vn + "=" + repr(getattr(self, vn)) for vn in self.__class__._reprOrder)
+
+	def asTuple(self) -> typing.Tuple[str, str]:
+		return (self.name, self.arch)
+
+	def recreatorFull(self, cls: BasePackageRefT) -> typing.Mapping[str, typing.Any]:
+		s = inspect.signature(cls.__init__)
+		dic = {}
+		pIter = iter(s.parameters.values())
+		selfArg = next(pIter)
+		assert selfArg.name == "self"
+
+		for p in pIter:
+			n = p.name
+			dic[n] = getattr(self, n)
+		return dic
+
+	def downgrade(self) -> "BasePackageRef":
+		mro = self.__class__.mro()
+		cls = mro[1]
+		assert issubclass(cls, __class__), "Cannot downgrade lower than " + __class__.__name__ + " :" + repr(mro)
+		return self.clone(cls=cls)
+
+	def clone(self, cls: typing.Optional[BasePackageRefT] = None, **kwargs) -> "BasePackageRef":
+		if cls is None:
+			cls = self.__class__
+
+		if issubclass(cls, self.__class__):  # upgrade or clone
+			k = self.recreatorFull(self.__class__)
+		elif issubclass(self.__class__, cls):  # downgrade or clone
+			k = self.recreatorFull(cls)
+		else:
+			raise ValueError("Only upgrades, downgrades and clones are allowed")
+
+		k.update(kwargs)
+		res = cls(**k)
+		return res
+
+	def __hash__(self) -> int:
+		return hash(self.asTuple())
+
+	def __eq__(self, other: "BasePackageRef") -> bool:
+		return isinstance(other, __class__) and self.asTuple() == other.asTuple()
+
+	def __repr__(self) -> str:
+		return self.__class__.__name__ + "(" + self._metadataInnerReprStr() + ",...)"
+
+	def toPath(self):
+		return "_".join(str(el) for el in self.asTuple()).replace("/", "_").replace("\\", "_")
+
+	def toName(self) -> str:
+		return self.name
+
+	def __str__(self) -> str:
+		return self.toName() + (":" + self.arch if self.arch is not None else "")
+
+
+class PackageRef(BasePackageRef):
+	"""A reference to a package. Used to identify a package in a system installed package manager. It is an incomplete class without version"""
+
+	__slots__ = ("group",)
+
+	def __init__(self, name: str, arch: str = "amd64", group: typing.Optional[str] = None, versionPostfix: int = 0) -> None:
+		super().__init__(name=name, arch=arch, versionPostfix=versionPostfix)
+		self.group = group
+
+	_reprOrder = ("name", "group", "arch")
+
+	def asTuple(self) -> typing.Tuple[str, str, str]:
+		return (self.name, self.arch, self.group)
+
+	def __str__(self) -> str:
+		return (str(self.group) + "@" if self.group is not None else "") + super().__str__()
+
+
+try:
+	from AnyVer import AnyVer, _AnyVer
+
+	class VersionedPackageRef(PackageRef):
+		"""A reference to a package. Used to identify a package in a system installed package manager. Also used to identify a package globally"""
+
+		__slots__ = ("_version",)
+
+		def __init__(self, name: str, arch: str = "amd64", group: typing.Optional[str] = None, version: typing.Optional[typing.Union[str, _AnyVer]] = None, versionPostfix: int = 0) -> None:
+			super().__init__(name, arch=arch, group=group, versionPostfix=versionPostfix)
+			assert version is not None
+			if isinstance(version, str):
+				version = AnyVer(version)
+			self.version = version
+
+		@property
+		def version(self):
+			return self._version
+
+		@version.setter
+		def version(self, version: typing.Optional[typing.Union[str, _AnyVer]]):
+			if version is not None:
+				version = AnyVer(version)
+
+			self._version = version
+
+		def asTuple(self) -> typing.Tuple[str, str, str, _AnyVer]:
+			return super().asTuple() + (self.version,)
+
+		_reprOrder = PackageRef._reprOrder + ("version",)
+
+		def toName(self) -> str:
+			return super().toName() + (self.versionPostfix(self.version) if self.versionPostfix else "")
+
+		def __str__(self) -> str:
+			return super().__str__() + " " + str(self.version)
+
+except ImportError:
+	warnings.warn("`AnyVer` is not present, so " + VersionedPackageRef.__name__ + " is not available")