GeneralManager 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

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)

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

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.0.dist-info → generalmanager-0.6.2.dist-info}/METADATA

@@ -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.dist-info → generalmanager-0.6.2.dist-info}/RECORD

@@ -11,7 +11,7 @@ general_manager/auxiliary/makeCacheKey.py,sha256=lczutqxlofLSUnheKRi8nazhOyPa04T
 general_manager/auxiliary/noneToZero.py,sha256=KfQtMQnrT6vsYST0K7lv6pVujkDcK3XL8czHYOhgqKQ,539
 general_manager/auxiliary/pathMapping.py,sha256=nrz5owQg2a69Yig1eCXorR9U0NSw7NmBAk5OkeoHTdA,6842
 general_manager/bucket/baseBucket.py,sha256=65oQbSE6C8TE0yVPP_Aoi_Fwq0Uo2TLVPWMG6l2qxyQ,7836
-general_manager/bucket/calculationBucket.py,sha256=M2z7H7mvs56BIlr0NKQYqxcbWO92cFsgXSeKgM4oAko,18056
+general_manager/bucket/calculationBucket.py,sha256=c4p4QBV6PVYi1sxM8iReZ2YQtMmD8q5uPXXwkgCX6fQ,18467
 general_manager/bucket/databaseBucket.py,sha256=V_xiPa8ErnPHVh_-i-oaH8qCa818UJxm5CVl80SVc1U,9060
 general_manager/bucket/groupBucket.py,sha256=55QdUaH_qO1JFJ2Jc1f2WcxniiLE5LB3vNwbnksKk8A,10939
 general_manager/cache/cacheDecorator.py,sha256=DK2ANIJgPpMxazfMSiFrI9OuVE_7K9zlIZQRrgaC2Lw,3268
@@ -25,9 +25,9 @@ general_manager/factory/factories.py,sha256=F6_nYFyJRYYc3LQApfoVFdctfLzsWUDHKafn
 general_manager/factory/factoryMethods.py,sha256=9Bag891j0XHe3dUBAFi7gUKcKeUwcBZN3cDLBobyBiI,3225
 general_manager/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 general_manager/interface/baseInterface.py,sha256=b7MH-jVADcpGluvJMogPn2O3Yiy37uCnWOM9j0Ec0o0,8692
-general_manager/interface/calculationInterface.py,sha256=ZMYQcJZdfnEimsKOGFVfg-8r6Syjo_D9_HPVJkd59ak,4018
+general_manager/interface/calculationInterface.py,sha256=Kg_OqLw67tcLwdzYNLq31eKVLzkM7taw-8Mzmk0CYi0,4232
 general_manager/interface/databaseBasedInterface.py,sha256=K2PYxANuLQU8wzrajcl922tuWwko642KJAS3f3PnAmg,21566
-general_manager/interface/databaseInterface.py,sha256=rQWeL5u_WCvDtikXLracFkECVM9vZHjs7UXTJlDDCmY,4146
+general_manager/interface/databaseInterface.py,sha256=08dFgxoLQNa13RK2NQ4cDNbNPIG-X9ChLs3NvJcSp6Y,4923
 general_manager/interface/readOnlyInterface.py,sha256=d2CM2gj5XZNEaVFZeNCgqZf46rwUAetVS3SyePCKNsY,4691
 general_manager/manager/__init__.py,sha256=l3RYp62aEhj3Y975_XUTIzo35LUnkTJHkb_hgChnXXI,111
 general_manager/manager/generalManager.py,sha256=HX69KhrnSGVkuJwHY_jzff5gS0VD-6fRxKnd59A5Ct4,6100
@@ -46,8 +46,8 @@ general_manager/permission/permissionDataManager.py,sha256=Ji7fsnuaKTa6M8yzCGyzr
 general_manager/rule/__init__.py,sha256=4Har5cfPD1fmOsilTDod-ZUz3Com-tkl58jz7yY4fD0,23
 general_manager/rule/handler.py,sha256=z8SFHTIZ0LbLh3fV56Mud0V4_OvWkqJjlHvFqau7Qfk,7334
 general_manager/rule/rule.py,sha256=3FVCKGL7BTVoStdgOTdWQwuoVRIxAIAilV4VOzouDpc,10759
-generalmanager-0.6.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
-generalmanager-0.6.0.dist-info/METADATA,sha256=Z3Eh9kL1htCX6HfL5DVmlU6FGIfvu_1k777eTxiNMjU,6205
-generalmanager-0.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-generalmanager-0.6.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
-generalmanager-0.6.0.dist-info/RECORD,,
+generalmanager-0.6.2.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.6.2.dist-info/METADATA,sha256=LpZhar2vKhlCPwavT15s1yWSeMCHH6M9rqtC69BjraQ,6205
+generalmanager-0.6.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+generalmanager-0.6.2.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.6.2.dist-info/RECORD,,