qnty 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

qnty/__init__.py

@@ -25,6 +25,7 @@ from .variables import (
     AreaPerUnitVolume,
     AtomicWeight,
     Concentration,
+    Dimensionless,
     DynamicFluidity,
     ElectricCapacitance,
     ElectricCharge,
@@ -81,6 +82,7 @@ from .variables import (
     MomentumFlux,
     NormalityOfSolution,
     ParticleDensity,
+    Percent,
     Permeability,
     PhotonEmissionRate,
     PowerPerUnitMass,
@@ -129,15 +131,15 @@ registry.finalize_registration()
 # Define public API
 __all__ = [
     # Core variable types (most commonly used)
-    "Length", "Pressure", "Temperature", "Time", "Mass", "Volume", "Area",
-    "Force", "EnergyHeatWork", "PowerThermalDuty",
+    "Dimensionless", "Length", "Pressure", "Temperature", "Time", "Mass",
+    "Volume", "Area", "Force", "EnergyHeatWork", "PowerThermalDuty",
 
     # Core classes for advanced usage
     "FastQuantity", "TypeSafeVariable", "TypeSafeSetter",
     "DimensionSignature", "BaseDimension",
     "Expression", "Equation",
 
-    # All other variable types (95 additional types)
+    # All other variable types (96 additional types)
     "AbsorbedDose", "Acceleration", "ActivationEnergy", "AmountOfSubstance",
     "AnglePlane", "AngleSolid", "AngularAcceleration", "AngularMomentum",
     "AreaPerUnitVolume", "AtomicWeight", "Concentration", "DynamicFluidity",
@@ -156,7 +158,7 @@ __all__ = [
     "MassTransferCoefficient", "MolalityOfSoluteI", "MolarConcentrationByMass",
     "MolarFlowRate", "MolarFlux", "MolarHeatCapacity", "MolarityOfI",
     "MoleFractionOfI", "MomentOfInertia", "MomentumFlowRate", "MomentumFlux",
-    "NormalityOfSolution", "ParticleDensity", "Permeability",
+    "NormalityOfSolution", "ParticleDensity", "Percent", "Permeability",
     "PhotonEmissionRate", "PowerPerUnitMass", "PowerPerUnitVolume",
     "RadiationDoseEquivalent", "RadiationExposure", "Radioactivity",
     "SecondMomentOfArea", "SecondRadiationConstantPlanck", "SpecificEnthalpy",

qnty/dimension.py

@@ -19,6 +19,7 @@ class BaseDimension(IntEnum):
     TEMPERATURE = 11
     AMOUNT = 13
     LUMINOSITY = 17
+    DIMENSIONLESS = 1  # Must be 1 to act as multiplicative identity
 
 
 @final
@@ -78,8 +79,8 @@ ACCELERATION = DimensionSignature.create(length=1, time=-2)  # L T^-2
 ACTIVATION_ENERGY = DimensionSignature.create(amount=-1, length=2, time=-2)  # N^-1 L^2 T^-2
 AMOUNT = DimensionSignature.create(amount=1)  # N
 AMOUNT_OF_SUBSTANCE = DimensionSignature.create(amount=1)  # N
-ANGLE_PLANE = DimensionSignature.create()  # Dimensionless
-ANGLE_SOLID = DimensionSignature.create()  # Dimensionless
+ANGLE_PLANE = DimensionSignature(BaseDimension.DIMENSIONLESS)  # Dimensionless
+ANGLE_SOLID = DimensionSignature(BaseDimension.DIMENSIONLESS)  # Dimensionless
 ANGULAR_ACCELERATION = DimensionSignature.create(time=-2)  # T^-2
 ANGULAR_MOMENTUM = DimensionSignature.create(length=2, mass=1, time=-1)  # L^2 M T^-1
 AREA = DimensionSignature.create(length=2)  # L^2
@@ -87,7 +88,7 @@ AREA_PER_UNIT_VOLUME = DimensionSignature.create(length=-1)  # L^-1
 ATOMIC_WEIGHT = DimensionSignature.create(amount=-1, mass=1)  # N^-1 M
 CONCENTRATION = DimensionSignature.create(length=-3, mass=1)  # L^-3 M
 CURRENT = DimensionSignature.create(current=1)  # A
-DIMENSIONLESS = DimensionSignature.create()  # Dimensionless
+DIMENSIONLESS = DimensionSignature(BaseDimension.DIMENSIONLESS)  # Dimensionless
 DYNAMIC_FLUIDITY = DimensionSignature.create(length=1, mass=-1, time=1)  # L M^-1 T
 ELECTRICAL_CONDUCTANCE = DimensionSignature.create(current=2, length=-2, mass=-1, time=3)  # A^2 L^-2 M^-1 T^3
 ELECTRICAL_PERMITTIVITY = DimensionSignature.create(current=2, length=-3, mass=-1, time=4)  # A^2 L^-3 M^-1 T^4
@@ -131,7 +132,7 @@ MASS = DimensionSignature.create(mass=1)  # M
 MASS_DENSITY = DimensionSignature.create(length=-3, mass=1)  # L^-3 M
 MASS_FLOW_RATE = DimensionSignature.create(mass=1, time=-1)  # M T^-1
 MASS_FLUX = DimensionSignature.create(length=-2, mass=1, time=-1)  # L^-2 M T^-1
-MASS_FRACTION_OF_I = DimensionSignature.create()  # Dimensionless
+MASS_FRACTION_OF_I = DimensionSignature(BaseDimension.DIMENSIONLESS)  # Dimensionless
 MASS_TRANSFER_COEFFICIENT = DimensionSignature.create(length=-2, mass=1, time=-1)  # L^-2 M T^-1
 MOLALITY_OF_SOLUTE_I = DimensionSignature.create(amount=1, mass=-1)  # N M^-1
 MOLARITY_OF_I = DimensionSignature.create(amount=1, length=-3)  # N L^-3
@@ -139,12 +140,13 @@ MOLAR_CONCENTRATION_BY_MASS = DimensionSignature.create(amount=1)  # N
 MOLAR_FLOW_RATE = DimensionSignature.create(amount=1, time=-1)  # N T^-1
 MOLAR_FLUX = DimensionSignature.create(amount=1, length=-2, time=-1)  # N L^-2 T^-1
 MOLAR_HEAT_CAPACITY = DimensionSignature.create(amount=-1, length=2, temp=-1, time=-2)  # N^-1 L^2 Θ^-1 T^-2
-MOLE_FRACTION_OF_I = DimensionSignature.create()  # Dimensionless
+MOLE_FRACTION_OF_I = DimensionSignature(BaseDimension.DIMENSIONLESS)  # Dimensionless
 MOMENTUM_FLOW_RATE = DimensionSignature.create(length=1, mass=1, time=-2)  # L M T^-2
 MOMENTUM_FLUX = DimensionSignature.create(length=-1, mass=1, time=-2)  # L^-1 M T^-2
 MOMENT_OF_INERTIA = DimensionSignature.create(length=2, mass=1)  # L^2 M
 NORMALITY_OF_SOLUTION = DimensionSignature.create(amount=1, length=-3)  # N L^-3
 PARTICLE_DENSITY = DimensionSignature.create(length=-3)  # L^-3
+PERCENT = DimensionSignature(BaseDimension.DIMENSIONLESS)  # Dimensionless
 PERMEABILITY = DimensionSignature.create(length=2)  # L^2
 PHOTON_EMISSION_RATE = DimensionSignature.create(length=-2, time=-1)  # L^-2 T^-1
 POWER_PER_UNIT_MASS = DimensionSignature.create(length=2, time=-3)  # L^2 T^-3
@@ -157,7 +159,7 @@ RADIOACTIVITY = DimensionSignature.create(time=-1)  # T^-1
 SECOND_MOMENT_OF_AREA = DimensionSignature.create(length=4)  # L^4
 SECOND_RADIATION_CONSTANT_PLANCK = DimensionSignature.create(length=1, temp=1)  # L Θ
 SPECIFIC_ENTHALPY = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
-SPECIFIC_GRAVITY = DimensionSignature.create()  # Dimensionless
+SPECIFIC_GRAVITY = DimensionSignature(BaseDimension.DIMENSIONLESS)  # Dimensionless
 SPECIFIC_HEAT_CAPACITY_CONSTANT_PRESSURE = DimensionSignature.create(length=2, mass=1, temp=-1, time=-2)  # L^2 M Θ^-1 T^-2
 SPECIFIC_LENGTH = DimensionSignature.create(length=1, mass=-1)  # L M^-1
 SPECIFIC_SURFACE = DimensionSignature.create(length=2, mass=-1)  # L^2 M^-1
@@ -180,5 +182,5 @@ VOLUMETRIC_COEFFICIENT_OF_EXPANSION = DimensionSignature.create(length=-3, mass=
 VOLUMETRIC_FLOW_RATE = DimensionSignature.create(length=3, time=-1)  # L^3 T^-1
 VOLUMETRIC_FLUX = DimensionSignature.create(length=1, time=-1)  # L T^-1
 VOLUMETRIC_MASS_FLOW_RATE = DimensionSignature.create(length=-3, mass=1, time=-1)  # L^-3 M T^-1
-VOLUME_FRACTION_OF_I = DimensionSignature.create()  # Dimensionless
+VOLUME_FRACTION_OF_I = DimensionSignature(BaseDimension.DIMENSIONLESS)  # Dimensionless
 WAVENUMBER = DimensionSignature.create(length=-1)  # L^-1

qnty/expression.py

@@ -246,11 +246,23 @@ class BinaryOperation(Expression):
         left_str = str(self.left)
         right_str = str(self.right)
         
-        # Add parentheses only when needed based on precedence
+        # Add parentheses for left side when precedence is strictly lower
         if isinstance(self.left, BinaryOperation) and precedence.get(self.left.operator, 0) < precedence.get(self.operator, 0):
             left_str = f"({left_str})"
-        if isinstance(self.right, BinaryOperation) and precedence.get(self.right.operator, 0) < precedence.get(self.operator, 0):
-            right_str = f"({right_str})"
+        
+        # CRITICAL FIX: For right side, add parentheses when:
+        # 1. Precedence is strictly lower, OR
+        # 2. Precedence is equal AND operation is left-associative (-, /)
+        if isinstance(self.right, BinaryOperation):
+            right_prec = precedence.get(self.right.operator, 0)
+            curr_prec = precedence.get(self.operator, 0)
+            
+            # Need parentheses if:
+            # - Right has lower precedence, OR
+            # - Same precedence and current operator is left-associative (- or /)
+            if (right_prec < curr_prec or 
+                (right_prec == curr_prec and self.operator in ['-', '/'])):
+                right_str = f"({right_str})"
             
         return f"{left_str} {self.operator} {right_str}"
 

qnty/unit.py

@@ -7,7 +7,7 @@ Unit definitions, constants and registry for the high-performance unit system.
 
 from dataclasses import dataclass
 
-from .dimension import DIMENSIONLESS, LENGTH, PRESSURE, DimensionSignature
+from .dimension import DimensionSignature
 from .prefixes import SIPrefix, StandardPrefixes
 
 
@@ -70,40 +70,8 @@ class HighPerformanceRegistry:
         self.base_units: dict[str, UnitDefinition] = {}  # Track base units for prefix generation
         self.prefixable_units: set[str] = set()  # Track which units can have prefixes
 
-        # Keep legacy initialization for backward compatibility
-        self._initialize_units()
-        self._precompute_conversions()
+        # Registry starts empty - units are registered via register_all_units() in __init__.py
     
-    def _initialize_units(self):
-        """Initialize with engineering units."""
-        
-        # Length units
-        meter = UnitDefinition("meter", "m", LENGTH, 1.0)
-        millimeter = UnitDefinition("millimeter", "mm", LENGTH, 0.001)
-        centimeter = UnitDefinition("centimeter", "cm", LENGTH, 0.01)
-        inch = UnitDefinition("inch", "in", LENGTH, 0.0254)
-        foot = UnitDefinition("foot", "ft", LENGTH, 0.3048)
-        
-        # Pressure units
-        pascal = UnitDefinition("pascal", "Pa", PRESSURE, 1.0)
-        kilopascal = UnitDefinition("kilopascal", "kPa", PRESSURE, 1000.0)
-        megapascal = UnitDefinition("megapascal", "MPa", PRESSURE, 1e6)
-        psi = UnitDefinition("psi", "psi", PRESSURE, 6894.757)
-        bar = UnitDefinition("bar", "bar", PRESSURE, 100000.0)
-        
-        # Dimensionless units
-        dimensionless = UnitDefinition("dimensionless", "", DIMENSIONLESS, 1.0)
-        
-        # Register all units
-        for unit_def in [meter, millimeter, centimeter, inch, foot,
-                        pascal, kilopascal, megapascal, psi, bar, dimensionless]:
-            self.units[unit_def.name] = unit_def
-            
-            # Group by dimension
-            dim_sig = unit_def.dimension._signature
-            if dim_sig not in self.dimensional_groups:
-                self.dimensional_groups[dim_sig] = []
-            self.dimensional_groups[dim_sig].append(unit_def)
     
     def register_unit(self, unit_def: UnitDefinition):
         """Register a single unit definition."""

qnty/units.py

@@ -3,8 +3,8 @@ Comprehensive Consolidated Units Module
 =======================================
 
 Auto-generated consolidated unit definitions for all engineering units.
-Contains 864 units
-across 105 fields organized into 105 dimensional groups.
+Contains 871 units
+across 107 fields organized into 107 dimensional groups.
 
 Generated from the complete NIST unit tables and engineering references.
 """
@@ -22,9 +22,6 @@ from .dimension import (
     CONCENTRATION,
     DIMENSIONLESS,
     DYNAMIC_FLUIDITY,
-    ELECTRICAL_CONDUCTANCE,
-    ELECTRICAL_PERMITTIVITY,
-    ELECTRICAL_RESISTIVITY,
     ELECTRIC_CAPACITANCE,
     ELECTRIC_CHARGE,
     ELECTRIC_CURRENT_INTENSITY,
@@ -33,6 +30,9 @@ from .dimension import (
     ELECTRIC_INDUCTANCE,
     ELECTRIC_POTENTIAL,
     ELECTRIC_RESISTANCE,
+    ELECTRICAL_CONDUCTANCE,
+    ELECTRICAL_PERMITTIVITY,
+    ELECTRICAL_RESISTIVITY,
     ENERGY_FLUX,
     ENERGY_HEAT_WORK,
     ENERGY_PER_UNIT_AREA,
@@ -65,14 +65,14 @@ from .dimension import (
     MASS_FLUX,
     MASS_TRANSFER_COEFFICIENT,
     MOLALITY_OF_SOLUTE_I,
-    MOLARITY_OF_I,
     MOLAR_CONCENTRATION_BY_MASS,
     MOLAR_FLOW_RATE,
     MOLAR_FLUX,
     MOLAR_HEAT_CAPACITY,
+    MOLARITY_OF_I,
+    MOMENT_OF_INERTIA,
     MOMENTUM_FLOW_RATE,
     MOMENTUM_FLUX,
-    MOMENT_OF_INERTIA,
     NORMALITY_OF_SOLUTION,
     PARTICLE_DENSITY,
     PERMEABILITY,
@@ -109,7 +109,7 @@ from .dimension import (
     VOLUMETRIC_FLOW_RATE,
     VOLUMETRIC_FLUX,
     VOLUMETRIC_MASS_FLOW_RATE,
-    WAVENUMBER
+    WAVENUMBER,
 )
 
 # Comprehensive unit definitions organized by dimensional signature
@@ -843,6 +843,46 @@ UNIT_DEFINITIONS = {
         "aliases": {}
     },
 
+    "dimensionless": {
+        # Dimensionless - Dimensionless
+        "dimension": DIMENSIONLESS,
+        "units": [
+            {
+                "name": "dimensionless",
+                "symbol": "",
+                "si_factor": 1.0,
+                "full_name": "dimensionless",
+                "notation": "",
+                "aliases": [],
+            },
+            {
+                "name": "parts_per_billion",
+                "symbol": "ppb",
+                "si_factor": 1e-09,
+                "full_name": "parts per billion",
+                "notation": "ppb",
+                "aliases": ['ppb'],
+            },
+            {
+                "name": "parts_per_million",
+                "symbol": "ppm",
+                "si_factor": 1e-06,
+                "full_name": "parts per million",
+                "notation": "ppm",
+                "aliases": ['ppm'],
+            },
+            {
+                "name": "ratio",
+                "symbol": "ratio",
+                "si_factor": 1.0,
+                "full_name": "ratio",
+                "notation": "ratio",
+                "aliases": [],
+            }
+        ],
+        "aliases": {}
+    },
+
     "dynamic_fluidity": {
         # Dynamic Fluidity - LENGTH MASS^-1 TIME
         "dimension": DYNAMIC_FLUIDITY,
@@ -4979,6 +5019,38 @@ UNIT_DEFINITIONS = {
         "aliases": {}
     },
 
+    "percent": {
+        # Percent - Dimensionless
+        "dimension": DIMENSIONLESS,
+        "units": [
+            {
+                "name": "basis_point",
+                "symbol": "bp",
+                "si_factor": 0.0001,
+                "full_name": "basis point",
+                "notation": "bp",
+                "aliases": ['bp', 'bps'],
+            },
+            {
+                "name": "per_mille",
+                "symbol": "‰",
+                "si_factor": 0.001,
+                "full_name": "per mille",
+                "notation": "‰",
+                "aliases": ['‰'],
+            },
+            {
+                "name": "percent",
+                "symbol": "%",
+                "si_factor": 0.01,
+                "full_name": "percent",
+                "notation": "%",
+                "aliases": ['%'],
+            }
+        ],
+        "aliases": {}
+    },
+
     "permeability": {
         # Permeability - LENGTH^2
         "dimension": PERMEABILITY,
@@ -5617,10 +5689,10 @@ UNIT_DEFINITIONS = {
             },
             {
                 "name": "pound_force_per_square_inch",
-                "symbol": "PSI or psi or $\\mathrm{lb}_{\\mathrm{f}} / \\mathrm{in}^{2}$",
-                "si_factor": 6894.8,
+                "symbol": "psi",
+                "si_factor": 6894.757,
                 "full_name": "pound force per square inch",
-                "notation": "PSI or psi or $\\mathrm{lb}_{\\mathrm{f}} / \\mathrm{in}^{2}$",
+                "notation": "psi",
                 "aliases": ['psi'],
             },
             {
@@ -6185,10 +6257,10 @@ UNIT_DEFINITIONS = {
             },
             {
                 "name": "pound_force_per_square_inch",
-                "symbol": "PSI or psi or $\\mathrm{lb}_{\\mathrm{f}} / \\mathrm{in}^{2}$",
-                "si_factor": 6894.8,
+                "symbol": "psi",
+                "si_factor": 6894.757,
                 "full_name": "pound force per square inch",
-                "notation": "PSI or psi or $\\mathrm{lb}_{\\mathrm{f}} / \\mathrm{in}^{2}$",
+                "notation": "psi",
                 "aliases": ['psi'],
             }
         ],
@@ -7824,8 +7896,8 @@ UNIT_DEFINITIONS = {
 
 def create_unit_class(class_name: str, dimension_data: dict) -> type:
     """Dynamically create a unit class with all unit constants as attributes."""
-    from .unit import UnitConstant, UnitDefinition
     from .prefixes import get_prefix_by_name
+    from .unit import UnitConstant, UnitDefinition
     
     # Create a new class dynamically
     unit_class = type(class_name, (), {})
@@ -7878,8 +7950,8 @@ def create_unit_class(class_name: str, dimension_data: dict) -> type:
 
 def register_all_units(registry):
     """Register all unit definitions to the given registry with prefix support."""
+    from .prefixes import PREFIXABLE_UNITS
     from .unit import UnitDefinition
-    from .prefixes import get_prefix_by_name, StandardPrefixes, PREFIXABLE_UNITS
     
     # First pass: register base units with prefixes where applicable
     for dimension_data in UNIT_DEFINITIONS.values():
@@ -7944,6 +8016,8 @@ AreaUnits = create_unit_class("AreaUnits", UNIT_DEFINITIONS["area"])
 AreaPerUnitVolumeUnits = create_unit_class("AreaPerUnitVolumeUnits", UNIT_DEFINITIONS["area_per_unit_volume"])
 AtomicWeightUnits = create_unit_class("AtomicWeightUnits", UNIT_DEFINITIONS["atomic_weight"])
 ConcentrationUnits = create_unit_class("ConcentrationUnits", UNIT_DEFINITIONS["concentration"])
+DimensionlessUnits = create_unit_class("DimensionlessUnits", UNIT_DEFINITIONS["dimensionless"])
+PercentUnits = create_unit_class("PercentUnits", UNIT_DEFINITIONS["percent"])
 DynamicFluidityUnits = create_unit_class("DynamicFluidityUnits", UNIT_DEFINITIONS["dynamic_fluidity"])
 ElectricCapacitanceUnits = create_unit_class("ElectricCapacitanceUnits", UNIT_DEFINITIONS["electric_capacitance"])
 ElectricChargeUnits = create_unit_class("ElectricChargeUnits", UNIT_DEFINITIONS["electric_charge"])
@@ -8037,56 +8111,3 @@ VolumetricFlowRateUnits = create_unit_class("VolumetricFlowRateUnits", UNIT_DEFI
 VolumetricFluxUnits = create_unit_class("VolumetricFluxUnits", UNIT_DEFINITIONS["volumetric_flux"])
 VolumetricMassFlowRateUnits = create_unit_class("VolumetricMassFlowRateUnits", UNIT_DEFINITIONS["volumetric_mass_flow_rate"])
 WavenumberUnits = create_unit_class("WavenumberUnits", UNIT_DEFINITIONS["wavenumber"])
-
-# Create standalone DimensionlessUnits class for backward compatibility
-class DimensionlessUnits:
-    """Standalone dimensionless units class."""
-    from .unit import UnitConstant, UnitDefinition
-    
-    # Standard dimensionless unit
-    dimensionless_def = UnitDefinition(
-        name="dimensionless",
-        symbol="",
-        dimension=DIMENSIONLESS,
-        si_factor=1.0,
-        si_offset=0.0
-    )
-    dimensionless = UnitConstant(dimensionless_def)
-
-
-# Module-level function for compatibility with existing code
-def get_consolidated_modules():
-    """Return a list of module-like objects for consolidated units."""
-    class ConsolidatedModule:
-        """Mock module object for compatibility with existing registration system."""
-        
-        def __init__(self, dimension_type: str):
-            self.dimension_type = dimension_type
-            self.dimension_data = UNIT_DEFINITIONS[dimension_type]
-        
-        def register_to_registry(self, registry):
-            """Register units for this dimension to the registry."""
-            from .unit import UnitDefinition
-            dimension = self.dimension_data["dimension"]
-            
-            for unit_data in self.dimension_data["units"]:
-                unit_def = UnitDefinition(
-                    name=unit_data["name"],
-                    symbol=unit_data["symbol"],
-                    dimension=dimension,
-                    si_factor=unit_data["si_factor"],
-                    si_offset=unit_data.get("si_offset", 0.0)
-                )
-                
-                if unit_def.name not in registry.units:
-                    registry.register_unit(unit_def)
-    
-    return [
-        ConsolidatedModule(dimension_name) for dimension_name in UNIT_DEFINITIONS
-    ]
-
-
-# Statistics
-TOTAL_UNITS = 864
-TOTAL_FIELDS = 105
-TOTAL_DIMENSIONS = 105

qnty/variable.py

@@ -85,6 +85,11 @@ class FastQuantity:
         if isinstance(other, int | float):
             return FastQuantity(self.value * other, self.unit)
         
+        # Handle TypeSafeVariable objects by using their quantity
+        from .variable_types.typed_variable import TypedVariable  # Avoid circular imports
+        if isinstance(other, TypedVariable) and other.quantity is not None:
+            other = other.quantity
+        
         # Fast dimensional analysis using cached signatures
         result_dimension_sig = self._dimension_sig * other._dimension_sig
         
@@ -129,6 +134,7 @@ class FastQuantity:
         
         # Initialize dimension cache if empty
         if not registry._dimension_cache:
+            from .dimension import ENERGY_PER_UNIT_AREA, SURFACE_TENSION
             registry._dimension_cache = {
                 DIMENSIONLESS._signature: DimensionlessUnits.dimensionless,
                 LENGTH._signature: LengthUnits.millimeter,
@@ -137,17 +143,25 @@ class FastQuantity:
                 VOLUME._signature: LengthUnits.millimeter,  # mm³
                 FORCE._signature: UnitConstant(UnitDefinition("newton", "N", FORCE, 1.0)),
                 ENERGY._signature: UnitConstant(UnitDefinition("joule", "J", ENERGY, 1.0)),
+                SURFACE_TENSION._signature: UnitConstant(UnitDefinition("newton_per_meter", "N/m", SURFACE_TENSION, 1.0)),
+                ENERGY_PER_UNIT_AREA._signature: UnitConstant(UnitDefinition("joule_per_square_meter", "J/m²", ENERGY_PER_UNIT_AREA, 1.0)),
             }
         
         # O(1) lookup for common dimensions
         if result_dimension_sig in registry._dimension_cache:
             return registry._dimension_cache[result_dimension_sig]
         
-        # For rare combined dimensions, create temporary unit
+        # For rare combined dimensions, create SI base unit with descriptive name
+        result_dimension = DimensionSignature(result_dimension_sig)
+        
+        # Create descriptive name based on dimensional analysis
+        si_name = self._create_si_unit_name(result_dimension)
+        si_symbol = self._create_si_unit_symbol(result_dimension)
+        
         temp_unit = UnitDefinition(
-            name=f"combined_{result_dimension_sig}",
-            symbol="combined",
-            dimension=DimensionSignature(result_dimension_sig),
+            name=si_name,
+            symbol=si_symbol,
+            dimension=result_dimension,
             si_factor=1.0
         )
         result_unit = UnitConstant(temp_unit)
@@ -156,6 +170,17 @@ class FastQuantity:
         registry._dimension_cache[result_dimension_sig] = result_unit
         return result_unit
     
+    def _create_si_unit_name(self, dimension: DimensionSignature) -> str:
+        """Create descriptive SI unit name based on dimensional analysis."""
+        # For now, return a generic SI unit name. In the future, this could be enhanced
+        # to parse the dimension signature and create descriptive names like "newton_per_meter"
+        return f"si_derived_unit_{abs(hash(dimension._signature)) % 10000}"
+    
+    def _create_si_unit_symbol(self, _dimension: DimensionSignature) -> str:
+        """Create SI unit symbol based on dimensional analysis."""
+        # For complex units, return descriptive symbol based on common engineering units
+        return "SI_unit"
+    
     def _find_result_unit(self, result_dimension: DimensionSignature,
                          left_qty: FastQuantity, right_qty: FastQuantity) -> UnitConstant:
         """Legacy method - kept for compatibility."""

qnty/variable_types/typed_variable.py

@@ -62,27 +62,22 @@ class TypedVariable(ExpressionVariable):
             # Auto-set the value with the specified unit
             setter = self._setter_class(self, value)
             
-            # Handle special unit aliases
-            if unit == "in":  # Handle Python reserved word
-                unit = "inchs"  # Match the actual property name
-            elif unit == "inches":  # Handle common plural form
-                unit = "inchs"  # Match the actual property name
-            
             # Try to find the unit property on the setter
             if hasattr(setter, unit):
                 getattr(setter, unit)
             elif hasattr(setter, unit + 's'):  # Handle singular/plural
                 getattr(setter, unit + 's')
-            elif self._default_unit_property and hasattr(setter, self._default_unit_property):
-                # Fall back to default unit
-                getattr(setter, self._default_unit_property)
+            elif unit.endswith('s') and hasattr(setter, unit[:-1]):  # Handle plural to singular
+                getattr(setter, unit[:-1])
             else:
-                # Last resort - try to find any valid unit property
-                # This helps with forward compatibility
+                # Unit not found - provide helpful error with available units
                 unit_properties = [attr for attr in dir(setter)
                                  if not attr.startswith('_') and attr != 'value' and attr != 'variable']
-                if unit_properties:
-                    getattr(setter, unit_properties[0])
+                available_units = ', '.join(sorted(unit_properties[:10]))  # Show first 10 units
+                if len(unit_properties) > 10:
+                    available_units += f' ... and {len(unit_properties) - 10} more'
+                raise ValueError(f"Unit '{unit}' not found for {self.__class__.__name__}. "
+                               f"Available units: {available_units}")
                     
         else:
             # More specific error messages matching test expectations

qnty/variables.py

@@ -7,8 +7,9 @@ Uses the exact same source of truth and approach as consolidated units system.
 Auto-generated from unit_data.json and dimension_mapping.json.
 """
 
-from typing import Any, cast
+from typing import Any
 
+from . import units
 from .dimension import (
     ABSORBED_DOSE,
     ACCELERATION,
@@ -24,9 +25,6 @@ from .dimension import (
     CONCENTRATION,
     DIMENSIONLESS,
     DYNAMIC_FLUIDITY,
-    ELECTRICAL_CONDUCTANCE,
-    ELECTRICAL_PERMITTIVITY,
-    ELECTRICAL_RESISTIVITY,
     ELECTRIC_CAPACITANCE,
     ELECTRIC_CHARGE,
     ELECTRIC_CURRENT_INTENSITY,
@@ -35,6 +33,9 @@ from .dimension import (
     ELECTRIC_INDUCTANCE,
     ELECTRIC_POTENTIAL,
     ELECTRIC_RESISTANCE,
+    ELECTRICAL_CONDUCTANCE,
+    ELECTRICAL_PERMITTIVITY,
+    ELECTRICAL_RESISTIVITY,
     ENERGY_FLUX,
     ENERGY_HEAT_WORK,
     ENERGY_PER_UNIT_AREA,
@@ -68,17 +69,18 @@ from .dimension import (
     MASS_FRACTION_OF_I,
     MASS_TRANSFER_COEFFICIENT,
     MOLALITY_OF_SOLUTE_I,
-    MOLARITY_OF_I,
     MOLAR_CONCENTRATION_BY_MASS,
     MOLAR_FLOW_RATE,
     MOLAR_FLUX,
     MOLAR_HEAT_CAPACITY,
+    MOLARITY_OF_I,
     MOLE_FRACTION_OF_I,
+    MOMENT_OF_INERTIA,
     MOMENTUM_FLOW_RATE,
     MOMENTUM_FLUX,
-    MOMENT_OF_INERTIA,
     NORMALITY_OF_SOLUTION,
     PARTICLE_DENSITY,
+    PERCENT,
     PERMEABILITY,
     PHOTON_EMISSION_RATE,
     POWER_PER_UNIT_MASS,
@@ -109,16 +111,14 @@ from .dimension import (
     VISCOSITY_DYNAMIC,
     VISCOSITY_KINEMATIC,
     VOLUME,
+    VOLUME_FRACTION_OF_I,
     VOLUMETRIC_CALORIFIC_HEATING_VALUE,
     VOLUMETRIC_COEFFICIENT_OF_EXPANSION,
     VOLUMETRIC_FLOW_RATE,
     VOLUMETRIC_FLUX,
     VOLUMETRIC_MASS_FLOW_RATE,
-    VOLUME_FRACTION_OF_I,
-    WAVENUMBER
+    WAVENUMBER,
 )
-from .unit import UnitConstant, UnitDefinition
-from .units import DimensionlessUnits
 from .variable import FastQuantity, TypeSafeSetter
 from .variable_types.typed_variable import TypedVariable
 
@@ -299,6 +299,18 @@ VARIABLE_DEFINITIONS = {
         "field_name": "concentration",
         "display_name": "Concentration",
     },
+    "Dimensionless": {
+        "dimension": DIMENSIONLESS,
+        "default_unit": "dimensionless",
+        "units": [
+            ("dimensionless", "dimensionless", 1.0, "", []),
+            ("ratio", "ratio", 1.0, "ratio", []),
+            ("parts per million", "parts_per_million", 1e-06, "ppm", ['ppm']),
+            ("parts per billion", "parts_per_billion", 1e-09, "ppb", ['ppb'])
+        ],
+        "field_name": "dimensionless",
+        "display_name": "Dimensionless",
+    },
     "DynamicFluidity": {
         "dimension": DYNAMIC_FLUIDITY,
         "default_unit": "meter_seconds_per_kilogram",
@@ -1210,6 +1222,17 @@ VARIABLE_DEFINITIONS = {
         "field_name": "particle_density",
         "display_name": "Particle Density",
     },
+    "Percent": {
+        "dimension": PERCENT,
+        "default_unit": "percent",
+        "units": [
+            ("percent", "percent", 0.01, "%", ['%']),
+            ("per mille", "per_mille", 0.001, "‰", ['‰']),
+            ("basis point", "basis_point", 0.0001, "bp", ['bp', 'bps'])
+        ],
+        "field_name": "percent",
+        "display_name": "Percent",
+    },
     "Permeability": {
         "dimension": PERMEABILITY,
         "default_unit": "square_meters",
@@ -1329,7 +1352,7 @@ VARIABLE_DEFINITIONS = {
             ("pascal", "pascal", 1.0, "Pa", ['Pa']),
             ("pièze", "pièze", 1000.0, "pz", ['pz']),
             ("pound force per square foot", "pound_force_per_square_foot", 47.880259, "PSF or psf or $\\mathrm{lb}_{\\mathrm{f}} / \\mathrm{ft}^{2}$", ['psf']),
-            ("pound force per square inch", "pound_force_per_square_inch", 6894.8, "PSI or psi or $\\mathrm{lb}_{\\mathrm{f}} / \\mathrm{in}^{2}$", ['psi']),
+            ("pound force per square inch", "pound_force_per_square_inch", 6894.757, "psi", ['psi']),
             ("torr", "torr", 133.322, "torr or mm Hg ( $0{ }^{\\circ}$ C)", ['mm Hg ( 0{ ^{circ C)']),
             ("kilopascal", "kilopascal", 1000.0, "kPa", ['kPa'])
         ],
@@ -1485,7 +1508,7 @@ VARIABLE_DEFINITIONS = {
             ("ounce force per square inch", "ounce_force_per_square_inch", 430.922, "OSI or osi or $\\mathrm{oz}_{\\mathrm{f}} / \\mathrm{in}^{2}$", ['OSI', 'osi', 'oz_{f / in^{2']),
             ("pascal", "pascal", 1.0, "Pa", ['Pa']),
             ("pound force per square foot", "pound_force_per_square_foot", 47.880259, "PSF or psf or $\\mathrm{lb}_{\\mathrm{f}} / \\mathrm{ft}^{2}$", ['PSF', 'psf', 'lb_{f / ft^{2']),
-            ("pound force per square inch", "pound_force_per_square_inch", 6894.8, "PSI or psi or $\\mathrm{lb}_{\\mathrm{f}} / \\mathrm{in}^{2}$", ['psi'])
+            ("pound force per square inch", "pound_force_per_square_inch", 6894.757, "psi", ['psi'])
         ],
         "field_name": "stress",
         "display_name": "Stress",
@@ -1830,38 +1853,6 @@ VARIABLE_DEFINITIONS = {
     }
 }
 
-# Special Dimensionless variable - handcrafted for proper behavior
-class DimensionlessSetter(TypeSafeSetter):
-    """Dimensionless-specific setter with only dimensionless units."""
-    
-    def __init__(self, variable: 'Dimensionless', value: float):
-        super().__init__(variable, value)
-    
-    # Dimensionless units
-    @property
-    def dimensionless(self) -> 'Dimensionless':
-        self.variable.quantity = FastQuantity(self.value, DimensionlessUnits.dimensionless)
-        return cast('Dimensionless', self.variable)
-    
-    # Common alias for no units
-    @property
-    def unitless(self) -> 'Dimensionless':
-        self.variable.quantity = FastQuantity(self.value, DimensionlessUnits.dimensionless)
-        return cast('Dimensionless', self.variable)
-
-
-class Dimensionless(TypedVariable):
-    """Type-safe dimensionless variable with expression capabilities."""
-
-    _setter_class = DimensionlessSetter
-    _expected_dimension = DIMENSIONLESS
-    _default_unit_property = "dimensionless"
-    
-    def set(self, value: float) -> DimensionlessSetter:
-        """Create a dimensionless setter for this variable with proper type annotation."""
-        return DimensionlessSetter(self, value)
-
-
 
 def convert_unit_name_to_property(unit_name: str) -> str:
     """Convert unit name to property name without automatic pluralization."""
@@ -1890,25 +1881,24 @@ def create_setter_class(class_name: str, variable_name: str, definition: dict[st
         }
     )
     
+    # Store reference to the unit class at class level
+    # Remove "Setter" from class_name to get the base variable name
+    base_class_name = class_name.replace("Setter", "")
+    units_class = getattr(units, f"{base_class_name}Units")
+    
     # Add properties for each unit using unit data directly
     for unit_name, property_name, si_factor, symbol, aliases in definition["units"]:
         # Create a unit definition from the consolidated data
-        def make_property(unit_nm, si_fac, sym):
+        def make_property(prop_nm, units_cls):
             def getter(self):
-                # Create unit definition and constant from consolidated unit data
-                unit_def = UnitDefinition(
-                    name=unit_nm,
-                    symbol=sym,
-                    dimension=definition["dimension"],
-                    si_factor=si_fac
-                )
-                unit_const = UnitConstant(unit_def)
+                # Use existing unit constant from units module
+                unit_const = getattr(units_cls, prop_nm)
                 self.variable.quantity = FastQuantity(self.value, unit_const)
                 return self.variable  # type: ignore
             return property(getter)
         
         # Add the primary property to the class
-        setattr(setter_class, property_name, make_property(unit_name, si_factor, symbol))
+        setattr(setter_class, property_name, make_property(property_name, units_class))
         
         # Add alias properties
         for alias in aliases:
@@ -1916,7 +1906,7 @@ def create_setter_class(class_name: str, variable_name: str, definition: dict[st
             alias_property = convert_unit_name_to_property(alias)
             # Only add if it's different from the main property and doesn't already exist
             if alias_property != property_name and not hasattr(setter_class, alias_property):
-                setattr(setter_class, alias_property, make_property(unit_name, si_factor, symbol))
+                setattr(setter_class, alias_property, make_property(property_name, units_class))
     
     return setter_class
 
@@ -1944,8 +1934,7 @@ def create_variable_class(class_name: str, definition: dict[str, Any], setter_cl
 
 
 # Create all variable and setter classes dynamically
-for var_name, var_def in VARIABLE_DEFINITIONS.items():
-    # Create setter class
+for var_name, var_def in VARIABLE_DEFINITIONS.items():    # Create setter class
     setter_name = f"{var_name}Setter"
     setter_class = create_setter_class(setter_name, var_name, var_def)
     
@@ -1957,7 +1946,6 @@ for var_name, var_def in VARIABLE_DEFINITIONS.items():
     globals()[var_name] = variable_class
 
 # Individual exports for easier import
-# Special Dimensionless class is already defined above
 
 AbsorbedDoseSetter = globals()['AbsorbedDoseSetter']
 AbsorbedDose = globals()['AbsorbedDose']
@@ -1983,6 +1971,8 @@ AtomicWeightSetter = globals()['AtomicWeightSetter']
 AtomicWeight = globals()['AtomicWeight']
 ConcentrationSetter = globals()['ConcentrationSetter']
 Concentration = globals()['Concentration']
+DimensionlessSetter = globals()['DimensionlessSetter']
+Dimensionless = globals()['Dimensionless']
 DynamicFluiditySetter = globals()['DynamicFluiditySetter']
 DynamicFluidity = globals()['DynamicFluidity']
 ElectricCapacitanceSetter = globals()['ElectricCapacitanceSetter']
@@ -2095,6 +2085,8 @@ NormalityOfSolutionSetter = globals()['NormalityOfSolutionSetter']
 NormalityOfSolution = globals()['NormalityOfSolution']
 ParticleDensitySetter = globals()['ParticleDensitySetter']
 ParticleDensity = globals()['ParticleDensity']
+PercentSetter = globals()['PercentSetter']
+Percent = globals()['Percent']
 PermeabilitySetter = globals()['PermeabilitySetter']
 Permeability = globals()['Permeability']
 PhotonEmissionRateSetter = globals()['PhotonEmissionRateSetter']
@@ -2206,6 +2198,7 @@ def get_consolidated_variable_modules():
         ConsolidatedVariableModule("AreaPerUnitVolume"),
         ConsolidatedVariableModule("AtomicWeight"),
         ConsolidatedVariableModule("Concentration"),
+        ConsolidatedVariableModule("Dimensionless"),
         ConsolidatedVariableModule("DynamicFluidity"),
         ConsolidatedVariableModule("ElectricCapacitance"),
         ConsolidatedVariableModule("ElectricCharge"),
@@ -2262,6 +2255,7 @@ def get_consolidated_variable_modules():
         ConsolidatedVariableModule("MomentumFlux"),
         ConsolidatedVariableModule("NormalityOfSolution"),
         ConsolidatedVariableModule("ParticleDensity"),
+        ConsolidatedVariableModule("Percent"),
         ConsolidatedVariableModule("Permeability"),
         ConsolidatedVariableModule("PhotonEmissionRate"),
         ConsolidatedVariableModule("PowerPerUnitMass"),

qnty/variables.pyi

@@ -3,52 +3,17 @@ Type stubs for consolidated variables module - Complete Edition.
 
 Provides complete type hints for IDE autocomplete and type checking
 for the fluent API with dimension-specific unit properties for all
-105 variable types with 864 total units.
+107 variable types with 871 total units.
 
 Auto-generated from the same source of truth as consolidated_new.py.
 """
 
 from typing import Any
+
 from .dimension import DimensionSignature
 from .variable import TypeSafeSetter
 from .variable_types.typed_variable import TypedVariable
 
-# ============================================================================
-# SPECIAL DIMENSIONLESS VARIABLE
-# ============================================================================
-
-class DimensionlessSetter(TypeSafeSetter):
-    """Dimensionless-specific setter with only dimensionless units."""
-    
-    def __init__(self, variable: Dimensionless, value: float) -> None: ...
-    
-    @property
-    def dimensionless(self) -> Dimensionless: ...
-    
-    @property
-    def unitless(self) -> Dimensionless: ...
-
-
-class Dimensionless(TypedVariable):
-    """Type-safe dimensionless variable with expression capabilities."""
-
-    _setter_class: type[TypeSafeSetter] | None
-    _expected_dimension: DimensionSignature | None
-    _default_unit_property: str | None
-    
-    def __init__(self, *args, is_known: bool = True) -> None: ...
-    
-    def set(self, value: float) -> DimensionlessSetter:
-        """
-        Create a dimensionless setter for fluent unit assignment.
-        
-        Example:
-            dimensionless.set(1.0).dimensionless
-            dimensionless.set(2.5).unitless
-        """
-        ...
-
-
 # ============================================================================
 # ABSORBED RADIATION DOSE
 # ============================================================================
@@ -677,6 +642,49 @@ class Concentration(TypedVariable):
         """
         ...
 
+# ============================================================================
+# DIMENSIONLESS
+# ============================================================================
+
+class DimensionlessSetter(TypeSafeSetter):
+    """Dimensionless-specific setter with only dimensionless unit properties."""
+    
+    def __init__(self, variable: Dimensionless, value: float) -> None: ...
+    
+    # All dimensionless unit properties - provides fluent API with full type hints
+    @property
+    def dimensionless(self) -> Dimensionless: ...
+    @property
+    def ratio(self) -> Dimensionless: ...
+    @property
+    def parts_per_million(self) -> Dimensionless: ...
+    @property
+    def ppm(self) -> Dimensionless: ...
+    @property
+    def parts_per_billion(self) -> Dimensionless: ...
+    @property
+    def ppb(self) -> Dimensionless: ...
+
+class Dimensionless(TypedVariable):
+    """Type-safe dimensionless variable with expression capabilities."""
+    
+    _setter_class: type[TypeSafeSetter] | None
+    _expected_dimension: DimensionSignature | None
+    _default_unit_property: str | None
+    
+    def __init__(self, *args, is_known: bool = True) -> None: ...
+    
+    def set(self, value: float) -> DimensionlessSetter:
+        """
+        Create a dimensionless setter for fluent unit assignment.
+        
+        Example:
+            dimensionless.set(100).dimensionless
+            dimensionless.set(100).ratio
+            dimensionless.set(100).parts_per_million
+        """
+        ...
+
 # ============================================================================
 # DYNAMIC FLUIDITY
 # ============================================================================
@@ -3782,6 +3790,49 @@ class ParticleDensity(TypedVariable):
         """
         ...
 
+# ============================================================================
+# PERCENT
+# ============================================================================
+
+class PercentSetter(TypeSafeSetter):
+    """Percent-specific setter with only percent unit properties."""
+    
+    def __init__(self, variable: Percent, value: float) -> None: ...
+    
+    # All percent unit properties - provides fluent API with full type hints
+    @property
+    def percent(self) -> Percent: ...
+    @property
+    def unit(self) -> Percent: ...
+    @property
+    def per_mille(self) -> Percent: ...
+    @property
+    def basis_point(self) -> Percent: ...
+    @property
+    def bp(self) -> Percent: ...
+    @property
+    def bps(self) -> Percent: ...
+
+class Percent(TypedVariable):
+    """Type-safe percent variable with expression capabilities."""
+    
+    _setter_class: type[TypeSafeSetter] | None
+    _expected_dimension: DimensionSignature | None
+    _default_unit_property: str | None
+    
+    def __init__(self, *args, is_known: bool = True) -> None: ...
+    
+    def set(self, value: float) -> PercentSetter:
+        """
+        Create a percent setter for fluent unit assignment.
+        
+        Example:
+            percent.set(100).percent
+            percent.set(100).per_mille
+            percent.set(100).basis_point
+        """
+        ...
+
 # ============================================================================
 # PERMEABILITY
 # ============================================================================

{qnty-0.0.4.dist-info → qnty-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qnty
-Version: 0.0.4
+Version: 0.0.6
 Summary: High-performance unit system library for Python with dimensional safety and fast unit conversions
 License: Apache-2.0
 Keywords: units,dimensional analysis,engineering,physics,quantities,measurements

qnty-0.0.6.dist-info/RECORD

@@ -0,0 +1,19 @@
+qnty/__init__.py,sha256=o9rtuo8QAdC3ppaD7ev1jqjrWbCvpdFbi_yZwUBuc6Q,5551
+qnty/dimension.py,sha256=uEm3p03DavihvXH7wnNkTCORZo9wPJihwEqvp4fj2lc,11110
+qnty/equation.py,sha256=XgzM91jn__GomKbgslncoFJWPDJiMb4_VKD-8sdcFXc,9096
+qnty/expression.py,sha256=WV0OfZYPZlNf_sBEgOrnG88KKzj-xvTn45YGMoZR1xc,21435
+qnty/prefixes.py,sha256=bRwcNbE_nX9gXI_WnJZLL-i7kQncIOZivCCSN8dur2g,6000
+qnty/unit.py,sha256=dTKaQ9gsO1rom0JJJ3MYjVaSCuCEU9018DWClTBv7w4,5569
+qnty/unit_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qnty/unit_types/base.py,sha256=Gk2Ab4TE-SfGBn-ko_p0vDI178PG9SyZOJ0cBOYEpdg,1620
+qnty/units.py,sha256=l1o0B4O19XXVH7hkacZqO1WwqqywYJLXYbGHKTOmXcc,302860
+qnty/variable.py,sha256=mqWWOqZX67jD1lLSzM-kSpKDP65l2GKcYRTJ5mwpMUA,11389
+qnty/variable_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qnty/variable_types/base.py,sha256=Otm7FOvuvi1gdlZm-djlTwqhlsSdzPIL46AXnB2cd18,1735
+qnty/variable_types/expression_variable.py,sha256=sRQ4VUMLBEh6tPqOwh4gLtGQH9Y3XeeHGdLKo0E6mWc,2997
+qnty/variable_types/typed_variable.py,sha256=kjw8VOShMaE7iorc3mqCIApYaFgOfvv-jSu_tmT1DgM,4227
+qnty/variables.py,sha256=amlj4xGMC_nuo9sQtGRMG5SAcX4WKK-YWNyXs1yzNbQ,142668
+qnty/variables.pyi,sha256=KYPDJ-Qh_LPP4vHsafzrV6ZAUeepErY-RwRpOTieuhk,219690
+qnty-0.0.6.dist-info/METADATA,sha256=l_noQC2KY0pSXEypKP-WPVe_uPVwMRwa-ECnubcRS-E,12113
+qnty-0.0.6.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+qnty-0.0.6.dist-info/RECORD,,

qnty-0.0.4.dist-info/RECORD

@@ -1,19 +0,0 @@
-qnty/__init__.py,sha256=ath8f_aNoOH_wAXqd71DOZNHckcvjbydSwvlU06VDlY,5491
-qnty/dimension.py,sha256=PiRpZydh7QifD7YdzGCoJZ9EI1fixDsX5KWZj92IXdo,10826
-qnty/equation.py,sha256=XgzM91jn__GomKbgslncoFJWPDJiMb4_VKD-8sdcFXc,9096
-qnty/expression.py,sha256=UM0hCqOVD1gK_O5-Rsq7BWIPDTEL_kFORprV6LIqGcU,20890
-qnty/prefixes.py,sha256=bRwcNbE_nX9gXI_WnJZLL-i7kQncIOZivCCSN8dur2g,6000
-qnty/unit.py,sha256=ZTL_H5FqDCnbNRjPbVrIvhvZkyR6qmMatuVwM5OGqmQ,7071
-qnty/unit_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qnty/unit_types/base.py,sha256=Gk2Ab4TE-SfGBn-ko_p0vDI178PG9SyZOJ0cBOYEpdg,1620
-qnty/units.py,sha256=d7qzWnD5y25EhGSd3Et-jBwZqJ4E0lO-yLZENHOZytA,302734
-qnty/variable.py,sha256=YP4zSvsR0JjEGPiMAFuFbj21SPFeSf1YZ0LhJc-t1qI,9850
-qnty/variable_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qnty/variable_types/base.py,sha256=Otm7FOvuvi1gdlZm-djlTwqhlsSdzPIL46AXnB2cd18,1735
-qnty/variable_types/expression_variable.py,sha256=sRQ4VUMLBEh6tPqOwh4gLtGQH9Y3XeeHGdLKo0E6mWc,2997
-qnty/variable_types/typed_variable.py,sha256=ibmbUh8JCXk2XLc0yvpjMYAtAlpxvia0vB_3xaBqzkc,4345
-qnty/variables.py,sha256=fc7CPLAgqxI7zjeB22PXrTTA6fnl_1gnaX74MYhXMFM,142963
-qnty/variables.pyi,sha256=Sm99jqyVQmuxdPhctmxuSvYrMO9vz4XqhMzBDsr2uC8,217982
-qnty-0.0.4.dist-info/METADATA,sha256=qOxMHMRcnziR5bPNi5QIOZUGShY-0CITI0zsSIqbsvY,12113
-qnty-0.0.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-qnty-0.0.4.dist-info/RECORD,,