GeneralManager 0.60.4__tar.gz → 0.60.6__tar.gz

{generalmanager-0.60.4/src/GeneralManager.egg-info → generalmanager-0.60.6}/PKG-INFO

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

{generalmanager-0.60.4 → generalmanager-0.60.6}/pyproject.toml

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

{generalmanager-0.60.4 → generalmanager-0.60.6/src/GeneralManager.egg-info}/PKG-INFO

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

{generalmanager-0.60.4 → generalmanager-0.60.6}/src/general_manager/api/graphql_errors.py

@@ -239,10 +239,10 @@ HANDLED_MANAGER_ERRORS: tuple[type[Exception], ...] = (
 
 
 class MeasurementType(ObjectType):
-    """GraphQL object wrapper exposing measurement magnitude and Pint unit text.
+    """GraphQL object wrapper exposing measurement magnitude and unit text.
 
     ``value`` is emitted through Graphene ``Float`` and may lose Decimal
-    precision. ``unit`` is the measurement's canonical Pint unit string.
+    precision. ``unit`` is the measurement's GeneralManager public unit string.
     """
 
     value = Float()
@@ -259,7 +259,7 @@ class MeasurementScalar(Scalar):
     are outside the documented user API.
 
     ``serialize()`` accepts only ``Measurement`` instances and returns their
-    canonical string representation; it raises ``InvalidMeasurementValueError``
+    public string representation; it raises ``InvalidMeasurementValueError``
     for every other value. ``parse_value()`` is the public variable-input parser,
     accepts a string, and returns a ``Measurement``. Type checkers should reject
     non-string direct calls. Runtime non-string calls are unsupported; their

{generalmanager-0.60.4 → generalmanager-0.60.6}/src/general_manager/api/graphql_resolvers.py

@@ -588,7 +588,7 @@ def create_measurement_resolver(field_name: str) -> Resolver:
             result = result.to(target_unit)
         return {
             "value": result.quantity.magnitude,
-            "unit": str(result.quantity.units),
+            "unit": result.unit,
         }
 
     return resolver

{generalmanager-0.60.4 → generalmanager-0.60.6}/src/general_manager/chat/system_prompt.py

@@ -255,16 +255,21 @@ def _relationship_lines(
     index: dict[str, dict[str, object]], manager_names: list[str]
 ) -> list[str]:
     relationship_lines: list[str] = []
-    if not PathMap.mapping and manager_names:
-        PathMap(manager_names[0])
-    for (from_manager, to_manager), tracer in sorted(PathMap.mapping.items()):
-        if from_manager not in index or to_manager not in index:
-            continue
-        path = getattr(tracer, "path", None)
-        if path:
-            relationship_lines.append(
-                f"{from_manager} -> {to_manager}: {' -> '.join(path)}"
-            )
+    exposed_names = [name for name in manager_names if name in index]
+    if len(exposed_names) > PROMPT_MANAGER_DETAIL_LIMIT:
+        # Bound lazy path resolution to avoid reintroducing CPU-bound O(n^2) work.
+        return relationship_lines
+    for from_manager in exposed_names:
+        path_map = PathMap(from_manager)
+        for to_manager in exposed_names:
+            if from_manager == to_manager:
+                continue
+            tracer = path_map.to(to_manager)
+            path = getattr(tracer, "path", None) if tracer is not None else None
+            if path:
+                relationship_lines.append(
+                    f"{from_manager} -> {to_manager}: {' -> '.join(path)}"
+                )
     return relationship_lines
 
 

{generalmanager-0.60.4 → generalmanager-0.60.6}/src/general_manager/measurement/measurement.py

@@ -19,12 +19,19 @@ ComparisonOperation: TypeAlias = Callable[[QuantityMagnitude, QuantityMagnitude]
 # Set precision for Decimal
 getcontext().prec = 28
 _PERCENT_SCALE = Decimal("100")
+_COUNT_PUBLIC_UNIT = "count"
+_PIECE_COUNT_CANONICAL_UNIT = "piece"
 
 # Create a new UnitRegistry
 ureg: pint.UnitRegistry[QuantityMagnitude] = pint.UnitRegistry(
     auto_reduce_dimensions=True
 )
 
+# Pint defines "count" as dimensionless. GeneralManager treats discrete item
+# counts as their own unit family so scalar arithmetic cannot silently erase it.
+ureg.define(f"{_PIECE_COUNT_CANONICAL_UNIT} = [piece_count] = {_COUNT_PUBLIC_UNIT}")
+_PIECE_COUNT_UNIT = ureg.parse_units(_COUNT_PUBLIC_UNIT)
+
 # Define currency units
 currency_units = ["EUR", "USD", "GBP", "JPY", "CHF", "AUD", "CAD"]
 for currency in currency_units:
@@ -43,7 +50,10 @@ def _parse_unit(unit: str) -> pint.Unit:
 def _canonical_unit_string(unit: str) -> str:
     """Return Pint's canonical unit string for one unit expression."""
 
-    return str(_parse_unit(unit))
+    parsed_unit = _parse_unit(unit)
+    if parsed_unit == _PIECE_COUNT_UNIT:
+        return _COUNT_PUBLIC_UNIT
+    return str(parsed_unit)
 
 
 def _format_decimal(value: Decimal) -> Decimal:
@@ -496,8 +506,11 @@ class Measurement:
     comparison, string parsing, pickling, and explicit currency conversion.
     Currency conversions never use implicit rates; callers must pass an
     ``exchange_rate`` when converting between different configured currencies.
-    Pint canonicalizes unit names, so ``unit`` and string/repr output may use
-    canonical names such as ``"kilogram"`` rather than the caller's spelling.
+    Pint canonicalizes most unit names, so ``unit`` and string/repr output may
+    use canonical names such as ``"kilogram"`` rather than the caller's
+    spelling. GeneralManager keeps the public ``"count"`` spelling for discrete
+    piece-count measurements even though Pint represents that base unit
+    internally as ``"piece"``.
     Exact Pint exception subclasses/messages, canonical compound-unit ordering,
     aliases, and offset-unit internals are delegated to the installed Pint
     version and are not a stable GeneralManager API contract.
@@ -515,8 +528,10 @@ class Measurement:
         Converts the provided numeric-like value to a Decimal through
         ``Decimal(str(value))`` and constructs the internal quantity using the
         given Pint unit expression. ``unit`` may be ``"dimensionless"`` or an
-        empty string for dimensionless measurements. Invalid units are reported
-        by Pint and are not wrapped by this constructor. String values are
+        empty string for dimensionless measurements. Discrete item quantities
+        should use ``"count"``, which belongs to its own unit family rather than
+        Pint's plain dimensionless family. Invalid units are reported by Pint and
+        are not wrapped by this constructor. String values are
         numeric magnitudes only; use ``from_string()`` for combined
         ``"<value> <unit>"`` text. ``bool`` is rejected even though it is an
         ``int`` subclass in Python.
@@ -531,7 +546,8 @@ class Measurement:
             value (Decimal | float | int | str): Numeric value to use as the measurement magnitude; strings and numeric types are coerced to Decimal.
             unit (str): Unit label registered in the module's unit registry,
                 including configured currency codes, physical unit names,
-                compound Pint expressions such as ``"kg / m^2"``, or
+                ``"count"`` for discrete item quantities, compound Pint
+                expressions such as ``"kg / m^2"``, or
                 dimensionless units.
 
         Raises:
@@ -585,7 +601,9 @@ class Measurement:
 
         self.__quantity = quantity
         self.__magnitude = _decimal_from_magnitude(quantity.magnitude)
-        self.__unit = unit if unit is not None else str(quantity.units)
+        self.__unit = (
+            unit if unit is not None else _canonical_unit_string(str(quantity.units))
+        )
         self.__quantity_exposed = False
 
     def __current_quantity(self) -> MeasurementQuantity:
@@ -605,7 +623,7 @@ class Measurement:
 
     def __current_unit(self) -> str:
         if self.__quantity_exposed:
-            return str(self.__current_quantity().units)
+            return _canonical_unit_string(str(self.__current_quantity().units))
         return self.__unit
 
     def __getstate__(self) -> dict[str, str]:
@@ -671,12 +689,15 @@ class Measurement:
         """
         Retrieve the unit label associated with the measurement.
 
-        The returned value is Pint's canonical unit string, not necessarily the
-        spelling passed to the constructor. Empty-string and ``"dimensionless"``
-        inputs both expose ``"dimensionless"``.
+        The returned value is GeneralManager's public unit string, usually
+        Pint's canonical unit string and not necessarily the spelling passed to
+        the constructor. Empty-string and ``"dimensionless"`` inputs both expose
+        ``"dimensionless"``. Discrete piece-count inputs such as ``"count"``
+        and ``"piece"`` expose ``"count"`` while Pint's internal quantity uses
+        ``"piece"``. The Pint ``"pc"`` alias remains parsec, not piece count.
 
         Returns:
-            str: Canonical unit string as provided by the unit registry.
+            str: Public unit string used by GeneralManager.
         """
         return self.__current_unit()
 
@@ -1118,8 +1139,8 @@ class Measurement:
         Return a detailed representation suitable for debugging.
 
         The magnitude is read through the ``magnitude`` property, and the unit
-        is Pint's canonical unit string. The GeneralManager-owned shape is
-        ``Measurement(<magnitude>, '<canonical unit>')``; exact magnitude and
+        is GeneralManager's public unit string. The GeneralManager-owned shape is
+        ``Measurement(<magnitude>, '<unit>')``; exact magnitude and
         compound-unit spelling follow the documented Decimal/Pint boundaries.
 
         Returns:

{generalmanager-0.60.4 → generalmanager-0.60.6}/src/general_manager/measurement/measurement_field.py

@@ -73,10 +73,10 @@ class MeasurementField(MeasurementFieldBase):
         """
         Create a MeasurementField configured with a canonical base unit and paired backing columns.
 
-        Initializes the field's canonical base unit and derived dimensionality, records the editable flag, constructs a Decimal-backed value column (`<name>_value`) and Char-backed unit column (`<name>_unit`), and forwards remaining arguments to the base Field constructor. Stored magnitudes are converted to `base_unit` and rounded to the backing `DecimalField(max_digits=30, decimal_places=10)` precision; the unit column stores Pint's canonical spelling for the assigned unit, such as `gram` for `g`.
+        Initializes the field's canonical base unit and derived dimensionality, records the editable flag, constructs a Decimal-backed value column (`<name>_value`) and Char-backed unit column (`<name>_unit`), and forwards remaining arguments to the base Field constructor. Stored magnitudes are converted to `base_unit` and rounded to the backing `DecimalField(max_digits=30, decimal_places=10)` precision; the unit column stores the Measurement's public unit spelling, such as `gram` for `g` and `count` for discrete item counts.
 
         Parameters:
-            base_unit (str): Multiplicative Pint unit used to normalize and store measurements. Currency units must be one of `currency_units`; each configured currency is treated as its own Pint dimension.
+            base_unit (str): Multiplicative Pint unit used to normalize and store measurements. Currency units must be one of `currency_units`; each configured currency is treated as its own Pint dimension. Use `count` for discrete item quantities.
             *args (object): Positional arguments forwarded to the base Field implementation.
             null (bool): If True, the backing columns may be NULL in the database.
             blank (bool): If True, forms may accept an empty value for this field.
@@ -536,7 +536,7 @@ class MeasurementField(MeasurementFieldBase):
         Resolve the field value on an instance, reconstructing the measurement when possible.
 
         The descriptor reads `<name>_value` as a base-unit magnitude and
-        `<name>_unit` as Pint's canonical spelling for the unit originally assigned. It converts the
+        `<name>_unit` as the Measurement public spelling for the unit originally assigned. It converts the
         base magnitude back to that stored unit for display. If stored data has
         drifted and the unit is no longer parseable or dimensionally compatible with the base
         unit, reconstruction falls back to a Measurement in `base_unit` rather
@@ -655,7 +655,7 @@ class MeasurementField(MeasurementFieldBase):
             ) from e
 
         setattr(instance, self.value_attr, self._normalize_base_magnitude(base_mag))
-        setattr(instance, self.unit_attr, str(value.quantity.units))
+        setattr(instance, self.unit_attr, str(value.unit))
 
     def validate(
         self,