55tech 0.1.0__py3-none-any.whl

55tech-0.1.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: 55tech
+Version: 0.1.0
+Summary: Python client for the 55Tech REST and WebSocket APIs
+Keywords: 55tech,odds,betting,bookmaker,api,sdk
+Author: brandon-betdex
+Author-email: brandon-betdex <brandon@betdex.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: requests>=2.28
+Requires-Dist: websocket-client>=1.6
+Requires-Dist: zstandard>=0.22
+Requires-Python: >=3.10
+Project-URL: Documentation, https://docs.oddspapi.io
+Project-URL: Homepage, https://oddspapi.io
+Project-URL: Issues, https://github.com/brandon-betdex/55tech-sdk-python/issues
+Project-URL: Repository, https://github.com/brandon-betdex/55tech-sdk-python
+Description-Content-Type: text/markdown
+
+# 55tech
+
+A Python client for the [55Tech](https://oddspapi.io) REST and WebSocket APIs.
+
+Unofficial: not affiliated with or endorsed by 55Tech.
+
+```sh
+pip install 55tech
+```
+
+## REST
+
+```python
+from fiftyfivetech import FiftyFiveTechClient
+
+client = FiftyFiveTechClient(api_key)
+
+markets = client.get_markets(sport_id=10).markets
+fixtures = client.get_fixtures(sport_id=10).fixtures
+odds = client.get_fixture_odds(fixtures[0].fixture_id, bookmakers=["pinnacle"]).odds
+```
+
+Errors derive from `FiftyFiveTechError`.
+
+## Streaming
+
+```python
+import threading
+from fiftyfivetech.streaming import FixtureBook, Reconnect, SnapshotRequired, StreamListener
+
+listener = StreamListener()
+stream = client.create_stream(listener, channels=["odds", "bookmakers"],
+                              bookmakers=["pinnacle"], sport_ids=[10])
+threading.Thread(target=stream.start, daemon=True).start()
+
+# Seed each fixture you follow, after the stream is connected
+listener.apply_snapshot(client.get_fixture_odds(fixture_id, bookmakers=["pinnacle"]), ["pinnacle"])
+
+while True:
+    update = listener.output_queue.get()
+    if isinstance(update, FixtureBook):
+        if update.is_tradeable("pinnacle"):          # has odds, not stale, not suspended
+            record = update.get("pinnacle", outcome_id)
+            ...
+    elif isinstance(update, SnapshotRequired):
+        ...    # updates were missed: call apply_snapshot again for each fixture you follow
+    elif isinstance(update, Reconnect):
+        stream.stop()    # the gateway is about to close: start() again
+```
+
+The listener merges stream updates and snapshots into one `FixtureBook` per fixture, keeping the later `changed_at` per record.
+`remove_fixture` frees a finished one.
+
+`start()` raises `FiftyFiveTechSocketError` when the connection drops; call it again to reconnect and resume.

55tech-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+fiftyfivetech/__init__.py,sha256=2cVdjLzDpDHGIYgTsEVMCUVlHUNTo_2-naPFniNImZM,1133
+fiftyfivetech/bookmakers/__init__.py,sha256=CjYMI3rrXLQIKrGy6_E2n8tDxoWPP2_efp3CymitMzo,229
+fiftyfivetech/bookmakers/endpoints.py,sha256=vVoOi4WwnPVLdvH0dV3cHFsExHprTQx3fESYWAh0syU,925
+fiftyfivetech/bookmakers/resources.py,sha256=rkX3CVxp0qqgezlbUa2QB9EFlwkeEKh7VWTkhhTOk4w,1153
+fiftyfivetech/client.py,sha256=ReClD_ctQ8WRCkDwB5R_opoI1ScD6-w3SgoT-mJpHtQ,1087
+fiftyfivetech/connection.py,sha256=KIrviXM2Z75mTXUvr4ifT9AbO_lPVgaWuGFmxxPhFjo,6460
+fiftyfivetech/endpoints.py,sha256=vYJoC0xvkQfgZoOVu6fr-1IpeGW24Si1ebtZ-glgl-M,412
+fiftyfivetech/exceptions.py,sha256=AZx1yFc74POcHcwEM2l7HhkrzAWhpGtBLUAmOp3haxs,2984
+fiftyfivetech/fixtures/__init__.py,sha256=YyLRt2-Qx3zhaXKe-7XjDg2foojJcB6KdN3ccrbOQBM,700
+fiftyfivetech/fixtures/endpoints.py,sha256=PwEcMAYPcO8pGwSnpjWU00ClaA0aas4gcRihIWHUnUE,6438
+fiftyfivetech/fixtures/resources.py,sha256=Q2C6fHsE8eGmGuoKA56D8pFP365s16YetGdmF02E3LY,6487
+fiftyfivetech/markets/__init__.py,sha256=oc2V_VqGDf8S13DCb63yEwFn_i-tyswWvZe_lV_XimM,241
+fiftyfivetech/markets/endpoints.py,sha256=1vi5vtcX2KySZmj0HruJM-VlQPrlWcJopyljdPspuzE,1380
+fiftyfivetech/markets/resources.py,sha256=bIeqCszjvbthKPJ3kUIazw1A0IzNjuGGzjjQuY2VRt8,1454
+fiftyfivetech/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fiftyfivetech/resources.py,sha256=gNobotez-3Tp2rTjOIibBopH6JgMzuck4XeBUpWXgro,1318
+fiftyfivetech/streaming/__init__.py,sha256=Alu0sfbJUajJqseTXdB7dztEBhRDMY4uOCT7T8jrg9M,1158
+fiftyfivetech/streaming/endpoints.py,sha256=orb_Nu-xXKZBKI42K4PNmPRu2GC9rC8no-xJmG75FtI,2477
+fiftyfivetech/streaming/listener.py,sha256=6XEW6YUu2oZ6hLJYCu-c8QOOj1jmFI6hStyzu4j0lT4,10448
+fiftyfivetech/streaming/resources.py,sha256=fcMCqCYzX7DdJTI5373m1MQi_XnAcruLF1mqApKdhB4,7084
+fiftyfivetech/streaming/stream.py,sha256=V-SYyHUIMcyqMuJh2QeFU0jFZWTOR9JIVtPLwGpuac8,14430
+fiftyfivetech/utils.py,sha256=hs21EBs6HljwaQcpXSmrWnlzsMSpZ3s3XbxCOwgEhbI,8816
+55tech-0.1.0.dist-info/licenses/LICENSE,sha256=gZdVQd_H29XbJ3Q1DxxA9RL38EUr_lpFgLEDhiaRqYA,1072
+55tech-0.1.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+55tech-0.1.0.dist-info/METADATA,sha256=Vv_pqLKWEeNi_hp10TGKEEXQV9CB_nCxIKgykyWXyTc,3074
+55tech-0.1.0.dist-info/RECORD,,

55tech-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.24
+Root-Is-Purelib: true
+Tag: py3-none-any

55tech-0.1.0.dist-info/licenses/LICENSE

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

fiftyfivetech/__init__.py

@@ -0,0 +1,36 @@
+from fiftyfivetech import bookmakers, fixtures, markets, streaming, utils
+from fiftyfivetech.client import FiftyFiveTechClient
+from fiftyfivetech.connection import DEFAULT_BASE_URL, DEFAULT_STREAM_URL, FiftyFiveTechConnection
+from fiftyfivetech.exceptions import (
+    FiftyFiveTechAPIError,
+    FiftyFiveTechDecodeError,
+    FiftyFiveTechError,
+    FiftyFiveTechInvalidRequestError,
+    FiftyFiveTechSocketError,
+    FiftyFiveTechStreamAuthenticationError,
+    FiftyFiveTechTransportError,
+)
+from fiftyfivetech.streaming import FiftyFiveTechStream, StreamListener
+from fiftyfivetech.utils import DEFAULT_BATCH_SIZE
+
+__all__ = [
+    "DEFAULT_BASE_URL",
+    "DEFAULT_BATCH_SIZE",
+    "DEFAULT_STREAM_URL",
+    "FiftyFiveTechAPIError",
+    "FiftyFiveTechClient",
+    "FiftyFiveTechConnection",
+    "FiftyFiveTechDecodeError",
+    "FiftyFiveTechError",
+    "FiftyFiveTechInvalidRequestError",
+    "FiftyFiveTechSocketError",
+    "FiftyFiveTechStream",
+    "FiftyFiveTechStreamAuthenticationError",
+    "FiftyFiveTechTransportError",
+    "StreamListener",
+    "bookmakers",
+    "fixtures",
+    "markets",
+    "streaming",
+    "utils",
+]

fiftyfivetech/bookmakers/__init__.py

@@ -0,0 +1,8 @@
+from fiftyfivetech.bookmakers.endpoints import BookmakersEndpoints
+from fiftyfivetech.bookmakers.resources import Bookmaker, BookmakersResponse
+
+__all__ = [
+    "BookmakersEndpoints",
+    "Bookmaker",
+    "BookmakersResponse",
+]

fiftyfivetech/bookmakers/endpoints.py

@@ -0,0 +1,30 @@
+from collections.abc import Sequence
+
+from fiftyfivetech.bookmakers.resources import BookmakersResponse
+from fiftyfivetech.endpoints import Endpoints
+
+
+class BookmakersEndpoints(Endpoints):
+    """
+    The bookmaker catalogue.
+    """
+
+    def get_bookmakers(
+        self,
+        *,
+        bookmakers: Sequence[str] | None = None,
+        player_props: bool | None = None,
+    ) -> BookmakersResponse:
+        """
+        Fetch the bookmakers the key can see, with their freshness bounds:
+        ``GET /bookmakers``.
+
+        :param bookmakers: Slugs to fetch; all if omitted.
+        :param player_props: Only bookmakers offering player markets, if ``True``.
+        :returns: The bookmakers.
+        """
+        return self.conn.call(
+            BookmakersResponse, "GET", "/bookmakers", wrap="bookmakers", params={
+                "bookmakers": bookmakers,
+                "playerProps": player_props,
+            })

fiftyfivetech/bookmakers/resources.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+from fiftyfivetech.resources import BaseModel, Response
+
+
+@dataclass(kw_only=True, slots=True)
+class Bookmaker(BaseModel):
+    """
+    A bookmaker the key can see (``GET /bookmakers``).
+    """
+    slug: str
+    bookmaker_name: str
+    active: bool
+    domain: str | None = None
+    websocket_pregame: bool | None = None
+    websocket_live: bool | None = None
+    player_props: bool | None = None
+    max_delay_pregame_in_sec: float | None = None
+    max_delay_live_in_sec: float | None = None
+    max_delay_pregame_main_in_sec: float | None = None
+    available_countries: list[str] = field(default_factory=list)
+    available_sports: str | None = None
+    limit_currency: str | None = None
+    stale_threshold_sec: Any = None
+    stale_odds_since: datetime | None = None
+    last_odds_at: datetime | None = None
+
+
+@dataclass(kw_only=True, slots=True)
+class BookmakersResponse(Response):
+    """
+    The bookmaker catalogue (``GET /bookmakers``; the array is wrapped as ``bookmakers``).
+    """
+    bookmakers: list[Bookmaker] = field(default_factory=list)

fiftyfivetech/client.py

@@ -0,0 +1,38 @@
+import requests
+
+from fiftyfivetech.bookmakers import BookmakersEndpoints
+from fiftyfivetech.connection import DEFAULT_BASE_URL, DEFAULT_STREAM_URL, FiftyFiveTechConnection
+from fiftyfivetech.fixtures import FixturesEndpoints
+from fiftyfivetech.markets import MarketsEndpoints
+from fiftyfivetech.streaming import StreamingEndpoints
+
+
+class FiftyFiveTechClient(
+    BookmakersEndpoints,
+    MarketsEndpoints,
+    FixturesEndpoints,
+    StreamingEndpoints,
+):
+    """
+    Top-level client for 55Tech.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        stream_url: str = DEFAULT_STREAM_URL,
+        session: requests.Session | None = None,
+        timeout: float | None = 30.0,
+    ) -> None:
+        """
+        Create the client and its connection; see ``FiftyFiveTechConnection`` for parameters.
+        """
+        super().__init__(FiftyFiveTechConnection(
+            api_key,
+            base_url=base_url,
+            stream_url=stream_url,
+            session=session,
+            timeout=timeout,
+        ))

fiftyfivetech/connection.py

@@ -0,0 +1,169 @@
+import time
+from collections.abc import Mapping
+from datetime import datetime, timezone
+from typing import Any
+from urllib.parse import quote
+
+import requests
+
+from fiftyfivetech.exceptions import (
+    FiftyFiveTechAPIError,
+    FiftyFiveTechDecodeError,
+    FiftyFiveTechInvalidRequestError,
+    FiftyFiveTechTransportError,
+)
+from fiftyfivetech.utils import decode, format_query_params
+
+
+DEFAULT_BASE_URL = "https://v5.oddspapi.io/en"
+DEFAULT_STREAM_URL = "wss://v5.oddspapi.io/ws"
+
+
+class FiftyFiveTechConnection:
+    """
+    Where and how to reach the 55Tech API.
+
+    Every endpoint function takes one first::
+
+        conn = FiftyFiveTechConnection(api_key)
+        markets.get_markets(conn, sport_id=10)
+
+    :param api_key: API key, sent as the ``X-API-Key`` header and in the stream login.
+    :param base_url: API root, including the language segment: one of ``en``, ``es``,
+        ``fr``, ``pt``, ``de``, ``it``, ``ru``, ``zh``. Only names are translated.
+    :param stream_url: WebSocket gateway URL.
+    :param session: ``requests.Session`` to send through; created if omitted. Mount
+        your own adapter on it for retries or TCP keepalives.
+    :param timeout: Seconds to wait per request; ``None`` waits forever.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        stream_url: str = DEFAULT_STREAM_URL,
+        session: requests.Session | None = None,
+        timeout: float | None = 30.0,
+    ) -> None:
+        """
+        Create a connection; see the class docstring for parameters.
+        """
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.stream_url = stream_url
+        self.http = session or requests.Session()
+        self.timeout = timeout
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Mapping[str, Any] | None = None,
+        json: Any = None,
+    ) -> Any:
+        """
+        Send a request to any path, e.g. one this SDK does not cover yet.
+
+        :param method: HTTP method.
+        :param path: Path below ``base_url``, e.g. ``"/sports"``.
+        :param params: Query parameters; ``None`` dropped, lists comma-joined,
+            booleans lower-case.
+        :param json: Request body.
+        :returns: The decoded JSON body, or ``None`` if empty.
+        :raises FiftyFiveTechAPIError: On a non-2xx response.
+        :raises FiftyFiveTechTransportError: If no response was received.
+        :raises FiftyFiveTechDecodeError: If a 2xx body is not JSON.
+        """
+        return self._send(method, path, params, json)[0]
+
+    def call(
+        self,
+        model: Any,
+        method: str,
+        path: str,
+        *,
+        path_params: Mapping[str, str] | None = None,
+        params: Mapping[str, Any] | None = None,
+        json: Any = None,
+        wrap: str | None = None,
+    ) -> Any:
+        """
+        Send a request and decode the body into ``model``, stamped with its timings.
+
+        :param model: Response model to decode into.
+        :param method: HTTP method.
+        :param path: Path below ``base_url``, with ``{placeholders}``.
+        :param path_params: Placeholder values; URL-escaped.
+        :param params: Query parameters, encoded as in ``request``.
+        :param json: Request body.
+        :param wrap: For an array body, the key to wrap it under, e.g. ``"markets"``.
+        :returns: The decoded model.
+        :raises FiftyFiveTechInvalidRequestError: If a path parameter is empty.
+        :raises FiftyFiveTechDecodeError: If the body does not fit ``model``.
+        """
+        if path_params:
+            missing = [k for k, v in path_params.items() if not v]
+            if missing:
+                raise FiftyFiveTechInvalidRequestError(
+                    f"{path} needs a value for {', '.join(missing)}")
+            path = path.format_map(
+                {k: quote(str(v), safe="") for k, v in path_params.items()})
+        body, sent_at, received_at, latency_ms = self._send(method, path, params, json)
+        if wrap is not None:
+            if not isinstance(body, list):
+                raise FiftyFiveTechDecodeError(
+                    f"{method} {path}: expected a JSON array, got {body!r:.100}")
+            body = {wrap: body}
+        try:
+            result = decode(model, body or {})
+        except FiftyFiveTechDecodeError as exc:
+            raise FiftyFiveTechDecodeError(
+                f"{method} {path}: body does not fit {model.__name__}") from exc
+        result.sent_at = sent_at
+        result.received_at = received_at
+        result.latency_ms = latency_ms
+        return result
+
+    def _send(
+        self,
+        method: str,
+        path: str,
+        params: Mapping[str, Any] | None,
+        json: Any,
+    ) -> tuple[Any, datetime, datetime, float]:
+        """
+        Send a request, timing it.
+
+        :returns: The decoded JSON body (or ``None`` if empty), when it was sent and
+            when the response arrived (UTC), and the round trip in milliseconds.
+        """
+        sent_at = datetime.now(timezone.utc)
+        started = time.perf_counter()
+        try:
+            response = self.http.request(
+                method,
+                self.base_url + path,
+                params=format_query_params(params or {}),
+                json=json,
+                # The header keeps the key out of URLs, and so out of logs and errors.
+                headers={"Accept": "application/json", "X-API-Key": self.api_key},
+                timeout=self.timeout,
+            )
+        except requests.RequestException as exc:
+            raise FiftyFiveTechTransportError(
+                f"{method} {path} failed: {exc}", sent_at=sent_at,
+                latency_ms=(time.perf_counter() - started) * 1000) from exc
+        # The monotonic clock times the trip; the wall clock can jump.
+        latency_ms = (time.perf_counter() - started) * 1000
+        received_at = datetime.now(timezone.utc)
+        if not response.ok:
+            raise FiftyFiveTechAPIError(
+                response, sent_at=sent_at, received_at=received_at, latency_ms=latency_ms)
+        if not response.content:
+            return None, sent_at, received_at, latency_ms
+        try:
+            return response.json(), sent_at, received_at, latency_ms
+        except ValueError as exc:
+            raise FiftyFiveTechDecodeError(f"{method} {path} returned a non-JSON body") from exc

fiftyfivetech/endpoints.py

@@ -0,0 +1,15 @@
+from fiftyfivetech.connection import FiftyFiveTechConnection
+
+
+class Endpoints:
+    """
+    Base for the endpoint groups: holds the ``FiftyFiveTechConnection`` they send through.
+
+    :param conn: Connection to send through.
+    """
+
+    def __init__(self, conn: FiftyFiveTechConnection) -> None:
+        """
+        Create the group; see the class docstring for parameters.
+        """
+        self.conn = conn

fiftyfivetech/exceptions.py

@@ -0,0 +1,108 @@
+from datetime import datetime
+from typing import Any
+
+import requests
+
+
+class FiftyFiveTechError(Exception):
+    """
+    Base class for every error this SDK raises.
+    """
+
+
+class FiftyFiveTechInvalidRequestError(FiftyFiveTechError):
+    """
+    A call is missing a required value, or has one out of range; raised before
+    anything is sent.
+    """
+
+
+class FiftyFiveTechDecodeError(FiftyFiveTechError):
+    """
+    A 2xx response body or stream frame could not be decoded; the cause is the ``__cause__``.
+    """
+
+
+class FiftyFiveTechTransportError(FiftyFiveTechError):
+    """
+    The request got no response; the ``requests`` error is the ``__cause__``.
+    """
+
+    def __init__(self, message: str, *, sent_at: datetime, latency_ms: float) -> None:
+        super().__init__(message)
+        self.sent_at = sent_at
+        self.latency_ms = latency_ms
+
+
+class FiftyFiveTechSocketError(FiftyFiveTechError):
+    """
+    The stream's socket could not connect, failed, or was closed by the server;
+    any underlying error is the ``__cause__``.
+    """
+
+    def __init__(
+        self, message: str, *, close_code: int | None = None, close_reason: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.close_code = close_code
+        self.close_reason = close_reason
+
+
+class FiftyFiveTechStreamAuthenticationError(FiftyFiveTechError):
+    """
+    The stream refused the login, or did not answer it in time.
+    """
+
+    def __init__(self, message: str, reply: Any = None) -> None:
+        super().__init__(message)
+        self.reply = reply
+
+
+class FiftyFiveTechAPIError(FiftyFiveTechError):
+    """
+    The API answered with a non-2xx status.
+    """
+
+    def __init__(
+        self,
+        response: requests.Response,
+        *,
+        sent_at: datetime,
+        received_at: datetime,
+        latency_ms: float,
+    ) -> None:
+        try:
+            body: Any = response.json()
+        except ValueError:
+            body = response.text
+
+        code = message = details = None
+        if isinstance(body, dict):
+            code = body.get("code")
+            message = body.get("message")
+            details = body.get("details")
+
+        self.status_code = response.status_code
+        self.code = code
+        self.message = message
+        self.details = details
+        self.body = body
+        self.response = response
+        self.sent_at = sent_at
+        self.received_at = received_at
+        self.latency_ms = latency_ms
+        summary = message or response.reason or "error"
+        if code:
+            summary += f" ({code})"
+        super().__init__(f"{self.status_code} {summary}")
+
+    @property
+    def retry_after(self) -> float | None:
+        """
+        Seconds to wait before retrying, on a 429: the ``Retry-After`` header.
+        """
+        value = self.response.headers.get("Retry-After")
+        try:
+            return float(value) if value is not None else None
+        except ValueError:
+            return None

fiftyfivetech/fixtures/__init__.py

@@ -0,0 +1,37 @@
+from fiftyfivetech.fixtures.endpoints import FixturesEndpoints
+from fiftyfivetech.fixtures.resources import (
+    BookmakerFixtureMeta,
+    Clock,
+    Fixture,
+    FixtureMapping,
+    FixtureMappingResponse,
+    FixtureOddsResponse,
+    FixturesResponse,
+    FixtureStatus,
+    OddsRecord,
+    Participants,
+    Score,
+    Season,
+    Sport,
+    Tournament,
+    Venue,
+)
+
+__all__ = [
+    "FixturesEndpoints",
+    "BookmakerFixtureMeta",
+    "Clock",
+    "Fixture",
+    "FixtureMapping",
+    "FixtureMappingResponse",
+    "FixtureOddsResponse",
+    "FixtureStatus",
+    "FixturesResponse",
+    "OddsRecord",
+    "Participants",
+    "Score",
+    "Season",
+    "Sport",
+    "Tournament",
+    "Venue",
+]