GeneralManager 0.10.5__tar.gz → 0.10.6__tar.gz

{generalmanager-0.10.5 → generalmanager-0.10.6}/GeneralManager.egg-info/PKG-INFO

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

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

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

@@ -102,9 +102,9 @@ class GraphQL:
     @classmethod
     def createGraphqlInterface(cls, generalManagerClass: GeneralManagerMeta) -> None:
         """
-        Generates and registers a GraphQL ObjectType for a given GeneralManager class.
+        Generates and registers a GraphQL ObjectType for the specified GeneralManager class.
         
-        This method maps interface and GraphQLProperty attributes to Graphene fields, creates resolvers for each field, registers the resulting type in the internal registry, and adds corresponding query fields to the schema.
+        This method maps interface attributes and GraphQLProperty fields to Graphene fields, creates appropriate resolvers, registers the resulting type in the internal registry, and adds related query fields to the schema.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -143,10 +143,12 @@ class GraphQL:
     @staticmethod
     def _sortByOptions(
         generalManagerClass: GeneralManagerMeta,
-    ) -> type[graphene.Enum]:
+    ) -> type[graphene.Enum] | None:
         """
-        Erzeugt ein Enum für Sortieroptionen basierend auf den Attributstypen der
-        Manager-Klasse.
+        Creates a Graphene Enum type representing sortable fields for a given GeneralManager class.
+        
+        Returns:
+            A Graphene Enum type with options for each sortable attribute, or None if no sortable fields exist.
         """
         sort_options = []
         for (
@@ -162,6 +164,9 @@ class GraphQL:
             else:
                 sort_options.append(field_name)
 
+        if not sort_options:
+            return None
+
         return type(
             f"{generalManagerClass.__name__}SortByOptions",
             (graphene.Enum,),
@@ -169,9 +174,13 @@ class GraphQL:
         )
 
     @staticmethod
-    def _createFilterOptions(field_name: str, field_type: GeneralManagerMeta) -> type:
+    def _createFilterOptions(
+        field_name: str, field_type: GeneralManagerMeta
+    ) -> type[graphene.InputObjectType] | None:
         """
-        Baut dynamisch ein InputObjectType für Filteroptionen auf.
+        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 options, as well as specialized handling for Measurement attributes. Returns the generated InputObjectType or None if no filter fields are applicable.
         """
         number_options = ["exact", "gt", "gte", "lt", "lte"]
         string_options = [
@@ -212,6 +221,8 @@ class GraphQL:
                         filter_fields[f"{attr_name}__{option}"] = (
                             GraphQL._mapFieldToGrapheneRead(attr_type, attr_name)
                         )
+        if not filter_fields:
+            return None
 
         filter_class = type(
             graphene_filter_type_name,
@@ -223,21 +234,32 @@ class GraphQL:
 
     @staticmethod
     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` types, returns a field with an optional `target_unit` argument. For `GeneralManager` subclasses, returns either a list field (with optional filtering, exclusion, sorting, pagination, and grouping arguments if available) or a single field, depending on the field name. For other types, returns the corresponding Graphene scalar field.
+        """
         if issubclass(field_type, Measurement):
             return graphene.Field(MeasurementType, target_unit=graphene.String())
         elif issubclass(field_type, GeneralManager):
             if field_name.endswith("_list"):
+                attributes = {
+                    "reverse": graphene.Boolean(),
+                    "page": graphene.Int(),
+                    "page_size": graphene.Int(),
+                    "group_by": graphene.List(graphene.String),
+                }
                 filter_options = GraphQL._createFilterOptions(field_name, field_type)
+                if filter_options:
+                    attributes["filter"] = filter_options()
+                    attributes["exclude"] = filter_options()
+
                 sort_by_options = GraphQL._sortByOptions(field_type)
+                if sort_by_options:
+                    attributes["sort_by"] = sort_by_options()
                 return graphene.List(
                     lambda: GraphQL.graphql_type_registry[field_type.__name__],
-                    filter=filter_options(),
-                    exclude=filter_options(),
-                    sort_by=sort_by_options(),
-                    reverse=graphene.Boolean(),
-                    page=graphene.Int(),
-                    page_size=graphene.Int(),
-                    group_by=graphene.List(graphene.String),
+                    **attributes,
                 )
             return graphene.Field(
                 lambda: GraphQL.graphql_type_registry[field_type.__name__]
@@ -348,7 +370,14 @@ class GraphQL:
         base_getter: Callable[[Any], Any], fallback_manager_class: type[GeneralManager]
     ) -> Callable[..., Any]:
         """
-        Returns a resolver function for GraphQL list fields that retrieves a queryset, applies permission-based filtering, query filters, sorting, pagination, and optional grouping, and returns the resulting data.
+        Create a resolver function for GraphQL list fields that retrieves and returns a queryset with permission filters, query filters, sorting, pagination, and optional grouping applied.
+        
+        Parameters:
+            base_getter: Function to obtain the base queryset from the parent instance.
+            fallback_manager_class: Manager class to use if the queryset does not specify one.
+        
+        Returns:
+            A resolver function that processes list queries with filtering, sorting, pagination, and grouping.
         """
 
         def resolver(
@@ -363,7 +392,7 @@ class GraphQL:
             group_by: list[str] | None = None,
         ) -> Any:
             """
-            Resolves a list field by returning a queryset filtered by permissions, query parameters, sorting, pagination, and optional grouping.
+            Resolves a list field by returning a queryset with permission filters, query filters, sorting, pagination, and optional grouping applied.
             
             Parameters:
                 filter: Filter criteria as a dictionary or JSON string.
@@ -375,7 +404,7 @@ class GraphQL:
                 group_by: List of field names to group results by.
             
             Returns:
-                A queryset with applied permission filters, filtering, sorting, pagination, and grouping.
+                The resulting queryset after applying permissions, filters, sorting, pagination, and grouping.
             """
             base_queryset = base_getter(self)
             # use _manager_class from the attribute if available, otherwise fallback
@@ -451,9 +480,9 @@ class GraphQL:
         cls, graphene_type: type, generalManagerClass: GeneralManagerMeta
     ) -> None:
         """
-        Adds list and single-item query fields for a GeneralManager-derived class to the GraphQL schema.
+        Add list and single-item query fields for a GeneralManager subclass to the GraphQL schema.
         
-        Registers a list query supporting filtering, sorting, pagination, and grouping, as well as a single-item query using identification fields for the specified manager class. The corresponding resolvers are attached to the schema.
+        Registers a list query field with optional filtering, exclusion, sorting, pagination, and grouping arguments, as well as a single-item query field using identification fields from the manager's interface. Attaches the corresponding resolvers for both queries to the schema.
         """
         if not issubclass(generalManagerClass, GeneralManager):
             raise TypeError(
@@ -465,19 +494,24 @@ class GraphQL:
 
         # resolver and field for the list query
         list_field_name = f"{generalManagerClass.__name__.lower()}_list"
+        attributes = {
+            "reverse": graphene.Boolean(),
+            "page": graphene.Int(),
+            "page_size": graphene.Int(),
+            "group_by": graphene.List(graphene.String),
+        }
         filter_options = cls._createFilterOptions(
             generalManagerClass.__name__.lower(), generalManagerClass
         )
+        if filter_options:
+            attributes["filter"] = filter_options()
+            attributes["exclude"] = filter_options()
         sort_by_options = cls._sortByOptions(generalManagerClass)
+        if sort_by_options:
+            attributes["sort_by"] = sort_by_options()
         list_field = graphene.List(
             graphene_type,
-            filter=filter_options(),
-            exclude=filter_options(),
-            sort_by=sort_by_options(),
-            reverse=graphene.Boolean(),
-            page=graphene.Int(),
-            page_size=graphene.Int(),
-            group_by=graphene.List(graphene.String),
+            **attributes,
         )
 
         list_resolver = cls._createListResolver(
@@ -519,7 +553,7 @@ class GraphQL:
         """
         Generate a dictionary of Graphene input fields for mutations based on the attributes of the provided interface class.
         
-        Skips system-managed fields and derived attributes. For attributes referencing `GeneralManager` subclasses, uses 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. Adds an optional `history_comment` field marked as editable.
+        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.
         
         Returns:
             dict[str, Any]: Mapping of attribute names to Graphene input fields for mutation arguments.
@@ -572,12 +606,12 @@ class GraphQL:
         default_return_values: dict[str, Any],
     ) -> type[graphene.Mutation] | None:
         """
-        Dynamically generates a Graphene mutation class for creating an instance of the specified GeneralManager subclass.
+        Dynamically generates a Graphene mutation class for creating an instance of a specified GeneralManager subclass.
         
-        The generated mutation class includes a `mutate` method that filters out fields with `NOT_PROVIDED` values, invokes the manager's `create` method with the provided arguments and the current user's ID, and returns a dictionary indicating success, any errors, and the created instance. Returns None if the manager class does not define an interface.
+        The generated mutation class filters out fields with `NOT_PROVIDED` values, calls the manager's `create` method with the provided arguments and the current user's ID, and returns a dictionary containing a success flag, any errors, and the created 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 for the manager class.
+            The generated Graphene mutation class, or None if the manager class does not define an interface.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -591,9 +625,9 @@ class GraphQL:
             **kwargs: Any,
         ) -> dict:
             """
-            Creates a new instance of the manager class with the provided arguments.
+            Create a new instance of the manager class using the provided arguments.
             
-            Filters out fields with values marked as `NOT_PROVIDED` before creation. Returns a dictionary containing a success flag, a list of errors (if any), and the created instance under a key named after the manager class.
+            Filters out any fields with values set to `NOT_PROVIDED` before invoking the creation method. Returns a dictionary with a success flag, a list of errors if creation fails, and the created instance keyed by the manager class name.
             """
             try:
                 kwargs = {
@@ -644,9 +678,9 @@ class GraphQL:
         default_return_values: dict[str, Any],
     ) -> type[graphene.Mutation] | None:
         """
-        Generates a GraphQL mutation class for updating instances of a GeneralManager subclass.
+        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 returns a dictionary indicating success, any errors, and the updated instance. Returns None if the manager class does not define an `Interface`.
+        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 the operation's success status, any error messages, 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.
@@ -663,14 +697,14 @@ class GraphQL:
             **kwargs: Any,
         ) -> dict:
             """
-            Performs an update mutation on a GeneralManager instance with the specified fields.
+            Updates a GeneralManager instance with the provided fields.
             
             Parameters:
                 info (GraphQLResolveInfo): The GraphQL resolver context, typically containing user and request information.
                 **kwargs: Fields to update, including the required 'id' of the instance.
             
             Returns:
-                dict: Contains the operation's success status, a list of error messages if any, and the updated instance keyed by its class name.
+                dict: A dictionary with keys 'success' (bool), 'errors' (list of str), and the updated instance keyed by its class name.
             """
             try:
                 manager_id = kwargs.pop("id", None)
@@ -716,9 +750,12 @@ class GraphQL:
         default_return_values: dict[str, Any],
     ) -> type[graphene.Mutation] | None:
         """
-        Generates a GraphQL mutation class for deleting (deactivating) an instance of a GeneralManager subclass.
+        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 the operation's success status, any error messages, and the deactivated instance keyed by the class name.
         
-        The generated mutation accepts input fields defined in the manager's interface, deactivates the specified instance using its ID, and returns a dictionary with the operation's success status, any error messages, and the deactivated instance.
+        Returns:
+            The generated Graphene mutation class, or None if the manager class does not define an interface.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -732,10 +769,13 @@ class GraphQL:
             **kwargs: Any,
         ) -> dict:
             """
-            Deactivates an instance of the specified GeneralManager class and returns the result.
+            Deactivates an instance of the specified GeneralManager class and returns the operation result.
             
             Returns:
-                dict: Contains the operation's success status, a list of error messages if any, and the deactivated instance keyed by the class name.
+                dict: A dictionary with keys:
+                    - "success": Boolean indicating if the operation was successful.
+                    - "errors": List of error messages, empty if successful.
+                    - <ClassName>: The deactivated instance, keyed by the class name.
             """
             try:
                 manager_id = kwargs.pop("id", None)

{generalmanager-0.10.5 → generalmanager-0.10.6}/src/general_manager/measurement/measurement.py

@@ -228,18 +228,18 @@ class Measurement:
 
     def __mul__(self, other: Any) -> Measurement:
         """
-        Returns the product of this measurement and another measurement or numeric value.
-
-        Multiplication between two currency measurements is not permitted. When multiplied by another measurement, the result combines their units. When multiplied by a numeric value, the magnitude is scaled and the unit remains unchanged.
-
+        Multiply this measurement by another measurement or a numeric value.
+        
+        Multiplying two currency measurements is not allowed. When multiplying by another measurement, the resulting measurement combines their units. When multiplying by a numeric value, only the magnitude is scaled.
+        
         Returns:
-            Measurement: A new Measurement representing the result.
-
+            Measurement: The result of the multiplication.
+        
         Raises:
-            TypeError: If multiplying two currency measurements or if the operand is neither a Measurement nor a numeric value.
+            TypeError: If both operands are currency measurements, or if the operand is not a Measurement or numeric value.
         """
         if isinstance(other, Measurement):
-            if self.is_currency() or other.is_currency():
+            if self.is_currency() and other.is_currency():
                 raise TypeError(
                     "Multiplication between two currency amounts is not allowed."
                 )