mirror of
https://github.com/hanzoskill/odds-checker-api.git
synced 2026-10-30 21:12:51 +00:00
332 lines
11 KiB
Python
332 lines
11 KiB
Python
#!/usr/bin/env python3
|
|
"""Minimal CLI for Odds-API.io (v3)."""
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import sys
|
|
import urllib.error
|
|
import urllib.parse
|
|
import urllib.request
|
|
|
|
DEFAULT_BASE_URL = "https://api.odds-api.io/v3"
|
|
|
|
|
|
def build_url(base_url, path, params):
|
|
base = base_url.rstrip("/")
|
|
clean_params = {k: v for k, v in params.items() if v is not None}
|
|
query = urllib.parse.urlencode(clean_params)
|
|
if query:
|
|
return f"{base}{path}?{query}"
|
|
return f"{base}{path}"
|
|
|
|
|
|
def request_json(url, timeout):
|
|
req = urllib.request.Request(url, headers={"Accept": "application/json"})
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=timeout) as resp:
|
|
raw = resp.read()
|
|
charset = resp.headers.get_content_charset() or "utf-8"
|
|
text = raw.decode(charset, errors="replace")
|
|
except urllib.error.HTTPError as exc:
|
|
body = exc.read().decode("utf-8", errors="replace")
|
|
raise RuntimeError(f"HTTP {exc.code} {exc.reason}: {body}") from exc
|
|
except urllib.error.URLError as exc:
|
|
raise RuntimeError(f"Network error: {exc.reason}") from exc
|
|
|
|
try:
|
|
return json.loads(text)
|
|
except json.JSONDecodeError as exc:
|
|
raise RuntimeError(f"Unexpected non-JSON response: {text[:200]}") from exc
|
|
|
|
|
|
def get_api_key(args, required):
|
|
key = args.api_key or os.getenv("ODDS_API_KEY")
|
|
if required and not key:
|
|
raise RuntimeError("Missing API key. Set ODDS_API_KEY or pass --api-key.")
|
|
return key
|
|
|
|
|
|
def slug_from(obj):
|
|
if isinstance(obj, dict):
|
|
return obj.get("slug") or obj.get("name")
|
|
return obj
|
|
|
|
|
|
def format_event(event):
|
|
event_id = event.get("id")
|
|
home = event.get("home") or ""
|
|
away = event.get("away") or ""
|
|
date = event.get("date") or ""
|
|
status = event.get("status") or ""
|
|
sport_slug = slug_from(event.get("sport")) or ""
|
|
league_slug = slug_from(event.get("league")) or ""
|
|
|
|
league_part = f"{sport_slug}/{league_slug}".strip("/")
|
|
parts = [str(event_id), date, league_part, f"{home} vs {away}", status]
|
|
return " | ".join([p for p in parts if p])
|
|
|
|
|
|
def print_events(events, limit):
|
|
if limit is not None:
|
|
events = events[:limit]
|
|
for event in events:
|
|
print(format_event(event))
|
|
|
|
|
|
def print_json(data):
|
|
print(json.dumps(data, indent=2, sort_keys=True))
|
|
|
|
|
|
def command_sports(args):
|
|
url = build_url(args.base_url, "/sports", {})
|
|
if args.dry_run:
|
|
print(url)
|
|
return 0
|
|
data = request_json(url, args.timeout)
|
|
if args.json:
|
|
print_json(data)
|
|
return 0
|
|
|
|
for sport in data:
|
|
name = sport.get("name")
|
|
slug = sport.get("slug")
|
|
if name and slug:
|
|
print(f"{slug} - {name}")
|
|
else:
|
|
print_json(sport)
|
|
return 0
|
|
|
|
|
|
def command_bookmakers(args):
|
|
url = build_url(args.base_url, "/bookmakers", {})
|
|
if args.dry_run:
|
|
print(url)
|
|
return 0
|
|
data = request_json(url, args.timeout)
|
|
if args.json:
|
|
print_json(data)
|
|
return 0
|
|
|
|
for bookmaker in data:
|
|
active = bookmaker.get("active")
|
|
if not args.all and not active:
|
|
continue
|
|
status = "active" if active else "inactive"
|
|
name = bookmaker.get("name")
|
|
print(f"{name} ({status})")
|
|
return 0
|
|
|
|
|
|
def command_events(args):
|
|
api_key = get_api_key(args, required=True)
|
|
params = {
|
|
"apiKey": api_key,
|
|
"sport": args.sport,
|
|
"league": args.league,
|
|
"participantId": args.participant_id,
|
|
"status": args.status,
|
|
"from": args.from_time,
|
|
"to": args.to_time,
|
|
"bookmaker": args.bookmaker,
|
|
}
|
|
url = build_url(args.base_url, "/events", params)
|
|
if args.dry_run:
|
|
print(url)
|
|
return 0
|
|
data = request_json(url, args.timeout)
|
|
if args.json:
|
|
print_json(data)
|
|
else:
|
|
print_events(data, args.limit)
|
|
return 0
|
|
|
|
|
|
def filter_events(events, sport_slug=None, league_slug=None):
|
|
if not sport_slug and not league_slug:
|
|
return events
|
|
filtered = []
|
|
for event in events:
|
|
sport = slug_from(event.get("sport"))
|
|
league = slug_from(event.get("league"))
|
|
if sport_slug and sport_slug != sport:
|
|
continue
|
|
if league_slug and league_slug != league:
|
|
continue
|
|
filtered.append(event)
|
|
return filtered
|
|
|
|
|
|
def command_search(args):
|
|
api_key = get_api_key(args, required=True)
|
|
params = {
|
|
"apiKey": api_key,
|
|
"query": args.query,
|
|
}
|
|
url = build_url(args.base_url, "/events/search", params)
|
|
if args.dry_run:
|
|
print(url)
|
|
return 0
|
|
data = request_json(url, args.timeout)
|
|
data = filter_events(data, args.sport, args.league)
|
|
if args.json:
|
|
print_json(data)
|
|
else:
|
|
print_events(data, args.limit)
|
|
return 0
|
|
|
|
|
|
def command_odds(args):
|
|
api_key = get_api_key(args, required=True)
|
|
params = {
|
|
"apiKey": api_key,
|
|
"eventId": args.event_id,
|
|
"bookmakers": args.bookmakers,
|
|
}
|
|
url = build_url(args.base_url, "/odds", params)
|
|
if args.dry_run:
|
|
print(url)
|
|
return 0
|
|
data = request_json(url, args.timeout)
|
|
if args.summary:
|
|
home = data.get("home")
|
|
away = data.get("away")
|
|
date = data.get("date")
|
|
status = data.get("status")
|
|
bookmakers = sorted((data.get("bookmakers") or {}).keys())
|
|
print(f"{home} vs {away}")
|
|
if date:
|
|
print(f"date: {date}")
|
|
if status:
|
|
print(f"status: {status}")
|
|
if bookmakers:
|
|
print("bookmakers:")
|
|
for name in bookmakers:
|
|
print(f"- {name}")
|
|
else:
|
|
print_json(data)
|
|
return 0
|
|
|
|
|
|
def command_matchup(args):
|
|
api_key = get_api_key(args, required=True)
|
|
query = args.query
|
|
if not query:
|
|
if not args.home or not args.away:
|
|
raise RuntimeError("Provide --query or both --home and --away.")
|
|
query = f"{args.home} vs {args.away}"
|
|
|
|
params = {
|
|
"apiKey": api_key,
|
|
"query": query,
|
|
}
|
|
url = build_url(args.base_url, "/events/search", params)
|
|
if args.dry_run:
|
|
print(url)
|
|
return 0
|
|
|
|
events = request_json(url, args.timeout)
|
|
events = filter_events(events, args.sport, args.league)
|
|
|
|
if not events:
|
|
print("No events found.")
|
|
return 1
|
|
|
|
if args.pick is not None:
|
|
if args.pick < 1 or args.pick > len(events):
|
|
raise RuntimeError("--pick is out of range for the returned events.")
|
|
event = events[args.pick - 1]
|
|
elif len(events) == 1:
|
|
event = events[0]
|
|
else:
|
|
print("Multiple events matched. Re-run with --pick or refine the query:")
|
|
print_events(events, args.limit)
|
|
return 1
|
|
|
|
odds_args = argparse.Namespace(
|
|
api_key=args.api_key,
|
|
base_url=args.base_url,
|
|
timeout=args.timeout,
|
|
dry_run=args.dry_run,
|
|
event_id=str(event.get("id")),
|
|
bookmakers=args.bookmakers,
|
|
summary=args.summary,
|
|
)
|
|
return command_odds(odds_args)
|
|
|
|
|
|
def build_parser():
|
|
parser = argparse.ArgumentParser(
|
|
description="Odds-API.io CLI helper",
|
|
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
|
|
)
|
|
parser.add_argument("--api-key", help="Odds-API.io API key")
|
|
parser.add_argument("--base-url", default=DEFAULT_BASE_URL, help="API base URL")
|
|
parser.add_argument("--timeout", type=int, default=20, help="Request timeout in seconds")
|
|
parser.add_argument("--dry-run", action="store_true", help="Print request URL without calling the API")
|
|
|
|
subparsers = parser.add_subparsers(dest="command", required=True)
|
|
|
|
sports = subparsers.add_parser("sports", help="List available sports")
|
|
sports.add_argument("--json", action="store_true", help="Print full JSON response")
|
|
sports.set_defaults(func=command_sports)
|
|
|
|
bookmakers = subparsers.add_parser("bookmakers", help="List bookmakers")
|
|
bookmakers.add_argument("--all", action="store_true", help="Include inactive bookmakers")
|
|
bookmakers.add_argument("--json", action="store_true", help="Print full JSON response")
|
|
bookmakers.set_defaults(func=command_bookmakers)
|
|
|
|
events = subparsers.add_parser("events", help="List events for a sport")
|
|
events.add_argument("--sport", required=True, help="Sport slug (e.g. football)")
|
|
events.add_argument("--league", help="League slug")
|
|
events.add_argument("--participant-id", help="Filter by participant ID")
|
|
events.add_argument("--status", help="Comma-separated statuses (pending,live,settled)")
|
|
events.add_argument("--from", dest="from_time", help="Start time (RFC3339)")
|
|
events.add_argument("--to", dest="to_time", help="End time (RFC3339)")
|
|
events.add_argument("--bookmaker", help="Filter by bookmaker name")
|
|
events.add_argument("--limit", type=int, help="Limit number of results shown")
|
|
events.add_argument("--json", action="store_true", help="Print full JSON response")
|
|
events.set_defaults(func=command_events)
|
|
|
|
search = subparsers.add_parser("search", help="Search events by team or league name")
|
|
search.add_argument("--query", required=True, help="Search term (min 3 chars)")
|
|
search.add_argument("--sport", help="Filter by sport slug")
|
|
search.add_argument("--league", help="Filter by league slug")
|
|
search.add_argument("--limit", type=int, help="Limit number of results shown")
|
|
search.add_argument("--json", action="store_true", help="Print full JSON response")
|
|
search.set_defaults(func=command_search)
|
|
|
|
odds = subparsers.add_parser("odds", help="Fetch odds for a specific event")
|
|
odds.add_argument("--event-id", required=True, help="Event ID")
|
|
odds.add_argument("--bookmakers", required=True, help="Comma-separated bookmaker names")
|
|
odds.add_argument("--summary", action="store_true", help="Print a compact summary")
|
|
odds.set_defaults(func=command_odds)
|
|
|
|
matchup = subparsers.add_parser("matchup", help="Search for a matchup and fetch odds")
|
|
matchup.add_argument("--query", help="Search term (min 3 chars)")
|
|
matchup.add_argument("--home", help="Home team name")
|
|
matchup.add_argument("--away", help="Away team name")
|
|
matchup.add_argument("--sport", help="Filter by sport slug")
|
|
matchup.add_argument("--league", help="Filter by league slug")
|
|
matchup.add_argument("--bookmakers", required=True, help="Comma-separated bookmaker names")
|
|
matchup.add_argument("--pick", type=int, help="Pick event by 1-based index when multiple match")
|
|
matchup.add_argument("--limit", type=int, help="Limit number of results shown")
|
|
matchup.add_argument("--summary", action="store_true", help="Print a compact summary")
|
|
matchup.set_defaults(func=command_matchup)
|
|
|
|
return parser
|
|
|
|
|
|
def main():
|
|
parser = build_parser()
|
|
args = parser.parse_args()
|
|
try:
|
|
return args.func(args)
|
|
except RuntimeError as exc:
|
|
print(f"Error: {exc}", file=sys.stderr)
|
|
return 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|