pyconvexity 0.5.0__tar.gz → 0.5.0.post1__tar.gz

{pyconvexity-0.5.0 → pyconvexity-0.5.0.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyconvexity
-Version: 0.5.0
+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.5.0 → pyconvexity-0.5.0.post1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyconvexity"
-version = "0.5.0"
+version = "0.5.0.post1"
 description = "Python library for energy system modeling and optimization with PyPSA"
 readme = "README.md"
 license = {text = "MIT"}
@@ -81,7 +81,7 @@ profile = "black"
 line_length = 88
 
 [tool.mypy]
-python_version = "0.5.0"
+python_version = "0.5.0.post1"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true

pyconvexity-0.5.0.post1/src/pyconvexity/_version.py

@@ -0,0 +1 @@
+__version__ = "0.5.0.post1"

{pyconvexity-0.5.0 → pyconvexity-0.5.0.post1}/src/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-0.5.0 → pyconvexity-0.5.0.post1}/src/pyconvexity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyconvexity
-Version: 0.5.0
+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.5.0/src/pyconvexity/_version.py

@@ -1 +0,0 @@
-__version__ = "0.5.0"