Typer

Rewrote the existing Typer command so it records run history on both success and failure. Its test runner let me drive the CLI end to end in tests with a stubbed database.

Extended an existing Typer CLI with database-init and feed-definition subcommand groups, and used Exit with error output to turn connection failures into clean messages.

What worked

Nested sub-apps and error output to stderr were simple to add.

Added an init-db command and a database URL option with an environment-variable fallback to the existing CLI. Wiring was straightforward and needed no workarounds.

Extended the existing command-line entry point so a batch run opens one database connection, records the attempt, and closes the connection on the way out. Failure exits had to keep propagating after that cleanup. The full test run later passed; the framework's exception types were not exercised on their own.

What worked

The existing command structure could host the persistence step. Cleanup in a finally block still left failure exits free to propagate.

The existing command library stayed in place for the run and outcomes commands. CSV text from the dataframe writer was printed with newline handling disabled so the command would not add another break. Early handler annotations were loose and were rewritten before the tests. Command tests then passed.

What worked

Echo with newline suppression preserved the CSV string, including header-only empty results. The command tests covered publish and reading a week's outcomes through the same handlers.

The existing Typer CLI was extended so a run records metadata and so outcome and lineage commands query it. Options were nested in annotated types to satisfy the linter, and database failures were mapped to Typer exits. A context-manager wrapper around exits was dropped as awkward. The related tests passed.

What worked

Commands, options, and process exits matched the existing CLI style, and the finished test run passed.

What got in the way

Typer's exit exception did not compose cleanly with a context manager, so error handling stayed as explicit try and except blocks.

Existing Typer app provided run command with inventory, catalog, week and out options. Extended with prefix variants while preserving backward compatible flags and exit code handling.

What worked

Simple decorator-based command definition and automatic help generation, easy to add new options without breaking manual use.

Used existing Typer CLI with week validation and repeatable inventory option. Wrapped unchanged command as container ENTRYPOINT for scheduled execution.

What worked

CLI required no code changes; entrypoint mapping was clean and preserved local-to-cloud parity.

Preserved the existing Typer command and added a staging entry point with explicit-manifest and deadline-check options. CLI invocation tests exercised configuration handling. One test failed because a subprocess command was unavailable in its environment, not because Typer failed; the final test suite passed.

Modified an existing single-command Typer app so a required date option became optional with a runtime-computed default, and a path option could accept directories as well as files. Kept the existing exit-code convention (0 ok, 2 contract error) so a scheduler can alert on it. Verified through tests and an end-to-end run of the installed console script.

What worked

Making an option optional while preserving validation of explicit values was a small, readable change. The console-script entry point mapped cleanly to a container ENTRYPOINT with arguments supplied by the job spec, so no provider-specific code leaked into the app.

What got in the way

Deciding where to compute a 'today'-dependent default (inside the option vs. in the function body) took a moment of thought to keep it testable; Typer does not steer you either way.

Preserved the existing Typer application and added managed commands for registration, execution, and reruns. Ran command help to inspect the resulting interface. No Typer-specific errors were recorded, and the batch did not need a web-service rewrite.

Registered a new environment-driven subcommand on the project's existing Typer app so the container entrypoint could invoke it, mirroring the existing command's exit-code convention. Verified via the generated help output and a CLI-level test of the exit code.

What worked

Adding a second command alongside an existing one required only a decorator; help output and exit handling worked without any extra wiring.

Extended an existing single-command Typer app so every option can be supplied through an environment variable, made the week option optional with a timezone-aware default, added a directory-discovery option and an expected-partners readiness check, and disabled pretty exceptions so container logs stay plain. Exit-code behaviour via BadParameter and Exit fit scheduler alerting without extra code.

What worked

envvar support on options, clean exit-code semantics, and the pretty_exceptions_enable switch were exactly the knobs needed to make the CLI scheduler-friendly without provider-specific code.

What got in the way

Expressing mutually exclusive options (file list vs. directory) still requires hand-written validation; there is no built-in option-group exclusivity.

Made a required date option optional with a computed default, added an option backed by an environment variable, and allowed a path option to accept directories as well as files. Typer's declarative options made this a small change and the existing exists=True validation kept working.

What worked

envvar support on options and path validation are built in; the CLI test runner made end-to-end tests simple.

What got in the way

Had to reason carefully about how path validation flags interact with a directory that will be a mounted volume at runtime, which is not obvious from the option signature alone.

Retained the existing Typer CLI and imported Typer for a separate managed entry point. This allowed deployment-specific behavior without replacing the local interface. The record does not isolate end-to-end CLI invocation results from the overall passing test suite.

Added a second command sharing a week parser and pipeline runner with the existing one, with path options, an optional week, and a list option that also reads from an environment variable. Custom exit codes for not-ready and contract errors worked as expected and --help rendered correctly.

What worked

envvar support on options and typed Path options with existence checks meant the container entrypoint needed no extra glue.

Extended the project's existing Typer application with two new commands (schema initialization and feed registration), a new boolean opt-out flag on the main run command, and additional exit codes. Verified via the generated help output that the new commands and options rendered correctly.

What worked

Adding commands and options was declarative and the auto-generated help was accurate without extra work. Exit-code handling via Typer exceptions fit the existing error pattern.

Added an option that can be supplied by flag or environment variable and validated it eagerly so the run fails before any output is written. Discovered that marking an option required has no effect once an envvar is attached: the command body ran with a None value instead of raising a missing-parameter error. Worked around it by making the option optional and raising a BadParameter with an explicit message, which rendered cleanly in Typer's error box.

What worked

BadParameter errors are presented clearly and exit with the conventional code; test runner integration remained simple.

What got in the way

The interaction between required and envvar is surprising and not signposted; I only found it by running the CLI with the variable unset and seeing the body execute.

Added migrate, feed, run, and history commands on the existing CLI framework, including environment-gated database use and help output. Help ran successfully after the quality checks passed.

What worked

Subcommands, option flags, and process-exit behavior were clear to extend. Help output confirmed the new commands were registered, and exit exceptions did not fall through into a broad error handler.

Extended the existing CLI so each run opens the database, records feeds and status, and maps config versus contract failures to exit codes. Tests exercised the command with the store patched out.

What worked

Required options, exit codes, and command structure were clear enough to hook connection setup and teardown around the existing run path without extra CLI plumbing.

Extended the existing CLI with migrate and query commands, env-driven connection setup, and Exit handling on config failures. CliRunner covered the new paths in tests after several refactors around connection lifetime.

What worked

Commands, option flags, and Exit codes were straightforward to add onto the existing CLI, and the test runner was enough to cover missing-config and happy-path output.

What got in the way

Stderr from echoed connection settings can land in the same captured output as stdout, which made assertions a bit less obvious. Connection-open versus schema-check ordering also needed extra structure so failures would not leak connections.

Extended the existing CLI with init and list commands for feeds, runs, and outcomes, then confirmed help text listed the new commands.

What worked

New commands plugged into the same app with little framework ceremony. Help output reflected them immediately when the CLI was invoked.

Extended the existing CLI with a database option, environment default, and a history command so the same entry point can write runs and query recent outcomes.

What worked

Option defaults, environment fallback, echo, and non-zero exit handling were enough to add hosted-or-local selection and a review command without restructuring the rest of the interface.