filtrix-cli 0.1.0__py3-none-any.whl

filtrix_cli/AGENTS.md

@@ -0,0 +1,47 @@
+# filtrix-cli — agent guide
+
+Structured command-line access to the FILTRIX historical backtest engine.
+
+## Output contract
+- Add `--json` (or pipe stdout) to get JSON on stdout. Human tables otherwise.
+- Data goes to stdout; errors/progress go to stderr.
+- Errors (stderr, JSON): {"error":{"type","message","status","retryable","suggestion","input"}}.
+
+## Exit codes
+- 0 success
+- 1 server/unexpected error (retryable)
+- 2 usage / invalid filter
+- 3 not found
+- 4 authentication required/failed
+- 5 rate limited (retryable)
+- 6 network/timeout (retryable)
+
+## Auth
+- Reads/backtests: set env FILTRIX_API_KEY=flt_... (or `filtrix config set api_key ...`).
+- Key management: `filtrix auth login` first (stores a JWT).
+
+## Commands
+- filtrix backtest --filter "COL OP VAL" [--filter ...] [--outcome ...] [--start YYYY-MM-DD] [--end YYYY-MM-DD]
+- filtrix screen   --filter ... [--limit N] [--offset N]
+- filtrix ticker   SYMBOL
+- filtrix filters  [--search TEXT] [--type number|date|string]
+- filtrix account
+- filtrix keys list|create|revoke
+- filtrix auth login|logout|status
+- filtrix auth register --email E --password P --accept-tos   (emails a 6-digit code, then prompts for it, then auto-logs-in)
+- filtrix auth verify-code CODE --email E --password P        (resume a pending signup)
+- filtrix auth resend-code --email E
+- filtrix config get|set|list|path
+
+Note: global flags like `--json` go BEFORE the subcommand (e.g. `filtrix --json backtest ...`).
+
+## Filter DSL
+"COL OP VAL", operators: >= <= != = > < like in. Repeat --filter for AND.
+Examples: "gap_gup>=10", "price_price<5", "earnings_date_days_earningd=0.25", "sic_code in 7372,7389".
+Use the RAW schema column names from `filtrix filters` (e.g. price_price, float_shares_float) — these
+can differ from screen's friendlier output field names (price, float_shares). Unknown columns return exit 2.
+For exact control, pass `--filters-json '[{"column":...,"operator":...,"value":...,"value_type":...}]'`
+or `--filters-json -` to read the JSON array from stdin.
+
+## Discover filters
+Run `filtrix filters --json` to enumerate valid columns, value types, and operators.

filtrix_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

filtrix_cli/__main__.py

@@ -0,0 +1,60 @@
+import typer
+
+from filtrix_cli import __version__
+from filtrix_cli.state import set_state
+from filtrix_cli.commands import backtest as backtest_cmd
+from filtrix_cli.commands import screen as screen_cmd
+from filtrix_cli.commands import ticker as ticker_cmd
+from filtrix_cli.commands import filters as filters_cmd
+from filtrix_cli.commands import account as account_cmd
+from filtrix_cli.commands import keys as keys_cmd
+from filtrix_cli.commands import authcmd
+from filtrix_cli.commands import configcmd
+from filtrix_cli.commands import llms as llms_cmd
+
+app = typer.Typer(
+    add_completion=False,
+    help="FILTRIX CLI — terminal access to the FILTRIX backtest engine.",
+)
+
+
+@app.callback(invoke_without_command=True)
+def _root(
+    ctx: typer.Context,
+    json: bool = typer.Option(False, "--json", help="Force JSON output to stdout."),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Bare values only."),
+    no_color: bool = typer.Option(False, "--no-color", help="Disable colored output."),
+    profile: str = typer.Option(None, "--profile", help="Config profile to use."),
+    api_key: str = typer.Option(None, "--api-key", help="Override API key for this run."),
+    base_url: str = typer.Option(None, "--base-url", help="Override API base URL for this run."),
+) -> None:
+    """FILTRIX CLI — terminal access to the FILTRIX backtest engine."""
+    set_state(json=json, quiet=quiet, no_color=no_color,
+              profile=profile, api_key=api_key, base_url=base_url)
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+
+
+@app.command()
+def version() -> None:
+    """Print the CLI version."""
+    typer.echo(f"filtrix-cli {__version__}")
+
+
+app.command("backtest")(backtest_cmd.backtest)
+app.command("screen")(screen_cmd.screen)
+app.command("ticker")(ticker_cmd.ticker)
+app.command("filters")(filters_cmd.filters)
+app.command("account")(account_cmd.account)
+app.add_typer(keys_cmd.app, name="keys")
+app.add_typer(authcmd.app, name="auth")
+app.add_typer(configcmd.app, name="config")
+app.command("llms")(llms_cmd.llms)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

filtrix_cli/auth.py

@@ -0,0 +1,76 @@
+"""Interactive login flows: direct, Telegram-2FA poll, and backup code."""
+import time
+from typing import Callable, Optional
+
+import httpx
+
+from filtrix_cli import __version__
+from filtrix_cli.output import CLIError
+
+_POLL_DEADLINE_SECONDS = 300
+
+
+def _ua() -> dict:
+    return {"User-Agent": f"filtrix-cli/{__version__}", "X-Agent-Request": "true"}
+
+
+def login(
+    base_url: str,
+    email: str,
+    password: str,
+    *,
+    poll_interval: float = 2.0,
+    on_pending: Optional[Callable[[str, Optional[str]], None]] = None,
+) -> str:
+    """Return a JWT. Handles direct login and Telegram 2FA. Raises CLIError
+    (type 'backup_code_required') when only a backup code can proceed."""
+    base = base_url.rstrip("/")
+    with httpx.Client(timeout=30) as client:
+        resp = client.post(f"{base}/api/auth/login", data={"username": email, "password": password}, headers=_ua())
+        if resp.status_code == 200:
+            return resp.json()["access_token"]
+        if resp.status_code == 400:
+            raise CLIError("auth_failed", "Incorrect email or password.", status=400, exit_code=4)
+        if resp.status_code == 202:
+            body = resp.json()
+            required = body.get("auth_required")
+            if required == "backup_code_only":
+                raise CLIError("backup_code_required",
+                               "2FA is on but Telegram is unlinked. Re-run with --backup-code.",
+                               status=202, exit_code=4)
+            if required == "telegram":
+                pending_id = body["pending_id"]
+                if on_pending:
+                    on_pending(pending_id, body.get("expires_at"))
+                return _poll_login(client, base, pending_id, poll_interval)
+            raise CLIError("auth_failed", f"Unexpected auth_required: {required}", status=202, exit_code=4)
+        raise CLIError("server_error", f"Login failed (HTTP {resp.status_code}).",
+                       status=resp.status_code, exit_code=1)
+
+
+def _poll_login(client: httpx.Client, base: str, pending_id: str, interval: float) -> str:
+    deadline = time.time() + _POLL_DEADLINE_SECONDS
+    while time.time() < deadline:
+        status = client.get(f"{base}/api/auth/login/status/{pending_id}", headers=_ua()).json().get("status")
+        if status == "approved":
+            done = client.post(f"{base}/api/auth/login/complete/{pending_id}", headers=_ua())
+            if done.status_code == 200:
+                return done.json()["access_token"]
+            raise CLIError("auth_failed", f"Could not finalize login (HTTP {done.status_code}).",
+                           status=done.status_code, exit_code=4)
+        if status == "denied":
+            raise CLIError("auth_failed", "Login was denied from Telegram.", exit_code=4)
+        if status == "expired":
+            raise CLIError("auth_failed", "Login approval expired. Try again.", exit_code=4)
+        time.sleep(interval)
+    raise CLIError("auth_failed", "Timed out waiting for Telegram approval.", retryable=True, exit_code=6)
+
+
+def login_backup_code(base_url: str, email: str, password: str, code: str) -> str:
+    base = base_url.rstrip("/")
+    with httpx.Client(timeout=30) as client:
+        resp = client.post(f"{base}/api/auth/login/backup-code",
+                           json={"email": email, "password": password, "code": code}, headers=_ua())
+        if resp.status_code == 200:
+            return resp.json()["access_token"]
+        raise CLIError("auth_failed", "Backup-code login failed.", status=resp.status_code, exit_code=4)

filtrix_cli/client.py

@@ -0,0 +1,132 @@
+"""Synchronous httpx client for the FILTRIX API, with error -> CLIError mapping."""
+import json
+from typing import Any, List, Optional
+
+import httpx
+
+from filtrix_cli import __version__
+from filtrix_cli.output import CLIError
+
+
+def _safe_detail(resp: httpx.Response) -> str:
+    try:
+        data = resp.json()
+    except Exception:
+        return resp.text or f"HTTP {resp.status_code}"
+    if isinstance(data, dict) and "detail" in data:
+        detail = data["detail"]
+        return detail if isinstance(detail, str) else json.dumps(detail)
+    return json.dumps(data)
+
+
+class FiltrixClient:
+    def __init__(self, base_url: str, api_key: Optional[str] = None,
+                 jwt: Optional[str] = None, timeout: float = 60.0):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.jwt = jwt
+        self.timeout = timeout
+
+    def _headers(self, auth: str) -> dict:
+        """auth in {'any', 'jwt', 'none'}."""
+        headers = {
+            "User-Agent": f"filtrix-cli/{__version__}",
+            "X-Agent-Request": "true",
+            "Content-Type": "application/json",
+        }
+        if auth == "none":
+            return headers
+        if auth == "jwt":
+            if not self.jwt:
+                raise CLIError("auth_failed", "This command requires login. Run `filtrix auth login`.",
+                               suggestion="filtrix auth login", exit_code=4)
+            headers["Authorization"] = f"Bearer {self.jwt}"
+            return headers
+        # auth == "any"
+        if self.api_key:
+            headers["X-API-Key"] = self.api_key
+        elif self.jwt:
+            headers["Authorization"] = f"Bearer {self.jwt}"
+        else:
+            raise CLIError("auth_failed", "No credentials. Set FILTRIX_API_KEY or run `filtrix auth login`.",
+                           suggestion="filtrix auth login", exit_code=4)
+        return headers
+
+    def _request(self, method: str, path: str, *, json_body: Any = None, auth: str = "any") -> Any:
+        url = f"{self.base_url}{path}"
+        headers = self._headers(auth)
+        try:
+            with httpx.Client(timeout=self.timeout) as client:
+                resp = client.request(method, url, headers=headers, json=json_body)
+        except httpx.TimeoutException as e:
+            raise CLIError("network", f"Request timed out: {e}", retryable=True, exit_code=6)
+        except httpx.HTTPError as e:
+            raise CLIError("network", f"Network error: {e}", retryable=True, exit_code=6)
+        return self._handle_response(resp)
+
+    def _handle_response(self, resp: httpx.Response) -> Any:
+        if resp.status_code < 400:
+            return resp.json() if resp.content else {}
+        detail = _safe_detail(resp)
+        code = resp.status_code
+        if code in (401, 403):
+            raise CLIError("auth_failed", detail, status=code,
+                           suggestion="Run `filtrix auth login` or check your API key.", exit_code=4)
+        if code == 404:
+            raise CLIError("not_found", detail, status=404, exit_code=3)
+        if code == 429:
+            raise CLIError("rate_limited", detail, status=429, retryable=True,
+                           suggestion="Run `filtrix account` to see your quota.", exit_code=5)
+        if 400 <= code < 500:
+            raise CLIError("invalid_request", detail, status=code, exit_code=2)
+        raise CLIError("server_error", detail, status=code, retryable=True, exit_code=1)
+
+    # ---- Public API v1 ----
+    def backtest(self, filters: List[dict], outcome: str = "day_close_position",
+                 flat_threshold: float = 0.002, start_date: Optional[str] = None,
+                 end_date: Optional[str] = None) -> Any:
+        body: dict = {"filters": filters, "outcome": outcome, "flat_threshold": flat_threshold}
+        if start_date:
+            body["start_date"] = start_date
+        if end_date:
+            body["end_date"] = end_date
+        return self._request("POST", "/api/v1/backtest", json_body=body)
+
+    def screen(self, filters: List[dict], limit: int = 50, offset: int = 0) -> Any:
+        return self._request("POST", "/api/v1/screen",
+                             json_body={"filters": filters, "limit": limit, "offset": offset})
+
+    def ticker_info(self, symbol: str) -> Any:
+        return self._request("GET", f"/api/v1/ticker/{symbol.upper()}")
+
+    def list_filters(self) -> Any:
+        return self._request("GET", "/api/v1/filters", auth="none")
+
+    def account(self) -> Any:
+        return self._request("GET", "/api/v1/account")
+
+    # ---- Key management (JWT) ----
+    def keys_list(self) -> Any:
+        return self._request("GET", "/api/keys", auth="jwt")
+
+    def keys_create(self, name: str = "default") -> Any:
+        return self._request("POST", "/api/keys", json_body={"name": name}, auth="jwt")
+
+    def keys_revoke(self, key_id: int) -> Any:
+        return self._request("DELETE", f"/api/keys/{key_id}", auth="jwt")
+
+    # ---- Registration (pre-auth) ----
+    def register(self, email: str, password: str, delivery: str = "code",
+                 ref_source: Optional[str] = None) -> Any:
+        body: dict = {"email": email, "password": password, "delivery": delivery}
+        if ref_source:
+            body["ref_data"] = {"ref_source": ref_source}
+        return self._request("POST", "/api/auth/register", json_body=body, auth="none")
+
+    def verify_email_code(self, email: str, code: str) -> Any:
+        return self._request("POST", "/api/auth/verify-email-code",
+                             json_body={"email": email, "code": code}, auth="none")
+
+    def resend_code(self, email: str) -> Any:
+        return self._request("POST", "/api/auth/resend-code",
+                             json_body={"email": email}, auth="none")

filtrix_cli/commands/_helpers.py

@@ -0,0 +1,44 @@
+"""Shared plumbing for Typer commands: error handling, client construction, output."""
+import functools
+from typing import Any, Callable, Tuple
+
+import typer
+
+from filtrix_cli import config as config_mod
+from filtrix_cli.client import FiltrixClient
+from filtrix_cli.output import CLIError, emit_error, emit_json, is_json_mode
+from filtrix_cli.render import render_human
+from filtrix_cli.state import get_state
+
+
+def command(func: Callable) -> Callable:
+    """Wrap a Typer command: catch CLIError, emit it, exit with its code.
+    functools.wraps keeps the original signature so Typer still sees the params."""
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        json_mode = is_json_mode(get_state().json)
+        try:
+            return func(*args, **kwargs)
+        except CLIError as err:
+            emit_error(err, json_mode)
+            raise typer.Exit(err.exit_code)
+    return wrapper
+
+
+def build_client() -> Tuple[FiltrixClient, dict]:
+    state = get_state()
+    settings = config_mod.resolve_settings(
+        profile=state.profile, api_key=state.api_key, base_url=state.base_url
+    )
+    client = FiltrixClient(
+        base_url=settings["base_url"], api_key=settings["api_key"], jwt=settings["jwt"]
+    )
+    return client, settings
+
+
+def output_result(result: Any, *, kind: str) -> None:
+    state = get_state()
+    if is_json_mode(state.json):
+        emit_json(result)
+    else:
+        render_human(result, kind=kind, quiet=state.quiet, no_color=state.no_color)

filtrix_cli/commands/account.py

@@ -0,0 +1,9 @@
+from filtrix_cli.commands._helpers import build_client, command, output_result
+
+
+@command
+def account() -> None:
+    """Show your tier and remaining daily quota."""
+    client, _ = build_client()
+    result = client.account()
+    output_result(result, kind="account")

filtrix_cli/commands/authcmd.py

@@ -0,0 +1,166 @@
+import sys
+from typing import Optional
+
+import typer
+
+from filtrix_cli import auth as auth_flow
+from filtrix_cli import config as config_mod
+from filtrix_cli.commands._helpers import build_client, command, output_result
+from filtrix_cli.output import CLIError
+from filtrix_cli.state import get_state
+
+app = typer.Typer(no_args_is_help=True, help="Authenticate and manage your session.")
+
+
+def _active_profile() -> str:
+    return get_state().profile or "default"
+
+
+@app.command("login")
+@command
+def login(
+    email: Optional[str] = typer.Option(None, "--email", help="Account email (prompted if omitted)."),
+    password: Optional[str] = typer.Option(None, "--password", help="Account password (prompted if omitted)."),
+    backup_code: bool = typer.Option(False, "--backup-code", help="Use a 2FA backup code instead of Telegram."),
+) -> None:
+    """Log in and store a JWT in your config profile."""
+    settings = config_mod.resolve_settings(profile=_active_profile(),
+                                           base_url=get_state().base_url)
+    base_url = settings["base_url"]
+    email = email or typer.prompt("Email")
+    password = password or typer.prompt("Password", hide_input=True)
+    profile = settings["profile"]
+
+    if backup_code:
+        code = typer.prompt("Backup code")
+        token = auth_flow.login_backup_code(base_url, email, password, code)
+    else:
+        def _notify(pending_id: str, expires_at):
+            typer.echo("Approve this login in your Telegram app...", err=True)
+        try:
+            token = auth_flow.login(base_url, email, password, on_pending=_notify)
+        except CLIError as err:
+            if err.error_type == "backup_code_required":
+                code = typer.prompt("2FA backup code")
+                token = auth_flow.login_backup_code(base_url, email, password, code)
+            else:
+                raise
+
+    config_mod.set_value(profile, "jwt", token)
+    config_mod.set_value(profile, "email", email)
+    output_result({"logged_in": True, "email": email, "profile": profile}, kind="account")
+
+
+@app.command("logout")
+@command
+def logout() -> None:
+    """Remove the stored JWT from the active profile."""
+    profile = _active_profile()
+    data = config_mod.load_config()
+    table = data.get("default", {}) if profile == "default" else data.get("profile", {}).get(profile, {})
+    table.pop("jwt", None)
+    table.pop("email", None)
+    config_mod.save_config(data)
+    output_result({"logged_out": True, "profile": profile}, kind="account")
+
+
+@app.command("status")
+@command
+def status() -> None:
+    """Show whether you are logged in and which credentials resolve."""
+    settings = config_mod.resolve_settings(
+        profile=_active_profile(), api_key=get_state().api_key, base_url=get_state().base_url)
+    output_result({
+        "logged_in": bool(settings["jwt"]),
+        "has_api_key": bool(settings["api_key"]),
+        "email": settings["email"],
+        "profile": settings["profile"],
+        "base_url": settings["base_url"],
+    }, kind="account")
+
+
+@app.command("register")
+@command
+def register(
+    email: Optional[str] = typer.Option(None, "--email", help="Account email (prompted if omitted)."),
+    password: Optional[str] = typer.Option(None, "--password", help="Account password (prompted if omitted)."),
+    accept_tos: bool = typer.Option(False, "--accept-tos", help="Accept the Terms of Service (https://filtrix.net/terms)."),
+    ref_source: Optional[str] = typer.Option(None, "--ref-source", help="Optional acquisition source tag."),
+) -> None:
+    """Create a FILTRIX account from the terminal (emailed 6-digit code), then auto-login."""
+    if not accept_tos:
+        raise CLIError(
+            "tos_required",
+            "You must accept the Terms of Service to register. "
+            "Re-run with --accept-tos (https://filtrix.net/terms).",
+            exit_code=2,
+        )
+    settings = config_mod.resolve_settings(profile=_active_profile(), base_url=get_state().base_url)
+    base_url, profile = settings["base_url"], settings["profile"]
+    email = email or typer.prompt("Email")
+    password = password or typer.prompt("Password", hide_input=True)
+
+    client, _ = build_client()
+    client.register(email, password, delivery="code", ref_source=ref_source)
+    typer.echo(f"We emailed a 6-digit code to {email}.", err=True)
+    typer.echo("Code: ", err=True, nl=False)
+    code = sys.stdin.readline().strip()
+    try:
+        client.verify_email_code(email, code)
+    except CLIError as err:
+        if err.error_type == "auth_failed":
+            raise CLIError(
+                "invalid_code",
+                f"That code is invalid or expired. Re-check it, or run "
+                f"`filtrix auth resend-code --email {email}` for a new one.",
+                exit_code=4,
+            )
+        raise
+
+    token = auth_flow.login(base_url, email, password)
+    config_mod.set_value(profile, "jwt", token)
+    config_mod.set_value(profile, "email", email)
+    output_result({"registered": True, "logged_in": True, "email": email, "profile": profile}, kind="account")
+
+
+@app.command("verify-code")
+@command
+def verify_code(
+    code: str = typer.Argument(..., help="The 6-digit code emailed to you."),
+    email: Optional[str] = typer.Option(None, "--email", help="Account email (prompted if omitted)."),
+    password: Optional[str] = typer.Option(None, "--password", help="Account password (prompted if omitted)."),
+) -> None:
+    """Verify a pending account with its emailed code, then auto-login."""
+    settings = config_mod.resolve_settings(profile=_active_profile(), base_url=get_state().base_url)
+    base_url, profile = settings["base_url"], settings["profile"]
+    email = email or typer.prompt("Email")
+    password = password or typer.prompt("Password", hide_input=True)
+
+    client, _ = build_client()
+    try:
+        client.verify_email_code(email, code)
+    except CLIError as err:
+        if err.error_type == "auth_failed":
+            raise CLIError(
+                "invalid_code",
+                f"That code is invalid or expired. Re-check it, or run "
+                f"`filtrix auth resend-code --email {email}` for a new one.",
+                exit_code=4,
+            )
+        raise
+    token = auth_flow.login(base_url, email, password)
+    config_mod.set_value(profile, "jwt", token)
+    config_mod.set_value(profile, "email", email)
+    output_result({"verified": True, "logged_in": True, "email": email, "profile": profile}, kind="account")
+
+
+@app.command("resend-code")
+@command
+def resend_code(
+    email: Optional[str] = typer.Option(None, "--email", help="Account email (prompted if omitted)."),
+) -> None:
+    """Request a fresh verification code by email."""
+    email = email or typer.prompt("Email")
+    client, _ = build_client()
+    client.resend_code(email)
+    output_result({"resent": True, "email": email}, kind="account")

filtrix_cli/commands/backtest.py

@@ -0,0 +1,25 @@
+from typing import List, Optional
+
+import typer
+
+from filtrix_cli.commands._helpers import build_client, command, output_result
+from filtrix_cli.filters import resolve_filters
+
+
+@command
+def backtest(
+    filter: Optional[List[str]] = typer.Option(None, "--filter", "-f",
+        help='Filter "COL OP VAL" (repeatable). E.g. -f "gap_gup>=10".'),
+    filters_json: Optional[str] = typer.Option(None, "--filters-json",
+        help="JSON array of filter objects, or '-' to read from stdin."),
+    outcome: str = typer.Option("day_close_position", "--outcome", help="Outcome to analyse."),
+    start: Optional[str] = typer.Option(None, "--start", help="Start date YYYY-MM-DD."),
+    end: Optional[str] = typer.Option(None, "--end", help="End date YYYY-MM-DD."),
+    flat_threshold: float = typer.Option(0.002, "--flat-threshold", help="Flat/range threshold."),
+) -> None:
+    """Run a historical backtest and print summary statistics."""
+    filters = resolve_filters(filter, filters_json)
+    client, _ = build_client()
+    result = client.backtest(filters, outcome=outcome, start_date=start,
+                             end_date=end, flat_threshold=flat_threshold)
+    output_result(result, kind="backtest")

filtrix_cli/commands/configcmd.py

@@ -0,0 +1,40 @@
+import typer
+
+from filtrix_cli import config as config_mod
+from filtrix_cli.commands._helpers import command, output_result
+from filtrix_cli.state import get_state
+
+app = typer.Typer(no_args_is_help=True, help="Inspect and edit CLI config.")
+
+
+def _profile() -> str:
+    return get_state().profile or "default"
+
+
+@app.command("get")
+@command
+def get_cmd(key: str = typer.Argument(..., help="Config key.")) -> None:
+    """Print a single config value from the active profile."""
+    output_result({"key": key, "value": config_mod.get_value(_profile(), key)}, kind="raw")
+
+
+@app.command("set")
+@command
+def set_cmd(key: str = typer.Argument(...), value: str = typer.Argument(...)) -> None:
+    """Set a config value in the active profile."""
+    config_mod.set_value(_profile(), key, value)
+    output_result({"key": key, "value": value, "profile": _profile()}, kind="raw")
+
+
+@app.command("list")
+@command
+def list_cmd() -> None:
+    """Print the whole config file as JSON."""
+    output_result(config_mod.load_config(), kind="raw")
+
+
+@app.command("path")
+@command
+def path_cmd() -> None:
+    """Print the config file path."""
+    typer.echo(str(config_mod.config_path()))

filtrix_cli/commands/filters.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+import typer
+
+from filtrix_cli.commands._helpers import build_client, command, output_result
+
+
+@command
+def filters(
+    search: Optional[str] = typer.Option(None, "--search", help="Substring filter on column name."),
+    type: Optional[str] = typer.Option(None, "--type", help="Filter by value_type (number/date/string/time)."),
+) -> None:
+    """List available filter columns (no authentication required)."""
+    client, _ = build_client()
+    result = client.list_filters()
+    cols = result.get("columns", []) or []
+    if search:
+        cols = [c for c in cols if search.lower() in c.get("column", "").lower()]
+    if type:
+        cols = [c for c in cols if c.get("value_type") == type]
+    output_result({"total": len(cols), "columns": cols}, kind="filters")

filtrix_cli/commands/keys.py

@@ -0,0 +1,29 @@
+import typer
+
+from filtrix_cli.commands._helpers import build_client, command, output_result
+
+app = typer.Typer(no_args_is_help=True, help="Manage API keys (requires login).")
+
+
+@app.command("list")
+@command
+def list_keys() -> None:
+    """List your API keys (prefixes only)."""
+    client, _ = build_client()
+    output_result(client.keys_list(), kind="keys")
+
+
+@app.command("create")
+@command
+def create_key(name: str = typer.Option("default", "--name", help="A label for the key.")) -> None:
+    """Create a new API key. The full key is shown once."""
+    client, _ = build_client()
+    output_result(client.keys_create(name), kind="keys")
+
+
+@app.command("revoke")
+@command
+def revoke_key(key_id: int = typer.Argument(..., help="ID of the key to revoke.")) -> None:
+    """Revoke an API key by ID."""
+    client, _ = build_client()
+    output_result(client.keys_revoke(key_id), kind="keys")

filtrix_cli/commands/llms.py

@@ -0,0 +1,12 @@
+from importlib import resources
+
+import typer
+
+from filtrix_cli.commands._helpers import command
+
+
+@command
+def llms() -> None:
+    """Print the agent-facing usage guide (AGENTS.md) to stdout."""
+    doc = resources.files("filtrix_cli").joinpath("AGENTS.md").read_text(encoding="utf-8")
+    typer.echo(doc)

filtrix_cli/commands/screen.py

@@ -0,0 +1,22 @@
+from typing import List, Optional
+
+import typer
+
+from filtrix_cli.commands._helpers import build_client, command, output_result
+from filtrix_cli.filters import resolve_filters
+
+
+@command
+def screen(
+    filter: Optional[List[str]] = typer.Option(None, "--filter", "-f",
+        help='Filter "COL OP VAL" (repeatable).'),
+    filters_json: Optional[str] = typer.Option(None, "--filters-json",
+        help="JSON array of filter objects, or '-' to read from stdin."),
+    limit: int = typer.Option(50, "--limit", help="Max results (1-200)."),
+    offset: int = typer.Option(0, "--offset", help="Pagination offset."),
+) -> None:
+    """Screen historical events matching the filters."""
+    filters = resolve_filters(filter, filters_json)
+    client, _ = build_client()
+    result = client.screen(filters, limit=limit, offset=offset)
+    output_result(result, kind="screen")

filtrix_cli/commands/ticker.py

@@ -0,0 +1,11 @@
+import typer
+
+from filtrix_cli.commands._helpers import build_client, command, output_result
+
+
+@command
+def ticker(symbol: str = typer.Argument(..., help="Ticker symbol, e.g. AAPL.")) -> None:
+    """Show metadata for a ticker."""
+    client, _ = build_client()
+    result = client.ticker_info(symbol)
+    output_result(result, kind="ticker")

filtrix_cli/config.py

@@ -0,0 +1,86 @@
+"""TOML config with named profiles and flag > env > file precedence."""
+import os
+from pathlib import Path
+
+try:
+    import tomllib  # Python 3.11+
+except ModuleNotFoundError:  # pragma: no cover - 3.10 fallback
+    import tomli as tomllib
+from typing import Any, Optional
+
+import platformdirs
+import tomli_w
+
+APP_NAME = "filtrix"
+DEFAULT_BASE_URL = "https://filtrix.net"
+
+
+def config_path() -> Path:
+    return Path(platformdirs.user_config_dir(APP_NAME)) / "config.toml"
+
+
+def load_config() -> dict:
+    path = config_path()
+    if not path.exists():
+        return {}
+    with path.open("rb") as f:
+        return tomllib.load(f)
+
+
+def save_config(data: dict) -> None:
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("wb") as f:
+        tomli_w.dump(data, f)
+    try:
+        os.chmod(path, 0o600)  # best-effort; Windows relies on profile ACL
+    except (OSError, NotImplementedError):
+        pass
+
+
+def _profile_table(data: dict, profile: str) -> dict:
+    if profile == "default":
+        return data.get("default", {})
+    return data.get("profile", {}).get(profile, {})
+
+
+def get_value(profile: str, key: str) -> Any:
+    return _profile_table(load_config(), profile).get(key)
+
+
+def set_value(profile: str, key: str, value: Any) -> None:
+    data = load_config()
+    if profile == "default":
+        data.setdefault("default", {})[key] = value
+    else:
+        data.setdefault("profile", {}).setdefault(profile, {})[key] = value
+    save_config(data)
+
+
+def resolve_settings(
+    profile: Optional[str] = None,
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+) -> dict:
+    """Resolve effective settings. Precedence: explicit arg > env var > config file."""
+    profile = profile or os.environ.get("FILTRIX_PROFILE", "default")
+    table = _profile_table(load_config(), profile)
+
+    resolved_base = (
+        base_url
+        or os.environ.get("FILTRIX_BASE_URL")
+        or table.get("base_url")
+        or DEFAULT_BASE_URL
+    )
+    resolved_key = (
+        api_key
+        or os.environ.get("FILTRIX_API_KEY")
+        or table.get("api_key")
+    )
+    return {
+        "profile": profile,
+        "base_url": resolved_base.rstrip("/"),
+        "api_key": resolved_key,
+        "jwt": table.get("jwt"),
+        "email": table.get("email"),
+    }

filtrix_cli/filters.py

@@ -0,0 +1,98 @@
+"""Parse the --filter mini-DSL ("COL OP VAL") into FilterCondition dicts."""
+import json
+import re
+import sys
+from typing import List, Optional
+
+from filtrix_cli.output import CLIError
+
+_TWO_CHAR = {">=", "<=", "!="}
+_ONE_CHAR = {">", "<", "="}
+_WORD_OP_RE = re.compile(r"^(?P<col>\w+)\s+(?P<op>like|in)\s+(?P<val>.+)$", re.IGNORECASE)
+_DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
+
+
+def infer_value_type(value: str) -> str:
+    v = value.strip()
+    if _DATE_RE.match(v):
+        return "date"
+    try:
+        float(v)
+        return "number"
+    except ValueError:
+        return "string"
+
+
+def _find_symbol_op(s: str):
+    """Return (index, operator) of the first symbol operator, longest-match
+    at that position; or None."""
+    i = 0
+    while i < len(s):
+        pair = s[i:i + 2]
+        if pair in _TWO_CHAR:
+            return i, pair
+        if s[i] in _ONE_CHAR:
+            return i, s[i]
+        i += 1
+    return None
+
+
+def parse_filter(expr: str) -> dict:
+    s = expr.strip()
+    if not s:
+        raise CLIError("invalid_filter", "Empty filter expression.", exit_code=2)
+
+    word = _WORD_OP_RE.match(s)
+    if word:
+        col = word.group("col")
+        op = word.group("op").lower()
+        val = word.group("val").strip()
+        vtype = "string" if op == "like" else infer_value_type(val.split(",")[0])
+        return {"column": col, "operator": op, "value": val, "value_type": vtype}
+
+    found = _find_symbol_op(s)
+    if not found:
+        raise CLIError(
+            "invalid_filter",
+            f'Could not find an operator in "{expr}". '
+            'Use one of >= <= != = > < like in.',
+            input={"filter": expr},
+            exit_code=2,
+        )
+    idx, op = found
+    col = s[:idx].strip()
+    val = s[idx + len(op):].strip()
+    if not col:
+        raise CLIError("invalid_filter", f'Missing column in "{expr}".', input={"filter": expr}, exit_code=2)
+    if not val:
+        raise CLIError("invalid_filter", f'Missing value in "{expr}".', input={"filter": expr}, exit_code=2)
+    if set(val) <= set("><!="):
+        raise CLIError("invalid_filter", f'Malformed value in "{expr}".', input={"filter": expr}, exit_code=2)
+    return {"column": col, "operator": op, "value": val, "value_type": infer_value_type(val)}
+
+
+def parse_filters(exprs: List[str]) -> List[dict]:
+    return [parse_filter(e) for e in exprs]
+
+
+def load_filters_json(arg: str) -> List[dict]:
+    raw = sys.stdin.read() if arg == "-" else arg
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as e:
+        raise CLIError("invalid_filter", f"Invalid --filters-json: {e}", exit_code=2)
+    if not isinstance(data, list):
+        raise CLIError("invalid_filter", "--filters-json must be a JSON array.", exit_code=2)
+    return data
+
+
+def resolve_filters(filter_exprs: Optional[List[str]], filters_json: Optional[str]) -> List[dict]:
+    """Pick exactly one input source and return a list of filter dicts."""
+    has_dsl = bool(filter_exprs)
+    if filters_json is not None and has_dsl:
+        raise CLIError("invalid_filter", "Use either --filter or --filters-json, not both.", exit_code=2)
+    if filters_json is not None:
+        return load_filters_json(filters_json)
+    if not has_dsl:
+        raise CLIError("invalid_filter", "At least one --filter (or --filters-json) is required.", exit_code=2)
+    return parse_filters(filter_exprs)

filtrix_cli/output.py

@@ -0,0 +1,56 @@
+"""Framework-agnostic output + error primitives. No Typer/Rich imports here."""
+import json
+import sys
+from typing import Any, Optional
+
+
+class CLIError(Exception):
+    """A user-facing error with a machine-readable type and an exit code."""
+
+    def __init__(
+        self,
+        error_type: str,
+        message: str,
+        *,
+        status: Optional[int] = None,
+        retryable: bool = False,
+        suggestion: Optional[str] = None,
+        input: Optional[Any] = None,
+        exit_code: int = 1,
+    ):
+        super().__init__(message)
+        self.error_type = error_type
+        self.message = message
+        self.status = status
+        self.retryable = retryable
+        self.suggestion = suggestion
+        self.input = input
+        self.exit_code = exit_code
+
+    def to_dict(self) -> dict:
+        err: dict = {"type": self.error_type, "message": self.message, "retryable": self.retryable}
+        if self.status is not None:
+            err["status"] = self.status
+        if self.suggestion:
+            err["suggestion"] = self.suggestion
+        if self.input is not None:
+            err["input"] = self.input
+        return {"error": err}
+
+
+def is_json_mode(json_flag: bool) -> bool:
+    """JSON when explicitly requested or when stdout is not a TTY (piped)."""
+    return json_flag or not sys.stdout.isatty()
+
+
+def emit_json(data: Any) -> None:
+    sys.stdout.write(json.dumps(data, default=str) + "\n")
+
+
+def emit_error(err: CLIError, json_mode: bool) -> None:
+    if json_mode:
+        sys.stderr.write(json.dumps(err.to_dict(), default=str) + "\n")
+    else:
+        sys.stderr.write(f"Error [{err.error_type}]: {err.message}\n")
+        if err.suggestion:
+            sys.stderr.write(f"  -> {err.suggestion}\n")

filtrix_cli/render.py

@@ -0,0 +1,120 @@
+"""Rich human-readable renderers. Only used when not in JSON mode."""
+import json
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+_console = Console()
+
+
+def render_human(result: Any, *, kind: str, quiet: bool = False, no_color: bool = False) -> None:
+    global _console
+    _console = Console(no_color=no_color)
+    renderer = _RENDERERS.get(kind, _render_fallback)
+    renderer(result, quiet)
+
+
+def _render_fallback(result: Any, quiet: bool) -> None:
+    _console.print_json(data=result)
+
+
+def _render_backtest(result: dict, quiet: bool) -> None:
+    n = result.get("n", 0)
+    if quiet:
+        _console.print(n)
+        return
+    summary = result.get("summary", {}) or {}
+    table = Table(title=f"Backtest — n={n}")
+    table.add_column("metric")
+    table.add_column("value", justify="right")
+    for key in ("mean", "median", "p05", "p25", "p75", "p95",
+                "long_pct", "short_pct", "flat_pct", "close_up_pct", "close_down_pct"):
+        if key in summary:
+            table.add_row(key, str(summary[key]))
+    _console.print(table)
+
+
+def _render_screen(result: dict, quiet: bool) -> None:
+    rows = result.get("results", []) or []
+    if quiet:
+        for row in rows:
+            _console.print(row.get("symbol", ""))
+        return
+    table = Table(title=f"Screen — {result.get('total', len(rows))} match(es)")
+    for col in ("date", "symbol", "name", "price", "gap_pct", "dollar_volume", "float_shares", "relative_volume"):
+        table.add_column(col)
+    for row in rows:
+        table.add_row(*[("" if row.get(c) is None else str(row.get(c))) for c in
+                        ("date", "symbol", "name", "price", "gap_pct", "dollar_volume", "float_shares", "relative_volume")])
+    _console.print(table)
+
+
+def _render_ticker(result: dict, quiet: bool) -> None:
+    if quiet:
+        _console.print(result.get("symbol", ""))
+        return
+    table = Table(show_header=False, title=result.get("symbol", "ticker"))
+    table.add_column("field", style="bold")
+    table.add_column("value")
+    for key, value in result.items():
+        table.add_row(key, "" if value is None else str(value))
+    _console.print(table)
+
+
+def _render_filters(result: dict, quiet: bool) -> None:
+    cols = result.get("columns", []) or []
+    if quiet:
+        for c in cols:
+            _console.print(c.get("column", ""))
+        return
+    table = Table(title=f"Filters — {result.get('total', len(cols))} columns")
+    table.add_column("column")
+    table.add_column("value_type")
+    table.add_column("operators")
+    for c in cols:
+        table.add_row(c.get("column", ""), c.get("value_type", ""), " ".join(c.get("operators", [])))
+    _console.print(table)
+
+
+def _render_account(result: dict, quiet: bool) -> None:
+    if quiet:
+        _console.print(result.get("remaining", ""))
+        return
+    table = Table(show_header=False, title="Account")
+    table.add_column("field", style="bold")
+    table.add_column("value")
+    for key in ("email", "tier", "is_admin", "daily_limit", "used_today", "remaining", "resets_at_utc"):
+        if key in result:
+            table.add_row(key, str(result[key]))
+    _console.print(table)
+
+
+def _render_keys(result: Any, quiet: bool) -> None:
+    if isinstance(result, dict) and not any(k in result for k in ("keys", "id", "key_prefix")):
+        if quiet:
+            return
+        for k, v in result.items():
+            _console.print(f"{k}: {v}")
+        return
+    keys = result if isinstance(result, list) else result.get("keys", [result])
+    if quiet:
+        for k in keys:
+            _console.print(k.get("key_prefix", k.get("id", "")))
+        return
+    table = Table(title="API keys")
+    for col in ("id", "name", "key_prefix", "created_at"):
+        table.add_column(col)
+    for k in keys:
+        table.add_row(*[str(k.get(c, "")) for c in ("id", "name", "key_prefix", "created_at")])
+    _console.print(table)
+
+
+_RENDERERS = {
+    "backtest": _render_backtest,
+    "screen": _render_screen,
+    "ticker": _render_ticker,
+    "filters": _render_filters,
+    "account": _render_account,
+    "keys": _render_keys,
+}

filtrix_cli/state.py

@@ -0,0 +1,30 @@
+"""Process-global CLI state set by the root Typer callback."""
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class State:
+    json: bool = False
+    quiet: bool = False
+    no_color: bool = False
+    profile: Optional[str] = None
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+
+
+_state = State()
+
+
+def get_state() -> State:
+    return _state
+
+
+def set_state(**kwargs) -> None:
+    for key, value in kwargs.items():
+        setattr(_state, key, value)
+
+
+def reset_state() -> None:
+    global _state
+    _state = State()

filtrix_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: filtrix-cli
+Version: 0.1.0
+Summary: Agent-first command-line interface for the FILTRIX backtest engine.
+Project-URL: Homepage, https://filtrix.net
+Project-URL: Documentation, https://pypi.org/project/filtrix-cli/
+Author-email: Filtrix <team@filtrix.net>
+License: MIT
+License-File: LICENSE
+Keywords: ai-agents,backtest,cli,filtrix,quant,screener,trading
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: platformdirs>=4
+Requires-Dist: rich>=13
+Requires-Dist: tomli-w>=1.0
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# filtrix-cli
+
+Agent-first command-line interface to [FILTRIX](https://filtrix.net) — historical trading-pattern backtesting.
+
+## Install
+
+```bash
+pipx install filtrix-cli      # or: uvx filtrix-cli ...
+```
+
+## Authenticate
+
+```bash
+export FILTRIX_API_KEY=flt_your_key      # for backtests/screens/ticker/account
+filtrix auth login                       # for managing API keys (stores a JWT)
+```
+
+### Sign up (terminal)
+
+```bash
+filtrix auth register --email you@example.com --accept-tos
+# FILTRIX emails a 6-digit code; paste it when prompted; you're logged in.
+```
+
+## Examples
+
+```bash
+filtrix backtest --filter "gap_gup>=50" --filter "price_price<5"
+filtrix screen --filter "gap_gup>=50" --limit 20
+filtrix --json screen --filter "gap_gup>=50"     # force JSON in a terminal
+filtrix ticker NVDA
+filtrix filters --search gap
+filtrix account
+filtrix keys create --name laptop
+filtrix llms          # machine-readable usage guide for AI agents
+```
+
+## Output & scripting
+
+Output is human-readable in a terminal and JSON when piped or with the global `--json` flag.
+Global flags (`--json`, `--quiet`, `--profile`, `--api-key`, `--base-url`) go BEFORE the subcommand.
+Exit codes: 0 ok, 2 usage, 3 not-found, 4 auth, 5 rate-limited, 6 network, 1 server.
+
+## Configuration
+
+Settings resolve in order: CLI flag > environment variable > config file
+(`filtrix config path` shows the location). Use `--profile NAME` for multiple environments.
+Credentials (API key / JWT) are stored in cleartext in this TOML file (best-effort `chmod 600` on POSIX) — treat it like an SSH key.

filtrix_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+filtrix_cli/__init__.py,sha256=QTYqXqSTHFRkM9TEgpDFcHvwLbvqHDqvqfQ9EiXkcAM,23
+filtrix_cli/__main__.py,sha256=etHHkz9bwutDNPKq2qEFxKDIPcCs1rbSV6dnZ0l4NKU,2195
+filtrix_cli/auth.py,sha256=iUljzwsWNN3odzzO3zvBDonCSKWO8z9UXP131MdrsQE,3626
+filtrix_cli/client.py,sha256=o8vlCTvpnio_8il6d4OVAvnJ8_BAIs99p6mEoROpWCc,5903
+filtrix_cli/config.py,sha256=-uPyJOLUWbGDTqrvrqOF6-PccubjMfSN-i4pDqRuuKg,2414
+filtrix_cli/filters.py,sha256=uYxpwUydRtAZif6Pa4ZX-w4EryF8RsPRH5ndDEx_iQI,3477
+filtrix_cli/output.py,sha256=Pg39y59H8lxWj3Wsh-fUiCaQtuzolghwdRXhmPkUwc0,1805
+filtrix_cli/render.py,sha256=K6_VGqkXfzEpJ0aOiUomw1TxbyV5wmhrsm5cNIo6icY,4256
+filtrix_cli/state.py,sha256=I7RQwUNqb8945chu_SPfteny9czq_3zISvp0G1m7h0E,600
+filtrix_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+filtrix_cli/commands/_helpers.py,sha256=-0550fgHvyv-Rh2xLX6Y3-WBZhB3dStGddJBUnUCIEI,1542
+filtrix_cli/commands/account.py,sha256=i71OmIvVVOnQ_kPgSkfQHZDu2FeGY6wDXHLYdtliQgQ,277
+filtrix_cli/commands/authcmd.py,sha256=lAVEKbT8ydsZbruRxGjj0SiSE1NRrZ49ztPrXvJPf-U,7051
+filtrix_cli/commands/backtest.py,sha256=wXzfd4cPN9cPl7kevpbHQI7VG7-6lvznLbxF5rak41s,1233
+filtrix_cli/commands/configcmd.py,sha256=5w1p3O2MQLWlgkYIp70MTDA71IJP14NvNdYJ3c1jmvs,1211
+filtrix_cli/commands/filters.py,sha256=4IoTg8G9NQ7tMsM7w0SjxgwwYbp50ZZfE4cfAao8Zrs,817
+filtrix_cli/commands/keys.py,sha256=rHqKJVGUBFwI6aHibM1u8_RCR7rhrv_22Ej3aF4NRcA,923
+filtrix_cli/commands/llms.py,sha256=niWYjhpwG5q64sjMNSf5PwwrNyJlnqKUMXtmFng3Dso,319
+filtrix_cli/commands/screen.py,sha256=e0fn4Yc7FxB4VWLwiFZfahrw7bGj2LJIk05BqH32NlM,893
+filtrix_cli/commands/ticker.py,sha256=8UEiKWOunMIK2WQpiGx0QrluUS6lg8XB-T-XF5M5q5g,354
+filtrix_cli/AGENTS.md,sha256=0OrM8nTivZY_KYMzKNaMHPlJWMURqXbcyGC6vZ1wkpE,2178
+filtrix_cli-0.1.0.dist-info/METADATA,sha256=fvL5VfzxVZWeQy39cjSCTfLCNVsTBD4Y0b5N5ILHyAQ,2816
+filtrix_cli-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+filtrix_cli-0.1.0.dist-info/entry_points.txt,sha256=zj35uQw9zqaUf2A6MFwQtbSFoDopNeRwAn5IaKpC-r8,54
+filtrix_cli-0.1.0.dist-info/licenses/LICENSE,sha256=r9lgEuR1lokoRIe3ucR7n8Xn_CtgLHz54VNAdvidDJw,1064
+filtrix_cli-0.1.0.dist-info/RECORD,,

filtrix_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

filtrix_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+filtrix = filtrix_cli.__main__:main

filtrix_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Filtrix
+
+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.