pyconvexity 0.5.0__tar.gz → 0.5.1__tar.gz

{pyconvexity-0.5.0 → pyconvexity-0.5.1}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyconvexity"
-version = "0.5.0"
+version = "0.5.1"
 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.1"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true

{pyconvexity-0.5.0 → pyconvexity-0.5.1}/src/pyconvexity/__init__.py

@@ -239,3 +239,12 @@ try:
 except ImportError:
     # NetCDF dependencies not available
     pass
+
+# Transformation operations
+try:
+    from pyconvexity.transformations import modify_time_axis
+
+    __all__.append("modify_time_axis")
+except ImportError:
+    # Transformation dependencies (pandas, numpy) not available
+    pass

pyconvexity-0.5.1/src/pyconvexity/_version.py

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

{pyconvexity-0.5.0 → pyconvexity-0.5.1}/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.1/src/pyconvexity/transformations/__init__.py

@@ -0,0 +1,15 @@
+"""
+Transformations module for PyConvexity.
+
+Provides functions for transforming network data, including:
+- Time axis modification (truncation, resampling)
+- Future: network merging, scenario duplication, etc.
+"""
+
+from pyconvexity.transformations.api import modify_time_axis
+from pyconvexity.transformations.time_axis import TimeAxisModifier
+
+__all__ = [
+    "modify_time_axis",
+    "TimeAxisModifier",
+]

pyconvexity-0.5.1/src/pyconvexity/transformations/api.py

@@ -0,0 +1,93 @@
+"""
+High-level API for network transformations.
+
+Provides user-friendly functions for transforming network data.
+"""
+
+from typing import Any, Callable, Dict, Optional
+
+from pyconvexity.transformations.time_axis import TimeAxisModifier
+
+
+def modify_time_axis(
+    source_db_path: str,
+    target_db_path: str,
+    new_start: str,
+    new_end: str,
+    new_resolution_minutes: int,
+    new_network_name: Optional[str] = None,
+    convert_timeseries: bool = True,
+    progress_callback: Optional[Callable[[float, str], None]] = None,
+) -> Dict[str, Any]:
+    """
+    Create a new database with modified time axis and resampled timeseries data.
+
+    This function copies a network database while adjusting the time axis -
+    useful for truncating time periods, changing resolution, or both.
+    All timeseries data is automatically resampled to match the new time axis.
+
+    Args:
+        source_db_path: Path to source database
+        target_db_path: Path to target database (will be created)
+        new_start: Start datetime as ISO string (e.g., "2024-01-01 00:00:00")
+        new_end: End datetime as ISO string (e.g., "2024-12-31 23:00:00")
+        new_resolution_minutes: New time resolution in minutes (e.g., 60 for hourly)
+        new_network_name: Optional new name for the network
+        convert_timeseries: If True, resample timeseries data to new time axis.
+            If False, wipe all timeseries attributes (useful for creating templates)
+        progress_callback: Optional callback for progress updates.
+            Called with (progress: float, message: str) where progress is 0-100.
+
+    Returns:
+        Dictionary with results and statistics:
+            - success: bool - Whether the operation completed successfully
+            - source_db_path: str - Path to source database
+            - target_db_path: str - Path to created target database
+            - new_periods_count: int - Number of time periods in new database
+            - new_resolution_minutes: int - Resolution in minutes
+            - new_start: str - Start time
+            - new_end: str - End time
+            - processing_stats: dict - Detailed processing statistics
+
+    Raises:
+        ValueError: If time parameters are invalid (end before start, negative resolution)
+        FileNotFoundError: If source database doesn't exist
+
+    Example:
+        # Truncate a yearly model to one week with hourly resolution
+        result = modify_time_axis(
+            source_db_path="full_year_model.db",
+            target_db_path="one_week_model.db",
+            new_start="2024-01-01 00:00:00",
+            new_end="2024-01-07 23:00:00",
+            new_resolution_minutes=60,
+            new_network_name="One Week Test Model",
+        )
+
+        if result["success"]:
+            print(f"Created {result['target_db_path']} with {result['new_periods_count']} periods")
+
+    Example with progress tracking:
+        def on_progress(progress: float, message: str):
+            print(f"[{progress:.0f}%] {message}")
+
+        result = modify_time_axis(
+            source_db_path="original.db",
+            target_db_path="resampled.db",
+            new_start="2024-01-01",
+            new_end="2024-06-30",
+            new_resolution_minutes=60,
+            progress_callback=on_progress,
+        )
+    """
+    modifier = TimeAxisModifier()
+    return modifier.modify_time_axis(
+        source_db_path=source_db_path,
+        target_db_path=target_db_path,
+        new_start=new_start,
+        new_end=new_end,
+        new_resolution_minutes=new_resolution_minutes,
+        new_network_name=new_network_name,
+        convert_timeseries=convert_timeseries,
+        progress_callback=progress_callback,
+    )