v440 2.0.0.dev60__tar.gz → 2.0.0.dev62__tar.gz

{v440-2.0.0.dev60/src/v440.egg-info → v440-2.0.0.dev62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: v440
-Version: 2.0.0.dev60
+Version: 2.0.0.dev62
 Summary: This project provides mutable version objects in accordance with PEP440.
 Author-email: Johannes <johannes.programming@gmail.com>
 License: The MIT License (MIT)

{v440-2.0.0.dev60 → v440-2.0.0.dev62}/pyproject.toml

@@ -36,7 +36,7 @@ keywords = []
 name = "v440"
 readme = "README.rst"
 requires-python = ">=3.11"
-version = "2.0.0.dev60"
+version = "2.0.0.dev62"
 
 [project.license]
 file = "LICENSE.txt"

{v440-2.0.0.dev60 → v440-2.0.0.dev62}/src/v440/_utils/BaseList.py

@@ -1,18 +1,17 @@
 import collections
-from abc import abstractmethod
+from abc import ABCMeta, abstractmethod
 from typing import *
 
 import scaevola
 import setdoc
 import unhash
-from datarepr import datarepr
 
 from v440._utils.utils import guard
 from v440.core.VersionError import VersionError
 
 
 @scaevola.auto
-class BaseList(collections.abc.Collection):
+class BaseList(metaclass=ABCMeta):
     __slots__ = ()
 
     string: str
@@ -21,17 +20,13 @@ class BaseList(collections.abc.Collection):
     @setdoc.basic
     def __bool__(self: Self) -> bool: ...
 
-    @setdoc.basic
-    def __contains__(self: Self, other: Any) -> bool:
-        return other in self.data
-
     @setdoc.basic
     def __eq__(self: Self, other: Any) -> bool:
         try:
             alt: Self = type(self)(other)
         except VersionError:
             return False
-        return self.data == alt.data
+        return self.string == alt.string
 
     @setdoc.basic
     def __format__(self: Self, format_spec: Any) -> str:
@@ -40,7 +35,7 @@ class BaseList(collections.abc.Collection):
         except Exception:
             msg: str = "unsupported format string passed to %s.__format__"
             msg %= type(self).__name__
-            raise TypeError(msg) from None
+            raise TypeError(msg)  # from None
 
     @setdoc.basic
     def __ge__(self: Self, other: Any) -> bool:
@@ -51,10 +46,6 @@ class BaseList(collections.abc.Collection):
             return NotImplemented
         return self._cmp() >= alt._cmp()
 
-    @setdoc.basic
-    def __getitem__(self: Self, key: Any) -> Any:
-        return self.data[key]
-
     @setdoc.basic
     def __gt__(self: Self, other: Any) -> bool:
         alt: Self
@@ -66,13 +57,9 @@ class BaseList(collections.abc.Collection):
 
     __hash__ = unhash
 
+    @abstractmethod
     @setdoc.basic
-    def __init__(self: Self, data: Any = None) -> None:
-        self.data = data
-
-    @setdoc.basic
-    def __iter__(self: Self) -> Iterator:
-        return iter(self.data)
+    def __init__(self: Self, string: Any) -> None: ...
 
     @setdoc.basic
     def __le__(self: Self, other: Any) -> bool:
@@ -96,19 +83,9 @@ class BaseList(collections.abc.Collection):
     def __ne__(self: Self, other: Any) -> bool:
         return not (self == other)
 
+    @abstractmethod
     @setdoc.basic
-    def __repr__(self: Self) -> str:
-        return datarepr(type(self).__name__, self.data)
-
-    @setdoc.basic
-    def __reversed__(self: Self) -> reversed:
-        return reversed(self.data)
-
-    @setdoc.basic
-    def __setitem__(self: Self, key: Any, value: Any) -> None:
-        data: list = list(self.data)
-        data[key] = value
-        self.data = data
+    def __repr__(self: Self) -> str: ...
 
     @classmethod
     def __subclasshook__(cls: type, other: type, /) -> bool:
@@ -125,26 +102,19 @@ class BaseList(collections.abc.Collection):
     @abstractmethod
     def _format(self: Self, format_spec: str) -> str: ...
 
+    @abstractmethod
+    def _set(self: Self, value: Any) -> None: ...
+
     @abstractmethod
     def _string_fset(self: Self, value: str) -> None: ...
 
+    @abstractmethod
+    def _todict(self: Self) -> dict: ...
+
     @setdoc.basic
     def copy(self: Self) -> Self:
         return type(self)(self)
 
-    @property
-    @abstractmethod
-    @setdoc.basic
-    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, *args: Any) -> None:
-        "This method returns the index of the first occurence."
-        return self.data.index(*args)
-
     @property
     def string(self: Self) -> str:
         return self._format("")

{v440-2.0.0.dev60 → v440-2.0.0.dev62}/src/v440/_utils/SlotList.py

@@ -1,7 +1,9 @@
+from abc import abstractmethod
 from functools import partial
 from typing import *
 
 import setdoc
+from datarepr import datarepr
 
 from v440._utils.BaseList import BaseList
 
@@ -11,16 +13,21 @@ __all__ = ["SlotList"]
 class SlotList(BaseList):
     __slots__ = ()
 
-    data: tuple
     string: str
 
-    @setdoc.basic
-    def __bool__(self: Self) -> bool:
-        return any(self.data)
-
     @setdoc.basic
     def __len__(self: Self) -> int:
         return len(type(self).__slots__)
 
+    @setdoc.basic
+    def __repr__(self: Self) -> str:
+        return datarepr(type(self).__name__, **self._todict())
+
     def _cmp(self: Self) -> tuple:
         return tuple(map(partial(getattr, self), type(self).__slots__))
+
+    def _set(self: Self, value: Any) -> None:
+        if value is None:
+            self.string = ""
+        else:
+            self.string = value

{v440-2.0.0.dev60 → v440-2.0.0.dev62}/src/v440/_utils/VList.py

@@ -1,14 +1,18 @@
+import collections
 from abc import abstractmethod
 from typing import *
 
 import setdoc
+from datarepr import datarepr
+from overloadable import Overloadable
 
 from v440._utils.BaseList import BaseList
+from v440._utils.utils import guard
 
 __all__ = ["VList"]
 
 
-class VList(BaseList):
+class VList(BaseList, collections.abc.MutableSequence):
 
     __slots__ = ("_data",)
     data: tuple
@@ -57,6 +61,9 @@ class VList(BaseList):
     @abstractmethod
     def _sort(cls: type, value: Any): ...
 
+    def _todict(self: Self) -> dict:
+        return dict(data=self.data)
+
     def append(self: Self, value: Self, /) -> None:
         "This method appends value to self."
         data: list = list(self.data)
@@ -110,3 +117,90 @@ class VList(BaseList):
         r: bool = bool(reverse)
         data.sort(key=k, reverse=r)
         self.data = data
+
+    # data-associated
+    @setdoc.basic
+    def __contains__(self: Self, other: Any) -> bool:
+        return other in self.data
+
+    @setdoc.basic
+    def __getitem__(self: Self, key: Any) -> Any:
+        return self.data[key]
+
+    @Overloadable
+    @setdoc.basic
+    def __init__(self: Self, *args: Any, **kwargs: Any) -> bool:
+        if len(args) == 0 and "string" in kwargs.keys():
+            return True
+        if len(args) == 1 and len(kwargs) == 0:
+            if isinstance(args[0], str):
+                return True
+            if hasattr(args[0], "__iter__"):
+                return False
+            return True
+        return False
+
+    @__init__.overload(True)
+    @setdoc.basic
+    def __init__(self: Self, string: Any) -> None:
+        self._init_setup()
+        self.string = string
+
+    @__init__.overload(False)
+    @setdoc.basic
+    def __init__(self: Self, data: Iterable = ()) -> None:
+        self._init_setup()
+        self.data = data
+
+    @setdoc.basic
+    def __iter__(self: Self) -> Iterator:
+        return iter(self.data)
+
+    @setdoc.basic
+    def __repr__(self: Self) -> str:
+        return datarepr(type(self).__name__, *self.data)
+
+    @setdoc.basic
+    def __reversed__(self: Self) -> reversed:
+        return reversed(self.data)
+
+    @setdoc.basic
+    def __setitem__(self: Self, key: Any, value: Any) -> None:
+        data: list = list(self.data)
+        data[key] = value
+        self.data = data
+
+    @classmethod
+    @abstractmethod
+    def _data_parse(cls: type, value: list) -> Iterable: ...
+
+    def _init_setup(self: Self) -> None:
+        self._data = ()
+
+    def _set(self: Self, value: Any) -> None:
+        if value is None:
+            self.data = ()
+        elif isinstance(value, str):
+            self.string = value
+        elif hasattr(value, "__iter__"):
+            self.data = value
+        else:
+            self.string = value
+
+    @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 count(self: Self, value: Any) -> int:
+        "This method counts the occurences of value."
+        return self.data.count(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.dev60 → v440-2.0.0.dev62}/src/v440/_utils/qualparse.py

@@ -7,51 +7,6 @@ from v440._utils.Cfg import Cfg
 from v440._utils.Digest import Digest
 from v440._utils.Pattern import Pattern
 
-parse_leg: Digest = Digest("parse_leg")
-
-
-@parse_leg.overload()
-def parse_leg() -> tuple:
-    return None, None, None
-
-
-@parse_leg.overload(int)
-def parse_leg(value: int) -> tuple:
-    return None, abs(value), None
-
-
-@parse_leg.overload(list)
-def parse_leg(value: list) -> tuple:
-    return tuple([value[:2]] + value[2:])
-
-
-@parse_leg.overload(str)
-def parse_leg(value: str) -> tuple:
-    v = value
-    pre: tuple = None, None
-    post: Optional[str] = None
-    dev: Optional[str] = None
-    m: Any
-    x: Any
-    y: Any
-    while v:
-        m = Pattern.QUALIFIERS.leftbound.search(v)
-        v = v[m.end() :]
-        if m.group("N"):
-            post = m.group("N")
-            continue
-        x = m.group("l")
-        y = m.group("n")
-        if x == "dev":
-            dev = y
-            continue
-        if x in ("post", "r", "rev"):
-            post = y
-            continue
-        pre = x, y
-    return pre, post, dev
-
-
 parse_dev: Digest = Digest("parse_dev")
 
 

{v440-2.0.0.dev60 → v440-2.0.0.dev62}/src/v440/_utils/utils.py

@@ -74,30 +74,17 @@ def ishashable(value: Any) -> bool:
 def guard(old: Any) -> Any:
     @functools.wraps(old)
     def new(self: Self, value: Any) -> None:
-        backup: dict = dict()
-        x: Any
-        y: Any
-        for x in type(self).__slots__:
-            y = getattr(self, x)
-            backup[x] = y if ishashable(y) else y.copy()
+        backup: str = str(getattr(self, old.__name__))
         try:
             old(self, value)
         except VersionError:
-            restore(obj=self, backup=backup)
+            setattr(self, old.__name__, backup)
             raise
         except Exception:
-            restore(obj=self, backup=backup)
+            setattr(self, old.__name__, backup)
             msg: str = "%r is an invalid value for %r"
             target: str = type(self).__name__ + "." + old.__name__
             msg %= (value, target)
             raise VersionError(msg)
 
     return new
-
-
-def restore(obj: Any, backup: dict) -> None:
-    for x in type(obj).__slots__:
-        if ishashable(backup[x]):
-            setattr(obj, x, backup[x])
-        else:
-            getattr(obj, x).data = backup[x]

{v440-2.0.0.dev60 → v440-2.0.0.dev62}/src/v440/core/Base.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import *
 
 import setdoc
+from overloadable import Overloadable
 
 from v440._utils.Digest import Digest
 from v440._utils.SlotList import SlotList
@@ -12,32 +13,6 @@ from v440.core.Release import Release
 __all__ = ["Base"]
 
 
-parse_data: Digest = Digest("parse_data")
-
-
-@parse_data.overload()
-def parse_data() -> tuple:
-    return None, None
-
-
-@parse_data.overload(int)
-def parse_data(value: int) -> tuple:
-    return None, value
-
-
-@parse_data.overload(list)
-def parse_data(value: list) -> tuple:
-    return tuple(value)
-
-
-@parse_data.overload(str)
-def parse_data(value: str) -> tuple:
-    if "!" in value:
-        return tuple(value.split("!"))
-    else:
-        return 0, value
-
-
 parse_epoch: Digest = Digest("parse_epoch")
 
 
@@ -70,16 +45,42 @@ class Base(SlotList):
 
     __slots__ = ("_epoch", "_release")
 
-    data: tuple
     string: str
     epoch: int
     release: Release
 
+    def __bool__(self: Self) -> bool:
+        return bool(self.epoch or self.release)
+
+    @Overloadable
+    @setdoc.basic
+    def __init__(self: Self, *args: Any, **kwargs: Any) -> bool:
+        if len(args) == 0 and "string" in kwargs.keys():
+            return True
+        if len(args) == 1 and len(kwargs) == 0:
+            return True
+        return False
+
+    @__init__.overload(True)
+    @setdoc.basic
+    def __init__(self: Self, string: Any) -> None:
+        self._init_setup()
+        self.string = string
+
+    @__init__.overload(False)
     @setdoc.basic
-    def __init__(self: Self, data: Any = None) -> None:
+    def __init__(
+        self: Self,
+        epoch: Any = "0",
+        release: Any = "0",
+    ) -> None:
+        self._init_setup()
+        self.epoch = epoch
+        self.release = release
+
+    def _init_setup(self: Self) -> None:
         self._epoch = 0
         self._release = Release()
-        self.data = data
 
     def _format(self: Self, format_spec: str) -> str:
         ans: str = ""
@@ -89,22 +90,18 @@ class Base(SlotList):
         return ans
 
     def _string_fset(self: Self, value: str) -> None:
+        v: str = value
+        if v.startswith("v"):
+            v = v[1:]
         parsed: Iterable
-        if "!" in value:
-            parsed = value.split("!")
+        if "!" in v:
+            parsed = v.split("!")
         else:
-            parsed = 0, value
+            parsed = 0, v
         self.epoch, self.release.string = parsed
 
-    @property
-    @setdoc.basic
-    def data(self: Self) -> tuple:
-        return self.epoch, self.release
-
-    @data.setter
-    @guard
-    def data(self: Self, value: Any) -> None:
-        self.epoch, self.release = parse_data(value)
+    def _todict(self: Self) -> dict:
+        return dict(epoch=self.epoch, release=self.release)
 
     @property
     def epoch(self: Self) -> int:
@@ -124,4 +121,4 @@ class Base(SlotList):
     @release.setter
     @guard
     def release(self: Self, value: Any) -> None:
-        self._release.data = value
+        self.release._set(value)

v440-2.0.0.dev62/src/v440/core/Local.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import *
+
+import setdoc
+
+from v440._utils import utils
+from v440._utils.Digest import Digest
+from v440._utils.utils import guard
+from v440._utils.VList import VList
+
+__all__ = ["Local"]
+
+
+class Local(VList):
+    __slots__ = ()
+
+    data: tuple[int | str]
+    string: str
+
+    @classmethod
+    def _data_parse(cls: type, value: list) -> Iterable:
+        ans: tuple = tuple(map(utils.segment, value))
+        if None in ans:
+            raise ValueError
+        return ans
+
+    def _format(self: Self, format_spec: str) -> str:
+        if format_spec:
+            raise ValueError
+        return ".".join(map(str, self))
+
+    @classmethod
+    def _sort(cls: type, value: Any) -> tuple[bool, int | str]:
+        return type(value) is int, value
+
+    def _string_fset(self: Self, value: str) -> None:
+        if value == "":
+            return ()
+        v: str = value
+        if v.startswith("+"):
+            v = v[1:]
+        v = v.replace("_", ".")
+        v = v.replace("-", ".")
+        self.data = v.split(".")

{v440-2.0.0.dev60 → v440-2.0.0.dev62}/src/v440/core/Public.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import *
 
 import setdoc
+from overloadable import Overloadable
 
 from v440._utils.Digest import Digest
 from v440._utils.Pattern import Pattern
@@ -14,44 +15,46 @@ from v440.core.Qual import Qual
 __all__ = ["Public"]
 
 
-parse_data: Digest = Digest("parse_data")
-
-
-@parse_data.overload()
-def parse_data() -> tuple:
-    return None, None
-
-
-@parse_data.overload(int)
-def parse_data(value: int) -> tuple:
-    return value, None
-
-
-@parse_data.overload(list)
-def parse_data(value: list) -> tuple:
-    return tuple(value)
-
-
-@parse_data.overload(str)
-def parse_data(value: str) -> tuple:
-    match: Any = Pattern.PUBLIC.leftbound.search(value)
-    return value[: match.end()], value[match.end() :]
-
-
 class Public(SlotList):
 
     __slots__ = ("_base", "_qual")
 
-    data: tuple
     string: str
     base: Base
     qual: Qual
 
+    def __bool__(self: Self) -> bool:
+        return bool(self.base or self.qual)
+
+    @Overloadable
+    @setdoc.basic
+    def __init__(self: Self, *args: Any, **kwargs: Any) -> bool:
+        if len(args) == 0 and "string" in kwargs.keys():
+            return True
+        if len(args) == 1 and len(kwargs) == 0:
+            return True
+        return False
+
+    @__init__.overload(True)
     @setdoc.basic
-    def __init__(self: Self, data: Any = None) -> None:
+    def __init__(self: Self, string: Any) -> None:
+        self._init_setup()
+        self.string = string
+
+    @__init__.overload(False)
+    @setdoc.basic
+    def __init__(
+        self: Self,
+        base: Any = "0",
+        qual: Any = "",
+    ) -> None:
+        self._init_setup()
+        self.base = base
+        self.qual = qual
+
+    def _init_setup(self: Self) -> None:
         self._base = Base()
         self._qual = Qual()
-        self.data = data
 
     def _format(self: Self, format_spec: str) -> str:
         return format(self.base, format_spec) + format(self.qual)
@@ -61,25 +64,17 @@ class Public(SlotList):
         self.base.string = value[: match.end()]
         self.qual.string = value[match.end() :]
 
+    def _todict(self: Self) -> dict:
+        return dict(base=self.base, qual=self.qual)
+
     @property
     def base(self: Self) -> Base:
         "This property represents the version base."
         return self._base
 
     @base.setter
-    @guard
     def base(self: Self, value: Any) -> None:
-        self.base.data = value
-
-    @property
-    @setdoc.basic
-    def data(self: Self) -> list:
-        return self.base, self.qual
-
-    @data.setter
-    @guard
-    def data(self: Self, value: Any) -> None:
-        self.base, self.qual = parse_data(value)
+        self.base._set(value)
 
     @property
     def qual(self: Self) -> Qual:
@@ -87,6 +82,5 @@ class Public(SlotList):
         return self._qual
 
     @qual.setter
-    @guard
     def qual(self: Self, value: Any) -> None:
-        self.qual.data = value
+        self.qual._set(value)

{v440-2.0.0.dev60 → v440-2.0.0.dev62}/src/v440/core/Qual.py

@@ -3,8 +3,10 @@ from __future__ import annotations
 from typing import *
 
 import setdoc
+from overloadable import Overloadable
 
-from v440._utils import qualparse
+from v440._utils import qualparse, utils
+from v440._utils.Pattern import Pattern
 from v440._utils.SlotList import SlotList
 from v440._utils.utils import guard
 
@@ -15,7 +17,6 @@ class Qual(SlotList):
 
     __slots__ = ("_prephase", "_presubphase", "_post", "_dev")
 
-    data: tuple
     string: str
     pre: tuple
     prephase: Optional[str]
@@ -23,17 +24,42 @@ class Qual(SlotList):
     post: Optional[int]
     dev: Optional[int]
 
-    @setdoc.basic
     def __bool__(self: Self) -> bool:
-        return set(self.data) != {None}
+        return self.string == ""
+
+    @Overloadable
+    @setdoc.basic
+    def __init__(self: Self, *args: Any, **kwargs: Any) -> bool:
+        if len(args) == 0 and "string" in kwargs.keys():
+            return True
+        if len(args) == 1 and len(kwargs) == 0:
+            return True
+        return False
+
+    @__init__.overload(True)
+    @setdoc.basic
+    def __init__(self: Self, string: Any) -> None:
+        self._init_setup()
+        self.string = string
 
+    @__init__.overload(False)
     @setdoc.basic
-    def __init__(self: Self, data: Any = None) -> None:
+    def __init__(
+        self: Self,
+        pre: Any = None,
+        post: Any = None,
+        dev: Any = None,
+    ) -> None:
+        self._init_setup()
+        self.pre = pre
+        self.post = post
+        self.dev = dev
+
+    def _init_setup(self: Self) -> None:
         self._prephase = None
         self._presubphase = None
         self._post = None
         self._dev = None
-        self.data = data
 
     def _cmp(self: Self) -> list:
         ans: list = list()
@@ -68,31 +94,30 @@ class Qual(SlotList):
         m: Any
         x: Any
         y: Any
+        pre: Any = (None, None)
+        post: Any = None
+        dev: Any = None
         while v:
             m = Pattern.QUALIFIERS.leftbound.search(v)
             v = v[m.end() :]
             if m.group("N"):
-                self.post = m.group("N")
+                post = m.group("N")
                 continue
             x = m.group("l")
             y = m.group("n")
             if x == "dev":
-                self.dev = y
+                dev = y
                 continue
             if x in ("post", "r", "rev"):
-                self.post = y
+                post = y
                 continue
-            self.pre = x, y
+            pre = x, y
+        self.pre = pre
+        self.post = post
+        self.dev = dev
 
-    @property
-    @setdoc.basic
-    def data(self: Self) -> tuple:
-        return self.prephase, self.presubphase, self.post, self.dev
-
-    @data.setter
-    @guard
-    def data(self: Self, value: Any) -> None:
-        self.pre, self.post, self.dev = qualparse.parse_leg(value)
+    def _todict(self: Self) -> dict:
+        return dict(pre=self.pre, post=self.post, dev=self.dev)
 
     @property
     def dev(self: Self) -> Optional[int]:

{v440-2.0.0.dev60 → v440-2.0.0.dev62}/src/v440/core/Release.py

@@ -157,10 +157,6 @@ class Release(VList):
         ans: list = list(m)
         return ans
 
-    @setdoc.basic
-    def __init__(self: Any, data: Any = None) -> None:
-        self.data = data
-
     @Overloadable
     @setdoc.basic
     def __setitem__(self: Self, key: Any, value: Any) -> bool:
@@ -178,6 +174,13 @@ class Release(VList):
         k: range = torange(key, len(self))
         self._setitem_range(k, value)
 
+    @classmethod
+    def _data_parse(cls: type, value: list) -> Iterable:
+        v: list = tolist(value, slicing="always")
+        while v and v[-1] == 0:
+            v.pop()
+        return v
+
     def _format(self: Self, format_spec: str) -> str:
         i: Optional[int]
         if format_spec:
@@ -254,16 +257,3 @@ class Release(VList):
         self._setitem_int(i, x)
         if i != -1:
             self.data = self.data[: i + 1]
-
-    @property
-    @setdoc.basic
-    def data(self: Self) -> tuple:
-        return self._data
-
-    @data.setter
-    @guard
-    def data(self: Self, value: Any) -> None:
-        v: list = tolist(value, slicing="always")
-        while v and v[-1] == 0:
-            v.pop()
-        self._data = tuple(v)

{v440-2.0.0.dev60 → v440-2.0.0.dev62}/src/v440/core/Version.py

@@ -4,8 +4,8 @@ from typing import *
 
 import packaging.version
 import setdoc
+from overloadable import Overloadable
 
-from v440._utils.Digest import Digest
 from v440._utils.SlotList import SlotList
 from v440._utils.utils import guard
 from v440.core.Local import Local
@@ -13,45 +13,46 @@ from v440.core.Public import Public
 
 __all__ = ["Version"]
 
-parse_data: Digest = Digest("parse_data")
-
-
-@parse_data.overload()
-def parse_data() -> tuple:
-    return None, None
-
-
-@parse_data.overload(int)
-def parse_data(value: int) -> tuple:
-    return value, None
-
-
-@parse_data.overload(list)
-def parse_data(value: list) -> tuple:
-    return tuple(value)
-
-
-@parse_data.overload(str)
-def parse_data(value: str) -> tuple:
-    if "+" in value:
-        return tuple(value.split("+"))
-    else:
-        return value, None
-
 
 class Version(SlotList):
     __slots__ = ("_public", "_local")
 
-    data: tuple
     string: str
     local: Local
     public: Public
 
+    def __bool__(self: Self) -> bool:
+        return bool(self.local or self.public)
+
+    @Overloadable
+    @setdoc.basic
+    def __init__(self: Self, *args: Any, **kwargs: Any) -> bool:
+        if len(args) == 0 and "string" in kwargs.keys():
+            return True
+        if len(args) == 1 and len(kwargs) == 0:
+            return True
+        return False
+
+    @__init__.overload(True)
+    @setdoc.basic
+    def __init__(self: Self, string: Any) -> None:
+        self._init_setup()
+        self.string = string
+
+    @__init__.overload(False)
     @setdoc.basic
-    def __init__(self: Self, data: Any = None) -> None:
+    def __init__(
+        self: Self,
+        public: Any = "0",
+        local: Any = "",
+    ) -> None:
+        self._init_setup()
+        self.public = public
+        self.local = local
+
+    def _init_setup(self: Self) -> None:
         self._public = Public()
         self._local = Local()
-        self.data = data
 
     def _format(self: Self, format_spec: str) -> str:
         ans: str = format(self.public, format_spec)
@@ -67,15 +68,8 @@ class Version(SlotList):
             parsed = value, ""
         self.public.string, self.local.string = parsed
 
-    @property
-    @setdoc.basic
-    def data(self: Self) -> tuple:
-        return self.public, self.local
-
-    @data.setter
-    @guard
-    def data(self: Self, value: Any) -> None:
-        self.public, self.local = parse_data(value)
+    def _todict(self: Self) -> dict:
+        return dict(public=self.public, local=self.local)
 
     @property
     def local(self: Self) -> Local:
@@ -85,7 +79,7 @@ class Version(SlotList):
     @local.setter
     @guard
     def local(self: Self, value: Any) -> None:
-        self.local.data = value
+        self.local._set(value)
 
     def packaging(self: Self) -> packaging.version.Version:
         "This method returns an eqivalent packaging.version.Version object."
@@ -99,4 +93,4 @@ class Version(SlotList):
     @public.setter
     @guard
     def public(self: Self, value: Any) -> None:
-        self.public.data = value
+        self.public._set(value)

{v440-2.0.0.dev60 → v440-2.0.0.dev62}/src/v440/tests/test_testdata.py

@@ -167,7 +167,8 @@ class TestSlicingGo(unittest.TestCase):
 class TestDataProperty(unittest.TestCase):
     def test_data(self: Self) -> None:
         for k, v in Util.util.data["data-property"].items():
-            self.go(**v, key=k)
+            with self.subTest(key=k):
+                self.go(**v, key=k)
 
     def go(
         self: Self,
@@ -177,7 +178,7 @@ class TestDataProperty(unittest.TestCase):
     ) -> None:
         msg: str = "data-property %r" % key
         version: Version = Version()
-        version.data = query
+        version.string = query
         self.assertEqual(solution, str(version), msg=msg)
 
 
@@ -384,7 +385,7 @@ class TestSlots(unittest.TestCase):
         clsname: str,
         attrname: str,
         attrvalue: Any,
-        data: Any = None,
+        string: Any = None,
         isimported: Optional[bool] = False,
     ) -> None:
         cls: type
@@ -392,7 +393,7 @@ class TestSlots(unittest.TestCase):
             cls = getattr(core, clsname)
         else:
             cls = getattr(getattr(core, clsname), clsname)
-        obj: Any = cls(data)
+        obj: Any = cls(string=string)
         with self.assertRaises(AttributeError):
             setattr(obj, attrname, attrvalue)
 

{v440-2.0.0.dev60 → v440-2.0.0.dev62}/src/v440/tests/test_version.py

@@ -59,7 +59,7 @@ class TestPre(unittest.TestCase):
 
         # Initial version, no pre-release version
         self.assertEqual(str(v), "1.2.3")
-        self.assertEqual(v.public.qual, [None, None, None, None])
+        self.assertEqual(v.public.qual.string, "")
 
         # Set pre-release version to "a1"
         v.public.qual = "a1"
@@ -88,7 +88,7 @@ class TestPre(unittest.TestCase):
         # Set pre-release to None
         v.public.qual = None
         self.assertEqual(str(v), "1.2.3")
-        self.assertEqual(v.public.qual, [None, None, None, None])
+        self.assertEqual(str(v.public.qual), "")
 
 
 class TestExample(unittest.TestCase):
@@ -179,7 +179,7 @@ class TestExample(unittest.TestCase):
     def test_example_7(self: Self) -> None:
         v: Version = Version("5.0.0")
         self.assertEqual(str(v), "5")  # Original version
-        v.data = None
+        v.string = ""
         self.assertEqual(str(v), "0")  # After reset
         v.public.base = "4!5.0.1"
         self.assertEqual(str(v), "4!5.0.1")  # Before error

{v440-2.0.0.dev60 → v440-2.0.0.dev62}/src/v440/tests/testdata.toml

@@ -961,9 +961,6 @@ solution = "9001"
 query = "1701!4.5.6.rc255+reset"
 solution = "1701!4.5.6rc255+reset"
 
-[data-property.none]
-solution = "0"
-
 [slicingmethod.test_slicing_1]
 query = "1.2.3.4.5.6.7.8.9.10"
 start = -8
@@ -1030,36 +1027,43 @@ full = "1.2.3"
 part = 0
 
 [core-non-attributes.test-0000]
+string = ""
 clsname = "Base"
 attrname = "fdsfvdsff"
 attrvalue = 42
 
 [core-non-attributes.test-0100]
+string = ""
 clsname = "Local"
 attrname = "fdsfvdsff"
 attrvalue = 42
 
 [core-non-attributes.test-0200]
+string = ""
 clsname = "Public"
 attrname = "fdsfvdsff"
 attrvalue = 42
 
 [core-non-attributes.test-0300]
+string = ""
 clsname = "Qual"
 attrname = "fdsfvdsff"
 attrvalue = 42
 
 [core-non-attributes.test-0400]
+string = ""
 clsname = "Release"
 attrname = "fdsfvdsff"
 attrvalue = 42
 
 [core-non-attributes.test-0500]
+string = ""
 clsname = "Public"
 attrname = "fdsfvdsff"
 attrvalue = 42
 
 [core-non-attributes.test-0600]
+string = ""
 clsname = "Version"
 attrname = "fdsfvdsff"
 attrvalue = 42

{v440-2.0.0.dev60 → v440-2.0.0.dev62/src/v440.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: v440
-Version: 2.0.0.dev60
+Version: 2.0.0.dev62
 Summary: This project provides mutable version objects in accordance with PEP440.
 Author-email: Johannes <johannes.programming@gmail.com>
 License: The MIT License (MIT)

v440-2.0.0.dev60/src/v440/core/Local.py

@@ -1,84 +0,0 @@
-from __future__ import annotations
-
-from typing import *
-
-import setdoc
-
-from v440._utils import utils
-from v440._utils.Digest import Digest
-from v440._utils.utils import guard
-from v440._utils.VList import VList
-
-__all__ = ["Local"]
-
-parse_data: Digest = Digest("parse_data")
-
-
-@parse_data.overload()
-def parse_data() -> tuple:
-    return ()
-
-
-@parse_data.overload(int)
-def parse_data(value: int) -> list:
-    return (value,)
-
-
-@parse_data.overload(list)
-def parse_data(value: list) -> list:
-    ans: tuple = tuple(map(utils.segment, value))
-    if None in ans:
-        raise ValueError
-    return ans
-
-
-@parse_data.overload(str)
-def parse_data(value: str) -> tuple:
-    v: str = value
-    if v.startswith("+"):
-        v = v[1:]
-    v = v.replace("_", ".")
-    v = v.replace("-", ".")
-    ans: tuple = v.split(".")
-    ans = tuple(map(utils.segment, ans))
-    if None in ans:
-        raise ValueError
-    return ans
-
-
-class Local(VList):
-    __slots__ = ()
-
-    data: tuple[int | str]
-    string: str
-
-    @setdoc.basic
-    def __init__(self: Any, data: Any = None) -> None:
-        self.data = data
-
-    def _format(self: Self, format_spec: str) -> str:
-        if format_spec:
-            raise ValueError
-        return ".".join(map(str, self))
-
-    @classmethod
-    def _sort(cls: type, value: Any) -> tuple[bool, int | str]:
-        return type(value) is int, value
-
-    def _string_fset(self: Self, value: str) -> None:
-        v: str = value
-        if v.startswith("+"):
-            v = v[1:]
-        v = v.replace("_", ".")
-        v = v.replace("-", ".")
-        self.data = v.split(".")
-
-    @property
-    @setdoc.basic
-    def data(self: Self) -> tuple[int | str]:
-        return self._data
-
-    @data.setter
-    @guard
-    def data(self: Self, value: Any) -> None:
-        self._data = parse_data(value)