pdata-client 0.1.0__py3-none-any.whl

pdata/__init__.py

@@ -0,0 +1,29 @@
+"""A small Python client for pdata.world, the prediction-market data API.
+
+pdata.world collects prices, volumes and results from eight venues —
+Polymarket, Kalshi, Manifold, Myriad, Limitless, Predict, Opinion and
+Gemini — and serves them through one read-only API. No key, no signup.
+The data is published under CC BY 4.0: use it, and credit pdata.world.
+
+    >>> from pdata import Client
+    >>> pd = Client()
+    >>> page = pd.markets(source="kalshi", sort="-volume_24hr", page_size=5)
+    >>> [m["question"] for m in page["items"]]
+
+Standard library only (urllib + json + gzip), Python 3.9+.
+"""
+
+from __future__ import annotations
+
+from ._version import __version__
+from .client import API_BASE, BULK_BASE, USER_AGENT, VENUES, Client, PdataError
+
+__all__ = [
+    "API_BASE",
+    "BULK_BASE",
+    "USER_AGENT",
+    "VENUES",
+    "Client",
+    "PdataError",
+    "__version__",
+]

pdata/_version.py

@@ -0,0 +1,3 @@
+"""The package version, in one place (pyproject.toml reads it from here)."""
+
+__version__ = "0.1.0"

pdata/client.py

@@ -0,0 +1,287 @@
+"""The client: one method per pdata.world API operation, plus the bulk files.
+
+Every method returns the API's JSON as plain dicts and lists, unchanged, so
+the API reference at https://api.pdata.world/docs describes the fields.
+List endpoints return a page: ``{"items": [...], "meta": {"page", "page_size",
+"total", "total_pages"}, "_meta": {...}}``; the ``iter_*`` methods walk the
+pages for you.
+
+Units: ``probability`` and prices are 0-1. ``volume`` and ``volume_24hr``
+are in each venue's own unit and are not converted across venues — shares
+for Polymarket, contracts for Kalshi (each pays $1 at resolution), play-money
+mana for Manifold.
+"""
+
+from __future__ import annotations
+
+import gzip
+import json
+import time
+from collections.abc import Iterator, Mapping
+from typing import Any, Callable
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote, urlencode
+from urllib.request import Request, urlopen
+
+from ._version import __version__
+
+API_BASE = "https://api.pdata.world/api/v1"
+BULK_BASE = "https://api.pdata.world/bulk"
+# Sent unless the caller passes its own; names the client and where to read
+# about pdata.world's agent and API access.
+USER_AGENT = f"pdata-client/{__version__} (+https://pdata.world/agents)"
+VENUES = (
+    "polymarket",
+    "kalshi",
+    "manifold",
+    "myriad",
+    "limitless",
+    "predict",
+    "opinion",
+    "gemini",
+)
+BULK_KINDS = ("markets-open", "events-open", "resolved")
+
+# The API caps page_size at 200.
+MAX_PAGE_SIZE = 200
+_RETRY_STATUSES = frozenset({429, 500, 502, 503, 504})
+
+JSON = dict[str, Any]
+
+
+class PdataError(Exception):
+    """An error answer from the API.
+
+    ``code`` is the API's machine-readable code (``not_found``,
+    ``unknown_param``, ``invalid_source``, ...) and ``message`` its
+    explanation. An ``unknown_param`` message lists every allowed parameter.
+    """
+
+    def __init__(self, status: int, code: str, message: str) -> None:
+        super().__init__(f"{status} {code}: {message}")
+        self.status = status
+        self.code = code
+        self.message = message
+
+
+def _encode(params: Mapping[str, Any]) -> str:
+    """Query string: None dropped, booleans as true/false, sequences comma-joined."""
+    out: list[tuple[str, str]] = []
+    for key, value in params.items():
+        if value is None:
+            continue
+        if isinstance(value, bool):
+            out.append((key, "true" if value else "false"))
+        elif isinstance(value, (list, tuple, set, frozenset)):
+            out.append((key, ",".join(str(v) for v in value)))
+        else:
+            out.append((key, str(value)))
+    return urlencode(out)
+
+
+def _seg(value: str) -> str:
+    """One URL path segment (ids can hold characters that need escaping)."""
+    return quote(str(value), safe="")
+
+
+class Client:
+    """pdata.world API client.
+
+    Args:
+        base_url: API root, default ``https://api.pdata.world/api/v1``.
+        bulk_url: bulk-file root, default ``https://api.pdata.world/bulk``.
+        timeout: seconds per request.
+        retries: extra attempts on 429/5xx and network errors, with backoff.
+        user_agent: sent on every request instead of ``USER_AGENT``; if you
+            set one, name your project in it.
+        opener: a ``urlopen``-compatible callable, for tests or a custom
+            transport.
+    """
+
+    def __init__(
+        self,
+        base_url: str = API_BASE,
+        *,
+        bulk_url: str = BULK_BASE,
+        timeout: float = 30.0,
+        retries: int = 2,
+        user_agent: str | None = None,
+        opener: Callable[..., Any] | None = None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.bulk_url = bulk_url.rstrip("/")
+        self.timeout = timeout
+        self.retries = retries
+        self.user_agent = user_agent or USER_AGENT
+        self._opener = opener or urlopen
+
+    # ── transport ────────────────────────────────────────────────────────
+
+    def _open(self, url: str) -> Any:
+        request = Request(url, headers={"User-Agent": self.user_agent, "Accept": "*/*"})
+        attempt = 0
+        while True:
+            try:
+                return self._opener(request, timeout=self.timeout)
+            except HTTPError as err:
+                if err.code in _RETRY_STATUSES and attempt < self.retries:
+                    retry_after = err.headers.get("Retry-After") if err.headers else None
+                    time.sleep(float(retry_after) if retry_after else 1.5 * 2**attempt)
+                    attempt += 1
+                    continue
+                raise self._error(err) from None
+            except URLError:
+                if attempt < self.retries:
+                    time.sleep(1.5 * 2**attempt)
+                    attempt += 1
+                    continue
+                raise
+
+    @staticmethod
+    def _error(err: HTTPError) -> PdataError:
+        try:
+            body = json.loads(err.read().decode("utf-8"))
+        except (ValueError, OSError):
+            body = {}
+        code = body.get("code") or "http_error"
+        message = body.get("message")
+        if message is None and "detail" in body:  # request validation errors
+            message = json.dumps(body["detail"])
+        return PdataError(err.code, code, message or str(err.reason))
+
+    def get(self, path: str, **params: Any) -> Any:
+        """GET ``base_url + path`` with ``params``; returns the decoded JSON."""
+        query = _encode(params)
+        url = f"{self.base_url}{path}" + (f"?{query}" if query else "")
+        with self._open(url) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+
+    def _iterate(self, path: str, max_items: int | None, params: dict[str, Any]) -> Iterator[JSON]:
+        params.setdefault("page_size", MAX_PAGE_SIZE)
+        page = int(params.pop("page", 1))
+        seen = 0
+        while True:
+            body = self.get(path, page=page, **params)
+            for item in body.get("items", []):
+                yield item
+                seen += 1
+                if max_items is not None and seen >= max_items:
+                    return
+            if page >= int((body.get("meta") or {}).get("total_pages") or page):
+                return
+            page += 1
+
+    # ── markets ──────────────────────────────────────────────────────────
+
+    def markets(self, **filters: Any) -> JSON:
+        """One page of markets (``GET /markets``).
+
+        Common filters: ``source`` (a venue or a list), ``search``,
+        ``categories``, ``closed``, ``probability_min``/``_max``,
+        ``volume_24hr_min``, ``ends_before``/``ends_after`` (ISO 8601),
+        ``sort`` (e.g. ``"-volume_24hr"``, ``"-prob_24h_change"``), ``page``,
+        ``page_size`` (max 200). Unknown parameters are rejected with the
+        full list of allowed ones.
+        """
+        return self.get("/markets", **filters)
+
+    def iter_markets(self, max_items: int | None = None, **filters: Any) -> Iterator[JSON]:
+        """Every market matching ``filters``, page by page."""
+        return self._iterate("/markets", max_items, dict(filters))
+
+    def market(self, source: str, market_id: str) -> JSON:
+        """One market by venue and id (``GET /markets/{source}/{market_id}``)."""
+        return self.get(f"/markets/{_seg(source)}/{_seg(market_id)}")
+
+    def top_movers(self, limit: int | None = None, **filters: Any) -> JSON:
+        """Markets with the largest probability change over 24 hours."""
+        return self.get("/markets/top-movers", limit=limit, **filters)
+
+    def closing_soon(self, limit: int | None = None, **filters: Any) -> JSON:
+        """Open markets closing soonest."""
+        return self.get("/markets/closing-soon", limit=limit, **filters)
+
+    # ── events ───────────────────────────────────────────────────────────
+
+    def events(self, **filters: Any) -> JSON:
+        """One page of events (``GET /events``); an event groups the markets of one question."""
+        return self.get("/events", **filters)
+
+    def iter_events(self, max_items: int | None = None, **filters: Any) -> Iterator[JSON]:
+        """Every event matching ``filters``, page by page."""
+        return self._iterate("/events", max_items, dict(filters))
+
+    def event(self, source: str, event_id: str, markets_limit: int | None = None) -> JSON:
+        """One event with its markets.
+
+        Events closed more than 10 days ago come back as
+        ``{"kind": "tombstone", ...}`` with each top market's final result;
+        live ones as ``{"kind": "live", ...}``. Check ``kind`` first.
+        ``_meta.cite_as`` holds a ready-made citation sentence.
+        """
+        return self.get(
+            f"/events/{_seg(source)}/{_seg(event_id)}", markets_limit=markets_limit
+        )
+
+    def event_history(
+        self,
+        source: str,
+        event_id: str,
+        range: str = "24h",
+        market_id: str | None = None,
+        limit: int | None = None,
+    ) -> JSON:
+        """Price and 24h-volume series for an event's top markets.
+
+        ``range`` is ``"24h"``, ``"7d"``, ``"30d"`` or ``"all"`` (history
+        starts May 2026; points older than 7 days are 12-hour buckets).
+        """
+        return self.get(
+            f"/events/{_seg(source)}/{_seg(event_id)}/history",
+            range=range,
+            market_id=market_id,
+            limit=limit,
+        )
+
+    def similar_events(self, source: str, event_id: str, limit: int | None = None) -> JSON:
+        """Events on other venues (and the same one) asking a similar question."""
+        return self.get(f"/events/{_seg(source)}/{_seg(event_id)}/similar", limit=limit)
+
+    # ── search, summary, news ───────────────────────────────────────────
+
+    def search(self, q: str, limit: int | None = None) -> JSON:
+        """Events and markets whose titles match ``q``."""
+        return self.get("/search/suggest", q=q, limit=limit)
+
+    def summary(self) -> JSON:
+        """Per-venue totals: open markets, events and 24h volume."""
+        return self.get("/summary")
+
+    def news_movers(self, **filters: Any) -> JSON:
+        """The /news feed: markets whose price moved most, scored by move and volume."""
+        return self.get("/news/movers", **filters)
+
+    # ── bulk files ───────────────────────────────────────────────────────
+
+    def bulk_index(self) -> JSON:
+        """The bulk-file index: each file's URL, row count, size, sha256 and time."""
+        with self._open(f"{self.bulk_url}/index.json") as resp:
+            return json.loads(resp.read().decode("utf-8"))
+
+    def iter_bulk(self, kind: str, *, include_manifest: bool = False) -> Iterator[JSON]:
+        """Stream a nightly bulk file, one record at a time.
+
+        ``kind`` is ``"markets-open"``, ``"events-open"`` or ``"resolved"``.
+        Line 1 of each file is a manifest (``{"_manifest": {...}}``) giving
+        the licence and every field's meaning and unit; it is skipped unless
+        ``include_manifest`` is true. Nothing is written to disk.
+        """
+        if kind not in BULK_KINDS:
+            raise ValueError(f"kind must be one of {BULK_KINDS}, not {kind!r}")
+        with self._open(f"{self.bulk_url}/{kind}-latest.jsonl.gz") as resp:
+            with gzip.GzipFile(fileobj=resp) as lines:
+                for i, line in enumerate(lines):
+                    row = json.loads(line)
+                    if i == 0 and "_manifest" in row and not include_manifest:
+                        continue
+                    yield row

pdata_client-0.1.0.dist-info/METADATA

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: pdata-client
+Version: 0.1.0
+Summary: Python client for pdata.world, a free read-only API for prediction-market data from Polymarket, Kalshi, Manifold and five more venues.
+Author-email: "pdata.world" <support@pdata.world>
+License-Expression: MIT
+Project-URL: Homepage, https://pdata.world
+Project-URL: Documentation, https://api.pdata.world/docs
+Project-URL: OpenAPI, https://api.pdata.world/openapi.json
+Project-URL: Repository, https://github.com/noskillcoding/pdata-client
+Project-URL: Issues, https://github.com/noskillcoding/pdata-client/issues
+Project-URL: Data, https://pdata.world/data
+Project-URL: Research, https://pdata.world/research
+Keywords: prediction markets,polymarket,kalshi,manifold,api client,open data
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Programming Language :: Python :: 3.14
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pdata-client
+
+Python client, AI-assistant plugin files and sample data for **[pdata.world](https://pdata.world)**,
+a free, read-only API for prediction-market data from eight venues: Polymarket, Kalshi,
+Manifold, Myriad, Limitless, Predict, Opinion and Gemini.
+
+```bash
+pip install pdata-client
+```
+
+```python
+from pdata import Client
+
+pd = Client()
+page = pd.markets(source=["kalshi", "polymarket"], closed=False, sort="-volume_24hr", page_size=5)
+for m in page["items"]:
+    print(m["source"], f"{m['probability']:.0%}", m["event_title"], "—", m["question"])
+```
+
+**Cite as:** Data aggregated by pdata.world (https://pdata.world) from 8 prediction-market
+venues; CC BY 4.0; source data © each venue. Dataset DOI
+[10.5281/zenodo.23211610](https://doi.org/10.5281/zenodo.23211610).
+
+pdata.world polls each venue every 10 to 60 minutes and keeps prices, 24-hour volume and
+results in one schema, so one request can compare venues that otherwise each need their own
+integration. There is no API key and no signup. The data is published under
+[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/): use it, and credit pdata.world.
+
+## Install
+
+```bash
+pip install pdata-client
+# or the latest commit:
+pip install git+https://github.com/noskillcoding/pdata-client
+```
+
+The client uses only the standard library (`urllib`, `json`, `gzip`), has no dependencies
+and runs on Python 3.9 or later. You can also copy
+[`src/pdata/client.py`](https://github.com/noskillcoding/pdata-client/blob/main/src/pdata/client.py) and
+[`src/pdata/_version.py`](https://github.com/noskillcoding/pdata-client/blob/main/src/pdata/_version.py) into a project. It identifies itself as
+`pdata-client/<version> (+https://pdata.world/agents)`; pass `user_agent=` to name your own
+project instead.
+
+## The MCP server and the assistant plugins
+
+pdata.world hosts an MCP server at `https://api.pdata.world/mcp` (Streamable HTTP, no key,
+no account). It is **read-only**: its 14 tools read the same public data as the API. The
+server is run by pdata.world and its code is **closed-source**; it is not in this
+repository. This repository holds the Python client, the plugin files that connect coding
+assistants to the hosted server, and notes on the datasets. The server is listed in the
+official MCP registry as `world.pdata/mcp`.
+
+- **Claude Code:** `/plugin install pdata --marketplace noskillcoding/pdata-client` inside a
+  session (Claude Code 2.1.275 or later), or from the shell
+  `claude plugin marketplace add noskillcoding/pdata-client` followed by
+  `claude plugin install pdata@pdata-world`. The plugin adds the MCP server and a skill,
+  [`skills/pdata-prediction-markets/SKILL.md`](https://github.com/noskillcoding/pdata-client/blob/main/skills/pdata-prediction-markets/SKILL.md),
+  that tells the assistant when to use pdata and how to cite it.
+- **Gemini CLI:** `gemini extensions install https://github.com/noskillcoding/pdata-client`
+  adds the same server and skill.
+- **Any other MCP client:** add the server by URL, for example
+  `claude mcp add --transport http pdata https://api.pdata.world/mcp`, or the config in
+  [`examples/mcp.json`](https://github.com/noskillcoding/pdata-client/blob/main/examples/mcp.json).
+
+## What is in this repository
+
+| Path | What it is |
+|---|---|
+| [`src/pdata/`](https://github.com/noskillcoding/pdata-client/blob/main/src/pdata/) | The Python client, published on PyPI as `pdata-client` |
+| [`.claude-plugin/`](https://github.com/noskillcoding/pdata-client/blob/main/.claude-plugin/), [`.mcp.json`](https://github.com/noskillcoding/pdata-client/blob/main/.mcp.json), [`skills/`](https://github.com/noskillcoding/pdata-client/blob/main/skills/) | Claude Code plugin and its one-plugin marketplace |
+| [`gemini-extension.json`](https://github.com/noskillcoding/pdata-client/blob/main/gemini-extension.json) | Gemini CLI extension (uses the same `skills/`) |
+| [`apify/`](https://github.com/noskillcoding/pdata-client/blob/main/apify/) | Source of an Apify actor that returns events with current prices |
+| [`data/`](https://github.com/noskillcoding/pdata-client/blob/main/data/) | Samples of the nightly bulk files, CC BY 4.0 |
+| [`examples/`](https://github.com/noskillcoding/pdata-client/blob/main/examples/) | Runnable scripts and an MCP client config |
+
+## What the client covers
+
+| Method | API operation | What it returns |
+|---|---|---|
+| `markets(**filters)`, `iter_markets(...)` | `GET /markets` | Markets, filtered and sorted, one page or all pages |
+| `market(source, id)` | `GET /markets/{source}/{id}` | One market |
+| `top_movers(...)`, `closing_soon(...)` | `GET /markets/top-movers`, `/closing-soon` | Largest 24h price changes; markets closing next |
+| `events(**filters)`, `iter_events(...)` | `GET /events` | Events (an event groups the markets of one question) |
+| `event(source, id)` | `GET /events/{source}/{id}` | One event with its markets, or its final results once archived |
+| `event_history(source, id, range=...)` | `GET /events/{source}/{id}/history` | Price and 24h-volume series, `24h` / `7d` / `30d` / `all` |
+| `similar_events(source, id)` | `GET /events/{source}/{id}/similar` | The same or similar question on other venues |
+| `search(q)` | `GET /search/suggest` | Events and markets by title |
+| `summary()` | `GET /summary` | Per-venue counts and 24h volume |
+| `news_movers(...)` | `GET /news/movers` | The price moves behind pdata.world/news |
+| `bulk_index()`, `iter_bulk(kind)` | `/bulk/` | Nightly full files, streamed without saving |
+
+Every method returns the API's JSON unchanged, so the
+[API reference](https://api.pdata.world/docs) describes every field. Unknown filters are
+rejected with a message listing every allowed one. Errors raise `PdataError` with the API's
+`code` and `message`.
+
+Runnable examples are in [`examples/`](https://github.com/noskillcoding/pdata-client/blob/main/examples/):
+[`quickstart.py`](https://github.com/noskillcoding/pdata-client/blob/main/examples/quickstart.py) makes five common calls, and
+[`resolved_archive.py`](https://github.com/noskillcoding/pdata-client/blob/main/examples/resolved_archive.py) streams the archive of settled events.
+
+## Other ways to get the same data
+
+- **MCP server for AI assistants:** `https://api.pdata.world/mcp`; see
+  [above](#the-mcp-server-and-the-assistant-plugins).
+- **Nightly bulk files** at <https://api.pdata.world/bulk/>: every open market
+  (`markets-open`), every open event (`events-open`) and the archive of settled events with
+  their results (`resolved`), as gzipped JSON lines. Line 1 of each file is a manifest
+  giving the licence and every field's meaning and unit.
+- **Monthly snapshot on Hugging Face:** the same three files as Parquet, each snapshot
+  tagged with its date:
+  [`lowskillcoding/pdata-prediction-markets`](https://huggingface.co/datasets/lowskillcoding/pdata-prediction-markets).
+- **Read-only Postgres** with full SQL:
+  `postgresql://pdata_readonly:pdata_public_2026@pg.pdata.world:6433/pdata_new`. The
+  password is published on purpose and is never rotated. Queries are capped at 5 seconds.
+  See [`examples/postgres.sql`](https://github.com/noskillcoding/pdata-client/blob/main/examples/postgres.sql).
+- **The website:** every event has a page at `https://pdata.world/events/{source}/{id}`,
+  and <https://pdata.world/data> describes all of the above.
+
+## Sample data
+
+[`data/`](https://github.com/noskillcoding/pdata-client/blob/main/data/) holds random samples of the three bulk files as of 7 October 2026: 1,000
+open markets, 500 open events and 1,000 settled events, with an equal share per venue where
+the venue had enough rows. Each file starts with the manifest line. They are for looking at
+the shape of the data; the full files are rebuilt every night.
+
+## Units and things to know
+
+- `probability` and prices are on a 0–1 scale.
+- `volume` and `volume_24hr` are in each venue's own unit and are **not** converted across
+  venues: shares for Polymarket and contracts for Kalshi (each pays $1 at resolution),
+  play-money mana for Manifold, and each other venue's figure as it reports it.
+  [How eight venues count volume](https://pdata.world/research/prediction-market-volume)
+  explains each one.
+- Price history starts in May 2026. Points older than 7 days are kept as 12-hour buckets,
+  and a market's history is deleted 10 days after it closes. After that, the event's URL
+  returns `"kind": "tombstone"` with each top market's final result.
+- In the `resolved` archive, each market's `probability` is the last price pdata saw, which
+  is usually after the market settled. It records the result; it is not a forecast.
+- Events that closed between 2 June and 11 August 2026 are missing from the `resolved`
+  archive: they were pruned before a backup was taken.
+- pdata groups Kalshi's sibling events for one game under a single group event
+  (`is_group`); its volume is the sum of its children.
+
+## Research using this data
+
+pdata.world publishes dated reports built from this data, each with its method and limits:
+
+- [How accurate were prediction-market prices a day before the result?](https://pdata.world/research/prediction-market-accuracy)
+  For 39,681 Polymarket and Kalshi markets that settled between 28 September and
+  5 October 2026, grouped into 10-point bands by their price 24 hours before close, the
+  share that resolved YES was on average 0.96 percentage points from the band's average
+  price (Brier score 0.110, against 0.199 for always guessing the base rate). Also published
+  as a citable note: [doi.org/10.5281/zenodo.23212130](https://doi.org/10.5281/zenodo.23212130).
+- [How eight prediction-market venues count volume](https://pdata.world/research/prediction-market-volume)
+- [What each prediction-market API gives you](https://pdata.world/research/prediction-market-apis)
+- [Same question, different price: prediction markets across venues](https://pdata.world/research/cross-venue-prices)
+- [What eight prediction-market venues list, by category](https://pdata.world/research/prediction-market-coverage)
+
+## Citing
+
+The data is CC BY 4.0. A credit such as "Data: pdata.world" with a link is enough. Every
+single-event API answer also carries `_meta.cite_as`, a ready-made citation sentence. For
+papers, cite the dataset on Zenodo: DOI
+[10.5281/zenodo.23211610](https://doi.org/10.5281/zenodo.23211610) always resolves to the
+latest snapshot, and each snapshot has its own DOI, such as
+[10.5281/zenodo.23211611](https://doi.org/10.5281/zenodo.23211611) for 7 October 2026. The
+calibration note is [10.5281/zenodo.23212130](https://doi.org/10.5281/zenodo.23212130).
+GitHub's "Cite this repository" button uses [`CITATION.cff`](https://github.com/noskillcoding/pdata-client/blob/main/CITATION.cff).
+
+## Licence
+
+The code in this repository, including the plugin files and the Apify actor, is under the
+[MIT licence](https://github.com/noskillcoding/pdata-client/blob/main/LICENSE). The data, including the files in `data/`, is under
+[CC BY 4.0](https://github.com/noskillcoding/pdata-client/blob/main/data/LICENSE.md); the underlying market data remains subject to each venue's
+own terms.
+
+pdata.world is independent and not affiliated with any of the venues it tracks.
+
+## Releasing
+
+One version covers the PyPI package, the Claude Code plugin and the Gemini extension. Bump
+it in [`src/pdata/_version.py`](https://github.com/noskillcoding/pdata-client/blob/main/src/pdata/_version.py),
+[`.claude-plugin/plugin.json`](https://github.com/noskillcoding/pdata-client/blob/main/.claude-plugin/plugin.json) and
+[`gemini-extension.json`](https://github.com/noskillcoding/pdata-client/blob/main/gemini-extension.json) together (a test fails otherwise), then
+push a tag `v<version>`: [`publish.yml`](https://github.com/noskillcoding/pdata-client/blob/main/.github/workflows/publish.yml) builds, tests and
+uploads to PyPI through trusted publishing. Contact: support@pdata.world.

pdata_client-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+pdata/__init__.py,sha256=1-FYMwC_sO0VWQCWi9wev8VCHVaWX7DhVaQ3P-CLogc,886
+pdata/_version.py,sha256=VDUr8he49zIUw29_8mMlYhbA0Ro1VaF266tuUpzR458,100
+pdata/client.py,sha256=v2QQiZA1fK2Qipe7hQnDlUx2yOy8284UXDtk3u_DoZI,11978
+pdata/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pdata_client-0.1.0.dist-info/licenses/LICENSE,sha256=P4PusSm-X1RpcDMUM15WrnVb-6mQ9zmDnMA2Rr_RmVI,1068
+pdata_client-0.1.0.dist-info/METADATA,sha256=2G9hEMISM3KRcCx_vlf6kfCc8oXSxjNkQAWl1BiNRLI,13487
+pdata_client-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+pdata_client-0.1.0.dist-info/top_level.txt,sha256=f1qR9sFanBfpYX5lj2A6c3lvHfBA4tw-_lGKSrzbl14,6
+pdata_client-0.1.0.dist-info/RECORD,,

pdata_client-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pdata_client-0.1.0.dist-info/licenses/LICENSE

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

pdata_client-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pdata