feat: add bowling_scorecard property with _bowling_entry helper

Implements bowling_scorecard (list[list[dict]]) and _bowling_entry helper
on Match, mirroring the batting_scorecard pattern. Also tightens the
batting_scorecard return-type annotation from `list` to `list[list[dict]]`.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dwillis

espncricinfo/match.py

@@ -716,7 +716,7 @@ def _batting_entry(self, raw: dict) -> dict:
         }
 
     @property
-    def batting_scorecard(self) -> list:
+    def batting_scorecard(self) -> list[list[dict]]:
         """
         Return batting scorecard for all innings as ``list[list[dict]]``.
 
@@ -740,6 +740,49 @@ def batting_scorecard(self) -> list:
                 result.append([])
         return result
 
+    def _bowling_entry(self, raw: dict) -> dict:
+        """Transform a raw inningBowlers dict into a clean flat dict."""
+        player = raw.get("player") or {}
+        economy = raw.get("economy")
+        overs = raw.get("overs")
+        return {
+            "name":      player.get("name"),
+            "full_name": player.get("longName"),
+            "player_id": player.get("objectId"),
+            "overs":     float(overs) if overs is not None else None,
+            "maidens":   raw.get("maidens"),
+            "runs":      raw.get("conceded"),
+            "wickets":   raw.get("wickets"),
+            "economy":   float(economy) if economy is not None else None,
+            "wides":     raw.get("wides"),
+            "no_balls":  raw.get("noballs"),
+            "dots":      raw.get("dots"),
+        }
+
+    @property
+    def bowling_scorecard(self) -> list[list[dict]]:
+        """
+        Return bowling scorecard for all innings as ``list[list[dict]]``.
+
+        Outer list is indexed by innings order; inner list has one entry
+        per bowler.
+
+        Example::
+
+            for i, innings in enumerate(m.bowling_scorecard, 1):
+                print(f"Innings {i}:")
+                for b in innings:
+                    print(f"  {b['name']}: {b['wickets']}/{b['runs']} ({b['overs']} ov)")
+        """
+        result = []
+        for i in range(1, len(self.innings) + 1):
+            raw_list = self.bowlers(i)
+            if raw_list:
+                result.append([self._bowling_entry(r) for r in raw_list])
+            else:
+                result.append([])
+        return result
+
     # ------------------------------------------------------------------
     # Static helpers
     # ------------------------------------------------------------------

tests/test_match.py

@@ -351,3 +351,44 @@ def patched_batsmen(i):
         with patch.object(self.match, 'batsmen', side_effect=patched_batsmen):
             sc = self.match.batting_scorecard
         self.assertEqual(sc[1], [])
+
+    # ---- bowling_scorecard ----
+
+    def test_bowling_scorecard_is_list_of_2_innings(self):
+        sc = self.match.bowling_scorecard
+        self.assertIsInstance(sc, list)
+        self.assertEqual(len(sc), 2)
+
+    def test_bowling_scorecard_innings_are_nonempty_lists(self):
+        for innings in self.match.bowling_scorecard:
+            self.assertIsInstance(innings, list)
+            self.assertGreater(len(innings), 0)
+
+    def test_bowling_scorecard_entry_has_required_keys(self):
+        entry = self.match.bowling_scorecard[0][0]
+        for key in ("name", "full_name", "player_id", "overs", "maidens",
+                    "runs", "wickets", "economy", "wides", "no_balls", "dots"):
+            self.assertIn(key, entry)
+
+    def test_bowling_scorecard_first_bowler_values(self):
+        # Darcie Brown bowled first innings
+        entry = self.match.bowling_scorecard[0][0]
+        self.assertEqual(entry["name"], "D Brown")
+        self.assertIsInstance(entry["wickets"], int)
+        self.assertIsInstance(entry["overs"], float)
+
+    def test_bowling_scorecard_economy_is_float_or_none(self):
+        entry = self.match.bowling_scorecard[0][0]
+        self.assertTrue(
+            entry["economy"] is None or isinstance(entry["economy"], float)
+        )
+
+    def test_bowling_scorecard_empty_innings_returns_empty_list(self):
+        original_bowlers = self.match.bowlers
+        def patched_bowlers(i):
+            if i == 2:
+                return None
+            return original_bowlers(i)
+        with patch.object(self.match, 'bowlers', side_effect=patched_bowlers):
+            sc = self.match.bowling_scorecard
+        self.assertEqual(sc[1], [])