aemo-mcp 0.1.2__py3-none-any.whl

aemo_mcp/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version as _version
+
+try:
+    __version__ = _version("aemo-mcp")
+except PackageNotFoundError:  # editable install before metadata is generated
+    __version__ = "0.0.0+unknown"

aemo_mcp/cache.py

@@ -0,0 +1,139 @@
+"""SQLite-backed HTTP cache with per-read TTL.
+
+Ported from rba-mcp 0.1.9. Same single-table design — TTL is evaluated at
+read time so one cached row can satisfy different freshness windows. The
+`kind` column lets us run targeted invalidation later.
+
+CacheKind values are tuned to AEMO cadences:
+- "live"      → 60 seconds  (5-min dispatch feeds)
+- "half_hour" → 5 minutes   (30-min feeds: rooftop PV, predispatch)
+- "forecast"  → 1 hour      (longer-horizon forecast bundles)
+- "daily"     → 24 hours    (daily rolled-up archives)
+- "archive"   → 7 days      (MMSDM and other immutable historical files)
+- "listing"   → 30 seconds  (NEMWEB directory HTML — drives latest-file detection)
+
+NEMWEB's published files are immutable once written (filename embeds the
+interval timestamp), so the file-body cache is effectively infinite — TTL
+only matters for directory listings and "latest" calls.
+"""
+from __future__ import annotations
+
+import asyncio
+import sqlite3
+import time
+from datetime import timedelta
+from pathlib import Path
+from typing import Literal
+
+import aiosqlite
+
+CacheKind = Literal["live", "half_hour", "forecast", "daily", "archive", "listing"]
+
+DEFAULT_DB_PATH = Path.home() / ".aemo-mcp" / "cache.db"
+
+TTL: dict[CacheKind, timedelta] = {
+    "live": timedelta(seconds=60),
+    "half_hour": timedelta(minutes=5),
+    "forecast": timedelta(hours=1),
+    "daily": timedelta(hours=24),
+    "archive": timedelta(days=7),
+    "listing": timedelta(seconds=30),
+}
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS http_cache (
+    cache_key  TEXT PRIMARY KEY,
+    payload    BLOB NOT NULL,
+    cached_at  REAL NOT NULL,
+    kind       TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_kind_cached_at ON http_cache(kind, cached_at);
+"""
+
+
+class Cache:
+    def __init__(self, db_path: Path | None = None) -> None:
+        # Resolve DEFAULT_DB_PATH at construction time (not class-def time)
+        # so tests that monkeypatch the module-level constant take effect.
+        # Default Path() args are evaluated once at class definition, which
+        # is too early to be overridden — leaked across tests previously.
+        import aemo_mcp.cache as _self_mod
+        self.db_path = db_path or _self_mod.DEFAULT_DB_PATH
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._initialized = False
+        self._init_lock = asyncio.Lock()
+
+    async def _ensure_init(self) -> None:
+        if self._initialized:
+            return
+        async with self._init_lock:
+            if self._initialized:
+                return
+            try:
+                await self._init_schema()
+            except sqlite3.DatabaseError:
+                # Pre-existing cache.db is corrupt or has an incompatible
+                # schema. The cache is a perf optimisation, not a source of
+                # truth — drop and recreate is always safe.
+                self.db_path.unlink(missing_ok=True)
+                await self._init_schema()
+            self._initialized = True
+
+    async def _init_schema(self) -> None:
+        async with aiosqlite.connect(self.db_path) as conn:
+            await conn.execute("PRAGMA journal_mode=WAL")
+            await conn.executescript(_SCHEMA)
+            await conn.commit()
+
+    async def get(self, key: str, ttl: timedelta) -> bytes | None:
+        await self._ensure_init()
+        cutoff = time.time() - ttl.total_seconds()
+        async with aiosqlite.connect(self.db_path) as conn:
+            async with conn.execute(
+                "SELECT payload FROM http_cache WHERE cache_key = ? AND cached_at >= ?",
+                (key, cutoff),
+            ) as cur:
+                row = await cur.fetchone()
+        return row[0] if row else None
+
+    async def get_stale(self, key: str) -> tuple[bytes, float] | None:
+        """Return cached (payload, cached_at_epoch) regardless of TTL.
+
+        Used by the client as a fallback when NEMWEB is unavailable —
+        graceful degradation per CLAUDE.md quality dimension #4. The caller
+        computes "how stale" from the timestamp and surfaces it in
+        `DataResponse.stale_reason`.
+        """
+        await self._ensure_init()
+        async with aiosqlite.connect(self.db_path) as conn:
+            async with conn.execute(
+                "SELECT payload, cached_at FROM http_cache WHERE cache_key = ?",
+                (key,),
+            ) as cur:
+                row = await cur.fetchone()
+        return (row[0], row[1]) if row else None
+
+    async def set(self, key: str, value: bytes, kind: CacheKind) -> None:
+        await self._ensure_init()
+        async with aiosqlite.connect(self.db_path) as conn:
+            await conn.execute(
+                """
+                INSERT INTO http_cache (cache_key, payload, cached_at, kind)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(cache_key) DO UPDATE SET
+                    payload = excluded.payload,
+                    cached_at = excluded.cached_at,
+                    kind = excluded.kind
+                """,
+                (key, value, time.time(), kind),
+            )
+            await conn.commit()
+
+    async def clear(self, kind: CacheKind | None = None) -> None:
+        await self._ensure_init()
+        async with aiosqlite.connect(self.db_path) as conn:
+            if kind:
+                await conn.execute("DELETE FROM http_cache WHERE kind = ?", (kind,))
+            else:
+                await conn.execute("DELETE FROM http_cache")
+            await conn.commit()

aemo_mcp/client.py

@@ -0,0 +1,237 @@
+"""Async NEMWEB fetcher.
+
+NEMWEB is a static IIS file server. There is no API — directory listings are
+HTML; files are ZIPs containing CSVs.
+
+Three responsibilities:
+
+1. `fetch_directory_listing(folder)` — GET the IIS HTML and return the list
+   of file names matching a regex.
+2. `fetch_zip(url)` — GET a single ZIP file and return its bytes.
+3. Cache + in-flight dedup — concurrent callers for the same URL share one
+   HTTP request. Critical at 5-min cadence where 50 concurrent `latest()`
+   calls would otherwise hammer NEMWEB.
+
+NEMWEB's published files are immutable once written (filename embeds the
+interval timestamp), so the file-body cache TTL is effectively infinite.
+Only the directory listing has freshness sensitivity — that's the 30s TTL.
+"""
+from __future__ import annotations
+
+import asyncio
+import re
+import time
+from contextvars import ContextVar
+from typing import Any
+
+import httpx
+
+from .cache import TTL, Cache, CacheKind
+
+
+# ─── stale signal (graceful-degradation reporting per CLAUDE.md dim #4) ─
+# When NEMWEB is unreachable, _fetch_cached falls back to the cached payload
+# regardless of TTL and records the staleness in this ContextVar. Server-side
+# tool wrappers read it after the request chain and set
+# DataResponse.stale / .stale_reason. ContextVar (not instance attr) so
+# concurrent MCP tool calls each see their own state.
+_stale_signal: ContextVar[tuple[bool, str | None]] = ContextVar(
+    "aemo_mcp_stale_signal", default=(False, None)
+)
+
+
+def reset_stale_signal() -> None:
+    """Clear the stale state. Call once at the start of each tool call."""
+    _stale_signal.set((False, None))
+
+
+def get_stale_signal() -> tuple[bool, str | None]:
+    """Return (stale, reason) for the most recent fetch chain in this context."""
+    return _stale_signal.get()
+
+
+def _mark_stale(reason: str) -> None:
+    """Record that a stale-cache fallback was served this context.
+
+    If multiple fetches in one chain are stale, we keep the FIRST reason
+    (it's usually the most informative — the originating upstream failure).
+    """
+    cur_stale, _ = _stale_signal.get()
+    if not cur_stale:
+        _stale_signal.set((True, reason))
+
+DEFAULT_BASE_URL = "http://nemweb.com.au"
+DEFAULT_TIMEOUT = httpx.Timeout(60.0, connect=10.0)
+
+# IIS directory listings render entries as <A HREF="path">name</A>.
+# Capture the file name (last segment after the slash) — relative or absolute.
+_HREF_PATTERN = re.compile(
+    r'<a\s+href="([^"]+)"',
+    re.IGNORECASE,
+)
+
+
+class AEMOAPIError(Exception):
+    """Raised when NEMWEB returns a non-2xx response or the request fails."""
+
+
+class AEMOClient:
+    def __init__(
+        self,
+        cache: Cache | None = None,
+        base_url: str = DEFAULT_BASE_URL,
+        transport: httpx.AsyncBaseTransport | None = None,
+        user_agent: str | None = None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.cache = cache or Cache()
+        ua = user_agent or "aemo-mcp/0.1 (+https://github.com/Bigred97/aemo-mcp)"
+        self._http = httpx.AsyncClient(
+            timeout=DEFAULT_TIMEOUT,
+            transport=transport,
+            headers={"User-Agent": ua},
+            follow_redirects=True,
+        )
+        self._in_flight: dict[str, asyncio.Future[bytes]] = {}
+        self._in_flight_lock = asyncio.Lock()
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> "AEMOClient":
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.aclose()
+
+    async def _fetch_cached(self, url: str, *, kind: CacheKind) -> bytes:
+        """Generic cached + in-flight-deduped fetch.
+
+        Concurrent callers for the same URL share one in-flight HTTP request.
+        """
+        cached = await self.cache.get(url, ttl=TTL[kind])
+        if cached is not None:
+            return cached
+
+        # Race-safe in-flight registration.
+        async with self._in_flight_lock:
+            existing = self._in_flight.get(url)
+            if existing is None:
+                future: asyncio.Future[bytes] = (
+                    asyncio.get_running_loop().create_future()
+                )
+                self._in_flight[url] = future
+
+        if existing is not None:
+            return await existing
+
+        try:
+            try:
+                resp = await self._http.get(url)
+                resp.raise_for_status()
+            except (httpx.HTTPStatusError, httpx.RequestError) as e:
+                # Graceful degradation: when NEMWEB is unreachable, fall back
+                # to the most-recent cached payload (regardless of TTL) rather
+                # than raising and breaking the agent's chain of reasoning.
+                # The staleness is surfaced via the _stale_signal ContextVar
+                # and ends up in DataResponse.stale / stale_reason.
+                fallback = await self.cache.get_stale(url)
+                if fallback is not None:
+                    payload, cached_at = fallback
+                    age_min = max(0, int((time.time() - cached_at) / 60))
+                    if isinstance(e, httpx.HTTPStatusError):
+                        upstream = (
+                            f"AEMO/OpenNEM fetch returned "
+                            f"{e.response.status_code}"
+                        )
+                    else:
+                        upstream = (
+                            f"AEMO/OpenNEM fetch unreachable "
+                            f"({type(e).__name__})"
+                        )
+                    _mark_stale(
+                        f"{upstream} for {url}; serving cached payload from "
+                        f"~{age_min} minute(s) ago"
+                    )
+                    future.set_result(payload)
+                    return payload
+                # Genuinely no cache to fall back to — preserve original behaviour
+                if isinstance(e, httpx.HTTPStatusError):
+                    raise AEMOAPIError(
+                        f"NEMWEB returned {e.response.status_code} for {url}"
+                    ) from e
+                raise AEMOAPIError(f"NEMWEB request failed: {e}") from e
+            await self.cache.set(url, resp.content, kind=kind)
+            future.set_result(resp.content)
+            return resp.content
+        except BaseException as e:
+            if not future.done():
+                future.set_exception(e)
+            # When no other coroutine is awaiting this future, the
+            # exception we just set would be GC'd unretrieved and Python
+            # would log "Future exception was never retrieved". Mark it
+            # retrieved here — the calling coroutine still gets `raise` so
+            # the exception propagates normally.
+            try:
+                future.exception()
+            except Exception:
+                pass
+            raise
+        finally:
+            async with self._in_flight_lock:
+                self._in_flight.pop(url, None)
+
+    async def fetch_directory_listing(
+        self,
+        folder: str,
+        *,
+        filename_regex: re.Pattern[str] | None = None,
+        kind: CacheKind = "listing",
+    ) -> list[str]:
+        """Fetch a NEMWEB folder's HTML listing and return sorted file names.
+
+        `folder` is a path under `base_url`, e.g.
+        '/Reports/Current/DispatchIS_Reports/'. Trailing slash optional.
+
+        If `filename_regex` is provided, only file names that fully match it
+        are returned. The list is sorted ascending — for AEMO filename
+        patterns (timestamp-prefixed) this means the LAST entry is the most
+        recent.
+        """
+        if not folder.startswith("/"):
+            folder = "/" + folder
+        if not folder.endswith("/"):
+            folder = folder + "/"
+        url = f"{self.base_url}{folder}"
+        body = await self._fetch_cached(url, kind=kind)
+        text = body.decode("utf-8", errors="replace")
+
+        names: list[str] = []
+        for match in _HREF_PATTERN.finditer(text):
+            href = match.group(1)
+            # Normalise: drop everything up to the final slash.
+            name = href.rsplit("/", 1)[-1]
+            if not name or name in (".", ".."):
+                continue
+            if filename_regex is not None and not filename_regex.fullmatch(name):
+                continue
+            names.append(name)
+        names.sort()
+        return names
+
+    async def fetch_zip(self, url: str, *, kind: CacheKind = "archive") -> bytes:
+        """Fetch a single NEMWEB ZIP file. Returns raw bytes.
+
+        Timestamped files are immutable — once a file with name
+        `PUBLIC_DISPATCHIS_202605141000_X.zip` exists it never changes. Cache
+        with `archive` TTL (7 days) by default. Caller can override for
+        feeds where files might be republished.
+        """
+        return await self._fetch_cached(url, kind=kind)
+
+    def build_url(self, folder: str, filename: str) -> str:
+        if not folder.startswith("/"):
+            folder = "/" + folder
+        if not folder.endswith("/"):
+            folder = folder + "/"
+        return f"{self.base_url}{folder}{filename}"

aemo_mcp/curated.py

@@ -0,0 +1,226 @@
+"""Hand-curated metadata for the 7 NEM datasets.
+
+Each YAML in `data/curated/` describes one dataset:
+- backend folder + filename pattern (regex)
+- multi-section CSV section name(s) to extract
+- filter dimensions (region, interconnector, metric, ...)
+- cadence + cache TTL kind
+- units + plain-English search keywords
+
+Loaded once at import time and stored in a frozen dataclass registry.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from importlib import resources
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from .cache import CacheKind
+from .models import DatasetDetail, DatasetFilter
+
+
+@dataclass(frozen=True)
+class CuratedFilter:
+    key: str
+    description: str
+    values: tuple[str, ...] = ()
+    required: bool = False
+    # Maps user-facing filter values → CSV row predicates. Each predicate is
+    # a dict {column: value}. Most filters map 1:1 to a single column.
+    column: str | None = None
+
+
+@dataclass(frozen=True)
+class CuratedMetric:
+    """One numeric metric extracted from the CSV section."""
+    key: str                                # response-side key (e.g. "rrp")
+    source_column: str                      # column header in the CSV section
+    description: str                        # plain-English
+    unit: str                               # e.g. "$/MWh"
+
+
+@dataclass(frozen=True)
+class CuratedSection:
+    """One CSV section to extract from the fetched ZIP."""
+    name: str                               # e.g. "DISPATCH.PRICE"
+    # When a single dataset stitches together multiple sections (eg.
+    # `rooftop_pv` combines ACTUAL + FORECAST from two different folders),
+    # `discriminator` distinguishes them in the output dimensions.
+    discriminator: str | None = None
+
+
+@dataclass(frozen=True)
+class CuratedFolder:
+    """One NEMWEB folder this dataset fetches from."""
+    path: str                               # e.g. "/Reports/Current/DispatchIS_Reports/"
+    filename_regex: str                     # e.g. "PUBLIC_DISPATCHIS_.*\\.zip"
+    sections: tuple[CuratedSection, ...] = ()
+    discriminator: str | None = None         # see CuratedSection.discriminator
+
+
+@dataclass(frozen=True)
+class CuratedDataset:
+    id: str
+    name: str
+    description: str
+    cadence: str                            # plain-English: "5 min" / "30 min" / "Daily"
+    cache_kind: CacheKind
+    folders: tuple[CuratedFolder, ...]
+    filters: tuple[CuratedFilter, ...] = ()
+    metrics: tuple[CuratedMetric, ...] = ()
+    settlement_column: str = "SETTLEMENTDATE"  # AEMO-standard period column
+    source_url: str = "http://nemweb.com.au/Reports/Current/"
+    search_keywords: tuple[str, ...] = ()
+    examples: tuple[str, ...] = ()
+
+    def to_detail(self) -> DatasetDetail:
+        return DatasetDetail(
+            id=self.id,
+            name=self.name,
+            description=self.description,
+            is_curated=True,
+            cadence=self.cadence,
+            filters=[
+                DatasetFilter(
+                    key=f.key,
+                    description=f.description,
+                    values=list(f.values),
+                    required=f.required,
+                )
+                for f in self.filters
+            ],
+            units={m.key: m.unit for m in self.metrics},
+            source_url=self.source_url,
+            examples=list(self.examples),
+        )
+
+    def get_filter(self, key: str) -> CuratedFilter | None:
+        for f in self.filters:
+            if f.key == key:
+                return f
+        return None
+
+    def get_metric(self, key: str) -> CuratedMetric | None:
+        for m in self.metrics:
+            if m.key == key:
+                return m
+        return None
+
+
+_REGISTRY: dict[str, CuratedDataset] | None = None
+
+
+def _yaml_dir() -> Path:
+    try:
+        ref = resources.files("aemo_mcp").joinpath("data/curated")
+        if ref.is_dir():
+            return Path(str(ref))
+    except (ModuleNotFoundError, AttributeError):
+        pass
+    here = Path(__file__).resolve().parent / "data" / "curated"
+    if here.is_dir():
+        return here
+    raise FileNotFoundError("Could not locate aemo_mcp/data/curated/")
+
+
+def _parse_filter(raw: dict[str, Any]) -> CuratedFilter:
+    return CuratedFilter(
+        key=str(raw["key"]),
+        description=str(raw.get("description", "")),
+        values=tuple(raw.get("values") or ()),
+        required=bool(raw.get("required", False)),
+        column=raw.get("column"),
+    )
+
+
+def _parse_metric(raw: dict[str, Any]) -> CuratedMetric:
+    return CuratedMetric(
+        key=str(raw["key"]),
+        source_column=str(raw["source_column"]),
+        description=str(raw.get("description", "")),
+        unit=str(raw.get("unit", "")),
+    )
+
+
+def _parse_section(raw: dict[str, Any] | str) -> CuratedSection:
+    if isinstance(raw, str):
+        return CuratedSection(name=raw)
+    return CuratedSection(
+        name=str(raw["name"]),
+        discriminator=raw.get("discriminator"),
+    )
+
+
+def _parse_folder(raw: dict[str, Any]) -> CuratedFolder:
+    sections_raw = raw.get("sections") or []
+    sections = tuple(_parse_section(s) for s in sections_raw)
+    return CuratedFolder(
+        path=str(raw["path"]),
+        filename_regex=str(raw["filename_regex"]),
+        sections=sections,
+        discriminator=raw.get("discriminator"),
+    )
+
+
+def _load_one(path: Path) -> CuratedDataset:
+    raw = yaml.safe_load(path.read_text(encoding="utf-8"))
+    folders = tuple(_parse_folder(f) for f in (raw.get("folders") or []))
+    if not folders:
+        raise ValueError(f"Curated YAML {path.name} has no folders")
+    filters = tuple(_parse_filter(f) for f in (raw.get("filters") or []))
+    metrics = tuple(_parse_metric(m) for m in (raw.get("metrics") or []))
+    return CuratedDataset(
+        id=str(raw["id"]),
+        name=str(raw["name"]),
+        description=str(raw.get("description", "")),
+        cadence=str(raw.get("cadence", "")),
+        cache_kind=str(raw.get("cache_kind", "live")),  # type: ignore[arg-type]
+        folders=folders,
+        filters=filters,
+        metrics=metrics,
+        settlement_column=str(raw.get("settlement_column", "SETTLEMENTDATE")),
+        source_url=str(raw.get("source_url", "http://nemweb.com.au/Reports/Current/")),
+        search_keywords=tuple(raw.get("search_keywords") or ()),
+        examples=tuple(raw.get("examples") or ()),
+    )
+
+
+def _load_all() -> dict[str, CuratedDataset]:
+    out: dict[str, CuratedDataset] = {}
+    for path in sorted(_yaml_dir().glob("*.yaml")):
+        cd = _load_one(path)
+        out[cd.id] = cd
+    return out
+
+
+def _registry() -> dict[str, CuratedDataset]:
+    global _REGISTRY
+    if _REGISTRY is None:
+        _REGISTRY = _load_all()
+    return _REGISTRY
+
+
+def get(dataset_id: str) -> CuratedDataset | None:
+    return _registry().get(dataset_id.strip().lower())
+
+
+def list_ids() -> list[str]:
+    return sorted(_registry().keys())
+
+
+def list_all() -> list[CuratedDataset]:
+    return [_registry()[k] for k in list_ids()]
+
+
+def reset_registry() -> None:
+    global _REGISTRY
+    _REGISTRY = None
+
+
+def compile_filename_regex(folder: CuratedFolder) -> re.Pattern[str]:
+    """Compiled regex for filenames in this folder (cached on the dataclass would be nicer but it's frozen)."""
+    return re.compile(folder.filename_regex)

aemo_mcp/data/curated/daily_summary.yaml

@@ -0,0 +1,68 @@
+id: daily_summary
+name: NEM Daily Summary (settled, prior trading day)
+description: |
+  Daily rolled-up summary of the previous trading day's dispatch — settled
+  prices and demand by region. Source: PUBLIC_DAILY / DREGION.
+
+  AEMO publishes a single compendium ZIP shortly after 04:10 AEST each day
+  covering yesterday's full data, including post-AP (after-price) revisions.
+  Each row is one 5-min interval × region for the prior trading day, so a
+  single response has 288 intervals × 5 regions = 1,440 rows by default.
+  Use this for backfill and "weekly average dispatch price for VIC, last 4
+  weeks" type questions where you want settled values rather than the
+  preliminary dispatch values served by `dispatch_price`.
+cadence: Daily
+cache_kind: daily
+settlement_column: SETTLEMENTDATE
+source_url: http://nemweb.com.au/Reports/Current/Daily_Reports/
+
+folders:
+  - path: /Reports/Current/Daily_Reports/
+    filename_regex: "PUBLIC_DAILY_\\d{12}_\\d{14}\\.zip"
+    sections:
+      # AEMO emits the daily region rollup as I,DREGION,,2,... — the
+      # second cell is empty, so the parser builds the section name
+      # "DREGION." (trailing dot). DREGION. is repeated v2 + v3 in the
+      # same file for old vs new schema; we read both and dedupe by
+      # (REGIONID, SETTLEMENTDATE) downstream.
+      - name: DREGION.
+
+filters:
+  - key: region
+    description: NEM region — NSW1, QLD1, SA1, TAS1, VIC1.
+    values: [NSW1, QLD1, SA1, TAS1, VIC1]
+    column: REGIONID
+
+metrics:
+  - key: rrp
+    source_column: RRP
+    description: Settled regional reference price ($/MWh)
+    unit: $/MWh
+  - key: total_demand
+    source_column: TOTALDEMAND
+    description: Total demand at the interval (MW)
+    unit: MW
+  - key: dispatchable_generation
+    source_column: DISPATCHABLEGENERATION
+    description: Dispatchable generation (scheduled + semi-scheduled, MW)
+    unit: MW
+  - key: net_interchange
+    source_column: NETINTERCHANGE
+    description: Net interconnector flow (MW). Positive = export.
+    unit: MW
+
+search_keywords:
+  - daily summary
+  - daily report
+  - yesterday
+  - settled price
+  - settlement
+  - post ap
+  - daily aggregate
+  - daily price
+  - settled rrp
+  - daily settlement
+
+examples:
+  - 'latest(dataset_id="daily_summary", filters={"region": "NSW1"})  # yesterday''s settled NSW prices'
+  - 'get_data(dataset_id="daily_summary", filters={"region": "VIC1"}, start_period="2026-04-17", end_period="2026-05-13")  # 4 weeks of VIC settled dispatch'