v440 2.0.0.dev52__tar.gz → 2.0.0.dev54__tar.gz

{v440-2.0.0.dev52/src/v440.egg-info → v440-2.0.0.dev54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: v440
-Version: 2.0.0.dev52
+Version: 2.0.0.dev54
 Summary: This project provides mutable version objects in accordance with PEP440.
 Author-email: Johannes <johannes.programming@gmail.com>
 License: The MIT License (MIT)
@@ -41,7 +41,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: catchlib<2.0,>=1.0
-Requires-Dist: datahold<2.0,>=1.1.8
+Requires-Dist: datarepr<2,>=1.0.2
 Requires-Dist: iterprod<2.0,>=1.0
 Requires-Dist: keyalias<2.0,>=1.0.3
 Requires-Dist: overloadable<2.0,>=1.0.5
@@ -49,6 +49,7 @@ Requires-Dist: packaging>=23.2
 Requires-Dist: scaevola<2.0,>=1.1
 Requires-Dist: setdoc<2,>=1.2
 Requires-Dist: tofunc<2,>=1.0.0
+Requires-Dist: unhash<2,>=1.0.1
 Dynamic: license-file
 
 ====

{v440-2.0.0.dev52 → v440-2.0.0.dev54}/pyproject.toml

@@ -21,7 +21,7 @@ classifiers = [
 ]
 dependencies = [
     "catchlib>=1.0,<2.0",
-    "datahold>=1.1.8,<2.0",
+    "datarepr>=1.0.2,<2",
     "iterprod>=1.0,<2.0",
     "keyalias>=1.0.3,<2.0",
     "overloadable>=1.0.5,<2.0",
@@ -29,13 +29,14 @@ dependencies = [
     "scaevola>=1.1,<2.0",
     "setdoc>=1.2,<2",
     "tofunc>=1.0.0,<2",
+    "unhash>=1.0.1,<2",
 ]
 description = "This project provides mutable version objects in accordance with PEP440."
 keywords = []
 name = "v440"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "2.0.0.dev52"
+version = "2.0.0.dev54"
 
 [project.license]
 file = "LICENSE.txt"

v440-2.0.0.dev52/src/v440/_utils/SlotList.py → v440-2.0.0.dev54/src/v440/_utils/BaseList.py

@@ -1,28 +1,22 @@
 import collections
-import sys
 from abc import abstractmethod
 from typing import *
 
 import scaevola
 import setdoc
+import unhash
 from datarepr import datarepr
-from unhash import unhash
 
-from v440._utils.BaseList import BaseList
 from v440.core.VersionError import VersionError
 
-__all__ = ["SlotList"]
-
 
 @scaevola.auto
-class SlotList(collections.abc.Collection, BaseList):
+class BaseList(collections.abc.Sized):
     __slots__ = ()
 
-    data: list
-
+    @abstractmethod
     @setdoc.basic
-    def __bool__(self: Self) -> bool:
-        return any(self.data)
+    def __bool__(self: Self) -> bool: ...
 
     @setdoc.basic
     def __contains__(self: Self, other: Any) -> bool:
@@ -34,8 +28,7 @@ class SlotList(collections.abc.Collection, BaseList):
             alt: Self = type(self)(other)
         except VersionError:
             return False
-        else:
-            return self.data == alt.data
+        return self.data == alt.data
 
     @setdoc.basic
     def __format__(self: Self, format_spec: Any) -> str:
@@ -47,28 +40,26 @@ class SlotList(collections.abc.Collection, BaseList):
             raise TypeError(msg) from None
 
     @setdoc.basic
-    def __getitem__(self: Self, key: Any) -> Any:
-        return self.data[key]
-
-    @setdoc.basic
-    def __ge__(self: Self, other: Any, /) -> bool:
+    def __ge__(self: Self, other: Any) -> bool:
         alt: Self
         try:
             alt = type(self)(other)
         except VersionError:
             return NotImplemented
-        else:
-            return self._cmp() >= alt._cmp()
+        return self._cmp() >= alt._cmp()
 
     @setdoc.basic
-    def __gt__(self: Self, other: Any, /) -> bool:
+    def __getitem__(self: Self, key: Any) -> Any:
+        return self.data[key]
+
+    @setdoc.basic
+    def __gt__(self: Self, other: Any) -> bool:
         alt: Self
         try:
             alt = type(self)(other)
         except VersionError:
             return NotImplemented
-        else:
-            return self._cmp() > alt._cmp()
+        return self._cmp() > alt._cmp()
 
     __hash__ = unhash
 
@@ -77,32 +68,26 @@ class SlotList(collections.abc.Collection, BaseList):
         self.data = data
 
     @setdoc.basic
-    def __iter__(self: Self) -> Any:
+    def __iter__(self: Self) -> Iterator:
         return iter(self.data)
 
     @setdoc.basic
-    def __le__(self: Self, other: Any, /) -> bool:
+    def __le__(self: Self, other: Any) -> bool:
         alt: Self
         try:
             alt = type(self)(other)
         except VersionError:
             return NotImplemented
-        else:
-            return self._cmp() <= alt._cmp()
-
-    @setdoc.basic
-    def __len__(self: Self) -> int:
-        return len(type(self).__slots__)
+        return self._cmp() <= alt._cmp()
 
     @setdoc.basic
-    def __lt__(self: Self, other: Any, /) -> bool:
+    def __lt__(self: Self, other: Any) -> bool:
         alt: Self
         try:
             alt = type(self)(other)
         except VersionError:
             return NotImplemented
-        else:
-            return self._cmp() < alt._cmp()
+        return self._cmp() < alt._cmp()
 
     @setdoc.basic
     def __ne__(self: Self, other: Any) -> bool:
@@ -113,38 +98,43 @@ class SlotList(collections.abc.Collection, BaseList):
         return datarepr(type(self).__name__, self.data)
 
     @setdoc.basic
-    def __reversed__(self: Self) -> Iterable:
+    def __reversed__(self: Self) -> reversed:
         return reversed(self.data)
 
     @setdoc.basic
     def __setitem__(self: Self, key: Any, value: Any) -> None:
-        data: list = self.data
+        data: list = list(self._data)
         data[key] = value
         self.data = data
 
-    @setdoc.basic
-    def __str__(self: Self) -> str:
-        return format(self)
-
     @classmethod
     def __subclasshook__(cls: type, other: type, /) -> bool:
         "This magic classmethod can be overwritten for a custom subclass check."
         return NotImplemented
 
-    def _cmp(self: Self) -> Any:
-        return self.data
+    @setdoc.basic
+    def __str__(self: Self) -> str:
+        return self._format("")
+
+    @abstractmethod
+    def _cmp(self: Self) -> Any: ...
+
+    @abstractmethod
+    def _format(self: Self, format_spec: str) -> str: ...
 
     @setdoc.basic
     def copy(self: Self) -> Self:
         return type(self)(self)
 
-    def count(self: Self, value: Any) -> Any:
-        return self.data.count(value)
-
     @property
     @abstractmethod
     @setdoc.basic
-    def data(self: Self) -> list: ...
+    def data(self: Self) -> tuple: ...
+
+    def count(self: Self, value: Any) -> int:
+        "This method counts the occurences of value."
+        return self.data.count(value)
 
-    def index(self: Self, value: Any) -> Any:
-        return self.data.index(value)
+    def index(self: Self, *args: Any) -> None:
+        "This method returns the index of the first occurence."
+        return self.data.index(*args)

v440-2.0.0.dev54/src/v440/_utils/SlotList.py

@@ -0,0 +1,32 @@
+import collections
+from abc import abstractmethod
+from functools import partial
+from typing import *
+
+import scaevola
+import setdoc
+from datarepr import datarepr
+
+from v440._utils.BaseList import BaseList
+from v440._utils.utils import guard
+from v440.core.VersionError import VersionError
+
+__all__ = ["SlotList"]
+
+
+@scaevola.auto
+class SlotList(collections.abc.Collection, BaseList):
+    __slots__ = ()
+
+    data: tuple
+
+    @setdoc.basic
+    def __bool__(self: Self) -> bool:
+        return any(self.data)
+
+    @setdoc.basic
+    def __len__(self: Self) -> int:
+        return len(type(self).__slots__)
+
+    def _cmp(self: Self) -> tuple:
+        return tuple(map(partial(getattr, self), type(self).__slots__))

v440-2.0.0.dev54/src/v440/_utils/VList.py

@@ -0,0 +1,112 @@
+from abc import abstractmethod
+from typing import *
+
+import setdoc
+
+from v440._utils import utils
+from v440._utils.BaseList import BaseList
+
+__all__ = ["VList"]
+
+
+class VList(BaseList):
+
+    __slots__ = ("_data",)
+    data: tuple
+
+    @setdoc.basic
+    def __add__(self: Self, other: Any) -> Self:
+        return type(self)(self.data + tuple(other))
+
+    @setdoc.basic
+    def __bool__(self: Self) -> bool:
+        return bool(self.data)
+
+    @setdoc.basic
+    def __delitem__(self: Self, key: Any) -> None:
+        data: list = list(self.data)
+        del data[key]
+        self.data = data
+
+    @setdoc.basic
+    def __iadd__(self: Self, other: Any, /) -> Self:
+        self.data = self.data + tuple(other)
+        return self
+
+    @setdoc.basic
+    def __imul__(self: Self, other: Any, /) -> Self:
+        self.data = self.data * other
+        return self
+
+    @setdoc.basic
+    def __len__(self: Self) -> int:
+        return len(self.data)
+
+    @setdoc.basic
+    def __mul__(self: Self, other: Any) -> Self:
+        return type(self)(self.data * other)
+
+    @setdoc.basic
+    def __rmul__(self: Self, other: Any) -> Self:
+        return self * other
+
+    def _cmp(self: Self) -> tuple:
+        return tuple(map(self._sort, self.data))
+
+    @classmethod
+    @abstractmethod
+    def _sort(cls: type, value: Any): ...
+
+    def append(self: Self, value: Self, /) -> None:
+        "This method appends value to self."
+        data: list = list(self.data)
+        data.append(value)
+        self.data = data
+
+    def clear(self: Self, /) -> None:
+        "This method clears the data."
+        self.data = ()
+
+    def extend(self: Self, value: Self, /) -> None:
+        "This method extends self by value."
+        data: list = list(self.data)
+        data.extend(value)
+        self.data = data
+
+    def insert(
+        self: Self,
+        index: SupportsIndex,
+        value: Any,
+        /,
+    ) -> None:
+        "This method inserts value at index."
+        data: list = list(self.data)
+        data.insert(index, value)
+        self.data = data
+
+    def pop(self: Self, index: SupportsIndex = -1, /) -> Any:
+        "This method pops an item."
+        data: list = list(self.data)
+        ans: Any = data.pop(index)
+        self.data = data
+        return ans
+
+    def remove(self: Self, value: Any) -> None:
+        "This method removes the first occurence of value."
+        data: list = list(self.data)
+        data.remove(value)
+        self.data = data
+
+    def reverse(self: Self) -> None:
+        "This method reverses the order of the data."
+        data: list = list(self.data)
+        data.reverse()
+        self.data = data
+
+    def sort(self: Self, *, key: Any = None, reverse: Any = False) -> None:
+        "This method sorts the data."
+        data: list = list(self.data)
+        k: Any = self._sort if key is None else key
+        r: bool = bool(reverse)
+        data.sort(key=k, reverse=r)
+        self.data = data

{v440-2.0.0.dev52 → v440-2.0.0.dev54}/src/v440/_utils/utils.py

@@ -63,37 +63,6 @@ def _segment(value: Any, /) -> int | str:
         return int(value)
 
 
-def torange(key: Any, length: Any) -> range:
-    start: Any = key.start
-    stop: Any = key.stop
-    step: Any = key.step
-    if step is None:
-        step = 1
-    else:
-        step = operator.index(step)
-        if step == 0:
-            raise ValueError
-    fwd: bool = step > 0
-    if start is None:
-        start = 0 if fwd else (length - 1)
-    else:
-        start = operator.index(start)
-    if stop is None:
-        stop = length if fwd else -1
-    else:
-        stop = operator.index(stop)
-    if start < 0:
-        start += length
-    if start < 0:
-        start = 0 if fwd else -1
-    if stop < 0:
-        stop += length
-    if stop < 0:
-        stop = 0 if fwd else -1
-    ans: range = range(start, stop, step)
-    return ans
-
-
 def ishashable(value: Any) -> bool:
     try:
         hash(value)

{v440-2.0.0.dev52 → v440-2.0.0.dev54}/src/v440/core/Base.py

@@ -70,7 +70,7 @@ class Base(SlotList):
 
     __slots__ = ("_epoch", "_release")
 
-    data: list
+    data: tuple
     epoch: int
     release: Release
 
@@ -89,12 +89,12 @@ class Base(SlotList):
 
     @property
     @setdoc.basic
-    def data(self: Self) -> list:
-        return [self.epoch, self.release]
+    def data(self: Self) -> tuple:
+        return self.epoch, self.release
 
     @data.setter
     @guard
-    def data(self: Self, value: Iterable) -> None:
+    def data(self: Self, value: Any) -> None:
         self.epoch, self.release = parse_data(value)
 
     @property

{v440-2.0.0.dev52 → v440-2.0.0.dev54}/src/v440/core/Local.py

@@ -16,32 +16,32 @@ parse_data: Digest = Digest("parse_data")
 
 
 @parse_data.overload()
-def parse_data() -> list:
-    return list()
+def parse_data() -> tuple:
+    return ()
 
 
 @parse_data.overload(int)
 def parse_data(value: int) -> list:
-    return [value]
+    return (value,)
 
 
 @parse_data.overload(list)
 def parse_data(value: list) -> list:
-    ans: list = list(map(utils.segment, value))
+    ans: tuple = tuple(map(utils.segment, value))
     if None in ans:
         raise ValueError
     return ans
 
 
 @parse_data.overload(str)
-def parse_data(value: str) -> list:
+def parse_data(value: str) -> tuple:
     v: str = value
     if v.startswith("+"):
         v = v[1:]
     v = v.replace("_", ".")
     v = v.replace("-", ".")
-    ans: list = v.split(".")
-    ans = list(map(utils.segment, ans))
+    ans: tuple = v.split(".")
+    ans = tuple(map(utils.segment, ans))
     if None in ans:
         raise ValueError
     return ans
@@ -50,47 +50,27 @@ def parse_data(value: str) -> list:
 class Local(VList):
     __slots__ = ()
 
-    data: list[int | str]
+    data: tuple[int | str]
 
     @setdoc.basic
     def __init__(self: Any, data: Any = None) -> None:
-        self._data = list()
         self.data = data
 
-    @setdoc.basic
-    def __le__(self: Self, other: Iterable) -> bool:
-        ans: bool
-        try:
-            alt: Self = type(self)(other)
-        except ValueError:
-            ans = self.data <= other
-        else:
-            ans = self._cmp() <= alt._cmp()
-        return ans
-
-    def _cmp(self: Self) -> list:
-        return list(map(self._sortkey, self))
-
     def _format(self: Self, format_spec: str) -> str:
         if format_spec:
             raise ValueError
         return ".".join(map(str, self))
 
-    @staticmethod
-    def _sortkey(value: Any) -> tuple[bool, Any]:
+    @classmethod
+    def _sort(cls: type, value: Any) -> tuple[bool, Any]:
         return type(value) is int, value
 
     @property
     @setdoc.basic
     def data(self: Self) -> list[int | str]:
-        return list(self._data)
+        return self._data
 
     @data.setter
     @guard
     def data(self: Self, value: Any) -> None:
         self._data = parse_data(value)
-
-    @functools.wraps(VList.sort)
-    def sort(self: Self, /, *, key: Any = None, **kwargs: Any) -> None:
-        k: Any = self._sortkey if key is None else key
-        self._data.sort(key=k, **kwargs)

{v440-2.0.0.dev52 → v440-2.0.0.dev54}/src/v440/core/Public.py

@@ -42,7 +42,7 @@ class Public(SlotList):
 
     __slots__ = ("_base", "_qual")
 
-    data: list
+    data: tuple
     base: Base
     qual: Qual
 
@@ -68,7 +68,7 @@ class Public(SlotList):
     @property
     @setdoc.basic
     def data(self: Self) -> list:
-        return [self.base, self.qual]
+        return self.base, self.qual
 
     @data.setter
     @guard

{v440-2.0.0.dev52 → v440-2.0.0.dev54}/src/v440/core/Qual.py

@@ -15,7 +15,7 @@ class Qual(SlotList):
 
     __slots__ = ("_prephase", "_presubphase", "_post", "_dev")
 
-    data: list
+    data: tuple
     pre: tuple
     prephase: Optional[str]
     presubphase: Optional[int]
@@ -64,8 +64,8 @@ class Qual(SlotList):
 
     @property
     @setdoc.basic
-    def data(self: Self) -> list:
-        return [self.prephase, self.presubphase, self.post, self.dev]
+    def data(self: Self) -> tuple:
+        return self.prephase, self.presubphase, self.post, self.dev
 
     @data.setter
     @guard
@@ -74,6 +74,7 @@ class Qual(SlotList):
 
     @property
     def dev(self: Self) -> Optional[int]:
+        "This property represents the stage of development."
         return self._dev
 
     @dev.setter

{v440-2.0.0.dev52 → v440-2.0.0.dev54}/src/v440/core/Release.py

@@ -68,23 +68,47 @@ def tolist(value: Any, *, slicing: Any) -> list:
     return l
 
 
+def torange(key: Any, length: Any) -> range:
+    start: Any = key.start
+    stop: Any = key.stop
+    step: Any = key.step
+    if step is None:
+        step = 1
+    else:
+        step = operator.index(step)
+        if step == 0:
+            raise ValueError
+    fwd: bool = step > 0
+    if start is None:
+        start = 0 if fwd else (length - 1)
+    else:
+        start = operator.index(start)
+    if stop is None:
+        stop = length if fwd else -1
+    else:
+        stop = operator.index(stop)
+    if start < 0:
+        start += length
+    if start < 0:
+        start = 0 if fwd else -1
+    if stop < 0:
+        stop += length
+    if stop < 0:
+        stop = 0 if fwd else -1
+    ans: range = range(start, stop, step)
+    return ans
+
+
 @keyalias(major=0, minor=1, micro=2, patch=2)
 class Release(VList):
     __slots__ = ()
 
-    data: list[int]
+    data: tuple[int]
     major: int
     minor: int
     micro: int
     patch: int
 
-    @setdoc.basic
-    def __add__(self: Self, other: Any, /) -> Self:
-        opp: Self = type(self)(other)
-        ans: Self = self.copy()
-        ans._data += opp._data
-        return ans
-
     @Overloadable
     @setdoc.basic
     def __delitem__(self: Self, key: Any) -> bool:
@@ -94,17 +118,23 @@ class Release(VList):
     @setdoc.basic
     def __delitem__(self: Self, key: SupportsIndex) -> None:
         i: int = operator.index(key)
-        if i < len(self):
-            del self._data[i]
+        if i >= len(self):
+            return
+        data: list = list(self.data)
+        del data[i]
+        self.data = data
 
     @__delitem__.overload(True)
     @setdoc.basic
     def __delitem__(self: Self, key: Any) -> None:
-        r: range = utils.torange(key, len(self))
+        r: range = torange(key, len(self))
+        k: Any
         l: list = [k for k in r if k < len(self)]
         l.sort(reverse=True)
+        data: list = list(self.data)
         for k in l:
-            del self._data[k]
+            del data[k]
+        self.data = data
 
     @Overloadable
     @setdoc.basic
@@ -121,14 +151,13 @@ class Release(VList):
     @__getitem__.overload(True)
     @setdoc.basic
     def __getitem__(self: Self, key: Any) -> list:
-        r: range = utils.torange(key, len(self))
+        r: range = torange(key, len(self))
         m: map = map(self._getitem_int, r)
         ans: list = list(m)
         return ans
 
     @setdoc.basic
     def __init__(self: Any, data: Any = None) -> None:
-        self._data = list()
         self.data = data
 
     @Overloadable
@@ -145,7 +174,7 @@ class Release(VList):
     @__setitem__.overload(True)
     @setdoc.basic
     def __setitem__(self: Self, key: SupportsIndex, value: Any) -> Any:
-        k: range = utils.torange(key, len(self))
+        k: range = torange(key, len(self))
         self._setitem_range(k, value)
 
     def _format(self: Self, format_spec: str) -> str:
@@ -163,20 +192,21 @@ class Release(VList):
 
     def _getitem_int(self: Self, key: int) -> int:
         if key < len(self):
-            return self._data[key]
+            return self.data[key]
         else:
             return 0
 
     def _setitem_int(self: Self, key: int, value: Any) -> Any:
         v: int = utils.numeral(value)
-        n: int = len(self)
-        if n > key:
-            self._data[key] = v
+        if key < len(self):
+            data = list(self.data)
+            data[key] = v
+            self.data = data
             return
         if v == 0:
             return
-        self._data.extend([0] * (key - n))
-        self._data.append(v)
+        self._data += (0,) * (key - len(self))
+        self._data += (v,)
 
     @Overloadable
     def _setitem_range(self: Self, key: range, value: Any) -> bool:
@@ -184,32 +214,31 @@ class Release(VList):
 
     @_setitem_range.overload(False)
     def _setitem_range(self: Self, key: range, value: Any) -> Any:
-        key = list(key)
-        value = tolist(value, slicing=len(key))
+        key: list = list(key)
+        value: list = tolist(value, slicing=len(key))
         if len(key) != len(value):
             e = "attempt to assign sequence of size %s to extended slice of size %s"
             e %= (len(value), len(key))
             raise ValueError(e)
-        maximum = max(*key)
-        ext = max(0, maximum + 1 - len(self))
-        data = self.data
+        ext: int = max(0, max(*key) + 1 - len(self))
+        data: list = list(self.data)
         data += [0] * ext
         for k, v in zip(key, value):
             data[k] = v
-        while len(data) and not data[-1]:
-            data.pop()
-        self._data = data
+        self.data = data
 
     @_setitem_range.overload(True)
     def _setitem_range(self: Self, key: range, value: Any) -> Any:
-        data: list = self.data
+        data: list = list(self.data)
         ext: int = max(0, key.start - len(data))
         data += ext * [0]
         l: list = tolist(value, slicing="always")
         data = data[: key.start] + l + data[key.stop :]
-        while len(data) and not data[-1]:
-            data.pop()
-        self._data = data
+        self.data = data
+
+    @classmethod
+    def _sort(cls: type, value: int) -> int:
+        return value
 
     def bump(self: Self, index: SupportsIndex = -1, amount: SupportsIndex = 1) -> None:
         i: int = operator.index(index)
@@ -221,8 +250,8 @@ class Release(VList):
 
     @property
     @setdoc.basic
-    def data(self: Self) -> list:
-        return list(self._data)
+    def data(self: Self) -> tuple:
+        return self._data
 
     @data.setter
     @guard
@@ -230,4 +259,4 @@ class Release(VList):
         v: list = tolist(value, slicing="always")
         while v and v[-1] == 0:
             v.pop()
-        self._data = v
+        self._data = tuple(v)

{v440-2.0.0.dev52 → v440-2.0.0.dev54}/src/v440/core/Version.py

@@ -42,7 +42,7 @@ def parse_data(value: str) -> tuple:
 class Version(SlotList):
     __slots__ = ("_public", "_local")
 
-    data: list
+    data: tuple
     local: Local
     public: Public
 
@@ -52,9 +52,6 @@ class Version(SlotList):
         self._local = Local()
         self.data = data
 
-    def __str__(self: Self) -> str:
-        return format(self)
-
     def _format(self: Self, format_spec: str) -> str:
         ans: str = format(self.public, format_spec)
         if self.local:
@@ -63,8 +60,8 @@ class Version(SlotList):
 
     @property
     @setdoc.basic
-    def data(self: Self) -> list:
-        return [self.public, self.local]
+    def data(self: Self) -> tuple:
+        return self.public, self.local
 
     @data.setter
     @guard
@@ -73,6 +70,7 @@ class Version(SlotList):
 
     @property
     def local(self: Self) -> Local:
+        "This property represents the local identifier."
         return self._local
 
     @local.setter
@@ -86,6 +84,7 @@ class Version(SlotList):
 
     @property
     def public(self: Self) -> Self:
+        "This property represents the public identifier."
         return self._public
 
     @public.setter

{v440-2.0.0.dev52 → v440-2.0.0.dev54}/src/v440/tests/test_testdata.py

@@ -267,18 +267,22 @@ class TestPackagingA(unittest.TestCase):
 
 class TestPackagingB(unittest.TestCase):
     def test_strings_b(self: Self) -> None:
+        x: str
+        y: list
+        for x, y in Util.util.data["strings"]["valid"].items():
+            with self.subTest(key=x):
+                self.go(y)
+
+    def go(self: Self, y: list) -> None:
         a: packaging.version.Version
         b: packaging.version.Version
         s: str
         msg: str
-        x: str
-        y: list
-        for x, y in Util.util.data["strings"]["valid"].items():
-            for s in y:
-                a = packaging.version.Version(s)
-                b = Version(s).packaging()
-                msg = f"{s} should match packaging.version.Version"
-                self.assertEqual(a, b, msg=msg)
+        for s in y:
+            a = packaging.version.Version(s)
+            b = Version(s).packaging()
+            msg = f"{s} should match packaging.version.Version"
+            self.assertEqual(a, b, msg=msg)
 
 
 class TestPackagingC(unittest.TestCase):

{v440-2.0.0.dev52 → v440-2.0.0.dev54}/src/v440/tests/test_version.py

@@ -303,7 +303,7 @@ class TestAdditionalVersionRelease(unittest.TestCase):
         # Test the 'data' property
         version: Version = Version()
         version.public.base.release = [1, 2, 3]
-        self.assertEqual(version.public.base.release.data, [1, 2, 3])
+        self.assertEqual(version.public.base.release.data, (1, 2, 3))
 
     def test_release_data_setter(self: Self) -> None:
         # Test setting the 'data' property directly
@@ -381,7 +381,7 @@ class TestVersionLocal(unittest.TestCase):
         # Test that 'data' property correctly reflects local's internal list
         version: Version = Version()
         version.local = [1, "dev", "build"]
-        self.assertEqual(version.local.data, [1, "dev", "build"])
+        self.assertEqual(version.local.data, (1, "dev", "build"))
 
     def test_local_data_setter(self: Self) -> None:
         # Test that 'data' property can be set directly

{v440-2.0.0.dev52 → v440-2.0.0.dev54/src/v440.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: v440
-Version: 2.0.0.dev52
+Version: 2.0.0.dev54
 Summary: This project provides mutable version objects in accordance with PEP440.
 Author-email: Johannes <johannes.programming@gmail.com>
 License: The MIT License (MIT)
@@ -41,7 +41,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: catchlib<2.0,>=1.0
-Requires-Dist: datahold<2.0,>=1.1.8
+Requires-Dist: datarepr<2,>=1.0.2
 Requires-Dist: iterprod<2.0,>=1.0
 Requires-Dist: keyalias<2.0,>=1.0.3
 Requires-Dist: overloadable<2.0,>=1.0.5
@@ -49,6 +49,7 @@ Requires-Dist: packaging>=23.2
 Requires-Dist: scaevola<2.0,>=1.1
 Requires-Dist: setdoc<2,>=1.2
 Requires-Dist: tofunc<2,>=1.0.0
+Requires-Dist: unhash<2,>=1.0.1
 Dynamic: license-file
 
 ====

{v440-2.0.0.dev52 → v440-2.0.0.dev54}/src/v440.egg-info/requires.txt

@@ -1,5 +1,5 @@
 catchlib<2.0,>=1.0
-datahold<2.0,>=1.1.8
+datarepr<2,>=1.0.2
 iterprod<2.0,>=1.0
 keyalias<2.0,>=1.0.3
 overloadable<2.0,>=1.0.5
@@ -7,3 +7,4 @@ packaging>=23.2
 scaevola<2.0,>=1.1
 setdoc<2,>=1.2
 tofunc<2,>=1.0.0
+unhash<2,>=1.0.1

v440-2.0.0.dev52/src/v440/_utils/BaseList.py

@@ -1,15 +0,0 @@
-from abc import ABCMeta, abstractmethod
-from typing import *
-
-import setdoc
-
-
-class BaseList(metaclass=ABCMeta):
-    __slots__ = ()
-
-    @abstractmethod
-    @setdoc.basic
-    def __bool__(self: Self) -> bool: ...
-
-    @abstractmethod
-    def _format(self: Self, format_spec: str) -> str: ...

v440-2.0.0.dev52/src/v440/_utils/VList.py

@@ -1,75 +0,0 @@
-import builtins
-from typing import *
-
-import setdoc
-from datahold import OkayList
-
-from v440._utils.BaseList import BaseList
-from v440.core.VersionError import VersionError
-
-
-class VList(OkayList, BaseList):
-
-    __slots__ = ()
-
-    @setdoc.basic
-    def __format__(self: Self, format_spec: Any) -> str:
-        try:
-            return self._format(str(format_spec))
-        except Exception:
-            msg: str = "unsupported format string passed to %s.__format__"
-            msg %= type(self).__name__
-            raise TypeError(msg) from None
-
-    @setdoc.basic
-    def __str__(self: Self) -> str:
-        return builtins.format(self)
-
-    @setdoc.basic
-    def __eq__(self: Self, other: Any) -> bool:
-        ans: bool
-        try:
-            alt: Self = type(self)(other)
-        except VersionError:
-            ans = False
-        else:
-            ans = self._data == alt._data
-        return ans
-
-    @setdoc.basic
-    def __ge__(self: Self, other: Any, /) -> bool:
-        ans: bool
-        try:
-            alt: Self = type(self)(other)
-        except Exception:
-            ans = self.data >= other
-        else:
-            ans = alt <= self
-        return ans
-
-    @setdoc.basic
-    def __iadd__(self: Self, other: Any, /) -> Self:
-        self.data += type(self)(other).data
-        return self
-
-    @setdoc.basic
-    def __imul__(self: Self, other: Any, /) -> Self:
-        self.data = self.data * other
-        return self
-
-    @setdoc.basic
-    def __le__(self: Self, other: Any, /) -> bool:
-        ans: bool
-        try:
-            alt: Self = type(self)(other)
-        except Exception:
-            ans = self.data <= other
-        else:
-            ans = self._data <= alt._data
-        return ans
-
-    def __sorted__(self: Any, /, **kwargs: Any) -> Self:
-        "This magic method implements sorted(self, **kwargs)."
-        ans: Any = self.copy()
-        ans.sort(**kwargs)
-        return ans