pyconvexity 0.3.8.post4__py3-none-any.whl → 0.3.8.post6__py3-none-any.whl

pyconvexity/_version.py

@@ -1 +1 @@
-__version__ = "0.3.8post4"
+__version__ = "0.3.8post6"

pyconvexity/data/schema/01_core_schema.sql

@@ -361,6 +361,57 @@ BEGIN
     WHERE id = NEW.component_id;
 END;
 
+-- ============================================================================
+-- COMPONENT GEOMETRIES - Optional GeoJSON geometries for spatial representation
+-- ============================================================================
+
+-- Component geometries - stores optional GeoJSON geometries for components
+-- Enables real spatial representation (e.g., actual line routes, generator footprints)
+CREATE TABLE component_geometries (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    component_id INTEGER NOT NULL UNIQUE,
+    
+    -- GeoJSON geometry stored as JSON text
+    -- Supports: Point, LineString, Polygon, MultiPolygon, MultiPoint, MultiLineString, GeometryCollection
+    geometry TEXT NOT NULL,
+    
+    -- Cache the geometry type for faster queries and validation
+    geometry_type TEXT NOT NULL CHECK (geometry_type IN (
+        'Point', 'LineString', 'Polygon', 'MultiPolygon', 
+        'MultiPoint', 'MultiLineString', 'GeometryCollection'
+    )),
+    
+    -- Cache bounding box for spatial indexing and quick filtering
+    bbox_min_lng REAL,
+    bbox_min_lat REAL,
+    bbox_max_lng REAL,
+    bbox_max_lat REAL,
+    
+    -- Metadata
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    
+    CONSTRAINT fk_geometry_component 
+        FOREIGN KEY (component_id) REFERENCES components(id) ON DELETE CASCADE
+);
+
+-- Indexes for efficient geometry queries
+CREATE INDEX idx_component_geometries_component ON component_geometries(component_id);
+CREATE INDEX idx_component_geometries_type ON component_geometries(geometry_type);
+CREATE INDEX idx_component_geometries_bbox ON component_geometries(
+    bbox_min_lng, bbox_min_lat, bbox_max_lng, bbox_max_lat
+);
+
+-- Trigger to update timestamp on geometry changes
+CREATE TRIGGER update_component_geometries_timestamp
+    BEFORE UPDATE ON component_geometries
+    FOR EACH ROW
+BEGIN
+    UPDATE component_geometries 
+    SET updated_at = CURRENT_TIMESTAMP 
+    WHERE id = NEW.id;
+END;
+
 -- ============================================================================
 -- NETWORK CONFIGURATION
 -- ============================================================================

pyconvexity/data/schema/migrate_add_geometries.sql

@@ -0,0 +1,73 @@
+-- ============================================================================
+-- MIGRATION: Add Component Geometries Support
+-- Adds the component_geometries table to existing databases
+-- This migration is safe and backwards compatible - existing functionality is unchanged
+-- ============================================================================
+
+-- Check if the table already exists before creating
+CREATE TABLE IF NOT EXISTS component_geometries (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    component_id INTEGER NOT NULL UNIQUE,
+    
+    -- GeoJSON geometry stored as JSON text
+    -- Supports: Point, LineString, Polygon, MultiPolygon, MultiPoint, MultiLineString, GeometryCollection
+    geometry TEXT NOT NULL,
+    
+    -- Cache the geometry type for faster queries and validation
+    geometry_type TEXT NOT NULL CHECK (geometry_type IN (
+        'Point', 'LineString', 'Polygon', 'MultiPolygon', 
+        'MultiPoint', 'MultiLineString', 'GeometryCollection'
+    )),
+    
+    -- Cache bounding box for spatial indexing and quick filtering
+    bbox_min_lng REAL,
+    bbox_min_lat REAL,
+    bbox_max_lng REAL,
+    bbox_max_lat REAL,
+    
+    -- Metadata
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    
+    CONSTRAINT fk_geometry_component 
+        FOREIGN KEY (component_id) REFERENCES components(id) ON DELETE CASCADE
+);
+
+-- Create indexes if they don't exist
+CREATE INDEX IF NOT EXISTS idx_component_geometries_component 
+    ON component_geometries(component_id);
+
+CREATE INDEX IF NOT EXISTS idx_component_geometries_type 
+    ON component_geometries(geometry_type);
+
+CREATE INDEX IF NOT EXISTS idx_component_geometries_bbox 
+    ON component_geometries(bbox_min_lng, bbox_min_lat, bbox_max_lng, bbox_max_lat);
+
+-- Create trigger for automatic timestamp updates
+DROP TRIGGER IF EXISTS update_component_geometries_timestamp;
+
+CREATE TRIGGER update_component_geometries_timestamp
+    BEFORE UPDATE ON component_geometries
+    FOR EACH ROW
+BEGIN
+    UPDATE component_geometries 
+    SET updated_at = CURRENT_TIMESTAMP 
+    WHERE id = NEW.id;
+END;
+
+-- Update schema version
+UPDATE system_metadata 
+SET value = '2.5.0', 
+    updated_at = CURRENT_TIMESTAMP,
+    description = 'Database schema version - Added component_geometries table'
+WHERE key = 'schema_version';
+
+-- Add metadata about the migration
+INSERT OR REPLACE INTO system_metadata (key, value, description) 
+VALUES ('geometries_migration_applied', datetime('now'), 'Timestamp when component geometries migration was applied');
+
+-- Verify the migration
+SELECT 
+    'Migration completed successfully!' as message,
+    COUNT(*) as existing_geometries
+FROM component_geometries;

pyconvexity/models/__init__.py

@@ -7,7 +7,8 @@ Contains high-level operations for networks, components, and attributes.
 from pyconvexity.models.components import (
     get_component_type, get_component, list_components_by_type,
     insert_component, create_component, update_component, delete_component,
-    list_component_attributes, get_default_carrier_id, get_bus_name_to_id_map
+    list_component_attributes, get_default_carrier_id, get_bus_name_to_id_map,
+    get_component_by_name, get_component_id, component_exists, get_component_carrier_map
 )
 
 from pyconvexity.models.attributes import (
@@ -17,18 +18,50 @@ from pyconvexity.models.attributes import (
 from pyconvexity.models.network import (
     create_network, get_network_info, get_network_time_periods, list_networks,
     create_carrier, list_carriers, get_network_config, set_network_config,
-    get_component_counts, get_master_scenario_id, resolve_scenario_id
+    get_component_counts, get_master_scenario_id, resolve_scenario_id,
+    get_first_network, get_network_by_name
 )
 
+# Import from new modules
 from pyconvexity.models.scenarios import (
-    create_scenario, list_scenarios, get_scenario, delete_scenario
+    list_scenarios as list_scenarios_new,
+    get_scenario_by_name, get_scenario_by_id, get_master_scenario
 )
 
+from pyconvexity.models.results import (
+    get_solve_results, get_yearly_results
+)
+
+from pyconvexity.models.carriers import (
+    list_carriers as list_carriers_new,
+    get_carrier_by_name, get_carrier_by_id, get_carrier_colors
+)
+
+# Try to import old scenarios functions if they exist
+try:
+    from pyconvexity.models.scenarios_old import (
+        create_scenario, list_scenarios as list_scenarios_old, 
+        get_scenario, delete_scenario
+    )
+    # Use old functions as primary for backward compatibility
+    list_scenarios_primary = list_scenarios_old
+except ImportError:
+    # Old module doesn't exist, use new functions
+    list_scenarios_primary = list_scenarios_new
+    # Create dummy functions for backward compatibility
+    def create_scenario(*args, **kwargs):
+        raise NotImplementedError("create_scenario not yet implemented in new API")
+    def get_scenario(*args, **kwargs):
+        return get_scenario_by_id(*args, **kwargs)
+    def delete_scenario(*args, **kwargs):
+        raise NotImplementedError("delete_scenario not yet implemented in new API")
+
 __all__ = [
     # Component operations
     "get_component_type", "get_component", "list_components_by_type",
     "insert_component", "create_component", "update_component", "delete_component",
     "list_component_attributes", "get_default_carrier_id", "get_bus_name_to_id_map",
+    "get_component_by_name", "get_component_id", "component_exists", "get_component_carrier_map",
     
     # Attribute operations
     "set_static_attribute", "set_timeseries_attribute", "get_attribute", "delete_attribute",
@@ -37,7 +70,18 @@ __all__ = [
     "create_network", "get_network_info", "get_network_time_periods", "list_networks",
     "create_carrier", "list_carriers", "get_network_config", "set_network_config",
     "get_component_counts", "get_master_scenario_id", "resolve_scenario_id",
+    "get_first_network", "get_network_by_name",
+    
+    # Scenario operations (backward compatible)
+    "create_scenario", "list_scenarios_primary", "get_scenario", "delete_scenario",
+    "list_scenarios_new", "get_scenario_by_name", "get_scenario_by_id", "get_master_scenario",
     
-    # Scenario operations
-    "create_scenario", "list_scenarios", "get_scenario", "delete_scenario",
+    # Results operations
+    "get_solve_results", "get_yearly_results",
+    
+    # Carrier operations
+    "list_carriers_new", "get_carrier_by_name", "get_carrier_by_id", "get_carrier_colors",
 ]
+
+# Expose primary list_scenarios for convenience
+list_scenarios = list_scenarios_primary

pyconvexity/models/carriers.py

@@ -0,0 +1,156 @@
+"""
+Carrier management operations for PyConvexity.
+
+Provides operations for querying carriers and their properties.
+"""
+
+import sqlite3
+import logging
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+
+from pyconvexity.core.errors import ValidationError
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Carrier:
+    """Represents an energy carrier in the network."""
+    id: int
+    network_id: int
+    name: str
+    co2_emissions: float
+    color: Optional[str]
+    nice_name: Optional[str]
+
+
+def list_carriers(conn: sqlite3.Connection, network_id: int) -> List[Carrier]:
+    """
+    List all carriers for a network.
+    
+    Args:
+        conn: Database connection
+        network_id: Network ID
+        
+    Returns:
+        List of Carrier objects ordered by name
+    """
+    cursor = conn.execute("""
+        SELECT id, network_id, name, co2_emissions, color, nice_name
+        FROM carriers
+        WHERE network_id = ?
+        ORDER BY name
+    """, (network_id,))
+    
+    carriers = []
+    for row in cursor.fetchall():
+        carriers.append(Carrier(
+            id=row[0],
+            network_id=row[1],
+            name=row[2],
+            co2_emissions=row[3] or 0.0,
+            color=row[4],
+            nice_name=row[5]
+        ))
+    
+    return carriers
+
+
+def get_carrier_by_name(conn: sqlite3.Connection, network_id: int, name: str) -> Carrier:
+    """
+    Get a carrier by name.
+    
+    Args:
+        conn: Database connection
+        network_id: Network ID
+        name: Carrier name
+        
+    Returns:
+        Carrier object
+        
+    Raises:
+        ValidationError: If carrier doesn't exist
+    """
+    cursor = conn.execute("""
+        SELECT id, network_id, name, co2_emissions, color, nice_name
+        FROM carriers
+        WHERE network_id = ? AND name = ?
+    """, (network_id, name))
+    
+    row = cursor.fetchone()
+    if not row:
+        raise ValidationError(f"Carrier '{name}' not found for network {network_id}")
+    
+    return Carrier(
+        id=row[0],
+        network_id=row[1],
+        name=row[2],
+        co2_emissions=row[3] or 0.0,
+        color=row[4],
+        nice_name=row[5]
+    )
+
+
+def get_carrier_by_id(conn: sqlite3.Connection, carrier_id: int) -> Carrier:
+    """
+    Get a carrier by ID.
+    
+    Args:
+        conn: Database connection
+        carrier_id: Carrier ID
+        
+    Returns:
+        Carrier object
+        
+    Raises:
+        ValidationError: If carrier doesn't exist
+    """
+    cursor = conn.execute("""
+        SELECT id, network_id, name, co2_emissions, color, nice_name
+        FROM carriers
+        WHERE id = ?
+    """, (carrier_id,))
+    
+    row = cursor.fetchone()
+    if not row:
+        raise ValidationError(f"Carrier with ID {carrier_id} not found")
+    
+    return Carrier(
+        id=row[0],
+        network_id=row[1],
+        name=row[2],
+        co2_emissions=row[3] or 0.0,
+        color=row[4],
+        nice_name=row[5]
+    )
+
+
+def get_carrier_colors(conn: sqlite3.Connection, network_id: int) -> Dict[str, str]:
+    """
+    Get carrier colors for visualization.
+    
+    Args:
+        conn: Database connection
+        network_id: Network ID
+        
+    Returns:
+        Dictionary mapping carrier names to color strings
+    """
+    cursor = conn.execute("""
+        SELECT name, color
+        FROM carriers
+        WHERE network_id = ?
+    """, (network_id,))
+    
+    colors = {}
+    for row in cursor.fetchall():
+        if row[1]:  # Only include if color is defined
+            colors[row[0]] = row[1]
+    
+    # Add default color for Unmet Load if not present
+    if 'Unmet Load' not in colors:
+        colors['Unmet Load'] = '#FF0000'
+    
+    return colors
+

pyconvexity/models/components.py

@@ -364,6 +364,126 @@ def list_component_attributes(
     return [row[0] for row in cursor.fetchall()]
 
 
+def get_component_by_name(conn: sqlite3.Connection, network_id: int, name: str) -> Component:
+    """
+    Get a component by name.
+    
+    Args:
+        conn: Database connection
+        network_id: Network ID
+        name: Component name
+        
+    Returns:
+        Component object
+        
+    Raises:
+        ComponentNotFound: If component doesn't exist
+    """
+    cursor = conn.execute("""
+        SELECT id, network_id, component_type, name, longitude, latitude, 
+               carrier_id, bus_id, bus0_id, bus1_id
+        FROM components 
+        WHERE network_id = ? AND name = ?
+    """, (network_id, name))
+    
+    row = cursor.fetchone()
+    if not row:
+        raise ComponentNotFound(f"Component '{name}' not found in network {network_id}")
+    
+    return Component(
+        id=row[0],
+        network_id=row[1],
+        component_type=row[2],
+        name=row[3],
+        longitude=row[4],
+        latitude=row[5],
+        carrier_id=row[6],
+        bus_id=row[7],
+        bus0_id=row[8],
+        bus1_id=row[9]
+    )
+
+
+def get_component_id(conn: sqlite3.Connection, network_id: int, name: str) -> int:
+    """
+    Get component ID by name.
+    
+    Args:
+        conn: Database connection
+        network_id: Network ID
+        name: Component name
+        
+    Returns:
+        Component ID
+        
+    Raises:
+        ComponentNotFound: If component doesn't exist
+    """
+    component = get_component_by_name(conn, network_id, name)
+    return component.id
+
+
+def component_exists(conn: sqlite3.Connection, network_id: int, name: str) -> bool:
+    """
+    Check if a component exists.
+    
+    Args:
+        conn: Database connection
+        network_id: Network ID
+        name: Component name
+        
+    Returns:
+        True if component exists, False otherwise
+    """
+    cursor = conn.execute("""
+        SELECT 1 FROM components WHERE network_id = ? AND name = ?
+    """, (network_id, name))
+    
+    return cursor.fetchone() is not None
+
+
+def get_component_carrier_map(
+    conn: sqlite3.Connection, 
+    network_id: int, 
+    component_type: Optional[str] = None
+) -> Dict[str, str]:
+    """
+    Get mapping from component names to carrier names.
+    
+    Args:
+        conn: Database connection
+        network_id: Network ID
+        component_type: Optional component type filter
+        
+    Returns:
+        Dictionary mapping component names to carrier names
+    """
+    if component_type:
+        cursor = conn.execute("""
+            SELECT c.name,
+                   CASE 
+                       WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
+                       ELSE carr.name
+                   END as carrier_name
+            FROM components c
+            LEFT JOIN carriers carr ON c.carrier_id = carr.id
+            WHERE c.network_id = ? AND c.component_type = ?
+        """, (network_id, component_type.upper()))
+    else:
+        cursor = conn.execute("""
+            SELECT c.name,
+                   CASE 
+                       WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
+                       ELSE carr.name
+                   END as carrier_name
+            FROM components c
+            LEFT JOIN carriers carr ON c.carrier_id = carr.id
+            WHERE c.network_id = ?
+        """, (network_id,))
+    
+    return {row[0]: row[1] for row in cursor.fetchall()}
+
+
 # Helper functions
 
 def get_default_carrier_id(

pyconvexity/models/network.py

@@ -176,6 +176,72 @@ def list_networks(conn: sqlite3.Connection) -> List[Dict[str, Any]]:
     return networks
 
 
+def get_first_network(conn: sqlite3.Connection) -> Optional[Dict[str, Any]]:
+    """
+    Get the first network (useful for single-network databases).
+    
+    Args:
+        conn: Database connection
+        
+    Returns:
+        Network dictionary or None if no networks exist
+    """
+    cursor = conn.execute("""
+        SELECT id, name, description, created_at, updated_at, time_interval, time_start, time_end 
+        FROM networks 
+        ORDER BY created_at DESC
+        LIMIT 1
+    """)
+    
+    row = cursor.fetchone()
+    if not row:
+        return None
+    
+    return {
+        "id": row[0],
+        "name": row[1],
+        "description": row[2],
+        "created_at": row[3],
+        "updated_at": row[4],
+        "time_resolution": row[5],
+        "start_time": row[6],
+        "end_time": row[7],
+    }
+
+
+def get_network_by_name(conn: sqlite3.Connection, name: str) -> Optional[Dict[str, Any]]:
+    """
+    Get a network by name.
+    
+    Args:
+        conn: Database connection
+        name: Network name
+        
+    Returns:
+        Network dictionary or None if not found
+    """
+    cursor = conn.execute("""
+        SELECT id, name, description, created_at, updated_at, time_interval, time_start, time_end 
+        FROM networks 
+        WHERE name = ?
+    """, (name,))
+    
+    row = cursor.fetchone()
+    if not row:
+        return None
+    
+    return {
+        "id": row[0],
+        "name": row[1],
+        "description": row[2],
+        "created_at": row[3],
+        "updated_at": row[4],
+        "time_resolution": row[5],
+        "start_time": row[6],
+        "end_time": row[7],
+    }
+
+
 def create_carrier(
     conn: sqlite3.Connection, 
     network_id: int, 
@@ -309,7 +375,7 @@ def get_network_config(
     # Apply system defaults for missing parameters
     defaults = {
         'unmet_load_active': True,
-        'discount_rate': 0.01,
+        'discount_rate': 0.0,  # No discounting by default
         'solver_name': 'default'
     }
     

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 solved_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,160 @@
 """
 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
+
+
+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
+        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]
+        ))
     
-    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
+        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]
     )
-    
-    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
+        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]
+    )
 
 
-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
+        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]
+    )

pyconvexity/solvers/pypsa/api.py

@@ -68,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:
@@ -205,6 +207,7 @@ 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,
     custom_solver_config: Optional[Dict[str, Any]] = None
@@ -222,6 +225,7 @@ def solve_pypsa_network(
         scenario_id: Optional scenario ID
         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"
@@ -243,6 +247,7 @@ def solve_pypsa_network(
         network,
         solver_name=solver_name,
         solver_options=solver_options,
+        discount_rate=discount_rate,
         custom_solver_config=custom_solver_config
     )
     

pyconvexity/solvers/pypsa/solver.py

@@ -133,12 +133,14 @@ class NetworkSolver:
             # Get solver configuration
             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)
@@ -402,17 +404,7 @@ class NetworkSolver:
             mosek_default_options = {
                 'solver_options': {
                     'MSK_DPAR_MIO_REL_GAP_CONST': 0.05,       # MIP relative gap tolerance (5% to match Gurobi)
-                    'MSK_IPAR_MIO_MAX_TIME': 3600,            # Max time 1 hour
-                    # Safe MIP performance improvements
-                    'MSK_IPAR_MIO_HEURISTIC_LEVEL': 2,        # Moderate heuristics (safe, helps find good solutions faster)
-                    'MSK_IPAR_MIO_SYMMETRY_LEVEL': 2,         # Moderate symmetry detection (safe, can dramatically speed up symmetric problems)
-                    'MSK_IPAR_MIO_PRESOLVE_AGGREGATOR_USE': 1, # MIP presolve aggregator (safe, helps reduce problem size)
-                    # Logging
-                    'MSK_IPAR_LOG': 4,                        # Moderate logging (was 10)
-                    'MSK_IPAR_LOG_INTPNT': 1,                 # Log interior-point progress
-                    'MSK_IPAR_LOG_SIM': 4,                    # Log simplex progress
-                    'MSK_IPAR_LOG_MIO': 2,                    # Reduced MIP logging (was 4)
-                    'MSK_IPAR_LOG_MIO_FREQ': 10,              # Log MIP every 10 seconds
+                    'MSK_IPAR_MIO_MAX_TIME': 36000,            # Max time 1 hour
                 }
             }
             if solver_options:
@@ -434,16 +426,7 @@ class NetworkSolver:
                     '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
-                    # Safe MIP performance improvements
-                    'MSK_IPAR_MIO_HEURISTIC_LEVEL': 4,        # Aggressive heuristics (was 2, match Gurobi's aggressive approach)
-                    'MSK_IPAR_MIO_SYMMETRY_LEVEL': 2,         # Moderate symmetry detection
-                    'MSK_IPAR_MIO_PRESOLVE_AGGREGATOR_USE': 1, # MIP presolve aggregator
-                    'MSK_DPAR_MIO_MAX_TIME': 3600,            # Max time 1 hour
-                    # Logging
-                    'MSK_IPAR_LOG': 4,                        # Moderate logging
-                    'MSK_IPAR_LOG_INTPNT': 1,                 # Log interior-point progress
-                    'MSK_IPAR_LOG_MIO': 2,                    # Reduced MIP logging
-                    'MSK_IPAR_LOG_MIO_FREQ': 10,              # Log MIP every 10 seconds
+                    'MSK_DPAR_MIO_MAX_TIME': 36000,            # Max time 10 hour
                 }
             }
             if solver_options:
@@ -459,22 +442,9 @@ class NetworkSolver:
                     '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_IPAR_PRESOLVE_USE': 1,               # Force presolve
-                    'MSK_IPAR_PRESOLVE_LINDEP_USE': 1,        # Linear dependency check
                     'MSK_DPAR_MIO_REL_GAP_CONST': 0.05,       # Match Gurobi 5% MIP gap (was 1e-6)
-                    'MSK_IPAR_MIO_NODE_OPTIMIZER': 4,         # Use interior-point for MIP nodes
                     'MSK_IPAR_MIO_ROOT_OPTIMIZER': 4,         # Use interior-point for MIP root
-                    # Safe MIP performance improvements
-                    'MSK_IPAR_MIO_HEURISTIC_LEVEL': 2,        # Moderate heuristics (safe, helps find good solutions faster)
-                    'MSK_IPAR_MIO_SYMMETRY_LEVEL': 2,         # Moderate symmetry detection (safe, can dramatically speed up symmetric problems)
-                    'MSK_IPAR_MIO_PRESOLVE_AGGREGATOR_USE': 1, # MIP presolve aggregator (safe, helps reduce problem size)
-                    'MSK_DPAR_MIO_MAX_TIME': 3600,            # Max time 1 hour (safety limit)
-                    # Logging
-                    'MSK_IPAR_LOG': 4,                        # Moderate logging (was 10)
-                    'MSK_IPAR_LOG_INTPNT': 1,                 # Log interior-point progress
-                    'MSK_IPAR_LOG_MIO': 2,                    # Reduced MIP logging (was 4)
-                    '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:
@@ -487,21 +457,11 @@ 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': 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
-                    # Safe MIP performance improvements
-                    'MSK_IPAR_MIO_HEURISTIC_LEVEL': 2,        # Moderate heuristics (safe, helps find good solutions faster)
-                    'MSK_IPAR_MIO_SYMMETRY_LEVEL': 2,         # Moderate symmetry detection (safe, can dramatically speed up symmetric problems)
-                    'MSK_IPAR_MIO_PRESOLVE_AGGREGATOR_USE': 1, # MIP presolve aggregator (safe, helps reduce problem size)
-                    'MSK_DPAR_MIO_MAX_TIME': 3600,            # Max time 1 hour (safety limit)
-                    # Logging
-                    'MSK_IPAR_LOG': 4,                        # Moderate logging (was 10)
-                    'MSK_IPAR_LOG_SIM': 4,                    # Log simplex progress
-                    'MSK_IPAR_LOG_MIO': 2,                    # Reduced MIP logging (was 4)
-                    '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:
@@ -515,18 +475,8 @@ class NetworkSolver:
             mosek_defaults = {
                 'solver_options': {
                     'MSK_DPAR_MIO_REL_GAP_CONST': 0.05,       # Match Gurobi 5% MIP gap (was 1e-4)
-                    'MSK_IPAR_MIO_MAX_TIME': 3600,            # Max time 1 hour
+                    'MSK_IPAR_MIO_MAX_TIME': 36000,            # Max time 1 hour
                     'MSK_IPAR_NUM_THREADS': 0,                # Use all cores (0 = auto)
-                    # CRITICAL: Use interior-point for MIP (much faster than simplex)
-                    '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)
-                    # Safe MIP performance improvements
-                    'MSK_IPAR_MIO_HEURISTIC_LEVEL': 2,        # Moderate heuristics (safe, helps find good solutions faster)
-                    'MSK_IPAR_MIO_SYMMETRY_LEVEL': 2,         # Moderate symmetry detection (safe, can dramatically speed up symmetric problems)
-                    'MSK_IPAR_MIO_PRESOLVE_AGGREGATOR_USE': 1, # MIP presolve aggregator (safe, helps reduce problem size)
-                    # Logging
-                    'MSK_IPAR_LOG': 4,                        # Moderate logging
-                    'MSK_IPAR_LOG_MIO': 2,                    # Log MIP occasionally
                 }
             }
             if solver_options:
@@ -556,8 +506,8 @@ class NetworkSolver:
                     'LpMethod': 2,              # Barrier method
                     'Crossover': 0,             # Skip crossover for speed
                     'RelGap': 0.05,             # 5% MIP gap (match Gurobi)
-                    'TimeLimit': 3600,          # 1 hour time limit
-                    'Threads': 2,               # 4 threads (memory-conscious)
+                    '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
@@ -581,7 +531,7 @@ class NetworkSolver:
                     'BarHomogeneous': 1,        # Use homogeneous self-dual form
                     'RelGap': 0.05,             # 5% MIP gap
                     'TimeLimit': 3600,          # 1 hour
-                    'Threads': 2,               # 4 threads (memory-conscious)
+                    'Threads': -1,               # 4 threads (memory-conscious)
                     'Presolve': 3,              # Aggressive presolve
                     'Scaling': 1,               # Enable scaling
                     'FeasTol': 1e-5,
@@ -603,16 +553,12 @@ class NetworkSolver:
                     'LpMethod': 2,              # Barrier method
                     'Crossover': 1,             # Enable crossover for better solutions
                     'RelGap': 0.05,             # 5% MIP gap (relaxed for faster solves)
-                    'TimeLimit': 3600,          # 1 hour
-                    'Threads': 2,              # Use all cores
-                    'Presolve': 3,              # Aggressive presolve
+                    'TimeLimit': 36000,          # 10 hour
+                    'Threads': -1,              # Use all cores
+                    'Presolve': 2,              # Aggressive presolve
                     'Scaling': 1,               # Enable scaling
-                    'FeasTol': 1e-6,            # Tighter feasibility
-                    'DualTol': 1e-6,            # Tighter dual tolerance
-                    # MIP performance settings
-                    'CutLevel': 3,              # Aggressive cuts
-                    'HeurLevel': 3,             # Aggressive heuristics
-                    'StrongBranching': 2,       # Normal strong branching
+                    'FeasTol': 1e-4,            # Tighter feasibility
+                    'DualTol': 1e-4,            # Tighter dual tolerance
                 }
             }
             if solver_options:
@@ -626,7 +572,7 @@ class NetworkSolver:
                     'LpMethod': 1,              # Dual simplex method
                     'RelGap': 0.05,             # 5% MIP gap
                     'TimeLimit': 3600,          # 1 hour
-                    'Threads': 2,              # Use all cores
+                    'Threads': -1,              # Use all cores
                     'Presolve': 3,              # Aggressive presolve
                     'Scaling': 1,               # Enable scaling
                     'FeasTol': 1e-6,
@@ -648,7 +594,7 @@ class NetworkSolver:
                     'LpMethod': 4,              # Concurrent (simplex + barrier)
                     'RelGap': 0.05,             # 5% MIP gap
                     'TimeLimit': 3600,          # 1 hour
-                    'Threads': 2,              # Use all cores
+                    'Threads': -1,              # Use all cores
                     'Presolve': 3,              # Aggressive presolve
                     'Scaling': 1,               # Enable scaling
                     'FeasTol': 1e-5,

{pyconvexity-0.3.8.post4.dist-info → pyconvexity-0.3.8.post6.dist-info}/METADATA

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

{pyconvexity-0.3.8.post4.dist-info → pyconvexity-0.3.8.post6.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pyconvexity/__init__.py,sha256=eiAFroO4n-z8F0jTLpJgBIO7vtSxu9ovu3G2N-qqpUo,4783
-pyconvexity/_version.py,sha256=QpKwBQB8nrOjAVlaA3W8ReZysT4se7cws6FTiK5PyJQ,27
+pyconvexity/_version.py,sha256=jO5GlIb68CD0eDfWJLp-lwidoi1UzGwf4_unGDQim90,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=zEbrFj7ReEBnKJz_Kpf__HfIuHoVsZvLpMoL4RobCYE,4030
+pyconvexity/models/scenarios.py,sha256=6pTfMusCQ6bwPUUFR_Wi1PUk3ZgCwG21uoTy667mZaM,3928
 pyconvexity/solvers/__init__.py,sha256=zoVf6T2Tmyj2XOeiVbEvaIMOX584orqCz1q9t1oXy0M,674
 pyconvexity/solvers/pypsa/__init__.py,sha256=KZqYDo7CvwB-5Kp784xxxtdn5kRcmn3gGSRlaQdDA4c,554
-pyconvexity/solvers/pypsa/api.py,sha256=Kjw4_AUegvF7CH3yx3kLgn9nm-xTgrNsyTCvjSWtNTk,17614
+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=qosBSNe0pr4va4dMmQFM-ifJCNGAkhS1R2gerNmhaiQ,16266
-pyconvexity/solvers/pypsa/solver.py,sha256=Yqf4_q9k5UAKm8XJwYPgGDrnGU_JYLFJsNP9OJ-fNz0,77061
+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.post4.dist-info/METADATA,sha256=24YZdnl-SFo5ZSe93PseCUi8hNB4fS1KxV3BBP3LJdU,4886
-pyconvexity-0.3.8.post4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyconvexity-0.3.8.post4.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
-pyconvexity-0.3.8.post4.dist-info/RECORD,,
+pyconvexity-0.3.8.post6.dist-info/METADATA,sha256=fKPUW65mNFxOCENHZuic30W1bbph8wORCzM56uFoP-U,4886
+pyconvexity-0.3.8.post6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyconvexity-0.3.8.post6.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
+pyconvexity-0.3.8.post6.dist-info/RECORD,,