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

ucon/graph.py

@@ -28,7 +28,15 @@ from contextvars import ContextVar
 from dataclasses import dataclass, field
 from typing import Union
 
-from ucon.core import Dimension, Unit, UnitFactor, UnitProduct, Scale
+from ucon.core import (
+    BasisTransform,
+    Dimension,
+    RebasedUnit,
+    Unit,
+    UnitFactor,
+    UnitProduct,
+    Scale,
+)
 from ucon.maps import Map, LinearMap, AffineMap
 
 
@@ -66,6 +74,9 @@ class ConversionGraph:
     # Edges between UnitProducts (keyed by frozen factor representation)
     _product_edges: dict[tuple, dict[tuple, Map]] = field(default_factory=dict)
 
+    # Rebased units: original unit → RebasedUnit (for cross-basis edges)
+    _rebased: dict[Unit, RebasedUnit] = field(default_factory=dict)
+
     # ------------- Edge Management -------------------------------------------
 
     def add_edge(
@@ -74,6 +85,7 @@ class ConversionGraph:
         src: Union[Unit, UnitProduct],
         dst: Union[Unit, UnitProduct],
         map: Map,
+        basis_transform: BasisTransform | None = None,
     ) -> None:
         """Register a conversion edge. Also registers the inverse.
 
@@ -85,15 +97,31 @@ class ConversionGraph:
             Destination unit expression.
         map : Map
             The conversion morphism (src → dst).
+        basis_transform : BasisTransform, optional
+            If provided, creates a cross-basis edge. The src unit is rebased
+            to the dst's dimension and the edge connects the rebased unit
+            to dst.
 
         Raises
         ------
         DimensionMismatch
-            If src and dst have different dimensions.
+            If src and dst have different dimensions (and no basis_transform).
         CyclicInconsistency
             If the reverse edge exists and round-trip is not identity.
         """
-        # Handle Unit vs UnitProduct dispatch
+        # Cross-basis edge with BasisTransform
+        if basis_transform is not None:
+            if isinstance(src, Unit) and not isinstance(src, UnitProduct):
+                if isinstance(dst, Unit) and not isinstance(dst, UnitProduct):
+                    self._add_cross_basis_edge(
+                        src=src,
+                        dst=dst,
+                        map=map,
+                        basis_transform=basis_transform,
+                    )
+                    return
+
+        # Handle Unit vs UnitProduct dispatch (normal case)
         if isinstance(src, Unit) and not isinstance(src, UnitProduct):
             if isinstance(dst, Unit) and not isinstance(dst, UnitProduct):
                 self._add_unit_edge(src=src, dst=dst, map=map)
@@ -142,6 +170,114 @@ class ConversionGraph:
         self._product_edges.setdefault(src_key, {})[dst_key] = map
         self._product_edges.setdefault(dst_key, {})[src_key] = map.inverse()
 
+    def _add_cross_basis_edge(
+        self,
+        *,
+        src: Unit,
+        dst: Unit,
+        map: Map,
+        basis_transform: BasisTransform,
+    ) -> None:
+        """Add cross-basis edge between Units via BasisTransform.
+
+        Creates a RebasedUnit for src in the destination's dimension partition,
+        then stores the edge from the rebased unit to dst.
+        """
+        # Validate that the transform maps src to dst's dimension
+        if not basis_transform.validate_edge(src, dst):
+            raise DimensionMismatch(
+                f"Transform {basis_transform.src.name} -> {basis_transform.dst.name} "
+                f"does not map {src.name} to {dst.name}'s dimension"
+            )
+
+        # Create RebasedUnit in destination's dimension partition
+        rebased = RebasedUnit(
+            original=src,
+            rebased_dimension=dst.dimension,
+            basis_transform=basis_transform,
+        )
+        self._rebased[src] = rebased
+
+        # Store edge from rebased to dst (same dimension now)
+        dim = dst.dimension
+        self._ensure_dimension(dim)
+        self._unit_edges[dim].setdefault(rebased, {})[dst] = map
+        self._unit_edges[dim].setdefault(dst, {})[rebased] = map.inverse()
+
+    def connect_systems(
+        self,
+        *,
+        basis_transform: BasisTransform,
+        edges: dict[tuple[Unit, Unit], Map],
+    ) -> None:
+        """Bulk-add edges between systems.
+
+        Parameters
+        ----------
+        basis_transform : BasisTransform
+            The transform bridging the two systems.
+        edges : dict
+            Mapping from (src_unit, dst_unit) to Map.
+        """
+        for (src, dst), edge_map in edges.items():
+            self.add_edge(
+                src=src,
+                dst=dst,
+                map=edge_map,
+                basis_transform=basis_transform,
+            )
+
+    def list_rebased_units(self) -> dict[Unit, RebasedUnit]:
+        """Return all rebased units in the graph.
+
+        Returns
+        -------
+        dict[Unit, RebasedUnit]
+            Mapping from original unit to its RebasedUnit.
+        """
+        return dict(self._rebased)
+
+    def list_transforms(self) -> list[BasisTransform]:
+        """Return all BasisTransforms active in the graph.
+
+        Returns
+        -------
+        list[BasisTransform]
+            Unique transforms used by rebased units.
+        """
+        seen = set()
+        result = []
+        for rebased in self._rebased.values():
+            bt = rebased.basis_transform
+            if id(bt) not in seen:
+                seen.add(id(bt))
+                result.append(bt)
+        return result
+
+    def edges_for_transform(self, transform: BasisTransform) -> list[tuple[Unit, Unit]]:
+        """Return all edges that use a specific BasisTransform.
+
+        Parameters
+        ----------
+        transform : BasisTransform
+            The transform to filter by.
+
+        Returns
+        -------
+        list[tuple[Unit, Unit]]
+            List of (original_unit, destination_unit) pairs.
+        """
+        result = []
+        for original, rebased in self._rebased.items():
+            if rebased.basis_transform == transform:
+                # Find the destination unit (the one the rebased unit connects to)
+                dim = rebased.dimension
+                if dim in self._unit_edges and rebased in self._unit_edges[dim]:
+                    for dst in self._unit_edges[dim][rebased]:
+                        if not isinstance(dst, RebasedUnit):
+                            result.append((original, dst))
+        return result
+
     def _ensure_dimension(self, dim: Dimension) -> None:
         if dim not in self._unit_edges:
             self._unit_edges[dim] = {}
@@ -206,10 +342,28 @@ class ConversionGraph:
         return self._convert_products(src=src_prod, dst=dst_prod)
 
     def _convert_units(self, *, src: Unit, dst: Unit) -> Map:
-        """Convert between plain Units via BFS."""
+        """Convert between plain Units via BFS.
+
+        Handles cross-basis conversions via rebased units.
+        """
         if src == dst:
             return LinearMap.identity()
 
+        # Check if src has a rebased version that can reach dst
+        if src in self._rebased:
+            rebased = self._rebased[src]
+            if rebased.dimension == dst.dimension:
+                # Convert via the rebased unit
+                return self._bfs_convert(start=rebased, target=dst, dim=dst.dimension)
+
+        # Check if dst has a rebased version (inverse conversion)
+        if dst in self._rebased:
+            rebased_dst = self._rebased[dst]
+            if rebased_dst.dimension == src.dimension:
+                # Convert from src to the rebased dst
+                return self._bfs_convert(start=src, target=rebased_dst, dim=src.dimension)
+
+        # Check for dimension mismatch
         if src.dimension != dst.dimension:
             raise DimensionMismatch(f"{src.dimension} != {dst.dimension}")
 
@@ -217,13 +371,16 @@ class ConversionGraph:
         if self._has_direct_unit_edge(src=src, dst=dst):
             return self._get_direct_unit_edge(src=src, dst=dst)
 
-        # BFS
-        dim = src.dimension
+        # BFS in same dimension
+        return self._bfs_convert(start=src, target=dst, dim=src.dimension)
+
+    def _bfs_convert(self, *, start, target, dim: Dimension) -> Map:
+        """BFS to find conversion path within a dimension."""
         if dim not in self._unit_edges:
             raise ConversionNotFound(f"No edges for dimension {dim}")
 
-        visited: dict[Unit, Map] = {src: LinearMap.identity()}
-        queue = deque([src])
+        visited: dict = {start: LinearMap.identity()}
+        queue = deque([start])
 
         while queue:
             current = queue.popleft()
@@ -239,12 +396,12 @@ class ConversionGraph:
                 composed = edge_map @ current_map
                 visited[neighbor] = composed
 
-                if neighbor == dst:
+                if neighbor == target:
                     return composed
 
                 queue.append(neighbor)
 
-        raise ConversionNotFound(f"No path from {src} to {dst}")
+        raise ConversionNotFound(f"No path from {start} to {target}")
 
     def _convert_products(self, *, src: UnitProduct, dst: UnitProduct) -> Map:
         """Convert between UnitProducts.

ucon/maps.py

@@ -25,7 +25,7 @@ from dataclasses import dataclass
 class Map(ABC):
     """Abstract base for all conversion morphisms.
 
-    Subclasses must implement ``__call__``, ``inverse``, and ``__pow__``.
+    Subclasses must implement ``__call__``, ``inverse``, ``__pow__``, and ``derivative``.
     Composition via ``@`` defaults to :class:`ComposedMap`; subclasses may
     override for closed composition within their own type.
     """
@@ -50,6 +50,14 @@ class Map(ABC):
         """Raise map to a power (for exponent handling in factorwise conversion)."""
         ...
 
+    @abstractmethod
+    def derivative(self, x: float) -> float:
+        """Return the derivative of the map at point x.
+
+        Used for uncertainty propagation: δy = |f'(x)| * δx
+        """
+        ...
+
     def is_identity(self, tol: float = 1e-9) -> bool:
         """Check if this map is approximately the identity."""
         return abs(self(1.0) - 1.0) < tol and abs(self(0.0) - 0.0) < tol
@@ -86,6 +94,10 @@ class LinearMap(Map):
     def __pow__(self, exp: float) -> LinearMap:
         return LinearMap(self.a ** exp)
 
+    def derivative(self, x: float) -> float:
+        """Derivative of y = a*x is a (constant)."""
+        return self.a
+
     @classmethod
     def identity(cls) -> LinearMap:
         return cls(1.0)
@@ -128,6 +140,10 @@ class AffineMap(Map):
             return self.inverse()
         raise ValueError("AffineMap only supports exp=1 or exp=-1")
 
+    def derivative(self, x: float) -> float:
+        """Derivative of y = a*x + b is a (constant)."""
+        return self.a
+
 
 @dataclass(frozen=True)
 class ComposedMap(Map):
@@ -159,3 +175,8 @@ class ComposedMap(Map):
         if exp == -1:
             return self.inverse()
         raise ValueError("ComposedMap only supports exp=1 or exp=-1")
+
+    def derivative(self, x: float) -> float:
+        """Chain rule: d/dx [outer(inner(x))] = outer'(inner(x)) * inner'(x)."""
+        inner_val = self.inner(x)
+        return self.outer.derivative(inner_val) * self.inner.derivative(x)

ucon/units.py

@@ -28,7 +28,7 @@ Notes
 The design allows for future extensibility: users can register their own units,
 systems, or aliases dynamically, without modifying the core definitions.
 """
-from ucon.core import Dimension, Unit
+from ucon.core import Dimension, Unit, UnitSystem
 
 
 none = Unit()
@@ -49,6 +49,7 @@ joule_per_kelvin = Unit(name='joule_per_kelvin', dimension=Dimension.entropy, al
 kelvin = Unit(name='kelvin', dimension=Dimension.temperature, aliases=('K',))
 kilogram = Unit(name='kilogram', dimension=Dimension.mass, aliases=('kg',))
 liter = Unit(name='liter', dimension=Dimension.volume, aliases=('L', 'l'))
+candela = Unit(name='candela', dimension=Dimension.luminous_intensity, aliases=('cd',))
 lumen = Unit(name='lumen', dimension=Dimension.luminous_intensity, aliases=('lm',))
 lux = Unit(name='lux', dimension=Dimension.illuminance, aliases=('lx',))
 meter = Unit(name='meter', dimension=Dimension.length, aliases=('m',))
@@ -141,6 +142,32 @@ basis_point = Unit(name='basis_point', dimension=Dimension.ratio, aliases=('bp',
 webers = weber
 
 
+# -- Predefined Unit Systems -----------------------------------------------
+si = UnitSystem(
+    name="SI",
+    bases={
+        Dimension.length: meter,
+        Dimension.mass: kilogram,
+        Dimension.time: second,
+        Dimension.temperature: kelvin,
+        Dimension.current: ampere,
+        Dimension.amount_of_substance: mole,
+        Dimension.luminous_intensity: candela,
+    }
+)
+
+imperial = UnitSystem(
+    name="Imperial",
+    bases={
+        Dimension.length: foot,
+        Dimension.mass: pound,
+        Dimension.time: second,
+        Dimension.temperature: fahrenheit,
+    }
+)
+# --------------------------------------------------------------------------
+
+
 def have(name: str) -> bool:
     assert name, "Must provide a unit name to check"
     assert isinstance(name, str), "Unit name must be a string"

{ucon-0.5.0.dist-info → ucon-0.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucon
-Version: 0.5.0
+Version: 0.5.2
 Summary: a tool for dimensional analysis: a "Unit CONverter"
 Home-page: https://github.com/withtwoemms/ucon
 Author: Emmanuel I. Obi
@@ -67,6 +67,7 @@ It combines **units**, **scales**, and **dimensions** into a composable algebra
 - Scale-aware arithmetic via `UnitFactor` and `UnitProduct`
 - Metric and binary prefixes (`kilo`, `kibi`, `micro`, `mebi`, etc.)
 - Pseudo-dimensions for angles, solid angles, and ratios with semantic isolation
+- Uncertainty propagation through arithmetic and conversions
 - A clean foundation for physics, chemistry, data modeling, and beyond
 
 Think of it as **`decimal.Decimal` for the physical world** — precise, predictable, and type-safe.
@@ -91,6 +92,9 @@ To best answer this question, we turn to an age-old technique ([dimensional anal
 | **`Ratio`**                   | `ucon.core`                             | Represents the division of two `Number` objects; captures relationships between quantities.         | Expressing rates, densities, efficiencies (e.g., energy / time = power, length / time = velocity).                     |
 | **`Map`** hierarchy           | `ucon.maps`                             | Composable conversion morphisms: `LinearMap`, `AffineMap`, `ComposedMap`.                           | Defining conversion functions between units (e.g., meter→foot, celsius→kelvin).                                        |
 | **`ConversionGraph`**         | `ucon.graph`                            | Registry of unit conversion edges with BFS path composition.                                        | Converting between units via `Number.to(target)`; managing default and custom graphs.                                  |
+| **`UnitSystem`**              | `ucon.core`                             | Named mapping from dimensions to base units (e.g., SI, Imperial).                                   | Defining coherent unit systems; grouping base units by dimension.                                                      |
+| **`BasisTransform`**          | `ucon.core`                             | Matrix-based transformation between dimensional exponent spaces.                                    | Converting between incompatible dimensional structures; exact arithmetic with `Fraction`.                              |
+| **`RebasedUnit`**             | `ucon.core`                             | A unit rebased to another system's dimension, preserving provenance.                                | Cross-basis conversions; tracking original unit through basis changes.                                                 |
 | **`units` module**            | `ucon.units`                            | Defines canonical unit instances (SI, imperial, information, and derived units).                    | Quick access to standard physical units (`units.meter`, `units.foot`, `units.byte`, etc.).                             |
 
 ### Under the Hood
@@ -215,6 +219,102 @@ print(ratio.to(units.ppm))  # <500000.0 ppm>
 units.radian(1).to(units.percent)  # raises ConversionNotFound
 ```
 
+Uncertainty propagates through arithmetic and conversions:
+```python
+from ucon import units
+
+# Measurements with uncertainty
+length = units.meter(1.234, uncertainty=0.005)
+width = units.meter(0.567, uncertainty=0.003)
+
+print(length)  # <1.234 ± 0.005 m>
+
+# Uncertainty propagates through arithmetic (quadrature)
+area = length * width
+print(area)  # <0.699678 ± 0.00424... m²>
+
+# Uncertainty propagates through conversion
+length_ft = length.to(units.foot)
+print(length_ft)  # <4.048... ± 0.0164... ft>
+```
+
+Unit systems and basis transforms enable conversions between incompatible dimensional structures.
+This goes beyond simple unit conversion (meter → foot) into structural transformation:
+
+```python
+from fractions import Fraction
+from ucon import BasisTransform, Dimension, Unit, UnitSystem, units
+from ucon.graph import ConversionGraph
+from ucon.maps import LinearMap
+
+# The realm of Valdris has three fundamental dimensions:
+#   - Aether (A): magical energy substrate
+#   - Resonance (R): vibrational frequency of magic
+#   - Substance (S): physical matter
+#
+# These combine into SI dimensions via a transformation matrix:
+#
+#   | L |   | 2  0  0 |   | A |
+#   | M | = | 1  0  1 | × | R |
+#   | T |   |-2 -1  0 |   | S |
+#
+# Reading the columns:
+#   - 1 aether contributes: L², M, T⁻²  (energy-like)
+#   - 1 resonance contributes: T⁻¹      (frequency-like)
+#   - 1 substance contributes: M         (mass-like)
+
+# Fantasy base units
+mote = Unit(name='mote', dimension=Dimension.energy, aliases=('mt',))
+chime = Unit(name='chime', dimension=Dimension.frequency, aliases=('ch',))
+ite = Unit(name='ite', dimension=Dimension.mass, aliases=('it',))
+
+valdris = UnitSystem(
+    name="Valdris",
+    bases={
+        Dimension.energy: mote,
+        Dimension.frequency: chime,
+        Dimension.mass: ite,
+    }
+)
+
+# The basis transform encodes how Valdris dimensions compose into SI
+valdris_to_si = BasisTransform(
+    src=valdris,
+    dst=units.si,
+    src_dimensions=(Dimension.energy, Dimension.frequency, Dimension.mass),
+    dst_dimensions=(Dimension.energy, Dimension.frequency, Dimension.mass),
+    matrix=(
+        (2, 0, 0),    # energy: 2 × aether
+        (1, 0, 1),    # frequency: aether + substance
+        (-2, -1, 0),  # mass: -2×aether - resonance
+    ),
+)
+
+# Physical calibration: how many SI units per fantasy unit
+graph = ConversionGraph()
+graph.connect_systems(
+    basis_transform=valdris_to_si,
+    edges={
+        (mote, units.joule): LinearMap(42),           # 1 mote = 42 J
+        (chime, units.hertz): LinearMap(7),           # 1 chime = 7 Hz
+        (ite, units.kilogram): LinearMap(Fraction(1, 2)),  # 1 ite = 0.5 kg
+    }
+)
+
+# Game engine converts between physics systems
+energy_map = graph.convert(src=mote, dst=units.joule)
+energy_map(10)  # 420 joules from 10 motes
+
+# Inverse: display real-world values in game units
+joule_to_mote = graph.convert(src=units.joule, dst=mote)
+joule_to_mote(420)  # 10 motes
+
+# The transform is invertible with exact Fraction arithmetic
+valdris_to_si.is_invertible  # True
+```
+
+This enables fantasy game physics, or any field where the dimensional structure differs from SI.
+
 ---
 
 ## Roadmap Highlights
@@ -224,8 +324,10 @@ units.radian(1).to(units.percent)  # raises ConversionNotFound
 | **0.3.x** | Dimensional Algebra | Unit/Scale separation, `UnitFactor`, `UnitProduct` | ✅ Complete |
 | **0.4.x** | Conversion System | `ConversionGraph`, `Number.to()`, callable units | ✅ Complete |
 | **0.5.0** | Dimensionless Units | Pseudo-dimensions for angle, solid angle, ratio | ✅ Complete |
-| **0.5.x** | Metrology | Uncertainty propagation, `UnitSystem` | 🚧 In Progress |
-| **0.7.x** | Pydantic Integration | Type-safe quantity validation | ⏳ Planned |
+| **0.5.x** | Uncertainty | Propagation through arithmetic and conversions | ✅ Complete |
+| **0.5.x** | Unit Systems | `BasisTransform`, `UnitSystem`, cross-basis conversion | ✅ Complete |
+| **0.6.x** | Pydantic Integration | Type-safe quantity validation | ⏳ Planned |
+| **0.7.x** | NumPy Arrays | Vectorized conversion and arithmetic | ⏳ Planned |
 
 See full roadmap: [ROADMAP.md](./ROADMAP.md)
 

ucon-0.5.2.dist-info/RECORD

@@ -0,0 +1,29 @@
+tests/ucon/__init__.py,sha256=9BAHYTs27Ed3VgqiMUH4XtVttAmOPgK0Zvj-dUNo7D8,119
+tests/ucon/test_algebra.py,sha256=NnoQOSMW8NJlOTnbr3M_5epvnDPXpVTgO21L2LcytRY,8503
+tests/ucon/test_basis_transform.py,sha256=P7ccr9wgDPCwCmsj4dceu3V0A72qFbTavjzm9kB3xP8,16710
+tests/ucon/test_core.py,sha256=bmwSRWPlhwossy5NJ9rcPWujFmzBBPOeZzPAzN1acFg,32631
+tests/ucon/test_default_graph_conversions.py,sha256=rkcDcSV1_kZeuPf4ModHDpgfkOPZS32xcKq7KPDRN-0,15760
+tests/ucon/test_dimensionless_units.py,sha256=K6BrIPOFL9IO_ksR8t_oJUXmjTgqBUzMdgaV-hZc52w,8410
+tests/ucon/test_graph_basis_transform.py,sha256=5-WglJaR1N_mJlqR6i8NuxLJ_FASqb5a8WoO_177smU,8249
+tests/ucon/test_quantity.py,sha256=md5nbmy0u2cFBdqNeu-ROhoj29vYrIlGm_AjlmCttgc,24519
+tests/ucon/test_rebased_unit.py,sha256=n2mksEYSJ8UJJXXwlgaLKg3THaf7_LKzWB7kwjoaXEU,5150
+tests/ucon/test_uncertainty.py,sha256=KkJw2dJR0EToxPpBN24x735jr9fv6a2myxjvhOH4MPU,9649
+tests/ucon/test_unit_system.py,sha256=gRc3fMvo9ded1tBUQWLKpcbpBepMAb7gPu8XvFzQZaM,5860
+tests/ucon/test_units.py,sha256=SILymDtDNDyxEhkYQubrfkakKCMexwEwjyHfhrkDrMI,869
+tests/ucon/test_vector_fraction.py,sha256=fTgxlV9aSP15sA4gATTXBzIDbtKXwWqG1Ip0o-V2B4Y,6369
+tests/ucon/conversion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/ucon/conversion/test_graph.py,sha256=fs0aP6qNf8eE1uI7SoGSCW2XAkHYb7T9aaI-kzmO02c,16955
+tests/ucon/conversion/test_map.py,sha256=DVFQ3xwp16Nuy9EtZRjKlWbkXfRUcM1mOzFrS4HhOaw,13886
+ucon/__init__.py,sha256=M_sijIUYPvU87Jtnq_O2X7TS4x9RW1LHZJ8bbm3gfk0,2255
+ucon/algebra.py,sha256=6QrPyD23L93XSrnIORcYEx2CLDv4WDcrh6H_hxeeOus,8668
+ucon/core.py,sha256=j2Xw73-Xuh0CkaUYEv5ljsxjt-XdthiH-EbqUBgG1a8,63139
+ucon/graph.py,sha256=Ec0Q2QiAGUm2RaxrKnpFHtwpNvTf4PYbvo62BWtGJG8,21159
+ucon/maps.py,sha256=tWP4ayYCEazJzf81EP1_fmtADhg18D1eHldudAMEY0U,5460
+ucon/quantity.py,sha256=GBxZ_96nocx-8F-usNWGbPvWHRhRgdZzqfH9Sx69iC4,465
+ucon/units.py,sha256=MWCJhicK6jQb71fREyW_HSfGFKL8KEQej2JnySL_MjE,8285
+ucon-0.5.2.dist-info/licenses/LICENSE,sha256=LtimSYBSw1L_X6n1-VEdZRdwuROzPumrMUNX21asFuI,11356
+ucon-0.5.2.dist-info/licenses/NOTICE,sha256=bh4fBOItio3kM4hSNYhqfFpcaAvOoixjD7Du8im-sYA,1079
+ucon-0.5.2.dist-info/METADATA,sha256=CTRgYp67awjnjy7ZzKL2opd81T2RK1feQ6AXMnXmSj4,17200
+ucon-0.5.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ucon-0.5.2.dist-info/top_level.txt,sha256=zZYRJiQrVUtN32ziJD2YEq7ClSvDmVYHYy5ArRAZGxI,11
+ucon-0.5.2.dist-info/RECORD,,

ucon-0.5.0.dist-info/RECORD

@@ -1,23 +0,0 @@
-tests/ucon/__init__.py,sha256=9BAHYTs27Ed3VgqiMUH4XtVttAmOPgK0Zvj-dUNo7D8,119
-tests/ucon/test_algebra.py,sha256=NnoQOSMW8NJlOTnbr3M_5epvnDPXpVTgO21L2LcytRY,8503
-tests/ucon/test_core.py,sha256=bmwSRWPlhwossy5NJ9rcPWujFmzBBPOeZzPAzN1acFg,32631
-tests/ucon/test_default_graph_conversions.py,sha256=rkcDcSV1_kZeuPf4ModHDpgfkOPZS32xcKq7KPDRN-0,15760
-tests/ucon/test_dimensionless_units.py,sha256=K6BrIPOFL9IO_ksR8t_oJUXmjTgqBUzMdgaV-hZc52w,8410
-tests/ucon/test_quantity.py,sha256=md5nbmy0u2cFBdqNeu-ROhoj29vYrIlGm_AjlmCttgc,24519
-tests/ucon/test_units.py,sha256=SILymDtDNDyxEhkYQubrfkakKCMexwEwjyHfhrkDrMI,869
-tests/ucon/conversion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/ucon/conversion/test_graph.py,sha256=fs0aP6qNf8eE1uI7SoGSCW2XAkHYb7T9aaI-kzmO02c,16955
-tests/ucon/conversion/test_map.py,sha256=DVFQ3xwp16Nuy9EtZRjKlWbkXfRUcM1mOzFrS4HhOaw,13886
-ucon/__init__.py,sha256=jaFcNFZC5gxHKzM8OkS1pLxltp6ToLRVpuuhJQY9FKQ,2000
-ucon/algebra.py,sha256=4JiT_SHHep86Sv3tVkgKsRY95lBRASMkyH4vOUA-gfM,7459
-ucon/core.py,sha256=GjLKV0ERyYLhBZBpyIfCrKL718EN1RlUKwqxx2B3Rc4,43606
-ucon/graph.py,sha256=lPoYSvHNGBZxeZ-4dyZIu2OS5R1JTo0qPZ9wd0vg-s4,15566
-ucon/maps.py,sha256=yyZ7RqnohO2joTUvvKh40in7E6SKMQIQ8jkECO0-_NA,4753
-ucon/quantity.py,sha256=GBxZ_96nocx-8F-usNWGbPvWHRhRgdZzqfH9Sx69iC4,465
-ucon/units.py,sha256=u1ILwGllzNiwGLadlg5jguKPyFV1u-CZSUMgUDWTen4,7509
-ucon-0.5.0.dist-info/licenses/LICENSE,sha256=LtimSYBSw1L_X6n1-VEdZRdwuROzPumrMUNX21asFuI,11356
-ucon-0.5.0.dist-info/licenses/NOTICE,sha256=bh4fBOItio3kM4hSNYhqfFpcaAvOoixjD7Du8im-sYA,1079
-ucon-0.5.0.dist-info/METADATA,sha256=TZDRVKaAMyCbbwanZ44Ej5JsCGNf0iWch1PD_CFnIx4,12901
-ucon-0.5.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ucon-0.5.0.dist-info/top_level.txt,sha256=zZYRJiQrVUtN32ziJD2YEq7ClSvDmVYHYy5ArRAZGxI,11
-ucon-0.5.0.dist-info/RECORD,,