Revive project: switch to Cricbuzz, pixi, and GitHub Actions CI

- Replace broken ESPN Cricinfo HTML scraper with Cricbuzz embedded JSON parser
- Switch from setup.py/requirements.txt to pyproject.toml with pixi
- Replace Travis CI with GitHub Actions (Python 3.10-3.13 matrix)
- Add proper tests for score formatting, match parsing, and e2e
- Drop lxml dependency (use html.parser instead)

Author: aktech

.github/workflows/test.yml

@@ -1,30 +1,26 @@
-# This workflow will install Python dependencies, run tests and lint with a single version of Python
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
-
 name: Test
 
 on:
   push:
+    branches: [master]
   pull_request:
 
 permissions:
   contents: read
 
 jobs:
-  build:
-
+  test:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
 
     steps:
-    - uses: actions/checkout@v3
-    - name: Set up Python 3.10
-      uses: actions/setup-python@v3
-      with:
-        python-version: "3.10"
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
-    - name: Test
-      run: |
-        python -m unittest discover -v
+      - uses: actions/checkout@v4
+
+      - uses: prefix-dev/setup-pixi@v0.8.1
+        with:
+          pixi-version: v0.46.0
+
+      - name: Run tests
+        run: pixi run test

.gitignore

@@ -90,3 +90,7 @@ ENV/
 
 # Rope project settings
 .ropeproject
+
+# Pixi
+.pixi/
+pixi.lock

.travis.yml

@@ -1,63 +1,181 @@
+import json
+import re
+import sys
+
 import requests
 from bs4 import BeautifulSoup
-
 from tabulate import tabulate
 
-SOURCE_URL = "https://www.espncricinfo.com/scores/"
+LIVE_SCORES_URL = "https://www.cricbuzz.com/cricket-match/live-scores"
+HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+        "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    ),
+    "Accept-Language": "en-US,en;q=0.9",
+}
+
+
+def get_scores():
+    """Fetch live cricket scores from Cricbuzz."""
+    response = requests.get(LIVE_SCORES_URL, headers=HEADERS, timeout=10)
+    response.raise_for_status()
+    soup = BeautifulSoup(response.text, "html.parser")
+
+    # Cricbuzz uses Next.js with embedded JSON data in script tags
+    for script in soup.find_all("script"):
+        text = script.string or ""
+        if "matchesList" not in text:
+            continue
+        return _parse_matches_from_script(text)
+
+    return []
+
+
+def _parse_matches_from_script(text):
+    """Extract match data from the Next.js RSC script payload."""
+    # Unescape the embedded JSON strings
+    unescaped = text.replace('\\"', '"').replace("\\n", "\n")
+
+    matches = []
+    # Find all match JSON blocks: {"match":{"matchInfo":{...},"matchScore":{...}}}
+    # We locate each matchInfo and extract the surrounding match object
+    for m in re.finditer(r'"match":\{"matchInfo":\{', unescaped):
+        start = m.start() - 1  # include the opening {
+        match_data = _extract_json_object(unescaped, start)
+        if match_data:
+            parsed = _parse_match(match_data)
+            if parsed:
+                matches.append(parsed)
+
+    # Deduplicate by matchId (data appears multiple times in RSC payload)
+    seen = set()
+    unique = []
+    for m in matches:
+        mid = m.get("match_id")
+        if mid and mid not in seen:
+            seen.add(mid)
+            unique.append(m)
+
+    return unique
+
+
+def _extract_json_object(text, start):
+    """Extract a balanced JSON object starting at position `start`."""
+    if text[start] != "{":
+        return None
+    depth = 0
+    for i in range(start, min(start + 5000, len(text))):
+        if text[i] == "{":
+            depth += 1
+        elif text[i] == "}":
+            depth -= 1
+            if depth == 0:
+                try:
+                    return json.loads(text[start : i + 1])
+                except json.JSONDecodeError:
+                    return None
+    return None
+
+
+def _parse_match(data):
+    """Parse a match dict into our display format."""
+    match = data.get("match", data)
+    info = match.get("matchInfo", {})
+    score_data = match.get("matchScore", {})
+
+    team1_info = info.get("team1", {})
+    team2_info = info.get("team2", {})
+
+    if not team1_info or not team2_info:
+        return None
+
+    team1_score = _format_score(score_data.get("team1Score", {}))
+    team2_score = _format_score(score_data.get("team2Score", {}))
+
+    status = info.get("stateTitle", "") or info.get("state", "")
+
+    return {
+        "match_id": info.get("matchId"),
+        "title": f"{info.get('seriesName', '')} - {info.get('matchDesc', '')}",
+        "format": info.get("matchFormat", ""),
+        "first_team": {
+            "name": team1_info.get("teamSName", team1_info.get("teamName", "")),
+            "score": team1_score,
+        },
+        "second_team": {
+            "name": team2_info.get("teamSName", team2_info.get("teamName", "")),
+            "score": team2_score,
+        },
+        "status": status,
+    }
+
+
+def _format_score(team_score):
+    """Format innings scores into a readable string."""
+    parts = []
+    for key in ("inngs1", "inngs2"):
+        innings = team_score.get(key)
+        if innings:
+            runs = innings.get("runs", "")
+            wickets = innings.get("wickets", "")
+            overs = innings.get("overs", "")
+            score_str = f"{runs}/{wickets}"
+            if overs:
+                score_str += f" ({overs} ov)"
+            parts.append(score_str)
+    return " & ".join(parts)
 
 
 def _print_scores(scores):
-    table = [
-        [
-            f"{score['first_team']['name']} {score['first_team']['score']}",
-            f"{score['second_team']['name']} {score['second_team']['score']}"
-        ]
-        for score in scores
-    ]
-    table_len = len(table)
-    print(tabulate(
-        table,
-        showindex=range(1, table_len + 1),
-        tablefmt='fancy_grid')
-    )
+    """Print scores in a formatted table."""
+    if not scores:
+        print("No live matches at the moment.")
+        return
 
+    table = []
+    for score in scores:
+        first = score["first_team"]
+        second = score["second_team"]
+        status = score.get("status", "")
+        fmt = score.get("format", "")
 
-def get_scores():
-    html = requests.get(SOURCE_URL).text
-    soup = BeautifulSoup(html, "lxml")
-    competitors = soup.find_all('ul', attrs={'class': 'cscore_competitors'})
-
-    scores = []
-
-    for each_competitor in competitors:
-        team_scores = list(map(_extract_score, each_competitor.find_all('div', {'class': 'cscore_score'})))
-        team_names = list(map(lambda x: x.contents[0], each_competitor.find_all('span', {'class': 'cscore_name--long'})))
-
-        scores.append(
-            {
-                'first_team': {
-                    'name': team_names[0],
-                    'score': team_scores[0]
-                },
-                'second_team': {
-                    'name': team_names[1],
-                    'score': team_scores[1]
-                },
-            }
-        )
-    return scores
+        first_col = first["name"]
+        if first["score"]:
+            first_col += f"  {first['score']}"
 
+        second_col = second["name"]
+        if second["score"]:
+            second_col += f"  {second['score']}"
 
-def _extract_score(score_soup):
-    score_string = score_soup.contents
-    if len(score_string) == 2:
-        score, overs = score_string
-        overs_content = overs.contents
-        score_string = [f'{score} {overs_content[0]}']
-    return score_string
+        table.append([first_col, "vs", second_col, fmt, status])
 
+    print(
+        tabulate(
+            table,
+            headers=["Team 1", "", "Team 2", "Format", "Status"],
+            showindex=range(1, len(table) + 1),
+            tablefmt="fancy_grid",
+        )
+    )
 
-def main():
-    scores = get_scores()
-    _print_scores(scores)
 
+def main():
+    try:
+        scores = get_scores()
+        _print_scores(scores)
+    except requests.ConnectionError:
+        print(
+            "Error: Could not connect. Check your internet connection.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    except requests.Timeout:
+        print("Error: Request timed out.", file=sys.stderr)
+        sys.exit(1)
+    except requests.HTTPError as e:
+        print(f"Error: HTTP {e.response.status_code}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)

criclive/main.py

@@ -0,0 +1,39 @@
+[project]
+name = "criclive"
+version = "0.3"
+description = "Live Cricket Scores in Command Line."
+authors = [{ name = "Amit Kumar", email = "dtu.amit@gmail.com" }]
+license = { text = "MIT" }
+keywords = ["Cricket", "score", "scores", "cli", "live"]
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "beautifulsoup4>=4.12",
+    "requests>=2.31",
+    "tabulate>=0.9",
+]
+
+[project.urls]
+Homepage = "https://github.com/aktech/criclive"
+
+[project.scripts]
+criclive = "criclive.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.pixi.workspace]
+channels = ["conda-forge"]
+platforms = ["linux-64", "linux-aarch64", "osx-arm64", "osx-64"]
+
+[tool.pixi.pypi-dependencies]
+criclive = { path = ".", editable = true }
+
+[tool.pixi.tasks]
+start = "criclive"
+test = "python -m pytest tests.py"
+
+[tool.pixi.dependencies]
+python = ">=3.10"
+pytest = ">=8"