1091 lines
35 KiB
Python
Executable File
1091 lines
35 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
SportsTime CLI - Unified entry point for all data operations.
|
|
|
|
Usage:
|
|
python sportstime.py <command> [options]
|
|
|
|
Commands:
|
|
scrape Scrape game schedules from sports reference sites
|
|
stadiums-update Scrape ALL stadium data for all 11 sports
|
|
canonicalize Run the canonicalization pipeline
|
|
validate Validate canonical data
|
|
cloudkit Import/export data to CloudKit
|
|
generate Generate canonical data files
|
|
pipeline Run the full data pipeline
|
|
|
|
Examples:
|
|
python sportstime.py scrape --sport mlb --season 2026
|
|
python sportstime.py stadiums-update
|
|
python sportstime.py canonicalize --season 2026
|
|
python sportstime.py validate --strict
|
|
python sportstime.py cloudkit --interactive
|
|
python sportstime.py pipeline --sport all --season 2026
|
|
"""
|
|
|
|
import argparse
|
|
import sys
|
|
import os
|
|
from datetime import datetime
|
|
|
|
# Add Scripts directory to path for imports
|
|
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
|
|
sys.path.insert(0, SCRIPT_DIR)
|
|
|
|
# ANSI colors for terminal output
|
|
class Colors:
|
|
HEADER = '\033[95m'
|
|
BLUE = '\033[94m'
|
|
CYAN = '\033[96m'
|
|
GREEN = '\033[92m'
|
|
YELLOW = '\033[93m'
|
|
RED = '\033[91m'
|
|
BOLD = '\033[1m'
|
|
DIM = '\033[2m'
|
|
RESET = '\033[0m'
|
|
|
|
|
|
def print_banner():
|
|
"""Print the SportsTime banner."""
|
|
banner = f"""
|
|
{Colors.CYAN}{Colors.BOLD}╔═══════════════════════════════════════════════════════════╗
|
|
║ ║
|
|
║ ⚾ 🏀 🏒 ⚽ 🏈 {Colors.YELLOW}SportsTime CLI{Colors.CYAN} ⚾ 🏀 🏒 ⚽ 🏈 ║
|
|
║ ║
|
|
║ {Colors.DIM}Unified data pipeline for sports scheduling{Colors.CYAN}{Colors.BOLD} ║
|
|
║ ║
|
|
╚═══════════════════════════════════════════════════════════╝{Colors.RESET}
|
|
"""
|
|
print(banner)
|
|
|
|
|
|
def interactive_menu():
|
|
"""Display interactive menu and return selected command args."""
|
|
print_banner()
|
|
|
|
current_year = datetime.now().year
|
|
|
|
print(f"{Colors.BOLD}What would you like to do?{Colors.RESET}\n")
|
|
|
|
print(f" {Colors.GREEN}[1]{Colors.RESET} {Colors.BOLD}Scrape{Colors.RESET}")
|
|
print(f" {Colors.DIM}Download schedules from web sources{Colors.RESET}")
|
|
|
|
print(f" {Colors.GREEN}[2]{Colors.RESET} {Colors.BOLD}Canonicalize{Colors.RESET}")
|
|
print(f" {Colors.DIM}Generate canonical IDs (requires scraped data){Colors.RESET}")
|
|
|
|
print(f" {Colors.GREEN}[3]{Colors.RESET} {Colors.BOLD}Validate{Colors.RESET}")
|
|
print(f" {Colors.DIM}Check data integrity (requires canonical data){Colors.RESET}")
|
|
|
|
print(f" {Colors.GREEN}[4]{Colors.RESET} {Colors.BOLD}Upload to CloudKit{Colors.RESET}")
|
|
print(f" {Colors.DIM}Upload to CloudKit (requires canonical data){Colors.RESET}")
|
|
|
|
print(f" {Colors.CYAN}[5]{Colors.RESET} {Colors.BOLD}Full Pipeline{Colors.RESET}")
|
|
print(f" {Colors.DIM}Scrape → Canonicalize → Validate → Upload (stops on error){Colors.RESET}")
|
|
|
|
print(f" {Colors.YELLOW}[6]{Colors.RESET} {Colors.BOLD}Update Stadiums{Colors.RESET}")
|
|
print(f" {Colors.DIM}Scrape ALL stadium data for all 11 sports (comprehensive){Colors.RESET}")
|
|
|
|
print(f" {Colors.DIM}[q]{Colors.RESET} Quit")
|
|
|
|
print()
|
|
choice = input(f"{Colors.CYAN}Enter choice:{Colors.RESET} ").strip().lower()
|
|
|
|
if choice == 'q':
|
|
print(f"\n{Colors.DIM}Goodbye!{Colors.RESET}")
|
|
sys.exit(0)
|
|
|
|
if choice == '1':
|
|
return get_season_and_sport('scrape')
|
|
elif choice == '2':
|
|
return get_season_and_sport('canonicalize-only')
|
|
elif choice == '3':
|
|
return ['validate', '--verbose']
|
|
elif choice == '4':
|
|
return ['cloudkit', '--interactive']
|
|
elif choice == '5':
|
|
return get_season_and_sport('full-pipeline')
|
|
elif choice == '6':
|
|
return ['stadiums-update']
|
|
else:
|
|
print(f"\n{Colors.RED}Invalid choice. Please try again.{Colors.RESET}")
|
|
return interactive_menu()
|
|
|
|
|
|
def get_season_and_sport(mode: str):
|
|
"""Get season and sport for scrape/canonicalize commands."""
|
|
current_year = datetime.now().year
|
|
|
|
# Get season
|
|
season_input = input(f"{Colors.CYAN}Enter season year [{current_year}]:{Colors.RESET} ").strip()
|
|
season = int(season_input) if season_input else current_year
|
|
|
|
# Get sport
|
|
print(f"\n{Colors.BOLD}Select sport:{Colors.RESET}")
|
|
print(f" {Colors.GREEN}[1]{Colors.RESET} All Sports")
|
|
print(f" {Colors.GREEN}[2]{Colors.RESET} MLB {Colors.GREEN}[3]{Colors.RESET} NBA {Colors.GREEN}[4]{Colors.RESET} NHL {Colors.GREEN}[5]{Colors.RESET} NFL")
|
|
print(f" {Colors.GREEN}[6]{Colors.RESET} MLS {Colors.GREEN}[7]{Colors.RESET} WNBA {Colors.GREEN}[8]{Colors.RESET} NWSL")
|
|
|
|
sport_map = {
|
|
'1': 'all', '2': 'mlb', '3': 'nba', '4': 'nhl', '5': 'nfl',
|
|
'6': 'mls', '7': 'wnba', '8': 'nwsl'
|
|
}
|
|
|
|
sport_choice = input(f"{Colors.CYAN}Enter choice [1]:{Colors.RESET} ").strip()
|
|
sport = sport_map.get(sport_choice, 'all')
|
|
|
|
if mode == 'scrape':
|
|
return ['scrape', '--sport', sport, '--season', str(season)]
|
|
elif mode == 'canonicalize-only':
|
|
return ['canonicalize', '--sport', sport, '--season', str(season)]
|
|
elif mode == 'full-pipeline':
|
|
return ['full-pipeline', '--sport', sport, '--season', str(season)]
|
|
|
|
return None
|
|
|
|
|
|
def scrape_submenu():
|
|
"""Submenu for scrape options."""
|
|
print(f"\n{Colors.BOLD}Select sport to scrape:{Colors.RESET}\n")
|
|
|
|
sports = [
|
|
('1', 'all', 'All Sports'),
|
|
('2', 'mlb', 'MLB - Major League Baseball'),
|
|
('3', 'nba', 'NBA - National Basketball Association'),
|
|
('4', 'nhl', 'NHL - National Hockey League'),
|
|
('5', 'nfl', 'NFL - National Football League'),
|
|
('6', 'mls', 'MLS - Major League Soccer'),
|
|
('7', 'wnba', 'WNBA - Women\'s National Basketball Association'),
|
|
('8', 'nwsl', 'NWSL - National Women\'s Soccer League'),
|
|
('b', 'back', 'Back to main menu'),
|
|
]
|
|
|
|
for key, _, desc in sports:
|
|
if key == 'b':
|
|
print(f" {Colors.DIM}[{key}]{Colors.RESET} {desc}")
|
|
else:
|
|
print(f" {Colors.GREEN}[{key}]{Colors.RESET} {desc}")
|
|
|
|
print()
|
|
choice = input(f"{Colors.CYAN}Enter choice:{Colors.RESET} ").strip().lower()
|
|
|
|
if choice == 'b':
|
|
return interactive_menu()
|
|
|
|
sport = None
|
|
for key, sport_code, _ in sports:
|
|
if key == choice:
|
|
sport = sport_code
|
|
break
|
|
|
|
if not sport:
|
|
print(f"\n{Colors.RED}Invalid choice.{Colors.RESET}")
|
|
return scrape_submenu()
|
|
|
|
# Get season
|
|
current_year = datetime.now().year
|
|
season_input = input(f"{Colors.CYAN}Enter season year [{current_year}]:{Colors.RESET} ").strip()
|
|
season = int(season_input) if season_input else current_year
|
|
|
|
return ['scrape', '--sport', sport, '--season', str(season)]
|
|
|
|
|
|
def validate_submenu():
|
|
"""Submenu for validate options."""
|
|
print(f"\n{Colors.BOLD}Validation options:{Colors.RESET}\n")
|
|
|
|
options = [
|
|
('1', 'Basic validation', []),
|
|
('2', 'Strict validation (warnings become errors)', ['--strict']),
|
|
('3', 'Verbose validation', ['--verbose']),
|
|
('4', 'Strict + Verbose', ['--strict', '--verbose']),
|
|
('b', 'Back to main menu', None),
|
|
]
|
|
|
|
for key, desc, _ in options:
|
|
if key == 'b':
|
|
print(f" {Colors.DIM}[{key}]{Colors.RESET} {desc}")
|
|
else:
|
|
print(f" {Colors.GREEN}[{key}]{Colors.RESET} {desc}")
|
|
|
|
print()
|
|
choice = input(f"{Colors.CYAN}Enter choice:{Colors.RESET} ").strip().lower()
|
|
|
|
if choice == 'b':
|
|
return interactive_menu()
|
|
|
|
for key, _, flags in options:
|
|
if key == choice and flags is not None:
|
|
return ['validate'] + flags
|
|
|
|
print(f"\n{Colors.RED}Invalid choice.{Colors.RESET}")
|
|
return validate_submenu()
|
|
|
|
|
|
def pipeline_submenu():
|
|
"""Submenu for pipeline options."""
|
|
print(f"\n{Colors.BOLD}Pipeline options:{Colors.RESET}\n")
|
|
|
|
sports = [
|
|
('1', 'all', 'All Sports'),
|
|
('2', 'mlb', 'MLB only'),
|
|
('3', 'nba', 'NBA only'),
|
|
('4', 'nhl', 'NHL only'),
|
|
('5', 'nfl', 'NFL only'),
|
|
('6', 'mls', 'MLS only'),
|
|
('7', 'wnba', 'WNBA only'),
|
|
('8', 'nwsl', 'NWSL only'),
|
|
('b', 'back', 'Back to main menu'),
|
|
]
|
|
|
|
for key, _, desc in sports:
|
|
if key == 'b':
|
|
print(f" {Colors.DIM}[{key}]{Colors.RESET} {desc}")
|
|
else:
|
|
print(f" {Colors.GREEN}[{key}]{Colors.RESET} {desc}")
|
|
|
|
print()
|
|
choice = input(f"{Colors.CYAN}Enter choice:{Colors.RESET} ").strip().lower()
|
|
|
|
if choice == 'b':
|
|
return interactive_menu()
|
|
|
|
sport = None
|
|
for key, sport_code, _ in sports:
|
|
if key == choice:
|
|
sport = sport_code
|
|
break
|
|
|
|
if not sport:
|
|
print(f"\n{Colors.RED}Invalid choice.{Colors.RESET}")
|
|
return pipeline_submenu()
|
|
|
|
# Get season
|
|
current_year = datetime.now().year
|
|
season_input = input(f"{Colors.CYAN}Enter season year [{current_year}]:{Colors.RESET} ").strip()
|
|
season = int(season_input) if season_input else current_year
|
|
|
|
# Verbose?
|
|
verbose = input(f"{Colors.CYAN}Verbose output? [y/N]:{Colors.RESET} ").strip().lower()
|
|
|
|
cmd = ['pipeline', '--sport', sport, '--season', str(season)]
|
|
if verbose == 'y':
|
|
cmd.append('--verbose')
|
|
|
|
return cmd
|
|
|
|
|
|
def canonicalize_submenu():
|
|
"""Submenu for canonicalize options."""
|
|
print(f"\n{Colors.BOLD}Canonicalization options:{Colors.RESET}\n")
|
|
|
|
options = [
|
|
('1', 'Full pipeline (scrape + canonicalize + validate)', []),
|
|
('2', 'Skip scraping (use existing data)', ['--skip-scrape']),
|
|
('3', 'Skip validation', ['--no-validate']),
|
|
('4', 'Verbose output', ['--verbose']),
|
|
('b', 'Back to main menu', None),
|
|
]
|
|
|
|
for key, desc, _ in options:
|
|
if key == 'b':
|
|
print(f" {Colors.DIM}[{key}]{Colors.RESET} {desc}")
|
|
else:
|
|
print(f" {Colors.GREEN}[{key}]{Colors.RESET} {desc}")
|
|
|
|
print()
|
|
choice = input(f"{Colors.CYAN}Enter choice:{Colors.RESET} ").strip().lower()
|
|
|
|
if choice == 'b':
|
|
return interactive_menu()
|
|
|
|
flags = None
|
|
for key, _, f in options:
|
|
if key == choice:
|
|
flags = f
|
|
break
|
|
|
|
if flags is None:
|
|
print(f"\n{Colors.RED}Invalid choice.{Colors.RESET}")
|
|
return canonicalize_submenu()
|
|
|
|
# Get season
|
|
current_year = datetime.now().year
|
|
season_input = input(f"{Colors.CYAN}Enter season year [{current_year}]:{Colors.RESET} ").strip()
|
|
season = int(season_input) if season_input else current_year
|
|
|
|
return ['canonicalize', '--season', str(season)] + flags
|
|
|
|
|
|
def cmd_scrape(args):
|
|
"""Scrape game schedules from sports reference sites."""
|
|
from scrape_schedules import main as scrape_main
|
|
|
|
# Build sys.argv for the scrape script
|
|
argv = ['scrape_schedules.py']
|
|
argv.extend(['--sport', args.sport])
|
|
argv.extend(['--season', str(args.season)])
|
|
argv.extend(['--output', args.output])
|
|
if args.stadiums_only:
|
|
argv.append('--stadiums-only')
|
|
|
|
sys.argv = argv
|
|
scrape_main()
|
|
|
|
|
|
def cmd_stadiums_update(args):
|
|
"""Scrape comprehensive stadium data for all 11 sports."""
|
|
from scrape_schedules import main as scrape_main
|
|
|
|
# Build sys.argv for the scrape script with --stadiums-update flag
|
|
argv = ['scrape_schedules.py']
|
|
argv.extend(['--output', args.output])
|
|
argv.append('--stadiums-update')
|
|
argv.append('--stadiums-only')
|
|
|
|
sys.argv = argv
|
|
scrape_main()
|
|
|
|
|
|
def cmd_canonicalize(args):
|
|
"""Run the canonicalization pipeline."""
|
|
from run_canonicalization_pipeline import main as canon_main
|
|
|
|
argv = ['run_canonicalization_pipeline.py']
|
|
argv.extend(['--season', str(args.season)])
|
|
argv.extend(['--output', args.output])
|
|
if args.skip_scrape:
|
|
argv.append('--skip-scrape')
|
|
if args.no_validate:
|
|
argv.append('--no-validate')
|
|
if args.verbose:
|
|
argv.append('--verbose')
|
|
if args.strict:
|
|
argv.append('--strict')
|
|
|
|
sys.argv = argv
|
|
canon_main()
|
|
|
|
|
|
def cmd_validate(args):
|
|
"""Validate canonical data."""
|
|
from validate_canonical import main as validate_main
|
|
|
|
argv = ['validate_canonical.py']
|
|
if args.data_dir:
|
|
argv.extend(['--data-dir', args.data_dir])
|
|
if args.stadiums:
|
|
argv.extend(['--stadiums', args.stadiums])
|
|
if args.teams:
|
|
argv.extend(['--teams', args.teams])
|
|
if args.games:
|
|
argv.extend(['--games', args.games])
|
|
if args.aliases:
|
|
argv.extend(['--aliases', args.aliases])
|
|
if args.output:
|
|
argv.extend(['--output', args.output])
|
|
if args.verbose:
|
|
argv.append('--verbose')
|
|
if args.strict:
|
|
argv.append('--strict')
|
|
|
|
sys.argv = argv
|
|
validate_main()
|
|
|
|
|
|
def cmd_cloudkit(args):
|
|
"""Import/export data to CloudKit."""
|
|
from cloudkit_import import main as cloudkit_main
|
|
|
|
argv = ['cloudkit_import.py']
|
|
if args.key_id:
|
|
argv.extend(['--key-id', args.key_id])
|
|
if args.key_file:
|
|
argv.extend(['--key-file', args.key_file])
|
|
if args.container:
|
|
argv.extend(['--container', args.container])
|
|
argv.extend(['--env', args.env])
|
|
argv.extend(['--data-dir', args.data_dir])
|
|
|
|
if args.stadiums_only:
|
|
argv.append('--stadiums-only')
|
|
if args.games_only:
|
|
argv.append('--games-only')
|
|
if args.games_files:
|
|
argv.extend(['--games-files', args.games_files])
|
|
if args.league_structure_only:
|
|
argv.append('--league-structure-only')
|
|
if args.team_aliases_only:
|
|
argv.append('--team-aliases-only')
|
|
if args.stadium_aliases_only:
|
|
argv.append('--stadium-aliases-only')
|
|
if args.canonical_only:
|
|
argv.append('--canonical-only')
|
|
if args.delete_all:
|
|
argv.append('--delete-all')
|
|
if args.delete_only:
|
|
argv.append('--delete-only')
|
|
if args.dry_run:
|
|
argv.append('--dry-run')
|
|
if args.verbose:
|
|
argv.append('--verbose')
|
|
if args.interactive:
|
|
argv.append('--interactive')
|
|
|
|
sys.argv = argv
|
|
cloudkit_main()
|
|
|
|
|
|
def cmd_generate(args):
|
|
"""Generate canonical data files."""
|
|
from generate_canonical_data import main as generate_main
|
|
|
|
argv = ['generate_canonical_data.py']
|
|
argv.extend(['--output', args.output])
|
|
|
|
sys.argv = argv
|
|
generate_main()
|
|
|
|
|
|
def cmd_pipeline(args):
|
|
"""Run the full data pipeline."""
|
|
from run_pipeline import main as pipeline_main
|
|
|
|
argv = ['run_pipeline.py']
|
|
argv.extend(['--season', str(args.season)])
|
|
argv.extend(['--sport', args.sport])
|
|
argv.extend(['--output', args.output])
|
|
if args.skip_scrape:
|
|
argv.append('--skip-scrape')
|
|
if args.no_validate:
|
|
argv.append('--no-validate')
|
|
if args.verbose:
|
|
argv.append('--verbose')
|
|
|
|
sys.argv = argv
|
|
pipeline_main()
|
|
|
|
|
|
def cmd_full_pipeline(args):
|
|
"""Run complete pipeline: Scrape → Canonicalize → Validate → Upload (stops on error)."""
|
|
print(f"\n{Colors.CYAN}{Colors.BOLD}╔═══════════════════════════════════════════════════════════╗")
|
|
print(f"║ FULL PIPELINE - {args.sport.upper()} {args.season} ║")
|
|
print(f"╚═══════════════════════════════════════════════════════════╝{Colors.RESET}\n")
|
|
|
|
steps = [
|
|
("Scrape", "Downloading schedules from web sources"),
|
|
("Canonicalize", "Generating canonical IDs"),
|
|
("Validate", "Checking data integrity"),
|
|
]
|
|
if not args.skip_upload:
|
|
steps.append(("Upload", "Uploading to CloudKit"))
|
|
|
|
# Step 1: Scrape
|
|
print(f"{Colors.CYAN}[1/{len(steps)}] SCRAPE{Colors.RESET}")
|
|
print(f" {Colors.DIM}Downloading schedules from web sources...{Colors.RESET}\n")
|
|
try:
|
|
from scrape_schedules import main as scrape_main
|
|
sys.argv = ['scrape_schedules.py', '--sport', args.sport, '--season', str(args.season), '--output', args.output]
|
|
scrape_main()
|
|
print(f"\n{Colors.GREEN}✓ Scrape completed{Colors.RESET}\n")
|
|
except Exception as e:
|
|
print(f"\n{Colors.RED}✗ Scrape FAILED: {e}{Colors.RESET}")
|
|
print(f"{Colors.YELLOW}Pipeline stopped at step 1/4.{Colors.RESET}")
|
|
return
|
|
|
|
# Step 2: Canonicalize
|
|
print(f"{Colors.CYAN}[2/{len(steps)}] CANONICALIZE{Colors.RESET}")
|
|
print(f" {Colors.DIM}Generating canonical IDs...{Colors.RESET}\n")
|
|
try:
|
|
from run_canonicalization_pipeline import main as canon_main
|
|
sys.argv = ['run_canonicalization_pipeline.py', '--season', str(args.season), '--output', args.output, '--skip-scrape']
|
|
canon_main()
|
|
print(f"\n{Colors.GREEN}✓ Canonicalize completed{Colors.RESET}\n")
|
|
except Exception as e:
|
|
print(f"\n{Colors.RED}✗ Canonicalize FAILED: {e}{Colors.RESET}")
|
|
print(f"{Colors.YELLOW}Pipeline stopped at step 2/4.{Colors.RESET}")
|
|
return
|
|
|
|
# Step 3: Validate
|
|
print(f"{Colors.CYAN}[3/{len(steps)}] VALIDATE{Colors.RESET}")
|
|
print(f" {Colors.DIM}Checking data integrity...{Colors.RESET}\n")
|
|
try:
|
|
from validate_canonical import main as validate_main
|
|
sys.argv = ['validate_canonical.py', '--data-dir', args.output, '--verbose']
|
|
validate_main()
|
|
print(f"\n{Colors.GREEN}✓ Validate completed{Colors.RESET}\n")
|
|
except SystemExit as e:
|
|
if e.code != 0:
|
|
print(f"\n{Colors.RED}✗ Validate FAILED (exit code {e.code}){Colors.RESET}")
|
|
print(f"{Colors.YELLOW}Pipeline stopped at step 3/4.{Colors.RESET}")
|
|
return
|
|
print(f"\n{Colors.GREEN}✓ Validate completed{Colors.RESET}\n")
|
|
except Exception as e:
|
|
print(f"\n{Colors.RED}✗ Validate FAILED: {e}{Colors.RESET}")
|
|
print(f"{Colors.YELLOW}Pipeline stopped at step 3/4.{Colors.RESET}")
|
|
return
|
|
|
|
# Step 4: Upload to CloudKit (unless skipped)
|
|
if not args.skip_upload:
|
|
print(f"{Colors.CYAN}[4/{len(steps)}] UPLOAD TO CLOUDKIT{Colors.RESET}")
|
|
print(f" {Colors.DIM}Uploading to CloudKit...{Colors.RESET}\n")
|
|
try:
|
|
from cloudkit_import import main as cloudkit_main
|
|
sys.argv = ['cloudkit_import.py', '--data-dir', args.output, '--interactive']
|
|
cloudkit_main()
|
|
print(f"\n{Colors.GREEN}✓ Upload completed{Colors.RESET}\n")
|
|
except Exception as e:
|
|
print(f"\n{Colors.RED}✗ Upload FAILED: {e}{Colors.RESET}")
|
|
print(f"{Colors.YELLOW}Pipeline stopped at step 4/4.{Colors.RESET}")
|
|
return
|
|
|
|
# Success!
|
|
print(f"\n{Colors.GREEN}{Colors.BOLD}╔═══════════════════════════════════════════════════════════╗")
|
|
print(f"║ PIPELINE COMPLETE ✓ ║")
|
|
print(f"╚═══════════════════════════════════════════════════════════╝{Colors.RESET}\n")
|
|
|
|
|
|
def cmd_canonicalize_stadiums(args):
|
|
"""Canonicalize stadium data."""
|
|
from canonicalize_stadiums import main as stadium_main
|
|
|
|
argv = ['canonicalize_stadiums.py']
|
|
if args.input:
|
|
argv.extend(['--input', args.input])
|
|
argv.extend(['--output', args.output])
|
|
if args.verbose:
|
|
argv.append('--verbose')
|
|
|
|
sys.argv = argv
|
|
stadium_main()
|
|
|
|
|
|
def cmd_canonicalize_teams(args):
|
|
"""Canonicalize team data."""
|
|
from canonicalize_teams import main as team_main
|
|
|
|
argv = ['canonicalize_teams.py']
|
|
if args.stadiums:
|
|
argv.extend(['--stadiums', args.stadiums])
|
|
argv.extend(['--output', args.output])
|
|
if args.verbose:
|
|
argv.append('--verbose')
|
|
|
|
sys.argv = argv
|
|
team_main()
|
|
|
|
|
|
def cmd_canonicalize_games(args):
|
|
"""Canonicalize game data."""
|
|
from canonicalize_games import main as game_main
|
|
|
|
argv = ['canonicalize_games.py']
|
|
if args.games:
|
|
argv.extend(['--games', args.games])
|
|
if args.teams:
|
|
argv.extend(['--teams', args.teams])
|
|
if args.aliases:
|
|
argv.extend(['--aliases', args.aliases])
|
|
argv.extend(['--output', args.output])
|
|
if args.verbose:
|
|
argv.append('--verbose')
|
|
|
|
sys.argv = argv
|
|
game_main()
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(
|
|
prog='sportstime',
|
|
description='SportsTime CLI - Unified entry point for all data operations',
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
epilog="""
|
|
Examples:
|
|
%(prog)s scrape --sport mlb --season 2026
|
|
%(prog)s scrape --sport all --season 2026
|
|
%(prog)s canonicalize --season 2026 --verbose
|
|
%(prog)s validate --strict
|
|
%(prog)s cloudkit --interactive
|
|
%(prog)s cloudkit --env production --stadiums-only
|
|
%(prog)s pipeline --sport all --season 2026
|
|
"""
|
|
)
|
|
|
|
subparsers = parser.add_subparsers(dest='command', help='Available commands')
|
|
|
|
# ============================================================
|
|
# SCRAPE command
|
|
# ============================================================
|
|
scrape_parser = subparsers.add_parser(
|
|
'scrape',
|
|
help='Scrape game schedules from sports reference sites',
|
|
description='Scrapes NBA, MLB, NHL, WNBA, MLS, and NWSL schedules'
|
|
)
|
|
scrape_parser.add_argument(
|
|
'--sport',
|
|
choices=['nba', 'mlb', 'nhl', 'nfl', 'wnba', 'mls', 'nwsl', 'all'],
|
|
default='all',
|
|
help='Sport to scrape (default: all)'
|
|
)
|
|
scrape_parser.add_argument(
|
|
'--season',
|
|
type=int,
|
|
default=2026,
|
|
help='Season year - ending year for sports that span years (default: 2026)'
|
|
)
|
|
scrape_parser.add_argument(
|
|
'--output',
|
|
type=str,
|
|
default='./data',
|
|
help='Output directory (default: ./data)'
|
|
)
|
|
scrape_parser.add_argument(
|
|
'--stadiums-only',
|
|
action='store_true',
|
|
help='Only scrape stadium data, not game schedules'
|
|
)
|
|
scrape_parser.set_defaults(func=cmd_scrape)
|
|
|
|
# ============================================================
|
|
# STADIUMS-UPDATE command (comprehensive stadium scraping)
|
|
# ============================================================
|
|
stadiums_update_parser = subparsers.add_parser(
|
|
'stadiums-update',
|
|
help='Scrape ALL stadium data for all 8 sports',
|
|
description='Comprehensive stadium scraping for NBA, MLB, NHL, NFL, WNBA, MLS, and NWSL'
|
|
)
|
|
stadiums_update_parser.add_argument(
|
|
'--output',
|
|
type=str,
|
|
default='./data',
|
|
help='Output directory (default: ./data)'
|
|
)
|
|
stadiums_update_parser.set_defaults(func=cmd_stadiums_update)
|
|
|
|
# ============================================================
|
|
# CANONICALIZE command (full pipeline)
|
|
# ============================================================
|
|
canon_parser = subparsers.add_parser(
|
|
'canonicalize',
|
|
help='Run the canonicalization pipeline',
|
|
description='Runs the full canonicalization pipeline: scrape -> canonicalize -> validate'
|
|
)
|
|
canon_parser.add_argument(
|
|
'--season',
|
|
type=int,
|
|
default=2026,
|
|
help='Season year (default: 2026)'
|
|
)
|
|
canon_parser.add_argument(
|
|
'--output',
|
|
type=str,
|
|
default='./data',
|
|
help='Output directory (default: ./data)'
|
|
)
|
|
canon_parser.add_argument(
|
|
'--skip-scrape',
|
|
action='store_true',
|
|
help='Skip scraping, use existing data'
|
|
)
|
|
canon_parser.add_argument(
|
|
'--no-validate',
|
|
action='store_true',
|
|
help='Skip validation step'
|
|
)
|
|
canon_parser.add_argument(
|
|
'--verbose', '-v',
|
|
action='store_true',
|
|
help='Verbose output'
|
|
)
|
|
canon_parser.add_argument(
|
|
'--strict',
|
|
action='store_true',
|
|
help='Strict validation mode'
|
|
)
|
|
canon_parser.set_defaults(func=cmd_canonicalize)
|
|
|
|
# ============================================================
|
|
# VALIDATE command
|
|
# ============================================================
|
|
validate_parser = subparsers.add_parser(
|
|
'validate',
|
|
help='Validate canonical data',
|
|
description='Validates canonical data files for consistency and completeness'
|
|
)
|
|
validate_parser.add_argument(
|
|
'--data-dir',
|
|
type=str,
|
|
default=None,
|
|
help='Data directory (auto-detects if not specified)'
|
|
)
|
|
validate_parser.add_argument(
|
|
'--stadiums',
|
|
type=str,
|
|
default=None,
|
|
help='Path to stadiums_canonical.json'
|
|
)
|
|
validate_parser.add_argument(
|
|
'--teams',
|
|
type=str,
|
|
default=None,
|
|
help='Path to teams_canonical.json'
|
|
)
|
|
validate_parser.add_argument(
|
|
'--games',
|
|
type=str,
|
|
default=None,
|
|
help='Path to games_canonical.json'
|
|
)
|
|
validate_parser.add_argument(
|
|
'--aliases',
|
|
type=str,
|
|
default=None,
|
|
help='Path to aliases file'
|
|
)
|
|
validate_parser.add_argument(
|
|
'--output',
|
|
type=str,
|
|
default=None,
|
|
help='Output file for validation report'
|
|
)
|
|
validate_parser.add_argument(
|
|
'--verbose', '-v',
|
|
action='store_true',
|
|
help='Verbose output'
|
|
)
|
|
validate_parser.add_argument(
|
|
'--strict',
|
|
action='store_true',
|
|
help='Strict validation mode (warnings become errors)'
|
|
)
|
|
validate_parser.set_defaults(func=cmd_validate)
|
|
|
|
# ============================================================
|
|
# CLOUDKIT command
|
|
# ============================================================
|
|
cloudkit_parser = subparsers.add_parser(
|
|
'cloudkit',
|
|
help='Import/export data to CloudKit',
|
|
description='Import or export data to/from CloudKit'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--key-id',
|
|
type=str,
|
|
default=None,
|
|
help='CloudKit key ID'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--key-file',
|
|
type=str,
|
|
default=None,
|
|
help='Path to CloudKit private key file'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--container',
|
|
type=str,
|
|
default=None,
|
|
help='CloudKit container ID'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--env',
|
|
choices=['development', 'production'],
|
|
default='development',
|
|
help='CloudKit environment (default: development)'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--data-dir',
|
|
type=str,
|
|
default='./data',
|
|
help='Data directory (default: ./data)'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--stadiums-only',
|
|
action='store_true',
|
|
help='Import only stadiums'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--games-only',
|
|
action='store_true',
|
|
help='Import only games (all files)'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--games-files',
|
|
type=str,
|
|
help='Import specific game files (e.g., mlb_2025.json,nba_2025.json)'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--league-structure-only',
|
|
action='store_true',
|
|
help='Import only league structure'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--team-aliases-only',
|
|
action='store_true',
|
|
help='Import only team aliases'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--stadium-aliases-only',
|
|
action='store_true',
|
|
help='Import only stadium aliases'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--canonical-only',
|
|
action='store_true',
|
|
help='Import only canonical data (league structure + aliases)'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--delete-all',
|
|
action='store_true',
|
|
help='Delete all records before importing'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--delete-only',
|
|
action='store_true',
|
|
help='Only delete records, do not import'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--dry-run',
|
|
action='store_true',
|
|
help='Show what would be done without making changes'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--verbose', '-v',
|
|
action='store_true',
|
|
help='Verbose output'
|
|
)
|
|
cloudkit_parser.add_argument(
|
|
'--interactive', '-i',
|
|
action='store_true',
|
|
help='Show interactive menu'
|
|
)
|
|
cloudkit_parser.set_defaults(func=cmd_cloudkit)
|
|
|
|
# ============================================================
|
|
# GENERATE command
|
|
# ============================================================
|
|
generate_parser = subparsers.add_parser(
|
|
'generate',
|
|
help='Generate canonical data files',
|
|
description='Generate canonical data JSON files from hardcoded data'
|
|
)
|
|
generate_parser.add_argument(
|
|
'--output',
|
|
type=str,
|
|
default='./data',
|
|
help='Output directory (default: ./data)'
|
|
)
|
|
generate_parser.set_defaults(func=cmd_generate)
|
|
|
|
# ============================================================
|
|
# PIPELINE command
|
|
# ============================================================
|
|
pipeline_parser = subparsers.add_parser(
|
|
'pipeline',
|
|
help='Run the full data pipeline',
|
|
description='Run the full data pipeline: fetch, validate, and report'
|
|
)
|
|
pipeline_parser.add_argument(
|
|
'--season',
|
|
type=int,
|
|
default=2026,
|
|
help='Season year (default: 2026)'
|
|
)
|
|
pipeline_parser.add_argument(
|
|
'--sport',
|
|
choices=['nba', 'mlb', 'nhl', 'nfl', 'wnba', 'mls', 'nwsl', 'all'],
|
|
default='all',
|
|
help='Sport to process (default: all)'
|
|
)
|
|
pipeline_parser.add_argument(
|
|
'--output',
|
|
type=str,
|
|
default='./data',
|
|
help='Output directory (default: ./data)'
|
|
)
|
|
pipeline_parser.add_argument(
|
|
'--skip-scrape',
|
|
action='store_true',
|
|
help='Skip scraping, use existing data'
|
|
)
|
|
pipeline_parser.add_argument(
|
|
'--no-validate',
|
|
action='store_true',
|
|
help='Skip validation step'
|
|
)
|
|
pipeline_parser.add_argument(
|
|
'--verbose', '-v',
|
|
action='store_true',
|
|
help='Verbose output'
|
|
)
|
|
pipeline_parser.set_defaults(func=cmd_pipeline)
|
|
|
|
# full-pipeline: scrape → canonicalize → validate → upload (stops on error)
|
|
full_pipeline_parser = subparsers.add_parser(
|
|
'full-pipeline',
|
|
help='Run complete pipeline: Scrape → Canonicalize → Validate → Upload',
|
|
description='Run all steps in sequence, stopping on any error'
|
|
)
|
|
full_pipeline_parser.add_argument(
|
|
'--season',
|
|
type=int,
|
|
default=2026,
|
|
help='Season year (default: 2026)'
|
|
)
|
|
full_pipeline_parser.add_argument(
|
|
'--sport',
|
|
choices=['nba', 'mlb', 'nhl', 'nfl', 'wnba', 'mls', 'nwsl', 'all'],
|
|
default='all',
|
|
help='Sport to process (default: all)'
|
|
)
|
|
full_pipeline_parser.add_argument(
|
|
'--output',
|
|
type=str,
|
|
default='./data',
|
|
help='Output directory (default: ./data)'
|
|
)
|
|
full_pipeline_parser.add_argument(
|
|
'--skip-upload',
|
|
action='store_true',
|
|
help='Skip CloudKit upload step'
|
|
)
|
|
full_pipeline_parser.set_defaults(func=cmd_full_pipeline)
|
|
|
|
# ============================================================
|
|
# Subcommands for individual canonicalization steps
|
|
# ============================================================
|
|
|
|
# canonicalize-stadiums
|
|
canon_stadiums_parser = subparsers.add_parser(
|
|
'canonicalize-stadiums',
|
|
help='Canonicalize stadium data only',
|
|
description='Canonicalize raw stadium data into canonical format'
|
|
)
|
|
canon_stadiums_parser.add_argument(
|
|
'--input',
|
|
type=str,
|
|
default=None,
|
|
help='Input stadiums file (default: ./data/stadiums.json)'
|
|
)
|
|
canon_stadiums_parser.add_argument(
|
|
'--output',
|
|
type=str,
|
|
default='./data',
|
|
help='Output directory (default: ./data)'
|
|
)
|
|
canon_stadiums_parser.add_argument(
|
|
'--verbose', '-v',
|
|
action='store_true',
|
|
help='Verbose output'
|
|
)
|
|
canon_stadiums_parser.set_defaults(func=cmd_canonicalize_stadiums)
|
|
|
|
# canonicalize-teams
|
|
canon_teams_parser = subparsers.add_parser(
|
|
'canonicalize-teams',
|
|
help='Canonicalize team data only',
|
|
description='Canonicalize raw team data into canonical format'
|
|
)
|
|
canon_teams_parser.add_argument(
|
|
'--stadiums',
|
|
type=str,
|
|
default=None,
|
|
help='Path to canonical stadiums file'
|
|
)
|
|
canon_teams_parser.add_argument(
|
|
'--output',
|
|
type=str,
|
|
default='./data',
|
|
help='Output directory (default: ./data)'
|
|
)
|
|
canon_teams_parser.add_argument(
|
|
'--verbose', '-v',
|
|
action='store_true',
|
|
help='Verbose output'
|
|
)
|
|
canon_teams_parser.set_defaults(func=cmd_canonicalize_teams)
|
|
|
|
# canonicalize-games
|
|
canon_games_parser = subparsers.add_parser(
|
|
'canonicalize-games',
|
|
help='Canonicalize game data only',
|
|
description='Canonicalize raw game data into canonical format'
|
|
)
|
|
canon_games_parser.add_argument(
|
|
'--games',
|
|
type=str,
|
|
default=None,
|
|
help='Path to raw games file'
|
|
)
|
|
canon_games_parser.add_argument(
|
|
'--teams',
|
|
type=str,
|
|
default=None,
|
|
help='Path to canonical teams file'
|
|
)
|
|
canon_games_parser.add_argument(
|
|
'--aliases',
|
|
type=str,
|
|
default=None,
|
|
help='Path to stadium aliases file'
|
|
)
|
|
canon_games_parser.add_argument(
|
|
'--output',
|
|
type=str,
|
|
default='./data',
|
|
help='Output directory (default: ./data)'
|
|
)
|
|
canon_games_parser.add_argument(
|
|
'--verbose', '-v',
|
|
action='store_true',
|
|
help='Verbose output'
|
|
)
|
|
canon_games_parser.set_defaults(func=cmd_canonicalize_games)
|
|
|
|
# Change to Scripts directory for consistent relative paths
|
|
os.chdir(SCRIPT_DIR)
|
|
|
|
# If no arguments, show interactive menu in a loop
|
|
if len(sys.argv) == 1:
|
|
while True:
|
|
cmd_args = interactive_menu()
|
|
if not cmd_args:
|
|
break
|
|
|
|
sys.argv = ['sportstime'] + cmd_args
|
|
print(f"\n{Colors.DIM}Running: sportstime {' '.join(cmd_args)}{Colors.RESET}\n")
|
|
|
|
# Parse and execute
|
|
args = parser.parse_args()
|
|
|
|
if args.command is None:
|
|
continue
|
|
|
|
try:
|
|
args.func(args)
|
|
except SystemExit:
|
|
pass # Catch sys.exit() from subcommands
|
|
except Exception as e:
|
|
print(f"\n{Colors.RED}Error: {e}{Colors.RESET}")
|
|
|
|
# Prompt to continue
|
|
print(f"\n{Colors.GREEN}{'─' * 60}{Colors.RESET}")
|
|
input(f"{Colors.CYAN}Press Enter to continue...{Colors.RESET}")
|
|
|
|
# Reset sys.argv for next iteration
|
|
sys.argv = ['sportstime']
|
|
|
|
sys.exit(0)
|
|
|
|
# Parse and execute (command-line mode)
|
|
args = parser.parse_args()
|
|
|
|
if args.command is None:
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
# Execute the command
|
|
args.func(args)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|