calkit-python 0.48.2__py3-none-any.whl → 0.49.0__py3-none-any.whl

calkit/calc.py

@@ -4,14 +4,20 @@ from __future__ import annotations
 
 from typing import Annotated, Literal
 
-from pydantic import BaseModel, Discriminator, model_validator
+from pydantic import BaseModel, ConfigDict, Discriminator, model_validator
 
 DTYPES = {"int": int, "float": float, "str": str}
 DEFAULT_IN_TYPE = "float"
 DEFAULT_OUT_TYPE = "float"
 
 
-class Input(BaseModel):
+class _Model(BaseModel):
+    # As calkit.models.base.Model, which importing here would import
+    # calkit.models, which imports this
+    model_config = ConfigDict(defer_build=True)
+
+
+class Input(_Model):
     name: str
     description: str | None = None
     dtype: Literal["int", "float", "str"] = DEFAULT_IN_TYPE
@@ -19,14 +25,14 @@ class Input(BaseModel):
     max: int | float | None = None
 
 
-class Output(BaseModel):
+class Output(_Model):
     name: str
     description: str | None = None
     dtype: Literal["int", "float", "str"] = DEFAULT_OUT_TYPE
     template: str | None = None
 
 
-class Calculation(BaseModel):
+class Calculation(_Model):
     kind: str
     params: dict = {}
     name: str | None = None
@@ -124,7 +130,7 @@ class Calculation(BaseModel):
         return template.format(**(inputs | {out_name: res}))
 
 
-class FormulaParams(BaseModel):
+class FormulaParams(_Model):
     formula: str
 
 
@@ -139,7 +145,7 @@ class Formula(Calculation):
         return arithmetic_eval.evaluate(self.params.formula, inputs)
 
 
-class LinearParams(BaseModel):
+class LinearParams(_Model):
     coeffs: dict[str, float]
     offset: float = 0.0
 
@@ -163,7 +169,7 @@ class Linear(Calculation):
         return val
 
 
-class LookupTableParams(BaseModel):
+class LookupTableParams(_Model):
     x_values: list[float]
     y_values: list[float]
     method: Literal["floor", "ceil", "round", "interpolate"] = "interpolate"
@@ -176,7 +182,7 @@ class LookupTable(Calculation):
     params: LookupTableParams
 
 
-class HttpRequestParams(BaseModel):
+class HttpRequestParams(_Model):
     url: str
     inputs_as_params: bool = True  # Otherwise, use body
     method: Literal["get", "post", "put"] = "get"
@@ -210,7 +216,7 @@ class HttpRequest(Calculation):
             return resp.text
 
 
-class XGBoostModelParams(BaseModel):
+class XGBoostModelParams(_Model):
     path: str
     type: Literal["classifier", "regressor"]
 

calkit/cli/__init__.py

@@ -1,7 +1,17 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from .core import *  # noqa: F403
 
+if TYPE_CHECKING:
+    import typer
+
 
 def run() -> None:
+    import os
+    import sys
+
     # Intercept ``--use-version`` before Typer/Click parses argv: Click
     # processes eager options like ``--help`` and ``--version`` (and the
     # group's ``no_args_is_help``) ahead of the callback body, so an
@@ -11,7 +21,61 @@ def run() -> None:
     _maybe_exec_with_version()
     from .main import app
 
-    app()
+    # Completion lists commands, so needs them all
+    if any(k.startswith("_") and k.endswith("_COMPLETE") for k in os.environ):
+        app()
+    else:
+        _only_invoked(app, sys.argv[1:])()
+
+
+def _only_invoked(
+    app: typer.Typer, args: list[str], top: bool = True
+) -> typer.Typer:
+    """Narrow ``app`` to the command or group ``args`` invoke.
+
+    Typer builds every command's options before running one, which for all
+    of Calkit's takes a few tenths of a second, so this leaves out the ones
+    that won't run. Anything else, e.g., ``--help`` or a misspelled command,
+    keeps them all, so help and suggestions list everything.
+    decisions/calkit.yaml has a question on how much that saves.
+    """
+    import copy
+    import re
+
+    from typer.main import get_command_name, solve_typer_info_defaults
+
+    from .main.core import APP_OPTIONS_WITH_VALUES
+
+    # Find the command name, skipping the top level's options
+    takes_value = {
+        flag for flags in APP_OPTIONS_WITH_VALUES.values() for flag in flags
+    }
+    i = 0
+    while i < len(args) and args[i].startswith("-") and top:
+        i += 2 if args[i] in takes_value else 1
+    if i >= len(args) or args[i].startswith("-"):
+        return app
+    name, rest = args[i], args[i + 1 :]
+
+    def names(spec: str | None) -> list[str]:
+        return re.split(r" ?[,|] ?", spec) if spec else []
+
+    narrowed = copy.copy(app)
+    for cmd in app.registered_commands:
+        default = cmd.callback and get_command_name(cmd.callback.__name__)
+        if name in names(cmd.name or default):
+            narrowed.registered_commands = [cmd]
+            narrowed.registered_groups = []
+            return narrowed
+    for group in app.registered_groups:
+        sub_app = group.typer_instance
+        if sub_app and name in names(solve_typer_info_defaults(group).name):
+            group = copy.copy(group)
+            group.typer_instance = _only_invoked(sub_app, rest, top=False)
+            narrowed.registered_commands = []
+            narrowed.registered_groups = [group]
+            return narrowed
+    return app
 
 
 def _maybe_exec_with_version() -> None: