GeneralManager 0.12.0__tar.gz → 0.12.2__tar.gz

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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.12.0"
+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.0 → generalmanager-0.12.2}/src/general_manager/api/graphql.py

@@ -4,6 +4,7 @@ from typing import Any, Callable, get_args, TYPE_CHECKING, cast, Type
 from decimal import Decimal
 from datetime import date, datetime
 import json
+from graphql.language import ast
 
 from general_manager.measurement.measurement import Measurement
 from general_manager.manager.generalManager import GeneralManagerMeta, GeneralManager
@@ -26,6 +27,28 @@ class MeasurementType(graphene.ObjectType):
     unit = graphene.String()
 
 
+class MeasurementScalar(graphene.Scalar):
+    """
+    A measurement in format "value unit", e.g. "12.5 m/s".
+    """
+
+    @staticmethod
+    def serialize(value: Measurement) -> str:
+        if not isinstance(value, Measurement):
+            raise TypeError(f"Expected Measurement, got {type(value)}")
+        return str(value)
+
+    @staticmethod
+    def parse_value(value: str) -> Measurement:
+        return Measurement.from_string(value)
+
+    @staticmethod
+    def parse_literal(node: Any) -> Measurement | None:
+        if isinstance(node, ast.StringValueNode):
+            return Measurement.from_string(node.value)
+        return None
+
+
 class PageInfo(graphene.ObjectType):
     total_count = graphene.Int(required=True)
     page_size = graphene.Int(required=False)
@@ -38,9 +61,9 @@ def getReadPermissionFilter(
     info: GraphQLResolveInfo,
 ) -> list[tuple[dict[str, Any], dict[str, Any]]]:
     """
-    Returns a list of filter and exclude dictionaries based on the read permissions for the specified manager class and user context.
-    
-    Each tuple in the returned list contains a filter dictionary and an exclude dictionary, representing permission-based constraints to be applied to queries.
+    Returns permission-based filter and exclude constraints for querying instances of a manager class.
+
+    For the given manager class and user context, retrieves a list of (filter, exclude) dictionary pairs that represent the read access restrictions to be applied to queries. Returns an empty list if no permission class is defined.
     """
     filters = []
     PermissionClass: type[BasePermission] | None = getattr(
@@ -74,9 +97,9 @@ class GraphQL:
     @classmethod
     def createGraphqlMutation(cls, generalManagerClass: type[GeneralManager]) -> None:
         """
-        Creates and registers GraphQL mutation classes (create, update, delete) for the given manager class if its interface overrides the corresponding base methods.
-        
-        For each supported mutation, generates a GraphQL mutation class with appropriate input and output fields, and adds it to the mutation registry.
+        Generates and registers GraphQL mutation classes for create, update, and delete operations on the specified manager class if its interface provides custom implementations.
+
+        For each supported mutation, a corresponding GraphQL mutation class is created and added to the mutation registry, enabling dynamic mutation support in the schema.
         """
 
         interface_cls: InterfaceBase | None = getattr(
@@ -112,9 +135,9 @@ class GraphQL:
     @classmethod
     def createGraphqlInterface(cls, generalManagerClass: GeneralManagerMeta) -> None:
         """
-        Creates and registers a GraphQL ObjectType for the given GeneralManager subclass.
-        
-        This method introspects the manager's interface and GraphQLProperty fields, maps them to Graphene fields with appropriate resolvers, registers the resulting type in the internal registry, and adds corresponding query fields to the schema.
+        Creates and registers a GraphQL ObjectType for a GeneralManager subclass.
+
+        Introspects the manager's interface and GraphQLProperty fields, maps them to Graphene fields with appropriate resolvers, registers the resulting type in the internal registry, and adds corresponding query fields to the schema.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -155,10 +178,10 @@ class GraphQL:
         generalManagerClass: GeneralManagerMeta,
     ) -> type[graphene.Enum] | None:
         """
-        Generate a Graphene Enum type listing the sortable fields for a given GeneralManager class.
-        
+        Creates a Graphene Enum type representing sortable fields for a given GeneralManager class.
+
         Returns:
-            A Graphene Enum type with options for each sortable attribute, including separate options for the value and unit of Measurement fields, or None if no sortable fields are found.
+            A Graphene Enum type with options for each sortable attribute, including separate entries for the value and unit of Measurement fields. Returns None if there are no sortable fields.
         """
         sort_options = []
         for (
@@ -168,9 +191,6 @@ class GraphQL:
             field_type = field_info["type"]
             if issubclass(field_type, GeneralManager):
                 continue
-            elif issubclass(field_type, Measurement):
-                sort_options.append(f"{field_name}_value")
-                sort_options.append(f"{field_name}_unit")
             else:
                 sort_options.append(field_name)
 
@@ -189,8 +209,15 @@ class GraphQL:
     ) -> type[graphene.InputObjectType] | None:
         """
         Dynamically generates a Graphene InputObjectType for filtering fields of a GeneralManager subclass.
-        
+
         Creates filter fields for each attribute based on its type, supporting numeric and string filter operations, and specialized handling for Measurement attributes. Returns the generated InputObjectType, or None if no applicable filter fields exist.
+
+        Parameters:
+            field_name (str): The name of the field to generate filter options for.
+            field_type (GeneralManagerMeta): The manager class whose attributes are used to build filter fields.
+
+        Returns:
+            type[graphene.InputObjectType] | None: The generated filter input type, or None if no filter fields are applicable.
         """
         number_options = ["exact", "gt", "gte", "lt", "lte"]
         string_options = [
@@ -212,11 +239,9 @@ class GraphQL:
             if issubclass(attr_type, GeneralManager):
                 continue
             elif issubclass(attr_type, Measurement):
-                filter_fields[f"{attr_name}_value"] = graphene.Float()
-                filter_fields[f"{attr_name}_unit"] = graphene.String()
+                filter_fields[f"{attr_name}"] = MeasurementScalar()
                 for option in number_options:
-                    filter_fields[f"{attr_name}_value__{option}"] = graphene.Float()
-                    filter_fields[f"{attr_name}_unit__{option}"] = graphene.String()
+                    filter_fields[f"{attr_name}__{option}"] = MeasurementScalar()
             else:
                 filter_fields[attr_name] = GraphQL._mapFieldToGrapheneRead(
                     attr_type, attr_name
@@ -246,8 +271,8 @@ class GraphQL:
     def _mapFieldToGrapheneRead(field_type: type, field_name: str) -> Any:
         """
         Maps a Python field type and name to the appropriate Graphene field for GraphQL schema generation.
-        
-        For `Measurement` fields, returns a field with an optional `target_unit` argument. For `GeneralManager` subclasses, returns a paginated field with filtering, exclusion, sorting, pagination, and grouping arguments if the field name ends with `_list`; otherwise, returns a single object field. For all other types, returns the corresponding Graphene scalar field.
+
+        For `Measurement` fields, returns a Graphene field with an optional `target_unit` argument. For `GeneralManager` subclasses, returns a paginated field with filtering, exclusion, sorting, pagination, and grouping arguments if the field name ends with `_list`; otherwise, returns a single object field. For all other types, returns the corresponding Graphene scalar field.
         """
         if issubclass(field_type, Measurement):
             return graphene.Field(MeasurementType, target_unit=graphene.String())
@@ -299,6 +324,8 @@ class GraphQL:
             return graphene.Float
         elif issubclass(field_type, (date, datetime)):
             return graphene.Date
+        elif issubclass(field_type, Measurement):
+            return MeasurementScalar
         else:
             return graphene.String
 
@@ -325,17 +352,16 @@ class GraphQL:
         reverse: bool,
     ) -> Bucket[GeneralManager]:
         """
-        Applies filtering, exclusion, and sorting parameters to a queryset.
-        
+        Apply filtering, exclusion, and sorting to a queryset based on provided parameters.
+
         Parameters:
-            queryset (Bucket[GeneralManager]): The queryset to modify.
-            filter_input (dict | str | None): Filters to apply, as a dict or JSON string.
-            exclude_input (dict | str | None): Exclusions to apply, as a dict or JSON string.
-            sort_by (graphene.Enum | None): Field to sort by, if provided.
-            reverse (bool): Whether to reverse the sort order.
-        
+            filter_input: Filters to apply, as a dictionary or JSON string.
+            exclude_input: Exclusions to apply, as a dictionary or JSON string.
+            sort_by: Field to sort by, as a Graphene Enum value.
+            reverse: If True, reverses the sort order.
+
         Returns:
-            Bucket[GeneralManager]: The modified queryset after applying filters, exclusions, and sorting.
+            The queryset after applying filters, exclusions, and sorting.
         """
         filters = GraphQL._parseInput(filter_input)
         if filters:
@@ -389,9 +415,9 @@ class GraphQL:
         base_getter: Callable[[Any], Any], fallback_manager_class: type[GeneralManager]
     ) -> Callable[..., Any]:
         """
-        Creates a resolver for GraphQL list fields that returns paginated, filtered, sorted, and optionally grouped results with permission checks applied.
-        
-        The returned resolver processes list queries by applying permission-based filtering, user-specified filters and exclusions, sorting, grouping, and pagination. It returns a dictionary containing the paginated items and pagination metadata.
+        Creates a resolver for GraphQL list fields that returns paginated, filtered, sorted, and optionally grouped results with permission checks.
+
+        The generated resolver applies permission-based filtering, user-specified filters and exclusions, sorting, grouping, and pagination to the list field. It returns a dictionary containing the resulting items and pagination metadata.
         """
 
         def resolver(
@@ -406,19 +432,19 @@ class GraphQL:
             group_by: list[str] | None = None,
         ) -> dict[str, Any]:
             """
-            Resolves a list field by returning paginated, filtered, sorted, and optionally grouped results with permission checks applied.
-            
+            Resolves a list field by returning filtered, excluded, sorted, grouped, and paginated results with permission checks.
+
             Parameters:
-                filter (dict[str, Any] | str | None): Filter criteria as a dictionary or JSON string.
-                exclude (dict[str, Any] | str | None): Exclusion criteria as a dictionary or JSON string.
-                sort_by (graphene.Enum | None): Field to sort by.
-                reverse (bool): Whether to reverse the sort order.
-                page (int | None): Page number for pagination.
-                page_size (int | None): Number of items per page.
-                group_by (list[str] | None): List of field names to group results by.
-            
+                filter: Filter criteria as a dictionary or JSON string.
+                exclude: Exclusion criteria as a dictionary or JSON string.
+                sort_by: Field to sort by, as a Graphene Enum.
+                reverse: If True, reverses the sort order.
+                page: Page number for pagination.
+                page_size: Number of items per page.
+                group_by: List of field names to group results by.
+
             Returns:
-                dict[str, Any]: A dictionary containing the paginated items under "items" and pagination metadata under "pageInfo".
+                A dictionary containing the paginated items under "items" and pagination metadata under "pageInfo".
             """
             base_queryset = base_getter(self)
             # use _manager_class from the attribute if available, otherwise fallback
@@ -453,9 +479,16 @@ class GraphQL:
         queryset: Bucket[GeneralManager], page: int | None, page_size: int | None
     ) -> Bucket[GeneralManager]:
         """
-        Return a paginated subset of the queryset based on the specified page number and page size.
-        
-        If either `page` or `page_size` is provided, pagination is applied; otherwise, the original queryset is returned.
+        Returns a paginated subset of the queryset based on the given page number and page size.
+
+        If neither `page` nor `page_size` is provided, the entire queryset is returned. Defaults to page 1 and page size 10 if only one parameter is specified.
+
+        Parameters:
+            page (int | None): The page number to retrieve (1-based).
+            page_size (int | None): The number of items per page.
+
+        Returns:
+            Bucket[GeneralManager]: The paginated queryset.
         """
         if page is not None or page_size is not None:
             page = page or 1
@@ -469,8 +502,8 @@ class GraphQL:
         queryset: Bucket[GeneralManager], group_by: list[str] | None
     ) -> Bucket[GeneralManager]:
         """
-        Group a queryset by the specified fields.
-        
+        Groups the queryset by the specified fields.
+
         If `group_by` is `[""]`, groups by all default fields. If `group_by` is a list of field names, groups by those fields. Returns the grouped queryset.
         """
         if group_by is not None:
@@ -483,13 +516,9 @@ class GraphQL:
     @staticmethod
     def _createMeasurementResolver(field_name: str) -> Callable[..., Any]:
         """
-        Creates a resolver function for Measurement fields that returns the value and unit, optionally converting to a specified target unit.
-        
-        Parameters:
-            field_name (str): The name of the Measurement field to resolve.
-        
-        Returns:
-            Callable[..., dict[str, Any] | None]: A resolver that returns a dictionary with 'value' and 'unit' keys, or None if permission is denied or the field is not a Measurement.
+        Creates a resolver for a Measurement field that returns its value and unit, with optional unit conversion.
+
+        The generated resolver checks read permissions for the specified field. If permitted and the field is a Measurement, it returns a dictionary containing the measurement's value and unit, converting to the specified target unit if provided. Returns None if permission is denied or the field is not a Measurement.
         """
 
         def resolver(
@@ -527,9 +556,9 @@ class GraphQL:
     @classmethod
     def _createResolver(cls, field_name: str, field_type: type) -> Callable[..., Any]:
         """
-        Selects and returns the appropriate resolver function for a given field based on its type and name.
-        
-        For fields ending with `_list` and referencing a `GeneralManager` subclass, returns a list resolver supporting pagination and filtering. For `Measurement` fields, returns a measurement resolver. For all other fields, returns a standard resolver.
+        Returns a resolver function for a field, selecting list, measurement, or standard resolution based on the field's type and name.
+
+        For fields ending with `_list` referencing a `GeneralManager` subclass, provides a resolver supporting pagination and filtering. For `Measurement` fields, returns a resolver that handles unit conversion and permission checks. For all other fields, returns a standard resolver with permission enforcement.
         """
         if field_name.endswith("_list") and issubclass(field_type, GeneralManager):
             return cls._createListResolver(
@@ -546,13 +575,9 @@ class GraphQL:
         item_type: type[graphene.ObjectType] | Callable[[], type[graphene.ObjectType]],
     ) -> type[graphene.ObjectType]:
         """
-        Return a paginated GraphQL ObjectType for the given item type, creating and caching it if it does not already exist.
-        
-        Parameters:
-            page_type_name (str): The name to use for the paginated type.
-        
-        Returns:
-            type[graphene.ObjectType]: A GraphQL ObjectType with `items` (list of item_type) and `pageInfo` (pagination metadata).
+        Returns a paginated GraphQL ObjectType for the specified item type, creating and caching it if it does not already exist.
+
+        The returned ObjectType includes an `items` field (a required list of the item type) and a `pageInfo` field (pagination metadata).
         """
         if page_type_name not in cls._page_type_registry:
             cls._page_type_registry[page_type_name] = type(
@@ -571,8 +596,8 @@ class GraphQL:
     ) -> None:
         """
         Adds paginated list and single-item query fields for a GeneralManager subclass to the GraphQL schema.
-        
-        The list query field supports filtering, exclusion, sorting, pagination, and grouping, returning a paginated result with metadata. The single-item query field retrieves an instance by its identification fields. Both queries are registered with their corresponding resolvers.
+
+        The list query field enables filtering, exclusion, sorting, pagination, and grouping, returning a paginated result with metadata. The single-item query field retrieves an instance by its identification fields. Both queries are registered with their respective resolvers.
         """
         if not issubclass(generalManagerClass, GeneralManager):
             raise TypeError(
@@ -642,10 +667,10 @@ class GraphQL:
     @classmethod
     def createWriteFields(cls, interface_cls: InterfaceBase) -> dict[str, Any]:
         """
-        Generate a dictionary of Graphene input fields for mutations based on the attributes of the provided interface class.
-        
-        Skips system-managed and derived attributes. For attributes referencing `GeneralManager` subclasses, uses an ID or list of IDs as appropriate. Other types are mapped to their corresponding Graphene scalar types. Each field is annotated with an `editable` attribute. An optional `history_comment` field, also marked as editable, is always included.
-        
+        Generates a dictionary of Graphene input fields for mutations based on the attributes of the provided interface class.
+
+        Skips system-managed and derived attributes. For attributes referencing `GeneralManager` subclasses, uses an ID or list of IDs as appropriate. Other types are mapped to their corresponding Graphene scalar types. Each field is annotated with an `editable` attribute. Always includes an optional `history_comment` field marked as editable.
+
         Returns:
             dict[str, Any]: Mapping of attribute names to Graphene input fields for mutation arguments.
         """
@@ -698,11 +723,11 @@ class GraphQL:
     ) -> type[graphene.Mutation] | None:
         """
         Dynamically generates a Graphene mutation class for creating an instance of a specified GeneralManager subclass.
-        
-        The generated mutation class accepts input fields defined by the manager's interface, filters out fields with `NOT_PROVIDED` values, and calls the manager's `create` method with the provided arguments and the current user's ID. If creation succeeds, it returns a dictionary with a success flag and the created instance; if an error occurs, a GraphQL error is raised. Returns None if the manager class does not define an interface.
-        
+
+        The generated mutation class uses the manager's interface to define input arguments, filters out fields with `NOT_PROVIDED` values, and invokes the manager's `create` method with the provided data and the current user's ID. On success, it returns a dictionary with a success flag and the created instance; on failure, it raises a GraphQL error. Returns `None` if the manager class does not define an interface.
+
         Returns:
-            The generated Graphene mutation class, or None if the manager class does not define an interface.
+            The generated Graphene mutation class, or `None` if the manager class does not define an interface.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -716,9 +741,9 @@ class GraphQL:
             **kwargs: Any,
         ) -> dict:
             """
-            Creates a new instance of the manager class with the provided arguments.
-            
-            Filters out fields set to `NOT_PROVIDED` before creation. Returns a dictionary containing a success flag and the created instance keyed by the manager class name. Raises a GraphQL error if creation fails.
+            Creates a new instance of the manager class using the provided arguments.
+
+            Filters out any fields set to `NOT_PROVIDED` before invoking the creation method. Returns a dictionary with a success flag and the created instance keyed by the manager class name. If creation fails, raises a GraphQL error and returns a dictionary with `success` set to `False`.
             """
             try:
                 kwargs = {
@@ -769,11 +794,11 @@ class GraphQL:
     ) -> type[graphene.Mutation] | None:
         """
         Generates a GraphQL mutation class for updating an instance of a GeneralManager subclass.
-        
-        The generated mutation accepts editable fields as arguments, invokes the manager's `update` method with the provided values and the current user's ID, and returns a dictionary containing the operation's success status and the updated instance. If the manager class does not define an `Interface`, returns None.
-        
+
+        The generated mutation accepts editable fields as arguments, calls the manager's `update` method with the provided values and the current user's ID, and returns a dictionary containing a success flag and the updated instance. Returns `None` if the manager class does not define an `Interface`.
+
         Returns:
-            The generated Graphene mutation class, or None if no interface is defined.
+            The generated Graphene mutation class, or `None` if no interface is defined.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -787,14 +812,14 @@ class GraphQL:
             **kwargs: Any,
         ) -> dict:
             """
-            Updates an instance of the specified GeneralManager class with the provided field values.
-            
+            Updates an instance of a GeneralManager subclass with the specified field values.
+
             Parameters:
-                info (GraphQLResolveInfo): The GraphQL resolver context, containing user and request information.
-                **kwargs: Fields to update, including the required 'id' of the instance.
-            
+                info (GraphQLResolveInfo): The GraphQL resolver context, including user and request data.
+                **kwargs: Field values to update, including the required 'id' of the instance.
+
             Returns:
-                dict: Contains 'success' (bool) and the updated instance keyed by its class name.
+                dict: A dictionary with 'success' (bool) and the updated instance keyed by its class name.
             """
             try:
                 manager_id = kwargs.pop("id", None)
@@ -841,9 +866,9 @@ class GraphQL:
     ) -> type[graphene.Mutation] | None:
         """
         Generates a GraphQL mutation class for deactivating (soft-deleting) an instance of a GeneralManager subclass.
-        
-        The generated mutation accepts input fields defined by the manager's interface, deactivates the specified instance using its ID, and returns a dictionary containing a success status and the deactivated instance keyed by the class name. If the manager class does not define an interface, returns None.
-        
+
+        The generated mutation accepts input fields defined by the manager's interface, deactivates the specified instance using its ID, and returns a dictionary containing a success status and the deactivated instance keyed by the class name. Returns None if the manager class does not define an interface.
+
         Returns:
             The generated Graphene mutation class, or None if no interface is defined.
         """
@@ -859,14 +884,10 @@ class GraphQL:
             **kwargs: Any,
         ) -> dict:
             """
-            Deactivates an instance of the specified GeneralManager class and returns the result.
-            
-            Parameters:
-                info (GraphQLResolveInfo): GraphQL resolver context containing user information.
-                **kwargs: Arguments including the instance ID to deactivate.
-            
+            Deactivates an instance of a GeneralManager subclass and returns the operation result.
+
             Returns:
-                dict: Contains "success" (bool) and the deactivated instance keyed by its class name.
+                dict: A dictionary with a "success" boolean and the deactivated instance keyed by its class name.
             """
             try:
                 manager_id = kwargs.pop("id", None)
@@ -908,9 +929,9 @@ class GraphQL:
     @staticmethod
     def _handleGraphQLError(error: Exception) -> None:
         """
-        Raises a GraphQLError with an appropriate error code based on the type of exception.
-        
-        If the error is a PermissionError, the code is set to "PERMISSION_DENIED". For ValueError or ValidationError, the code is "BAD_USER_INPUT". All other exceptions result in a code of "INTERNAL_SERVER_ERROR".
+        Raises a GraphQLError with a specific error code based on the exception type.
+
+        PermissionError results in "PERMISSION_DENIED", ValueError or ValidationError in "BAD_USER_INPUT", and all other exceptions in "INTERNAL_SERVER_ERROR".
         """
         if isinstance(error, PermissionError):
             raise GraphQLError(

{generalmanager-0.12.0 → 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.0 → 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.0 → 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()