v440 2.0.0.dev59__tar.gz → 2.0.0.dev61__tar.gz

{v440-2.0.0.dev59/src/v440.egg-info → v440-2.0.0.dev61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: v440
-Version: 2.0.0.dev59
+Version: 2.0.0.dev61
 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.dev59 → v440-2.0.0.dev61}/pyproject.toml

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

{v440-2.0.0.dev59 → v440-2.0.0.dev61}/src/v440/_utils/BaseList.py

@@ -1,34 +1,32 @@
 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
+
     @abstractmethod
     @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:
@@ -37,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:
@@ -48,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
@@ -63,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:
@@ -93,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:
@@ -122,19 +102,27 @@ 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 string(self: Self) -> str:
+        return self._format("")
 
-    def index(self: Self, *args: Any) -> None:
-        "This method returns the index of the first occurence."
-        return self.data.index(*args)
+    @string.setter
+    @guard
+    def string(self: Self, value: Any) -> None:
+        if value is None:
+            self._string_fset("")
+        else:
+            self._string_fset(str(value))

{v440-2.0.0.dev59 → v440-2.0.0.dev61}/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,15 +13,21 @@ __all__ = ["SlotList"]
 class SlotList(BaseList):
     __slots__ = ()
 
-    data: tuple
-
-    @setdoc.basic
-    def __bool__(self: Self) -> bool:
-        return any(self.data)
+    string: str
 
     @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.dev59 → v440-2.0.0.dev61}/src/v440/_utils/VList.py

@@ -1,17 +1,22 @@
+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
+    string: str
 
     @setdoc.basic
     def __add__(self: Self, other: Any) -> Self:
@@ -56,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)
@@ -109,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.dev59 → v440-2.0.0.dev61}/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.dev59 → v440-2.0.0.dev61}/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.dev59 → v440-2.0.0.dev61}/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,15 +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 = ""
@@ -87,15 +89,19 @@ class Base(SlotList):
         ans += format(self.release, format_spec)
         return ans
 
-    @property
-    @setdoc.basic
-    def data(self: Self) -> tuple:
-        return self.epoch, self.release
+    def _string_fset(self: Self, value: str) -> None:
+        v: str = value
+        if v.startswith("v"):
+            v = v[1:]
+        parsed: Iterable
+        if "!" in v:
+            parsed = v.split("!")
+        else:
+            parsed = 0, v
+        self.epoch, self.release.string = parsed
 
-    @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:
@@ -115,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.dev61/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.dev61/src/v440/core/Public.py

@@ -0,0 +1,86 @@
+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
+from v440._utils.SlotList import SlotList
+from v440._utils.utils import guard
+from v440.core.Base import Base
+from v440.core.Qual import Qual
+
+__all__ = ["Public"]
+
+
+class Public(SlotList):
+
+    __slots__ = ("_base", "_qual")
+
+    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, 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()
+
+    def _format(self: Self, format_spec: str) -> str:
+        return format(self.base, format_spec) + format(self.qual)
+
+    def _string_fset(self: Self, value: str) -> None:
+        match: Any = Pattern.PUBLIC.leftbound.search(value)
+        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
+    def base(self: Self, value: Any) -> None:
+        self.base._set(value)
+
+    @property
+    def qual(self: Self) -> Qual:
+        "This property represents the qualification."
+        return self._qual
+
+    @qual.setter
+    def qual(self: Self, value: Any) -> None:
+        self.qual._set(value)

{v440-2.0.0.dev59 → v440-2.0.0.dev61}/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,24 +17,49 @@ class Qual(SlotList):
 
     __slots__ = ("_prephase", "_presubphase", "_post", "_dev")
 
-    data: tuple
+    string: str
     pre: tuple
     prephase: Optional[str]
     presubphase: Optional[int]
     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()
@@ -62,15 +89,35 @@ class Qual(SlotList):
             ans += ".dev%s" % self.dev
         return ans
 
-    @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 _string_fset(self: Self, value: str) -> None:
+        v: str = value
+        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"):
+                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
+        self.pre = pre
+        self.post = post
+        self.dev = dev
+
+    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.dev59 → v440-2.0.0.dev61}/src/v440/core/Release.py

@@ -104,6 +104,7 @@ class Release(VList):
     __slots__ = ()
 
     data: tuple[int]
+    string: str
     major: int
     minor: int
     micro: int
@@ -156,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:
@@ -177,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:
@@ -240,6 +244,12 @@ class Release(VList):
     def _sort(cls: type, value: int) -> int:
         return value
 
+    def _string_fset(self: Self, value: str) -> None:
+        v: str = value
+        v = v.replace("_", ".")
+        v = v.replace("-", ".")
+        self.data = v.split(".")
+
     def bump(self: Self, index: SupportsIndex = -1, amount: SupportsIndex = 1) -> None:
         i: int = operator.index(index)
         a: int = operator.index(amount)
@@ -247,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.dev59 → v440-2.0.0.dev61}/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,44 +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)
@@ -58,15 +60,16 @@ class Version(SlotList):
             ans += "+" + format(self.local)
         return ans
 
-    @property
-    @setdoc.basic
-    def data(self: Self) -> tuple:
-        return self.public, self.local
+    def _string_fset(self: Self, value: str) -> None:
+        parsed: Iterable
+        if "+" in value:
+            parsed = value.split("+")
+        else:
+            parsed = value, ""
+        self.public.string, self.local.string = parsed
 
-    @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:
@@ -76,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."
@@ -90,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.dev59 → v440-2.0.0.dev61}/src/v440/tests/test_testdata.py

@@ -177,7 +177,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)
 
 

{v440-2.0.0.dev59 → v440-2.0.0.dev61}/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):
@@ -105,27 +105,41 @@ class TestExample(unittest.TestCase):
         v.public.base.release.micro = 4
         self.assertEqual(str(v), "2.64.4")  # Further modified version
 
-    def test_example_3(self: Self) -> None:
-        t: list = [
-            [Version, str],
-            [str, Version],
-            [Version, Version],
-        ]
-        X: type
-        Y: type
-        x: Any
-        y: Any
-        for X, Y in t:
-            x = X("1.6.3")
-            y = Y("1.6.3")
-            self.assertEqual(str(x), "1.6.3")  # x
-            self.assertEqual(str(y), "1.6.4")  # y
-            self.assertFalse(x == y)  # x == y gives False
-            self.assertTrue(x != y)  # x != y gives True
-            self.assertFalse(x >= y)  # x >= y gives False
-            self.assertTrue(x <= y)  # x <= y gives True
-            self.assertFalse(x > y)  # x > y gives False
-            self.assertTrue(x < y)  # x < y gives True
+    def test_example_3a(self: Self) -> None:
+        v1: Version = Version("1.6.3")
+        v2: str = "1.6.4"
+        self.assertEqual(str(v1), "1.6.3")  # v1
+        self.assertEqual(str(v2), "1.6.4")  # v2
+        self.assertFalse(v1 == v2)  # v1 == v2 gives False
+        self.assertTrue(v1 != v2)  # v1 != v2 gives True
+        self.assertFalse(v1 >= v2)  # v1 >= v2 gives False
+        self.assertTrue(v1 <= v2)  # v1 <= v2 gives True
+        self.assertFalse(v1 > v2)  # v1 > v2 gives False
+        self.assertTrue(v1 < v2)  # v1 < v2 gives True
+
+    def test_example_3b(self: Self) -> None:
+        v1: str = "1.6.3"
+        v2: Version = Version("1.6.4")
+        self.assertEqual(str(v1), "1.6.3")  # v1
+        self.assertEqual(str(v2), "1.6.4")  # v2
+        self.assertFalse(v1 == v2)  # v1 == v2 gives False
+        self.assertTrue(v1 != v2)  # v1 != v2 gives True
+        self.assertFalse(v1 >= v2)  # v1 >= v2 gives False
+        self.assertTrue(v1 <= v2)  # v1 <= v2 gives True
+        self.assertFalse(v1 > v2)  # v1 > v2 gives False
+        self.assertTrue(v1 < v2)  # v1 < v2 gives True
+
+    def test_example_3c(self: Self) -> None:
+        v1: Version = Version("1.6.3")
+        v2: Version = Version("1.6.4")
+        self.assertEqual(str(v1), "1.6.3")  # v1
+        self.assertEqual(str(v2), "1.6.4")  # v2
+        self.assertFalse(v1 == v2)  # v1 == v2 gives False
+        self.assertTrue(v1 != v2)  # v1 != v2 gives True
+        self.assertFalse(v1 >= v2)  # v1 >= v2 gives False
+        self.assertTrue(v1 <= v2)  # v1 <= v2 gives True
+        self.assertFalse(v1 > v2)  # v1 > v2 gives False
+        self.assertTrue(v1 < v2)  # v1 < v2 gives True
 
     def test_example_4(self: Self) -> None:
         v: Version = Version("2.5.3.9")
@@ -165,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.dev59 → v440-2.0.0.dev61/src/v440.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: v440
-Version: 2.0.0.dev59
+Version: 2.0.0.dev61
 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.dev59/src/v440/core/Local.py

@@ -1,75 +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]
-
-    @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
-
-    @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)

v440-2.0.0.dev59/src/v440/core/Public.py

@@ -1,86 +0,0 @@
-from __future__ import annotations
-
-from typing import *
-
-import setdoc
-
-from v440._utils.Digest import Digest
-from v440._utils.Pattern import Pattern
-from v440._utils.SlotList import SlotList
-from v440._utils.utils import guard
-from v440.core.Base import Base
-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
-    base: Base
-    qual: Qual
-
-    @setdoc.basic
-    def __init__(self: Self, data: Any = None) -> 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)
-
-    @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)
-
-    @property
-    def qual(self: Self) -> Qual:
-        "This property represents the qualification."
-        return self._qual
-
-    @qual.setter
-    @guard
-    def qual(self: Self, value: Any) -> None:
-        self.qual.data = value