v440 2.0.0.dev14__tar.gz → 2.0.0.dev16__tar.gz

{v440-2.0.0.dev14/src/v440.egg-info → v440-2.0.0.dev16}/PKG-INFO

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

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

{v440-2.0.0.dev14 → v440-2.0.0.dev16}/src/v440/_utils/VList.py

@@ -5,13 +5,6 @@ from datahold import OkayList
 from v440.core.VersionError import VersionError
 
 
-def clone(value: Any) -> Any:
-    if isinstance(value, VList):
-        return list(map(clone, value))
-    else:
-        return value
-
-
 class VList(OkayList):
     def __eq__(self: Self, other: Any) -> bool:
         "This magic method implements self==other."
@@ -56,21 +49,6 @@ class VList(OkayList):
             ans = self._data <= alt._data
         return ans
 
-    def __setattr__(self: Self, name: str, value: Any) -> Any:
-        if name not in type(self).__annotations__.keys():
-            return object.__setattr__(self, name, value)
-        backup: list = clone(self)
-        exc: BaseException
-        try:
-            object.__setattr__(self, name, value)
-        except BaseException as exc:
-            self.data = backup
-            if isinstance(exc, VersionError):
-                raise
-            msg: str = "%r is an invalid value for %r"
-            msg %= (value, type(self).__name__ + "." + name)
-            raise VersionError(msg)
-
     def __sorted__(self: Any, /, **kwargs: Any) -> Self:
         "This magic method implements sorted(self, **kwargs)."
         ans: Any = self.copy()

{v440-2.0.0.dev14 → v440-2.0.0.dev16}/src/v440/_utils/WList.py

@@ -1,5 +1,6 @@
 from typing import *
 
+from v440._utils.utils import guard
 from v440._utils.VList import VList
 
 __all__ = ["WList"]
@@ -11,5 +12,6 @@ class WList(VList):
         return list(self._data)
 
     @data.setter
+    @guard
     def data(self: Self, value: Any) -> None:
         self._data = value

{v440-2.0.0.dev14 → v440-2.0.0.dev16}/src/v440/_utils/utils.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import functools
 import operator
 import string
 from typing import *
@@ -91,3 +92,48 @@ def torange(key: Any, length: Any) -> range:
         stop = 0 if fwd else -1
     ans: range = range(start, stop, step)
     return ans
+
+
+def ishashable(value: Any) -> bool:
+    try:
+        hash(value)
+    except:
+        return False
+    else:
+        return True
+
+
+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()
+        try:
+            old(self, value)
+        except VersionError:
+            restore(obj=self, backup=backup)
+            raise
+        except Exception:
+            restore(obj=self, backup=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):
+    # print("backup", backup)
+    for x in type(obj).__slots__:
+        # print("x", x)
+        if ishashable(backup[x]):
+            # print("ishashable", True)
+            setattr(obj, x, backup[x])
+        else:
+            # print("ishashable", False)
+            getattr(obj, x).data = backup[x]

{v440-2.0.0.dev14 → v440-2.0.0.dev16}/src/v440/core/Base.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import *
 
 from v440._utils.Digest import Digest
+from v440._utils.utils import guard
 from v440._utils.WList import WList
 from v440.core.Release import Release
 
@@ -92,6 +93,7 @@ class Base(WList):
         return self._epoch
 
     @epoch.setter
+    @guard
     def epoch(self: Self, value: Any) -> None:
         self._epoch = parse_epoch(value)
 
@@ -107,5 +109,6 @@ class Base(WList):
         return self._release
 
     @release.setter
+    @guard
     def release(self: Self, value: Any) -> None:
         self._release.data = value

{v440-2.0.0.dev14 → v440-2.0.0.dev16}/src/v440/core/Local.py

@@ -5,6 +5,7 @@ from typing import *
 
 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"]
@@ -76,6 +77,7 @@ class Local(VList):
         return list(self._data)
 
     @data.setter
+    @guard
     def data(self: Self, value: Any) -> None:
         self._data = self._data_calc(value)
 

{v440-2.0.0.dev14 → v440-2.0.0.dev16}/src/v440/core/Pre.py

@@ -7,6 +7,7 @@ import keyalias
 from v440._utils import utils
 from v440._utils.Digest import Digest
 from v440._utils.Pattern import Pattern
+from v440._utils.utils import guard
 from v440._utils.WList import WList
 
 __all__ = ["Pre"]

{v440-2.0.0.dev14 → v440-2.0.0.dev16}/src/v440/core/Public.py

@@ -4,6 +4,7 @@ from typing import *
 
 from v440._utils.Digest import Digest
 from v440._utils.Pattern import Pattern
+from v440._utils.utils import guard
 from v440._utils.WList import WList
 from v440.core.Base import Base
 from v440.core.Qualification import Qualification
@@ -64,6 +65,7 @@ class Public(WList):
         return self._base
 
     @base.setter
+    @guard
     def base(self: Self, value: Any) -> None:
         self.base.data = value
 
@@ -75,5 +77,6 @@ class Public(WList):
         return self._qualification
 
     @qualification.setter
+    @guard
     def qualification(self: Self, value: Any) -> None:
         self.qualification.data = value

{v440-2.0.0.dev14 → v440-2.0.0.dev16}/src/v440/core/Qualification.py

@@ -5,6 +5,7 @@ from typing import *
 from v440._utils import SimpleQualifierParser
 from v440._utils.Digest import Digest
 from v440._utils.Pattern import Pattern
+from v440._utils.utils import guard
 from v440._utils.WList import WList
 from v440.core.Pre import Pre
 
@@ -111,6 +112,7 @@ class Qualification(WList):
         return self._dev
 
     @dev.setter
+    @guard
     def dev(self: Self, value: Any) -> None:
         self._dev = SimpleQualifierParser.DEV(value)
 
@@ -131,6 +133,7 @@ class Qualification(WList):
         return self._post
 
     @post.setter
+    @guard
     def post(self: Self, value: Any) -> None:
         self._post = SimpleQualifierParser.POST(value)
 
@@ -139,5 +142,6 @@ class Qualification(WList):
         return self._pre
 
     @pre.setter
+    @guard
     def pre(self: Self, value: Any) -> None:
         self._pre.data = value

{v440-2.0.0.dev14 → v440-2.0.0.dev16}/src/v440/core/Release.py

@@ -8,6 +8,7 @@ from keyalias import keyalias
 from overloadable import Overloadable
 
 from v440._utils import utils
+from v440._utils.utils import guard
 from v440._utils.VList import VList
 
 
@@ -191,6 +192,7 @@ class Release(VList):
         return list(self._data)
 
     @data.setter
+    @guard
     def data(self: Self, value: Any) -> None:
         v: list = self._tolist(value, slicing="always")
         while v and v[-1] == 0:

{v440-2.0.0.dev14 → v440-2.0.0.dev16}/src/v440/core/Version.py

@@ -5,6 +5,7 @@ from typing import *
 import packaging.version
 
 from v440._utils.Digest import Digest
+from v440._utils.utils import guard
 from v440._utils.WList import WList
 from v440.core.Base import Base
 from v440.core.Local import Local
@@ -113,6 +114,7 @@ class Version(WList):
         return self._local
 
     @local.setter
+    @guard
     def local(self: Self, value: Any) -> None:
         self.local.data = value
 
@@ -140,6 +142,7 @@ class Version(WList):
         return self._public
 
     @public.setter
+    @guard
     def public(self: Self, value: Any) -> None:
         self.public.data = value
 

{v440-2.0.0.dev14 → v440-2.0.0.dev16}/src/v440/tests/test_testdata.py

@@ -10,6 +10,7 @@ import iterprod
 import packaging.version
 from catchlib import Catcher
 
+from v440.core.Release import Release
 from v440.core.Version import Version
 from v440.core.VersionError import VersionError
 
@@ -77,9 +78,9 @@ class TestVersionLocalVersionError(unittest.TestCase):
         k: str
         v: dict
         for k, v in Util.util.data["local_VersionError"].items():
-            self.local(**v, key=k)
+            self.go(**v, key=k)
 
-    def local(
+    def go(
         self: Self,
         key: str,
         query: list,
@@ -177,37 +178,32 @@ class TestSlicing(unittest.TestCase):
 
 class TestDataProperty(unittest.TestCase):
     def test_data(self: Self) -> None:
-        self.v = Version()
-        for k, v in Util.util.data["data_property"].items():
-            self.data(**v, key=k)
-        self.data(query=None, solution="0")
+        for k, v in Util.util.data["data-property"].items():
+            self.go(**v, key=k)
 
-    def data(
+    def go(
         self: Self,
-        query: Any,
-        solution: str,
+        query: Any = None,
+        solution: Any = None,
         key: str = "",
     ) -> None:
-        msg: str = "data_property %r" % key
-        self.v.data = query
-        self.assertEqual(solution, str(self.v), msg=msg)
+        msg: str = "data-property %r" % key
+        version: Version = Version()
+        version.data = query
+        self.assertEqual(solution, str(version), msg=msg)
 
 
 class TestVersionRelease(unittest.TestCase):
 
-    def setUp(self: Self) -> None:
-        # Create a version class instance
-        self.version = Version()
-
     def test_0(self: Self) -> None:
         k: str
         v: Any
         for k, v in Util.util.data["release"].items():
-            self.release(key=k, **v)
+            self.go(key=k, **v)
 
-    def release(self: Self, query: Any, solution: Any, key: str = "") -> None:
-        self.version.release = query
-        self.assertEqual(self.version.release, solution)
+    def go(self: Self, query: Any, solution: Any, key: str = "") -> None:
+        release: Release = Release(query)
+        self.assertEqual(release, solution)
 
 
 class TestDev(unittest.TestCase):

{v440-2.0.0.dev14 → v440-2.0.0.dev16}/src/v440/tests/test_version.py

@@ -10,7 +10,7 @@ class TestVersionManipulation(unittest.TestCase):
 
     def test_version_modification(self: Self) -> None:
         # Create an instance of the v440.Version class
-        v = Version("1.2.3")
+        v: Version = Version("1.2.3")
 
         # Modify individual parts of the version
         v.release.major = 2
@@ -25,7 +25,7 @@ class TestVersionManipulation(unittest.TestCase):
 class TestVersionLocal(unittest.TestCase):
 
     def test_version_operations(self: Self) -> None:
-        v = Version("1.2.3")
+        v: Version = Version("1.2.3")
         backup = v.local
         v.local = "local.1.2.3"
         self.assertEqual(str(v), "1.2.3+local.1.2.3")
@@ -53,7 +53,7 @@ class TestVersionLocal(unittest.TestCase):
 class TestVersion(unittest.TestCase):
 
     def test_version_pre(self: Self) -> None:
-        v = Version("1.2.3")
+        v: Version = Version("1.2.3")
         backup = v.pre
 
         # Initial version, no pre-release version
@@ -93,20 +93,20 @@ class TestVersion(unittest.TestCase):
 class TestExample(unittest.TestCase):
 
     def test_example_1(self: Self) -> None:
-        v = Version("v1.0.0")
+        v: Version = Version("v1.0.0")
         self.assertEqual(str(v), "1")  # Initial version
         self.assertEqual(v.format("3"), "1.0.0")  # Initial version formatted
 
     def test_example_2(self: Self) -> None:
-        v = Version("2.5.3")
+        v: Version = Version("2.5.3")
         self.assertEqual(str(v), "2.5.3")  # Modified version
         v.release[1] = 64
         v.release.micro = 4
         self.assertEqual(str(v), "2.64.4")  # Further modified version
 
     def test_example_3(self: Self) -> None:
-        v1 = Version("1.6.3")
-        v2 = Version("1.6.4")
+        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
@@ -117,8 +117,8 @@ class TestExample(unittest.TestCase):
         self.assertTrue(v1 < v2)  # v1 < v2 gives True
 
     def test_example_3a(self: Self) -> None:
-        v1 = Version("1.6.3")
-        v2 = "1.6.4"
+        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
@@ -129,8 +129,8 @@ class TestExample(unittest.TestCase):
         self.assertTrue(v1 < v2)  # v1 < v2 gives True
 
     def test_example_3b(self: Self) -> None:
-        v1 = "1.6.3"
-        v2 = Version("1.6.4")
+        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
@@ -141,13 +141,13 @@ class TestExample(unittest.TestCase):
         self.assertTrue(v1 < v2)  # v1 < v2 gives True
 
     def test_example_4(self: Self) -> None:
-        v = Version("2.5.3.9")
+        v: Version = Version("2.5.3.9")
         self.assertEqual(str(v), "2.5.3.9")  # before sorting
         v.release.sort()
         self.assertEqual(str(v), "2.3.5.9")  # after sorting
 
     def test_example_5(self: Self) -> None:
-        v = Version("2.0.0-alpha.1")
+        v: Version = Version("2.0.0-alpha.1")
         self.assertEqual(str(v), "2a1")  # Pre-release version
         v.pre = "beta.2"
         self.assertEqual(str(v), "2b2")  # Modified pre-release version
@@ -157,7 +157,7 @@ class TestExample(unittest.TestCase):
         self.assertEqual(str(v), "2rc4")  # Even further modified pre-release version
 
     def test_example_6(self: Self) -> None:
-        v = Version("1.2.3")
+        v: Version = Version("1.2.3")
         v.post = "post1"
         v.local = "local.7.dev"
         self.assertEqual(str(v), "1.2.3.post1+local.7.dev")  # Post-release version
@@ -175,17 +175,14 @@ class TestExample(unittest.TestCase):
         self.assertEqual(str(v), "1.2.3.post3+3.test.19")  # Modified local again
 
     def test_example_7(self: Self) -> None:
-        v = Version("5.0.0")
+        v: Version = Version("5.0.0")
         self.assertEqual(str(v), "5")  # Original version
         v.data = None
         self.assertEqual(str(v), "0")  # After reset
         v.base = "4!5.0.1"
         self.assertEqual(str(v), "4!5.0.1")  # Before error
-        with self.assertRaises(Exception) as context:
+        with self.assertRaises(VersionError) as context:
             v.base = "9!x"
-        self.assertTrue(
-            "not a valid numeral segment" in str(context.exception)
-        )  # Error
         self.assertEqual(str(v), "4!5.0.1")  # After error
 
 
@@ -199,184 +196,200 @@ class TestPatch(unittest.TestCase):
 
 class TestVersionRelease(unittest.TestCase):
 
-    def setUp(self: Self) -> None:
-        # Create a version class instance
-        self.version = Version()
-
     def test_major_minor_micro_aliases(self: Self) -> None:
         # Test major, minor, and micro aliases for the first three indices
-        self.version.release = [1, 2, 3]
-        self.assertEqual(self.version.release.major, 1)
-        self.assertEqual(self.version.release.minor, 2)
-        self.assertEqual(self.version.release.micro, 3)
-        self.assertEqual(self.version.release.patch, 3)  # 'patch' is an alias for micro
+        version: Version = Version()
+        version.release = [1, 2, 3]
+        self.assertEqual(version.release.major, 1)
+        self.assertEqual(version.release.minor, 2)
+        self.assertEqual(version.release.micro, 3)
+        self.assertEqual(version.release.patch, 3)  # 'patch' is an alias for micro
 
     def test_release_modify_aliases(self: Self) -> None:
         # Test modifying the release via major, minor, and micro properties
-        self.version.release = [1, 2, 3]
-        self.version.release.major = 10
-        self.version.release.minor = 20
-        self.version.release.micro = 30
-        self.assertEqual(self.version.release, [10, 20, 30])
-        self.assertEqual(self.version.release.patch, 30)
+        version: Version = Version()
+        version.release = [1, 2, 3]
+        version.release.major = 10
+        version.release.minor = 20
+        version.release.micro = 30
+        self.assertEqual(version.release, [10, 20, 30])
+        self.assertEqual(version.release.patch, 30)
 
     def test_release_with_tailing_zeros_simulation(self: Self) -> None:
         # Test that the release can simulate arbitrary high number of tailing zeros
-        self.version.release = [1, 2]
-        simulated_release = self.version.release[:5]
+        version: Version = Version()
+        version.release = [1, 2]
+        simulated_release = version.release[:5]
         self.assertEqual(simulated_release, [1, 2, 0, 0, 0])
 
     def test_release_empty_major(self: Self) -> None:
         # Test that an empty release still has valid major, minor, micro values
-        self.version.release = []
-        self.assertEqual(self.version.release.major, 0)
-        self.assertEqual(self.version.release.minor, 0)
-        self.assertEqual(self.version.release.micro, 0)
-        self.assertEqual(self.version.release.patch, 0)
+        version: Version = Version()
+        version.release = []
+        self.assertEqual(version.release.major, 0)
+        self.assertEqual(version.release.minor, 0)
+        self.assertEqual(version.release.micro, 0)
+        self.assertEqual(version.release.patch, 0)
 
     def test_release_modify_with_alias_increase_length(self: Self) -> None:
         # Test that modifying an alias can extend the length of release
-        self.version.release = [1]
-        self.version.release.minor = 5  # This should make release [1, 5]
-        self.assertEqual(self.version.release, [1, 5])
-        self.version.release.micro = 3  # This should make release [1, 5, 3]
-        self.assertEqual(self.version.release, [1, 5, 3])
+        version: Version = Version()
+        version.release = [1]
+        version.release.minor = 5  # This should make release [1, 5]
+        self.assertEqual(version.release, [1, 5])
+        version.release.micro = 3  # This should make release [1, 5, 3]
+        self.assertEqual(version.release, [1, 5, 3])
 
     def test_release_modify_major_only(self: Self) -> None:
         # Test that setting just the major property works
-        self.version.release.major = 10
-        self.assertEqual(self.version.release, [10])
+        version: Version = Version()
+        version.release.major = 10
+        self.assertEqual(version.release, [10])
 
     def test_release_modify_minor_only(self: Self) -> None:
         # Test that setting just the minor property extends release
-        self.version.release = []
-        self.version.release.minor = 1
-        self.assertEqual(self.version.release, [0, 1])
+        version: Version = Version()
+        version.release = []
+        version.release.minor = 1
+        self.assertEqual(version.release, [0, 1])
 
     def test_release_modify_micro_only(self: Self) -> None:
         # Test that setting just the micro (patch) property extends release
-        self.version.release = []
-        self.version.release.micro = 1
-        self.assertEqual(self.version.release, [0, 0, 1])
+        version: Version = Version()
+        version.release = []
+        version.release.micro = 1
+        self.assertEqual(version.release, [0, 0, 1])
 
 
 class TestAdditionalVersionRelease(unittest.TestCase):
 
-    def setUp(self: Self) -> None:
-        # Initialize a fresh Version instance for every test
-        self.version = Version()
-
     def test_release_inequality_with_list(self: Self) -> None:
         # Test inequality of release with a normal list
-        self.version.release = [1, 2, 3]
-        self.assertFalse(self.version.release == [1, 2, 4])
+        version: Version = Version()
+        version.release = [1, 2, 3]
+        self.assertFalse(version.release == [1, 2, 4])
 
     def test_release_len(self: Self) -> None:
         # Test the length of the release list
-        self.version.release = [1, 2, 3]
-        self.assertEqual(len(self.version.release), 3)
+        version: Version = Version()
+        version.release = [1, 2, 3]
+        self.assertEqual(len(version.release), 3)
 
     def test_release_slice_assignment(self: Self) -> None:
         # Test assigning a slice to release
-        self.version.release = [1, 2, 3, 4, 5]
-        self.version.release[1:4] = [20, 30, 40]
-        self.assertEqual(self.version.release, [1, 20, 30, 40, 5])
+        version: Version = Version()
+        version.release = [1, 2, 3, 4, 5]
+        version.release[1:4] = [20, 30, 40]
+        self.assertEqual(version.release, [1, 20, 30, 40, 5])
 
     def test_release_iterable(self: Self) -> None:
         # Test if release supports iteration
-        self.version.release = [1, 2, 3]
-        result = [x for x in self.version.release]
+        version: Version = Version()
+        version.release = [1, 2, 3]
+        result = [x for x in version.release]
         self.assertEqual(result, [1, 2, 3])
 
     def test_release_repr(self: Self) -> None:
         # Test the repr of the release property
-        self.version.release = [1, 2, 3]
-        self.assertEqual(str(self.version.release), "1.2.3")
+        version: Version = Version()
+        version.release = [1, 2, 3]
+        self.assertEqual(str(version.release), "1.2.3")
 
     def test_release_data_property(self: Self) -> None:
         # Test the 'data' property
-        self.version.release = [1, 2, 3]
-        self.assertEqual(self.version.release.data, [1, 2, 3])
+        version: Version = Version()
+        version.release = [1, 2, 3]
+        self.assertEqual(version.release.data, [1, 2, 3])
 
     def test_release_data_setter(self: Self) -> None:
         # Test setting the 'data' property directly
-        self.version.release.data = [10, 20, 30]
-        self.assertEqual(self.version.release, [10, 20, 30])
+        version: Version = Version()
+        version.release.data = [10, 20, 30]
+        self.assertEqual(version.release, [10, 20, 30])
 
     def test_release_contains(self: Self) -> None:
         # Test 'in' keyword with release
-        self.version.release = [1, 2, 3]
-        self.assertIn(2, self.version.release)
-        self.assertNotIn(4, self.version.release)
+        version: Version = Version()
+        version.release = [1, 2, 3]
+        self.assertIn(2, version.release)
+        self.assertNotIn(4, version.release)
 
     def test_release_mul(self: Self) -> None:
         # Test multiplying the release (list behavior)
-        self.version.release = [1, 2]
-        self.assertEqual(self.version.release * 3, [1, 2, 1, 2, 1, 2])
+        version: Version = Version()
+        version.release = [1, 2]
+        self.assertEqual(version.release * 3, [1, 2, 1, 2, 1, 2])
 
     def test_release_addition(self: Self) -> None:
         # Test adding another list to release
-        self.version.release = [1, 2, 3]
-        self.assertEqual(self.version.release + [4, 5], [1, 2, 3, 4, 5])
+        version: Version = Version()
+        version.release = [1, 2, 3]
+        self.assertEqual(version.release + [4, 5], [1, 2, 3, 4, 5])
 
 
 class TestVersionLocal(unittest.TestCase):
 
-    def setUp(self: Self) -> None:
-        # Initialize a fresh Version instance for every test
-        self.version = Version()
-
     def test_local_len(self: Self) -> None:
         # Test the length of the local list
-        self.version.local = [1, "dev", "build"]
-        self.assertEqual(len(self.version.local), 3)
+        version: Version = Version()
+        version.local = [1, "dev", "build"]
+        self.assertEqual(len(version.local), 3)
 
     def test_local_slice_assignment(self: Self) -> None:
         # Test assigning a slice to the local list
-        self.version.local = [1, "dev", "build"]
-        self.version.local[1:3] = ["alpha", "beta"]
-        self.assertEqual(self.version.local, [1, "alpha", "beta"])
+        version: Version = Version()
+        version.local = [1, "dev", "build"]
+        version.local[1:3] = ["alpha", "beta"]
+        self.assertEqual(version.local, [1, "alpha", "beta"])
 
     def test_local_contains(self: Self) -> None:
         # Test 'in' keyword with local list
-        self.version.local = [1, "dev", "build"]
-        self.assertIn("dev", self.version.local)
-        self.assertNotIn("alpha", self.version.local)
+        version: Version = Version()
+        version.local = [1, "dev", "build"]
+        self.assertIn("dev", version.local)
+        self.assertNotIn("alpha", version.local)
 
     def test_local_mul(self: Self) -> None:
         # Test multiplying the local list
-        self.version.local = [1, "dev"]
-        self.assertEqual(self.version.local * 3, [1, "dev", 1, "dev", 1, "dev"])
+        version: Version = Version()
+        version.local = [1, "dev"]
+        self.assertEqual(version.local * 3, [1, "dev", 1, "dev", 1, "dev"])
 
     def test_local_addition(self: Self) -> None:
         # Test adding another list to local
-        self.version.local = [1, "dev"]
-        self.assertEqual(self.version.local + ["build"], [1, "dev", "build"])
+        version: Version = Version()
+        version.local = [1, "dev"]
+        self.assertEqual(version.local + ["build"], [1, "dev", "build"])
 
     def test_local_inequality_with_list(self: Self) -> None:
         # Test inequality of local with a normal list
-        self.version.local = [1, "dev"]
-        self.assertFalse(self.version.local == [1, "build"])
+        version: Version = Version()
+        version.local = [1, "dev"]
+        self.assertFalse(version.local == [1, "build"])
 
     def test_local_repr(self: Self) -> None:
         # Test repr of local list
-        self.version.local = [1, "dev", "build"]
-        self.assertEqual(str(self.version.local), "1.dev.build")
+        version: Version = Version()
+        version.local = [1, "dev", "build"]
+        self.assertEqual(str(version.local), "1.dev.build")
 
     def test_local_data_property(self: Self) -> None:
         # Test that 'data' property correctly reflects local's internal list
-        self.version.local = [1, "dev", "build"]
-        self.assertEqual(self.version.local.data, [1, "dev", "build"])
+        version: Version = Version()
+        version.local = [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
-        self.version.local.data = ["custom", "data"]
-        self.assertEqual(self.version.local, ["custom", "data"])
+        version: Version = Version()
+        version.local.data = ["custom", "data"]
+        self.assertEqual(version.local, ["custom", "data"])
 
     def test_local_iterable(self: Self) -> None:
         # Test if local supports iteration
-        self.version.local = "1.dev.build"
-        result = [x for x in self.version.local]
+        version: Version = Version()
+        version.local = "1.dev.build"
+        result: list = [x for x in version.local]
         self.assertEqual(result, [1, "dev", "build"])
 
 

{v440-2.0.0.dev14 → v440-2.0.0.dev16}/src/v440/tests/testdata.toml

@@ -941,22 +941,25 @@ solution = [
     3,
 ]
 
-[data_property.local]
+[data-property.local]
 query = "42!1.2.3.dev1337+5.nov"
 solution = "42!1.2.3.dev1337+5.nov"
 
-[data_property.hitch]
+[data-property.hitch]
 query = 4.2
 solution = "4.2"
 
-[data_property.dragon]
+[data-property.dragon]
 query = 9001
 solution = "9001"
 
-[data_property.local_again]
+[data-property.local_again]
 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

{v440-2.0.0.dev14 → v440-2.0.0.dev16/src/v440.egg-info}/PKG-INFO

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