GeneralManager 0.11.2__py3-none-any.whl → 0.12.1__py3-none-any.whl

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
@@ -11,6 +12,10 @@ from general_manager.api.property import GraphQLProperty
 from general_manager.bucket.baseBucket import Bucket
 from general_manager.interface.baseInterface import InterfaceBase
 from django.db.models import NOT_PROVIDED
+from django.core.exceptions import ValidationError
+
+from graphql import GraphQLError
+
 
 if TYPE_CHECKING:
     from general_manager.permission.basePermission import BasePermission
@@ -22,13 +27,43 @@ 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)
+    current_page = graphene.Int(required=True)
+    total_pages = graphene.Int(required=True)
+
+
 def getReadPermissionFilter(
     generalManagerClass: GeneralManagerMeta,
     info: GraphQLResolveInfo,
 ) -> list[tuple[dict[str, Any], dict[str, Any]]]:
     """
-    Ermittelt die Filter, die auf Basis der read-Permission für den angegebenen
-    Manager angewendet werden müssen.
+    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(
@@ -55,17 +90,16 @@ class GraphQL:
     _mutation_class: type[graphene.ObjectType] | None = None
     _mutations: dict[str, Any] = {}
     _query_fields: dict[str, Any] = {}
+    _page_type_registry: dict[str, type[graphene.ObjectType]] = {}
     graphql_type_registry: dict[str, type] = {}
     graphql_filter_type_registry: dict[str, type] = {}
 
     @classmethod
     def createGraphqlMutation(cls, generalManagerClass: type[GeneralManager]) -> None:
         """
-        Erzeugt ein GraphQL-Mutation-Interface für die übergebene Manager-Klasse.
-        Dabei werden:
-          - Attribute aus dem Interface in Graphene-Felder abgebildet
-          - Zu jedem Feld ein Resolver generiert und hinzugefügt
-          - Der neue Type in das Registry eingetragen und Mutationen angehängt.
+        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(
@@ -76,7 +110,6 @@ class GraphQL:
 
         default_return_values = {
             "success": graphene.Boolean(),
-            "errors": graphene.List(graphene.String),
             generalManagerClass.__name__: graphene.Field(
                 lambda: GraphQL.graphql_type_registry[generalManagerClass.__name__]
             ),
@@ -102,9 +135,9 @@ class GraphQL:
     @classmethod
     def createGraphqlInterface(cls, generalManagerClass: GeneralManagerMeta) -> None:
         """
-        Generates and registers a GraphQL ObjectType for the specified GeneralManager class.
-        
-        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.
+        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
@@ -146,9 +179,9 @@ class GraphQL:
     ) -> type[graphene.Enum] | None:
         """
         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.
+            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 (
@@ -158,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)
 
@@ -179,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 options, as well as specialized handling for Measurement attributes. Returns the generated InputObjectType or None if no filter fields are applicable.
+
+        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 = [
@@ -202,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
@@ -236,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` 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.
+
+        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())
@@ -257,6 +292,13 @@ class GraphQL:
                 sort_by_options = GraphQL._sortByOptions(field_type)
                 if sort_by_options:
                     attributes["sort_by"] = sort_by_options()
+
+                page_type = GraphQL._getOrCreatePageType(
+                    field_type.__name__ + "Page",
+                    lambda: GraphQL.graphql_type_registry[field_type.__name__],
+                )
+                return graphene.Field(page_type, **attributes)
+
                 return graphene.List(
                     lambda: GraphQL.graphql_type_registry[field_type.__name__],
                     **attributes,
@@ -282,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
 
@@ -306,11 +350,18 @@ class GraphQL:
         exclude_input: dict[str, Any] | str | None,
         sort_by: graphene.Enum | None,
         reverse: bool,
-        page: int | None,
-        page_size: int | None,
     ) -> Bucket[GeneralManager]:
         """
-        Wendet Filter, Excludes, Sortierung und Paginierung auf das Queryset an.
+        Apply filtering, exclusion, and sorting to a queryset based on provided parameters.
+
+        Parameters:
+            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:
+            The queryset after applying filters, exclusions, and sorting.
         """
         filters = GraphQL._parseInput(filter_input)
         if filters:
@@ -324,12 +375,6 @@ class GraphQL:
             sort_by_str = cast(str, getattr(sort_by, "value", sort_by))
             queryset = queryset.sort(sort_by_str, reverse=reverse)
 
-        if page is not None or page_size is not None:
-            page = page or 1
-            page_size = page_size or 10
-            offset = (page - 1) * page_size
-            queryset = cast(Bucket, queryset[offset : offset + page_size])
-
         return queryset
 
     @staticmethod
@@ -370,14 +415,9 @@ class GraphQL:
         base_getter: Callable[[Any], Any], fallback_manager_class: type[GeneralManager]
     ) -> Callable[..., Any]:
         """
-        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.
+        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(
@@ -390,21 +430,21 @@ class GraphQL:
             page: int | None = None,
             page_size: int | None = None,
             group_by: list[str] | None = None,
-        ) -> Any:
+        ) -> dict[str, Any]:
             """
-            Resolves a list field by returning a queryset with permission filters, query filters, sorting, pagination, and optional grouping applied.
-            
+            Resolves a list field by returning filtered, excluded, sorted, grouped, and paginated results with permission checks.
+
             Parameters:
                 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: Whether to reverse the sort order.
+                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:
-                The resulting queryset after applying permissions, filters, sorting, pagination, and grouping.
+                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
@@ -412,22 +452,73 @@ class GraphQL:
                 base_queryset, "_manager_class", fallback_manager_class
             )
             qs = GraphQL._applyPermissionFilters(base_queryset, manager_class, info)
-            qs = GraphQL._applyQueryParameters(
-                qs, filter, exclude, sort_by, reverse, page, page_size
-            )
-            if group_by is not None:
-                if group_by == [""]:
-                    qs = qs.group_by()
-                else:
-                    qs = qs.group_by(*group_by)
-            return qs
+            qs = GraphQL._applyQueryParameters(qs, filter, exclude, sort_by, reverse)
+            qs = GraphQL._applyGrouping(qs, group_by)
+
+            total_count = len(qs)
+
+            qs_paginated = GraphQL._applyPagination(qs, page, page_size)
+
+            page_info = {
+                "total_count": total_count,
+                "page_size": page_size,
+                "current_page": page or 1,
+                "total_pages": (
+                    ((total_count + page_size - 1) // page_size) if page_size else 1
+                ),
+            }
+            return {
+                "items": qs_paginated,
+                "pageInfo": page_info,
+            }
 
         return resolver
 
+    @staticmethod
+    def _applyPagination(
+        queryset: Bucket[GeneralManager], page: int | None, page_size: int | None
+    ) -> Bucket[GeneralManager]:
+        """
+        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
+            page_size = page_size or 10
+            offset = (page - 1) * page_size
+            queryset = cast(Bucket, queryset[offset : offset + page_size])
+        return queryset
+
+    @staticmethod
+    def _applyGrouping(
+        queryset: Bucket[GeneralManager], group_by: list[str] | None
+    ) -> Bucket[GeneralManager]:
+        """
+        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:
+            if group_by == [""]:
+                queryset = queryset.group_by()
+            else:
+                queryset = queryset.group_by(*group_by)
+        return queryset
+
     @staticmethod
     def _createMeasurementResolver(field_name: str) -> Callable[..., Any]:
         """
-        Erzeugt einen Resolver für Felder vom Typ 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(
@@ -465,7 +556,9 @@ class GraphQL:
     @classmethod
     def _createResolver(cls, field_name: str, field_type: type) -> Callable[..., Any]:
         """
-        Wählt anhand des Feldtyps den passenden Resolver aus.
+        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(
@@ -475,14 +568,36 @@ class GraphQL:
             return cls._createMeasurementResolver(field_name)
         return cls._createNormalResolver(field_name)
 
+    @classmethod
+    def _getOrCreatePageType(
+        cls,
+        page_type_name: str,
+        item_type: type[graphene.ObjectType] | Callable[[], type[graphene.ObjectType]],
+    ) -> type[graphene.ObjectType]:
+        """
+        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(
+                page_type_name,
+                (graphene.ObjectType,),
+                {
+                    "items": graphene.List(item_type, required=True),
+                    "pageInfo": graphene.Field(PageInfo, required=True),
+                },
+            )
+        return cls._page_type_registry[page_type_name]
+
     @classmethod
     def _addQueriesToSchema(
         cls, graphene_type: type, generalManagerClass: GeneralManagerMeta
     ) -> None:
         """
-        Add list and single-item query fields for a GeneralManager subclass to the GraphQL 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.
+        Adds paginated list and single-item query fields for a GeneralManager subclass to the GraphQL schema.
+
+        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(
@@ -509,10 +624,11 @@ class GraphQL:
         sort_by_options = cls._sortByOptions(generalManagerClass)
         if sort_by_options:
             attributes["sort_by"] = sort_by_options()
-        list_field = graphene.List(
-            graphene_type,
-            **attributes,
+
+        page_type = cls._getOrCreatePageType(
+            graphene_type.__name__ + "Page", graphene_type
         )
+        list_field = graphene.Field(page_type, **attributes)
 
         list_resolver = cls._createListResolver(
             lambda self: generalManagerClass.all(), generalManagerClass
@@ -551,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.
         """
@@ -607,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 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.
-        
+
+        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
@@ -625,9 +741,9 @@ class GraphQL:
             **kwargs: Any,
         ) -> dict:
             """
-            Create a new instance of the manager class using the provided arguments.
-            
-            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.
+            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 = {
@@ -639,14 +755,13 @@ class GraphQL:
                     **kwargs, creator_id=info.context.user.id
                 )
             except Exception as e:
+                GraphQL._handleGraphQLError(e)
                 return {
                     "success": False,
-                    "errors": [str(e)],
                 }
 
             return {
                 "success": True,
-                "errors": [],
                 generalManagerClass.__name__: instance,
             }
 
@@ -679,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, 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`.
-        
+
+        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
@@ -697,14 +812,14 @@ class GraphQL:
             **kwargs: Any,
         ) -> dict:
             """
-            Updates a GeneralManager instance with the provided fields.
-            
+            Updates an instance of a GeneralManager subclass with the specified field values.
+
             Parameters:
-                info (GraphQLResolveInfo): The GraphQL resolver context, typically 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: A dictionary with keys 'success' (bool), 'errors' (list of str), 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)
@@ -712,13 +827,13 @@ class GraphQL:
                     creator_id=info.context.user.id, **kwargs
                 )
             except Exception as e:
+                GraphQL._handleGraphQLError(e)
                 return {
                     "success": False,
-                    "errors": [str(e)],
                 }
+
             return {
                 "success": True,
-                "errors": [],
                 generalManagerClass.__name__: instance,
             }
 
@@ -751,11 +866,11 @@ 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 the operation's success status, any error messages, and the deactivated instance keyed by the class name.
-        
+
+        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 the manager class does not define an interface.
+            The generated Graphene mutation class, or None if no interface is defined.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -769,13 +884,10 @@ class GraphQL:
             **kwargs: Any,
         ) -> dict:
             """
-            Deactivates an instance of the specified GeneralManager class and returns the operation result.
-            
+            Deactivates an instance of a GeneralManager subclass and returns the operation result.
+
             Returns:
-                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.
+                dict: A dictionary with a "success" boolean and the deactivated instance keyed by its class name.
             """
             try:
                 manager_id = kwargs.pop("id", None)
@@ -783,13 +895,13 @@ class GraphQL:
                     creator_id=info.context.user.id
                 )
             except Exception as e:
+                GraphQL._handleGraphQLError(e)
                 return {
                     "success": False,
-                    "errors": [str(e)],
                 }
+
             return {
                 "success": True,
-                "errors": [],
                 generalManagerClass.__name__: instance,
             }
 
@@ -813,3 +925,32 @@ class GraphQL:
                 "mutate": delete_mutation,
             },
         )
+
+    @staticmethod
+    def _handleGraphQLError(error: Exception) -> None:
+        """
+        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(
+                str(error),
+                extensions={
+                    "code": "PERMISSION_DENIED",
+                },
+            )
+        elif isinstance(error, (ValueError, ValidationError)):
+            raise GraphQLError(
+                str(error),
+                extensions={
+                    "code": "BAD_USER_INPUT",
+                },
+            )
+        else:
+            raise GraphQLError(
+                str(error),
+                extensions={
+                    "code": "INTERNAL_SERVER_ERROR",
+                },
+            )

general_manager/api/mutation.py

@@ -21,19 +21,23 @@ from general_manager.permission.mutationPermission import MutationPermission
 
 def graphQlMutation(permission: Optional[Type[MutationPermission]] = None):
     """
-    Decorator that transforms a function into a GraphQL mutation class and registers it for use in a Graphene-based API.
-
-    The decorated function must have type hints for all parameters (except `info`) and a return annotation. The decorator dynamically generates a mutation class with arguments and output fields based on the function's signature and return type. It also enforces authentication if `auth_required` is set to True, returning an error if the user is not authenticated.
-
+    Decorator that converts a function into a GraphQL mutation class for use with Graphene, automatically generating argument and output fields from the function's signature and type annotations.
+    
+    The decorated function must provide type hints for all parameters (except `info`) and a return annotation. The decorator dynamically constructs a mutation class with appropriate Graphene fields, enforces permission checks if a `permission` class is provided, and registers the mutation for use in the GraphQL API.
+    
     Parameters:
-        needs_role (Optional[str]): Reserved for future use to specify a required user role.
-        auth_required (bool): If True, the mutation requires an authenticated user.
-
+        permission (Optional[Type[MutationPermission]]): An optional permission class to enforce access control on the mutation.
+    
     Returns:
         Callable: A decorator that registers the mutation and returns the original function.
     """
 
     def decorator(fn):
+        """
+        Decorator that transforms a function into a GraphQL mutation class compatible with Graphene.
+        
+        Analyzes the decorated function's signature and type hints to dynamically generate a mutation class with appropriate argument and output fields. Handles permission checks if a permission class is provided, manages mutation execution, and registers the mutation for use in the GraphQL API. On success, returns output fields and a `success` flag; on error, returns only `success=False`.
+        """
         sig = inspect.signature(fn)
         hints = get_type_hints(fn)
 
@@ -86,10 +90,9 @@ def graphQlMutation(permission: Optional[Type[MutationPermission]] = None):
 
         Arguments = type("Arguments", (), arg_fields)
 
-        # Build output fields: success, errors, + fn return types
+        # Build output fields: success + fn return types
         outputs = {
             "success": graphene.Boolean(required=True),
-            "errors": graphene.List(graphene.String),
         }
         return_ann: type | tuple[type] | None = hints.get("return")
         if return_ann is None:
@@ -120,28 +123,35 @@ def graphQlMutation(permission: Optional[Type[MutationPermission]] = None):
         # Define mutate method
         def _mutate(root, info, **kwargs):
 
+            """
+            Handles the execution of a GraphQL mutation, including permission checks, result unpacking, and error handling.
+            
+            Returns:
+                An instance of the mutation class with output fields populated from the mutation result and a success status.
+            """
             if permission:
                 permission.check(kwargs, info.context.user)
             try:
                 result = fn(info, **kwargs)
                 data = {}
                 if isinstance(result, tuple):
-                    # unpack according to outputs ordering after success/errors
+                    # unpack according to outputs ordering after success
                     for (field, _), val in zip(
-                        outputs.items(), [None, None] + list(result)
+                        outputs.items(),
+                        [None, *list(result)],  # None for success field to be set later
                     ):
-                        # skip success/errors
-                        if field in ("success", "errors"):
+                        # skip success
+                        if field == "success":
                             continue
                         data[field] = val
                 else:
-                    only = next(k for k in outputs if k not in ("success", "errors"))
+                    only = next(k for k in outputs if k != "success")
                     data[only] = result
                 data["success"] = True
-                data["errors"] = []
                 return mutation_class(**data)
             except Exception as e:
-                return mutation_class(**{"success": False, "errors": [str(e)]})
+                GraphQL._handleGraphQLError(e)
+                return mutation_class(**{"success": False})
 
         # Assemble class dict
         class_dict = {

general_manager/measurement/measurement.py

@@ -22,20 +22,18 @@ for currency in currency_units:
 class Measurement:
     def __init__(self, value: Decimal | float | int | str, unit: str):
         """
-        Create a Measurement with the specified numeric value and unit.
-
-        Parameters:
-            value: The numeric value to associate with the unit. Accepts Decimal, float, int, or a string convertible to Decimal.
-            unit: The unit of measurement as a string.
-
+        Initialize a Measurement with a numeric value and unit.
+        
+        Converts the provided value to a Decimal and associates it with the specified unit, creating a unit-aware measurement.
+        
         Raises:
-            TypeError: If the value cannot be converted to a Decimal.
+            ValueError: If the value cannot be converted to a Decimal.
         """
         if not isinstance(value, (Decimal, float, int)):
             try:
                 value = Decimal(str(value))
             except Exception:
-                raise TypeError("Value must be a Decimal, float, int or compatible.")
+                raise ValueError("Value must be a Decimal, float, int or compatible.")
         if not isinstance(value, Decimal):
             value = Decimal(str(value))
         self.__quantity = ureg.Quantity(self.formatDecimal(value), unit)
@@ -230,13 +228,13 @@ class Measurement:
         """
         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.
+        Multiplication between 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: The result of the multiplication.
+            Measurement: The product as a new Measurement instance.
         
         Raises:
-            TypeError: If both operands are currency measurements, or if the operand is not a Measurement or numeric value.
+            TypeError: If both operands are currency measurements, or if the operand is neither a Measurement nor a numeric value.
         """
         if isinstance(other, Measurement):
             if self.is_currency() and other.is_currency():
@@ -306,17 +304,19 @@ class Measurement:
 
     def _compare(self, other: Any, operation: Callable[..., bool]) -> bool:
         """
-        Compares this Measurement to another using a specified comparison operation.
-
-        If `other` is a string, it is parsed as a Measurement. The comparison is performed after converting `other` to this instance's unit. Raises a TypeError if `other` is not a Measurement or a valid string, and a ValueError if the measurements have incompatible dimensions.
-
+        Compare this Measurement to another using a specified comparison operation.
+        
+        If `other` is a string, it is parsed as a Measurement. Returns `False` if `other` is `None` or an empty value. Raises `TypeError` if `other` is not a Measurement or a valid string. Raises `ValueError` if the measurements have incompatible dimensions.
+        
         Parameters:
-            other: The object to compare, either a Measurement or a string in the format "value unit".
-            operation: A callable that takes two magnitudes and returns a boolean.
-
+            other: The object to compare, which can be a Measurement instance or a string in the format "value unit".
+            operation: A callable that takes two magnitudes and returns a boolean result.
+        
         Returns:
-            bool: The result of the comparison.
+            bool: The result of applying the comparison operation to the magnitudes.
         """
+        if other is None or other in ("", [], (), {}):
+            return False
         if isinstance(other, str):
             other = Measurement.from_string(other)
 

general_manager/measurement/measurementField.py

@@ -1,168 +1,271 @@
-# fields.py
 from __future__ import annotations
+
 from django.db import models
 from django.core.exceptions import ValidationError
+from django.db.models.expressions import Col
 from decimal import Decimal
-from general_manager.measurement.measurement import Measurement, ureg, currency_units
 import pint
-from typing import Any
+from general_manager.measurement.measurement import Measurement, ureg, currency_units
 
 
-class MeasurementField(models.Field):  # type: ignore
-    description = (
-        "A field that stores a measurement value, both in base unit and original unit"
-    )
+class MeasurementField(models.Field):
+    description = "Stores a measurement (value + unit) but exposes a single field API"
+
+    empty_values = (None, "", [], (), {})
 
     def __init__(
-        self,
-        base_unit: str,
-        null: bool = False,
-        blank: bool = False,
-        editable: bool = True,
-        *args: Any,
-        **kwargs: Any,
+        self, base_unit: str, *args, null=False, blank=False, editable=True, **kwargs
     ):
         """
-        Initialize a MeasurementField to store values in a specified base unit and retain the original unit.
-        
+        Initialize a MeasurementField to store a numeric value and its unit with unit-aware validation.
+
         Parameters:
-            base_unit (str): The canonical unit in which values are stored (e.g., 'meter').
-            null (bool, optional): Whether the field allows NULL values.
-            blank (bool, optional): Whether the field allows blank values.
-            editable (bool, optional): Whether the field is editable in Django admin and forms.
-        
-        The field internally manages a DecimalField for the value (in the base unit) and a CharField for the original unit.
-        """
-        self.base_unit = base_unit  # E.g., 'meter' for length units
-        # Determine the dimensionality of the base unit
+            base_unit (str): The canonical unit for the measurement, used for conversions and validation.
+            null (bool, optional): Whether the field allows NULL values. Defaults to False.
+            blank (bool, optional): Whether the field allows blank values. Defaults to False.
+            editable (bool, optional): Whether the field is editable in forms and admin. Defaults to True.
+
+        The field internally manages a DecimalField for the value and a CharField for the unit, both configured according to the provided options.
+        """
+        self.base_unit = base_unit
         self.base_dimension = ureg.parse_expression(self.base_unit).dimensionality
-        # Internal fields
-        null_blank_kwargs = {}
-        if null is True:
-            null_blank_kwargs["null"] = True
-        if blank is True:
-            null_blank_kwargs["blank"] = True
+
+        nb = {}
+        if null:
+            nb["null"] = True
+        if blank:
+            nb["blank"] = True
+
         self.editable = editable
-        self.value_field: models.DecimalField[Decimal] = models.DecimalField(
-            max_digits=30,
-            decimal_places=10,
-            db_index=True,
-            **null_blank_kwargs,
-            editable=editable,
+        self.value_field = models.DecimalField(
+            max_digits=30, decimal_places=10, db_index=True, editable=editable, **nb
         )
-        self.unit_field: models.CharField[str] = models.CharField(
-            max_length=30, **null_blank_kwargs, editable=editable
-        )
-        super().__init__(null=null, blank=blank, *args, **kwargs)
+        self.unit_field = models.CharField(max_length=30, editable=editable, **nb)
 
-    def contribute_to_class(
-        self, cls: type, name: str, private_only: bool = False, **kwargs: Any
-    ) -> None:
+        super().__init__(*args, null=null, blank=blank, editable=editable, **kwargs)
+
+    def contribute_to_class(self, cls, name, private_only=False, **kwargs):
+        # Register myself first (so opts.get_field('height') works)
         """
-        Integrates the MeasurementField into the Django model class, setting up internal fields for value and unit storage.
-        
-        This method assigns unique attribute names for the value and unit fields, attaches them to the model, and sets the descriptor for the custom field on the model class.
+        Registers the MeasurementField with the model class and attaches internal value and unit fields.
+
+        This method sets up the composite field by creating and adding separate fields for the numeric value and unit to the model class, ensuring they are not duplicated. It also overrides the model attribute with the MeasurementField descriptor itself to manage access and assignment.
         """
-        self.name = name
+        super().contribute_to_class(cls, name, private_only=private_only, **kwargs)
+        self.concrete = False
+        self.column = None  # type: ignore # will not be set in db
+        self.field = self
+
         self.value_attr = f"{name}_value"
         self.unit_attr = f"{name}_unit"
-        self.value_field.attname = self.value_attr
-        self.unit_field.attname = self.unit_attr
-        self.value_field.name = self.value_attr
-        self.unit_field.name = self.unit_attr
-        self.value_field.column = self.value_attr
-        self.unit_field.column = self.unit_attr
 
-        self.value_field.model = cls
-        self.unit_field.model = cls
+        # prevent duplicate attributes
+        if hasattr(cls, self.value_attr):
+            self.value_field = getattr(cls, self.value_attr).field
+        else:
+            self.value_field.set_attributes_from_name(self.value_attr)
+            self.value_field.contribute_to_class(cls, self.value_attr)
+
+        if hasattr(cls, self.unit_attr):
+            self.unit_field = getattr(cls, self.unit_attr).field
+        else:
+            self.unit_field.set_attributes_from_name(self.unit_attr)
+            self.unit_field.contribute_to_class(cls, self.unit_attr)
 
-        self.value_field.contribute_to_class(cls, self.value_attr)
-        self.unit_field.contribute_to_class(cls, self.unit_attr)
+        # Descriptor override
+        setattr(cls, name, self)
 
-        setattr(cls, self.name, self)
+    # ---- ORM Delegation ----
+    def get_col(self, alias, output_field=None):
+        """
+        Returns a Django ORM column expression for the internal value field, enabling queries on the numeric part of the measurement.
+        """
+        return Col(alias, self.value_field, output_field or self.value_field)  # type: ignore
+
+    def get_lookup(self, lookup_name):
+        """
+        Return the lookup class for the specified lookup name, delegating to the internal value field.
+
+        Parameters:
+                lookup_name (str): The name of the lookup to retrieve.
+
+        Returns:
+                The lookup class corresponding to the given name, as provided by the internal decimal value field.
+        """
+        return self.value_field.get_lookup(lookup_name)
+
+    def get_transform(self, lookup_name) -> models.Transform | None:
+        """
+        Delegates retrieval of a transform operation to the internal value field.
+
+        Returns:
+            The transform corresponding to the given lookup name, or None if not found.
+        """
+        return self.value_field.get_transform(lookup_name)
+
+    def db_type(self, connection) -> None:  # type: ignore
+        """
+        Return None to indicate that MeasurementField does not correspond to a single database column.
+
+        This field manages its data using separate internal fields and does not require a direct database type.
+        """
+        return None
+
+    def run_validators(self, value: Measurement | None) -> None:
+        """
+        Runs all validators on the provided Measurement value if it is not None.
+
+        Parameters:
+            value (Measurement | None): The measurement to validate, or None to skip validation.
+        """
+        if value is None:
+            return
+        for v in self.validators:
+            v(value)
+
+    def clean(
+        self, value: Measurement | None, model_instance: models.Model | None = None
+    ) -> Measurement | None:
+        """
+        Validates and cleans a Measurement value for use in the model field.
+
+        Runs field-level validation and all configured validators on the provided value, returning it unchanged if valid.
+
+        Parameters:
+            value (Measurement | None): The measurement value to validate and clean.
+            model_instance (models.Model | None): The model instance this value is associated with, if any.
 
-    def __get__(self, instance: Any, owner: Any) -> Any:
+        Returns:
+            Measurement | None: The validated measurement value, or None if the input was None.
+        """
+        self.validate(value, model_instance)
+        self.run_validators(value)
+        return value
+
+    def to_python(self, value):
+        """
+        Returns the input value unchanged.
+
+        This method is required by Django custom fields to convert database values to Python objects, but no conversion is performed for this field.
+        """
+        return value
+
+    def get_prep_value(self, value):
+        """
+        Prepare a value for database storage by converting a Measurement to its decimal magnitude in the base unit.
+
+        If the input is a string, it is parsed into a Measurement. If the value cannot be converted to the base unit due to dimensionality mismatch, a ValidationError is raised. Only Measurement instances or None are accepted.
+
+        Returns:
+            Decimal: The numeric value of the measurement in the base unit, or None if the input is None.
+
+        Raises:
+            ValidationError: If the value is not a Measurement or cannot be converted to the base unit.
+        """
+        if value is None:
+            return None
+        if isinstance(value, str):
+            value = Measurement.from_string(value)
+        if isinstance(value, Measurement):
+            try:
+                return Decimal(str(value.quantity.to(self.base_unit).magnitude))
+            except pint.errors.DimensionalityError as e:
+                raise ValidationError(
+                    {self.name: [f"Unit must be compatible with '{self.base_unit}'."]}
+                ) from e
+        raise ValidationError(
+            {self.name: ["Value must be a Measurement instance or None."]}
+        )
+
+    # ------------ Descriptor ------------
+    def __get__(  # type: ignore
+        self, instance: models.Model | None, owner: None = None
+    ) -> MeasurementField | Measurement | None:
+        """
+        Retrieve the measurement value from the model instance, reconstructing it as a `Measurement` object with the stored unit.
+
+        Returns:
+            Measurement: The measurement with its original unit if both value and unit are present.
+            None: If either the value or unit is missing.
+            MeasurementField: If accessed from the class rather than an instance.
+        """
         if instance is None:
             return self
-        value = getattr(instance, self.value_attr)
+        val = getattr(instance, self.value_attr)
         unit = getattr(instance, self.unit_attr)
-        if value is None or unit is None:
+        if val is None or unit is None:
             return None
-        # Create a Measurement object with the value in the original unit
-        quantity_in_base_unit = Decimal(value) * ureg(self.base_unit)
-        # Convert back to the original unit
+        qty_base = Decimal(val) * ureg(self.base_unit)
         try:
-            quantity_in_original_unit: pint.Quantity = quantity_in_base_unit.to(unit)  # type: ignore
+            qty_orig = qty_base.to(unit)
         except pint.errors.DimensionalityError:
-            # If the unit is not compatible, return the value in base unit
-            quantity_in_original_unit = quantity_in_base_unit
-        return Measurement(
-            quantity_in_original_unit.magnitude, str(quantity_in_original_unit.units)
-        )
+            qty_orig = qty_base
+        return Measurement(qty_orig.magnitude, str(qty_orig.units))
 
-    def __set__(self, instance: Any, value: Any) -> None:
-        if self.editable is False:
+    def __set__(self, instance, value):
+        """
+        Assigns a measurement value to the model instance, validating type, unit compatibility, and editability.
+
+        If the value is a string, attempts to parse it as a Measurement. Ensures the unit matches the expected base unit's dimensionality or currency status. Stores the numeric value (converted to the base unit) and the original unit string in the instance. Raises ValidationError if the value is invalid or incompatible.
+        """
+        if not self.editable:
             raise ValidationError(f"{self.name} is not editable.")
         if value is None:
             setattr(instance, self.value_attr, None)
             setattr(instance, self.unit_attr, None)
             return
-        elif isinstance(value, str):
+        if isinstance(value, str):
             try:
                 value = Measurement.from_string(value)
-            except ValueError:
+            except ValueError as e:
                 raise ValidationError(
                     {self.name: ["Value must be a Measurement instance or None."]}
-                )
-        if isinstance(value, Measurement):
-            if str(self.base_unit) in currency_units:
-                # Base unit is a currency
-                if not value.is_currency():
-                    raise ValidationError(
-                        {
-                            self.name: [
-                                f"The unit must be a currency ({', '.join(currency_units)})."
-                            ]
-                        }
-                    )
-            else:
-                # Physical unit
-                if value.is_currency():
-                    raise ValidationError(
-                        {self.name: ["The unit cannot be a currency."]}
-                    )
-                elif value.quantity.dimensionality != self.base_dimension:
-                    raise ValidationError(
-                        {
-                            self.name: [
-                                f"The unit must be compatible with '{self.base_unit}'."
-                            ]
-                        }
-                    )
-            # Store the value in the base unit
-            try:
-                value_in_base_unit: Any = value.quantity.to(self.base_unit).magnitude  # type: ignore
-            except pint.errors.DimensionalityError:
+                ) from e
+        if not isinstance(value, Measurement):
+            raise ValidationError(
+                {self.name: ["Value must be a Measurement instance or None."]}
+            )
+
+        if str(self.base_unit) in currency_units:
+            if not value.is_currency():
                 raise ValidationError(
                     {
                         self.name: [
-                            f"The unit must be compatible with '{self.base_unit}'."
+                            f"Unit must be a currency ({', '.join(currency_units)})."
                         ]
                     }
                 )
-            setattr(instance, self.value_attr, Decimal(str(value_in_base_unit)))
-            # Store the original unit
-            setattr(instance, self.unit_attr, str(value.quantity.units))
         else:
+            if value.is_currency():
+                raise ValidationError({self.name: ["Unit cannot be a currency."]})
+
+        try:
+            base_mag = value.quantity.to(self.base_unit).magnitude
+        except pint.errors.DimensionalityError as e:
             raise ValidationError(
-                {self.name: ["Value must be a Measurement instance or None."]}
-            )
+                {self.name: [f"Unit must be compatible with '{self.base_unit}'."]}
+            ) from e
 
-    def get_prep_value(self, value: Any) -> Any:
-        # Not needed since we use internal fields
-        pass
+        setattr(instance, self.value_attr, Decimal(str(base_mag)))
+        setattr(instance, self.unit_attr, str(value.quantity.units))
+
+    def validate(
+        self, value: Measurement | None, model_instance: models.Model | None = None
+    ) -> None:
+        """
+        Validates a measurement value against null and blank constraints and applies all field validators.
+
+        Raises:
+            ValidationError: If the value is None and the field does not allow nulls, or if the value is blank and the field does not allow blanks, or if any validator fails.
+        """
+        if value is None:
+            if not self.null:
+                raise ValidationError(self.error_messages["null"], code="null")
+            return
+        if value in ("", [], (), {}):
+            if not self.blank:
+                raise ValidationError(self.error_messages["blank"], code="blank")
+            return
 
-    def deconstruct(self):
-        name, path, args, kwargs = super().deconstruct()
-        kwargs["base_unit"] = self.base_unit
-        return name, path, args, kwargs
+        for validator in self.validators:
+            validator(value)

{generalmanager-0.11.2.dist-info → generalmanager-0.12.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.11.2
+Version: 0.12.1
 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.11.2.dist-info → generalmanager-0.12.1.dist-info}/RECORD

@@ -1,7 +1,7 @@
 general_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 general_manager/apps.py,sha256=ii-48klC2kBRjxtdQU9-RtPq66lZ8fDa7BmqyH-mbzk,9904
-general_manager/api/graphql.py,sha256=jpdtaep_ql94krsVvGJRpuqT-MR6iZCFpezeJAl4Mlw,33382
-general_manager/api/mutation.py,sha256=41BvkY4qYU_Kq2R6GUK14AnU7sSTydw4tSw1f4CAlxI,5954
+general_manager/api/graphql.py,sha256=FyukDVM3doDAcD_TTeGkrIIHtsMqTEDX5Opa-hUZcrk,39351
+general_manager/api/mutation.py,sha256=9T892INzH4ip5sX3_BxB2WX145zt8S_0HGVPhGzyXZA,6736
 general_manager/api/property.py,sha256=oc93p1P8dcIvrNorRuqD1EJVsd6eYttYhZuAS0s28gs,696
 general_manager/bucket/baseBucket.py,sha256=UjEai7cVxgDJysoVY2-7s3YULW7bi-sx2mPqRKFWyTw,7728
 general_manager/bucket/calculationBucket.py,sha256=a41YVdfhxKf_gpWlRKjXYmS1YuO-6VC0hn60RyLKByU,18777
@@ -29,8 +29,8 @@ general_manager/manager/groupManager.py,sha256=8dpZUfm7aFL4lraUWv4qbbDRClQZaYxw4
 general_manager/manager/input.py,sha256=-pJXGJ-g2-OxZfl4Buj3mQkf05fN4p8MsR2Lh9BQcEo,3208
 general_manager/manager/meta.py,sha256=-9celpo-oZmkTb8TnHfvcd_4XWTy1cn2UO-jp13NFmQ,6387
 general_manager/measurement/__init__.py,sha256=X97meFujBldE5v0WMF7SmKeGpC5R0JTczfLo_Lq1Xek,84
-general_manager/measurement/measurement.py,sha256=T3R2qqDkqPY_91DzN0zJF4ug62aCNyN5-75WE9Tm7ko,16067
-general_manager/measurement/measurementField.py,sha256=ixkZR_t--HGckK2iYi6sXOOa_Vbni4QRxK5Ngmy5YKc,6863
+general_manager/measurement/measurement.py,sha256=wrxwbmaKOUuvwyDa6wUZ5t2mF2mTtXdy6urzA7Q7k_M,16169
+general_manager/measurement/measurementField.py,sha256=hesh8YMQqBuX-thcMUcawHpQWEKUqRapn-3tbNgvoPA,11466
 general_manager/permission/__init__.py,sha256=5UlDERN60Vn8obGVkT-cOM8kHjzmoxgK5w5FgTCDhGE,59
 general_manager/permission/basePermission.py,sha256=DeiAX2sQQhtdquO13jys2MSkp0kPdg2oo7PSqB9q5Bw,5653
 general_manager/permission/fileBasedPermission.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -51,8 +51,8 @@ general_manager/utils/makeCacheKey.py,sha256=UlFsxHXgsYy69AAelkF6GDvY4h7AImT2bBn
 general_manager/utils/noneToZero.py,sha256=KfQtMQnrT6vsYST0K7lv6pVujkDcK3XL8czHYOhgqKQ,539
 general_manager/utils/pathMapping.py,sha256=nrz5owQg2a69Yig1eCXorR9U0NSw7NmBAk5OkeoHTdA,6842
 general_manager/utils/testing.py,sha256=ElZ8p4iZHxsHjDN8Lm5TmI6527CW747ltDOmtY6gAhk,11872
-generalmanager-0.11.2.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
-generalmanager-0.11.2.dist-info/METADATA,sha256=zj1UfC74gZUgz9inrRIBqx2FAw0_UlXdxt_Iu-mvCyE,6206
-generalmanager-0.11.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-generalmanager-0.11.2.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
-generalmanager-0.11.2.dist-info/RECORD,,
+generalmanager-0.12.1.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.12.1.dist-info/METADATA,sha256=SdQ9KGXGoKes7mp8Rw1HhyJKCJzh__AlOCyRZSBBwW4,6206
+generalmanager-0.12.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+generalmanager-0.12.1.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.12.1.dist-info/RECORD,,