dlpwait 1.0.0__tar.gz

dlpwait-1.0.0/.github/workflows/linting.yml

@@ -0,0 +1,49 @@
+name: Linting
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e .
+          pip install ruff
+
+      - name: Run ruff
+        run: ruff check src
+
+  pylint:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e .
+          pip install pylint
+
+      - name: Run pylint
+        run: pylint src

dlpwait-1.0.0/.github/workflows/publish.yml

@@ -0,0 +1,32 @@
+name: Publish Python package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  build-and-publish:
+    name: Build and publish package
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build distribution
+        run: python -m build
+
+      - name: Publish to PyPI via Trusted Publisher
+        uses: pypa/gh-action-pypi-publish@release/v1

dlpwait-1.0.0/.github/workflows/tests.yml

@@ -0,0 +1,39 @@
+name: Tests
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+jobs:
+  pytest:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e .
+          pip install pytest pytest-asyncio pytest-cov aioresponses
+
+      - name: Run tests with coverage
+        run: |
+          pytest
+
+      - name: Upload coverage artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-${{ matrix.python-version }}
+          path: coverage.xml

dlpwait-1.0.0/.github/workflows/typing.yml

@@ -0,0 +1,28 @@
+name: Typing
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+jobs:
+  mypy:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e .
+          pip install mypy
+
+      - name: Run mypy
+        run: mypy src/dlpwait

dlpwait-1.0.0/.gitignore

@@ -0,0 +1,13 @@
+# PhpStorm
+.idea
+
+# General files
+*~
+*.DS_STORE
+
+# python
+.venv
+
+# pytest
+.coverage
+coverage.xml

dlpwait-1.0.0/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Glenn de Haan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dlpwait-1.0.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: dlpwait
+Version: 1.0.0
+Summary: Asynchronous Python client for Disneyland Paris park data
+Project-URL: Homepage, https://github.com/glenndehaan/python-dlpwait
+Project-URL: Issues, https://github.com/glenndehaan/python-dlpwait/issues
+Author-email: Glenn de Haan <glenn@dehaan.cloud>
+License: MIT
+License-File: LICENCE
+Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.0.0
+Description-Content-Type: text/markdown
+
+# DLPWait API Client
+
+An **asynchronous Python client** for fetching real-time **Disneyland Paris park and attraction data** via the DLPWait API.
+This lightweight library provides methods for retrieving park hours, attractions, and standby wait times.
+
+## Features
+
+* Asynchronous communication using `aiohttp`
+* Fetch park hours and operating schedules
+* Fetch attractions
+* Get real-time standby wait times
+* Built-in error handling for connection and parsing failures
+* Designed for easy integration into automation tools or async workflows
+
+## Requirements
+
+* Python **3.11+**
+* `aiohttp` library
+
+## Usage Example
+
+```python
+import asyncio
+from dlpwait import DLPWaitAPI, DLPWaitConnectionError, Parks
+
+async def main():
+    client = DLPWaitAPI()
+
+    try:
+        await client.update()  # Fetch all park data
+
+        for park in Parks:
+            park_data = client.parks[Parks(park)]
+            print(f"{park_data.slug} is open from {park_data.opening_time} to {park_data.closing_time}")
+            print("Attractions:")
+            for attraction_id, name in park_data.attractions.items():
+                wait_time = park_data.standby_wait_times.get(attraction_id, "N/A")
+                print(f"  {name}: {wait_time} min")
+
+    except DLPWaitConnectionError as err:
+        print(f"Error fetching park data: {err}")
+
+    finally:
+        await client.close()
+
+asyncio.run(main())
+```
+
+## API Reference
+
+### Class: `DLPWaitAPI`
+
+#### Initialization
+
+```python
+DLPWaitAPI(session: aiohttp.ClientSession | None = None)
+```
+
+* **session** *(optional)* – existing `aiohttp.ClientSession` to reuse.
+
+#### Fetch & Update Methods
+
+| Method     | Description                              |
+|------------|------------------------------------------|
+| `update()` | Fetch and parse all park data            |
+| `close()`  | Close the HTTP session to free resources |
+
+### Models
+
+#### `Parks` Enum
+
+| Member                | Description              |
+|-----------------------|--------------------------|
+| `DISNEYLAND`          | Disneyland Park          |
+| `WALT_DISNEY_STUDIOS` | Walt Disney Studios Park |
+
+#### `Park` Dataclass
+
+| Field                | Type             | Description                                   |
+|----------------------|------------------|-----------------------------------------------|
+| `slug`               | `Parks`          | Park identifier                               |
+| `opening_time`       | `datetime`       | Park opening time                             |
+| `closing_time`       | `datetime`       | Park closing time                             |
+| `attractions`        | `dict[str, str]` | Attraction IDs mapped to names                |
+| `standby_wait_times` | `dict[str, int]` | Attraction IDs mapped to wait times (minutes) |
+
+## Exception Handling
+
+All exceptions inherit from `DLPWaitError`.
+
+| Exception                | Description                                         |
+|--------------------------|-----------------------------------------------------|
+| `DLPWaitError`           | Base exception for DLPWait client                   |
+| `DLPWaitConnectionError` | Connection-related errors (timeouts, bad responses) |
+
+## License
+
+MIT

dlpwait-1.0.0/README.md

@@ -0,0 +1,98 @@
+# DLPWait API Client
+
+An **asynchronous Python client** for fetching real-time **Disneyland Paris park and attraction data** via the DLPWait API.
+This lightweight library provides methods for retrieving park hours, attractions, and standby wait times.
+
+## Features
+
+* Asynchronous communication using `aiohttp`
+* Fetch park hours and operating schedules
+* Fetch attractions
+* Get real-time standby wait times
+* Built-in error handling for connection and parsing failures
+* Designed for easy integration into automation tools or async workflows
+
+## Requirements
+
+* Python **3.11+**
+* `aiohttp` library
+
+## Usage Example
+
+```python
+import asyncio
+from dlpwait import DLPWaitAPI, DLPWaitConnectionError, Parks
+
+async def main():
+    client = DLPWaitAPI()
+
+    try:
+        await client.update()  # Fetch all park data
+
+        for park in Parks:
+            park_data = client.parks[Parks(park)]
+            print(f"{park_data.slug} is open from {park_data.opening_time} to {park_data.closing_time}")
+            print("Attractions:")
+            for attraction_id, name in park_data.attractions.items():
+                wait_time = park_data.standby_wait_times.get(attraction_id, "N/A")
+                print(f"  {name}: {wait_time} min")
+
+    except DLPWaitConnectionError as err:
+        print(f"Error fetching park data: {err}")
+
+    finally:
+        await client.close()
+
+asyncio.run(main())
+```
+
+## API Reference
+
+### Class: `DLPWaitAPI`
+
+#### Initialization
+
+```python
+DLPWaitAPI(session: aiohttp.ClientSession | None = None)
+```
+
+* **session** *(optional)* – existing `aiohttp.ClientSession` to reuse.
+
+#### Fetch & Update Methods
+
+| Method     | Description                              |
+|------------|------------------------------------------|
+| `update()` | Fetch and parse all park data            |
+| `close()`  | Close the HTTP session to free resources |
+
+### Models
+
+#### `Parks` Enum
+
+| Member                | Description              |
+|-----------------------|--------------------------|
+| `DISNEYLAND`          | Disneyland Park          |
+| `WALT_DISNEY_STUDIOS` | Walt Disney Studios Park |
+
+#### `Park` Dataclass
+
+| Field                | Type             | Description                                   |
+|----------------------|------------------|-----------------------------------------------|
+| `slug`               | `Parks`          | Park identifier                               |
+| `opening_time`       | `datetime`       | Park opening time                             |
+| `closing_time`       | `datetime`       | Park closing time                             |
+| `attractions`        | `dict[str, str]` | Attraction IDs mapped to names                |
+| `standby_wait_times` | `dict[str, int]` | Attraction IDs mapped to wait times (minutes) |
+
+## Exception Handling
+
+All exceptions inherit from `DLPWaitError`.
+
+| Exception                | Description                                         |
+|--------------------------|-----------------------------------------------------|
+| `DLPWaitError`           | Base exception for DLPWait client                   |
+| `DLPWaitConnectionError` | Connection-related errors (timeouts, bad responses) |
+
+## License
+
+MIT

dlpwait-1.0.0/pyproject.toml

@@ -0,0 +1,70 @@
+[project]
+name = "dlpwait"
+version = "1.0.0"
+description = "Asynchronous Python client for Disneyland Paris park data"
+authors = [
+    { name = "Glenn de Haan", email = "glenn@dehaan.cloud" }
+]
+license = { text = "MIT" }
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "aiohttp>=3.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/glenndehaan/python-dlpwait"
+Issues = "https://github.com/glenndehaan/python-dlpwait/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dlpwait"]
+
+[tool.hatch.build.targets.wheel.package-data]
+dlpwait = ["py.typed"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+addopts = [
+    "--strict-markers",
+    "--cov=dlpwait",
+    "--cov-report=term-missing",
+    "--cov-report=xml",
+]
+
+[tool.ruff]
+line-length = 120
+exclude = ["build", ".venv"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]
+extend-select = ["B", "D"]
+ignore = [
+    "D203",  # incompatible with D211
+    "D213",  # incompatible with D212
+]
+extend-ignore = []
+
+[tool.pylint."BASIC"]
+good-names = ["JSON"]
+
+[tool.pylint."MESSAGES CONTROL"]
+disable = [
+    "redefined-builtin",
+    "too-many-public-methods",
+]
+
+[tool.mypy]
+python_version = 3.11
+files = "src,dlpwait"
+ignore_missing_imports = true
+strict = true
+disallow_untyped_defs = true
+warn_unused_ignores = true
+warn_return_any = true
+pretty = true
+show_error_codes = true

dlpwait-1.0.0/src/dlpwait/__init__.py

@@ -0,0 +1,13 @@
+"""DLPWait Client."""
+
+from .api import DLPWaitAPI
+from .exceptions import DLPWaitConnectionError, DLPWaitError
+from .models import Park, Parks
+
+__all__ = [
+    "DLPWaitAPI",
+    "DLPWaitConnectionError",
+    "DLPWaitError",
+    "Park",
+    "Parks",
+]

dlpwait-1.0.0/src/dlpwait/api.py

@@ -0,0 +1,184 @@
+"""DLPWait Client API."""
+
+from asyncio import TimeoutError
+from datetime import datetime
+from typing import Any, TypeAlias
+from zoneinfo import ZoneInfo
+
+import aiohttp
+from aiohttp import ClientError, ClientResponseError, ClientTimeout
+
+from .exceptions import DLPWaitConnectionError
+from .models import Park, Parks
+
+JSON: TypeAlias = dict[str, Any]
+
+GRAPHQL_QUERY = """
+query {
+  parks {
+    slug
+    schedules {
+      status
+      startTime
+      endTime
+      date
+    }
+  }
+  attractions {
+    id
+    active
+    hide
+    status
+    name
+    park {
+      slug
+    }
+    waitTime {
+      standby {
+        minutes
+      }
+    }
+  }
+}
+"""
+
+
+class DLPWaitAPI:
+    """Asynchronous API client for DLPWait."""
+
+    def __init__(self, session: aiohttp.ClientSession | None = None) -> None:
+        """DLPWait API Client."""
+        self._session: aiohttp.ClientSession = session or aiohttp.ClientSession()
+
+        self.parks: dict[Parks, Park] = {}
+
+    async def _request(self) -> JSON:
+        """Handle a request to the DLPWait api."""
+        try:
+            async with self._session.post(
+                    "https://api.dlpwait.com",
+                    json={"query": GRAPHQL_QUERY},
+                    timeout=ClientTimeout(total=10)
+            ) as response:
+                if response.status != 200:
+                    raise DLPWaitConnectionError(
+                        f"Unexpected response (Status: {response.status})"
+                    )
+
+                payload: JSON = await response.json()
+                data = payload.get("data")
+                if not isinstance(data, dict):
+                    raise DLPWaitConnectionError("Invalid API response")
+
+                return data
+        except TimeoutError as err:
+            raise DLPWaitConnectionError("Timeout while fetching") from err
+        except (ClientError, ClientResponseError) as err:
+            raise DLPWaitConnectionError(f"Request failed: {err}") from err
+        except Exception as err:
+            raise DLPWaitConnectionError(f"Unexpected error: {err}") from err
+
+    @staticmethod
+    def _parse_park_hours(parks: list[JSON]) -> dict[Parks, tuple[datetime, datetime]]:
+        """Return park hours from the API data."""
+        result: dict[Parks, tuple[datetime, datetime]] = {}
+
+        for park in parks:
+            try:
+                slug = Parks(park["slug"])
+            except ValueError:
+                continue
+
+            for schedule in park["schedules"]:
+                if schedule["status"] == "OPERATING":
+                    result[slug] = (datetime.strptime(
+                        f"{schedule['date']} {schedule['startTime']}",
+                        "%Y-%m-%d %H:%M:%S"
+                    ).replace(tzinfo=ZoneInfo("Europe/Paris")), datetime.strptime(
+                        f"{schedule['date']} {schedule['endTime']}",
+                        "%Y-%m-%d %H:%M:%S"
+                    ).replace(tzinfo=ZoneInfo("Europe/Paris")))
+
+        return result
+
+    @staticmethod
+    def _parse_attractions(attractions: list[JSON]) -> dict[Parks, dict[str, str]]:
+        """Return park attractions from the API data."""
+        result: dict[Parks, dict[str, str]] = {}
+
+        for attraction in attractions:
+            if not attraction["active"]:
+                continue
+
+            if attraction["hide"]:
+                continue
+
+            if attraction["status"] != "OPERATING":
+                continue
+
+            try:
+                slug = Parks(attraction["park"]["slug"])
+            except ValueError:
+                continue
+
+            result.setdefault(slug, {})
+            result[slug][attraction["id"]] = attraction["name"]
+
+        return result
+
+    @staticmethod
+    def _parse_standby_wait_times(attractions: list[JSON]) -> dict[Parks, dict[str, int]]:
+        """Return park wait times from the API data."""
+        result: dict[Parks, dict[str, int]] = {}
+
+        for attraction in attractions:
+            if not attraction["active"]:
+                continue
+
+            if attraction["hide"]:
+                continue
+
+            if attraction["status"] != "OPERATING":
+                continue
+
+            try:
+                slug = Parks(attraction["park"]["slug"])
+            except ValueError:
+                continue
+
+            standby = attraction.get("waitTime", {}).get("standby")
+            if not standby:
+                continue
+
+            minutes = standby.get("minutes")
+            if minutes is None:
+                continue
+
+            result.setdefault(slug, {})
+            result[slug][attraction["id"]] = minutes
+
+        return result
+
+    async def update(self) -> None:
+        """Fetch and parse all park data."""
+        data = await self._request()
+
+        park_hours = self._parse_park_hours(data["parks"])
+        attractions = self._parse_attractions(data["attractions"])
+        standby_wait_times = self._parse_standby_wait_times(data["attractions"])
+
+        self.parks = {}
+
+        for park in Parks:
+            self.parks[park] = Park(
+                slug=Parks(park),
+                opening_time=park_hours[Parks(park)][0],
+                closing_time=park_hours[Parks(park)][1],
+                attractions=attractions[Parks(park)],
+                standby_wait_times=standby_wait_times[Parks(park)],
+            )
+
+    async def close(self) -> None:
+        """Close open client session."""
+        if self._session:
+            await self._session.close()

dlpwait-1.0.0/src/dlpwait/exceptions.py

@@ -0,0 +1,8 @@
+"""DLPWait Client Exceptions."""
+
+class DLPWaitError(Exception):
+    """Base exception for DLPWait client."""
+
+
+class DLPWaitConnectionError(DLPWaitError):
+    """DLPWait connection exception."""

dlpwait-1.0.0/src/dlpwait/models.py

@@ -0,0 +1,23 @@
+"""DLPWait Models."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from enum import StrEnum
+
+
+class Parks(StrEnum):
+    """Parks available within the API."""
+
+    DISNEYLAND = "disneyland-park"
+    WALT_DISNEY_STUDIOS = "walt-disney-studios-park"
+
+
+@dataclass(kw_only=True, frozen=True)
+class Park:
+    """Park data returned from the API."""
+
+    slug: Parks
+    opening_time: datetime
+    closing_time: datetime
+    attractions: dict[str, str]
+    standby_wait_times: dict[str, int]

dlpwait-1.0.0/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for the DLPWait library."""

dlpwait-1.0.0/tests/test_api.py

@@ -0,0 +1,472 @@
+"""Tests for the DLPWait api."""
+
+import asyncio
+from datetime import datetime
+from unittest.mock import AsyncMock, MagicMock
+from zoneinfo import ZoneInfo
+
+import pytest
+from aiohttp import ClientError
+
+from dlpwait.api import DLPWaitAPI
+from dlpwait.exceptions import DLPWaitConnectionError
+from dlpwait.models import Park, Parks
+
+tz = ZoneInfo("Europe/Paris")
+
+# -------------------------
+# Helpers
+# -------------------------
+
+class MockResponse:
+    """Mock aiohttp response object supporting async context management."""
+
+    def __init__(self, status=200, payload=None, json_side_effect=None):
+        """Initialize the mock response."""
+        self.status = status
+        self._payload = payload or {}
+        self._json_side_effect = json_side_effect
+
+    async def json(self):
+        """Return JSON payload or raise configured exception."""
+        if self._json_side_effect:
+            raise self._json_side_effect
+        return self._payload
+
+    async def __aenter__(self):
+        """Enter async context manager."""
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        """Exit async context manager."""
+        pass
+
+
+def make_session(response: MockResponse = None, side_effect=None):
+    """Create a mocked aiohttp session with configurable behavior."""
+    session = MagicMock()
+    if side_effect:
+        session.post.side_effect = side_effect
+    else:
+        session.post.return_value = response
+    return session
+
+
+# -------------------------
+# _request tests
+# -------------------------
+
+@pytest.mark.asyncio
+async def test_request_success():
+    """Ensure _request returns parsed data on successful response."""
+    payload = {"data": {"parks": [], "attractions": []}}
+    response = MockResponse(status=200, payload=payload)
+    session = make_session(response=response)
+
+    api = DLPWaitAPI(session=session)
+    result = await api._request()
+
+    assert result == payload["data"]
+
+
+@pytest.mark.asyncio
+async def test_request_non_200_status():
+    """Ensure _request raises on non-200 HTTP status."""
+    response = MockResponse(status=500)
+    session = make_session(response=response)
+
+    api = DLPWaitAPI(session=session)
+
+    with pytest.raises(DLPWaitConnectionError, match="Unexpected response"):
+        await api._request()
+
+
+@pytest.mark.asyncio
+async def test_request_invalid_payload():
+    """Ensure _request raises when API payload format is invalid."""
+    payload = {"data": "invalid"}
+    response = MockResponse(status=200, payload=payload)
+    session = make_session(response=response)
+
+    api = DLPWaitAPI(session=session)
+
+    with pytest.raises(DLPWaitConnectionError, match="Invalid API response"):
+        await api._request()
+
+
+@pytest.mark.asyncio
+async def test_request_timeout():
+    """Ensure _request raises connection error on timeout."""
+    session = make_session(side_effect=asyncio.TimeoutError())
+
+    api = DLPWaitAPI(session=session)
+
+    with pytest.raises(DLPWaitConnectionError, match="Timeout"):
+        await api._request()
+
+
+@pytest.mark.asyncio
+async def test_request_client_error():
+    """Ensure _request raises connection error on aiohttp client error."""
+    session = make_session(side_effect=ClientError("boom"))
+
+    api = DLPWaitAPI(session=session)
+
+    with pytest.raises(DLPWaitConnectionError, match="Request failed"):
+        await api._request()
+
+
+# -------------------------
+# Static parsing methods
+# -------------------------
+
+def test_parse_park_hours():
+    """Ensure park hours are parsed correctly and invalid parks are ignored."""
+    parks = [
+        {
+            "slug": "disneyland-park",
+            "schedules": [
+                {
+                    "status": "OPERATING",
+                    "startTime": "09:00:00",
+                    "endTime": "22:00:00",
+                    "date": "2026-01-01"
+                }
+            ],
+        },
+        {
+            "slug": "invalid-park",
+            "schedules": [
+                {
+                    "status": "OPERATING",
+                    "startTime": "09:00:00",
+                    "endTime": "22:00:00",
+                    "date": "2026-01-01"
+                }
+            ],
+        },
+    ]
+
+    result = DLPWaitAPI._parse_park_hours(parks)
+
+    assert result == {
+        Parks.DISNEYLAND: (
+            datetime(2026, 1, 1, 9, 0, tzinfo=tz),
+            datetime(2026, 1, 1, 22, 0, tzinfo=tz),
+        )
+    }
+
+
+def test_parse_attractions_filters_correctly():
+    """Ensure attractions are filtered by active, visible, and operating status."""
+    attractions = [
+        {
+            "id": "1",
+            "name": "Big Thunder Mountain",
+            "active": True,
+            "hide": False,
+            "status": "OPERATING",
+            "park": {"slug": "disneyland-park"},
+        },
+        {
+            "id": "2",
+            "name": "Hidden Ride",
+            "active": True,
+            "hide": True,
+            "status": "OPERATING",
+            "park": {"slug": "disneyland-park"},
+        },
+    ]
+
+    result = DLPWaitAPI._parse_attractions(attractions)
+
+    assert result == {
+        Parks.DISNEYLAND: {
+            "1": "Big Thunder Mountain"
+        }
+    }
+
+
+def test_parse_standby_wait_times_filters_correctly():
+    """Ensure standby wait times are parsed and filtered correctly."""
+    attractions = [
+        {
+            "id": "1",
+            "active": True,
+            "hide": False,
+            "status": "OPERATING",
+            "park": {"slug": "disneyland-park"},
+            "waitTime": {"standby": {"minutes": 35}},
+        },
+        {
+            "id": "2",
+            "active": True,
+            "hide": False,
+            "status": "OPERATING",
+            "park": {"slug": "disneyland-park"},
+            "waitTime": {"standby": None},
+        },
+    ]
+
+    result = DLPWaitAPI._parse_standby_wait_times(attractions)
+
+    assert result == {
+        Parks.DISNEYLAND: {
+            "1": 35
+        }
+    }
+
+
+# -------------------------
+# Additional branch coverage
+# -------------------------
+
+def test_parse_attractions_skips_non_operating():
+    """Ensure non-operating attractions are ignored."""
+    attractions = [
+        {
+            "id": "1",
+            "name": "Closed Ride",
+            "active": True,
+            "hide": False,
+            "status": "DOWN",
+            "park": {"slug": "disneyland-park"},
+        }
+    ]
+
+    result = DLPWaitAPI._parse_attractions(attractions)
+    assert result == {}
+
+
+def test_parse_attractions_skips_inactive():
+    """Ensure inactive attractions are ignored."""
+    attractions = [
+        {
+            "id": "1",
+            "name": "Inactive Ride",
+            "active": False,
+            "hide": False,
+            "status": "OPERATING",
+            "park": {"slug": "disneyland-park"},
+        }
+    ]
+
+    result = DLPWaitAPI._parse_attractions(attractions)
+    assert result == {}
+
+
+def test_parse_attractions_skips_invalid_slug():
+    """Ensure attractions with invalid park slugs are ignored."""
+    attractions = [
+        {
+            "id": "1",
+            "name": "Invalid Park Ride",
+            "active": True,
+            "hide": False,
+            "status": "OPERATING",
+            "park": {"slug": "not-a-real-park"},
+        }
+    ]
+
+    result = DLPWaitAPI._parse_attractions(attractions)
+    assert result == {}
+
+
+def test_parse_standby_wait_times_skips_inactive():
+    """Ensure inactive attractions are ignored in standby wait times."""
+    attractions = [
+        {
+            "id": "1",
+            "active": False,
+            "hide": False,
+            "status": "OPERATING",
+            "park": {"slug": "disneyland-park"},
+            "waitTime": {"standby": {"minutes": 10}},
+        }
+    ]
+
+    result = DLPWaitAPI._parse_standby_wait_times(attractions)
+    assert result == {}
+
+
+def test_parse_standby_wait_times_skips_hidden():
+    """Ensure hidden attractions are ignored in standby wait times."""
+    attractions = [
+        {
+            "id": "1",
+            "active": True,
+            "hide": True,
+            "status": "OPERATING",
+            "park": {"slug": "disneyland-park"},
+            "waitTime": {"standby": {"minutes": 10}},
+        }
+    ]
+
+    result = DLPWaitAPI._parse_standby_wait_times(attractions)
+    assert result == {}
+
+
+def test_parse_standby_wait_times_skips_non_operating():
+    """Ensure non-operating attractions are ignored in standby wait times."""
+    attractions = [
+        {
+            "id": "1",
+            "active": True,
+            "hide": False,
+            "status": "DOWN",
+            "park": {"slug": "disneyland-park"},
+            "waitTime": {"standby": {"minutes": 10}},
+        }
+    ]
+
+    result = DLPWaitAPI._parse_standby_wait_times(attractions)
+    assert result == {}
+
+
+def test_parse_standby_wait_times_skips_invalid_slug():
+    """Ensure attractions with invalid park slugs are ignored in standby wait times."""
+    attractions = [
+        {
+            "id": "1",
+            "active": True,
+            "hide": False,
+            "status": "OPERATING",
+            "park": {"slug": "invalid-park"},
+            "waitTime": {"standby": {"minutes": 10}},
+        }
+    ]
+
+    result = DLPWaitAPI._parse_standby_wait_times(attractions)
+    assert result == {}
+
+
+def test_parse_standby_wait_times_skips_missing_wait_time():
+    """Ensure attractions missing waitTime are ignored."""
+    attractions = [
+        {
+            "id": "1",
+            "active": True,
+            "hide": False,
+            "status": "OPERATING",
+            "park": {"slug": "disneyland-park"},
+        }
+    ]
+
+    result = DLPWaitAPI._parse_standby_wait_times(attractions)
+    assert result == {}
+
+
+def test_parse_standby_wait_times_skips_missing_standby():
+    """Ensure attractions missing standby data are ignored."""
+    attractions = [
+        {
+            "id": "1",
+            "active": True,
+            "hide": False,
+            "status": "OPERATING",
+            "park": {"slug": "disneyland-park"},
+            "waitTime": {},
+        }
+    ]
+
+    result = DLPWaitAPI._parse_standby_wait_times(attractions)
+    assert result == {}
+
+
+def test_parse_standby_wait_times_skips_none_minutes():
+    """Ensure attractions with None standby minutes are ignored."""
+    attractions = [
+        {
+            "id": "1",
+            "active": True,
+            "hide": False,
+            "status": "OPERATING",
+            "park": {"slug": "disneyland-park"},
+            "waitTime": {"standby": {"minutes": None}},
+        }
+    ]
+
+    result = DLPWaitAPI._parse_standby_wait_times(attractions)
+    assert result == {}
+
+
+# -------------------------
+# update() integration
+# -------------------------
+
+@pytest.mark.asyncio
+async def test_update_populates_parks():
+    """Ensure update() populates parks with hours and standby wait times."""
+    payload = {
+        "data": {
+            "parks": [
+                {
+                    "slug": "disneyland-park",
+                    "schedules": [
+                        {
+                            "status": "OPERATING",
+                            "startTime": "09:00:00",
+                            "endTime": "22:00:00",
+                            "date": "2026-01-01"
+                        }
+                    ],
+                },
+                {
+                    "slug": "walt-disney-studios-park",
+                    "schedules": [
+                        {
+                            "status": "OPERATING",
+                            "startTime": "09:30:00",
+                            "endTime": "21:00:00",
+                            "date": "2026-01-01"
+                        }
+                    ],
+                },
+            ],
+            "attractions": [
+                {
+                    "id": "1",
+                    "name": "Ride A",
+                    "active": True,
+                    "hide": False,
+                    "status": "OPERATING",
+                    "park": {"slug": "disneyland-park"},
+                    "waitTime": {"standby": {"minutes": 20}},
+                },
+                {
+                    "id": "2",
+                    "name": "Ride B",
+                    "active": True,
+                    "hide": False,
+                    "status": "OPERATING",
+                    "park": {"slug": "walt-disney-studios-park"},
+                    "waitTime": {"standby": {"minutes": 15}},
+                },
+            ],
+        }
+    }
+
+    response = MockResponse(status=200, payload=payload)
+    session = make_session(response=response)
+
+    api = DLPWaitAPI(session=session)
+    await api.update()
+
+    assert isinstance(api.parks[Parks.DISNEYLAND], Park)
+    assert api.parks[Parks.DISNEYLAND].opening_time == datetime(2026, 1, 1, 9, 0, tzinfo=tz)
+    assert api.parks[Parks.DISNEYLAND].standby_wait_times["1"] == 20
+
+    assert api.parks[Parks.WALT_DISNEY_STUDIOS].opening_time == datetime(2026, 1, 1, 9, 30, tzinfo=tz)
+    assert api.parks[Parks.WALT_DISNEY_STUDIOS].standby_wait_times["2"] == 15
+
+
+@pytest.mark.asyncio
+async def test_close_closes_session():
+    """Ensure close() properly closes the aiohttp session."""
+    session = MagicMock()
+    session.close = AsyncMock()
+
+    api = DLPWaitAPI(session=session)
+    await api.close()
+
+    session.close.assert_awaited_once()