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

qnty/equations/equation.py

@@ -7,24 +7,18 @@ Mathematical equations for qnty variables with solving capabilities.
 
 from __future__ import annotations
 
+import logging
 from typing import cast
 
+from ..constants import SOLVER_DEFAULT_TOLERANCE
 from ..expressions import Expression, VariableReference
-from ..quantities.quantity import TypeSafeVariable
-
-# Global optimization flags and cache
-_SCOPE_DISCOVERY_ENABLED = False  # Disabled by default due to high overhead
-_VARIABLE_TYPE_CACHE = {}  # Cache for hasattr checks
+from ..quantities import FieldQnty
+from ..utils.scope_discovery import ScopeDiscoveryService
 
+_logger = logging.getLogger(__name__)
 
-def _is_typesafe_variable(obj) -> bool:
-    """Optimized type check with caching for hasattr calls."""
-    obj_type = type(obj)
-    if obj_type not in _VARIABLE_TYPE_CACHE:
-        _VARIABLE_TYPE_CACHE[obj_type] = (
-            hasattr(obj, 'symbol') and hasattr(obj, 'name') and hasattr(obj, 'quantity')
-        )
-    return _VARIABLE_TYPE_CACHE[obj_type]
+# Global optimization flags
+_SCOPE_DISCOVERY_ENABLED = False  # Disabled by default due to high overhead
 
 
 class Equation:
@@ -32,21 +26,22 @@ class Equation:
     Represents a mathematical equation with left-hand side equal to right-hand side.
     Optimized with __slots__ for memory efficiency.
     """
-    __slots__ = ('name', 'lhs', 'rhs', '_variables')
-    
-    def __init__(self, name: str, lhs: TypeSafeVariable | Expression, rhs: Expression):
+
+    __slots__ = ("name", "lhs", "rhs", "_variables")
+
+    def __init__(self, name: str, lhs: FieldQnty | Expression, rhs: Expression):
         self.name = name
-        
+
         # Convert Variable to VariableReference if needed - use isinstance for performance
-        if isinstance(lhs, TypeSafeVariable):
+        if isinstance(lhs, FieldQnty):
             self.lhs = VariableReference(lhs)
         else:
             # It's already an Expression
             self.lhs = cast(Expression, lhs)
-            
+
         self.rhs = rhs
         self._variables: set[str] | None = None  # Lazy initialization for better performance
-    
+
     def get_all_variables(self) -> set[str]:
         """Get all variable names used in this equation."""
         if self._variables is None:
@@ -55,71 +50,67 @@ class Equation:
             rhs_vars = self.rhs.get_variables()
             self._variables = lhs_vars | rhs_vars
         return self._variables
-    
+
     @property
     def variables(self) -> set[str]:
         """Get all variable names used in this equation (cached property)."""
         return self.get_all_variables()
-    
+
     def get_unknown_variables(self, known_vars: set[str]) -> set[str]:
         """Get variables that are unknown (not in known_vars set)."""
         return self.variables - known_vars
-    
+
     def get_known_variables(self, known_vars: set[str]) -> set[str]:
         """Get variables that are known (in known_vars set)."""
         return self.variables & known_vars
-    
+
     def can_solve_for(self, target_var: str, known_vars: set[str]) -> bool:
         """Check if this equation can solve for target_var given known_vars."""
         if target_var not in self.variables:
             return False
+
         # Direct assignment case: lhs is the variable
         if isinstance(self.lhs, VariableReference) and self.lhs.name == target_var:
             rhs_vars = self.rhs.get_variables()
             return rhs_vars.issubset(known_vars)
+
+        # General case: can solve if target_var is the only unknown
         unknown_vars = self.get_unknown_variables(known_vars)
-        # Can solve if target_var is the only unknown
         return unknown_vars == {target_var}
-    
-    def solve_for(self, target_var: str, variable_values: dict[str, TypeSafeVariable]) -> TypeSafeVariable:
+
+    def solve_for(self, target_var: str, variable_values: dict[str, FieldQnty]) -> FieldQnty:
         """
         Solve the equation for target_var.
         Returns the target variable with updated quantity.
         """
         if target_var not in self.variables:
             raise ValueError(f"Variable '{target_var}' not found in equation")
-        
-        # Handle direct assignment: target = expression
-        if isinstance(self.lhs, VariableReference) and self.lhs.name == target_var:
-            # Direct assignment: target_var = rhs
-            result_qty = self.rhs.evaluate(variable_values)
-            
-            # Update existing variable object to preserve references
-            var_obj = variable_values.get(target_var)
-            if var_obj is not None:
-                # Convert result to the target variable's original unit if it had one
-                if var_obj.quantity is not None and var_obj.quantity.unit is not None:
-                    # Convert to the target variable's defined unit - be more specific about exceptions
-                    try:
-                        result_qty = result_qty.to(var_obj.quantity.unit)
-                    except (ValueError, TypeError, AttributeError):
-                        # Log specific conversion issues but continue with calculated unit
-                        # This preserves the original behavior while being more explicit
-                        pass
-                
-                var_obj.quantity = result_qty
-                var_obj.is_known = True
-                return var_obj
-            
-            # Create new variable if not found - this shouldn't happen in normal usage
+
+        # Only handle direct assignment: target = expression
+        if not (isinstance(self.lhs, VariableReference) and self.lhs.name == target_var):
+            raise NotImplementedError(f"Cannot solve for {target_var} in equation {self}. Only direct assignment equations (var = expression) are supported.")
+
+        # Direct assignment: target_var = rhs
+        result_qty = self.rhs.evaluate(variable_values)
+
+        # Get the variable object to update
+        var_obj = variable_values.get(target_var)
+        if var_obj is None:
             raise ValueError(f"Variable '{target_var}' not found in variable_values")
-        
-        # For more complex equations, we would need algebraic manipulation
-        # Currently focusing on direct assignment which covers most engineering cases
-        raise NotImplementedError(f"Cannot solve for {target_var} in equation {self}. "
-                                f"Only direct assignment equations (var = expression) are supported.")
-    
-    def check_residual(self, variable_values: dict[str, TypeSafeVariable], tolerance: float = 1e-10) -> bool:
+
+        # Convert result to the target variable's original unit if it had one
+        if var_obj.quantity is not None and var_obj.quantity.unit is not None:
+            try:
+                result_qty = result_qty.to(var_obj.quantity.unit)
+            except (ValueError, TypeError, AttributeError) as e:
+                _logger.debug(f"Unit conversion failed for {target_var}: {e}. Using calculated unit.")
+
+        # Update the variable and return it
+        var_obj.quantity = result_qty
+        var_obj.is_known = True
+        return var_obj
+
+    def check_residual(self, variable_values: dict[str, FieldQnty], tolerance: float = SOLVER_DEFAULT_TOLERANCE) -> bool:
         """
         Check if equation is satisfied by evaluating residual (LHS - RHS).
         Returns True if |residual| < tolerance, accounting for units.
@@ -128,112 +119,86 @@ class Equation:
             # Both lhs and rhs should be Expressions after __init__ conversion
             lhs_value = self.lhs.evaluate(variable_values)
             rhs_value = self.rhs.evaluate(variable_values)
-            
-            # Check dimensional compatibility
-            if lhs_value._dimension_sig != rhs_value._dimension_sig:
+
+            # Check dimensional compatibility using public API
+            if not self._are_dimensionally_compatible(lhs_value, rhs_value):
                 return False
-            
+
             # Convert to same units for comparison
             rhs_converted = rhs_value.to(lhs_value.unit)
             residual = abs(lhs_value.value - rhs_converted.value)
-            
+
             return residual < tolerance
-        except (ValueError, TypeError, AttributeError, KeyError):
-            # Handle specific expected errors during evaluation/conversion
+        except (ValueError, TypeError, AttributeError, KeyError) as e:
+            _logger.debug(f"Expected error in residual check for equation '{self.name}': {e}")
             return False
         except Exception as e:
-            # Re-raise unexpected errors to avoid masking bugs
-            raise RuntimeError(f"Unexpected error in residual check for equation '{self.name}': {e}") from e
-    
-    def _discover_variables_from_scope(self) -> dict[str, TypeSafeVariable]:
+            error_msg = f"Unexpected error in residual check for equation '{self.name}': {e}"
+            _logger.error(error_msg)
+            raise RuntimeError(error_msg) from e
+
+    def _discover_variables_from_scope(self) -> dict[str, FieldQnty]:
         """
-        Automatically discover variables from the calling scope.
-        Now optimized with caching and conditional execution.
+        Automatically discover variables from the calling scope using centralized service.
         """
         if not _SCOPE_DISCOVERY_ENABLED:
             return {}
-            
-        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
-            depth = 0
-            max_depth = 8  # Reduced from 10 for performance
-            while frame and depth < max_depth and (
-                frame.f_code.co_filename.endswith(('equation.py', 'expression.py')) or
-                frame.f_code.co_name in ['__str__', '__repr__']
-            ):
-                frame = frame.f_back
-                depth += 1
-            
-            if not frame:
-                return {}
-                
-            # Only get local variables first (faster than combining both)
-            local_vars = frame.f_locals
-            required_vars = self.variables
-            discovered = {}
-            
-            # First pass: check locals only (most common case)
-            for var_name in required_vars:
-                for obj in local_vars.values():
-                    if _is_typesafe_variable(obj) and (
-                        (hasattr(obj, 'symbol') and obj.symbol == var_name) or
-                        (hasattr(obj, 'name') and obj.name == var_name)
-                    ):
-                        discovered[var_name] = obj
-                        break
-            
-            # Second pass: check globals only if needed
-            if len(discovered) < len(required_vars):
-                global_vars = frame.f_globals
-                remaining_vars = required_vars - discovered.keys()
-                for var_name in remaining_vars:
-                    for obj in global_vars.values():
-                        if _is_typesafe_variable(obj) and (
-                            (hasattr(obj, 'symbol') and obj.symbol == var_name) or
-                            (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."""
+
+        # Use centralized scope discovery service
+        return ScopeDiscoveryService.discover_variables(self.variables, enable_caching=True)
+
+    def _are_dimensionally_compatible(self, lhs_value, rhs_value) -> bool:
+        """Check if two quantities are dimensionally compatible."""
         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
+            # Try to convert - if successful, they're compatible
+            rhs_value.to(lhs_value.unit)
+            return True
+        except (ValueError, TypeError, AttributeError):
+            return False
+
+    def _analyze_variable_states(self, discovered: dict[str, FieldQnty]) -> dict[str, str]:
+        """Analyze which variables are known vs unknown."""
+        states = {}
+        for var_name in self.variables:
+            if var_name not in discovered:
+                states[var_name] = "missing"
+            else:
+                var = discovered[var_name]
+                if hasattr(var, "is_known") and not var.is_known:
+                    states[var_name] = "unknown"
+                elif hasattr(var, "quantity") and var.quantity is not None:
+                    states[var_name] = "known"
                 else:
-                    return False, "", {}  # Missing variable
-            
-            # Can only auto-solve if there's exactly one unknown
-            if len(unknowns) == 1:
-                return True, unknowns[0], discovered
-            
+                    states[var_name] = "unknown"
+        return states
+
+    def _determine_solvability(self, states: dict[str, str], discovered: dict[str, FieldQnty]) -> tuple[bool, str, dict[str, FieldQnty]]:
+        """Determine if equation can be solved based on variable states."""
+        if "missing" in states.values():
             return False, "", {}
-            
-        except Exception:
+
+        unknowns = [name for name, state in states.items() if state == "unknown"]
+
+        # Can only auto-solve if there's exactly one unknown
+        if len(unknowns) == 1:
+            return True, unknowns[0], discovered
+
+        return False, "", {}
+
+    def _can_auto_solve(self) -> tuple[bool, str, dict[str, FieldQnty]]:
+        """Check if equation can be auto-solved from scope using centralized service."""
+        try:
+            discovered = self._discover_variables_from_scope()
+            if not discovered:
+                return False, "", {}
+
+            variable_states = self._analyze_variable_states(discovered)
+            return self._determine_solvability(variable_states, discovered)
+
+        except (AttributeError, KeyError, ValueError, TypeError) as e:
+            _logger.debug(f"Cannot auto-solve equation '{self.name}': {e}")
             return False, "", {}
-    
+
     def _try_auto_solve(self) -> bool:
         """Try to automatically solve the equation if possible."""
         try:
@@ -242,16 +207,14 @@ class Equation:
                 self.solve_for(target_var, variables)
                 return True
             return False
-        except Exception:
+        except (AttributeError, KeyError, ValueError, TypeError) as e:
+            _logger.debug(f"Auto-solve failed for equation '{self.name}': {e}")
             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:
         return f"Equation(name='{self.name}', lhs={self.lhs!r}, rhs={self.rhs!r})"
-
-
-

qnty/equations/system.py

@@ -1,4 +1,4 @@
-from ..quantities.quantity import TypeSafeVariable
+from ..quantities import FieldQnty
 from .equation import Equation
 
 
@@ -7,121 +7,124 @@ class EquationSystem:
     System of equations that can be solved together.
     Optimized with __slots__ for memory efficiency.
     """
-    __slots__ = ('equations', 'variables', '_known_cache', '_unknown_cache')
-    
+
+    __slots__ = ("equations", "variables", "_known_cache", "_unknown_cache")
+
     def __init__(self, equations: list[Equation] | None = None):
         self.equations = equations or []
-        self.variables = {}  # Dict[str, TypeSafeVariable]
+        self.variables: dict[str, FieldQnty] = {}  # Dict[str, FieldQnty]
         self._known_cache: set[str] | None = None  # Cache for known variables
         self._unknown_cache: set[str] | None = None  # Cache for unknown variables
-    
+
     def add_equation(self, equation: Equation):
         """Add an equation to the system."""
         self.equations.append(equation)
         self._invalidate_caches()
-    
-    def add_variable(self, variable: TypeSafeVariable):
+
+    def add_variable(self, variable: FieldQnty):
         """Add a variable to the system."""
         self.variables[variable.name] = variable
         self._invalidate_caches()
-    
+
     def _invalidate_caches(self):
         """Invalidate cached known/unknown variable sets."""
         self._known_cache = None
         self._unknown_cache = None
-    
+
+    def _is_variable_known(self, var: FieldQnty) -> bool:
+        """Determine if a variable should be considered known."""
+        return var.is_known and var.quantity is not None
+
     def get_known_variables(self) -> set[str]:
         """Get names of all known variables (cached)."""
         if self._known_cache is None:
-            self._known_cache = {name for name, var in self.variables.items() if var.is_known and var.quantity is not None}
+            self._known_cache = {name for name, var in self.variables.items() if self._is_variable_known(var)}
         return self._known_cache
-    
+
     def get_unknown_variables(self) -> set[str]:
         """Get names of all unknown variables (cached)."""
         if self._unknown_cache is None:
-            self._unknown_cache = {name for name, var in self.variables.items() if not var.is_known or var.quantity is None}
+            self._unknown_cache = {name for name, var in self.variables.items() if not self._is_variable_known(var)}
         return self._unknown_cache
-    
+
+    def _find_solvable_equation_variable_pair(self, known_vars: set[str], unknown_vars: set[str]) -> tuple[Equation, str] | None:
+        """Find the first equation-variable pair that can be solved."""
+        for equation in self.equations:
+            for unknown_var in unknown_vars:
+                if equation.can_solve_for(unknown_var, known_vars):
+                    return equation, unknown_var
+        return None
+
     def can_solve_any(self) -> bool:
         """Check if any equation can be solved with current known variables."""
         known_vars = self.get_known_variables()
         unknown_vars = self.get_unknown_variables()
-        
-        for equation in self.equations:
-            for unknown_var in unknown_vars:
-                if equation.can_solve_for(unknown_var, known_vars):
-                    return True
-        return False
-    
+        return self._find_solvable_equation_variable_pair(known_vars, unknown_vars) is not None
+
     def solve_step(self) -> bool:
         """Solve one step - find and solve one equation. Returns True if progress made."""
         known_vars = self.get_known_variables()
         unknown_vars = self.get_unknown_variables()
-        
-        # Find an equation that can be solved
-        for equation in self.equations:
-            for unknown_var in unknown_vars:
-                if equation.can_solve_for(unknown_var, known_vars):
-                    # Solve for this variable
-                    equation.solve_for(unknown_var, self.variables)
-                    # Invalidate caches since variable states have changed
-                    self._invalidate_caches()
-                    return True  # Progress made
-        
-        return False  # No progress possible
-    
+
+        pair = self._find_solvable_equation_variable_pair(known_vars, unknown_vars)
+        if pair is None:
+            return False
+
+        equation, unknown_var = pair
+        equation.solve_for(unknown_var, self.variables)
+        self._invalidate_caches()
+        return True
+
     def solve(self, max_iterations: int = 100) -> bool:
         """Solve the system iteratively. Returns True if fully solved."""
+        if max_iterations <= 0:
+            raise ValueError("max_iterations must be positive")
+
         for _ in range(max_iterations):
             if not self.can_solve_any():
                 break
             if not self.solve_step():
                 break
-        
+
         # Check if all variables are known
         unknown_vars = self.get_unknown_variables()
         return len(unknown_vars) == 0
-    
+
+    def _get_next_solvable_variable(self, simulated_known: set[str]) -> str | None:
+        """Find the next variable that can be solved given current known variables."""
+        unknown_vars = {name for name in self.variables.keys() if name not in simulated_known}
+        if not unknown_vars:
+            return None
+
+        for equation in self.equations:
+            for unknown_var in unknown_vars:
+                if equation.can_solve_for(unknown_var, simulated_known):
+                    return unknown_var
+        return None
+
     def get_solving_order(self) -> list[str]:
         """
         Get the order in which variables can be solved.
         Optimized to avoid creating full system copies.
         """
         order = []
-        # Track known variables without modifying the original
         simulated_known = self.get_known_variables().copy()
-        
-        # Continue until no more variables can be solved
+
         max_iterations = len(self.variables)  # Prevent infinite loops
-        iterations = 0
-        
-        while iterations < max_iterations:
-            unknown_vars = {name for name in self.variables.keys() if name not in simulated_known}
-            if not unknown_vars:
+        for _ in range(max_iterations):
+            next_var = self._get_next_solvable_variable(simulated_known)
+            if next_var is None:
                 break
-                
-            found_solvable = False
-            # Find next solvable variable
-            for equation in self.equations:
-                for unknown_var in unknown_vars:
-                    if equation.can_solve_for(unknown_var, simulated_known):
-                        order.append(unknown_var)
-                        # Simulate marking as known for next iteration
-                        simulated_known.add(unknown_var)
-                        found_solvable = True
-                        break
-                if found_solvable:
-                    break
-            
-            if not found_solvable:
-                break  # No more progress possible
-                
-            iterations += 1
-        
+
+            order.append(next_var)
+            simulated_known.add(next_var)
+
         return order
-    
+
     def __str__(self) -> str:
-        return f"EquationSystem({len(self.equations)} equations, {len(self.variables)} variables)"
-    
+        known_count = len(self.get_known_variables())
+        total_vars = len(self.variables)
+        return f"EquationSystem({len(self.equations)} equations, {known_count}/{total_vars} variables known)"
+
     def __repr__(self) -> str:
         return f"EquationSystem(equations={self.equations!r})"

qnty/expressions/__init__.py

@@ -6,56 +6,35 @@ Mathematical expressions for building equation trees with qnty variables.
 """
 
 # Core AST classes
-from .nodes import (
-    Expression,
-    VariableReference,
-    Constant,
-    BinaryOperation,
-    UnaryFunction,
-    ConditionalExpression
-)
-
 # Helper functions
-from .functions import (
-    sin,
-    cos,
-    tan,
-    sqrt,
-    abs_expr,
-    ln,
-    log10,
-    exp,
-    cond_expr,
-    min_expr,
-    max_expr
-)
-
-# Cache utilities
-from .cache import wrap_operand
+# Scope discovery service
+from ..utils.scope_discovery import ScopeDiscoveryService
+from .functions import abs_expr, cond_expr, cos, exp, ln, log10, max_expr, min_expr, sin, sqrt, tan
+from .nodes import BinaryOperation, ConditionalExpression, Constant, Expression, UnaryFunction, VariableReference, wrap_operand
 
 # Define public API
 __all__ = [
     # Core AST classes
-    'Expression',
-    'VariableReference',
-    'Constant',
-    'BinaryOperation',
-    'UnaryFunction',
-    'ConditionalExpression',
-    
+    "Expression",
+    "VariableReference",
+    "Constant",
+    "BinaryOperation",
+    "UnaryFunction",
+    "ConditionalExpression",
     # Helper functions
-    'sin',
-    'cos',
-    'tan',
-    'sqrt',
-    'abs_expr',
-    'ln',
-    'log10',
-    'exp',
-    'cond_expr',
-    'min_expr',
-    'max_expr',
-    
+    "sin",
+    "cos",
+    "tan",
+    "sqrt",
+    "abs_expr",
+    "ln",
+    "log10",
+    "exp",
+    "cond_expr",
+    "min_expr",
+    "max_expr",
     # Utilities
-    'wrap_operand'
-]
+    "wrap_operand",
+    # Scope discovery
+    "ScopeDiscoveryService",
+]