lottevo 0.1.0__tar.gz

lottevo-0.1.0/LICENSE

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

lottevo-0.1.0/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: lottevo
+Version: 0.1.0
+Summary: A thin Python client for the Lottevo lottery data API.
+Author-email: Lottevo <contact@lottevo.com>
+License-Expression: MIT
+Project-URL: Homepage, https://lottevo.com/docs/sdks
+Project-URL: Source, https://github.com/astefalabs/lottevo-python
+Project-URL: Issues, https://github.com/astefalabs/lottevo-python/issues
+Keywords: lottevo,lottery,results,api,sdk
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Lottevo Python
+
+A thin client for the [Lottevo](https://lottevo.com) lottery data API: results, jackpots, schedules,
+prize breakdowns and statistics for lotteries worldwide. Standard library only; Python 3.8+.
+
+```bash
+pip install lottevo
+```
+
+## First call
+
+```python
+from lottevo import Client
+
+lottevo = Client("lv_…")  # or set LOTTEVO_API_KEY and pass nothing
+
+account = lottevo.account.get()                              # the smoke test: plan, scopes, quota
+draws = lottevo.lotteries.draws("EU-002", {"per_page": 5})   # EuroJackpot's latest results
+
+for draw in draws["data"]:
+    print(draw["drawn_at"], *draw["numbers"])
+```
+
+Every operation of the API is a method on a resource — `lottevo.lotteries`, `.draws`, `.webhooks`,
+`.countries` … — and returns the decoded JSON. Path parameters come first, then the query (or, for
+`create`/`update`, the JSON body):
+
+```python
+lottevo.draws.list({"filter": {"lottery": ["EU-002", "RO-001"], "from": "2026-01-01"}, "include": "prizes"})
+lottevo.lotteries.check("EU-002", {"numbers": "4,7,12,31,44", "bonus": "8,11"})
+```
+
+## Pagination
+
+Listings are cursor-paginated. `paginate()` walks every page from the one you give it:
+
+```python
+for lottery in lottevo.paginate(lottevo.lotteries.list()):
+    print(lottery["code"])
+```
+
+## Errors
+
+A refused call raises `LottevoError`. Branch on `code`, not on the message:
+
+```python
+from lottevo import LottevoError
+
+try:
+    lottevo.lotteries.draws("US-001")
+except LottevoError as error:
+    if error.code == "lottery_not_entitled":
+        ...  # not in your plan
+```
+
+`error.status`, `error.request_id` and `error.retry_after` are there too; `lottevo.last_headers` holds
+the last answer's headers, including `x-quota-remaining`.
+
+## Options
+
+```python
+Client(api_key, locale="ro", timeout=30)
+```
+
+`locale` is sent as `Accept-Language`: game names, schedules and error messages come back in it.
+
+Full reference: <https://lottevo.com/docs/reference>.

lottevo-0.1.0/README.md

@@ -0,0 +1,67 @@
+# Lottevo Python
+
+A thin client for the [Lottevo](https://lottevo.com) lottery data API: results, jackpots, schedules,
+prize breakdowns and statistics for lotteries worldwide. Standard library only; Python 3.8+.
+
+```bash
+pip install lottevo
+```
+
+## First call
+
+```python
+from lottevo import Client
+
+lottevo = Client("lv_…")  # or set LOTTEVO_API_KEY and pass nothing
+
+account = lottevo.account.get()                              # the smoke test: plan, scopes, quota
+draws = lottevo.lotteries.draws("EU-002", {"per_page": 5})   # EuroJackpot's latest results
+
+for draw in draws["data"]:
+    print(draw["drawn_at"], *draw["numbers"])
+```
+
+Every operation of the API is a method on a resource — `lottevo.lotteries`, `.draws`, `.webhooks`,
+`.countries` … — and returns the decoded JSON. Path parameters come first, then the query (or, for
+`create`/`update`, the JSON body):
+
+```python
+lottevo.draws.list({"filter": {"lottery": ["EU-002", "RO-001"], "from": "2026-01-01"}, "include": "prizes"})
+lottevo.lotteries.check("EU-002", {"numbers": "4,7,12,31,44", "bonus": "8,11"})
+```
+
+## Pagination
+
+Listings are cursor-paginated. `paginate()` walks every page from the one you give it:
+
+```python
+for lottery in lottevo.paginate(lottevo.lotteries.list()):
+    print(lottery["code"])
+```
+
+## Errors
+
+A refused call raises `LottevoError`. Branch on `code`, not on the message:
+
+```python
+from lottevo import LottevoError
+
+try:
+    lottevo.lotteries.draws("US-001")
+except LottevoError as error:
+    if error.code == "lottery_not_entitled":
+        ...  # not in your plan
+```
+
+`error.status`, `error.request_id` and `error.retry_after` are there too; `lottevo.last_headers` holds
+the last answer's headers, including `x-quota-remaining`.
+
+## Options
+
+```python
+Client(api_key, locale="ro", timeout=30)
+```
+
+`locale` is sent as `Accept-Language`: game names, schedules and error messages come back in it.
+
+Full reference: <https://lottevo.com/docs/reference>.

lottevo-0.1.0/lottevo/__init__.py

@@ -0,0 +1,5 @@
+"""A thin Python client for the Lottevo lottery data API."""
+
+from .client import DEFAULT_BASE_URL, Client, LottevoError, __version__
+
+__all__ = ["Client", "LottevoError", "DEFAULT_BASE_URL", "__version__"]

lottevo-0.1.0/lottevo/_resources.py

@@ -0,0 +1,383 @@
+# Generated from the Lottevo OpenAPI document. Do not edit.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Optional, Union
+from urllib.parse import quote
+
+if TYPE_CHECKING:
+    from .client import Client
+
+PathValue = Union[str, int]
+Params = Optional[Dict[str, Any]]
+
+
+def _segment(value: PathValue) -> str:
+    return quote(str(value), safe="")
+
+
+class _Resource:
+    def __init__(self, client: Client) -> None:
+        self._client = client
+
+
+class Account(_Resource):
+    def get(self, params: Params = None) -> Any:
+        r"""What the calling key is: its account's plan, its scopes and what the account
+        has spent today. The integration smoke test — a client can verify a key
+        works without needing a scope, and read its own ceiling from the answer
+
+        GET /account
+        """
+        return self._client.request("GET", "/account", params=params)
+
+
+class Lotteries(_Resource):
+    def compliance(self, lottery: PathValue, params: Params = None) -> Any:
+        r"""The legal frame of every jurisdiction a lottery is sold in
+
+        GET /lotteries/{lottery}/compliance
+
+        A national game lists its country only: which states or provinces
+        sell it is not known for every game, and the country entry says when
+        the rules differ between them.
+        """
+        return self._client.request("GET", f"/lotteries/{_segment(lottery)}/compliance", params=params)
+
+    def list(self, params: Params = None) -> Any:
+        r"""The catalogue. Inactive games are not listed
+
+        GET /lotteries
+        """
+        return self._client.request("GET", "/lotteries", params=params)
+
+    def get(self, lottery: PathValue, params: Params = None) -> Any:
+        r"""One game, addressed by its code, with the long description the list leaves
+        out — plus its last results and its payout table, which are cheap for one
+        game and are what a game's own page shows
+
+        GET /lotteries/{lottery}
+        """
+        return self._client.request("GET", f"/lotteries/{_segment(lottery)}", params=params)
+
+    def data_quality(self, lottery: PathValue, params: Params = None) -> Any:
+        r"""How complete and how fast a game's results have been
+
+        GET /lotteries/{lottery}/data-quality
+
+        Over the last 30 days: how many draws the game's schedule called for,
+        how many were published, how many the operator did not hold, and how
+        many are missing — plus how long after each draw's scheduled time its
+        result was available, as the median, the 90th percentile and the
+        slowest. Recomputed once a day. `completeness` is null for a game drawn
+        on a calendar no fixed schedule describes; `data` is null for a game
+        that has not been measured yet.
+        """
+        return self._client.request("GET", f"/lotteries/{_segment(lottery)}/data-quality", params=params)
+
+    def draws(self, lottery: PathValue, params: Params = None) -> Any:
+        r"""One game's result history, newest first, as far back as your plan includes
+        (see `/v1/account`). Pages stay equally fast however deep you walk back
+
+        GET /lotteries/{lottery}/draws
+        """
+        return self._client.request("GET", f"/lotteries/{_segment(lottery)}/draws", params=params)
+
+    def freshness(self, lottery: PathValue, params: Params = None) -> Any:
+        r"""How current a game's results are right now
+
+        GET /lotteries/{lottery}/freshness
+
+        Whether the latest scheduled draw has its result (`current`), is still
+        within the time results normally take (`awaiting`) or is late and
+        flagged as missing (`overdue`); when the game's results last changed
+        here, which is not the same as when it was last drawn; how long after
+        its scheduled time the latest result arrived, against the usual delay;
+        and how many results were corrected after publication recently.
+        Computed on every request, unlike the daily data-quality figures.
+        """
+        return self._client.request("GET", f"/lotteries/{_segment(lottery)}/freshness", params=params)
+
+    def jackpots(self, lottery: PathValue, params: Params = None) -> Any:
+        r"""How a game's announced jackpot has moved
+
+        GET /lotteries/{lottery}/jackpots
+
+        Every distinct figure the operator announced for an upcoming draw, newest
+        first, with the span over which it stood unchanged. A figure revised
+        during the week becomes a new entry, so the list shows how the estimate
+        grew toward each draw. The history starts when we began recording it.
+        """
+        return self._client.request("GET", f"/lotteries/{_segment(lottery)}/jackpots", params=params)
+
+    def payouts(self, lottery: PathValue, params: Params = None) -> Any:
+        r"""The payout table of a fixed-odds game
+
+        GET /lotteries/{lottery}/payouts
+
+        Some games do not split a pool between winners: the prize is a function
+        of the ticket — what was bet on, how many numbers were played, how many
+        matched — so it is the same for every draw and is published here rather
+        than with each result. A game that splits a pool returns an empty list;
+        its money is on the draws.
+        """
+        return self._client.request("GET", f"/lotteries/{_segment(lottery)}/payouts", params=params)
+
+    def schedule(self, lottery: PathValue, params: Params = None) -> Any:
+        r"""When a game draws: each schedule written out in the language of the request,
+        plus the next few occurrences already resolved to UTC instants so a client
+        does not have to handle DST to build a calendar
+
+        GET /lotteries/{lottery}/schedule
+
+        `regular` is false for a game that draws on irregular days, such as
+        one tied to horse-racing fixtures: it has no timetable, so the
+        schedules, the next draw and the upcoming occurrences are empty.
+        Query `occurrences`
+        """
+        return self._client.request("GET", f"/lotteries/{_segment(lottery)}/schedule", params=params)
+
+    def statistics(self, lottery: PathValue, params: Params = None) -> Any:
+        r"""The three rankings for a game: most drawn, least drawn, and longest without
+        appearing
+
+        GET /lotteries/{lottery}/statistics
+
+        Historical analysis of past results, not a prediction of future ones.
+        Query `combo_size`
+        Query `limit`
+        """
+        return self._client.request("GET", f"/lotteries/{_segment(lottery)}/statistics", params=params)
+
+    def check(self, lottery: PathValue, params: Params = None) -> Any:
+        r"""Check a ticket against a game's history
+
+        GET /lotteries/{lottery}/check
+
+        Pass the ticket as `numbers=3,11,17,24,38,45` — plus `bonus=7` for a game
+        whose bonus is played separately — and get every past draw it matched,
+        newest first. For a number game a draw is listed when it contained at
+        least `min_matched` of the numbers; for a digit game (Pick 3, Joker, …)
+        when it was an exact or any-order hit, or matched at least `min_matched`
+        digits by position or in a row from either end. `meta.summary` counts
+        every outcome over the whole window, and for a game whose operator
+        publishes prizes per draw `meta.winnings` adds up what the ticket would
+        have won, by currency, at the amounts paid per winner then — gross, as
+        published; `complete` is false when some draws could not be judged.
+        For a fixed-odds game (Lotto's wheels, Pick 3, keno) name the bet with
+        `bet_type` — one of the game's `ticket_check.bet_types` — and
+        optionally `stake`, and every draw is priced at the game's payout table
+        instead: `meta.bet` says the stake, currency and whether the amounts
+        are before withholdings. The window is `range` (`3months`,
+        `6months`, `1year`, `2years`, `all`) or `from`/`to`, and never reaches
+        back before the game took its current format nor further than your plan
+        includes (`meta.window`).
+        Query `numbers`
+        Query `bonus`
+        Query `bet_type`
+        Query `stake`
+        Query `min_matched`
+        """
+        return self._client.request("GET", f"/lotteries/{_segment(lottery)}/check", params=params)
+
+    def check_batch(self, lottery: PathValue, body: Params = None) -> Any:
+        r"""Check up to twenty tickets against a game's history at once
+
+        POST /lotteries/{lottery}/check
+
+        Send `tickets` — each `{"numbers": [...], "bonus": [...]}`, plus
+        `bet_type` and `stake` for a fixed-odds game — with the same window as
+        a single check (`range` or `from`/`to`), and get each ticket's summary:
+        how many draws it matched, and how. The draws themselves are
+        listed by the single-ticket check. Counts as one request. A game with a
+        very long history may need a shorter window for many tickets at once
+        (`ticket_check_too_large`).
+        """
+        return self._client.request("POST", f"/lotteries/{_segment(lottery)}/check", body=body)
+
+
+class Compliance(_Resource):
+    def list(self, params: Params = None) -> Any:
+        r"""The legal frame of every researched jurisdiction, optionally within one
+        country
+
+        GET /compliance
+
+        Countries and their states or provinces come in one list, each
+        country followed by its states. A US state carries the federal tax
+        level alongside its own, so it can be read on its own.
+        """
+        return self._client.request("GET", "/compliance", params=params)
+
+
+class Draws(_Resource):
+    def list(self, params: Params = None) -> Any:
+        r"""The results feed, newest first, across the whole catalogue or narrowed to a
+        game, a country or a date range. The cursor is what a client re-syncs
+        against; an offset page would be shifted by every draw that lands while it
+        reads. Results older than the history your plan includes are not listed —
+        `/v1/account` gives the exact start
+
+        GET /draws
+        """
+        return self._client.request("GET", "/draws", params=params)
+
+    def latest(self, params: Params = None) -> Any:
+        r"""The latest result of every game, paginated over games — the board a
+        dashboard renders. A game with no result yet is listed with `latest_draw:
+        null`
+
+        GET /draws/latest
+        """
+        return self._client.request("GET", "/draws/latest", params=params)
+
+    def get(self, draw: PathValue, params: Params = None) -> Any:
+        r"""One result by id. Ids are stable, and this is the URL a webhook payload and
+        an export row both point back at. A result older than the history your plan
+        includes is refused with `history_not_included`
+
+        GET /draws/{draw}
+        """
+        return self._client.request("GET", f"/draws/{_segment(draw)}", params=params)
+
+    def changes(self, params: Params = None) -> Any:
+        r"""Everything that happened to the results, in order
+
+        GET /draws/changes
+
+        The feed to keep a copy of the results in step without re-reading
+        them. Each entry says what happened — `published`, `updated` (money
+        filled in later: the jackpot, the prize categories), `revised` (the
+        numbers or the draw time corrected) or `deleted` — which fields it
+        touched, and carries the draw as it stands now; a deleted draw carries
+        only its id. Start from `filter[since]`, then follow `next_cursor`
+        from one request to the next. Entries older than the retention window
+        are no longer listed, except corrections; a client further behind
+        than that re-reads the results feed.
+        Query `per_page`
+        """
+        return self._client.request("GET", "/draws/changes", params=params)
+
+    def revisions(self, draw: PathValue, params: Params = None) -> Any:
+        r"""The corrections of one result, oldest first
+
+        GET /draws/{draw}/revisions
+
+        Each entry holds the fields that were corrected, with their values
+        before and after. A result that was never corrected has none.
+        """
+        return self._client.request("GET", f"/draws/{_segment(draw)}/revisions", params=params)
+
+
+class Continents(_Resource):
+    def list(self, params: Params = None) -> Any:
+        r"""The continents that have any lottery. Unpaginated on purpose: there are only
+        a handful of them, and a client building a dropdown should not have to
+        follow a cursor for it
+
+        GET /continents
+        """
+        return self._client.request("GET", "/continents", params=params)
+
+
+class Countries(_Resource):
+    def list(self, params: Params = None) -> Any:
+        r"""The countries that have any lottery, optionally within one continent. Lists
+        both the countries that own games and those where games are sold, so Cyprus
+        appears for the Greek games
+
+        GET /countries
+        Query `filter[continent]`
+        """
+        return self._client.request("GET", "/countries", params=params)
+
+
+class States(_Resource):
+    def list(self, params: Params = None) -> Any:
+        r"""The states that have any lottery, optionally within one country
+
+        GET /states
+        Query `filter[country]`
+        """
+        return self._client.request("GET", "/states", params=params)
+
+
+class Webhooks(_Resource):
+    def deliveries(self, webhook_endpoint: PathValue, params: Params = None) -> Any:
+        r"""What this subscription has been sent, newest first. Filterable by
+        `filter[status]=dead` — which is the dead-letter list, and the only thing
+        most clients ever look at
+
+        GET /webhooks/{webhookEndpoint}/deliveries
+        """
+        return self._client.request("GET", f"/webhooks/{_segment(webhook_endpoint)}/deliveries", params=params)
+
+    def replay(self, webhook_endpoint: PathValue, uuid: PathValue, body: Params = None) -> Any:
+        r"""Offer a delivery again — the recovery path for a receiver that was down
+        longer than the backoff lasts
+
+        POST /webhooks/{webhookEndpoint}/deliveries/{uuid}/replay
+
+        The uuid is kept, so a receiver that DID process the original still
+        recognises it as the same event and can drop it. Only a delivery that
+        is no longer being retried — dead, or already delivered — can be
+        offered again.
+        """
+        return self._client.request("POST", f"/webhooks/{_segment(webhook_endpoint)}/deliveries/{_segment(uuid)}/replay", body=body)
+
+    def list(self, params: Params = None) -> Any:
+        r"""The subscriptions this key holds
+
+        GET /webhooks
+        """
+        return self._client.request("GET", "/webhooks", params=params)
+
+    def create(self, body: Params = None) -> Any:
+        r"""Subscribe. The signing secret comes back on this response only —
+        afterwards it is encrypted at rest and can be rotated but not read
+
+        POST /webhooks
+        """
+        return self._client.request("POST", "/webhooks", body=body)
+
+    def get(self, webhook_endpoint: PathValue, params: Params = None) -> Any:
+        r"""Show one subscription
+
+        GET /webhooks/{webhookEndpoint}
+        """
+        return self._client.request("GET", f"/webhooks/{_segment(webhook_endpoint)}", params=params)
+
+    def update(self, webhook_endpoint: PathValue, body: Params = None) -> Any:
+        r"""Change what a subscription listens to, or switch it back on after it was
+        disabled for being unreachable
+
+        PATCH /webhooks/{webhookEndpoint}
+        """
+        return self._client.request("PATCH", f"/webhooks/{_segment(webhook_endpoint)}", body=body)
+
+    def delete(self, webhook_endpoint: PathValue, params: Params = None) -> Any:
+        r"""Unsubscribe for good, taking the delivery history with it
+
+        DELETE /webhooks/{webhookEndpoint}
+        """
+        return self._client.request("DELETE", f"/webhooks/{_segment(webhook_endpoint)}", params=params)
+
+    def rotate_secret(self, webhook_endpoint: PathValue, body: Params = None) -> Any:
+        r"""Replace the signing secret, returning the new one once. The old one stops
+        verifying immediately — rotate when it has leaked, not on a schedule
+
+        POST /webhooks/{webhookEndpoint}/rotate-secret
+        """
+        return self._client.request("POST", f"/webhooks/{_segment(webhook_endpoint)}/rotate-secret", body=body)
+
+
+class Resources:
+    def _boot_resources(self) -> None:
+        self.account = Account(self)
+        self.lotteries = Lotteries(self)
+        self.compliance = Compliance(self)
+        self.draws = Draws(self)
+        self.continents = Continents(self)
+        self.countries = Countries(self)
+        self.states = States(self)
+        self.webhooks = Webhooks(self)

lottevo-0.1.0/lottevo/client.py

@@ -0,0 +1,166 @@
+"""The Lottevo API client: transport, errors and pagination."""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import Any, Dict, Iterator, List, Optional, Tuple
+from urllib.parse import urlencode
+
+from ._resources import Resources
+
+__version__ = "0.1.0"
+
+DEFAULT_BASE_URL = "https://api.lottevo.com/v1"
+
+
+class LottevoError(Exception):
+    """A refused or failed call.
+
+    Branch on ``code`` (``lottery_not_entitled``, ``quota_exceeded``, ...) —
+    the message is translated and will change. ``status`` is 0 when the API
+    was never reached.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        status: int = 0,
+        code: Optional[str] = None,
+        request_id: Optional[str] = None,
+        retry_after: Optional[int] = None,
+        body: Any = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.code = code
+        self.request_id = request_id
+        self.retry_after = retry_after
+        self.body = body
+
+
+class Client(Resources):
+    """The Lottevo API client.
+
+    Every operation hangs off a resource — ``client.lotteries.draws("EU-002")``
+    — and returns the decoded JSON. The key defaults to the LOTTEVO_API_KEY
+    environment variable; ``locale`` is sent as Accept-Language.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        locale: Optional[str] = None,
+        timeout: float = 30,
+    ) -> None:
+        api_key = api_key or os.environ.get("LOTTEVO_API_KEY")
+        if not api_key:
+            raise ValueError("Pass an api_key or set the LOTTEVO_API_KEY environment variable.")
+
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._locale = locale
+        self._timeout = timeout
+        self.last_headers: Dict[str, str] = {}
+        self._boot_resources()
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        body: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """Send one call and decode its JSON.
+
+        A list value in ``params`` is sent comma-separated, the way the API
+        reads ``filter[lottery]=EU-002,RO-001``; ``{"filter": {"lottery": "EU-002"}}``
+        and ``{"filter[lottery]": "EU-002"}`` are the same.
+        """
+        query = urlencode(_flatten(params or {}))
+        headers = {
+            "Authorization": f"Bearer {self._api_key}",
+            "Accept": "application/json",
+            "User-Agent": f"lottevo-python/{__version__}",
+        }
+        if self._locale:
+            headers["Accept-Language"] = self._locale
+        data = None
+        if body:
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(body).encode()
+
+        request = urllib.request.Request(
+            f"{self._base_url}{path}{'?' + query if query else ''}", data=data, headers=headers, method=method
+        )
+
+        try:
+            with urllib.request.urlopen(request, timeout=self._timeout) as response:
+                status, raw = response.status, response.read()
+                self.last_headers = {k.lower(): v for k, v in response.headers.items()}
+        except urllib.error.HTTPError as error:
+            status, raw = error.code, error.read()
+            self.last_headers = {k.lower(): v for k, v in error.headers.items()}
+        except (urllib.error.URLError, OSError) as error:
+            raise LottevoError(f"Could not reach the Lottevo API: {error}", code="network_error") from error
+
+        try:
+            payload = json.loads(raw) if raw else {}
+        except ValueError:
+            payload = None
+
+        if status >= 400 or not isinstance(payload, dict):
+            payload = payload if isinstance(payload, dict) else {}
+            retry_after = payload.get("retry_after", self.last_headers.get("retry-after"))
+            raise LottevoError(
+                payload.get("message", f"The Lottevo API answered {status}."),
+                status=status,
+                code=payload.get("code"),
+                request_id=self.last_headers.get("x-request-id"),
+                retry_after=int(retry_after) if retry_after is not None else None,
+                body=payload,
+            )
+
+        return payload
+
+    def paginate(self, page: Dict[str, Any]) -> Iterator[Any]:
+        """Every item of a listing, following ``links.next`` from the page given.
+
+        ``for draw in client.paginate(client.draws.list()): ...``
+        """
+        while True:
+            yield from page.get("data") or []
+
+            next_url = (page.get("links") or {}).get("next")
+            if not next_url:
+                return
+
+            # The key is only ever sent to the host the client was built for.
+            if not next_url.startswith(self._base_url + "/"):
+                raise LottevoError(
+                    f"Refusing to follow a next page outside {self._base_url}: {next_url}",
+                    code="unexpected_next_page",
+                )
+
+            page = self.request("GET", next_url[len(self._base_url):])
+
+
+def _flatten(values: Dict[str, Any], prefix: Optional[str] = None) -> List[Tuple[str, str]]:
+    pairs: List[Tuple[str, str]] = []
+    for key, value in values.items():
+        name = f"{prefix}[{key}]" if prefix else key
+        if value is None:
+            continue
+        if isinstance(value, dict):
+            pairs.extend(_flatten(value, name))
+        elif isinstance(value, (list, tuple)):
+            pairs.append((name, ",".join(str(item) for item in value)))
+        elif isinstance(value, bool):
+            pairs.append((name, "true" if value else "false"))
+        else:
+            pairs.append((name, str(value)))
+    return pairs

lottevo-0.1.0/lottevo.egg-info/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: lottevo
+Version: 0.1.0
+Summary: A thin Python client for the Lottevo lottery data API.
+Author-email: Lottevo <contact@lottevo.com>
+License-Expression: MIT
+Project-URL: Homepage, https://lottevo.com/docs/sdks
+Project-URL: Source, https://github.com/astefalabs/lottevo-python
+Project-URL: Issues, https://github.com/astefalabs/lottevo-python/issues
+Keywords: lottevo,lottery,results,api,sdk
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Lottevo Python
+
+A thin client for the [Lottevo](https://lottevo.com) lottery data API: results, jackpots, schedules,
+prize breakdowns and statistics for lotteries worldwide. Standard library only; Python 3.8+.
+
+```bash
+pip install lottevo
+```
+
+## First call
+
+```python
+from lottevo import Client
+
+lottevo = Client("lv_…")  # or set LOTTEVO_API_KEY and pass nothing
+
+account = lottevo.account.get()                              # the smoke test: plan, scopes, quota
+draws = lottevo.lotteries.draws("EU-002", {"per_page": 5})   # EuroJackpot's latest results
+
+for draw in draws["data"]:
+    print(draw["drawn_at"], *draw["numbers"])
+```
+
+Every operation of the API is a method on a resource — `lottevo.lotteries`, `.draws`, `.webhooks`,
+`.countries` … — and returns the decoded JSON. Path parameters come first, then the query (or, for
+`create`/`update`, the JSON body):
+
+```python
+lottevo.draws.list({"filter": {"lottery": ["EU-002", "RO-001"], "from": "2026-01-01"}, "include": "prizes"})
+lottevo.lotteries.check("EU-002", {"numbers": "4,7,12,31,44", "bonus": "8,11"})
+```
+
+## Pagination
+
+Listings are cursor-paginated. `paginate()` walks every page from the one you give it:
+
+```python
+for lottery in lottevo.paginate(lottevo.lotteries.list()):
+    print(lottery["code"])
+```
+
+## Errors
+
+A refused call raises `LottevoError`. Branch on `code`, not on the message:
+
+```python
+from lottevo import LottevoError
+
+try:
+    lottevo.lotteries.draws("US-001")
+except LottevoError as error:
+    if error.code == "lottery_not_entitled":
+        ...  # not in your plan
+```
+
+`error.status`, `error.request_id` and `error.retry_after` are there too; `lottevo.last_headers` holds
+the last answer's headers, including `x-quota-remaining`.
+
+## Options
+
+```python
+Client(api_key, locale="ro", timeout=30)
+```
+
+`locale` is sent as `Accept-Language`: game names, schedules and error messages come back in it.
+
+Full reference: <https://lottevo.com/docs/reference>.

lottevo-0.1.0/lottevo.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+lottevo/__init__.py
+lottevo/_resources.py
+lottevo/client.py
+lottevo/py.typed
+lottevo.egg-info/PKG-INFO
+lottevo.egg-info/SOURCES.txt
+lottevo.egg-info/dependency_links.txt
+lottevo.egg-info/top_level.txt

lottevo-0.1.0/lottevo.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lottevo-0.1.0/lottevo.egg-info/top_level.txt

@@ -0,0 +1 @@
+lottevo

lottevo-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lottevo"
+version = "0.1.0"
+description = "A thin Python client for the Lottevo lottery data API."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Lottevo", email = "contact@lottevo.com" }]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+    "Typing :: Typed",
+]
+keywords = ["lottevo", "lottery", "results", "api", "sdk"]
+dependencies = []
+
+[project.urls]
+Homepage = "https://lottevo.com/docs/sdks"
+Source = "https://github.com/astefalabs/lottevo-python"
+Issues = "https://github.com/astefalabs/lottevo-python/issues"
+
+[tool.setuptools]
+packages = ["lottevo"]
+
+[tool.setuptools.package-data]
+lottevo = ["py.typed"]

lottevo-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+