GeneralManager 0.41.0__tar.gz → 0.41.2__tar.gz

{generalmanager-0.41.0/src/GeneralManager.egg-info → generalmanager-0.41.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.41.0
+Version: 0.41.2
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.41.0 → generalmanager-0.41.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.41.0"
+version = "0.41.2"
 description = "Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching."
 readme = "README.md"
 authors = [{ name = "Tim Kleindick", email = "tkleindick@yahoo.de" }]

{generalmanager-0.41.0 → generalmanager-0.41.2/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.41.0
+Version: 0.41.2
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.41.0 → generalmanager-0.41.2}/src/general_manager/interface/capabilities/orm_utils/field_descriptors.py

@@ -11,6 +11,7 @@ from uuid import UUID
 
 from django.apps import apps
 from django.contrib.contenttypes.fields import GenericForeignKey
+from django.core.exceptions import ObjectDoesNotExist
 from django.db import models
 
 from general_manager.interface.base_interface import AttributeTypedDict
@@ -135,6 +136,7 @@ class _FieldDescriptorBuilder:
         self._add_custom_fields()
         self._add_model_fields()
         self._add_foreign_key_fields()
+        self._add_reverse_one_to_one_relations()
         self._add_collection_relations()
         return self._descriptors
 
@@ -209,6 +211,41 @@ class _FieldDescriptorBuilder:
                 filter_lookup=field.name,
             )
 
+    def _add_reverse_one_to_one_relations(self) -> None:
+        """Register snake_case aliases for reverse one-to-one relation accessors."""
+        for relation in _iter_reverse_one_to_one_relations(self.model):
+            related_model = self._resolve_related_model(
+                getattr(relation, "related_model", None)
+            )
+            if related_model is None:
+                continue
+            accessor_name = relation.get_accessor_name() or relation.name
+            attribute_name = _to_snake_case(related_model.__name__)
+            if attribute_name in self._descriptors:
+                continue
+            general_manager_class = getattr(
+                related_model, "_general_manager_class", None
+            )
+            if general_manager_class:
+                accessor = _general_manager_accessor(
+                    accessor_name, general_manager_class
+                )
+                relation_type = cast(type, general_manager_class)
+            else:
+                accessor = _instance_attribute_accessor(accessor_name)
+                relation_type = cast(type, related_model)
+            self._register(
+                attribute_name=attribute_name,
+                raw_type=relation_type,
+                is_required=False,
+                is_editable=False,
+                default=None,
+                is_derived=True,
+                accessor=accessor,
+                relation_kind="direct",
+                filter_lookup=relation.name,
+            )
+
     def _add_collection_relations(self) -> None:
         """
         Register collection relation field descriptors for the builder's model.
@@ -521,6 +558,22 @@ def _iter_many_to_many_fields(
             yield cast(models.Field, field)
 
 
+def _iter_reverse_one_to_one_relations(
+    model: type[models.Model],
+) -> Iterable[models.OneToOneRel]:
+    """Yield reverse one-to-one relations declared on a Django model."""
+    meta = getattr(model, "_meta", None)
+    get_fields = getattr(meta, "get_fields", None)
+    if not callable(get_fields):
+        return
+    for field in get_fields():
+        if getattr(field, "is_relation", False) and getattr(field, "one_to_one", False):
+            if getattr(field, "auto_created", False) and not getattr(
+                field, "concrete", False
+            ):
+                yield cast(models.OneToOneRel, field)
+
+
 def _iter_reverse_relations(
     model: type[models.Model],
 ) -> Iterable[models.ManyToOneRel]:
@@ -558,7 +611,10 @@ def _instance_attribute_accessor(field_name: str) -> DescriptorAccessor:
         Returns:
             The attribute value retrieved from the underlying model instance.
         """
-        return getattr(self._instance, field_name)
+        try:
+            return getattr(self._instance, field_name)
+        except ObjectDoesNotExist:
+            return None
 
     return getter
 
@@ -584,7 +640,10 @@ def _general_manager_accessor(
         Returns:
             The value produced by calling `manager_class` with the related object's primary key, or `None` if the related object is `None`.
         """
-        related = getattr(self._instance, field_name)
+        try:
+            related = getattr(self._instance, field_name)
+        except ObjectDoesNotExist:
+            return None
         if related is None:
             return None
         return manager_class(related.pk)

{generalmanager-0.41.0 → generalmanager-0.41.2}/src/general_manager/measurement/measurement.py

@@ -2,7 +2,7 @@
 
 # units.py
 from __future__ import annotations
-from typing import Any, Callable
+from typing import Any, Callable, cast
 import math
 import pint
 from decimal import Decimal, getcontext, InvalidOperation
@@ -104,6 +104,27 @@ def _convert_quantity(quantity: PlainQuantity, target_unit: str) -> PlainQuantit
     return source_quantity.to(target_unit)
 
 
+def _currency_component(unit: str) -> tuple[str, int] | None:
+    """Return the single configured currency component in a unit expression."""
+
+    parsed_unit = ureg.parse_units(str(unit))
+    currency_components = [
+        (unit_name, int(cast(Any, power)))
+        for unit_name, power in parsed_unit._units.items()
+        if unit_name in currency_units
+    ]
+    if len(currency_components) != 1:
+        return None
+    return currency_components[0]
+
+
+def _unit_without_currency(unit: str, currency: str, power: int) -> str:
+    """Return a unit expression with one currency component removed."""
+
+    stripped_unit = ureg.parse_units(str(unit)) / (ureg.parse_units(currency) ** power)
+    return str(stripped_unit)
+
+
 def convert_magnitude(value: Decimal, source_unit: str, target_unit: str) -> Decimal:
     """
     Convert a magnitude between units while keeping offset-unit math away from Decimal.
@@ -457,6 +478,30 @@ class Measurement:
         Raises:
             MissingExchangeRateError: If converting between two different currencies without providing an exchange rate.
         """
+        source_currency = _currency_component(self.unit)
+        target_currency = _currency_component(target_unit)
+        if (
+            source_currency is not None
+            and target_currency is not None
+            and source_currency[0] != target_currency[0]
+        ):
+            if exchange_rate is None:
+                raise MissingExchangeRateError()
+            source_currency_name, source_currency_power = source_currency
+            target_currency_name, target_currency_power = target_currency
+            if source_currency_power == target_currency_power:
+                value = convert_magnitude(
+                    self.magnitude,
+                    _unit_without_currency(
+                        self.unit, source_currency_name, source_currency_power
+                    ),
+                    _unit_without_currency(
+                        target_unit, target_currency_name, target_currency_power
+                    ),
+                )
+                value *= Decimal(str(exchange_rate)) ** source_currency_power
+                return Measurement(value, target_unit)
+
         if self.is_currency():
             if str(self.unit) == str(target_unit):
                 return self  # Same currency, no conversion needed