pyconvexity 0.4.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

pyconvexity/models/results.py

@@ -18,6 +18,7 @@ logger = logging.getLogger(__name__)
 @dataclass
 class SolveResults:
     """Represents solve results for a scenario."""
+
     network_statistics: Dict[str, Any]
     metadata: Dict[str, Any]
     status: str
@@ -28,58 +29,65 @@ class SolveResults:
 @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
+    conn: sqlite3.Connection, scenario_id: Optional[int] = None
 ) -> Optional[SolveResults]:
     """
-    Get overall solve results for a scenario.
-    
+    Get overall solve results for a scenario (single network per database).
+
     Args:
         conn: Database connection
-        network_id: Network ID
-        scenario_id: Scenario ID (uses master scenario if None)
-        
+        scenario_id: Scenario ID (NULL for base network)
+
     Returns:
         SolveResults object or None if no results found
     """
-    # Resolve scenario ID if not provided
+    # Query based on scenario_id (NULL for base network)
     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 solved_at DESC
-        LIMIT 1
-    """, (network_id, scenario_id))
-    
+        cursor = conn.execute(
+            """
+            SELECT results_json, metadata_json, solve_status, objective_value, solve_time_seconds
+            FROM network_solve_results
+            WHERE scenario_id IS NULL
+            ORDER BY solved_at DESC
+            LIMIT 1
+        """
+        )
+    else:
+        cursor = conn.execute(
+            """
+            SELECT results_json, metadata_json, solve_status, objective_value, solve_time_seconds
+            FROM network_solve_results
+            WHERE scenario_id = ?
+            ORDER BY solved_at DESC
+            LIMIT 1
+        """,
+            (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', {})
-        
+        network_statistics = results_json.get("network_statistics", {})
+
         return SolveResults(
             network_statistics=network_statistics,
             metadata=metadata_json,
-            status=row[2] or 'unknown',
+            status=row[2] or "unknown",
             objective_value=row[3],
-            solve_time=row[4] or 0.0
+            solve_time=row[4] or 0.0,
         )
     except json.JSONDecodeError as e:
         logger.error(f"Error parsing JSON for scenario {scenario_id}: {e}")
@@ -87,52 +95,54 @@ def get_solve_results(
 
 
 def get_yearly_results(
-    conn: sqlite3.Connection,
-    network_id: int,
-    scenario_id: Optional[int] = None
+    conn: sqlite3.Connection, scenario_id: Optional[int] = None
 ) -> Dict[int, YearlyResults]:
     """
-    Get year-by-year solve results for a scenario.
-    
+    Get year-by-year solve results for a scenario (single network per database).
+
     Args:
         conn: Database connection
-        network_id: Network ID
-        scenario_id: Scenario ID (uses master scenario if None)
-        
+        scenario_id: Scenario ID (NULL for base network)
+
     Returns:
         Dictionary mapping years to YearlyResults objects
     """
-    # Resolve scenario ID if not provided
+    # Query based on scenario_id (NULL for base network)
     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))
-    
+        cursor = conn.execute(
+            """
+            SELECT year, results_json, metadata_json
+            FROM network_solve_results_by_year
+            WHERE scenario_id IS NULL
+            ORDER BY year
+        """
+        )
+    else:
+        cursor = conn.execute(
+            """
+            SELECT year, results_json, metadata_json
+            FROM network_solve_results_by_year
+            WHERE scenario_id = ?
+            ORDER BY year
+        """,
+            (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', {})
-            
+            network_statistics = results_json.get("network_statistics", {})
+
             yearly_results[year] = YearlyResults(
-                year=year,
-                network_statistics=network_statistics,
-                metadata=metadata_json
+                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
 
+    return yearly_results

pyconvexity/models/scenarios.py

@@ -16,145 +16,115 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class Scenario:
-    """Represents a scenario in the network."""
+    """Represents a scenario (single network per database)."""
+
     id: int
-    network_id: int
     name: str
     description: Optional[str]
-    is_master: bool
+    probability: Optional[float]  # For stochastic optimization
     created_at: str
 
 
-def list_scenarios(conn: sqlite3.Connection, network_id: int) -> List[Scenario]:
+def list_scenarios(conn: sqlite3.Connection) -> List[Scenario]:
     """
-    List all scenarios for a network.
-    
+    List all scenarios (single network per database).
+
     Args:
         conn: Database connection
-        network_id: Network ID
-        
+
     Returns:
-        List of Scenario objects ordered by master first, then by creation date
+        List of Scenario objects ordered by creation date
     """
-    cursor = conn.execute("""
-        SELECT id, network_id, name, description, is_master, created_at
+    cursor = conn.execute(
+        """
+        SELECT id, name, description, probability, created_at
         FROM scenarios
-        WHERE network_id = ?
-        ORDER BY is_master DESC, created_at
-    """, (network_id,))
-    
+        ORDER BY created_at
+    """
+    )
+
     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]
-        ))
-    
+        scenarios.append(
+            Scenario(
+                id=row[0],
+                name=row[1],
+                description=row[2],
+                probability=row[3],
+                created_at=row[4],
+            )
+        )
+
     return scenarios
 
 
-def get_scenario_by_name(conn: sqlite3.Connection, network_id: int, name: str) -> Scenario:
+def get_scenario_by_name(conn: sqlite3.Connection, name: str) -> Scenario:
     """
-    Get a scenario by name.
-    
+    Get a scenario by name (single network per database).
+
     Args:
         conn: Database connection
-        network_id: Network ID
         name: Scenario name
-        
+
     Returns:
         Scenario object
-        
+
     Raises:
         ValidationError: If scenario doesn't exist
     """
-    cursor = conn.execute("""
-        SELECT id, network_id, name, description, is_master, created_at
+    cursor = conn.execute(
+        """
+        SELECT id, name, description, probability, created_at
         FROM scenarios
-        WHERE network_id = ? AND name = ?
-    """, (network_id, name))
-    
+        WHERE name = ?
+    """,
+        (name,),
+    )
+
     row = cursor.fetchone()
     if not row:
-        raise ValidationError(f"Scenario '{name}' not found for network {network_id}")
-    
+        raise ValidationError(f"Scenario '{name}' not found")
+
     return Scenario(
         id=row[0],
-        network_id=row[1],
-        name=row[2],
-        description=row[3],
-        is_master=bool(row[4]),
-        created_at=row[5]
+        name=row[1],
+        description=row[2],
+        probability=row[3],
+        created_at=row[4],
     )
 
 
 def get_scenario_by_id(conn: sqlite3.Connection, scenario_id: int) -> Scenario:
     """
     Get a scenario by ID.
-    
+
     Args:
         conn: Database connection
         scenario_id: Scenario ID
-        
+
     Returns:
         Scenario object
-        
+
     Raises:
         ValidationError: If scenario doesn't exist
     """
-    cursor = conn.execute("""
-        SELECT id, network_id, name, description, is_master, created_at
+    cursor = conn.execute(
+        """
+        SELECT id, name, description, probability, created_at
         FROM scenarios
         WHERE id = ?
-    """, (scenario_id,))
-    
-    row = cursor.fetchone()
-    if not row:
-        raise ValidationError(f"Scenario with ID {scenario_id} not found")
-    
-    return Scenario(
-        id=row[0],
-        network_id=row[1],
-        name=row[2],
-        description=row[3],
-        is_master=bool(row[4]),
-        created_at=row[5]
+    """,
+        (scenario_id,),
     )
 
-
-def get_master_scenario(conn: sqlite3.Connection, network_id: int) -> Scenario:
-    """
-    Get the master scenario for a network.
-    
-    Args:
-        conn: Database connection
-        network_id: Network ID
-        
-    Returns:
-        Scenario object for the master scenario
-        
-    Raises:
-        ValidationError: If master scenario doesn't exist
-    """
-    cursor = conn.execute("""
-        SELECT id, network_id, name, description, is_master, created_at
-        FROM scenarios
-        WHERE network_id = ? AND is_master = TRUE
-    """, (network_id,))
-    
     row = cursor.fetchone()
     if not row:
-        raise ValidationError(f"No master scenario found for network {network_id}")
-    
+        raise ValidationError(f"Scenario with ID {scenario_id} not found")
+
     return Scenario(
         id=row[0],
-        network_id=row[1],
-        name=row[2],
-        description=row[3],
-        is_master=bool(row[4]),
-        created_at=row[5]
+        name=row[1],
+        description=row[2],
+        probability=row[3],
+        created_at=row[4],
     )

pyconvexity/solvers/__init__.py

@@ -12,18 +12,18 @@ try:
         solve_pypsa_network,
         load_network_components,
         apply_constraints,
-        store_solve_results
+        store_solve_results,
     )
-    
+
     __all__ = [
         "solve_network",
-        "build_pypsa_network", 
+        "build_pypsa_network",
         "solve_pypsa_network",
         "load_network_components",
         "apply_constraints",
-        "store_solve_results"
+        "store_solve_results",
     ]
-    
+
 except ImportError:
     # PyPSA not available
     __all__ = []

pyconvexity/solvers/pypsa/__init__.py

@@ -11,14 +11,14 @@ from pyconvexity.solvers.pypsa.api import (
     solve_pypsa_network,
     load_network_components,
     apply_constraints,
-    store_solve_results
+    store_solve_results,
 )
 
 __all__ = [
     "solve_network",
     "build_pypsa_network",
-    "solve_pypsa_network", 
+    "solve_pypsa_network",
     "load_network_components",
     "apply_constraints",
-    "store_solve_results"
+    "store_solve_results",
 ]