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

qnty/problem/equations.py

@@ -1,413 +0,0 @@
-"""
-Equation processing pipeline for Problem class.
-
-This module contains all equation-related operations including adding equations,
-processing equation validation, handling missing variables, and equation reconstruction.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from qnty.equations import Equation
-    from qnty.quantities import TypeSafeVariable as Variable
-
-from qnty.equations import Equation
-
-# Constants for equation processing
-MATHEMATICAL_OPERATORS = ['+', '-', '*', '/', ' / ', ' * ', ' + ', ' - ']
-COMMON_COMPOSITE_VARIABLES = ['P', 'c', 'S', 'E', 'W', 'Y']
-
-
-# Custom Exceptions
-class EquationValidationError(ValueError):
-    """Raised when an equation fails validation."""
-    pass
-
-
-class EquationsMixin:
-    """Mixin class providing equation management functionality."""
-    
-    # These attributes/methods will be provided by other mixins in the final Problem class
-    variables: dict[str, Variable]
-    equations: list[Equation]
-    equation_system: Any
-    sub_problems: dict[str, Any]
-    logger: Any
-    equation_reconstructor: Any
-    
-    def _create_placeholder_variable(self, _symbol: str) -> None:
-        """Will be provided by VariablesMixin."""
-        ...
-
-    def add_equation(self, equation: Equation) -> None:
-        """
-        Add an equation to the problem.
-        
-        The equation will be validated to ensure all referenced variables exist.
-        Missing variables that look like simple identifiers will be auto-created
-        as unknown placeholders.
-        
-        Args:
-            equation: Equation object to add to the problem
-            
-        Raises:
-            EquationValidationError: If the equation is invalid or cannot be processed
-            
-        Note:
-            Adding an equation resets the problem to unsolved state.
-        """
-        if equation is None:
-            raise EquationValidationError("Cannot add None equation to problem")
-        
-        # Fix VariableReferences in equation to point to correct Variables
-        equation = self._fix_variable_references(equation)
-        
-        # Validate that all variables in the equation exist
-        try:
-            equation_vars = equation.get_all_variables()
-        except Exception as e:
-            raise EquationValidationError(f"Failed to extract variables from equation: {e}") from e
-        
-        missing_vars = [var for var in equation_vars if var not in self.variables]
-        
-        if missing_vars:
-            self._handle_missing_variables(missing_vars)
-            
-            # Check again for remaining missing variables
-            equation_vars = equation.get_all_variables()
-            remaining_missing = [var for var in equation_vars if var not in self.variables]
-            if remaining_missing:
-                self.logger.warning(f"Equation references missing variables: {remaining_missing}")
-        
-        self.equations.append(equation)
-        self.equation_system.add_equation(equation)
-        self.is_solved = False
-
-    def add_equations(self, *equations: Equation):
-        """Add multiple equations to the problem."""
-        for eq in equations:
-            self.add_equation(eq)
-        return self
-
-    def _handle_missing_variables(self, missing_vars: list[str]) -> None:
-        """Handle missing variables by creating placeholders for simple symbols."""
-        for missing_var in missing_vars:
-            if self._is_simple_variable_symbol(missing_var):
-                self._create_placeholder_variable(missing_var)
-
-    def _is_simple_variable_symbol(self, symbol: str) -> bool:
-        """Check if a symbol looks like a simple variable identifier."""
-        return (symbol.isidentifier() and
-                not any(char in symbol for char in ['(', ')', '+', '-', '*', '/', ' ']))
-
-    def _process_equation(self, attr_name: str, equation: Equation) -> bool:
-        """Process a single equation and add it to the problem if valid."""
-        return self._process_equation_impl(attr_name, equation)
-    
-    def _process_equation_impl(self, attr_name: str, equation: Equation) -> bool:
-        """
-        Process a single equation and determine if it should be added.
-        Returns True if the equation was successfully processed.
-        """
-        # First, update variable references to use symbols instead of names
-        updated_equation = self._update_equation_variable_references(equation)
-        
-        # Check if this equation contains delayed expressions
-        try:
-            has_delayed = self.equation_reconstructor.contains_delayed_expressions(updated_equation)
-            if has_delayed:
-                return self._handle_delayed_equation(attr_name, updated_equation)
-        except Exception as e:
-            self.logger.debug(f"Error checking delayed expressions for {attr_name}: {e}")
-        
-        # Check if this equation has invalid self-references
-        try:
-            has_self_ref = self._has_invalid_self_references(updated_equation)
-            if has_self_ref:
-                self.logger.debug(f"Skipping invalid self-referencing equation {attr_name}: {updated_equation}")
-                return False
-        except Exception as e:
-            self.logger.debug(f"Error checking self-references for {attr_name}: {e}")
-        
-        # Check if equation references non-existent variables
-        try:
-            has_missing = self._equation_has_missing_variables(updated_equation)
-            if has_missing:
-                return self._handle_equation_with_missing_variables(attr_name, updated_equation)
-        except Exception as e:
-            self.logger.debug(f"Error checking missing variables for {attr_name}: {e}")
-        
-        # Process valid equation
-        self.add_equation(updated_equation)
-        return True
-
-    def _handle_delayed_equation(self, attr_name: str, equation: Equation) -> bool:
-        """Handle equations with delayed expressions."""
-        resolved_equation = self.equation_reconstructor.resolve_delayed_equation(equation)
-        if resolved_equation:
-            self.add_equation(resolved_equation)
-            setattr(self, attr_name, resolved_equation)
-            return True
-        else:
-            self.logger.debug(f"Skipping unresolvable delayed equation {attr_name}: {equation}")
-            return False
-
-    def _handle_equation_with_missing_variables(self, attr_name: str, equation: Equation) -> bool:
-        """Handle equations that reference missing variables."""
-        # Handle conditional equations more carefully
-        if self._is_conditional_equation(equation):
-            return self._handle_conditional_equation(attr_name, equation)
-        
-        # Only attempt reconstruction for simple mathematical expressions from composition
-        if self.equation_reconstructor.should_attempt_reconstruction(equation):
-            return self._attempt_equation_reconstruction(attr_name, equation)
-        else:
-            # Skip other problematic equations
-            self.logger.debug(f"Skipping equation with missing variables {attr_name}: {equation}")
-            return False
-
-    def _handle_conditional_equation(self, attr_name: str, equation: Equation) -> bool:
-        """Handle conditional equations with missing variables."""
-        missing_vars = equation.get_all_variables() - set(self.variables.keys())
-        
-        # Skip conditional equations from sub-problems in composed systems
-        if self.sub_problems and self._is_conditional_equation_from_subproblem(equation, attr_name):
-            self.logger.debug(f"Skipping conditional equation {attr_name} from sub-problem in composed system")
-            return False
-        
-        # Check for composite expressions that might be reconstructable
-        unresolvable_vars = [var for var in missing_vars
-                           if any(op in var for op in MATHEMATICAL_OPERATORS)]
-        
-        if self.sub_problems and unresolvable_vars:
-            # Before skipping, try to reconstruct conditional equations with composite expressions
-            self.logger.debug(f"Attempting to reconstruct conditional equation {attr_name} with composite variables: {unresolvable_vars}")
-            reconstructed_equation = self.equation_reconstructor.reconstruct_composite_expressions_generically(equation)
-            if reconstructed_equation:
-                self.logger.debug(f"Successfully reconstructed conditional equation {attr_name}: {reconstructed_equation}")
-                self.add_equation(reconstructed_equation)
-                setattr(self, attr_name, reconstructed_equation)
-                return True
-            else:
-                self.logger.debug(f"Failed to reconstruct conditional equation {attr_name}, trying simple substitution")
-                # Try simple substitution for basic arithmetic expressions
-                reconstructed_equation = self._try_simple_substitution(equation, missing_vars)
-                if reconstructed_equation:
-                    self.add_equation(reconstructed_equation)
-                    return True
-                else:
-                    self.add_equation(equation)
-                    return True
-        else:
-            # Try to add the conditional equation even with missing simple variables
-            self.add_equation(equation)
-            return True
-
-    def _try_simple_substitution(self, _equation: Equation, _missing_vars: set[str]) -> Equation | None:
-        """
-        Try simple substitution for basic arithmetic expressions in conditional equations.
-        
-        The real issue is that nested expressions in conditionals aren't being handled properly.
-        For now, just return None and let the equation be added as-is.
-        """
-        return None
-
-    def _attempt_equation_reconstruction(self, attr_name: str, equation: Equation) -> bool:
-        """Attempt to reconstruct equations with composite expressions."""
-        missing_vars = equation.get_all_variables() - set(self.variables.keys())
-        self.logger.debug(f"Attempting to reconstruct equation {attr_name} with missing variables: {missing_vars}")
-        
-        reconstructed_equation = self.equation_reconstructor.reconstruct_composite_expressions_generically(equation)
-        if reconstructed_equation:
-            self.logger.debug(f"Successfully reconstructed {attr_name}: {reconstructed_equation}")
-            self.add_equation(reconstructed_equation)
-            setattr(self, attr_name, reconstructed_equation)
-            return True
-        else:
-            self.logger.debug(f"Failed to reconstruct equation {attr_name}: {equation}")
-            return False
-
-    def _get_equation_lhs_symbol(self, equation: Equation) -> str | None:
-        """Safely extract the symbol from equation's left-hand side."""
-        return getattr(equation.lhs, 'symbol', None)
-
-    def _is_conditional_equation(self, equation: Equation) -> bool:
-        """Check if an equation is a conditional equation."""
-        return 'cond(' in str(equation)
-
-    def _equation_has_missing_variables(self, equation: Equation) -> bool:
-        """Check if an equation references variables that don't exist in this problem."""
-        try:
-            all_vars = equation.get_all_variables()
-            missing_vars = [var for var in all_vars if var not in self.variables]
-            return len(missing_vars) > 0
-        except Exception:
-            return False
-
-    def _has_invalid_self_references(self, equation: Equation) -> bool:
-        """
-        Check if an equation has invalid self-references.
-        This catches malformed equations like 'c = max(c, c)' from class definition.
-        """
-        try:
-            # Get LHS variable - check if it has symbol attribute
-            lhs_symbol = self._get_equation_lhs_symbol(equation)
-            if lhs_symbol is None:
-                return False
-            
-            # Get all variables referenced in RHS
-            rhs_vars = equation.rhs.get_variables() if hasattr(equation.rhs, 'get_variables') else set()
-            
-            # Check if the LHS variable appears multiple times in RHS (indicating self-reference)
-            # This is a heuristic - a proper implementation would parse the expression tree
-            equation_str = str(equation)
-            if lhs_symbol in rhs_vars:
-                # For conditional equations, self-references are often valid (as fallback values)
-                if 'cond(' in equation_str:
-                    return False  # Allow self-references in conditional equations
-                
-                # Count occurrences of the variable in the equation string
-                count = equation_str.count(lhs_symbol)
-                if count > 2:  # LHS + multiple RHS occurrences
-                    return True
-            
-            return False
-            
-        except Exception:
-            return False
-
-    def _is_conditional_equation_from_subproblem(self, equation: Equation, _equation_name: str) -> bool:
-        """
-        Check if a conditional equation comes from a sub-problem and should be skipped in composed systems.
-        
-        In composed systems, if a sub-problem's conditional variable is already set to a known value,
-        we don't want to include the conditional equation that would override that known value.
-        """
-        try:
-            # Check if this is a conditional equation with a known LHS variable
-            lhs_symbol = self._get_equation_lhs_symbol(equation)
-            if lhs_symbol is not None:
-                
-                # Check if the LHS variable already exists and is known
-                if lhs_symbol in self.variables:
-                    var = self.variables[lhs_symbol]
-                    # If the variable is already known (set explicitly in composition),
-                    # and this conditional equation references missing variables, skip it
-                    missing_vars = equation.get_all_variables() - set(self.variables.keys())
-                    if missing_vars and var.is_known:
-                        # This is a sub-problem's conditional equation for a variable that's already known
-                        # No point including it since the value is already determined
-                        return True
-            
-            return False
-            
-        except Exception:
-            return False
-
-    def _fix_variable_references(self, equation: Equation) -> Equation:
-        """
-        Fix VariableReferences in equation expressions to point to Variables in problem.variables.
-        
-        This resolves issues where expression trees contain VariableReferences pointing to
-        proxy Variables from class creation time instead of the actual Variables in the problem.
-        """
-        try:
-            # Fix the RHS expression
-            fixed_rhs = self._fix_expression_variables(equation.rhs)
-            
-            # Create new equation with fixed RHS (LHS should already be correct)
-            return Equation(equation.name, equation.lhs, fixed_rhs)
-            
-        except Exception as e:
-            self.logger.debug(f"Error fixing variable references in equation {equation.name}: {e}")
-            return equation  # Return original if fixing fails
-
-    def _fix_expression_variables(self, expr):
-        """
-        Recursively fix VariableReferences in an expression tree to point to correct Variables.
-        """
-        from qnty.expressions import BinaryOperation, Constant, VariableReference
-        
-        if isinstance(expr, VariableReference):
-            # Check if this VariableReference points to the wrong Variable
-            symbol = getattr(expr, 'symbol', None)
-            if symbol and symbol in self.variables:
-                correct_var = self.variables[symbol]
-                if expr.variable is not correct_var:
-                    # Create new VariableReference pointing to correct Variable
-                    return VariableReference(correct_var)
-            return expr
-            
-        elif isinstance(expr, BinaryOperation):
-            # Recursively fix left and right operands
-            fixed_left = self._fix_expression_variables(expr.left)
-            fixed_right = self._fix_expression_variables(expr.right)
-            return BinaryOperation(expr.operator, fixed_left, fixed_right)
-            
-        elif hasattr(expr, 'operand'):
-            # Recursively fix operand
-            fixed_operand = self._fix_expression_variables(expr.operand)
-            return type(expr)(expr.operator, fixed_operand)
-            
-        elif hasattr(expr, 'function_name'):
-            # Recursively fix left and right operands
-            fixed_left = self._fix_expression_variables(expr.left)
-            fixed_right = self._fix_expression_variables(expr.right)
-            return type(expr)(expr.function_name, fixed_left, fixed_right)
-            
-        elif isinstance(expr, Constant):
-            return expr
-            
-        else:
-            # Unknown expression type, return as-is
-            return expr
-
-    def _update_equation_variable_references(self, equation: Equation) -> Equation:
-        """Update VariableReference objects in equation to use symbols instead of names."""
-        from qnty.expressions import VariableReference
-        
-        # Update LHS if it's a VariableReference
-        updated_lhs = equation.lhs
-        if isinstance(equation.lhs, VariableReference):
-            # Find the variable by name and update to use symbol
-            var_name = equation.lhs.variable.name
-            matching_var = None
-            for var in self.variables.values():
-                if var.name == var_name:
-                    matching_var = var
-                    break
-            if matching_var and matching_var.symbol:
-                updated_lhs = VariableReference(matching_var)
-        
-        # Update RHS by recursively updating expressions
-        updated_rhs = self._update_expression_variable_references(equation.rhs)
-        
-        # Create new equation with updated references
-        return Equation(equation.name, updated_lhs, updated_rhs)
-    
-    def _update_expression_variable_references(self, expr):
-        """Recursively update VariableReference objects in expression tree."""
-        from qnty.expressions import BinaryOperation, Constant, VariableReference
-        
-        if isinstance(expr, VariableReference):
-            # Find the variable by name and update to use symbol
-            var_name = expr.variable.name
-            matching_var = None
-            for var in self.variables.values():
-                if var.name == var_name:
-                    matching_var = var
-                    break
-            if matching_var and matching_var.symbol:
-                return VariableReference(matching_var)
-            return expr
-        elif isinstance(expr, BinaryOperation):
-            updated_left = self._update_expression_variable_references(expr.left)
-            updated_right = self._update_expression_variable_references(expr.right)
-            return BinaryOperation(expr.operator, updated_left, updated_right)
-        elif isinstance(expr, Constant):
-            return expr
-        else:
-            # Return unknown expression types as-is
-            return expr