pyconvexity 0.4.6.post1__py3-none-any.whl → 0.4.8.post1__py3-none-any.whl

pyconvexity/__init__.py

@@ -96,6 +96,15 @@ from pyconvexity.timeseries import (
     numpy_to_timeseries,
 )
 
+# Dashboard configuration for Convexity app
+from pyconvexity.dashboard import (
+    DashboardConfig,
+    set_dashboard_config,
+    get_dashboard_config,
+    clear_dashboard_config,
+    auto_layout,
+)
+
 # High-level API functions
 __all__ = [
     # Version info
@@ -171,6 +180,12 @@ __all__ = [
     "get_multiple_timeseries",
     "timeseries_to_numpy",
     "numpy_to_timeseries",
+    # Dashboard configuration
+    "DashboardConfig",
+    "set_dashboard_config",
+    "get_dashboard_config",
+    "clear_dashboard_config",
+    "auto_layout",
 ]
 
 # Data module imports

pyconvexity/_version.py

@@ -1 +1 @@
-__version__ = "0.4.6.post1"
+__version__ = "0.4.8.post1"

pyconvexity/dashboard.py

@@ -0,0 +1,265 @@
+"""
+Dashboard configuration for Convexity app visualization.
+
+Allows programmatic configuration of the analytics dashboard layout
+that will be displayed when the model is loaded in the Convexity app.
+
+Example:
+    >>> from pyconvexity.dashboard import set_dashboard_config, DashboardConfig, auto_layout
+    >>> 
+    >>> charts = [
+    ...     {
+    ...         "id": "dispatch-1",
+    ...         "title": "Generation by Carrier",
+    ...         "visible": True,
+    ...         "view": {
+    ...             "timeseries": {
+    ...                 "component": "Generator",
+    ...                 "attribute": "p",
+    ...                 "group_by": "carrier"
+    ...             }
+    ...         }
+    ...     },
+    ...     {
+    ...         "id": "lmp-1",
+    ...         "title": "Locational Marginal Prices",
+    ...         "visible": True,
+    ...         "view": {
+    ...             "timeseries": {
+    ...                 "component": "Bus",
+    ...                 "attribute": "marginal_price"
+    ...             }
+    ...         }
+    ...     }
+    ... ]
+    >>> 
+    >>> config = DashboardConfig(charts=charts, layout=auto_layout(charts))
+    >>> set_dashboard_config(conn, config)
+"""
+
+import json
+import sqlite3
+from dataclasses import dataclass, field, asdict
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class DashboardConfig:
+    """
+    Dashboard configuration for the Convexity app analytics view.
+    
+    Attributes:
+        charts: List of chart configurations. Each chart is a dict with:
+            - id: Unique identifier (e.g., "dispatch-1", "lmp-main")
+            - title: Display title
+            - visible: Whether chart is shown
+            - view: Chart type configuration (see below)
+            - filters: Optional chart-specific filters
+            
+        layout: List of layout positions. Each position is a dict with:
+            - i: Chart ID (must match a chart's id)
+            - x: Grid column (0-11)
+            - y: Grid row
+            - w: Width in grid units (max 12)
+            - h: Height in grid units
+            
+        selected_scenario_id: Pre-selected scenario ID (optional)
+        selected_ensemble_name: Pre-selected ensemble name (optional)
+        selected_bus_id: Pre-selected bus ID for filtering (optional)
+    
+    Chart View Types:
+        Timeseries (dispatch, LMP, etc.):
+            {"timeseries": {"component": "Generator", "attribute": "p", "group_by": "carrier"}}
+            {"timeseries": {"component": "Bus", "attribute": "marginal_price"}}
+            {"timeseries": {"component": "Load", "attribute": "p"}}
+            
+        Network map:
+            {"network": {"network": true}}
+            
+        Statistics/Summary:
+            {"statistic": {"statistic": "optimal_capacity", "metric": "capacity"}}
+            {"statistic": {"statistic": "total_cost"}}
+    """
+    charts: List[Dict[str, Any]]
+    layout: List[Dict[str, Any]]
+    selected_scenario_id: Optional[int] = None
+    selected_ensemble_name: Optional[str] = None
+    selected_bus_id: Optional[int] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        result = {
+            "charts": self.charts,
+            "layout": self.layout,
+        }
+        # Only include optional fields if set (matches Rust's skip_serializing_if)
+        if self.selected_scenario_id is not None:
+            result["selected_scenario_id"] = self.selected_scenario_id
+        if self.selected_ensemble_name is not None:
+            result["selected_ensemble_name"] = self.selected_ensemble_name
+        if self.selected_bus_id is not None:
+            result["selected_bus_id"] = self.selected_bus_id
+        return result
+
+
+def set_dashboard_config(conn: sqlite3.Connection, config: DashboardConfig) -> int:
+    """
+    Save dashboard configuration to the database.
+    
+    This configuration will be loaded by the Convexity app when the model
+    is opened, setting up the analytics dashboard with the specified charts
+    and layout.
+    
+    Args:
+        conn: Database connection
+        config: Dashboard configuration
+        
+    Returns:
+        Row ID of the stored configuration
+        
+    Example:
+        >>> config = DashboardConfig(
+        ...     charts=[{"id": "dispatch-1", "title": "Dispatch", "visible": True, 
+        ...              "view": {"timeseries": {"component": "Generator", "attribute": "p", "group_by": "carrier"}}}],
+        ...     layout=[{"i": "dispatch-1", "x": 0, "y": 0, "w": 12, "h": 40}]
+        ... )
+        >>> set_dashboard_config(conn, config)
+    """
+    data_json = json.dumps(config.to_dict())
+    data_bytes = data_json.encode('utf-8')
+    
+    # Check if analytics config exists
+    cursor = conn.execute(
+        "SELECT id FROM network_data_store WHERE category = 'analytics_view' AND name = 'default'"
+    )
+    row = cursor.fetchone()
+    
+    if row:
+        # Update existing
+        row_id = row[0]
+        conn.execute(
+            "UPDATE network_data_store SET data = ?, updated_at = datetime('now') WHERE id = ?",
+            (data_bytes, row_id)
+        )
+    else:
+        # Insert new
+        conn.execute(
+            """INSERT INTO network_data_store (category, name, data_format, data, created_at, updated_at)
+               VALUES ('analytics_view', 'default', 'json', ?, datetime('now'), datetime('now'))""",
+            (data_bytes,)
+        )
+        row_id = conn.execute("SELECT last_insert_rowid()").fetchone()[0]
+    
+    conn.commit()
+    return row_id
+
+
+def get_dashboard_config(conn: sqlite3.Connection) -> Optional[DashboardConfig]:
+    """
+    Get the current dashboard configuration from the database.
+    
+    Args:
+        conn: Database connection
+        
+    Returns:
+        DashboardConfig if one exists, None otherwise
+    """
+    cursor = conn.execute(
+        """SELECT data FROM network_data_store 
+           WHERE category = 'analytics_view' 
+           ORDER BY updated_at DESC LIMIT 1"""
+    )
+    row = cursor.fetchone()
+    
+    if not row:
+        return None
+    
+    data_bytes = row[0]
+    if isinstance(data_bytes, bytes):
+        data_str = data_bytes.decode('utf-8')
+    else:
+        data_str = data_bytes
+        
+    data = json.loads(data_str)
+    
+    return DashboardConfig(
+        charts=data.get("charts", []),
+        layout=data.get("layout", []),
+        selected_scenario_id=data.get("selected_scenario_id"),
+        selected_ensemble_name=data.get("selected_ensemble_name"),
+        selected_bus_id=data.get("selected_bus_id"),
+    )
+
+
+def auto_layout(charts: List[Dict[str, Any]], cols: int = 12) -> List[Dict[str, Any]]:
+    """
+    Automatically generate layout positions for charts.
+    
+    Places charts in a vertical stack, each taking full width.
+    Timeseries charts get height 40, others get height 20.
+    
+    Args:
+        charts: List of chart configurations
+        cols: Grid columns (default 12)
+        
+    Returns:
+        List of layout position dicts
+        
+    Example:
+        >>> charts = [
+        ...     {"id": "dispatch-1", "title": "Dispatch", "visible": True, 
+        ...      "view": {"timeseries": {...}}},
+        ...     {"id": "network-1", "title": "Network", "visible": True,
+        ...      "view": {"network": {"network": True}}}
+        ... ]
+        >>> layout = auto_layout(charts)
+        >>> # Returns: [{"i": "dispatch-1", "x": 0, "y": 0, "w": 12, "h": 40}, ...]
+    """
+    layout = []
+    y = 0
+    
+    for chart in charts:
+        if not chart.get("visible", True):
+            continue
+            
+        chart_id = chart["id"]
+        view = chart.get("view", {})
+        
+        # Determine chart dimensions based on type
+        if "timeseries" in view:
+            w, h = 12, 40
+        elif "network" in view:
+            w, h = 6, 40
+        elif "statistic" in view:
+            w, h = 6, 20
+        else:
+            w, h = 12, 20
+        
+        layout.append({
+            "i": chart_id,
+            "x": 0,
+            "y": y,
+            "w": w,
+            "h": h,
+        })
+        
+        y += h
+    
+    return layout
+
+
+def clear_dashboard_config(conn: sqlite3.Connection) -> bool:
+    """
+    Remove any existing dashboard configuration.
+    
+    Args:
+        conn: Database connection
+        
+    Returns:
+        True if a config was deleted, False if none existed
+    """
+    cursor = conn.execute(
+        "DELETE FROM network_data_store WHERE category = 'analytics_view' AND name = 'default'"
+    )
+    conn.commit()
+    return cursor.rowcount > 0

pyconvexity/data/schema/01_core_schema.sql

@@ -54,7 +54,7 @@ CREATE TABLE carriers (
     nice_name TEXT,                  -- Display name  
     max_growth REAL DEFAULT NULL,    -- MW - can be infinite
     max_relative_growth REAL DEFAULT 0.0,  -- MW
-    curtailable BOOLEAN DEFAULT FALSE, -- Whether the carrier can be curtailed
+    curtailable BOOLEAN DEFAULT TRUE, -- Whether the carrier can be curtailed
     
     -- Metadata
     created_at DATETIME DEFAULT CURRENT_TIMESTAMP,

pyconvexity/data/schema/03_validation_data.sql

@@ -33,8 +33,8 @@ INSERT INTO attribute_validation_rules (component_type, attribute_name, display_
 ('BUS', 'q', 'Reactive Power', 'float', 'MVar', '0', 'timeseries', FALSE, FALSE, 'reactive power (positive if net generation at bus)', NULL, NULL, 'electrical', TRUE),
 ('BUS', 'v_mag_pu', 'Voltage Magnitude', 'float', 'per unit', '1', 'timeseries', FALSE, FALSE, 'Voltage magnitude, per unit of v_nom', NULL, NULL, 'electrical', TRUE),
 ('BUS', 'v_ang', 'Voltage Angle', 'float', 'radians', '0', 'timeseries', FALSE, FALSE, 'Voltage angle', NULL, NULL, 'electrical', TRUE),
-('BUS', 'marginal_price', 'Marginal Price', 'float', 'currency/MWh', '0', 'timeseries', FALSE, FALSE, 'Locational marginal price from LOPF from power balance constraint', NULL, NULL, 'costs', TRUE),
-('BUS', 'market_price', 'Market Price', 'float', 'currency/MWh', '0', 'timeseries', FALSE, FALSE, 'Custom calculated market price for the bus (independent of PyPSA marginal cost)', NULL, NULL, 'costs', TRUE);
+('BUS', 'marginal_price', 'Marginal Price', 'float', 'currency/MWh', '0', 'timeseries', FALSE, FALSE, 'Locational marginal price from LOPF from power balance constraint (shadow price). Includes effects of UC constraints, ramping limits, and other binding constraints.', NULL, NULL, 'costs', TRUE),
+('BUS', 'clearing_price', 'Clearing Price', 'float', 'currency/MWh', '0', 'timeseries', FALSE, FALSE, 'Pay-as-clear price: marginal cost of the cheapest available source (generator, storage, or import via uncongested link) with spare capacity. Calculated as min of: (1) local generators/storage with spare capacity, (2) adjacent bus local marginal + link cost adjusted for efficiency, for uncongested links, (3) unmet load price in scarcity. Differs from marginal_price which is the LP shadow price.', NULL, NULL, 'costs', TRUE);
 
 -- ============================================================================
 -- GENERATOR ATTRIBUTES  

pyconvexity/solvers/pypsa/__init__.py

@@ -3,6 +3,10 @@ PyPSA solver integration for PyConvexity.
 
 Provides high-level and low-level APIs for building PyPSA networks from database,
 solving them, and storing results back to the database.
+
+After solving, the following prices are stored on each bus:
+- marginal_price: LP shadow price of power balance constraint (from PyPSA)
+- clearing_price: Pay-as-clear price based on cheapest source with spare capacity
 """
 
 from pyconvexity.solvers.pypsa.api import (
@@ -13,6 +17,7 @@ from pyconvexity.solvers.pypsa.api import (
     apply_constraints,
     store_solve_results,
 )
+from pyconvexity.solvers.pypsa.clearing_price import ClearingPriceCalculator
 
 __all__ = [
     "solve_network",
@@ -21,4 +26,5 @@ __all__ = [
     "load_network_components",
     "apply_constraints",
     "store_solve_results",
+    "ClearingPriceCalculator",
 ]

pyconvexity/solvers/pypsa/clearing_price.py

@@ -0,0 +1,678 @@
+"""
+Clearing Price Calculator
+=========================
+
+Calculates pay-as-clear prices for all buses after network solve.
+
+The clearing price at each bus represents the cost of the marginal MW
+that could be supplied to that bus, considering:
+- Local generators with spare capacity (dispatch < available capacity)
+- Local storage units with spare discharge capacity  
+- Imports via uncongested links from adjacent buses
+
+This differs from PyPSA's marginal_price (shadow price) which includes
+effects of UC constraints, ramping limits, and other binding constraints.
+
+Algorithm (Single-Pass "Local Marginal"):
+=========================================
+For each bus at each timestep:
+1. Find the cheapest LOCAL source with spare capacity:
+   - Generators where p < p_nom * p_max_pu (has spare capacity)
+   - Storage units where p < p_nom * p_max_pu (can discharge more)
+   - Exclude "unmet load" penalty generators (marginal_cost > threshold)
+
+2. Find the cheapest IMPORT option via uncongested inbound links:
+   - For each link where this bus is the destination (bus1):
+     - Check if link has spare import capacity: p0 < p_nom * p_max_pu
+     - Import price = local_marginal[source_bus] + link.marginal_cost) / link.efficiency
+   - For bidirectional links, check both directions
+
+3. clearing_price = min(local_marginal, cheapest_import)
+
+4. If no source has spare capacity (scarcity):
+   - Use the unmet load penalty price
+
+Note on Multi-hop Imports:
+--------------------------
+This single-pass algorithm uses the LOCAL marginal price of adjacent buses,
+not their full clearing prices. This means multi-hop import economics are
+not captured. For example, if Bus A can import from Bus B, and Bus B can
+import cheaply from Bus C, this algorithm won't reflect Bus A's ability
+to effectively import from C via B.
+
+This is a deliberate simplification that:
+- Avoids iteration/recursion for meshed networks
+- Matches a "local market" interpretation where each bus sees instantaneous offers
+- Is correct for radial networks (tree topology)
+
+For most practical networks (radial or nearly radial), this gives accurate results.
+"""
+
+import logging
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple, Any
+
+import numpy as np
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LinkInfo:
+    """Information about a link for clearing price calculation."""
+    link_name: str
+    adjacent_bus: str
+    marginal_cost: np.ndarray  # Per timestep
+    efficiency: float
+    spare_capacity_mask: np.ndarray  # Boolean per timestep: True if has spare capacity
+
+
+@dataclass 
+class PriceSetter:
+    """Tracks which asset sets the clearing price."""
+    asset_name: str
+    asset_type: str  # 'generator', 'storage', 'link_import'
+    marginal_cost: float
+    bus: str
+
+
+class ClearingPriceCalculator:
+    """
+    Calculate pay-as-clear prices for all buses in a solved network.
+    
+    The clearing price is the marginal cost of the cheapest source with
+    spare capacity that could supply the next MW to a bus. This differs
+    from the LP shadow price (marginal_price) which includes constraint effects.
+    
+    Example usage:
+        calculator = ClearingPriceCalculator()
+        clearing_prices = calculator.calculate_all_buses(conn, network, scenario_id)
+        # Returns: {'GB_Main': array([45.2, 46.1, ...]), 'FR': array([...]), ...}
+    """
+    
+    def __init__(
+        self, 
+        unmet_load_threshold: float = 10000.0,
+        spare_capacity_tolerance: float = 0.01,
+        min_dispatch_threshold: float = 1.0,
+        verbose: bool = True,
+        include_storage: bool = False,
+        min_marginal_cost: float = 1.0,
+    ):
+        """
+        Initialize the calculator.
+        
+        Args:
+            unmet_load_threshold: Marginal cost above which a generator is
+                considered an "unmet load" penalty generator and excluded
+                from normal clearing price calculation.
+            spare_capacity_tolerance: Fraction tolerance for "at capacity".
+                A source is considered to have spare capacity if 
+                dispatch < available_capacity * (1 - tolerance).
+            min_dispatch_threshold: Minimum dispatch (MW) to consider a source
+                as "dispatching". Handles numerical noise.
+            verbose: Enable detailed logging of price-setting assets.
+            include_storage: Whether to include storage units in clearing price.
+                Default False because storage marginal_cost in PyPSA is typically
+                ~0 (no fuel cost) and doesn't represent the market clearing price.
+                In pay-as-clear markets, storage is a price-taker, not a price-setter.
+            min_marginal_cost: Minimum marginal cost to consider for price setting.
+                Sources with marginal_cost below this are excluded (e.g., to filter
+                out renewables with mc=0 that shouldn't set the clearing price).
+        """
+        self.unmet_load_threshold = unmet_load_threshold
+        self.spare_capacity_tolerance = spare_capacity_tolerance
+        self.min_dispatch_threshold = min_dispatch_threshold
+        self.verbose = verbose
+        self.include_storage = include_storage
+        self.min_marginal_cost = min_marginal_cost
+        
+        # Track price setters for logging
+        self._price_setters: Dict[str, List[Optional[PriceSetter]]] = {}
+    
+    def calculate_all_buses(
+        self,
+        conn,
+        network: "pypsa.Network",
+        scenario_id: Optional[int] = None,
+    ) -> Dict[str, np.ndarray]:
+        """
+        Calculate clearing prices for all buses in the network.
+        
+        Args:
+            conn: Database connection (for component lookups if needed)
+            network: Solved PyPSA Network object
+            scenario_id: Scenario ID (for logging)
+            
+        Returns:
+            Dict mapping bus_name -> array of clearing prices per timestep.
+            Length of each array equals len(network.snapshots).
+        """
+        n_periods = len(network.snapshots)
+        bus_names = list(network.buses.index)
+        
+        logger.debug(f"Clearing price calculation: {len(bus_names)} buses, {n_periods} periods")
+        
+        # Reset price setters tracking
+        self._price_setters = {bus: [None] * n_periods for bus in bus_names}
+        
+        # Step 1: Calculate local marginal price at each bus
+        local_marginals, local_setters = self._calculate_local_marginals(network, n_periods)
+        
+        # Step 2: Build link adjacency map (which buses can import from where)
+        link_adjacency = self._build_link_adjacency(network, n_periods)
+        
+        # Step 3: Calculate clearing prices (single pass)
+        clearing_prices = {}
+        for bus_name in bus_names:
+            clearing_prices[bus_name], setters = self._calculate_bus_clearing_price(
+                bus_name,
+                local_marginals,
+                local_setters,
+                link_adjacency,
+                n_periods,
+            )
+            self._price_setters[bus_name] = setters
+        
+        # Log summary for key buses only
+        self._log_clearing_price_summary(clearing_prices, n_periods)
+        
+        return clearing_prices
+    
+    def _calculate_local_marginals(
+        self, 
+        network: "pypsa.Network", 
+        n_periods: int
+    ) -> Tuple[Dict[str, np.ndarray], Dict[str, List[Optional[PriceSetter]]]]:
+        """
+        For each bus, calculate the marginal cost of the cheapest local source
+        (generator or storage unit) with spare capacity at each timestep.
+        
+        Returns:
+            Tuple of:
+            - Dict mapping bus_name -> array of local marginal prices
+            - Dict mapping bus_name -> list of PriceSetter objects (one per timestep)
+        """
+        bus_names = list(network.buses.index)
+        local_marginals = {bus: np.full(n_periods, np.inf) for bus in bus_names}
+        local_setters = {bus: [None] * n_periods for bus in bus_names}
+        
+        # Process generators
+        gen_stats = self._process_generators(network, n_periods, local_marginals, local_setters)
+        
+        # Process storage units (discharge as source) - only if enabled
+        # By default, storage is excluded because:
+        # 1. Storage marginal_cost in PyPSA is typically ~0 (no fuel cost)
+        # 2. In pay-as-clear markets, storage is a price-taker, not a price-setter
+        # 3. Storage arbitrages between periods; its cost is opportunity cost, not marginal cost
+        if self.include_storage:
+            storage_stats = self._process_storage_units(network, n_periods, local_marginals, local_setters)
+        else:
+            storage_stats = {'processed': 0, 'with_spare': 0}
+        
+        # Process stores (if they can inject power)
+        self._process_stores(network, n_periods, local_marginals, local_setters)
+        
+        logger.debug(f"  Generators: {gen_stats['processed']} processed, {gen_stats['with_spare']} with spare capacity")
+        logger.debug(f"  Storage units: {storage_stats['processed']} processed, {storage_stats['with_spare']} with spare capacity")
+        
+        return local_marginals, local_setters
+    
+    def _process_generators(
+        self,
+        network: "pypsa.Network",
+        n_periods: int,
+        local_marginals: Dict[str, np.ndarray],
+        local_setters: Dict[str, List[Optional[PriceSetter]]],
+    ) -> Dict[str, int]:
+        """Process generators to find local marginals at each bus."""
+        stats = {'processed': 0, 'with_spare': 0, 'skipped_unmet': 0, 'skipped_no_pnom': 0}
+        
+        if network.generators.empty:
+            return stats
+        
+        generators = network.generators
+        
+        # Get dispatch timeseries
+        if hasattr(network.generators_t, 'p') and not network.generators_t.p.empty:
+            p_dispatch = network.generators_t.p
+        else:
+            logger.warning("  No generator dispatch data found (generators_t.p empty)")
+            return stats
+        
+        # Get p_max_pu timeseries (or static)
+        if hasattr(network.generators_t, 'p_max_pu') and not network.generators_t.p_max_pu.empty:
+            p_max_pu_ts = network.generators_t.p_max_pu
+        else:
+            p_max_pu_ts = None
+        
+        # Get marginal_cost timeseries (or static)
+        if hasattr(network.generators_t, 'marginal_cost') and not network.generators_t.marginal_cost.empty:
+            marginal_cost_ts = network.generators_t.marginal_cost
+        else:
+            marginal_cost_ts = None
+        
+        # First pass: regular generators (not unmet load)
+        for gen_name in generators.index:
+            gen = generators.loc[gen_name]
+            bus = gen['bus']
+            
+            if bus not in local_marginals:
+                continue
+            
+            # Get p_nom
+            p_nom = gen.get('p_nom', 0)
+            if p_nom <= 0:
+                stats['skipped_no_pnom'] += 1
+                continue
+            
+            # Get dispatch values
+            if gen_name not in p_dispatch.columns:
+                continue
+            p_values = p_dispatch[gen_name].values
+            if len(p_values) != n_periods:
+                p_values = self._pad_or_truncate(p_values, n_periods)
+            
+            # Get p_max_pu values
+            if p_max_pu_ts is not None and gen_name in p_max_pu_ts.columns:
+                p_max_pu_values = p_max_pu_ts[gen_name].values
+            else:
+                p_max_pu_values = np.full(n_periods, gen.get('p_max_pu', 1.0))
+            if len(p_max_pu_values) != n_periods:
+                p_max_pu_values = self._pad_or_truncate(p_max_pu_values, n_periods)
+            
+            # Get marginal_cost values
+            if marginal_cost_ts is not None and gen_name in marginal_cost_ts.columns:
+                mc_values = marginal_cost_ts[gen_name].values
+            else:
+                mc_values = np.full(n_periods, gen.get('marginal_cost', 0.0))
+            if len(mc_values) != n_periods:
+                mc_values = self._pad_or_truncate(mc_values, n_periods)
+            
+            # Skip unmet load generators (handle in second pass)
+            if np.any(mc_values > self.unmet_load_threshold):
+                stats['skipped_unmet'] += 1
+                continue
+            
+            stats['processed'] += 1
+            
+            # Calculate available capacity
+            available = p_nom * p_max_pu_values
+            
+            # Find timesteps where generator has spare capacity
+            spare_capacity_mask = p_values < available * (1 - self.spare_capacity_tolerance)
+            n_spare = spare_capacity_mask.sum()
+            
+            if n_spare > 0:
+                stats['with_spare'] += 1
+            
+            # Log details for this generator
+            if self.verbose and n_spare > 0:
+                mean_mc = np.mean(mc_values)
+                mean_dispatch = np.mean(p_values)
+                mean_available = np.mean(available)
+                logger.debug(f"    {gen_name} @ {bus}: mc={mean_mc:.2f}, dispatch={mean_dispatch:.1f}MW, available={mean_available:.1f}MW, spare_periods={n_spare}/{n_periods}")
+            
+            # Update local marginal where this generator is cheaper and has spare capacity
+            # Also filter by min_marginal_cost (e.g., to exclude renewables with mc=0)
+            for t in range(n_periods):
+                if (spare_capacity_mask[t] 
+                    and mc_values[t] >= self.min_marginal_cost
+                    and mc_values[t] < local_marginals[bus][t]):
+                    local_marginals[bus][t] = mc_values[t]
+                    local_setters[bus][t] = PriceSetter(
+                        asset_name=gen_name,
+                        asset_type='generator',
+                        marginal_cost=mc_values[t],
+                        bus=bus
+                    )
+        
+        # Second pass: handle unmet load generators (only set price if no other source available)
+        for gen_name in generators.index:
+            gen = generators.loc[gen_name]
+            bus = gen['bus']
+            
+            if bus not in local_marginals:
+                continue
+            
+            p_nom = gen.get('p_nom', 0)
+            if p_nom <= 0:
+                continue
+            
+            # Get marginal_cost values
+            if marginal_cost_ts is not None and gen_name in marginal_cost_ts.columns:
+                mc_values = marginal_cost_ts[gen_name].values
+            else:
+                mc_values = np.full(n_periods, gen.get('marginal_cost', 0.0))
+            if len(mc_values) != n_periods:
+                mc_values = self._pad_or_truncate(mc_values, n_periods)
+            
+            # Only process unmet load generators
+            if not np.any(mc_values > self.unmet_load_threshold):
+                continue
+            
+            # Get dispatch and check spare capacity
+            if gen_name not in p_dispatch.columns:
+                continue
+            p_values = p_dispatch[gen_name].values
+            if len(p_values) != n_periods:
+                p_values = self._pad_or_truncate(p_values, n_periods)
+            
+            if p_max_pu_ts is not None and gen_name in p_max_pu_ts.columns:
+                p_max_pu_values = p_max_pu_ts[gen_name].values
+            else:
+                p_max_pu_values = np.full(n_periods, gen.get('p_max_pu', 1.0))
+            if len(p_max_pu_values) != n_periods:
+                p_max_pu_values = self._pad_or_truncate(p_max_pu_values, n_periods)
+            
+            available = p_nom * p_max_pu_values
+            spare_capacity_mask = p_values < available * (1 - self.spare_capacity_tolerance)
+            
+            # Only use unmet load price where local_marginal is still inf (no other source)
+            n_set = 0
+            for t in range(n_periods):
+                if spare_capacity_mask[t] and np.isinf(local_marginals[bus][t]):
+                    local_marginals[bus][t] = mc_values[t]
+                    local_setters[bus][t] = PriceSetter(
+                        asset_name=gen_name,
+                        asset_type='unmet_load',
+                        marginal_cost=mc_values[t],
+                        bus=bus
+                    )
+                    n_set += 1
+            
+            if n_set > 0:
+                logger.debug(f"    UNMET LOAD {gen_name}: set price for {n_set} periods (no other source)")
+        
+        return stats
+    
+    def _process_storage_units(
+        self,
+        network: "pypsa.Network",
+        n_periods: int,
+        local_marginals: Dict[str, np.ndarray],
+        local_setters: Dict[str, List[Optional[PriceSetter]]],
+    ) -> Dict[str, int]:
+        """Process storage units (discharge capacity) to find local marginals."""
+        stats = {'processed': 0, 'with_spare': 0}
+        
+        if network.storage_units.empty:
+            return stats
+        
+        storage_units = network.storage_units
+        
+        # Get dispatch timeseries (positive = discharge)
+        if hasattr(network.storage_units_t, 'p') and not network.storage_units_t.p.empty:
+            p_dispatch = network.storage_units_t.p
+        else:
+            logger.warning("  No storage unit dispatch data found")
+            return stats
+        
+        for su_name in storage_units.index:
+            su = storage_units.loc[su_name]
+            bus = su['bus']
+            
+            if bus not in local_marginals:
+                continue
+            
+            # Get p_nom (discharge capacity)
+            p_nom = su.get('p_nom', 0)
+            if p_nom <= 0:
+                continue
+            
+            # Get dispatch values
+            if su_name not in p_dispatch.columns:
+                continue
+            p_values = p_dispatch[su_name].values
+            if len(p_values) != n_periods:
+                p_values = self._pad_or_truncate(p_values, n_periods)
+            
+            # Get p_max_pu
+            if hasattr(network.storage_units_t, 'p_max_pu') and su_name in network.storage_units_t.p_max_pu.columns:
+                p_max_pu_values = network.storage_units_t.p_max_pu[su_name].values
+            else:
+                p_max_pu_values = np.full(n_periods, su.get('p_max_pu', 1.0))
+            if len(p_max_pu_values) != n_periods:
+                p_max_pu_values = self._pad_or_truncate(p_max_pu_values, n_periods)
+            
+            # Get marginal_cost
+            if hasattr(network.storage_units_t, 'marginal_cost') and su_name in network.storage_units_t.marginal_cost.columns:
+                mc_values = network.storage_units_t.marginal_cost[su_name].values
+            else:
+                mc_values = np.full(n_periods, su.get('marginal_cost', 0.0))
+            if len(mc_values) != n_periods:
+                mc_values = self._pad_or_truncate(mc_values, n_periods)
+            
+            stats['processed'] += 1
+            
+            # Calculate available discharge capacity
+            available = p_nom * p_max_pu_values
+            
+            # Spare capacity for discharge: current discharge < max discharge
+            spare_capacity_mask = p_values < available * (1 - self.spare_capacity_tolerance)
+            n_spare = spare_capacity_mask.sum()
+            
+            if n_spare > 0:
+                stats['with_spare'] += 1
+            
+            if self.verbose and n_spare > 0:
+                logger.debug(f"    {su_name} @ {bus}: mc={np.mean(mc_values):.2f}, spare_periods={n_spare}/{n_periods}")
+            
+            # Update local marginal
+            for t in range(n_periods):
+                if spare_capacity_mask[t] and mc_values[t] < local_marginals[bus][t]:
+                    local_marginals[bus][t] = mc_values[t]
+                    local_setters[bus][t] = PriceSetter(
+                        asset_name=su_name,
+                        asset_type='storage',
+                        marginal_cost=mc_values[t],
+                        bus=bus
+                    )
+        
+        return stats
+    
+    def _process_stores(
+        self,
+        network: "pypsa.Network",
+        n_periods: int,
+        local_marginals: Dict[str, np.ndarray],
+        local_setters: Dict[str, List[Optional[PriceSetter]]],
+    ) -> None:
+        """Process stores (if they can inject power) to find local marginals."""
+        if network.stores.empty:
+            return
+        
+        # Stores are complex - skip for now
+        # They don't have a fixed p_nom like generators/storage_units
+        logger.debug(f"  Skipping {len(network.stores)} stores (complex capacity constraints)")
+    
+    def _build_link_adjacency(
+        self,
+        network: "pypsa.Network",
+        n_periods: int,
+    ) -> Dict[str, List[LinkInfo]]:
+        """
+        Build a map of bus -> list of inbound link options.
+        """
+        link_adjacency: Dict[str, List[LinkInfo]] = {}
+        
+        if network.links.empty:
+            return link_adjacency
+        
+        links = network.links
+        
+        # Get link flow timeseries
+        if hasattr(network.links_t, 'p0') and not network.links_t.p0.empty:
+            p0_dispatch = network.links_t.p0
+        else:
+            p0_dispatch = None
+            logger.warning("  No link flow data found (links_t.p0 empty)")
+        
+        for link_name in links.index:
+            link = links.loc[link_name]
+            bus0 = link['bus0']
+            bus1 = link['bus1']
+            
+            p_nom = link.get('p_nom', 0)
+            if p_nom <= 0:
+                continue
+            
+            efficiency = link.get('efficiency', 1.0)
+            if pd.isna(efficiency) or efficiency <= 0:
+                efficiency = 1.0
+            
+            # Get marginal_cost
+            if hasattr(network.links_t, 'marginal_cost') and link_name in network.links_t.marginal_cost.columns:
+                mc_values = network.links_t.marginal_cost[link_name].values
+            else:
+                mc_values = np.full(n_periods, link.get('marginal_cost', 0.0))
+            if len(mc_values) != n_periods:
+                mc_values = self._pad_or_truncate(mc_values, n_periods)
+            
+            # Get p_max_pu
+            if hasattr(network.links_t, 'p_max_pu') and link_name in network.links_t.p_max_pu.columns:
+                p_max_pu_values = network.links_t.p_max_pu[link_name].values
+            else:
+                p_max_pu_values = np.full(n_periods, link.get('p_max_pu', 1.0))
+            if len(p_max_pu_values) != n_periods:
+                p_max_pu_values = self._pad_or_truncate(p_max_pu_values, n_periods)
+            
+            # Get p_min_pu
+            if hasattr(network.links_t, 'p_min_pu') and link_name in network.links_t.p_min_pu.columns:
+                p_min_pu_values = network.links_t.p_min_pu[link_name].values
+            else:
+                p_min_pu_values = np.full(n_periods, link.get('p_min_pu', 0.0))
+            if len(p_min_pu_values) != n_periods:
+                p_min_pu_values = self._pad_or_truncate(p_min_pu_values, n_periods)
+            
+            # Get actual flow
+            if p0_dispatch is not None and link_name in p0_dispatch.columns:
+                p0_values = p0_dispatch[link_name].values
+            else:
+                p0_values = np.zeros(n_periods)
+            if len(p0_values) != n_periods:
+                p0_values = self._pad_or_truncate(p0_values, n_periods)
+            
+            # Direction 1: bus0 -> bus1 (positive flow)
+            max_forward = p_nom * p_max_pu_values
+            spare_forward = p0_values < max_forward * (1 - self.spare_capacity_tolerance)
+            
+            if bus1 not in link_adjacency:
+                link_adjacency[bus1] = []
+            link_adjacency[bus1].append(LinkInfo(
+                link_name=link_name,
+                adjacent_bus=bus0,
+                marginal_cost=mc_values,
+                efficiency=efficiency,
+                spare_capacity_mask=spare_forward,
+            ))
+            
+            logger.debug(f"    {link_name}: {bus0} -> {bus1}, p_nom={p_nom:.0f}MW, eff={efficiency:.2f}, spare_periods={spare_forward.sum()}")
+            
+            # Direction 2: bus1 -> bus0 (negative flow, if allowed)
+            if np.any(p_min_pu_values < 0):
+                max_reverse = p_nom * np.abs(p_min_pu_values)
+                current_reverse = np.maximum(-p0_values, 0)
+                spare_reverse = current_reverse < max_reverse * (1 - self.spare_capacity_tolerance)
+                
+                if bus0 not in link_adjacency:
+                    link_adjacency[bus0] = []
+                link_adjacency[bus0].append(LinkInfo(
+                    link_name=f"{link_name}_reverse",
+                    adjacent_bus=bus1,
+                    marginal_cost=mc_values,
+                    efficiency=efficiency,
+                    spare_capacity_mask=spare_reverse,
+                ))
+                
+                logger.debug(f"    {link_name}_reverse: {bus1} -> {bus0}, spare_periods={spare_reverse.sum()}")
+        
+        return link_adjacency
+    
+    def _calculate_bus_clearing_price(
+        self,
+        bus_name: str,
+        local_marginals: Dict[str, np.ndarray],
+        local_setters: Dict[str, List[Optional[PriceSetter]]],
+        link_adjacency: Dict[str, List[LinkInfo]],
+        n_periods: int,
+    ) -> Tuple[np.ndarray, List[Optional[PriceSetter]]]:
+        """
+        Calculate clearing price for a single bus.
+        
+        Returns:
+            Tuple of (clearing_prices array, list of PriceSetter for each timestep)
+        """
+        clearing_prices = np.copy(local_marginals.get(bus_name, np.full(n_periods, np.inf)))
+        setters = list(local_setters.get(bus_name, [None] * n_periods))
+        
+        # Check import options
+        n_import_better = 0
+        if bus_name in link_adjacency:
+            for link_info in link_adjacency[bus_name]:
+                adj_bus = link_info.adjacent_bus
+                adj_marginal = local_marginals.get(adj_bus, np.full(n_periods, np.inf))
+                
+                for t in range(n_periods):
+                    if link_info.spare_capacity_mask[t]:
+                        # Import price = (adjacent marginal + link cost) / efficiency
+                        import_price = (adj_marginal[t] + link_info.marginal_cost[t]) / link_info.efficiency
+                        if import_price < clearing_prices[t]:
+                            clearing_prices[t] = import_price
+                            setters[t] = PriceSetter(
+                                asset_name=link_info.link_name,
+                                asset_type='link_import',
+                                marginal_cost=import_price,
+                                bus=bus_name
+                            )
+                            n_import_better += 1
+        
+        # Handle remaining inf values (true scarcity)
+        n_scarcity = np.isinf(clearing_prices).sum()
+        clearing_prices = np.where(np.isinf(clearing_prices), self.unmet_load_threshold * 10, clearing_prices)
+        
+        # Log warning only for problematic buses
+        n_zeros = (clearing_prices == 0).sum()
+        if n_zeros > 0 or n_scarcity > 0:
+            logger.warning(f"  {bus_name}: zeros={n_zeros}, scarcity={n_scarcity}")
+        
+        return clearing_prices, setters
+    
+    def _log_clearing_price_summary(
+        self,
+        clearing_prices: Dict[str, np.ndarray],
+        n_periods: int,
+    ) -> None:
+        """Log compact summary of clearing prices."""
+        # Log summary for key buses (GB_Main if present, otherwise all)
+        key_buses = ['GB_Main'] if 'GB_Main' in clearing_prices else list(clearing_prices.keys())[:3]
+        
+        for bus_name in key_buses:
+            prices = clearing_prices.get(bus_name)
+            if prices is None:
+                continue
+                
+            setters = self._price_setters.get(bus_name, [])
+            
+            # Count price setters by type
+            setter_counts: Dict[str, int] = {}
+            for setter in setters:
+                key = setter.asset_type if setter else 'none'
+                setter_counts[key] = setter_counts.get(key, 0) + 1
+            
+            # Summary stats
+            valid = prices[(prices > 0) & (prices < self.unmet_load_threshold)]
+            setters_str = ", ".join(f"{k}:{v}" for k, v in sorted(setter_counts.items(), key=lambda x: -x[1]))
+            
+            if len(valid) > 0:
+                logger.info(f"  Clearing prices [{bus_name}]: mean=£{np.mean(valid):.2f}, range=[£{np.min(valid):.2f}, £{np.max(valid):.2f}], setters: {setters_str}")
+    
+    def _pad_or_truncate(self, arr: np.ndarray, target_length: int) -> np.ndarray:
+        """Pad array with last value or truncate to target length."""
+        arr = np.asarray(arr)
+        if len(arr) >= target_length:
+            return arr[:target_length]
+        else:
+            padding = np.full(target_length - len(arr), arr[-1] if len(arr) > 0 else 0)
+            return np.concatenate([arr, padding])

pyconvexity/solvers/pypsa/storage.py

@@ -4,12 +4,16 @@ Result storage functionality for PyPSA solver integration.
 Handles storing solve results back to the database with proper validation and error handling.
 """
 
+import logging
 import uuid
 import pandas as pd
 import numpy as np
 from typing import Dict, Any, Optional, Callable
 
 from pyconvexity.core.types import StaticValue
+
+logger = logging.getLogger(__name__)
+
 from pyconvexity.models import (
     list_components_by_type,
     set_static_attribute,
@@ -60,6 +64,12 @@ class ResultStorage:
             # Store component results
             component_stats = self._store_component_results(conn, network, scenario_id)
 
+            # Calculate and store clearing prices for all buses
+            clearing_prices_stored = self._calculate_and_store_clearing_prices(
+                conn, network, scenario_id
+            )
+            component_stats["stored_clearing_prices"] = clearing_prices_stored
+
             # Calculate network statistics first
             network_stats = self._calculate_network_statistics(
                 conn, network, solve_result
@@ -193,6 +203,94 @@ class ResultStorage:
             results_stats["errors"] += 1
             return results_stats
 
+    def _calculate_and_store_clearing_prices(
+        self,
+        conn,
+        network: "pypsa.Network",
+        scenario_id: Optional[int],
+    ) -> int:
+        """
+        Calculate and store clearing prices for all buses.
+        
+        The clearing price at each bus is the pay-as-clear price: the marginal
+        cost of the cheapest source (generator, storage, or import) with spare
+        capacity. This differs from the marginal_price (LP shadow price).
+        
+        Args:
+            conn: Database connection
+            network: Solved PyPSA Network object
+            scenario_id: Scenario ID for result storage
+            
+        Returns:
+            Number of buses with clearing prices stored
+        """
+        logger.info(f"=== CALCULATING AND STORING CLEARING PRICES (scenario_id={scenario_id}) ===")
+        
+        try:
+            from .clearing_price import ClearingPriceCalculator
+            
+            calculator = ClearingPriceCalculator(verbose=True)
+            clearing_prices = calculator.calculate_all_buses(conn, network, scenario_id)
+            
+            if not clearing_prices:
+                logger.warning("No clearing prices calculated - clearing_prices dict is empty")
+                return 0
+            
+            # Log what we got from the calculator
+            logger.info(f"Clearing prices calculated for {len(clearing_prices)} buses")
+            for bus_name, prices in clearing_prices.items():
+                n_zeros = np.sum(prices == 0)
+                n_inf = np.sum(np.isinf(prices))
+                valid = prices[(prices > 0) & np.isfinite(prices)]
+                if len(valid) > 0:
+                    logger.info(f"  {bus_name}: {len(prices)} periods, mean=£{np.mean(valid):.2f}, "
+                               f"zeros={n_zeros}, inf={n_inf}, range=[£{np.min(valid):.2f}, £{np.max(valid):.2f}]")
+                else:
+                    logger.warning(f"  {bus_name}: {len(prices)} periods, ALL ZERO OR INF (zeros={n_zeros}, inf={n_inf})")
+            
+            # Get bus component IDs
+            buses = list_components_by_type(conn, "BUS")
+            bus_name_to_id = {bus.name: bus.id for bus in buses}
+            logger.info(f"Found {len(buses)} buses in database: {list(bus_name_to_id.keys())}")
+            
+            stored_count = 0
+            for bus_name, prices in clearing_prices.items():
+                if bus_name not in bus_name_to_id:
+                    logger.warning(f"  {bus_name}: not found in database - skipping")
+                    continue
+                
+                bus_id = bus_name_to_id[bus_name]
+                values = [float(p) if np.isfinite(p) else 0.0 for p in prices]
+                
+                # Log what we're about to store
+                n_zeros = sum(1 for v in values if v == 0)
+                if n_zeros > 0:
+                    logger.warning(f"  {bus_name}: storing {len(values)} values, {n_zeros} zeros")
+                
+                try:
+                    set_timeseries_attribute(
+                        conn, bus_id, "clearing_price", values, scenario_id
+                    )
+                    stored_count += 1
+                    logger.info(f"  ✅ {bus_name} (id={bus_id}): stored {len(values)} clearing prices")
+                except Exception as e:
+                    logger.error(f"  ❌ {bus_name} (id={bus_id}): failed to store clearing_price: {e}")
+                    import traceback
+                    traceback.print_exc()
+                    continue
+            
+            logger.info(f"=== CLEARING PRICES: Stored {stored_count}/{len(clearing_prices)} buses ===")
+            return stored_count
+            
+        except ImportError as e:
+            logger.error(f"ClearingPriceCalculator not available - skipping clearing price calculation: {e}")
+            return 0
+        except Exception as e:
+            logger.error(f"Failed to calculate/store clearing prices: {e}")
+            import traceback
+            traceback.print_exc()
+            return 0
+
     def _store_component_type_results(
         self,
         conn,

{pyconvexity-0.4.6.post1.dist-info → pyconvexity-0.4.8.post1.dist-info}/METADATA

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

{pyconvexity-0.4.6.post1.dist-info → pyconvexity-0.4.8.post1.dist-info}/RECORD

@@ -1,5 +1,6 @@
-pyconvexity/__init__.py,sha256=TJvgkEaMHFFWhIGaOdjMgc4rHVIxHKni3Ggg1YAQziE,5347
-pyconvexity/_version.py,sha256=mb7cZWFtBTYPgotnX_1oAZadFITLHrAXwTSs2Eb1dvU,28
+pyconvexity/__init__.py,sha256=P67QJ8npf-QWmBX12im__eICLoRz8cByQ5OJXiyIBmA,5706
+pyconvexity/_version.py,sha256=E6iPG1WE6yyF-fToZYo4ZM-iwegVLaXOKuEXlAJ_kvg,28
+pyconvexity/dashboard.py,sha256=7x04Hr-EwzTAf-YJdHzfV83Gf2etltwtzwh_bCYJ5lk,8579
 pyconvexity/timeseries.py,sha256=QdKbiqjAlxkJATyKm2Kelx1Ea2PsAnnCYfVLU5VER1Y,11085
 pyconvexity/core/__init__.py,sha256=gdyyHNqOc4h9Nfe9u6NA936GNzH6coGNCMgBvvvOnGE,1196
 pyconvexity/core/database.py,sha256=vwCmuN0B0xwImh6L0bFR4vNWHw_wVfYSG1KwsUjK4iY,14831
@@ -9,9 +10,9 @@ pyconvexity/data/README.md,sha256=-tyDHVjqzfWbVvgM4yYYx8cysmgvFXI6plVQNxSHBmo,31
 pyconvexity/data/__init__.py,sha256=CFFwuIKS0qBk0HVLSByOK-oA5qm4krstJTUGFwUZyjo,509
 pyconvexity/data/loaders/__init__.py,sha256=6xPtOmH2n1mNby7ZjA-2Mk9F48Q246RNsyMnCnJ6gwA,60
 pyconvexity/data/loaders/cache.py,sha256=R-DUIiFpphjyi5EitcUZwzwUdZeqN6poYVyuNpKzB4g,7040
-pyconvexity/data/schema/01_core_schema.sql,sha256=xCCxUl65IGYxaMxAbgZVS7jVceRUJ_wOMw5c7cm6_Ww,16903
+pyconvexity/data/schema/01_core_schema.sql,sha256=8uz5_adp5IdW9kqrpK9pAlaWpeyHQFIej5GhhElSYu4,16902
 pyconvexity/data/schema/02_data_metadata.sql,sha256=BbpTkH1s7IbZQkDBRF2kL_UR9tzMEWDBYS3VBkwDRu0,4323
-pyconvexity/data/schema/03_validation_data.sql,sha256=Y4iZ1RzqMzeaBWalecT6BRd8I3MSW5nclXJI3cE_JAQ,88663
+pyconvexity/data/schema/03_validation_data.sql,sha256=fepFx1n-Gvls-MbGmVOEhxp82xFZXfNitpNw5k6R_IM,89083
 pyconvexity/data/sources/__init__.py,sha256=Dn6_oS7wB-vLjMj2YeXlmIl6hNjACbicimSabKxIWnc,108
 pyconvexity/data/sources/gem.py,sha256=v8OYCMsb2t-8u-YmK8vzMsgI9ArUAOAXMZZQOFpJ-nI,14923
 pyconvexity/io/__init__.py,sha256=FCyvRDfBUrrNei-y5JVod6MMN1bkPMSSfE0fpKi1aKQ,751
@@ -27,16 +28,17 @@ pyconvexity/models/network.py,sha256=P2Cuxv2lX9gWDwIBDDFqLs1sznhAXYquYNYstaMPjfU
 pyconvexity/models/results.py,sha256=6j1H4AwVmp94L97gl_sGnE8izMxkU5o89guKIU8JdtE,4169
 pyconvexity/models/scenarios.py,sha256=-0UPUDXf6r9mFriA-z2fD5KKMARm2PUBjLba49S9mCI,5867
 pyconvexity/solvers/__init__.py,sha256=t1gOUTqbYDCtIvKPqGVY1fjKwqJi2Od9bGeIO7bPvJE,667
-pyconvexity/solvers/pypsa/__init__.py,sha256=nudu0AOYEfPhpGHZ1Q9pUgjGeeIJd_zeULc975iyluE,555
+pyconvexity/solvers/pypsa/__init__.py,sha256=W3kmb8a5M0t9ktyf-1NIBcCGLN723RnNk12N2uFAjBM,881
 pyconvexity/solvers/pypsa/api.py,sha256=CWKslptTlZrSbuHy916_PHhCG8nO9SCfjTXkJZylLM8,17512
 pyconvexity/solvers/pypsa/batch_loader.py,sha256=ZgOcZqMnMS3TOYTq2Ly2O4cuwhNNAicu3EDq1Fj38OI,11929
 pyconvexity/solvers/pypsa/builder.py,sha256=1ZU68Wtl_jQSXHzspKQDkR6bxAVU1nKvPfnPUl0aO3k,23256
+pyconvexity/solvers/pypsa/clearing_price.py,sha256=HdAk7GPfJFVI4t6mL0zQGEOMAvuyfpl0yNCnah1ZGH0,29164
 pyconvexity/solvers/pypsa/constraints.py,sha256=20WliFDhPQGMAsS4VOTU8LZJpsFpLVRHpNsZW49GTcc,16397
 pyconvexity/solvers/pypsa/solver.py,sha256=M-s-VUCnRD8Jdh22PCUA-gWgYp1eH6_sgpoSzcv6kNQ,59762
-pyconvexity/solvers/pypsa/storage.py,sha256=C8zLPXSd95LT0Aq6c00vZu1xlJHEF_l8RDUhB-s5mJ0,91704
+pyconvexity/solvers/pypsa/storage.py,sha256=0C5WBHjm5gnU7KOqPogWE_j6dS_ZOv5JFSVM-1GY2DE,96100
 pyconvexity/validation/__init__.py,sha256=VJNZlFoWABsWwUKktNk2jbtXIepH5omvC0WtsTS7o3o,583
 pyconvexity/validation/rules.py,sha256=GiNadc8hvbWBr09vUkGiLLTmSdvtNSeGLFwvCjlikYY,9241
-pyconvexity-0.4.6.post1.dist-info/METADATA,sha256=42uMFhx4muAr2ZyGYa00osp9K_ifn5l14814yYyHkis,4973
-pyconvexity-0.4.6.post1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyconvexity-0.4.6.post1.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
-pyconvexity-0.4.6.post1.dist-info/RECORD,,
+pyconvexity-0.4.8.post1.dist-info/METADATA,sha256=hd4yVPZttXDtysXtC-y_E3qxNz2nD173nUAiavPaBEA,4973
+pyconvexity-0.4.8.post1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyconvexity-0.4.8.post1.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
+pyconvexity-0.4.8.post1.dist-info/RECORD,,