GeneralManager 0.4.3__tar.gz → 0.4.5__tar.gz

{generalmanager-0.4.3 → generalmanager-0.4.5}/GeneralManager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.4.3
+Version: 0.4.5
 Summary: Kurzbeschreibung deines Pakets
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License-Expression: MIT

{generalmanager-0.4.3 → generalmanager-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.4.3
+Version: 0.4.5
 Summary: Kurzbeschreibung deines Pakets
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License-Expression: MIT

{generalmanager-0.4.3 → generalmanager-0.4.5}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.4.3"
+version = "0.4.5"
 description = "Kurzbeschreibung deines Pakets"
 readme = "README.md"
 authors = [

{generalmanager-0.4.3 → generalmanager-0.4.5}/src/general_manager/measurement/measurement.py

@@ -56,7 +56,22 @@ class Measurement:
 
     @classmethod
     def from_string(cls, value: str) -> Measurement:
-        value, unit = value.split(" ")
+        """
+        Creates a Measurement instance from a string in the format 'value unit'.
+        
+        Args:
+            value: A string containing a numeric value and a unit separated by a space (e.g., '10.5 kg').
+        
+        Returns:
+            A Measurement instance representing the parsed value and unit.
+        
+        Raises:
+            ValueError: If the input string does not contain exactly two parts separated by a space.
+        """
+        splitted = value.split(" ")
+        if len(splitted) != 2:
+            raise ValueError("String must be in the format 'value unit'.")
+        value, unit = splitted
         return cls(value, unit)
 
     @staticmethod
@@ -202,12 +217,31 @@ class Measurement:
         return f"Measurement({self.quantity.magnitude}, '{self.quantity.units}')"
 
     def _compare(self, other: Any, operation: Callable[..., bool]) -> bool:
+        """
+        Compares this Measurement with another using the specified comparison operation.
+        
+        If `other` is a string, it is parsed into a Measurement. Raises a TypeError if
+        `other` is not a Measurement instance. Converts `other` to this instance's unit
+        before applying the comparison. Raises a ValueError if the measurements have
+        incompatible dimensions.
+        
+        Args:
+            other: The object to compare with, either a Measurement or a string in the format "value unit".
+            operation: A callable that takes two magnitudes and returns a boolean result.
+        
+        Returns:
+            The result of the comparison operation.
+        
+        Raises:
+            TypeError: If `other` is not a Measurement instance or a valid string representation.
+            ValueError: If the measurements have different dimensions and cannot be compared.
+        """
         if isinstance(other, str):
             other = Measurement.from_string(other)
 
         # Überprüfen, ob `other` ein Measurement-Objekt ist
         if not isinstance(other, Measurement):
-            return NotImplemented
+            raise TypeError("Comparison is only allowed between Measurement instances.")
         try:
             # Convert `other` to the same units as `self`
             other_converted: pint.Quantity = other.quantity.to(self.quantity.units)  # type: ignore
@@ -238,4 +272,17 @@ class Measurement:
         return self._compare(other, gt)
 
     def __ge__(self, other: Any) -> bool:
+        """
+        Returns True if this measurement is greater than or equal to another measurement.
+        
+        Comparison is performed after converting the other operand to the same unit. Raises a TypeError if the other object is not a Measurement instance or a compatible string, or a ValueError if the units are not compatible.
+        """
         return self._compare(other, ge)
+
+    def __hash__(self) -> int:
+        """
+        Returns a hash value based on the magnitude and unit of the measurement.
+        
+        This enables Measurement instances to be used in hash-based collections such as sets and dictionaries.
+        """
+        return hash((self.quantity.magnitude, str(self.quantity.units)))

{generalmanager-0.4.3 → generalmanager-0.4.5}/tests/test_measurement.py

@@ -40,12 +40,29 @@ class MeasurementTestCase(TestCase):
         self.assertEqual(str(result), "3 meter")
 
     def test_addition_different_units_same_dimension(self):
+        """
+        Tests addition of `Measurement` instances with different units of the same physical dimension.
+        
+        Verifies correct unit conversion and commutativity when adding measurements with compatible units (e.g., kilometers and meters). Asserts that adding zero to a `Measurement` returns the measurement unchanged, and that adding a plain number raises a `TypeError`.
+        """
         m1 = Measurement(1, "kilometer")  # 1000 meter
         m2 = Measurement(500, "meter")
         result = m1 + m2
         self.assertEqual(str(result), "1.5 kilometer")
 
+        result = m2 + m1  # Commutative property
+        self.assertEqual(str(result), "1500 meter")
+
+        result = 0 + m1
+        self.assertEqual(str(result), "1 kilometer")
+
+        with self.assertRaises(TypeError):
+            _ = 10 + m1  # Adding a number to a Measurement should raise an error
+
     def test_subtraction_different_units_same_dimension(self):
+        """
+        Tests subtraction of two Measurement instances with different units but the same physical dimension, verifying correct unit conversion and result.
+        """
         m1 = Measurement(2, "kilometer")  # 2000 meter
         m2 = Measurement(500, "meter")
         result = m1 - m2
@@ -104,6 +121,11 @@ class MeasurementTestCase(TestCase):
         self.assertEqual(str(result), "1 meter")
 
     def test_random_measurements(self):
+        """
+        Tests addition and subtraction of randomly generated Measurement instances with various units.
+        
+        Randomly generates pairs of Measurement objects with physical or currency units and verifies correct arithmetic behavior. Ensures that operations with matching units succeed, while operations between incompatible units or between currency and physical units raise appropriate exceptions.
+        """
         units = ["meter", "second", "kilogram", "liter", "EUR", "USD"]
         for _ in range(100):
             random_value_1 = Decimal(random.uniform(1, 1000))
@@ -138,3 +160,93 @@ class MeasurementTestCase(TestCase):
 
                     with self.assertRaises(ValueError):
                         result_sub = measurement_1 - measurement_2
+
+    def test_pickleable(self):
+        """
+        Tests that a Measurement instance can be pickled and unpickled, preserving its value and units.
+        """
+        import pickle
+
+        m = Measurement(10, "meter")
+        m_pickled = pickle.dumps(m)
+        m_unpickled = pickle.loads(m_pickled)
+        self.assertEqual(str(m), str(m_unpickled))
+        self.assertEqual(m.quantity.units, m_unpickled.quantity.units)
+        self.assertEqual(m.quantity.magnitude, m_unpickled.quantity.magnitude)
+
+    def test_equality(self):
+        """
+        Tests equality comparisons between Measurement instances, including correct handling of value and unit differences and appropriate exception raising for invalid comparisons.
+        """
+        m1 = Measurement(10, "meter")
+        m2 = Measurement(10, "meter")
+        m3 = Measurement(5, "meter")
+
+        self.assertEqual(m1, m2)
+        self.assertNotEqual(m1, m3)
+        with self.assertRaises(ValueError):
+            _ = m1 == "not a measurement"
+        with self.assertRaises(TypeError):
+            _ = m1 == 10
+        with self.assertRaises(ValueError):
+            _ = m1 == Measurement(10, "second")
+
+    def test_inequality(self):
+        """
+        Tests inequality comparisons between Measurement instances.
+        
+        Verifies that measurements with identical values and units are considered equal, while those with different values are not. Ensures that comparing a Measurement to an incompatible type or to a measurement with a different unit raises the appropriate exception.
+        """
+        m1 = Measurement(10, "meter")
+        m2 = Measurement(10, "meter")
+        m3 = Measurement(5, "meter")
+
+        self.assertFalse(m1 != m2)
+        self.assertTrue(m1 != m3)
+        with self.assertRaises(ValueError):
+            _ = m1 != "not a measurement"
+        with self.assertRaises(TypeError):
+            _ = m1 != 10
+        with self.assertRaises(ValueError):
+            _ = m1 != Measurement(10, "second")
+
+    def test_comparison(self):
+        """
+        Tests relational comparison operators for Measurement instances.
+        
+        Verifies correct behavior of equality and ordering comparisons between Measurement objects with the same and different values and units. Ensures that comparing with incompatible types or units raises appropriate exceptions.
+        """
+        m1 = Measurement(10, "meter")
+        m2 = Measurement(10, "meter")
+        m3 = Measurement(5, "meter")
+
+        self.assertTrue(m1 == m2)
+        self.assertFalse(m1 < m2)
+        self.assertFalse(m1 > m2)
+        self.assertTrue(m1 >= m2)
+        self.assertTrue(m1 <= m2)
+
+        self.assertTrue(m1 > m3)
+        self.assertFalse(m1 < m3)
+        self.assertTrue(m1 >= m3)
+        self.assertFalse(m1 <= m3)
+
+        with self.assertRaises(ValueError):
+            _ = m1 < "not a measurement"
+        with self.assertRaises(TypeError):
+            _ = m1 < 10
+        with self.assertRaises(ValueError):
+            _ = m1 < Measurement(10, "second")
+
+    def test_hash(self):
+        """
+        Tests that Measurement instances with equal values and units have equal hashes, and that differing values, units, or types produce different hashes.
+        """
+        m1 = Measurement(10, "meter")
+        m2 = Measurement(10, "meter")
+        m3 = Measurement(5, "meter")
+
+        self.assertEqual(hash(m1), hash(m2))
+        self.assertNotEqual(hash(m1), hash(m3))
+        self.assertNotEqual(hash(m1), hash(Measurement(10, "second")))
+        self.assertNotEqual(hash(m1), hash("not a measurement"))