GeneralManager 0.12.1__tar.gz → 0.12.2__tar.gz

{generalmanager-0.12.1 → generalmanager-0.12.2}/GeneralManager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.12.1
+Version: 0.12.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.12.1 → generalmanager-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.12.1
+Version: 0.12.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.12.1 → generalmanager-0.12.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.12.1"
+version = "0.12.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.12.1 → generalmanager-0.12.2}/src/general_manager/interface/databaseBasedInterface.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 from typing import Type, Any, Callable, TYPE_CHECKING, TypeVar, Generic, cast
 from django.db import models
+
 from datetime import datetime, timedelta
 from general_manager.measurement.measurement import Measurement
 from general_manager.measurement.measurementField import MeasurementField
@@ -66,6 +67,25 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
             instance = self.getHistoricalRecord(instance, search_date)
         return instance
 
+    @staticmethod
+    def __parseKwargs(**kwargs: Any) -> dict[str, Any]:
+        """
+        Parses keyword arguments to ensure they are compatible with the model's fields.
+
+        Converts GeneralManager instances to their primary key values and returns a dictionary of parsed arguments.
+        """
+        from general_manager.manager.generalManager import GeneralManager
+
+        parsed_kwargs: dict[str, Any] = {}
+        for key, value in kwargs.items():
+            if isinstance(value, GeneralManager):
+                parsed_kwargs[key] = getattr(
+                    value._interface, "_instance", value.identification["id"]
+                )
+            else:
+                parsed_kwargs[key] = value
+        return parsed_kwargs
+
     @classmethod
     def filter(cls, **kwargs: Any) -> DatabaseBucket:
         """
@@ -77,6 +97,9 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         Returns:
             A DatabaseBucket wrapping the filtered queryset and associated metadata.
         """
+
+        kwargs = cls.__parseKwargs(**kwargs)
+
         return DatabaseBucket(
             cls._model.objects.filter(**kwargs),
             cls._parent_class,
@@ -94,6 +117,8 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         Returns:
             A DatabaseBucket wrapping the queryset of excluded model instances.
         """
+        kwargs = cls.__parseKwargs(**kwargs)
+
         return DatabaseBucket(
             cls._model.objects.exclude(**kwargs),
             cls._parent_class,
@@ -135,9 +160,9 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
         """
-        Return a dictionary mapping each attribute name of the model to its type information and metadata.
+        Return a dictionary mapping each model attribute name to its type information and metadata.
 
-        The returned dictionary includes all standard model fields, custom fields, foreign keys, many-to-many, and reverse relation fields, excluding any GenericForeignKey fields. For each attribute, the metadata specifies its Python type (translated from Django field types when possible), whether it is required, editable, derived, and its default value. For related models with a general manager class, the type is set to that class.
+        Includes standard fields, custom fields, foreign keys, many-to-many, and reverse relation fields, excluding GenericForeignKey fields. For each attribute, provides its Python type (translated from Django field types when possible), required and editable status, whether it is derived, and its default value. For related models with a general manager class, the type is set to that class.
 
         Returns:
             dict[str, AttributeTypedDict]: Mapping of attribute names to their type information and metadata.
@@ -178,7 +203,8 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                 fields[field_name] = {
                     "type": type(field),
                     "is_derived": False,
-                    "is_required": not field.null,
+                    "is_required": not field.null
+                    and field.default is models.NOT_PROVIDED,
                     "is_editable": field.editable,
                     "default": field.default,
                 }
@@ -196,7 +222,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
             ):
                 related_model = related_model._general_manager_class  # type: ignore
 
-            elif related_model is not None:
+            if related_model is not None:
                 default = None
                 if hasattr(field, "default"):
                     default = field.default  # type: ignore
@@ -247,12 +273,12 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def getAttributes(cls) -> dict[str, Callable[[DBBasedInterface], Any]]:
         """
-        Return a dictionary mapping attribute names to callables that retrieve values from a DBBasedInterface instance.
+        Return a mapping of attribute names to callables that extract values from a DBBasedInterface instance.
 
-        The mapping includes accessors for custom fields, standard model fields, foreign keys, many-to-many relations, and reverse relations. For related models with a general manager class, the accessor returns an instance of that class; otherwise, it returns the related object or queryset. Raises a ValueError if a field name conflict is detected.
+        The returned dictionary includes accessors for custom fields, standard model fields, foreign keys, many-to-many relations, and reverse relations. For related models with a general manager class, the accessor returns an instance or queryset of that class; otherwise, it returns the related object or queryset directly. Raises a ValueError if a field name conflict is detected.
 
         Returns:
-            dict: A dictionary where keys are attribute names and values are callables that extract the corresponding value from a DBBasedInterface instance.
+            dict[str, Callable[[DBBasedInterface], Any]]: Mapping of attribute names to callables for retrieving values from a DBBasedInterface instance.
         """
         from general_manager.manager.generalManager import GeneralManager
 
@@ -306,12 +332,22 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                 cls._model._meta.get_field(field_name).related_model,
                 "_general_manager_class",
             ):
+                related_model = cast(
+                    Type[models.Model],
+                    cls._model._meta.get_field(field_name).related_model,
+                )
+                related_fields = [
+                    f
+                    for f in related_model._meta.get_fields()
+                    if f.related_model == cls._model
+                ]
+
                 field_values[
                     f"{field_name}_list"
-                ] = lambda self, field_name=field_name: self._instance._meta.get_field(
+                ] = lambda self, field_name=field_name, related_fields=related_fields: self._instance._meta.get_field(
                     field_name
                 ).related_model._general_manager_class.filter(
-                    **{self._instance.__class__.__name__.lower(): self.pk}
+                    **{related_field.name: self.pk for related_field in related_fields}
                 )
             else:
                 field_values[f"{field_name}_list"] = (
@@ -319,6 +355,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                         self._instance, field_call
                     ).all()
                 )
+
         return field_values
 
     @staticmethod

{generalmanager-0.12.1 → generalmanager-0.12.2}/src/general_manager/interface/databaseInterface.py

@@ -84,19 +84,23 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         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.
+        Set many-to-many relationship fields on a model instance using provided values.
 
-        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.
+        Converts lists of `GeneralManager` instances to their corresponding IDs before updating the relationships. Returns the updated instance.
         """
+        from general_manager.manager.generalManager import GeneralManager
+
         for key, value in many_to_many_kwargs.items():
             if not value:
                 continue
-            field_name = key.split("_id_list")[0]
+            field_name = key.removesuffix("_id_list")
+            if isinstance(value, list) and all(
+                isinstance(v, GeneralManager) for v in value
+            ):
+                value = [
+                    v.identification["id"] if hasattr(v, "identification") else v
+                    for v in value
+                ]
             getattr(instance, field_name).set(value)
 
         return instance

{generalmanager-0.12.1 → generalmanager-0.12.2}/src/general_manager/interface/models.py

@@ -39,7 +39,7 @@ def getFullCleanMethode(model: Type[models.Model]) -> Callable[..., None]:
         except ValidationError as e:
             errors.update(e.message_dict)
 
-        rules: list[Rule] = getattr(self._meta, "rules")
+        rules: list[Rule] = getattr(self._meta, "rules", [])
         for rule in rules:
             if rule.evaluate(self) is False:
                 error_message = rule.getErrorMessage()