qnty 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

qnty/variable.py

@@ -2,21 +2,37 @@
 High-Performance Quantity and Variables
 ========================================
 
-FastQuantity class and type-safe variables optimized for engineering calculations 
+FastQuantity class and type-safe variables optimized for engineering calculations
 with dimensional safety.
 """
 
-from typing import Union, Optional, TypeVar, Generic, TYPE_CHECKING
-from .dimension import DimensionSignature, DIMENSIONLESS, LENGTH, PRESSURE, AREA, VOLUME, FORCE, ENERGY
+from __future__ import annotations
+
+from typing import Generic, Self, TypeVar
+
+from .dimension import AREA, DIMENSIONLESS, FORCE, LENGTH, PRESSURE, VOLUME, DimensionSignature
+from .dimension import ENERGY_HEAT_WORK as ENERGY
 from .unit import UnitConstant, UnitDefinition, registry
 from .units import DimensionlessUnits, LengthUnits, PressureUnits
 
-if TYPE_CHECKING:
-    from .setters import TypeSafeSetter, LengthSetter, PressureSetter
+# TypeVar for generic dimensional types
+DimensionType = TypeVar('DimensionType', bound='FastQuantity')
 
 
-DimensionType = TypeVar('DimensionType', bound='FastQuantity')
-SetterType = TypeVar('SetterType')
+class TypeSafeSetter:
+    """Basic type-safe setter that accepts compatible units."""
+    
+    def __init__(self, variable: TypeSafeVariable, value: float):
+        self.variable = variable
+        self.value = value
+    
+    def with_unit(self, unit: UnitConstant) -> TypeSafeVariable:
+        """Set with type-safe unit constant."""
+        if not self.variable.expected_dimension.is_compatible(unit.dimension):
+            raise TypeError(f"Unit {unit.name} incompatible with expected dimension")
+        
+        self.variable.quantity = FastQuantity(self.value, unit)
+        return self.variable
 
 
 class FastQuantity:
@@ -39,7 +55,7 @@ class FastQuantity:
         return f"FastQuantity({self.value}, {self.unit.name})"
     
     # Ultra-fast arithmetic with dimensional checking
-    def __add__(self, other: 'FastQuantity') -> 'FastQuantity':
+    def __add__(self, other: FastQuantity) -> FastQuantity:
         # Fast dimension compatibility check using cached signatures
         if self._dimension_sig != other._dimension_sig:
             raise ValueError(f"Cannot add {self.unit.name} and {other.unit.name}")
@@ -52,7 +68,7 @@ class FastQuantity:
         other_value = other.value * other._si_factor / self._si_factor
         return FastQuantity(self.value + other_value, self.unit)
     
-    def __sub__(self, other: 'FastQuantity') -> 'FastQuantity':
+    def __sub__(self, other: FastQuantity) -> FastQuantity:
         # Fast dimension compatibility check using cached signatures
         if self._dimension_sig != other._dimension_sig:
             raise ValueError(f"Cannot subtract {other.unit.name} from {self.unit.name}")
@@ -65,8 +81,8 @@ class FastQuantity:
         other_value = other.value * other._si_factor / self._si_factor
         return FastQuantity(self.value - other_value, self.unit)
     
-    def __mul__(self, other: Union['FastQuantity', float, int]) -> 'FastQuantity':
-        if isinstance(other, (int, float)):
+    def __mul__(self, other: FastQuantity | float | int) -> FastQuantity:
+        if isinstance(other, int | float):
             return FastQuantity(self.value * other, self.unit)
         
         # Fast dimensional analysis using cached signatures
@@ -83,14 +99,14 @@ class FastQuantity:
         
         return FastQuantity(result_value, result_unit)
     
-    def __rmul__(self, other: Union[float, int]) -> 'FastQuantity':
+    def __rmul__(self, other: float | int) -> FastQuantity:
         """Reverse multiplication for cases like 2 * quantity."""
-        if isinstance(other, (int, float)):
+        if isinstance(other, int | float):
             return FastQuantity(other * self.value, self.unit)
         return NotImplemented
     
-    def __truediv__(self, other: Union['FastQuantity', float, int]) -> 'FastQuantity':
-        if isinstance(other, (int, float)):
+    def __truediv__(self, other: FastQuantity | float | int) -> FastQuantity:
+        if isinstance(other, int | float):
             return FastQuantity(self.value / other, self.unit)
         
         # Fast dimensional analysis using cached signatures
@@ -107,8 +123,8 @@ class FastQuantity:
         
         return FastQuantity(result_value, result_unit)
     
-    def _find_result_unit_fast(self, result_dimension_sig: int, 
-                              left_qty: 'FastQuantity', right_qty: 'FastQuantity') -> UnitConstant:
+    def _find_result_unit_fast(self, result_dimension_sig: int,
+                              left_qty: FastQuantity, right_qty: FastQuantity) -> UnitConstant:
         """Ultra-fast unit finding using cached dimension signatures."""
         
         # Initialize dimension cache if empty
@@ -130,7 +146,7 @@ class FastQuantity:
         # For rare combined dimensions, create temporary unit
         temp_unit = UnitDefinition(
             name=f"combined_{result_dimension_sig}",
-            symbol="combined", 
+            symbol="combined",
             dimension=DimensionSignature(result_dimension_sig),
             si_factor=1.0
         )
@@ -140,13 +156,13 @@ class FastQuantity:
         registry._dimension_cache[result_dimension_sig] = result_unit
         return result_unit
     
-    def _find_result_unit(self, result_dimension: DimensionSignature, 
-                         left_qty: 'FastQuantity', right_qty: 'FastQuantity') -> UnitConstant:
+    def _find_result_unit(self, result_dimension: DimensionSignature,
+                         left_qty: FastQuantity, right_qty: FastQuantity) -> UnitConstant:
         """Legacy method - kept for compatibility."""
         return self._find_result_unit_fast(result_dimension._signature, left_qty, right_qty)
     
     # Ultra-fast comparisons
-    def __lt__(self, other: 'FastQuantity') -> bool:
+    def __lt__(self, other: FastQuantity) -> bool:
         if self._dimension_sig != other._dimension_sig:
             raise ValueError("Cannot compare incompatible dimensions")
         
@@ -172,7 +188,7 @@ class FastQuantity:
         other_value = other.value * other._si_factor / self._si_factor
         return abs(self.value - other_value) < 1e-10
     
-    def to(self, target_unit: UnitConstant) -> 'FastQuantity':
+    def to(self, target_unit: UnitConstant) -> FastQuantity:
         """Ultra-fast unit conversion."""
         if self.unit == target_unit:
             return FastQuantity(self.value, target_unit)
@@ -183,16 +199,40 @@ class FastQuantity:
 
 
 class TypeSafeVariable(Generic[DimensionType]):
-    """Type-safe variable with compile-time dimensional checking."""
+    """
+    Base class for type-safe variables with dimensional checking.
     
-    def __init__(self, name: str, expected_dimension: DimensionSignature):
+    This is a simple data container without dependencies on expressions or equations.
+    Mathematical operations are added by subclasses or mixins.
+    """
+    
+    # Class attribute defining which setter to use - subclasses can override
+    _setter_class = TypeSafeSetter
+    
+    def __init__(self, name: str, expected_dimension, is_known: bool = True):
         self.name = name
+        self.symbol: str | None = None  # Will be set by EngineeringProblem to attribute name
         self.expected_dimension = expected_dimension
-        self.quantity: Optional[FastQuantity] = None
+        self.quantity: FastQuantity | None = None
+        self.is_known = is_known
+    
+    def set(self, value: float):
+        """Create a setter for this variable using the class-specific setter type."""
+        return self._setter_class(self, value)
     
-    def set(self, value: float) -> Union['TypeSafeSetter', 'LengthSetter', 'PressureSetter']:
-        from .setters import TypeSafeSetter
-        return TypeSafeSetter(self, value)
+    @property
+    def unknown(self) -> Self:
+        """Mark this variable as unknown using fluent API."""
+        self.is_known = False
+        return self
+    
+    @property
+    def known(self) -> Self:
+        """Mark this variable as known using fluent API."""
+        self.is_known = True
+        return self
     
     def __str__(self):
-        return f"{self.name}: {self.quantity}" if self.quantity else f"{self.name}: unset"
+        return f"{self.name}: {self.quantity}" if self.quantity else f"{self.name}: unset"
+
+

qnty/variable_types/base.py

@@ -0,0 +1,58 @@
+"""
+Base Variable Module Definition
+===============================
+
+Provides abstract base class for variable modules and registration functionality.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class VariableModule(ABC):
+    """Abstract base class for variable modules."""
+    
+    @abstractmethod
+    def get_variable_class(self) -> type[Any]:
+        """Return the variable class for this module."""
+        pass
+    
+    @abstractmethod
+    def get_setter_class(self) -> type[Any]:
+        """Return the setter class for this module."""
+        pass
+    
+    @abstractmethod
+    def get_expected_dimension(self) -> Any:
+        """Return the expected dimension for this variable type."""
+        pass
+    
+    def register_to_registry(self, variable_registry):
+        """Register this variable module to the given registry."""
+        variable_registry.register_module(
+            self.get_expected_dimension(),
+            self.get_variable_class(),
+            self.get_setter_class()
+        )
+
+
+class VariableRegistry:
+    """Registry for variable modules."""
+    
+    def __init__(self):
+        self._modules = {}
+    
+    def register_module(self, dimension, variable_class, setter_class):
+        """Register a variable module."""
+        self._modules[dimension] = {
+            'variable_class': variable_class,
+            'setter_class': setter_class
+        }
+    
+    def get_variable_class(self, dimension):
+        """Get variable class for a dimension."""
+        return self._modules.get(dimension, {}).get('variable_class')
+    
+    def get_setter_class(self, dimension):
+        """Get setter class for a dimension."""
+        return self._modules.get(dimension, {}).get('setter_class')

qnty/variable_types/expression_variable.py

@@ -0,0 +1,68 @@
+"""
+Expression Variable Base Class
+==============================
+
+Base class that extends TypeSafeVariable with mathematical expression
+and equation capabilities.
+"""
+
+from __future__ import annotations
+
+from ..equation import Equation
+from ..expression import Expression, wrap_operand
+from ..variable import FastQuantity, TypeSafeVariable
+
+
+class ExpressionVariable(TypeSafeVariable):
+    """
+    TypeSafeVariable extended with expression and equation capabilities.
+    
+    This adds mathematical operations that create expressions and equations,
+    keeping the base TypeSafeVariable free of these dependencies.
+    """
+    
+    def equals(self, expression: Expression | TypeSafeVariable | FastQuantity | int | float):
+        """Create an equation: self = expression."""
+        # Wrap the expression in proper Expression type
+        rhs_expr = wrap_operand(expression)
+        return Equation(f"{self.name}_eq", self, rhs_expr)
+    
+    def __add__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
+        """Add this variable to another operand, returning an Expression."""
+        return wrap_operand(self) + wrap_operand(other)
+
+    def __radd__(self, other: FastQuantity | int | float) -> Expression:
+        """Reverse add for this variable."""
+        return wrap_operand(other) + wrap_operand(self)
+    
+    def __sub__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
+        """Subtract another operand from this variable, returning an Expression."""
+        return wrap_operand(self) - wrap_operand(other)
+    
+    def __rsub__(self, other: FastQuantity | int | float) -> Expression:
+        """Reverse subtract for this variable."""
+        return wrap_operand(other) - wrap_operand(self)
+    
+    def __mul__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
+        """Multiply this variable by another operand, returning an Expression."""
+        return wrap_operand(self) * wrap_operand(other)
+    
+    def __rmul__(self, other: FastQuantity | int | float) -> Expression:
+        """Reverse multiply for this variable."""
+        return wrap_operand(other) * wrap_operand(self)
+    
+    def __truediv__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
+        """Divide this variable by another operand, returning an Expression."""
+        return wrap_operand(self) / wrap_operand(other)
+
+    def __rtruediv__(self, other: FastQuantity | int | float) -> Expression:
+        """Reverse divide for this variable."""
+        return wrap_operand(other) / wrap_operand(self)
+    
+    def __pow__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
+        """Raise this variable to a power, returning an Expression."""
+        return wrap_operand(self) ** wrap_operand(other)
+
+    def __rpow__(self, other: FastQuantity | int | float) -> Expression:
+        """Reverse power for this variable."""
+        return wrap_operand(other) ** wrap_operand(self)

qnty/variable_types/typed_variable.py

@@ -0,0 +1,92 @@
+"""
+Typed Variable Base Class
+=========================
+
+Base class that provides common constructor logic for all typed variables,
+handling both the original syntax and the new value/unit/name syntax.
+"""
+
+from ..dimension import DimensionSignature
+from ..variable import TypeSafeSetter
+from .expression_variable import ExpressionVariable
+
+
+class TypedVariable(ExpressionVariable):
+    """
+    Base class for typed variables with common constructor logic.
+    
+    Subclasses need to define:
+    - _setter_class: The setter class to use
+    - _expected_dimension: The expected dimension
+    - _default_unit_property: The default unit property name for fallback
+    """
+    
+    _setter_class: type[TypeSafeSetter] | None = None
+    _expected_dimension: DimensionSignature | None = None
+    _default_unit_property: str | None = None
+    
+    def __init__(self, *args, is_known: bool = True):
+        """
+        Flexible constructor supporting multiple syntaxes.
+        
+        Single argument: TypedVariable("name")
+        Three arguments: TypedVariable(value, "unit", "name")
+        Two arguments (Dimensionless only): TypedVariable(value, "name")
+        """
+        if self._setter_class is None or self._expected_dimension is None:
+            raise NotImplementedError("Subclass must define _setter_class and _expected_dimension")
+        
+        # Handle different argument patterns
+        if len(args) == 1:
+            # Original syntax: Variable("name")
+            super().__init__(args[0], self._expected_dimension, is_known=is_known)
+            
+        elif len(args) == 2 and self.__class__.__name__ == 'Dimensionless':
+            # Special case for Dimensionless: (value, "name")
+            value, name = args
+            super().__init__(name, self._expected_dimension, is_known=is_known)
+            setter = self._setter_class(self, value)
+            # For DimensionlessSetter, use the dimensionless property
+            # Type ignore since we know DimensionlessSetter has this property
+            getattr(setter, 'dimensionless', None)  # type: ignore
+            
+        elif len(args) == 3:
+            # New syntax: Variable(value, "unit", "name")
+            # But Dimensionless doesn't support this pattern
+            if self.__class__.__name__ == 'Dimensionless':
+                raise ValueError(f"{self.__class__.__name__} expects either 1 argument (name) or 2 arguments (value, name), got {len(args)}")
+            
+            value, unit, name = args
+            super().__init__(name, self._expected_dimension, is_known=is_known)
+            
+            # 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)
+            else:
+                # Last resort - try to find any valid unit property
+                # This helps with forward compatibility
+                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])
+                    
+        else:
+            # More specific error messages matching test expectations
+            if self.__class__.__name__ == 'Dimensionless':
+                raise ValueError(f"{self.__class__.__name__} expects either 1 argument (name) or 2 arguments (value, name), got {len(args)}")
+            else:
+                raise ValueError(f"{self.__class__.__name__} expects either 1 argument (name) or 3 arguments (value, unit, name), got {len(args)}")