GeneralManager 0.9.1__py3-none-any.whl → 0.10.1__py3-none-any.whl

general_manager/api/mutation.py

@@ -5,19 +5,19 @@ import graphene
 from general_manager.api.graphql import GraphQL
 from general_manager.manager.generalManager import GeneralManager
 
-from general_manager.auxiliary.formatString import snake_to_camel
+from general_manager.utils.formatString import snake_to_camel
 
 
 def graphQlMutation(needs_role: Optional[str] = None, auth_required: bool = False):
     """
     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.
-    
+
     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.
-    
+
     Returns:
         Callable: A decorator that registers the mutation and returns the original function.
     """

general_manager/apps.py

@@ -30,7 +30,7 @@ class GeneralmanagerConfig(AppConfig):
     def ready(self):
         """
         Performs initialization tasks for the general_manager app when Django starts.
-        
+
         Sets up synchronization and schema validation for read-only interfaces, initializes attributes and property accessors for general manager classes, and configures the GraphQL schema and endpoint if enabled in settings.
         """
         self.handleReadOnlyInterface(GeneralManagerMeta.read_only_classes)
@@ -47,7 +47,7 @@ class GeneralmanagerConfig(AppConfig):
     ):
         """
         Configures synchronization and schema validation for the provided read-only interface classes.
-        
+
         Ensures that each read-only interface is synchronized before Django management commands run, and registers system checks to validate that their schemas are up to date.
         """
         GeneralmanagerConfig.patchReadOnlyInterfaceSync(read_only_classes)
@@ -72,7 +72,7 @@ class GeneralmanagerConfig(AppConfig):
     ):
         """
         Monkey-patches Django's management command runner to synchronize all provided read-only interfaces before executing any management command, except during autoreload subprocesses of 'runserver'.
-        
+
         For each class in `general_manager_classes`, the associated read-only interface's `syncData` method is called prior to command execution, ensuring data consistency before management operations.
         """
         from general_manager.interface.readOnlyInterface import ReadOnlyInterface
@@ -83,10 +83,10 @@ class GeneralmanagerConfig(AppConfig):
             # Ensure syncData is only called at real run of runserver
             """
             Executes a Django management command, synchronizing all registered read-only interfaces before execution unless running in an autoreload subprocess of 'runserver'.
-            
+
             Parameters:
                 argv (list): Command-line arguments for the management command.
-            
+
             Returns:
                 The result of the original management command execution.
             """
@@ -113,7 +113,7 @@ class GeneralmanagerConfig(AppConfig):
     ):
         """
         Initializes attributes and establishes dynamic relationships for GeneralManager classes.
-        
+
         For each class pending attribute initialization, assigns interface attributes and creates property accessors. Then, for all registered GeneralManager classes, connects input fields referencing other GeneralManager subclasses by adding GraphQL properties to enable filtered access to related objects.
         """
         logger.debug("Initializing GeneralManager classes...")
@@ -144,6 +144,8 @@ class GeneralmanagerConfig(AppConfig):
                         f"{general_manager_class.__name__.lower()}_list",
                         graphQlProperty(func),
                     )
+        for general_manager_class in all_classes:
+            GeneralmanagerConfig.checkPermissionClass(general_manager_class)
 
     @staticmethod
     def handleGraphQL(
@@ -177,10 +179,10 @@ class GeneralmanagerConfig(AppConfig):
     def addGraphqlUrl(schema):
         """
         Adds a GraphQL endpoint to the Django URL configuration using the provided schema.
-        
+
         Parameters:
             schema: The GraphQL schema to use for the endpoint.
-        
+
         Raises:
             Exception: If the ROOT_URLCONF setting is not defined in Django settings.
         """
@@ -196,3 +198,24 @@ class GeneralmanagerConfig(AppConfig):
                 GraphQLView.as_view(graphiql=True, schema=schema),
             )
         )
+
+    @staticmethod
+    def checkPermissionClass(general_manager_class: Type[GeneralManager]):
+        """
+        Checks if the class has a Permission attribute and if it is a subclass of BasePermission.
+        If so, it sets the Permission attribute on the class.
+        """
+        from general_manager.permission.basePermission import BasePermission
+        from general_manager.permission.managerBasedPermission import (
+            ManagerBasedPermission,
+        )
+
+        if hasattr(general_manager_class, "Permission"):
+            permission = general_manager_class.Permission
+            if not issubclass(permission, BasePermission):
+                raise TypeError(
+                    f"{permission.__name__} must be a subclass of BasePermission"
+                )
+            general_manager_class.Permission = permission
+        else:
+            general_manager_class.Permission = ManagerBasedPermission

general_manager/bucket/calculationBucket.py

@@ -15,10 +15,11 @@ from general_manager.interface.baseInterface import (
 )
 from general_manager.bucket.baseBucket import Bucket
 from general_manager.manager.input import Input
-from general_manager.auxiliary.filterParser import parse_filters
+from general_manager.utils.filterParser import parse_filters
 
 if TYPE_CHECKING:
     from general_manager.manager.generalManager import GeneralManager
+    from general_manager.interface.calculationInterface import CalculationInterface
 
 
 class CalculationBucket(Bucket[GeneralManagerType]):
@@ -90,7 +91,11 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         self._current_combinations = state.get("current_combinations")
 
     def __or__(
-        self, other: Bucket[GeneralManagerType] | GeneralManager[GeneralManagerType]
+        self,
+        other: (
+            Bucket[GeneralManagerType]
+            | GeneralManager[GeneralManagerType, CalculationInterface]
+        ),
     ) -> CalculationBucket[GeneralManagerType]:
         """
         Combines this CalculationBucket with another bucket or manager of the same type.
@@ -158,7 +163,7 @@ class CalculationBucket(Bucket[GeneralManagerType]):
     def filter(self, **kwargs: Any) -> CalculationBucket:
         """
         Returns a new CalculationBucket with additional filters applied.
-        
+
         Merges the provided filter criteria with existing filters to further restrict valid input combinations.
         """
         filters = self.filters.copy()
@@ -316,12 +321,12 @@ class CalculationBucket(Bucket[GeneralManagerType]):
     ) -> List[dict[str, Any]]:
         """
         Recursively generates all valid input combinations for the specified input fields, applying filters and exclusions.
-        
+
         Args:
             sorted_inputs: Input field names ordered to respect dependency constraints.
             filters: Mapping of input field names to filter definitions.
             excludes: Mapping of input field names to exclusion definitions.
-        
+
         Returns:
             A list of dictionaries, each representing a valid combination of input values that satisfy all filters and exclusions.
         """
@@ -329,7 +334,7 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         def helper(index, current_combo):
             """
             Recursively generates all valid input combinations for calculation inputs.
-            
+
             Yields:
                 Dict[str, Any]: A dictionary representing a valid combination of input values, filtered and excluded according to the provided criteria.
             """

general_manager/cache/cacheDecorator.py

@@ -4,7 +4,7 @@ from django.core.cache import cache as django_cache
 from general_manager.cache.cacheTracker import DependencyTracker
 from general_manager.cache.dependencyIndex import record_dependencies, Dependency
 from general_manager.cache.modelDependencyCollector import ModelDependencyCollector
-from general_manager.auxiliary.makeCacheKey import make_cache_key
+from general_manager.utils.makeCacheKey import make_cache_key
 
 
 class CacheBackend(Protocol):

general_manager/interface/baseInterface.py

@@ -13,7 +13,7 @@ from typing import (
 from datetime import datetime
 from django.conf import settings
 from django.db.models import Model
-from general_manager.auxiliary import args_to_kwargs
+from general_manager.utils import args_to_kwargs
 
 if TYPE_CHECKING:
     from general_manager.manager.input import Input

general_manager/interface/databaseBasedInterface.py

@@ -52,7 +52,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     ):
         """
         Initialize the interface and load the associated model instance.
-        
+
         If `search_date` is provided, loads the historical record as of that date; otherwise, loads the current record.
         """
         super().__init__(*args, **kwargs)
@@ -141,9 +141,9 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
         """
         Return a dictionary mapping attribute names to metadata describing their types and properties.
-        
+
         The dictionary includes all model fields, custom fields, foreign keys, many-to-many, and reverse relation 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.
-        
+
         Returns:
             dict[str, AttributeTypedDict]: Mapping of attribute names to their type information and metadata.
         """
@@ -309,7 +309,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         model: Type[models.Model] | models.Model,
     ) -> tuple[list[str], list[str]]:
         """
-        Identifies custom fields on a model and their associated auxiliary fields to ignore.
+        Identifies custom fields on a model and their associated utils fields to ignore.
 
         Returns:
             A tuple containing a list of custom field names and a list of related field names
@@ -401,15 +401,15 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         # Felder aus der Interface-Klasse sammeln
         """
         Dynamically generates a Django model class, its associated interface class, and a factory class from an interface definition.
-        
+
         This method collects fields and metadata from the provided interface class, creates a new Django model inheriting from the specified base model class, attaches custom validation rules if present, and constructs corresponding interface and factory classes. The updated attributes dictionary, the new interface class, and the newly created model class are returned for integration into the general manager framework.
-        
+
         Parameters:
             name: The name for the dynamically created model class.
             attrs: The attributes dictionary to be updated with the new interface and factory classes.
             interface: The interface base class defining the model structure and metadata.
             base_model_class: The base class to use for the new model (defaults to GeneralManagerModel).
-        
+
         Returns:
             tuple: A tuple containing the updated attributes dictionary, the new interface class, and the newly created model class.
         """

general_manager/interface/databaseInterface.py

@@ -9,6 +9,7 @@ from general_manager.interface.databaseBasedInterface import (
     DBBasedInterface,
     GeneralManagerModel,
 )
+from django.db.models import NOT_PROVIDED
 
 
 class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
@@ -111,6 +112,8 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
             if isinstance(value, GeneralManager):
                 value = value.identification["id"]
                 key = f"{key}_id"
+            if value is NOT_PROVIDED:
+                continue
             try:
                 setattr(instance, key, value)
             except ValueError as e:
@@ -158,8 +161,8 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         """
         instance.changed_by_id = creator_id
         instance.full_clean()
+        instance.save()
         if history_comment:
             update_change_reason(instance, history_comment)
-        instance.save()
 
         return instance.pk

general_manager/manager/generalManager.py

@@ -20,12 +20,13 @@ class GeneralManager(
     Generic[GeneralManagerType, InterfaceType], metaclass=GeneralManagerMeta
 ):
     Interface: Type[InterfaceType]
+    Permission: Type[BasePermission]
     _attributes: dict[str, Any]
 
     def __init__(self, *args: Any, **kwargs: Any):
         """
         Initialize the manager by creating an interface instance with the provided arguments and storing its identification.
-        
+
         The identification is registered with the dependency tracker for tracking purposes.
         """
         self._interface = self.Interface(*args, **kwargs)
@@ -55,9 +56,9 @@ class GeneralManager(
     ) -> Bucket[GeneralManagerType]:
         """
         Combine this manager with another manager of the same class or a Bucket using the union operator.
-        
+
         If combined with a Bucket, returns the union of the Bucket and this manager. If combined with another manager of the same class, returns a Bucket containing both instances. Raises a TypeError for unsupported types.
-        
+
         Returns:
             Bucket[GeneralManagerType]: A Bucket containing the union of the involved managers.
         """
@@ -93,20 +94,19 @@ class GeneralManager(
     ) -> GeneralManager[GeneralManagerType, InterfaceType]:
         """
         Creates a new managed object using the underlying interface and returns a corresponding manager instance.
-        
+
         Performs a permission check if a `Permission` class is defined and permission checks are not ignored. Passes all provided arguments to the interface's `create` method.
-        
+
         Parameters:
             creator_id (int | None): Optional identifier for the creator of the object.
             history_comment (str | None): Optional comment for audit or history tracking.
             ignore_permission (bool): If True, skips the permission check.
-        
+
         Returns:
             GeneralManager[GeneralManagerType, InterfaceType]: A new manager instance for the created object.
         """
-        Permission: Type[BasePermission] | None = getattr(cls, "Permission", None)
-        if Permission is not None and not ignore_permission:
-            Permission.checkCreatePermission(kwargs, cls, creator_id)
+        if not ignore_permission:
+            cls.Permission.checkCreatePermission(kwargs, cls, creator_id)
         identification = cls.Interface.create(
             creator_id=creator_id, history_comment=history_comment, **kwargs
         )
@@ -122,19 +122,18 @@ class GeneralManager(
     ) -> GeneralManager[GeneralManagerType, InterfaceType]:
         """
         Update the underlying interface object with new data and return a new manager instance.
-        
+
         Parameters:
             creator_id (int | None): Optional identifier for the user performing the update.
             history_comment (str | None): Optional comment describing the update.
             ignore_permission (bool): If True, skips permission checks.
             **kwargs: Additional fields to update on the interface object.
-        
+
         Returns:
             GeneralManager[GeneralManagerType, InterfaceType]: A new manager instance reflecting the updated object.
         """
-        Permission: Type[BasePermission] | None = getattr(self, "Permission", None)
-        if Permission is not None and not ignore_permission:
-            Permission.checkUpdatePermission(kwargs, self, creator_id)
+        if not ignore_permission:
+            self.Permission.checkUpdatePermission(kwargs, self, creator_id)
         self._interface.update(
             creator_id=creator_id,
             history_comment=history_comment,
@@ -151,18 +150,17 @@ class GeneralManager(
     ) -> GeneralManager[GeneralManagerType, InterfaceType]:
         """
         Deactivates the underlying interface object and returns a new manager instance.
-        
+
         Parameters:
             creator_id (int | None): Optional identifier for the user performing the deactivation.
             history_comment (str | None): Optional comment describing the reason for deactivation.
             ignore_permission (bool): If True, skips permission checks.
-        
+
         Returns:
             GeneralManager[GeneralManagerType, InterfaceType]: A new instance representing the deactivated object.
         """
-        Permission: Type[BasePermission] | None = getattr(self, "Permission", None)
-        if Permission is not None and not ignore_permission:
-            Permission.checkDeletePermission(self, creator_id)
+        if not ignore_permission:
+            self.Permission.checkDeletePermission(self, creator_id)
         self._interface.deactivate(
             creator_id=creator_id, history_comment=history_comment
         )
@@ -190,12 +188,12 @@ class GeneralManager(
     def __parse_identification(kwargs: dict[str, Any]) -> dict[str, Any] | None:
         """
         Return a dictionary with all GeneralManager instances in the input replaced by their identification dictionaries.
-        
+
         For each key-value pair in the input, any GeneralManager instance is replaced by its identification. Lists and tuples are processed recursively, substituting contained GeneralManager instances with their identifications. Returns None if the resulting dictionary is empty.
-        
+
         Parameters:
             kwargs (dict[str, Any]): Dictionary to process.
-        
+
         Returns:
             dict[str, Any] | None: Processed dictionary with identifications, or None if empty.
         """

general_manager/manager/meta.py

@@ -26,9 +26,9 @@ class GeneralManagerMeta(type):
     def __new__(mcs, name: str, bases: tuple[type, ...], attrs: dict[str, Any]) -> type:
         """
         Creates a new class using the metaclass, integrating interface hooks and registering the class for attribute initialization and tracking.
-        
+
         If the class definition includes an `Interface` attribute, validates it as a subclass of `InterfaceBase`, applies pre- and post-creation hooks from the interface, and registers the resulting class for attribute initialization and management. Regardless of interface presence, the new class is tracked for pending GraphQL interface creation.
-        
+
         Returns:
             The newly created class, potentially augmented with interface integration and registration logic.
         """
@@ -38,7 +38,7 @@ class GeneralManagerMeta(type):
         ) -> Type[GeneralManager]:
             """
             Create a new GeneralManager class using the standard metaclass instantiation process.
-            
+
             Returns:
                 The newly created GeneralManager subclass.
             """
@@ -59,6 +59,7 @@ class GeneralManagerMeta(type):
 
         else:
             new_class = createNewGeneralManagerClass(mcs, name, bases, attrs)
+
         if getattr(settings, "AUTOCREATE_GRAPHQL", False):
             mcs.pending_graphql_interfaces.append(new_class)
 
@@ -70,7 +71,7 @@ class GeneralManagerMeta(type):
     ):
         """
         Dynamically assigns property descriptors to a class for each specified attribute name.
-        
+
         For each attribute, creates a descriptor that:
         - Returns the field type from the class's interface when accessed on the class.
         - Retrieves the value from the instance's `_attributes` dictionary when accessed on an instance.
@@ -81,9 +82,10 @@ class GeneralManagerMeta(type):
         def desciptorMethod(attr_name: str, new_class: type):
             """
             Creates a property descriptor for an attribute, enabling dynamic access and callable resolution.
-            
+
             When accessed on the class, returns the field type from the associated interface. When accessed on an instance, retrieves the attribute value from the instance's `_attributes` dictionary, invoking it with the instance's interface if the value is callable. Raises `AttributeError` if the attribute is missing or if a callable attribute raises an exception.
             """
+
             class Descriptor(Generic[GeneralManagerType]):
                 def __init__(self, attr_name: str, new_class: Type[GeneralManager]):
                     self.attr_name = attr_name

general_manager/measurement/measurement.py

@@ -22,12 +22,12 @@ for currency in currency_units:
 class Measurement:
     def __init__(self, value: Decimal | float | int | str, unit: str):
         """
-        Initialize a Measurement instance with a numeric value and unit.
-        
+        Create a Measurement with the specified numeric value and unit.
+
         Parameters:
-            value (Decimal | float | int | str): The numeric value to be associated with the unit. Can be a Decimal, float, int, or a string convertible to Decimal.
-            unit (str): The unit of measurement as a string.
-        
+            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.
+
         Raises:
             TypeError: If the value cannot be converted to a Decimal.
         """
@@ -42,10 +42,10 @@ class Measurement:
 
     def __getstate__(self):
         """
-        Return a serializable state dictionary containing the magnitude and unit of the measurement.
-        
+        Return a dictionary representing the serializable state of the measurement, including its magnitude and unit as strings.
+
         Returns:
-            dict: A dictionary with 'magnitude' as a string and 'unit' as a string, suitable for pickling or other serialization.
+            dict: Contains 'magnitude' and 'unit' keys for serialization purposes.
         """
         state = {
             "magnitude": str(self.magnitude),
@@ -55,10 +55,10 @@ class Measurement:
 
     def __setstate__(self, state):
         """
-        Restore the Measurement object from a serialized state dictionary.
-        
+        Restore the Measurement object from a serialized state.
+
         Parameters:
-            state (dict): A dictionary containing 'magnitude' as a string and 'unit' as a string.
+            state (dict): Dictionary with 'magnitude' (as a string) and 'unit' (as a string) representing the measurement.
         """
         value = Decimal(state["magnitude"])
         unit = state["unit"]
@@ -82,16 +82,15 @@ class Measurement:
     @classmethod
     def from_string(cls, value: str) -> Measurement:
         """
-        Parse a string of the form 'value unit' and return a Measurement instance.
-        
-        Parameters:
-            value (str): String containing a numeric value and a unit, separated by a space (e.g., '10.5 kg').
-        
+        Creates a Measurement instance from a string containing a numeric value and a unit.
+
+        If the string contains only a value, it is treated as dimensionless. If the string contains both a value and a unit separated by a space, both are used to construct the Measurement. Raises ValueError if the format is invalid or the value cannot be parsed.
+
         Returns:
-            Measurement: The corresponding Measurement object.
-        
+            Measurement: The constructed Measurement object.
+
         Raises:
-            ValueError: If the input string does not contain exactly two parts separated by a space.
+            ValueError: If the string format is invalid or the value cannot be parsed as a number.
         """
         splitted = value.split(" ")
         if len(splitted) == 1:
@@ -118,19 +117,19 @@ class Measurement:
 
     def to(self, target_unit: str, exchange_rate: float | None = None):
         """
-        Convert the measurement to a specified target unit, handling both currency and physical unit conversions.
-        
-        For currency units, an explicit exchange rate must be provided if converting between different currencies; otherwise, the original measurement is returned. For physical units, standard unit conversion is performed using the underlying unit registry.
-        
+        Convert this measurement to a specified target unit, supporting both currency and physical unit conversions.
+
+        For currency conversions between different currencies, an explicit exchange rate must be provided; if converting to the same currency, the original measurement is returned. For physical units, standard unit conversion is performed using the unit registry.
+
         Parameters:
-            target_unit (str): The unit to convert the measurement to.
-            exchange_rate (float, optional): The exchange rate to use for currency conversion. Required if converting between different currencies.
-        
+            target_unit (str): The unit to convert to.
+            exchange_rate (float, optional): Required for currency conversion between different currencies.
+
         Returns:
-            Measurement: A new Measurement instance in the target unit.
-        
+            Measurement: The converted measurement in the target unit.
+
         Raises:
-            ValueError: If converting between different currencies without providing an exchange rate.
+            ValueError: If converting between different currencies without an exchange rate.
         """
         if self.is_currency():
             if self.unit == ureg(target_unit):
@@ -159,10 +158,10 @@ class Measurement:
 
     def __add__(self, other: Any) -> Measurement:
         """
-        Add two Measurement instances, supporting both currency and physical units.
-        
-        Addition is allowed only if both operands are currencies of the same unit or both are physical units with compatible dimensions. Raises a TypeError if operands are of different types (currency vs. physical unit) or not Measurement instances, and raises a ValueError if units are incompatible.
-        
+        Add this measurement to another, supporting both currency and physical units.
+
+        Addition is permitted only if both operands are currencies of the same unit or both are physical units with compatible dimensions. Raises a TypeError if operands are of different types (currency vs. physical unit) or not Measurement instances, and raises a ValueError if units are incompatible.
+
         Returns:
             Measurement: A new Measurement representing the sum.
         """
@@ -198,11 +197,11 @@ class Measurement:
     def __sub__(self, other: Any) -> Measurement:
         """
         Subtracts another Measurement from this one, enforcing unit compatibility.
-        
-        Subtraction is allowed only between two currencies of the same unit or two physical units with compatible dimensions. Raises a TypeError if the operand is not a Measurement or if attempting to subtract a currency from a physical unit (or vice versa). Raises a ValueError if subtracting different currencies or incompatible physical units.
-        
+
+        Subtraction is permitted only between two currency measurements of the same unit or two physical measurements with compatible dimensions. Raises a TypeError if the operand is not a Measurement or if subtracting between a currency and a physical unit. Raises a ValueError if subtracting different currencies or incompatible physical units.
+
         Returns:
-            Measurement: The result of the subtraction as a new Measurement instance.
+            Measurement: A new Measurement representing the result of the subtraction.
         """
         if not isinstance(other, Measurement):
             raise TypeError(
@@ -229,15 +228,15 @@ class Measurement:
 
     def __mul__(self, other: Any) -> Measurement:
         """
-        Multiply this measurement by another measurement or a numeric value.
-        
-        Multiplication between two currency measurements is not allowed. If multiplied by another measurement, returns a new Measurement with the combined units. If multiplied by a numeric value, returns a new Measurement with the same unit and scaled magnitude.
-        
+        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.
+
         Returns:
-            Measurement: The result of the multiplication as a new Measurement instance.
-        
+            Measurement: A new Measurement representing the result.
+
         Raises:
-            TypeError: If attempting to multiply two currency measurements or if the operand is not a Measurement or numeric value.
+            TypeError: If multiplying two currency measurements or if the operand is neither a Measurement nor a numeric value.
         """
         if isinstance(other, Measurement):
             if self.is_currency() or other.is_currency():
@@ -261,15 +260,22 @@ class Measurement:
     def __truediv__(self, other: Any) -> Measurement:
         """
         Divide this measurement by another measurement or a numeric value.
-        
-        If dividing by another `Measurement`, both must not be currencies. Returns a new `Measurement` with the resulting value and unit. If dividing by a numeric value, returns a new `Measurement` with the same unit and divided magnitude.
-        
+
+        If dividing by another `Measurement`:
+          - Division between two *different* currencies is disallowed (raises TypeError).
+          - Division between the *same* currency is allowed and yields a dimensionless result.
+        Returns a new `Measurement` with the resulting value and unit.
+
         Raises:
-            TypeError: If dividing two currency measurements, or if the operand is not a `Measurement` or numeric value.
+            TypeError: If dividing two currency measurements with different units, or if the operand is not a `Measurement` or numeric value.
+        Returns:
+            Measurement: The result of the division as a new `Measurement` instance.
         """
         if isinstance(other, Measurement):
-            if self.is_currency() and other.is_currency():
-                raise TypeError("Division between two currency amounts is not allowed.")
+            if self.is_currency() and other.is_currency() and self.unit != other.unit:
+                raise TypeError(
+                    "Division between two different currency amounts is not allowed."
+                )
             result_quantity = self.quantity / other.quantity
             return Measurement(
                 Decimal(str(result_quantity.magnitude)), str(result_quantity.units)
@@ -300,14 +306,14 @@ class Measurement:
 
     def _compare(self, other: Any, operation: Callable[..., bool]) -> bool:
         """
-        Compare this Measurement to another using a specified comparison operation.
-        
-        If `other` is a string, it is parsed into 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.
-        
+        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.
+
         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.
-        
+
         Returns:
             bool: The result of the comparison.
         """
@@ -348,16 +354,16 @@ class Measurement:
 
     def __ge__(self, other: Any) -> bool:
         """
-        Return True if this measurement is greater than or equal to another measurement.
-        
-        The comparison is performed after converting the other operand to the same unit as this measurement. Raises a TypeError if the other object is not a Measurement instance or a compatible string, or a ValueError if the units are incompatible.
+        Return True if this measurement is greater than or equal to another measurement or compatible value.
+
+        The comparison converts the other operand to this measurement's unit before evaluating. Raises TypeError if the operand is not a Measurement or convertible string, or ValueError if units are incompatible.
         """
         return self._compare(other, ge)
 
     def __hash__(self) -> int:
         """
-        Return a hash value derived from the measurement's magnitude and unit.
-        
-        Enables use of Measurement instances in hash-based collections such as sets and dictionaries.
+        Return a hash based on the measurement's magnitude and unit.
+
+        Enables Measurement instances to be used in hash-based collections.
         """
         return hash((self.magnitude, str(self.unit)))

general_manager/{auxiliary → utils}/makeCacheKey.py

@@ -1,21 +1,21 @@
 import inspect
 import json
-from general_manager.auxiliary.jsonEncoder import CustomJSONEncoder
+from general_manager.utils.jsonEncoder import CustomJSONEncoder
 from hashlib import sha256
 
 
 def make_cache_key(func, args, kwargs):
     """
     Generates a unique, deterministic cache key for a specific function call.
-    
+
     The key is derived from the function's module, qualified name, and bound arguments,
     serialized to JSON and hashed with SHA-256 to ensure uniqueness for each call signature.
-    
+
     Args:
         func: The target function to be identified.
         args: Positional arguments for the function call.
         kwargs: Keyword arguments for the function call.
-    
+
     Returns:
         A hexadecimal SHA-256 hash string uniquely representing the function call.
     """

general_manager/utils/testing.py

@@ -10,6 +10,14 @@ from general_manager.api.graphql import GraphQL
 from django.apps import apps as global_apps
 
 
+from unittest.mock import ANY
+from general_manager.cache.cacheDecorator import _SENTINEL
+
+
+from django.test import override_settings
+from django.core.cache import caches
+from django.core.cache.backends.locmem import LocMemCache
+
 _original_get_app = global_apps.get_containing_app_config
 
 
@@ -61,9 +69,9 @@ class GMTestCaseMeta(type):
 
     def __new__(mcs, name, bases, attrs):
         """
-        Creates a new test case class with a customized setUpClass that prepares the database schema and GraphQL environment for GeneralManager integration tests.
-
-        The generated setUpClass method resets GraphQL class registries, invokes any user-defined setUpClass, clears default GraphQL URL patterns, creates missing database tables for specified GeneralManager classes and their history models, initializes GeneralManager and GraphQL configurations, and finally calls the original GraphQLTransactionTestCase setUpClass.
+        Creates a new test case class with a customized setUpClass method for GeneralManager and GraphQL integration tests.
+        
+        The generated setUpClass ensures the test environment is properly initialized by resetting GraphQL registries, applying any user-defined setup, clearing default GraphQL URL patterns, creating missing database tables for specified GeneralManager models and their history, initializing GeneralManager and GraphQL configurations, and invoking the base GraphQLTransactionTestCase setup.
         """
         user_setup = attrs.get("setUpClass")
         fallback_app = attrs.get("fallback_app", "general_manager")
@@ -72,9 +80,9 @@ class GMTestCaseMeta(type):
 
         def wrapped_setUpClass(cls):
             """
-            Performs comprehensive setup for a test case class, initializing GraphQL and GeneralManager environments and ensuring required database tables exist.
-
-            This method resets internal GraphQL registries, invokes any user-defined setup, removes default GraphQL URL patterns, creates missing database tables for models and their history associated with specified GeneralManager classes, initializes GeneralManager and GraphQL configurations, and finally calls the base test case setup.
+            Performs setup for a test case class by resetting GraphQL internals, configuring fallback app lookup, clearing default GraphQL URL patterns, ensuring database tables exist for specified GeneralManager models and their history, initializing GeneralManager and GraphQL configurations, and invoking the base test case setup.
+            
+            Skips database table creation for any GeneralManager class lacking an `Interface` or `_model` attribute.
             """
             GraphQL._query_class = None
             GraphQL._mutation_class = None
@@ -97,6 +105,10 @@ class GMTestCaseMeta(type):
             existing = connection.introspection.table_names()
             with connection.schema_editor() as editor:
                 for manager_class in cls.general_manager_classes:
+                    if not hasattr(manager_class, "Interface") or not hasattr(
+                        manager_class.Interface, "_model"
+                    ):
+                        continue
                     model_class = cast(
                         type[models.Model], manager_class.Interface._model  # type: ignore
                     )
@@ -116,9 +128,105 @@ class GMTestCaseMeta(type):
         return super().__new__(mcs, name, bases, attrs)
 
 
+class LoggingCache(LocMemCache):
+    def __init__(self, *args, **kwargs):
+        """
+        Initialize the LoggingCache and set up an empty list to record cache operations.
+        """
+        super().__init__(*args, **kwargs)
+        self.ops = []
+
+    def get(self, key, default=None, version=None):
+        """
+        Retrieve a value from the cache and log whether it was a cache hit or miss.
+        
+        Parameters:
+            key (str): The cache key to retrieve.
+            default: The value to return if the key is not found.
+            version: Optional cache version.
+        
+        Returns:
+            The cached value if found; otherwise, the default value.
+        """
+        val = super().get(key, default)
+        self.ops.append(("get", key, val is not _SENTINEL))
+        return val
+
+    def set(self, key, value, timeout=None, version=None):
+        """
+        Store a value in the cache and log the set operation.
+        
+        Parameters:
+            key (str): The cache key to set.
+            value (Any): The value to store in the cache.
+            timeout (Optional[int]): The cache timeout in seconds.
+            version (Optional[int]): The cache version (unused).
+        """
+        super().set(key, value, timeout)
+        self.ops.append(("set", key))
+
+
+@override_settings(
+    CACHES={
+        "default": {
+            "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+            "LOCATION": "test-cache",
+        }
+    }
+)
 class GeneralManagerTransactionTestCase(
     GraphQLTransactionTestCase, metaclass=GMTestCaseMeta
 ):
     general_manager_classes: list[type[GeneralManager]] = []
     read_only_classes: list[type[GeneralManager]] = []
     fallback_app: str | None = "general_manager"
+
+    def setUp(self) -> None:
+        """
+        Prepares the test environment by replacing the default cache with a LoggingCache and resetting the cache operations log.
+        """
+        super().setUp()
+        setattr(caches._connections, "default", LoggingCache("test-cache", {}))  # type: ignore
+        self.__resetCacheCounter()
+
+    #
+    def assertCacheMiss(self):
+        """
+        Assert that a cache miss occurred, followed by a cache set operation.
+        
+        Checks that the cache's `get` method was called and did not find a value, and that the `set` method was subsequently called to store a value. Resets the cache operation log after the assertion.
+        """
+        ops = getattr(caches["default"], "ops")
+        self.assertIn(
+            ("get", ANY, False),
+            ops,
+            "Cache.get should have been called and found nothing",
+        )
+        self.assertIn(("set", ANY), ops, "Cache.set should have stored the value")
+        self.__resetCacheCounter()
+
+    def assertCacheHit(self):
+        """
+        Assert that a cache get operation resulted in a cache hit and no cache set operation occurred.
+        
+        Raises an assertion error if the cache did not return a value for a get operation or if a set operation was performed. Resets the cache operation log after the check.
+        """
+        ops = getattr(caches["default"], "ops")
+        self.assertIn(
+            ("get", ANY, True),
+            ops,
+            "Cache.get should have been called and found something",
+        )
+
+        self.assertNotIn(
+            ("set", ANY),
+            ops,
+            "Cache.set should not have stored anything",
+        )
+        self.__resetCacheCounter()
+
+    def __resetCacheCounter(self):
+        """
+        Clear the log of cache operations recorded by the LoggingCache instance.
+        """
+        caches["default"].ops = []  # type: ignore

{generalmanager-0.9.1.dist-info → generalmanager-0.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.9.1
+Version: 0.10.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.9.1.dist-info → generalmanager-0.10.1.dist-info}/RECORD

@@ -1,21 +1,13 @@
 general_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-general_manager/apps.py,sha256=Q6_by4VT4BtL6TxqyI0tG3XeiU3C3QZSiH4ok9a4XJY,8928
+general_manager/apps.py,sha256=dNzdcOTLs53y7JAGjQ7rqY1VWLtwO43NTTGJhbmbq1s,9906
 general_manager/api/graphql.py,sha256=ZMzlpgmyn2X9Zwxo12r-b5UZ2R-u1pXys_nhNczxyX8,31622
-general_manager/api/mutation.py,sha256=RYCogAdUpUedyh2B9keMAzq9u-iIhEKAsoiw5xXmhrQ,5669
+general_manager/api/mutation.py,sha256=muoQxXFCSJl4CGWQ9sqmyt4WzHB9H4lqDc0Qgtpg7II,5653
 general_manager/api/property.py,sha256=oc93p1P8dcIvrNorRuqD1EJVsd6eYttYhZuAS0s28gs,696
-general_manager/auxiliary/__init__.py,sha256=4IwKJzsNxGduF-Ej0u1BNHVaMhkql8PjHbVtx9DOTSY,76
-general_manager/auxiliary/argsToKwargs.py,sha256=kmp1xonpQp4X_y8ZJG6c5uOW7zQwo0HtPqsHWVzXRSM,921
-general_manager/auxiliary/filterParser.py,sha256=wmR4YzsnYgjI2Co5eyvCFROldotAraHx_GiCDJo79IY,5410
-general_manager/auxiliary/formatString.py,sha256=gZSbsKvpywBmf5bIx6YW43LmNJcqsCP7ZfrB7YPvaFo,1436
-general_manager/auxiliary/jsonEncoder.py,sha256=TDsgFQvheITHZgdmn-m8tk1_QCzpT0XwEHo7bY3Qe-M,638
-general_manager/auxiliary/makeCacheKey.py,sha256=lczutqxlofLSUnheKRi8nazhOyPa04TZOFNxNn5vDu4,1126
-general_manager/auxiliary/noneToZero.py,sha256=KfQtMQnrT6vsYST0K7lv6pVujkDcK3XL8czHYOhgqKQ,539
-general_manager/auxiliary/pathMapping.py,sha256=nrz5owQg2a69Yig1eCXorR9U0NSw7NmBAk5OkeoHTdA,6842
 general_manager/bucket/baseBucket.py,sha256=65oQbSE6C8TE0yVPP_Aoi_Fwq0Uo2TLVPWMG6l2qxyQ,7836
-general_manager/bucket/calculationBucket.py,sha256=c4p4QBV6PVYi1sxM8iReZ2YQtMmD8q5uPXXwkgCX6fQ,18467
+general_manager/bucket/calculationBucket.py,sha256=7AjoqdTOrbUCfWu7kZDjtu7vaFFJ7SPHELvtOZ8wfQg,18578
 general_manager/bucket/databaseBucket.py,sha256=V_xiPa8ErnPHVh_-i-oaH8qCa818UJxm5CVl80SVc1U,9060
 general_manager/bucket/groupBucket.py,sha256=55QdUaH_qO1JFJ2Jc1f2WcxniiLE5LB3vNwbnksKk8A,10939
-general_manager/cache/cacheDecorator.py,sha256=DK2ANIJgPpMxazfMSiFrI9OuVE_7K9zlIZQRrgaC2Lw,3268
+general_manager/cache/cacheDecorator.py,sha256=XQvs322lDDafecS6osPKmf7DyuZgDq8kuQaYpMeXXYg,3264
 general_manager/cache/cacheTracker.py,sha256=rRw3OhBDf86hTC2Xbt1ocRgZqwu8_kXk4lczamcADFg,2955
 general_manager/cache/dependencyIndex.py,sha256=lxD7IfnWVsBNt9l0_yDfJlHDRHAFC7N7p-Typ2tJp88,11044
 general_manager/cache/modelDependencyCollector.py,sha256=lIqBvo0QygoxxZPJ32_vMs_-eJaVJDznGyrEmxPV41E,2436
@@ -25,19 +17,19 @@ general_manager/factory/autoFactory.py,sha256=WBhSuMVsxkPAPLhlZhYXwHVIqiomUveS7v
 general_manager/factory/factories.py,sha256=F6_nYFyJRYYc3LQApfoVFdctfLzsWUDHKafn6xjckB8,7224
 general_manager/factory/factoryMethods.py,sha256=9Bag891j0XHe3dUBAFi7gUKcKeUwcBZN3cDLBobyBiI,3225
 general_manager/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-general_manager/interface/baseInterface.py,sha256=GCMo0MGlaRAElovfI34qfuWuVYOyTQLG0OA-ZJx8i3s,8604
+general_manager/interface/baseInterface.py,sha256=IWEtY--IuFiB3cjrCgtyXBTMpAPTayiFDnRQY7JZeaw,8600
 general_manager/interface/calculationInterface.py,sha256=Kg_OqLw67tcLwdzYNLq31eKVLzkM7taw-8Mzmk0CYi0,4232
-general_manager/interface/databaseBasedInterface.py,sha256=S7xSEYnguihx5RD633hwXcDk830a9-NwOwOnCFmeJMo,20738
-general_manager/interface/databaseInterface.py,sha256=UBmsfS6gF-3G6slvrGsq3UbKhSkWBWqtSOzRmdsw3Cw,6627
+general_manager/interface/databaseBasedInterface.py,sha256=OpKHpN509mcS86q3WgyAp7gQBwEqmA3BQPCFgF5q_Ig,20686
+general_manager/interface/databaseInterface.py,sha256=rhKVXhg0ztdIxKikTWtgjrkA7cwZTOYlEsRh0RWajDQ,6732
 general_manager/interface/models.py,sha256=gGYW5f1AUBpBakV3O0qsZwqMiWxZGdKRYXWaCBjt1oI,3334
 general_manager/interface/readOnlyInterface.py,sha256=TkfbOeaa2wCq5kCv0a3IwJWcYOTVbtNsdNWmGAz0Mns,11217
 general_manager/manager/__init__.py,sha256=l3RYp62aEhj3Y975_XUTIzo35LUnkTJHkb_hgChnXXI,111
-general_manager/manager/generalManager.py,sha256=AVFZICHzqiIyn7lgPU_WLH8X8WLP1edvWAE5CljZPrk,9178
+general_manager/manager/generalManager.py,sha256=jzLLAZTKgUOrzzOTXiWQsYj0FQk6Md8ggIQz0ie44qo,8793
 general_manager/manager/groupManager.py,sha256=8dpZUfm7aFL4lraUWv4qbbDRClQZaYxw4prclhBZYZs,4367
 general_manager/manager/input.py,sha256=-pJXGJ-g2-OxZfl4Buj3mQkf05fN4p8MsR2Lh9BQcEo,3208
-general_manager/manager/meta.py,sha256=IN5Xzz4lcUBe2umqvBz84qoyjkzKubNaMwfuYFQjFGU,5631
+general_manager/manager/meta.py,sha256=EruJhpaYA1glWvb07HuTPAL919K3z7clU5_x2dG0ryA,5585
 general_manager/measurement/__init__.py,sha256=X97meFujBldE5v0WMF7SmKeGpC5R0JTczfLo_Lq1Xek,84
-general_manager/measurement/measurement.py,sha256=0jVU6eZmEwDs0CW_W_RpUxaWDPd9J4uQXWPpxMkfJWQ,16079
+general_manager/measurement/measurement.py,sha256=emd1z3IDClK7nrIrUL_JXPxNhJEq2HnXq6qNYv9ubcM,16090
 general_manager/measurement/measurementField.py,sha256=iq9Hqe6ZGX8CxXm4nIqTAWTRkQVptzpqE9ExX-jFyNs,5928
 general_manager/permission/__init__.py,sha256=5UlDERN60Vn8obGVkT-cOM8kHjzmoxgK5w5FgTCDhGE,59
 general_manager/permission/basePermission.py,sha256=14iKo6qVmaUdg1sAz-gSZyNtpVKAAapIhutVAMDf93c,6056
@@ -48,9 +40,17 @@ general_manager/permission/permissionDataManager.py,sha256=Ji7fsnuaKTa6M8yzCGyzr
 general_manager/rule/__init__.py,sha256=4Har5cfPD1fmOsilTDod-ZUz3Com-tkl58jz7yY4fD0,23
 general_manager/rule/handler.py,sha256=z8SFHTIZ0LbLh3fV56Mud0V4_OvWkqJjlHvFqau7Qfk,7334
 general_manager/rule/rule.py,sha256=3FVCKGL7BTVoStdgOTdWQwuoVRIxAIAilV4VOzouDpc,10759
-general_manager/utils/testing.py,sha256=R6l-9PVAgxeVywvynkzSR6xXcHCu4z2UzRqzHDVrBUY,5591
-generalmanager-0.9.1.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
-generalmanager-0.9.1.dist-info/METADATA,sha256=KlP-5CSEpz1tbI4ec2SzBKT8aSCBWhiUboTS5zgLzoQ,6205
-generalmanager-0.9.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-generalmanager-0.9.1.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
-generalmanager-0.9.1.dist-info/RECORD,,
+general_manager/utils/__init__.py,sha256=4IwKJzsNxGduF-Ej0u1BNHVaMhkql8PjHbVtx9DOTSY,76
+general_manager/utils/argsToKwargs.py,sha256=kmp1xonpQp4X_y8ZJG6c5uOW7zQwo0HtPqsHWVzXRSM,921
+general_manager/utils/filterParser.py,sha256=wmR4YzsnYgjI2Co5eyvCFROldotAraHx_GiCDJo79IY,5410
+general_manager/utils/formatString.py,sha256=gZSbsKvpywBmf5bIx6YW43LmNJcqsCP7ZfrB7YPvaFo,1436
+general_manager/utils/jsonEncoder.py,sha256=TDsgFQvheITHZgdmn-m8tk1_QCzpT0XwEHo7bY3Qe-M,638
+general_manager/utils/makeCacheKey.py,sha256=UlFsxHXgsYy69AAelkF6GDvY4h7AImT2bBn6iD6dvi4,1110
+general_manager/utils/noneToZero.py,sha256=KfQtMQnrT6vsYST0K7lv6pVujkDcK3XL8czHYOhgqKQ,539
+general_manager/utils/pathMapping.py,sha256=nrz5owQg2a69Yig1eCXorR9U0NSw7NmBAk5OkeoHTdA,6842
+general_manager/utils/testing.py,sha256=IdVvrgLuYIvHRgdSj_j9mC-damQ-2ivSJ7Ngguez5vo,9366
+generalmanager-0.10.1.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.10.1.dist-info/METADATA,sha256=1s7xiuMN9uzioICRAl19thEixmRzZPtD70aYJ6psR-w,6206
+generalmanager-0.10.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+generalmanager-0.10.1.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.10.1.dist-info/RECORD,,