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

general_manager/apps.py

@@ -29,26 +29,32 @@ class GeneralmanagerConfig(AppConfig):
 
     def ready(self):
         """
-        Initializes the general_manager app on Django startup.
+        Performs initialization tasks for the general_manager app when Django starts.
         
-        Sets up read-only interface synchronization and schema validation, initializes general manager class attributes and interconnections, and configures the GraphQL schema and endpoint if enabled in settings.
+        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()
-        self.initializeGeneralManagerClasses()
+        self.handleReadOnlyInterface(GeneralManagerMeta.read_only_classes)
+        self.initializeGeneralManagerClasses(
+            GeneralManagerMeta.pending_attribute_initialization,
+            GeneralManagerMeta.all_classes,
+        )
         if getattr(settings, "AUTOCREATE_GRAPHQL", False):
-            self.handleGraphQL()
+            self.handleGraphQL(GeneralManagerMeta.pending_graphql_interfaces)
 
-    def handleReadOnlyInterface(self):
+    @staticmethod
+    def handleReadOnlyInterface(
+        read_only_classes: list[Type[GeneralManager[Any, ReadOnlyInterface]]],
+    ):
         """
-        Configures synchronization and schema validation for all registered read-only interfaces.
+        Configures synchronization and schema validation for the provided read-only interface classes.
         
-        This method ensures that read-only interfaces are synchronized before Django management commands execute and registers system checks to validate that each read-only interface's schema remains current.
+        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.
         """
-        self.patchReadOnlyInterfaceSync(GeneralManagerMeta.read_only_classes)
+        GeneralmanagerConfig.patchReadOnlyInterfaceSync(read_only_classes)
         from general_manager.interface.readOnlyInterface import ReadOnlyInterface
 
         logger.debug("starting to register ReadOnlyInterface schema warnings...")
-        for general_manager_class in GeneralManagerMeta.read_only_classes:
+        for general_manager_class in read_only_classes:
             read_only_interface = cast(
                 Type[ReadOnlyInterface], general_manager_class.Interface
             )
@@ -65,9 +71,9 @@ class GeneralmanagerConfig(AppConfig):
         general_manager_classes: list[Type[GeneralManager[Any, ReadOnlyInterface]]],
     ):
         """
-        Monkey-patches Django's management command runner to synchronize data for all provided read-only interfaces before executing management commands.
+        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 general manager class, its associated read-only interface's `syncData` method is called prior to command execution, 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
 
@@ -76,7 +82,7 @@ class GeneralmanagerConfig(AppConfig):
         def run_from_argv_with_sync(self, argv):
             # 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 an autoreload subprocess 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.
@@ -100,18 +106,20 @@ class GeneralmanagerConfig(AppConfig):
 
         BaseCommand.run_from_argv = run_from_argv_with_sync
 
-    def initializeGeneralManagerClasses(self):
+    @staticmethod
+    def initializeGeneralManagerClasses(
+        pending_attribute_initialization: list[Type[GeneralManager]],
+        all_classes: list[Type[GeneralManager]],
+    ):
         """
-        Initializes attributes and sets up dynamic relationships for all registered GeneralManager classes.
+        Initializes attributes and establishes dynamic relationships for GeneralManager classes.
         
-        For each pending GeneralManager class, assigns its interface attributes and creates property accessors. Then, for all GeneralManager classes, dynamically connects input fields that reference other GeneralManager subclasses by adding GraphQL properties to enable filtered access to related objects.
+        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...")
 
         logger.debug("starting to create attributes for GeneralManager classes...")
-        for (
-            general_manager_class
-        ) in GeneralManagerMeta.pending_attribute_initialization:
+        for general_manager_class in pending_attribute_initialization:
             attributes = general_manager_class.Interface.getAttributes()
             setattr(general_manager_class, "_attributes", attributes)
             GeneralManagerMeta.createAtPropertiesForAttributes(
@@ -119,7 +127,7 @@ class GeneralmanagerConfig(AppConfig):
             )
 
         logger.debug("starting to connect inputs to other general manager classes...")
-        for general_manager_class in GeneralManagerMeta.all_classes:
+        for general_manager_class in all_classes:
             attributes = getattr(general_manager_class.Interface, "input_fields", {})
             for attribute_name, attribute in attributes.items():
                 if isinstance(attribute, Input) and issubclass(
@@ -137,12 +145,15 @@ class GeneralmanagerConfig(AppConfig):
                         graphQlProperty(func),
                     )
 
-    def handleGraphQL(self):
+    @staticmethod
+    def handleGraphQL(
+        pending_graphql_interfaces: list[Type[GeneralManager]],
+    ):
         """
-        Sets up GraphQL interfaces, mutations, and schema for all pending general manager classes, and adds the GraphQL endpoint to the Django URL configuration.
+        Creates GraphQL interfaces and mutations for the provided general manager classes, builds the GraphQL schema, and registers the GraphQL endpoint in the Django URL configuration.
         """
         logger.debug("Starting to create GraphQL interfaces and mutations...")
-        for general_manager_class in GeneralManagerMeta.pending_graphql_interfaces:
+        for general_manager_class in pending_graphql_interfaces:
             GraphQL.createGraphqlInterface(general_manager_class)
             GraphQL.createGraphqlMutation(general_manager_class)
 
@@ -160,18 +171,22 @@ class GeneralmanagerConfig(AppConfig):
             query=GraphQL._query_class,
             mutation=GraphQL._mutation_class,
         )
-        self.addGraphqlUrl(schema)
+        GeneralmanagerConfig.addGraphqlUrl(schema)
 
-    def addGraphqlUrl(self, schema):
+    @staticmethod
+    def addGraphqlUrl(schema):
         """
-        Dynamically appends a GraphQL endpoint to the Django URL configuration using the given 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.
         """
         logging.debug("Adding GraphQL URL to Django settings...")
         root_url_conf_path = getattr(settings, "ROOT_URLCONF", None)
-        graph_ql_url = getattr(settings, "GRAPHQL_URL", "graphql/")
+        graph_ql_url = getattr(settings, "GRAPHQL_URL", "graphql")
         if not root_url_conf_path:
             raise Exception("ROOT_URLCONF not found in settings")
         urlconf = import_module(root_url_conf_path)

general_manager/interface/databaseBasedInterface.py

@@ -23,6 +23,11 @@ from general_manager.interface.baseInterface import (
 )
 from general_manager.manager.input import Input
 from general_manager.bucket.databaseBucket import DatabaseBucket
+from general_manager.interface.models import (
+    GeneralManagerBasisModel,
+    GeneralManagerModel,
+    getFullCleanMethode,
+)
 
 if TYPE_CHECKING:
     from general_manager.manager.generalManager import GeneralManager
@@ -32,72 +37,6 @@ if TYPE_CHECKING:
 modelsModel = TypeVar("modelsModel", bound=models.Model)
 
 
-def getFullCleanMethode(model: Type[models.Model]) -> Callable[..., None]:
-    """
-    Generates a custom `full_clean` method for a Django model that combines standard validation with additional rule-based checks.
-
-    The returned method first performs Django's built-in model validation, then evaluates any custom rules defined in the model's `_meta.rules` attribute. If any validation or rule fails, a `ValidationError` is raised containing all collected errors.
-    """
-
-    def full_clean(self: models.Model, *args: Any, **kwargs: Any):
-        errors: dict[str, Any] = {}
-        try:
-            super(model, self).full_clean(*args, **kwargs)  # type: ignore
-        except ValidationError as e:
-            errors.update(e.message_dict)
-
-        rules: list[Rule] = getattr(self._meta, "rules")
-        for rule in rules:
-            if not rule.evaluate(self):
-                error_message = rule.getErrorMessage()
-                if error_message:
-                    errors.update(error_message)
-
-        if errors:
-            raise ValidationError(errors)
-
-    return full_clean
-
-
-class GeneralManagerBasisModel(models.Model):
-    _general_manager_class: ClassVar[Type[GeneralManager]]
-    is_active = models.BooleanField(default=True)
-    history = HistoricalRecords(inherit=True)
-
-    class Meta:
-        abstract = True
-
-
-class GeneralManagerModel(GeneralManagerBasisModel):
-    changed_by = models.ForeignKey(
-        settings.AUTH_USER_MODEL, on_delete=models.PROTECT, null=True, blank=True
-    )
-    changed_by_id: int | None
-
-    @property
-    def _history_user(self) -> AbstractUser | None:
-        """
-        Gets the user who last modified this model instance, or None if not set.
-        
-        Returns:
-            AbstractUser | None: The user who last changed the instance, or None if unavailable.
-        """
-        return self.changed_by
-
-    @_history_user.setter
-    def _history_user(self, value: AbstractUser) -> None:
-        """
-        Sets the user responsible for the latest change to the model instance.
-
-        Args:
-            value: The user to associate with the change.
-        """
-        self.changed_by = value
-
-    class Meta:  # type: ignore
-        abstract = True
-
-
 MODEL_TYPE = TypeVar("MODEL_TYPE", bound=GeneralManagerBasisModel)
 
 
@@ -112,9 +51,9 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         **kwargs: dict[str, Any],
     ):
         """
-        Initialize the interface instance and load the associated model record.
+        Initialize the interface and load the associated model instance.
         
-        If `search_date` is provided, retrieves the historical record as of that date; otherwise, loads the current record.
+        If `search_date` is provided, loads the historical record as of that date; otherwise, loads the current record.
         """
         super().__init__(*args, **kwargs)
         self.pk = self.identification["id"]
@@ -201,10 +140,10 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
         """
-        Return a dictionary mapping attribute names to metadata describing their type and properties.
+        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.
         
-        The returned dictionary includes all model fields, custom fields, foreign keys, many-to-many, and reverse relation fields. For each attribute, the metadata includes 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.
         """
@@ -461,9 +400,9 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     ) -> tuple[attributes, interfaceBaseClass, relatedClass]:
         # Felder aus der Interface-Klasse sammeln
         """
-        Dynamically creates a Django model class, its associated interface class, and a factory class from an interface definition.
+        Dynamically generates a Django model class, its associated interface class, and a factory class from an interface definition.
         
-        This method extracts fields and meta information from the provided interface class, constructs a new Django model inheriting from the specified base model class, attaches custom validation rules if present, and generates corresponding interface and factory classes. The resulting classes are returned for integration into the general manager framework.
+        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.

general_manager/interface/databaseInterface.py

@@ -111,7 +111,12 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
             if isinstance(value, GeneralManager):
                 value = value.identification["id"]
                 key = f"{key}_id"
-            setattr(instance, key, value)
+            try:
+                setattr(instance, key, value)
+            except ValueError as e:
+                raise ValueError(f"Invalid value for {key}: {value}") from e
+            except TypeError as e:
+                raise TypeError(f"Type error for {key}: {e}") from e
         return instance
 
     @staticmethod

general_manager/interface/models.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+from typing import Type, ClassVar, Any, Callable, TYPE_CHECKING, TypeVar
+from django.db import models
+from django.conf import settings
+from simple_history.models import HistoricalRecords  # type: ignore
+from django.core.exceptions import ValidationError
+
+
+if TYPE_CHECKING:
+    from general_manager.manager.generalManager import GeneralManager
+    from django.contrib.auth.models import AbstractUser
+    from general_manager.rule.rule import Rule
+
+modelsModel = TypeVar("modelsModel", bound=models.Model)
+
+
+def getFullCleanMethode(model: Type[models.Model]) -> Callable[..., None]:
+    """
+    Return a custom `full_clean` method for a Django model that performs both standard validation and additional rule-based checks.
+    
+    The generated method first applies Django's built-in model validation, then evaluates custom rules defined in the model's `_meta.rules` attribute. If any validation or rule fails, it raises a `ValidationError` containing all collected errors.
+    
+    Parameters:
+        model (Type[models.Model]): The Django model class for which to generate the custom `full_clean` method.
+    
+    Returns:
+        Callable[..., None]: A `full_clean` method that can be assigned to the model class.
+    """
+
+    def full_clean(self: models.Model, *args: Any, **kwargs: Any):
+        """
+        Performs full validation on the model instance, including both standard Django validation and custom rule-based checks.
+        
+        Aggregates errors from Django's built-in validation and any additional rules defined in the model's `_meta.rules` attribute. Raises a `ValidationError` containing all collected errors if any validation or rule check fails.
+        """
+        errors: dict[str, Any] = {}
+        try:
+            super(model, self).full_clean(*args, **kwargs)  # type: ignore
+        except ValidationError as e:
+            errors.update(e.message_dict)
+
+        rules: list[Rule] = getattr(self._meta, "rules")
+        for rule in rules:
+            if not rule.evaluate(self):
+                error_message = rule.getErrorMessage()
+                if error_message:
+                    errors.update(error_message)
+
+        if errors:
+            raise ValidationError(errors)
+
+    return full_clean
+
+
+class GeneralManagerBasisModel(models.Model):
+    _general_manager_class: ClassVar[Type[GeneralManager]]
+    is_active = models.BooleanField(default=True)
+    history = HistoricalRecords(inherit=True)
+
+    class Meta:
+        abstract = True
+
+
+class GeneralManagerModel(GeneralManagerBasisModel):
+    changed_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL, on_delete=models.PROTECT, null=True, blank=True
+    )
+    changed_by_id: int | None
+
+    @property
+    def _history_user(self) -> AbstractUser | None:
+        """
+        Returns the user who last modified this model instance, or None if no user is set.
+        """
+        return self.changed_by
+
+    @_history_user.setter
+    def _history_user(self, value: AbstractUser) -> None:
+        """
+        Set the user responsible for the most recent change to the model instance.
+        
+        Parameters:
+            value (AbstractUser): The user to associate with the latest modification.
+        """
+        self.changed_by = value
+
+    class Meta:  # type: ignore
+        abstract = True

general_manager/manager/meta.py

@@ -25,9 +25,9 @@ class GeneralManagerMeta(type):
 
     def __new__(mcs, name: str, bases: tuple[type, ...], attrs: dict[str, Any]) -> type:
         """
-        Create a new class using the metaclass, integrating interface hooks and registering the class for attribute initialization and tracking.
+        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. If the `AUTOCREATE_GRAPHQL` setting is enabled, also registers the class for pending GraphQL interface creation.
+        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.
@@ -37,10 +37,10 @@ class GeneralManagerMeta(type):
             mcs, name: str, bases: tuple[type, ...], attrs: dict[str, Any]
         ) -> Type[GeneralManager]:
             """
-            Create a new general manager class using the standard metaclass instantiation process.
+            Create a new GeneralManager class using the standard metaclass instantiation process.
             
             Returns:
-                The newly created general manager class.
+                The newly created GeneralManager subclass.
             """
             return super().__new__(mcs, name, bases, attrs)
 
@@ -59,7 +59,6 @@ class GeneralManagerMeta(type):
 
         else:
             new_class = createNewGeneralManagerClass(mcs, name, bases, attrs)
-
         if getattr(settings, "AUTOCREATE_GRAPHQL", False):
             mcs.pending_graphql_interfaces.append(new_class)
 
@@ -69,13 +68,22 @@ class GeneralManagerMeta(type):
     def createAtPropertiesForAttributes(
         attributes: Iterable[str], new_class: Type[GeneralManager]
     ):
-
         """
-        Dynamically assigns property descriptors to a class for the specified attribute names.
+        Dynamically assigns property descriptors to a class for each specified attribute name.
         
-        For each attribute name, creates a descriptor that retrieves the value from an instance's `_attributes` dictionary. If accessed on the class, returns the field type from the class's interface. If the attribute is callable, it is invoked with the instance's interface. Raises `AttributeError` if the attribute is missing or if an error occurs during callable invocation.
+        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.
+        - Invokes the attribute with the instance's interface if it is callable.
+        - Raises `AttributeError` if the attribute is missing or if an error occurs during callable invocation.
         """
+
         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

@@ -4,7 +4,7 @@ from typing import Any, Callable
 import pint
 from decimal import Decimal, getcontext, InvalidOperation
 from operator import eq, ne, lt, le, gt, ge
-
+from pint.facets.plain import PlainQuantity
 
 # Set precision for Decimal
 getcontext().prec = 28
@@ -21,6 +21,16 @@ 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.
+        
+        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.
+        
+        Raises:
+            TypeError: If the value cannot be converted to a Decimal.
+        """
         if not isinstance(value, (Decimal, float, int)):
             try:
                 value = Decimal(str(value))
@@ -28,22 +38,37 @@ class Measurement:
                 raise TypeError("Value must be a Decimal, float, int or compatible.")
         if not isinstance(value, Decimal):
             value = Decimal(str(value))
-        self.__quantity = self.formatDecimal(value) * ureg.Quantity(1, unit)
+        self.__quantity = ureg.Quantity(self.formatDecimal(value), unit)
 
     def __getstate__(self):
+        """
+        Return a serializable state dictionary containing the magnitude and unit of the measurement.
+        
+        Returns:
+            dict: A dictionary with 'magnitude' as a string and 'unit' as a string, suitable for pickling or other serialization.
+        """
         state = {
-            "magnitude": str(self.quantity.magnitude),
-            "unit": str(self.quantity.units),
+            "magnitude": str(self.magnitude),
+            "unit": str(self.unit),
         }
         return state
 
     def __setstate__(self, state):
+        """
+        Restore the Measurement object from a serialized state dictionary.
+        
+        Parameters:
+            state (dict): A dictionary containing 'magnitude' as a string and 'unit' as a string.
+        """
         value = Decimal(state["magnitude"])
         unit = state["unit"]
-        self.__quantity = self.formatDecimal(value) * ureg.Quantity(1, unit)
+        self.__quantity = ureg.Quantity(self.formatDecimal(value), unit)
 
     @property
-    def quantity(self) -> pint.Quantity:
+    def quantity(self) -> PlainQuantity:
+        """
+        Return the internal quantity as a `PlainQuantity` object from the `pint` library.
+        """
         return self.__quantity
 
     @property
@@ -57,18 +82,24 @@ class Measurement:
     @classmethod
     def from_string(cls, value: str) -> Measurement:
         """
-        Creates a Measurement instance from a string in the format 'value unit'.
+        Parse a string of the form 'value unit' and return a Measurement instance.
         
-        Args:
-            value: A string containing a numeric value and a unit separated by a space (e.g., '10.5 kg').
+        Parameters:
+            value (str): String containing a numeric value and a unit, separated by a space (e.g., '10.5 kg').
         
         Returns:
-            A Measurement instance representing the parsed value and unit.
+            Measurement: The corresponding Measurement object.
         
         Raises:
             ValueError: If the input string does not contain exactly two parts separated by a space.
         """
         splitted = value.split(" ")
+        if len(splitted) == 1:
+            # If only one part, assume it's a dimensionless value
+            try:
+                return cls(Decimal(splitted[0]), "dimensionless")
+            except InvalidOperation:
+                raise ValueError("Invalid value for dimensionless measurement.")
         if len(splitted) != 2:
             raise ValueError("String must be in the format 'value unit'.")
         value, unit = splitted
@@ -86,12 +117,27 @@ class Measurement:
             return value
 
     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.
+        
+        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.
+        
+        Returns:
+            Measurement: A new Measurement instance in the target unit.
+        
+        Raises:
+            ValueError: If converting between different currencies without providing an exchange rate.
+        """
         if self.is_currency():
-            if self.quantity.units == ureg(target_unit):
+            if self.unit == ureg(target_unit):
                 return self  # Same currency, no conversion needed
             elif exchange_rate is not None:
                 # Convert using the provided exchange rate
-                value = self.quantity.magnitude * Decimal(str(exchange_rate))
+                value = self.magnitude * Decimal(str(exchange_rate))
                 return Measurement(value, target_unit)
             else:
                 raise ValueError(
@@ -106,14 +152,25 @@ class Measurement:
 
     def is_currency(self):
         # Check if the unit is a defined currency
-        return str(self.quantity.units) in currency_units
+        """
+        Return True if the measurement's unit is one of the defined currency units.
+        """
+        return str(self.unit) in currency_units
 
     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.
+        
+        Returns:
+            Measurement: A new Measurement representing the sum.
+        """
         if not isinstance(other, Measurement):
             raise TypeError("Addition is only allowed between Measurement instances.")
         if self.is_currency() and other.is_currency():
             # Both are currencies
-            if self.quantity.units != other.quantity.units:
+            if self.unit != other.unit:
                 raise ValueError(
                     "Addition between different currencies is not allowed."
                 )
@@ -139,34 +196,49 @@ 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.
+        
+        Returns:
+            Measurement: The result of the subtraction as a new Measurement instance.
+        """
         if not isinstance(other, Measurement):
             raise TypeError(
                 "Subtraction is only allowed between Measurement instances."
             )
         if self.is_currency() and other.is_currency():
             # Both are currencies
-            if self.quantity.units != other.quantity.units:
+            if self.unit != other.unit:
                 raise ValueError(
                     "Subtraction between different currencies is not allowed."
                 )
             result_quantity = self.quantity - other.quantity
-            return Measurement(
-                Decimal(str(result_quantity.magnitude)), str(self.quantity.units)
-            )
+            return Measurement(Decimal(str(result_quantity.magnitude)), str(self.unit))
         elif not self.is_currency() and not other.is_currency():
             # Both are physical units
             if self.quantity.dimensionality != other.quantity.dimensionality:
                 raise ValueError("Units are not compatible for subtraction.")
             result_quantity = self.quantity - other.quantity
-            return Measurement(
-                Decimal(str(result_quantity.magnitude)), str(self.quantity.units)
-            )
+            return Measurement(Decimal(str(result_quantity.magnitude)), str(self.unit))
         else:
             raise TypeError(
                 "Subtraction between currency and physical unit is not allowed."
             )
 
     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:
+            Measurement: The result of the multiplication as a new Measurement instance.
+        
+        Raises:
+            TypeError: If attempting to multiply two currency measurements or if the operand is not a Measurement or numeric value.
+        """
         if isinstance(other, Measurement):
             if self.is_currency() or other.is_currency():
                 raise TypeError(
@@ -180,15 +252,21 @@ class Measurement:
             if not isinstance(other, Decimal):
                 other = Decimal(str(other))
             result_quantity = self.quantity * other
-            return Measurement(
-                Decimal(str(result_quantity.magnitude)), str(self.quantity.units)
-            )
+            return Measurement(Decimal(str(result_quantity.magnitude)), str(self.unit))
         else:
             raise TypeError(
                 "Multiplication is only allowed with Measurement or numeric values."
             )
 
     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.
+        
+        Raises:
+            TypeError: If dividing two currency measurements, or if the operand is not a `Measurement` or numeric value.
+        """
         if isinstance(other, Measurement):
             if self.is_currency() and other.is_currency():
                 raise TypeError("Division between two currency amounts is not allowed.")
@@ -200,41 +278,38 @@ class Measurement:
             if not isinstance(other, Decimal):
                 other = Decimal(str(other))
             result_quantity = self.quantity / other
-            return Measurement(
-                Decimal(str(result_quantity.magnitude)), str(self.quantity.units)
-            )
+            return Measurement(Decimal(str(result_quantity.magnitude)), str(self.unit))
         else:
             raise TypeError(
                 "Division is only allowed with Measurement or numeric values."
             )
 
     def __str__(self):
-        if not str(self.quantity.units) == "dimensionless":
-            return f"{self.quantity.magnitude} {self.quantity.units}"
-        return f"{self.quantity.magnitude}"
+        """
+        Return a string representation of the measurement, including the unit unless it is dimensionless.
+        """
+        if not str(self.unit) == "dimensionless":
+            return f"{self.magnitude} {self.unit}"
+        return f"{self.magnitude}"
 
     def __repr__(self):
-        return f"Measurement({self.quantity.magnitude}, '{self.quantity.units}')"
+        """
+        Return a string representation of the Measurement instance for debugging, showing its magnitude and unit.
+        """
+        return f"Measurement({self.magnitude}, '{self.unit}')"
 
     def _compare(self, other: Any, operation: Callable[..., bool]) -> bool:
         """
-        Compares this Measurement with another using the specified comparison operation.
+        Compare this Measurement to another using a specified comparison operation.
         
-        If `other` is a string, it is parsed into a Measurement. Raises a TypeError if
-        `other` is not a Measurement instance. Converts `other` to this instance's unit
-        before applying the comparison. Raises a ValueError if the measurements have
-        incompatible dimensions.
+        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.
         
-        Args:
-            other: The object to compare with, either a Measurement or a string in the format "value unit".
-            operation: A callable that takes two magnitudes and returns a boolean result.
+        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:
-            The result of the comparison operation.
-        
-        Raises:
-            TypeError: If `other` is not a Measurement instance or a valid string representation.
-            ValueError: If the measurements have different dimensions and cannot be compared.
+            bool: The result of the comparison.
         """
         if isinstance(other, str):
             other = Measurement.from_string(other)
@@ -244,9 +319,9 @@ class Measurement:
             raise TypeError("Comparison is only allowed between Measurement instances.")
         try:
             # Convert `other` to the same units as `self`
-            other_converted: pint.Quantity = other.quantity.to(self.quantity.units)  # type: ignore
+            other_converted: pint.Quantity = other.quantity.to(self.unit)  # type: ignore
             # Apply the comparison operation
-            return operation(self.quantity.magnitude, other_converted.magnitude)
+            return operation(self.magnitude, other_converted.magnitude)
         except pint.DimensionalityError:
             raise ValueError("Cannot compare measurements with different dimensions.")
 
@@ -273,16 +348,16 @@ class Measurement:
 
     def __ge__(self, other: Any) -> bool:
         """
-        Returns True if this measurement is greater than or equal to another measurement.
+        Return True if this measurement is greater than or equal to another measurement.
         
-        Comparison is performed after converting the other operand to the same unit. Raises a TypeError if the other object is not a Measurement instance or a compatible string, or a ValueError if the units are not compatible.
+        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 self._compare(other, ge)
 
     def __hash__(self) -> int:
         """
-        Returns a hash value based on the magnitude and unit of the measurement.
+        Return a hash value derived from the measurement's magnitude and unit.
         
-        This enables Measurement instances to be used in hash-based collections such as sets and dictionaries.
+        Enables use of Measurement instances in hash-based collections such as sets and dictionaries.
         """
-        return hash((self.quantity.magnitude, str(self.quantity.units)))
+        return hash((self.magnitude, str(self.unit)))

general_manager/utils/testing.py

@@ -0,0 +1,124 @@
+from graphene_django.utils.testing import GraphQLTransactionTestCase
+from general_manager.apps import GeneralmanagerConfig
+from importlib import import_module
+from django.db import connection
+from django.conf import settings
+from typing import cast
+from django.db import models
+from general_manager.manager.generalManager import GeneralManager
+from general_manager.api.graphql import GraphQL
+from django.apps import apps as global_apps
+
+
+_original_get_app = global_apps.get_containing_app_config
+
+
+def createFallbackGetApp(fallback_app: str):
+    """
+    Creates a fallback function for getting the app config, which returns the specified fallback app if the original lookup fails.
+
+    Parameters:
+        fallback_app (str): The name of the app to return if the original lookup fails.
+
+    Returns:
+        function: A function that attempts to get the app config for a given object name, falling back to the specified app if not found.
+    """
+
+    def _fallback_get_app(object_name: str):
+        cfg = _original_get_app(object_name)
+        if cfg is not None:
+            return cfg
+        try:
+            return global_apps.get_app_config(fallback_app)
+        except LookupError:
+            return None
+
+    return _fallback_get_app
+
+
+def _default_graphql_url_clear():
+    """
+    Removes the first URL pattern for the GraphQL view from the project's root URL configuration.
+
+    This function searches the root URL patterns for a pattern whose callback is a `GraphQLView` and removes it, effectively clearing the default GraphQL endpoint from the URL configuration.
+    """
+    urlconf = import_module(settings.ROOT_URLCONF)
+    for pattern in urlconf.urlpatterns:
+        if (
+            hasattr(pattern, "callback")
+            and hasattr(pattern.callback, "view_class")
+            and pattern.callback.view_class.__name__ == "GraphQLView"
+        ):
+            urlconf.urlpatterns.remove(pattern)
+            break
+
+
+class GMTestCaseMeta(type):
+    """
+    Metaclass that wraps setUpClass: first calls user-defined setup,
+    then performs GM environment initialization, then super().setUpClass().
+    """
+
+    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.
+        """
+        user_setup = attrs.get("setUpClass")
+        fallback_app = attrs.get("fallback_app", "general_manager")
+        # MERKE dir das echte GraphQLTransactionTestCase.setUpClass
+        base_setup = GraphQLTransactionTestCase.setUpClass
+
+        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.
+            """
+            GraphQL._query_class = None
+            GraphQL._mutation_class = None
+            GraphQL._mutations = {}
+            GraphQL._query_fields = {}
+            GraphQL.graphql_type_registry = {}
+            GraphQL.graphql_filter_type_registry = {}
+
+            if fallback_app is not None:
+                global_apps.get_containing_app_config = createFallbackGetApp(
+                    fallback_app
+                )
+
+            # 1) user-defined setUpClass (if any)
+            if user_setup:
+                user_setup.__func__(cls)
+            # 2) clear URL patterns
+            _default_graphql_url_clear()
+            # 3) register models & create tables
+            existing = connection.introspection.table_names()
+            with connection.schema_editor() as editor:
+                for manager_class in cls.general_manager_classes:
+                    model_class = cast(
+                        type[models.Model], manager_class.Interface._model  # type: ignore
+                    )
+                    if model_class._meta.db_table not in existing:
+                        editor.create_model(model_class)
+                        editor.create_model(model_class.history.model)  # type: ignore
+            # 4) GM & GraphQL initialization
+            GeneralmanagerConfig.initializeGeneralManagerClasses(
+                cls.general_manager_classes, cls.general_manager_classes
+            )
+            GeneralmanagerConfig.handleReadOnlyInterface(cls.read_only_classes)
+            GeneralmanagerConfig.handleGraphQL(cls.general_manager_classes)
+            # 5) GraphQLTransactionTestCase.setUpClass
+            base_setup.__func__(cls)
+
+        attrs["setUpClass"] = classmethod(wrapped_setUpClass)
+        return super().__new__(mcs, name, bases, attrs)
+
+
+class GeneralManagerTransactionTestCase(
+    GraphQLTransactionTestCase, metaclass=GMTestCaseMeta
+):
+    general_manager_classes: list[type[GeneralManager]] = []
+    read_only_classes: list[type[GeneralManager]] = []
+    fallback_app: str | None = "general_manager"

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

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

@@ -1,5 +1,5 @@
 general_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-general_manager/apps.py,sha256=P_SmEPHto0Wl7cgP6l2MAOQJgXjuGBLzRIidpfHsdc0,8316
+general_manager/apps.py,sha256=Q6_by4VT4BtL6TxqyI0tG3XeiU3C3QZSiH4ok9a4XJY,8928
 general_manager/api/graphql.py,sha256=ZMzlpgmyn2X9Zwxo12r-b5UZ2R-u1pXys_nhNczxyX8,31622
 general_manager/api/mutation.py,sha256=RYCogAdUpUedyh2B9keMAzq9u-iIhEKAsoiw5xXmhrQ,5669
 general_manager/api/property.py,sha256=oc93p1P8dcIvrNorRuqD1EJVsd6eYttYhZuAS0s28gs,696
@@ -27,16 +27,17 @@ general_manager/factory/factoryMethods.py,sha256=9Bag891j0XHe3dUBAFi7gUKcKeUwcBZ
 general_manager/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 general_manager/interface/baseInterface.py,sha256=GCMo0MGlaRAElovfI34qfuWuVYOyTQLG0OA-ZJx8i3s,8604
 general_manager/interface/calculationInterface.py,sha256=Kg_OqLw67tcLwdzYNLq31eKVLzkM7taw-8Mzmk0CYi0,4232
-general_manager/interface/databaseBasedInterface.py,sha256=twdqUyvPci77WXqCX0k2dpFajhx38bbUfgxrV_BjcxQ,22788
-general_manager/interface/databaseInterface.py,sha256=kYPuwjAVcVMbxozc-eg-LwGY1C0k-sqt73b7DSlVxWI,6389
+general_manager/interface/databaseBasedInterface.py,sha256=S7xSEYnguihx5RD633hwXcDk830a9-NwOwOnCFmeJMo,20738
+general_manager/interface/databaseInterface.py,sha256=UBmsfS6gF-3G6slvrGsq3UbKhSkWBWqtSOzRmdsw3Cw,6627
+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/groupManager.py,sha256=8dpZUfm7aFL4lraUWv4qbbDRClQZaYxw4prclhBZYZs,4367
 general_manager/manager/input.py,sha256=-pJXGJ-g2-OxZfl4Buj3mQkf05fN4p8MsR2Lh9BQcEo,3208
-general_manager/manager/meta.py,sha256=gtzFKBMCvyAx5qo2BVuTBqHZzngR-ivu8YLY7oiSUEk,5059
+general_manager/manager/meta.py,sha256=IN5Xzz4lcUBe2umqvBz84qoyjkzKubNaMwfuYFQjFGU,5631
 general_manager/measurement/__init__.py,sha256=X97meFujBldE5v0WMF7SmKeGpC5R0JTczfLo_Lq1Xek,84
-general_manager/measurement/measurement.py,sha256=e_FjHieeJbBtjXGCO9J7vRPw6KCkMrOxwWjaD0m8ee4,11777
+general_manager/measurement/measurement.py,sha256=0jVU6eZmEwDs0CW_W_RpUxaWDPd9J4uQXWPpxMkfJWQ,16079
 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
@@ -47,8 +48,9 @@ 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
-generalmanager-0.8.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
-generalmanager-0.8.0.dist-info/METADATA,sha256=awQ6aVm9myhb0KpGFMC_2Pc_McXqbMzECdrwxeORSkM,6205
-generalmanager-0.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-generalmanager-0.8.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
-generalmanager-0.8.0.dist-info/RECORD,,
+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,,