pyconvexity 0.3.7__py3-none-any.whl → 0.3.8.post1__py3-none-any.whl

pyconvexity/_version.py

@@ -1 +1 @@
-__version__ = "0.3.7"
+__version__ = "0.3.8.post1"

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/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/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']:
             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.7.dist-info → pyconvexity-0.3.8.post1.dist-info}/METADATA

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

{pyconvexity-0.3.7.dist-info → pyconvexity-0.3.8.post1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pyconvexity/__init__.py,sha256=eiAFroO4n-z8F0jTLpJgBIO7vtSxu9ovu3G2N-qqpUo,4783
-pyconvexity/_version.py,sha256=J0I0c7-a50EOnWXMryTu_E6xhXSYFBPjVpeYP_a3vRI,22
+pyconvexity/_version.py,sha256=bzpt5I55RpJ9-TikkLRgUK3tzieEqyUA-wVI8qcMUx0,28
 pyconvexity/timeseries.py,sha256=4p1Tdpa1otqDvCq2zppA4tw660sF_XWb8Xobib-cCms,11340
 pyconvexity/core/__init__.py,sha256=MgVa5rrRWIi2w1UI1P4leiBntvHeeOPv0Thm0DEXBHo,1209
 pyconvexity/core/database.py,sha256=M02q4UkJqAPeTXuwng9I7kHm16reJ7eq7wccWxnhE5I,15227
@@ -7,14 +7,19 @@ pyconvexity/core/errors.py,sha256=HhrrOOEBJrzyB56_pmqh3NWvX6uHqWWNkdE5XM16rYI,28
 pyconvexity/core/types.py,sha256=LkB49qklA-9ObI0br0IazfVxvWvYzQrYMdwzrqqAMYQ,11335
 pyconvexity/data/README.md,sha256=-tyDHVjqzfWbVvgM4yYYx8cysmgvFXI6plVQNxSHBmo,3156
 pyconvexity/data/__init__.py,sha256=BrgC3LGSlReLbC0EpM6UxywwUHxRvts379CvZFE0qWU,514
+pyconvexity/data/__pycache__/__init__.cpython-313.pyc,sha256=F2XXlQZlN5aoFmi7Ar1B3RW-DZjIUqp81fr3zNsPxpY,617
 pyconvexity/data/loaders/__init__.py,sha256=6xPtOmH2n1mNby7ZjA-2Mk9F48Q246RNsyMnCnJ6gwA,60
 pyconvexity/data/loaders/cache.py,sha256=nnz8bV3slSehOT0alexFga9tM1XoJqWHBGqaXvz132U,7299
+pyconvexity/data/loaders/__pycache__/__init__.cpython-313.pyc,sha256=AuT3aXy3v5gssxdD1_CBaKqNAVmDt6GBwFSyAe3jHow,265
+pyconvexity/data/loaders/__pycache__/cache.cpython-313.pyc,sha256=9_xMQN6AciMzbzhCmWAzvEKRXfRINmfRsO8Dyg0_CUQ,9804
 pyconvexity/data/schema/01_core_schema.sql,sha256=Ww3eD71JGIBNw-t_eVJ6TVGju-sEDzpLqyRGqGDje54,18871
 pyconvexity/data/schema/02_data_metadata.sql,sha256=oOfwa3PLY2_8rxKDD4cpDeqP5I_PdahcF8m6cSKStJM,10732
 pyconvexity/data/schema/03_validation_data.sql,sha256=1rKFi9y6jQ2OnfH32jnIKnZ5WtB8eG43hz0OVJhwn3w,58325
 pyconvexity/data/schema/04_scenario_schema.sql,sha256=sL4PySJNHIthXsnoJ2T5pdXUbpAi94ld0XGuU8LwNuQ,4641
 pyconvexity/data/sources/__init__.py,sha256=Dn6_oS7wB-vLjMj2YeXlmIl6hNjACbicimSabKxIWnc,108
 pyconvexity/data/sources/gem.py,sha256=Ft2pAYsWe1V9poRge2Q4xdNt15XkG-USSR0XR9KFmsY,14935
+pyconvexity/data/sources/__pycache__/__init__.cpython-313.pyc,sha256=9x5FyLxmTE5ZRaEFNSF375KBd_rDLY6pGHGSWPpcxxA,313
+pyconvexity/data/sources/__pycache__/gem.cpython-313.pyc,sha256=VA7v6miTbKJcSMwKElsRKwuyGP3ek95O3ALa133Lx_U,14476
 pyconvexity/io/__init__.py,sha256=glGzXBRGHROrTS8xe-RTGyRQUgsaksafxXVt9GpW63E,803
 pyconvexity/io/excel_exporter.py,sha256=pjgvTs5vq9K61mNOVutEzaH5Zx4FgrDG4Xc_YmXhE5o,48483
 pyconvexity/io/excel_importer.py,sha256=M7YcBqKUVzOMoR5HN-v8M2UnZgHRfhqgXBMUVD10-IQ,56898
@@ -27,15 +32,15 @@ pyconvexity/models/network.py,sha256=ePydR3l60-AaOBbrA4uld3hu3X9sB7GOSyBYMh3_rBA
 pyconvexity/models/scenarios.py,sha256=6-devNWZccnFeQr3IsP19GkO6Ixp914RKD-6lIduN-A,5164
 pyconvexity/solvers/__init__.py,sha256=zoVf6T2Tmyj2XOeiVbEvaIMOX584orqCz1q9t1oXy0M,674
 pyconvexity/solvers/pypsa/__init__.py,sha256=KZqYDo7CvwB-5Kp784xxxtdn5kRcmn3gGSRlaQdDA4c,554
-pyconvexity/solvers/pypsa/api.py,sha256=u1MTSZkCxXMukSUQ83oDz_pWf4kRXKV_Bk7b0yd7lV4,16762
+pyconvexity/solvers/pypsa/api.py,sha256=05IN6KgjpVNJ3TrH0gv1F2-GLRnffLQOc3rsT1ZEql8,16629
 pyconvexity/solvers/pypsa/batch_loader.py,sha256=eQb8B11akQYtH3aK93WAOoXEI-ktk4imATw9gaYDNR4,13547
 pyconvexity/solvers/pypsa/builder.py,sha256=WrimcBvG4mNFLTrLq7131Ku0AXY_0oRKxfI81ywc5Cs,24460
-pyconvexity/solvers/pypsa/constraints.py,sha256=uX0X_EDFak7YtnjgNxj3CSv1nxDQI-fT4eg9lyySAv4,13678
-pyconvexity/solvers/pypsa/solver.py,sha256=NFZ4_8inW-xHkv7pTrfq09vkKFINDwdTuJAQTn8lMfg,54555
+pyconvexity/solvers/pypsa/constraints.py,sha256=MycS-pvuYIEEa0s2tkskiydX_HhAKNTnsQdVc842u50,19792
+pyconvexity/solvers/pypsa/solver.py,sha256=PA0_S95JQm6ZifuY_TEjRvEhm-zgmtZsap5G1TEHBVA,57739
 pyconvexity/solvers/pypsa/storage.py,sha256=T-0qEryiEy_8G4KiscPoiiWvTPd_OGqpLczW0_Xm85E,87331
 pyconvexity/validation/__init__.py,sha256=_6SVqXkaDFqmagub_O064Zm_QIdBrOra-Gvvbo9vM4I,549
 pyconvexity/validation/rules.py,sha256=6Kak12BVfUpjmgB5B7Wre55eGc5e1dvIdFca-vN-IFI,9296
-pyconvexity-0.3.7.dist-info/METADATA,sha256=sSqe9fkreaNnzTbxlms2n96Tp1wKwbGghQ60LEiP0uY,4880
-pyconvexity-0.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyconvexity-0.3.7.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
-pyconvexity-0.3.7.dist-info/RECORD,,
+pyconvexity-0.3.8.post1.dist-info/METADATA,sha256=XAs5-GMZ1W6GM8E-aPhdO78v-sg5Ko-fmQGWFXueXN8,4886
+pyconvexity-0.3.8.post1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyconvexity-0.3.8.post1.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
+pyconvexity-0.3.8.post1.dist-info/RECORD,,