hydopt-client 0.2.0__tar.gz → 0.4.0__tar.gz

{hydopt_client-0.2.0 → hydopt_client-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hydopt-client
-Version: 0.2.0
+Version: 0.4.0
 Summary: Python client for the HydOpt hydropower optimization API
 Requires-Python: >=3.13
 Requires-Dist: google-auth>=2.56.3

{hydopt_client-0.2.0 → hydopt_client-0.4.0}/docker-compose.yml

@@ -2,7 +2,7 @@ name: hydopt-api
 
 services:
   api:
-    image: us-central1-docker.pkg.dev/hydopt/hydopt-backend/hydopt-api:20260910T125042-abf20a2
+    image: us-central1-docker.pkg.dev/hydopt/hydopt-backend/hydopt-api:20260922T111447-86bcc45
     ports:
       - "${PORT:-8083}:8083"
     environment:

{hydopt_client-0.2.0 → hydopt_client-0.4.0}/src/hydopt_client/auth/azure.py

@@ -1,3 +1,7 @@
+import base64
+import json
+import time
+
 import msal
 
 hydopt_client_id = "2902dddd-fab8-4843-baae-dbde348275bd"
@@ -10,6 +14,20 @@ class IdTokenError(RuntimeError):
         super().__init__("Failed to get access token")
 
 
+def _id_token_expired(token: str, now: float | None = None) -> bool:
+    """True when the JWT ``exp`` is in the past, or the token cannot be read."""
+    try:
+        payload_b64 = token.split(".")[1]
+        padding = "=" * (-len(payload_b64) % 4)
+        payload = json.loads(base64.urlsafe_b64decode(payload_b64 + padding))
+        exp = payload.get("exp")
+    except (IndexError, ValueError, json.JSONDecodeError):
+        return True
+    if exp is None:
+        return False
+    return float(exp) <= (now if now is not None else time.time())
+
+
 class AzureTokenProvider:
     def __init__(
         self,
@@ -25,17 +43,23 @@ class AzureTokenProvider:
             self.client_id,
             authority=f"https://login.microsoftonline.com/{self.tenant_id}",
         )
+        self._id_token: str | None = None
 
     def get_token(self) -> str:
+        if self._id_token and not _id_token_expired(self._id_token):
+            return self._id_token
+
         accounts = self._client.get_accounts()
         result = None
         if accounts:
             result = self._client.acquire_token_silent(self.scopes, account=accounts[0])
 
-        if not result:
+        # A silent cache hit carries the access token and omits the ID token the API needs.
+        if not result or "id_token" not in result:
             result = self._client.acquire_token_interactive(self.scopes)
 
-        if "id_token" not in result:
+        token = result.get("id_token") if result else None
+        if not token:
             raise IdTokenError()
-
-        return result["id_token"]
+        self._id_token = str(token)
+        return self._id_token

{hydopt_client-0.2.0 → hydopt_client-0.4.0}/src/hydopt_client/client.py

@@ -17,6 +17,7 @@ from hydopt_client.models import (
     GraphLayers,
     HydoptRecord,
     KeyNumbers,
+    Link,
     ObjectStatReport,
     Order,
     parse_records,
@@ -95,7 +96,7 @@ class Category(StrEnum):
     balance_energy_rate = "Balance energy rate"
     balance_energy = "Balance energy"
     balance_power = "Balance power"
-    day = "Day"
+    day_ahead_price = "Day ahead price"
     discharge = "Discharge"
     forward_curve = "Forward curve"
     generator_water_value = "Generator water value"
@@ -109,6 +110,38 @@ class Category(StrEnum):
     wind = "Wind@100m"
 
 
+class ValueType(StrEnum):
+    actual = "Actual"
+    actual_region = "Actual region"
+    daily = "Daily"
+    estimate = "Estimate"
+    forecast = "Forecast"
+    forecast_buffer = "Forecast buffer"
+    forecast_region = "Forecast region"
+    history = "History"
+    history_avg = "History avg"
+    history_buffer = "History buffer"
+    history_max = "History max"
+    history_min = "History min"
+    history_region = "History region"
+    monthly = "Monthly"
+    normal = "Normal"
+    quarterly = "Quarterly"
+    smooth = "Smooth"
+    weekly = "Weekly"
+    yearly = "Yearly"
+
+
+class DataSource(StrEnum):
+    ecmwf_era5 = "ECMWF-ERA5"
+    entsoe = "ENTSOE"
+    euronext = "Euronext"
+    hydopt = "HydOpt"
+    nve = "NVE"
+    smhi = "SMHI"
+    vattenreglering = "Vattenreglering"
+
+
 class DifferenceTypes(StrEnum):
     anomaly_forecast = "Anomaly Forecast"
     anomaly_forecast_region = "Anomaly Forecast Region"
@@ -264,6 +297,11 @@ class Client:
         response.raise_for_status()
         return response.json()["availableDates"]
 
+    def links(self) -> list[Link]:
+        response = self._request("GET", "/v1/links")
+        response.raise_for_status()
+        return [Link.model_validate(item) for item in response.json().get("links") or []]
+
     def catchments(self, asof: str) -> list[CatchmentRecord]:
         response = self._request("GET", f"/v1/catchments/{asof}")
         response.raise_for_status()

{hydopt_client-0.2.0 → hydopt_client-0.4.0}/src/hydopt_client/models.py

@@ -45,6 +45,19 @@ def parse_records(items: list[dict]) -> list[HydoptRecord]:
     return [HydoptRecord.model_validate(item) for item in items]
 
 
+class Link(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+    id: str
+    up: str
+    down: str
+    edge_type: str = ""
+    lat_up: float = 0.0
+    lon_up: float = 0.0
+    lat_down: float = 0.0
+    lon_down: float = 0.0
+
+
 class CatchmentRecord(BaseModel):
     model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
 

hydopt_client-0.4.0/tests/test_azure.py

@@ -0,0 +1,105 @@
+import base64
+import json
+import os
+import time
+
+import pytest
+
+from hydopt_client.auth.azure import AzureTokenProvider, IdTokenError
+from hydopt_client.auth.base import TokenProvider
+from hydopt_client.client import Client
+
+
+def _jwt(exp: float | None) -> str:
+    payload = {} if exp is None else {"exp": exp}
+    body = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip("=")
+    return f"e30.{body}.sig"
+
+
+class _FakeApp:
+    def __init__(self, id_token: str) -> None:
+        self.id_token = id_token
+        self.accounts: list[dict[str, str]] = []
+        self.silent_calls = 0
+        self.interactive_calls = 0
+        self.interactive_result: dict[str, str] | None = None
+
+    def get_accounts(self) -> list[dict[str, str]]:
+        return self.accounts
+
+    def acquire_token_silent(
+        self, scopes: list[str], account: dict[str, str]
+    ) -> dict[str, str]:
+        self.silent_calls += 1
+        return {"access_token": "access"}
+
+    def acquire_token_interactive(self, scopes: list[str]) -> dict[str, str]:
+        self.interactive_calls += 1
+        if self.interactive_result is not None:
+            return self.interactive_result
+        self.accounts = [{"username": "a"}]
+        return {"id_token": self.id_token}
+
+
+def _provider(
+    monkeypatch: pytest.MonkeyPatch, id_token: str
+) -> tuple[AzureTokenProvider, _FakeApp]:
+    app = _FakeApp(id_token)
+    monkeypatch.setattr(
+        "hydopt_client.auth.azure.msal.PublicClientApplication",
+        lambda *args, **kwargs: app,
+    )
+    return AzureTokenProvider(), app
+
+
+def test_satisfy_interface():
+    assert isinstance(AzureTokenProvider(), TokenProvider)
+
+
+def test_reuses_id_token_from_interactive_login(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    provider, app = _provider(monkeypatch, _jwt(time.time() + 3600))
+
+    assert provider.get_token() == app.id_token
+    assert provider.get_token() == app.id_token
+    assert app.interactive_calls == 1
+    assert app.silent_calls == 0
+
+
+def test_expired_id_token_signs_in_again(monkeypatch: pytest.MonkeyPatch) -> None:
+    provider, app = _provider(monkeypatch, _jwt(time.time() - 10))
+
+    assert provider.get_token() == app.id_token
+    app.id_token = _jwt(time.time() + 3600)
+    assert provider.get_token() == app.id_token
+    assert app.interactive_calls == 2
+    assert app.silent_calls == 1
+
+
+def test_silent_result_without_id_token_is_a_miss(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    provider, app = _provider(monkeypatch, _jwt(time.time() + 3600))
+    app.accounts = [{"username": "a"}]
+
+    assert provider.get_token() == app.id_token
+    assert app.silent_calls == 1
+    assert app.interactive_calls == 1
+
+
+def test_missing_id_token_raises(monkeypatch: pytest.MonkeyPatch) -> None:
+    provider, app = _provider(monkeypatch, _jwt(time.time() + 3600))
+    app.interactive_result = {"error": "invalid_grant"}
+
+    with pytest.raises(IdTokenError):
+        provider.get_token()
+
+
+def test_can_get_data_via_azure():
+    if os.getenv("CI"):
+        pytest.skip("Test can not run in CI/CD")
+
+    client = Client(token_provider=AzureTokenProvider())
+    partitions = client.list_partitions()
+    assert partitions

{hydopt_client-0.2.0 → hydopt_client-0.4.0}/tests/test_client_unit.py

@@ -129,6 +129,36 @@ def test_hierarchy_layers_parses_graph_layers() -> None:
     assert layers.point_ids == ["p1"]
 
 
+def test_links_parses_watercourse_edges() -> None:
+    def handler(request: httpx.Request) -> httpx.Response:
+        assert request.url.path == "/v1/links"
+        return httpx.Response(
+            200,
+            json={
+                "links": [
+                    {
+                        "id": "a//b",
+                        "up": "A::R::Bergsdalen",
+                        "down": "B::G::Bergsdalen",
+                        "edgeType": "Release",
+                        "latUp": 60.5,
+                        "lonUp": 6.1,
+                        "latDown": 60.4,
+                        "lonDown": 6.0,
+                    }
+                ]
+            },
+        )
+
+    client, _ = make_client(handler)
+    links = client.links()
+    assert len(links) == 1
+    assert links[0].up == "A::R::Bergsdalen"
+    assert links[0].down == "B::G::Bergsdalen"
+    assert links[0].edge_type == "Release"
+    assert links[0].lat_up == 60.5
+
+
 def test_hierarchy_layers_sends_selected_nodes() -> None:
     captured = {}
 

hydopt_client-0.2.0/tests/test_azure.py

@@ -1,20 +0,0 @@
-import os
-
-import pytest
-
-from hydopt_client.auth.azure import AzureTokenProvider
-from hydopt_client.auth.base import TokenProvider
-from hydopt_client.client import Client
-
-
-def test_satisfy_interface():
-    assert isinstance(AzureTokenProvider(), TokenProvider)
-
-
-def test_can_get_data_via_azure():
-    if os.getenv("CI"):
-        pytest.skip("Test can not run in CI/CD")
-
-    client = Client(token_provider=AzureTokenProvider())
-    partitions = client.list_partitions()
-    assert partitions