qnty 0.0.6__tar.gz → 0.0.8__tar.gz

{qnty-0.0.6 → qnty-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qnty
-Version: 0.0.6
+Version: 0.0.8
 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 → qnty-0.0.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qnty"
-version = "0.0.6"
+version = "0.0.8"
 description = "High-performance unit system library for Python with dimensional safety and fast unit conversions"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{qnty-0.0.6 → qnty-0.0.8}/src/qnty/dimension.py

@@ -28,7 +28,7 @@ class DimensionSignature:
     """Immutable dimension signature for zero-cost dimensional analysis."""
     
     # Store as bit pattern for ultra-fast comparison
-    _signature: int = 1
+    _signature: int | float = 1
     
     @classmethod
     def create(cls, length=0, mass=0, time=0, current=0, temp=0, amount=0, luminosity=0):
@@ -55,7 +55,7 @@ class DimensionSignature:
         return DimensionSignature(self._signature * other._signature)
     
     def __truediv__(self, other):
-        return DimensionSignature(self._signature // other._signature)
+        return DimensionSignature(self._signature / other._signature)
     
     def __pow__(self, power):
         return DimensionSignature(self._signature ** power)

{qnty-0.0.6 → qnty-0.0.8}/src/qnty/equation.py

@@ -117,7 +117,88 @@ class Equation:
         except Exception:
             return False
     
+    def _discover_variables_from_scope(self) -> dict[str, TypeSafeVariable]:
+        """Automatically discover variables from the calling scope."""
+        import inspect
+        
+        # Get the frame that called this method (skip through __str__ calls)
+        frame = inspect.currentframe()
+        try:
+            # Skip frames until we find one outside the equation system
+            while frame and (
+                frame.f_code.co_filename.endswith(('equation.py', 'expression.py')) or
+                frame.f_code.co_name in ['__str__', '__repr__']
+            ):
+                frame = frame.f_back
+            
+            if not frame:
+                return {}
+                
+            # Combine local and global variables
+            all_vars = {**frame.f_globals, **frame.f_locals}
+            
+            # Find TypeSafeVariable objects that match our required variables
+            required_vars = self.variables
+            discovered = {}
+            
+            for var_name in required_vars:
+                for name, obj in all_vars.items():
+                    if hasattr(obj, 'symbol') and obj.symbol == var_name:
+                        discovered[var_name] = obj
+                        break
+                    elif hasattr(obj, 'name') and obj.name == var_name:
+                        discovered[var_name] = obj
+                        break
+            
+            return discovered
+            
+        finally:
+            del frame
+    
+    def _can_auto_solve(self) -> tuple[bool, str, dict[str, TypeSafeVariable]]:
+        """Check if equation can be auto-solved from scope."""
+        try:
+            discovered = self._discover_variables_from_scope()
+            
+            # Check if this is a simple assignment equation (one unknown)
+            unknowns = []
+            knowns = []
+            
+            for var_name in self.variables:
+                if var_name in discovered:
+                    var = discovered[var_name]
+                    if hasattr(var, 'is_known') and not var.is_known:
+                        unknowns.append(var_name)
+                    elif hasattr(var, 'quantity') and var.quantity is not None:
+                        knowns.append(var_name)
+                    else:
+                        unknowns.append(var_name)  # Assume unknown if no quantity
+                else:
+                    return False, "", {}  # Missing variable
+            
+            # Can only auto-solve if there's exactly one unknown
+            if len(unknowns) == 1:
+                return True, unknowns[0], discovered
+            
+            return False, "", {}
+            
+        except Exception:
+            return False, "", {}
+    
+    def _try_auto_solve(self) -> bool:
+        """Try to automatically solve the equation if possible."""
+        try:
+            can_solve, target_var, variables = self._can_auto_solve()
+            if can_solve:
+                self.solve_for(target_var, variables)
+                return True
+            return False
+        except Exception:
+            return False
+    
     def __str__(self) -> str:
+        # Try to auto-solve if possible before displaying
+        self._try_auto_solve()
         return f"{self.lhs} = {self.rhs}"
     
     def __repr__(self) -> str:

{qnty-0.0.6 → qnty-0.0.8}/src/qnty/expression.py

@@ -62,6 +62,80 @@ class Expression(ABC):
     def __str__(self) -> str:
         pass
     
+    def _discover_variables_from_scope(self) -> dict[str, 'TypeSafeVariable']:
+        """Automatically discover variables from the calling scope."""
+        import inspect
+        
+        # Get the frame that called this method (skip through __str__ calls)
+        frame = inspect.currentframe()
+        try:
+            # Skip frames until we find one outside the expression system
+            while frame and (
+                frame.f_code.co_filename.endswith('expression.py') or
+                frame.f_code.co_name in ['__str__', '__repr__']
+            ):
+                frame = frame.f_back
+            
+            if not frame:
+                return {}
+                
+            # Combine local and global variables
+            all_vars = {**frame.f_globals, **frame.f_locals}
+            
+            # Find TypeSafeVariable objects that match our required variables
+            required_vars = self.get_variables()
+            discovered = {}
+            
+            for var_name in required_vars:
+                for name, obj in all_vars.items():
+                    # Check if this is a TypeSafeVariable with matching symbol/name
+                    if hasattr(obj, 'symbol') and obj.symbol == var_name:
+                        discovered[var_name] = obj
+                        break
+                    elif hasattr(obj, 'name') and obj.name == var_name:
+                        discovered[var_name] = obj
+                        break
+                    # Check if this is an Expression that can be evaluated to get the variable
+                    elif hasattr(obj, 'get_variables') and name == var_name:
+                        # This is an expression named after our variable - try to evaluate it
+                        try:
+                            if hasattr(obj, '_can_auto_evaluate'):
+                                can_eval, expr_vars = obj._can_auto_evaluate()
+                                if can_eval:
+                                    result = obj.evaluate(expr_vars)
+                                    # Create a temporary variable to hold the result
+                                    from .variables import Length  # Import here to avoid circular import
+                                    temp_var = Length(result.value, result.unit.symbol, f"temp_{var_name}")
+                                    temp_var.symbol = var_name
+                                    discovered[var_name] = temp_var
+                                    break
+                        except Exception:
+                            pass
+            
+            return discovered
+            
+        finally:
+            del frame
+    
+    def _can_auto_evaluate(self) -> tuple[bool, dict[str, 'TypeSafeVariable']]:
+        """Check if expression can be auto-evaluated from scope."""
+        try:
+            discovered = self._discover_variables_from_scope()
+            required_vars = self.get_variables()
+            
+            # Check if all required variables are available and have values
+            for var_name in required_vars:
+                if var_name not in discovered:
+                    return False, {}
+                var = discovered[var_name]
+                if not hasattr(var, 'quantity') or var.quantity is None:
+                    return False, {}
+            
+            return True, discovered
+            
+        except Exception:
+            return False, {}
+    
     def __add__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
         return BinaryOperation('+', self, wrap_operand(other))
     
@@ -93,17 +167,17 @@ class Expression(ABC):
         return BinaryOperation('**', wrap_operand(other), self)
     
     # Comparison operators for conditional expressions
-    def __lt__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'ComparisonExpression':
-        return ComparisonExpression('<', self, self._wrap_operand(other))
+    def __lt__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'BinaryOperation':
+        return BinaryOperation('<', self, self._wrap_operand(other))
 
-    def __le__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'ComparisonExpression':
-        return ComparisonExpression('<=', self, self._wrap_operand(other))
+    def __le__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'BinaryOperation':
+        return BinaryOperation('<=', self, self._wrap_operand(other))
     
-    def __gt__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'ComparisonExpression':
-        return ComparisonExpression('>', self, self._wrap_operand(other))
+    def __gt__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'BinaryOperation':
+        return BinaryOperation('>', self, self._wrap_operand(other))
     
-    def __ge__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'ComparisonExpression':
-        return ComparisonExpression('>=', self, self._wrap_operand(other))
+    def __ge__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'BinaryOperation':
+        return BinaryOperation('>=', self, self._wrap_operand(other))
     
     @staticmethod
     def _wrap_operand(operand: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
@@ -167,6 +241,7 @@ class Constant(Expression):
         self.value = value
     
     def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'FastQuantity':
+        del variable_values  # Suppress unused variable warning
         return self.value
     
     def get_variables(self) -> set[str]:
@@ -214,6 +289,30 @@ class BinaryOperation(Expression):
                     return FastQuantity(result_value, left_val.unit)
                 else:
                     raise ValueError("Exponent must be dimensionless number")
+            elif self.operator in ['<', '<=', '>', '>=', '==', '!=']:
+                # Comparison operations - return dimensionless 1.0 or 0.0
+                # Convert to same units for comparison if possible
+                try:
+                    if left_val._dimension_sig == right_val._dimension_sig and left_val.unit != right_val.unit:
+                        right_val = right_val.to(left_val.unit)
+                except (ValueError, TypeError, AttributeError):
+                    pass
+                
+                result = False  # Initialize result
+                if self.operator == '<':
+                    result = left_val.value < right_val.value
+                elif self.operator == '<=':
+                    result = left_val.value <= right_val.value
+                elif self.operator == '>':
+                    result = left_val.value > right_val.value
+                elif self.operator == '>=':
+                    result = left_val.value >= right_val.value
+                elif self.operator == '==':
+                    result = abs(left_val.value - right_val.value) < 1e-10
+                elif self.operator == '!=':
+                    result = abs(left_val.value - right_val.value) >= 1e-10
+                
+                return FastQuantity(1.0 if result else 0.0, DimensionlessUnits.dimensionless)
             else:
                 raise ValueError(f"Unknown operator: {self.operator}")
         except Exception as e:
@@ -241,8 +340,17 @@ class BinaryOperation(Expression):
         return BinaryOperation(self.operator, left_simplified, right_simplified)
     
     def __str__(self) -> str:
+        # Try to auto-evaluate if all variables are available
+        can_eval, variables = self._can_auto_evaluate()
+        if can_eval:
+            try:
+                result = self.evaluate(variables)
+                return str(result)
+            except Exception:
+                pass  # Fall back to symbolic representation
+        
         # Handle operator precedence for cleaner string representation
-        precedence = {'+': 1, '-': 1, '*': 2, '/': 2, '**': 3}
+        precedence = {'+': 1, '-': 1, '*': 2, '/': 2, '**': 3, '<': 0, '<=': 0, '>': 0, '>=': 0, '==': 0, '!=': 0}
         left_str = str(self.left)
         right_str = str(self.right)
         
@@ -260,60 +368,13 @@ class BinaryOperation(Expression):
             # Need parentheses if:
             # - Right has lower precedence, OR
             # - Same precedence and current operator is left-associative (- or /)
-            if (right_prec < curr_prec 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}"
 
 
-class ComparisonExpression(Expression):
-    """Comparison expression for conditional logic."""
-    
-    def __init__(self, operator: str, left: Expression, right: Expression):
-        self.operator = operator
-        self.left = left
-        self.right = right
-    
-    def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'FastQuantity':
-        """Evaluate comparison and return dimensionless result (1.0 for True, 0.0 for False)."""
-        
-        left_val = self.left.evaluate(variable_values)
-        right_val = self.right.evaluate(variable_values)
-        
-        # Convert to same units for comparison if possible
-        try:
-            if left_val._dimension_sig == right_val._dimension_sig and left_val.unit != right_val.unit:
-                right_val = right_val.to(left_val.unit)
-        except (ValueError, TypeError, AttributeError):
-            pass
-        
-        if self.operator == '<':
-            result = left_val.value < right_val.value
-        elif self.operator == '<=':
-            result = left_val.value <= right_val.value
-        elif self.operator == '>':
-            result = left_val.value > right_val.value
-        elif self.operator == '>=':
-            result = left_val.value >= right_val.value
-        elif self.operator == '==':
-            result = abs(left_val.value - right_val.value) < 1e-10
-        elif self.operator == '!=':
-            result = abs(left_val.value - right_val.value) >= 1e-10
-        else:
-            raise ValueError(f"Unknown comparison operator: {self.operator}")
-        
-        return FastQuantity(1.0 if result else 0.0, DimensionlessUnits.dimensionless)
-    
-    def get_variables(self) -> set[str]:
-        return self.left.get_variables() | self.right.get_variables()
-    
-    def simplify(self) -> Expression:
-        return ComparisonExpression(self.operator, self.left.simplify(), self.right.simplify())
-    
-    def __str__(self) -> str:
-        return f"({self.left} {self.operator} {self.right})"
-
 
 class UnaryFunction(Expression):
     """Unary mathematical function expression."""
@@ -453,7 +514,7 @@ def exp(expr: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float])
     """Exponential function."""
     return UnaryFunction('exp', Expression._wrap_operand(expr))
 
-def cond_expr(condition: Union[Expression, 'ComparisonExpression'],
+def cond_expr(condition: Union[Expression, 'BinaryOperation'],
               true_expr: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float],
               false_expr: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float]) -> ConditionalExpression:
     """Conditional expression: if condition then true_expr else false_expr."""

{qnty-0.0.6 → qnty-0.0.8}/src/qnty/unit.py

@@ -64,8 +64,8 @@ class HighPerformanceRegistry:
     def __init__(self):
         self.units: dict[str, UnitDefinition] = {}
         self.conversion_table: dict[tuple[str, str], float] = {}  # (from_unit, to_unit) -> factor
-        self.dimensional_groups: dict[int, list[UnitDefinition]] = {}
-        self._dimension_cache: dict[int, UnitConstant] = {}  # Cache for common dimension mappings
+        self.dimensional_groups: dict[int | float, list[UnitDefinition]] = {}
+        self._dimension_cache: dict[int | float, UnitConstant] = {}  # Cache for common dimension mappings
         self._finalized = False
         self.base_units: dict[str, UnitDefinition] = {}  # Track base units for prefix generation
         self.prefixable_units: set[str] = set()  # Track which units can have prefixes

{qnty-0.0.6 → qnty-0.0.8}/src/qnty/units.py

@@ -22,6 +22,9 @@ from .dimension import (
     CONCENTRATION,
     DIMENSIONLESS,
     DYNAMIC_FLUIDITY,
+    ELECTRICAL_CONDUCTANCE,
+    ELECTRICAL_PERMITTIVITY,
+    ELECTRICAL_RESISTIVITY,
     ELECTRIC_CAPACITANCE,
     ELECTRIC_CHARGE,
     ELECTRIC_CURRENT_INTENSITY,
@@ -30,9 +33,6 @@ 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
@@ -7896,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 .prefixes import get_prefix_by_name
     from .unit import UnitConstant, UnitDefinition
+    from .prefixes import get_prefix_by_name
     
     # Create a new class dynamically
     unit_class = type(class_name, (), {})
@@ -7950,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():

{qnty-0.0.6 → qnty-0.0.8}/src/qnty/variable.py

@@ -115,7 +115,7 @@ class FastQuantity:
             return FastQuantity(self.value / other, self.unit)
         
         # Fast dimensional analysis using cached signatures
-        result_dimension_sig = self._dimension_sig // other._dimension_sig
+        result_dimension_sig = self._dimension_sig / other._dimension_sig
         
         # Use cached SI factors for conversion
         self_si_value = self.value * self._si_factor
@@ -128,7 +128,7 @@ class FastQuantity:
         
         return FastQuantity(result_value, result_unit)
     
-    def _find_result_unit_fast(self, result_dimension_sig: int,
+    def _find_result_unit_fast(self, result_dimension_sig: int | float,
                               left_qty: FastQuantity, right_qty: FastQuantity) -> UnitConstant:
         """Ultra-fast unit finding using cached dimension signatures."""
         
@@ -257,6 +257,43 @@ class TypeSafeVariable(Generic[DimensionType]):
         self.is_known = True
         return self
     
+    def update(self, value=None, unit=None, quantity=None, is_known=None):
+        """Update variable properties flexibly."""
+        if quantity is not None:
+            self.quantity = quantity
+        elif value is not None:
+            # Create setter and call the appropriate unit property
+            setter = self.set(value)
+            if unit is not None:
+                # 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 unit.endswith('s') and hasattr(setter, unit[:-1]):  # Handle plural to singular
+                    getattr(setter, unit[:-1])
+                else:
+                    raise ValueError(f"Unit '{unit}' not found for {self.__class__.__name__}")
+            else:
+                # If no unit specified, we can't automatically choose a unit
+                # The caller should specify either a unit or a quantity
+                raise ValueError("Must specify either 'unit' with 'value' or provide 'quantity' directly")
+        if is_known is not None:
+            self.is_known = is_known
+        return self  # For method chaining
+    
+    def mark_known(self, quantity=None):
+        """Mark variable as known, optionally updating its value."""
+        self.is_known = True
+        if quantity is not None:
+            self.quantity = quantity
+        return self  # For method chaining
+    
+    def mark_unknown(self):
+        """Mark variable as unknown."""
+        self.is_known = False
+        return self  # For method chaining
+    
     def __str__(self):
         return f"{self.name}: {self.quantity}" if self.quantity else f"{self.name}: unset"
 

{qnty-0.0.6 → qnty-0.0.8}/src/qnty/variable_types/expression_variable.py

@@ -66,3 +66,41 @@ class ExpressionVariable(TypeSafeVariable):
     def __rpow__(self, other: FastQuantity | int | float) -> Expression:
         """Reverse power for this variable."""
         return wrap_operand(other) ** wrap_operand(self)
+    
+    # Comparison methods
+    def lt(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
+        """Less than comparison (<)."""
+        from ..expression import BinaryOperation
+        return BinaryOperation('<', wrap_operand(self), wrap_operand(other))
+    
+    def leq(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
+        """Less than or equal comparison (<=)."""
+        from ..expression import BinaryOperation
+        return BinaryOperation('<=', wrap_operand(self), wrap_operand(other))
+    
+    def geq(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
+        """Greater than or equal comparison (>=)."""
+        from ..expression import BinaryOperation
+        return BinaryOperation('>=', wrap_operand(self), wrap_operand(other))
+    
+    def gt(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
+        """Greater than comparison (>)."""
+        from ..expression import BinaryOperation
+        return BinaryOperation('>', wrap_operand(self), wrap_operand(other))
+    
+    # Python comparison operators
+    def __lt__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
+        """Less than comparison (<) operator."""
+        return self.lt(other)
+    
+    def __le__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
+        """Less than or equal comparison (<=) operator."""
+        return self.leq(other)
+    
+    def __gt__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
+        """Greater than comparison (>) operator."""
+        return self.gt(other)
+    
+    def __ge__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
+        """Greater than or equal comparison (>=) operator."""
+        return self.geq(other)

{qnty-0.0.6 → qnty-0.0.8}/src/qnty/variables.py

@@ -9,7 +9,6 @@ Auto-generated from unit_data.json and dimension_mapping.json.
 
 from typing import Any
 
-from . import units
 from .dimension import (
     ABSORBED_DOSE,
     ACCELERATION,
@@ -25,6 +24,9 @@ from .dimension import (
     CONCENTRATION,
     DIMENSIONLESS,
     DYNAMIC_FLUIDITY,
+    ELECTRICAL_CONDUCTANCE,
+    ELECTRICAL_PERMITTIVITY,
+    ELECTRICAL_RESISTIVITY,
     ELECTRIC_CAPACITANCE,
     ELECTRIC_CHARGE,
     ELECTRIC_CURRENT_INTENSITY,
@@ -33,9 +35,6 @@ from .dimension import (
     ELECTRIC_INDUCTANCE,
     ELECTRIC_POTENTIAL,
     ELECTRIC_RESISTANCE,
-    ELECTRICAL_CONDUCTANCE,
-    ELECTRICAL_PERMITTIVITY,
-    ELECTRICAL_RESISTIVITY,
     ENERGY_FLUX,
     ENERGY_HEAT_WORK,
     ENERGY_PER_UNIT_AREA,
@@ -69,15 +68,15 @@ 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,
@@ -111,14 +110,16 @@ 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,
 )
+from . import units
+from .unit import UnitConstant, UnitDefinition
 from .variable import FastQuantity, TypeSafeSetter
 from .variable_types.typed_variable import TypedVariable