ucon 0.3.4__py3-none-any.whl → 0.3.5__py3-none-any.whl

ucon/quantity.py

@@ -1,3 +1,7 @@
+# © 2025 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
 """
 ucon.quantity
 ==========
@@ -18,7 +22,7 @@ from dataclasses import dataclass
 from typing import Union
 
 from ucon import units
-from ucon.core import CompositeUnit, Scale, Unit
+from ucon.core import Unit, UnitProduct, Scale
 
 
 Quantifiable = Union['Number', 'Ratio']
@@ -39,12 +43,24 @@ class Number:
         <2.5 (m/s)>
     """
     quantity: Union[float, int] = 1.0
-    unit: Unit = units.none
+    unit: Union[Unit, UnitProduct] = units.none
 
     @property
     def value(self) -> float:
-        """Return numeric magnitude as quantity × scale factor."""
-        return round(self.quantity * self.unit.scale.value.evaluated, 15)
+        """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)."""
@@ -56,38 +72,6 @@ class Number:
     def as_ratio(self):
         return Ratio(self)
 
-    def _inherit_symbolic_identity(self, new_unit: Unit, lhs: Unit, rhs: Unit) -> Unit:
-        """
-        If new_unit has no name/aliases but is dimension-compatible
-        with either lhs or rhs, inherit symbolic identity.
-        """
-        if isinstance(new_unit, CompositeUnit):
-            return new_unit  # composite units have their own structure
-
-        if new_unit.aliases or new_unit.name:
-            return new_unit  # already has a symbol
-
-        if new_unit.scale is not Scale.one:
-            return new_unit  # keep scaled units intact
-
-        # inheritance priority: lhs → rhs
-        if lhs.dimension == new_unit.dimension:
-            return Unit(
-                *lhs.aliases,
-                name=lhs.name,
-                dimension=new_unit.dimension,
-                scale=Scale.one,
-            )
-        if rhs.dimension == new_unit.dimension:
-            return Unit(
-                *rhs.aliases,
-                name=rhs.name,
-                dimension=new_unit.dimension,
-                scale=Scale.one,
-            )
-
-        return new_unit
-
     def __mul__(self, other: Quantifiable) -> 'Number':
         if isinstance(other, Ratio):
             other = other.evaluate()
@@ -115,8 +99,8 @@ class Number:
         # 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.value       # quantity × scale
-            den = other.value
+            num = self._canonical_magnitude    # quantity × scale
+            den = other._canonical_magnitude
             return Number(quantity=num / den, unit=units.none)
 
         # --- Case 2: Dimensionful result -----------------------------------
@@ -140,7 +124,7 @@ class Number:
             return False
 
         # Compare magnitudes, scale-adjusted
-        if abs(self.value - other.value) >= 1e-12:
+        if abs(self._canonical_magnitude - other._canonical_magnitude) >= 1e-12:
             return False
 
         return True
@@ -174,49 +158,12 @@ class Ratio:
         # Pure arithmetic, no scale normalization.
         numeric = self.numerator.quantity / self.denominator.quantity
 
-        # Pure unit division, with FactoredUnit preservation.
+        # 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 _fold_scales(self, unit: Union[Unit, CompositeUnit]):
-        """
-        Extracts numeric scaling from unit prefixes while preserving exponent structure.
-        Returns: (numeric_factor: float, stripped_unit: Unit|CompositeUnit)
-        """
-        # --- UNIT CASE ----------------------------------------------------
-        if isinstance(unit, Unit) and not isinstance(unit, CompositeUnit):
-            return self._fold_scales_from_unit(unit)
-
-        # --- COMPOSITE CASE -----------------------------------------------
-        total = 1.0
-        normalized: dict[Unit, float] = {}
-
-        for u, exp in unit.components.items():
-            factor, base_unit = self._fold_scales_from_unit(u, exp)
-            total *= factor
-            if abs(exp) >= 1e-12:   # drop zero powers
-                normalized[base_unit] = normalized.get(base_unit, 0) + exp
-
-        return total, CompositeUnit(normalized) if normalized else units.none
-
-    def _fold_scales_from_unit(self, u: Unit, power: float = 1):
-        """Extract numeric scale^power and return (factor, scale-free Unit)."""
-        if u.scale is Scale.one:
-            return 1.0, Unit(*u.aliases, name=u.name, dimension=u.dimension, scale=Scale.one)
-
-        factor = u.scale.value.evaluated ** power
-        return factor, Unit(*u.aliases, name=u.name, dimension=u.dimension, scale=Scale.one)
-
-    def normalize(self, number: Number) -> Number:
-        scale_factor, base_unit = self._fold_scales(number.unit)
-
-        return Number(
-            quantity = number.quantity * scale_factor,
-            unit = base_unit
-        )    
-
     def __mul__(self, another_ratio: 'Ratio') -> 'Ratio':
         if self.numerator.unit == another_ratio.denominator.unit:
             factor = self.numerator / another_ratio.denominator

ucon/units.py

@@ -1,3 +1,7 @@
+# © 2025 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
 """
 ucon.units
 ===========

{ucon-0.3.4.dist-info → ucon-0.3.5.dist-info}/METADATA

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: ucon
-Version: 0.3.4
+Version: 0.3.5
 Summary: a tool for dimensional analysis: a "Unit CONverter"
 Home-page: https://github.com/withtwoemms/ucon
 Author: Emmanuel I. Obi
 Maintainer: Emmanuel I. Obi
 Maintainer-email: withtwoemms@gmail.com
-License: MIT
+License: Apache-2.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Software Development :: Build Tools
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -23,6 +23,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
+License-File: NOTICE
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -54,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.
@@ -69,20 +70,22 @@ 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 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).             |
+| **`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.    |
-| **`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.).                               |                                                   |
+| **`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.quantity`                         | Combines a numeric quantity with a unit; the primary measurable type.                               | Performing arithmetic with units; representing physical quantities like 5 m/s.                                         |
+| **`Ratio`**                   | `ucon.quantity`                         | 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.).                          |
 
 ### 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/f24134c362829dc72e7dff18bfcaa24b9be01b54/ucon.data-model_v035.png align="center" alt="ucon Data Model" width=600/>
 
 ## Why `ucon`?
 
@@ -90,24 +93,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
 
@@ -135,7 +136,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
@@ -148,27 +150,36 @@ 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
-grams_bromine.to(Scale.milli)  # <6238.0 milligram>
-grams_bromine.to(Scale.kibi)   # <0.006091796875 kibigram>
+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
 ```
 
+> **Note:** Unit _conversions_ (e.g., `number.to(units.inch)`) are planned for v0.4.x
+> via the `ConversionGraph` abstraction. See [ROADMAP.md](./ROADMAP.md).
+
 ---
 
 ## 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()` | 🚧 Up Next |
+| [**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)
 
@@ -181,13 +192,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.3.5.dist-info/RECORD

@@ -0,0 +1,16 @@
+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=Va7KJ5ImQCkf06TWPKs0r6kfziURsvGh5I63ipiYiLo,1927
+ucon/algebra.py,sha256=ZVF8B2kUOeSN20R-lTHJNJDxe_Zv7s8kJ70F2JOSYxk,7262
+ucon/core.py,sha256=Dx8HNwjGpF-RFlO_2Cz1BZikRFeLcYlMy7hscw106vo,29825
+ucon/quantity.py,sha256=skXge9RU-5dW1ULCV6kiE4jk-rMVzXpBa4hV4mVr_Eo,7310
+ucon/units.py,sha256=-CShNMLr9t7f3pyYsfmZv3wMCZU4lEnoe8r_9YQWjxA,3783
+ucon-0.3.5.dist-info/licenses/LICENSE,sha256=LtimSYBSw1L_X6n1-VEdZRdwuROzPumrMUNX21asFuI,11356
+ucon-0.3.5.dist-info/licenses/NOTICE,sha256=bh4fBOItio3kM4hSNYhqfFpcaAvOoixjD7Du8im-sYA,1079
+ucon-0.3.5.dist-info/METADATA,sha256=unyLeaX8cl9Uf-EaX1NnylgaW5yUBLf_k22-cfCzaq0,11429
+ucon-0.3.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ucon-0.3.5.dist-info/top_level.txt,sha256=zZYRJiQrVUtN32ziJD2YEq7ClSvDmVYHYy5ArRAZGxI,11
+ucon-0.3.5.dist-info/RECORD,,

{ucon-0.3.4.dist-info → ucon-0.3.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ucon-0.3.5.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright © 2025 The Radiativity Company
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

ucon-0.3.5.dist-info/licenses/NOTICE

@@ -0,0 +1,28 @@
+ucon — A dimensional analysis and unit algebra library
+© 2025 The Radiativity Company
+
+Licensed under the Apache License, Version 2.0.
+You may not use this project except in compliance with the License.
+A copy of the License is included in the LICENSE file or at:
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+This NOTICE file is part of the ucon distribution.
+
+ucon implements:
+  • A compositional unit algebra (UnitFactor, UnitProduct, UnitForm)
+  • A dimension algebra based on vector-space operations
+  • Expression-level scale separation for unit provenance
+  • A foundation for ConversionGraph-based unit transformations
+
+Portions of this software may incorporate or depend upon
+third-party libraries. Attribution notices for those components,
+if required, are included here or in the accompanying documentation.
+
+The Radiativity Company retains all trademark rights to the names:
+  • "ucon"
+  • "The Radiativity Company"
+  • "Project Calico"
+
+This file is for attribution purposes only and does not modify
+the terms of the Apache License, Version 2.0.

ucon-0.3.4.dist-info/RECORD

@@ -1,15 +0,0 @@
-tests/ucon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/ucon/test_algebra.py,sha256=seQ5qfvtqc7uojzldQIk4jRr5O9FCNqpagox1Q53lMU,8212
-tests/ucon/test_core.py,sha256=CMbToQiFJ_2MW26qV2RGKFWo-tLwz_3XN7O7dRDaoBg,26605
-tests/ucon/test_quantity.py,sha256=XacQHxinlwoABR6tHPrw27ct5b_4le36c0e7d2h0JIw,14486
-tests/ucon/test_units.py,sha256=NUEbcKgvj5nn9xIe3D-5NoaOpQry5Dkg_OmIAxY7QpU,777
-ucon/__init__.py,sha256=B_yFxd47zl4toP4v5M6ODfJNnssoSzQz3VTM2md1rfg,1745
-ucon/algebra.py,sha256=qe7Hfvo_P4YiBjSahBQu6rcH0ZfjBuO1cGtqG-ip_x8,7142
-ucon/core.py,sha256=54zJpnutgK-RwrqajS81p8uiR_26ADSSzfI6co7fOFo,28797
-ucon/quantity.py,sha256=wbgzc48Qs1ncgtU0Dz0F8x6q88eKe8jK2Ii5lVJKJ4E,9344
-ucon/units.py,sha256=HqpATy3QPISLRfenWFaNnc-w6QhF1_Mm6_XIb93imOk,3663
-ucon-0.3.4.dist-info/licenses/LICENSE,sha256=-Djjiq2wM8Cc6fzTsdMbr_T2_uaX6Yorxcemr3GGkqc,1072
-ucon-0.3.4.dist-info/METADATA,sha256=qXIkp1XhZmjpDdKoY_mqk8LrA8b0h2av0WezAuCQZwE,10583
-ucon-0.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ucon-0.3.4.dist-info/top_level.txt,sha256=zZYRJiQrVUtN32ziJD2YEq7ClSvDmVYHYy5ArRAZGxI,11
-ucon-0.3.4.dist-info/RECORD,,

ucon-0.3.4.dist-info/licenses/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 Emmanuel I. Obi
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.