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

pyconvexity/_version.py

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

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

pyconvexity/solvers/pypsa/builder.py

@@ -4,7 +4,6 @@ Network building functionality for PyPSA solver integration.
 Simplified to always use MultiIndex format for consistent multi-period optimization.
 """
 
-import logging
 import json
 import pandas as pd
 from typing import Dict, Any, Optional, Callable
@@ -15,8 +14,6 @@ from pyconvexity.models import (
     get_network_info,
 )
 
-logger = logging.getLogger(__name__)
-
 
 class NetworkBuilder:
     """
@@ -140,7 +137,7 @@ class NetworkBuilder:
                 for tp in time_periods
             ]
         except Exception as e:
-            logger.warning(f"Failed to load time periods: {e}")
+            pass  # Failed to load time periods
 
         # Load all component types
         component_types = [
@@ -173,7 +170,7 @@ class NetworkBuilder:
                         for comp in components
                     ]
             except Exception as e:
-                logger.warning(f"Failed to load {comp_type} components: {e}")
+                pass  # Failed to load components
 
         return data
 
@@ -188,7 +185,6 @@ class NetworkBuilder:
         try:
             time_periods = get_network_time_periods(conn)
             if not time_periods:
-                logger.error("No time periods found for network")
                 return
 
             # Convert to pandas DatetimeIndex
@@ -221,12 +217,7 @@ class NetworkBuilder:
             # Store years for statistics
             network._available_years = years
 
-            logger.info(
-                f"Time index: {len(multi_index)} snapshots across {len(years)} investment periods: {years}"
-            )
-
         except Exception as e:
-            logger.error(f"Failed to set time index: {e}")
             network._available_years = []
 
     def _load_carriers(self, conn, network: "pypsa.Network"):
@@ -381,14 +372,8 @@ class NetworkBuilder:
         if include_unmet_loads:
             unmet_loads = list_components_by_type(conn, "UNMET_LOAD")
             all_generators = generators + unmet_loads
-            if self.verbose:
-                logger.info(
-                    f"Loading {len(generators)} generators and {len(unmet_loads)} unmet loads"
-                )
         else:
             all_generators = generators
-            if self.verbose:
-                logger.info(f"Loading {len(generators)} generators (unmet loads disabled)")
 
         generator_ids = [gen.id for gen in all_generators]
 
@@ -635,12 +620,8 @@ class NetworkBuilder:
                     network.snapshot_weightings.loc[:, "objective"] = weightings
                     network.snapshot_weightings.loc[:, "generators"] = weightings
                     network.snapshot_weightings.loc[:, "stores"] = weightings
-                else:
-                    logger.warning(
-                        f"Mismatch between weightings ({len(weightings)}) and snapshots ({len(network.snapshots)})"
-                    )
         except Exception as e:
-            logger.warning(f"Failed to set snapshot weightings: {e}")
+            pass  # Failed to set snapshot weightings
 
     def _parse_time_interval(self, time_interval: str) -> Optional[float]:
         """Parse time interval string to hours."""
@@ -661,7 +642,6 @@ class NetworkBuilder:
                 # Try to parse as float (assume hours)
                 return float(time_interval)
         except (ValueError, TypeError):
-            logger.warning(f"Could not parse time interval: {time_interval}")
             return None
 
     def _build_bus_id_to_name_map(self, conn) -> Dict[int, str]:

pyconvexity/solvers/pypsa/solver.py

@@ -4,15 +4,12 @@ Solving functionality for PyPSA networks.
 Simplified to always use multi-period optimization for consistency.
 """
 
-import logging
 import time
 import uuid
 import pandas as pd
 import numpy as np
 from typing import Dict, Any, Optional
 
-logger = logging.getLogger(__name__)
-
 
 class NetworkSolver:
     """
@@ -66,7 +63,6 @@ class NetworkSolver:
             return settings_file if settings_file.exists() else None
 
         except Exception as e:
-            logger.warning(f"Failed to determine user settings path: {e}")
             return None
 
     def _resolve_default_solver(self) -> str:
@@ -76,9 +72,6 @@ class NetworkSolver:
 
             settings_path = self._get_user_settings_path()
             if not settings_path:
-                logger.debug(
-                    "User settings file not found, using 'highs' as default solver"
-                )
                 return "highs"
 
             with open(settings_path, "r") as f:
@@ -115,13 +108,9 @@ class NetworkSolver:
             if default_solver in known_solvers:
                 return default_solver
             else:
-                logger.warning(
-                    f"Unknown default solver '{default_solver}' in user settings, falling back to 'highs'"
-                )
                 return "highs"
 
         except Exception as e:
-            logger.warning(f"Failed to read default solver from user settings: {e}")
             return "highs"
 
     def solve_network(
@@ -173,8 +162,6 @@ class NetworkSolver:
 
             years = list(network.investment_periods)
 
-            logger.info(f"Solving with {actual_solver_name}: {len(years)} periods {years}, discount rate {effective_discount_rate}")
-
             # Calculate investment period weightings with discount rate
             self._calculate_investment_weightings(network, effective_discount_rate)
 
@@ -206,17 +193,10 @@ class NetworkSolver:
                         extra_functionality = self._create_extra_functionality(
                             model_constraints, constraint_applicator
                         )
-                        if self.verbose:
-                            logger.info(
-                                f"Prepared {len(model_constraints)} model constraints for optimization"
-                            )
 
             # NOTE: Model constraints are applied DURING solve via extra_functionality
             # Network constraints were already applied to the network structure before solve
 
-            if self.verbose:
-                logger.info(f"Snapshots: {len(network.snapshots)}, Solver options: {solver_config}")
-
             if solver_config:
                 result = network.optimize(
                     solver_name=actual_solver_name,
@@ -252,17 +232,10 @@ class NetworkSolver:
                 solve_result["year_statistics"] = year_statistics
                 solve_result["year_statistics_available"] = len(year_statistics) > 0
 
-            objective_value = getattr(network, "objective", None)
-            logger.info(
-                f"Solve completed in {solve_time:.2f}s - status: {solve_result['status']}, objective: {objective_value}"
-            )
-
             return solve_result
 
         except Exception as e:
             solve_time = time.time() - start_time
-            logger.error(f"Solve failed after {solve_time:.2f} seconds: {e}")
-            logger.exception("Full solve error traceback:")
 
             return {
                 "success": False,
@@ -609,10 +582,7 @@ class NetworkSolver:
             return solver_name, solver_options
 
         else:
-            # Unknown solver name - log warning and fall back to highs
-            logger.warning(
-                f"Unknown solver name '{solver_name}' - falling back to 'highs'"
-            )
+            # Unknown solver name - fall back to highs
             return "highs", solver_options
 
     def _detect_constraint_type(self, constraint_code: str) -> str:
@@ -690,14 +660,10 @@ class NetworkSolver:
                             network, snapshots, constraint
                         )
                     except Exception as e:
-                        logger.error(
-                            f"Failed to apply optimization constraint {constraint.get('name', 'unknown')}: {e}"
-                        )
                         continue
 
             except Exception as e:
-                logger.error(f"Failed to apply optimization constraints: {e}")
-                # Don't re-raise - let optimization continue
+                pass  # Don't re-raise - let optimization continue
 
         return extra_functionality
 
@@ -717,9 +683,6 @@ class NetworkSolver:
 
                 if weight is None:
                     weight = 1.0
-                    logger.warning(
-                        f"Could not parse time interval '{time_interval}', using default weight of 1.0"
-                    )
 
                 # Create weightings array - all snapshots get the same weight for this time resolution
                 weightings = [weight] * len(time_periods)
@@ -729,14 +692,8 @@ class NetworkSolver:
                     network.snapshot_weightings.loc[:, "objective"] = weightings
                     network.snapshot_weightings.loc[:, "generators"] = weightings
                     network.snapshot_weightings.loc[:, "stores"] = weightings
-                else:
-                    logger.warning(
-                        f"Mismatch between weightings ({len(weightings)}) and snapshots ({len(network.snapshots)})"
-                    )
         except Exception as e:
-            logger.warning(
-                f"Failed to set snapshot weightings after multi-period setup: {e}"
-            )
+            pass  # Failed to set snapshot weightings
 
     def _parse_time_interval(self, time_interval: str) -> Optional[float]:
         """Parse time interval string to hours - handles multiple formats."""
@@ -780,7 +737,6 @@ class NetworkSolver:
                 return float(interval)
 
         except (ValueError, TypeError) as e:
-            logger.warning(f"Could not parse time interval '{time_interval}': {e}")
             return None
 
     def _calculate_investment_weightings(
@@ -872,8 +828,7 @@ class NetworkSolver:
                 network.investment_period_weightings = weightings_df
 
         except Exception as e:
-            logger.error(f"Failed to calculate investment weightings: {e}")
-            logger.exception("Full traceback:")
+            pass  # Failed to calculate investment weightings
 
     def _extract_solve_results(
         self,
@@ -934,7 +889,6 @@ class NetworkSolver:
             return solve_result
 
         except Exception as e:
-            logger.error(f"Failed to extract solve results: {e}")
             return {
                 "success": False,
                 "status": "extraction_failed",
@@ -983,13 +937,9 @@ class NetworkSolver:
                     if "optimal" in term_condition:
                         return True
 
-            logger.warning(
-                f"Could not determine solve success: status={status}, objective={objective_value}"
-            )
             return False
 
         except Exception as e:
-            logger.error(f"Error determining solve success: {e}")
             return False
 
     def _convert_pypsa_result_to_dict(self, result) -> Dict[str, Any]:
@@ -1029,7 +979,6 @@ class NetworkSolver:
             return result_dict
 
         except Exception as e:
-            logger.warning(f"Failed to convert PyPSA result to dict: {e}")
             return {"status": "conversion_failed", "error": str(e)}
 
     def _calculate_comprehensive_network_statistics(
@@ -1125,7 +1074,6 @@ class NetworkSolver:
                 else:
                     statistics["pypsa_statistics"] = {}
             except Exception as e:
-                logger.error(f"Failed to calculate PyPSA statistics: {e}")
                 statistics["pypsa_statistics"] = {}
 
             # Custom statistics - calculate detailed breakdowns
@@ -1205,10 +1153,6 @@ class NetworkSolver:
             return statistics
 
         except Exception as e:
-            logger.error(
-                f"Failed to calculate comprehensive network statistics: {e}",
-                exc_info=True,
-            )
             return {
                 "error": str(e),
                 "core_summary": {},
@@ -1245,15 +1189,11 @@ class NetworkSolver:
                     )
                     year_statistics[year] = year_stats
                 except Exception as e:
-                    logger.error(f"Failed to calculate statistics for year {year}: {e}")
                     continue
 
             return year_statistics
 
         except Exception as e:
-            logger.error(
-                f"Failed to calculate year-based statistics: {e}", exc_info=True
-            )
             return {}
 
     def _calculate_network_statistics_for_year(
@@ -1367,10 +1307,6 @@ class NetworkSolver:
             return statistics
 
         except Exception as e:
-            logger.error(
-                f"Failed to calculate network statistics for year {year}: {e}",
-                exc_info=True,
-            )
             return {
                 "error": str(e),
                 "core_summary": {},
@@ -1402,7 +1338,6 @@ class NetworkSolver:
             return None
 
         except Exception as e:
-            logger.error(f"Failed to filter timeseries by year {year}: {e}")
             return None
 
     def _get_year_weightings(self, network: "pypsa.Network", year: int) -> "np.ndarray":
@@ -1438,7 +1373,6 @@ class NetworkSolver:
             return None
 
         except Exception as e:
-            logger.error(f"Failed to get year weightings for year {year}: {e}")
             return None
 
     def _count_year_snapshots(self, snapshots: "pd.Index", year: int) -> int:
@@ -1459,7 +1393,6 @@ class NetworkSolver:
             return 0
 
         except Exception as e:
-            logger.error(f"Failed to count snapshots for year {year}: {e}")
             return 0
 
     def _calculate_year_carrier_statistics(

pyconvexity/solvers/pypsa/storage.py

@@ -4,7 +4,6 @@ Result storage functionality for PyPSA solver integration.
 Handles storing solve results back to the database with proper validation and error handling.
 """
 
-import logging
 import uuid
 import pandas as pd
 import numpy as np
@@ -18,8 +17,6 @@ from pyconvexity.models import (
 )
 from pyconvexity.validation import get_validation_rule
 
-logger = logging.getLogger(__name__)
-
 
 class ResultStorage:
     """
@@ -80,12 +77,6 @@ class ResultStorage:
                 )
                 conn.commit()
 
-            total_gen = network_stats.get("core_summary", {}).get("total_generation_mwh", 0)
-            total_cost = network_stats.get("core_summary", {}).get("total_cost", 0)
-            logger.info(
-                f"Results stored: {total_gen:.0f} MWh generation, {total_cost:.0f} cost, {year_stats_stored} years"
-            )
-
             return {
                 "component_stats": component_stats,
                 "network_stats": network_stats,
@@ -95,7 +86,6 @@ class ResultStorage:
             }
 
         except Exception as e:
-            logger.error(f"Result storage failed: {e}")
             return {
                 "component_stats": {},
                 "network_stats": {},
@@ -200,7 +190,6 @@ class ResultStorage:
             return results_stats
 
         except Exception as e:
-            logger.error(f"Error storing solve results: {e}", exc_info=True)
             results_stats["errors"] += 1
             return results_stats
 
@@ -272,9 +261,6 @@ class ResultStorage:
                         ):
                             continue
                         else:
-                            logger.warning(
-                                f"Error storing timeseries {attr_name} for {component_type} '{component_name}': {e}"
-                            )
                             continue
 
             # Store static optimization results - ONLY OUTPUT ATTRIBUTES (is_input=FALSE)
@@ -325,17 +311,11 @@ class ResultStorage:
                             ):
                                 continue
                             else:
-                                logger.warning(
-                                    f"Error storing static {attr_name} for {component_type} '{component_name}': {e}"
-                                )
                                 continue
 
             return stored_count
 
         except Exception as e:
-            logger.error(
-                f"Error storing results for {component_type}: {e}", exc_info=True
-            )
             return stored_count
 
     def _store_solve_summary(
@@ -394,7 +374,6 @@ class ResultStorage:
             )
 
         except Exception as e:
-            logger.error(f"Failed to store solve summary: {e}")
             raise  # Re-raise to trigger rollback
 
     def _calculate_network_statistics(
@@ -487,13 +466,9 @@ class ResultStorage:
                 },
             }
 
-            logger.info(
-                f"Calculated network statistics: core_summary={network_statistics['core_summary']}"
-            )
             return network_statistics
 
         except Exception as e:
-            logger.error(f"Failed to calculate network statistics: {e}", exc_info=True)
             # Return empty structure matching expected format
             return {
                 "core_summary": {
@@ -549,7 +524,6 @@ class ResultStorage:
                 years = network._available_years
             else:
                 years = [2020]  # Fallback
-                logger.warning(f"No year information found, using fallback: {years}")
 
             # Calculate per-year statistics first
             all_year_stats = {
@@ -618,7 +592,6 @@ class ResultStorage:
             return all_year_stats
 
         except Exception as e:
-            logger.error(f"Failed to calculate carrier statistics: {e}")
             return {
                 "dispatch_by_carrier": {},
                 "power_capacity_by_carrier": {},
@@ -718,13 +691,11 @@ class ResultStorage:
                     stored_count += 1
 
                 except Exception as e:
-                    logger.error(f"Failed to store statistics for year {year}: {e}")
                     continue
 
             return stored_count
 
         except Exception as e:
-            logger.error(f"Failed to store year-based statistics: {e}")
             return 0
 
     def _calculate_year_carrier_statistics(
@@ -805,9 +776,6 @@ class ResultStorage:
                             else:
                                 # Fallback: simple sum (will be incorrect for non-1H models)
                                 generation_mwh = float(year_generation[gen_name].sum())
-                                logger.warning(
-                                    f"Could not apply snapshot weightings for {gen_name} in year {year} - energy may be incorrect"
-                                )
 
                             if carrier_name in carrier_stats["dispatch_by_carrier"]:
                                 carrier_stats["dispatch_by_carrier"][
@@ -852,9 +820,6 @@ class ResultStorage:
                                 discharge_mwh = float(
                                     year_storage[su_name].clip(lower=0).sum()
                                 )
-                                logger.warning(
-                                    f"Could not apply snapshot weightings for storage unit {su_name} in year {year} - energy may be incorrect"
-                                )
 
                             if carrier_name in carrier_stats["dispatch_by_carrier"]:
                                 carrier_stats["dispatch_by_carrier"][
@@ -897,9 +862,6 @@ class ResultStorage:
                                 discharge_mwh = float(
                                     year_stores[store_name].clip(lower=0).sum()
                                 )
-                                logger.warning(
-                                    f"Could not apply snapshot weightings for store {store_name} in year {year} - energy may be incorrect"
-                                )
 
                             if carrier_name in carrier_stats["dispatch_by_carrier"]:
                                 carrier_stats["dispatch_by_carrier"][
@@ -1741,7 +1703,6 @@ class ResultStorage:
             return carrier_stats
 
         except Exception as e:
-            logger.error(f"Failed to calculate year {year} carrier statistics: {e}")
             return {
                 "dispatch_by_carrier": {},
                 "power_capacity_by_carrier": {},
@@ -1829,7 +1790,7 @@ class ResultStorage:
                         )
 
             except Exception as e:
-                logger.error(f"Failed to process last year ({last_year}) results: {e}")
+                pass  # Failed to process last year results
 
             # For other stats (dispatch, emissions, costs): sum across all years
             for year, results_json in year_results:
@@ -1881,13 +1842,11 @@ class ResultStorage:
                             )
 
                 except Exception as e:
-                    logger.error(f"Failed to process year {year} results: {e}")
                     continue
 
             return totals
 
         except Exception as e:
-            logger.error(f"Failed to sum year-based carrier statistics: {e}")
             # Return empty structure on error
             return {
                 "dispatch_by_carrier": {},
@@ -1917,7 +1876,6 @@ class ResultStorage:
             }
             return json.dumps(results, default=self._json_serializer)
         except Exception as e:
-            logger.warning(f"Failed to serialize results JSON: {e}")
             return json.dumps({"error": "serialization_failed"})
 
     def _serialize_metadata_json(self, solve_result: Dict[str, Any]) -> str:
@@ -1935,7 +1893,6 @@ class ResultStorage:
             }
             return json.dumps(metadata, default=self._json_serializer)
         except Exception as e:
-            logger.warning(f"Failed to serialize metadata JSON: {e}")
             return json.dumps({"error": "serialization_failed"})
 
     def _filter_timeseries_by_year(
@@ -1961,7 +1918,6 @@ class ResultStorage:
             return None
 
         except Exception as e:
-            logger.error(f"Failed to filter timeseries by year {year}: {e}")
             return None
 
     def _get_year_weightings(self, network: "pypsa.Network", year: int) -> "np.ndarray":
@@ -1997,7 +1953,6 @@ class ResultStorage:
             return None
 
         except Exception as e:
-            logger.error(f"Failed to get year weightings for year {year}: {e}")
             return None
 
     def _calculate_total_demand(self, network: "pypsa.Network") -> float:
@@ -2024,7 +1979,6 @@ class ResultStorage:
             return total_demand
 
         except Exception as e:
-            logger.error(f"Failed to calculate total demand: {e}")
             return 0.0
 
     def _json_serializer(self, obj):

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

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

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

@@ -1,5 +1,5 @@
 pyconvexity/__init__.py,sha256=TJvgkEaMHFFWhIGaOdjMgc4rHVIxHKni3Ggg1YAQziE,5347
-pyconvexity/_version.py,sha256=bbBpXE_PBbo_SaI807mDML0QJywD0_ufCDPgAMlDHaE,22
+pyconvexity/_version.py,sha256=mb7cZWFtBTYPgotnX_1oAZadFITLHrAXwTSs2Eb1dvU,28
 pyconvexity/timeseries.py,sha256=QdKbiqjAlxkJATyKm2Kelx1Ea2PsAnnCYfVLU5VER1Y,11085
 pyconvexity/core/__init__.py,sha256=gdyyHNqOc4h9Nfe9u6NA936GNzH6coGNCMgBvvvOnGE,1196
 pyconvexity/core/database.py,sha256=vwCmuN0B0xwImh6L0bFR4vNWHw_wVfYSG1KwsUjK4iY,14831
@@ -17,8 +17,8 @@ pyconvexity/data/sources/gem.py,sha256=v8OYCMsb2t-8u-YmK8vzMsgI9ArUAOAXMZZQOFpJ-
 pyconvexity/io/__init__.py,sha256=FCyvRDfBUrrNei-y5JVod6MMN1bkPMSSfE0fpKi1aKQ,751
 pyconvexity/io/excel_exporter.py,sha256=9MkZAVnHvsJSmfZ12w29GhDTsYI89fCGphjdo7s_ABs,50506
 pyconvexity/io/excel_importer.py,sha256=Q5petB0WXjbw0TIR4ofG3EkjdT8lBh21yJMbEgdtXfU,59347
-pyconvexity/io/netcdf_exporter.py,sha256=9EUPvDSYR7RxYDfOBT7O9clpC9F4sIj1RaNayvOmb5I,7119
-pyconvexity/io/netcdf_importer.py,sha256=WATZutznl7uMfcbi7957qxdP5NRQs3c1dV6mhBJotdc,70783
+pyconvexity/io/netcdf_exporter.py,sha256=ndbYa_b34LZQ-70Y7KXh3oLpATnARLciQHXKNpcjNoY,6828
+pyconvexity/io/netcdf_importer.py,sha256=JtdfIp48F_fQIlRgWJ3XaeeqtvQRa_FeE4hjVaA623I,67189
 pyconvexity/models/__init__.py,sha256=WqDSq1Mst7iJsFytausruoM562FKlOKV0Egmnpm2900,4695
 pyconvexity/models/attributes.py,sha256=RpH3rBoHD33xBSXUEfaD-CvRj3JruolCwexo6HPMGC8,23388
 pyconvexity/models/carriers.py,sha256=L_WuDMW13k8aaA-obsDPxjmpZgZELiIAZuNtxq7YLpg,3447
@@ -28,15 +28,15 @@ pyconvexity/models/results.py,sha256=6j1H4AwVmp94L97gl_sGnE8izMxkU5o89guKIU8JdtE
 pyconvexity/models/scenarios.py,sha256=-0UPUDXf6r9mFriA-z2fD5KKMARm2PUBjLba49S9mCI,5867
 pyconvexity/solvers/__init__.py,sha256=t1gOUTqbYDCtIvKPqGVY1fjKwqJi2Od9bGeIO7bPvJE,667
 pyconvexity/solvers/pypsa/__init__.py,sha256=nudu0AOYEfPhpGHZ1Q9pUgjGeeIJd_zeULc975iyluE,555
-pyconvexity/solvers/pypsa/api.py,sha256=OXGfVsv76HIXMJ4b_5LSiWW1OL5Xiq5EnUzaArTuaTI,18196
-pyconvexity/solvers/pypsa/batch_loader.py,sha256=w525_lqanKtARKgicajhBiDwIJzkaU_HbkL1I82gDqg,12361
-pyconvexity/solvers/pypsa/builder.py,sha256=SOr77SmDCYKNxfb-wGHYRX5A0M7zdv_E2Sjyf82uS6Y,24208
+pyconvexity/solvers/pypsa/api.py,sha256=CWKslptTlZrSbuHy916_PHhCG8nO9SCfjTXkJZylLM8,17512
+pyconvexity/solvers/pypsa/batch_loader.py,sha256=ZgOcZqMnMS3TOYTq2Ly2O4cuwhNNAicu3EDq1Fj38OI,11929
+pyconvexity/solvers/pypsa/builder.py,sha256=1ZU68Wtl_jQSXHzspKQDkR6bxAVU1nKvPfnPUl0aO3k,23256
 pyconvexity/solvers/pypsa/constraints.py,sha256=20WliFDhPQGMAsS4VOTU8LZJpsFpLVRHpNsZW49GTcc,16397
-pyconvexity/solvers/pypsa/solver.py,sha256=oXX2kqU9AWg8GgsMOV0fYqv93XjIk8Kh-fKWbQSzaig,63239
-pyconvexity/solvers/pypsa/storage.py,sha256=9edLe46f62jvpai1mNQEKypV77L26VyFdvKgQLCEA3o,94635
+pyconvexity/solvers/pypsa/solver.py,sha256=M-s-VUCnRD8Jdh22PCUA-gWgYp1eH6_sgpoSzcv6kNQ,59762
+pyconvexity/solvers/pypsa/storage.py,sha256=C8zLPXSd95LT0Aq6c00vZu1xlJHEF_l8RDUhB-s5mJ0,91704
 pyconvexity/validation/__init__.py,sha256=VJNZlFoWABsWwUKktNk2jbtXIepH5omvC0WtsTS7o3o,583
 pyconvexity/validation/rules.py,sha256=GiNadc8hvbWBr09vUkGiLLTmSdvtNSeGLFwvCjlikYY,9241
-pyconvexity-0.4.6.dist-info/METADATA,sha256=YEKMDpHrBrlWJZ8VA1DJgHrLN2oLXZNl3aojYwebRfg,4967
-pyconvexity-0.4.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyconvexity-0.4.6.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
-pyconvexity-0.4.6.dist-info/RECORD,,
+pyconvexity-0.4.6.post1.dist-info/METADATA,sha256=42uMFhx4muAr2ZyGYa00osp9K_ifn5l14814yYyHkis,4973
+pyconvexity-0.4.6.post1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyconvexity-0.4.6.post1.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
+pyconvexity-0.4.6.post1.dist-info/RECORD,,