pyconvexity 0.4.3__py3-none-any.whl → 0.4.6.post1__py3-none-any.whl

pyconvexity/_version.py

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

pyconvexity/data/schema/03_validation_data.sql

@@ -33,7 +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', '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);
 
 -- ============================================================================
 -- GENERATOR ATTRIBUTES  

pyconvexity/io/netcdf_exporter.py

@@ -3,22 +3,18 @@ NetCDF exporter for PyConvexity energy system models.
 Exports networks to PyPSA NetCDF format using existing PyPSA infrastructure.
 """
 
-import logging
 from typing import Dict, Any, Optional, Callable
 from pathlib import Path
 
 # Import existing PyPSA functionality from pyconvexity
-from pyconvexity.core.database import open_connection
 from pyconvexity.solvers.pypsa import build_pypsa_network
 
-logger = logging.getLogger(__name__)
-
 
 class NetCDFModelExporter:
     """Export network model to PyPSA NetCDF format"""
 
     def __init__(self):
-        self.logger = logging.getLogger(__name__)
+        pass
 
     def export_to_netcdf(
         self,
@@ -78,7 +74,6 @@ class NetCDFModelExporter:
             }
 
         except Exception as e:
-            self.logger.error(f"NetCDF export failed: {e}", exc_info=True)
             if progress_callback:
                 progress_callback(None, f"Export failed: {str(e)}")
             raise
@@ -141,7 +136,6 @@ class NetCDFModelExporter:
             }
 
         except Exception as e:
-            self.logger.error(f"CSV export failed: {e}", exc_info=True)
             if progress_callback:
                 progress_callback(None, f"Export failed: {str(e)}")
             raise

pyconvexity/io/netcdf_importer.py

@@ -3,7 +3,6 @@ NetCDF importer for PyConvexity energy system models.
 Imports PyPSA NetCDF files into PyConvexity database format.
 """
 
-import logging
 import pandas as pd
 import numpy as np
 from typing import Dict, Any, Optional, Callable, Tuple, List
@@ -33,14 +32,81 @@ from pyconvexity.models import (
 from pyconvexity.validation import get_validation_rule
 from pyconvexity.timeseries import set_timeseries
 
-logger = logging.getLogger(__name__)
+
+def _pandas_freq_to_iso8601(freq: str) -> str:
+    """
+    Convert pandas frequency code to ISO 8601 duration format.
+    
+    Args:
+        freq: Pandas frequency code (e.g., "H", "30T", "2H", "15min", "D")
+        
+    Returns:
+        ISO 8601 duration string (e.g., "PT1H", "PT30M", "PT2H", "PT15M", "P1D")
+    """
+    if not freq:
+        return "PT1H"  # Default to hourly
+    
+    freq = freq.strip().upper()
+    
+    # Handle common pandas frequency codes
+    # Hourly patterns: "H", "1H", "2H", etc.
+    if freq == "H" or freq == "1H":
+        return "PT1H"
+    if freq.endswith("H"):
+        try:
+            hours = int(freq[:-1])
+            return f"PT{hours}H"
+        except ValueError:
+            pass
+    
+    # Minute patterns: "T", "MIN", "30T", "30MIN", "15T", etc.
+    if freq == "T" or freq == "MIN" or freq == "1T" or freq == "1MIN":
+        return "PT1M"
+    if freq.endswith("T"):
+        try:
+            minutes = int(freq[:-1])
+            return f"PT{minutes}M"
+        except ValueError:
+            pass
+    if freq.endswith("MIN"):
+        try:
+            minutes = int(freq[:-3])
+            return f"PT{minutes}M"
+        except ValueError:
+            pass
+    
+    # Second patterns: "S", "1S", "30S", etc.
+    if freq == "S" or freq == "1S":
+        return "PT1S"
+    if freq.endswith("S") and not freq.endswith("MS"):
+        try:
+            seconds = int(freq[:-1])
+            return f"PT{seconds}S"
+        except ValueError:
+            pass
+    
+    # Daily patterns: "D", "1D", etc.
+    if freq == "D" or freq == "1D":
+        return "P1D"
+    if freq.endswith("D"):
+        try:
+            days = int(freq[:-1])
+            return f"P{days}D"
+        except ValueError:
+            pass
+    
+    # Weekly patterns: "W", "1W", etc.
+    if freq == "W" or freq == "1W" or freq.startswith("W-"):
+        return "P1W"
+    
+    # If we can't parse it, default to hourly
+    return "PT1H"
 
 
 class NetCDFModelImporter:
     """Import PyPSA NetCDF files into PyConvexity database format"""
 
     def __init__(self):
-        self.logger = logging.getLogger(__name__)
         # Set random seed for reproducible coordinate generation
         random.seed(42)
         np.random.seed(42)
@@ -103,7 +169,6 @@ class NetCDFModelImporter:
             )
 
         except Exception as e:
-            self.logger.error(f"Error importing NetCDF: {e}", exc_info=True)
             if progress_callback:
                 progress_callback(None, f"Error: {str(e)}")
             raise
@@ -164,7 +229,6 @@ class NetCDFModelImporter:
                     error_msg += f"\n\nThis indicates a required column is missing from one of your CSV files. "
                     error_msg += "Please ensure your CSV files follow the PyPSA format specification."
 
-                self.logger.error(error_msg)
                 raise ValueError(error_msg)
 
             if progress_callback:
@@ -185,7 +249,6 @@ class NetCDFModelImporter:
             )
 
         except Exception as e:
-            self.logger.error(f"Error importing PyPSA CSV: {e}", exc_info=True)
             if progress_callback:
                 progress_callback(None, f"Error: {str(e)}")
             raise
@@ -197,16 +260,10 @@ class NetCDFModelImporter:
 
             return pypsa
         except ImportError as e:
-            self.logger.error(f"Failed to import PyPSA: {e}", exc_info=True)
             raise ImportError(
                 "PyPSA is not installed or could not be imported. "
                 "Please ensure it is installed correctly in the environment."
             ) from e
-        except Exception as e:
-            self.logger.error(
-                f"An unexpected error occurred during PyPSA import: {e}", exc_info=True
-            )
-            raise
 
     def _validate_csv_directory(self, csv_directory: str) -> None:
         """Validate that the CSV directory contains valid PyPSA CSV files"""
@@ -415,7 +472,6 @@ class NetCDFModelImporter:
                 conn.close()
 
         except Exception as e:
-            self.logger.error(f"Error importing network: {e}", exc_info=True)
             if progress_callback:
                 progress_callback(None, f"Error: {str(e)}")
             raise
@@ -427,7 +483,6 @@ class NetCDFModelImporter:
     def _extract_datetime_snapshots(self, network) -> pd.DatetimeIndex:
         """Extract datetime snapshots from a PyPSA network"""
         if not hasattr(network, "snapshots") or len(network.snapshots) == 0:
-            self.logger.warning("No snapshots found in PyPSA network")
             return pd.DatetimeIndex([])
 
         snapshots = network.snapshots
@@ -435,7 +490,7 @@ class NetCDFModelImporter:
         try:
             # Try direct conversion first (works for simple DatetimeIndex)
             return pd.to_datetime(snapshots)
-        except (TypeError, ValueError) as e:
+        except (TypeError, ValueError):
             # Handle MultiIndex case
             if hasattr(snapshots, "nlevels") and snapshots.nlevels > 1:
                 # Try to use the timesteps attribute if available (common in multi-period networks)
@@ -450,15 +505,10 @@ class NetCDFModelImporter:
                     last_level = snapshots.get_level_values(snapshots.nlevels - 1)
                     datetime_snapshots = pd.to_datetime(last_level)
                     return datetime_snapshots
-                except Exception as multi_e:
-                    self.logger.warning(
-                        f"Failed to extract datetime from MultiIndex: {multi_e}"
-                    )
+                except Exception:
+                    pass
 
             # Final fallback: create a default hourly range
-            self.logger.warning(
-                "Could not extract datetime snapshots, creating default hourly range"
-            )
             default_start = pd.Timestamp("2024-01-01 00:00:00")
             default_end = pd.Timestamp("2024-01-01 23:59:59")
             return pd.date_range(start=default_start, end=default_end, freq="H")
@@ -479,17 +529,17 @@ class NetCDFModelImporter:
             time_start = snapshots.min().strftime("%Y-%m-%d %H:%M:%S")
             time_end = snapshots.max().strftime("%Y-%m-%d %H:%M:%S")
 
-            # Try to infer time interval
+            # Try to infer time interval and convert to ISO 8601 format
             if len(snapshots) > 1:
                 freq = pd.infer_freq(snapshots)
-                time_interval = freq or "H"  # Default to hourly if can't infer
+                time_interval = _pandas_freq_to_iso8601(freq) if freq else "PT1H"
             else:
-                time_interval = "H"
+                time_interval = "PT1H"
         else:
             # Default time range if no snapshots
             time_start = "2024-01-01 00:00:00"
             time_end = "2024-01-01 23:59:59"
-            time_interval = "H"
+            time_interval = "PT1H"
 
         description = (
             network_description
@@ -511,9 +561,6 @@ class NetCDFModelImporter:
         snapshots = self._extract_datetime_snapshots(network)
 
         if len(snapshots) == 0:
-            self.logger.warning(
-                "No valid snapshots found in PyPSA network, skipping time periods creation"
-            )
             return
 
         # Insert optimized time periods metadata
@@ -686,12 +733,9 @@ class NetCDFModelImporter:
                 # Generate a unique name for this bus
                 unique_name = self._generate_unique_name(str(bus_name), "BUS")
 
-                # Extract and log coordinate data for debugging
+                # Extract coordinate data
                 x_value = bus_data.get("x", None)
                 y_value = bus_data.get("y", None)
-                self.logger.debug(
-                    f"Bus '{bus_name}' -> '{unique_name}': x={x_value} (type: {type(x_value)}), y={y_value} (type: {type(y_value)})"
-                )
 
                 # Handle NaN/None values properly
                 longitude = (
@@ -743,7 +787,6 @@ class NetCDFModelImporter:
             except Exception as e:
                 if strict_validation:
                     raise
-                self.logger.warning(f"Failed to import bus {bus_name}: {e}")
                 continue
 
         return count
@@ -776,9 +819,6 @@ class NetCDFModelImporter:
                 bus_id = bus_name_to_id.get(bus_name) if bus_name else None
 
                 if not bus_id:
-                    self.logger.warning(
-                        f"Generator {gen_name}: bus '{bus_name}' not found, skipping"
-                    )
                     continue
 
                 # Get or create carrier
@@ -821,7 +861,6 @@ class NetCDFModelImporter:
             except Exception as e:
                 if strict_validation:
                     raise
-                self.logger.warning(f"Failed to import generator {gen_name}: {e}")
                 continue
 
         return count
@@ -855,9 +894,6 @@ class NetCDFModelImporter:
             try:
                 bus_id = bus_map.get(load_data["bus"])
                 if bus_id is None:
-                    self.logger.warning(
-                        f"Bus '{load_data['bus']}' not found for load '{load_name}'"
-                    )
                     continue
 
                 # Generate a unique name for this load
@@ -918,7 +954,6 @@ class NetCDFModelImporter:
             except Exception as e:
                 if strict_validation:
                     raise
-                self.logger.warning(f"Failed to import load {load_name}: {e}")
                 continue
 
         return count
@@ -941,9 +976,6 @@ class NetCDFModelImporter:
                 bus1_id = bus_map.get(line_data["bus1"])
 
                 if bus0_id is None or bus1_id is None:
-                    self.logger.warning(
-                        f"Bus not found for line '{line_name}': bus0='{line_data['bus0']}', bus1='{line_data['bus1']}'"
-                    )
                     continue
 
                 # Handle duplicate names by appending counter
@@ -951,9 +983,6 @@ class NetCDFModelImporter:
                 if line_name in name_counter:
                     name_counter[line_name] += 1
                     unique_name = f"{line_name}_{name_counter[line_name]}"
-                    self.logger.warning(
-                        f"Duplicate line name '{line_name}' renamed to '{unique_name}'"
-                    )
                 else:
                     name_counter[line_name] = 0
 
@@ -993,7 +1022,6 @@ class NetCDFModelImporter:
             except Exception as e:
                 if strict_validation:
                     raise
-                self.logger.warning(f"Failed to import line {line_name}: {e}")
                 continue
 
         return count
@@ -1015,9 +1043,6 @@ class NetCDFModelImporter:
                 bus1_id = bus_map.get(link_data["bus1"])
 
                 if bus0_id is None or bus1_id is None:
-                    self.logger.warning(
-                        f"Bus not found for link '{link_name}': bus0='{link_data['bus0']}', bus1='{link_data['bus1']}'"
-                    )
                     continue
 
                 # Generate a unique name for this link
@@ -1064,7 +1089,6 @@ class NetCDFModelImporter:
             except Exception as e:
                 if strict_validation:
                     raise
-                self.logger.warning(f"Failed to import link {link_name}: {e}")
                 continue
 
         return count
@@ -1098,9 +1122,6 @@ class NetCDFModelImporter:
             try:
                 bus_id = bus_map.get(su_data["bus"])
                 if bus_id is None:
-                    self.logger.warning(
-                        f"Bus '{su_data['bus']}' not found for storage unit '{su_name}'"
-                    )
                     continue
 
                 # Generate a unique name for this storage unit
@@ -1166,7 +1187,6 @@ class NetCDFModelImporter:
             except Exception as e:
                 if strict_validation:
                     raise
-                self.logger.warning(f"Failed to import storage unit {su_name}: {e}")
                 continue
 
         return count
@@ -1203,9 +1223,6 @@ class NetCDFModelImporter:
             try:
                 bus_id = bus_map.get(store_data["bus"])
                 if bus_id is None:
-                    self.logger.warning(
-                        f"Bus '{store_data['bus']}' not found for store '{store_name}'"
-                    )
                     continue
 
                 # Handle duplicate names by appending counter
@@ -1213,9 +1230,6 @@ class NetCDFModelImporter:
                 if store_name in name_counter:
                     name_counter[store_name] += 1
                     unique_name = f"{store_name}_{name_counter[store_name]}"
-                    self.logger.warning(
-                        f"Duplicate store name '{store_name}' renamed to '{unique_name}'"
-                    )
                 else:
                     name_counter[store_name] = 0
 
@@ -1276,7 +1290,6 @@ class NetCDFModelImporter:
             except Exception as e:
                 if strict_validation:
                     raise
-                self.logger.warning(f"Failed to import store {store_name}: {e}")
                 continue
 
         return count
@@ -1355,15 +1368,10 @@ class NetCDFModelImporter:
                 # Validate required columns
                 required_columns = {"name", "longitude", "latitude"}
                 if not required_columns.issubset(location_df.columns):
-                    missing_cols = required_columns - set(location_df.columns)
-                    self.logger.warning(
-                        f"Location CSV missing required columns: {missing_cols}. Found columns: {list(location_df.columns)}"
-                    )
                     return None
 
                 # Create lookup dictionary
                 location_map = {}
-                skipped_count = 0
 
                 for _, row in location_df.iterrows():
                     name = row["name"]
@@ -1372,15 +1380,10 @@ class NetCDFModelImporter:
 
                     # Skip rows with missing data
                     if pd.isna(name) or pd.isna(longitude) or pd.isna(latitude):
-                        skipped_count += 1
                         continue
 
                     # Validate coordinate ranges
                     if not (-180 <= longitude <= 180) or not (-90 <= latitude <= 90):
-                        self.logger.warning(
-                            f"Invalid coordinates for '{name}': longitude={longitude}, latitude={latitude}"
-                        )
-                        skipped_count += 1
                         continue
 
                     location_map[str(name).strip()] = (
@@ -1388,17 +1391,12 @@ class NetCDFModelImporter:
                         float(longitude),
                     )
 
-                self.logger.info(
-                    f"Loaded {len(location_map)} component locations from CSV (skipped {skipped_count} invalid entries)"
-                )
                 return location_map
 
-            except Exception as e:
-                self.logger.error(f"Failed to parse location CSV {csv_path}: {e}")
+            except Exception:
                 return None
 
-        except Exception as e:
-            self.logger.warning(f"Error detecting location CSV: {e}")
+        except Exception:
             return None
 
     def _get_or_create_carrier(self, conn, carrier_name: str) -> int:
@@ -1564,16 +1562,9 @@ class NetCDFModelImporter:
                     if strict_validation:
                         raise
                     else:
-                        self.logger.warning(
-                            f"Skipping undefined/invalid attribute '{attr_name}' for {component_type} component {component_id}: {e}"
-                        )
                         skipped_count += 1
                         continue
                 else:
-                    # Log but don't fail on other attribute import errors (like type conversion issues)
-                    self.logger.warning(
-                        f"Skipping attribute {attr_name} for component {component_id}: {e}"
-                    )
                     skipped_count += 1
 
     def _import_component_timeseries(
@@ -1632,9 +1623,6 @@ class NetCDFModelImporter:
                         values.append(float(value))
 
                 if not values:
-                    self.logger.warning(
-                        f"No valid timeseries points for '{attr_name}' on {component_type} '{component_name}'"
-                    )
                     continue
 
                 # Use optimized timeseries attribute setting
@@ -1647,16 +1635,8 @@ class NetCDFModelImporter:
                 if strict_validation:
                     raise
                 else:
-                    self.logger.warning(
-                        f"Skipping timeseries attribute '{attr_name}' for {component_type} component '{component_name}': {e}"
-                    )
                     continue
 
-        if timeseries_count > 0:
-            self.logger.debug(
-                f"Imported {timeseries_count} timeseries attributes for {component_type} '{component_name}'"
-            )
-
     def _generate_unique_name(self, base_name: str, component_type: str) -> str:
         """
         Generate a unique name for a component, ensuring no duplicates across all component types.
@@ -1720,7 +1700,7 @@ class NetCDFModelImporter:
             base_angle = (2 * math.pi * component_index) / component_count_at_bus
             angle_jitter = random.uniform(
                 -math.pi / 8, math.pi / 8
-            )  # ±22.5 degrees jitter
+            )  # +/- 22.5 degrees jitter
             angle = base_angle + angle_jitter
 
             # Vary distance randomly within the radius (use more of the available radius)
@@ -1811,23 +1791,12 @@ class NetCDFModelImporter:
 
         # Try exact match first
         if component_name in location_map:
-            coordinates = location_map[component_name]
-            self.logger.debug(
-                f"CSV location exact match for '{component_name}': {coordinates}"
-            )
-            return coordinates
+            return location_map[component_name]
 
         # Try resolving back to original name
         original_name = self._resolve_original_component_name(component_name)
         if original_name != component_name and original_name in location_map:
-            coordinates = location_map[original_name]
-            self.logger.debug(
-                f"CSV location resolved match for '{component_name}' -> '{original_name}': {coordinates}"
-            )
-            return coordinates
+            return location_map[original_name]
 
         # No match found
-        self.logger.debug(
-            f"No CSV location found for component '{component_name}' (original: '{original_name}')"
-        )
         return None

pyconvexity/solvers/pypsa/api.py

@@ -4,7 +4,6 @@ High-level API for PyPSA solver integration.
 Provides user-friendly functions for the most common workflows.
 """
 
-import logging
 from typing import Dict, Any, Optional, Callable
 
 from pyconvexity.core.database import database_context
@@ -13,8 +12,6 @@ from pyconvexity.solvers.pypsa.solver import NetworkSolver
 from pyconvexity.solvers.pypsa.storage import ResultStorage
 from pyconvexity.solvers.pypsa.constraints import ConstraintApplicator
 
-logger = logging.getLogger(__name__)
-
 
 def solve_network(
     db_path: str,
@@ -143,19 +140,11 @@ def solve_network(
 
                 # Only optimize if there's significant free space (>5% threshold for post-solve)
                 if should_optimize_database(conn, free_space_threshold_percent=5.0):
-                    logger.info("Running database optimization after successful solve")
-                    optimization_result = optimize_database(conn)
-                    logger.info(
-                        f"Database optimization completed: {optimization_result['space_reclaimed']:,} bytes reclaimed"
-                    )
-                else:
-                    logger.debug(
-                        "Skipping database optimization - insufficient free space"
-                    )
-
-            except Exception as e:
+                    optimize_database(conn)
+
+            except Exception:
                 # Don't fail the solve if optimization fails
-                logger.warning(f"Database optimization failed (non-critical): {e}")
+                pass
 
         if progress_callback:
             progress_callback(100, "Complete")
@@ -448,9 +437,6 @@ def _transform_to_comprehensive_format(
         return comprehensive_result
 
     except Exception as e:
-        logger.error(
-            f"Failed to transform result to comprehensive format: {e}", exc_info=True
-        )
         # Return original result with error info if transformation fails
         return {
             **pyconvexity_result,

pyconvexity/solvers/pypsa/batch_loader.py

@@ -3,7 +3,6 @@ PyPSA Batch Data Loader
 Simplified to always create MultiIndex timeseries for consistent multi-period optimization.
 """
 
-import logging
 import pandas as pd
 import json
 from typing import Dict, Any, List, Optional
@@ -11,8 +10,6 @@ from typing import Dict, Any, List, Optional
 from pyconvexity.models.attributes import get_timeseries
 from pyconvexity.models import get_network_time_periods
 
-logger = logging.getLogger(__name__)
-
 
 class PyPSABatchLoader:
     """
@@ -156,7 +153,6 @@ class PyPSABatchLoader:
         # Get network time periods for proper timestamp alignment
         network_time_periods = get_network_time_periods(conn)
         if not network_time_periods:
-            logger.warning("No time periods found for network")
             return {comp_id: {} for comp_id in component_ids}
 
         # Convert to timestamps and extract years
@@ -252,15 +248,8 @@ class PyPSABatchLoader:
                         component_timeseries[comp_id][attr_name] = pd.Series(
                             values, index=multi_index
                         )
-                    else:
-                        logger.warning(
-                            f"No valid timestamps for timeseries {attr_name}"
-                        )
 
-            except Exception as e:
-                logger.warning(
-                    f"Failed to load timeseries {attr_name} for component {comp_id}: {e}"
-                )
+            except Exception:
                 continue
 
         return component_timeseries