qnty 0.0.7__py3-none-any.whl → 0.0.8__py3-none-any.whl

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/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/variable.py

@@ -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/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.7.dist-info → qnty-0.0.8.dist-info}/METADATA

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

@@ -1,19 +1,19 @@
 qnty/__init__.py,sha256=o9rtuo8QAdC3ppaD7ev1jqjrWbCvpdFbi_yZwUBuc6Q,5551
 qnty/dimension.py,sha256=yc4zSJ5KCzgihya2MZX4lfP3E4YNg97mP8Sw_ajO2Pg,11117
-qnty/equation.py,sha256=XgzM91jn__GomKbgslncoFJWPDJiMb4_VKD-8sdcFXc,9096
-qnty/expression.py,sha256=WV0OfZYPZlNf_sBEgOrnG88KKzj-xvTn45YGMoZR1xc,21435
+qnty/equation.py,sha256=RRe3pJBn3ZrM3LtSnioG_i7gKmBnNVsIxc9KXf5UrTg,12278
+qnty/expression.py,sha256=pbQ8fB2xc7VVi4LTqw8PbJFqG7XW4U36wI2pe6P4yto,24609
 qnty/prefixes.py,sha256=bRwcNbE_nX9gXI_WnJZLL-i7kQncIOZivCCSN8dur2g,6000
 qnty/unit.py,sha256=V3rQY-fYAnYC8Ed2r9FlCCkMOZ4zQQvGaVPS4VH-K9c,5585
 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=8swGhiJQfrA_-gas2e2cbwKTXf4g0xmBbeVibYsqCHk,302897
-qnty/variable.py,sha256=TOdh30vCF_TQHQuCC2sjRkwlXibryHhteb9djoJt5Fc,11396
+qnty/variable.py,sha256=y2rQnGKeErC7_NKz9Z3WLV_cEn2Ya3ZvBEEPwioHrSo,13091
 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/expression_variable.py,sha256=xTHTSqITZt9h5vas3M_pZsQeE8Bm5cJxZBr7Q1EdhUs,4838
 qnty/variable_types/typed_variable.py,sha256=kjw8VOShMaE7iorc3mqCIApYaFgOfvv-jSu_tmT1DgM,4227
 qnty/variables.py,sha256=boClctOkzemu18yMv2rzuVq96MNCVFR-MOVVO1InBQc,142715
 qnty/variables.pyi,sha256=KYPDJ-Qh_LPP4vHsafzrV6ZAUeepErY-RwRpOTieuhk,219690
-qnty-0.0.7.dist-info/METADATA,sha256=vxA0YIrA0DDqVbKz9e9rfEHIBdJ-Pk7S7bfc4BRdKeM,12113
-qnty-0.0.7.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-qnty-0.0.7.dist-info/RECORD,,
+qnty-0.0.8.dist-info/METADATA,sha256=uo_wncOYHiRWJYeie3RWMWMOeAVbWBnQMquWnYLPGAs,12113
+qnty-0.0.8.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+qnty-0.0.8.dist-info/RECORD,,