themeparks 1.0.0__tar.gz → 2.0.0__tar.gz

themeparks-2.0.0/.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.venv/
+venv/
+dist/
+build/
+*.egg-info/
+.coverage
+htmlcov/
+site/

themeparks-2.0.0/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+## [2.0.0] - 2026-04-15
+First stable v2 release. Identical surface to `2.0.0a1` after a brief alpha
+soak; no code changes since `2.0.0a1`. Bumped `Development Status` classifier
+to `Production/Stable`.
+
+## [2.0.0a1] - 2026-04-15
+### Added
+- MkDocs Material documentation site with full API reference and a cookbook
+  (recipes for sorted wait times, 7-day schedules, geo-locations grouped by
+  entity type, every queue variant, and HTTP debugging).
+- Top-level exports for `current_wait_time`, `iter_queues`, `parse_api_datetime`.
+- Class-level docstrings on every public surface for readable API reference rendering.
+- README sections explaining every queue variant (STANDBY, PAID_RETURN_TIME,
+  BOARDING_GROUP, etc.) and how to enable the httpx logger for HTTP debugging.
+
+### Fixed
+- `walk()` now makes a single API call instead of one per descendant — the
+  `/children` endpoint already returns the entire subtree recursively. Walking
+  Walt Disney World dropped from ~250 requests to 1.
+- `get_entity_schedule_month` now zero-pads the month (`/schedule/2026/05`,
+  not `/schedule/2026/5`) per the API requirement.
+- `RetryConfig` field renamed `max_attempts` → `max_retries` to match its
+  actual semantics (N retries beyond the first attempt = N+1 total calls).
+- `APIError` now includes a server-body excerpt in the exception message;
+  `RateLimitError.__repr__` includes `retry_after`.
+- `destinations.find()` now performs the loose, case-insensitive substring
+  match it had always promised in its docstring (was exact equality).
+- Generated queue variant classes renamed (`STANDBY` → `StandbyQueue` etc.)
+  so users access `queue.STANDBY` instead of the awkward `queue.STANDBY_1`.
+- `eval-type-backport` is now a conditional dep on Python 3.9 so pydantic
+  can evaluate PEP 604 union syntax in the generated models.
+
+## [2.0.0a0] - 2026-04-14
+### Added
+- Full rewrite on pydantic v2 + httpx.
+- Sync `ThemeParks` and `AsyncThemeParks` clients with shared core.
+- Ergonomic `client.entity(id)` navigation, `walk()`, `schedule.range()`.
+- Typed pydantic models, correctly handling nullable queue fields (fixes #1, #2).
+- Default-on caching with per-endpoint TTLs and pluggable adapter.
+- 429 `Retry-After` handling.
+
+### Removed
+- Legacy `openapi_client` top-level import and generated surface. See MIGRATION.md.
+- `urllib3`-based transport.

themeparks-2.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ThemeParks.wiki contributors
+
+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.

themeparks-2.0.0/MIGRATION.md

@@ -0,0 +1,178 @@
+# Migrating from v1 to v2
+
+v2 is a full rewrite. The package name on PyPI is still `themeparks`, but the
+import surface has changed. This guide walks through the common patterns.
+
+If you are blocked on a migration detail not covered here, please open an
+issue: https://github.com/ThemeParks/ThemeParks_Python/issues
+
+## TL;DR
+
+- Replace `from openapi_client...` imports with `from themeparks import ThemeParks`.
+- Wrap usage in a `with ThemeParks() as tp:` block (or use `AsyncThemeParks`).
+- Access response fields as attributes on pydantic models, not dict keys.
+- `openapi_client.ApiException` is now `themeparks.APIError` (with typed subclasses).
+- Null `waitTime` and other queue fields no longer raise — the fields are
+  `Optional` and deserialize correctly.
+
+## Imports and client setup
+
+### v1
+
+```python
+from openapi_client import ApiClient, Configuration
+from openapi_client.api.destinations_api import DestinationsApi
+from openapi_client.api.entity_api import EntityApi
+
+configuration = Configuration(host="https://api.themeparks.wiki/v1")
+api_client = ApiClient(configuration)
+destinations_api = DestinationsApi(api_client)
+entity_api = EntityApi(api_client)
+```
+
+### v2
+
+```python
+from themeparks import ThemeParks
+
+with ThemeParks() as tp:
+    ...  # tp.destinations, tp.entity(...), tp.raw.*
+```
+
+One client, one context manager, both sync and async variants.
+
+## Listing destinations
+
+### v1
+
+```python
+response = destinations_api.get_destinations()
+for d in response["destinations"]:
+    print(d["id"], d["name"])
+```
+
+### v2
+
+```python
+# Ergonomic
+resp = tp.destinations.list()
+for d in resp.destinations or []:
+    print(d.id, d.name)
+
+# Or raw (same return type)
+resp = tp.raw.get_destinations()
+```
+
+Note the switch from `response["destinations"]` to attribute access
+(`resp.destinations`). All response types are pydantic models.
+
+## Fetching an entity
+
+### v1
+
+```python
+entity = entity_api.get_entity(entity_id)
+print(entity["name"], entity["entityType"])
+```
+
+### v2
+
+```python
+entity = tp.entity(entity_id).get()         # ergonomic
+entity = tp.raw.get_entity(entity_id)       # raw
+print(entity.name, entity.entityType)
+```
+
+## Live wait times (the main v1 bug)
+
+In v1, calling `get_entity_live_data` on a park where any queue had a null
+`waitTime` raised `ApiTypeError` (see issues #1 and #2). The typical workaround
+was patching the generated models or catching and ignoring the error. In v2
+this Just Works — `waitTime` is `Optional[float]` and null values deserialize
+to `None`:
+
+### v1 (broken)
+
+```python
+try:
+    live = entity_api.get_live_data(park_id)
+except openapi_client.exceptions.ApiTypeError:
+    # fall back to raw urllib3, re-parse by hand, etc.
+    ...
+```
+
+### v2 (works)
+
+```python
+live = tp.entity(park_id).live()
+for item in live.liveData or []:
+    standby = item.queue.STANDBY if item.queue else None
+    wait = standby.waitTime if standby else None
+    if wait is None:
+        print(f"{item.name}: closed / no data")
+    else:
+        print(f"{item.name}: {int(wait)} min")
+```
+
+No workaround needed.
+
+## Error handling
+
+### v1
+
+```python
+from openapi_client.exceptions import ApiException
+
+try:
+    entity_api.get_entity(entity_id)
+except ApiException as exc:
+    print(exc.status, exc.body)
+```
+
+### v2
+
+```python
+from themeparks import APIError, RateLimitError, NetworkError, TimeoutError
+
+try:
+    tp.entity(entity_id).get()
+except RateLimitError as exc:
+    # 429: exc.retry_after is seconds (from Retry-After header), if present
+    ...
+except APIError as exc:
+    # any non-2xx
+    print(exc.status, exc.url, exc.body)
+except (NetworkError, TimeoutError):
+    ...
+```
+
+`APIError`, `RateLimitError`, `NetworkError`, and `TimeoutError` all inherit
+from `ThemeParksError` if you want a single catch-all.
+
+## Async
+
+v1 had no async client. In v2:
+
+```python
+import asyncio
+from themeparks import AsyncThemeParks
+
+async def main():
+    async with AsyncThemeParks() as tp:
+        resp = await tp.destinations.list()
+        for d in resp.destinations or []:
+            print(d.name)
+
+asyncio.run(main())
+```
+
+The async surface mirrors the sync surface method-for-method.
+
+## New in v2 (not in v1)
+
+- `tp.entity(id).walk()` — breadth-first iterator over every descendant.
+- `tp.entity(id).schedule.range(start, end)` — stitches monthly schedule
+  responses into a single sorted, filtered list.
+- `tp.destinations.find(query)` — case-insensitive lookup by slug or name.
+- Default-on response caching with per-endpoint TTLs (see README).
+- Automatic 429 `Retry-After` handling.

themeparks-2.0.0/PKG-INFO

@@ -0,0 +1,395 @@
+Metadata-Version: 2.4
+Name: themeparks
+Version: 2.0.0
+Summary: Official SDK for the ThemeParks.wiki API
+Project-URL: Homepage, https://api.themeparks.wiki
+Project-URL: Source, https://github.com/ThemeParks/ThemeParks_Python
+Project-URL: Issues, https://github.com/ThemeParks/ThemeParks_Python/issues
+Author: ThemeParks.wiki contributors
+License: MIT
+License-File: LICENSE
+Keywords: api,disney,themeparks,universal,wait-times
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: eval-type-backport>=0.2; python_version < '3.10'
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.6
+Requires-Dist: typing-extensions>=4.10
+Provides-Extra: dev
+Requires-Dist: datamodel-code-generator[http]>=0.25; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-recording>=0.13; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocs>=1.5; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.24; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# themeparks
+
+A typed, modern Python SDK for the [ThemeParks.wiki](https://api.themeparks.wiki)
+API. Built on `httpx` and `pydantic` v2, with first-class sync **and** async
+clients, default-on caching, and ergonomic helpers for the common workflows
+(list destinations, walk a park's children, fetch live wait times, pull a
+date-ranged schedule).
+
+📚 **[Full documentation, API reference, and cookbook](https://themeparks.github.io/ThemeParks_Python/)**
+
+## Install
+
+```bash
+pip install themeparks
+```
+
+Python 3.9+ is required.
+
+## Print live wait times (sync)
+
+```python
+from themeparks import ThemeParks, current_wait_time
+
+MAGIC_KINGDOM = "75ea578a-adc8-4116-a54d-dccb60765ef9"
+
+with ThemeParks() as tp:
+    live = tp.entity(MAGIC_KINGDOM).live()
+    for entry in sorted(live.liveData or [], key=lambda e: e.name):
+        wait = current_wait_time(entry)
+        if wait is None:
+            print(f"{entry.name:50s}  --")
+        else:
+            print(f"{entry.name:50s}  {wait:>3d} min")
+```
+
+Sample output:
+
+```
+Astro Orbiter                                       15 min
+Big Thunder Mountain Railroad                       45 min
+Buzz Lightyear's Space Ranger Spin                  20 min
+...
+```
+
+## Print live wait times (async)
+
+```python
+import asyncio
+from themeparks import AsyncThemeParks, current_wait_time
+
+MAGIC_KINGDOM = "75ea578a-adc8-4116-a54d-dccb60765ef9"
+
+async def main() -> None:
+    async with AsyncThemeParks() as tp:
+        live = await tp.entity(MAGIC_KINGDOM).live()
+        for entry in sorted(live.liveData or [], key=lambda e: e.name):
+            wait = current_wait_time(entry)
+            if wait is None:
+                print(f"{entry.name:50s}  --")
+            else:
+                print(f"{entry.name:50s}  {wait:>3d} min")
+
+asyncio.run(main())
+```
+
+The sync and async clients mirror each other method-for-method. Only the
+call sites need `await` and you use `async with` instead of `with`.
+
+### Just the open rides, sorted longest-wait first
+
+```python
+from themeparks import ThemeParks, current_wait_time
+
+with ThemeParks() as tp:
+    live = tp.entity("75ea578a-adc8-4116-a54d-dccb60765ef9").live()
+    waits = [
+        (entry.name, current_wait_time(entry))
+        for entry in live.liveData or []
+    ]
+    waits = [(name, w) for name, w in waits if w is not None]
+    waits.sort(key=lambda pair: pair[1], reverse=True)
+    for name, wait in waits:
+        print(f"{wait:>3d} min  {name}")
+```
+
+## Client options
+
+Both `ThemeParks` and `AsyncThemeParks` take the same keyword-only options:
+
+| Option       | Type                                     | Default                              | Purpose |
+|--------------|------------------------------------------|--------------------------------------|---------|
+| `base_url`   | `str`                                    | `https://api.themeparks.wiki/v1`     | API base URL (point at a mock / staging if you need to). |
+| `user_agent` | `str \| None`                            | `themeparks-sdk-py/<version>`        | Sent as the `User-Agent` header. Set this to identify your app. |
+| `timeout`    | `float` (seconds)                        | `10.0`                               | Per-request timeout. |
+| `retry`      | `RetryConfig \| None`                    | `RetryConfig(max_retries=3, respect_429=True)` | Retry/backoff behavior. `max_retries` is N retries beyond the first attempt (so N+1 total calls). |
+| `cache`      | `Cache \| CacheConfig \| bool \| None`   | `True` (in-memory LRU)               | See **Caching** below. `False` disables caching entirely. |
+
+Example:
+
+```python
+from themeparks import ThemeParks, RetryConfig
+
+tp = ThemeParks(
+    user_agent="my-app/1.2.3 (+https://example.com)",
+    timeout=15.0,
+    retry=RetryConfig(max_retries=5, respect_429=True),
+)
+```
+
+## Ergonomic helpers
+
+```python
+from datetime import date
+from themeparks import ThemeParks
+
+with ThemeParks() as tp:
+    # Directory lookup
+    wdw = tp.destinations.find("waltdisneyworldresort")
+    print(wdw.id, wdw.name)
+
+    # Walk a destination and yield every descendant (parks, lands, attractions, ...)
+    for child in tp.entity(wdw.id).walk():
+        print(child.entityType, child.name)
+
+    # Schedule across a date range (stitches monthly responses and filters)
+    mk = "75ea578a-adc8-4116-a54d-dccb60765ef9"
+    entries = tp.entity(mk).schedule.range(date(2026, 5, 1), date(2026, 5, 31))
+    print(f"{len(entries)} schedule entries")
+```
+
+### Reading every queue type
+
+`current_wait_time` covers the standby-queue case. There are six queue
+variants in total, and an attraction may have more than one populated at
+once (e.g. STANDBY + SINGLE_RIDER + PAID_STANDBY for a Lightning Lane ride).
+
+Each variant is exposed as an attribute on `entry.queue`. All are
+`Optional` — `None` if that queue type isn't offered for the attraction:
+
+| Attribute              | Type                  | Fields                                                                                              |
+|------------------------|-----------------------|------------------------------------------------------------------------------------------------------|
+| `queue.STANDBY`        | `StandbyQueue`        | `waitTime: int \| None`                                                                              |
+| `queue.SINGLE_RIDER`   | `SingleRiderQueue`    | `waitTime: int \| None`                                                                              |
+| `queue.PAID_STANDBY`   | `PaidStandbyQueue`    | `waitTime: int \| None`                                                                              |
+| `queue.RETURN_TIME`    | `ReturnTimeQueue`     | `state`, `returnStart`, `returnEnd`                                                                  |
+| `queue.PAID_RETURN_TIME` | `PaidReturnTimeQueue` | `state`, `returnStart`, `returnEnd`, `price`                                                       |
+| `queue.BOARDING_GROUP` | `BoardingGroupQueue`  | `allocationStatus`, `currentGroupStart`, `currentGroupEnd`, `nextAllocationTime`, `estimatedWait` |
+
+#### Direct access
+
+```python
+from themeparks import ThemeParks
+
+with ThemeParks() as tp:
+    live = tp.entity("75ea578a-adc8-4116-a54d-dccb60765ef9").live()
+    for entry in live.liveData or []:
+        if entry.queue is None:
+            continue
+
+        # Standby
+        if entry.queue.STANDBY and entry.queue.STANDBY.waitTime is not None:
+            print(f"{entry.name}: standby {entry.queue.STANDBY.waitTime} min")
+
+        # Lightning Lane / paid line
+        if entry.queue.PAID_RETURN_TIME:
+            prt = entry.queue.PAID_RETURN_TIME
+            price = prt.price.formatted if prt.price else "?"
+            print(f"{entry.name}: Lightning Lane {price}, return {prt.returnStart} → {prt.returnEnd}")
+
+        # Boarding group
+        if entry.queue.BOARDING_GROUP:
+            bg = entry.queue.BOARDING_GROUP
+            print(
+                f"{entry.name}: boarding group {bg.currentGroupStart}–{bg.currentGroupEnd}, "
+                f"~{bg.estimatedWait} min wait, status {bg.allocationStatus}"
+            )
+
+        # Return-time only (no paid component)
+        if entry.queue.RETURN_TIME:
+            rt = entry.queue.RETURN_TIME
+            print(f"{entry.name}: virtual queue {rt.returnStart} → {rt.returnEnd} ({rt.state})")
+```
+
+#### Generic iteration
+
+If you'd rather not branch on every variant, `iter_queues(entry)` flattens
+all populated queue types into one sequence of dicts keyed by `type`:
+
+```python
+from themeparks import ThemeParks, iter_queues
+
+with ThemeParks() as tp:
+    live = tp.entity("75ea578a-adc8-4116-a54d-dccb60765ef9").live()
+    for entry in live.liveData or []:
+        for q in iter_queues(entry):
+            # q is a dict, e.g. {"type": "STANDBY", "waitTime": 35}
+            #                or {"type": "PAID_RETURN_TIME", "state": "AVAILABLE", ...}
+            print(entry.name, q)
+```
+
+The `type` key matches the API's variant name (`STANDBY`, `SINGLE_RIDER`,
+`RETURN_TIME`, `PAID_RETURN_TIME`, `BOARDING_GROUP`, `PAID_STANDBY`). The
+remaining keys are whatever fields that variant carries.
+
+### Other helpers
+
+`parse_api_datetime(value, timezone)` parses any API date/time string into a
+timezone-aware `datetime`, honoring the entity's IANA timezone for naive
+inputs.
+
+## Low-level escape hatch
+
+Every ergonomic helper is built on top of `tp.raw`, which is a thin, typed
+1:1 wrapper over the OpenAPI operations. Use it directly when you want the
+raw response shape:
+
+```python
+with ThemeParks() as tp:
+    live = tp.raw.get_entity_live("75ea578a-adc8-4116-a54d-dccb60765ef9")
+    dests = tp.raw.get_destinations()
+    children = tp.raw.get_entity_children(wdw.id)
+```
+
+The raw methods return `pydantic` models, so you still get full type checking
+and attribute access.
+
+## Error handling
+
+All SDK errors inherit from `ThemeParksError`. The ones you will want to
+catch in application code:
+
+```python
+from themeparks import ThemeParks, APIError, RateLimitError, NetworkError, TimeoutError
+
+with ThemeParks() as tp:
+    try:
+        live = tp.entity("75ea578a-adc8-4116-a54d-dccb60765ef9").live()
+    except RateLimitError as exc:
+        # 429; exc.retry_after is seconds if the server told us
+        print(f"rate limited, retry after {exc.retry_after}s")
+    except APIError as exc:
+        # any non-2xx status
+        print(f"api error {exc.status} at {exc.url}: {exc.body}")
+    except (NetworkError, TimeoutError) as exc:
+        # transport failure or slow server
+        print(f"transport: {exc!r}")
+```
+
+`RateLimitError` is a subclass of `APIError`, so the order of the `except`
+blocks matters if you want to handle 429 specially.
+
+## Debugging — see every HTTP request
+
+The SDK is built on `httpx`, which has a built-in logger. Turn it on to see
+every outbound request and response status:
+
+```python
+import logging
+logging.basicConfig(level=logging.INFO)
+logging.getLogger("httpx").setLevel(logging.DEBUG)
+
+from themeparks import ThemeParks
+with ThemeParks() as tp:
+    tp.entity("75ea578a-adc8-4116-a54d-dccb60765ef9").live()
+```
+
+Output:
+
+```
+INFO httpx HTTP Request: GET https://api.themeparks.wiki/v1/entity/75ea578a-adc8-4116-a54d-dccb60765ef9/live "HTTP/1.1 200 OK"
+```
+
+For raw byte-level traces (TLS handshake, header bytes, etc.), also enable
+the `httpcore` logger:
+
+```python
+logging.getLogger("httpcore").setLevel(logging.DEBUG)
+```
+
+> **Note:** requests served from the in-memory cache do **not** appear in
+> `httpx` logs — they're returned before the transport is touched. To see
+> every call as a network round-trip while debugging, pass `cache=False`.
+
+## Caching
+
+The default client caches `GET` responses in-memory with sensible per-endpoint
+TTLs:
+
+| Endpoint                                | TTL        | Rationale |
+|-----------------------------------------|------------|-----------|
+| `GET /destinations`                     | 1 hour     | Directory rarely changes. |
+| `GET /entity/{id}`                      | 1 hour     | Entity metadata is static. |
+| `GET /entity/{id}/children`             | 1 hour     | Park topology is stable. |
+| `GET /entity/{id}/schedule[/yyyy/mm]`   | 5 minutes  | Schedules update but not rapidly. |
+| `GET /entity/{id}/live`                 | 0 (bypass) | Live data is always fetched. |
+
+### Disable caching
+
+```python
+tp = ThemeParks(cache=False)
+```
+
+### Plug in your own adapter
+
+`Cache` is a `Protocol`; any object implementing `get`, `set`, and `delete`
+works. Here is a minimal `dict`-backed example (for real-world use you would
+want TTL enforcement and bounded size):
+
+```python
+from typing import Any
+from themeparks import ThemeParks, Cache
+
+class DictCache:
+    def __init__(self) -> None:
+        self._data: dict[str, Any] = {}
+
+    def get(self, key: str) -> Any | None:
+        return self._data.get(key)
+
+    def set(self, key: str, value: Any, ttl_seconds: float) -> None:
+        self._data[key] = value
+
+    def delete(self, key: str) -> None:
+        self._data.pop(key, None)
+
+tp = ThemeParks(cache=DictCache())
+```
+
+The per-endpoint TTL table is applied by the transport layer, so your adapter
+receives the correct `ttl_seconds` for each call and can honor it however it
+likes (Redis `EXPIRE`, filesystem mtime, etc.).
+
+## What's new in v2
+
+v2 is a full rewrite on `httpx` + `pydantic` v2. It replaces the generated
+`openapi_client` surface with a hand-crafted client, fixes the nullable
+queue-field crash from issues #1 and #2, and adds native async support.
+
+See [MIGRATION.md](./MIGRATION.md) for a side-by-side v1 to v2 guide.
+
+## Supported Python versions
+
+3.9, 3.10, 3.11, 3.12, 3.13.
+
+## Links
+
+- **SDK documentation:** https://themeparks.github.io/ThemeParks_Python/
+- **API reference:** https://themeparks.github.io/ThemeParks_Python/api/client/
+- **Cookbook:** https://themeparks.github.io/ThemeParks_Python/cookbook/
+- **Underlying API:** https://api.themeparks.wiki
+- **Issues:** https://github.com/ThemeParks/ThemeParks_Python/issues
+- **Changelog:** [CHANGELOG.md](./CHANGELOG.md)
+
+## License
+
+MIT.