ucon 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

tests/ucon/test_graph_basis_transform.py

@@ -0,0 +1,263 @@
+# (c) 2026 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+"""
+Tests for ConversionGraph integration with BasisTransform.
+
+Verifies cross-basis edge handling, RebasedUnit creation,
+and conversion paths that span dimensional bases.
+"""
+
+import unittest
+from fractions import Fraction
+
+from ucon.core import (
+    BasisTransform,
+    Dimension,
+    RebasedUnit,
+    Unit,
+    UnitSystem,
+)
+from ucon.graph import ConversionGraph, DimensionMismatch
+from ucon.maps import LinearMap
+from ucon import units
+
+
+class TestGraphAddEdgeWithBasisTransform(unittest.TestCase):
+    """Test add_edge with basis_transform parameter."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+            }
+        )
+        self.imperial = UnitSystem(
+            name="Imperial",
+            bases={
+                Dimension.length: units.foot,
+                Dimension.mass: units.pound,
+                Dimension.time: units.second,
+            }
+        )
+        # Simple 1:1 transform for length
+        self.bt = BasisTransform(
+            src=self.imperial,
+            dst=self.si,
+            src_dimensions=(Dimension.length,),
+            dst_dimensions=(Dimension.length,),
+            matrix=((1,),),
+        )
+        self.graph = ConversionGraph()
+
+    def test_add_edge_with_basis_transform(self):
+        # foot -> meter with basis transform
+        self.graph.add_edge(
+            src=units.foot,
+            dst=units.meter,
+            map=LinearMap(0.3048),
+            basis_transform=self.bt,
+        )
+        # Verify the rebased unit was created
+        self.assertIn(units.foot, self.graph._rebased)
+        rebased = self.graph._rebased[units.foot]
+        self.assertIsInstance(rebased, RebasedUnit)
+        self.assertEqual(rebased.original, units.foot)
+        self.assertEqual(rebased.rebased_dimension, Dimension.length)
+
+    def test_add_edge_without_basis_transform_requires_same_dimension(self):
+        # foot and meter both have Dimension.length, so this should work
+        self.graph.add_edge(
+            src=units.foot,
+            dst=units.meter,
+            map=LinearMap(0.3048),
+        )
+        # Verify no rebased unit was created (normal edge)
+        self.assertNotIn(units.foot, self.graph._rebased)
+
+
+class TestGraphConvertWithBasisTransform(unittest.TestCase):
+    """Test convert() with cross-basis edges."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+            }
+        )
+        self.imperial = UnitSystem(
+            name="Imperial",
+            bases={
+                Dimension.length: units.foot,
+                Dimension.mass: units.pound,
+                Dimension.time: units.second,
+            }
+        )
+        self.bt = BasisTransform(
+            src=self.imperial,
+            dst=self.si,
+            src_dimensions=(Dimension.length,),
+            dst_dimensions=(Dimension.length,),
+            matrix=((1,),),
+        )
+        self.graph = ConversionGraph()
+        # Add edge with basis transform
+        self.graph.add_edge(
+            src=units.foot,
+            dst=units.meter,
+            map=LinearMap(0.3048),
+            basis_transform=self.bt,
+        )
+
+    def test_convert_uses_rebased_path(self):
+        # Convert via the rebased edge
+        map = self.graph.convert(src=units.foot, dst=units.meter)
+        # 1 foot = 0.3048 meters
+        self.assertAlmostEqual(map(1), 0.3048, places=5)
+
+    def test_convert_inverse_works(self):
+        # The inverse edge should also be available
+        map = self.graph.convert(src=units.meter, dst=units.foot)
+        # 1 meter ≈ 3.28084 feet
+        self.assertAlmostEqual(map(1), 1/0.3048, places=5)
+
+
+class TestGraphConnectSystems(unittest.TestCase):
+    """Test connect_systems convenience method."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+            }
+        )
+        self.imperial = UnitSystem(
+            name="Imperial",
+            bases={
+                Dimension.length: units.foot,
+                Dimension.mass: units.pound,
+                Dimension.time: units.second,
+            }
+        )
+        self.bt = BasisTransform(
+            src=self.imperial,
+            dst=self.si,
+            src_dimensions=(Dimension.length, Dimension.mass),
+            dst_dimensions=(Dimension.length, Dimension.mass),
+            matrix=((1, 0), (0, 1)),
+        )
+        self.graph = ConversionGraph()
+
+    def test_connect_systems_bulk_adds_edges(self):
+        self.graph.connect_systems(
+            basis_transform=self.bt,
+            edges={
+                (units.foot, units.meter): LinearMap(0.3048),
+                (units.pound, units.kilogram): LinearMap(0.453592),
+            }
+        )
+        # Both should be converted
+        length_map = self.graph.convert(src=units.foot, dst=units.meter)
+        self.assertAlmostEqual(length_map(1), 0.3048, places=5)
+
+        mass_map = self.graph.convert(src=units.pound, dst=units.kilogram)
+        self.assertAlmostEqual(mass_map(1), 0.453592, places=5)
+
+
+class TestGraphListTransforms(unittest.TestCase):
+    """Test introspection methods for transforms."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+            }
+        )
+        self.imperial = UnitSystem(
+            name="Imperial",
+            bases={
+                Dimension.length: units.foot,
+            }
+        )
+        self.bt = BasisTransform(
+            src=self.imperial,
+            dst=self.si,
+            src_dimensions=(Dimension.length,),
+            dst_dimensions=(Dimension.length,),
+            matrix=((1,),),
+        )
+        self.graph = ConversionGraph()
+        self.graph.add_edge(
+            src=units.foot,
+            dst=units.meter,
+            map=LinearMap(0.3048),
+            basis_transform=self.bt,
+        )
+
+    def test_list_rebased_units(self):
+        rebased = self.graph.list_rebased_units()
+        self.assertEqual(len(rebased), 1)
+        self.assertIn(units.foot, rebased)
+        self.assertIsInstance(rebased[units.foot], RebasedUnit)
+
+    def test_list_transforms(self):
+        transforms = self.graph.list_transforms()
+        self.assertEqual(len(transforms), 1)
+        self.assertEqual(transforms[0], self.bt)
+
+    def test_edges_for_transform(self):
+        edges = self.graph.edges_for_transform(self.bt)
+        self.assertEqual(len(edges), 1)
+        self.assertEqual(edges[0], (units.foot, units.meter))
+
+    def test_list_transforms_multiple(self):
+        # Add another transform
+        custom = UnitSystem(
+            name="Custom",
+            bases={Dimension.mass: units.pound}
+        )
+        bt2 = BasisTransform(
+            src=custom,
+            dst=self.si,
+            src_dimensions=(Dimension.mass,),
+            dst_dimensions=(Dimension.mass,),
+            matrix=((1,),),
+        )
+        # Need to add a mass base to SI for this test
+        si_with_mass = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+            }
+        )
+        bt2 = BasisTransform(
+            src=custom,
+            dst=si_with_mass,
+            src_dimensions=(Dimension.mass,),
+            dst_dimensions=(Dimension.mass,),
+            matrix=((1,),),
+        )
+        self.graph.add_edge(
+            src=units.pound,
+            dst=units.kilogram,
+            map=LinearMap(0.453592),
+            basis_transform=bt2,
+        )
+        transforms = self.graph.list_transforms()
+        self.assertEqual(len(transforms), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/ucon/test_rebased_unit.py

@@ -0,0 +1,184 @@
+# (c) 2026 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+"""
+Tests for RebasedUnit.
+
+Verifies that units transformed by a BasisTransform preserve
+provenance while exposing the rebased dimension.
+"""
+
+import unittest
+from fractions import Fraction
+
+from ucon.core import (
+    BasisTransform,
+    Dimension,
+    RebasedUnit,
+    Unit,
+    UnitSystem,
+)
+from ucon import units
+
+
+class TestRebasedUnitConstruction(unittest.TestCase):
+    """Test RebasedUnit construction."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+            }
+        )
+        self.custom = UnitSystem(
+            name="Custom",
+            bases={
+                Dimension.length: units.foot,
+                Dimension.mass: units.pound,
+                Dimension.time: units.second,
+            }
+        )
+        self.bt = BasisTransform(
+            src=self.custom,
+            dst=self.si,
+            src_dimensions=(Dimension.length,),
+            dst_dimensions=(Dimension.length,),
+            matrix=((1,),),
+        )
+
+    def test_valid_construction(self):
+        rebased = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        self.assertEqual(rebased.original, units.foot)
+        self.assertEqual(rebased.rebased_dimension, Dimension.length)
+        self.assertEqual(rebased.basis_transform, self.bt)
+
+    def test_dimension_property(self):
+        rebased = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        self.assertEqual(rebased.dimension, Dimension.length)
+
+    def test_name_property(self):
+        rebased = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        self.assertEqual(rebased.name, "foot")
+
+
+class TestRebasedUnitEquality(unittest.TestCase):
+    """Test RebasedUnit equality and hashing."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+            }
+        )
+        self.custom = UnitSystem(
+            name="Custom",
+            bases={
+                Dimension.length: units.foot,
+                Dimension.mass: units.pound,
+                Dimension.time: units.second,
+            }
+        )
+        self.bt = BasisTransform(
+            src=self.custom,
+            dst=self.si,
+            src_dimensions=(Dimension.length,),
+            dst_dimensions=(Dimension.length,),
+            matrix=((1,),),
+        )
+
+    def test_equal_rebased_units(self):
+        r1 = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        r2 = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        self.assertEqual(r1, r2)
+
+    def test_hashable(self):
+        r1 = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        r2 = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        self.assertEqual(hash(r1), hash(r2))
+        self.assertEqual(len({r1, r2}), 1)
+
+    def test_different_original_not_equal(self):
+        r1 = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        r2 = RebasedUnit(
+            original=units.inch,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        self.assertNotEqual(r1, r2)
+
+
+class TestRebasedUnitImmutability(unittest.TestCase):
+    """Test that RebasedUnit is immutable."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+            }
+        )
+        self.custom = UnitSystem(
+            name="Custom",
+            bases={
+                Dimension.length: units.foot,
+            }
+        )
+        self.bt = BasisTransform(
+            src=self.custom,
+            dst=self.si,
+            src_dimensions=(Dimension.length,),
+            dst_dimensions=(Dimension.length,),
+            matrix=((1,),),
+        )
+
+    def test_frozen_dataclass(self):
+        rebased = RebasedUnit(
+            original=units.foot,
+            rebased_dimension=Dimension.length,
+            basis_transform=self.bt,
+        )
+        with self.assertRaises(AttributeError):
+            rebased.original = units.meter
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/ucon/test_unit_system.py

@@ -0,0 +1,174 @@
+# © 2026 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+"""
+Tests for UnitSystem.
+
+Verifies construction, validation, and query methods for named
+unit system definitions.
+"""
+
+import unittest
+
+from ucon import units
+from ucon.core import Dimension, Unit, UnitSystem, DimensionNotCovered
+
+
+class TestUnitSystemConstruction(unittest.TestCase):
+    """Test UnitSystem construction and validation."""
+
+    def test_valid_construction(self):
+        system = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+            }
+        )
+        self.assertEqual(system.name, "SI")
+        self.assertEqual(len(system.bases), 3)
+
+    def test_single_base_allowed(self):
+        system = UnitSystem(
+            name="length-only",
+            bases={Dimension.length: units.meter}
+        )
+        self.assertEqual(len(system.bases), 1)
+
+    def test_empty_name_rejected(self):
+        with self.assertRaises(ValueError) as ctx:
+            UnitSystem(name="", bases={Dimension.length: units.meter})
+        self.assertIn("name", str(ctx.exception).lower())
+
+    def test_empty_bases_rejected(self):
+        with self.assertRaises(ValueError) as ctx:
+            UnitSystem(name="empty", bases={})
+        self.assertIn("base", str(ctx.exception).lower())
+
+    def test_mismatched_dimension_rejected(self):
+        # meter has Dimension.length, but we declare it as mass
+        with self.assertRaises(ValueError) as ctx:
+            UnitSystem(
+                name="bad",
+                bases={Dimension.mass: units.meter}
+            )
+        self.assertIn("dimension", str(ctx.exception).lower())
+
+    def test_partial_system_allowed(self):
+        # Imperial doesn't need mole or candela
+        system = UnitSystem(
+            name="Imperial",
+            bases={
+                Dimension.length: units.foot,
+                Dimension.mass: units.pound,
+                Dimension.time: units.second,
+            }
+        )
+        self.assertEqual(len(system.bases), 3)
+
+
+class TestUnitSystemQueries(unittest.TestCase):
+    """Test UnitSystem query methods."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+                Dimension.temperature: units.kelvin,
+            }
+        )
+
+    def test_covers_returns_true_for_covered(self):
+        self.assertTrue(self.si.covers(Dimension.length))
+        self.assertTrue(self.si.covers(Dimension.mass))
+        self.assertTrue(self.si.covers(Dimension.time))
+
+    def test_covers_returns_false_for_uncovered(self):
+        self.assertFalse(self.si.covers(Dimension.current))
+        self.assertFalse(self.si.covers(Dimension.luminous_intensity))
+
+    def test_base_for_returns_correct_unit(self):
+        self.assertEqual(self.si.base_for(Dimension.length), units.meter)
+        self.assertEqual(self.si.base_for(Dimension.mass), units.kilogram)
+        self.assertEqual(self.si.base_for(Dimension.time), units.second)
+
+    def test_base_for_raises_for_uncovered(self):
+        with self.assertRaises(DimensionNotCovered) as ctx:
+            self.si.base_for(Dimension.current)
+        self.assertIn("current", str(ctx.exception).lower())
+
+    def test_dimensions_property(self):
+        dims = self.si.dimensions
+        self.assertIsInstance(dims, set)
+        self.assertEqual(len(dims), 4)
+        self.assertIn(Dimension.length, dims)
+        self.assertIn(Dimension.mass, dims)
+
+
+class TestUnitSystemEquality(unittest.TestCase):
+    """Test UnitSystem equality and hashing."""
+
+    def test_same_systems_equal(self):
+        s1 = UnitSystem(
+            name="SI",
+            bases={Dimension.length: units.meter}
+        )
+        s2 = UnitSystem(
+            name="SI",
+            bases={Dimension.length: units.meter}
+        )
+        self.assertEqual(s1, s2)
+
+    def test_different_names_not_equal(self):
+        s1 = UnitSystem(name="SI", bases={Dimension.length: units.meter})
+        s2 = UnitSystem(name="CGS", bases={Dimension.length: units.meter})
+        self.assertNotEqual(s1, s2)
+
+    def test_different_bases_not_equal(self):
+        s1 = UnitSystem(name="test", bases={Dimension.length: units.meter})
+        s2 = UnitSystem(name="test", bases={Dimension.length: units.foot})
+        self.assertNotEqual(s1, s2)
+
+    def test_hashable(self):
+        s1 = UnitSystem(name="SI", bases={Dimension.length: units.meter})
+        s2 = UnitSystem(name="SI", bases={Dimension.length: units.meter})
+        self.assertEqual(hash(s1), hash(s2))
+        self.assertEqual(len({s1, s2}), 1)
+
+
+class TestUnitSystemImmutability(unittest.TestCase):
+    """Test that UnitSystem is immutable."""
+
+    def test_frozen_dataclass(self):
+        system = UnitSystem(
+            name="SI",
+            bases={Dimension.length: units.meter}
+        )
+        with self.assertRaises(AttributeError):
+            system.name = "changed"
+
+
+class TestPredefinedSystems(unittest.TestCase):
+    """Test predefined unit systems in ucon.units."""
+
+    def test_si_system_exists(self):
+        from ucon.units import si
+        self.assertEqual(si.name, "SI")
+        self.assertTrue(si.covers(Dimension.length))
+        self.assertTrue(si.covers(Dimension.mass))
+        self.assertTrue(si.covers(Dimension.time))
+
+    def test_imperial_system_exists(self):
+        from ucon.units import imperial
+        self.assertEqual(imperial.name, "Imperial")
+        self.assertTrue(imperial.covers(Dimension.length))
+        self.assertTrue(imperial.covers(Dimension.mass))
+
+
+if __name__ == "__main__":
+    unittest.main()