python-entsoe 0.6.1__tar.gz → 0.6.3__tar.gz

python_entsoe-0.6.3/.github/workflows/publish.yml

@@ -0,0 +1,26 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

python_entsoe-0.6.3/.gitlab-ci.yml

@@ -0,0 +1,22 @@
+stages:
+  - build
+  - publish
+
+default:
+  image: ghcr.io/astral-sh/uv:python3.13-bookworm
+
+build:
+  stage: build
+  script:
+    - uv build --no-sources
+  artifacts:
+    paths:
+      - dist/
+
+publish:
+  stage: publish
+  rules:
+    - if: '$CI_COMMIT_TAG =~ /^v[0-9]+\.[0-9]+\.[0-9]+/'
+  script:
+    - uv build --no-sources
+    - uv publish --publish-url "$CI_API_V4_URL/projects/$CI_PROJECT_ID/packages/pypi" --check-url "$CI_API_V4_URL/projects/$CI_PROJECT_ID/packages/pypi/simple" --username gitlab-ci-token --password "$CI_JOB_TOKEN"

{python_entsoe-0.6.1 → python_entsoe-0.6.3}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.6.3](https://gitlab.com/datons.com/libraries/python-entsoe/-/tags/v0.6.3) (2026-10-15)
+
+
+### Bug Fixes
+
+* **cli:** `--period today` and `--period yesterday` produced an empty range and always failed with "start must be before end"; each now covers the full day.
+* **cache:** a failed download (timeout, HTTP error) no longer returns an empty or partial DataFrame with only a warning in the log; the error is raised.
+
+## [0.6.2](https://gitlab.com/datons.com/libraries/python-entsoe/-/tags/v0.6.2) (2026-10-15)
+
+
+### Bug Fixes
+
+* **prices:** `day_ahead` mixed the SDAC and EXAA auctions for DE_LU and AT, and the intraday auctions for ES, returning several prices per timestamp. It now returns SDAC; `sequence=2` returns EXAA (CLI: `--sequence 2`).
+* **parser:** points omitted from A03 (variable-sized block) curves are filled with the previous value, so no interval is lost. Affects every endpoint.
+* **parser:** TimeSeries that the API repeats verbatim no longer produce duplicate rows.
+* **cache:** the cache moves to a versioned layout (`~/.cache/entsoe/v2/`). Data cached by earlier versions, which may hold the errors above, is deleted on first use and downloaded again.
+
 ## [0.6.1](https://github.com/datons/python-entsoe/compare/python-entsoe-v0.6.0...python-entsoe-v0.6.1) (2026-05-16)
 
 

{python_entsoe-0.6.1 → python_entsoe-0.6.3}/CLAUDE.md

@@ -9,19 +9,23 @@ Python client for the ENTSO-E Transparency Platform API.
 - Run scripts: `uv run python <script>`
 - Run tests: `uv run pytest`
 
-## PyPI Publishing
+## Publishing
 
-Publishing is **tag-based only**. Pushing to `main` does NOT trigger a release.
+The repo lives in GitLab (`datons.com/libraries/python-entsoe`, private). Publishing is **tag-based only**: pushing to `main` does NOT release. The CI publishes to the `datons.com/libraries` package registry, which `esios` and the other services consume through the `datons-libraries` index.
 
 ```bash
 # 1. Bump version in pyproject.toml
 # 2. Commit the version bump
 # 3. Tag and push
-git tag v0.3.0
+git tag v0.6.2
 git push origin main --tags
 ```
 
-The GitHub Actions workflow (`.github/workflows/publish.yml`) uses OIDC trusted publishing — no tokens needed.
+Public users install from PyPI, so a fix that matters to them is also released there: push `main` and the same tag to the `github` remote. `.github/workflows/publish.yml` builds and publishes on `v*` tags through PyPI trusted publishing (no token). GitLab stays the source of truth.
+
+```bash
+git push github main --tags
+```
 
 ## Example Notebooks
 

{python_entsoe-0.6.1 → python_entsoe-0.6.3}/PKG-INFO

@@ -1,11 +1,11 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: python-entsoe
-Version: 0.6.1
+Version: 0.6.3
 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
@@ -93,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`
@@ -251,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.1 → python_entsoe-0.6.3}/README.md

@@ -65,11 +65,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`
@@ -223,7 +226,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.1 → python_entsoe-0.6.3}/docs/data-availability.md

@@ -92,6 +92,28 @@ environment variable.
 export $(cat .env | xargs) && uv run jupyter nbconvert --execute ...
 ```
 
+## 7. Day-ahead documents (A44) mix several auctions
+
+**Affected endpoints:** `prices.day_ahead`
+
+**Problem:** One A44 response can hold several price series for the same hours:
+
+- DE_LU and AT publish the SDAC auction (gate closure 12:00 CET) as `classificationSequence_AttributeInstanceComponent.position` 1 and the EXAA auction (10:15 CET) as position 2.
+- ES also returns the intraday auctions (IDA1–3) under `contract_MarketAgreement.type` A07, numbered by the same sequence element.
+- Some zones (FR, AT) repeat an identical TimeSeries.
+
+Parsing every series gives two or more prices per timestamp.
+
+**Solution:** Keep only daily contracts (`A01`, or no contract type) whose sequence matches the requested one, treating a missing sequence as 1. `day_ahead(..., sequence=2)` returns EXAA. Identical rows are dropped.
+
+## 8. Curve type A03 omits repeated points
+
+**Affected endpoints:** all (prices, load, generation, transmission)
+
+**Problem:** With `<curveType>A03</curveType>` (variable-sized blocks), a Point applies until the next Point, and positions whose value equals the previous one are left out. Reading only the Points present loses those intervals: a day of quarter-hourly prices can come back with 95 rows, and a flat generation series with a single row.
+
+**Solution:** Fill every position up to the Period's `timeInterval/end` with the last value seen. The Period end tracks published data, so recent partial days are not extended.
+
 ## Summary table
 
 | Issue | Endpoint | Symptom | Fix |
@@ -102,3 +124,5 @@ export $(cat .env | xargs) && uv run jupyter nbconvert --execute ...
 | Route availability | net_transfer_capacity | `NoDataError` for FR→DE_LU | Use FR→ES, FR→GB, FR→IT_NORTH |
 | Value tag name | imbalance_prices | All values are `None` | Parse `imbalance_Price.amount` tag |
 | Env vars in notebooks | all (via nbconvert) | `ValueError: API key required` | Export env vars before execution |
+| Mixed auctions | prices.day_ahead | Duplicate timestamps (DE_LU, AT, ES) | Filter by contract type and sequence |
+| A03 omitted points | all | Missing intervals | Forward-fill to Period end |

{python_entsoe-0.6.1 → python_entsoe-0.6.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-entsoe"
-version = "0.6.1"
+version = "0.6.3"
 description = "Python client for the ENTSO-E Transparency Platform API"
 readme = "README.md"
 license = "MIT"
@@ -32,10 +32,10 @@ dependencies = [
 entsoe = "entsoe.cli:app"
 
 [project.urls]
-Homepage = "https://github.com/datons/python-entsoe"
-Repository = "https://github.com/datons/python-entsoe"
-Issues = "https://github.com/datons/python-entsoe/issues"
-Changelog = "https://github.com/datons/python-entsoe/releases"
+Homepage = "https://gitlab.com/datons.com/libraries/python-entsoe"
+Repository = "https://gitlab.com/datons.com/libraries/python-entsoe"
+Issues = "https://gitlab.com/datons.com/libraries/python-entsoe/-/issues"
+Changelog = "https://gitlab.com/datons.com/libraries/python-entsoe/-/releases"
 
 [build-system]
 requires = ["hatchling"]

{python_entsoe-0.6.1 → python_entsoe-0.6.3}/src/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

{python_entsoe-0.6.1 → python_entsoe-0.6.3}/src/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": {}}
 

{python_entsoe-0.6.1 → python_entsoe-0.6.3}/src/entsoe/cli/_resolve.py

@@ -100,11 +100,11 @@ def _expand_period(period: str, today: date) -> tuple[date, date]:
 
     p = period.lower().strip()
 
+    # The library's end is exclusive, so a single day ends on the next one.
     if p == "today":
-        return today, today
+        return today, today + timedelta(days=1)
     if p == "yesterday":
-        yesterday = today - timedelta(days=1)
-        return yesterday, yesterday
+        return today - timedelta(days=1), today
     if p == "week":
         monday = today - timedelta(days=today.weekday())
         return monday, today

{python_entsoe-0.6.1 → python_entsoe-0.6.3}/src/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)
 
 

{python_entsoe-0.6.1 → python_entsoe-0.6.3}/src/entsoe/namespaces/_base.py

@@ -3,14 +3,16 @@
 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
 
-from ..exceptions import InvalidParameterError, NoDataError
+from ..exceptions import InvalidParameterError
 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)
@@ -223,17 +232,14 @@ class BaseNamespace:
         )
         new_wide_frames = []
         gap_meta: dict = {}
+        # A failed request propagates: returning the cache without the gap
+        # would silently hand back partial or empty data.
         for gap in valid_gaps:
-            try:
-                raw_df = self._query(params, gap.start, gap.end)
-                wide, meta = self._to_wide(raw_df, pivot_col, value_col)
-                new_wide_frames.append(wide)
-                if meta:
-                    gap_meta.update(meta)
-            except (InvalidParameterError, NoDataError):
-                raise
-            except Exception as exc:
-                logger.warning("Failed to fetch gap %s→%s: %s", gap.start, gap.end, exc)
+            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:
+                gap_meta.update(meta)
 
         # 4. Merge new data with cache and persist
         if new_wide_frames:
@@ -279,27 +285,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)

{python_entsoe-0.6.1 → python_entsoe-0.6.3}/src/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.3/tests/test_cache_layout.py

@@ -0,0 +1,23 @@
+"""Offline tests for cache layout versioning."""
+
+from entsoe.cache import CACHE_LAYOUT_VERSION, CacheConfig, CacheStore
+
+
+def test_outdated_layouts_are_purged(tmp_path):
+    legacy = tmp_path / "prices" / "day_ahead" / "DE_LU"
+    legacy.mkdir(parents=True)
+    (legacy / "data.parquet").write_bytes(b"stale")
+    old_version = tmp_path / "v1" / "load"
+    old_version.mkdir(parents=True)
+    current = tmp_path / f"v{CACHE_LAYOUT_VERSION}" / "prices"
+    current.mkdir(parents=True)
+    unrelated = tmp_path / "notes.txt"
+    unrelated.write_text("keep")
+
+    store = CacheStore(CacheConfig(cache_dir=tmp_path))
+
+    assert not (tmp_path / "prices").exists()
+    assert not (tmp_path / "v1").exists()
+    assert current.exists()
+    assert unrelated.exists()
+    assert store.root == tmp_path / f"v{CACHE_LAYOUT_VERSION}"

python_entsoe-0.6.3/tests/test_cli_periods.py

@@ -0,0 +1,15 @@
+"""Offline tests for CLI period shorthands."""
+
+from datetime import date
+
+from entsoe.cli._resolve import _expand_period
+
+TODAY = date(2026, 10, 15)
+
+
+def test_today_is_one_full_day():
+    assert _expand_period("today", TODAY) == (date(2026, 10, 15), date(2026, 10, 16))
+
+
+def test_yesterday_is_one_full_day():
+    assert _expand_period("yesterday", TODAY) == (date(2026, 10, 14), date(2026, 10, 15))

python_entsoe-0.6.3/tests/test_xml_day_ahead.py

@@ -0,0 +1,113 @@
+"""Offline tests for day-ahead parsing: auction selection, A03 gaps, duplicates."""
+
+import pandas as pd
+import pytest
+
+from entsoe._xml import parse_timeseries
+from entsoe.namespaces.prices import PricesNamespace
+
+NS = "urn:iec62325.351:tc57wg16:451-3:publicationdocument:7:3"
+
+
+def _series(mrid, prices, *, contract="A01", sequence=None, start="2026-10-12T22:00Z",
+            end="2026-10-12T23:00Z"):
+    seq = (
+        "<classificationSequence_AttributeInstanceComponent.position>"
+        f"{sequence}</classificationSequence_AttributeInstanceComponent.position>"
+        if sequence is not None else ""
+    )
+    points = "".join(
+        f"<Point><position>{pos}</position><price.amount>{val}</price.amount></Point>"
+        for pos, val in prices.items()
+    )
+    return (
+        f"<TimeSeries><mRID>{mrid}</mRID><auction.type>A01</auction.type>"
+        f"<contract_MarketAgreement.type>{contract}</contract_MarketAgreement.type>"
+        "<currency_Unit.name>EUR</currency_Unit.name>"
+        f"<price_Measure_Unit.name>MWH</price_Measure_Unit.name>{seq}"
+        "<curveType>A03</curveType>"
+        f"<Period><timeInterval><start>{start}</start><end>{end}</end></timeInterval>"
+        f"<resolution>PT15M</resolution>{points}</Period></TimeSeries>"
+    )
+
+
+def _doc(*series):
+    return f'<Publication_MarketDocument xmlns="{NS}">{"".join(series)}</Publication_MarketDocument>'
+
+
+class _FakeHttp:
+    def __init__(self, xml):
+        self.xml = xml
+
+    def query(self, params, start, end):
+        return self.xml
+
+
+def _day_ahead(xml, **kwargs):
+    ns = PricesNamespace(_FakeHttp(xml), cache=None)
+    return ns.day_ahead("2026-10-13", "2026-10-14", country="DE_LU", **kwargs)
+
+
+# Shaped like the live DE_LU response: EXAA (sequence 2) listed before SDAC (1).
+DE_LU = _doc(
+    _series(1, {1: 189.61, 2: 180.0, 3: 175.0, 4: 170.0}, sequence=2),
+    _series(2, {1: 191.89, 2: 185.0, 3: 178.0, 4: 172.0}, sequence=1),
+)
+
+# Shaped like the live ES response: unsequenced SDAC plus IDA intraday auctions.
+ES = _doc(
+    _series(1, {1: 220.0, 2: 210.0, 3: 205.0, 4: 200.0}),
+    _series(2, {1: 220.49, 2: 211.0, 3: 206.0, 4: 201.0}, contract="A07", sequence=1),
+    _series(3, {1: 219.0, 2: 209.0, 3: 204.0, 4: 199.0}, contract="A07", sequence=2),
+)
+
+
+def test_de_lu_defaults_to_sdac():
+    df = _day_ahead(DE_LU)
+    assert df["timestamp"].is_unique
+    assert df["value"].tolist() == [191.89, 185.0, 178.0, 172.0]
+
+
+def test_de_lu_sequence_2_is_exaa():
+    df = _day_ahead(DE_LU, sequence=2)
+    assert df["value"].tolist() == [189.61, 180.0, 175.0, 170.0]
+
+
+def test_spain_drops_intraday_auctions():
+    df = _day_ahead(ES)
+    assert df["value"].tolist() == [220.0, 210.0, 205.0, 200.0]
+
+
+def test_a03_omitted_point_repeats_previous_value():
+    # Position 3 omitted: it carries position 2's value. Trailing slot 4 too.
+    df = parse_timeseries(_doc(_series(1, {1: 10.0, 2: 20.0})))
+    assert len(df) == 4
+    assert df["value"].tolist() == [10.0, 20.0, 20.0, 20.0]
+    assert df["timestamp"].iloc[-1] == pd.Timestamp("2026-10-12T22:45Z")
+
+
+def test_verbatim_duplicate_series_dropped():
+    s = {1: 1.0, 2: 2.0, 3: 3.0, 4: 4.0}
+    df = parse_timeseries(_doc(_series(1, s), _series(1, s)))
+    assert len(df) == 4
+
+
+def test_unknown_sequence_raises_no_data():
+    from entsoe.exceptions import NoDataError
+
+    with pytest.raises(NoDataError):
+        _day_ahead(ES, sequence=2)
+
+
+def test_cached_query_raises_on_network_error(tmp_path):
+    import requests
+
+    from entsoe.cache import CacheConfig, CacheStore
+
+    class _DownHttp:
+        def query(self, params, start, end):
+            raise requests.exceptions.ConnectTimeout("down")
+
+    ns = PricesNamespace(_DownHttp(), cache=CacheStore(CacheConfig(cache_dir=tmp_path)))
+    with pytest.raises(requests.exceptions.ConnectTimeout):
+        ns.day_ahead("2026-10-13", "2026-10-14", country="DE_LU")

{python_entsoe-0.6.1 → python_entsoe-0.6.3}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 2
+revision = 3
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.14' and sys_platform == 'win32'",
@@ -1705,7 +1705,7 @@ wheels = [
 
 [[package]]
 name = "python-entsoe"
-version = "0.4.1"
+version = "0.6.3"
 source = { editable = "." }
 dependencies = [
     { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },

python_entsoe-0.6.1/.github/workflows/publish.yml

@@ -1,42 +0,0 @@
-name: Release Please
-
-on:
-  push:
-    branches: [main]
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  release-please:
-    runs-on: ubuntu-latest
-    outputs:
-      release_created: ${{ steps.release.outputs.release_created }}
-    steps:
-      - uses: googleapis/release-please-action@v4
-        id: release
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-  publish:
-    needs: release-please
-    if: needs.release-please.outputs.release_created == 'true'
-    runs-on: ubuntu-latest
-    permissions:
-      id-token: write
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-
-      - name: Install build tools
-        run: pip install build
-
-      - name: Build package
-        run: python -m build
-
-      - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1

python_entsoe-0.6.1/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.6.1"
-}

python_entsoe-0.6.1/release-please-config.json

@@ -1,19 +0,0 @@
-{
-  "packages": {
-    ".": {
-      "release-type": "python",
-      "package-name": "python-entsoe",
-      "extra-files": [
-        "pyproject.toml"
-      ],
-      "changelog-sections": [
-        { "type": "feat", "section": "Features" },
-        { "type": "fix", "section": "Bug Fixes" },
-        { "type": "perf", "section": "Performance" },
-        { "type": "docs", "section": "Documentation", "hidden": true },
-        { "type": "chore", "section": "Miscellaneous", "hidden": true }
-      ]
-    }
-  },
-  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json"
-}