gammonview 3.2.0__tar.gz → 3.3.0__tar.gz

{gammonview-3.2.0 → gammonview-3.3.0}/CHANGELOG.md

@@ -13,6 +13,24 @@ when the repository was opened; they are kept because they record why things
 are the way they are — particularly the breaking changes and the measurements
 behind several design decisions. Dates are the tag dates.
 
+## 3.3.0 — 2026-11-05
+
+**A money session is analysed under the rules it was played under** *(fixed)*
+
+`analyze_file` read a session's Jacoby and beaver rules and wrote them into the
+summary, but passed neither to the engine, so every money session was judged
+under bgsage's defaults, both on, whatever the file said. A session played
+without Jacoby had its gammons counted with the cube centred, which moves cube
+verdicts, checker equities, error sizes and PR across the whole session; one
+played without beavers had a wrong double answered with a beaver. Every engine
+call a decision makes now gets the session's rules, and so does `fill_luck`.
+Match play is unaffected: it has neither rule.
+
+Behaviour change: a money session whose file says Jacoby or beavers are off is
+now analysed that way. The money golden, a session with neither, is
+regenerated; its first game no longer has a missed double, which the v2 format
+cases now write in rather than find.
+
 ## 3.2.0 — 2026-11-04
 
 **`analyze_position` takes the money rules: Jacoby and beavers** *(added)*

{gammonview-3.2.0 → gammonview-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gammonview
-Version: 3.2.0
+Version: 3.3.0
 Summary: Backgammon match analysis — the pure-Python OGXM/GVA codec (`gvformat`) plus bgsage-powered match and position analysis (`gvanalysis`).
 Project-URL: Homepage, https://github.com/gammonview/gammonview-analysis
 Project-URL: Repository, https://github.com/gammonview/gammonview-analysis

{gammonview-3.2.0 → gammonview-3.3.0}/gvanalysis/game_eval.py

@@ -140,6 +140,8 @@ def _compute_luck(
     verbose: bool = False,
     postroll_eq: float | None = None,
     hint_eq: float | None = None,
+    jacoby: bool = True,
+    beaver: bool = True,
 ) -> tuple[float, float] | tuple[None, None]:
     """Return (luck, preroll_equity).
 
@@ -170,6 +172,9 @@ def _compute_luck(
     roll, given I am the one on roll", which silently discards the roll-off that
     decided *who* is on roll. Positive luck means the actual dice were above
     average for the mover.
+
+    `jacoby` and `beaver` are the session's money rules, as for every other
+    engine call in a match; bgsage ignores them at a match score.
     """
     if list(board) == list(STARTING_BOARD):
         preroll = _opening_baseline(away1, away2, cube_value, is_crawford)
@@ -179,6 +184,7 @@ def _compute_luck(
                     board, die1, die2,
                     cube_value=cube_value, cube_owner=cube_owner,
                     away1=away1, away2=away2, is_crawford=is_crawford,
+                    jacoby=jacoby, beaver=beaver,
                 )
                 moves = list(result.moves)
                 postroll_eq = float(moves[0].equity) if moves else 0.0
@@ -197,6 +203,7 @@ def _compute_luck(
                 board, d1, d2,
                 cube_value=cube_value, cube_owner=cube_owner,
                 away1=away1, away2=away2, is_crawford=is_crawford,
+                jacoby=jacoby, beaver=beaver,
             )
             moves = list(result.moves)
         except Exception as e:
@@ -273,6 +280,18 @@ class _EvalCtx:
     # pass's 2T.
     analyzer_cube: "BgBotAnalyzer | None" = None
     level_display_cube: str | None = None
+    # The session's money rules. Defaulted to bgsage's own, both on, but a
+    # match passes what its file states: until 3.3.0 nothing did, and every
+    # money session was judged under Jacoby and beavers whatever it was played
+    # under.
+    jacoby: bool = True
+    beaver: bool = True
+
+    def rules(self, dec: dict) -> dict:
+        """The money rules for one decision's engine calls, as keywords.
+        Match play has neither, as `checker_eval.checker_play` also says."""
+        money = not dec["away1"] and not dec["away2"]
+        return {"jacoby": self.jacoby and money, "beaver": self.beaver and money}
 
     @property
     def cube_analyzer(self) -> "BgBotAnalyzer":
@@ -397,6 +416,7 @@ def _eval_cube_decision(dec: dict, ctx: _EvalCtx) -> _DecResult:
                 away1=dec["away1"],
                 away2=dec["away2"],
                 is_crawford=dec["is_crawford"],
+                **ctx.rules(dec),
             )
 
         top = ctx.cube_analyzer
@@ -693,14 +713,15 @@ def _eval_resign_decision(dec: dict, ctx: _EvalCtx) -> _DecResult:
                 analyzer, dec["board"], dice[0], dice[1],
                 cube_value=dec["cube_value"], cube_owner=dec["cube_owner"],
                 away1=dec["away1"], away2=dec["away2"], is_crawford=dec["is_crawford"],
-                seed=seen[-1] if seen else None)
+                seed=seen[-1] if seen else None, **ctx.rules(dec))
             seen.append(r)
             best = list(r.moves)[0]
             e_roll, level, probs = float(best.equity), best.eval_level, best.probs
         else:
             r = analyzer.cube_action(
                 dec["board"], cube_value=dec["cube_value"], cube_owner=dec["cube_owner"],
-                away1=dec["away1"], away2=dec["away2"], is_crawford=dec["is_crawford"])
+                away1=dec["away1"], away2=dec["away2"], is_crawford=dec["is_crawford"],
+                **ctx.rules(dec))
             nd = float(r.equity_nd)
             e_roll = max(nd, min(float(r.equity_dt), float(r.equity_dp))) if can_double else nd
             level, probs = r.eval_level, r.probs
@@ -811,6 +832,7 @@ def _eval_checker_decision(dec: dict, ctx: _EvalCtx) -> _DecResult:
                 away1=dec["away1"],
                 away2=dec["away2"],
                 is_crawford=dec["is_crawford"],
+                **ctx.rules(dec),
             )
             forced_moves = list(forced_result.moves)
             if forced_moves:
@@ -849,6 +871,7 @@ def _eval_checker_decision(dec: dict, ctx: _EvalCtx) -> _DecResult:
                 away2=dec["away2"],
                 is_crawford=dec["is_crawford"],
                 force_boards=[dec["board_played"]],
+                **ctx.rules(dec),
             )
             cheap_moves = list(cheap_result.moves)
             if len(cheap_moves) >= 2:
@@ -887,6 +910,7 @@ def _eval_checker_decision(dec: dict, ctx: _EvalCtx) -> _DecResult:
                             force_boards=[dec["board_played"]],
                             seed=seed,
                             seed_window=window,
+                            **ctx.rules(dec),
                         )
 
                     def played_error(move_list) -> float | None:
@@ -999,6 +1023,8 @@ def _eval_checker_decision(dec: dict, ctx: _EvalCtx) -> _DecResult:
                                 away1=dec["away1"],
                                 away2=dec["away2"],
                                 is_crawford=dec["is_crawford"],
+                                # bgsage takes no beaver rule here.
+                                jacoby=ctx.rules(dec)["jacoby"],
                             )
                             played_eq = post.cubeful_equity
                             checker_err = max(0.0, best_eq - played_eq)
@@ -1028,6 +1054,8 @@ def _eval_checker_decision(dec: dict, ctx: _EvalCtx) -> _DecResult:
                                 away1=dec["away1"],
                                 away2=dec["away2"],
                                 is_crawford=dec["is_crawford"],
+                                # bgsage takes no beaver rule here.
+                                jacoby=ctx.rules(dec)["jacoby"],
                             )
                             played_eq = float(post.cubeful_equity)
                             checker_err = max(0.0, best_eq - played_eq)
@@ -1138,6 +1166,7 @@ def _eval_checker_decision(dec: dict, ctx: _EvalCtx) -> _DecResult:
         dec["cube_value"], dec["cube_owner"],
         dec["away1"], dec["away2"], dec["is_crawford"],
         _luck_az, verbose=ctx.verbose,
+        **ctx.rules(dec),
         postroll_eq=None,  # use the 1-ply (luck-level) post-roll, not the preset best_eq,
         hint_eq=_hint,     # so luck is preset-independent (hint_eq still guards sign errors)
     )
@@ -1255,6 +1284,7 @@ def evaluate_game(game: dict, analyzer: BgBotAnalyzer, recon: dict,
                   level: str = "3ply", level_cube: str | None = None,
                   all_moves: bool = False,
                   count_illegal: bool = False,
+                  jacoby: bool = True, beaver: bool = True,
                   progress: "Callable[[], None] | None" = None) -> dict:
     """Evaluate all decisions in one game. Returns per-player error/decision counts and move log.
 
@@ -1262,6 +1292,7 @@ def evaluate_game(game: dict, analyzer: BgBotAnalyzer, recon: dict,
     entry) supplying the decisions and game result; `game` carries only the
     per-game metadata (number, starting scores) used for reporting.
     `progress`, if given, is called once per decision processed (for a bar).
+    `jacoby` and `beaver` are the session's money rules (`_EvalCtx.rules`).
     """
     level_display = _LEVEL_DISPLAY.get(level, level)
     decisions = recon["decisions"]
@@ -1281,6 +1312,7 @@ def evaluate_game(game: dict, analyzer: BgBotAnalyzer, recon: dict,
         analyzer_cube=analyzer_cube,
         level_display_cube=(None if level_cube is None
                             else _LEVEL_DISPLAY.get(level_cube, level_cube)),
+        jacoby=jacoby, beaver=beaver,
     )
 
     results: "list[_DecResult]" = []

{gammonview-3.2.0 → gammonview-3.3.0}/gvanalysis/luck.py

@@ -101,6 +101,8 @@ def fill_luck(ogxm: dict, *, analyzer=None, on_progress=None, verbose: bool = Fa
         from bgsage import BgBotAnalyzer
         analyzer = BgBotAnalyzer(eval_level=LUCK_LEVEL, cubeful=True)
 
+    jacoby = bool(ogxm.get("jacoby"))
+    beaver = bool(ogxm.get("beaver"))
     filled = 0
     for done, (ply, wanting) in enumerate(todo, start=1):
         try:
@@ -121,6 +123,8 @@ def fill_luck(ogxm: dict, *, analyzer=None, on_progress=None, verbose: bool = Fa
             state.cube_value, cube_owner,
             state.away1, state.away2, state.crawford,
             analyzer, verbose=verbose, hint_eq=hint,
+            # An OGID carries no money rules; the match states them.
+            jacoby=jacoby, beaver=beaver,
         )
         if luck is not None:
             for analysis in wanting:

{gammonview-3.2.0 → gammonview-3.3.0}/gvanalysis/match.py

@@ -221,7 +221,7 @@ _WORKER: dict = {}
 
 def _worker_init(base_level, base_level_cube, mid_level_checker, mid_level_cube, level,
                  level_cube, thresholds, resign_errors, all_moves, count_illegal,
-                 level_display, engine_threads, verbose) -> None:
+                 level_display, engine_threads, verbose, rules) -> None:
     # First, before any weights are loaded: from here on this process holds
     # hundreds of megabytes, and if the parent dies hard nothing else will ever
     # tell it to let go. See `parentwatch`.
@@ -260,6 +260,7 @@ def _worker_init(base_level, base_level_cube, mid_level_checker, mid_level_cube,
         level_display=level_display,
         level_display_cube=(None if level_cube is None
                             else _LEVEL_DISPLAY.get(level_cube, level_cube)),
+        jacoby=rules[0], beaver=rules[1],
     )
 
 
@@ -606,6 +607,7 @@ def analyze_ogxm(
                               level=level, level_cube=level_cube,
                               all_moves=all_moves,
                               count_illegal=count_illegal,
+                              jacoby=jacoby_rule, beaver=beaver_rule,
                               progress=advance)
             game_results.append(r)
             if not quiet:
@@ -625,6 +627,7 @@ def analyze_ogxm(
             base_level_r, base_level_cube, mid_level_checker, mid_level_cube, level,
             level_cube, (close_checker, close_cube, err_checker, err_cube), p.resign_errors, all_moves,
             count_illegal, _LEVEL_DISPLAY.get(level, level), worker_threads, verbose,
+            (jacoby_rule, beaver_rule),
         )
         buckets: "list[list[tuple[int, object]]]" = [[] for _ in recons]
         with ProcessPoolExecutor(max_workers=n_jobs, initializer=_worker_init,