ucon 0.3.5rc1__py3-none-any.whl → 0.4.0__py3-none-any.whl

ucon/quantity.py

@@ -4,193 +4,14 @@
 
 """
 ucon.quantity
-==========
+=============
 
-Implements the **quantitative core** of the *ucon* system — the machinery that
-defines how numeric values are coupled with units and scales to represent
-physical quantities.
+Re-exports :class:`Number` and :class:`Ratio` from :mod:`ucon.core`
+for backward compatibility.
 
-Classes
--------
-- :class:`Number` — Couples a numeric value with a unit and scale.
-- :class:`Ratio` — Represents a ratio between two :class:`Number` objects.
-
-Together, these classes allow full arithmetic, conversion, and introspection
-of physical quantities with explicit dimensional semantics.
+These classes now live in :mod:`ucon.core` to enable the callable
+unit syntax: ``meter(5)`` returns a ``Number``.
 """
-from dataclasses import dataclass
-from typing import Union
-
-from ucon import units
-from ucon.core import Unit, UnitProduct, Scale
-
-
-Quantifiable = Union['Number', 'Ratio']
-
-@dataclass
-class Number:
-    """
-    Represents a **numeric quantity** with an associated :class:`Unit` and :class:`Scale`.
-
-    Combines magnitude, unit, and scale into a single, composable object that
-    supports dimensional arithmetic and conversion:
-
-        >>> from ucon import core, units
-        >>> length = core.Number(unit=units.meter, quantity=5)
-        >>> time = core.Number(unit=units.second, quantity=2)
-        >>> speed = length / time
-        >>> speed
-        <2.5 (m/s)>
-    """
-    quantity: Union[float, int] = 1.0
-    unit: Unit = units.none
-
-    @property
-    def value(self) -> float:
-        """Return the numeric magnitude as-expressed (no scale folding).
-
-        Scale lives in the unit expression (e.g. kJ, mL) and is NOT
-        folded into the returned value.  Use ``unit.fold_scale()`` on a
-        UnitProduct when you need the base-unit-equivalent magnitude.
-        """
-        return round(self.quantity, 15)
-
-    @property
-    def _canonical_magnitude(self) -> float:
-        """Quantity folded to base-unit scale (internal use for eq/div)."""
-        if isinstance(self.unit, UnitProduct):
-            return self.quantity * self.unit.fold_scale()
-        return self.quantity
-
-    def simplify(self):
-        """Return a new Number expressed in base scale (Scale.one)."""
-        raise NotImplementedError("Unit simplification requires ConversionGraph; coming soon.")
-
-    def to(self, new_scale: Scale):
-        raise NotImplementedError("Unit conversion requires ConversionGraph; coming soon.")
-
-    def as_ratio(self):
-        return Ratio(self)
-
-    def __mul__(self, other: Quantifiable) -> 'Number':
-        if isinstance(other, Ratio):
-            other = other.evaluate()
-
-        if not isinstance(other, Number):
-            return NotImplemented
-
-        return Number(
-            quantity=self.quantity * other.quantity,
-            unit=self.unit * other.unit,
-        )
-
-    def __truediv__(self, other: Quantifiable) -> "Number":
-        # Allow dividing by a Ratio (interpret as its evaluated Number)
-        if isinstance(other, Ratio):
-            other = other.evaluate()
-
-        if not isinstance(other, Number):
-            raise TypeError("Cannot divide Number by non-Number/Ratio type: {type(other)}")
-
-        # Symbolic quotient in the unit algebra
-        unit_quot = self.unit / other.unit
-
-        # --- Case 1: Dimensionless result ----------------------------------
-        # If the net dimension is none, we want a pure scalar:
-        # fold *all* scale factors into the numeric magnitude.
-        if not unit_quot.dimension:
-            num = self._canonical_magnitude    # quantity × scale
-            den = other._canonical_magnitude
-            return Number(quantity=num / den, unit=units.none)
-
-        # --- Case 2: Dimensionful result -----------------------------------
-        # For "real" physical results like g/mL, m/s², etc., preserve the
-        # user's chosen unit scales symbolically. Only divide the raw quantities.
-        new_quantity = self.quantity / other.quantity
-        return Number(quantity=new_quantity, unit=unit_quot)
-
-    def __eq__(self, other: Quantifiable) -> bool:
-        if not isinstance(other, (Number, Ratio)):
-            raise TypeError(
-                f"Cannot compare Number to non-Number/Ratio type: {type(other)}"
-            )
-
-        # If comparing with a Ratio, evaluate it to a Number
-        if isinstance(other, Ratio):
-            other = other.evaluate()
-
-        # Dimensions must match
-        if self.unit.dimension != other.unit.dimension:
-            return False
-
-        # Compare magnitudes, scale-adjusted
-        if abs(self._canonical_magnitude - other._canonical_magnitude) >= 1e-12:
-            return False
-
-        return True
-
-    def __repr__(self):
-        if not self.unit.dimension:
-            return f"<{self.quantity}>"
-        return f"<{self.quantity} {self.unit.shorthand}>"
-
-
-# TODO -- consider using a dataclass
-class Ratio:
-    """
-    Represents a **ratio of two Numbers**, preserving their unit semantics.
-
-    Useful for expressing physical relationships like efficiency, density,
-    or dimensionless comparisons:
-
-        >>> ratio = Ratio(length, time)
-        >>> ratio.evaluate()
-        <2.5 (m/s)>
-    """
-    def __init__(self, numerator: Number = Number(), denominator: Number = Number()):
-        self.numerator = numerator
-        self.denominator = denominator
-
-    def reciprocal(self) -> 'Ratio':
-        return Ratio(numerator=self.denominator, denominator=self.numerator)
-
-    def evaluate(self) -> "Number":
-        # Pure arithmetic, no scale normalization.
-        numeric = self.numerator.quantity / self.denominator.quantity
-
-        # Pure unit division, with UnitFactor preservation.
-        unit = self.numerator.unit / self.denominator.unit
-
-        # DO NOT normalize, DO NOT fold scale.
-        return Number(quantity=numeric, unit=unit)
-
-    def __mul__(self, another_ratio: 'Ratio') -> 'Ratio':
-        if self.numerator.unit == another_ratio.denominator.unit:
-            factor = self.numerator / another_ratio.denominator
-            numerator, denominator = factor * another_ratio.numerator, self.denominator
-        elif self.denominator.unit == another_ratio.numerator.unit:
-            factor = another_ratio.numerator / self.denominator
-            numerator, denominator = factor * self.numerator, another_ratio.denominator
-        else:
-            factor = Number()
-            another_number = another_ratio.evaluate()
-            numerator, denominator = self.numerator * another_number, self.denominator
-        return Ratio(numerator=numerator, denominator=denominator)
-
-    def __truediv__(self, another_ratio: 'Ratio') -> 'Ratio':
-        return Ratio(
-            numerator=self.numerator * another_ratio.denominator,
-            denominator=self.denominator * another_ratio.numerator,
-        )
-
-    def __eq__(self, another_ratio: 'Ratio') -> bool:
-        if isinstance(another_ratio, Ratio):
-            return self.evaluate() == another_ratio.evaluate()
-        elif isinstance(another_ratio, Number):
-            return self.evaluate() == another_ratio
-        else:
-            raise ValueError(f'"{another_ratio}" is not a Ratio or Number. Comparison not possible.')
+from ucon.core import Number, Ratio, Quantifiable
 
-    def __repr__(self):
-        # TODO -- resolve int/float inconsistency
-        return f'{self.evaluate()}' if self.numerator == self.denominator else f'{self.numerator} / {self.denominator}'
+__all__ = ['Number', 'Ratio', 'Quantifiable']

ucon/units.py

@@ -35,40 +35,83 @@ none = Unit()
 
 
 # -- International System of Units (SI) --------------------------------
-ampere = Unit('I', 'amp', name='ampere', dimension=Dimension.current)
-becquerel = Unit('Bq', name='becquerel', dimension=Dimension.frequency)
-celsius = Unit('°C', name='celsius', dimension=Dimension.temperature)
-coulomb = Unit('C', name='coulomb', dimension=Dimension.charge)
-farad = Unit('F', name='farad', dimension=Dimension.capacitance)
-gram = Unit('g', 'G', name='gram', dimension=Dimension.mass)
-gray = Unit('Gy', name='gray', dimension=Dimension.energy)
-henry = Unit('H', name='henry', dimension=Dimension.inductance)
-hertz = Unit('Hz', name='hertz', dimension=Dimension.frequency)
-hour = Unit('h', 'H', name='hour', dimension=Dimension.time)
-joule = Unit('J', name='joule', dimension=Dimension.energy)
-joule_per_kelvin = Unit('J/K', name='joule_per_kelvin', dimension=Dimension.entropy)
-kelvin = Unit('K', name='kelvin', dimension=Dimension.temperature)
-liter = Unit('L', 'l', name='liter', dimension=Dimension.volume)
-lumen = Unit('lm', name='lumen', dimension=Dimension.luminous_intensity)
-lux = Unit('lx', name='lux', dimension=Dimension.illuminance)
-meter = Unit('m', 'M', name='meter', dimension=Dimension.length)
-mole = Unit('mol', 'n', name='mole', dimension=Dimension.amount_of_substance)
-newton = Unit('N', name='newton', dimension=Dimension.force)
-ohm = Unit('Ω', name='ohm', dimension=Dimension.resistance)
-pascal = Unit('Pa', name='pascal', dimension=Dimension.pressure)
-radian = Unit('rad', name='radian', dimension=Dimension.none)
-second = Unit('s', 'sec', name='second', dimension=Dimension.time)
-sievert = Unit('Sv', name='sievert', dimension=Dimension.energy)
-siemens = Unit('S', name='siemens', dimension=Dimension.conductance)
-steradian = Unit('sr', name='steradian', dimension=Dimension.none)
-tesla = Unit('T', name='tesla', dimension=Dimension.magnetic_flux_density)
-volt = Unit('V', name='volt', dimension=Dimension.voltage)
-watt = Unit('W', name='watt', dimension=Dimension.power)
-webers = Unit('Wb', name='weber', dimension=Dimension.magnetic_flux)
-webers_per_meter = Unit('Wb/m', name='webers_per_meter', dimension=Dimension.magnetic_permeability)
+ampere = Unit(name='ampere', dimension=Dimension.current, aliases=('I', 'amp'))
+becquerel = Unit(name='becquerel', dimension=Dimension.frequency, aliases=('Bq',))
+celsius = Unit(name='celsius', dimension=Dimension.temperature, aliases=('°C', 'degC'))
+coulomb = Unit(name='coulomb', dimension=Dimension.charge, aliases=('C',))
+farad = Unit(name='farad', dimension=Dimension.capacitance, aliases=('F',))
+gram = Unit(name='gram', dimension=Dimension.mass, aliases=('g',))
+gray = Unit(name='gray', dimension=Dimension.energy, aliases=('Gy',))
+henry = Unit(name='henry', dimension=Dimension.inductance, aliases=('H',))
+hertz = Unit(name='hertz', dimension=Dimension.frequency, aliases=('Hz',))
+joule = Unit(name='joule', dimension=Dimension.energy, aliases=('J',))
+joule_per_kelvin = Unit(name='joule_per_kelvin', dimension=Dimension.entropy, aliases=('J/K',))
+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'))
+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',))
+mole = Unit(name='mole', dimension=Dimension.amount_of_substance, aliases=('mol', 'n'))
+newton = Unit(name='newton', dimension=Dimension.force, aliases=('N',))
+ohm = Unit(name='ohm', dimension=Dimension.resistance, aliases=('Ω',))
+pascal = Unit(name='pascal', dimension=Dimension.pressure, aliases=('Pa',))
+radian = Unit(name='radian', dimension=Dimension.none, aliases=('rad',))
+siemens = Unit(name='siemens', dimension=Dimension.conductance, aliases=('S',))
+sievert = Unit(name='sievert', dimension=Dimension.energy, aliases=('Sv',))
+steradian = Unit(name='steradian', dimension=Dimension.none, aliases=('sr',))
+tesla = Unit(name='tesla', dimension=Dimension.magnetic_flux_density, aliases=('T',))
+volt = Unit(name='volt', dimension=Dimension.voltage, aliases=('V',))
+watt = Unit(name='watt', dimension=Dimension.power, aliases=('W',))
+weber = Unit(name='weber', dimension=Dimension.magnetic_flux, aliases=('Wb',))
+webers_per_meter = Unit(name='webers_per_meter', dimension=Dimension.magnetic_permeability, aliases=('Wb/m',))
 # ----------------------------------------------------------------------
 
 
+# -- Time Units --------------------------------------------------------
+second = Unit(name='second', dimension=Dimension.time, aliases=('s', 'sec'))
+minute = Unit(name='minute', dimension=Dimension.time, aliases=('min',))
+hour = Unit(name='hour', dimension=Dimension.time, aliases=('h', 'hr'))
+day = Unit(name='day', dimension=Dimension.time, aliases=('d',))
+# ----------------------------------------------------------------------
+
+
+# -- Imperial / US Customary Units -------------------------------------
+# Length
+foot = Unit(name='foot', dimension=Dimension.length, aliases=('ft',))
+inch = Unit(name='inch', dimension=Dimension.length, aliases=('in',))
+yard = Unit(name='yard', dimension=Dimension.length, aliases=('yd',))
+mile = Unit(name='mile', dimension=Dimension.length, aliases=('mi',))
+
+# Mass
+pound = Unit(name='pound', dimension=Dimension.mass, aliases=('lb', 'lbs'))
+ounce = Unit(name='ounce', dimension=Dimension.mass, aliases=('oz',))
+
+# Temperature
+fahrenheit = Unit(name='fahrenheit', dimension=Dimension.temperature, aliases=('°F', 'degF'))
+
+# Volume
+gallon = Unit(name='gallon', dimension=Dimension.volume, aliases=('gal',))
+
+# Energy
+calorie = Unit(name='calorie', dimension=Dimension.energy, aliases=('cal',))
+btu = Unit(name='btu', dimension=Dimension.energy, aliases=('BTU',))
+
+# Power
+horsepower = Unit(name='horsepower', dimension=Dimension.power, aliases=('hp',))
+# ----------------------------------------------------------------------
+
+
+# -- Information Units -------------------------------------------------
+bit = Unit(name='bit', dimension=Dimension.information, aliases=('b',))
+byte = Unit(name='byte', dimension=Dimension.information, aliases=('B',))
+# ----------------------------------------------------------------------
+
+
+# Backward compatibility alias
+webers = weber
+
+
 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.3.5rc1.dist-info → ucon-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucon
-Version: 0.3.5rc1
+Version: 0.4.0
 Summary: a tool for dimensional analysis: a "Unit CONverter"
 Home-page: https://github.com/withtwoemms/ucon
 Author: Emmanuel I. Obi
@@ -55,8 +55,8 @@ Dynamic: summary
 It combines **units**, **scales**, and **dimensions** into a composable algebra that supports:
 
 - Dimensional analysis through `Number` and `Ratio`
-- Scale-aware arithmetic and conversions
-- Metric and binary prefixes (`kilo`, `kibi`, `micro`, `mebi`, ect.)
+- Scale-aware arithmetic via `UnitFactor` and `UnitProduct`
+- Metric and binary prefixes (`kilo`, `kibi`, `micro`, `mebi`, etc.)
 - 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.
@@ -70,20 +70,24 @@ The crux of this tiny library is to provide abstractions that simplify the answe
 To best answer this question, we turn to an age-old technique ([dimensional analysis](https://en.wikipedia.org/wiki/Dimensional_analysis)) which essentially allows for the solution to be written as a product of ratios. `ucon` comes equipped with some useful primitives:
 | Type                          | Defined In                              | Purpose                                                                                             | Typical Use Cases                                                                                                      |
 | ----------------------------- | --------------------------------------- | --------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
-| **`Vector`**                  | `ucon.dimension`                        | Represents the exponent tuple of a physical quantity’s base dimensions (e.g., T, L, M, I, Θ, J, N). | Internal representation of dimensional algebra; building derived quantities (e.g., area, velocity, force).             |
-| **`Dimension`**               | `ucon.dimension`                        | Encapsulates physical dimensions (e.g., length, time, mass) as algebraic combinations of vectors.   | Enforcing dimensional consistency; defining relationships between quantities (e.g., length / time = velocity).         |
-| **`Unit`**                    | `ucon.unit`                             | Represents a named, dimensioned measurement unit (e.g., meter, second, joule).                      | Attaching human-readable units to quantities; defining or composing new units (`newton = kilogram * meter / second²`). |
+| **`Vector`**                  | `ucon.algebra`                          | Represents the 8-component exponent tuple of a physical quantity's base dimensions (T, L, M, I, Θ, J, N, B). | Internal representation of dimensional algebra; building derived quantities (e.g., area, velocity, force).             |
+| **`Exponent`**                | `ucon.algebra`                          | Represents base-power pairs (e.g., 10³, 2¹⁰) used by `Scale`.                                       | Performing arithmetic on powers and bases; normalizing scales across conversions.                                      |
+| **`Dimension`**               | `ucon.core`                             | Encapsulates physical dimensions (e.g., length, time, mass) as algebraic combinations of vectors.   | Enforcing dimensional consistency; defining relationships between quantities (e.g., length / time = velocity).         |
 | **`Scale`**                   | `ucon.core`                             | Encodes powers of base magnitudes (binary or decimal prefixes like kilo-, milli-, mebi-).           | Adjusting numeric scale without changing dimension (e.g., kilometer ↔ meter, byte ↔ kibibyte).                         |
-| **`Exponent`**                | `ucon.core`                             | Represents base-power pairs (e.g., 10³, 2¹⁰) used by `Scale`.                                       | Performing arithmetic on powers and bases; normalizing scales across conversions.                                      |
-| **`Number`**                  | `ucon.core`                             | Combines a numeric quantity with a unit and scale; the primary measurable type.                     | Performing arithmetic with units; converting between compatible units; representing physical quantities like 5 m/s.    |
+| **`Unit`**                    | `ucon.core`                             | An atomic, scale-free measurement symbol (e.g., meter, second, joule) with a `Dimension`.           | Defining base units; serving as graph nodes for future conversions.                                                    |
+| **`UnitFactor`**              | `ucon.core`                             | Pairs a `Unit` with a `Scale` (e.g., kilo + gram = kg). Used as keys inside `UnitProduct`.          | Preserving user-provided scale prefixes through algebraic operations.                                                  |
+| **`UnitProduct`**             | `ucon.core`                             | A product/quotient of `UnitFactor`s with exponent tracking and simplification.                      | Representing composite units like m/s, kg·m/s², kJ·h.                                                                 |
+| **`Number`**                  | `ucon.core`                             | Combines a numeric quantity with a unit; the primary measurable type.                               | Performing arithmetic with units; representing physical quantities like 5 m/s.                                         |
 | **`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).                     |
-| **`units` module**            | `ucon.units`                            | Defines canonical unit instances (SI and common derived units).                                     | Quick access to standard physical units (`units.meter`, `units.second`, `units.newton`, etc.).                               |                                                   |
+| **`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.                                  |
+| **`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
 
 `ucon` models unit math through a hierarchy where each layer builds on the last:
 
-<img src=https://gist.githubusercontent.com/withtwoemms/429d2ca1f979865aa80a2658bf9efa32/raw/0c704737a52b9e4a87cda5c839e9aa40f7e5bb48/ucon.data-model_v035.png align="center" alt="ucon Data Model" width=600/>
+<img src=https://gist.githubusercontent.com/withtwoemms/429d2ca1f979865aa80a2658bf9efa32/raw/5df6a7fb2a6426ee6804096c092c10bed1b30b6f/ucon.data-model_v040.png align="center" alt="ucon Data Model" width=600/>
 
 ## Why `ucon`?
 
@@ -91,24 +95,22 @@ Python already has mature libraries for handling units and physical quantities
 
 | Library   | Focus                                                   | Limitation                                                                                                             |
 | --------- | ------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
-| **Pint**  | Runtime unit conversion and compatibility checking      | Treats quantities as decorated numbers — conversions work, but the algebra behind them isn’t inspectable or type-safe. |
+| **Pint**  | Runtime unit conversion and compatibility checking      | Treats quantities as decorated numbers — conversions work, but the algebra behind them isn't inspectable or type-safe. |
 | **SymPy** | Symbolic algebra and simplification of unit expressions | Excellent for symbolic reasoning, but not designed for runtime validation, conversion, or serialization.               |
 | **Unum**  | Unit-aware arithmetic and unit propagation              | Tracks units through arithmetic but lacks explicit dimensional algebra, conversion taxonomy, or runtime introspection. |
 
 Together, these tools can _use_ units, but none can explicitly represent and verify the relationships between units and dimensions.
 
-That’s the gap `ucon` fills.
+That's the gap `ucon` fills.
 
 It treats units, dimensions, and scales as first-class objects and builds a composable algebra around them.
 This allows you to:
 - Represent dimensional meaning explicitly (`Dimension`, `Vector`);
 - Compose and compute with type-safe, introspectable quantities (`Unit`, `Number`);
-- Perform reversible, declarative conversions (standard, linear, affine, nonlinear);
-- Serialize and validate measurements with Pydantic integration;
 - Extend the system with custom unit registries and conversion families.
 
 Where Pint, Unum, and SymPy focus on _how_ to compute with units,
-`ucon` focuses on why those computations make sense. Every operation checks the dimensional structure, _not just the unit labels_. This means ucon doesn’t just track names: it enforces physics:
+`ucon` focuses on why those computations make sense. Every operation checks the dimensional structure, _not just the unit labels_. This means ucon doesn't just track names: it enforces physics:
 ```python
 from ucon import Number, units
 
@@ -136,7 +138,8 @@ This sort of dimensional analysis:
 ```
 becomes straightforward when you define a measurement:
 ```python
-from ucon import Number, Scale, Units, Ratio
+from ucon import Number, Scale, units
+from ucon.quantity import Ratio
 
 # Two milliliters of bromine
 mL = Scale.milli * units.liter
@@ -149,27 +152,52 @@ bromine_density = Ratio(
 )
 
 # Multiply to find mass
-grams_bromine = two_mL_bromine * bromine_density
-print(grams_bromine)  # <6.238 gram>
+grams_bromine = bromine_density.evaluate() * two_mL_bromine
+print(grams_bromine)  # <6.238 g>
 ```
 
-Scale conversion is automatic and precise:
+Scale prefixes compose naturally:
+```python
+km = Scale.kilo * units.meter       # UnitProduct with kilo-scaled meter
+mg = Scale.milli * units.gram       # UnitProduct with milli-scaled gram
+
+print(km.shorthand)  # 'km'
+print(mg.shorthand)  # 'mg'
+
+# Scale arithmetic
+print(km.fold_scale())  # 1000.0
+print(mg.fold_scale())  # 0.001
+```
 
+Units are callable for ergonomic quantity construction:
 ```python
-grams_bromine.to(Scale.milli)  # <6238.0 milligram>
-grams_bromine.to(Scale.kibi)   # <0.006091796875 kibigram>
+from ucon import units, Scale
+
+# Callable syntax: unit(quantity) → Number
+height = units.meter(1.8)
+speed = (units.mile / units.hour)(60)
+
+# Convert between units
+height_ft = height.to(units.foot)
+print(height_ft)  # <5.905... ft>
+
+# Scaled units work too
+km = Scale.kilo * units.meter
+distance = km(5)
+distance_mi = distance.to(units.mile)
+print(distance_mi)  # <3.107... mi>
 ```
 
 ---
 
 ## Roadmap Highlights
 
-| Version | Theme | Focus |
-|----------|-------|--------|
-| [**0.3.x**](https://github.com/withtwoemms/ucon/milestone/1) | Primitive Type Refinement | Unified algebraic foundation |
-| [**0.4.x**](https://github.com/withtwoemms/ucon/milestone/2) | Conversion System | Linear & affine conversions |
-| [**0.6.x**](https://github.com/withtwoemms/ucon/milestone/4) | Nonlinear / Specialized Units | Decibel, Percent, pH |
-| [**0.8.x**](https://github.com/withtwoemms/ucon/milestone/6) | Pydantic Integration | Type-safe quantity validation |
+| Version | Theme | Focus | Status |
+|----------|-------|--------|--------|
+| **0.3.5** | Dimensional Algebra | Unit/Scale separation, `UnitFactor`, `UnitProduct` | ✅ Complete |
+| [**0.4.x**](https://github.com/withtwoemms/ucon/milestone/2) | Conversion System | `ConversionGraph`, `Number.to()`, callable units | 🚧 In Progress |
+| [**0.6.x**](https://github.com/withtwoemms/ucon/milestone/4) | Nonlinear / Specialized Units | Decibel, Percent, pH | ⏳ Planned |
+| [**0.8.x**](https://github.com/withtwoemms/ucon/milestone/6) | Pydantic Integration | Type-safe quantity validation | ⏳ Planned |
 
 See full roadmap: [ROADMAP.md](./ROADMAP.md)
 
@@ -182,13 +210,13 @@ Ensure `nox` is installed.
 ```
 pip install -r requirements.txt
 ```
-Then run the full test suite (agains all supported python versions) before committing:
+Then run the full test suite (against all supported python versions) before committing:
 
 ```bash
 nox -s test
 ```
 ---
 
-> “If it can be measured, it can be represented.
+> "If it can be measured, it can be represented.
 If it can be represented, it can be validated.
-If it can be validated, it can be trusted.”
+If it can be validated, it can be trusted."

ucon-0.4.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+tests/ucon/__init__.py,sha256=9BAHYTs27Ed3VgqiMUH4XtVttAmOPgK0Zvj-dUNo7D8,119
+tests/ucon/test_algebra.py,sha256=Esm38M1QBNsV7vdfoFgqRUluyvWX7yccB0RwZXk4DpA,8433
+tests/ucon/test_core.py,sha256=NqmyKMkrF3T4ekucsFzVsxbkErdB6assbkhBAYH2fug,32664
+tests/ucon/test_quantity.py,sha256=qJ-dXOPgIp0SKelASu45IC6KquTjlcRwHVkSKicsrXw,22754
+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=R3u-0FCpgffoUXvJmT7aBJCUDUpzmBYROh5I0WLHA_Y,7256
+tests/ucon/conversion/test_map.py,sha256=2_bxXCuga-lTGxU5rGferiziJmjzrltksA-6JJseEQ0,5359
+ucon/__init__.py,sha256=jaFcNFZC5gxHKzM8OkS1pLxltp6ToLRVpuuhJQY9FKQ,2000
+ucon/algebra.py,sha256=wGl4jJVMd8SXQ4sYDBOxV00ymAzRWfDhea1o4t2kVp4,7482
+ucon/core.py,sha256=o3Q4posUOYoIhQVHl6bANCIcGKgGOpNZsnqGZw9ujYk,41523
+ucon/graph.py,sha256=lgueyVdBI73pgqsydwRtOY9sxt02G-gy8-Lf7993RNw,14224
+ucon/maps.py,sha256=yyZ7RqnohO2joTUvvKh40in7E6SKMQIQ8jkECO0-_NA,4753
+ucon/quantity.py,sha256=GBxZ_96nocx-8F-usNWGbPvWHRhRgdZzqfH9Sx69iC4,465
+ucon/units.py,sha256=PJFAqUoEq_0--Zo7JDHezZBPHPbAlS_5eArIVCLemxA,5852
+ucon-0.4.0.dist-info/licenses/LICENSE,sha256=LtimSYBSw1L_X6n1-VEdZRdwuROzPumrMUNX21asFuI,11356
+ucon-0.4.0.dist-info/licenses/NOTICE,sha256=bh4fBOItio3kM4hSNYhqfFpcaAvOoixjD7Du8im-sYA,1079
+ucon-0.4.0.dist-info/METADATA,sha256=_hZdjrgY1lvorBac-JPQQVzNVuNet-QY2zPP0G8-hik,12349
+ucon-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ucon-0.4.0.dist-info/top_level.txt,sha256=zZYRJiQrVUtN32ziJD2YEq7ClSvDmVYHYy5ArRAZGxI,11
+ucon-0.4.0.dist-info/RECORD,,

ucon-0.3.5rc1.dist-info/RECORD

@@ -1,16 +0,0 @@
-tests/ucon/__init__.py,sha256=9BAHYTs27Ed3VgqiMUH4XtVttAmOPgK0Zvj-dUNo7D8,119
-tests/ucon/test_algebra.py,sha256=0mxkiXibZfnzYtbscgVXPDcX1JelrVpcqNBcQe3cn3g,8330
-tests/ucon/test_core.py,sha256=x5JLJAKuaTBkxQzYqTFnDaStVcIlnCviJNiN2OJ7KGQ,32435
-tests/ucon/test_quantity.py,sha256=YLV78_t4AkZcJeEGu-lBvIXNLhTV_MLkTbIKV67rs4Y,14955
-tests/ucon/test_units.py,sha256=SILymDtDNDyxEhkYQubrfkakKCMexwEwjyHfhrkDrMI,869
-ucon/__init__.py,sha256=vJ6A2BU6s2_3vW4fExhn3VEjbn8yrvgF2hYBfGrKPrY,1865
-ucon/algebra.py,sha256=ZVF8B2kUOeSN20R-lTHJNJDxe_Zv7s8kJ70F2JOSYxk,7262
-ucon/core.py,sha256=cjq0hc5L7iA3ObWUT9JetUnWN6-WWqoQJ7c9YWbS35Y,29597
-ucon/quantity.py,sha256=rjJLx1bktnfddfgn80m3eyVEPq0LU9RmUVR0aOeopqM,7290
-ucon/units.py,sha256=-CShNMLr9t7f3pyYsfmZv3wMCZU4lEnoe8r_9YQWjxA,3783
-ucon-0.3.5rc1.dist-info/licenses/LICENSE,sha256=LtimSYBSw1L_X6n1-VEdZRdwuROzPumrMUNX21asFuI,11356
-ucon-0.3.5rc1.dist-info/licenses/NOTICE,sha256=bh4fBOItio3kM4hSNYhqfFpcaAvOoixjD7Du8im-sYA,1079
-ucon-0.3.5rc1.dist-info/METADATA,sha256=EqRVt-FxtnB-C73U_-JZqzouAKJl_y3ofiBAKxxBVtM,10626
-ucon-0.3.5rc1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ucon-0.3.5rc1.dist-info/top_level.txt,sha256=zZYRJiQrVUtN32ziJD2YEq7ClSvDmVYHYy5ArRAZGxI,11
-ucon-0.3.5rc1.dist-info/RECORD,,