beefcot 1.0.3__tar.gz → 1.0.4__tar.gz

{beefcot-1.0.3 → beefcot-1.0.4}/.gitignore

@@ -28,6 +28,9 @@ coverage.xml
 # Runtime caches
 .cache/
 
+# Workbench passwords (scrypt hashes). Created by `beefcot user add`.
+/config/auth/
+
 # Run records (written under the workspace's runs folder).
 /runs/
 /workflow-log/

{beefcot-1.0.3 → beefcot-1.0.4}/PKG-INFO

@@ -1,8 +1,10 @@
 Metadata-Version: 2.5
 Name: beefcot
-Version: 1.0.3
+Version: 1.0.4
 Summary: Carcass yield models and cutting plans: one YAML in, one delivered model out
 Requires-Python: >=3.13
+Requires-Dist: fastapi>=0.115
+Requires-Dist: httpx>=0.27
 Requires-Dist: jarvisplot>=2.1
 Requires-Dist: numpy>=2.5
 Requires-Dist: pandas>=3.0
@@ -10,6 +12,8 @@ Requires-Dist: pytest>=8
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: scikit-learn>=1.9
 Requires-Dist: scipy>=1.18
+Requires-Dist: threadpoolctl>=3.6
+Requires-Dist: uvicorn>=0.32
 Requires-Dist: xgboost>=3.3
 Description-Content-Type: text/markdown
 
@@ -23,8 +27,16 @@ python3 -m pip install beefcot
 beefcot --help
 beefcot validate /path/to/job.yaml
 beefcot fit /path/to/job.yaml
+beefcot project create HERD
+beefcot project list
 ```
 
+`beefcot project create` writes one project directory. The machine list
+defaults to `~/.beefcot/projects.json`. Pass `--projects` or set
+`BEEFCOT_PROJECTS` to use another file. `beefcot serve` reads that list and
+opens a loopback workbench. The HTML pages stay with the source checkout and
+are not part of this package.
+
 Each fit starts from a `kind: regression_tree` YAML declaring its input table,
 feature and target columns, cut-tree mapping, split and regression space.
 Available methods are profile, RF, DNN, ReRF and exhaustive search. Structural

{beefcot-1.0.3 → beefcot-1.0.4}/README.pypi.md

@@ -8,8 +8,16 @@ python3 -m pip install beefcot
 beefcot --help
 beefcot validate /path/to/job.yaml
 beefcot fit /path/to/job.yaml
+beefcot project create HERD
+beefcot project list
 ```
 
+`beefcot project create` writes one project directory. The machine list
+defaults to `~/.beefcot/projects.json`. Pass `--projects` or set
+`BEEFCOT_PROJECTS` to use another file. `beefcot serve` reads that list and
+opens a loopback workbench. The HTML pages stay with the source checkout and
+are not part of this package.
+
 Each fit starts from a `kind: regression_tree` YAML declaring its input table,
 feature and target columns, cut-tree mapping, split and regression space.
 Available methods are profile, RF, DNN, ReRF and exhaustive search. Structural

{beefcot-1.0.3 → beefcot-1.0.4}/pyproject.toml

@@ -16,10 +16,14 @@ dependencies = [
     "pandas>=3.0",
     "scipy>=1.18",
     "scikit-learn>=1.9",
+    "threadpoolctl>=3.6",
     "xgboost>=3.3",
     "PyYAML>=6.0",
     "JarvisPLOT>=2.1",
     "pytest>=8",
+    "fastapi>=0.115",
+    "uvicorn>=0.32",
+    "httpx>=0.27",
 ]
 
 [project.scripts]

{beefcot-1.0.3 → beefcot-1.0.4}/src/beefcot/__init__.py

@@ -6,7 +6,7 @@ Every job is one YAML and one verb, the same in Python as on the command line (`
 
     beefcot.fit("config/regression/murdoch_rf.yaml")          # kind: regression_tree -> a run with a model
     beefcot.predict("config/prediction/murdoch_rf_241.yaml")  # kind: prediction      -> one table
-    beefcot.plan("config/plan/murdoch_demo.yaml")             # kind: cutting_plan    -> a plan
+    beefcot.plan("config/plan/breakdown.yaml")                # kind: cutting_plan    -> a plan
     beefcot.check("config/checks/murdoch_core3_bins.yaml")    # kind: bin_variance    -> a data check
     beefcot.decompose("config/decomposition/murdoch_rf.yaml") # kind: error_decomposition -> noise / bias² / variance
     beefcot.run("config/pipelines/murdoch_smoke.yaml")        # kind: pipeline        -> several, in order
@@ -24,7 +24,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any
 
-__version__ = "1.0.3"  # the one place it is written; CHANGELOG.md records each version
+__version__ = "1.0.4"  # the one place it is written; CHANGELOG.md records each version
 
 __all__ = ["__version__", "fit", "predict", "plan", "check", "decompose", "run", "load_model"]
 

beefcot-1.0.4/src/beefcot/__main__.py

@@ -0,0 +1,5 @@
+"""``python -m beefcot`` is the same command as the ``beefcot`` script."""
+
+from beefcot.cli import main
+
+raise SystemExit(main())

{beefcot-1.0.3 → beefcot-1.0.4}/src/beefcot/cli.py

@@ -2,12 +2,19 @@
 
     beefcot fit      config/regression/murdoch_rf.yaml       # kind: regression_tree -> a run with a model
     beefcot predict  config/prediction/murdoch_rf_241.yaml   # kind: prediction      -> one table
-    beefcot plan     config/plan/murdoch_demo.yaml           # kind: cutting_plan    -> a plan
+    beefcot plan     config/plan/breakdown.yaml              # kind: cutting_plan    -> a plan
     beefcot check    config/checks/murdoch_core3_bins.yaml   # kind: bin_variance    -> a data check
     beefcot decompose config/decomposition/murdoch_rf.yaml   # kind: error_decomposition -> noise / bias² / variance
     beefcot run      config/pipelines/murdoch_smoke.yaml     # kind: pipeline        -> several, in order
     beefcot validate <any YAML>                              # read and check it, compute nothing
     beefcot models   list | show ID | verify ID | import PATH | export ID OUT
+    beefcot serve    # loopback workbench; --design draws the column grid
+    beefcot user add NAME   # create a workbench login
+    beefcot project create PATH     # a standard project and an empty model library
+    beefcot project validate [PATH] # check that project; compute nothing
+    beefcot project list            # projects recorded on this machine
+    beefcot project add PATH        # record an existing project
+    beefcot project remove ID       # drop it from the list; keep the directory
     beefcot kinds | version
     beefcot -V | -v | --version                            # package version, no job required
 
@@ -35,6 +42,33 @@ PRODUCING = ("fit", "predict", "plan", "check", "decompose", "run")
 WITH_LIBRARY = ("predict", "plan", "run")  # the jobs that may look a model up by id
 
 
+def _user(args: argparse.Namespace) -> int:
+    """Create or list workbench accounts. The password is read from the terminal."""
+    import getpass
+
+    from beefcot.service.auth import Accounts, AuthError
+
+    root = Path(args.root).expanduser() if args.root else Path.cwd()
+    accounts = Accounts(root / "config" / "auth" / "users.yaml")
+    try:
+        if args.user_command == "list":
+            for name in accounts.names():
+                print(name)
+            return 0
+        if not sys.stdin.isatty():
+            raise AuthError(422, "INVALID_PASSWORD", "run beefcot user add in a terminal so the password is not saved in a command")
+        password = getpass.getpass("Password: ")
+        repeated = getpass.getpass("Repeat password: ")
+        if password != repeated:
+            raise AuthError(422, "INVALID_PASSWORD", "the two passwords did not match")
+        accounts.add(args.name, password)
+    except AuthError as failure:
+        print(failure.message, file=sys.stderr)
+        return 1
+    print(f"added {args.name}")
+    return 0
+
+
 def _produce(args: argparse.Namespace) -> dict[str, Any]:
     import beefcot
     from beefcot import registry
@@ -135,6 +169,26 @@ def _models(args: argparse.Namespace) -> dict[str, Any]:
     return {"ok": True, "id": args.id, "written": str(written)}
 
 
+def _project(args: argparse.Namespace) -> dict[str, Any]:
+    """Create or check a project, or change the machine list. None of these fit a model."""
+    from beefcot.project import create, validate
+    from beefcot.project_registry import add, describe, location, remove
+
+    registry = location(getattr(args, "projects", None))
+    if args.project_command == "create":
+        report = create(args.path)
+        report.update(add(registry, report["project"]))
+        report["registry"] = str(registry)
+        return report
+    if args.project_command == "add":
+        return {"ok": True, "registry": str(registry), **add(registry, args.path)}
+    if args.project_command == "remove":
+        return {"ok": True, "registry": str(registry), **remove(registry, args.id)}
+    if args.project_command == "list":
+        return {"ok": True, "registry": str(registry), "projects": describe(registry)}
+    return validate(args.path or Path.cwd())
+
+
 def _kinds() -> dict[str, Any]:
     from beefcot import registry
 
@@ -146,9 +200,10 @@ def _parser(presentation: Terminal | None = None) -> argparse.ArgumentParser:
     parser = HelpParser(prog="beefcot", presentation=presentation,
                         description="Define a job in YAML. Validate it, run it, inspect the delivered results.",
                         help_panels=[('Regression & data', ('validate', 'fit', 'predict', 'check', 'decompose')),
-                                     ('Planning & pipelines', ('plan', 'run')),
+                                     ('Planning & pipelines', ('plan', 'run', 'serve', 'user', 'project')),
                                      ('Models & reference', ('models', 'kinds', 'version'))],
                         examples=[('Validate', 'beefcot validate path/to/job.yaml'),
+                                  ('New project', 'beefcot project create HERD'),
                                   ('Fit', 'beefcot fit config/regression/murdoch_core3_rf.yaml'),
                                   ('Command help', 'beefcot fit --help')])
     parser.add_argument('-V', '-v', '--version', action=VersionAction,
@@ -186,6 +241,63 @@ def _parser(presentation: Terminal | None = None) -> argparse.ArgumentParser:
         command(name, helps[name], library=name in WITH_LIBRARY, quiet=True).add_argument("config", metavar="YAML", help="job configuration; paths inside it are relative to this YAML")
     command("validate", "validate a YAML and its paths without running the job", library=True).add_argument(
         "config", metavar="YAML", help="the configuration to validate")
+    serve = sub.add_parser("serve", help="serve the local cutting-plan workbench on 127.0.0.1",
+                           description="Serve the local cutting-plan workbench. The host is loopback only.",
+                           examples=[("Open", "beefcot serve"), ("Grid", "beefcot serve --design")])
+    presentation_options(serve)
+    serve.add_argument("--port", type=int, default=8765, help="loopback port (default: 8765)")
+    serve.add_argument("--root", default=None, help="project directory that contains config/ (default: the current directory)")
+    serve.add_argument("--design", action="store_true", help="draw the 12-column reference grid in magenta")
+    serve.add_argument("--projects", default=None, help="the machine project list (default: ~/.beefcot/projects.json)")
+
+    account = sub.add_parser("user", help="add or list workbench logins",
+                             description="Add a workbench login. The password is typed, not passed as an argument. "
+                                         "The web page cannot register a user.",
+                             examples=[("Add", "beefcot user add NAME"), ("List", "beefcot user list")])
+    presentation_options(account)
+    account_commands = account.add_subparsers(dest="user_command", required=True)
+    added = account_commands.add_parser("add", help="create one user in config/auth/users.yaml")
+    presentation_options(added)
+    added.add_argument("name", help="the name typed on the login page")
+    added.add_argument("--root", default=None, help="project directory that contains config/ (default: the current directory)")
+    listed = account_commands.add_parser("list", help="list user names")
+    presentation_options(listed)
+    listed.add_argument("--root", default=None, help="project directory that contains config/ (default: the current directory)")
+
+    project = sub.add_parser(
+        "project",
+        help="create or validate a project directory",
+        description="A project holds tables, job YAML and a model library. The package stays separate.",
+        examples=[("Create", "beefcot project create HERD"),
+                  ("Validate", "beefcot project validate HERD"),
+                  ("Register", "beefcot project add HERD"),
+                  ("On this machine", "beefcot project list")],
+    )
+    presentation_options(project)
+    project_commands = project.add_subparsers(dest="project_command", required=True)
+
+    def project_command(name: str, help_text: str, description: str) -> argparse.ArgumentParser:
+        made = project_commands.add_parser(name, help=help_text, description=description)
+        presentation_options(made)
+        made.add_argument("--projects", default=None, help="the machine project list (default: ~/.beefcot/projects.json)")
+        return made
+
+    created = project_command("create", "write a standard project and an empty model library",
+                              "Write a standard project and an empty model library. "
+                              "The directory must be missing or empty. No table is copied. "
+                              "The new project is recorded in the machine list.")
+    created.add_argument("path", help="the new project directory")
+    checked = project_command("validate", "check a project directory and compute nothing",
+                              "Check a project directory and compute nothing.")
+    checked.add_argument("path", nargs="?", default=None, help="the project directory (default: the current directory)")
+    project_command("list", "list the projects recorded on this machine",
+                    "List the projects recorded on this machine.")
+    added = project_command("add", "record an existing project directory",
+                            "Record an existing project directory. The directory is not copied.")
+    added.add_argument("path", help="the project directory")
+    removed = project_command("remove", "drop a project from the machine list",
+                              "Drop a project from the machine list. The directory is kept.")
+    removed.add_argument("id", help="the project id")
 
     models = sub.add_parser("models", help="inspect, verify and move delivered models",
                            description="Inspect, verify and move delivered models.",
@@ -224,6 +336,21 @@ def main(argv: Sequence[str] | None = None) -> int:
         parser.print_help()
         return 0
     args = parser.parse_args(raw)
+    if args.command == "serve":
+        from beefcot.service.errors import ServiceError
+        from beefcot.service.server import serve
+
+        try:
+            serve(Path(args.root).expanduser() if args.root else Path.cwd(), args.port,
+                  design=args.design, projects=args.projects)
+        except ServiceError as failure:
+            print(failure.message, file=sys.stderr)
+            return 1
+        except KeyboardInterrupt:
+            return 130
+        return 0
+    if args.command == "user":
+        return _user(args)
     ui.as_json = getattr(args, 'json', False)
     ui.no_color = getattr(args, 'no_color', False)
     quiet = getattr(args, 'quiet', False)
@@ -241,6 +368,8 @@ def main(argv: Sequence[str] | None = None) -> int:
                 result = _produce(args)
             elif args.command == "validate":
                 result = _validate(args)
+            elif args.command == "project":
+                result = _project(args)
             elif args.command == "models":
                 result = _models(args)
             elif args.command == "kinds":
@@ -254,7 +383,12 @@ def main(argv: Sequence[str] | None = None) -> int:
             result = {"ok": False, "error": "Interrupted by user."}
         except Exception as failure:  # one structured failure, without a traceback
             result = {"ok": False, "error": f"{type(failure).__name__}: {failure}"}
-    label = f'models {args.models_command}' if args.command == 'models' else args.command
+    if args.command == "models":
+        label = f"models {args.models_command}"
+    elif args.command == "project":
+        label = f"project {args.project_command}"
+    else:
+        label = args.command
     ui.result(result, label, time.monotonic() - started)
     return 130 if interrupted else 0 if result["ok"] else 1
 

{beefcot-1.0.3 → beefcot-1.0.4}/src/beefcot/cli_presentation.py

@@ -159,6 +159,33 @@ class Terminal:
             return
         if 'kinds' in result:
             rows = [(item['kind'], f"{item['command']}\n{item['does']}") for item in result['kinds']]
+        elif 'project' in result and 'workspace' in result:
+            rows = []
+            if result.get('id'):
+                rows.append(('Id', result['id']))
+            if result.get('name'):
+                rows.append(('Name', result['name']))
+            rows += [('Project', result['project']), ('Workspace', result['workspace'] or 'Missing')]
+            rows.append(('Libraries', '\n'.join(result.get('models') or []) or 'None'))
+            rows.append(('Config', ', '.join(result.get('config') or []) or 'None'))
+            if result.get('registry'):
+                rows.append(('Registry', result['registry']))
+            if elapsed is not None:
+                rows.append(('Elapsed', f'{elapsed:.2f}s'))
+        elif result.get('registry') and isinstance(result.get('projects'), list):
+            rows = [('Registry', result['registry'])]
+            if not result['projects']:
+                rows.append(('Projects', 'None'))
+            for item in result['projects']:
+                state = 'ready' if item.get('ready') else 'not ready'
+                rows.append((item['id'], f"{item.get('name') or item['id']}\n{item.get('path', '')}\n{state}"))
+        elif result.get('registry') and result.get('id'):
+            rows = [('Id', result['id'])]
+            if result.get('name'):
+                rows.append(('Name', result['name']))
+            if result.get('path'):
+                rows.append(('Path', result['path']))
+            rows.append(('Registry', result['registry']))
         elif isinstance(result.get('models'), list) and 'libraries' in result:
             rows = [('Library', place) for place in result['libraries']]
             rows += [(f'{index:02d}', f"{item['id']}\n{item['producer']} / {item['products']} products / {item['created_at'][:10]}")
@@ -195,7 +222,9 @@ class Terminal:
                 rows.append(('Report', str(Path(output) / 'report.html')))
             if elapsed is not None:
                 rows.append(('Elapsed', f'{elapsed:.2f}s'))
-        titles = {'validate': 'VALID YAML', 'kinds': 'YAML KINDS', 'models list': 'MODEL LIBRARY',
+        titles = {'validate': 'VALID YAML', 'kinds': 'YAML KINDS',
+                  'project list': 'PROJECTS', 'project add': 'PROJECT ADDED', 'project remove': 'PROJECT REMOVED',
+                  'models list': 'MODEL LIBRARY',
                   'models show': 'MODEL DETAILS', 'models verify': 'MODEL VERIFIED',
                   'models import': 'MODEL IMPORTED', 'models export': 'MODEL EXPORTED'}
         self.write(self.panel(titles.get(command, f'{command.upper()} COMPLETE'), rows, color='32'), self.out)

{beefcot-1.0.3 → beefcot-1.0.4}/src/beefcot/cutting_plan/economics.py

@@ -67,11 +67,17 @@ class Pattern:
 
     @classmethod
     def from_dict(cls, payload: Mapping[str, Any]) -> "Pattern":
+        if not isinstance(payload, Mapping):
+            raise TypeError("a pattern must be a mapping")
         allowed = {"name", "products", "process_speed", "hourly_labor_cost", "min_carcasses",
                    "max_carcasses", "prices"}
         unknown = sorted(set(payload) - allowed)
         if unknown:
             raise ValueError(f"pattern {payload.get('name')!r}: unknown keys={unknown}; allowed={sorted(allowed)}")
+        required = ("name", "products", "process_speed", "hourly_labor_cost")
+        missing = [key for key in required if key not in payload]
+        if missing:
+            raise ValueError(f"pattern {payload.get('name', '?')!r}: missing keys={missing}")
         return cls(
             name=str(payload["name"]),
             products=tuple(str(item) for item in payload["products"]),
@@ -138,6 +144,8 @@ class ScenarioSpec:
 
     @classmethod
     def from_dict(cls, payload: Mapping[str, Any]) -> "ScenarioSpec":
+        if not isinstance(payload, Mapping):
+            raise TypeError("scenario must be a mapping")
         allowed = {
             "patterns", "prices", "pieces_per_carcass", "purchase_price_column", "purchase_price",
             "weight_column", "available_column", "uncovered_products", "assignment",
@@ -145,6 +153,9 @@ class ScenarioSpec:
         unknown = sorted(set(payload) - allowed)
         if unknown:
             raise ValueError(f"scenario: unknown keys={unknown}; allowed={sorted(allowed)}")
+        missing = [key for key in ("patterns", "prices") if key not in payload]
+        if missing:
+            raise ValueError(f"scenario: missing keys={missing}")
         return cls(
             patterns=tuple(Pattern.from_dict(item) for item in payload["patterns"]),
             prices={str(key): float(value) for key, value in dict(payload["prices"]).items()},
@@ -381,6 +392,63 @@ def _plain(value: Any) -> Any:
     return value.item() if hasattr(value, "item") else value
 
 
+def random_assignment_comparison(
+    inputs: CuttingPlanInputs,
+    assignment: pd.DataFrame | None,
+) -> tuple[dict[str, Any], pd.DataFrame]:
+    """What uniform random cutting returns, beside the solved plan.
+
+    Each available carcass independently takes one pattern with equal probability. That is the
+    expectation, not one shuffled draw. A pattern minimum or maximum is not applied: those limits
+    couple the carcasses, and this number is the mean of the unrestricted draws. Purchase is paid
+    for every carcass, because a random cut still processes it. Profit, income and labour are the
+    per-carcass figures times how many carcasses the row stands for.
+    """
+    profit = inputs.profit
+    patterns = list(profit.columns)
+    if not patterns:
+        raise ValueError("a random comparison needs at least one pattern")
+    available = inputs.available.reindex(profit.index).astype(float)
+    expected_profit = profit.mean(axis=1) * available
+    expected_income = inputs.income.reindex(columns=patterns).mean(axis=1) * available
+    expected_labor = inputs.labor_cost.reindex(columns=patterns).mean(axis=1) * available
+    expected_purchase = inputs.purchase_cost.reindex(profit.index).astype(float) * available
+    limits = any(
+        pattern.min_carcasses is not None or pattern.max_carcasses is not None
+        for pattern in inputs.patterns
+    )
+    solved = assignment is not None
+    if solved:
+        counts = assignment.reindex(index=profit.index, columns=patterns).fillna(0.0).astype(float)
+        chosen_profit = (profit * counts).sum(axis=1)
+        advantage = chosen_profit - expected_profit
+    else:
+        chosen_profit = pd.Series(np.nan, index=profit.index)
+        advantage = pd.Series(np.nan, index=profit.index)
+    by_carcass = pd.DataFrame(
+        {
+            "available": available.to_numpy(),
+            "expected_profit": expected_profit.to_numpy(),
+            "chosen_profit": chosen_profit.to_numpy(),
+            "advantage": advantage.to_numpy(),
+        },
+        index=profit.index,
+    )
+    total_carcasses = float(available.sum())
+    report = {
+        "rule": "each available carcass independently and uniformly among the patterns",
+        "patterns": len(patterns),
+        "respects_pattern_limits": not limits,
+        "expected_profit": float(expected_profit.sum()),
+        "expected_income": float(expected_income.sum()),
+        "expected_labor_cost": float(expected_labor.sum()),
+        "expected_purchase_cost": float(expected_purchase.sum()),
+        "expected_carcasses_per_pattern": total_carcasses / len(patterns),
+        "advantage_over_random": None if not solved else float(advantage.sum()),
+    }
+    return report, by_carcass
+
+
 def solve(inputs: CuttingPlanInputs) -> PlanResult:
     """Assign carcasses to patterns: a mixed-integer problem (one pattern per carcass, pattern
     capacities), solved exactly by HiGHS."""

{beefcot-1.0.3 → beefcot-1.0.4}/src/beefcot/cutting_plan/run.py

@@ -31,7 +31,9 @@ from beefcot import runtime
 from beefcot.model_format.library import LibraryError, ModelLibrary
 from beefcot.runtime import MANIFEST as MANIFEST_NAME
 from beefcot.runtime import Model
-from beefcot.cutting_plan.economics import SOLVER, CuttingPlanInputs, ScenarioSpec, build_inputs, solve
+from beefcot.cutting_plan.economics import (
+    SOLVER, CuttingPlanInputs, ScenarioSpec, build_inputs, random_assignment_comparison, solve,
+)
 from beefcot.yamlio import block, fresh_dir, from_yaml, load_yaml
 
 KIND = "cutting_plan"
@@ -278,6 +280,15 @@ def run(config: str | Path) -> Path:
             f"they cover as much as by value; compare patterns that break up the same cuts, or "
             f"supply the rest with uncovered_products: external"
         )
+    random_report, random_by_carcass = random_assignment_comparison(
+        inputs, result.assignment if solved else None
+    )
+    random_by_carcass.to_csv(root / "random_comparison.csv", index_label="carcass")
+    if not random_report["respects_pattern_limits"]:
+        warnings.append(
+            "the random expectation assigns every carcass uniformly and does not enforce a pattern's "
+            "minimum or maximum; the advantage is against that unrestricted draw"
+        )
     unusual = inputs.provenance.get("unusual_inputs", {})
     for column, entry in unusual.items():
         warnings.append(
@@ -293,6 +304,7 @@ def run(config: str | Path) -> Path:
         "solver": result.solver,
         "seconds": result.seconds,
         "objective_profit": result.objective,
+        "random_assignment": random_report,
         "carcasses": int(len(carcasses)),
         "carcasses_assigned": int(assigned.to_numpy().sum()),
         "per_pattern": per_pattern,

{beefcot-1.0.3 → beefcot-1.0.4}/src/beefcot/model/learners.py

@@ -521,8 +521,17 @@ def _fit_lstsq(adapter: "NodeRegressorAdapter", X: np.ndarray, y: np.ndarray) ->
     adapter.beta = linalg.lstsq(X, y)[0]
 
 
+class NNLSConvergenceError(ValueError):
+    """A known, non-computable candidate fit; other runtime errors still propagate."""
+
+
 def _fit_nnls(adapter: "NodeRegressorAdapter", X: np.ndarray, y: np.ndarray) -> None:
-    adapter.beta = optimize.nnls(X, y)[0]
+    try:
+        adapter.beta = optimize.nnls(X, y)[0]
+    except RuntimeError as exc:
+        if str(exc) != "Maximum number of iterations reached.":
+            raise
+        raise NNLSConvergenceError(f"nnls convergence failure: {exc}") from exc
 
 
 def _fit_robust(adapter: "NodeRegressorAdapter", X: np.ndarray, y: np.ndarray) -> None:

{beefcot-1.0.3 → beefcot-1.0.4}/src/beefcot/model/transforms.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 
 import warnings
 from dataclasses import dataclass
+from functools import lru_cache
 from typing import Sequence
 
 import numpy as np
@@ -180,8 +181,21 @@ def _boxcox_lambda(values: np.ndarray, bounds: tuple[float, float] = (-2.0, 2.0)
     directly rather than reimplemented, and clamped because an unbounded lambda
     on 190 rows can wander far enough to make the inverse overflow.
     """
+    values = np.asarray(values, dtype=float)
+    # The response and its fold, not the input mapping or learner, determine
+    # lambda. Key by every training value (in order) and both bounds: held-out
+    # data, other folds and other targets can never share fitted state by name.
+    # Bytes also bound the retained data without keeping whole frames alive.
+    return _boxcox_lambda_cached(values.tobytes(), tuple(bounds))
+
+
+@lru_cache(maxsize=128)
+def _boxcox_lambda_cached(training_values: bytes, bounds: tuple[float, float]) -> float:
+    """Process-local, bounded memoization of the unchanged deterministic fit."""
     from scipy import stats
 
+    values = np.frombuffer(training_values, dtype=float)
+
     try:
         lam = float(stats.boxcox_normmax(np.asarray(values, dtype=float), brack=bounds))
     except (ValueError, ArithmeticError, RuntimeError):  # pragma: no cover - degenerate response

{beefcot-1.0.3 → beefcot-1.0.4}/src/beefcot/model_format/blocks.py

@@ -108,7 +108,7 @@ def flat_tree(tree: Mapping[str, Any]) -> dict[str, list]:
     return flat
 
 
-def network_block(fitted, products: Sequence[str]) -> dict[str, Any]:
+def network_block(fitted, products: Sequence[str], *, selected: Sequence[str] | None = None) -> dict[str, Any]:
     """A shared network (``beefcot.producers.network.FittedNetwork``) as one block: its design, its
     members' weights, one output per product, each put back in its product's unit by the
     standardisation the targets were fitted in."""
@@ -116,7 +116,7 @@ def network_block(fitted, products: Sequence[str]) -> dict[str, Any]:
     mean, scale = [float(v) for v in fitted.target_mean], [float(v) for v in fitted.target_scale]
     if list(fitted.outputs) != list(products) or len(mean) != len(products):
         raise ValueError(f"the network gives {list(fitted.outputs)}, not {list(products)}")
-    return {
+    block = {
         "terms": terms_of(design),
         "center": list(design.center),
         "scale": list(design.scale),
@@ -135,3 +135,13 @@ def network_block(fitted, products: Sequence[str]) -> dict[str, Any]:
             for i, code in enumerate(products)
         ],
     }
+    if selected is not None:
+        selected = list(selected)
+        if not selected or len(set(selected)) != len(selected) or not set(selected) <= set(products):
+            raise ValueError("selected network outputs must be distinct declared products")
+        indices = [list(products).index(code) for code in selected]
+        block["outputs"] = [block["outputs"][i] for i in indices]
+        for member in block["kernel"]["members"]:
+            member["weights"][-1] = [[row[i] for i in indices] for row in member["weights"][-1]]
+            member["biases"][-1] = [member["biases"][-1][i] for i in indices]
+    return block