ps-version 0.2.8__tar.gz

ps_version-0.2.8/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: ps-version
+Version: 0.2.8
+Summary: 
+Requires-Python: >=3.10,<3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13

ps_version-0.2.8/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name        = "ps-version"
+description = ""
+requires-python = ">=3.10,<3.14"
+version = "0.2.8"
+
+[tool.poetry]
+packages = [ { include = "ps/version", from = "src" } ]
+
+[tool.ps-plugin]
+host-project = "../.."
+
+[build-system]
+requires    = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

ps_version-0.2.8/src/ps/version/__init__.py

@@ -0,0 +1,20 @@
+from ._version import Version, VersionFormatter
+from ._version_constraint import VersionConstraint
+from ._version_metadata import VersionMetadata
+from ._version_prerelease import VersionPreRelease
+from ._version_standard import VersionStandard
+from .parsers import CalVerParser, LooseParser, NuGetParser, PEP440Parser, SemVerParser
+
+__all__ = [
+    "Version",
+    "VersionFormatter",
+    "VersionConstraint",
+    "VersionMetadata",
+    "VersionPreRelease",
+    "VersionStandard",
+    "CalVerParser",
+    "LooseParser",
+    "NuGetParser",
+    "PEP440Parser",
+    "SemVerParser",
+]

ps_version-0.2.8/src/ps/version/_version.py

@@ -0,0 +1,287 @@
+# ruff: noqa: PLC0415
+from dataclasses import dataclass
+from functools import lru_cache, total_ordering
+from typing import Optional
+
+from ._version_metadata import VersionMetadata
+from ._version_prerelease import VersionPreRelease
+from ._version_constraint import VersionConstraint
+from ._version_standard import VersionStandard
+
+
+_PEP440_CANONICAL_LABELS: dict[str, str] = {
+    "alpha": "a",
+    "beta": "b",
+    "c": "rc",
+    "pre": "rc",
+    "preview": "rc",
+}
+
+
+@lru_cache
+def _get_parsers() -> list:
+    from .parsers import CalVerParser, LooseParser, NuGetParser, PEP440Parser, SemVerParser
+
+    return [
+        PEP440Parser(),
+        SemVerParser(),
+        NuGetParser(),
+        CalVerParser(),
+        LooseParser(),
+    ]
+
+
+@total_ordering
+@dataclass(slots=True)
+class Version:
+    major: int = 0
+    minor: Optional[int] = None
+    patch: Optional[int] = None
+    rev: Optional[int] = None
+    pre: Optional[VersionPreRelease] = None
+    post: Optional[int] = None
+    dev: Optional[int] = None
+    metadata: Optional[VersionMetadata] = None
+
+    def __post_init__(self) -> None:
+        if self.major < 0:
+            raise ValueError(f"major must be non-negative, got {self.major}")
+        if self.minor is not None and self.minor < 0:
+            raise ValueError(f"minor must be non-negative, got {self.minor}")
+        if self.patch is not None and self.patch < 0:
+            raise ValueError(f"patch must be non-negative, got {self.patch}")
+        if self.rev is not None and self.rev < 0:
+            raise ValueError(f"rev must be non-negative, got {self.rev}")
+        if self.post is not None and self.post < 0:
+            raise ValueError(f"post must be non-negative, got {self.post}")
+        if self.dev is not None and self.dev < 0:
+            raise ValueError(f"dev must be non-negative, got {self.dev}")
+
+    @property
+    def core(self) -> str:
+        parts = [str(self.major)]
+        if self.minor is not None:
+            parts.append(str(self.minor))
+        if self.patch is not None:
+            parts.append(str(self.patch))
+        if self.rev is not None and self.rev > 0:
+            parts.append(str(self.rev))
+        return ".".join(parts)
+
+    @property
+    def standards(self) -> list[VersionStandard]:
+        compatible = []
+
+        # SEMVER: requires minor and patch, no rev/post/dev
+        if (
+            self.minor is not None
+            and self.patch is not None
+            and self.rev is None
+            and self.post is None
+            and self.dev is None
+        ):
+            compatible.append(VersionStandard.SEMVER)
+
+        # NUGET: requires minor and patch, no metadata/post/dev
+        if (
+            self.minor is not None
+            and self.patch is not None
+            and self.metadata is None
+            and self.post is None
+            and self.dev is None
+        ):
+            compatible.append(VersionStandard.NUGET)
+
+        # CALVER: requires minor, major >= 20, no pre/post/dev
+        if (
+            self.minor is not None
+            and self.major >= 20
+            and self.pre is None
+            and self.post is None
+            and self.dev is None
+        ):
+            compatible.append(VersionStandard.CALVER)
+
+        # LOOSE: no pre/post/dev
+        if self.pre is None and self.post is None and self.dev is None:
+            compatible.append(VersionStandard.LOOSE)
+
+        # PEP440 is always compatible
+        compatible.append(VersionStandard.PEP440)
+
+        return compatible
+
+    @property
+    def format(self) -> "VersionFormatter":
+        return VersionFormatter(self)
+
+    def _compare_core(self, other: "Version") -> int:
+        self_parts = (self.major, self.minor or 0, self.patch or 0, self.rev or 0)
+        other_parts = (other.major, other.minor or 0, other.patch or 0, other.rev or 0)
+        if self_parts < other_parts:
+            return -1
+        if self_parts > other_parts:
+            return 1
+        return 0
+
+    def _compare_pre(self, other: "Version") -> int:
+        if self.pre is None and other.pre is None:
+            return 0
+        if self.pre is None:
+            return 1
+        if other.pre is None:
+            return -1
+
+        self_parts = (self.pre.name.casefold(), self.pre.number or 0)
+        other_parts = (other.pre.name.casefold(), other.pre.number or 0)
+        if self_parts < other_parts:
+            return -1
+        if self_parts > other_parts:
+            return 1
+        return 0
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Version):
+            return NotImplemented
+        return (
+            self._compare_core(other) == 0
+            and self._compare_pre(other) == 0
+            and (self.post or 0) == (other.post or 0)
+            and (self.dev or 0) == (other.dev or 0)
+        )
+
+    def __hash__(self) -> int:
+        return hash((
+            self.major,
+            self.minor,
+            self.patch,
+            self.rev,
+            self.pre.name.casefold() if self.pre else None,
+            self.pre.number if self.pre else None,
+            self.post,
+            self.dev,
+        ))
+
+    def __lt__(self, other: object) -> bool:
+        if not isinstance(other, Version):
+            return NotImplemented
+
+        core_cmp = self._compare_core(other)
+        if core_cmp != 0:
+            return core_cmp < 0
+
+        dev_cmp = (self.dev or 0, other.dev or 0)
+        if dev_cmp[0] != dev_cmp[1]:
+            if self.dev is None:
+                return False
+            if other.dev is None:
+                return True
+            return self.dev < other.dev
+
+        pre_cmp = self._compare_pre(other)
+        if pre_cmp != 0:
+            return pre_cmp < 0
+
+        return (self.post or 0) < (other.post or 0)
+
+    def __str__(self) -> str:
+        standards = self.standards
+        return self.format(standards[0] if standards else VersionStandard.PEP440)
+
+    def get_constraint(self, constraint: VersionConstraint) -> str:
+        major = self.major
+        minor = self.minor or 0
+        patch = self.patch or 0
+        full_version = str(self)
+
+        if constraint == VersionConstraint.EXACT:
+            return f"=={full_version}"
+        if constraint == VersionConstraint.MINIMUM_ONLY:
+            return f">={full_version}"
+        if constraint == VersionConstraint.RANGE_NEXT_MAJOR:
+            return f">={full_version},<{major + 1}.0.0"
+        if constraint == VersionConstraint.RANGE_NEXT_MINOR:
+            return f">={full_version},<{major}.{minor + 1}.0"
+        if constraint == VersionConstraint.RANGE_NEXT_PATCH:
+            return f">={full_version},<{major}.{minor}.{patch + 1}"
+        if major > 0:
+            upper = f"{major + 1}.0.0"
+        elif minor > 0:
+            upper = f"0.{minor + 1}.0"
+        else:
+            upper = f"0.0.{patch + 1}"
+        return f">={full_version},<{upper}"
+
+    @staticmethod
+    def parse(version_string: Optional[str]) -> Optional["Version"]:
+        if version_string:
+            for parser in _get_parsers():
+                result = parser.parse(version_string.strip())
+                if result:
+                    return result
+        return None
+
+
+@dataclass(slots=True)
+class VersionFormatter:
+    version: Version
+
+    def __call__(self, standard: VersionStandard) -> str:
+        if standard == VersionStandard.PEP440:
+            parts = [self.version.core]
+            if self.version.pre:
+                canonical = _PEP440_CANONICAL_LABELS.get(self.version.pre.name.casefold(), self.version.pre.name)
+                num = str(self.version.pre.number) if self.version.pre.number is not None else ""
+                parts.append(f"{canonical}{num}")
+            if self.version.post is not None:
+                parts.append(f".post{self.version.post}")
+            if self.version.dev is not None:
+                parts.append(f".dev{self.version.dev}")
+            if self.version.metadata:
+                parts.append(f"+{self.version.metadata}")
+            return "".join(parts)
+
+        if standard == VersionStandard.SEMVER:
+            parts = [self.version.core]
+            if self.version.pre:
+                parts.append(f"-{self.version.pre.name}")
+                if self.version.pre.number is not None:
+                    parts.append(f".{self.version.pre.number}")
+            if self.version.metadata:
+                parts.append(f"+{self.version.metadata}")
+            return "".join(parts)
+
+        if standard == VersionStandard.NUGET:
+            parts = [self.version.core]
+            if self.version.pre:
+                parts.append(f"-{self.version.pre.name}")
+                if self.version.pre.number is not None:
+                    parts.append(f".{self.version.pre.number}")
+            return "".join(parts)
+
+        if standard in (VersionStandard.CALVER, VersionStandard.LOOSE):
+            if self.version.metadata:
+                return f"{self.version.core}-{self.version.metadata}"
+            return self.version.core
+
+        return self(VersionStandard.PEP440)
+
+    @property
+    def pep440(self) -> str:
+        return self(VersionStandard.PEP440)
+
+    @property
+    def semver(self) -> str:
+        return self(VersionStandard.SEMVER)
+
+    @property
+    def nuget(self) -> str:
+        return self(VersionStandard.NUGET)
+
+    @property
+    def calver(self) -> str:
+        return self(VersionStandard.CALVER)
+
+    @property
+    def loose(self) -> str:
+        return self(VersionStandard.LOOSE)

ps_version-0.2.8/src/ps/version/_version_constraint.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class VersionConstraint(str, Enum):
+    EXACT = "exact"
+    MINIMUM_ONLY = "minimum-only"
+    RANGE_NEXT_MAJOR = "range-next-major"
+    RANGE_NEXT_MINOR = "range-next-minor"
+    RANGE_NEXT_PATCH = "range-next-patch"
+    COMPATIBLE = "compatible"

ps_version-0.2.8/src/ps/version/_version_metadata.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+from functools import total_ordering
+
+
+@total_ordering
+@dataclass(slots=True)
+class VersionMetadata:
+    value: str
+
+    def __str__(self) -> str:
+        return self.value
+
+    @property
+    def parts(self) -> list[str]:
+        return self.value.split(".")
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, VersionMetadata):
+            return NotImplemented
+        return self.value == other.value
+
+    def __lt__(self, other: object) -> bool:
+        if not isinstance(other, VersionMetadata):
+            return NotImplemented
+        return self.value < other.value
+
+    def __hash__(self) -> int:
+        return hash(self.value)

ps_version-0.2.8/src/ps/version/_version_prerelease.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+from functools import total_ordering
+from typing import Optional
+
+
+@total_ordering
+@dataclass(slots=True)
+class VersionPreRelease:
+    name: str
+    number: Optional[int] = None
+
+    def __post_init__(self) -> None:
+        if self.number is not None and self.number < 0:
+            raise ValueError(f"Pre-release number must be non-negative, got {self.number}")
+
+    def __str__(self) -> str:
+        result = self.name
+        if self.number is not None:
+            result += str(self.number)
+        return result
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, VersionPreRelease):
+            return NotImplemented
+        return self.name.casefold() == other.name.casefold() and (self.number or 0) == (other.number or 0)
+
+    def __lt__(self, other: object) -> bool:
+        if not isinstance(other, VersionPreRelease):
+            return NotImplemented
+        self_name = self.name.casefold()
+        other_name = other.name.casefold()
+        if self_name != other_name:
+            return self_name < other_name
+        return (self.number or 0) < (other.number or 0)
+
+    def __hash__(self) -> int:
+        return hash((self.name.casefold(), self.number))

ps_version-0.2.8/src/ps/version/_version_standard.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class VersionStandard(Enum):
+    PEP440 = "pep440"
+    SEMVER = "semver"
+    NUGET = "nuget"
+    CALVER = "calver"
+    LOOSE = "loose"

ps_version-0.2.8/src/ps/version/parsers/__init__.py

@@ -0,0 +1,13 @@
+from ._calver_parser import CalVerParser
+from ._loose_parser import LooseParser
+from ._nuget_parser import NuGetParser
+from ._pep440_parser import PEP440Parser
+from ._semver_parser import SemVerParser
+
+__all__ = [
+    "CalVerParser",
+    "LooseParser",
+    "NuGetParser",
+    "PEP440Parser",
+    "SemVerParser",
+]

ps_version-0.2.8/src/ps/version/parsers/_base_parser.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from .. import Version
+
+
+class BaseParser(ABC):
+    @abstractmethod
+    def parse(self, version_string: str) -> Optional[Version]:
+        pass

ps_version-0.2.8/src/ps/version/parsers/_calver_parser.py

@@ -0,0 +1,38 @@
+import re
+from typing import Optional, cast
+
+from .. import Version, VersionMetadata
+from ._base_parser import BaseParser
+
+
+class CalVerParser(BaseParser):
+    PATTERN = re.compile(
+        r"^(?P<major>20\d{2}|\d{2})"
+        r"\.(?P<minor>\d+)"
+        r"(?:\.(?P<patch>\d+))?"
+        r"(?:\.(?P<rev>\d+))?"
+        r"(?:[.\-+](?P<suffix>.+))?$"
+    )
+
+    def parse(self, version_string: str) -> Optional[Version]:
+        match = self.PATTERN.match(version_string)
+        if not match:
+            return None
+
+        groups = match.groupdict()
+        major = int(groups["major"])
+
+        if major < 20 or (major > 99 and major < 2020):
+            return None
+
+        patch = groups["patch"]
+        rev = groups["rev"]
+        suffix = groups["suffix"]
+
+        return Version(
+            major=major,
+            minor=int(groups["minor"]),
+            patch=int(patch) if patch else None,
+            rev=int(rev) if rev else None,
+            metadata=VersionMetadata(cast(str, suffix)) if suffix else None,
+        )

ps_version-0.2.8/src/ps/version/parsers/_loose_parser.py

@@ -0,0 +1,34 @@
+import re
+from typing import Optional, cast
+
+from .. import Version, VersionMetadata
+from ._base_parser import BaseParser
+
+
+class LooseParser(BaseParser):
+    PATTERN = re.compile(
+        r"^(?P<major>\d+)"
+        r"(?:\.(?P<minor>\d+))?"
+        r"(?:\.(?P<patch>\d+))?"
+        r"(?:\.(?P<rev>\d+))?"
+        r"(?:[.\-+](?P<suffix>.+))?$"
+    )
+
+    def parse(self, version_string: str) -> Optional[Version]:
+        match = self.PATTERN.match(version_string)
+        if not match:
+            return None
+
+        groups = match.groupdict()
+        minor = groups["minor"]
+        patch = groups["patch"]
+        rev = groups["rev"]
+        suffix = groups["suffix"]
+
+        return Version(
+            major=int(groups["major"]),
+            minor=int(minor) if minor else None,
+            patch=int(patch) if patch else None,
+            rev=int(rev) if rev else None,
+            metadata=VersionMetadata(cast(str, suffix)) if suffix else None,
+        )

ps_version-0.2.8/src/ps/version/parsers/_nuget_parser.py

@@ -0,0 +1,42 @@
+import re
+from typing import Optional, cast
+
+from .. import Version, VersionPreRelease
+from ._base_parser import BaseParser
+
+
+class NuGetParser(BaseParser):
+    PATTERN = re.compile(
+        r"^(?P<major>\d+)"
+        r"\.(?P<minor>\d+)"
+        r"\.(?P<patch>\d+)"
+        r"(?:\.(?P<rev>\d+))?"
+        r"(?:-(?P<pre>[0-9A-Za-z\-]+(?:\.[0-9A-Za-z\-]+)*))?$"
+    )
+
+    def parse(self, version_string: str) -> Optional[Version]:
+        match = self.PATTERN.match(version_string)
+        if not match:
+            return None
+
+        groups = match.groupdict()
+        pre_str = cast(Optional[str], groups["pre"])
+        pre_release: Optional[VersionPreRelease] = None
+
+        if pre_str:
+            pre_parts = re.match(r"^([A-Za-z]+)\.?(\d+)?", pre_str)
+            if pre_parts:
+                pre_num = pre_parts.group(2)
+                pre_release = VersionPreRelease(
+                    cast(str, pre_parts.group(1)),
+                    int(pre_num) if pre_num else None,
+                )
+
+        rev = groups["rev"]
+        return Version(
+            major=int(groups["major"]),
+            minor=int(groups["minor"]),
+            patch=int(groups["patch"]),
+            rev=int(rev) if rev else None,
+            pre=pre_release,
+        )

ps_version-0.2.8/src/ps/version/parsers/_pep440_parser.py

@@ -0,0 +1,45 @@
+import re
+from typing import Optional, cast
+
+from .. import Version, VersionMetadata, VersionPreRelease
+from ._base_parser import BaseParser
+
+
+class PEP440Parser(BaseParser):
+    PATTERN = re.compile(
+        r"^(?P<major>\d+)"
+        r"(?:\.(?P<minor>\d+))?"
+        r"(?:\.(?P<patch>\d+))?"
+        r"(?:\.(?P<rev>\d+))?"
+        r"(?:(?P<pre_label>a|alpha|b|beta|rc|c|pre|preview)(?P<pre_num>\d+))?"
+        r"(?:\.post(?P<post>\d+))?"
+        r"(?:\.dev(?P<dev>\d+))?"
+        r"(?:\+(?P<meta>[a-zA-Z0-9]+(?:\.[a-zA-Z0-9]+)*))?$",
+        re.IGNORECASE,
+    )
+
+    def parse(self, version_string: str) -> Optional[Version]:
+        match = self.PATTERN.match(version_string)
+        if not match:
+            return None
+
+        groups = match.groupdict()
+        minor = groups["minor"]
+        patch = groups["patch"]
+        rev = groups["rev"]
+        pre_label = groups["pre_label"]
+        pre_num = groups["pre_num"]
+        post = groups["post"]
+        dev = groups["dev"]
+        meta = groups["meta"]
+
+        return Version(
+            major=int(groups["major"]),
+            minor=int(minor) if minor else None,
+            patch=int(patch) if patch else None,
+            rev=int(rev) if rev else None,
+            pre=VersionPreRelease(pre_label, int(pre_num)) if pre_label and pre_num else None,
+            post=int(post) if post else None,
+            dev=int(dev) if dev else None,
+            metadata=VersionMetadata(cast(str, meta)) if meta else None,
+        )

ps_version-0.2.8/src/ps/version/parsers/_semver_parser.py

@@ -0,0 +1,42 @@
+import re
+from typing import Optional, cast
+
+from .. import Version, VersionMetadata, VersionPreRelease
+from ._base_parser import BaseParser
+
+
+class SemVerParser(BaseParser):
+    PATTERN = re.compile(
+        r"^(?P<major>\d+)"
+        r"\.(?P<minor>\d+)"
+        r"\.(?P<patch>\d+)"
+        r"(?:-(?P<pre>[0-9A-Za-z\-]+(?:\.[0-9A-Za-z\-]+)*))?"
+        r"(?:\+(?P<meta>[0-9A-Za-z\-]+(?:\.[0-9A-Za-z\-]+)*))?$"
+    )
+
+    def parse(self, version_string: str) -> Optional[Version]:
+        match = self.PATTERN.match(version_string)
+        if not match:
+            return None
+
+        groups = match.groupdict()
+        pre_str = cast(Optional[str], groups["pre"])
+        pre_release: Optional[VersionPreRelease] = None
+
+        if pre_str:
+            pre_parts = re.match(r"^([A-Za-z]+)\.?(\d+)?", pre_str)
+            if pre_parts:
+                pre_num = pre_parts.group(2)
+                pre_release = VersionPreRelease(
+                    cast(str, pre_parts.group(1)),
+                    int(pre_num) if pre_num else None,
+                )
+
+        meta = groups["meta"]
+        return Version(
+            major=int(groups["major"]),
+            minor=int(groups["minor"]),
+            patch=int(groups["patch"]),
+            pre=pre_release,
+            metadata=VersionMetadata(cast(str, meta)) if meta else None,
+        )