pyconvexity 0.3.8__tar.gz → 0.3.8.post2__tar.gz

{pyconvexity-0.3.8 → pyconvexity-0.3.8.post2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyconvexity
-Version: 0.3.8
+Version: 0.3.8.post2
 Summary: Python library for energy system modeling and optimization with PyPSA
 Author-email: Convexity Team <info@convexity.com>
 License: MIT

{pyconvexity-0.3.8 → pyconvexity-0.3.8.post2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyconvexity"
-version = "0.3.8"
+version = "0.3.8.post2"
 description = "Python library for energy system modeling and optimization with PyPSA"
 readme = "README.md"
 license = {text = "MIT"}
@@ -81,7 +81,7 @@ profile = "black"
 line_length = 100
 
 [tool.mypy]
-python_version = "0.3.8"
+python_version = "0.3.8.post2"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true

pyconvexity-0.3.8.post2/src/pyconvexity/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.8.post2"

{pyconvexity-0.3.8 → pyconvexity-0.3.8.post2}/src/pyconvexity/solvers/pypsa/api.py

@@ -76,14 +76,10 @@ def solve_network(
         if progress_callback:
             progress_callback(50, f"Network built: {len(network.buses)} buses, {len(network.generators)} generators")
         
-        # Apply constraints
+        # Create constraint applicator (constraints will be applied during solve via extra_functionality)
         constraint_applicator = ConstraintApplicator()
-        if constraints_dsl or progress_callback:
-            if progress_callback:
-                progress_callback(60, "Applying constraints...")
-            constraint_applicator.apply_constraints(conn, network_id, network, scenario_id, constraints_dsl)
         
-        # Solve network
+        # Solve network (constraints are applied during optimization)
         if progress_callback:
             progress_callback(70, f"Solving with {solver_name}...")
             

{pyconvexity-0.3.8 → pyconvexity-0.3.8.post2}/src/pyconvexity/solvers/pypsa/constraints.py

@@ -47,6 +47,53 @@ class ConstraintApplicator:
         if constraints_dsl:
             self._apply_dsl_constraints(network, constraints_dsl)
     
+    def _detect_constraint_type(self, constraint_code: str) -> str:
+        """
+        Detect if constraint is network-modification or model-constraint type.
+        
+        Args:
+            constraint_code: The constraint code to analyze
+            
+        Returns:
+            "model_constraint" or "network_modification"
+        """
+        # Type 2 indicators (model constraints) - need access to optimization model
+        model_indicators = [
+            'n.optimize.create_model()',
+            'm.variables',
+            'm.add_constraints',
+            'gen_p =',
+            'constraint_expr =',
+            'LinearExpression',
+            'linopy',
+            'Generator-p',
+            'lhs <=',
+            'constraint_expr =',
+            'model.variables',
+            'model.add_constraints'
+        ]
+        
+        # Type 1 indicators (network modifications) - modify network directly
+        network_indicators = [
+            'n.generators.loc',
+            'n.add(',
+            'n.buses.',
+            'n.lines.',
+            'network.generators.loc',
+            'network.add(',
+            'network.buses.',
+            'network.lines.'
+        ]
+        
+        # Check for model constraint indicators first (more specific)
+        if any(indicator in constraint_code for indicator in model_indicators):
+            return "model_constraint"
+        elif any(indicator in constraint_code for indicator in network_indicators):
+            return "network_modification"
+        else:
+            # Default to network_modification for safety (existing behavior)
+            return "network_modification"
+
     def _apply_database_constraints(
         self,
         conn,
@@ -64,6 +111,9 @@ class ConstraintApplicator:
             
             # Load constraint attributes and filter active ones
             active_constraints = []
+            model_constraints = []
+            network_constraints = []
+            
             for constraint in constraints:
                 try:
                     # Get constraint attributes
@@ -79,16 +129,12 @@ class ConstraintApplicator:
                             is_active_bool = is_active.static_value.data["Boolean"]
                         
                         if is_active_bool:
-                            # Extract code value first to check if it's an optimization constraint
+                            # Extract code value
                             code_val = ""
                             if constraint_code.variant == "Static":
                                 if "String" in constraint_code.static_value.data:
                                     code_val = constraint_code.static_value.data["String"]
                             
-                            # Skip optimization-time constraints in pre-optimization phase
-                            if 'net.model' in code_val or 'network.model' in code_val or 'n.model' in code_val:
-                                continue
-                            
                             # Extract priority value
                             priority_val = 0
                             if priority.variant == "Static":
@@ -97,48 +143,137 @@ class ConstraintApplicator:
                                 elif "Float" in priority.static_value.data:
                                     priority_val = int(priority.static_value.data["Float"])
                             
-                            active_constraints.append({
+                            constraint_dict = {
                                 'id': constraint.id,
                                 'name': constraint.name,
                                 'priority': priority_val,
-                                'code': code_val
-                            })
+                                'code': code_val,
+                                'constraint_code': code_val  # For compatibility
+                            }
+                            
+                            # Detect constraint type and separate them
+                            constraint_type = self._detect_constraint_type(code_val)
+                            if constraint_type == "model_constraint":
+                                model_constraints.append(constraint_dict)
+                                logger.info(f"Detected model constraint: {constraint.name}")
+                            else:
+                                network_constraints.append(constraint_dict)
+                                logger.info(f"Detected network constraint: {constraint.name}")
                         
                 except Exception as e:
                     logger.warning(f"Failed to load constraint {constraint.name}: {e}")
                     continue
             
-            if not active_constraints:
+            if not model_constraints and not network_constraints:
                 return
             
-            # Sort constraints by priority (lower numbers first)
-            active_constraints.sort(key=lambda x: x['priority'])
+            logger.info(f"Constraint breakdown: {len(model_constraints)} model constraints, {len(network_constraints)} network constraints")
+            
+            # Apply network constraints first (they modify the network structure)
+            if network_constraints:
+                network_constraints.sort(key=lambda x: x['priority'])
+                for constraint in network_constraints:
+                    try:
+                        logger.info(f"Executing network constraint '{constraint['name']}' (priority {constraint['priority']})")
+                        
+                        # Execute the constraint code in the normal Python environment
+                        exec_globals = {
+                            'n': network,
+                            'network': network,
+                            'pd': pd,
+                            'np': np,
+                        }
+                        
+                        # Execute the constraint code
+                        exec(constraint['code'], exec_globals)
+                        
+                    except Exception as e:
+                        error_msg = f"Failed to execute network constraint '{constraint['name']}': {e}"
+                        logger.error(error_msg, exc_info=True)
+                        # Continue with other constraints instead of failing the entire solve
+                        continue
+            
+            # Apply model constraints (they need access to the optimization model)
+            if model_constraints:
+                self._apply_model_constraints(network, model_constraints)
+                
+        except Exception as e:
+            logger.error(f"Failed to apply custom constraints: {e}", exc_info=True)
+    
+    def _apply_model_constraints(self, network: 'pypsa.Network', model_constraints: list):
+        """
+        Apply model constraints that need access to the optimization model.
+        
+        This creates the optimization model, applies constraints to it, and then
+        replaces PyPSA's solve method to use the pre-constrained model.
+        
+        Args:
+            network: PyPSA Network object
+            model_constraints: List of model constraint dictionaries
+        """
+        try:
+            logger.info(f"Applying {len(model_constraints)} model constraints...")
+            
+            # Create the optimization model (same as PyPSA would do internally)
+            logger.info("Creating optimization model for constraint application...")
+            model = network.optimize.create_model()
+            logger.info(f"Created optimization model with {len(model.variables)} variable groups")
             
-            # Execute constraints in order
-            for constraint in active_constraints:
+            # Sort constraints by priority
+            sorted_constraints = sorted(model_constraints, key=lambda x: x['priority'])
+            
+            # Apply each model constraint
+            for constraint in sorted_constraints:
                 try:
-                    logger.info(f"Executing constraint '{constraint['name']}' (priority {constraint['priority']})")
-                    logger.debug(f"Code: {constraint['code']}")
+                    constraint_code = constraint['constraint_code']
+                    constraint_name = constraint['name']
                     
-                    # Execute the constraint code in the normal Python environment
-                    # The network object 'n' is available in the global scope
+                    logger.info(f"Applying model constraint '{constraint_name}' (priority {constraint['priority']})")
+                    
+                    # Create execution environment with network, model, and utilities
                     exec_globals = {
                         'n': network,
+                        'network': network,
+                        'model': model,
+                        'm': model,
+                        'snapshots': network.snapshots,
                         'pd': pd,
                         'np': np,
+                        'xr': __import__('xarray'),  # Import xarray for DataArray operations
                     }
                     
                     # Execute the constraint code
-                    exec(constraint['code'], exec_globals)
+                    exec(constraint_code, exec_globals)
+                    logger.info(f"Successfully applied model constraint '{constraint_name}'")
                     
                 except Exception as e:
-                    error_msg = f"Failed to execute constraint '{constraint['name']}': {e}"
+                    error_msg = f"Failed to apply model constraint '{constraint.get('name', 'unknown')}': {e}"
                     logger.error(error_msg, exc_info=True)
-                    # Continue with other constraints instead of failing the entire solve
+                    # Continue with other constraints instead of failing
                     continue
-                
+            
+            # Store the constrained model for the solver to use
+            # We'll replace PyPSA's solve_model method to use our pre-constrained model
+            logger.info("Replacing PyPSA's solve method to use pre-constrained model...")
+            
+            # Store original methods
+            original_optimize = network.optimize
+            original_solve_model = original_optimize.solve_model
+            
+            # Create a wrapper that uses our pre-constrained model
+            def constrained_solve_model(*args, **kwargs):
+                """Use the pre-constrained model instead of creating a new one."""
+                logger.info("Using pre-constrained model for solve...")
+                return original_solve_model(model, *args, **kwargs)
+            
+            # Replace the solve_model method
+            network.optimize.solve_model = constrained_solve_model
+            
+            logger.info(f"Successfully applied {len(model_constraints)} model constraints")
+            
         except Exception as e:
-            logger.error(f"Failed to apply custom constraints: {e}", exc_info=True)
+            logger.error(f"Failed to apply model constraints: {e}", exc_info=True)
+            # Don't re-raise - let the solve continue without constraints rather than fail completely
     
     def _apply_dsl_constraints(self, network: 'pypsa.Network', constraints_dsl: str):
         """
@@ -172,7 +307,8 @@ class ConstraintApplicator:
         scenario_id: Optional[int] = None
     ) -> List[Dict[str, Any]]:
         """
-        Get constraints that need to be applied during optimization (via extra_functionality).
+        Get ALL active constraints for optimization-time application.
+        The solver will determine which are model constraints vs network constraints.
         
         Args:
             conn: Database connection
@@ -180,7 +316,7 @@ class ConstraintApplicator:
             scenario_id: Optional scenario ID
             
         Returns:
-            List of optimization constraints
+            List of all active constraints
         """
         try:
             # Load all constraints for this network
@@ -189,7 +325,7 @@ class ConstraintApplicator:
             if not constraints:
                 return []
             
-            # Load constraint attributes and filter active optimization-time ones
+            # Load constraint attributes and filter active ones
             optimization_constraints = []
             for constraint in constraints:
                 try:
@@ -212,26 +348,24 @@ class ConstraintApplicator:
                                 if "String" in constraint_code.static_value.data:
                                     code_val = constraint_code.static_value.data["String"]
                             
-                            # Check if this is an optimization-time constraint
-                            # (contains model access patterns like 'net.model' or 'network.model')
-                            if 'net.model' in code_val or 'network.model' in code_val or 'n.model' in code_val:
-                                # Extract priority value
-                                priority_val = 0
-                                if priority.variant == "Static":
-                                    if "Integer" in priority.static_value.data:
-                                        priority_val = priority.static_value.data["Integer"]
-                                    elif "Float" in priority.static_value.data:
-                                        priority_val = int(priority.static_value.data["Float"])
-                                
-                                optimization_constraints.append({
-                                    'id': constraint.id,
-                                    'name': constraint.name,
-                                    'priority': priority_val,
-                                    'code': code_val
-                                })
+                            # Extract priority value
+                            priority_val = 0
+                            if priority.variant == "Static":
+                                if "Integer" in priority.static_value.data:
+                                    priority_val = priority.static_value.data["Integer"]
+                                elif "Float" in priority.static_value.data:
+                                    priority_val = int(priority.static_value.data["Float"])
+                            
+                            optimization_constraints.append({
+                                'id': constraint.id,
+                                'name': constraint.name,
+                                'priority': priority_val,
+                                'constraint_code': code_val,  # Use consistent key name
+                                'code': code_val  # Keep both for compatibility
+                            })
                         
                 except Exception as e:
-                    logger.warning(f"Failed to load optimization constraint {constraint.name}: {e}")
+                    logger.warning(f"Failed to load constraint {constraint.name}: {e}")
                     continue
             
             # Sort constraints by priority (lower numbers first)
@@ -310,6 +444,7 @@ class ConstraintApplicator:
                 'snapshots': snapshots,
                 'pd': pd,
                 'np': np,
+                'xr': __import__('xarray'),
             }
             
             # Execute the constraint code

{pyconvexity-0.3.8 → pyconvexity-0.3.8.post2}/src/pyconvexity/solvers/pypsa/solver.py

@@ -139,13 +139,39 @@ class NetworkSolver:
             if conn and network_id:
                 self._set_snapshot_weightings_after_multiperiod(conn, network_id, network)
             
-            # Prepare optimization constraints (extra_functionality)
+            # Prepare optimization constraints with type detection
             extra_functionality = None
+            model_constraints = []
+            network_constraints = []
+            
             if conn and network_id and constraint_applicator:
                 optimization_constraints = constraint_applicator.get_optimization_constraints(conn, network_id, scenario_id)
                 if optimization_constraints:
-                    logger.info(f"Applying {len(optimization_constraints)} optimization-time constraints")
-                    extra_functionality = self._create_extra_functionality(optimization_constraints, constraint_applicator)
+                    logger.info(f"Found {len(optimization_constraints)} optimization constraints")
+                    
+                    # Separate constraints by type
+                    for constraint in optimization_constraints:
+                        constraint_code = constraint.get('constraint_code', '')
+                        constraint_type = self._detect_constraint_type(constraint_code)
+                        constraint_name = constraint.get('name', 'unknown')
+                        
+                        if constraint_type == "model_constraint":
+                            model_constraints.append(constraint)
+                            logger.info(f"Detected model constraint: {constraint_name}")
+                        else:
+                            network_constraints.append(constraint)
+                            logger.info(f"Detected network constraint: {constraint_name}")
+                    
+                    logger.info(f"Constraint breakdown: {len(model_constraints)} model constraints, {len(network_constraints)} network constraints")
+                    
+                    # Create extra_functionality for ALL constraints (both model and network)
+                    all_constraints = model_constraints + network_constraints
+                    if all_constraints:
+                        extra_functionality = self._create_extra_functionality(all_constraints, constraint_applicator)
+                        logger.info(f"Prepared {len(all_constraints)} constraints for optimization-time application")
+            
+            # NOTE: Model constraints are now applied DURING solve via extra_functionality
+            # This ensures they are applied to the actual model PyPSA creates, not a separate model
             
             # Solver diagnostics
             logger.info(f"=== PYPSA SOLVER DIAGNOSTICS ===")
@@ -342,7 +368,7 @@ class NetworkSolver:
             return 'gurobi', gurobi_dual_options
         
         # Check if this is a known valid solver name
-        elif solver_name in ['highs', 'gurobi', 'cplex', 'glpk', 'cbc', 'scip']:
+        elif solver_name in ['highs', 'gurobi', 'cplex', 'glpk', 'cbc', 'scip', 'copt', 'mosek']:
             return solver_name, solver_options
         
         else:
@@ -351,6 +377,51 @@ class NetworkSolver:
             return 'highs', solver_options
     
     
+    def _detect_constraint_type(self, constraint_code: str) -> str:
+        """
+        Detect if constraint is network-modification or model-constraint type.
+        
+        Args:
+            constraint_code: The constraint code to analyze
+            
+        Returns:
+            "model_constraint" or "network_modification"
+        """
+        # Type 2 indicators (model constraints) - need access to optimization model
+        model_indicators = [
+            'n.optimize.create_model()',
+            'm.variables',
+            'm.add_constraints',
+            'gen_p =',
+            'constraint_expr =',
+            'LinearExpression',
+            'linopy',
+            'Generator-p',
+            'lhs <=',
+            'constraint_expr ='
+        ]
+        
+        # Type 1 indicators (network modifications) - modify network directly
+        network_indicators = [
+            'n.generators.loc',
+            'n.add(',
+            'n.buses.',
+            'n.lines.',
+            'network.generators.loc',
+            'network.add(',
+            'network.buses.',
+            'network.lines.'
+        ]
+        
+        # Check for model constraint indicators first (more specific)
+        if any(indicator in constraint_code for indicator in model_indicators):
+            return "model_constraint"
+        elif any(indicator in constraint_code for indicator in network_indicators):
+            return "network_modification"
+        else:
+            # Default to network_modification for safety (existing behavior)
+            return "network_modification"
+
     def _create_extra_functionality(self, optimization_constraints: list, constraint_applicator) -> callable:
         """
         Create extra_functionality function for optimization-time constraints.

{pyconvexity-0.3.8 → pyconvexity-0.3.8.post2}/src/pyconvexity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyconvexity
-Version: 0.3.8
+Version: 0.3.8.post2
 Summary: Python library for energy system modeling and optimization with PyPSA
 Author-email: Convexity Team <info@convexity.com>
 License: MIT

{pyconvexity-0.3.8 → pyconvexity-0.3.8.post2}/src/pyconvexity.egg-info/SOURCES.txt

@@ -14,14 +14,19 @@ src/pyconvexity/core/errors.py
 src/pyconvexity/core/types.py
 src/pyconvexity/data/README.md
 src/pyconvexity/data/__init__.py
+src/pyconvexity/data/__pycache__/__init__.cpython-313.pyc
 src/pyconvexity/data/loaders/__init__.py
 src/pyconvexity/data/loaders/cache.py
+src/pyconvexity/data/loaders/__pycache__/__init__.cpython-313.pyc
+src/pyconvexity/data/loaders/__pycache__/cache.cpython-313.pyc
 src/pyconvexity/data/schema/01_core_schema.sql
 src/pyconvexity/data/schema/02_data_metadata.sql
 src/pyconvexity/data/schema/03_validation_data.sql
 src/pyconvexity/data/schema/04_scenario_schema.sql
 src/pyconvexity/data/sources/__init__.py
 src/pyconvexity/data/sources/gem.py
+src/pyconvexity/data/sources/__pycache__/__init__.cpython-313.pyc
+src/pyconvexity/data/sources/__pycache__/gem.cpython-313.pyc
 src/pyconvexity/io/__init__.py
 src/pyconvexity/io/excel_exporter.py
 src/pyconvexity/io/excel_importer.py

pyconvexity-0.3.8/src/pyconvexity/_version.py

@@ -1 +0,0 @@
-__version__ = "0.3.8"