factor-qc 0.1.0__tar.gz

factor_qc-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Factor QC contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

factor_qc-0.1.0/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: factor-qc
+Version: 0.1.0
+Summary: Fail-closed quality gate for backtests: DSR, PBO, Harvey-Liu haircut and MinTRL in one numpy-only engine, with P0/P1/P2 severity grading.
+License-Expression: MIT
+Keywords: backtest,overfitting,deflated-sharpe,pbo,mintrl,factor,qc,quant
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Dynamic: license-file
+
+# factor-qc
+
+A **fail-closed quality gate** for backtests: one numpy-only engine covering
+Deflated Sharpe Ratio, Probability of Backtest Overfitting (CSCV), the
+Harvey-Liu multiple-testing haircut and Minimum Track Record Length —
+graded P0/P1/P2, and **it refuses to judge a backtest that will not declare
+how many configurations were tried**. Python 3.11+, one dependency
+(`numpy`), Windows / Linux / macOS.
+
+**Status:** v0.1 — alpha. The statistics are battle-tested inside a
+production research pipeline and validated against published reference
+values, but this standalone package is new: expect the CLI to shift before
+v1.0.
+
+## Why this exists
+
+The standard story: you try 200 factor configurations, the best one shows a
+Sharpe of 1.65, you feel great. The honest story: with 200 trials of pure
+noise, *someone* is going to show a Sharpe of 1.65 — the expected maximum of
+200 zero-true-SR trials — and it will not be your skill, it will be your
+selection bias.
+
+Most backtest tooling computes statistics and prints reports. `factor-qc`
+is a **gate**: it decides, with graded severity, whether a candidate may
+pass — and its default answer is *no*:
+
+- **P0 (fatal)** — DSR below threshold, PBO above threshold, haircut Sharpe
+  below floor, MinTRL longer than the sample → the candidate must not pass.
+- **P1 (warning)** — weak PSR vs zero, short sample, aggressive trial count
+  → proceed with eyes open.
+- **P2 (info)** — non-normal moments, tiny trial count → recorded, no action.
+
+## Philosophy
+
+**Honesty is the default; the gate is fail-closed.**
+
+The one non-negotiable input is `n_trials`: the honest count of
+configurations you tried. Without it there is no deflation benchmark
+([Bailey & López de Prado 2014](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2460551)),
+no haircut ([Harvey, Liu & Zhu 2016, RFS](https://doi.org/10.1093/rfs/hhv059)),
+no track-record floor
+([Bailey & López de Prado 2018, JPM](https://ideas.repec.org/a/rsk/journl/0journalpm-v44n5.html))
+and no overfitting probability
+([Bailey, Borwein, López de Prado & Zhu 2017, JCF](https://escholarship.org/uc/item/4w1110bb)).
+Refuse to declare, and the gate refuses to judge — that asymmetry is the
+point. `qc check` exits non-zero on any P0 failure, so it drops into CI,
+pre-commit hooks and research gates as a hard blocker, not a suggestion.
+
+Two design commitments that keep it honest:
+
+1. **numpy only, no scipy** — the standard-normal inverse CDF is Acklam's
+   rational approximation with one Newton refinement; every number in the
+   report is reproducible from the code in this repo, no hidden black box.
+2. **PBO is optional but explicit** — without a trials matrix the gate says
+   PBO *was not computed*, and the DSR cross-trial variance degrades to a
+   conservative single-trial estimate. Absence of evidence is reported as
+   absence, never as evidence.
+
+## Quick start
+
+```bash
+# install from PyPI (once published)
+pip install factor-qc
+
+# or run without installing anything:
+#   PYTHONPATH=src python -m factor_qc --help
+
+python examples/demo.py   # try it on reproducible synthetic cases
+```
+
+Your own backtest:
+
+```bash
+# returns.json = JSON list of per-period returns of the selected candidate
+# trials.json   = JSON 2D matrix (T x N) of every configuration you tried
+
+qc check --returns returns.json --trials trials.json --n-trials 200
+# -> FAIL - P0 blocker(s): dsr: 0.63 vs 0.95; mintrl: 250.8 vs <= 1000; ...
+
+qc check --returns returns.json --n-trials 5 --json   # machine-readable
+```
+
+Exit codes: `0` = no P0 failures (P1/P2 may still be failing), `1` = at
+least one P0 failure (or missing `n_trials`), `2` = usage error. Wire it
+into CI as a hard gate.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `check` | Run the gate: DSR, PBO (when `--trials` given), haircut Sharpe, MinTRL as P0; PSR-vs-zero, sample length, trial aggression as P1; moments and trial count as P2. Human-readable or `--json` output |
+| `version` | Print version |
+
+Flags: `--returns` (required), `--trials` (optional), `--n-trials`
+(required unless `require_declared_trials` is disabled in code),
+`--periods-per-year` (default 252), `--n-blocks` (CSCV granularity, default
+16).
+
+## The checks
+
+| Check | Severity | Method | Reference |
+| --- | --- | --- | --- |
+| `dsr` | P0 | Deflated Sharpe Ratio: P(SR > E[max SR of N trials]) under non-normal moments | [Bailey & López de Prado (2014), JPM 40(5)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2460551) |
+| `pbo` | P0 | Probability of Backtest Overfitting via Combinatorially-Symmetric Cross-Validation (12,870 splits at n_blocks=16) | [Bailey, Borwein, López de Prado & Zhu (2017), JCF](https://escholarship.org/uc/item/4w1110bb) |
+| `haircut_sharpe` | P0 | Multiple-testing haircut of the Sharpe ratio (Bonferroni/Holm/BHY) | [Harvey & Liu (2015)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2528780) |
+| `mintrl` | P0 | Minimum Track Record Length: observations needed before SR is significant | [Bailey & López de Prado (2018), JPM 44(5)](https://ideas.repec.org/a/rsk/journl/0journalpm-v44n5.html) |
+| `psr_vs_zero` | P1 | Probabilistic Sharpe vs zero | [Bailey & López de Prado (2012)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2168747) |
+| `sample_length` | P1 | ≥ 252 observations | — |
+| `trial_aggression` | P1 | n_trials ≤ n_obs / 5 | — |
+| `return_moments` | P2 | skew ≈ 0, kurtosis ≈ 3 | — |
+| `trial_count` | P2 | n_trials ≥ 5 | — |
+
+The P0 set mirrors the spirit of [Harvey, Liu & Zhu (2016),
+"…and the Cross-Section of Expected Returns"](https://doi.org/10.1093/rfs/hhv059):
+a factor must survive multiple-testing correction to earn the right to be
+called a factor. The gate is the machine version of that editorial stance.
+
+## Performance note
+
+CSCV enumerates C(n_blocks, n_blocks/2) splits — 12,870 at the default 16.
+On large trial matrices (T=1000, N=200) that takes minutes; use
+`--n-blocks 8` (70 splits) or `10` (252 splits) for interactive speed at
+slightly coarser granularity.
+
+## Development
+
+```bash
+python -m pip install -e . pytest
+python -m pytest
+```
+
+CI runs the full test suite on Ubuntu, Windows and macOS with Python 3.11
+and 3.12. Issues are handled on weekends; pull requests are welcome.
+
+## Related work
+
+- [Bailey & López de Prado (2014), The Deflated Sharpe Ratio](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2460551)
+- [Bailey, Borwein, López de Prado & Zhu (2017), The Probability of Backtest Overfitting](https://escholarship.org/uc/item/4w1110bb)
+- [Harvey, Liu & Zhu (2016), …and the Cross-Section of Expected Returns (RFS)](https://doi.org/10.1093/rfs/hhv059)
+- [Harvey & Liu (2021), Lucky Factors (JFE)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2528780)
+- [Mobarekeh & López de Prado (2024), Backtest Overfitting in the Machine Learning Era (SSRN 4778909)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4778909) — why OOS methods still need honest trial accounting
+
+## License
+
+MIT

factor_qc-0.1.0/README.md

@@ -0,0 +1,145 @@
+# factor-qc
+
+A **fail-closed quality gate** for backtests: one numpy-only engine covering
+Deflated Sharpe Ratio, Probability of Backtest Overfitting (CSCV), the
+Harvey-Liu multiple-testing haircut and Minimum Track Record Length —
+graded P0/P1/P2, and **it refuses to judge a backtest that will not declare
+how many configurations were tried**. Python 3.11+, one dependency
+(`numpy`), Windows / Linux / macOS.
+
+**Status:** v0.1 — alpha. The statistics are battle-tested inside a
+production research pipeline and validated against published reference
+values, but this standalone package is new: expect the CLI to shift before
+v1.0.
+
+## Why this exists
+
+The standard story: you try 200 factor configurations, the best one shows a
+Sharpe of 1.65, you feel great. The honest story: with 200 trials of pure
+noise, *someone* is going to show a Sharpe of 1.65 — the expected maximum of
+200 zero-true-SR trials — and it will not be your skill, it will be your
+selection bias.
+
+Most backtest tooling computes statistics and prints reports. `factor-qc`
+is a **gate**: it decides, with graded severity, whether a candidate may
+pass — and its default answer is *no*:
+
+- **P0 (fatal)** — DSR below threshold, PBO above threshold, haircut Sharpe
+  below floor, MinTRL longer than the sample → the candidate must not pass.
+- **P1 (warning)** — weak PSR vs zero, short sample, aggressive trial count
+  → proceed with eyes open.
+- **P2 (info)** — non-normal moments, tiny trial count → recorded, no action.
+
+## Philosophy
+
+**Honesty is the default; the gate is fail-closed.**
+
+The one non-negotiable input is `n_trials`: the honest count of
+configurations you tried. Without it there is no deflation benchmark
+([Bailey & López de Prado 2014](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2460551)),
+no haircut ([Harvey, Liu & Zhu 2016, RFS](https://doi.org/10.1093/rfs/hhv059)),
+no track-record floor
+([Bailey & López de Prado 2018, JPM](https://ideas.repec.org/a/rsk/journl/0journalpm-v44n5.html))
+and no overfitting probability
+([Bailey, Borwein, López de Prado & Zhu 2017, JCF](https://escholarship.org/uc/item/4w1110bb)).
+Refuse to declare, and the gate refuses to judge — that asymmetry is the
+point. `qc check` exits non-zero on any P0 failure, so it drops into CI,
+pre-commit hooks and research gates as a hard blocker, not a suggestion.
+
+Two design commitments that keep it honest:
+
+1. **numpy only, no scipy** — the standard-normal inverse CDF is Acklam's
+   rational approximation with one Newton refinement; every number in the
+   report is reproducible from the code in this repo, no hidden black box.
+2. **PBO is optional but explicit** — without a trials matrix the gate says
+   PBO *was not computed*, and the DSR cross-trial variance degrades to a
+   conservative single-trial estimate. Absence of evidence is reported as
+   absence, never as evidence.
+
+## Quick start
+
+```bash
+# install from PyPI (once published)
+pip install factor-qc
+
+# or run without installing anything:
+#   PYTHONPATH=src python -m factor_qc --help
+
+python examples/demo.py   # try it on reproducible synthetic cases
+```
+
+Your own backtest:
+
+```bash
+# returns.json = JSON list of per-period returns of the selected candidate
+# trials.json   = JSON 2D matrix (T x N) of every configuration you tried
+
+qc check --returns returns.json --trials trials.json --n-trials 200
+# -> FAIL - P0 blocker(s): dsr: 0.63 vs 0.95; mintrl: 250.8 vs <= 1000; ...
+
+qc check --returns returns.json --n-trials 5 --json   # machine-readable
+```
+
+Exit codes: `0` = no P0 failures (P1/P2 may still be failing), `1` = at
+least one P0 failure (or missing `n_trials`), `2` = usage error. Wire it
+into CI as a hard gate.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `check` | Run the gate: DSR, PBO (when `--trials` given), haircut Sharpe, MinTRL as P0; PSR-vs-zero, sample length, trial aggression as P1; moments and trial count as P2. Human-readable or `--json` output |
+| `version` | Print version |
+
+Flags: `--returns` (required), `--trials` (optional), `--n-trials`
+(required unless `require_declared_trials` is disabled in code),
+`--periods-per-year` (default 252), `--n-blocks` (CSCV granularity, default
+16).
+
+## The checks
+
+| Check | Severity | Method | Reference |
+| --- | --- | --- | --- |
+| `dsr` | P0 | Deflated Sharpe Ratio: P(SR > E[max SR of N trials]) under non-normal moments | [Bailey & López de Prado (2014), JPM 40(5)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2460551) |
+| `pbo` | P0 | Probability of Backtest Overfitting via Combinatorially-Symmetric Cross-Validation (12,870 splits at n_blocks=16) | [Bailey, Borwein, López de Prado & Zhu (2017), JCF](https://escholarship.org/uc/item/4w1110bb) |
+| `haircut_sharpe` | P0 | Multiple-testing haircut of the Sharpe ratio (Bonferroni/Holm/BHY) | [Harvey & Liu (2015)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2528780) |
+| `mintrl` | P0 | Minimum Track Record Length: observations needed before SR is significant | [Bailey & López de Prado (2018), JPM 44(5)](https://ideas.repec.org/a/rsk/journl/0journalpm-v44n5.html) |
+| `psr_vs_zero` | P1 | Probabilistic Sharpe vs zero | [Bailey & López de Prado (2012)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2168747) |
+| `sample_length` | P1 | ≥ 252 observations | — |
+| `trial_aggression` | P1 | n_trials ≤ n_obs / 5 | — |
+| `return_moments` | P2 | skew ≈ 0, kurtosis ≈ 3 | — |
+| `trial_count` | P2 | n_trials ≥ 5 | — |
+
+The P0 set mirrors the spirit of [Harvey, Liu & Zhu (2016),
+"…and the Cross-Section of Expected Returns"](https://doi.org/10.1093/rfs/hhv059):
+a factor must survive multiple-testing correction to earn the right to be
+called a factor. The gate is the machine version of that editorial stance.
+
+## Performance note
+
+CSCV enumerates C(n_blocks, n_blocks/2) splits — 12,870 at the default 16.
+On large trial matrices (T=1000, N=200) that takes minutes; use
+`--n-blocks 8` (70 splits) or `10` (252 splits) for interactive speed at
+slightly coarser granularity.
+
+## Development
+
+```bash
+python -m pip install -e . pytest
+python -m pytest
+```
+
+CI runs the full test suite on Ubuntu, Windows and macOS with Python 3.11
+and 3.12. Issues are handled on weekends; pull requests are welcome.
+
+## Related work
+
+- [Bailey & López de Prado (2014), The Deflated Sharpe Ratio](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2460551)
+- [Bailey, Borwein, López de Prado & Zhu (2017), The Probability of Backtest Overfitting](https://escholarship.org/uc/item/4w1110bb)
+- [Harvey, Liu & Zhu (2016), …and the Cross-Section of Expected Returns (RFS)](https://doi.org/10.1093/rfs/hhv059)
+- [Harvey & Liu (2021), Lucky Factors (JFE)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2528780)
+- [Mobarekeh & López de Prado (2024), Backtest Overfitting in the Machine Learning Era (SSRN 4778909)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4778909) — why OOS methods still need honest trial accounting
+
+## License
+
+MIT

factor_qc-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "factor-qc"
+version = "0.1.0"
+description = "Fail-closed quality gate for backtests: DSR, PBO, Harvey-Liu haircut and MinTRL in one numpy-only engine, with P0/P1/P2 severity grading."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+dependencies = ["numpy>=1.24"]
+keywords = ["backtest", "overfitting", "deflated-sharpe", "pbo", "mintrl", "factor", "qc", "quant"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Financial and Insurance Industry",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Office/Business :: Financial :: Investment",
+    "Topic :: Scientific/Engineering",
+]
+
+[project.scripts]
+qc = "factor_qc.cli:main"
+factor-qc = "factor_qc.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

factor_qc-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

factor_qc-0.1.0/src/factor_qc/__init__.py

@@ -0,0 +1,34 @@
+"""factor-qc: fail-closed quality gate for backtests.
+
+One numpy-only engine for the standard backtest-overfit statistics —
+Deflated Sharpe Ratio, Probability of Backtest Overfitting (CSCV),
+Harvey-Liu multiple-testing haircut, Minimum Track Record Length — wrapped
+in a gate that refuses to judge a backtest that does not declare how many
+configurations were tried.
+"""
+
+from .gate import run_gate
+from .stats import (
+    build_check_artifact,
+    build_overfit_report,
+    deflated_sharpe_ratio,
+    haircut_sharpe,
+    minimum_track_record_length,
+    probability_of_backtest_overfitting,
+    sharpe_ratio,
+    skew_kurt,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "build_check_artifact",
+    "build_overfit_report",
+    "deflated_sharpe_ratio",
+    "haircut_sharpe",
+    "minimum_track_record_length",
+    "probability_of_backtest_overfitting",
+    "run_gate",
+    "sharpe_ratio",
+    "skew_kurt",
+]

factor_qc-0.1.0/src/factor_qc/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

factor_qc-0.1.0/src/factor_qc/cli.py

@@ -0,0 +1,114 @@
+"""Command-line interface for factor-qc.
+
+Subcommands:
+
+- ``check``   run the fail-closed gate on a returns series
+- ``version`` print version
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from . import __version__
+from .gate import run_gate
+
+
+def _load_returns(path: str) -> np.ndarray:
+    value = json.loads(Path(path).read_text(encoding="utf-8"))
+    if not isinstance(value, list) or not all(isinstance(x, (int, float)) for x in value):
+        raise ValueError(f"returns must be a JSON list of numbers: {path}")
+    return np.asarray(value, dtype=float)
+
+
+def _load_trials(path: str) -> np.ndarray:
+    value = json.loads(Path(path).read_text(encoding="utf-8"))
+    if not isinstance(value, list) or not value:
+        raise ValueError(f"trials must be a non-empty JSON list of lists: {path}")
+    rows = []
+    for row in value:
+        if not isinstance(row, list):
+            raise ValueError(f"trials rows must be lists: {path}")
+        rows.append([float(x) for x in row])
+    matrix = np.asarray(rows, dtype=float)
+    if matrix.ndim != 2:
+        raise ValueError(f"trials must be 2D (T x N): {path}")
+    return matrix
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="qc",
+        description="Fail-closed quality gate for backtests.",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    check = sub.add_parser("check", help="run the fail-closed gate")
+    check.add_argument("--returns", required=True, help="JSON list of per-period returns")
+    check.add_argument("--trials", default=None, help="JSON 2D matrix (T x N) of trial returns")
+    check.add_argument(
+        "--n-trials",
+        type=int,
+        default=None,
+        help="honest number of configurations tried (required, fail-closed)",
+    )
+    check.add_argument("--periods-per-year", type=int, default=252)
+    check.add_argument(
+        "--n-blocks",
+        type=int,
+        default=16,
+        help="CSCV blocks for PBO (default 16 = 12,870 splits; use 8 or 10 for speed)",
+    )
+    check.add_argument("--json", action="store_true", help="machine-readable output")
+
+    sub.add_parser("version", help="print version")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "version":
+        print(__version__)
+        return 0
+
+    if args.command == "check":
+        returns = _load_returns(args.returns)
+        trials = _load_trials(args.trials) if args.trials else None
+        if args.n_trials is not None and args.n_trials < 1:
+            parser.error("--n-trials must be >= 1")
+        body: dict[str, Any] = run_gate(
+            returns,
+            args.n_trials,
+            trials_matrix=trials,
+            periods_per_year=args.periods_per_year,
+            n_blocks=args.n_blocks,
+        )
+        if args.json:
+            print(json.dumps(body, ensure_ascii=False, indent=2))
+        else:
+            print(body["verdict"])
+            if body["report"] is not None:
+                print(body["report_text"])
+            for check in body["checks"]:
+                marker = "PASS" if check["passed"] else "FAIL"
+                print(
+                    f" [{marker}] {check['severity']} {check['check_id']}: "
+                    f"{check['title']} (value={check['value']}, "
+                    f"threshold={check['threshold']})"
+                )
+        return 0 if body["passed"] else 1
+
+    parser.error(f"unknown command: {args.command}")
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())