pyconvexity 0.5.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

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/_version.py

@@ -1 +1 @@
-__version__ = "0.5.0"
+__version__ = "0.5.1"

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/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/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,
+    )

pyconvexity/transformations/time_axis.py

@@ -0,0 +1,721 @@
+"""
+Time axis modification for PyConvexity networks.
+
+Handles truncation and resampling of network time periods and all associated timeseries data.
+"""
+
+import logging
+import shutil
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+
+from pyconvexity.core.database import database_context
+from pyconvexity.core.types import TimePeriod
+from pyconvexity.models.network import get_network_info, get_network_time_periods
+from pyconvexity.timeseries import get_timeseries, set_timeseries
+
+logger = logging.getLogger(__name__)
+
+
+class TimeAxisModifier:
+    """
+    Service for modifying network time axis and resampling all timeseries data.
+
+    This class handles the complete workflow of:
+    1. Copying a network database
+    2. Modifying the time axis (start, end, resolution)
+    3. Resampling all timeseries data to match the new time axis
+
+    Example:
+        modifier = TimeAxisModifier()
+        result = modifier.modify_time_axis(
+            source_db_path="original.db",
+            target_db_path="resampled.db",
+            new_start="2024-01-01 00:00:00",
+            new_end="2024-01-07 23:00:00",
+            new_resolution_minutes=60,
+        )
+    """
+
+    def __init__(self):
+        logger.debug("TimeAxisModifier initialized")
+
+    def _minutes_to_freq_str(self, minutes: int) -> str:
+        """Convert minutes to a pandas frequency string, preferring aliases like 'D' or 'h'."""
+        if minutes == 1440:
+            return "D"
+        if minutes % (60 * 24) == 0:
+            days = minutes // (60 * 24)
+            return f"{days}D"
+        if minutes == 60:
+            return "h"
+        if minutes % 60 == 0:
+            hours = minutes // 60
+            return f"{hours}h"
+        return f"{minutes}min"
+
+    def modify_time_axis(
+        self,
+        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 method creates a copy of the source database and modifies its time axis,
+        optionally resampling all timeseries data to match the new time periods.
+
+        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. If False, wipe all timeseries
+            progress_callback: Optional callback for progress updates (progress: float, message: str)
+
+        Returns:
+            Dictionary with results and statistics:
+                - success: bool
+                - source_db_path: str
+                - target_db_path: str
+                - new_periods_count: int
+                - new_resolution_minutes: int
+                - new_start: str
+                - new_end: str
+                - processing_stats: dict with detailed statistics
+
+        Raises:
+            ValueError: If time parameters are invalid
+            FileNotFoundError: If source database doesn't exist
+        """
+
+        def update_progress(progress: float, message: str):
+            if progress_callback:
+                progress_callback(progress, message)
+            logger.info(f"[{progress:.1f}%] {message}")
+
+        try:
+            update_progress(0, "Starting time axis modification...")
+
+            # Validate inputs
+            start_dt = pd.Timestamp(new_start)
+            end_dt = pd.Timestamp(new_end)
+
+            if end_dt <= start_dt:
+                raise ValueError("End time must be after start time")
+
+            if new_resolution_minutes <= 0:
+                raise ValueError("Time resolution must be positive")
+
+            update_progress(5, "Validating source database...")
+
+            # Validate source database and get network info
+            with database_context(source_db_path, read_only=True) as source_conn:
+                network_info = get_network_info(source_conn)
+                if not network_info:
+                    raise ValueError("No network metadata found in source database")
+
+            # Generate new time periods
+            update_progress(10, "Generating new time axis...")
+            new_time_periods = self._generate_time_periods(
+                start_dt, end_dt, new_resolution_minutes
+            )
+            update_progress(15, f"Generated {len(new_time_periods)} new time periods")
+
+            # Copy database schema and static data
+            update_progress(20, "Creating target database...")
+            self._copy_database_structure(
+                source_db_path,
+                target_db_path,
+                new_time_periods,
+                new_resolution_minutes,
+                new_network_name,
+                update_progress,
+            )
+
+            # Process timeseries data based on convert_timeseries flag
+            if convert_timeseries:
+                update_progress(40, "Processing timeseries data...")
+                stats = self._process_all_timeseries(
+                    source_db_path,
+                    target_db_path,
+                    new_time_periods,
+                    new_resolution_minutes,
+                    update_progress,
+                )
+            else:
+                update_progress(40, "Wiping timeseries data...")
+                stats = self._wipe_all_timeseries(target_db_path, update_progress)
+
+            update_progress(95, "Finalizing database...")
+
+            # Validate target database
+            with database_context(target_db_path, read_only=True) as target_conn:
+                target_network_info = get_network_info(target_conn)
+                if not target_network_info:
+                    raise ValueError("Failed to create target network")
+
+            update_progress(100, "Time axis modification completed successfully")
+
+            return {
+                "success": True,
+                "source_db_path": source_db_path,
+                "target_db_path": target_db_path,
+                "new_periods_count": len(new_time_periods),
+                "original_resolution_minutes": None,  # Could be calculated from source
+                "new_resolution_minutes": new_resolution_minutes,
+                "new_start": new_start,
+                "new_end": new_end,
+                "processing_stats": stats,
+            }
+
+        except Exception as e:
+            logger.error(f"Time axis modification failed: {e}", exc_info=True)
+
+            # Clean up partial target file
+            try:
+                target_path = Path(target_db_path)
+                if target_path.exists():
+                    target_path.unlink()
+                    logger.info(f"Cleaned up partial target database: {target_db_path}")
+            except Exception as cleanup_error:
+                logger.warning(
+                    f"Failed to clean up partial target database: {cleanup_error}"
+                )
+
+            raise
+
+    def _generate_time_periods(
+        self, start: pd.Timestamp, end: pd.Timestamp, resolution_minutes: int
+    ) -> List[TimePeriod]:
+        """Generate new time periods based on start, end, and resolution."""
+
+        # Create time range
+        freq_str = self._minutes_to_freq_str(resolution_minutes)
+        timestamps = pd.date_range(
+            start=start, end=end, freq=freq_str, inclusive="both"
+        )
+
+        periods = []
+        for i, timestamp in enumerate(timestamps):
+            # Convert to Unix timestamp (seconds)
+            unix_timestamp = int(timestamp.timestamp())
+
+            # Create formatted time string (UTC to avoid DST issues)
+            formatted_time = timestamp.strftime("%Y-%m-%d %H:%M:%S")
+
+            periods.append(
+                TimePeriod(
+                    timestamp=unix_timestamp,
+                    period_index=i,
+                    formatted_time=formatted_time,
+                )
+            )
+
+        logger.info(
+            f"Generated {len(periods)} time periods from {start} to {end} "
+            f"at {resolution_minutes}min resolution"
+        )
+        return periods
+
+    def _copy_database_structure(
+        self,
+        source_path: str,
+        target_path: str,
+        new_periods: List[TimePeriod],
+        new_resolution_minutes: int,
+        new_network_name: Optional[str],
+        progress_callback: Callable[[float, str], None],
+    ):
+        """Copy database schema and static data, update time periods."""
+
+        # Copy entire database file as starting point
+        progress_callback(25, "Copying database file...")
+        shutil.copy2(source_path, target_path)
+
+        # Connect to target database and update time periods
+        progress_callback(30, "Updating time periods...")
+
+        with database_context(target_path) as target_conn:
+            # Clear existing time periods (single row for entire database)
+            target_conn.execute("DELETE FROM network_time_periods")
+
+            # Insert new optimized time periods metadata
+            if new_periods:
+                period_count = len(new_periods)
+                start_timestamp = new_periods[0].timestamp
+
+                # Calculate interval in seconds
+                if len(new_periods) > 1:
+                    interval_seconds = (
+                        new_periods[1].timestamp - new_periods[0].timestamp
+                    )
+                else:
+                    interval_seconds = new_resolution_minutes * 60
+
+                target_conn.execute(
+                    """
+                    INSERT INTO network_time_periods (period_count, start_timestamp, interval_seconds)
+                    VALUES (?, ?, ?)
+                """,
+                    (period_count, start_timestamp, interval_seconds),
+                )
+
+            # Update network metadata with new time range and resolution
+            start_time = new_periods[0].formatted_time if new_periods else None
+            end_time = new_periods[-1].formatted_time if new_periods else None
+
+            # Convert resolution to ISO 8601 duration format
+            if new_resolution_minutes < 60:
+                time_interval = f"PT{new_resolution_minutes}M"
+            elif new_resolution_minutes % 60 == 0:
+                hours = new_resolution_minutes // 60
+                time_interval = f"PT{hours}H"
+            else:
+                time_interval = f"PT{new_resolution_minutes}M"
+
+            # Update network metadata including name if provided
+            if new_network_name:
+                target_conn.execute(
+                    """
+                    UPDATE network_metadata 
+                    SET name = ?, time_start = ?, time_end = ?, time_interval = ?, updated_at = datetime('now')
+                """,
+                    (new_network_name, start_time, end_time, time_interval),
+                )
+            else:
+                target_conn.execute(
+                    """
+                    UPDATE network_metadata 
+                    SET time_start = ?, time_end = ?, time_interval = ?, updated_at = datetime('now')
+                """,
+                    (start_time, end_time, time_interval),
+                )
+
+            # Clear data that becomes invalid with new time axis
+            progress_callback(32, "Clearing time-dependent data...")
+
+            # Clear solve results (they're tied to specific time periods)
+            target_conn.execute("DELETE FROM network_solve_results")
+
+            # Clear year-based solve results (also tied to specific time periods)
+            target_conn.execute("DELETE FROM network_solve_results_by_year")
+
+            # Clear any cached data in network_data_store that might be time-dependent
+            target_conn.execute(
+                """
+                DELETE FROM network_data_store 
+                WHERE category IN ('results', 'statistics', 'cache')
+            """
+            )
+
+            target_conn.commit()
+            progress_callback(35, f"Updated time periods: {len(new_periods)} periods")
+
+    def _process_all_timeseries(
+        self,
+        source_path: str,
+        target_path: str,
+        new_periods: List[TimePeriod],
+        new_resolution_minutes: int,
+        progress_callback: Callable[[float, str], None],
+    ) -> Dict[str, Any]:
+        """Process all timeseries attributes across all scenarios."""
+
+        stats = {
+            "total_components_processed": 0,
+            "total_attributes_processed": 0,
+            "total_scenarios_processed": 0,
+            "attributes_by_component_type": {},
+            "errors": [],
+        }
+
+        try:
+            # Find all components with timeseries data
+            components_with_timeseries = self._find_components_with_timeseries(
+                source_path
+            )
+
+            total_items = len(components_with_timeseries)
+            progress_callback(
+                45, f"Found {total_items} timeseries attributes to process"
+            )
+
+            if total_items == 0:
+                progress_callback(90, "No timeseries data found to process")
+                return stats
+
+            # Group by scenario for batch processing efficiency
+            by_scenario: Dict[Optional[int], List[Tuple[int, str]]] = {}
+            for comp_id, attr_name, scenario_id in components_with_timeseries:
+                if scenario_id not in by_scenario:
+                    by_scenario[scenario_id] = []
+                by_scenario[scenario_id].append((comp_id, attr_name))
+
+            stats["total_scenarios_processed"] = len(by_scenario)
+            logger.info(
+                f"Processing timeseries across {len(by_scenario)} scenarios: "
+                f"{list(by_scenario.keys())}"
+            )
+
+            # Process each scenario
+            processed = 0
+            for scenario_id, items in by_scenario.items():
+                scenario_name = f"scenario_{scenario_id}" if scenario_id else "base"
+                progress_callback(
+                    45 + (processed * 40 / total_items),
+                    f"Processing scenario {scenario_name} ({len(items)} attributes)",
+                )
+
+                for comp_id, attr_name in items:
+                    try:
+                        # Get component type for statistics
+                        comp_type = self._get_component_type(source_path, comp_id)
+                        if comp_type not in stats["attributes_by_component_type"]:
+                            stats["attributes_by_component_type"][comp_type] = 0
+
+                        # Load original timeseries using pyconvexity API
+                        original_timeseries = get_timeseries(
+                            source_path, comp_id, attr_name, scenario_id
+                        )
+
+                        if not original_timeseries or not original_timeseries.values:
+                            logger.warning(
+                                f"No timeseries data found for component {comp_id}, "
+                                f"attribute {attr_name}"
+                            )
+                            continue
+
+                        # Get original time periods to understand the time mapping
+                        with database_context(
+                            source_path, read_only=True
+                        ) as source_conn:
+                            original_periods = get_network_time_periods(source_conn)
+
+                        # Resample to new time axis with proper time-based slicing
+                        resampled_values = self._resample_timeseries_with_time_mapping(
+                            original_timeseries.values,
+                            original_periods,
+                            new_periods,
+                            new_resolution_minutes,
+                        )
+
+                        if resampled_values:
+                            # Save to target database using pyconvexity API
+                            set_timeseries(
+                                target_path,
+                                comp_id,
+                                attr_name,
+                                resampled_values,
+                                scenario_id,
+                            )
+                            stats["attributes_by_component_type"][comp_type] += 1
+                            stats["total_attributes_processed"] += 1
+
+                        processed += 1
+
+                        if processed % 10 == 0:  # Update progress every 10 items
+                            progress = 45 + (processed * 40 / total_items)
+                            progress_callback(
+                                progress,
+                                f"Processed {processed}/{total_items} attributes",
+                            )
+
+                    except Exception as e:
+                        error_msg = (
+                            f"Failed to process component {comp_id}, "
+                            f"attribute {attr_name}: {str(e)}"
+                        )
+                        logger.error(error_msg)
+                        stats["errors"].append(error_msg)
+                        continue
+
+            # Count unique components processed
+            unique_components = set()
+            for comp_id, _, _ in components_with_timeseries:
+                unique_components.add(comp_id)
+            stats["total_components_processed"] = len(unique_components)
+
+            progress_callback(
+                87,
+                f"Completed processing {stats['total_attributes_processed']} "
+                "timeseries attributes",
+            )
+
+            # VACUUM the database to reclaim space from replaced timeseries data
+            progress_callback(88, "Reclaiming database space...")
+            with database_context(target_path) as conn:
+                conn.execute("VACUUM")
+            progress_callback(
+                90,
+                f"Database space reclaimed. Processed "
+                f"{stats['total_attributes_processed']} timeseries attributes.",
+            )
+
+        except Exception as e:
+            logger.error(f"Error processing timeseries data: {e}", exc_info=True)
+            stats["errors"].append(f"General processing error: {str(e)}")
+            raise
+
+        return stats
+
+    def _wipe_all_timeseries(
+        self, target_db_path: str, progress_callback: Callable[[float, str], None]
+    ) -> Dict[str, Any]:
+        """Wipes all timeseries attributes."""
+
+        with database_context(target_db_path) as target_conn:
+            try:
+                # Count timeseries attributes before deletion for statistics
+                cursor = target_conn.execute(
+                    """
+                    SELECT COUNT(*) FROM component_attributes
+                    WHERE storage_type = 'timeseries'
+                """
+                )
+                count_before = cursor.fetchone()[0]
+
+                # Clear all timeseries attributes
+                target_conn.execute(
+                    """
+                    DELETE FROM component_attributes
+                    WHERE storage_type = 'timeseries'
+                """
+                )
+
+                target_conn.commit()
+                progress_callback(
+                    85, f"Wiped {count_before} timeseries attributes from network."
+                )
+
+                # VACUUM the database to reclaim space and reduce file size
+                progress_callback(87, "Reclaiming database space...")
+                target_conn.execute("VACUUM")
+                progress_callback(
+                    90,
+                    f"Database space reclaimed. Wiped {count_before} timeseries attributes.",
+                )
+
+                return {
+                    "total_attributes_wiped": count_before,
+                    "total_components_processed": 0,
+                    "total_attributes_processed": 0,
+                    "total_scenarios_processed": 0,
+                    "attributes_by_component_type": {},
+                    "errors": [],
+                }
+            except Exception as e:
+                logger.error(
+                    f"Failed to wipe timeseries attributes: {e}", exc_info=True
+                )
+                return {
+                    "total_attributes_wiped": 0,
+                    "total_components_processed": 0,
+                    "total_attributes_processed": 0,
+                    "total_scenarios_processed": 0,
+                    "attributes_by_component_type": {},
+                    "errors": [f"Failed to wipe timeseries attributes: {str(e)}"],
+                }
+
+    def _find_components_with_timeseries(
+        self, db_path: str
+    ) -> List[Tuple[int, str, Optional[int]]]:
+        """Find all components that have timeseries attributes."""
+
+        with database_context(db_path, read_only=True) as conn:
+            cursor = conn.execute(
+                """
+                SELECT DISTINCT component_id, attribute_name, scenario_id
+                FROM component_attributes
+                WHERE storage_type = 'timeseries'
+                AND timeseries_data IS NOT NULL
+                ORDER BY component_id, attribute_name, scenario_id
+            """
+            )
+
+            results = cursor.fetchall()
+            logger.info(f"Found {len(results)} timeseries attributes in database")
+
+            return results
+
+    def _get_component_type(self, db_path: str, component_id: int) -> str:
+        """Get component type for statistics tracking."""
+        with database_context(db_path, read_only=True) as conn:
+            cursor = conn.execute(
+                "SELECT component_type FROM components WHERE id = ?", (component_id,)
+            )
+            row = cursor.fetchone()
+            return row[0] if row else "UNKNOWN"
+
+    def _resample_timeseries_with_time_mapping(
+        self,
+        original_values: List[float],
+        original_periods: List[TimePeriod],
+        new_periods: List[TimePeriod],
+        new_resolution_minutes: int,
+    ) -> List[float]:
+        """
+        Resample timeseries data to new time axis with proper time-based slicing.
+
+        This method:
+        1. First slices the original data to match the new time range
+        2. Then resamples the sliced data to the new resolution
+
+        Args:
+            original_values: Original timeseries values
+            original_periods: Original time periods from source database
+            new_periods: New time periods for target database
+            new_resolution_minutes: New time resolution in minutes
+
+        Returns:
+            Resampled values list, or empty list if resampling fails
+        """
+
+        if not original_values or not new_periods or not original_periods:
+            return []
+
+        try:
+            # Get time bounds for the new time axis
+            new_start_timestamp = new_periods[0].timestamp
+            new_end_timestamp = new_periods[-1].timestamp
+
+            logger.debug(
+                f"Original data: {len(original_values)} points, "
+                f"{len(original_periods)} periods"
+            )
+            logger.debug(
+                f"New time range: {new_periods[0].formatted_time} to "
+                f"{new_periods[-1].formatted_time}"
+            )
+
+            # Find the slice of original data that falls within the new time range
+            start_idx = 0
+            end_idx = len(original_periods)
+
+            # Find start index - first period >= new_start_timestamp
+            for i, period in enumerate(original_periods):
+                if period.timestamp >= new_start_timestamp:
+                    start_idx = i
+                    break
+
+            # Find end index - last period <= new_end_timestamp
+            for i in range(len(original_periods) - 1, -1, -1):
+                if original_periods[i].timestamp <= new_end_timestamp:
+                    end_idx = i + 1  # +1 because slice end is exclusive
+                    break
+
+            # Slice the original data to the new time range
+            if start_idx >= len(original_values):
+                logger.warning("Start index beyond original data range")
+                return []
+
+            end_idx = min(end_idx, len(original_values))
+            sliced_values = original_values[start_idx:end_idx]
+            sliced_periods = original_periods[start_idx:end_idx]
+
+            logger.debug(
+                f"Sliced data: {len(sliced_values)} points from index "
+                f"{start_idx} to {end_idx}"
+            )
+
+            if not sliced_values:
+                logger.warning("No data in the specified time range")
+                return []
+
+            # Now resample the sliced data to the new resolution
+            return self._resample_sliced_data(sliced_values, len(new_periods))
+
+        except Exception as e:
+            logger.error(
+                f"Failed to resample timeseries with time mapping: {e}", exc_info=True
+            )
+            # Return empty list rather than failing the entire operation
+            return []
+
+    def _resample_sliced_data(
+        self, sliced_values: List[float], target_length: int
+    ) -> List[float]:
+        """
+        Resample already time-sliced data to target length.
+
+        For downsampling (fewer periods): Use mean aggregation
+        For upsampling (more periods): Use interpolation
+        For same length: Return as-is
+        """
+
+        if not sliced_values:
+            return []
+
+        try:
+            original_length = len(sliced_values)
+
+            if original_length == target_length:
+                # Same length, return as-is
+                return sliced_values
+            elif original_length > target_length:
+                # Downsample using mean aggregation for better accuracy
+                return self._downsample_with_mean(sliced_values, target_length)
+            else:
+                # Upsample using linear interpolation
+                return self._upsample_with_interpolation(sliced_values, target_length)
+
+        except Exception as e:
+            logger.error(f"Failed to resample sliced data: {e}", exc_info=True)
+            return []
+
+    def _downsample_with_mean(
+        self, values: List[float], target_length: int
+    ) -> List[float]:
+        """Downsample using mean aggregation for better accuracy than simple sampling."""
+        if target_length >= len(values):
+            return values
+
+        # Calculate how many original points to average for each new point
+        chunk_size = len(values) / target_length
+        resampled = []
+
+        for i in range(target_length):
+            start_idx = int(i * chunk_size)
+            end_idx = int((i + 1) * chunk_size)
+
+            # Handle the last chunk to include any remaining values
+            if i == target_length - 1:
+                end_idx = len(values)
+
+            # Calculate mean of the chunk
+            chunk_values = values[start_idx:end_idx]
+            if chunk_values:
+                mean_value = sum(chunk_values) / len(chunk_values)
+                resampled.append(mean_value)
+            else:
+                # Fallback to last known value
+                resampled.append(values[start_idx] if start_idx < len(values) else 0.0)
+
+        return resampled
+
+    def _upsample_with_interpolation(
+        self, values: List[float], target_length: int
+    ) -> List[float]:
+        """Upsample using linear interpolation for smoother results."""
+        if target_length <= len(values):
+            return values[:target_length]
+
+        # Use numpy for efficient interpolation
+        original_indices = np.linspace(0, len(values) - 1, len(values))
+        target_indices = np.linspace(0, len(values) - 1, target_length)
+
+        # Perform linear interpolation
+        interpolated = np.interp(target_indices, original_indices, values)
+
+        return interpolated.tolist()

{pyconvexity-0.5.0.dist-info → pyconvexity-0.5.1.dist-info}/METADATA

@@ -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.dist-info → pyconvexity-0.5.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pyconvexity/__init__.py,sha256=P67QJ8npf-QWmBX12im__eICLoRz8cByQ5OJXiyIBmA,5706
-pyconvexity/_version.py,sha256=LBK46heutvn3KmsCrKIYu8RQikbfnjZaj2xFrXaeCzQ,22
+pyconvexity/__init__.py,sha256=Prol-EntlU_jWLR3D55ZRYqkLnenLnt5cXVc_NT1cI4,5934
+pyconvexity/_version.py,sha256=eZ1bOun1DDVV0YLOBW4wj2FP1ajReLjbIrGmzN7ASBw,22
 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,14 @@ 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/solver.py,sha256=pNI9ch0vO5q-8mWc3RHTscWB_ymj4s2lVJQ_e2nbzHY,44417
 pyconvexity/solvers/pypsa/storage.py,sha256=nbONOBnunq3tyexa5yDUsT9xdxieUfrqhoM76_2HIGg,94956
+pyconvexity/transformations/__init__.py,sha256=JfTk0b2O3KM22Dcem2ZnNvDDBmlmqS2X3Q_cO0H3r44,406
+pyconvexity/transformations/api.py,sha256=t_kAAk9QSF1YTlrTM7BECd_v08jUgXVV6e9iX2M0aAg,3694
+pyconvexity/transformations/time_axis.py,sha256=VyQPp09PyIr7IlxoKPeZCMkHPKPcIhI9ap_6kCyzjyk,28362
 pyconvexity/validation/__init__.py,sha256=VJNZlFoWABsWwUKktNk2jbtXIepH5omvC0WtsTS7o3o,583
 pyconvexity/validation/rules.py,sha256=GiNadc8hvbWBr09vUkGiLLTmSdvtNSeGLFwvCjlikYY,9241
-pyconvexity-0.5.0.dist-info/METADATA,sha256=Hr8Vs4joo_WbYlpodHndgIVJJ--cBJ2WNsKYCWHLYVs,4967
-pyconvexity-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyconvexity-0.5.0.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
-pyconvexity-0.5.0.dist-info/RECORD,,
+pyconvexity-0.5.1.dist-info/METADATA,sha256=DUDViqyeOCBaSihifxoHTu7P4tjBms1JU90L3jGdbxc,4967
+pyconvexity-0.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyconvexity-0.5.1.dist-info/top_level.txt,sha256=wFPEDXVaebR3JO5Tt3HNse-ws5aROCcxEco15d6j64s,12
+pyconvexity-0.5.1.dist-info/RECORD,,