pyconvexity 0.3.8.post3__py3-none-any.whl → 0.3.8.post5__py3-none-any.whl

pyconvexity/solvers/pypsa/solver.py

@@ -77,6 +77,8 @@ class NetworkSolver:
             known_solvers = ['highs', 'gurobi', 'gurobi (barrier)', 'gurobi (barrier homogeneous)', 
                            'gurobi (barrier+crossover balanced)', 'gurobi (dual simplex)', 
                            'mosek', 'mosek (default)', 'mosek (barrier)', 'mosek (barrier+crossover)', 'mosek (dual simplex)',
+                           'copt', 'copt (barrier)', 'copt (barrier homogeneous)', 'copt (barrier+crossover)', 
+                           'copt (dual simplex)', 'copt (concurrent)',
                            'cplex', 'glpk', 'cbc', 'scip']
             
             if default_solver in known_solvers:
@@ -99,17 +101,21 @@ class NetworkSolver:
         conn=None,
         network_id: Optional[int] = None,
         scenario_id: Optional[int] = None,
-        constraint_applicator=None
+        constraint_applicator=None,
+        custom_solver_config: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
         """
         Solve PyPSA network and return results.
         
         Args:
             network: PyPSA Network object to solve
-            solver_name: Solver to use (default: "highs")
+            solver_name: Solver to use (default: "highs"). Use "custom" for custom_solver_config.
             solver_options: Optional solver-specific options
             discount_rate: Optional discount rate for multi-period optimization
             job_id: Optional job ID for tracking
+            custom_solver_config: Optional custom solver configuration when solver_name="custom"
+                Format: {"solver": "actual_solver_name", "solver_options": {...}}
+                Example: {"solver": "gurobi", "solver_options": {"Method": 2, "Crossover": 0}}
             
         Returns:
             Dictionary with solve results and metadata
@@ -125,14 +131,16 @@ class NetworkSolver:
         
         try:
             # Get solver configuration
-            actual_solver_name, solver_config = self._get_solver_config(solver_name, solver_options)
+            actual_solver_name, solver_config = self._get_solver_config(solver_name, solver_options, custom_solver_config)
             
+            # Resolve discount rate - fallback to 0.0 if None
+            # Note: API layer (api.py) handles fetching from network_config before calling this
+            effective_discount_rate = discount_rate if discount_rate is not None else 0.0
+            logger.info(f"Discount rate for solve: {effective_discount_rate}")
             
             years = list(network.investment_periods)
-            effective_discount_rate = discount_rate if discount_rate is not None else 0.05  # Default 5%
             
             logger.info(f"Multi-period optimization with {len(years)} periods: {years}")
-            logger.info(f"Discount rate: {effective_discount_rate}")
             
             # Calculate investment period weightings with discount rate
             self._calculate_investment_weightings(network, effective_discount_rate)
@@ -141,17 +149,17 @@ class NetworkSolver:
             if conn and network_id:
                 self._set_snapshot_weightings_after_multiperiod(conn, network_id, network)
             
-            # Prepare optimization constraints with type detection
+            # Prepare optimization constraints - ONLY model constraints
+            # Network constraints were already applied before solve in api.py
             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"Found {len(optimization_constraints)} optimization constraints")
                     
-                    # Separate constraints by type
+                    # Filter for model constraints only (network constraints already applied)
                     for constraint in optimization_constraints:
                         constraint_code = constraint.get('constraint_code', '')
                         constraint_type = self._detect_constraint_type(constraint_code)
@@ -159,21 +167,19 @@ class NetworkSolver:
                         
                         if constraint_type == "model_constraint":
                             model_constraints.append(constraint)
-                            logger.info(f"Detected model constraint: {constraint_name}")
+                            logger.info(f"Will apply model constraint during solve: {constraint_name}")
                         else:
-                            network_constraints.append(constraint)
-                            logger.info(f"Detected network constraint: {constraint_name}")
+                            logger.info(f"Skipping network constraint (already applied): {constraint_name}")
                     
-                    logger.info(f"Constraint breakdown: {len(model_constraints)} model constraints, {len(network_constraints)} network constraints")
+                    logger.info(f"Will apply {len(model_constraints)} model constraints during optimization")
                     
-                    # 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")
+                    # Create extra_functionality for model constraints only
+                    if model_constraints:
+                        extra_functionality = self._create_extra_functionality(model_constraints, constraint_applicator)
+                        logger.info(f"Prepared {len(model_constraints)} model 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
+            # NOTE: Model constraints are applied DURING solve via extra_functionality
+            # Network constraints were already applied to the network structure before solve
             
             # Solver diagnostics
             logger.info(f"=== PYPSA SOLVER DIAGNOSTICS ===")
@@ -273,17 +279,40 @@ class NetworkSolver:
                 "objective_value": None
             }
     
-    def _get_solver_config(self, solver_name: str, solver_options: Optional[Dict[str, Any]] = None) -> tuple[str, Optional[Dict[str, Any]]]:
+    def _get_solver_config(self, solver_name: str, solver_options: Optional[Dict[str, Any]] = None, 
+                           custom_solver_config: Optional[Dict[str, Any]] = None) -> tuple[str, Optional[Dict[str, Any]]]:
         """
         Get the actual solver name and options for special solver configurations.
         
         Args:
-            solver_name: The solver name (e.g., 'gurobi (barrier)', 'highs')
+            solver_name: The solver name (e.g., 'gurobi (barrier)', 'highs', 'custom')
             solver_options: Optional additional solver options
+            custom_solver_config: Optional custom solver configuration for solver_name='custom'
+                Format: {"solver": "actual_solver_name", "solver_options": {...}}
             
         Returns:
             Tuple of (actual_solver_name, solver_options_dict)
         """
+        # Handle "custom" solver with custom configuration
+        if solver_name == 'custom':
+            if not custom_solver_config:
+                raise ValueError("custom_solver_config must be provided when solver_name='custom'")
+            
+            if 'solver' not in custom_solver_config:
+                raise ValueError("custom_solver_config must contain 'solver' key with the actual solver name")
+            
+            actual_solver = custom_solver_config['solver']
+            custom_options = custom_solver_config.get('solver_options', {})
+            
+            # Merge with any additional solver_options passed separately
+            if solver_options:
+                merged_options = {'solver_options': {**custom_options, **solver_options}}
+            else:
+                merged_options = {'solver_options': custom_options} if custom_options else None
+            
+            logger.info(f"Using custom solver configuration: {actual_solver} with options: {custom_options}")
+            return actual_solver, merged_options
+        
         # Handle "default" solver
         if solver_name == 'default':
             # Try to read user's default solver preference
@@ -298,7 +327,7 @@ class NetworkSolver:
                     'Method': 2,             # Barrier
                     'Crossover': 0,          # Skip crossover
                     'MIPGap': 0.05,          # 5% gap
-                    'Threads': 4,            # Use all cores
+                    'Threads': 0,            # Use all cores (0 = auto)
                     'Presolve': 2,           # Aggressive presolve
                     'ConcurrentMIP': 1,      # Parallel root strategies
                     'BarConvTol': 1e-4,      # Relaxed barrier convergence
@@ -319,7 +348,7 @@ class NetworkSolver:
                     'Method': 2,             # Barrier
                     'Crossover': 0,          # Skip crossover
                     'MIPGap': 0.05,
-                    'Threads': 4,
+                    'Threads': 0,            # Use all cores (0 = auto)
                     'Presolve': 2,
                     'ConcurrentMIP': 1,
                     'BarConvTol': 1e-4,
@@ -340,7 +369,7 @@ class NetworkSolver:
                     'Method': 2,
                     'Crossover': 1,         # Dual crossover
                     'MIPGap': 0.01,
-                    'Threads': 4,
+                    'Threads': 0,            # Use all cores (0 = auto)
                     'Presolve': 2,
                     'Heuristics': 0.1,
                     'Cuts': 2,
@@ -374,67 +403,53 @@ class NetworkSolver:
             # No custom options - let Mosek use its default configuration
             mosek_default_options = {
                 'solver_options': {
-                    'MSK_IPAR_LOG': 10,                       # Enable full logging (10 = verbose)
-                    'MSK_IPAR_LOG_INTPNT': 1,                 # Log interior-point progress
-                    'MSK_IPAR_LOG_SIM': 4,                    # Log simplex progress
-                    'MSK_IPAR_LOG_MIO': 4,                    # Log MIP progress (4 = full)
-                    'MSK_IPAR_LOG_MIO_FREQ': 10,              # Log MIP every 10 seconds
+                    'MSK_DPAR_MIO_REL_GAP_CONST': 0.05,       # MIP relative gap tolerance (5% to match Gurobi)
+                    'MSK_IPAR_MIO_MAX_TIME': 36000,            # Max time 1 hour
                 }
             }
             if solver_options:
                 mosek_default_options['solver_options'].update(solver_options)
-            logger.info(f"Using Mosek with default configuration (auto-select optimizer)")
+            logger.info(f"Using Mosek with default configuration (auto-select optimizer) and moderate MIP strategies")
             return 'mosek', mosek_default_options
         
         elif solver_name == 'mosek (barrier)':
             mosek_barrier_options = {
                 'solver_options': {
                     'MSK_IPAR_INTPNT_BASIS': 0,                # Skip crossover (barrier-only) - 0 = MSK_BI_NEVER
-                    'MSK_DPAR_INTPNT_TOL_REL_GAP': 1e-5,      # Relaxed relative gap tolerance
-                    'MSK_DPAR_INTPNT_TOL_PFEAS': 1e-6,        # Primal feasibility tolerance
-                    'MSK_DPAR_INTPNT_TOL_DFEAS': 1e-6,        # Dual feasibility tolerance
-                    'MSK_DPAR_INTPNT_TOL_INFEAS': 1e-8,       # Infeasibility tolerance
-                    'MSK_IPAR_NUM_THREADS': 4,                # Number of threads
-                    'MSK_IPAR_PRESOLVE_USE': 1,               # Force presolve (1 = ON)
-                    'MSK_IPAR_PRESOLVE_LINDEP_USE': 1,        # Linear dependency check (1 = ON)
-                    'MSK_DPAR_MIO_REL_GAP_CONST': 1e-5,       # MIP relative gap tolerance
-                    'MSK_IPAR_MIO_NODE_OPTIMIZER': 4,         # Use interior-point for MIP nodes (4 = MSK_OPTIMIZER_INTPNT)
-                    'MSK_IPAR_MIO_ROOT_OPTIMIZER': 4,         # Use interior-point for MIP root (4 = MSK_OPTIMIZER_INTPNT)
-                    'MSK_IPAR_LOG': 10,                       # Enable full logging (10 = verbose)
-                    'MSK_IPAR_LOG_INTPNT': 1,                 # Log interior-point progress
-                    'MSK_IPAR_LOG_MIO': 4,                    # Log MIP progress (4 = full)
-                    'MSK_IPAR_LOG_MIO_FREQ': 10,              # Log MIP every 10 seconds
-                    # Note: Don't force MSK_IPAR_OPTIMIZER - let Mosek choose based on problem type (LP vs MILP)
+                    'MSK_DPAR_INTPNT_TOL_REL_GAP': 1e-4,      # Match Gurobi barrier tolerance
+                    'MSK_DPAR_INTPNT_TOL_PFEAS': 1e-5,        # Match Gurobi primal feasibility
+                    'MSK_DPAR_INTPNT_TOL_DFEAS': 1e-5,        # Match Gurobi dual feasibility
+                    # Removed MSK_DPAR_INTPNT_TOL_INFEAS - was 1000x tighter than other tolerances!
+                    'MSK_IPAR_NUM_THREADS': 0,                # Use all available cores (0 = auto)
+                    'MSK_IPAR_PRESOLVE_USE': 2,               # Aggressive presolve (match Gurobi Presolve=2)
+                    'MSK_IPAR_PRESOLVE_LINDEP_USE': 1,        # Linear dependency check
+                    'MSK_DPAR_MIO_REL_GAP_CONST': 0.05,       # Match Gurobi 5% MIP gap
+                    'MSK_IPAR_MIO_NODE_OPTIMIZER': 4,         # Use interior-point for MIP nodes
+                    'MSK_IPAR_MIO_ROOT_OPTIMIZER': 4,         # Use interior-point for MIP root
+                    'MSK_DPAR_MIO_MAX_TIME': 36000,            # Max time 10 hour
                 }
             }
             if solver_options:
                 mosek_barrier_options['solver_options'].update(solver_options)
-            logger.info(f"Using Mosek Barrier (no crossover) configuration with verbose logging")
+            logger.info(f"Using Mosek Barrier with aggressive presolve and relaxed tolerances")
             return 'mosek', mosek_barrier_options
         
         elif solver_name == 'mosek (barrier+crossover)':
             mosek_barrier_crossover_options = {
                 'solver_options': {
                     'MSK_IPAR_INTPNT_BASIS': 1,                # Always crossover (1 = MSK_BI_ALWAYS)
-                    'MSK_DPAR_INTPNT_TOL_REL_GAP': 1e-6,      # Tighter relative gap tolerance
-                    'MSK_DPAR_INTPNT_TOL_PFEAS': 1e-6,        # Primal feasibility tolerance
-                    'MSK_DPAR_INTPNT_TOL_DFEAS': 1e-6,        # Dual feasibility tolerance
-                    'MSK_IPAR_NUM_THREADS': 4,                # Number of threads
-                    'MSK_IPAR_PRESOLVE_USE': 1,               # Force presolve
-                    'MSK_IPAR_PRESOLVE_LINDEP_USE': 1,        # Linear dependency check
-                    'MSK_DPAR_MIO_REL_GAP_CONST': 1e-6,       # MIP relative gap tolerance
-                    'MSK_IPAR_MIO_NODE_OPTIMIZER': 4,         # Use interior-point for MIP nodes
+                    'MSK_DPAR_INTPNT_TOL_REL_GAP': 1e-4,      # Match Gurobi barrier tolerance (was 1e-6)
+                    'MSK_DPAR_INTPNT_TOL_PFEAS': 1e-5,        # Match Gurobi (was 1e-6)
+                    'MSK_DPAR_INTPNT_TOL_DFEAS': 1e-5,        # Match Gurobi (was 1e-6)
+                    'MSK_IPAR_NUM_THREADS': 0,                # Use all available cores (0 = auto)
+                    'MSK_DPAR_MIO_REL_GAP_CONST': 0.05,       # Match Gurobi 5% MIP gap (was 1e-6)
                     'MSK_IPAR_MIO_ROOT_OPTIMIZER': 4,         # Use interior-point for MIP root
-                    'MSK_IPAR_LOG': 10,                       # Enable full logging (10 = verbose)
-                    'MSK_IPAR_LOG_INTPNT': 1,                 # Log interior-point progress
-                    'MSK_IPAR_LOG_MIO': 4,                    # Log MIP progress (4 = full)
-                    'MSK_IPAR_LOG_MIO_FREQ': 10,              # Log MIP every 10 seconds
-                    # Note: Don't force MSK_IPAR_OPTIMIZER - let Mosek choose based on problem type
+                    'MSK_DPAR_MIO_MAX_TIME': 36000,            # Max time 10 hour (safety limit)
                 }
             }
             if solver_options:
                 mosek_barrier_crossover_options['solver_options'].update(solver_options)
-            logger.info(f"Using Mosek Barrier+Crossover configuration with verbose logging")
+            logger.info(f"Using Mosek Barrier+Crossover configuration with Gurobi-matched tolerances and moderate MIP strategies")
             return 'mosek', mosek_barrier_crossover_options
         
         elif solver_name == 'mosek (dual simplex)':
@@ -442,20 +457,16 @@ class NetworkSolver:
                 'solver_options': {
                     'MSK_IPAR_NUM_THREADS': 0,                # Use all available cores (0 = automatic)
                     'MSK_IPAR_PRESOLVE_USE': 1,               # Force presolve
-                    'MSK_IPAR_SIM_SCALING': 2,                # Aggressive scaling (2 = MSK_SCALING_AGGRESSIVE)
-                    'MSK_DPAR_MIO_REL_GAP_CONST': 1e-6,       # MIP relative gap tolerance
+                    'MSK_DPAR_MIO_REL_GAP_CONST': 0.05,       # Match Gurobi 5% MIP gap (was 1e-6)
                     'MSK_IPAR_MIO_NODE_OPTIMIZER': 1,         # Use dual simplex for MIP nodes (1 = MSK_OPTIMIZER_DUAL_SIMPLEX)
                     'MSK_IPAR_MIO_ROOT_OPTIMIZER': 1,         # Use dual simplex for MIP root
-                    'MSK_IPAR_LOG': 10,                       # Enable full logging (10 = verbose)
-                    'MSK_IPAR_LOG_SIM': 4,                    # Log simplex progress (4 = full)
-                    'MSK_IPAR_LOG_MIO': 4,                    # Log MIP progress (4 = full)
-                    'MSK_IPAR_LOG_MIO_FREQ': 10,              # Log MIP every 10 seconds
-                    # Note: For pure LP, set optimizer; for MILP, only set node/root optimizers
+                    'MSK_DPAR_MIO_MAX_TIME': 36000,            # Max time 10 hour (safety limit)
+
                 }
             }
             if solver_options:
                 mosek_dual_options['solver_options'].update(solver_options)
-            logger.info(f"Using Mosek Dual Simplex configuration with verbose logging")
+            logger.info(f"Using Mosek Dual Simplex configuration with Gurobi-matched tolerances and moderate MIP strategies")
             return 'mosek', mosek_dual_options
         
         # Check if this is a known valid solver name
@@ -463,16 +474,14 @@ class NetworkSolver:
             # Add default MILP-friendly settings for plain Mosek
             mosek_defaults = {
                 'solver_options': {
-                    'MSK_DPAR_MIO_REL_GAP_CONST': 1e-4,       # MIP relative gap tolerance (10^-4 = 0.01%)
-                    'MSK_IPAR_MIO_MAX_TIME': 3600,            # Max time 1 hour
+                    'MSK_DPAR_MIO_REL_GAP_CONST': 0.05,       # Match Gurobi 5% MIP gap (was 1e-4)
+                    'MSK_IPAR_MIO_MAX_TIME': 36000,            # Max time 1 hour
                     'MSK_IPAR_NUM_THREADS': 0,                # Use all cores (0 = auto)
-                    'MSK_IPAR_LOG': 4,                        # Moderate logging
-                    'MSK_IPAR_LOG_MIO': 2,                    # Log MIP occasionally
                 }
             }
             if solver_options:
                 mosek_defaults['solver_options'].update(solver_options)
-            logger.info(f"Using Mosek with default MILP-friendly settings")
+            logger.info(f"Using Mosek with barrier method for MIP (interior-point for root/nodes)")
             return solver_name, mosek_defaults
         
         elif solver_name == 'gurobi':
@@ -490,6 +499,117 @@ class NetworkSolver:
             logger.info(f"Using Gurobi with default MILP-friendly settings")
             return solver_name, gurobi_defaults
         
+        # Handle special COPT configurations
+        elif solver_name == 'copt (barrier)':
+            copt_barrier_options = {
+                'solver_options': {
+                    'LpMethod': 2,              # Barrier method
+                    'Crossover': 0,             # Skip crossover for speed
+                    'RelGap': 0.05,             # 5% MIP gap (match Gurobi)
+                    'TimeLimit': 7200,          # 1 hour time limit
+                    'Threads': -1,               # 4 threads (memory-conscious)
+                    'Presolve': 3,              # Aggressive presolve
+                    'Scaling': 1,               # Enable scaling
+                    'FeasTol': 1e-5,            # Match Gurobi feasibility
+                    'DualTol': 1e-5,            # Match Gurobi dual tolerance
+                    # MIP performance settings
+                    'CutLevel': 2,              # Normal cut generation
+                    'HeurLevel': 3,             # Aggressive heuristics
+                    'StrongBranching': 1,       # Fast strong branching
+                }
+            }
+            if solver_options:
+                copt_barrier_options['solver_options'].update(solver_options)
+            logger.info(f"Using COPT Barrier configuration (fast interior-point method)")
+            return 'copt', copt_barrier_options
+        
+        elif solver_name == 'copt (barrier homogeneous)':
+            copt_barrier_homogeneous_options = {
+                'solver_options': {
+                    'LpMethod': 2,              # Barrier method
+                    'Crossover': 0,             # Skip crossover
+                    'BarHomogeneous': 1,        # Use homogeneous self-dual form
+                    'RelGap': 0.05,             # 5% MIP gap
+                    'TimeLimit': 3600,          # 1 hour
+                    'Threads': -1,               # 4 threads (memory-conscious)
+                    'Presolve': 3,              # Aggressive presolve
+                    'Scaling': 1,               # Enable scaling
+                    'FeasTol': 1e-5,
+                    'DualTol': 1e-5,
+                    # MIP performance settings
+                    'CutLevel': 2,              # Normal cuts
+                    'HeurLevel': 3,             # Aggressive heuristics
+                    'StrongBranching': 1,       # Fast strong branching
+                }
+            }
+            if solver_options:
+                copt_barrier_homogeneous_options['solver_options'].update(solver_options)
+            logger.info(f"Using COPT Barrier Homogeneous configuration")
+            return 'copt', copt_barrier_homogeneous_options
+        
+        elif solver_name == 'copt (barrier+crossover)':
+            copt_barrier_crossover_options = {
+                'solver_options': {
+                    'LpMethod': 2,              # Barrier method
+                    'Crossover': 1,             # Enable crossover for better solutions
+                    'RelGap': 0.05,             # 5% MIP gap (relaxed for faster solves)
+                    'TimeLimit': 36000,          # 10 hour
+                    'Threads': -1,              # Use all cores
+                    'Presolve': 2,              # Aggressive presolve
+                    'Scaling': 1,               # Enable scaling
+                    'FeasTol': 1e-4,            # Tighter feasibility
+                    'DualTol': 1e-4,            # Tighter dual tolerance
+                }
+            }
+            if solver_options:
+                copt_barrier_crossover_options['solver_options'].update(solver_options)
+            logger.info(f"Using COPT Barrier+Crossover configuration (balanced performance)")
+            return 'copt', copt_barrier_crossover_options
+        
+        elif solver_name == 'copt (dual simplex)':
+            copt_dual_simplex_options = {
+                'solver_options': {
+                    'LpMethod': 1,              # Dual simplex method
+                    'RelGap': 0.05,             # 5% MIP gap
+                    'TimeLimit': 3600,          # 1 hour
+                    'Threads': -1,              # Use all cores
+                    'Presolve': 3,              # Aggressive presolve
+                    'Scaling': 1,               # Enable scaling
+                    'FeasTol': 1e-6,
+                    'DualTol': 1e-6,
+                    # MIP performance settings
+                    'CutLevel': 2,              # Normal cuts
+                    'HeurLevel': 2,             # Normal heuristics
+                    'StrongBranching': 1,       # Fast strong branching
+                }
+            }
+            if solver_options:
+                copt_dual_simplex_options['solver_options'].update(solver_options)
+            logger.info(f"Using COPT Dual Simplex configuration (robust method)")
+            return 'copt', copt_dual_simplex_options
+        
+        elif solver_name == 'copt (concurrent)':
+            copt_concurrent_options = {
+                'solver_options': {
+                    'LpMethod': 4,              # Concurrent (simplex + barrier)
+                    'RelGap': 0.05,             # 5% MIP gap
+                    'TimeLimit': 3600,          # 1 hour
+                    'Threads': -1,              # Use all cores
+                    'Presolve': 3,              # Aggressive presolve
+                    'Scaling': 1,               # Enable scaling
+                    'FeasTol': 1e-5,
+                    'DualTol': 1e-5,
+                    # MIP performance settings
+                    'CutLevel': 2,              # Normal cuts
+                    'HeurLevel': 3,             # Aggressive heuristics
+                    'StrongBranching': 1,       # Fast strong branching
+                }
+            }
+            if solver_options:
+                copt_concurrent_options['solver_options'].update(solver_options)
+            logger.info(f"Using COPT Concurrent configuration (parallel simplex + barrier)")
+            return 'copt', copt_concurrent_options
+        
         elif solver_name in ['highs', 'cplex', 'glpk', 'cbc', 'scip', 'copt']:
             return solver_name, solver_options
         

{pyconvexity-0.3.8.post3.dist-info → pyconvexity-0.3.8.post5.dist-info}/METADATA

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

{pyconvexity-0.3.8.post3.dist-info → pyconvexity-0.3.8.post5.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pyconvexity/__init__.py,sha256=eiAFroO4n-z8F0jTLpJgBIO7vtSxu9ovu3G2N-qqpUo,4783
-pyconvexity/_version.py,sha256=jxRGlI_N8vedEkv7nqYjYQvDc31-O3CwZMs1KZ9Odq8,28
+pyconvexity/_version.py,sha256=hAXE8ndUYHyK3gOK1hBR1ri9H4YX_KTmcufHouTLgTo,27
 pyconvexity/timeseries.py,sha256=4p1Tdpa1otqDvCq2zppA4tw660sF_XWb8Xobib-cCms,11340
 pyconvexity/core/__init__.py,sha256=MgVa5rrRWIi2w1UI1P4leiBntvHeeOPv0Thm0DEXBHo,1209
 pyconvexity/core/database.py,sha256=M02q4UkJqAPeTXuwng9I7kHm16reJ7eq7wccWxnhE5I,15227
@@ -12,10 +12,11 @@ pyconvexity/data/loaders/__init__.py,sha256=6xPtOmH2n1mNby7ZjA-2Mk9F48Q246RNsyMn
 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/01_core_schema.sql,sha256=2kkEevAhXJtNnC-wca2bnyw0m11mjheh4g9MPZpwBAc,20865
 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/schema/migrate_add_geometries.sql,sha256=ljTz2ZIvfRkHCjJiUbZJr7PvUxPv3UeLl3ADb9U7dWc,2710
 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
@@ -25,22 +26,24 @@ pyconvexity/io/excel_exporter.py,sha256=pjgvTs5vq9K61mNOVutEzaH5Zx4FgrDG4Xc_YmXh
 pyconvexity/io/excel_importer.py,sha256=M7YcBqKUVzOMoR5HN-v8M2UnZgHRfhqgXBMUVD10-IQ,56898
 pyconvexity/io/netcdf_exporter.py,sha256=AMM-uXBj8sh86n5m57aZ6S7LulAyIx_HM-eM-26BrWQ,7428
 pyconvexity/io/netcdf_importer.py,sha256=nv4CYYqnbCBeznwCU_JGBMTbg-BGNpXKlsqbu2R8fTU,72152
-pyconvexity/models/__init__.py,sha256=-CEdfjwOp-6XvR4vVyV1Z6umF1axs82zzvv7VRZNcys,1690
+pyconvexity/models/__init__.py,sha256=N8YqEntbF5NrxIgUk1Knj9FiOzmMtD5Kywc6THJVeFk,3528
 pyconvexity/models/attributes.py,sha256=LTvYF0hl56HeLjS8ZVocZWLhbLRTNhmZ5gUKxf93eSE,18254
-pyconvexity/models/components.py,sha256=yccDW9ROtjsk5eIO38Tr420VUj9KeV03IVLrfmZgj3c,14942
-pyconvexity/models/network.py,sha256=ePydR3l60-AaOBbrA4uld3hu3X9sB7GOSyBYMh3_rBA,13117
-pyconvexity/models/scenarios.py,sha256=6-devNWZccnFeQr3IsP19GkO6Ixp914RKD-6lIduN-A,5164
+pyconvexity/models/carriers.py,sha256=-nmasYvsaUeYPY1B0QdzfF_eph2HUFb5n3KF3CFd-YI,3700
+pyconvexity/models/components.py,sha256=wWRdX6vErZrQhhLTnHBLDOnkmLjbHY2e9J9ITZJi3F8,18287
+pyconvexity/models/network.py,sha256=2oEZOeVotyAs-SJl-b73zJKzSBvJEa6n1ryM0wV-Nko,14762
+pyconvexity/models/results.py,sha256=9IKgO4bve94OGHgUGUcxvFpySGRW8-K3Wwvv9RXEF2k,4031
+pyconvexity/models/scenarios.py,sha256=oF_xSOjrKMmUTzSR4oBAKKqWyudOGewW6DvZBa5IKXw,4125
 pyconvexity/solvers/__init__.py,sha256=zoVf6T2Tmyj2XOeiVbEvaIMOX584orqCz1q9t1oXy0M,674
 pyconvexity/solvers/pypsa/__init__.py,sha256=KZqYDo7CvwB-5Kp784xxxtdn5kRcmn3gGSRlaQdDA4c,554
-pyconvexity/solvers/pypsa/api.py,sha256=05IN6KgjpVNJ3TrH0gv1F2-GLRnffLQOc3rsT1ZEql8,16629
+pyconvexity/solvers/pypsa/api.py,sha256=si2VAvotQKk-hcNtT3bIWV0CE4EzSER94mxehPFm7M8,18015
 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=MycS-pvuYIEEa0s2tkskiydX_HhAKNTnsQdVc842u50,19792
-pyconvexity/solvers/pypsa/solver.py,sha256=2EB1EL6VRtYJ-KAk00vecEn8egMfdjOUaMfFuT8aPgA,65763
+pyconvexity/solvers/pypsa/constraints.py,sha256=qosBSNe0pr4va4dMmQFM-ifJCNGAkhS1R2gerNmhaiQ,16266
+pyconvexity/solvers/pypsa/solver.py,sha256=7jaksRKMaQuFYWb7Pl7rw7Pu0kO5DPysQX2JtWdUbBc,72074
 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.8.post3.dist-info/METADATA,sha256=bqoTl9zga7X365E-kBanrXKrvepNvxvFrSSEEqBwTkg,4886
-pyconvexity-0.3.8.post3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyconvexity-0.3.8.post3.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
-pyconvexity-0.3.8.post3.dist-info/RECORD,,
+pyconvexity-0.3.8.post5.dist-info/METADATA,sha256=Sls9yFmzwrnujuODybzOPn5Z7s-8DoikRaHfto5sbuM,4886
+pyconvexity-0.3.8.post5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyconvexity-0.3.8.post5.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
+pyconvexity-0.3.8.post5.dist-info/RECORD,,