v440 2.0.0.dev29__tar.gz → 2.0.0.dev31__tar.gz

{v440-2.0.0.dev29/src/v440.egg-info → v440-2.0.0.dev31}/PKG-INFO

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

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

{v440-2.0.0.dev29 → v440-2.0.0.dev31}/src/v440/core/Version.py

@@ -110,22 +110,6 @@ class Version(SlotList):
     def packaging(self: Self) -> packaging.version.Version:
         return packaging.version.Version(str(self))
 
-    @property
-    def post(self: Self) -> Optional[int]:
-        return self.qualification.post
-
-    @post.setter
-    def post(self: Self, value: Any) -> None:
-        self.qualification.post = value
-
-    @property
-    def pre(self: Self) -> list:
-        return self.qualification.pre
-
-    @pre.setter
-    def pre(self: Self, value: Any) -> None:
-        self.qualification.pre = value
-
     @property
     def public(self: Self) -> Self:
         return self._public
@@ -134,11 +118,3 @@ class Version(SlotList):
     @guard
     def public(self: Self, value: Any) -> None:
         self.public.data = value
-
-    @property
-    def qualification(self: Self) -> Qualification:
-        return self.public.qualification
-
-    @qualification.setter
-    def qualification(self: Self, value: Any) -> None:
-        self.qualification.data = value

{v440-2.0.0.dev29 → v440-2.0.0.dev31}/src/v440/tests/test_testdata.py

@@ -8,7 +8,6 @@ from typing import *
 
 import iterprod
 import packaging.version
-from catchlib import Catcher
 
 from v440.core.Release import Release
 from v440.core.Version import Version
@@ -78,11 +77,11 @@ class TestVersionLocalVersionError(unittest.TestCase):
         k: str
         v: dict
         for k, v in Util.util.data["local_VersionError"].items():
-            self.go(**v, key=k)
+            with self.subTest(key=k):
+                self.go(**v)
 
     def go(
         self: Self,
-        key: str,
         query: list,
     ) -> None:
         version: Version = Version()
@@ -90,16 +89,16 @@ class TestVersionLocalVersionError(unittest.TestCase):
             version.local = query
 
 
-class TestVersionLocal(unittest.TestCase):
+class TestVersionLocalGo(unittest.TestCase):
     def test_0(self: Self) -> None:
         k: str
         v: dict
         for k, v in Util.util.data["local_attr"].items():
-            self.local(**v, key=k)
+            with self.subTest(key=k):
+                self.go(**v)
 
-    def local(
+    def go(
         self: Self,
-        key: str,
         query: list,
         attrname: Optional[str] = None,
         args: list | tuple = (),
@@ -117,8 +116,16 @@ class TestVersionLocal(unittest.TestCase):
             self.assertEqual(version.local, target)
 
 
-class TestVersionEpoch(unittest.TestCase):
-    def epoch(
+class TestVersionEpochGo(unittest.TestCase):
+
+    def test_0(self: Self) -> None:
+        k: str
+        v: dict
+        for k, v in Util.util.data["epoch"].items():
+            with self.subTest(key=k):
+                self.go(**v)
+
+    def go(
         self: Self,
         full: Any,
         part: Any,
@@ -132,23 +139,16 @@ class TestVersionEpoch(unittest.TestCase):
         self.assertIsInstance(v.epoch, int, msg=msg)
         self.assertEqual(v.epoch, part, msg=msg)
 
-    def test_0(self: Self) -> None:
+
+class TestSlicingGo(unittest.TestCase):
+    def test_slicing_3(self: Self) -> None:
+        sli: dict = Util.util.data["slicingmethod"]
         k: str
         v: dict
-        for k, v in Util.util.data["epoch"].items():
-            self.epoch(**v, key=k)
-
-
-class TestSlicing(unittest.TestCase):
-
-    def test_slicing_2(self: Self) -> None:
-        v: Version = Version("1.2.3.4.5.6.7.8.9.10")
-        catcher: Catcher = Catcher()
-        with catcher.catch(Exception):
-            v.public.base.release[-8:15:5] = 777
-        self.assertNotEqual(catcher.caught, None)
+        for k, v in sli.items():
+            self.go(**v, key=k)
 
-    def slicingmethod(
+    def go(
         self: Self,
         query: Any,
         change: Any,
@@ -162,19 +162,6 @@ class TestSlicing(unittest.TestCase):
         v.public.base.release[start:stop:step] = change
         self.assertEqual(str(v), solution, "slicingmethod %s" % key)
 
-    def test_slicing_3(self: Self) -> None:
-        sli: dict = Util.util.data["slicingmethod"]
-        k: str
-        v: dict
-        for k, v in sli.items():
-            self.slicingmethod(**v, key=k)
-
-    def test_slicing_7(self: Self) -> None:
-        # test_slicing_7
-        v: Version = Version("1.2.3.4.5.6.7.8.9.10")
-        del v.public.base.release[-8:15:5]
-        self.assertEqual(str(v), "1.2.4.5.6.7.9.10")
-
 
 class TestDataProperty(unittest.TestCase):
     def test_data(self: Self) -> None:
@@ -207,21 +194,9 @@ class TestVersionRelease(unittest.TestCase):
         self.assertEqual(release, solution)
 
 
-class TestDev(unittest.TestCase):
-
-    def test_initial_none_dev(self: Self) -> None:
-        v: Version = Version("1.2.3")
-        self.assertEqual(str(v), "1.2.3")
-        self.assertIsNone(v.dev)
-
-    def test_dev_as_none(self: Self) -> None:
-        v: Version = Version("1.2.3")
-        v.dev = None
-        self.assertEqual(str(v), "1.2.3")
-        self.assertIsNone(v.dev)
-
+class TestDevGo(unittest.TestCase):
     def test_dev_as_tuple(self: Self) -> None:
-        self.dev(
+        self.go(
             key="test_dev_as_tuple",
             v_version="1.2.3",
             v_dev=("dev", "5000"),
@@ -233,9 +208,10 @@ class TestDev(unittest.TestCase):
         k: str
         v: dict
         for k, v in Util.util.data["devint"].items():
-            self.dev(key=k, **v)
+            with self.subTest(key=k):
+                self.go(**v, key=k)
 
-    def dev(
+    def go(
         self: Self,
         key: str,
         v_version: Any,
@@ -246,35 +222,27 @@ class TestDev(unittest.TestCase):
     ):
         msg: str = "dev %r" % key
         v: Version = Version(v_version)
-        v.dev = v_dev
+        v.public.qualification.dev = v_dev
         self.assertEqual(str(v), v_str, msg=msg)
-        self.assertIsInstance(v.dev, dev_type, msg=msg)
-        self.assertEqual(v.dev, v_ans, msg=msg)
+        self.assertIsInstance(v.public.qualification.dev, dev_type, msg=msg)
+        self.assertEqual(v.public.qualification.dev, v_ans, msg=msg)
 
 
-class TestVersionSpecifiers(unittest.TestCase):
-
-    def test_version_with_invalid_specifiers(self: Self) -> None:
-        # Test version with invalid specifiers that should raise an error
-        with self.assertRaises(VersionError):
-            Version("1.2.3--4")
-
-        with self.assertRaises(VersionError):
-            Version("1.2.3a1--4")
+class TestVersionSpecifiersGo(unittest.TestCase):
 
     def test_spec_toml(self: Self) -> None:
         k: str
         v: dict
         for k, v in Util.util.data["spec"].items():
-            self.spec(**v, key=k)
+            self.go(**v, key=k)
 
-    def spec(self: Self, string_a: str, string_b: str, key: str = "") -> None:
+    def go(self: Self, string_a: str, string_b: str, key: str = "") -> None:
         msg: str = "spec %r" % key
         version: Version = Version(string_a)
         self.assertEqual(str(version), string_b, msg=msg)
 
 
-class TestPackaging(unittest.TestCase):
+class TestPackagingA(unittest.TestCase):
     def test_strings_a(self: Self) -> None:
         a: packaging.version.Version
         b: str
@@ -291,6 +259,8 @@ class TestPackaging(unittest.TestCase):
                 g = Version(s).format(f)
                 self.assertEqual(b, g)
 
+
+class TestPackagingB(unittest.TestCase):
     def test_strings_b(self: Self) -> None:
         a: packaging.version.Version
         b: packaging.version.Version
@@ -305,6 +275,8 @@ class TestPackaging(unittest.TestCase):
                 msg = f"{s} should match packaging.version.Version"
                 self.assertEqual(a, b, msg=msg)
 
+
+class TestPackagingC(unittest.TestCase):
     def test_strings_c(self: Self) -> None:
         pure: list = list()
         l: list
@@ -336,6 +308,8 @@ class TestPackaging(unittest.TestCase):
             msg = f"{op} should match for {x!r} and {y!r}"
             self.assertEqual(native, convert, msg=msg)
 
+
+class TestPackagingField(unittest.TestCase):
     def test_field(self: Self) -> None:
         versionable: list = list()
         l: list
@@ -362,6 +336,8 @@ class TestPackaging(unittest.TestCase):
             version_obj.local = v.packaging().local
             self.assertEqual(str(v.local), str(version_obj.local))
 
+
+class TestPackagingExc(unittest.TestCase):
     def test_exc_pack(self: Self) -> None:
         impure: list = list()
         l: list

{v440-2.0.0.dev29 → v440-2.0.0.dev31}/src/v440/tests/test_version.py

@@ -1,6 +1,8 @@
 import unittest
 from typing import *
 
+from catchlib import Catcher
+
 from v440.core.Qualification import Qualification
 from v440.core.Version import Version
 from v440.core.VersionError import VersionError
@@ -15,7 +17,7 @@ class TestVersionManipulation(unittest.TestCase):
         # Modify individual parts of the version
         v.public.base.release.major = 2
         v.public.base.release.minor = 5
-        v.qualification = "beta.1"
+        v.public.qualification = "beta.1"
         v.local = "local.7.dev"
 
         # Verify the expected output
@@ -54,40 +56,40 @@ class TestPre(unittest.TestCase):
 
     def test_pre(self: Self) -> None:
         v: Version = Version("1.2.3")
-        backup: Qualification = v.qualification
+        backup: Qualification = v.public.qualification
 
         # Initial version, no pre-release version
         self.assertEqual(str(v), "1.2.3")
-        self.assertEqual(v.qualification, [None, None, None, None])
+        self.assertEqual(v.public.qualification, [None, None, None, None])
 
         # Set pre-release version to "a1"
-        v.qualification = "a1"
+        v.public.qualification = "a1"
         self.assertEqual(str(v), "1.2.3a1")
-        self.assertEqual(str(v.qualification), "a1")
+        self.assertEqual(str(v.public.qualification), "a1")
 
         # Modify pre-release phase to "preview"
-        v.qualification.prephase = "preview"
+        v.public.qualification.prephase = "preview"
         self.assertEqual(str(v), "1.2.3rc1")
-        self.assertEqual(str(v.qualification), "rc1")
+        self.assertEqual(str(v.public.qualification), "rc1")
 
         # Modify subphase to "42"
-        v.qualification.presubphase = "42"
+        v.public.qualification.presubphase = "42"
         self.assertEqual(str(v), "1.2.3rc42")
-        self.assertEqual(str(v.qualification), "rc42")
+        self.assertEqual(str(v.public.qualification), "rc42")
 
         # Change phase to a formatted string "BeTa"
-        v.qualification.prephase = """
+        v.public.qualification.prephase = """
         BeTa
         """
         self.assertEqual(str(v), "1.2.3b42")
-        self.assertEqual(str(v.qualification), "b42")
+        self.assertEqual(str(v.public.qualification), "b42")
 
-        self.assertEqual(v.qualification, backup)
+        self.assertEqual(v.public.qualification, backup)
 
         # Set pre-release to None
-        v.qualification = None
+        v.public.qualification = None
         self.assertEqual(str(v), "1.2.3")
-        self.assertEqual(v.qualification, [None, None, None, None])
+        self.assertEqual(v.public.qualification, [None, None, None, None])
 
 
 class TestExample(unittest.TestCase):
@@ -149,25 +151,25 @@ class TestExample(unittest.TestCase):
     def test_example_5(self: Self) -> None:
         v: Version = Version("2.0.0-alpha.1")
         self.assertEqual(str(v), "2a1")  # Pre-release version
-        v.pre = "beta.2"
+        v.public.qualification.pre = "beta.2"
         self.assertEqual(str(v), "2b2")  # Modified pre-release version
         with self.assertRaises(Exception):
-            v.qualification.pre[1] = 4
+            v.public.qualification.pre[1] = 4
         self.assertEqual(str(v), "2b2")  # Further modified pre-release version
-        v.qualification.prephase = "PrEvIeW"
+        v.public.qualification.prephase = "PrEvIeW"
         self.assertEqual(str(v), "2rc2")  # Even further modified pre-release version
 
     def test_example_6(self: Self) -> None:
         v: Version = Version("1.2.3")
-        v.post = "post1"
+        v.public.qualification.post = "post1"
         v.local = "local.7.dev"
         self.assertEqual(str(v), "1.2.3.post1+local.7.dev")  # Post-release version
         self.assertEqual(v.format("-1"), "1.2.post1+local.7.dev")  # Formatted version
-        v.post = "post.2"
+        v.public.qualification.post = "post.2"
         self.assertEqual(str(v), "1.2.3.post2+local.7.dev")  # Modified version
-        v.post = None
+        v.public.qualification.post = None
         self.assertEqual(str(v), "1.2.3+local.7.dev")  # Modified without post
-        v.post = "post", 3
+        v.public.qualification.post = "post", 3
         v.local.sort()
         self.assertEqual(str(v), "1.2.3.post3+dev.local.7")  # After sorting local
         v.local.append(8)
@@ -396,5 +398,46 @@ class TestVersionLocal(unittest.TestCase):
         self.assertEqual(result, [1, "dev", "build"])
 
 
+class TestSlicingNoGo(unittest.TestCase):
+
+    def test_slicing_2(self: Self) -> None:
+        v: Version = Version("1.2.3.4.5.6.7.8.9.10")
+        catcher: Catcher = Catcher()
+        with catcher.catch(Exception):
+            v.public.base.release[-8:15:5] = 777
+        self.assertNotEqual(catcher.caught, None)
+
+    def test_slicing_7(self: Self) -> None:
+        # test_slicing_7
+        v: Version = Version("1.2.3.4.5.6.7.8.9.10")
+        del v.public.base.release[-8:15:5]
+        self.assertEqual(str(v), "1.2.4.5.6.7.9.10")
+
+
+class TestDevNoGo(unittest.TestCase):
+
+    def test_initial_none_dev(self: Self) -> None:
+        v: Version = Version("1.2.3")
+        self.assertEqual(str(v), "1.2.3")
+        self.assertIsNone(v.public.qualification.dev)
+
+    def test_dev_as_none(self: Self) -> None:
+        v: Version = Version("1.2.3")
+        v.public.qualification.dev = None
+        self.assertEqual(str(v), "1.2.3")
+        self.assertIsNone(v.public.qualification.dev)
+
+
+class TestVersionSpecifiersNoGo(unittest.TestCase):
+
+    def test_version_with_invalid_specifiers(self: Self) -> None:
+        # Test version with invalid specifiers that should raise an error
+        with self.assertRaises(VersionError):
+            Version("1.2.3--4")
+
+        with self.assertRaises(VersionError):
+            Version("1.2.3a1--4")
+
+
 if __name__ == "__main__":
     unittest.main()

{v440-2.0.0.dev29 → v440-2.0.0.dev31/src/v440.egg-info}/PKG-INFO

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