GeneralManager 0.6.0__tar.gz → 0.6.2__tar.gz

{generalmanager-0.6.0 → generalmanager-0.6.2}/GeneralManager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.6.0
+Version: 0.6.2
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License-Expression: MIT

{generalmanager-0.6.0 → generalmanager-0.6.2}/GeneralManager.egg-info/SOURCES.txt

@@ -61,8 +61,11 @@ tests/test_baseInterface.py
 tests/test_basePermission.py
 tests/test_cacheDecorator.py
 tests/test_cacheTracker.py
-tests/test_dabaseBasedInterface.py
+tests/test_calculationBucket.py
+tests/test_calculationInterface.py
+tests/test_databaseBasedInterface.py
 tests/test_databaseBucket.py
+tests/test_databaseInterface.py
 tests/test_dependencyIndex.py
 tests/test_factories.py
 tests/test_factoryMethods.py

{generalmanager-0.6.0 → generalmanager-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.6.0
+Version: 0.6.2
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License-Expression: MIT

{generalmanager-0.6.0 → generalmanager-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.6.0"
+version = "0.6.2"
 description = "Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching."
 readme = "README.md"
 authors = [{ name = "Tim Kleindick", email = "tkleindick@yahoo.de" }]

{generalmanager-0.6.0 → generalmanager-0.6.2}/src/general_manager/bucket/calculationBucket.py

@@ -151,15 +151,15 @@ class CalculationBucket(Bucket[GeneralManagerType]):
 
     def __repr__(self) -> str:
         """
-        Returns a string representation of the CalculationBucket, showing a preview of its contents.
+        Returns a concise string representation of the CalculationBucket, including the manager class name, filters, excludes, sort key, and sort order.
         """
-        return self.__str__()
+        return f"{self.__class__.__name__}({self._manager_class.__name__}, {self.filters}, {self.excludes}, {self.sort_key}, {self.reverse})"
 
     def filter(self, **kwargs: Any) -> CalculationBucket:
         """
-        Returns a new CalculationBucket with additional filters applied to input combinations.
-
-        Additional filters are merged with existing filters, narrowing the set of valid input configurations.
+        Returns a new CalculationBucket with additional filters applied.
+        
+        Merges the provided filter criteria with existing filters to further restrict valid input combinations.
         """
         filters = self.filters.copy()
         excludes = self.excludes.copy()
@@ -315,42 +315,45 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         excludes: dict[str, dict],
     ) -> List[dict[str, Any]]:
         """
-        Recursively generates all valid input combinations based on sorted input fields, applying filters and exclusions.
-
+        Recursively generates all valid input combinations for the specified input fields, applying filters and exclusions.
+        
         Args:
-            sorted_inputs: List of input field names ordered by dependency.
-            filters: Dictionary mapping input names to filter definitions.
-            excludes: Dictionary mapping input names to exclusion definitions.
-
+            sorted_inputs: Input field names ordered to respect dependency constraints.
+            filters: Mapping of input field names to filter definitions.
+            excludes: Mapping of input field names to exclusion definitions.
+        
         Returns:
-            A list of dictionaries, each representing a valid combination of input values.
+            A list of dictionaries, each representing a valid combination of input values that satisfy all filters and exclusions.
         """
 
         def helper(index, current_combo):
+            """
+            Recursively generates all valid input combinations for calculation inputs.
+            
+            Yields:
+                Dict[str, Any]: A dictionary representing a valid combination of input values, filtered and excluded according to the provided criteria.
+            """
             if index == len(sorted_inputs):
                 yield current_combo.copy()
                 return
             input_name: str = sorted_inputs[index]
             input_field = self.input_fields[input_name]
 
-            # Hole mögliche Werte
             possible_values = self.get_possible_values(
                 input_name, input_field, current_combo
             )
 
-            # Wende die Filter an
             field_filters = filters.get(input_name, {})
             field_excludes = excludes.get(input_name, {})
 
+            # use filter_funcs and exclude_funcs to filter possible values
             if isinstance(possible_values, Bucket):
-                # Wende die Filter- und Exklusionsargumente direkt an
                 filter_kwargs = field_filters.get("filter_kwargs", {})
                 exclude_kwargs = field_excludes.get("filter_kwargs", {})
                 possible_values = possible_values.filter(**filter_kwargs).exclude(
                     **exclude_kwargs
                 )
             else:
-                # Wende die Filterfunktionen an
                 filter_funcs = field_filters.get("filter_funcs", [])
                 for filter_func in filter_funcs:
                     possible_values = filter(filter_func, possible_values)

{generalmanager-0.6.0 → generalmanager-0.6.2}/src/general_manager/interface/calculationInterface.py

@@ -61,7 +61,15 @@ class CalculationInterface(InterfaceBase):
     def _preCreate(
         name: generalManagerClassName, attrs: attributes, interface: interfaceBaseClass
     ) -> tuple[attributes, interfaceBaseClass, None]:
-        # Felder aus der Interface-Klasse sammeln
+
+        """
+        Prepares attributes and a new interface class before creating a GeneralManager class.
+        
+        Collects all `Input` instances from the provided interface class, sets the interface type in the attributes, dynamically creates a new interface class with these input fields, and adds it to the attributes.
+        
+        Returns:
+            A tuple containing the updated attributes dictionary, the new interface class, and None.
+        """
         input_fields: dict[str, Input[Any]] = {}
         for key, value in vars(interface).items():
             if key.startswith("__"):
@@ -69,7 +77,6 @@ class CalculationInterface(InterfaceBase):
             if isinstance(value, Input):
                 input_fields[key] = value
 
-        # Interface-Typ bestimmen
         attrs["_interface_type"] = interface._interface_type
         interface_cls = type(
             interface.__name__, (interface,), {"input_fields": input_fields}
@@ -102,18 +109,12 @@ class CalculationInterface(InterfaceBase):
     @classmethod
     def getFieldType(cls, field_name: str) -> type:
         """
-        Returns the type of the specified input field.
-        
-        Args:
-            field_name: The name of the input field.
-        
-        Returns:
-            The Python type associated with the input field.
+        Returns the Python type of a specified input field.
         
         Raises:
-            ValueError: If the specified field name does not exist in input_fields.
+            KeyError: If the field name does not exist in input_fields.
         """
         input = cls.input_fields.get(field_name)
         if input is None:
-            raise ValueError(f"Field '{field_name}' not found in input fields.")
+            raise KeyError(f"Field '{field_name}' not found in input fields.")
         return input.type

{generalmanager-0.6.0 → generalmanager-0.6.2}/src/general_manager/interface/databaseInterface.py

@@ -18,36 +18,24 @@ class DatabaseInterface(DBBasedInterface):
     def create(
         cls, creator_id: int, history_comment: str | None = None, **kwargs: Any
     ) -> int:
-        from general_manager.manager.generalManager import GeneralManager
 
-        cls.__checkForInvalidKwargs(cls._model, kwargs=kwargs)
-        kwargs, many_to_many_kwargs = cls.__sortKwargs(cls._model, kwargs)
-        instance = cls._model()
-        for key, value in kwargs.items():
-            if isinstance(value, GeneralManager):
-                value = value.identification["id"]
-                key = f"{key}_id"
-            setattr(instance, key, value)
-        for key, value in many_to_many_kwargs.items():
-            getattr(instance, key).set(value)
-        return cls.__save_with_history(instance, creator_id, history_comment)
+        cls._checkForInvalidKwargs(cls._model, kwargs=kwargs)
+        kwargs, many_to_many_kwargs = cls._sortKwargs(cls._model, kwargs)
+        instance = cls.__setAttrForWrite(cls._model(), kwargs)
+        pk = cls._save_with_history(instance, creator_id, history_comment)
+        cls.__setManyToManyAttributes(instance, many_to_many_kwargs)
+        return pk
 
     def update(
         self, creator_id: int, history_comment: str | None = None, **kwargs: Any
     ) -> int:
-        from general_manager.manager.generalManager import GeneralManager
 
-        self.__checkForInvalidKwargs(self._model, kwargs=kwargs)
-        kwargs, many_to_many_kwargs = self.__sortKwargs(self._model, kwargs)
-        instance = self._model.objects.get(pk=self.pk)
-        for key, value in kwargs.items():
-            if isinstance(value, GeneralManager):
-                value = value.identification["id"]
-                key = f"{key}_id"
-            setattr(instance, key, value)
-        for key, value in many_to_many_kwargs.items():
-            getattr(instance, key).set(value)
-        return self.__save_with_history(instance, creator_id, history_comment)
+        self._checkForInvalidKwargs(self._model, kwargs=kwargs)
+        kwargs, many_to_many_kwargs = self._sortKwargs(self._model, kwargs)
+        instance = self.__setAttrForWrite(self._model.objects.get(pk=self.pk), kwargs)
+        pk = self._save_with_history(instance, creator_id, history_comment)
+        self.__setManyToManyAttributes(instance, many_to_many_kwargs)
+        return pk
 
     def deactivate(self, creator_id: int, history_comment: str | None = None) -> int:
         instance = self._model.objects.get(pk=self.pk)
@@ -56,32 +44,68 @@ class DatabaseInterface(DBBasedInterface):
             history_comment = f"{history_comment} (deactivated)"
         else:
             history_comment = "Deactivated"
-        return self.__save_with_history(instance, creator_id, history_comment)
+        return self._save_with_history(instance, creator_id, history_comment)
 
     @staticmethod
-    def __checkForInvalidKwargs(model: Type[models.Model], kwargs: dict[Any, Any]):
+    def __setManyToManyAttributes(
+        instance: GeneralManagerModel, many_to_many_kwargs: dict[str, list[Any]]
+    ) -> GeneralManagerModel:
+        """
+        Sets many-to-many attributes for the given instance based on the provided kwargs.
+
+        Args:
+            instance: The model instance to update.
+            many_to_many_kwargs: A dictionary containing many-to-many field names and their corresponding values.
+
+        Returns:
+            The updated model instance.
+        """
+        for key, value in many_to_many_kwargs.items():
+            if not value:
+                continue
+            field_name = key.split("_id_list")[0]
+            getattr(instance, field_name).set(value)
+
+        return instance
+
+    @staticmethod
+    def __setAttrForWrite(
+        instance: GeneralManagerModel,
+        kwargs: dict[str, Any],
+    ) -> GeneralManagerModel:
+        from general_manager.manager.generalManager import GeneralManager
+
+        for key, value in kwargs.items():
+            if isinstance(value, GeneralManager):
+                value = value.identification["id"]
+                key = f"{key}_id"
+            setattr(instance, key, value)
+        return instance
+
+    @staticmethod
+    def _checkForInvalidKwargs(model: Type[models.Model], kwargs: dict[str, Any]):
         attributes = vars(model)
-        fields = model._meta.get_fields()
+        field_names = {f.name for f in model._meta.get_fields()}
         for key in kwargs:
-            if key not in attributes and key not in fields:
+            temp_key = key.split("_id_list")[0]  # Remove '_id_list' suffix
+            if temp_key not in attributes and temp_key not in field_names:
                 raise ValueError(f"{key} does not exsist in {model.__name__}")
 
     @staticmethod
-    def __sortKwargs(
+    def _sortKwargs(
         model: Type[models.Model], kwargs: dict[Any, Any]
     ) -> tuple[dict[str, Any], dict[str, list[Any]]]:
-        many_to_many_fields = model._meta.many_to_many
+        many_to_many_fields = [field.name for field in model._meta.many_to_many]
         many_to_many_kwargs: dict[Any, Any] = {}
-        for key, value in kwargs.items():
+        for key, value in list(kwargs.items()):
             many_to_many_key = key.split("_id_list")[0]
             if many_to_many_key in many_to_many_fields:
-                many_to_many_kwargs[key] = value
-                kwargs.pop(key)
+                many_to_many_kwargs[key] = kwargs.pop(key)
         return kwargs, many_to_many_kwargs
 
     @classmethod
     @transaction.atomic
-    def __save_with_history(
+    def _save_with_history(
         cls, instance: GeneralManagerModel, creator_id: int, history_comment: str | None
     ) -> int:
         """

generalmanager-0.6.2/tests/test_calculationBucket.py

@@ -0,0 +1,373 @@
+# type: ignore
+from django.test import TestCase
+from unittest.mock import patch
+from general_manager.bucket.calculationBucket import CalculationBucket
+from general_manager.interface.calculationInterface import CalculationInterface
+from general_manager.manager.input import Input
+
+
+# Create a dummy CalculationInterface with no input fields for simplicity
+class DummyCalculationInterface(CalculationInterface):
+    input_fields = {}
+
+
+# Dummy manager class that uses the dummy interface
+class DummyGeneralManager:
+    Interface = DummyCalculationInterface
+
+    def __init__(self, **kwargs):
+        # Initialize with any keyword arguments, simulating a manager
+        """
+        Initializes the dummy manager with provided keyword arguments.
+        
+        Stores all keyword arguments for later comparison and representation.
+        """
+        self.kwargs = kwargs
+
+    def __eq__(self, value: object) -> bool:
+        """
+        Checks equality with another DummyGeneralManager based on initialization arguments.
+        
+        Returns:
+            True if the other object is a DummyGeneralManager with identical kwargs; otherwise, False.
+        """
+        if not isinstance(value, DummyGeneralManager):
+            return False
+        return self.kwargs == value.kwargs
+
+    def __repr__(self):
+        """
+        Returns a string representation of the DummyGeneralManager instance with its initialization arguments.
+        """
+        return f"DummyGeneralManager({self.kwargs})"
+
+
+# Link parent class for the interface
+DummyCalculationInterface._parent_class = DummyGeneralManager
+
+
+@patch(
+    "general_manager.bucket.calculationBucket.parse_filters",
+    return_value={"dummy": {"filter_kwargs": {}}},
+)
+class TestCalculationBucket(TestCase):
+    def test_initialization_defaults(self, mock_parse):
+        # Test basic initialization without optional parameters
+        """
+        Tests that CalculationBucket initializes with default values when only the manager class is provided.
+        
+        Verifies that filters, excludes, sort key, and reverse flag are set to their defaults, and that input fields are sourced from the associated interface.
+        """
+        bucket = CalculationBucket(manager_class=DummyGeneralManager)
+        self.assertIsInstance(bucket, CalculationBucket)
+        self.assertEqual(bucket._manager_class, DummyGeneralManager)
+        self.assertEqual(bucket.filters, {})
+        self.assertEqual(bucket.excludes, {})
+        self.assertIsNone(bucket.sort_key)
+        self.assertFalse(bucket.reverse)
+        # input_fields should come from the interface
+        self.assertEqual(bucket.input_fields, DummyCalculationInterface.input_fields)
+
+    def test_initialization_with_filters_and_excludes(self, mock_parse):
+        # Filters and excludes passed directly to constructor
+        """
+        Tests that CalculationBucket initializes with provided filter and exclude definitions, sort key, and reverse flag.
+        
+        Verifies that the constructor correctly assigns the given filters, excludes, sort key, and reverse attributes.
+        """
+        fdefs = {"f": {"filter_kwargs": {"f": 1}}}
+        edefs = {"e": {"filter_kwargs": {"e": 2}}}
+        bucket = CalculationBucket(
+            manager_class=DummyGeneralManager,
+            filter_definitions=fdefs,
+            exclude_definitions=edefs,
+            sort_key="key",
+            reverse=True,
+        )
+        self.assertEqual(bucket.filters, fdefs)
+        self.assertEqual(bucket.excludes, edefs)
+        self.assertEqual(bucket.sort_key, "key")
+        self.assertTrue(bucket.reverse)
+
+    def test_reduce_and_setstate(self, mock_parse):
+        # Test pickling support
+        """
+        Tests that CalculationBucket supports pickling and unpickling via __reduce__ and __setstate__.
+        
+        Verifies that the reduced state includes current combinations and that state restoration
+        correctly sets the internal combinations on a new instance.
+        """
+        bucket = CalculationBucket(DummyGeneralManager, {"a": 1}, {"b": 2}, "k", True)
+        # Prepopulate state
+        bucket._current_combinations = [{"x": 10}]
+        cls, args, state = bucket.__reduce__()
+        # Check reduce data
+        self.assertEqual(cls, CalculationBucket)
+        self.assertEqual(args, (DummyGeneralManager, {"a": 1}, {"b": 2}, "k", True))
+        self.assertIn("current_combinations", state)
+        # Restore state on new instance
+        new_bucket = CalculationBucket(*args)
+        new_bucket.__setstate__(state)
+        self.assertEqual(new_bucket._current_combinations, [{"x": 10}])
+
+    def test_or_with_same_bucket(self, mock_parse):
+        # Combining two buckets of same class should intersect filters/excludes
+        """
+        Tests that combining two CalculationBucket instances with the same manager class using the bitwise OR operator results in a new bucket containing only the filters and excludes that are identical in both buckets.
+        """
+        b1 = CalculationBucket(DummyGeneralManager, {"f1": 1}, {"e1": 2})
+        b2 = CalculationBucket(
+            DummyGeneralManager, {"f1": 1, "f2": 3}, {"e1": 2, "e2": 4}
+        )
+        combined = b1 | b2
+        self.assertIsInstance(combined, CalculationBucket)
+        # Only common identical definitions should remain
+        self.assertEqual(combined.filters, {"f1": 1})
+        self.assertEqual(combined.excludes, {"e1": 2})
+
+    def test_or_with_invalid(self, mock_parse):
+        """
+        Tests that combining a CalculationBucket with an incompatible type or a bucket of a different manager class raises a ValueError.
+        """
+        b1 = CalculationBucket(DummyGeneralManager)
+        # Combining with different type should raise
+        with self.assertRaises(ValueError):
+            _ = b1 | 123
+
+        # Combining with bucket of different manager class should raise
+        class OtherManager:
+            Interface = DummyCalculationInterface
+
+        b2 = CalculationBucket(OtherManager)
+        with self.assertRaises(ValueError):
+            _ = b1 | b2
+
+    def test_str_and_repr_formatting(self, mock_parse):
+        """
+        Tests the string and repr formatting of CalculationBucket instances.
+        
+        Verifies that the string representation displays the total count and up to five combinations, using an ellipsis if more exist, and that the repr shows the constructor parameters.
+        """
+        bucket = CalculationBucket(DummyGeneralManager)
+        # Manually set combinations for string formatting tests
+        combos = [{"x": i} for i in range(7)]
+        bucket._current_combinations = combos
+        s = str(bucket)
+        # Should show total count and at most 5 entries
+        self.assertTrue(s.startswith("CalculationBucket (7)["))
+        self.assertIn("...", s)
+        # Test below threshold (no ellipsis)
+        bucket._current_combinations = combos[:3]
+        s2 = str(bucket)
+        self.assertFalse("..." in s2)
+
+        s3 = repr(bucket)
+        self.assertEqual(
+            s3,
+            f"CalculationBucket({DummyGeneralManager.__name__}, {{}}, {{}}, None, False)",
+        )
+
+    def test_all_iter_len_count(self, mock_parse):
+        """
+        Tests that CalculationBucket's all(), iteration, count(), and length methods behave as expected.
+        
+        Verifies that all() returns the bucket itself, iteration yields one manager instance per combination, and both count() and len() return the correct number of combinations.
+        """
+        bucket = CalculationBucket(DummyGeneralManager)
+        # Set a single empty combination so manager(**{}) works
+        bucket._current_combinations = [{}] * 4
+        # all() returns self
+        self.assertIs(bucket.all(), bucket)
+        # Iteration yields one manager per combo
+        items = list(bucket)
+        self.assertEqual(len(items), 4)
+        # count() and len() reflect number of combos
+        self.assertEqual(bucket.count(), 4)
+        self.assertEqual(len(bucket), 4)
+
+    def test_first_last_empty_and_nonempty(self, mock_parse):
+        """
+        Tests the behavior of the `first()` and `last()` methods on a `CalculationBucket`.
+        
+        Verifies that `first()` and `last()` return `None` when the bucket has no combinations, and return the same manager instance when only one combination exists.
+        """
+        bucket = CalculationBucket(DummyGeneralManager)
+        # Empty combos
+        bucket._current_combinations = []
+        self.assertIsNone(bucket.first())
+        self.assertIsNone(bucket.last())
+        # Single combo
+        bucket._current_combinations = [{"test": 1}]
+        first = bucket.first()
+        last = bucket.last()
+        self.assertIsNotNone(first)
+        self.assertEqual(first, last)
+
+    def test_getitem_index_and_slice(self, mock_parse):
+        """
+        Tests that indexing a CalculationBucket returns a manager instance and slicing returns a new CalculationBucket with the correct subset of combinations.
+        """
+        bucket = CalculationBucket(DummyGeneralManager)
+        # Create distinct combos for index and slice
+        bucket._current_combinations = [{"i": 1}, {"i": 2}, {"i": 3}]
+        # Index __getitem__
+        mgr = bucket[1]
+        self.assertIsInstance(mgr, DummyGeneralManager)
+        # Slice __getitem__
+        sliced = bucket[0:2]
+        self.assertIsInstance(sliced, CalculationBucket)
+        # Sliced bucket should have its own combinations
+        self.assertEqual(sliced._current_combinations, [{"i": 1}, {"i": 2}])
+
+    def test_sort_returns_new_bucket(self, mock_parse):
+        """
+        Tests that the sort() method returns a new CalculationBucket with updated sort key and reverse flag, leaving the original bucket unchanged.
+        """
+        bucket = CalculationBucket(DummyGeneralManager, {"a": 1}, {"b": 2}, None, False)
+        sorted_bucket = bucket.sort(key="a", reverse=True)
+        self.assertIsInstance(sorted_bucket, CalculationBucket)
+        # Original bucket unchanged
+        self.assertIsNone(bucket.sort_key)
+        # New bucket has updated sort settings
+        self.assertEqual(sorted_bucket.sort_key, "a")
+        self.assertTrue(sorted_bucket.reverse)
+
+
+@patch("general_manager.bucket.calculationBucket.parse_filters", return_value={})
+class TestGenerateCombinations(TestCase):
+
+    def _make_bucket_with_fields(self, fields):
+        # Dynamically create an interface and manager class with given input_fields
+        """
+        Creates a CalculationBucket with dynamically defined input fields.
+        
+        Args:
+            fields: A list of input field definitions to assign to the generated interface.
+        
+        Returns:
+            A CalculationBucket instance using a dynamically created manager and interface with the specified input fields.
+        """
+        class DynInterface(CalculationInterface):
+            input_fields = fields
+
+        class DynManager:
+            Interface = DynInterface
+
+        DynInterface._parent_class = DynManager
+        return CalculationBucket(DynManager)
+
+    def test_basic_cartesian_product(self, mock_parse):
+        # Two independent fields produce a Cartesian product
+        """
+        Tests that generate_combinations produces the Cartesian product of independent input fields.
+        
+        Verifies that two fields with independent possible values yield all possible combinations.
+        """
+        fields = {
+            "num": Input(type=int, possible_values=[1, 2]),
+            "char": Input(type=str, possible_values=["a", "b"]),
+        }
+        bucket = self._make_bucket_with_fields(fields)
+        combos = bucket.generate_combinations()
+        # Expect 4 combinations
+        expected = [
+            {"num": 1, "char": "a"},
+            {"num": 1, "char": "b"},
+            {"num": 2, "char": "a"},
+            {"num": 2, "char": "b"},
+        ]
+        # Compare as multisets since insertion order of fields may vary
+        self.assertCountEqual(combos, expected)
+
+    def test_empty_possible_values(self, mock_parse):
+        # A field with no possible_values yields no combinations
+        """
+        Tests that a field with an empty list of possible values results in no generated combinations.
+        """
+        fields = {
+            "x": Input(type=int, possible_values=[]),
+        }
+        bucket = self._make_bucket_with_fields(fields)
+        combos = bucket.generate_combinations()
+        self.assertEqual(
+            combos, [], "Expected no combinations when possible_values is empty"
+        )
+
+    def test_dependent_field(self, mock_parse):
+        # Field2 depends on field1 and its possible_values is a callable
+        """
+        Tests that a dependent input field with callable possible values generates combinations reflecting the dependency.
+        
+        Verifies that when one field's possible values depend on another field's value, the generated combinations correctly incorporate this relationship.
+        """
+        def pv_func(a):
+            return [a * 10]
+
+        fields = {
+            "a": Input(type=int, possible_values=[1, 2]),
+            "b": Input(type=int, possible_values=pv_func, depends_on=["a"]),
+        }
+        bucket = self._make_bucket_with_fields(fields)
+        combos = bucket.generate_combinations()
+        expected = [
+            {"a": 1, "b": 10},
+            {"a": 2, "b": 20},
+        ]
+        self.assertCountEqual(combos, expected)
+
+    def test_filters_and_excludes(self, mock_parse):
+        # Apply filter_funcs to include only even numbers, and exclude a specific value
+        """
+        Tests that filter and exclude functions are correctly applied to input values.
+        
+        Verifies that only even numbers are included and a specific value is excluded from the generated combinations.
+        """
+        fields = {
+            "n": Input(type=int, possible_values=[1, 2, 3, 4]),
+        }
+        bucket = self._make_bucket_with_fields(fields)
+        # Manually set filter and exclude definitions
+        bucket.filters = {"n": {"filter_funcs": [lambda x: x % 2 == 0]}}
+        bucket.excludes = {"n": {"filter_funcs": [lambda x: x == 4]}}
+        combos = bucket.generate_combinations()
+        # Should include only 2, excluding 4
+        self.assertEqual(combos, [{"n": 2}])
+
+    def test_sort_and_reverse_and_caching(self, mock_parse):
+        # Three values, sorted and reversed
+        """
+        Tests that sorting and reversing combinations works as expected and that results are cached.
+        
+        Verifies that combinations are sorted in descending order by the specified key, and that repeated calls to `generate_combinations` return the cached result.
+        """
+        fields = {
+            "v": Input(type=int, possible_values=[3, 1, 2]),
+        }
+        # Create unsorted bucket
+        bucket = self._make_bucket_with_fields(fields)
+        # New bucket with sort_key
+        sorted_bucket = CalculationBucket(
+            bucket._manager_class,
+            bucket.filters,
+            bucket.excludes,
+            sort_key="v",
+            reverse=True,
+        )
+        combos = sorted_bucket.generate_combinations()
+        # Should be [3,2,1]
+        self.assertEqual([d["v"] for d in combos], [3, 2, 1])
+        # Test caching: calling again yields same object
+        combos2 = sorted_bucket.generate_combinations()
+        self.assertIs(combos, combos2)
+
+    def test_invalid_possible_values_type(self, mock_parse):
+        # possible_values not iterable or callable should raise TypeError
+        """
+        Tests that a TypeError is raised when a field's possible_values is neither iterable nor callable.
+        """
+        fields = {
+            "z": Input(type=int, possible_values=123),
+        }
+        bucket = self._make_bucket_with_fields(fields)
+        with self.assertRaises(TypeError):
+            bucket.generate_combinations()