ucon 0.3.3rc2__py3-none-any.whl → 0.3.5__py3-none-any.whl

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.

tests/ucon/test_dimension.py

@@ -1,206 +0,0 @@
-import unittest
-from ucon.dimension import Vector, Dimension
-
-
-class TestVector(unittest.TestCase):
-
-    def test_vector_iteration_and_length(self):
-        v = Vector(1, 0, 0, 0, 0, 0, 0)
-        self.assertEqual(tuple(v), (1, 0, 0, 0, 0, 0, 0))
-        self.assertEqual(len(v), 7)  # always 7 components
-
-    def test_vector_addition(self):
-        v1 = Vector(1, 0, 0, 0, 0, 0, 0)
-        v2 = Vector(0, 2, 0, 0, 0, 0, 0)
-        result = v1 + v2
-        self.assertEqual(result, Vector(1, 2, 0, 0, 0, 0, 0))
-
-    def test_vector_subtraction(self):
-        v1 = Vector(2, 1, 0, 0, 0, 0, 0)
-        v2 = Vector(1, 1, 0, 0, 0, 0, 0)
-        self.assertEqual(v1 - v2, Vector(1, 0, 0, 0, 0, 0, 0))
-
-    def test_vector_equality_and_hash(self):
-        v1 = Vector(1, 0, 0, 0, 0, 0, 0)
-        v2 = Vector(1, 0, 0, 0, 0, 0, 0)
-        v3 = Vector(0, 1, 0, 0, 0, 0, 0)
-        self.assertTrue(v1 == v2)
-        self.assertFalse(v1 == v3)
-        self.assertEqual(hash(v1), hash(v2))
-        self.assertNotEqual(hash(v1), hash(v3))
-
-
-class TestDimension(unittest.TestCase):
-
-    def test_basic_dimensions_are_unique(self):
-        seen = set()
-        for dim in Dimension:
-            self.assertNotIn(dim.value, seen, f'Duplicate vector found for {dim.name}')
-            seen.add(dim.value)
-
-    def test_multiplication_adds_exponents(self):
-        self.assertEqual(
-            Dimension.mass * Dimension.acceleration,
-            Dimension.force,
-        )
-        self.assertEqual(
-            Dimension.length * Dimension.length,
-            Dimension.area,
-        )
-        self.assertEqual(
-            Dimension.length * Dimension.length * Dimension.length,
-            Dimension.volume,
-        )
-
-    def test_division_subtracts_exponents(self):
-        self.assertEqual(
-            Dimension.length / Dimension.time,
-            Dimension.velocity,
-        )
-        self.assertEqual(
-            Dimension.force / Dimension.area,
-            Dimension.pressure,
-        )
-
-    def test_none_dimension_behaves_neutrally(self):
-        base = Dimension.mass
-        self.assertEqual(base * Dimension.none, base)
-        self.assertEqual(base / Dimension.none, base)
-        self.assertEqual(Dimension.none * base, base)
-        with self.assertRaises(ValueError) as exc:
-            Dimension.none / base
-        assert type(exc.exception) == ValueError
-        assert str(exc.exception).endswith('is not a valid Dimension')
-
-    def test_hash_and_equality_consistency(self):
-        d1 = Dimension.mass
-        d2 = Dimension.mass
-        d3 = Dimension.length
-        self.assertEqual(d1, d2)
-        self.assertNotEqual(d1, d3)
-        self.assertEqual(hash(d1), hash(d2))
-        self.assertNotEqual(hash(d1), hash(d3))
-
-    def test_composite_quantities_examples(self):
-        # Energy = Force * Length
-        self.assertEqual(
-            Dimension.force * Dimension.length,
-            Dimension.energy,
-        )
-        # Power = Energy / Time
-        self.assertEqual(
-            Dimension.energy / Dimension.time,
-            Dimension.power,
-        )
-        # Pressure = Force / Area
-        self.assertEqual(
-            Dimension.force / Dimension.area,
-            Dimension.pressure,
-        )
-        # Charge = Current * Time
-        self.assertEqual(
-            Dimension.current * Dimension.time,
-            Dimension.charge,
-        )
-
-    def test_vector_equality_reflects_dimension_equality(self):
-        self.assertEqual(Dimension.mass.value, Dimension.mass.value)
-        self.assertNotEqual(Dimension.mass.value, Dimension.time.value)
-        self.assertEqual(Dimension.mass, Dimension.mass)
-        self.assertNotEqual(Dimension.mass, Dimension.time)
-
-
-class TestVectorEdgeCases(unittest.TestCase):
-
-    def test_zero_vector_equality_and_additivity(self):
-        zero = Vector()
-        self.assertEqual(zero, Vector(0, 0, 0, 0, 0, 0, 0))
-        # Adding or subtracting zero should yield same vector
-        v = Vector(1, 2, 3, 4, 5, 6, 7)
-        self.assertEqual(v + zero, v)
-        self.assertEqual(v - zero, v)
-
-    def test_vector_with_negative_exponents(self):
-        v1 = Vector(1, -2, 3, 0, 0, 0, 0)
-        v2 = Vector(-1, 2, -3, 0, 0, 0, 0)
-        result = v1 + v2
-        self.assertEqual(result, Vector(0, 0, 0, 0, 0, 0, 0))
-        self.assertEqual(v1 - v1, Vector())  # perfect cancellation
-
-    def test_vector_equality_with_non_vector(self):
-        v = Vector()
-        with self.assertRaises(AssertionError):
-            v == "not a vector"
-        with self.assertRaises(AssertionError):
-            v == None
-
-    def test_hash_consistency_for_equal_vectors(self):
-        v1 = Vector(1, 0, 0, 0, 0, 0, 0)
-        v2 = Vector(1, 0, 0, 0, 0, 0, 0)
-        self.assertEqual(hash(v1), hash(v2))
-        self.assertEqual(len({v1, v2}), 1)
-
-    def test_iter_length_order_consistency(self):
-        v = Vector(1, 2, 3, 4, 5, 6, 7)
-        components = list(v)
-        self.assertEqual(len(components), len(v))
-        # Ensure order of iteration is fixed (T→L→M→I→Θ→J→N)
-        self.assertEqual(components, [1, 2, 3, 4, 5, 6, 7])
-
-    def test_vector_arithmetic_does_not_mutate_operands(self):
-        v1 = Vector(1, 0, 0, 0, 0, 0, 0)
-        v2 = Vector(0, 1, 0, 0, 0, 0, 0)
-        _ = v1 + v2
-        self.assertEqual(v1, Vector(1, 0, 0, 0, 0, 0, 0))
-        self.assertEqual(v2, Vector(0, 1, 0, 0, 0, 0, 0))
-
-    def test_invalid_addition_type_raises(self):
-        v = Vector(1, 0, 0, 0, 0, 0, 0)
-        with self.assertRaises(TypeError):
-            _ = v + "length"
-        with self.assertRaises(TypeError):
-            _ = v - 5
-
-
-class TestDimensionEdgeCases(unittest.TestCase):
-
-    def test_invalid_multiplication_type(self):
-        with self.assertRaises(TypeError):
-            Dimension.length * 5
-        with self.assertRaises(TypeError):
-            "mass" * Dimension.time
-
-    def test_invalid_division_type(self):
-        with self.assertRaises(TypeError):
-            Dimension.time / "length"
-        with self.assertRaises(TypeError):
-            5 / Dimension.mass
-
-    def test_equality_with_non_dimension(self):
-        with self.assertRaises(TypeError):
-            Dimension.mass ==  "mass"
-
-    def test_enum_uniqueness_and_hash(self):
-        # Hashes should be unique per distinct dimension
-        hashes = {hash(d) for d in Dimension}
-        self.assertEqual(len(hashes), len(Dimension))
-        # All Dimension.value entries must be distinct Vectors
-        values = [d.value for d in Dimension]
-        self.assertEqual(len(values), len(set(values)))
-
-    def test_combined_chained_operations(self):
-        # (mass * acceleration) / area = pressure
-        result = (Dimension.mass * Dimension.acceleration) / Dimension.area
-        self.assertEqual(result, Dimension.pressure)
-
-    def test_dimension_round_trip_equality(self):
-        # Multiplying and dividing by the same dimension returns self
-        d = Dimension.energy
-        self.assertEqual((d * Dimension.none) / Dimension.none, d)
-        self.assertEqual(d / Dimension.none, d)
-        self.assertEqual(Dimension.none * d, d)
-
-    def test_enum_is_hashable_and_iterable(self):
-        seen = {d for d in Dimension}
-        self.assertIn(Dimension.mass, seen)
-        self.assertEqual(len(seen), len(Dimension))

tests/ucon/test_unit.py

@@ -1,143 +0,0 @@
-
-
-from unittest import TestCase
-
-from ucon.dimension import Dimension
-from ucon.unit import Unit
-
-
-class TestUnit(TestCase):
-
-    unit_name = 'second'
-    unit_type = 'time'
-    unit_aliases = ('seconds', 'secs', 's', 'S')
-    unit = Unit(*unit_aliases, name=unit_name, dimension=Dimension.time)
-
-    def test___repr__(self):
-        self.assertEqual(f'<{self.unit_type} | {self.unit_name}>', str(self.unit))
-
-
-class TestUnitEdgeCases(TestCase):
-
-    # --- Initialization & representation -----------------------------------
-
-    def test_default_unit_is_dimensionless(self):
-        u = Unit()
-        self.assertEqual(u.dimension, Dimension.none)
-        self.assertEqual(u.name, '')
-        self.assertEqual(u.aliases, ())
-        self.assertEqual(u.shorthand, '')
-        self.assertEqual(repr(u), '<none>')
-
-    def test_unit_with_aliases_and_name(self):
-        u = Unit('m', 'M', name='meter', dimension=Dimension.length)
-        self.assertEqual(u.shorthand, 'm')
-        self.assertIn('m', u.aliases)
-        self.assertIn('M', u.aliases)
-        self.assertIn('length', repr(u))
-        self.assertIn('meter', repr(u))
-
-    def test_hash_and_equality_consistency(self):
-        u1 = Unit('m', name='meter', dimension=Dimension.length)
-        u2 = Unit('m', name='meter', dimension=Dimension.length)
-        u3 = Unit('s', name='second', dimension=Dimension.time)
-        self.assertEqual(u1, u2)
-        self.assertEqual(hash(u1), hash(u2))
-        self.assertNotEqual(u1, u3)
-        self.assertNotEqual(hash(u1), hash(u3))
-
-    def test_units_with_same_name_but_different_dimension_not_equal(self):
-        u1 = Unit(name='amp', dimension=Dimension.current)
-        u2 = Unit(name='amp', dimension=Dimension.time)
-        self.assertNotEqual(u1, u2)
-
-    # --- generate_name edge cases -----------------------------------------
-
-    def test_generate_name_both_have_shorthand(self):
-        u1 = Unit('m', name='meter', dimension=Dimension.length)
-        u2 = Unit('s', name='second', dimension=Dimension.time)
-        result = u1.generate_name(u2, '*')
-        self.assertEqual(result, '(m*s)')
-
-    def test_generate_name_missing_left_shorthand(self):
-        u1 = Unit(name='unitless', dimension=Dimension.none)
-        u2 = Unit('s', name='second', dimension=Dimension.time)
-        self.assertEqual(u1.generate_name(u2, '/'), 'second')
-
-    def test_generate_name_missing_right_shorthand(self):
-        u1 = Unit('m', name='meter', dimension=Dimension.length)
-        u2 = Unit(name='none', dimension=Dimension.none)
-        self.assertEqual(u1.generate_name(u2, '*'), 'meter')
-
-    def test_generate_name_no_aliases_on_either_side(self):
-        u1 = Unit(name='foo', dimension=Dimension.length)
-        u2 = Unit(name='bar', dimension=Dimension.time)
-        self.assertEqual(u1.generate_name(u2, '*'), '(foo*bar)')
-
-    # --- arithmetic behavior ----------------------------------------------
-
-    def test_multiplication_produces_composite_unit(self):
-        m = Unit('m', name='meter', dimension=Dimension.length)
-        s = Unit('s', name='second', dimension=Dimension.time)
-        v = m / s
-        self.assertIsInstance(v, Unit)
-        self.assertEqual(v.dimension, Dimension.velocity)
-        self.assertIn('/', v.name)
-
-    def test_division_with_dimensionless_denominator_returns_self(self):
-        m = Unit('m', name='meter', dimension=Dimension.length)
-        none = Unit(name='none', dimension=Dimension.none)
-        result = m / none
-        self.assertEqual(result, m)
-
-    def test_division_of_identical_units_returns_dimensionless(self):
-        m1 = Unit('m', name='meter', dimension=Dimension.length)
-        m2 = Unit('m', name='meter', dimension=Dimension.length)
-        result = m1 / m2
-        self.assertEqual(result.dimension, Dimension.none)
-        self.assertEqual(result.name, '')
-
-    def test_multiplying_with_dimensionless_returns_self(self):
-        m = Unit('m', name='meter', dimension=Dimension.length)
-        none = Unit(name='none', dimension=Dimension.none)
-        result = m * none
-        self.assertEqual(result.dimension, Dimension.length)
-        self.assertIn('m', result.name)
-
-    def test_invalid_dimension_combinations_raise_value_error(self):
-        m = Unit('m', name='meter', dimension=Dimension.length)
-        c = Unit('C', name='coulomb', dimension=Dimension.charge)
-        # The result of dividing these is undefined (no such Dimension)
-        with self.assertRaises(ValueError):
-            _ = m / c
-        with self.assertRaises(ValueError):
-            _ = c * m
-
-    # --- equality, hashing, immutability ----------------------------------
-
-    def test_equality_with_non_unit(self):
-        with self.assertRaises(TypeError):
-            Unit('m', name='meter', dimension=Dimension.length) == 'meter'
-
-    def test_hash_stability_in_collections(self):
-        m1 = Unit('m', name='meter', dimension=Dimension.length)
-        s = set([m1])
-        self.assertIn(Unit('m', name='meter', dimension=Dimension.length), s)
-
-    def test_operations_do_not_mutate_operands(self):
-        m = Unit('m', name='meter', dimension=Dimension.length)
-        s = Unit('s', name='second', dimension=Dimension.time)
-        _ = m / s
-        self.assertEqual(m.dimension, Dimension.length)
-        self.assertEqual(s.dimension, Dimension.time)
-
-    # --- operator edge cases ----------------------------------------------
-
-    def test_generate_name_handles_empty_names_and_aliases(self):
-        a = Unit()
-        b = Unit()
-        self.assertEqual(a.generate_name(b, '*'), '')
-
-    def test_repr_contains_dimension_name_even_without_name(self):
-        u = Unit(dimension=Dimension.force)
-        self.assertIn('force', repr(u))

ucon/dimension.py

@@ -1,172 +0,0 @@
-"""
-ucon.dimension
-===============
-
-Defines the algebra of **physical dimensions**--the foundation of all unit
-relationships and dimensional analysis in *ucon*.
-
-Each :class:`Dimension` represents a physical quantity (time, mass, length, etc.)
-expressed as a 7-element exponent vector following the SI base system:
-
-    (T, L, M, I, Θ, J, N) :: (s * m * kg * A * K * cd * mol)
-     time, length, mass, current, temperature, luminous intensity, substance
-
-Derived dimensions are expressed as algebraic sums or differences of these base
-vectors (e.g., `velocity = length / time`, `force = mass * acceleration`).
-
-Classes
--------
-- :class:`Vector` — Represents the exponent vector of a physical quantity.
-- :class:`Dimension` — Enum of known physical quantities, each with a `Vector`
-  value and operator overloads for dimensional algebra.
-"""
-from dataclasses import dataclass
-from enum import Enum
-from functools import partial, reduce
-from operator import __sub__ as subtraction
-from typing import Callable, Iterable, Iterator
-
-
-diff: Callable[[Iterable], int] = partial(reduce, subtraction)
-
-@dataclass
-class Vector:
-    """
-    Represents the **exponent vector** of a physical quantity.
-
-    Each component corresponds to the power of a base dimension in the SI system:
-    time (T), length (L), mass (M), current (I), temperature (Θ),
-    luminous intensity (J), and amount of substance (N).
-
-    Arithmetic operations correspond to dimensional composition:
-    - Addition (`+`) → multiplication of quantities
-    - Subtraction (`-`) → division of quantities
-
-    e.g.
-    Vector(T=1, L=0, M=0, I=0, Θ=0, J=0, N=0)   => "time"
-    Vector(T=0, L=2, M=0, I=0, Θ=0, J=0, N=0)   => "area"
-    Vector(T=-2, L=1, M=1, I=0, Θ=0, J=0, N=0)  => "force"
-    """
-    T: int = 0  # time
-    L: int = 0  # length
-    M: int = 0  # mass
-    I: int = 0  # current
-    Θ: int = 0  # temperature
-    J: int = 0  # luminous intensity
-    N: int = 0  # amount of substance
-
-    def __iter__(self) -> Iterator[int]:
-        yield self.T
-        yield self.L
-        yield self.M
-        yield self.I
-        yield self.Θ
-        yield self.J
-        yield self.N
-
-    def __len__(self) -> int:
-        return sum(tuple(1 for x in self))
-
-    def __add__(self, vector: 'Vector') -> 'Vector':
-        """
-        Addition, here, comes from the multiplication of base quantities
-
-        e.g. F = m * a
-        F =
-            (s^-2 * m^1 * kg   * A * K * cd * mol) +
-            (s    * m   * kg^1 * A * K * cd * mol)
-        """
-        values = tuple(sum(pair) for pair in zip(tuple(self), tuple(vector)))
-        return Vector(*values)
-
-    def __sub__(self, vector: 'Vector') -> 'Vector':
-        """
-        Subtraction, here, comes from the division of base quantities
-        """
-        values = tuple(diff(pair) for pair in zip(tuple(self), tuple(vector)))
-        return Vector(*values)
-
-    def __eq__(self, vector: 'Vector') -> bool:
-        assert isinstance(vector, Vector), "Can only compare Vector to another Vector"
-        return tuple(self) == tuple(vector)
-
-    def __hash__(self) -> int:
-        # Hash based on the string because tuples have been shown to collide
-        # Not the most performant, but effective
-        return hash(str(tuple(self)))
-
-
-class Dimension(Enum):
-    """
-    Represents a **physical dimension** defined by a :class:`Vector`.
-
-    Each dimension corresponds to a distinct combination of base exponents.
-    Dimensions are algebraically composable via multiplication and division:
-
-        >>> Dimension.length / Dimension.time
-        <Dimension.velocity: Vector(T=-1, L=1, M=0, I=0, Θ=0, J=0, N=0)>
-
-    This algebra forms the foundation for unit compatibility and conversion.
-    """
-    none = Vector()
-
-    # -- BASIS ---------------------------------------
-    time                = Vector(1, 0, 0, 0, 0, 0, 0)
-    length              = Vector(0, 1, 0, 0, 0, 0, 0)
-    mass                = Vector(0, 0, 1, 0, 0, 0, 0)
-    current             = Vector(0, 0, 0, 1, 0, 0, 0)
-    temperature         = Vector(0, 0, 0, 0, 1, 0, 0)
-    luminous_intensity  = Vector(0, 0, 0, 0, 0, 1, 0)
-    amount_of_substance = Vector(0, 0, 0, 0, 0, 0, 1)
-    # ------------------------------------------------
-
-    acceleration = Vector(-2, 1, 0, 0, 0, 0, 0)
-    angular_momentum = Vector(-1, 2, 1, 0, 0, 0, 0)
-    area = Vector(0, 2, 0, 0, 0, 0, 0)
-    capacitance = Vector(4, -2, -1, 2, 0, 0, 0)
-    charge = Vector(1, 0, 0, 1, 0, 0, 0)
-    conductance = Vector(3, -2, -1, 2, 0, 0, 0)
-    conductivity = Vector(3, -3, -1, 2, 0, 0, 0)
-    density = Vector(0, -3, 1, 0, 0, 0, 0)
-    electric_field_strength = Vector(-3, 1, 1, -1, 0, 0, 0)
-    energy = Vector(-2, 2, 1, 0, 0, 0, 0)
-    entropy = Vector(-2, 2, 1, 0, -1, 0, 0)
-    force = Vector(-2, 1, 1, 0, 0, 0, 0)
-    frequency = Vector(-1, 0, 0, 0, 0, 0, 0)
-    gravitation = Vector(-2, 3, -1, 0, 0, 0, 0)
-    illuminance = Vector(0, -2, 0, 0, 0, 1, 0)
-    inductance = Vector(-2, 2, 1, -2, 0, 0, 0)
-    magnetic_flux = Vector(-2, 2, 1, -1, 0, 0, 0)
-    magnetic_flux_density = Vector(-2, 0, 1, -1, 0, 0, 0)
-    magnetic_permeability = Vector(-2, 1, 1, -2, 0, 0, 0)
-    molar_mass = Vector(0, 0, 1, 0, 0, 0, -1)
-    molar_volume = Vector(0, 3, 0, 0, 0, 0, -1)
-    momentum = Vector(-1, 1, 1, 0, 0, 0, 0)
-    permittivity = Vector(4, -3, -1, 2, 0, 0, 0)
-    power = Vector(-3, 2, 1, 0, 0, 0, 0)
-    pressure = Vector(-2, -1, 1, 0, 0, 0, 0)
-    resistance = Vector(-3, 2, 1, -2, 0, 0, 0)
-    resistivity = Vector(-3, 3, 1, -2, 0, 0, 0)
-    specific_heat_capacity = Vector(-2, 2, 0, 0, -1, 0, 0)
-    thermal_conductivity = Vector(-3, 1, 1, 0, -1, 0, 0)
-    velocity = Vector(-1, 1, 0, 0, 0, 0, 0)
-    voltage = Vector(-3, 2, 1, -1, 0, 0, 0)
-    volume = Vector(0, 3, 0, 0, 0, 0, 0)
-
-    def __truediv__(self, dimension: 'Dimension') -> 'Dimension':
-        if not isinstance(dimension, Dimension):
-            raise TypeError(f"Cannot divide Dimension by non-Dimension type: {type(dimension)}")
-        return Dimension(self.value - dimension.value)
-
-    def __mul__(self, dimension: 'Dimension') -> 'Dimension':
-        if not isinstance(dimension, Dimension):
-            raise TypeError(f"Cannot multiply Dimension by non-Dimension type: {type(dimension)}")
-        return Dimension(self.value + dimension.value)
-
-    def __eq__(self, dimension) -> bool:
-        if not isinstance(dimension, Dimension):
-            raise TypeError(f"Cannot compare Dimension with non-Dimension type: {type(dimension)}")
-        return self.value == dimension.value
-
-    def __hash__(self) -> int:
-        return hash(self.value)

ucon/unit.py

@@ -1,92 +0,0 @@
-"""
-ucon.unit
-==========
-
-Defines the **Unit** abstraction — the symbolic and algebraic representation of
-a measurable quantity associated with a :class:`ucon.dimension.Dimension`.
-
-A :class:`Unit` pairs a human-readable name and aliases with its underlying
-dimension.
-
-Units are composable:
-
-    >>> from ucon import units
-    >>> units.meter / units.second
-    <velocity | (m/s)>
-
-They can be multiplied or divided to form compound units, and their dimensional
-relationships are preserved algebraically.
-"""
-from ucon.dimension import Dimension
-
-
-class Unit:
-    """
-    Represents a **unit of measure** associated with a :class:`Dimension`.
-
-    Parameters
-    ----------
-    *aliases : str
-        Optional shorthand symbols (e.g., "m", "sec").
-    name : str
-        Canonical name of the unit (e.g., "meter").
-    dimension : Dimension
-        The physical dimension this unit represents.
-
-    Notes
-    -----
-    Units participate in algebraic operations that produce new compound units:
-
-        >>> density = units.gram / units.liter
-        >>> density.dimension
-        <Dimension.density: Vector(T=0, L=-3, M=1, I=0, Θ=0, J=0, N=0)>
-
-    The combination rules follow the same algebra as :class:`Dimension`.
-    """
-    def __init__(self, *aliases: str, name: str = '', dimension: Dimension = Dimension.none):
-        self.dimension = dimension
-        self.name = name
-        self.aliases = aliases
-        self.shorthand = aliases[0] if aliases else self.name
-
-    def __repr__(self):
-        addendum = f' | {self.name}' if self.name else ''
-        return f'<{self.dimension.name}{addendum}>'
-
-    # TODO -- limit `operator` param choices
-    def generate_name(self, unit: 'Unit', operator: str):
-        if (self.dimension is Dimension.none) and not (unit.dimension is Dimension.none):
-            return unit.name
-        if not (self.dimension is Dimension.none) and (unit.dimension is Dimension.none):
-            return self.name
-
-        if not self.shorthand and not unit.shorthand:
-            name = ''
-        elif self.shorthand and not unit.shorthand:
-            name = f'({self.shorthand}{operator}?)'
-        elif not self.shorthand and unit.shorthand:
-            name = f'(?{operator}{unit.shorthand})'
-        else:
-            name = f'({self.shorthand}{operator}{unit.shorthand})'
-        return name
-
-    def __truediv__(self, unit: 'Unit') -> 'Unit':
-        # TODO -- define __eq__ for simplification, here
-        if (self.name == unit.name) and (self.dimension == unit.dimension):
-            return Unit()
-
-        if (unit.dimension is Dimension.none):
-            return self
-        
-        return Unit(name=self.generate_name(unit, '/'), dimension=self.dimension / unit.dimension)
-
-    def __mul__(self, unit: 'Unit') -> 'Unit':
-        return Unit(name=self.generate_name(unit, '*'), dimension=self.dimension * unit.dimension)
-
-    def __eq__(self, unit: 'Unit') -> bool:
-        if not isinstance(unit, Unit):
-            raise TypeError(f'Cannot compare Unit to non-Unit type: {type(unit)}')
-        return (self.name == unit.name) and (self.dimension == unit.dimension)
-
-    def __hash__(self) -> int:
-        return hash(tuple([self.name, self.dimension,]))

ucon-0.3.3rc2.dist-info/RECORD

@@ -1,15 +0,0 @@
-tests/ucon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/ucon/test_core.py,sha256=a48nfTqg-WJ_jzjVT6KtsBb6E8oPUZaqCmscKDzlG_g,22871
-tests/ucon/test_dimension.py,sha256=JyA9ySFvohs2l6oK77ehCQ7QvvFVqB_9t0iC7CUErjw,7296
-tests/ucon/test_unit.py,sha256=vEPOeSxFBqcRBAUczCN9KPo_dTmLk4LQExPSt6UGVa4,5712
-tests/ucon/test_units.py,sha256=248JZbo8RVvG_q3T0IhKG43vxM4F_2Xgf4_RjGZNsFM,704
-ucon/__init__.py,sha256=ZWWLodIiG17OgCfoAm532wpwmJzdRXlUGX3w6OBxFeQ,1743
-ucon/core.py,sha256=QI0aayUm0rgggdD7_zvdrmV26dbEARCJ6Yj5gn5PitI,13729
-ucon/dimension.py,sha256=uUP05bPE8r15oFeD36DrclNIfBsugV7uFhvtJRYy4qI,6598
-ucon/unit.py,sha256=KxOBcQNxciljGskhZCfktLhRF5u-rWgrTg565Flo3eI,3213
-ucon/units.py,sha256=e1j7skYMghlMZi7l94EAgxq4_lNRDC7FcSooJoE_U50,3689
-ucon-0.3.3rc2.dist-info/licenses/LICENSE,sha256=-Djjiq2wM8Cc6fzTsdMbr_T2_uaX6Yorxcemr3GGkqc,1072
-ucon-0.3.3rc2.dist-info/METADATA,sha256=ngEwpM1VYJIqUwDilCUwNavOqt0ol55k4zFNDb7Xcpg,10606
-ucon-0.3.3rc2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ucon-0.3.3rc2.dist-info/top_level.txt,sha256=zZYRJiQrVUtN32ziJD2YEq7ClSvDmVYHYy5ArRAZGxI,11
-ucon-0.3.3rc2.dist-info/RECORD,,

ucon-0.3.3rc2.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.