pyconvexity 0.4.9.post1__py3-none-any.whl → 0.5.0.post1__py3-none-any.whl

pyconvexity/_version.py

@@ -1 +1 @@
-__version__ = "0.4.9.post1"
+__version__ = "0.5.0.post1"

pyconvexity/solvers/pypsa/solver.py

@@ -38,81 +38,6 @@ class NetworkSolver:
                 "Please ensure it is installed correctly in the environment."
             ) from e
 
-    def _get_user_settings_path(self):
-        """Get the path to the user settings file (same location as Tauri uses)"""
-        try:
-            import platform
-            import os
-            from pathlib import Path
-
-            system = platform.system()
-            if system == "Darwin":  # macOS
-                home = Path.home()
-                app_data_dir = (
-                    home / "Library" / "Application Support" / "com.convexity.desktop"
-                )
-            elif system == "Windows":
-                app_data_dir = (
-                    Path(os.environ.get("APPDATA", "")) / "com.convexity.desktop"
-                )
-            else:  # Linux
-                home = Path.home()
-                app_data_dir = home / ".local" / "share" / "com.convexity.desktop"
-
-            settings_file = app_data_dir / "user_settings.json"
-            return settings_file if settings_file.exists() else None
-
-        except Exception as e:
-            return None
-
-    def _resolve_default_solver(self) -> str:
-        """Resolve 'default' solver to user's preferred solver"""
-        try:
-            import json
-
-            settings_path = self._get_user_settings_path()
-            if not settings_path:
-                return "highs"
-
-            with open(settings_path, "r") as f:
-                user_settings = json.load(f)
-
-            # Get default solver from user settings
-            default_solver = user_settings.get("default_solver", "highs")
-
-            # Validate that it's a known solver
-            known_solvers = [
-                "highs",
-                "gurobi",
-                "gurobi (barrier)",
-                "gurobi (barrier homogeneous)",
-                "gurobi (barrier+crossover balanced)",
-                "gurobi (dual simplex)",
-                "mosek",
-                "mosek (default)",
-                "mosek (barrier)",
-                "mosek (barrier+crossover)",
-                "mosek (dual simplex)",
-                "copt",
-                "copt (barrier)",
-                "copt (barrier homogeneous)",
-                "copt (barrier+crossover)",
-                "copt (dual simplex)",
-                "copt (concurrent)",
-                "cplex",
-                "glpk",
-                "cbc",
-                "scip",
-            ]
-
-            if default_solver in known_solvers:
-                return default_solver
-            else:
-                return "highs"
-
-        except Exception as e:
-            return "highs"
-
     def solve_network(
         self,
         network: "pypsa.Network",
@@ -269,24 +194,19 @@ class NetworkSolver:
         custom_solver_config: Optional[Dict[str, Any]] = None,
     ) -> tuple[str, Optional[Dict[str, Any]]]:
         """
-        Get the actual solver name and options for special solver configurations.
+        Get the actual solver name and options for solver configurations.
 
         Args:
-            solver_name: The solver name (e.g., 'gurobi (barrier)', 'highs', 'custom')
+            solver_name: The solver name (e.g., 'highs', 'gurobi', 'custom')
             solver_options: Optional additional solver options
-            custom_solver_config: Optional custom solver configuration for solver_name='custom'
+            custom_solver_config: Custom solver configuration (from frontend)
                 Format: {"solver": "actual_solver_name", "solver_options": {...}}
 
         Returns:
             Tuple of (actual_solver_name, solver_options_dict)
         """
-        # Handle "custom" solver with custom configuration
-        if solver_name == "custom":
-            if not custom_solver_config:
-                raise ValueError(
-                    "custom_solver_config must be provided when solver_name='custom'"
-                )
-
+        # Handle "custom" solver with custom configuration from frontend
+        if solver_name == "custom" and custom_solver_config:
             if "solver" not in custom_solver_config:
                 raise ValueError(
                     "custom_solver_config must contain 'solver' key with the actual solver name"
@@ -307,294 +227,12 @@ class NetworkSolver:
 
             return actual_solver, merged_options
 
-        # Handle "default" solver
-        if solver_name == "default":
-            # Try to read user's default solver preference
-            actual_solver = self._resolve_default_solver()
-            return actual_solver, solver_options
-
-        # Handle special Gurobi configurations
-        if solver_name == "gurobi (barrier)":
-            gurobi_barrier_options = {
-                "solver_options": {
-                    "Method": 2,  # Barrier
-                    "Crossover": 0,  # Skip crossover
-                    "MIPGap": 0.05,  # 5% gap
-                    "Threads": 0,  # Use all cores (0 = auto)
-                    "Presolve": 2,  # Aggressive presolve
-                    "ConcurrentMIP": 1,  # Parallel root strategies
-                    "BarConvTol": 1e-4,  # Relaxed barrier convergence
-                    "FeasibilityTol": 1e-5,
-                    "OptimalityTol": 1e-5,
-                    "NumericFocus": 1,  # Improve stability
-                    "PreSparsify": 1,
-                }
-            }
-            # Merge with any additional options
-            if solver_options:
-                gurobi_barrier_options.update(solver_options)
-            return "gurobi", gurobi_barrier_options
-
-        elif solver_name == "gurobi (barrier homogeneous)":
-            gurobi_barrier_homogeneous_options = {
-                "solver_options": {
-                    "Method": 2,  # Barrier
-                    "Crossover": 0,  # Skip crossover
-                    "MIPGap": 0.05,
-                    "Threads": 0,  # Use all cores (0 = auto)
-                    "Presolve": 2,
-                    "ConcurrentMIP": 1,
-                    "BarConvTol": 1e-4,
-                    "FeasibilityTol": 1e-5,
-                    "OptimalityTol": 1e-5,
-                    "NumericFocus": 1,
-                    "PreSparsify": 1,
-                    "BarHomogeneous": 1,  # Enable homogeneous barrier algorithm
-                }
-            }
-            if solver_options:
-                gurobi_barrier_homogeneous_options.update(solver_options)
-            return "gurobi", gurobi_barrier_homogeneous_options
-
-        elif solver_name == "gurobi (barrier+crossover balanced)":
-            gurobi_options_balanced = {
-                "solver_options": {
-                    "Method": 2,
-                    "Crossover": 1,  # Dual crossover
-                    "MIPGap": 0.01,
-                    "Threads": 0,  # Use all cores (0 = auto)
-                    "Presolve": 2,
-                    "Heuristics": 0.1,
-                    "Cuts": 2,
-                    "ConcurrentMIP": 1,
-                    "BarConvTol": 1e-6,
-                    "FeasibilityTol": 1e-6,
-                    "OptimalityTol": 1e-6,
-                    "NumericFocus": 1,
-                    "PreSparsify": 1,
-                }
-            }
-            if solver_options:
-                gurobi_options_balanced.update(solver_options)
-            return "gurobi", gurobi_options_balanced
-
-        elif solver_name == "gurobi (dual simplex)":
-            gurobi_dual_options = {
-                "solver_options": {
-                    "Method": 1,  # Dual simplex method
-                    "Threads": 0,  # Use all available cores
-                    "Presolve": 2,  # Aggressive presolve
-                }
-            }
-            if solver_options:
-                gurobi_dual_options.update(solver_options)
-            return "gurobi", gurobi_dual_options
-
-        # Handle special Mosek configurations
-        elif solver_name == "mosek (default)":
-            # No custom options - let Mosek use its default configuration
-            mosek_default_options = {
-                "solver_options": {
-                    "MSK_DPAR_MIO_REL_GAP_CONST": 0.05,  # MIP relative gap tolerance (5% to match Gurobi)
-                    "MSK_DPAR_MIO_MAX_TIME": 36000,  # Max time 10 hours
-                }
-            }
-            if solver_options:
-                mosek_default_options["solver_options"].update(solver_options)
-            return "mosek", mosek_default_options
-
-        elif solver_name == "mosek (barrier)":
-            mosek_barrier_options = {
-                "solver_options": {
-                    "MSK_IPAR_INTPNT_BASIS": 0,  # Skip crossover (barrier-only) - 0 = MSK_BI_NEVER
-                    "MSK_DPAR_INTPNT_TOL_REL_GAP": 1e-4,  # Match Gurobi barrier tolerance
-                    "MSK_DPAR_INTPNT_TOL_PFEAS": 1e-5,  # Match Gurobi primal feasibility
-                    "MSK_DPAR_INTPNT_TOL_DFEAS": 1e-5,  # Match Gurobi dual feasibility
-                    # Removed MSK_DPAR_INTPNT_TOL_INFEAS - was 1000x tighter than other tolerances!
-                    "MSK_IPAR_NUM_THREADS": 0,  # Use all available cores (0 = auto)
-                    "MSK_IPAR_PRESOLVE_USE": 2,  # Aggressive presolve (match Gurobi Presolve=2)
-                    "MSK_DPAR_MIO_REL_GAP_CONST": 0.05,  # Match Gurobi 5% MIP gap
-                    "MSK_IPAR_MIO_ROOT_OPTIMIZER": 4,  # Use interior-point for MIP root
-                    "MSK_DPAR_MIO_MAX_TIME": 36000,  # Max time 10 hour
-                }
-            }
-            if solver_options:
-                mosek_barrier_options["solver_options"].update(solver_options)
-            return "mosek", mosek_barrier_options
-
-        elif solver_name == "mosek (barrier+crossover)":
-            mosek_barrier_crossover_options = {
-                "solver_options": {
-                    "MSK_IPAR_INTPNT_BASIS": 1,  # Always crossover (1 = MSK_BI_ALWAYS)
-                    "MSK_DPAR_INTPNT_TOL_REL_GAP": 1e-4,  # Match Gurobi barrier tolerance (was 1e-6)
-                    "MSK_DPAR_INTPNT_TOL_PFEAS": 1e-5,  # Match Gurobi (was 1e-6)
-                    "MSK_DPAR_INTPNT_TOL_DFEAS": 1e-5,  # Match Gurobi (was 1e-6)
-                    "MSK_IPAR_NUM_THREADS": 0,  # Use all available cores (0 = auto)
-                    "MSK_DPAR_MIO_REL_GAP_CONST": 0.05,  # Match Gurobi 5% MIP gap (was 1e-6)
-                    "MSK_IPAR_MIO_ROOT_OPTIMIZER": 4,  # Use interior-point for MIP root
-                    "MSK_DPAR_MIO_MAX_TIME": 36000,  # Max time 10 hour (safety limit)
-                }
-            }
-            if solver_options:
-                mosek_barrier_crossover_options["solver_options"].update(solver_options)
-            return "mosek", mosek_barrier_crossover_options
-
-        elif solver_name == "mosek (dual simplex)":
-            mosek_dual_options = {
-                "solver_options": {
-                    "MSK_IPAR_NUM_THREADS": 0,  # Use all available cores (0 = automatic)
-                    "MSK_IPAR_PRESOLVE_USE": 1,  # Force presolve
-                    "MSK_DPAR_MIO_REL_GAP_CONST": 0.05,  # Match Gurobi 5% MIP gap (was 1e-6)
-                    "MSK_IPAR_MIO_ROOT_OPTIMIZER": 1,  # Use dual simplex for MIP root
-                    "MSK_DPAR_MIO_MAX_TIME": 36000,  # Max time 10 hour (safety limit)
-                }
-            }
-            if solver_options:
-                mosek_dual_options["solver_options"].update(solver_options)
-            return "mosek", mosek_dual_options
-
-        # Check if this is a known valid solver name
-        elif solver_name == "mosek":
-            # Add default MILP-friendly settings for plain Mosek
-            mosek_defaults = {
-                "solver_options": {
-                    "MSK_DPAR_MIO_REL_GAP_CONST": 0.05,  # Match Gurobi 5% MIP gap (was 1e-4)
-                    "MSK_DPAR_MIO_MAX_TIME": 36000,  # Max time 10 hours
-                    "MSK_IPAR_NUM_THREADS": 0,  # Use all cores (0 = auto)
-                }
-            }
-            if solver_options:
-                mosek_defaults["solver_options"].update(solver_options)
-            return solver_name, mosek_defaults
-
-        elif solver_name == "gurobi":
-            # Add default MILP-friendly settings for plain Gurobi (for consistency)
-            gurobi_defaults = {
-                "solver_options": {
-                    "MIPGap": 1e-4,  # 0.01% gap
-                    "TimeLimit": 3600,  # 1 hour
-                    "Threads": 0,  # Use all cores
-                    "OutputFlag": 1,  # Enable output
-                }
-            }
-            if solver_options:
-                gurobi_defaults["solver_options"].update(solver_options)
-            return solver_name, gurobi_defaults
-
-        # Handle special COPT configurations
-        elif solver_name == "copt (barrier)":
-            copt_barrier_options = {
-                "solver_options": {
-                    "LpMethod": 2,  # Barrier method
-                    "Crossover": 0,  # Skip crossover for speed
-                    "RelGap": 0.05,  # 5% MIP gap (match Gurobi)
-                    "TimeLimit": 7200,  # 1 hour time limit
-                    "Threads": -1,  # 4 threads (memory-conscious)
-                    "Presolve": 3,  # Aggressive presolve
-                    "Scaling": 1,  # Enable scaling
-                    "FeasTol": 1e-5,  # Match Gurobi feasibility
-                    "DualTol": 1e-5,  # Match Gurobi dual tolerance
-                    # MIP performance settings
-                    "CutLevel": 2,  # Normal cut generation
-                    "HeurLevel": 3,  # Aggressive heuristics
-                    "StrongBranching": 1,  # Fast strong branching
-                }
-            }
-            if solver_options:
-                copt_barrier_options["solver_options"].update(solver_options)
-            return "copt", copt_barrier_options
-
-        elif solver_name == "copt (barrier homogeneous)":
-            copt_barrier_homogeneous_options = {
-                "solver_options": {
-                    "LpMethod": 2,  # Barrier method
-                    "Crossover": 0,  # Skip crossover
-                    "BarHomogeneous": 1,  # Use homogeneous self-dual form
-                    "RelGap": 0.05,  # 5% MIP gap
-                    "TimeLimit": 3600,  # 1 hour
-                    "Threads": -1,  # 4 threads (memory-conscious)
-                    "Presolve": 3,  # Aggressive presolve
-                    "Scaling": 1,  # Enable scaling
-                    "FeasTol": 1e-5,
-                    "DualTol": 1e-5,
-                    # MIP performance settings
-                    "CutLevel": 2,  # Normal cuts
-                    "HeurLevel": 3,  # Aggressive heuristics
-                    "StrongBranching": 1,  # Fast strong branching
-                }
-            }
-            if solver_options:
-                copt_barrier_homogeneous_options["solver_options"].update(
-                    solver_options
-                )
-            return "copt", copt_barrier_homogeneous_options
-
-        elif solver_name == "copt (barrier+crossover)":
-            copt_barrier_crossover_options = {
-                "solver_options": {
-                    "LpMethod": 2,  # Barrier method
-                    "Crossover": 1,  # Enable crossover for better solutions
-                    "RelGap": 0.05,  # 5% MIP gap (relaxed for faster solves)
-                    "TimeLimit": 36000,  # 10 hour
-                    "Threads": -1,  # Use all cores
-                    "Presolve": 2,  # Aggressive presolve
-                    "Scaling": 1,  # Enable scaling
-                    "FeasTol": 1e-4,  # Tighter feasibility
-                    "DualTol": 1e-4,  # Tighter dual tolerance
-                }
-            }
-            if solver_options:
-                copt_barrier_crossover_options["solver_options"].update(solver_options)
-            return "copt", copt_barrier_crossover_options
-
-        elif solver_name == "copt (dual simplex)":
-            copt_dual_simplex_options = {
-                "solver_options": {
-                    "LpMethod": 1,  # Dual simplex method
-                    "RelGap": 0.05,  # 5% MIP gap
-                    "TimeLimit": 3600,  # 1 hour
-                    "Threads": -1,  # Use all cores
-                    "Presolve": 3,  # Aggressive presolve
-                    "Scaling": 1,  # Enable scaling
-                    "FeasTol": 1e-6,
-                    "DualTol": 1e-6,
-                    # MIP performance settings
-                    "CutLevel": 2,  # Normal cuts
-                    "HeurLevel": 2,  # Normal heuristics
-                    "StrongBranching": 1,  # Fast strong branching
-                }
-            }
-            if solver_options:
-                copt_dual_simplex_options["solver_options"].update(solver_options)
-            return "copt", copt_dual_simplex_options
-
-        elif solver_name == "copt (concurrent)":
-            copt_concurrent_options = {
-                "solver_options": {
-                    "LpMethod": 4,  # Concurrent (simplex + barrier)
-                    "RelGap": 0.05,  # 5% MIP gap
-                    "TimeLimit": 3600,  # 1 hour
-                    "Threads": -1,  # Use all cores
-                    "Presolve": 3,  # Aggressive presolve
-                    "Scaling": 1,  # Enable scaling
-                    "FeasTol": 1e-5,
-                    "DualTol": 1e-5,
-                    # MIP performance settings
-                    "CutLevel": 2,  # Normal cuts
-                    "HeurLevel": 3,  # Aggressive heuristics
-                    "StrongBranching": 1,  # Fast strong branching
-                }
-            }
-            if solver_options:
-                copt_concurrent_options["solver_options"].update(solver_options)
-            return "copt", copt_concurrent_options
-
-        elif solver_name in ["highs", "cplex", "glpk", "cbc", "scip", "copt"]:
-            return solver_name, solver_options
-
-        else:
-            # Unknown solver name - fall back to highs
-            return "highs", solver_options
+        # For all other cases, pass through solver name and options directly
+        # The frontend is responsible for resolving presets and defaults
+        if solver_options:
+            return solver_name, {"solver_options": solver_options}
+        
+        return solver_name, None
 
     def _detect_constraint_type(self, constraint_code: str) -> str:
         """

pyconvexity/solvers/pypsa/storage.py

@@ -829,6 +829,7 @@ class ResultStorage:
             # 1. GENERATORS - Generation dispatch (including UNMET_LOAD)
             if hasattr(network, "generators_t") and hasattr(network.generators_t, "p"):
                 # Get generator-carrier mapping (include both GENERATOR and UNMET_LOAD)
+                # Use LEFT JOIN to include UNMET_LOAD components even if they don't have a carrier_id
                 cursor = conn.execute(
                     """
                 SELECT c.name as component_name, 
@@ -837,7 +838,7 @@ class ResultStorage:
                            ELSE carr.name 
                        END as carrier_name
                 FROM components c
-                JOIN carriers carr ON c.carrier_id = carr.id
+                LEFT JOIN carriers carr ON c.carrier_id = carr.id
                 WHERE c.component_type IN ('GENERATOR', 'UNMET_LOAD')
             """
                 )
@@ -1006,19 +1007,16 @@ class ResultStorage:
                 end_year = build_year + lifetime - 1
                 return current_year <= end_year
 
-            # 1. GENERATORS - Capital costs (including UNMET_LOAD)
+            # 1. GENERATORS - Capital costs (excluding UNMET_LOAD)
             if hasattr(network, "generators") and not network.generators.empty:
-                # Get generator info: carrier, capital_cost, build_year, lifetime (include UNMET_LOAD)
+                # Get generator info: carrier, capital_cost, build_year, lifetime
+                # EXCLUDE UNMET_LOAD - their capital cost is not meaningful (usually $0)
                 cursor = conn.execute(
                     """
-                    SELECT c.name as component_name, 
-                           CASE 
-                               WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
-                               ELSE carr.name 
-                           END as carrier_name
+                    SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
-                    JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.component_type IN ('GENERATOR', 'UNMET_LOAD')
+                    LEFT JOIN carriers carr ON c.carrier_id = carr.id
+                    WHERE c.component_type = 'GENERATOR'
                 """
                 )
                 generator_carriers = {row[0]: row[1] for row in cursor.fetchall()}
@@ -1297,19 +1295,16 @@ class ResultStorage:
             # Operational costs = dispatch (MWh) × marginal_cost (currency/MWh)
             # Only for components that are active in this year
 
-            # 1. GENERATORS - Operational costs (including UNMET_LOAD)
+            # 1. GENERATORS - Operational costs (excluding UNMET_LOAD)
             if hasattr(network, "generators_t") and hasattr(network.generators_t, "p"):
-                # Get generator info: carrier, marginal_cost, build_year, lifetime (include UNMET_LOAD)
+                # Get generator info: carrier, marginal_cost, build_year, lifetime
+                # EXCLUDE UNMET_LOAD - their marginal cost is a penalty price, not a real operational cost
                 cursor = conn.execute(
                     """
-                    SELECT c.name as component_name, 
-                           CASE 
-                               WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
-                               ELSE carr.name 
-                           END as carrier_name
+                    SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
-                    JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.component_type IN ('GENERATOR', 'UNMET_LOAD')
+                    LEFT JOIN carriers carr ON c.carrier_id = carr.id
+                    WHERE c.component_type = 'GENERATOR'
                 """
                 )
                 generator_carriers = {row[0]: row[1] for row in cursor.fetchall()}
@@ -1539,19 +1534,16 @@ class ResultStorage:
 
             # Calculate capacity by carrier for this specific year
 
-            # 4. GENERATORS - Power capacity (MW) (including UNMET_LOAD)
+            # 4. GENERATORS - Power capacity (MW) (excluding UNMET_LOAD)
             if hasattr(network, "generators") and not network.generators.empty:
-                # Get generator-carrier mapping (include UNMET_LOAD)
+                # Get generator-carrier mapping for capacity
+                # EXCLUDE UNMET_LOAD - their capacity (often infinite) is not meaningful for capacity stats
                 cursor = conn.execute(
                     """
-                    SELECT c.name as component_name, 
-                           CASE 
-                               WHEN c.component_type = 'UNMET_LOAD' THEN 'Unmet Load'
-                               ELSE carr.name 
-                           END as carrier_name
+                    SELECT c.name as component_name, carr.name as carrier_name
                     FROM components c
-                    JOIN carriers carr ON c.carrier_id = carr.id
-                    WHERE c.component_type IN ('GENERATOR', 'UNMET_LOAD')
+                    LEFT JOIN carriers carr ON c.carrier_id = carr.id
+                    WHERE c.component_type = 'GENERATOR'
                 """
                 )
                 generator_carriers = {row[0]: row[1] for row in cursor.fetchall()}

{pyconvexity-0.4.9.post1.dist-info → pyconvexity-0.5.0.post1.dist-info}/METADATA

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

{pyconvexity-0.4.9.post1.dist-info → pyconvexity-0.5.0.post1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pyconvexity/__init__.py,sha256=P67QJ8npf-QWmBX12im__eICLoRz8cByQ5OJXiyIBmA,5706
-pyconvexity/_version.py,sha256=zFQM77wgAmWBTKJkmd0BFXV3JGA69nyLLIJtFnFJo6Q,28
+pyconvexity/_version.py,sha256=J1kBZAgpuK-WFUqCCzGZrBt454s_I5sVWXeEXZ7DyLQ,28
 pyconvexity/dashboard.py,sha256=7x04Hr-EwzTAf-YJdHzfV83Gf2etltwtzwh_bCYJ5lk,8579
 pyconvexity/timeseries.py,sha256=QdKbiqjAlxkJATyKm2Kelx1Ea2PsAnnCYfVLU5VER1Y,11085
 pyconvexity/core/__init__.py,sha256=gdyyHNqOc4h9Nfe9u6NA936GNzH6coGNCMgBvvvOnGE,1196
@@ -34,11 +34,11 @@ pyconvexity/solvers/pypsa/batch_loader.py,sha256=ZgOcZqMnMS3TOYTq2Ly2O4cuwhNNAic
 pyconvexity/solvers/pypsa/builder.py,sha256=1ZU68Wtl_jQSXHzspKQDkR6bxAVU1nKvPfnPUl0aO3k,23256
 pyconvexity/solvers/pypsa/clearing_price.py,sha256=HdAk7GPfJFVI4t6mL0zQGEOMAvuyfpl0yNCnah1ZGH0,29164
 pyconvexity/solvers/pypsa/constraints.py,sha256=20WliFDhPQGMAsS4VOTU8LZJpsFpLVRHpNsZW49GTcc,16397
-pyconvexity/solvers/pypsa/solver.py,sha256=iVgDsmYK7AvutkpuNoW_DoLAKODFJTFA2W1cCo1yhPQ,60427
-pyconvexity/solvers/pypsa/storage.py,sha256=KcHIK3wgYjs7oV4tAqWU3HnxJcC_5MoylLoPuAECmDU,95195
+pyconvexity/solvers/pypsa/solver.py,sha256=pNI9ch0vO5q-8mWc3RHTscWB_ymj4s2lVJQ_e2nbzHY,44417
+pyconvexity/solvers/pypsa/storage.py,sha256=nbONOBnunq3tyexa5yDUsT9xdxieUfrqhoM76_2HIGg,94956
 pyconvexity/validation/__init__.py,sha256=VJNZlFoWABsWwUKktNk2jbtXIepH5omvC0WtsTS7o3o,583
 pyconvexity/validation/rules.py,sha256=GiNadc8hvbWBr09vUkGiLLTmSdvtNSeGLFwvCjlikYY,9241
-pyconvexity-0.4.9.post1.dist-info/METADATA,sha256=IcOxAbx3C6EXGDxn6LkqQzCrxagzhY26F_aNg0VhX_g,4973
-pyconvexity-0.4.9.post1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyconvexity-0.4.9.post1.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
-pyconvexity-0.4.9.post1.dist-info/RECORD,,
+pyconvexity-0.5.0.post1.dist-info/METADATA,sha256=ww2Vp1jYb4upZigNRSZ4augdGBQWBGfokrvFyPm_Vq8,4973
+pyconvexity-0.5.0.post1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyconvexity-0.5.0.post1.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
+pyconvexity-0.5.0.post1.dist-info/RECORD,,