ucon 0.6.2__tar.gz → 0.6.4__tar.gz

{ucon-0.6.2 → ucon-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucon
-Version: 0.6.2
+Version: 0.6.4
 Summary: A tool for dimensional analysis: a 'Unit CONverter'
 Home-page: https://github.com/withtwoemms/ucon
 Author: Emmanuel I. Obi

{ucon-0.6.2 → ucon-0.6.4}/ROADMAP.md

@@ -244,6 +244,7 @@ Building on v0.5.x baseline:
 - [x] `parse("kg * m / s^2")` → `UnitProduct` (completed in v0.6.0 via `get_unit_by_name()`)
 - [x] Alias resolution (`meters`, `metre`, `m` all work) (completed in v0.6.0)
 - [ ] Uncertainty parsing: `parse("1.234 ± 0.005 m")`
+- [ ] Revisit priority alias architecture (v0.6.x uses `_PRIORITY_ALIASES` / `_PRIORITY_SCALED_ALIASES` for `min`, `mcg`; consider "exact match first" or longest-match strategy if list grows)
 
 **Outcomes:**
 - Human-friendly unit input for interactive and configuration use cases

{ucon-0.6.2 → ucon-0.6.4}/tests/ucon/test_unit_parsing.py

@@ -329,5 +329,70 @@ class TestPriorityAliases(unittest.TestCase):
         self.assertEqual(result, units.inch)
 
 
+class TestPriorityScaledAliases(unittest.TestCase):
+    """Test priority scaled aliases for domain-specific conventions.
+
+    Some domains use non-standard abbreviations that include an implicit
+    scale, like 'mcg' for microgram in medical contexts.
+    """
+
+    def test_mcg_is_microgram(self):
+        """'mcg' should parse as microgram (medical convention)."""
+        from ucon.core import Dimension
+        result = get_unit_by_name("mcg")
+        self.assertIsInstance(result, UnitProduct)
+        self.assertEqual(result.dimension, Dimension.mass)
+        self.assertAlmostEqual(result.fold_scale(), 1e-6, places=15)
+
+    def test_mcg_to_mg(self):
+        """Conversion from mcg to mg should work."""
+        from ucon.core import Number
+        dose = Number(500, unit=get_unit_by_name("mcg"))
+        result = dose.to(get_unit_by_name("mg"))
+        self.assertAlmostEqual(result.quantity, 0.5, places=9)
+
+    def test_mcg_to_ug(self):
+        """mcg and µg should be equivalent."""
+        from ucon.core import Number
+        dose = Number(1, unit=get_unit_by_name("mcg"))
+        result = dose.to(get_unit_by_name("µg"))
+        self.assertAlmostEqual(result.quantity, 1.0, places=9)
+
+    def test_mcg_in_composite(self):
+        """'mcg' should work in composite units."""
+        result = get_unit_by_name("mcg/mL")
+        self.assertIsInstance(result, UnitProduct)
+        from ucon.core import Dimension
+        self.assertEqual(result.dimension, Dimension.density)
+
+    def test_mcg_per_kg_per_min(self):
+        """'mcg/kg/min' style dosing units (requires chained division support)."""
+        # This tests mcg works; chained division is a separate issue
+        result = get_unit_by_name("mcg")
+        self.assertIsInstance(result, UnitProduct)
+
+    def test_cc_is_milliliter(self):
+        """'cc' should parse as milliliter (1 cc = 1 mL)."""
+        from ucon.core import Dimension
+        result = get_unit_by_name("cc")
+        self.assertIsInstance(result, UnitProduct)
+        self.assertEqual(result.dimension, Dimension.volume)
+        self.assertAlmostEqual(result.fold_scale(), 0.001, places=10)
+
+    def test_cc_to_mL(self):
+        """Conversion from cc to mL should be 1:1."""
+        from ucon.core import Number
+        vol = Number(5, unit=get_unit_by_name("cc"))
+        result = vol.to(get_unit_by_name("mL"))
+        self.assertAlmostEqual(result.quantity, 5.0, places=9)
+
+    def test_cc_to_L(self):
+        """Conversion from cc to L should work."""
+        from ucon.core import Number
+        vol = Number(1000, unit=get_unit_by_name("cc"))
+        result = vol.to(get_unit_by_name("L"))
+        self.assertAlmostEqual(result.quantity, 1.0, places=9)
+
+
 if __name__ == '__main__':
     unittest.main()

{ucon-0.6.2 → ucon-0.6.4}/ucon/units.py

@@ -208,6 +208,11 @@ _UNIT_REGISTRY_CASE_SENSITIVE: Dict[str, Unit] = {}
 # Prevents ambiguous parses like "min" -> milli-inch instead of minute.
 _PRIORITY_ALIASES: set = {'min'}
 
+# Priority scaled aliases that map to a specific (unit, scale) tuple.
+# Used for medical conventions like "mcg" -> (gram, Scale.micro).
+# Populated by _build_registry() after units are defined.
+_PRIORITY_SCALED_ALIASES: Dict[str, Tuple[Unit, Scale]] = {}
+
 # Scale prefix mapping (shorthand -> Scale)
 # Sorted by length descending for greedy matching
 _SCALE_PREFIXES: Dict[str, Scale] = {
@@ -260,6 +265,10 @@ def _build_registry() -> None:
                     _UNIT_REGISTRY[alias.lower()] = obj
                     _UNIT_REGISTRY_CASE_SENSITIVE[alias] = obj
 
+    # Register priority scaled aliases (medical conventions)
+    _PRIORITY_SCALED_ALIASES['mcg'] = (gram, Scale.micro)  # microgram
+    _PRIORITY_SCALED_ALIASES['cc'] = (liter, Scale.milli)  # cubic centimeter = 1 mL
+
 
 def _parse_exponent(s: str) -> Tuple[str, float]:
     """
@@ -299,8 +308,8 @@ def _lookup_factor(s: str) -> Tuple[Unit, Scale]:
     Look up a single unit factor, handling scale prefixes.
 
     Prioritizes prefix+unit interpretation over direct unit lookup,
-    except for priority aliases (like 'min') which are checked first
-    to avoid ambiguous parses.
+    except for priority aliases (like 'min', 'mcg') which are checked first
+    to avoid ambiguous parses or to handle domain-specific conventions.
 
     This means "kg" returns (gram, Scale.kilo) rather than (kilogram, Scale.one).
 
@@ -311,6 +320,7 @@ def _lookup_factor(s: str) -> Tuple[Unit, Scale]:
     - 'kg' -> (gram, Scale.kilo)
     - 'mL' -> (liter, Scale.milli)
     - 'min' -> (minute, Scale.one)  # priority alias, not milli-inch
+    - 'mcg' -> (gram, Scale.micro)  # medical convention for microgram
 
     Returns:
         Tuple of (unit, scale).
@@ -318,7 +328,11 @@ def _lookup_factor(s: str) -> Tuple[Unit, Scale]:
     Raises:
         UnknownUnitError: If the unit cannot be resolved.
     """
-    # Check priority aliases first (prevents "min" -> milli-inch)
+    # Check priority scaled aliases first (e.g., "mcg" -> microgram)
+    if s in _PRIORITY_SCALED_ALIASES:
+        return _PRIORITY_SCALED_ALIASES[s]
+
+    # Check priority aliases (prevents "min" -> milli-inch)
     if s in _PRIORITY_ALIASES:
         if s in _UNIT_REGISTRY_CASE_SENSITIVE:
             return _UNIT_REGISTRY_CASE_SENSITIVE[s], Scale.one

{ucon-0.6.2 → ucon-0.6.4}/ucon.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucon
-Version: 0.6.2
+Version: 0.6.4
 Summary: A tool for dimensional analysis: a 'Unit CONverter'
 Home-page: https://github.com/withtwoemms/ucon
 Author: Emmanuel I. Obi