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

pyconvexity/io/excel_exporter.py

@@ -15,97 +15,104 @@ import json
 from pyconvexity.core.database import open_connection
 from pyconvexity.core.errors import AttributeNotFound
 from pyconvexity.models import (
-    list_components_by_type, list_carriers, get_network_info,
-    get_network_time_periods, get_attribute, list_component_attributes,
-    get_network_config
+    list_components_by_type,
+    list_carriers,
+    get_network_info,
+    get_network_time_periods,
+    get_attribute,
+    list_component_attributes,
+    get_network_config,
 )
 from pyconvexity.validation import list_validation_rules
 from pyconvexity.models.attributes import get_timeseries as get_timeseries_conn
 
 logger = logging.getLogger(__name__)
 
+
 class ExcelModelExporter:
     """Export entire network model to Excel workbook"""
-    
+
     def __init__(self):
         self.logger = logging.getLogger(__name__)
-    
+
     def export_model_to_excel(
         self,
         db_path: str,
-        network_id: int,
         output_path: str,
         scenario_id: Optional[int] = None,
-        progress_callback: Optional[callable] = None
+        progress_callback: Optional[callable] = None,
     ) -> Dict[str, Any]:
         """
         Export complete network model to Excel workbook
-        
+
         Args:
             db_path: Database path
-            network_id: Network ID to export
+
             output_path: Excel file output path
             scenario_id: Scenario ID (defaults to master scenario)
             progress_callback: Optional callback for progress updates
-            
+
         Returns:
             Export statistics and metadata
         """
-        
+
         try:
             if progress_callback:
                 progress_callback(0, "Starting Excel export...")
-            
+
             # Connect to database
             conn = open_connection(db_path)
-            
+
             if progress_callback:
                 progress_callback(5, "Loading network information...")
-            
+
             # Get network information
-            network_info = get_network_info(conn, network_id)
-            
+            network_info = get_network_info(conn)
+
             # Get master scenario if no scenario specified
             if scenario_id is None:
-                cursor = conn.execute(
-                    "SELECT id FROM scenarios WHERE network_id = ? AND is_master = TRUE",
-                    (network_id,)
-                )
-                scenario_result = cursor.fetchone()
-                if scenario_result:
-                    scenario_id = scenario_result[0]
-                else:
-                    raise ValueError("No master scenario found for network")
-            
+                # Base network uses scenario_id = NULL, no need to query
+                # scenario_id remains None for base network
+                pass
+
             if progress_callback:
                 progress_callback(10, "Loading carriers...")
-            
+
             # Get carriers
-            carriers = list_carriers(conn, network_id)
-            
+            carriers = list_carriers(conn)
+
             if progress_callback:
                 progress_callback(15, "Loading components...")
-            
+
             # Get all component types
-            component_types = ['BUS', 'GENERATOR', 'LOAD', 'LINE', 'LINK', 'STORAGE_UNIT', 'STORE', 'CONSTRAINT']
-            
+            component_types = [
+                "BUS",
+                "GENERATOR",
+                "LOAD",
+                "LINE",
+                "LINK",
+                "STORAGE_UNIT",
+                "STORE",
+                "CONSTRAINT",
+            ]
+
             # Load components by type
             components_by_type = {}
             for comp_type in component_types:
-                components = list_components_by_type(conn, network_id, comp_type)
+                components = list_components_by_type(conn, comp_type)
                 components_by_type[comp_type] = components
-            
+
             if progress_callback:
                 progress_callback(25, "Processing component attributes...")
-            
+
             # Process components and their attributes
             processed_components = {}
             timeseries_data = {}
-            
+
             for comp_type, components in components_by_type.items():
                 processed_components[comp_type] = []
                 timeseries_data[comp_type] = {}
-                
+
                 for component in components:
                     # Check for cancellation during processing
                     if progress_callback:
@@ -114,35 +121,41 @@ class ExcelModelExporter:
                         except KeyboardInterrupt:
                             self.logger.info("Excel export cancelled by user")
                             raise
-                    
+
                     # Get component attributes (all possible attributes for this component type)
-                    attributes = self._get_component_attributes(conn, component.id, scenario_id, comp_type)
-                    
+                    attributes = self._get_component_attributes(
+                        conn, component.id, scenario_id, comp_type
+                    )
+
                     # Process component data
                     processed_component = self._process_component_for_excel(
                         component, attributes, carriers, components_by_type
                     )
                     processed_components[comp_type].append(processed_component)
-                    
+
                     # Extract timeseries data
                     for attr_name, attr_data in attributes.items():
-                        if isinstance(attr_data, dict) and 'Timeseries' in attr_data:
+                        if isinstance(attr_data, dict) and "Timeseries" in attr_data:
                             if comp_type not in timeseries_data:
                                 timeseries_data[comp_type] = {}
                             if attr_name not in timeseries_data[comp_type]:
                                 timeseries_data[comp_type][attr_name] = {}
-                            
+
                             # Handle both new efficient format and legacy format
-                            if 'values' in attr_data:
+                            if "values" in attr_data:
                                 # New efficient format - store values directly
-                                timeseries_data[comp_type][attr_name][component.name] = attr_data['values']
-                            elif 'points' in attr_data:
+                                timeseries_data[comp_type][attr_name][
+                                    component.name
+                                ] = attr_data["values"]
+                            elif "points" in attr_data:
                                 # Legacy format - store the timeseries points
-                                timeseries_data[comp_type][attr_name][component.name] = attr_data['points']
-            
+                                timeseries_data[comp_type][attr_name][
+                                    component.name
+                                ] = attr_data["points"]
+
             if progress_callback:
                 progress_callback(50, "Creating Excel workbook...")
-            
+
             # Check for cancellation before starting Excel creation
             if progress_callback:
                 try:
@@ -150,17 +163,19 @@ class ExcelModelExporter:
                 except KeyboardInterrupt:
                     self.logger.info("Excel export cancelled before workbook creation")
                     raise
-            
+
             # Get scenario information if scenario_id is provided
             scenario_info = None
             if scenario_id is not None:
                 scenario_info = self._get_scenario_info(conn, scenario_id)
-            
+
             # Create Excel workbook
-            with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
+            with pd.ExcelWriter(output_path, engine="openpyxl") as writer:
                 # Create overview sheet
-                self._create_overview_sheet(writer, network_info, processed_components, scenario_info)
-                
+                self._create_overview_sheet(
+                    writer, network_info, processed_components, scenario_info
+                )
+
                 # Create component sheets
                 for comp_type in component_types:
                     if processed_components[comp_type]:
@@ -169,61 +184,67 @@ class ExcelModelExporter:
                             try:
                                 progress_callback(None, None)  # Check for cancellation
                             except KeyboardInterrupt:
-                                self.logger.info(f"Excel export cancelled during {comp_type} sheet creation")
+                                self.logger.info(
+                                    f"Excel export cancelled during {comp_type} sheet creation"
+                                )
                                 raise
-                        
-                        self._create_component_sheet(writer, conn, comp_type, processed_components[comp_type])
-                        
+
+                        self._create_component_sheet(
+                            writer, conn, comp_type, processed_components[comp_type]
+                        )
+
                         # Create timeseries sheet if there's timeseries data
                         if comp_type in timeseries_data and timeseries_data[comp_type]:
                             self._create_timeseries_sheet(
-                                writer, comp_type, timeseries_data[comp_type], network_id, conn
+                                writer, comp_type, timeseries_data[comp_type], conn
                             )
-                
+
                 # Create carriers sheet
                 self._create_carriers_sheet(writer, carriers)
-                
+
                 # Create network config sheet
-                self._create_network_config_sheet(writer, network_id, conn)
-                
+                self._create_network_config_sheet(writer, conn)
+
                 # Create statistics sheet if solve results are available
-                self._create_statistics_sheet(writer, network_id, scenario_id, conn)
-                
+                self._create_statistics_sheet(writer, scenario_id, conn)
+
                 # Create per-year statistics sheet if available
-                self._create_per_year_statistics_sheet(writer, network_id, scenario_id, conn)
-            
+                self._create_per_year_statistics_sheet(writer, scenario_id, conn)
+
             if progress_callback:
                 progress_callback(100, "Excel export completed")
-            
+
             # Calculate statistics
             stats = self._calculate_export_stats(processed_components, timeseries_data)
-            
+
             return {
                 "success": True,
                 "message": f"Network exported to Excel: {output_path}",
                 "output_path": output_path,
-                "stats": stats
+                "stats": stats,
             }
-            
+
         except Exception as e:
             self.logger.error(f"Excel export failed: {e}", exc_info=True)
             if progress_callback:
                 progress_callback(None, f"Export failed: {str(e)}")
             raise
-    
-    def _get_component_attributes(self, conn, component_id: int, scenario_id: int, component_type: str) -> Dict[str, Any]:
+
+    def _get_component_attributes(
+        self, conn, component_id: int, scenario_id: int, component_type: str
+    ) -> Dict[str, Any]:
         """Get all possible attributes for a component type, with values where set"""
         attributes = {}
-        
+
         # Get ALL possible attribute names for this component type from validation rules
         validation_rules = list_validation_rules(conn, component_type)
-        
+
         for rule in validation_rules:
             attr_name = rule.attribute_name
             try:
                 # Try to get the attribute value (may not exist)
                 attr_value = get_attribute(conn, component_id, attr_name, scenario_id)
-                
+
                 if attr_value.variant == "Static":
                     # Extract static value
                     static_value = attr_value.static_value
@@ -237,294 +258,394 @@ class ExcelModelExporter:
                         attributes[attr_name] = static_value.data["String"]
                     else:
                         attributes[attr_name] = static_value.data
-                        
+
                 elif attr_value.variant == "Timeseries":
                     # Use new efficient timeseries access
                     try:
-                        timeseries = get_timeseries_conn(conn, component_id, attr_name, scenario_id)
+                        timeseries = get_timeseries_conn(
+                            conn, component_id, attr_name, scenario_id
+                        )
                         if timeseries and timeseries.values:
                             attributes[attr_name] = {
-                                'Timeseries': True,
-                                'values': timeseries.values
+                                "Timeseries": True,
+                                "values": timeseries.values,
                             }
                         else:
                             # Fallback to legacy method if new method fails
                             attributes[attr_name] = {
-                                'Timeseries': True,
-                                'points': attr_value.timeseries_value
+                                "Timeseries": True,
+                                "points": attr_value.timeseries_value,
                             }
                     except Exception as ts_e:
-                        self.logger.warning(f"Failed to load timeseries {attr_name} for component {component_id}: {ts_e}")
+                        self.logger.warning(
+                            f"Failed to load timeseries {attr_name} for component {component_id}: {ts_e}"
+                        )
                         # Fallback to legacy method
                         attributes[attr_name] = {
-                            'Timeseries': True,
-                            'points': attr_value.timeseries_value
+                            "Timeseries": True,
+                            "points": attr_value.timeseries_value,
                         }
-                    
+
             except AttributeNotFound:
                 # Attribute not set - always use empty string for blank Excel cell
                 attributes[attr_name] = ""
-                        
+
             except Exception as e:
-                self.logger.warning(f"Failed to load attribute {attr_name} for component {component_id}: {e}")
+                self.logger.warning(
+                    f"Failed to load attribute {attr_name} for component {component_id}: {e}"
+                )
                 # Still include the attribute with empty value
                 attributes[attr_name] = ""
                 continue
-        
+
         return attributes
-    
-    def _process_component_for_excel(self, component, attributes: Dict, carriers: List, components_by_type: Dict) -> Dict[str, Any]:
+
+    def _process_component_for_excel(
+        self, component, attributes: Dict, carriers: List, components_by_type: Dict
+    ) -> Dict[str, Any]:
         """Process a component for Excel export"""
         processed = {
-            'name': component.name,
-            'type': component.component_type.lower(),
+            "name": component.name,
+            "type": component.component_type.lower(),
         }
-        
+
         # Add carrier name
         if component.carrier_id:
-            carrier = next((c for c in carriers if c['id'] == component.carrier_id), None)
-            carrier_name = carrier['name'] if carrier else 'CARRIER_NOT_FOUND'
-            processed['carrier'] = carrier_name
-            self.logger.info(f"Component '{component.name}' has carrier_id={component.carrier_id}, resolved to carrier: {carrier_name}")
+            # Carriers are objects with attributes, not dictionaries
+            carrier = next((c for c in carriers if c.id == component.carrier_id), None)
+            carrier_name = carrier.name if carrier else "CARRIER_NOT_FOUND"
+            processed["carrier"] = carrier_name
+            self.logger.info(
+                f"Component '{component.name}' has carrier_id={component.carrier_id}, resolved to carrier: {carrier_name}"
+            )
         else:
-            processed['carrier'] = ''  # Use empty string for no carrier
-            self.logger.info(f"Component '{component.name}' has no carrier_id (carrier_id={component.carrier_id})")
-        
+            processed["carrier"] = ""  # Use empty string for no carrier
+            self.logger.info(
+                f"Component '{component.name}' has no carrier_id (carrier_id={component.carrier_id})"
+            )
+
         # Add bus connections
         if component.bus_id:
-            bus = next((b for b in components_by_type.get('BUS', []) if b.id == component.bus_id), None)
-            processed['bus'] = bus.name if bus else ''
+            bus = next(
+                (
+                    b
+                    for b in components_by_type.get("BUS", [])
+                    if b.id == component.bus_id
+                ),
+                None,
+            )
+            processed["bus"] = bus.name if bus else ""
         else:
-            processed['bus'] = ''
-        
+            processed["bus"] = ""
+
         if component.bus0_id:
-            bus0 = next((b for b in components_by_type.get('BUS', []) if b.id == component.bus0_id), None)
-            processed['bus0'] = bus0.name if bus0 else ''
+            bus0 = next(
+                (
+                    b
+                    for b in components_by_type.get("BUS", [])
+                    if b.id == component.bus0_id
+                ),
+                None,
+            )
+            processed["bus0"] = bus0.name if bus0 else ""
         else:
-            processed['bus0'] = ''
-        
+            processed["bus0"] = ""
+
         if component.bus1_id:
-            bus1 = next((b for b in components_by_type.get('BUS', []) if b.id == component.bus1_id), None)
-            processed['bus1'] = bus1.name if bus1 else ''
+            bus1 = next(
+                (
+                    b
+                    for b in components_by_type.get("BUS", [])
+                    if b.id == component.bus1_id
+                ),
+                None,
+            )
+            processed["bus1"] = bus1.name if bus1 else ""
         else:
-            processed['bus1'] = ''
-        
+            processed["bus1"] = ""
+
         # Add coordinates
-        processed['latitude'] = component.latitude if component.latitude is not None else ''
-        processed['longitude'] = component.longitude if component.longitude is not None else ''
-        
+        processed["latitude"] = (
+            component.latitude if component.latitude is not None else ""
+        )
+        processed["longitude"] = (
+            component.longitude if component.longitude is not None else ""
+        )
+
         # Add attributes
         for attr_name, attr_value in attributes.items():
-            if isinstance(attr_value, dict) and 'Timeseries' in attr_value:
-                processed[attr_name] = '[timeseries]'
+            if isinstance(attr_value, dict) and "Timeseries" in attr_value:
+                processed[attr_name] = "[timeseries]"
             else:
                 # Special handling for carrier attribute - don't overwrite relationship carrier
-                if attr_name == 'carrier':
+                if attr_name == "carrier":
                     if component.carrier_id is not None:
-                        self.logger.info(f"DEBUG: Skipping carrier attribute '{attr_value}' for '{component.name}' - using relationship carrier '{processed['carrier']}'")
+                        self.logger.info(
+                            f"DEBUG: Skipping carrier attribute '{attr_value}' for '{component.name}' - using relationship carrier '{processed['carrier']}'"
+                        )
                         continue  # Skip the carrier attribute, keep the relationship carrier
                     else:
-                        self.logger.info(f"DEBUG: Using carrier attribute '{attr_value}' for '{component.name}' (no relationship carrier)")
-                
+                        self.logger.info(
+                            f"DEBUG: Using carrier attribute '{attr_value}' for '{component.name}' (no relationship carrier)"
+                        )
+
                 processed[attr_name] = attr_value
-        
-        self.logger.info(f"DEBUG: Final processed data for '{component.name}': carrier='{processed.get('carrier', 'NOT_SET')}'")
+
+        self.logger.info(
+            f"DEBUG: Final processed data for '{component.name}': carrier='{processed.get('carrier', 'NOT_SET')}'"
+        )
         return processed
-    
-    def _filter_component_columns(self, conn, component_data: Dict[str, Any], component_type: str) -> Dict[str, Any]:
+
+    def _filter_component_columns(
+        self, conn, component_data: Dict[str, Any], component_type: str
+    ) -> Dict[str, Any]:
         """Filter out unused columns based on component type, following DatabaseTable logic"""
-        
+
         filtered_data = {}
-        
+
         # Always include basic fields (name, carrier, latitude, longitude)
         # Note: bus connections are NOT basic fields - they are component-type specific
         # Note: "type" is NOT included - it's implicit based on the sheet/component type
         # Note: CONSTRAINT components don't have carrier, latitude, or longitude - they are code-based rules
-        if component_type.upper() == 'CONSTRAINT':
-            basic_fields = ['name']  # Constraints only have name - no physical location or carrier
+        if component_type.upper() == "CONSTRAINT":
+            basic_fields = [
+                "name"
+            ]  # Constraints only have name - no physical location or carrier
         else:
-            basic_fields = ['name', 'carrier', 'latitude', 'longitude']
-        
+            basic_fields = ["name", "carrier", "latitude", "longitude"]
+
         for field in basic_fields:
             if field in component_data:
                 filtered_data[field] = component_data[field]
-                self.logger.info(f"Added basic field '{field}' = '{component_data[field]}' for component type {component_type}")
-                if field == 'carrier':
-                    self.logger.info(f"DEBUG: Setting carrier field to '{component_data[field]}' from component_data")
-        
+                self.logger.info(
+                    f"Added basic field '{field}' = '{component_data[field]}' for component type {component_type}"
+                )
+                if field == "carrier":
+                    self.logger.info(
+                        f"DEBUG: Setting carrier field to '{component_data[field]}' from component_data"
+                    )
+
         # Add bus connection columns based on component type - EXACT DatabaseTable logic
         component_type_lower = component_type.lower()
-        needs_bus_connection = component_type_lower in ['generator', 'load', 'storage_unit', 'store', 'unmet_load']
-        needs_two_bus_connections = component_type_lower in ['line', 'link']
-        
+        needs_bus_connection = component_type_lower in [
+            "generator",
+            "load",
+            "storage_unit",
+            "store",
+            "unmet_load",
+        ]
+        needs_two_bus_connections = component_type_lower in ["line", "link"]
 
         if needs_bus_connection:
-            if 'bus' in component_data:
-                filtered_data['bus'] = component_data['bus']
+            if "bus" in component_data:
+                filtered_data["bus"] = component_data["bus"]
         elif needs_two_bus_connections:
-            if 'bus0' in component_data:
-                filtered_data['bus0'] = component_data['bus0']
-            if 'bus1' in component_data:
-                filtered_data['bus1'] = component_data['bus1']
+            if "bus0" in component_data:
+                filtered_data["bus0"] = component_data["bus0"]
+            if "bus1" in component_data:
+                filtered_data["bus1"] = component_data["bus1"]
         else:
             # Buses and other components don't get bus connection columns
             self.logger.info(f"No bus connection columns for {component_type_lower}")
-        
+
         # Get validation rules to determine which attributes are input vs output
         try:
-            
+
             # Add all other attributes that aren't filtered out
             for key, value in component_data.items():
                 if key in filtered_data:
                     continue  # Already handled
-                    
+
                 # Filter out unused attributes following DatabaseTable logic
                 should_exclude = False
                 exclude_reason = ""
-                
+
                 # Note: Carrier attribute exclusion is now handled in _process_component_for_excel
                 # to prevent overwriting relationship carriers
-                
+
                 # Remove location and carrier attributes for CONSTRAINT components (they don't have physical location or carriers)
-                if component_type.upper() == 'CONSTRAINT' and key in ['carrier', 'latitude', 'longitude']:
+                if component_type.upper() == "CONSTRAINT" and key in [
+                    "carrier",
+                    "latitude",
+                    "longitude",
+                ]:
                     should_exclude = True
-                    exclude_reason = f"constraint exclusion - constraints don't have {key}"
-                    
+                    exclude_reason = (
+                        f"constraint exclusion - constraints don't have {key}"
+                    )
+
                 # Remove 'type' and 'unit' attributes for buses (not used in this application)
-                elif component_type.upper() == 'BUS' and key in ['type', 'unit']:
+                elif component_type.upper() == "BUS" and key in ["type", "unit"]:
                     should_exclude = True
                     exclude_reason = f"bus-specific exclusion ({key})"
-                    
+
                 # Remove 'x' and 'y' coordinates for buses only - we use latitude/longitude instead
-                elif component_type.upper() == 'BUS' and key in ['x', 'y']:
+                elif component_type.upper() == "BUS" and key in ["x", "y"]:
                     should_exclude = True
                     exclude_reason = f"bus coordinate exclusion ({key})"
-                    
+
                 # Remove sub-network and slack generator attributes for buses
-                elif component_type.upper() == 'BUS' and key in ['sub_network', 'slack_generator']:
+                elif component_type.upper() == "BUS" and key in [
+                    "sub_network",
+                    "slack_generator",
+                ]:
                     should_exclude = True
                     exclude_reason = f"bus network exclusion ({key})"
-                
+
                 # CRITICAL: Remove bus connection columns for components that shouldn't have them
-                elif key in ['bus', 'bus0', 'bus1']:
-                    if key == 'bus' and not needs_bus_connection:
+                elif key in ["bus", "bus0", "bus1"]:
+                    if key == "bus" and not needs_bus_connection:
                         should_exclude = True
-                        exclude_reason = f"bus connection not needed for {component_type_lower}"
-                    elif key in ['bus0', 'bus1'] and not needs_two_bus_connections:
+                        exclude_reason = (
+                            f"bus connection not needed for {component_type_lower}"
+                        )
+                    elif key in ["bus0", "bus1"] and not needs_two_bus_connections:
                         should_exclude = True
-                        exclude_reason = f"two-bus connection not needed for {component_type_lower}"
-                
-                
+                        exclude_reason = (
+                            f"two-bus connection not needed for {component_type_lower}"
+                        )
+
                 if should_exclude:
                     self.logger.info(f"Excluded {key}: {exclude_reason}")
                 else:
                     # Special handling for carrier attribute - don't overwrite relationship field
-                    if key == 'carrier' and 'carrier' in filtered_data:
-                        self.logger.info(f"Skipping carrier attribute '{value}' - keeping relationship carrier '{filtered_data['carrier']}'")
+                    if key == "carrier" and "carrier" in filtered_data:
+                        self.logger.info(
+                            f"Skipping carrier attribute '{value}' - keeping relationship carrier '{filtered_data['carrier']}'"
+                        )
                     else:
                         filtered_data[key] = value
                         self.logger.info(f"Added attribute: {key} = {value}")
-        
+
         except Exception as e:
             self.logger.warning(f"Could not load validation rules for filtering: {e}")
             # Fallback: include all attributes except the basic exclusions
             for key, value in component_data.items():
                 if key in filtered_data:
                     continue
-                if key == 'carrier':  # Skip carrier attribute
+                if key == "carrier":  # Skip carrier attribute
                     continue
                 filtered_data[key] = value
-        
-        
+
         return filtered_data
-    
-    def _create_overview_sheet(self, writer, network_info: Dict, processed_components: Dict, scenario_info: Dict = None):
+
+    def _create_overview_sheet(
+        self,
+        writer,
+        network_info: Dict,
+        processed_components: Dict,
+        scenario_info: Dict = None,
+    ):
         """Create overview sheet with network metadata"""
         # Create key-value pairs as separate lists for two columns
         keys = []
         values = []
-        
+
         # Network information
-        keys.extend(['Name', 'Description', 'Time Start', 'Time End', 'Time Interval'])
-        values.extend([
-            network_info['name'],
-            network_info.get('description', ''),
-            network_info['time_start'],
-            network_info['time_end'],
-            network_info['time_interval']
-        ])
-        
+        keys.extend(["Name", "Description", "Time Start", "Time End", "Time Interval"])
+        values.extend(
+            [
+                network_info["name"],
+                network_info.get("description", ""),
+                network_info["time_start"],
+                network_info["time_end"],
+                network_info["time_interval"],
+            ]
+        )
+
         # Scenario information
         if scenario_info:
-            keys.append('')
-            values.append('')
-            keys.extend(['Scenario Information', 'Scenario Name', 'Scenario Description', 'Is Master Scenario', 'Scenario Created'])
-            values.extend([
-                '',
-                scenario_info.get('name', 'Unknown'),
-                scenario_info.get('description', '') or 'No description',
-                'Yes' if scenario_info.get('is_master', False) else 'No',
-                scenario_info.get('created_at', '')
-            ])
-        
+            keys.append("")
+            values.append("")
+            keys.extend(
+                [
+                    "Scenario Information",
+                    "Scenario Name",
+                    "Scenario Description",
+                    "Is Master Scenario",
+                    "Scenario Created",
+                ]
+            )
+            values.extend(
+                [
+                    "",
+                    scenario_info.get("name", "Unknown"),
+                    scenario_info.get("description", "") or "No description",
+                    "Yes" if scenario_info.get("is_master", False) else "No",
+                    scenario_info.get("created_at", ""),
+                ]
+            )
+
         # Empty row
-        keys.append('')
-        values.append('')
-        
+        keys.append("")
+        values.append("")
+
         # Export information
-        keys.extend(['Export Information', 'Export Date', 'Export Version'])
-        values.extend(['', datetime.now().strftime('%Y-%m-%d %H:%M:%S'), self._get_app_version()])
-        
+        keys.extend(["Export Information", "Export Date", "Export Version"])
+        values.extend(
+            ["", datetime.now().strftime("%Y-%m-%d %H:%M:%S"), self._get_app_version()]
+        )
+
         # Create two-column DataFrame
-        df = pd.DataFrame({
-            'Property': keys,
-            'Value': values
-        })
-        df.to_excel(writer, sheet_name='Overview', index=False)
-    
+        df = pd.DataFrame({"Property": keys, "Value": values})
+        df.to_excel(writer, sheet_name="Overview", index=False)
+
     def _get_scenario_info(self, conn, scenario_id: int) -> Dict[str, Any]:
         """Get scenario information from database"""
         try:
-            cursor = conn.execute("""
-                SELECT id, network_id, name, description, is_master, created_at
+            cursor = conn.execute(
+                """
+                SELECT id, name, description, created_at
                 FROM scenarios 
                 WHERE id = ?
-            """, (scenario_id,))
-            
+            """,
+                (scenario_id,),
+            )
+
             row = cursor.fetchone()
             if not row:
                 self.logger.warning(f"No scenario found with ID {scenario_id}")
                 return {}
-            
+
             return {
-                'id': row[0],
-                'network_id': row[1],
-                'name': row[2],
-                'description': row[3],
-                'is_master': bool(row[4]),
-                'created_at': row[5]
+                "id": row[0],
+                "name": row[1],
+                "description": row[2],
+                "created_at": row[3],
             }
-            
+
         except Exception as e:
             self.logger.warning(f"Failed to retrieve scenario info: {e}")
             return {}
-    
-    def _create_component_sheet(self, writer, conn, component_type: str, components: List[Dict]):
+
+    def _create_component_sheet(
+        self, writer, conn, component_type: str, components: List[Dict]
+    ):
         """Create a sheet for a specific component type"""
         if not components:
             return
-        
+
         # Apply column filtering to each component
         filtered_components = []
         for component in components:
-            filtered_component = self._filter_component_columns(conn, component, component_type)
+            filtered_component = self._filter_component_columns(
+                conn, component, component_type
+            )
             filtered_components.append(filtered_component)
-        
+
         # Convert to DataFrame
         df = pd.DataFrame(filtered_components)
-        
+
         # Reorder columns to put core fields first
-        core_columns = ['name', 'carrier', 'bus', 'bus0', 'bus1', 'latitude', 'longitude']
+        core_columns = [
+            "name",
+            "carrier",
+            "bus",
+            "bus0",
+            "bus1",
+            "latitude",
+            "longitude",
+        ]
         other_columns = []
         for col in df.columns:
             if col not in core_columns:
@@ -534,459 +655,552 @@ class ExcelModelExporter:
             if col in df.columns:
                 ordered_columns.append(col)
         ordered_columns.extend(other_columns)
-        
+
         df = df[ordered_columns]
-        
+
         # Write to Excel with proper pluralization
         sheet_name_mapping = {
-            'BUS': 'Buses',
-            'GENERATOR': 'Generators', 
-            'LOAD': 'Loads',
-            'LINE': 'Lines',
-            'LINK': 'Links',
-            'STORAGE_UNIT': 'Storage Units',
-            'STORE': 'Stores',
-            'CONSTRAINT': 'Constraints'
+            "BUS": "Buses",
+            "GENERATOR": "Generators",
+            "LOAD": "Loads",
+            "LINE": "Lines",
+            "LINK": "Links",
+            "STORAGE_UNIT": "Storage Units",
+            "STORE": "Stores",
+            "CONSTRAINT": "Constraints",
         }
-        sheet_name = sheet_name_mapping.get(component_type, f"{component_type.title()}s")
+        sheet_name = sheet_name_mapping.get(
+            component_type, f"{component_type.title()}s"
+        )
         df.to_excel(writer, sheet_name=sheet_name, index=False)
-    
-    def _create_timeseries_sheet(self, writer, component_type: str, timeseries_data: Dict, network_id: int, conn):
+
+    def _create_timeseries_sheet(
+        self, writer, component_type: str, timeseries_data: Dict, conn
+    ):
         """Create a timeseries sheet for a component type"""
         # Get network time periods
-        time_periods = get_network_time_periods(conn, network_id)
+        time_periods = get_network_time_periods(conn)
         if not time_periods:
-            self.logger.warning(f"No time periods found for network {network_id}, skipping timeseries sheet for {component_type}")
+            self.logger.warning(
+                f"No time periods found, skipping timeseries sheet for {component_type}"
+            )
             return
-        
-        self.logger.info(f"Creating timeseries sheet for {component_type} with {len(time_periods)} time periods")
-        self.logger.info(f"First few time periods: {[(p.formatted_time, p.timestamp, p.period_index) for p in time_periods[:3]]}")
-        
+
+        self.logger.info(
+            f"Creating timeseries sheet for {component_type} with {len(time_periods)} time periods"
+        )
+        self.logger.info(
+            f"First few time periods: {[(p.formatted_time, p.timestamp, p.period_index) for p in time_periods[:3]]}"
+        )
+
         # Create DataFrame with human-readable timestamps
-        timestamps = [period.formatted_time for period in time_periods]  # Use formatted_time instead of timestamp
-        df_data = {'timestamp': timestamps}
-        
+        timestamps = [
+            period.formatted_time for period in time_periods
+        ]  # Use formatted_time instead of timestamp
+        df_data = {"timestamp": timestamps}
+
         # Add component columns for each attribute
         for attr_name, component_data in timeseries_data.items():
             for component_name, timeseries_data_item in component_data.items():
                 if isinstance(timeseries_data_item, list):
                     # Handle efficient format (list of values)
                     values = timeseries_data_item
-                    
+
                     # Pad or truncate to match time periods
                     while len(values) < len(timestamps):
                         values.append(0)
-                    values = values[:len(timestamps)]
+                    values = values[: len(timestamps)]
                     df_data[f"{component_name}_{attr_name}"] = values
-        
+
         df = pd.DataFrame(df_data)
         sheet_name = f"{component_type.title()} Timeseries"
         df.to_excel(writer, sheet_name=sheet_name, index=False)
-        self.logger.info(f"Created timeseries sheet '{sheet_name}' with {len(df)} rows and {len(df.columns)} columns")
-    
+        self.logger.info(
+            f"Created timeseries sheet '{sheet_name}' with {len(df)} rows and {len(df.columns)} columns"
+        )
+
     def _create_carriers_sheet(self, writer, carriers: List[Dict]):
         """Create carriers sheet"""
         if not carriers:
             return
-        
+
         df = pd.DataFrame(carriers)
-        df.to_excel(writer, sheet_name='Carriers', index=False)
-    
-    def _create_network_config_sheet(self, writer, network_id: int, conn):
+        df.to_excel(writer, sheet_name="Carriers", index=False)
+
+    def _create_network_config_sheet(self, writer, conn):
         """Create network configuration sheet"""
         try:
-            config = get_network_config(conn, network_id, None)  # Master scenario
+            config = get_network_config(conn, None)  # Master scenario
             if config:
                 config_data = []
                 for param_name, param_value in config.items():
-                    config_data.append({
-                        'Parameter': param_name,
-                        'Value': str(param_value),
-                        'Type': type(param_value).__name__,
-                        'Description': ''
-                    })
-                
+                    config_data.append(
+                        {
+                            "Parameter": param_name,
+                            "Value": str(param_value),
+                            "Type": type(param_value).__name__,
+                            "Description": "",
+                        }
+                    )
+
                 if config_data:
                     df = pd.DataFrame(config_data)
-                    df.to_excel(writer, sheet_name='Network Config', index=False)
+                    df.to_excel(writer, sheet_name="Network Config", index=False)
         except Exception as e:
             self.logger.warning(f"Could not create network config sheet: {e}")
-    
-    def _calculate_export_stats(self, processed_components: Dict, timeseries_data: Dict) -> Dict[str, Any]:
+
+    def _calculate_export_stats(
+        self, processed_components: Dict, timeseries_data: Dict
+    ) -> Dict[str, Any]:
         """Calculate export statistics"""
-        total_components = sum(len(components) for components in processed_components.values())
+        total_components = sum(
+            len(components) for components in processed_components.values()
+        )
         total_timeseries = sum(
-            len(attr_data) 
-            for comp_data in timeseries_data.values() 
+            len(attr_data)
+            for comp_data in timeseries_data.values()
             for attr_data in comp_data.values()
         )
-        
+
         return {
-            'total_components': total_components,
-            'total_timeseries': total_timeseries,
-            'component_types': len(processed_components),
-            'components_by_type': {
-                comp_type: len(components) 
+            "total_components": total_components,
+            "total_timeseries": total_timeseries,
+            "component_types": len(processed_components),
+            "components_by_type": {
+                comp_type: len(components)
                 for comp_type, components in processed_components.items()
-            }
-        } 
+            },
+        }
 
-    def _get_solve_results(self, conn, network_id: int, scenario_id: int) -> Optional[Dict[str, Any]]:
+    def _get_solve_results(
+        self, conn, scenario_id: Optional[int]
+    ) -> Optional[Dict[str, Any]]:
         """Get solve results from the database"""
         try:
-            cursor = conn.execute("""
+            cursor = conn.execute(
+                """
                 SELECT results_json, metadata_json, solver_name, solve_status, 
                        objective_value, solve_time_seconds, solved_at
                 FROM network_solve_results 
-                WHERE network_id = ? AND scenario_id = ?
-            """, (network_id, scenario_id))
-            
+                WHERE scenario_id = ? OR (scenario_id IS NULL AND ? IS NULL)
+            """,
+                (scenario_id, scenario_id),
+            )
+
             row = cursor.fetchone()
             if not row:
-                self.logger.info(f"No solve results found for network {network_id}, scenario {scenario_id}")
+                self.logger.info(f"No solve results found for scenario {scenario_id}")
                 return None
-            
-            results_json_str, metadata_json_str, solver_name, solve_status, objective_value, solve_time, solved_at = row
-            
+
+            (
+                results_json_str,
+                metadata_json_str,
+                solver_name,
+                solve_status,
+                objective_value,
+                solve_time,
+                solved_at,
+            ) = row
+
             # Parse the JSON results
             if results_json_str:
                 results = json.loads(results_json_str)
                 # Add metadata from the table columns
-                results['solver_name'] = solver_name
-                results['solve_status'] = solve_status
-                results['objective_value'] = objective_value
-                results['solve_time_seconds'] = solve_time
-                results['solved_at'] = solved_at
-                
+                results["solver_name"] = solver_name
+                results["solve_status"] = solve_status
+                results["objective_value"] = objective_value
+                results["solve_time_seconds"] = solve_time
+                results["solved_at"] = solved_at
+
                 if metadata_json_str:
                     metadata = json.loads(metadata_json_str)
-                    results['metadata'] = metadata
-                
+                    results["metadata"] = metadata
+
                 return results
-            
+
             return None
-            
+
         except Exception as e:
             self.logger.warning(f"Failed to retrieve solve results: {e}")
             return None
-    
-    def _get_solve_results_by_year(self, conn, network_id: int, scenario_id: int) -> Optional[Dict[int, Dict[str, Any]]]:
+
+    def _get_solve_results_by_year(
+        self, conn, scenario_id: Optional[int]
+    ) -> Optional[Dict[int, Dict[str, Any]]]:
         """Get per-year solve results from the database"""
         try:
-            cursor = conn.execute("""
+            cursor = conn.execute(
+                """
                 SELECT year, results_json, metadata_json
                 FROM network_solve_results_by_year 
-                WHERE network_id = ? AND scenario_id = ?
+                WHERE scenario_id = ? OR (scenario_id IS NULL AND ? IS NULL)
                 ORDER BY year
-            """, (network_id, scenario_id))
-            
+            """,
+                (scenario_id, scenario_id),
+            )
+
             rows = cursor.fetchall()
             if not rows:
-                self.logger.info(f"No per-year solve results found for network {network_id}, scenario {scenario_id}")
+                self.logger.info(
+                    f"No per-year solve results found for scenario {scenario_id}"
+                )
                 return None
-            
+
             year_results = {}
             for row in rows:
                 year, results_json_str, metadata_json_str = row
-                
+
                 if results_json_str:
                     year_data = json.loads(results_json_str)
-                    
+
                     # Add metadata if available
                     if metadata_json_str:
                         metadata = json.loads(metadata_json_str)
-                        year_data['metadata'] = metadata
-                    
+                        year_data["metadata"] = metadata
+
                     year_results[year] = year_data
-            
+
             return year_results if year_results else None
-            
+
         except Exception as e:
             self.logger.warning(f"Failed to retrieve per-year solve results: {e}")
             return None
-    
-    def _create_statistics_sheet(self, writer, network_id: int, scenario_id: int, conn):
+
+    def _create_statistics_sheet(self, writer, scenario_id: int, conn):
         """Create statistics sheet with full-run solve results (no per-year data)"""
         try:
             # Get solve results
-            solve_results = self._get_solve_results(conn, network_id, scenario_id)
+            solve_results = self._get_solve_results(conn, scenario_id)
             if not solve_results:
-                self.logger.info("No solve results available, skipping statistics sheet")
+                self.logger.info(
+                    "No solve results available, skipping statistics sheet"
+                )
                 return
-            
+
             # Prepare data for the statistics sheet
             stats_data = []
-            
+
             # Section 1: Solve Summary
-            stats_data.extend([
-                ['SOLVE SUMMARY', ''],
-                ['Solver Name', solve_results.get('solver_name', 'Unknown')],
-                ['Solve Status', solve_results.get('solve_status', 'Unknown')],
-                ['Solve Time (seconds)', solve_results.get('solve_time_seconds', 0)],
-                ['Objective Value', solve_results.get('objective_value', 0)],
-                ['Solved At', solve_results.get('solved_at', '')],
-                ['', '']  # Empty row separator
-            ])
-            
+            stats_data.extend(
+                [
+                    ["SOLVE SUMMARY", ""],
+                    ["Solver Name", solve_results.get("solver_name", "Unknown")],
+                    ["Solve Status", solve_results.get("solve_status", "Unknown")],
+                    [
+                        "Solve Time (seconds)",
+                        solve_results.get("solve_time_seconds", 0),
+                    ],
+                    ["Objective Value", solve_results.get("objective_value", 0)],
+                    ["Solved At", solve_results.get("solved_at", "")],
+                    ["", ""],  # Empty row separator
+                ]
+            )
+
             # Extract network statistics if available
-            network_stats = solve_results.get('network_statistics', {})
-            
+            network_stats = solve_results.get("network_statistics", {})
+
             # Section 2: Core Network Statistics
-            core_summary = network_stats.get('core_summary', {})
+            core_summary = network_stats.get("core_summary", {})
             if core_summary:
-                stats_data.extend([
-                    ['CORE NETWORK STATISTICS', ''],
-                    ['Total Generation (MWh)', core_summary.get('total_generation_mwh', 0)],
-                    ['Total Demand (MWh)', core_summary.get('total_demand_mwh', 0)],
-                    ['Total Cost', core_summary.get('total_cost', 0)],
-                    ['Load Factor', core_summary.get('load_factor', 0)],
-                    ['Unserved Energy (MWh)', core_summary.get('unserved_energy_mwh', 0)],
-                    ['', '']
-                ])
-            
+                stats_data.extend(
+                    [
+                        ["CORE NETWORK STATISTICS", ""],
+                        [
+                            "Total Generation (MWh)",
+                            core_summary.get("total_generation_mwh", 0),
+                        ],
+                        ["Total Demand (MWh)", core_summary.get("total_demand_mwh", 0)],
+                        ["Total Cost", core_summary.get("total_cost", 0)],
+                        ["Load Factor", core_summary.get("load_factor", 0)],
+                        [
+                            "Unserved Energy (MWh)",
+                            core_summary.get("unserved_energy_mwh", 0),
+                        ],
+                        ["", ""],
+                    ]
+                )
+
             # Section 3: Custom Statistics
-            custom_stats = network_stats.get('custom_statistics', {})
+            custom_stats = network_stats.get("custom_statistics", {})
             if custom_stats:
                 # Emissions by Carrier
-                emissions = custom_stats.get('emissions_by_carrier', {})
+                emissions = custom_stats.get("emissions_by_carrier", {})
                 if emissions:
-                    stats_data.extend([
-                        ['EMISSIONS BY CARRIER (tons CO2)', '']
-                    ])
+                    stats_data.extend([["EMISSIONS BY CARRIER (tons CO2)", ""]])
                     for carrier, value in emissions.items():
                         if value > 0:  # Only show carriers with emissions
                             stats_data.append([carrier, value])
-                    stats_data.extend([
-                        ['Total Emissions (tons CO2)', custom_stats.get('total_emissions_tons_co2', 0)],
-                        ['', '']
-                    ])
-                
+                    stats_data.extend(
+                        [
+                            [
+                                "Total Emissions (tons CO2)",
+                                custom_stats.get("total_emissions_tons_co2", 0),
+                            ],
+                            ["", ""],
+                        ]
+                    )
+
                 # Generation Dispatch by Carrier
-                dispatch = custom_stats.get('dispatch_by_carrier', {})
+                dispatch = custom_stats.get("dispatch_by_carrier", {})
                 if dispatch:
-                    stats_data.extend([
-                        ['GENERATION DISPATCH BY CARRIER (MWh)', '']
-                    ])
+                    stats_data.extend([["GENERATION DISPATCH BY CARRIER (MWh)", ""]])
                     for carrier, value in dispatch.items():
                         if value > 0:  # Only show carriers with generation
                             stats_data.append([carrier, value])
-                    stats_data.append(['', ''])
-                
+                    stats_data.append(["", ""])
+
                 # Power Capacity by Carrier (MW)
-                power_capacity = custom_stats.get('power_capacity_by_carrier', {})
+                power_capacity = custom_stats.get("power_capacity_by_carrier", {})
                 if power_capacity:
-                    stats_data.extend([
-                        ['POWER CAPACITY BY CARRIER (MW)', '']
-                    ])
+                    stats_data.extend([["POWER CAPACITY BY CARRIER (MW)", ""]])
                     for carrier, value in power_capacity.items():
                         if value > 0:  # Only show carriers with capacity
                             stats_data.append([carrier, value])
-                    stats_data.append(['', ''])
-                
+                    stats_data.append(["", ""])
+
                 # Energy Capacity by Carrier (MWh)
-                energy_capacity = custom_stats.get('energy_capacity_by_carrier', {})
+                energy_capacity = custom_stats.get("energy_capacity_by_carrier", {})
                 if energy_capacity:
-                    stats_data.extend([
-                        ['ENERGY CAPACITY BY CARRIER (MWh)', '']
-                    ])
+                    stats_data.extend([["ENERGY CAPACITY BY CARRIER (MWh)", ""]])
                     for carrier, value in energy_capacity.items():
                         if value > 0:  # Only show carriers with capacity
                             stats_data.append([carrier, value])
-                    stats_data.append(['', ''])
-                
+                    stats_data.append(["", ""])
+
                 # Capital Costs by Carrier
-                capital_costs = custom_stats.get('capital_cost_by_carrier', {})
+                capital_costs = custom_stats.get("capital_cost_by_carrier", {})
                 if capital_costs:
-                    stats_data.extend([
-                        ['CAPITAL COSTS BY CARRIER', '']
-                    ])
+                    stats_data.extend([["CAPITAL COSTS BY CARRIER", ""]])
                     for carrier, value in capital_costs.items():
                         if value > 0:  # Only show carriers with costs
                             stats_data.append([carrier, value])
-                    stats_data.extend([
-                        ['Total Capital Cost', custom_stats.get('total_capital_cost', 0)],
-                        ['', '']
-                    ])
-                
+                    stats_data.extend(
+                        [
+                            [
+                                "Total Capital Cost",
+                                custom_stats.get("total_capital_cost", 0),
+                            ],
+                            ["", ""],
+                        ]
+                    )
+
                 # Operational Costs by Carrier
-                op_costs = custom_stats.get('operational_cost_by_carrier', {})
+                op_costs = custom_stats.get("operational_cost_by_carrier", {})
                 if op_costs:
-                    stats_data.extend([
-                        ['OPERATIONAL COSTS BY CARRIER', '']
-                    ])
+                    stats_data.extend([["OPERATIONAL COSTS BY CARRIER", ""]])
                     for carrier, value in op_costs.items():
                         if value > 0:  # Only show carriers with costs
                             stats_data.append([carrier, value])
-                    stats_data.extend([
-                        ['Total Operational Cost', custom_stats.get('total_operational_cost', 0)],
-                        ['', '']
-                    ])
-                
+                    stats_data.extend(
+                        [
+                            [
+                                "Total Operational Cost",
+                                custom_stats.get("total_operational_cost", 0),
+                            ],
+                            ["", ""],
+                        ]
+                    )
+
                 # Total System Costs by Carrier
-                total_costs = custom_stats.get('total_system_cost_by_carrier', {})
+                total_costs = custom_stats.get("total_system_cost_by_carrier", {})
                 if total_costs:
-                    stats_data.extend([
-                        ['TOTAL SYSTEM COSTS BY CARRIER', '']
-                    ])
+                    stats_data.extend([["TOTAL SYSTEM COSTS BY CARRIER", ""]])
                     for carrier, value in total_costs.items():
                         if value > 0:  # Only show carriers with costs
                             stats_data.append([carrier, value])
-                    stats_data.extend([
-                        ['Total Currency Cost', custom_stats.get('total_currency_cost', 0)],
-                        ['Average Price per MWh', custom_stats.get('average_price_per_mwh', 0)],
-                        ['', '']
-                    ])
-                
+                    stats_data.extend(
+                        [
+                            [
+                                "Total Currency Cost",
+                                custom_stats.get("total_currency_cost", 0),
+                            ],
+                            [
+                                "Average Price per MWh",
+                                custom_stats.get("average_price_per_mwh", 0),
+                            ],
+                            ["", ""],
+                        ]
+                    )
+
                 # Unmet Load Statistics
-                unmet_stats = custom_stats.get('unmet_load_statistics', {})
+                unmet_stats = custom_stats.get("unmet_load_statistics", {})
                 if unmet_stats:
-                    stats_data.extend([
-                        ['UNMET LOAD STATISTICS', ''],
-                        ['Unmet Load (MWh)', unmet_stats.get('unmet_load_mwh', 0)],
-                        ['Unmet Load Percentage', custom_stats.get('unmet_load_percentage', 0)],
-                        ['Max Unmet Load Hour (MW)', custom_stats.get('max_unmet_load_hour_mw', 0)],
-                        ['', '']
-                    ])
-            
+                    stats_data.extend(
+                        [
+                            ["UNMET LOAD STATISTICS", ""],
+                            ["Unmet Load (MWh)", unmet_stats.get("unmet_load_mwh", 0)],
+                            [
+                                "Unmet Load Percentage",
+                                custom_stats.get("unmet_load_percentage", 0),
+                            ],
+                            [
+                                "Max Unmet Load Hour (MW)",
+                                custom_stats.get("max_unmet_load_hour_mw", 0),
+                            ],
+                            ["", ""],
+                        ]
+                    )
+
             # Section 4: Component Storage Statistics
-            storage_stats = solve_results.get('component_storage_stats', {})
+            storage_stats = solve_results.get("component_storage_stats", {})
             if storage_stats:
-                stats_data.extend([
-                    ['COMPONENT STORAGE STATISTICS', '']
-                ])
+                stats_data.extend([["COMPONENT STORAGE STATISTICS", ""]])
                 for key, value in storage_stats.items():
                     # Convert snake_case to readable format
-                    readable_key = key.replace('_', ' ').title()
+                    readable_key = key.replace("_", " ").title()
                     stats_data.append([readable_key, value])
-                stats_data.append(['', ''])
-            
+                stats_data.append(["", ""])
+
             # Section 5: Runtime Information
-            runtime_info = network_stats.get('runtime_info', {})
+            runtime_info = network_stats.get("runtime_info", {})
             if runtime_info:
-                stats_data.extend([
-                    ['RUNTIME INFORMATION', '']
-                ])
+                stats_data.extend([["RUNTIME INFORMATION", ""]])
                 for key, value in runtime_info.items():
                     # Convert snake_case to readable format
-                    readable_key = key.replace('_', ' ').title()
+                    readable_key = key.replace("_", " ").title()
                     stats_data.append([readable_key, value])
-                stats_data.append(['', ''])
-            
+                stats_data.append(["", ""])
+
             # Section 6: Solver Information
-            solver_info = network_stats.get('solver_info', {})
+            solver_info = network_stats.get("solver_info", {})
             if solver_info:
-                stats_data.extend([
-                    ['SOLVER INFORMATION', '']
-                ])
+                stats_data.extend([["SOLVER INFORMATION", ""]])
                 for key, value in solver_info.items():
                     # Convert snake_case to readable format
-                    readable_key = key.replace('_', ' ').title()
+                    readable_key = key.replace("_", " ").title()
                     stats_data.append([readable_key, value])
-                stats_data.append(['', ''])
-            
+                stats_data.append(["", ""])
+
             # Create DataFrame and write to Excel (simple 2-column format)
             if stats_data:
-                df = pd.DataFrame(stats_data, columns=['Parameter', 'Value'])
-                df.to_excel(writer, sheet_name='Statistics', index=False)
-                self.logger.info(f"Created Statistics sheet with {len(stats_data)} rows")
-            
+                df = pd.DataFrame(stats_data, columns=["Parameter", "Value"])
+                df.to_excel(writer, sheet_name="Statistics", index=False)
+                self.logger.info(
+                    f"Created Statistics sheet with {len(stats_data)} rows"
+                )
+
         except Exception as e:
             self.logger.warning(f"Failed to create statistics sheet: {e}")
             # Don't fail the entire export if statistics sheet fails
-    
-    def _create_per_year_statistics_sheet(self, writer, network_id: int, scenario_id: int, conn):
+
+    def _create_per_year_statistics_sheet(self, writer, scenario_id: int, conn):
         """Create per-year statistics sheet in tidy data format"""
         try:
             # Get per-year solve results
-            year_results = self._get_solve_results_by_year(conn, network_id, scenario_id)
+            year_results = self._get_solve_results_by_year(conn, scenario_id)
             if not year_results:
-                self.logger.info("No per-year solve results available, skipping per-year statistics sheet")
+                self.logger.info(
+                    "No per-year solve results available, skipping per-year statistics sheet"
+                )
                 return
-            
+
             # Prepare tidy data: Variable, Year, Carrier, Value, Units
             tidy_data = []
-            
+
             # Get sorted years
             years = sorted(year_results.keys())
-            
+
             # Define the statistics we want to include with their units
             stat_definitions = [
-                ('dispatch_by_carrier', 'Generation Dispatch', 'MWh'),
-                ('power_capacity_by_carrier', 'Power Capacity', 'MW'),
-                ('energy_capacity_by_carrier', 'Energy Capacity', 'MWh'),
-                ('capital_cost_by_carrier', 'Capital Cost', 'Currency'),
-                ('operational_cost_by_carrier', 'Operational Cost', 'Currency'),
-                ('total_system_cost_by_carrier', 'Total System Cost', 'Currency'),
-                ('emissions_by_carrier', 'Emissions', 'tons CO2')
+                ("dispatch_by_carrier", "Generation Dispatch", "MWh"),
+                ("power_capacity_by_carrier", "Power Capacity", "MW"),
+                ("energy_capacity_by_carrier", "Energy Capacity", "MWh"),
+                ("capital_cost_by_carrier", "Capital Cost", "Currency"),
+                ("operational_cost_by_carrier", "Operational Cost", "Currency"),
+                ("total_system_cost_by_carrier", "Total System Cost", "Currency"),
+                ("emissions_by_carrier", "Emissions", "tons CO2"),
             ]
-            
+
             # Process each statistic type
             for stat_key, stat_name, units in stat_definitions:
                 # Collect all carriers across all years for this statistic
                 all_carriers = set()
                 for year in years:
                     year_data = year_results[year]
-                    if 'network_statistics' in year_data and 'custom_statistics' in year_data['network_statistics']:
-                        custom_stats = year_data['network_statistics']['custom_statistics']
+                    if (
+                        "network_statistics" in year_data
+                        and "custom_statistics" in year_data["network_statistics"]
+                    ):
+                        custom_stats = year_data["network_statistics"][
+                            "custom_statistics"
+                        ]
                         if stat_key in custom_stats:
                             all_carriers.update(custom_stats[stat_key].keys())
-                
+
                 # Add data rows for each carrier and year combination
                 for carrier in sorted(all_carriers):
                     for year in years:
                         year_data = year_results[year]
                         value = 0.0
-                        
-                        if 'network_statistics' in year_data and 'custom_statistics' in year_data['network_statistics']:
-                            custom_stats = year_data['network_statistics']['custom_statistics']
-                            if stat_key in custom_stats and carrier in custom_stats[stat_key]:
+
+                        if (
+                            "network_statistics" in year_data
+                            and "custom_statistics" in year_data["network_statistics"]
+                        ):
+                            custom_stats = year_data["network_statistics"][
+                                "custom_statistics"
+                            ]
+                            if (
+                                stat_key in custom_stats
+                                and carrier in custom_stats[stat_key]
+                            ):
                                 value = custom_stats[stat_key][carrier]
-                        
+
                         # Only include rows with non-zero values to keep the data clean
                         if value > 0:
                             tidy_data.append([stat_name, year, carrier, value, units])
-            
+
             # Add core summary statistics (these don't have carriers)
             core_stat_definitions = [
-                ('total_generation_mwh', 'Total Generation', 'MWh'),
-                ('total_demand_mwh', 'Total Demand', 'MWh'),
-                ('total_cost', 'Total Cost', 'Currency'),
-                ('load_factor', 'Load Factor', 'Ratio'),
-                ('unserved_energy_mwh', 'Unserved Energy', 'MWh'),
-                ('total_emissions_tons_co2', 'Total Emissions', 'tons CO2')
+                ("total_generation_mwh", "Total Generation", "MWh"),
+                ("total_demand_mwh", "Total Demand", "MWh"),
+                ("total_cost", "Total Cost", "Currency"),
+                ("load_factor", "Load Factor", "Ratio"),
+                ("unserved_energy_mwh", "Unserved Energy", "MWh"),
+                ("total_emissions_tons_co2", "Total Emissions", "tons CO2"),
             ]
-            
+
             for stat_key, stat_name, units in core_stat_definitions:
                 for year in years:
                     year_data = year_results[year]
                     value = 0.0
-                    
+
                     # Check both core_summary and custom_statistics
-                    if 'network_statistics' in year_data:
-                        network_stats = year_data['network_statistics']
-                        
+                    if "network_statistics" in year_data:
+                        network_stats = year_data["network_statistics"]
+
                         # Try core_summary first
-                        if 'core_summary' in network_stats and stat_key in network_stats['core_summary']:
-                            value = network_stats['core_summary'][stat_key]
+                        if (
+                            "core_summary" in network_stats
+                            and stat_key in network_stats["core_summary"]
+                        ):
+                            value = network_stats["core_summary"][stat_key]
                         # Try custom_statistics as fallback
-                        elif 'custom_statistics' in network_stats and stat_key in network_stats['custom_statistics']:
-                            value = network_stats['custom_statistics'][stat_key]
-                    
+                        elif (
+                            "custom_statistics" in network_stats
+                            and stat_key in network_stats["custom_statistics"]
+                        ):
+                            value = network_stats["custom_statistics"][stat_key]
+
                     # Include all core statistics (even zeros for completeness)
-                    tidy_data.append([stat_name, year, 'Total', value, units])
-            
+                    tidy_data.append([stat_name, year, "Total", value, units])
+
             # Create DataFrame and write to Excel
             if tidy_data:
-                df = pd.DataFrame(tidy_data, columns=['Variable', 'Year', 'Carrier', 'Value', 'Units'])
-                df.to_excel(writer, sheet_name='Per-Year Statistics', index=False)
-                self.logger.info(f"Created Per-Year Statistics sheet with {len(tidy_data)} rows")
+                df = pd.DataFrame(
+                    tidy_data, columns=["Variable", "Year", "Carrier", "Value", "Units"]
+                )
+                df.to_excel(writer, sheet_name="Per-Year Statistics", index=False)
+                self.logger.info(
+                    f"Created Per-Year Statistics sheet with {len(tidy_data)} rows"
+                )
             else:
                 self.logger.info("No per-year statistics data to export")
-            
+
         except Exception as e:
             self.logger.warning(f"Failed to create per-year statistics sheet: {e}")
             # Don't fail the entire export if per-year statistics sheet fails
-    
+
     def _get_app_version(self) -> str:
         """Get the application version."""
         try:
@@ -994,7 +1208,7 @@ class ExcelModelExporter:
             import json
             import os
             from pathlib import Path
-            
+
             # Look for package.json in parent directories
             current_dir = Path(__file__).parent
             while current_dir != current_dir.parent:
@@ -1004,7 +1218,7 @@ class ExcelModelExporter:
                         package_data = json.load(f)
                         return package_data.get("version", "1.0.0")
                 current_dir = current_dir.parent
-            
+
             # Fallback version
             return "1.0.0"
         except Exception as e: