v440 2.0.0.dev196__tar.gz → 2.0.0.dev200__tar.gz

{v440-2.0.0.dev196/src/v440.egg-info → v440-2.0.0.dev200}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: v440
-Version: 2.0.0.dev196
+Version: 2.0.0.dev200
 Summary: This project provides mutable version objects in accordance with PEP440.
 Author-email: Johannes <johannes.programming@gmail.com>
 License: The MIT License (MIT)
@@ -40,15 +40,14 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-Requires-Dist: catchlib<2.0,>=1.0
-Requires-Dist: datarepr<2,>=1.0.2
+Requires-Dist: datahold<3,>=2.0
+Requires-Dist: datarepr<2,>=1.1
+Requires-Dist: iterflat<2,>=0.1.3
 Requires-Dist: iterprod<2.0,>=1.0
 Requires-Dist: keyalias<2.0,>=1.0.3
-Requires-Dist: packaging>=23.2
-Requires-Dist: scaevola<2.0,>=1.1
+Requires-Dist: packaging<26,>=25.0
 Requires-Dist: setdoc<2,>=1.2.6
 Requires-Dist: setsig<2,>=1.0
-Requires-Dist: tofunc<2,>=1.0.0
 Requires-Dist: unhash<2,>=1.0.1
 Dynamic: license-file
 

{v440-2.0.0.dev196 → v440-2.0.0.dev200}/pyproject.toml

@@ -1,7 +1,7 @@
 [build-system]
 build-backend = "setuptools.build_meta"
 requires = [
-    "setuptools>=61.0",
+    "setuptools>=64.0",
 ]
 
 [project]
@@ -20,15 +20,14 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "catchlib>=1.0,<2.0",
-    "datarepr>=1.0.2,<2",
+    "datahold>=2.0,<3",
+    "datarepr>=1.1,<2",
+    "iterflat>=0.1.3,<2",
     "iterprod>=1.0,<2.0",
     "keyalias>=1.0.3,<2.0",
-    "packaging>=23.2",
-    "scaevola>=1.1,<2.0",
+    "packaging>=25.0,<26",
     "setdoc>=1.2.6,<2",
     "setsig>=1.0,<2",
-    "tofunc>=1.0.0,<2",
     "unhash>=1.0.1,<2",
 ]
 description = "This project provides mutable version objects in accordance with PEP440."
@@ -36,7 +35,7 @@ keywords = []
 name = "v440"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "2.0.0.dev196"
+version = "2.0.0.dev200"
 
 [project.license]
 file = "LICENSE.txt"

{v440-2.0.0.dev196/src/v440/core → v440-2.0.0.dev200/src/v440}/__init__.py

@@ -1,2 +1,3 @@
 from v440.core.Version import Version
 from v440.core.VersionError import VersionError
+from v440.tests import *

{v440-2.0.0.dev196 → v440-2.0.0.dev200}/src/v440/_utils/BaseStringer.py

@@ -3,8 +3,11 @@ from typing import *
 
 import setdoc
 import unhash
+from datarepr import oxford
 
+from v440._utils.Cfg import Cfg
 from v440._utils.guarding import guard
+from v440.core.VersionError import VersionError
 
 __all__ = ["BaseStringer"]
 
@@ -13,6 +16,7 @@ class BaseStringer(metaclass=ABCMeta):
     __slots__ = ()
 
     string: str
+    packaging: Any
 
     @abstractmethod
     @setdoc.basic
@@ -27,12 +31,17 @@ class BaseStringer(metaclass=ABCMeta):
 
     @setdoc.basic
     def __format__(self: Self, format_spec: Any) -> str:
+        parsed: dict
+        ans: str
+        msg: str
         try:
-            return self._format(str(format_spec))
+            parsed = self._format_parse(str(format_spec))
         except Exception:
-            msg: str = "Invalid format specifier %r for object of type %r"
+            msg = Cfg.cfg.data["consts"]["errors"]["format"]
             msg %= (format_spec, type(self).__name__)
-            raise TypeError(msg) from None
+            raise VersionError(msg)  # from None
+        ans = str(self._format_parsed(**parsed))
+        return ans
 
     @setdoc.basic
     def __ge__(self: Self, other: Any) -> bool:
@@ -83,13 +92,21 @@ class BaseStringer(metaclass=ABCMeta):
 
     @setdoc.basic
     def __str__(self: Self) -> str:
-        return self._format("")
+        return format(self, "")
 
     @abstractmethod
     def _cmp(self: Self) -> Any: ...
 
+    @classmethod
+    @abstractmethod
+    def _deformat(cls: type, info: dict[str, Self], /) -> Any: ...
+
+    @classmethod
     @abstractmethod
-    def _format(self: Self, format_spec: str) -> str: ...
+    def _format_parse(self: Self, spec: str, /) -> dict: ...
+
+    @abstractmethod
+    def _format_parsed(self: Self, **kwargs: Any) -> Any: ...
 
     @abstractmethod
     def _string_fset(self: Self, value: str) -> None: ...
@@ -98,10 +115,27 @@ class BaseStringer(metaclass=ABCMeta):
     def copy(self: Self) -> Self:
         return type(self)(self)
 
+    @classmethod
+    def deformat(cls: type, *strings: Any) -> str:
+        keys: tuple = tuple(map(str, strings))
+        values: tuple = tuple(map(cls, keys))
+        info: dict = dict(zip(keys, values))
+        try:
+            ans: str = cls._deformat(info)
+        except Exception:
+            msg: str = Cfg.cfg.data["consts"]["errors"]["deformat"]
+            msg %= oxford(*strings)
+            raise TypeError(msg)
+        return ans
+
+    @property
+    @abstractmethod
+    def packaging(self: Self) -> Any: ...
+
     @property
     def string(self: Self) -> str:
         "This property represents self as str."
-        return self._format("")
+        return format(self, "")
 
     @string.setter
     @guard

v440-2.0.0.dev200/src/v440/_utils/Cfg.py

@@ -0,0 +1,41 @@
+import enum
+import functools
+import re
+import tomllib
+from importlib import resources
+from typing import *
+
+__all__ = ["Cfg"]
+
+
+class Cfg(enum.Enum):
+    cfg = None
+
+    @functools.cached_property
+    def data(self: Self) -> dict:
+        "This cached property holds the cfg data."
+        text: str = resources.read_text("v440._utils", "cfg.toml")
+        ans: dict = tomllib.loads(text)
+        return ans
+
+    @classmethod
+    def fullmatches(cls: type, key: str, value: str) -> dict[str, str]:
+        ans: dict = cls.cfg.patterns[key].fullmatch(value).groupdict()
+        x: str
+        for x in ans.keys():
+            if ans[x] is None:
+                ans[x] = ""
+        return ans
+
+    @functools.cached_property
+    def patterns(self: Self) -> dict[str, re.Pattern]:
+        ans: dict = dict()
+        parts: dict = dict()
+        x: str
+        y: str
+        z: str
+        for x, y in self.data["patterns"].items():
+            z = y.format(**parts)
+            parts[x] = f"(?P<{x}>{z})"
+            ans[x] = re.compile(z, re.IGNORECASE | re.VERBOSE)
+        return ans

v440-2.0.0.dev200/src/v440/_utils/Clue.py

@@ -0,0 +1,114 @@
+import string as string_
+from typing import *
+
+from v440._utils.Cfg import Cfg
+
+
+class Clue(NamedTuple):
+    head: str = ""
+    sep: str = "?"
+    mag: int = 0
+
+    def __and__(self: Self, other: Self) -> Self:
+        s: str
+        m: int
+        if self.head == "":
+            return other
+        if other.head == "":
+            return self
+        if self.head != other.head:
+            raise ValueError
+        if self.sep == "?":
+            s = other.sep
+        elif other.sep == "?":
+            s = self.sep
+        elif self.sep == other.sep:
+            s = self.sep
+        else:
+            raise ValueError
+        if self.mag < 0 and other.mag < 0:
+            m = max(self.mag, other.mag)
+        elif self.mag < 0 or other.mag < 0:
+            if 0 < self.mag + other.mag:
+                raise ValueError
+            m = max(self.mag, other.mag)
+        else:
+            if self.mag != other.mag:
+                raise ValueError
+            m = self.mag
+        return type(self)(self.head, s, m)
+
+    @classmethod
+    def by_example(cls: type, value: str, /) -> Self:
+        sep: str
+        mag: int
+        matches: dict[str, str]
+        if value == "-0":
+            return cls("-", "", -1)
+        matches = Cfg.fullmatches("clue", value)
+        if matches["sep"] or matches["num"]:
+            sep = matches["sep"]
+        else:
+            sep = "?"
+        if matches["num"].startswith("0"):
+            mag = len(matches["num"])
+        else:
+            mag = -len(matches["num"])
+        return cls(matches["head"], sep, mag)
+
+    @classmethod
+    def by_examples(cls: type, *values: str) -> Self:
+        ans: Self = cls()
+        s: str
+        for s in values:
+            ans &= cls.by_string(s)
+        return ans
+
+    @classmethod
+    def by_spec(cls: type, value: str, /) -> Self:
+        matches: dict[str, str]
+        matches = Cfg.fullmatches("clue_f", value)
+        return cls(matches["head_f"], matches["sep_f"], len(matches["num_f"]))
+
+    def seal(self: Self) -> Self:
+        mag: int
+        mag = self.mag if self.mag >= -1 else -1
+        return type(self)(self.head, self.sep, mag)
+
+    def solo(self: Self, hollow: str) -> str:
+        sep: str
+        mag: int
+        if self.head == "":
+            return ""
+        mag = self.mag if self.mag >= -1 else -1
+        sep = self.sep.replace("?", "")
+        if self.head == hollow and sep == "" and mag in (-1, 1):
+            return ""
+        return self.head + sep + max(0, mag) * "#"
+
+    def possible(self: Self, *, hollow: str, short: str) -> set:
+        s: str
+        n: str
+        seps: set[str]
+        nums: set[str]
+        ans: set
+        ans = set()
+        if self.head == "":
+            ans.add("")
+            ans.add(short + "#")
+            return ans
+        if self.sep != "?":
+            seps = {self.sep}
+        else:
+            seps = {"", "."}
+        if self.mag < 0:
+            nums = {"", "#"}
+        else:
+            nums = {"#" * self.mag}
+        ans = set()
+        for s in seps:
+            for n in nums:
+                ans.add(self.head + s + n)
+        if (hollow + "#") in ans:
+            ans.add("")
+        return ans

v440-2.0.0.dev200/src/v440/_utils/ListStringer.py

@@ -0,0 +1,90 @@
+from abc import abstractmethod
+from typing import *
+
+import setdoc
+from datahold import OkayList
+from datarepr import datarepr
+
+from v440._utils.BaseStringer import BaseStringer
+from v440._utils.guarding import guard
+
+__all__ = ["ListStringer"]
+
+
+class ListStringer(BaseStringer, OkayList):
+
+    __slots__ = ()
+    string: str
+    packaging: Any
+    data: tuple
+
+    @setdoc.basic
+    def __add__(self: Self, other: Any) -> Self:
+        alt: tuple
+        ans: Self
+        try:
+            alt = tuple(other)
+        except Exception:
+            return NotImplemented
+        ans = type(self)()
+        ans.data = self.data + alt
+        return ans
+
+    @setdoc.basic
+    def __bool__(self: Self) -> bool:
+        return bool(self.data)
+
+    @setdoc.basic
+    def __mul__(self: Self, other: Any) -> Self:
+        ans: Self
+        ans = type(self)()
+        ans.data = self.data * other
+        return ans
+
+    @setdoc.basic
+    def __radd__(self: Self, other: Any) -> Self:
+        alt: tuple
+        ans: Self
+        try:
+            alt = tuple(other)
+        except Exception:
+            return NotImplemented
+        ans = type(self)()
+        ans.data = alt + self.data
+        return ans
+
+    @setdoc.basic
+    def __repr__(self: Self) -> str:
+        return datarepr(type(self).__name__, list(self))
+
+    def _cmp(self: Self) -> tuple:
+        return tuple(map(self._sort, self.data))
+
+    @classmethod
+    @abstractmethod
+    def _data_parse(cls: type, value: list) -> Iterable: ...
+
+    @classmethod
+    @abstractmethod
+    def _sort(cls: type, value: Any): ...
+
+    @property
+    @setdoc.basic
+    def data(self: Self) -> tuple:
+        return self._data
+
+    @data.setter
+    @guard
+    def data(self: Self, value: Iterable) -> None:
+        self._data = tuple(self._data_parse(list(value)))
+
+    def sort(self: Self, *, key: Any = None, reverse: Any = False) -> None:
+        "This method sorts the data."
+        data: list
+        k: Any
+        r: bool
+        data = list(self.data)
+        k = self._sort if key is None else key
+        r = bool(reverse)
+        data.sort(key=k, reverse=r)
+        self.data = data

{v440-2.0.0.dev196 → v440-2.0.0.dev200}/src/v440/_utils/QualStringer.py

@@ -15,12 +15,13 @@ class QualStringer(BaseStringer):
     __slots__ = ("_lit", "_num")
 
     string: str
+    packaging: Any
     lit: str
     num: int
 
     @setdoc.basic
     def __bool__(self: Self) -> bool:
-        return self.lit != ""
+        return bool(self.lit)
 
     @setdoc.basic
     def __init__(self: Self, string: Any = "") -> None:
@@ -36,29 +37,25 @@ class QualStringer(BaseStringer):
             num=self.num,
         )
 
-    def _format(self: Self, format_spec: str) -> str:
-        if format_spec:
-            raise ValueError
-        if self.lit:
-            return self.lit + str(self.num)
-        else:
-            return ""
-
     @classmethod
     @abstractmethod
     def _lit_parse(cls: type, value: str) -> str: ...
 
     def _string_fset(self: Self, value: str) -> None:
+        x: str
+        y: str
         if value == "":
             self._lit = ""
             self._num = 0
             return
-        x: str = value.rstrip("0123456789")
-        y: str = value[len(x) :]
+        x = value.rstrip("0123456789")
+        y = value[len(x) :]
         if x == "-":
-            self._string_fset_minus(y)
+            if not y:
+                raise ValueError
+            self._lit = self._lit_parse("-")
+            self._num = int(y)
             return
-        x = x.lower()
         x = x.replace("-", ".")
         x = x.replace("_", ".")
         if x.endswith("."):
@@ -72,8 +69,21 @@ class QualStringer(BaseStringer):
         self._lit = self._lit_parse(x)
         self._num = int("0" + y)
 
-    @abstractmethod
-    def _string_fset_minus(self: Self, value: str) -> None: ...
+    @property
+    def lit(self: Self) -> str:
+        return self._lit
+
+    @lit.setter
+    @guard
+    def lit(self: Self, value: Any) -> None:
+        x: str
+        x = str(value).lower()
+        if x:
+            self._lit = self._lit_parse(x)
+        elif self.num:
+            self.string = self.num
+        else:
+            self._lit = ""
 
     @property
     def num(self: Self) -> int:
@@ -82,25 +92,11 @@ class QualStringer(BaseStringer):
     @num.setter
     @guard
     def num(self: Self, value: SupportsIndex) -> None:
-        y: int = operator.index(value)
+        y: int
+        y = operator.index(value)
         if y < 0:
             raise ValueError
         if y and not self.lit:
             self.string = y
         else:
             self._num = y
-
-    @property
-    def lit(self: Self) -> str:
-        return self._lit
-
-    @lit.setter
-    @guard
-    def lit(self: Self, value: Any) -> None:
-        x: str = str(value).lower()
-        if x:
-            self._lit = self._lit_parse(x)
-        elif self.num:
-            self.string = self.num
-        else:
-            self._lit = ""

{v440-2.0.0.dev196 → v440-2.0.0.dev200}/src/v440/_utils/SlotStringer.py

@@ -13,6 +13,7 @@ class SlotStringer(BaseStringer):
     __slots__ = ()
 
     string: str
+    packaging: str
 
     @setdoc.basic
     def __bool__(self: Self) -> bool:
@@ -24,3 +25,5 @@ class SlotStringer(BaseStringer):
 
     @abstractmethod
     def _todict(self: Self) -> dict: ...
+
+    packaging = BaseStringer.string

v440-2.0.0.dev200/src/v440/_utils/cfg.toml

@@ -0,0 +1,51 @@
+[consts.errors]
+deformat = "No common format specifier for %s."
+format = "Invalid format specifier %r for object of type %r."
+
+[consts.phases]
+alpha = "a"
+a = "a"
+beta = "b"
+b = "b"
+preview = "rc"
+pre = "rc"
+c = "rc"
+rc = "rc"
+
+[patterns]
+basev_f = "V?"
+epoch_f = "\\#*"
+release_f = "[\\#\\.]*"
+base_f = "{basev_f}({epoch_f}!)?{release_f}"
+a_f = "[-_\\.]?(ALPHA|A)[-_\\.]?\\#*"
+b_f = "[-_\\.]?(BETA|B)[-_\\.]?\\#*"
+rc_f = "[-_\\.]?(PREVIEW|PRE|C|RC)[-_\\.]?\\#*"
+pre_f = "{a_f}?{b_f}?{rc_f}?"
+post_hyphen_f = "-"
+post_head_f = "[-_\\.]?(POST|REV|R)"
+post_sep_f = "[-_\\.]?"
+post_lit_f = "({post_hyphen_f}|({post_head_f}{post_sep_f}))"
+post_num_f = "\\#*"
+post_f = "({post_lit_f}{post_num_f})?"
+dev_head_f = "[-_\\.]?DEV"
+dev_sep_f = "[-_\\.]?"
+dev_num_f = "\\#*"
+dev_f = "({dev_head_f}{dev_sep_f}{dev_num_f})?"
+qual_f = "{pre_f}{post_f}{dev_f}"
+basev = "V"
+epoch = "[0-9]+"
+release = "[0-9]+(\\.[0-9]+)*"
+base = "{basev}?({epoch}!)?{release}"
+pre = "[-_\\.]?(ALPHA|A|BETA|B|PREVIEW|PRE|C|RC)([-_\\.]?[0-9]+)?"
+post = "(-([0-9]+))|(([-_\\.]?(POST|REV|R))([-_\\.]?([0-9]+))?)"
+dev = "[-_\\.]?DEV([-_\\.]?[0-9]+)?"
+qual = "{pre}?{post}?{dev}?"
+local_splitter = "([-_\\.])"
+head = "[-_\\.]?[A-Z]*"
+sep = "[-_\\.]?"
+num = "[0-9]*"
+clue = "{head}?{sep}?{num}?"
+head_f = "[-_\\.]?[A-Z]*"
+sep_f = "[-_\\.]?"
+num_f = "\\#*"
+clue_f = "{head_f}?{sep_f}?{num_f}?"

{v440-2.0.0.dev196 → v440-2.0.0.dev200}/src/v440/_utils/guarding.py

@@ -11,16 +11,19 @@ __all__ = ["guard"]
 def guard(old: Any) -> Any:
     @functools.wraps(old)
     def new(self: Self, value: Any) -> None:
-        backup: str = str(self)
+        backup: str
+        msg: str
+        target: str
+        backup = str(self)
         try:
             old(self, value)
         except VersionError:
             self.string = backup
             raise
         except Exception:
-            self.string = backup
-            msg: str = "%r is an invalid value for %r"
-            target: str = type(self).__name__ + "." + old.__name__
+            self._string_fset(backup.lower())
+            msg = "%r is an invalid value for %r"
+            target = type(self).__name__ + "." + old.__name__
             msg %= (value, target)
             raise VersionError(msg)
 

{v440-2.0.0.dev196 → v440-2.0.0.dev200}/src/v440/_utils/releaseparse/getting.py

@@ -7,8 +7,8 @@ from typing import *
 from v440._utils.releaseparse import ranging
 
 
-def getitem(data: tuple, key: SupportsIndex | slice) -> list:
-    ans: int | tuple
+def getitem(data: tuple, key: SupportsIndex | slice) -> int | list:
+    ans: int | list
     if type(key) is slice:
         r: range = ranging.torange(key, len(data))
         f: partial = partial(getitem_int, data)