strikerapi 0.1.0__py3-none-any.whl

strikerapi/__init__.py

@@ -0,0 +1,25 @@
+"""StrikerAPI: Python client for the StrikerAPI soccer data API."""
+from ._core import (
+    APIConnectionError,
+    APIError,
+    AuthError,
+    InsufficientCreditsError,
+    NotFoundError,
+    RateLimitError,
+    to_dataframe,
+)
+from ._version import __version__
+from .client import TOOLS, Client
+
+__all__ = [
+    "APIConnectionError",
+    "APIError",
+    "AuthError",
+    "Client",
+    "InsufficientCreditsError",
+    "NotFoundError",
+    "RateLimitError",
+    "TOOLS",
+    "__version__",
+    "to_dataframe",
+]

strikerapi/_core.py

@@ -0,0 +1,307 @@
+"""Shared runtime for the StrikerAPI Python client.
+
+Standard library only. The generated methods live in client.py and call
+``Client._call``; everything else (auth, retries, errors, credits headers) is here.
+"""
+from __future__ import annotations
+
+import json
+import os
+import socket
+import ssl
+import time
+import urllib.error
+import urllib.request
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+from ._version import __version__
+
+BRAND = "StrikerAPI"
+ENV_VAR = "STRIKERAPI_API_KEY"
+DEFAULT_BASE_URL = "https://mcp.strikerapi.com"
+SIGNUP_URL = "https://strikerapi.com/signup"
+DEFAULT_TIMEOUT = 60.0
+MAX_RETRIES = 3
+MAX_RETRY_WAIT = 30.0
+
+# A transport takes (method, url, headers, body, timeout) and returns
+# (status, headers, body). Header names in the returned dict are lowercase.
+Transport = Callable[
+    [str, str, Dict[str, str], Optional[bytes], float],
+    Tuple[int, Dict[str, str], bytes],
+]
+
+
+class APIError(Exception):
+    """Any error response from the API, or a failed connection."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        body: Any = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.body = body
+
+    def __str__(self) -> str:
+        if self.status_code:
+            return "%s (HTTP %s)" % (self.message, self.status_code)
+        return self.message
+
+
+class AuthError(APIError):
+    """401: the API key is missing, invalid or revoked."""
+
+
+class InsufficientCreditsError(APIError):
+    """402: the account does not have enough credits for this call."""
+
+
+class NotFoundError(APIError):
+    """404: the game, player, team or other id does not exist."""
+
+
+class RateLimitError(APIError):
+    """429: too many requests. ``retry_after`` is in seconds when the server sent it."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = 429,
+        body: Any = None,
+        retry_after: Optional[float] = None,
+    ) -> None:
+        super().__init__(message, status_code, body)
+        self.retry_after = retry_after
+
+
+class APIConnectionError(APIError):
+    """The request never got a response (DNS, TLS, timeout, reset)."""
+
+
+def _ssl_context() -> Optional[ssl.SSLContext]:
+    """Use certifi's CA bundle when it is installed, else the system default.
+
+    Some python.org installs on macOS ship without root certificates. Installing
+    certifi (or running the "Install Certificates" script) fixes the resulting
+    CERTIFICATE_VERIFY_FAILED error.
+    """
+    try:
+        import certifi
+    except ImportError:
+        return None
+    return ssl.create_default_context(cafile=certifi.where())
+
+
+def _urllib_transport(
+    method: str,
+    url: str,
+    headers: Dict[str, str],
+    body: Optional[bytes],
+    timeout: float,
+) -> Tuple[int, Dict[str, str], bytes]:
+    req = urllib.request.Request(url, data=body, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=timeout, context=_ssl_context()) as resp:
+            return (
+                resp.status,
+                {k.lower(): v for k, v in resp.headers.items()},
+                resp.read(),
+            )
+    except urllib.error.HTTPError as exc:
+        try:
+            payload = exc.read()
+        finally:
+            exc.close()
+        return (
+            exc.code,
+            {k.lower(): v for k, v in (exc.headers or {}).items()},
+            payload,
+        )
+    except (urllib.error.URLError, socket.timeout, ConnectionError, OSError) as exc:
+        reason = getattr(exc, "reason", exc)
+        raise APIConnectionError("Could not reach the API: %s" % (reason,)) from exc
+
+
+def _to_number(value: Optional[str]) -> Optional[Union[int, float]]:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except ValueError:
+        try:
+            return float(value)
+        except ValueError:
+            return None
+
+
+def _error_message(parsed: Any, raw: bytes, status: int) -> str:
+    if isinstance(parsed, dict):
+        err = parsed.get("error")
+        if isinstance(err, str) and err:
+            return err
+        if isinstance(err, dict) and isinstance(err.get("message"), str):
+            return err["message"]
+    text = raw.decode("utf-8", "replace").strip()
+    if text:
+        return text[:300]
+    return "HTTP %s" % status
+
+
+class BaseClient:
+    """Holds the key, base URL, retry policy and the last credit counters."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: Optional[str] = None,
+        timeout: float = DEFAULT_TIMEOUT,
+        max_retries: int = MAX_RETRIES,
+        transport: Optional[Transport] = None,
+    ) -> None:
+        key = api_key or os.environ.get(ENV_VAR)
+        if not key:
+            raise AuthError(
+                "No API key. Pass api_key=... or set %s. "
+                "A free key is at %s" % (ENV_VAR, SIGNUP_URL)
+            )
+        self.api_key = key
+        self.base_url = (base_url or os.environ.get(BRAND.upper() + "_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max(0, int(max_retries))
+        self._transport: Transport = transport or _urllib_transport
+        self._sleep: Callable[[float], None] = time.sleep
+        self.last_credits_used: Optional[Union[int, float]] = None
+        self.last_credits_remaining: Optional[Union[int, float]] = None
+
+    def __repr__(self) -> str:
+        return "<%s.Client base_url=%r>" % (BRAND, self.base_url)
+
+    def call(self, tool: str, arguments: Optional[Dict[str, Any]] = None) -> Any:
+        """Call any tool by name. Useful for tools newer than this package."""
+        return self._call(tool, arguments or {})
+
+    def _call(self, tool: str, arguments: Dict[str, Any]) -> Any:
+        payload = {k: v for k, v in arguments.items() if v is not None}
+        url = "%s/v1/%s" % (self.base_url, tool)
+        headers = {
+            "x-api-key": self.api_key,
+            "content-type": "application/json",
+            "accept": "application/json",
+            "user-agent": "%s-python/%s" % (BRAND.lower(), __version__),
+        }
+        body = json.dumps(payload).encode("utf-8")
+
+        attempt = 0
+        while True:
+            try:
+                status, resp_headers, raw = self._transport("POST", url, headers, body, self.timeout)
+            except APIConnectionError:
+                if attempt >= self.max_retries:
+                    raise
+                self._sleep(self._backoff(attempt, None))
+                attempt += 1
+                continue
+
+            self._record_credits(resp_headers)
+            if status == 429 or status >= 500:
+                if attempt < self.max_retries:
+                    self._sleep(self._backoff(attempt, self._retry_after(resp_headers)))
+                    attempt += 1
+                    continue
+            return self._handle(status, resp_headers, raw)
+
+    @staticmethod
+    def _retry_after(headers: Dict[str, str]) -> Optional[float]:
+        value = headers.get("retry-after")
+        if value is None:
+            return None
+        try:
+            return max(0.0, float(value))
+        except ValueError:
+            return None
+
+    @staticmethod
+    def _backoff(attempt: int, retry_after: Optional[float]) -> float:
+        if retry_after is not None:
+            return min(retry_after, MAX_RETRY_WAIT)
+        return min(0.5 * (2 ** attempt), MAX_RETRY_WAIT)
+
+    def _record_credits(self, headers: Dict[str, str]) -> None:
+        used = _to_number(headers.get("x-credits-used"))
+        remaining = _to_number(headers.get("x-credits-remaining"))
+        if used is not None:
+            self.last_credits_used = used
+        if remaining is not None:
+            self.last_credits_remaining = remaining
+
+    def _handle(self, status: int, headers: Dict[str, str], raw: bytes) -> Any:
+        try:
+            parsed = json.loads(raw.decode("utf-8")) if raw else None
+        except ValueError:
+            parsed = None
+
+        if 200 <= status < 300:
+            if parsed is None:
+                raise APIError("The API returned a response that is not JSON", status, raw[:300])
+            if isinstance(parsed, dict) and "data" in parsed:
+                return parsed["data"]
+            return parsed
+
+        message = _error_message(parsed, raw, status)
+        if status == 401:
+            raise AuthError(message, status, parsed)
+        if status == 402:
+            raise InsufficientCreditsError(message, status, parsed)
+        if status == 404:
+            raise NotFoundError(message, status, parsed)
+        if status == 429:
+            raise RateLimitError(message, status, parsed, self._retry_after(headers))
+        raise APIError(message, status, parsed)
+
+
+def _rows(data: Any, key: Optional[str]) -> List[Any]:
+    if key is not None:
+        cur = data
+        for part in key.split("."):
+            if not isinstance(cur, dict) or part not in cur:
+                raise KeyError("No %r in the response. Keys: %s" % (key, sorted(cur) if isinstance(cur, dict) else type(cur).__name__))
+            cur = cur[part]
+        if isinstance(cur, list):
+            return cur
+        return [cur]
+    if isinstance(data, list):
+        return data
+    if isinstance(data, dict):
+        lists = {k: v for k, v in data.items() if isinstance(v, list)}
+        records = {k: v for k, v in lists.items() if v and all(isinstance(r, dict) for r in v)}
+        pool = records or lists
+        if pool:
+            return pool[max(pool, key=lambda k: len(pool[k]))]
+        for v in data.values():
+            if isinstance(v, dict) and any(isinstance(x, list) for x in v.values()):
+                return _rows(v, None)
+        return [data]
+    return [data]
+
+
+def to_dataframe(data: Any, key: Optional[str] = None) -> Any:
+    """Turn a response into a pandas DataFrame.
+
+    ``data`` is what a client method returned. ``key`` names the list to use
+    (dots reach into nested dicts, for example ``"props"``). Without a key the
+    longest list of records in the response is used. Nested dicts are flattened
+    into dotted columns. pandas is imported here, so it stays optional.
+    """
+    try:
+        import pandas as pd
+    except ImportError as exc:  # pragma: no cover
+        raise ImportError("to_dataframe needs pandas: pip install pandas") from exc
+    rows = _rows(data, key)
+    if rows and all(isinstance(r, dict) for r in rows):
+        return pd.json_normalize(rows)
+    return pd.DataFrame(rows)

strikerapi/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

strikerapi/client.py

@@ -0,0 +1,799 @@
+"""Generated by packages/python/generate.py from the StrikerAPI OpenAPI spec. Do not edit by hand."""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from ._core import BaseClient
+
+#: Credits each tool costs, from the spec.
+TOOLS: Dict[str, int] = {
+    "list_teams": 1,
+    "list_games": 2,
+    "get_schedule": 2,
+    "get_game": 5,
+    "get_lineups": 5,
+    "get_standings": 2,
+    "get_ratings": 2,
+    "get_head_to_head": 2,
+    "search_players": 1,
+    "get_player": 5,
+    "get_player_games": 5,
+    "get_leaders": 5,
+    "get_team_stats": 5,
+    "get_events": 10,
+    "get_shot_map": 10,
+    "get_odds": 5,
+    "get_line_movement": 10,
+    "get_player_props": 10,
+    "get_prop_history": 10,
+}
+
+
+class Client(BaseClient):
+    """Client for the StrikerAPI API (soccer).
+
+    Create one with ``Client()`` (reads STRIKERAPI_API_KEY) or ``Client(api_key="...")``.
+    Every method returns the unwrapped ``data`` from the response.
+    ``last_credits_used`` and ``last_credits_remaining`` hold the counters from
+    the most recent response.
+    """
+
+    def list_teams(
+        self,
+        *,
+        season: Optional[Union[int, float, str]] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """List teams.
+
+        Use to find club ids and abbreviations for a season (default: the latest). Every other tool
+        takes a club as an id, abbreviation or name. Pass league for MLS (mls), La Liga (laliga), Serie
+        A (seriea), the Bundesliga (bundesliga), Ligue 1 (ligue1), the Champions League (ucl), the EFL
+        Championship (championship), the NWSL (nwsl), Liga MX (ligamx), the Europa League (uel), the
+        Conference League (uecl), the Eredivisie (eredivisie), the Primeira Liga (primeira), the
+        Scottish Premiership (scotland), Brazil's Serie A (brazil) or Argentina's Liga Profesional
+        (argentina); default: the Premier League. Costs 1 credit.
+
+        Costs 1 credit per call.
+
+        Args:
+            season (optional): Season by the year it starts: 2025 = 2025-26. MLS, the NWSL, Liga MX,
+                Brazil and Argentina: the calendar year. Default: the latest.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "list_teams",
+            {
+                "season": season,
+                "league": league,
+            },
+        )
+
+    def list_games(
+        self,
+        *,
+        season: Optional[Union[int, float, str]] = None,
+        stage: Optional[Literal["league", "knockout"]] = None,
+        team: Optional[str] = None,
+        date: Optional[str] = None,
+        from_: Optional[str] = None,
+        to: Optional[str] = None,
+        status: Optional[Literal["scheduled", "final"]] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """List games.
+
+        Use to list fixtures and results by season, stage, date, date range or club, newest first. For
+        upcoming fixtures with lines use get_schedule; for one match in full use get_game. Costs 2
+        credits.
+
+        Costs 2 credits per call.
+
+        Args:
+            season (optional): Season by the year it starts: 2025 = 2025-26. MLS, the NWSL, Liga MX,
+                Brazil and Argentina: the calendar year. Default: the latest.
+            stage (optional): league = league-table games (regular season, group stage, league phase);
+                knockout = qualifying, knockout rounds and playoffs.
+            team (optional): Club id, abbreviation or name.
+            date (optional): One date, YYYY-MM-DD (UTC).
+            from_ (optional): From date, YYYY-MM-DD.
+            to (optional): To date, YYYY-MM-DD.
+            status (optional): One of: scheduled, final.
+            limit (optional): Max matches (default 50).
+            offset (optional): Page offset; use next_offset.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "list_games",
+            {
+                "season": season,
+                "stage": stage,
+                "team": team,
+                "date": date,
+                "from": from_,
+                "to": to,
+                "status": status,
+                "limit": limit,
+                "offset": offset,
+                "league": league,
+            },
+        )
+
+    def get_schedule(
+        self,
+        *,
+        days: Optional[int] = None,
+        team: Optional[str] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Schedule.
+
+        Use for upcoming fixtures (next 1-30 days, default 7) with the median three-way line across
+        posted sportsbooks (home, draw, away moneylines, goal total, handicap) and its implied
+        probabilities. For every book's line use get_odds. Costs 2 credits.
+
+        Costs 2 credits per call.
+
+        Args:
+            days (optional): Days ahead (default 7).
+            team (optional): Club id, abbreviation or name.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_schedule",
+            {
+                "days": days,
+                "team": team,
+                "league": league,
+            },
+        )
+
+    def get_game(
+        self,
+        game_id: str,
+        *,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Game.
+
+        Use for one match in full: score (with shootout), both clubs' box scores (possession, shots, xG,
+        passing, discipline), every player's line, the key events (goals, cards, substitutions,
+        penalties, VAR) and each sportsbook's opening and closing line. For every event use get_events;
+        for formations use get_lineups. Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            game_id: ESPN match id, from list_games or get_schedule.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_game",
+            {
+                "game_id": game_id,
+                "league": league,
+            },
+        )
+
+    def get_lineups(
+        self,
+        game_id: str,
+        *,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Lineups.
+
+        Use for a match's lineups: each club's formation, starting XI with positions and formation
+        slots, the substitutes used with the minute they came on (and who went off when), and the unused
+        bench. Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            game_id: ESPN match id, from list_games or get_schedule.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_lineups",
+            {
+                "game_id": game_id,
+                "league": league,
+            },
+        )
+
+    def get_standings(
+        self,
+        *,
+        season: Optional[Union[int, float, str]] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil"]] = None,
+    ) -> Any:
+        """Standings.
+
+        Use for a season's league table: rank, played, won, drawn, lost, goals for and against, goal
+        difference, points (official, with any deduction), qualification or relegation note, plus home
+        and away records and recent form. Champions League: one table per group or the league phase.
+        Costs 2 credits.
+
+        Costs 2 credits per call.
+
+        Args:
+            season (optional): Season by the year it starts: 2025 = 2025-26. MLS, the NWSL, Liga MX,
+                Brazil and Argentina: the calendar year. Default: the latest.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, uel, uecl, eredivisie, primeira, scotland,
+                brazil.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_standings",
+            {
+                "season": season,
+                "league": league,
+            },
+        )
+
+    def get_ratings(
+        self,
+        *,
+        date: Optional[str] = None,
+        limit: Optional[int] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Ratings.
+
+        Use for our club Elo ratings, strongest first, as of the latest match (or as of date). A
+        100-point gap is about a 64% expected score for the stronger side at a neutral venue. Costs 2
+        credits.
+
+        Costs 2 credits per call.
+
+        Args:
+            date (optional): Ratings as of this day, YYYY-MM-DD (default: the latest).
+            limit (optional): Max clubs (default 50).
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_ratings",
+            {
+                "date": date,
+                "limit": limit,
+                "league": league,
+            },
+        )
+
+    def get_head_to_head(
+        self,
+        team: str,
+        opponent: str,
+        *,
+        limit: Optional[int] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Head to head.
+
+        Use for two clubs' meetings in this competition: wins, draws and goals each, the first meeting,
+        and the results newest first. Costs 2 credits.
+
+        Costs 2 credits per call.
+
+        Args:
+            team: Club id, abbreviation or name.
+            opponent: The other club.
+            limit (optional): Max results listed (default 20); the summary counts every meeting.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_head_to_head",
+            {
+                "team": team,
+                "opponent": opponent,
+                "limit": limit,
+                "league": league,
+            },
+        )
+
+    def search_players(
+        self,
+        name: str,
+        *,
+        team: Optional[str] = None,
+        limit: Optional[int] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Search players.
+
+        Use to find a player's id by name (accents optional), optionally within a club. Returns
+        position, current club, last season and appearances. Costs 1 credit.
+
+        Costs 1 credit per call.
+
+        Args:
+            name: Full or partial name, e.g. Saka.
+            team (optional): Club id, abbreviation or name.
+            limit (optional): limit
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "search_players",
+            {
+                "name": name,
+                "team": team,
+                "limit": limit,
+                "league": league,
+            },
+        )
+
+    def get_player(
+        self,
+        player_id: str,
+        *,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Player.
+
+        Use for one player: profile, per-season appearances, starts, minutes, goals, assists, shots, our
+        xG, cards and goalkeeping (saves, clean sheets) with per-90 rates, and the last 10 matches.
+        Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            player_id: ESPN player id (search_players).
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_player",
+            {
+                "player_id": player_id,
+                "league": league,
+            },
+        )
+
+    def get_player_games(
+        self,
+        player_id: str,
+        *,
+        season: Optional[Union[int, float, str]] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Player games.
+
+        Use for a player's match log, newest first: opponent, score, minutes on and off, goals, assists,
+        shots, xG, fouls, cards and goalkeeping. Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            player_id: ESPN player id.
+            season (optional): One season (the year it starts).
+            limit (optional): limit
+            offset (optional): offset
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_player_games",
+            {
+                "player_id": player_id,
+                "season": season,
+                "limit": limit,
+                "offset": offset,
+                "league": league,
+            },
+        )
+
+    def get_leaders(
+        self,
+        *,
+        stat: Optional[Literal["goals", "assists", "goal_contributions", "shots", "shots_on_target", "xg", "yellow_cards", "red_cards", "saves", "clean_sheets"]] = None,
+        season: Optional[Union[int, float, str]] = None,
+        per90: Optional[bool] = None,
+        min_games: Optional[int] = None,
+        limit: Optional[int] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Leaders.
+
+        Use for a season's leaders in goals, assists, goal contributions, shots, shots on target, our
+        xG, cards, saves or clean sheets, as totals or per 90 minutes (per90, with a minimum of 10
+        matches by default). Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            stat (optional): Default goals. One of: goals, assists, goal_contributions, shots,
+                shots_on_target, xg, yellow_cards, red_cards, saves, clean_sheets.
+            season (optional): Season by the year it starts (default: the latest).
+            per90 (optional): Rank by the rate per 90 minutes.
+            min_games (optional): Minimum appearances.
+            limit (optional): limit
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_leaders",
+            {
+                "stat": stat,
+                "season": season,
+                "per90": per90,
+                "min_games": min_games,
+                "limit": limit,
+                "league": league,
+            },
+        )
+
+    def get_team_stats(
+        self,
+        *,
+        season: Optional[Union[int, float, str]] = None,
+        team: Optional[str] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Team stats.
+
+        Use for clubs' per-match averages over a season, for and against: goals, our xG, shots, shots on
+        target, possession, pass accuracy, corners, fouls, cards, tackles, clean sheets. Costs 5
+        credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            season (optional): Season by the year it starts (default: the latest).
+            team (optional): One club.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_team_stats",
+            {
+                "season": season,
+                "team": team,
+                "league": league,
+            },
+        )
+
+    def get_events(
+        self,
+        game_id: str,
+        *,
+        kind: Optional[Literal["goals", "shots", "cards", "substitutions", "set_pieces", "fouls", "all"]] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Events.
+
+        Use for a match's events in order: goals (with assister, own goals, penalties), shots with
+        location, outcome, body part and our xG, cards, substitutions, fouls, corners, offsides and VAR
+        decisions. Filter with kind. Older matches carry goals, cards and substitutions only. Costs 10
+        credits.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id: ESPN match id.
+            kind (optional): goals, shots, cards, substitutions, set_pieces, fouls or all (default).
+            limit (optional): Max events (default 300).
+            offset (optional): Page offset; use next_offset.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_events",
+            {
+                "game_id": game_id,
+                "kind": kind,
+                "limit": limit,
+                "offset": offset,
+                "league": league,
+            },
+        )
+
+    def get_shot_map(
+        self,
+        *,
+        team: Optional[str] = None,
+        player: Optional[str] = None,
+        against: Optional[bool] = None,
+        season: Optional[Union[int, float, str]] = None,
+        game_id: Optional[str] = None,
+        include_shots: Optional[bool] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Shot map.
+
+        Use for a shot map: a club's shots (or, with against, the shots it conceded), a player's, or one
+        match's, for a season (default: the latest). Returns totals and zones (six-yard box, penalty
+        area, outside the box, penalties) with goals, shots on target, xG and conversion, and every
+        located shot with its x/y, end point, outcome and xG. Costs 10 credits.
+
+        Costs 10 credits per call.
+
+        Args:
+            team (optional): Club id, abbreviation or name.
+            player (optional): Player id (search_players).
+            against (optional): With team: the shots it conceded.
+            season (optional): Season by the year it starts (default: the latest).
+            game_id (optional): One match instead of a season.
+            include_shots (optional): false = totals and zones only.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_shot_map",
+            {
+                "team": team,
+                "player": player,
+                "against": against,
+                "season": season,
+                "game_id": game_id,
+                "include_shots": include_shots,
+                "league": league,
+            },
+        )
+
+    def get_odds(
+        self,
+        *,
+        game_id: Optional[str] = None,
+        date: Optional[str] = None,
+        season: Optional[Union[int, float, str]] = None,
+        team: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Odds.
+
+        Use for betting lines: each sportsbook's three-way moneyline (home, draw, away), goal handicap
+        and total (opening and closing from June 2020 for 16 competitions from The Odds API, and from
+        2024 from ESPN; ESPN's final pre-match line before that), the no-margin probabilities each
+        book's prices imply, and for finished matches the result and whether the total went over against
+        the median close. Pass game_id for one match (5 credits), date for a day's matches (10 credits),
+        or season (optionally a team) for a season of priced matches, 2 credits per match returned, up
+        to 100 a page.
+
+        Costs 5 credits per call.
+
+        Args:
+            game_id (optional): One match.
+            date (optional): A day's matches, YYYY-MM-DD (UTC).
+            season (optional): A season of priced matches, by the year it starts (2025 = 2025-26; MLS,
+                the NWSL, Liga MX, Brazil and Argentina: the calendar year).
+            team (optional): With season: one club's matches.
+            limit (optional): With season: matches per page (default 50).
+            offset (optional): With season: page offset; use next_offset.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_odds",
+            {
+                "game_id": game_id,
+                "date": date,
+                "season": season,
+                "team": team,
+                "limit": limit,
+                "offset": offset,
+                "league": league,
+            },
+        )
+
+    def get_line_movement(
+        self,
+        game_id: str,
+        *,
+        provider: Optional[str] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl", "championship", "nwsl", "ligamx", "uel", "uecl", "eredivisie", "primeira", "scotland", "brazil", "argentina"]] = None,
+    ) -> Any:
+        """Line movement.
+
+        Use to see how a match's line moved before kick-off: our pre-game snapshots of each sportsbook's
+        three-way moneyline, handicap and total (ESPN's once a day, The Odds API's every hour for
+        matches in the next two days). Costs 10 credits.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id: Match id.
+            provider (optional): One sportsbook, e.g. DraftKings.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl, championship, nwsl, ligamx, uel, uecl, eredivisie, primeira,
+                scotland, brazil, argentina.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_line_movement",
+            {
+                "game_id": game_id,
+                "provider": provider,
+                "league": league,
+            },
+        )
+
+    def get_player_props(
+        self,
+        *,
+        game_id: Optional[str] = None,
+        player_id: Optional[str] = None,
+        from_date: Optional[str] = None,
+        to_date: Optional[str] = None,
+        market: Optional[Literal["player_goal_scorer_anytime"]] = None,
+        bookmaker: Optional[str] = None,
+        snapshot_type: Optional[Literal["opening", "closing"]] = None,
+        estimate_only: Optional[bool] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl"]] = None,
+    ) -> Any:
+        """Player props.
+
+        Use for player prop lines by sportsbook: the anytime goalscorer price, Yes in over_odds (and No
+        in under_odds where a book posts it), with no line, from DraftKings, FanDuel, William Hill and
+        Pinnacle as the archive holds them. Pass game_id for every player's props in one game (10
+        credits), or player_id with from_date (and to_date) for one player across games (10 credits per
+        game returned, up to 100). Returns the closing line by default (the last before the game starts)
+        or the opening line, with each book's over and under prices. Set estimate_only to get the price
+        without being charged.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id (optional): Game id: every player's props for that game.
+            player_id (optional): Player id (e.g. 280555) from search_players. With from_date: that
+                player's props across games.
+            from_date (optional): With player_id: first date, YYYY-MM-DD (the game's date).
+            to_date (optional): With player_id: last date (default: no end), YYYY-MM-DD (the game's
+                date).
+            market (optional): One market: player_goal_scorer_anytime (anytime goalscorer (over =
+                scores))
+            bookmaker (optional): Bookmaker key, e.g. draftkings, fanduel, pinnacle.
+            snapshot_type (optional): closing (default): the last line before the game starts. opening:
+                the first one captured.
+            estimate_only (optional): Return what this call would cost, without charging or running it.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_player_props",
+            {
+                "game_id": game_id,
+                "player_id": player_id,
+                "from_date": from_date,
+                "to_date": to_date,
+                "market": market,
+                "bookmaker": bookmaker,
+                "snapshot_type": snapshot_type,
+                "estimate_only": estimate_only,
+                "league": league,
+            },
+        )
+
+    def get_prop_history(
+        self,
+        player_id: str,
+        market: Literal["player_goal_scorer_anytime"],
+        *,
+        from_date: Optional[str] = None,
+        to_date: Optional[str] = None,
+        bookmaker: Optional[str] = None,
+        limit: Optional[int] = None,
+        league: Optional[Literal["soccer", "mls", "laliga", "seriea", "bundesliga", "ligue1", "ucl"]] = None,
+    ) -> Any:
+        """Prop history.
+
+        Use to see how a player did against his prop line over time: for one market (anytime goalscorer:
+        one row per match with the closing price and whether he scored), one row per game with the
+        closing line (the median across books, or one book's), the opening line, the prices, what the
+        player actually recorded from our box scores and the result against the line, plus the over
+        rate. Costs 10 credits for up to 200 games. over_odds is the Yes price; result is over when he
+        scored, under when he played and did not, and null when he was not in the squad or on the pitch
+        (a void).
+
+        Costs 10 credits per call.
+
+        Args:
+            player_id: Player id (e.g. 280555) from search_players.
+            market: The market: player_goal_scorer_anytime (anytime goalscorer (over = scores))
+            from_date (optional): First date, YYYY-MM-DD (the game's date).
+            to_date (optional): Last date, YYYY-MM-DD (the game's date).
+            bookmaker (optional): One book's closing line instead of the median across books, e.g.
+                draftkings.
+            limit (optional): Games to return, oldest first (default 50, max 200). next_from_date says
+                where to continue.
+            league (optional): League. Defaults to soccer. One of: soccer, mls, laliga, seriea,
+                bundesliga, ligue1, ucl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_prop_history",
+            {
+                "player_id": player_id,
+                "market": market,
+                "from_date": from_date,
+                "to_date": to_date,
+                "bookmaker": bookmaker,
+                "limit": limit,
+                "league": league,
+            },
+        )

strikerapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,189 @@
+Metadata-Version: 2.5
+Name: strikerapi
+Version: 0.1.0
+Summary: Python client for the StrikerAPI soccer data API. No dependencies.
+Project-URL: Homepage, https://strikerapi.com
+Project-URL: Documentation, https://strikerapi.com/docs
+Project-URL: Repository, https://github.com/noahowsh/puckapi
+Project-URL: Sign up, https://strikerapi.com/signup
+Author-email: StrikerAPI <support@strikerapi.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api-client,betting,odds,player-props,soccer,sports-data,strikerapi
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: pandas
+Requires-Dist: pandas>=1.5; extra == 'pandas'
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# StrikerAPI for Python
+
+Python client for the [StrikerAPI](https://strikerapi.com) soccer data API. It has no required dependencies (standard library only) and works on Python 3.9 and newer. Pandas is optional.
+
+## Install
+
+```bash
+pip install strikerapi
+pip install "strikerapi[pandas]"   # only if you want DataFrames
+```
+
+## Set your key
+
+Get a free key at https://strikerapi.com/signup. Free accounts get 500 credits a month.
+
+```bash
+export STRIKERAPI_API_KEY=your_key_here
+```
+
+```python
+from strikerapi import Client
+
+client = Client()                      # reads STRIKERAPI_API_KEY
+client = Client(api_key="your_key")    # or pass it in
+```
+
+## Examples
+
+### 1. A league table
+
+Pass `league` to pick a competition. Here is MLS.
+
+```python
+from strikerapi import Client, to_dataframe
+
+client = Client()
+
+table = client.get_standings(league="mls")
+df = to_dataframe(table, key="standings")
+print(df[["group_name", "rank", "display_name", "played", "points"]].head(10))
+```
+
+### 2. Top scorers per 90 minutes
+
+`get_leaders` can rank by the raw count or per 90 minutes.
+
+```python
+from strikerapi import Client
+
+client = Client()
+
+leaders = client.get_leaders(stat="goals", league="mls", per90=True, limit=5)
+print(leaders)
+```
+
+### 3. Find a player and see his recent games
+
+`search_players` finds the id, `get_player_games` returns his match log.
+
+```python
+from strikerapi import Client
+
+client = Client()
+
+haaland = client.search_players("Haaland", limit=1)["players"][0]
+games = client.get_player_games(haaland["player_id"], limit=5)
+print(haaland["name"], games)
+```
+
+## Credits
+
+Every method returns the `data` object from the response. After each call, `client.last_credits_used` and `client.last_credits_remaining` hold the counters from the `X-Credits-Used` and `X-Credits-Remaining` headers. Methods that take `estimate_only=True` return the price of a call without running or charging it.
+
+## Pandas
+
+```python
+from strikerapi import to_dataframe
+
+df = to_dataframe(data)                # finds the main list in the response
+df = to_dataframe(data, key="rows")    # or name the list yourself
+```
+
+Nested fields become dotted columns. Install pandas separately or with `pip install "strikerapi[pandas]"`.
+
+## Errors
+
+Every error is an `APIError` subclass, with the server's message and the HTTP status.
+
+| Exception | Status | Meaning |
+| --- | --- | --- |
+| `AuthError` | 401 | Missing, invalid or revoked key |
+| `InsufficientCreditsError` | 402 | Not enough credits for the call |
+| `NotFoundError` | 404 | The id or name does not exist |
+| `RateLimitError` | 429 | Too many requests; has `.retry_after` when the server sends it |
+| `APIError` | 400, 5xx | Bad arguments or a server problem |
+| `APIConnectionError` | none | No response (network or timeout) |
+
+```python
+from strikerapi import Client, APIError, InsufficientCreditsError, RateLimitError
+
+client = Client()
+try:
+    data = client.list_teams()
+except InsufficientCreditsError:
+    print("Out of credits, top up at https://strikerapi.com")
+except RateLimitError as exc:
+    print("Slow down, retry after", exc.retry_after)
+except APIError as exc:
+    print(exc.status_code, exc.message)
+```
+
+The client retries 429 and 5xx responses and connection failures up to 3 times with backoff, and honors `Retry-After`. Set `Client(max_retries=0)` to turn that off.
+
+If you see `CERTIFICATE_VERIFY_FAILED` on a python.org install for macOS, run the "Install Certificates.command" script that came with Python, or `pip install certifi` (the client uses it when present).
+
+## Options
+
+```python
+Client(
+    api_key=None,                          # defaults to $STRIKERAPI_API_KEY
+    base_url="https://mcp.strikerapi.com",           # point at another host
+    timeout=60.0,                          # seconds per request
+    max_retries=3,
+)
+```
+
+`client.call("tool_name", {"arg": "value"})` calls any tool by name, which helps when the API adds a tool before this package does.
+
+## Tools
+
+Method names match the API tool names. Arguments are keyword arguments; required ones can also be passed positionally. Each method's docstring lists its arguments (`help(client.list_teams)`).
+
+| Method | Credits | What it does |
+| --- | --- | --- |
+| `list_teams` | 1 | List teams |
+| `list_games` | 2 | List games |
+| `get_schedule` | 2 | Schedule |
+| `get_game` | 5 | Game |
+| `get_lineups` | 5 | Lineups |
+| `get_standings` | 2 | Standings |
+| `get_ratings` | 2 | Ratings |
+| `get_head_to_head` | 2 | Head to head |
+| `search_players` | 1 | Search players |
+| `get_player` | 5 | Player |
+| `get_player_games` | 5 | Player games |
+| `get_leaders` | 5 | Leaders |
+| `get_team_stats` | 5 | Team stats |
+| `get_events` | 10 | Events |
+| `get_shot_map` | 10 | Shot map |
+| `get_odds` | 5 | Odds |
+| `get_line_movement` | 10 | Line movement |
+| `get_player_props` | 10 | Player props |
+| `get_prop_history` | 10 | Prop history |
+
+Full API reference: https://strikerapi.com/docs
+
+## License
+
+MIT

strikerapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+strikerapi/__init__.py,sha256=PtYwDM6xwn5CkrO3FGz26f_VmDbR5796cebDo8zTPmo,514
+strikerapi/_core.py,sha256=pfLGo1z21KGgQcIi3ii9xL7FzTydjr7Bbw5PNPajIAc,10609
+strikerapi/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+strikerapi/client.py,sha256=Y865ZxajyvkYOR6tSLYqVWw7GNSouTS4rAzie6qNpEk,33077
+strikerapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+strikerapi-0.1.0.dist-info/METADATA,sha256=XP_mAxFv4UTmBWwKdSTPqsIAZABcvHDU0nva6o9BZtc,6206
+strikerapi-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+strikerapi-0.1.0.dist-info/licenses/LICENSE,sha256=WKIp5NCP-OXFw6DNzFGZrxcR9NxNsMJyVZdN4DDRl2s,1067
+strikerapi-0.1.0.dist-info/RECORD,,

strikerapi-0.1.0.dist-info/WHEEL

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

strikerapi-0.1.0.dist-info/licenses/LICENSE

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