qnty 0.1.0__tar.gz → 0.1.2__tar.gz

{qnty-0.1.0 → qnty-0.1.2}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "qnty"
-version = "0.1.0"
+version = "0.1.2"
 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.1.0 → qnty-0.1.2}/src/qnty/expressions/nodes.py

@@ -374,15 +374,16 @@ class BinaryOperation(Expression):
         if abs(right_value) < DIVISION_BY_ZERO_THRESHOLD:
             raise ValueError(f"Division by zero in expression: {self}")
 
-        # Fast paths
-        if right_value == 1.0:
+        # Fast paths - but only when they preserve correct dimensional analysis
+        if right_value == 1.0 and right_val._dimension_sig == 1:
+            # Division by dimensionless 1.0 - safe optimization
             return left_val
         elif left_value == 0.0:
             # Zero divided by anything is zero (with appropriate unit)
             return Quantity(0.0, (left_val / right_val).unit)
-        elif right_value == -1.0:
-            # Division by -1 is negation
-            return Quantity(-left_value, (left_val / right_val).unit)
+        elif right_value == -1.0 and right_val._dimension_sig == 1:
+            # Division by dimensionless -1.0 is negation - safe optimization
+            return Quantity(-left_value, left_val.unit)
 
         # Regular division
         return left_val / right_val

{qnty-0.1.0 → qnty-0.1.2}/src/qnty/problems/composition.py

@@ -133,6 +133,7 @@ class SubProblemProxy:
             is_known=original_var.is_known,
             proxy=self,
             original_symbol=original_var.symbol,
+            original_variable=original_var,  # Pass the original variable for type preservation
         )
 
         return namespaced_var
@@ -152,16 +153,25 @@ class ConfigurableVariable:
     This acts as a proxy around the actual qnty Variable rather than inheriting from it.
     """
 
-    def __init__(self, symbol, name, quantity, is_known=True, proxy=None, original_symbol=None):
+    def __init__(self, symbol, name, quantity, is_known=True, proxy=None, original_symbol=None, original_variable=None):
         # Store the actual variable (we'll delegate to it)
         # Create a variable of the appropriate type based on the original
-        # For now, we'll create a Dimensionless variable and update it
-        self._variable = Dimensionless(name)
+        if original_variable is not None:
+            # Preserve the original variable type
+            self._variable = type(original_variable)(name)
+        else:
+            # Fallback to Dimensionless if no original variable provided
+            self._variable = Dimensionless(name)
 
         # Set the properties
         self._variable.symbol = symbol
         self._variable.quantity = quantity
         self._variable.is_known = is_known
+        
+        # Ensure the arithmetic mode is properly initialized
+        # The __init__ should have set it, but in case it didn't
+        if not hasattr(self._variable, '_arithmetic_mode'):
+            self._variable._arithmetic_mode = "expression"
 
         # Store proxy information
         self._proxy = proxy
@@ -169,6 +179,13 @@ class ConfigurableVariable:
 
     def __getattr__(self, name):
         """Delegate all other attributes to the wrapped variable."""
+        # Handle special case for _arithmetic_mode since it's accessed in __mul__ etc.
+        if name == '_arithmetic_mode':
+            # First check if we have it directly
+            if hasattr(self._variable, '_arithmetic_mode'):
+                return self._variable._arithmetic_mode
+            # Otherwise default to 'expression'
+            return 'expression'
         return getattr(self._variable, name)
 
     # Delegate arithmetic operations to the wrapped variable
@@ -230,11 +247,64 @@ class ConfigurableVariable:
             setattr(self._variable, name, value)
 
     def set(self, value):
-        """Override set method to track configuration changes."""
-        result = self._variable.set(value)
+        """Override set method to track configuration changes and return the correct setter."""
+        # Create a wrapper setter that tracks changes after unit application
+        original_setter = self._variable.set(value)
+        
         if self._proxy and self._original_symbol:
-            # Track this configuration change
-            self._proxy.track_configuration(self._original_symbol, self._variable.quantity, self._variable.is_known)
+            # Create tracking wrapper
+            return TrackingSetterWrapper(original_setter, self._proxy, self._original_symbol, self._variable)
+        else:
+            return original_setter
+
+
+class TrackingSetterWrapper:
+    """
+    A wrapper around setter objects that tracks configuration changes after unit application.
+    This ensures that when `proxy.set(value).unit` is called, the proxy tracks the final
+    configuration after the unit is applied.
+    """
+    
+    def __init__(self, original_setter, proxy, original_symbol, variable):
+        self._original_setter = original_setter
+        self._proxy = proxy
+        self._original_symbol = original_symbol
+        self._variable = variable
+        
+    def __getattr__(self, name):
+        """
+        Intercept property access for unit properties and track configuration after application.
+        """
+        # Get the property from the original setter
+        attr = getattr(self._original_setter, name)
+        
+        # If it's a property (unit setter), wrap it to track configuration
+        if hasattr(attr, '__call__'):
+            # It's a method, just delegate
+            return attr
+        else:
+            # It's a property access, call it and then track configuration
+            result = attr  # This will set the variable quantity and return the variable
+            
+            # Track the configuration after the unit is applied
+            if self._proxy and self._original_symbol:
+                self._proxy.track_configuration(
+                    self._original_symbol, 
+                    self._variable.quantity, 
+                    self._variable.is_known
+                )
+            
+            return result
+    
+    def with_unit(self, unit):
+        """Delegate with_unit method and track configuration."""
+        result = self._original_setter.with_unit(unit)
+        if self._proxy and self._original_symbol:
+            self._proxy.track_configuration(
+                self._original_symbol, 
+                self._variable.quantity, 
+                self._variable.is_known
+            )
         return result
 
     def update(self, value=None, unit=None, quantity=None, is_known=None):

{qnty-0.1.0 → qnty-0.1.2}/src/qnty/problems/problem.py

@@ -177,6 +177,10 @@ class Problem(ValidationMixin):
         # Sub-problem composition support
         self.sub_problems: dict[str, Any] = {}
         self.variable_aliases: dict[str, str] = {}
+        
+        # Track original variable states for re-solving
+        self._original_variable_states: dict[str, bool] = {}
+        self._original_variable_units: dict[str, Any] = {}
 
         # Initialize equation reconstructor
         self.equation_reconstructor = None
@@ -227,6 +231,11 @@ class Problem(ValidationMixin):
 
         if variable.symbol is not None:
             self.variables[variable.symbol] = variable
+            # Track original is_known state and unit for re-solving
+            self._original_variable_states[variable.symbol] = variable.is_known
+            # Store the unit from original quantity to preserve unit info
+            if variable.quantity is not None:
+                self._original_variable_units[variable.symbol] = variable.quantity.unit
         # Set parent problem reference for dependency invalidation
         if hasattr(variable, "_parent_problem"):
             setattr(variable, "_parent_problem", self)
@@ -353,11 +362,11 @@ class Problem(ValidationMixin):
         # This ensures domain-specific variables (Length, Pressure, etc.) keep their type
         variable_type = type(variable)
 
-        # Use __new__ to avoid constructor parameter issues
-        cloned = variable_type.__new__(variable_type)
+        # Create a new instance properly initialized
+        # Pass the name to the constructor which all FieldQnty subclasses accept
+        cloned = variable_type(variable.name)
 
-        # Initialize manually with the same attributes as the original
-        cloned.name = variable.name
+        # Copy over the attributes from the original
         cloned.symbol = variable.symbol
         cloned.expected_dimension = variable.expected_dimension
         cloned.quantity = variable.quantity  # Keep reference to same quantity - units must not be copied
@@ -368,6 +377,37 @@ class Problem(ValidationMixin):
             cloned.validation_checks = []
         return cloned
 
+    def _update_variables_with_solution(self, solved_variables: dict[str, FieldQnty]):
+        """
+        Update variables with solution, preserving original units for display.
+        """
+        for symbol, solved_var in solved_variables.items():
+            if symbol in self.variables:
+                original_var = self.variables[symbol]
+                
+                # If we have a solved quantity and an original unit to preserve
+                if (solved_var.quantity is not None and 
+                    symbol in self._original_variable_units and 
+                    symbol in self._original_variable_states and 
+                    not self._original_variable_states[symbol]):  # Was originally unknown
+                    
+                    # Convert solved quantity to original unit for display
+                    original_unit = self._original_variable_units[symbol]
+                    try:
+                        # Convert the solved quantity to the original unit
+                        converted_value = solved_var.quantity.to(original_unit).value
+                        from ..quantities.base_qnty import Quantity
+                        original_var.quantity = Quantity(converted_value, original_unit)
+                        original_var.is_known = True
+                    except Exception:
+                        # If conversion fails, use the solved quantity as-is
+                        original_var.quantity = solved_var.quantity
+                        original_var.is_known = solved_var.is_known
+                else:
+                    # For originally known variables or if no unit conversion needed
+                    original_var.quantity = solved_var.quantity
+                    original_var.is_known = solved_var.is_known
+
     def _sync_variables_to_instance_attributes(self):
         """
         Sync variable objects to instance attributes after solving.
@@ -539,10 +579,8 @@ class Problem(ValidationMixin):
         self.logger.info(f"Solving problem: {self.name}")
 
         try:
-            # Clear previous solution
-            self.solution = {}
-            self.is_solved = False
-            self.solving_history = []
+            # Reset solution state and restore original variable states
+            self.reset_solution()
 
             # Build dependency graph
             self._build_dependency_graph()
@@ -551,8 +589,8 @@ class Problem(ValidationMixin):
             solve_result = self.solver_manager.solve(self.equations, self.variables, self.dependency_graph, max_iterations, tolerance)
 
             if solve_result.success:
-                # Update variables with the result
-                self.variables = solve_result.variables
+                # Update variables with the result, preserving original units where possible
+                self._update_variables_with_solution(solve_result.variables)
                 self.solving_history.extend(solve_result.steps)
 
                 # Sync solved values back to instance attributes
@@ -641,10 +679,14 @@ class Problem(ValidationMixin):
         self.solution = {}
         self.solving_history = []
 
-        # Reset unknown variables to unknown state
-        for var in self.variables.values():
-            if not var.is_known:
-                var.is_known = False
+        # Reset variables to their original known/unknown states
+        for symbol, var in self.variables.items():
+            if symbol in self._original_variable_states:
+                original_state = self._original_variable_states[symbol]
+                var.is_known = original_state
+                # If variable was originally unknown, reset it to None so solver can update it
+                if not original_state:
+                    var.quantity = None
 
     def copy(self):
         """Create a copy of this problem."""
@@ -672,6 +714,20 @@ class Problem(ValidationMixin):
 
         super().__setattr__(name, value)
 
+    def __getattr__(self, name: str) -> Any:
+        """Dynamic attribute access for composed variables and other attributes."""
+        # Avoid recursion by checking the dict directly instead of using hasattr
+        try:
+            variables = object.__getattribute__(self, "variables")
+            if name in variables:
+                return variables[name]
+        except AttributeError:
+            # variables attribute doesn't exist yet (during initialization)
+            pass
+        
+        # If not found, raise AttributeError
+        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+
     def __getitem__(self, key: str):
         """Allow dict-like access to variables."""
         return self.get_variable(key)

{qnty-0.1.0 → qnty-0.1.2}/src/qnty/quantities/field_qnty.py

@@ -738,7 +738,7 @@ class ExpressionMixin:
                 continue
 
         # Strategy 2: Look for Equation objects in scope (created with .equals())
-        frame = ScopeDiscoveryService._find_user_frame(getattr(ScopeDiscoveryService, '_get_current_frame', lambda: None)())  # type: ignore[misc]
+        frame = ScopeDiscoveryService._get_cached_user_frame()
         if frame:
             for obj in list(frame.f_locals.values()) + list(frame.f_globals.values()):
                 if isinstance(obj, Equation):
@@ -775,8 +775,20 @@ class SetterCompatibilityMixin:
         if not hasattr(self, "_setter_class"):
             self._setter_class: type | None = None
 
-    def set(self, value: float) -> TypeSafeSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | TypeSafeSetter':
         """Create setter object for fluent API compatibility."""
+        if unit is not None:
+            # Handle direct unit setting using the specialized setter
+            if hasattr(self, "_setter_class") and self._setter_class:
+                setter = self._setter_class(self, value)
+                if hasattr(setter, unit):
+                    getattr(setter, unit)
+                    return self
+                else:
+                    raise ValueError(f"Unknown unit: {unit}")
+            else:
+                raise ValueError("Unit parameter not supported for this variable type")
+        
         if hasattr(self, "_setter_class") and self._setter_class:
             return self._setter_class(self, value)  # Correct parameter order
         else: