qnty 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

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/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/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."""

qnty/quantities/field_vars.py

@@ -765,16 +765,34 @@ class Dimensionless(FieldQnty):
         
         Args:
             value: The numeric value to set
-            unit: Optional unit string (for compatibility with base class)
+            unit: Optional unit string (for direct setting)
         
         Returns:
-            DimensionlessSetter: A setter with unit properties like .meters, .inches, etc.
+            DimensionlessSetter: A setter with unit properties like .dimensionless
         
         Example:
-            >>> length = Length("beam_length")
-            >>> length.set(100).millimeters  # Sets to 100 mm
-        """
-        return ts.DimensionlessSetter(self, value)
+            >>> factor = Dimensionless("factor")
+            >>> factor.set(2.5).dimensionless  # Sets to 2.5
+            >>> factor.set(2.5, "dimensionless")  # Direct setting
+        """
+        if unit is not None:
+            # Direct setting with unit
+            setter = ts.DimensionlessSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                # Try common aliases
+                unit_aliases = {
+                    "dimensionless": "dimensionless", "": "dimensionless"
+                }
+                if unit in unit_aliases and hasattr(setter, unit_aliases[unit]):
+                    getattr(setter, unit_aliases[unit])
+                else:
+                    raise ValueError(f"Unknown unit: {unit}")
+            return self  # Return the variable itself for consistency
+        else:
+            return ts.DimensionlessSetter(self, value)
     
 
 class DynamicFluidity(FieldQnty):
@@ -2358,7 +2376,7 @@ class Length(FieldQnty):
         
         Args:
             value: The numeric value to set
-            unit: Optional unit string (for compatibility with base class)
+            unit: Optional unit string (for direct setting)
         
         Returns:
             LengthSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2366,8 +2384,30 @@ class Length(FieldQnty):
         Example:
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
-        """
-        return ts.LengthSetter(self, value)
+            >>> length.set(100, "inch")  # Direct setting
+        """
+        if unit is not None:
+            # Direct setting with unit
+            setter = ts.LengthSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                # Try common aliases
+                unit_aliases = {
+                    "inch": "inch", "inches": "inch", "in": "inch",
+                    "foot": "foot", "feet": "foot", "ft": "foot", 
+                    "meter": "meter", "meters": "meter", "m": "meter",
+                    "millimeter": "millimeter", "millimeters": "millimeter", "mm": "millimeter",
+                    "centimeter": "centimeter", "centimeters": "centimeter", "cm": "centimeter"
+                }
+                if unit in unit_aliases and hasattr(setter, unit_aliases[unit]):
+                    getattr(setter, unit_aliases[unit])
+                else:
+                    raise ValueError(f"Unknown unit: {unit}")
+            return self  # Return the variable itself for consistency
+        else:
+            return ts.LengthSetter(self, value)
     
 
 class LinearMassDensity(FieldQnty):
@@ -4482,16 +4522,39 @@ class Pressure(FieldQnty):
         
         Args:
             value: The numeric value to set
-            unit: Optional unit string (for compatibility with base class)
+            unit: Optional unit string (for direct setting)
         
         Returns:
-            PressureSetter: A setter with unit properties like .meters, .inches, etc.
+            PressureSetter: A setter with unit properties like .psi, .bar, etc.
         
         Example:
-            >>> length = Length("beam_length")
-            >>> length.set(100).millimeters  # Sets to 100 mm
-        """
-        return ts.PressureSetter(self, value)
+            >>> pressure = Pressure("system_pressure")
+            >>> pressure.set(100).psi  # Sets to 100 psi
+            >>> pressure.set(100, "psi")  # Direct setting
+        """
+        if unit is not None:
+            # Direct setting with unit
+            setter = ts.PressureSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                # Try common aliases
+                unit_aliases = {
+                    "psi": "psi", "pound_per_square_inch": "psi",
+                    "bar": "bar", "bars": "bar",
+                    "pascal": "pascal", "pascals": "pascal", "pa": "pascal",
+                    "kpa": "kilopascal", "kilopascal": "kilopascal",
+                    "mpa": "megapascal", "megapascal": "megapascal",
+                    "atm": "atmosphere", "atmosphere": "atmosphere"
+                }
+                if unit in unit_aliases and hasattr(setter, unit_aliases[unit]):
+                    getattr(setter, unit_aliases[unit])
+                else:
+                    raise ValueError(f"Unknown unit: {unit}")
+            return self  # Return the variable itself for consistency
+        else:
+            return ts.PressureSetter(self, value)
     
 
 class RadiationDoseEquivalent(FieldQnty):

{qnty-0.1.0.dist-info → qnty-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qnty
-Version: 0.1.0
+Version: 0.1.1
 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.dist-info → qnty-0.1.1.dist-info}/RECORD

@@ -14,15 +14,15 @@ qnty/equations/system.py,sha256=vMoD1iTUrAHnVFVvCUKeyNfSBfMiqpwQbfDx46kN9N8,5155
 qnty/expressions/__init__.py,sha256=DA2s7DBhVCmdUgsYSTJWObsp2DbbpFn492yr1nUTg2g,930
 qnty/expressions/formatter.py,sha256=yLGLwLYjhBvVi2Q6rfkg8pbyH0-a1Ko0AYLsqJTJf50,7806
 qnty/expressions/functions.py,sha256=ek43udfUDpThKo38rVPBYPvKfZNc9Bbs8RuL-CvQc_A,2729
-qnty/expressions/nodes.py,sha256=7JxHzhqZNrNUqShIBsIyuLmHQyeC14m4RxPCwxKvmrE,28431
+qnty/expressions/nodes.py,sha256=oqMFfMeeWhccv4KBHNI5qYBz2pSe6jD-OwE4P2HyG1A,28644
 qnty/expressions/types.py,sha256=eoM-IqY-k-IypRHAlRwjEtMmB6DiwX7YGot8t_vGw3o,1729
 qnty/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qnty/extensions/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qnty/extensions/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qnty/extensions/reporting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qnty/problems/__init__.py,sha256=g7zuml2IecoSwgzX6r1zZ5SlmBKFc8qqTR_cao037pc,4808
-qnty/problems/composition.py,sha256=JUOu3IksLRJEJ2OvPyarxkuzvcrnYI9fNeov2Lj7ynk,41937
-qnty/problems/problem.py,sha256=Yh7wLo7RyZcR9fie6niJqcnP81rZhDKtNTgd5KQr1XE,28279
+qnty/problems/composition.py,sha256=HI5ffsF14IXRuqjM0z_O0kkpme9fPnJVdz6m4rDCJsM,44916
+qnty/problems/problem.py,sha256=zCUFsD44Clp0lezKLeG0hPAzR-Qee9JHeonjoERBmNM,30933
 qnty/problems/rules.py,sha256=NwIStAa8bocVtvzAsnPmRdC_0ENTJWyXLOoYBnkvpPA,5176
 qnty/problems/solving.py,sha256=LTI8F9ujDiSqXE9Aiz8sOgaGJNX9p7oaR5CQIZHpCY8,44315
 qnty/problems/validation.py,sha256=SmFEsgHx5XwRNlR2suOhxO-WNsOwPZhCP8wyVKYo1EE,4826
@@ -31,7 +31,7 @@ qnty/quantities/base_qnty.py,sha256=QasOR4-a7gwPBvc6cLJ3ooQHmOcWbYexgtNQ9I6bXI8,
 qnty/quantities/field_converters.py,sha256=rDWttIE0lwF1doGlLG5RJTcTikYEYruMrRBMlr8fvBI,1008701
 qnty/quantities/field_qnty.py,sha256=9A-KP8DyO5oOfmxw41HKJq48dUF0LP9M_YYqvdbVvRM,42562
 qnty/quantities/field_setter.py,sha256=JCvRom4qvCYvgRNgFLZEuwb1PCmz0qrKzxDv0-h4RMo,449348
-qnty/quantities/field_vars.py,sha256=mo-kh3WFx6h_dfROUIXAyhdDAoEDEgGN_TlaLwu_o1U,264561
+qnty/quantities/field_vars.py,sha256=l2xWxuPrS8W1q1KtrBJQBST667-hxZXQERZXusombaA,267592
 qnty/quantities/field_vars.pyi,sha256=DJtLmxXJ9MrphAqSSOkMYNlLrq7-mAzvclp6bufT4RY,154868
 qnty/solving/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qnty/solving/manager.py,sha256=LQBMhWD3ajRYMBXkwRpkVzdo7qVEDviBAoHpjAzS-0U,3945
@@ -55,6 +55,6 @@ qnty/utils/error_handling/handlers.py,sha256=_q12co-jr4YSktRoCPpGBbh6WXEDw9MbmWx
 qnty/utils/logging.py,sha256=2H6_gSOQjxdK5024XTY3E1jGIQPE8WdalVhVBFw51OA,1143
 qnty/utils/protocols.py,sha256=c_Ya_epCm7qenAADRMZiwiQ0PdD-Z4T85b1z1YQNXAk,5247
 qnty/utils/scope_discovery.py,sha256=mQc-FHJ5-VNBzqQwiFofV-hqeF3GpLRaLlTjYDRnOqs,15184
-qnty-0.1.0.dist-info/METADATA,sha256=IEWbkj_Ll1dkIkr50avhKUlChVE6rrAnSy5Bv9y4Ma0,6761
-qnty-0.1.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-qnty-0.1.0.dist-info/RECORD,,
+qnty-0.1.1.dist-info/METADATA,sha256=9Khz22UTCVgWts-ktT19CxzUPKWPgA0RGmCTYVjFZRE,6761
+qnty-0.1.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+qnty-0.1.1.dist-info/RECORD,,