GeneralManager 0.1.1__tar.gz → 0.1.2__tar.gz

{generalmanager-0.1.1 → generalmanager-0.1.2}/GeneralManager.egg-info/PKG-INFO

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

{generalmanager-0.1.1 → generalmanager-0.1.2}/GeneralManager.egg-info/SOURCES.txt

@@ -47,8 +47,10 @@ src/general_manager/rule/rule.py
 tests/test_argsToKwargs.py
 tests/test_basePermission.py
 tests/test_graph_ql.py
+tests/test_input.py
 tests/test_managerBasedPermission.py
 tests/test_measurement.py
 tests/test_measurement_field.py
+tests/test_noneToZero.py
 tests/test_rules.py
 tests/test_settings.py

{generalmanager-0.1.1 → generalmanager-0.1.2}/PKG-INFO

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

{generalmanager-0.1.1 → generalmanager-0.1.2}/pyproject.toml

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

{generalmanager-0.1.1 → generalmanager-0.1.2}/src/general_manager/auxiliary/noneToZero.py

@@ -1,12 +1,12 @@
 from typing import Optional, TypeVar, Literal
 from general_manager.measurement import Measurement
 
-VALUE = TypeVar("VALUE", int, float, Measurement)
+NUMBERVALUE = TypeVar("NUMBERVALUE", int, float, Measurement)
 
 
 def noneToZero(
-    value: Optional[VALUE],
-) -> VALUE | Literal[0]:
+    value: Optional[NUMBERVALUE],
+) -> NUMBERVALUE | Literal[0]:
     if value is None:
         return 0
     return value

{generalmanager-0.1.1 → generalmanager-0.1.2}/src/general_manager/interface/databaseInterface.py

@@ -654,7 +654,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             kwarg_filter[key].append(value)
         return kwarg_filter
 
-    def filter(self, **kwargs: Any) -> DatabaseBucket:
+    def filter(self, **kwargs: Any) -> DatabaseBucket[GeneralManagerType]:
         merged_filter = self.__mergeFilterDefinitions(self.filters, **kwargs)
         return self.__class__(
             self._data.filter(**kwargs),
@@ -663,7 +663,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             self.excludes,
         )
 
-    def exclude(self, **kwargs: Any) -> DatabaseBucket:
+    def exclude(self, **kwargs: Any) -> DatabaseBucket[GeneralManagerType]:
         merged_exclude = self.__mergeFilterDefinitions(self.excludes, **kwargs)
         return self.__class__(
             self._data.exclude(**kwargs),

{generalmanager-0.1.1 → generalmanager-0.1.2}/src/general_manager/manager/input.py

@@ -17,6 +17,14 @@ class Input(Generic[INPUT_TYPE]):
         possible_values: Optional[Callable | Iterable] = None,
         depends_on: Optional[List[str]] = None,
     ):
+        """
+        Initializes an Input instance with type information, possible values, and dependencies.
+        
+        Args:
+            type: The expected type for the input value.
+            possible_values: An optional iterable or callable that defines allowed values.
+            depends_on: An optional list of dependency names. If not provided and possible_values is callable, dependencies are inferred from its parameters.
+        """
         self.type = type
         self.possible_values = possible_values
         self.is_manager = issubclass(type, GeneralManager)
@@ -33,16 +41,33 @@ class Input(Generic[INPUT_TYPE]):
             self.depends_on = []
 
     def cast(self, value: Any) -> Any:
+        """
+        Casts the input value to the type specified by this Input instance.
+        
+        Handles special cases for date, datetime, GeneralManager subclasses, and Measurement types.
+        If the value is already of the target type, it is returned unchanged. Otherwise, attempts to
+        convert or construct the value as appropriate for the target type.
+        
+        Args:
+            value: The value to be cast or converted.
+        
+        Returns:
+            The value converted to the target type, or an instance of the target type.
+        """
+        if self.type == date:
+            if isinstance(value, datetime) and type(value) is not date:
+                return value.date()
+            return date.fromisoformat(value)
+        if self.type == datetime:
+            if isinstance(value, date):
+                return datetime.combine(value, datetime.min.time())
+            return datetime.fromisoformat(value)
         if isinstance(value, self.type):
             return value
         if issubclass(self.type, GeneralManager):
             if isinstance(value, dict):
                 return self.type(**value)  # type: ignore
             return self.type(id=value)  # type: ignore
-        if self.type == date:
-            return date.fromisoformat(value)
-        if self.type == datetime:
-            return datetime.fromisoformat(value)
         if self.type == Measurement and isinstance(value, str):
             return Measurement.from_string(value)
         return self.type(value)

generalmanager-0.1.2/tests/test_input.py

@@ -0,0 +1,165 @@
+from django.test import TestCase
+from unittest.mock import patch
+from general_manager.manager.input import Input
+from general_manager.measurement import Measurement
+from datetime import date, datetime
+
+
+class TestInput(TestCase):
+
+    def test_simple_input_initialization(self):
+        # Test with a simple type
+        input_obj = Input(int)
+        self.assertEqual(input_obj.type, int)
+        self.assertIsNone(input_obj.possible_values)
+        self.assertEqual(input_obj.depends_on, [])
+
+    def test_input_initialization_with_callable_possible_values(self):
+        # Test with a callable for possible_values
+        """
+        Tests that initializing Input with a callable possible_values assigns attributes correctly.
+        
+        Verifies that the type is set, possible_values references the callable, and depends_on is an empty list.
+        """
+        def possible_values_func():
+            return [1, 2, 3]
+
+        input_obj = Input(int, possible_values=possible_values_func)
+        self.assertEqual(input_obj.type, int)
+        self.assertEqual(input_obj.possible_values, possible_values_func)
+        self.assertEqual(input_obj.depends_on, [])
+
+    def test_input_initialization_with_list_depends_on(self):
+        # Test with a list for depends_on
+        """
+        Tests that initializing an Input with a list for depends_on sets the attribute correctly.
+        
+        Verifies that the type is set to int, possible_values is None, and depends_on matches the provided list.
+        """
+        input_obj = Input(int, depends_on=["input1", "input2"])
+        self.assertEqual(input_obj.type, int)
+        self.assertIsNone(input_obj.possible_values)
+        self.assertEqual(input_obj.depends_on, ["input1", "input2"])
+
+    def test_input_initialization_with_type_not_matching_possible_values(self):
+        # Test with a type that doesn't match the possible_values
+        """
+        Tests initialization of Input with a type that does not match possible_values.
+        
+        Verifies that the Input object accepts possible_values of a different type than the declared type without validation, and sets attributes accordingly.
+        """
+        input_obj = Input(str, possible_values=[1, 2, 3])
+        self.assertEqual(input_obj.type, str)
+        self.assertEqual(input_obj.possible_values, [1, 2, 3])
+        self.assertEqual(input_obj.depends_on, [])
+
+    def test_input_initialization_with_callable_and_list_depends_on(self):
+        # Test with both callable and list for depends_on
+        """
+        Tests that an Input can be initialized with a callable for possible_values and a list for depends_on.
+        
+        Verifies that the type, possible_values, and depends_on attributes are set correctly when both are provided.
+        """
+        def possible_values_func():
+            return [1, 2, 3]
+
+        input_obj = Input(
+            int, possible_values=possible_values_func, depends_on=["input1"]
+        )
+        self.assertEqual(input_obj.type, int)
+        self.assertEqual(input_obj.possible_values, possible_values_func)
+        self.assertEqual(input_obj.depends_on, ["input1"])
+
+    def test_simple_input_casting(self):
+        # Test casting a value to the specified type
+        """
+        Tests that the Input class correctly casts values to integers and raises exceptions for invalid inputs.
+        
+        Verifies successful casting from strings, integers, and floats to int, and asserts that invalid strings, None, or unsupported types raise ValueError or TypeError.
+        """
+        input_obj = Input(int)
+        self.assertEqual(input_obj.cast("123"), 123)
+        self.assertEqual(input_obj.cast(456), 456)
+        self.assertEqual(input_obj.cast(789.0), 789)
+
+        with self.assertRaises(ValueError):
+            input_obj.cast("abc")
+        with self.assertRaises(TypeError):
+            input_obj.cast(None)
+        with self.assertRaises(TypeError):
+            input_obj.cast([1, 2, 3])
+
+    def test_input_casting_with_general_manager(self):
+        # Test casting with a GeneralManager subclass
+        """
+        Tests casting to a GeneralManager subclass using the Input class.
+        
+        Verifies that casting a dictionary or integer to an Input expecting a GeneralManager subclass returns an instance with the correct id attribute. Uses mocking to simulate subclass checks.
+        """
+        class MockGeneralManager:
+            def __init__(self, id):
+                self.id = id
+
+        with patch("general_manager.manager.input.issubclass", return_value=True):
+            input_obj = Input(MockGeneralManager)
+            self.assertEqual(input_obj.cast({"id": 1}).id, 1)
+            self.assertEqual(input_obj.cast(2).id, 2)
+
+    def test_input_casting_with_date(self):
+        # Test casting with date
+        """
+        Tests that the Input class correctly casts values to date objects.
+        
+        Verifies successful casting from ISO format strings and datetime objects to date,
+        and asserts that invalid strings, None, or unsupported types raise exceptions.
+        """
+        input_obj = Input(date)
+        self.assertEqual(input_obj.cast("2023-10-01"), date(2023, 10, 1))
+        self.assertEqual(
+            input_obj.cast(datetime(2023, 10, 1, 12, 1, 5)), date(2023, 10, 1)
+        )
+        with self.assertRaises(ValueError):
+            input_obj.cast("invalid-date")
+        with self.assertRaises(TypeError):
+            input_obj.cast(None)
+        with self.assertRaises(TypeError):
+            input_obj.cast([1, 2, 3])
+
+    def test_input_casting_with_datetime(self):
+        # Test casting with datetime
+        """
+        Tests that the Input class correctly casts values to datetime objects.
+        
+        Verifies successful casting from ISO format strings and date objects to datetime,
+        and asserts that invalid strings, None, or unsupported types raise appropriate exceptions.
+        """
+        input_obj = Input(datetime)
+        self.assertEqual(
+            input_obj.cast("2023-10-01T12:00:00"), datetime(2023, 10, 1, 12, 0, 0)
+        )
+        self.assertEqual(
+            input_obj.cast(date(2023, 10, 1)), datetime(2023, 10, 1, 0, 0, 0)
+        )
+        with self.assertRaises(ValueError):
+            input_obj.cast("invalid-datetime")
+        with self.assertRaises(TypeError):
+            input_obj.cast(None)
+        with self.assertRaises(TypeError):
+            input_obj.cast([1, 2, 3])
+
+    def test_input_casting_with_measurement(self):
+        # Test casting with Measurement
+        """
+        Tests that the Input class correctly casts values to Measurement instances.
+        
+        Verifies successful casting from valid measurement strings and Measurement objects, and asserts that invalid strings, None, or unsupported types raise appropriate exceptions.
+        """
+        input_obj = Input(Measurement)
+        self.assertEqual(input_obj.cast("1.0 m"), Measurement(1.0, "m"))
+        self.assertEqual(input_obj.cast(Measurement(2.0, "m")), Measurement(2.0, "m"))
+        with self.assertRaises(ValueError):
+            input_obj.cast("invalid-measurement")
+        with self.assertRaises(TypeError):
+            input_obj.cast(None)
+        with self.assertRaises(TypeError):
+            input_obj.cast([1, 2, 3])

generalmanager-0.1.2/tests/test_noneToZero.py

@@ -0,0 +1,14 @@
+from django.test import TestCase
+from general_manager.auxiliary.noneToZero import noneToZero
+
+
+class TestNoneToZero(TestCase):
+
+    def test_none_to_zero(self):
+        """
+        Tests the noneToZero function to ensure it correctly converts None to 0.
+
+        Verifies that the function returns 0 when given None, and returns the original value for non-None inputs.
+        """
+        self.assertEqual(noneToZero(None), 0)
+        self.assertEqual(noneToZero(5), 5)