ucon 0.6.1__tar.gz → 0.6.3__tar.gz

{ucon-0.6.1 → ucon-0.6.3}/PKG-INFO

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

{ucon-0.6.1 → ucon-0.6.3}/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.1 → ucon-0.6.3}/tests/ucon/test_unit_parsing.py

@@ -286,5 +286,91 @@ class TestWhitespaceHandling(unittest.TestCase):
         self.assertEqual(result, units.meter)
 
 
+class TestPriorityAliases(unittest.TestCase):
+    """Test that priority aliases are matched before prefix decomposition.
+
+    Some aliases like 'min' could be misinterpreted as prefix+unit
+    (e.g., 'm' + 'in' = milli-inch). Priority aliases ensure these
+    are matched exactly first.
+    """
+
+    def test_min_is_minute_not_milli_inch(self):
+        """'min' should parse as minute (time), not milli-inch (length)."""
+        from ucon.core import Dimension
+        result = get_unit_by_name("min")
+        self.assertEqual(result, units.minute)
+        self.assertEqual(result.dimension, Dimension.time)
+
+    def test_min_in_composite(self):
+        """'min' should work correctly in composite units."""
+        result = get_unit_by_name("mL/min")
+        self.assertIsInstance(result, UnitProduct)
+        # Volume / time dimension
+        from ucon.core import Dimension
+        expected_dim = Dimension.volume / Dimension.time
+        self.assertEqual(result.dimension, expected_dim)
+
+    def test_mL_per_min_conversion(self):
+        """Conversion using 'min' should work correctly."""
+        from ucon.core import Number
+        rate_per_hour = Number(120, unit=get_unit_by_name("mL/h"))
+        rate_per_min = rate_per_hour.to(get_unit_by_name("mL/min"))
+        self.assertAlmostEqual(rate_per_min.quantity, 2.0, places=9)
+
+    def test_milli_prefix_still_works(self):
+        """Normal milli- prefix parsing should still work."""
+        result = get_unit_by_name("mL")
+        self.assertIsInstance(result, UnitProduct)
+        self.assertAlmostEqual(result.fold_scale(), 0.001, places=10)
+
+    def test_inch_still_works(self):
+        """Inch unit should still be accessible."""
+        result = get_unit_by_name("in")
+        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)
+
+
 if __name__ == '__main__':
     unittest.main()

{ucon-0.6.1 → ucon-0.6.3}/ucon/units.py

@@ -204,6 +204,15 @@ def have(name: str) -> bool:
 _UNIT_REGISTRY: Dict[str, Unit] = {}
 _UNIT_REGISTRY_CASE_SENSITIVE: Dict[str, Unit] = {}
 
+# Priority aliases that must match exactly before prefix decomposition.
+# 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] = {
@@ -256,6 +265,9 @@ 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
+
 
 def _parse_exponent(s: str) -> Tuple[str, float]:
     """
@@ -294,7 +306,10 @@ 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.
+    Prioritizes prefix+unit interpretation over direct unit lookup,
+    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).
 
     Examples:
@@ -303,6 +318,8 @@ def _lookup_factor(s: str) -> Tuple[Unit, Scale]:
     - 'km' -> (meter, Scale.kilo)
     - '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).
@@ -310,7 +327,19 @@ def _lookup_factor(s: str) -> Tuple[Unit, Scale]:
     Raises:
         UnknownUnitError: If the unit cannot be resolved.
     """
-    # Try scale prefix + unit first (prioritize decomposition)
+    # 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
+        s_lower = s.lower()
+        if s_lower in _UNIT_REGISTRY:
+            return _UNIT_REGISTRY[s_lower], Scale.one
+
+    # Try scale prefix + unit (prioritize decomposition)
     # Only case-sensitive matching for remainder (e.g., "fT" = femto-tesla, "ft" = foot)
     for prefix in _SCALE_PREFIXES_SORTED:
         if s.startswith(prefix) and len(s) > len(prefix):

{ucon-0.6.1 → ucon-0.6.3}/ucon.egg-info/PKG-INFO

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