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

pyconvexity/models/results.py

@@ -0,0 +1,138 @@
+"""
+Results and statistics operations for PyConvexity.
+
+Provides operations for querying solve results and statistics.
+"""
+
+import sqlite3
+import json
+import logging
+from typing import Dict, Any, Optional
+from dataclasses import dataclass
+
+from pyconvexity.core.errors import ValidationError
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SolveResults:
+    """Represents solve results for a scenario."""
+    network_statistics: Dict[str, Any]
+    metadata: Dict[str, Any]
+    status: str
+    objective_value: Optional[float]
+    solve_time: float
+
+
+@dataclass
+class YearlyResults:
+    """Represents yearly solve results."""
+    year: int
+    network_statistics: Dict[str, Any]
+    metadata: Dict[str, Any]
+
+
+def get_solve_results(
+    conn: sqlite3.Connection,
+    network_id: int,
+    scenario_id: Optional[int] = None
+) -> Optional[SolveResults]:
+    """
+    Get overall solve results for a scenario.
+    
+    Args:
+        conn: Database connection
+        network_id: Network ID
+        scenario_id: Scenario ID (uses master scenario if None)
+        
+    Returns:
+        SolveResults object or None if no results found
+    """
+    # Resolve scenario ID if not provided
+    if scenario_id is None:
+        from pyconvexity.models.scenarios import get_master_scenario
+        scenario = get_master_scenario(conn, network_id)
+        scenario_id = scenario.id
+    
+    cursor = conn.execute("""
+        SELECT results_json, metadata_json, solve_status, objective_value, solve_time_seconds
+        FROM network_solve_results
+        WHERE network_id = ? AND scenario_id = ?
+        ORDER BY created_at DESC
+        LIMIT 1
+    """, (network_id, scenario_id))
+    
+    row = cursor.fetchone()
+    if not row:
+        return None
+    
+    try:
+        results_json = json.loads(row[0]) if row[0] else {}
+        metadata_json = json.loads(row[1]) if row[1] else {}
+        
+        # Extract network_statistics from results_json
+        network_statistics = results_json.get('network_statistics', {})
+        
+        return SolveResults(
+            network_statistics=network_statistics,
+            metadata=metadata_json,
+            status=row[2] or 'unknown',
+            objective_value=row[3],
+            solve_time=row[4] or 0.0
+        )
+    except json.JSONDecodeError as e:
+        logger.error(f"Error parsing JSON for scenario {scenario_id}: {e}")
+        return None
+
+
+def get_yearly_results(
+    conn: sqlite3.Connection,
+    network_id: int,
+    scenario_id: Optional[int] = None
+) -> Dict[int, YearlyResults]:
+    """
+    Get year-by-year solve results for a scenario.
+    
+    Args:
+        conn: Database connection
+        network_id: Network ID
+        scenario_id: Scenario ID (uses master scenario if None)
+        
+    Returns:
+        Dictionary mapping years to YearlyResults objects
+    """
+    # Resolve scenario ID if not provided
+    if scenario_id is None:
+        from pyconvexity.models.scenarios import get_master_scenario
+        scenario = get_master_scenario(conn, network_id)
+        scenario_id = scenario.id
+    
+    cursor = conn.execute("""
+        SELECT year, results_json, metadata_json
+        FROM network_solve_results_by_year
+        WHERE network_id = ? AND scenario_id = ?
+        ORDER BY year
+    """, (network_id, scenario_id))
+    
+    yearly_results = {}
+    for row in cursor.fetchall():
+        year = row[0]
+        try:
+            results_json = json.loads(row[1]) if row[1] else {}
+            metadata_json = json.loads(row[2]) if row[2] else {}
+            
+            # Extract network_statistics from results_json
+            network_statistics = results_json.get('network_statistics', {})
+            
+            yearly_results[year] = YearlyResults(
+                year=year,
+                network_statistics=network_statistics,
+                metadata=metadata_json
+            )
+        except json.JSONDecodeError as e:
+            logger.error(f"Error parsing JSON for year {year}: {e}")
+            continue
+    
+    return yearly_results
+

pyconvexity/models/scenarios.py

@@ -1,177 +1,165 @@
 """
 Scenario management operations for PyConvexity.
 
-Provides operations for creating and managing scenarios within networks.
+Provides operations for listing, querying, and managing scenarios.
 """
 
 import sqlite3
 import logging
 from typing import List, Optional
-from datetime import datetime
+from dataclasses import dataclass
 
-from pyconvexity.core.errors import ValidationError, DatabaseError
+from pyconvexity.core.errors import ValidationError
 
 logger = logging.getLogger(__name__)
 
 
-def create_scenario(
-    conn: sqlite3.Connection,
-    network_id: int,
-    name: str,
-    description: Optional[str] = None,
-    is_master: bool = False,
-) -> int:
+@dataclass
+class Scenario:
+    """Represents a scenario in the network."""
+    id: int
+    network_id: int
+    name: str
+    description: Optional[str]
+    is_master: bool
+    created_at: str
+    updated_at: Optional[str] = None
+
+
+def list_scenarios(conn: sqlite3.Connection, network_id: int) -> List[Scenario]:
     """
-    Create a new scenario for a network.
+    List all scenarios for a network.
     
     Args:
         conn: Database connection
-        network_id: ID of the network
-        name: Name of the scenario
-        description: Optional description
-        is_master: Whether this is a master scenario (default False)
+        network_id: Network ID
         
     Returns:
-        ID of the newly created scenario
-        
-    Raises:
-        ValidationError: If network doesn't exist or scenario name conflicts
-        DatabaseError: If creation fails
+        List of Scenario objects ordered by master first, then by creation date
     """
+    cursor = conn.execute("""
+        SELECT id, network_id, name, description, is_master, created_at, updated_at
+        FROM scenarios
+        WHERE network_id = ?
+        ORDER BY is_master DESC, created_at
+    """, (network_id,))
     
-    # Validate network exists
-    cursor = conn.execute("SELECT COUNT(*) FROM networks WHERE id = ?", (network_id,))
-    if cursor.fetchone()[0] == 0:
-        raise ValidationError(f"Network with ID {network_id} not found")
-    
-    # Check for name conflicts within the network
-    cursor = conn.execute(
-        "SELECT COUNT(*) FROM scenarios WHERE network_id = ? AND name = ?",
-        (network_id, name)
-    )
-    if cursor.fetchone()[0] > 0:
-        raise ValidationError(f"Scenario with name '{name}' already exists in network {network_id}")
-    
-    # Insert the scenario (database triggers will handle master scenario uniqueness)
-    cursor = conn.execute(
-        "INSERT INTO scenarios (network_id, name, description, is_master, created_at) "
-        "VALUES (?, ?, ?, ?, datetime('now'))",
-        (network_id, name, description, is_master)
-    )
-    
-    scenario_id = cursor.lastrowid
-    if not scenario_id:
-        raise DatabaseError("Failed to create scenario")
+    scenarios = []
+    for row in cursor.fetchall():
+        scenarios.append(Scenario(
+            id=row[0],
+            network_id=row[1],
+            name=row[2],
+            description=row[3],
+            is_master=bool(row[4]),
+            created_at=row[5],
+            updated_at=row[6]
+        ))
     
-    logger.info(f"Created scenario '{name}' (ID: {scenario_id}) for network {network_id}")
-    return scenario_id
+    return scenarios
 
 
-def list_scenarios(conn: sqlite3.Connection, network_id: int) -> List[dict]:
+def get_scenario_by_name(conn: sqlite3.Connection, network_id: int, name: str) -> Scenario:
     """
-    List all scenarios for a network.
+    Get a scenario by name.
     
     Args:
         conn: Database connection
-        network_id: ID of the network
+        network_id: Network ID
+        name: Scenario name
         
     Returns:
-        List of scenario dictionaries with keys: id, network_id, name, description, is_master, created_at
+        Scenario object
         
     Raises:
-        DatabaseError: If query fails
+        ValidationError: If scenario doesn't exist
     """
+    cursor = conn.execute("""
+        SELECT id, network_id, name, description, is_master, created_at, updated_at
+        FROM scenarios
+        WHERE network_id = ? AND name = ?
+    """, (network_id, name))
     
-    cursor = conn.execute(
-        "SELECT id, network_id, name, description, is_master, created_at "
-        "FROM scenarios "
-        "WHERE network_id = ? "
-        "ORDER BY is_master DESC, created_at ASC",
-        (network_id,)
+    row = cursor.fetchone()
+    if not row:
+        raise ValidationError(f"Scenario '{name}' not found for network {network_id}")
+    
+    return Scenario(
+        id=row[0],
+        network_id=row[1],
+        name=row[2],
+        description=row[3],
+        is_master=bool(row[4]),
+        created_at=row[5],
+        updated_at=row[6]
     )
-    
-    scenarios = []
-    for row in cursor.fetchall():
-        scenarios.append({
-            'id': row[0],
-            'network_id': row[1],
-            'name': row[2],
-            'description': row[3],
-            'is_master': bool(row[4]),
-            'created_at': row[5],
-        })
-    
-    logger.debug(f"Found {len(scenarios)} scenarios for network {network_id}")
-    return scenarios
 
 
-def get_scenario(conn: sqlite3.Connection, scenario_id: int) -> dict:
+def get_scenario_by_id(conn: sqlite3.Connection, scenario_id: int) -> Scenario:
     """
-    Get a specific scenario by ID.
+    Get a scenario by ID.
     
     Args:
         conn: Database connection
-        scenario_id: ID of the scenario
+        scenario_id: Scenario ID
         
     Returns:
-        Scenario dictionary with keys: id, network_id, name, description, is_master, created_at
+        Scenario object
         
     Raises:
-        ValidationError: If scenario not found
-        DatabaseError: If query fails
+        ValidationError: If scenario doesn't exist
     """
-    
-    cursor = conn.execute(
-        "SELECT id, network_id, name, description, is_master, created_at "
-        "FROM scenarios "
-        "WHERE id = ?",
-        (scenario_id,)
-    )
+    cursor = conn.execute("""
+        SELECT id, network_id, name, description, is_master, created_at, updated_at
+        FROM scenarios
+        WHERE id = ?
+    """, (scenario_id,))
     
     row = cursor.fetchone()
     if not row:
         raise ValidationError(f"Scenario with ID {scenario_id} not found")
     
-    return {
-        'id': row[0],
-        'network_id': row[1],
-        'name': row[2],
-        'description': row[3],
-        'is_master': bool(row[4]),
-        'created_at': row[5],
-    }
+    return Scenario(
+        id=row[0],
+        network_id=row[1],
+        name=row[2],
+        description=row[3],
+        is_master=bool(row[4]),
+        created_at=row[5],
+        updated_at=row[6]
+    )
 
 
-def delete_scenario(conn: sqlite3.Connection, scenario_id: int) -> None:
+def get_master_scenario(conn: sqlite3.Connection, network_id: int) -> Scenario:
     """
-    Delete a scenario (cannot delete master scenarios).
+    Get the master scenario for a network.
     
     Args:
         conn: Database connection
-        scenario_id: ID of the scenario to delete
+        network_id: Network ID
+        
+    Returns:
+        Scenario object for the master scenario
         
     Raises:
-        ValidationError: If scenario not found or is master scenario
-        DatabaseError: If deletion fails
+        ValidationError: If master scenario doesn't exist
     """
-    
-    # Check if scenario exists and is not master
-    cursor = conn.execute(
-        "SELECT is_master FROM scenarios WHERE id = ?",
-        (scenario_id,)
-    )
+    cursor = conn.execute("""
+        SELECT id, network_id, name, description, is_master, created_at, updated_at
+        FROM scenarios
+        WHERE network_id = ? AND is_master = TRUE
+    """, (network_id,))
     
     row = cursor.fetchone()
     if not row:
-        raise ValidationError(f"Scenario with ID {scenario_id} not found")
-    
-    if row[0]:  # is_master
-        raise ValidationError("Cannot delete master scenario")
-    
-    # Delete the scenario (this will cascade to delete related component attributes)
-    cursor = conn.execute("DELETE FROM scenarios WHERE id = ?", (scenario_id,))
-    
-    if cursor.rowcount == 0:
-        raise DatabaseError("Failed to delete scenario")
-    
-    logger.info(f"Deleted scenario {scenario_id}")
+        raise ValidationError(f"No master scenario found for network {network_id}")
+    
+    return Scenario(
+        id=row[0],
+        network_id=row[1],
+        name=row[2],
+        description=row[3],
+        is_master=bool(row[4]),
+        created_at=row[5],
+        updated_at=row[6]
+    )

pyconvexity/solvers/pypsa/api.py

@@ -25,7 +25,8 @@ def solve_network(
     constraints_dsl: Optional[str] = None,
     discount_rate: Optional[float] = None,
     progress_callback: Optional[Callable[[int, str], None]] = None,
-    return_detailed_results: bool = True
+    return_detailed_results: bool = True,
+    custom_solver_config: Optional[Dict[str, Any]] = None
 ) -> Dict[str, Any]:
     """
     Complete solve workflow: build PyPSA network from database, solve, store results.
@@ -38,12 +39,15 @@ def solve_network(
         db_path: Path to the database file
         network_id: ID of the network to solve
         scenario_id: Optional scenario ID (uses master scenario if None)
-        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
         constraints_dsl: Optional DSL constraints to apply
         discount_rate: Optional discount rate for multi-period optimization
         progress_callback: Optional callback for progress updates (progress: int, message: str)
         return_detailed_results: If True, return comprehensive results; if False, return simple status
+        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 - comprehensive if return_detailed_results=True, simple status otherwise
@@ -64,7 +68,9 @@ def solve_network(
             progress_callback(8, "Loaded network configuration")
         
         # Use configuration values with parameter overrides
-        effective_discount_rate = discount_rate if discount_rate is not None else network_config.get('discount_rate', 0.05)
+        # Note: network_config already has default of 0.0 from get_network_config()
+        effective_discount_rate = discount_rate if discount_rate is not None else network_config.get('discount_rate')
+        logger.info(f"Using discount rate: {effective_discount_rate} (from {'parameter override' if discount_rate is not None else 'network config'})")
         
         # Build network
         if progress_callback:
@@ -76,10 +82,18 @@ def solve_network(
         if progress_callback:
             progress_callback(50, f"Network built: {len(network.buses)} buses, {len(network.generators)} generators")
         
-        # Create constraint applicator (constraints will be applied during solve via extra_functionality)
+        # Create constraint applicator and apply constraints BEFORE solve
         constraint_applicator = ConstraintApplicator()
         
-        # Solve network (constraints are applied during optimization)
+        # Apply constraints before solving (network modifications like GlobalConstraints)
+        if progress_callback:
+            progress_callback(60, "Applying constraints...")
+        
+        constraint_applicator.apply_constraints(
+            conn, network_id, network, scenario_id, constraints_dsl
+        )
+        
+        # Solve network
         if progress_callback:
             progress_callback(70, f"Solving with {solver_name}...")
             
@@ -92,7 +106,8 @@ def solve_network(
             conn=conn,
             network_id=network_id,
             scenario_id=scenario_id,
-            constraint_applicator=constraint_applicator
+            constraint_applicator=constraint_applicator,
+            custom_solver_config=custom_solver_config
         )
         
         if progress_callback:
@@ -192,8 +207,10 @@ def solve_pypsa_network(
     scenario_id: Optional[int] = None,
     solver_name: str = "highs",
     solver_options: Optional[Dict[str, Any]] = None,
+    discount_rate: Optional[float] = None,
     store_results: bool = True,
-    progress_callback: Optional[Callable[[int, str], None]] = None
+    progress_callback: Optional[Callable[[int, str], None]] = None,
+    custom_solver_config: Optional[Dict[str, Any]] = None
 ) -> Dict[str, Any]:
     """
     Solve PyPSA network and optionally store results back to database.
@@ -206,10 +223,13 @@ def solve_pypsa_network(
         db_path: Path to the database file (needed for result storage)
         network_id: ID of the network (for result storage)
         scenario_id: Optional scenario ID
-        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 (default: 0.0)
         store_results: Whether to store results back to database (default: True)
         progress_callback: Optional callback for progress updates
+        custom_solver_config: Optional custom solver configuration when solver_name="custom"
+            Format: {"solver": "actual_solver_name", "solver_options": {...}}
         
     Returns:
         Dictionary with solve results and statistics
@@ -226,7 +246,9 @@ def solve_pypsa_network(
     solve_result = solver.solve_network(
         network,
         solver_name=solver_name,
-        solver_options=solver_options
+        solver_options=solver_options,
+        discount_rate=discount_rate,
+        custom_solver_config=custom_solver_config
     )
     
     if progress_callback:

pyconvexity/solvers/pypsa/constraints.py

@@ -169,7 +169,8 @@ class ConstraintApplicator:
             
             logger.info(f"Constraint breakdown: {len(model_constraints)} model constraints, {len(network_constraints)} network constraints")
             
-            # Apply network constraints first (they modify the network structure)
+            # Apply network constraints ONLY (they modify the network structure before solve)
+            # Model constraints will be applied later by the solver via extra_functionality
             if network_constraints:
                 network_constraints.sort(key=lambda x: x['priority'])
                 for constraint in network_constraints:
@@ -193,88 +194,14 @@ class ConstraintApplicator:
                         # Continue with other constraints instead of failing the entire solve
                         continue
             
-            # Apply model constraints (they need access to the optimization model)
+            # Skip model constraints here - they will be applied by the solver during optimization
+            # via extra_functionality to ensure they have access to the actual optimization model
             if model_constraints:
-                self._apply_model_constraints(network, model_constraints)
+                logger.info(f"Skipping {len(model_constraints)} model constraints - will be applied during solve")
                 
         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")
-            
-            # Sort constraints by priority
-            sorted_constraints = sorted(model_constraints, key=lambda x: x['priority'])
-            
-            # Apply each model constraint
-            for constraint in sorted_constraints:
-                try:
-                    constraint_code = constraint['constraint_code']
-                    constraint_name = constraint['name']
-                    
-                    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)
-                    logger.info(f"Successfully applied model constraint '{constraint_name}'")
-                    
-                except Exception as 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
-                    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 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):
         """
         Apply DSL constraints to the network.