pyetm 2.0.2__tar.gz → 2.0.4__tar.gz

{pyetm-2.0.2 → pyetm-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyetm
-Version: 2.0.2
+Version: 2.0.4
 Summary: Python-ETM Connector
 License-Expression: MIT
 License-File: LICENSE
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Requires-Dist: aiohttp (>=3.14.1,<4.0.0)
 Requires-Dist: click (>=8.0.0)
 Requires-Dist: openpyxl (>=3.0.0)

{pyetm-2.0.2 → pyetm-2.0.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "pyetm"
-version = "2.0.2"
+version = "2.0.4"
 description = "Python-ETM Connector"
 readme = "README.md"
 license = "MIT"

pyetm-2.0.4/src/pyetm/config/api_compat.py

@@ -0,0 +1,55 @@
+"""Request shapes that work across every engine version pyetm targets.
+
+Sibling of :mod:`pyetm.config.curve_registry`, which does the same for curve names.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import urlparse
+
+STABLE_2025_01_LABEL = "2025-01"
+
+
+def _targets_stable_2025_01(base_url: str | None) -> bool:
+    """Is this client pointed at the 2025-01 stable engine?"""
+    if not base_url:
+        return False
+
+    host = urlparse(base_url).hostname or ""
+    return host.split(".")[0] == STABLE_2025_01_LABEL
+
+
+def _environment_label(base_url: str | None) -> str | None:
+    """Environment label used to build this host, or None for production/local."""
+    if not base_url:
+        return None
+
+    host = urlparse(base_url).hostname or ""
+    label = host.split(".")[0]
+
+    if label in ("", "engine", "localhost"):
+        return None
+
+    return label
+
+
+def saved_scenario_payload(
+    attributes: dict[str, Any], base_url: str | None = None
+) -> dict[str, Any]:
+    """Build a saved scenario body the target engine can read.
+
+    2025-01 reads attributes from the top level; later engines from a
+    ``saved_scenario`` root key. Also stamps ``version`` with the environment
+    label, since MyETM defaults an unlabelled scenario to production.
+    """
+    body = dict(attributes)
+
+    label = _environment_label(base_url)
+    if label is not None:
+        body.setdefault("version", label)
+
+    if _targets_stable_2025_01(base_url):
+        return body
+
+    return {"saved_scenario": body}

{pyetm-2.0.2 → pyetm-2.0.4}/src/pyetm/models/scenario.py

@@ -388,14 +388,28 @@ class Scenario(Base):
 
     def update(self, client: Optional[BaseClient] = None, **kwargs: Any) -> None:
         """
-        Update this SavedScenario
+        Update this SavedScenario.
+
+        Passing a new ``scenario_id`` saves a version: MyETM moves the current
+        session into the scenario's history and points the SavedScenario at the
+        new session. Passing an ID already in the history restores that version.
 
         Args:
             client: Optional BaseClient instance
-            **kwargs: Fields to update (title, private, discarded)
+            **kwargs: Fields to update (title, private, discarded, scenario_id)
+
+        Raises:
+            SavedScenarioError: If the update fails
+
+        Example:
+            ```python
+            snapshot = scenario.session.copy_with_preset()
+            scenario.update(scenario_id=snapshot.id)
+            ```
         """
         if client is None:
             client = get_client()
+        previous_scenario_id = self.scenario_id
         result = UpdateSavedScenarioRunner.run(client, self.id, kwargs)
 
         if not result.success:
@@ -408,13 +422,22 @@ class Scenario(Base):
 
         if result.data:
             for field, value in result.data.items():
-                if hasattr(self, field):
+                if field in Scenario.model_fields:
                     setattr(self, field, value)
 
         for field, value in kwargs.items():
-            if hasattr(self, field) and (not result.data or field not in result.data):
+            if field in Scenario.model_fields and (not result.data or field not in result.data):
                 setattr(self, field, value)
 
+        if self.scenario_id != previous_scenario_id:
+            self._forget_session(result.data)
+
+    def _forget_session(self, response: Optional[Dict[str, Any]]) -> None:
+        """Drop the cached session so the next access loads the new scenario_id."""
+        self._scenario_session = None
+        if not response or "scenario" not in response:
+            self.scenario = None
+
     def discard(self, client: Optional[BaseClient] = None) -> None:
         """
         Discard this SavedScenario from MyETM (soft-delete, recoverable).

{pyetm-2.0.2 → pyetm-2.0.4}/src/pyetm/models/scenario_loader.py

@@ -1,15 +1,23 @@
 """Utilities for loading scenarios from various sources."""
 
 import logging
-from typing import Protocol, Optional, Dict, Any, cast
+from typing import Any, Protocol, cast
+
 from pyetm.models.session import Session
 
 logger = logging.getLogger(__name__)
 
 
+def _warn_save_failed(session: Session, row_label: str, error: Exception) -> Session:
+    """Record a failed MyETM save on the session itself."""
+    message = f"Row '{row_label}' was not saved to MyETM: {error}"
+    logger.warning("%s Returning session instead.", message)
+    session.add_warning("save", message)
+    return session
+
+
 class ScenarioLoader(Protocol):
-    """
-    Protocol for loading, copying, and creating scenarios.
+    """Protocol for loading, copying, and creating scenarios.
 
     Different implementations interpret scenario IDs differently:
     - SessionLoader: IDs refer to ETEngine Sessions
@@ -20,10 +28,10 @@ class ScenarioLoader(Protocol):
         self,
         scenario_id: int,
         area_code: Any,
-        end_year: Optional[int],
+        end_year: int | None,
         row_label: str,
-        metadata_updates: Dict[str, Any],
-    ) -> Optional[Session]:
+        metadata_updates: dict[str, Any],
+    ) -> Session | None:
         """Load an existing scenario by ID and apply metadata updates."""
         ...
 
@@ -31,33 +39,31 @@ class ScenarioLoader(Protocol):
         self,
         scenario_id: int,
         row_label: str,
-        metadata_updates: Dict[str, Any],
-    ) -> Optional[Session]:
+        metadata_updates: dict[str, Any],
+    ) -> Session | None:
         """Create a deep copy of a scenario (no template link)."""
         ...
 
     def create_new(
         self,
         area_code: Any,
-        end_year: Optional[int],
+        end_year: int | None,
         row_label: str,
-        metadata_updates: Dict[str, Any],
-    ) -> Optional[Session]:
+        metadata_updates: dict[str, Any],
+    ) -> Session | None:
         """Create a brand new scenario."""
         ...
 
 
 class SessionLoader:
-    """
-    Loader for ETEngine Sessions.
+    """Loader for ETEngine Sessions.
 
     Interprets IDs as ETEngine scenario/session IDs.
     """
 
     def __init__(self, packer_helper: Any) -> None:
-        """
-        Args:
-            packer_helper: Reference to ScenarioPacker instance for helper methods
+        """Args:
+        packer_helper: Reference to ScenarioPacker instance for helper methods
         """
         self._helper = packer_helper
 
@@ -65,10 +71,10 @@ class SessionLoader:
         self,
         scenario_id: int,
         area_code: Any,
-        end_year: Optional[int],
+        end_year: int | None,
         row_label: str,
-        metadata_updates: Dict[str, Any],
-    ) -> Optional[Session]:
+        metadata_updates: dict[str, Any],
+    ) -> Session | None:
         """Load an ETEngine Session by ID."""
         scenario = self._helper._load_or_create_scenario(
             scenario_id, area_code, end_year, row_label, **metadata_updates
@@ -82,8 +88,8 @@ class SessionLoader:
         self,
         scenario_id: int,
         row_label: str,
-        metadata_updates: Dict[str, Any],
-    ) -> Optional[Session]:
+        metadata_updates: dict[str, Any],
+    ) -> Session | None:
         """Deep copy an ETEngine Session."""
         try:
             source_scenario = Session.load(scenario_id)
@@ -100,10 +106,10 @@ class SessionLoader:
     def create_new(
         self,
         area_code: Any,
-        end_year: Optional[int],
+        end_year: int | None,
         row_label: str,
-        metadata_updates: Dict[str, Any],
-    ) -> Optional[Session]:
+        metadata_updates: dict[str, Any],
+    ) -> Session | None:
         """Create a new ETEngine Session."""
         scenario = self._helper._load_or_create_scenario(
             None, area_code, end_year, row_label, **metadata_updates
@@ -115,22 +121,19 @@ class SessionLoader:
 
 
 class SavedScenarioLoader:
-    """
-    Loader for MyETM SavedScenarios.
+    """Loader for MyETM SavedScenarios.
 
     Interprets IDs as MyETM SavedScenario IDs and automatically saves new scenarios.
     """
 
     def __init__(self, packer_helper: Any) -> None:
-        """
-        Args:
-            packer_helper: Reference to ScenarioPacker instance for helper methods
+        """Args:
+        packer_helper: Reference to ScenarioPacker instance for helper methods
         """
         self._helper = packer_helper
 
     def _require_authentication(self) -> None:
-        """
-        Validate that authentication token is available for SavedScenario operations.
+        """Validate that authentication token is available for SavedScenario operations.
 
         Raises:
             PermissionError: If no ETM_API_TOKEN is configured
@@ -150,10 +153,10 @@ class SavedScenarioLoader:
         self,
         scenario_id: int,
         area_code: Any,
-        end_year: Optional[int],
+        end_year: int | None,
         row_label: str,
-        metadata_updates: Dict[str, Any],
-    ) -> Optional[Session]:
+        metadata_updates: dict[str, Any],
+    ) -> Session | None:
         """Load a SavedScenario from MyETM."""
         from pyetm.models.scenario import Scenario
 
@@ -181,8 +184,8 @@ class SavedScenarioLoader:
         self,
         scenario_id: int,
         row_label: str,
-        metadata_updates: Dict[str, Any],
-    ) -> Optional[Session]:
+        metadata_updates: dict[str, Any],
+    ) -> Session | None:
         """Copy a SavedScenario and save the copy to MyETM."""
         from pyetm.models.scenario import Scenario
 
@@ -197,7 +200,7 @@ class SavedScenarioLoader:
             try:
                 saved_copy = copied_session.save(title=title)
                 # Validate that we got a proper SavedScenario back with required attributes
-                if hasattr(saved_copy, 'id') and hasattr(saved_copy, 'scenario_id'):
+                if hasattr(saved_copy, "id") and hasattr(saved_copy, "scenario_id"):
                     logger.info(
                         "Automatically saved copy to MyETM with ID %s (session ID: %s)",
                         saved_copy.id,
@@ -211,12 +214,7 @@ class SavedScenarioLoader:
                     )
                     return copied_session
             except Exception as save_error:
-                logger.warning(
-                    "Failed to save copy to MyETM for row '%s': %s. Returning session instead.",
-                    row_label,
-                    save_error,
-                )
-                return copied_session
+                return _warn_save_failed(copied_session, row_label, save_error)
         except Exception as e:
             error_msg = str(e)
             if "does not exist" in error_msg or "not found" in error_msg.lower():
@@ -237,13 +235,11 @@ class SavedScenarioLoader:
     def create_new(
         self,
         area_code: Any,
-        end_year: Optional[int],
+        end_year: int | None,
         row_label: str,
-        metadata_updates: Dict[str, Any],
-    ) -> Optional[Session]:
+        metadata_updates: dict[str, Any],
+    ) -> Session | None:
         """Create a new scenario and save it to MyETM."""
-        from pyetm.models.scenario import Scenario
-
         # Validate authentication before attempting to save
         self._require_authentication()
 
@@ -259,7 +255,7 @@ class SavedScenarioLoader:
         try:
             saved_scenario = scenario.save(title=title)
             # Validate that we got a proper SavedScenario back with required attributes
-            if hasattr(saved_scenario, 'id') and hasattr(saved_scenario, 'scenario_id'):
+            if hasattr(saved_scenario, "id") and hasattr(saved_scenario, "scenario_id"):
                 logger.info(
                     "Saved new scenario to MyETM with ID %s (session ID: %s)",
                     saved_scenario.id,
@@ -273,9 +269,4 @@ class SavedScenarioLoader:
                 )
                 return cast(Session, scenario)
         except Exception as e:
-            logger.warning(
-                "Failed to save new scenario to MyETM for row '%s': %s. Returning session instead.",
-                row_label,
-                e,
-            )
-            return cast(Session, scenario)
+            return _warn_save_failed(cast(Session, scenario), row_label, e)