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

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):