python-entsoe 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

entsoe/_mappings.py

@@ -399,7 +399,6 @@ NEIGHBOURS: dict[str, set[str]] = {
     "BG": {"RO", "RS", "MK", "GR", "TR"},
     "MK": {"RS", "BG", "GR", "AL"},
     "GR": {"BG", "MK", "AL", "IT_SUD", "TR"},
-    "IT_SUD": {"GR"},
     "AL": {"RS", "MK", "GR", "ME"},
     "ME": {"RS", "BA", "AL"},
     "TR": {"BG", "GR"},

entsoe/_xml.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 import re
 import xml.etree.ElementTree as ET
 from datetime import timedelta
+from typing import Callable
 
 import pandas as pd
 
@@ -79,12 +80,42 @@ def _extract_point_value(point: ET.Element) -> float | None:
     return None
 
 
-def parse_timeseries(xml_text: str) -> pd.DataFrame:
+#: Element holding the sequence of a TimeSeries within a document, e.g. the
+#: SDAC (1) and EXAA (2) day-ahead auctions both published for DE_LU and AT.
+SEQUENCE_TAG = "classificationSequence_AttributeInstanceComponent.position"
+
+
+def timeseries_sequence(ts: ET.Element) -> int | None:
+    """Return the classification sequence of a TimeSeries, or None if absent."""
+    for el in ts.iter():
+        if _strip_ns(el.tag) == SEQUENCE_TAG and el.text:
+            return int(el.text)
+    return None
+
+
+def timeseries_contract_type(ts: ET.Element) -> str | None:
+    """Return the contract_MarketAgreement.type of a TimeSeries (A01 daily, A07 intraday)."""
+    return _find_text(ts, "contract_MarketAgreement.type")
+
+
+def parse_timeseries(
+    xml_text: str,
+    ts_filter: Callable[[ET.Element], bool] | None = None,
+) -> pd.DataFrame:
     """Parse an ENTSO-E XML response into a DataFrame.
 
     Handles multiple TimeSeries (e.g., generation per type) and multiple
     Periods within each TimeSeries (e.g., multi-day responses).
 
+    Points omitted from a curveType A03 (variable-sized block) Period carry
+    the previous point's value, so they are filled in. TimeSeries the API
+    repeats verbatim produce duplicate rows, which are dropped.
+
+    Args:
+        xml_text: Raw XML response.
+        ts_filter: Optional predicate on each TimeSeries element; series for
+            which it returns False are skipped.
+
     Returns a DataFrame with columns:
     - timestamp: tz-aware UTC datetime
     - value: numeric value (MW or EUR/MWh depending on query)
@@ -107,6 +138,9 @@ def parse_timeseries(xml_text: str) -> pd.DataFrame:
     rows: list[dict] = []
 
     for ts in timeseries_list:
+        if ts_filter is not None and not ts_filter(ts):
+            continue
+
         # Extract TimeSeries metadata
         ts_meta: dict = {}
 
@@ -163,23 +197,38 @@ def parse_timeseries(xml_text: str) -> pd.DataFrame:
             period_start = pd.Timestamp(start_text)
             resolution = _parse_resolution(resolution_text)
 
+            values: dict[int, float | None] = {}
             for point in _findall(period, "Point"):
                 position_text = _find_text(point, "position")
                 if position_text is None:
                     continue
+                values[int(position_text)] = _extract_point_value(point)
 
-                position = int(position_text)
-                value = _extract_point_value(point)
+            if not values:
+                continue
 
+            positions = sorted(values)
+            if _find_text(ts, "curveType") == "A03":
+                end_text = _find_text(time_interval, "end")
+                if end_text is not None:
+                    n_slots = int((pd.Timestamp(end_text) - period_start) / resolution)
+                else:
+                    n_slots = positions[-1]
+                filled: dict[int, float | None] = {}
+                last = None
+                for pos in range(positions[0], max(n_slots, positions[-1]) + 1):
+                    last = values.get(pos, last)
+                    filled[pos] = last
+                values, positions = filled, list(filled)
+
+            for position in positions:
                 timestamp = period_start + resolution * (position - 1)
-
-                row = {"timestamp": timestamp, "value": value, **ts_meta}
-                rows.append(row)
+                rows.append({"timestamp": timestamp, "value": values[position], **ts_meta})
 
     if not rows:
         raise NoDataError()
 
-    df = pd.DataFrame(rows)
+    df = pd.DataFrame(rows).drop_duplicates()
     df["timestamp"] = pd.to_datetime(df["timestamp"], utc=True)
     df = df.sort_values("timestamp").reset_index(drop=True)
     return df

entsoe/cache.py

@@ -6,7 +6,7 @@ published (~48h), so caching is safe and enabled by default.
 
 Storage layout::
 
-    {cache_dir}/
+    {cache_dir}/v{CACHE_LAYOUT_VERSION}/
     ├── prices/day_ahead/{ES,FR,...}/data.parquet
     ├── load/{actual,forecast}/{ES,FR,...}/data.parquet
     ├── generation/{actual,forecast,capacity}/{ES,...}/data.parquet
@@ -18,6 +18,9 @@ Each partition stores a single wide-format parquet file: the DatetimeIndex
 holds timestamps, and columns are values (e.g. "value", or per-type
 columns like "solar", "wind_onshore").
 
+The version directory changes whenever cached values from earlier releases
+are known to be wrong; data from older layouts is removed on first use.
+
 Gap detection works per-column: requesting specific columns checks whether
 those columns have data for the requested range, not whether any column does.
 """
@@ -42,6 +45,13 @@ _DEFAULT_CACHE_DIR = Path(
     os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache")
 ) / "entsoe"
 
+# Bumped when previously cached values are known to be wrong.
+# v2 (0.6.2): A03 curves lost their omitted points; day-ahead mixed auctions.
+CACHE_LAYOUT_VERSION = 2
+
+# Domain directories written by the unversioned (<= 0.6.1) layout.
+_LEGACY_DOMAINS = ("prices", "load", "generation", "transmission", "balancing")
+
 # Data older than this (hours) is considered final and won't be re-fetched
 _DEFAULT_RECENT_TTL_HOURS = 48
 
@@ -71,16 +81,37 @@ class CacheStore:
 
     def __init__(self, config: CacheConfig):
         self.config = config
+        self._purge_stale_layouts()
+
+    @property
+    def root(self) -> Path:
+        """Directory holding the current cache layout."""
+        return self.config.cache_dir / f"v{CACHE_LAYOUT_VERSION}"
+
+    def _purge_stale_layouts(self) -> None:
+        """Delete data cached by older layouts, which may hold wrong values."""
+        base = self.config.cache_dir
+        if not base.is_dir():
+            return
+        stale = [base / d for d in _LEGACY_DOMAINS]
+        stale += [
+            p for p in base.glob("v*")
+            if p.name[1:].isdigit() and int(p.name[1:]) < CACHE_LAYOUT_VERSION
+        ]
+        for path in stale:
+            if path.is_dir():
+                logger.info("Removing outdated ENTSO-E cache: %s", path)
+                shutil.rmtree(path, ignore_errors=True)
 
     # -- Path resolution -------------------------------------------------------
 
     def _parquet_path(self, domain: str, topic: str, partition: str) -> Path:
-        """Data file: {cache_dir}/{domain}/{topic}/{partition}/data.parquet"""
-        return self.config.cache_dir / domain / topic / partition / "data.parquet"
+        """Data file: {root}/{domain}/{topic}/{partition}/data.parquet"""
+        return self.root / domain / topic / partition / "data.parquet"
 
     def _meta_path(self, domain: str, topic: str, partition: str) -> Path:
-        """Metadata file: {cache_dir}/{domain}/{topic}/{partition}/meta.json"""
-        return self.config.cache_dir / domain / topic / partition / "meta.json"
+        """Metadata file: {root}/{domain}/{topic}/{partition}/meta.json"""
+        return self.root / domain / topic / partition / "meta.json"
 
     # -- Data Read / Write -----------------------------------------------------
 
@@ -291,13 +322,13 @@ class CacheStore:
         count = 0
 
         if domain and topic and partition:
-            target = self.config.cache_dir / domain / topic / partition
+            target = self.root / domain / topic / partition
         elif domain and topic:
-            target = self.config.cache_dir / domain / topic
+            target = self.root / domain / topic
         elif domain:
-            target = self.config.cache_dir / domain
+            target = self.root / domain
         else:
-            target = self.config.cache_dir
+            target = self.root
 
         if target.exists():
             count = sum(1 for f in target.rglob("*") if f.is_file())
@@ -307,7 +338,7 @@ class CacheStore:
 
     def status(self) -> dict:
         """Return cache statistics."""
-        cache_dir = self.config.cache_dir
+        cache_dir = self.root
         if not cache_dir.exists():
             return {"path": str(cache_dir), "files": 0, "size_mb": 0.0, "domains": {}}
 

entsoe/catalog.py

@@ -7,25 +7,202 @@ consult external documentation every time.
 
 from __future__ import annotations
 
-# Re-export dataclasses for backward compatibility
-from entsoe._models import Category, Endpoint
-from entsoe.catalog_manager import ENTSOECatalogManager as _Manager
+from dataclasses import dataclass, field
 
-__all__ = ["Category", "Endpoint", "CATEGORIES", "get_category", "summary"]
 
-# ── Load categories from YAML ──────────────────────────────────────────
+@dataclass(frozen=True)
+class Endpoint:
+    """A queryable data endpoint."""
 
-_mgr = _Manager()
-_cats = {c.key: c for c in _mgr._load_categories()}
+    name: str
+    description: str
+    method: str  # Python client method name
+    cli: str  # CLI command
+    resolution: str  # e.g. "15min", "hourly", "daily"
+    columns: tuple[str, ...]  # key columns returned
+    units: str
+    notes: str = ""
 
-CATEGORIES: dict[str, Category] = _cats
 
-# Individual constants for backward compatibility
-PRICES = CATEGORIES["prices"]
-LOAD = CATEGORIES["load"]
-GENERATION = CATEGORIES["generation"]
-TRANSMISSION = CATEGORIES["transmission"]
-BALANCING = CATEGORIES["balancing"]
+@dataclass(frozen=True)
+class Category:
+    """A top-level data category grouping related endpoints."""
+
+    name: str
+    description: str
+    namespace: str  # Python client namespace (e.g. "prices")
+    endpoints: tuple[Endpoint, ...]
+
+
+# ── Prices ──────────────────────────────────────────────────────────────
+
+PRICES = Category(
+    name="Prices",
+    description="Day-ahead electricity market prices",
+    namespace="prices",
+    endpoints=(
+        Endpoint(
+            name="Day-Ahead Prices",
+            description="Hourly day-ahead market clearing prices per bidding zone",
+            method="client.prices.day_ahead(start, end, country='FR')",
+            cli="entsoe prices day-ahead -s 2024-06-01 -e 2024-06-08 -c FR",
+            resolution="hourly",
+            columns=("timestamp", "country", "value", "currency", "quantity_unit"),
+            units="EUR/MWh",
+        ),
+    ),
+)
+
+# ── Load ────────────────────────────────────────────────────────────────
+
+LOAD = Category(
+    name="Load",
+    description="Actual system load and day-ahead load forecasts",
+    namespace="load",
+    endpoints=(
+        Endpoint(
+            name="Actual Total Load",
+            description="Actual total electricity consumption per control area",
+            method="client.load.actual(start, end, country='FR')",
+            cli="entsoe load actual -s 2024-06-01 -e 2024-06-08 -c FR",
+            resolution="15min or hourly (varies by country)",
+            columns=("timestamp", "country", "value", "quantity_unit"),
+            units="MW",
+        ),
+        Endpoint(
+            name="Day-Ahead Load Forecast",
+            description="Day-ahead forecast of total electricity consumption",
+            method="client.load.forecast(start, end, country='FR')",
+            cli="entsoe load forecast -s 2024-06-01 -e 2024-06-08 -c FR",
+            resolution="15min or hourly (varies by country)",
+            columns=("timestamp", "country", "value", "quantity_unit"),
+            units="MW",
+        ),
+    ),
+)
+
+# ── Generation ──────────────────────────────────────────────────────────
+
+GENERATION = Category(
+    name="Generation",
+    description="Actual generation, forecasts, installed capacity, and per-plant output",
+    namespace="generation",
+    endpoints=(
+        Endpoint(
+            name="Actual Generation per Type",
+            description="Actual electricity generation broken down by fuel/technology type (PSR)",
+            method="client.generation.actual(start, end, country='FR')",
+            cli="entsoe generation actual -s 2024-06-01 -e 2024-06-08 -c FR",
+            resolution="15min or hourly",
+            columns=("timestamp", "country", "psr_type", "value", "quantity_unit"),
+            units="MW",
+            notes="Filter by PSR type: --psr solar --psr wind_onshore",
+        ),
+        Endpoint(
+            name="Generation Forecast (Wind/Solar)",
+            description="Day-ahead forecast for wind and solar generation",
+            method="client.generation.forecast(start, end, country='FR')",
+            cli="entsoe generation forecast -s 2024-06-01 -e 2024-06-08 -c FR",
+            resolution="15min or hourly",
+            columns=("timestamp", "country", "psr_type", "value", "quantity_unit"),
+            units="MW",
+        ),
+        Endpoint(
+            name="Installed Generation Capacity",
+            description="Installed generation capacity per type (updated annually or on change)",
+            method="client.generation.installed_capacity(start, end, country='FR')",
+            cli="entsoe generation capacity -s 2024-06-01 -e 2024-06-08 -c FR",
+            resolution="yearly (point-in-time)",
+            columns=("timestamp", "country", "psr_type", "value", "quantity_unit"),
+            units="MW",
+        ),
+        Endpoint(
+            name="Actual Generation per Plant",
+            description="Generation output per individual production unit (>= 100 MW)",
+            method="client.generation.per_plant(start, end, country='FR')",
+            cli="entsoe generation per-plant -s 2024-06-01 -e 2024-06-08 -c FR",
+            resolution="15min or hourly",
+            columns=("timestamp", "country", "unit_name", "psr_type", "value", "quantity_unit"),
+            units="MW",
+        ),
+    ),
+)
+
+# ── Transmission ────────────────────────────────────────────────────────
+
+TRANSMISSION = Category(
+    name="Transmission",
+    description="Cross-border physical flows, scheduled exchanges, and transfer capacity",
+    namespace="transmission",
+    endpoints=(
+        Endpoint(
+            name="Physical Cross-Border Flows",
+            description="Actual measured electricity flows between bidding zones",
+            method="client.transmission.crossborder_flows(start, end, country_from='FR', country_to='DE_LU')",
+            cli="entsoe transmission flows -s 2024-06-01 -e 2024-06-08 --from FR --to DE_LU",
+            resolution="15min or hourly",
+            columns=("timestamp", "in_domain", "value", "quantity_unit"),
+            units="MW",
+            notes="Use --border for multi-border queries: --border FR-*, --border iberian",
+        ),
+        Endpoint(
+            name="Scheduled Commercial Exchanges",
+            description="Day-ahead scheduled commercial power exchanges between zones",
+            method="client.transmission.scheduled_exchanges(start, end, country_from='FR', country_to='ES')",
+            cli="entsoe transmission exchanges -s 2024-06-01 -e 2024-06-08 --from FR --to ES",
+            resolution="hourly",
+            columns=("timestamp", "in_domain", "value", "quantity_unit"),
+            units="MW",
+        ),
+        Endpoint(
+            name="Net Transfer Capacity",
+            description="Available transfer capacity (NTC) between bidding zones",
+            method="client.transmission.net_transfer_capacity(start, end, country_from='FR', country_to='ES')",
+            cli="entsoe transmission capacity -s 2024-06-01 -e 2024-06-08 --from FR --to ES",
+            resolution="hourly",
+            columns=("timestamp", "in_domain", "value", "quantity_unit"),
+            units="MW",
+        ),
+    ),
+)
+
+# ── Balancing ───────────────────────────────────────────────────────────
+
+BALANCING = Category(
+    name="Balancing",
+    description="System imbalance prices and volumes",
+    namespace="balancing",
+    endpoints=(
+        Endpoint(
+            name="Imbalance Prices",
+            description="System imbalance settlement prices",
+            method="client.balancing.imbalance_prices(start, end, country='FR')",
+            cli="entsoe balancing prices -s 2024-06-01 -e 2024-06-08 -c FR",
+            resolution="15min or hourly (varies by country)",
+            columns=("timestamp", "country", "value", "quantity_unit"),
+            units="EUR/MWh",
+        ),
+        Endpoint(
+            name="Imbalance Volumes",
+            description="Net system imbalance volumes",
+            method="client.balancing.imbalance_volumes(start, end, country='FR')",
+            cli="entsoe balancing volumes -s 2024-06-01 -e 2024-06-08 -c FR",
+            resolution="15min or hourly (varies by country)",
+            columns=("timestamp", "country", "value", "quantity_unit"),
+            units="MW",
+        ),
+    ),
+)
+
+# ── Full catalog ────────────────────────────────────────────────────────
+
+CATEGORIES: dict[str, Category] = {
+    "prices": PRICES,
+    "load": LOAD,
+    "generation": GENERATION,
+    "transmission": TRANSMISSION,
+    "balancing": BALANCING,
+}
 
 
 def get_category(name: str) -> Category:

entsoe/cli/prices.py

@@ -18,6 +18,7 @@ def day_ahead(
     end: Optional[str] = typer.Option(None, "--end", "-e", help="End date (YYYY-MM-DD)"),
     period: Optional[str] = typer.Option(None, "--period", "-P", help="Period shorthand: today, yesterday, week, month, ytd, <N>d"),
     country: list[str] = typer.Option(..., "--country", "-c", help="Country code(s), comma-separated or repeated (e.g. ES,FR,DE_LU)"),
+    sequence: int = typer.Option(1, "--sequence", help="Auction: 1 = SDAC (default), 2 = EXAA (DE_LU, AT)"),
     format: str = typer.Option("table", "--format", "-f", help="Output format: table, csv, json"),
     output_path: Optional[str] = typer.Option(None, "--output", "-o", help="Output file path"),
     api_key: Optional[str] = typer.Option(None, "--api-key", help="ENTSO-E API key"),
@@ -28,7 +29,7 @@ def day_ahead(
     s, e = resolve_dates(start, end, period)
     client = get_client(api_key)
     countries = resolve_many_required(country)
-    df = client.prices.day_ahead(s, e, country=countries)
+    df = client.prices.day_ahead(s, e, country=countries, sequence=sequence)
     output(df, format, title="Day-Ahead Prices", output_path=output_path)
 
 

entsoe/client.py

@@ -7,7 +7,6 @@ from pathlib import Path
 
 from ._http import HttpClient
 from .cache import CacheConfig, CacheStore
-from .catalog_manager import ENTSOECatalogManager
 from .namespaces import (
     BalancingNamespace,
     GenerationNamespace,
@@ -101,8 +100,6 @@ class ENTSOEClient:
         self.transmission = TransmissionNamespace(http, tz=tz, cache=cache_store)
         self.balancing = BalancingNamespace(http, tz=tz, cache=cache_store)
 
-        self.catalog = ENTSOECatalogManager(self)
-
         # Expose for CLI cache commands
         self._cache = cache_store
 

entsoe/namespaces/_base.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Callable, Union
+from typing import TYPE_CHECKING, Callable, Optional, Union
 
 import pandas as pd
 
@@ -11,6 +11,8 @@ from ..exceptions import InvalidParameterError, NoDataError
 from .._mappings import country_name, lookup_area
 
 if TYPE_CHECKING:
+    import xml.etree.ElementTree as ET
+
     from .._http import HttpClient
     from ..cache import CacheStore
 
@@ -22,6 +24,9 @@ Timestamp = Union[str, pd.Timestamp]
 #: Parameters that accept a single value or a list.
 OneOrMany = Union[str, list[str]]
 
+#: Predicate deciding which TimeSeries of a response to keep.
+TimeSeriesFilter = Optional[Callable[["ET.Element"], bool]]
+
 
 class BaseNamespace:
     """Base class for domain namespaces.
@@ -61,6 +66,8 @@ class BaseNamespace:
         params: dict,
         start: Timestamp,
         end: Timestamp,
+        *,
+        ts_filter: TimeSeriesFilter = None,
     ) -> pd.DataFrame:
         """Execute a query and parse the XML response into a DataFrame."""
         from .._xml import parse_timeseries
@@ -71,10 +78,10 @@ class BaseNamespace:
 
         # Handle multi-chunk responses (year-splitting)
         if isinstance(result, list):
-            dfs = [parse_timeseries(xml) for xml in result]
+            dfs = [parse_timeseries(xml, ts_filter) for xml in result]
             return pd.concat(dfs, ignore_index=True).sort_values("timestamp").reset_index(drop=True)
 
-        return parse_timeseries(result)
+        return parse_timeseries(result, ts_filter)
 
     def _query_multi(
         self,
@@ -85,6 +92,7 @@ class BaseNamespace:
         *,
         label_fn: Callable[[str], str] = country_name,
         label_col: str = "country",
+        ts_filter: TimeSeriesFilter = None,
     ) -> pd.DataFrame:
         """Execute a query for one or many values, concatenating results.
 
@@ -110,11 +118,11 @@ class BaseNamespace:
             queries with an additional label column.
         """
         if isinstance(values, str):
-            return self._query(build_params(values), start, end)
+            return self._query(build_params(values), start, end, ts_filter=ts_filter)
 
         frames = []
         for val in values:
-            df = self._query(build_params(val), start, end)
+            df = self._query(build_params(val), start, end, ts_filter=ts_filter)
             df[label_col] = label_fn(val)
             frames.append(df)
         return pd.concat(frames, ignore_index=True)
@@ -134,6 +142,7 @@ class BaseNamespace:
         *,
         pivot_col: str | None = None,
         value_col: str = "value",
+        ts_filter: TimeSeriesFilter = None,
     ) -> pd.DataFrame:
         """Execute a query with parquet cache support.
 
@@ -174,7 +183,7 @@ class BaseNamespace:
             raise InvalidParameterError("start must be before end.")
 
         if self._cache is None:
-            return self._query(params, start_ts, end_ts)
+            return self._query(params, start_ts, end_ts, ts_filter=ts_filter)
 
         # 1. Read cached wide data
         cached_wide = self._cache.read(domain, topic, partition, start_ts, end_ts)
@@ -225,7 +234,7 @@ class BaseNamespace:
         gap_meta: dict = {}
         for gap in valid_gaps:
             try:
-                raw_df = self._query(params, gap.start, gap.end)
+                raw_df = self._query(params, gap.start, gap.end, ts_filter=ts_filter)
                 wide, meta = self._to_wide(raw_df, pivot_col, value_col)
                 new_wide_frames.append(wide)
                 if meta:
@@ -279,27 +288,30 @@ class BaseNamespace:
         value_col: str = "value",
         label_fn: Callable[[str], str] = country_name,
         label_col: str = "country",
+        ts_filter: TimeSeriesFilter = None,
+        partition_fn: Callable[[str], str] = str,
     ) -> pd.DataFrame:
         """Execute a cached query for one or many values.
 
-        Each value is its own cache partition. Multi-value queries add
-        a label column, same as :meth:`_query_multi`.
+        Each value is its own cache partition, named by *partition_fn(value)*.
+        Multi-value queries add a label column, same as :meth:`_query_multi`.
         """
         if self._cache is None:
             return self._query_multi(build_params, values, start, end,
-                                     label_fn=label_fn, label_col=label_col)
+                                     label_fn=label_fn, label_col=label_col,
+                                     ts_filter=ts_filter)
 
         if isinstance(values, str):
             return self._query_cached(
-                domain, topic, values, build_params(values), start, end,
-                pivot_col=pivot_col, value_col=value_col,
+                domain, topic, partition_fn(values), build_params(values), start, end,
+                pivot_col=pivot_col, value_col=value_col, ts_filter=ts_filter,
             )
 
         frames = []
         for val in values:
             df = self._query_cached(
-                domain, topic, val, build_params(val), start, end,
-                pivot_col=pivot_col, value_col=value_col,
+                domain, topic, partition_fn(val), build_params(val), start, end,
+                pivot_col=pivot_col, value_col=value_col, ts_filter=ts_filter,
             )
             df[label_col] = label_fn(val)
             frames.append(df)

entsoe/namespaces/prices.py

@@ -2,11 +2,13 @@
 
 from __future__ import annotations
 
+import xml.etree.ElementTree as ET
+
 import pandas as pd
 
+from .._xml import timeseries_contract_type, timeseries_sequence
 from ._base import BaseNamespace, OneOrMany, Timestamp
 
-
 class PricesNamespace(BaseNamespace):
     """Access electricity price data.
 
@@ -19,14 +21,24 @@ class PricesNamespace(BaseNamespace):
         start: Timestamp,
         end: Timestamp,
         country: OneOrMany,
+        sequence: int = 1,
     ) -> pd.DataFrame:
         """Query day-ahead electricity prices.
 
+        The A44 document mixes several auctions. Only daily contracts are
+        kept (intraday auctions such as the Spanish IDAs are dropped), and
+        among them the one with the requested classification sequence.
+
         Args:
             start: Period start — date string or tz-aware Timestamp.
             end: Period end — date string or tz-aware Timestamp.
             country: Country code or list of codes (e.g., "FR" or ["FR", "ES"]).
                 When a list is passed, results include a ``country`` column.
+            sequence: Which day-ahead auction to return. ``1`` (default) is
+                the Single Day-Ahead Coupling (SDAC, gate closure 12:00 CET).
+                ``2`` is the separate EXAA auction (10:15 CET) published for
+                DE_LU and AT. Zones that publish a single auction without a
+                sequence count as ``1``.
 
         Returns:
             DataFrame with columns: timestamp, value (EUR/MWh).
@@ -41,6 +53,13 @@ class PricesNamespace(BaseNamespace):
                 "out_Domain": area,
             }
 
+        def _keep(ts: ET.Element) -> bool:
+            if timeseries_contract_type(ts) not in (None, "A01"):
+                return False
+            return (timeseries_sequence(ts) or 1) == sequence
+
         return self._query_multi_cached(
             "prices", "day_ahead", _params, country, start, end,
+            ts_filter=_keep,
+            partition_fn=lambda code: code if sequence == 1 else f"{code}.seq{sequence}",
         )

{python_entsoe-0.6.0.dist-info → python_entsoe-0.6.2.dist-info}/METADATA

@@ -1,11 +1,11 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: python-entsoe
-Version: 0.6.0
+Version: 0.6.2
 Summary: Python client for the ENTSO-E Transparency Platform API
-Project-URL: Homepage, https://github.com/datons/python-entsoe
-Project-URL: Repository, https://github.com/datons/python-entsoe
-Project-URL: Issues, https://github.com/datons/python-entsoe/issues
-Project-URL: Changelog, https://github.com/datons/python-entsoe/releases
+Project-URL: Homepage, https://gitlab.com/datons.com/libraries/python-entsoe
+Project-URL: Repository, https://gitlab.com/datons.com/libraries/python-entsoe
+Project-URL: Issues, https://gitlab.com/datons.com/libraries/python-entsoe/-/issues
+Project-URL: Changelog, https://gitlab.com/datons.com/libraries/python-entsoe/-/releases
 Author-email: Jesús López <jesus.lopez@datons.com>
 License-Expression: MIT
 Keywords: api,electricity,energy,entsoe,transparency
@@ -21,7 +21,6 @@ Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.10
 Requires-Dist: pandas>=2.0
 Requires-Dist: pyarrow>=23.0.1
-Requires-Dist: pyyaml>=6.0
 Requires-Dist: requests>=2.28
 Requires-Dist: rich>=13.0
 Requires-Dist: typer>=0.9
@@ -94,11 +93,14 @@ df = client.load.forecast(start, end, country="FR")
 
 | Method | Description | Parameters |
 |--------|-------------|------------|
-| `day_ahead(start, end, country)` | Day-ahead market prices (EUR/MWh) | `country`: ISO code |
+| `day_ahead(start, end, country, sequence=1)` | Day-ahead market prices (EUR/MWh) | `country`: ISO code; `sequence`: `1` SDAC, `2` EXAA |
 
 ```python
 df = client.prices.day_ahead(start, end, country="FR")
 # Returns: timestamp, value, currency, price_unit
+
+# DE_LU and AT also publish the separate EXAA auction (10:15 CET)
+exaa = client.prices.day_ahead(start, end, country="DE_LU", sequence=2)
 ```
 
 ### `client.generation`
@@ -252,7 +254,7 @@ See the [`examples/`](examples/) directory for Jupyter notebooks with plotly vis
 ## Development
 
 ```bash
-git clone https://github.com/jsulopzs/python-entsoe.git
+git clone git@gitlab.com:datons.com/libraries/python-entsoe.git
 cd python-entsoe
 uv sync
 

{python_entsoe-0.6.0.dist-info → python_entsoe-0.6.2.dist-info}/RECORD

@@ -1,10 +1,10 @@
 entsoe/__init__.py,sha256=9qzvMUzoD-CRfX1vTzWIBfpXBMdJ2MgRwJEgQQsw1fA,529
 entsoe/_http.py,sha256=XhZZy059XHh8uAP2Vsm1e7BfRwQcmGLEYdREcgaF3Tk,6608
-entsoe/_mappings.py,sha256=uzR1X_ADPV3Nauz9TVpwkeIURTqdX2grefpweUZzkwM,15556
-entsoe/_xml.py,sha256=222kgi8lStU0qQIU-oxiciO2WtplqKySi6qBZXbyiEc,6393
-entsoe/cache.py,sha256=rRkuQPGYg05Uo3xFW7gVltNE56M-1_E5mdEvgLoWhpM,13356
-entsoe/catalog.py,sha256=Kytze4bowZ2PphK7h3eYdbza15y-dnDIcLIEzL3pO7A,1846
-entsoe/client.py,sha256=T0Dz1k1ylNU7R10HDi4UGCW_5vYAMUCgX9QP-caLwdk,3643
+entsoe/_mappings.py,sha256=6-IKLtwChvM7_YG90oSRDxo3IfQUuz3Gnv17TmQgPjM,15534
+entsoe/_xml.py,sha256=cJa4_nVIk27O9bCXkp2w-QR2fV3UrH-A80mX54KReVU,8439
+entsoe/cache.py,sha256=3UIuhaSH9LVGk9Ony5eMsk_qOmRzzMEyskQS_cmY020,14547
+entsoe/catalog.py,sha256=FUPg_WqLBkfl5sUgT9m8Bua7IP10NvBsakcndpUOBa0,9733
+entsoe/client.py,sha256=zHB9y2TbCRjSNe9d5c9XVt_BNZ7b8KsvJDORc5V-ypE,3542
 entsoe/exceptions.py,sha256=vqeu6_LxAtDvJziPnjbH52KV0fm63F8n2Y1lzSNp2Bs,1017
 entsoe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 entsoe/.agents/skills/entsoe/SKILL.md,sha256=JsFECSkfnxyR6iFx55WBBcMJjAOaMu84vhcsPsTVWC0,6452
@@ -20,16 +20,16 @@ entsoe/cli/config_cmd.py,sha256=HfpMMv8S1kDUIid6kxX-cNirCvhDby2lSPNSD8o3qX8,923
 entsoe/cli/exec_cmd.py,sha256=KiGwOTIjYQQPEg7v51oRbpk3Cj9-7hDDCbEYXfZ_lfQ,11308
 entsoe/cli/generation.py,sha256=wSQUyZJ3vuhcHss4R8g__2BMkTSik6rYkr4FvwWvvrs,5681
 entsoe/cli/load.py,sha256=wC8ZYGi8ce_b5OBBC7fdUPLCgUN_ssC79A0eZJuXGSQ,2685
-entsoe/cli/prices.py,sha256=BSUhPKw-K2hw7GrgPnmCtdR7iAo9tMMoKNSuqscPT5o,1601
+entsoe/cli/prices.py,sha256=Gj_Irw4i5KJ7lUUUChkm9FqBDCHorP9tN4fFMnc5v0c,1729
 entsoe/cli/transmission.py,sha256=nQMQwxNcvxHEdlldHnVY02oL2aUKONKRpz2M3bFKM1U,5592
 entsoe/namespaces/__init__.py,sha256=ZVd80s5OVxegLo3A6nI64tHlBA1Iwe2ejqQilGNod5E,399
-entsoe/namespaces/_base.py,sha256=iVUVYYeYz3qAvyjzWLV_4ewUGiS63WpbyIKLTaWIFsU,14366
+entsoe/namespaces/_base.py,sha256=euieKT3MZkOdIq9ER_hSHJuYPVXH2Ie_NDbzmiKZf6Y,15042
 entsoe/namespaces/balancing.py,sha256=210Ft6dE7WXEuxtTJqyEvCIL960n-sDHT7tsqpSbXIw,2143
 entsoe/namespaces/generation.py,sha256=V4DkvV5ai7aWYYSdZKwWyxTEv1ed4nCCq7DYyVwvc6M,6729
 entsoe/namespaces/load.py,sha256=fbkwKWZifb8DOf5Rc_7c4_eFAXiqT_562r9WTMQwsuo,2160
-entsoe/namespaces/prices.py,sha256=5-hVmpxytyxPKx0eBRN7mjKDhfPUK0ZZi1nnF5zOE9A,1295
+entsoe/namespaces/prices.py,sha256=Dr1y5Y9wVdTOzTTWXlx11eiQLQc75chua3UoRpBYfxw,2311
 entsoe/namespaces/transmission.py,sha256=V8zrs2CQXf1WPjJRqz7wc-ztnkfriIKXPLfYHBDJD9M,8067
-python_entsoe-0.6.0.dist-info/METADATA,sha256=9n_ZXWv_3DGfQ9Lw-joS3wlb1ghXmYtmwu0thC2YkTc,8639
-python_entsoe-0.6.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-python_entsoe-0.6.0.dist-info/entry_points.txt,sha256=tYyCheggCsGRKOq2vIjpAxBksEM7K_iGI6vHkkQLmYg,42
-python_entsoe-0.6.0.dist-info/RECORD,,
+python_entsoe-0.6.2.dist-info/METADATA,sha256=kdpKrENk7toC8X3fJQUfuyeP8Jv3VAsc-tDkHwGN5uI,8863
+python_entsoe-0.6.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+python_entsoe-0.6.2.dist-info/entry_points.txt,sha256=tYyCheggCsGRKOq2vIjpAxBksEM7K_iGI6vHkkQLmYg,42
+python_entsoe-0.6.2.dist-info/RECORD,,

{python_entsoe-0.6.0.dist-info → python_entsoe-0.6.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.29.0
+Generator: hatchling 1.32.4
 Root-Is-Purelib: true
 Tag: py3-none-any