tptools 0.7.2__tar.gz → 0.7.4__tar.gz

{tptools-0.7.2 → tptools-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tptools
-Version: 0.7.2
+Version: 0.7.4
 Summary: A set of tools to export data from TournamentSoftware
 Author-email: "martin f. krafft" <tptools@pobox.madduck.net>
 License-File: LICENSE
@@ -364,6 +364,9 @@ one or more `--url` arguments and will post the data there.
 | `post`      | A simple tournament representation (players, draws, courts, matches) |
 | `sq-stdout` | A view of the data sent to Squore (see below)                        |
 
+Matches in the `stdout` and `post` output carry an `errors` array. See [Invalid
+match data](#invalid-match-data) below.
+
 ### Forwarding TP data
 
 If you prefer to work mostly on another machine than the one running
@@ -560,6 +563,29 @@ instead of the TP file as argument to the `tp` subcommand.
 
 ## Known Problems
 
+### Invalid match data
+
+TournamentSoftware sometimes stores set scores that cannot happen in the
+configured scoring format. An example is 15-11 in a "Par 11" tournament: a set
+ends at 14-11, so 15-11 is impossible. Another example is a match whose two
+player rows disagree about the scoreline.
+
+`tptools` does not reject such a match. It loads the match and adds one string
+to the match's `errors` array for each problem:
+
+* a set score that cannot happen in the format, such as 15-11 in a "Par 11"
+  tournament;
+* two player rows that disagree about the scoreline;
+* a recorded winner who did not win more sets than the opponent.
+
+When `errors` is empty, the match data is valid. An unplayed match has no
+score to check, so it has no errors.
+
+The `stdout` and `post` commands serve the match like any other, with the
+`errors` array next to the data. The Squore endpoints do not include `errors`,
+because the Squore schema has no field for them. Use `stdout` or `post` when
+you need the `errors` array.
+
 ### BYEs in Group Draws
 
 There seems to be no way to identify a match with a BYE in the database, and

{tptools-0.7.2 → tptools-0.7.4}/README.md

@@ -318,6 +318,9 @@ one or more `--url` arguments and will post the data there.
 | `post`      | A simple tournament representation (players, draws, courts, matches) |
 | `sq-stdout` | A view of the data sent to Squore (see below)                        |
 
+Matches in the `stdout` and `post` output carry an `errors` array. See [Invalid
+match data](#invalid-match-data) below.
+
 ### Forwarding TP data
 
 If you prefer to work mostly on another machine than the one running
@@ -514,6 +517,29 @@ instead of the TP file as argument to the `tp` subcommand.
 
 ## Known Problems
 
+### Invalid match data
+
+TournamentSoftware sometimes stores set scores that cannot happen in the
+configured scoring format. An example is 15-11 in a "Par 11" tournament: a set
+ends at 14-11, so 15-11 is impossible. Another example is a match whose two
+player rows disagree about the scoreline.
+
+`tptools` does not reject such a match. It loads the match and adds one string
+to the match's `errors` array for each problem:
+
+* a set score that cannot happen in the format, such as 15-11 in a "Par 11"
+  tournament;
+* two player rows that disagree about the scoreline;
+* a recorded winner who did not win more sets than the opponent.
+
+When `errors` is empty, the match data is valid. An unplayed match has no
+score to check, so it has no errors.
+
+The `stdout` and `post` commands serve the match like any other, with the
+`errors` array next to the data. The Squore endpoints do not include `errors`,
+because the Squore schema has no field for them. Use `stdout` or `post` when
+you need the `errors` array.
+
 ### BYEs in Group Draws
 
 There seems to be no way to identify a match with a BYE in the database, and

{tptools-0.7.2 → tptools-0.7.4}/integration/test_loading_matches.py

@@ -1,13 +1,20 @@
-from collections.abc import Iterable
+import pathlib
+import shutil
+import sqlite3
+from collections.abc import Generator, Iterable
 
 import pytest
 import pytest_subtests
+from sqlmodel import Session, create_engine
 
+from tptools import load_tournament
 from tptools.tpmatch import TPMatch, TPMatchStatus
 from tptools.util import ScoresType
 
 type MatchIdTuple = tuple[int, int]
 
+SQLITE_EXPORT = pathlib.Path(__file__).parent / "anon_tournament.sqlite"
+
 
 def test_loading_all_matches(all_tpmatches: list[TPMatch]) -> None:
     assert len(all_tpmatches) == 68
@@ -205,3 +212,50 @@ def test_match_scores(
 
 
 # vim:fdm=marker:fdl=0
+
+
+@pytest.fixture
+def bad_score_db(tmp_path: pathlib.Path) -> Generator[pathlib.Path]:
+    """A copy of the export where match 80-11 ends 15-11, inconsistently.
+
+    The two PlayerMatch rows store the scoreline in the same orientation, so
+    they disagree, reproducing the TP export that made load_tournament raise a
+    ValidationError.
+    """
+    dest = tmp_path / "bad_scores.sqlite"
+    shutil.copy(SQLITE_EXPORT, dest)
+    with sqlite3.connect(dest) as conn:
+        # pm 1199 wins 15-11; pm 1200 stores the same orientation, not reversed
+        conn.execute(
+            "update PlayerMatch set winner=1, "
+            "team1set1=15, team2set1=11, "
+            "team1set2=0, team2set2=0, team1set3=0, team2set3=0 "
+            "where id=1199"
+        )
+        conn.execute(
+            "update PlayerMatch set winner=2, "
+            "team1set1=15, team2set1=11, "
+            "team1set2=0, team2set2=0, team1set3=0, team2set3=0 "
+            "where id=1200"
+        )
+        conn.commit()
+    yield dest
+
+
+@pytest.mark.asyncio
+async def test_load_tournament_records_bad_scores_errors(
+    bad_score_db: pathlib.Path,
+) -> None:
+    """load_tournament loads the bad match and records its errors."""
+    engine = create_engine(f"sqlite:///{bad_score_db}")
+    session = Session(engine)
+    session.begin()
+    try:
+        tournament = await load_tournament(session)
+    finally:
+        session.close()
+        engine.dispose()
+
+    match = tournament.matches["80-11"]
+    assert match.errors
+    assert match.scores == [(15, 11)]

{tptools-0.7.2 → tptools-0.7.4}/tests/conftest.py

@@ -424,6 +424,50 @@ def TPMatchFactory() -> TPMatchFactoryType:
     return match_maker
 
 
+type ScorePairFactoryType = Callable[..., TPMatch]
+
+
+@pytest.fixture
+def ScorePairFactory(tpmatch1: TPMatch) -> ScorePairFactoryType:
+    """Build a TPMatch from a scored set list.
+
+    ``scores`` are from pm1's perspective. ``pm2`` normally stores the reversed
+    scoreline and claims the opposite winner. Pass ``pm2_winner`` or
+    ``pm2_scores`` to deliberately construct an inconsistent pair, e.g. as
+    produced by a faulty TP export.
+    """
+
+    def pair_maker(
+        scores: list[tuple[int, int]],
+        *,
+        pm1_winner: int = 1,
+        pm2_winner: int | None = None,
+        pm2_scores: list[tuple[int, int]] | None = None,
+    ) -> TPMatch:
+        def apply(
+            pm: TPPlayerMatch,
+            pairs: list[tuple[int, int]],
+            winner: int,
+        ) -> TPPlayerMatch:
+            update: dict[str, int] = {
+                "winner": winner,
+                **{f"team{a}set{g}": 0 for a in (1, 2) for g in range(1, 6)},
+            }
+            for g, (a, b) in enumerate(pairs, start=1):
+                update |= {f"team1set{g}": a, f"team2set{g}": b}
+            return pm.model_copy(update=update)
+
+        pm1 = apply(tpmatch1.pm1, scores, pm1_winner)
+        if pm2_scores is None:
+            pm2_scores = [(b, a) for a, b in scores]
+        if pm2_winner is None:
+            pm2_winner = 3 - pm1_winner if pm1_winner in (1, 2) else pm1_winner
+        pm2 = apply(tpmatch1.pm2, pm2_scores, pm2_winner)
+        return TPMatch(pm1=pm1, pm2=pm2)
+
+    return pair_maker
+
+
 @pytest.fixture
 def tpmatch1(
     TPMatchFactory: TPMatchFactoryType,

{tptools-0.7.2 → tptools-0.7.4}/tests/ext/squore/test_match.py

@@ -16,3 +16,8 @@ def test_pending_match(sqmatch_pending: SquoreMatch) -> None:
     assert sqmatch_pending.court is None
     assert isinstance(sqmatch_pending.A, SquoreEntry)
     assert sqmatch_pending.B == "Unknown"
+
+
+def test_squore_match_dump_excludes_errors(sqmatch1: SquoreMatch) -> None:
+    """The Squore wire format must not contain the errors array."""
+    assert "errors" not in sqmatch1.model_dump()

{tptools-0.7.2 → tptools-0.7.4}/tests/test_devcourtmap.py

@@ -91,3 +91,27 @@ def test_find_abnormal_court_name(
     devcourtmap: DeviceCourtMap, courts: dict[str, Court]
 ) -> None:
     assert devcourtmap.find_court_for_ip("192.0.2.99", courts.values()) is None
+
+
+def test_manual_add(devcourtmap: DeviceCourtMap, courts: dict[str, Court]) -> None:
+    devcourtmap.add_devcourt_mapping("192.0.2.14", "court10")
+    assert devcourtmap.find_court_for_ip("192.0.2.14", courts.values()) == courts.get(
+        "court10"
+    )
+
+
+def test_manual_remove(devcourtmap: DeviceCourtMap, courts: dict[str, Court]) -> None:
+    assert devcourtmap.pop_devcourt_mapping("192.0.2.11") == 11
+    assert devcourtmap.find_court_for_ip("192.0.2.11", courts.values()) is None
+
+
+def test_manual_remove_nonexisting(
+    devcourtmap: DeviceCourtMap, courts: dict[str, Court]
+) -> None:
+    with pytest.raises(KeyError, match="No mapping from"):
+        assert devcourtmap.pop_devcourt_mapping("192.0.2.15")
+
+
+def test_manual_add_does_not_overwrite(devcourtmap: DeviceCourtMap) -> None:
+    with pytest.raises(KeyError, match="already exists"):
+        devcourtmap.add_devcourt_mapping("192.0.2.11", "court")

tptools-0.7.4/tests/test_match.py

@@ -0,0 +1,116 @@
+from datetime import datetime
+
+import pytest
+
+from tptools import Match
+
+from .conftest import ScorePairFactoryType
+
+
+def test_repr(match1: Match) -> None:
+    assert repr(match1) == (
+        "Match(id='1-14', matchnr=14, draw=Draw(id=1, name='Baum', "
+        "stage.name='Qual', type=MONRAD, size=8), time=datetime(2025, 6, 1, 11, 30), "
+        "court=Court(id=1, name='C01', location.name='Sports4You'), "
+        "A=Entry(event.name='Herren 1', player1.name='Martin Krafft'), "
+        "B=Entry(event.name='Herren 1', player1.name='Iddo Hoeve'), "
+        "status=ready, starttime=None, endtime=None, winner=None, scores=-)"
+    )
+
+
+def test_str(match1: Match) -> None:
+    assert str(match1) == "1-14 ready on C01 (Sports4You) @ 11:30"
+
+
+def test_cmp_eq(match1: Match, match1copy: Match) -> None:
+    assert match1 == match1copy
+
+
+def test_cmp_ne(match1: Match, match2: Match) -> None:
+    assert match1 != match2
+
+
+def test_cmp_lt(match1: Match, match2: Match) -> None:
+    assert match1 < match2
+
+
+def test_cmp_le(match1: Match, match1copy: Match, match2: Match) -> None:
+    assert match1 < match2 and match1 <= match1copy
+
+
+def test_cmp_gt(match1: Match, match2: Match) -> None:
+    assert match2 > match1
+
+
+def test_cmp_ge(match1: Match, match1copy: Match, match2: Match) -> None:
+    assert match2 > match1 and match1 >= match1copy
+
+
+@pytest.mark.parametrize("attr", ["time", "starttime", "endtime"])
+def test_match_timestamps_have_timezone(
+    match1: Match, attr: str, now: datetime
+) -> None:
+    m = Match(**match1.model_dump() | {attr: now})  # pyright: ignore[reportArgumentType]
+    assert getattr(m, attr).tzinfo is not None
+
+
+def test_match_dump_includes_errors(ScorePairFactory: ScorePairFactoryType) -> None:
+    """The generic Match dump carries the errors array."""
+    match = Match.from_tpmatch(ScorePairFactory([(15, 11)]))
+    assert match.errors
+    assert match.model_dump()["errors"] == match.errors
+
+
+@pytest.mark.parametrize(
+    "scores",
+    [
+        [(11, 10)],
+        [(11, 12)],
+        [(15, 11)],
+    ],
+)
+def test_match_errors_for_illegal_set_scores(
+    ScorePairFactory: ScorePairFactoryType, scores: list[tuple[int, int]]
+) -> None:
+    """A Match built from an illegal TPMatch carries the recorded errors."""
+    match = Match.from_tpmatch(ScorePairFactory(scores))
+    assert match.errors
+
+
+def test_match_errors_empty_for_legal_set_scores(
+    ScorePairFactory: ScorePairFactoryType,
+) -> None:
+    """A Match built from a clean TPMatch has no errors."""
+    match = Match.from_tpmatch(ScorePairFactory([(11, 5)]))
+    assert match.errors == []
+
+
+def test_match_from_tpmatch_shallow_copies_errors(
+    ScorePairFactory: ScorePairFactoryType,
+) -> None:
+    """Match.from_tpmatch shallow-copies the TPMatch's errors.
+
+    The Match must get a list of its own (same contents, distinct object), so
+    that appending to one model's errors does not affect the other's.
+    """
+    tpmatch = ScorePairFactory([(15, 11)])
+    tpmatch.errors.append("invented")
+    match = Match.from_tpmatch(tpmatch)
+    assert match.errors == tpmatch.errors
+    assert match.errors is not tpmatch.errors
+    match.errors.append("only on the match")
+    assert "only on the match" not in tpmatch.errors
+
+
+def test_match_errors_default_is_not_shared(
+    ScorePairFactory: ScorePairFactoryType,
+) -> None:
+    """The Match errors default must come from default_factory=list.
+
+    A bare ``errors: list[str] = []`` default would be shared across all
+    instances: mutating one match's errors would leak into every other match.
+    """
+    one = Match.from_tpmatch(ScorePairFactory([(11, 5)]))
+    two = Match.from_tpmatch(ScorePairFactory([(11, 5)]))
+    one.errors.append("marker")
+    assert two.errors == []

{tptools-0.7.2 → tptools-0.7.4}/tests/test_tpmatch.py

@@ -8,7 +8,7 @@ from tptools.slot import Bye, Slot, Unknown
 from tptools.sqlmodels import TPEntry, TPPlayerMatch
 from tptools.tpmatch import TPMatch, TPMatchStatus
 
-from .conftest import TPMatchFactoryType
+from .conftest import ScorePairFactoryType, TPMatchFactoryType
 
 
 def test_repr(tpmatch1: TPMatch) -> None:
@@ -248,3 +248,138 @@ def test_slot_accessor_explicit(slot1: Slot, slot2: Slot, tpmatch1: TPMatch) ->
     # the order of set_slots() overrides the winner field
     assert m.slot1 == slot2
     assert m.slot2 == slot1
+
+
+# A tournament using "Par 11" scoring: a set is won by reaching 11 (or more)
+# with a two-point margin. Therefore 11-10, 11-12, and 15-11 are all illegal.
+
+
+@pytest.mark.parametrize(
+    "scores",
+    [
+        [(11, 10)],
+        [(11, 12)],
+        [(15, 11)],
+    ],
+)
+def test_illegal_set_scores(
+    ScorePairFactory: ScorePairFactoryType, scores: list[tuple[int, int]]
+) -> None:
+    """An illegal set score is flagged, not silently accepted or raised."""
+    m = ScorePairFactory(scores)
+    assert m.errors
+
+
+@pytest.mark.parametrize(
+    "scores",
+    [
+        [(11, 5)],
+        [(11, 9)],
+        [(13, 11)],
+        [(11, 4), (6, 11), (13, 11), (11, 8)],
+    ],
+)
+def test_legal_set_scores_are_not_flagged(
+    ScorePairFactory: ScorePairFactoryType, scores: list[tuple[int, int]]
+) -> None:
+    """Legal set scores leave the match unflagged."""
+    m = ScorePairFactory(scores)
+    assert m.errors == []
+
+
+def test_errors_default_is_not_shared(
+    ScorePairFactory: ScorePairFactoryType,
+) -> None:
+    """The errors default must come from default_factory=list, not a shared []
+
+    A bare ``errors: list[str] = []`` default would be shared across all
+    instances: mutating one match's errors would leak into every other match.
+    """
+    one = ScorePairFactory([(11, 5)])
+    two = ScorePairFactory([(11, 5)])
+    one.errors.append("marker")
+    assert two.errors == []
+
+
+def test_inconsistent_pair_is_flagged_with_errors(
+    ScorePairFactory: ScorePairFactoryType,
+) -> None:
+    """A 15-11 set whose two PlayerMatches disagree no longer raises.
+
+    This reproduces the real-world TP export where one set ends 15-11 and the
+    two PlayerMatch rows store the scoreline in the same orientation, so they
+    disagree about it. The match must load, but record the error(s) for
+    downstream alerting.
+    """
+    # Both winners agree, but pm2 stores the scoreline in pm1's orientation.
+    # Previously this made TPMatch raise a ValidationError.
+    m = ScorePairFactory([(15, 11)], pm2_scores=[(15, 11)], pm2_winner=2)
+    assert m.errors
+
+
+@pytest.mark.parametrize(
+    "pm1_scores, pm2_scores, pm1_winner, pm2_winner",
+    [
+        # pm1 (A) wins the match 2-0
+        ([(11, 5), (11, 6)], [(5, 11), (6, 11)], 1, 2),
+        # pm1 (A) wins 2-1
+        ([(11, 5), (6, 11), (11, 7)], [(5, 11), (11, 6), (7, 11)], 1, 2),
+        # pm2 (B) wins 2-0
+        ([(5, 11), (6, 11)], [(11, 5), (11, 6)], 2, 1),
+    ],
+)
+def test_winner_matches_set_count(
+    ScorePairFactory: ScorePairFactoryType,
+    pm1_scores: list[tuple[int, int]],
+    pm2_scores: list[tuple[int, int]],
+    pm1_winner: int,
+    pm2_winner: int,
+) -> None:
+    """The winner field agrees with who won more sets."""
+    m = ScorePairFactory(
+        pm1_scores,
+        pm1_winner=pm1_winner,
+        pm2_scores=pm2_scores,
+        pm2_winner=pm2_winner,
+    )
+    assert m.errors == []
+
+
+@pytest.mark.parametrize(
+    "pm1_scores, pm2_scores, pm1_winner, pm2_winner, won_by",
+    [
+        # winner says A, but pm2 won both sets
+        ([(5, 11), (6, 11)], [(11, 5), (11, 6)], 1, 2, "A"),
+        # winner says B, but pm1 won both sets
+        ([(11, 5), (11, 6)], [(5, 11), (6, 11)], 2, 1, "B"),
+        # winner says A, but the sets are split 1-1
+        ([(11, 5), (6, 11)], [(5, 11), (11, 6)], 1, 2, "A"),
+    ],
+)
+def test_winner_contradicts_set_count(
+    ScorePairFactory: ScorePairFactoryType,
+    pm1_scores: list[tuple[int, int]],
+    pm2_scores: list[tuple[int, int]],
+    pm1_winner: int,
+    pm2_winner: int,
+    won_by: str,
+) -> None:
+    """A recorded winner who did not win more sets is flagged."""
+    m = ScorePairFactory(
+        pm1_scores,
+        pm1_winner=pm1_winner,
+        pm2_scores=pm2_scores,
+        pm2_winner=pm2_winner,
+    )
+    assert any(
+        e.startswith(f"winner '{won_by}' does not match the set count")
+        for e in m.errors
+    )
+
+
+def test_unplayed_match_has_no_set_count_error(
+    ScorePairFactory: ScorePairFactoryType,
+) -> None:
+    """An unplayed match records no set-count error, even without scores."""
+    m = ScorePairFactory([], pm1_winner=0, pm2_winner=0)
+    assert m.errors == []

{tptools-0.7.2 → tptools-0.7.4}/tests/test_util.py

@@ -439,6 +439,49 @@ def test_scores_to_string_gamesep() -> None:
     assert util.scores_to_string([(1, 2), (3, 4), (5, 6)], gamesep="g") == "1-2g3-4g5-6"
 
 
+@pytest.mark.parametrize(
+    "high, low",
+    [
+        (11, 0),
+        (11, 9),
+        (12, 10),
+        (13, 11),
+        (14, 12),
+        (15, 13),
+        (18, 16),
+    ],
+)
+def test_is_score_legal(high: int, low: int) -> None:
+    assert util.is_score_legal(high, low)
+    # the order of the two scores does not matter
+    assert util.is_score_legal(low, high)
+
+
+@pytest.mark.parametrize(
+    "high, low",
+    [
+        (11, 10),
+        (11, 12),
+        (15, 11),
+        (14, 11),
+        (15, 12),
+        (10, 0),
+    ],
+)
+def test_set_score_is_illegal(high: int, low: int) -> None:
+    assert not util.is_score_legal(high, low)
+
+
+def test_is_score_legal_par() -> None:
+    assert util.is_score_legal(15, 13, par=15)
+    assert util.is_score_legal(15, 12, par=15)
+    assert util.is_score_legal(15, 0, par=15)
+    assert util.is_score_legal(16, 14, par=15)
+    assert util.is_score_legal(17, 15, par=15)
+    assert not util.is_score_legal(15, 14, par=15)
+    assert not util.is_score_legal(18, 15, par=15)
+
+
 @pytest.mark.parametrize(
     "input, sep, exp",
     [

{tptools-0.7.2 → tptools-0.7.4}/tests/tpsrv/test_squoresrv.py

@@ -696,9 +696,10 @@ def test_settings_for_device_on_a_court(
 
     assert resp.status_code == 200
     settings = resp.json()
-    assert settings["customData"] == {
-        "court": {"id": court_id, "location_id": location_id}
-    }
+    c = Court.model_validate(settings["customData"]["court"])
+    assert c.id == court_id
+    assert c.location is not None
+    assert c.location.id == location_id
     assert settings["liveScoreDeviceId_customSuffix"] == suffix
     assert settings["feedPostUrl"] == feed_idx, "the feed of the court is preselected"
     assert "Pre-selected feed" in caplog.text

{tptools-0.7.2 → tptools-0.7.4}/tptools/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.7.2'
-__version_tuple__ = version_tuple = (0, 7, 2)
+__version__ = version = '0.7.4'
+__version_tuple__ = version_tuple = (0, 7, 4)
 
 __commit_id__ = commit_id = None

{tptools-0.7.2 → tptools-0.7.4}/tptools/devcourtmap.py

@@ -24,6 +24,17 @@ class DeviceCourtMap:
         # so for convenience, flatten this:
         return flatten_dict(devmap)
 
+    def add_devcourt_mapping(self, ip: str, court: int | str) -> None | Never:
+        if ip in self._devmap:
+            raise KeyError(f"A mapping from {ip} already exists")
+        self._devmap[ip] = court
+        return None
+
+    def pop_devcourt_mapping(self, ip: str) -> int | str | Never:
+        if ip not in self._devmap:
+            raise KeyError(f"No mapping from {ip} to remove")
+        return self._devmap.pop(ip)
+
     @staticmethod
     def normalise_court_name_for_matching(
         courtname: str,

{tptools-0.7.2 → tptools-0.7.4}/tptools/ext/squore/match.py

@@ -70,6 +70,9 @@ class SquoreMatch(Match[SquoreEntry, SquoreDraw, SquoreCourt]):
         self, handler: SerializerFunctionWrapHandler
     ) -> SquoreMatchStruct:
         ret: SquoreMatchStruct = handler(self)
+        # Squore does not know about our error reporting, and its struct forbids
+        # extra keys, so keep errors out of the Squore wire format.
+        cast(dict[str, Any], ret).pop("errors", None)
         dt = self.time
         ret["date"] = dt.date().strftime("%F") if dt is not None else None
         ret["time"] = dt.time().strftime("%H:%M") if dt is not None else None

{tptools-0.7.2 → tptools-0.7.4}/tptools/match.py

@@ -5,7 +5,7 @@ from typing import Annotated, Literal, Self, cast
 from zoneinfo import ZoneInfo
 
 import tzlocal
-from pydantic import AfterValidator, BaseModel
+from pydantic import AfterValidator, BaseModel, Field
 
 from .court import Court
 from .draw import Draw
@@ -42,6 +42,9 @@ class Match[EntryT: Entry = Entry, DrawT: Draw = Draw, CourtT: Court = Court](
     endtime: Annotated[datetime, AfterValidator(_ensure_tzaware_time)] | None
     winner: Literal["A"] | Literal["B"] | None = None
     scores: ScoresType = []
+    # Problems recorded while loading the match, e.g. illegal set scores. This is
+    # a shallow copy of TPMatch.errors; downstream consumers should surface them.
+    errors: list[str] = Field(default_factory=list)
 
     __repr_fields__ = [
         "id",
@@ -108,6 +111,7 @@ class Match[EntryT: Entry = Entry, DrawT: Draw = Draw, CourtT: Court = Court](
             endtime=tpmatch.endtime,
             winner=winner,
             scores=tpmatch.scores,
+            errors=list(tpmatch.errors),
             **players,
         )