zeroquantz 0.1.0__py3-none-any.whl

zeroquantz/agent/parser.py

@@ -0,0 +1,255 @@
+"""Parse user text (slash commands *or* natural language) into an :class:`Intent`.
+
+Natural-language understanding here is deliberately rule-based (no LLM): the core
+must work fully offline. The important, well-tested piece is :func:`parse_goal`,
+which turns phrases like "fit this under 8GB and target vLLM, quality matters"
+into structured :class:`OptimizationGoal` updates.
+"""
+
+from __future__ import annotations
+
+import re
+
+from zeroquantz.agent.intents import Intent, IntentKind
+
+# ---- slash command table ---------------------------------------------------
+
+_SLASH: dict[str, IntentKind] = {
+    "model": IntentKind.LOAD_MODEL,
+    "load": IntentKind.LOAD_MODEL,  # /load MODEL (ambiguous with sessions; see parse)
+    "inspect": IntentKind.INSPECT,
+    "hardware": IntentKind.HARDWARE,
+    "hw": IntentKind.HARDWARE,
+    "goal": IntentKind.SET_GOAL,
+    "recommend": IntentKind.RECOMMEND,
+    "rec": IntentKind.RECOMMEND,
+    "profile": IntentKind.PROFILE,
+    "plan": IntentKind.PLAN,
+    "quantize": IntentKind.QUANTIZE,
+    "benchmark": IntentKind.BENCHMARK,
+    "bench": IntentKind.BENCHMARK,
+    "compare": IntentKind.COMPARE,
+    "verify": IntentKind.VERIFY,
+    "export": IntentKind.EXPORT,
+    "history": IntentKind.HISTORY,
+    "undo": IntentKind.UNDO,
+    "checkout": IntentKind.CHECKOUT,
+    "sessions": IntentKind.SESSIONS,
+    "save": IntentKind.SAVE,
+    "help": IntentKind.HELP,
+    "exit": IntentKind.EXIT,
+    "quit": IntentKind.EXIT,
+}
+
+# ---- natural-language command verbs (ordered; first match wins) ------------
+
+_NL_VERBS: tuple[tuple[IntentKind, tuple[str, ...]], ...] = (
+    (IntentKind.RECOMMEND, ("recommend", "suggest", "what should i", "which quant", "advise", "best strategy", "best way")),
+    (IntentKind.HARDWARE, ("my gpu", "my hardware", "what gpu", "hardware", "my card", "my vram")),
+    (IntentKind.PLAN, ("mixed precision", "precision plan", "make a plan", "build a plan", "plan it")),
+    (IntentKind.PROFILE, ("sensitivity", "profile the", "which layers", "sensitive layers")),
+    (IntentKind.BENCHMARK, ("benchmark", "measure speed", "how fast", "throughput test")),
+    (IntentKind.VERIFY, ("verify", "validate quality", "check quality", "how lossy")),
+    (IntentKind.COMPARE, ("compare", "side by side", "side-by-side")),
+    (IntentKind.QUANTIZE, ("quantize", "compress", "shrink the model", "make it smaller")),
+    (IntentKind.EXPORT, ("export", "write the report", "save the model")),
+    (IntentKind.INSPECT, ("inspect", "tell me about", "details about", "info on", "describe")),
+    (IntentKind.HISTORY, ("show history", "history")),
+    (IntentKind.UNDO, ("undo", "go back")),
+    (IntentKind.SESSIONS, ("list sessions", "my sessions")),
+)
+
+_LOAD_VERBS = ("load", "open", "use", "optimize", "model", "quantize", "compress")
+
+_MODEL_ID_RE = re.compile(r"\b([A-Za-z0-9][\w.\-]*/[\w.\-]+)\b")
+_GB_RE = re.compile(r"(\d+(?:\.\d+)?)\s*(gib|gb|g)\b")
+_PCT_RE = re.compile(r"(\d+(?:\.\d+)?)\s*%")
+
+_KNOWN_RUNTIMES = ("vllm", "transformers", "sglang", "tensorrt-llm", "tensorrt", "llama.cpp", "ollama", "tgi")
+
+_OBJECTIVE_KEYWORDS: dict[str, tuple[str, ...]] = {
+    "quality": ("quality", "accuracy", "accurate", "preserve", "lossless", "faithful", "precise", "minimal loss", "without losing", "keep quality"),
+    "speed": ("fastest", "faster", "speed", "throughput", "low latency", "latency", "quick", "tokens/sec", "tok/s", "high throughput"),
+    "memory": ("smallest", "as small as possible", "minimize memory", "tiniest", "most compact", "smallest footprint", "least vram"),
+    "balanced": ("balanced", "good balance", "trade off", "tradeoff"),
+}
+_OBJECTIVE_PRECEDENCE = ("quality", "speed", "memory", "balanced")
+
+
+def parse_goal(text: str) -> dict:
+    """Extract structured :class:`OptimizationGoal` updates from free text.
+
+    Returns only the keys it actually detected, so callers can merge with
+    ``goal.with_updates(**parse_goal(text))``.
+    """
+    t = text.lower()
+    out: dict = {}
+
+    m = _GB_RE.search(t)
+    if m:
+        val = float(m.group(1))
+        preceding = t[max(0, m.start() - 28) : m.start()]
+        if any(w in preceding for w in ("size", "disk", "file", "weights")):
+            out["max_model_size_gb"] = val
+        else:
+            out["max_vram_gb"] = val
+
+    for rt in _KNOWN_RUNTIMES:
+        if rt in t:
+            out["runtime"] = rt
+            break
+
+    pct = _PCT_RE.search(t)
+    if pct and any(w in t for w in ("loss", "degrad", "accuracy", "quality", "within", "perplexity", "drop")):
+        out["max_quality_loss"] = round(float(pct.group(1)) / 100.0, 4)
+
+    objective = _detect_objective(t)
+    if objective:
+        out["objective"] = objective
+
+    return out
+
+
+def _detect_objective(t: str) -> str | None:
+    scores = {
+        obj: sum(1 for kw in kws if kw in t) for obj, kws in _OBJECTIVE_KEYWORDS.items()
+    }
+    best = max(scores.values())
+    if best == 0:
+        return None
+    for obj in _OBJECTIVE_PRECEDENCE:  # deterministic tie-break
+        if scores[obj] == best:
+            return obj
+    return None
+
+
+def _detect_model_id(text: str) -> str | None:
+    m = _MODEL_ID_RE.search(text)
+    if m:
+        return m.group(1)
+    # local path heuristic
+    for token in text.split():
+        if token.startswith(("./", "~/", "../")) or "\\" in token:
+            return token
+    return None
+
+
+class IntentParser:
+    """Turn a raw input line into an :class:`Intent`."""
+
+    @staticmethod
+    def parse(text: str) -> Intent:
+        raw = text.strip()
+        if not raw:
+            return Intent(IntentKind.UNKNOWN, raw=raw)
+
+        if raw.startswith("/"):
+            return IntentParser._parse_slash(raw)
+        return IntentParser._parse_natural(raw)
+
+    # ---- slash --------------------------------------------------------------
+
+    @staticmethod
+    def _parse_slash(raw: str) -> Intent:
+        parts = raw[1:].split()
+        if not parts:
+            return Intent(IntentKind.UNKNOWN, raw=raw)
+        cmd = parts[0].lower()
+        rest = parts[1:]
+        rest_str = " ".join(rest)
+        kind = _SLASH.get(cmd)
+        if kind is None:
+            return Intent(IntentKind.UNKNOWN, args={"command": cmd}, raw=raw)
+
+        # /load is a session load when it names a saved session, but /model is the
+        # canonical way to load a model; treat bare "/load X" as model load only if
+        # X looks like a model id/path.
+        if cmd == "load":
+            if rest and _looks_like_model(rest_str):
+                return Intent(IntentKind.LOAD_MODEL, {"model_id": rest_str}, raw)
+            return Intent(IntentKind.LOAD_SESSION, {"name": rest_str}, raw)
+
+        if kind is IntentKind.LOAD_MODEL:
+            return Intent(kind, {"model_id": rest_str}, raw)
+        if kind is IntentKind.SET_GOAL:
+            return Intent(kind, {"goal_updates": parse_goal(rest_str)}, raw)
+        if kind is IntentKind.CHECKOUT:
+            return Intent(kind, {"index": _safe_int(rest_str)}, raw)
+        if kind is IntentKind.SAVE:
+            return Intent(kind, {"name": rest_str or None}, raw)
+        if kind is IntentKind.EXPORT:
+            return Intent(kind, {"path": rest_str or None}, raw)
+        if kind is IntentKind.QUANTIZE:
+            return Intent(kind, {"method": rest[0] if rest else None}, raw)
+        if kind is IntentKind.VERIFY:
+            args = {}
+            if len(rest) >= 1:
+                args["base"] = rest[0]
+            if len(rest) >= 2:
+                args["quant"] = rest[1]
+            return Intent(kind, args, raw)
+        if kind in (IntentKind.BENCHMARK, IntentKind.INSPECT):
+            return Intent(kind, {"target": rest_str or None}, raw)
+        return Intent(kind, raw=raw)
+
+    # ---- natural language ---------------------------------------------------
+
+    @staticmethod
+    def _parse_natural(raw: str) -> Intent:
+        t = raw.lower()
+
+        if t in ("exit", "quit", "q", ":q"):
+            return Intent(IntentKind.EXIT, raw=raw)
+        if t in ("help", "?", "commands"):
+            return Intent(IntentKind.HELP, raw=raw)
+
+        goal_updates = parse_goal(raw)
+        model_id = _detect_model_id(raw)
+        verb = IntentParser._detect_verb(t)
+
+        # explicit load ("load X", "use X", or a bare model id)
+        has_load_verb = any(re.search(rf"\b{v}\b", t) for v in _LOAD_VERBS)
+        if verb is None and model_id and (has_load_verb or _is_bare_id(raw)):
+            return Intent(IntentKind.LOAD_MODEL, {"model_id": model_id}, raw)
+
+        if verb is None:
+            if goal_updates:
+                return Intent(IntentKind.SET_GOAL, {"goal_updates": goal_updates}, raw)
+            return Intent(IntentKind.UNKNOWN, raw=raw)
+
+        args: dict = {}
+        if goal_updates:
+            args["goal_updates"] = goal_updates
+        if model_id and verb in (
+            IntentKind.INSPECT,
+            IntentKind.QUANTIZE,
+            IntentKind.BENCHMARK,
+            IntentKind.VERIFY,
+            IntentKind.RECOMMEND,
+        ):
+            args["target"] = model_id
+        return Intent(verb, args, raw)
+
+    @staticmethod
+    def _detect_verb(t: str) -> IntentKind | None:
+        for kind, keywords in _NL_VERBS:
+            if any(kw in t for kw in keywords):
+                return kind
+        return None
+
+
+def _looks_like_model(text: str) -> bool:
+    return bool(_MODEL_ID_RE.search(text)) or text.startswith((".", "~", "/")) or "\\" in text
+
+
+def _is_bare_id(text: str) -> bool:
+    """A message that is essentially just a model id (optionally 'load <id>')."""
+    tokens = text.split()
+    return len(tokens) <= 2 and _MODEL_ID_RE.search(text) is not None
+
+
+def _safe_int(text: str) -> int | None:
+    try:
+        return int(text.strip())
+    except (ValueError, AttributeError):
+        return None

zeroquantz/benchmark/__init__.py

@@ -0,0 +1,7 @@
+"""Benchmarking: measured VRAM, latency, throughput, size, and quality."""
+
+from __future__ import annotations
+
+from zeroquantz.benchmark.runner import BenchmarkResult, BenchmarkRunner
+
+__all__ = ["BenchmarkResult", "BenchmarkRunner"]

zeroquantz/benchmark/latency.py

@@ -0,0 +1,66 @@
+"""Latency and throughput measurement (torch/transformers, imported lazily)."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class LatencyStats:
+    latency_ms_mean: float
+    latency_ms_p50: float
+    tokens_per_sec: float
+    generated_tokens: int
+    runs: int
+
+
+def measure_generation_latency(
+    model: Any,
+    tokenizer: Any,
+    prompt: str,
+    *,
+    max_new_tokens: int = 64,
+    warmup: int = 2,
+    runs: int = 5,
+) -> LatencyStats:
+    """Time ``model.generate`` over ``runs`` iterations (after ``warmup``)."""
+    import torch
+
+    device = next(model.parameters()).device
+    inputs = tokenizer(prompt, return_tensors="pt").to(device)
+
+    def _one() -> tuple[float, int]:
+        torch.cuda.synchronize() if torch.cuda.is_available() else None
+        start = time.perf_counter()
+        with torch.no_grad():
+            out = model.generate(
+                **inputs, max_new_tokens=max_new_tokens, do_sample=False
+            )
+        torch.cuda.synchronize() if torch.cuda.is_available() else None
+        elapsed = time.perf_counter() - start
+        new_tokens = int(out.shape[-1] - inputs["input_ids"].shape[-1])
+        return elapsed, new_tokens
+
+    for _ in range(max(warmup, 0)):
+        _one()
+
+    times: list[float] = []
+    total_tokens = 0
+    for _ in range(max(runs, 1)):
+        elapsed, new_tokens = _one()
+        times.append(elapsed)
+        total_tokens += new_tokens
+
+    times.sort()
+    mean = sum(times) / len(times)
+    p50 = times[len(times) // 2]
+    tps = (total_tokens / sum(times)) if sum(times) > 0 else 0.0
+    return LatencyStats(
+        latency_ms_mean=round(mean * 1000, 2),
+        latency_ms_p50=round(p50 * 1000, 2),
+        tokens_per_sec=round(tps, 2),
+        generated_tokens=total_tokens,
+        runs=len(times),
+    )

zeroquantz/benchmark/memory.py

@@ -0,0 +1,41 @@
+"""Measured VRAM helpers (torch-backed, imported lazily)."""
+
+from __future__ import annotations
+
+from zeroquantz.utils import units
+
+
+def reset_peak_memory() -> None:
+    try:
+        import torch
+
+        if torch.cuda.is_available():
+            torch.cuda.reset_peak_memory_stats()
+            torch.cuda.empty_cache()
+    except Exception:  # pragma: no cover - torch/CUDA optional
+        pass
+
+
+def peak_vram_gb() -> float | None:
+    """Peak allocated VRAM since the last reset, in GiB, or None if unavailable."""
+    try:
+        import torch
+
+        if torch.cuda.is_available():
+            return round(units.bytes_to_gb(torch.cuda.max_memory_allocated()), 3)
+    except Exception:  # pragma: no cover
+        pass
+    return None
+
+
+def module_size_gb(module) -> float | None:  # noqa: ANN001
+    """On-device size of a live module's parameters + buffers, in GiB."""
+    try:
+        total = 0
+        for p in module.parameters():
+            total += p.numel() * p.element_size()
+        for b in module.buffers():
+            total += b.numel() * b.element_size()
+        return round(units.bytes_to_gb(total), 3)
+    except Exception:  # pragma: no cover
+        return None

zeroquantz/benchmark/quality.py

@@ -0,0 +1,38 @@
+"""Quality measurement: perplexity over calibration/eval text (lazy torch)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def measure_perplexity(
+    model: Any,
+    tokenizer: Any,
+    texts: list[str],
+    *,
+    max_length: int = 512,
+) -> float:
+    """Token-level perplexity of ``model`` over ``texts`` (teacher forcing)."""
+    import torch
+
+    device = next(model.parameters()).device
+    total_nll = 0.0
+    total_tokens = 0
+    with torch.no_grad():
+        for text in texts:
+            enc = tokenizer(
+                text, return_tensors="pt", truncation=True, max_length=max_length
+            ).to(device)
+            input_ids = enc["input_ids"]
+            if input_ids.shape[-1] < 2:
+                continue
+            out = model(**enc, labels=input_ids)
+            # HF returns mean NLL over tokens; weight by token count.
+            n_tokens = int(input_ids.shape[-1] - 1)
+            total_nll += float(out.loss) * n_tokens
+            total_tokens += n_tokens
+    if total_tokens == 0:
+        return float("nan")
+    import math
+
+    return float(math.exp(total_nll / total_tokens))

zeroquantz/benchmark/runner.py

@@ -0,0 +1,151 @@
+"""The common benchmark runner.
+
+Loads a model (base or quantized directory), measures peak VRAM, load time,
+generation latency, throughput, on-device size, and optional perplexity. Every
+result records the hardware + software environment it was produced on. All
+numbers here are *measured* (``measured=True``) — distinct from the planner's
+estimates.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, Field
+
+from zeroquantz.benchmark import latency as latency_mod
+from zeroquantz.benchmark import memory as memory_mod
+from zeroquantz.benchmark import quality as quality_mod
+from zeroquantz.core.exceptions import DependencyError, ZeroQuantzError
+from zeroquantz.utils import units
+from zeroquantz.utils.env import capture_environment
+from zeroquantz.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from zeroquantz.hardware.capabilities import HardwareProfile
+
+log = get_logger(__name__)
+
+
+class BenchmarkResult(BaseModel):
+    model_ref: str
+    measured: bool = True
+    peak_vram_gb: float | None = None
+    load_time_s: float | None = None
+    model_size_gb: float | None = None
+    latency_ms_mean: float | None = None
+    latency_ms_p50: float | None = None
+    tokens_per_sec: float | None = None
+    perplexity: float | None = None
+    num_prompts: int = 0
+    warmup: int = 0
+    runs: int = 0
+    max_new_tokens: int = 0
+    environment: dict = Field(default_factory=dict)
+    notes: list[str] = Field(default_factory=list)
+
+    def summary_rows(self) -> list[tuple[str, str]]:
+        def fmt(v: float | None, unit: str = "") -> str:
+            return f"{v:g}{unit}" if v is not None else "n/a"
+
+        return [
+            ("Peak VRAM", fmt(self.peak_vram_gb, " GB")),
+            ("Load time", fmt(self.load_time_s, " s")),
+            ("Model size", fmt(self.model_size_gb, " GB")),
+            ("Latency (mean)", fmt(self.latency_ms_mean, " ms")),
+            ("Throughput", fmt(self.tokens_per_sec, " tok/s")),
+            ("Perplexity", fmt(self.perplexity)),
+        ]
+
+
+class BenchmarkRunner:
+    """Load and benchmark a model end-to-end."""
+
+    @staticmethod
+    def run(
+        model_ref: str,
+        *,
+        prompts: list[str] | None = None,
+        eval_texts: list[str] | None = None,
+        warmup: int = 2,
+        runs: int = 5,
+        max_new_tokens: int = 64,
+        measure_quality: bool = False,
+        hardware: HardwareProfile | None = None,
+        progress: Callable[[str, float], None] | None = None,
+    ) -> BenchmarkResult:
+        try:
+            import torch
+            from transformers import AutoModelForCausalLM, AutoTokenizer
+        except ImportError as exc:
+            raise DependencyError.for_extra(
+                "transformers", "torch", purpose="benchmark a model"
+            ) from exc
+
+        prompts = prompts or ["Explain the theory of relativity in simple terms."]
+
+        if progress:
+            progress("Loading model", 0.05)
+        memory_mod.reset_peak_memory()
+        load_start = time.perf_counter()
+        try:
+            tokenizer = AutoTokenizer.from_pretrained(model_ref)
+            model = AutoModelForCausalLM.from_pretrained(model_ref, device_map="auto")
+            model.eval()
+        except Exception as exc:  # pragma: no cover - requires weights
+            raise ZeroQuantzError(
+                f"Could not load '{model_ref}' for benchmarking.",
+                detail=str(exc),
+                suggestions=["zeroquantz inspect " + model_ref, "check available VRAM"],
+            ) from exc
+        load_time = time.perf_counter() - load_start
+
+        if tokenizer.pad_token is None and tokenizer.eos_token is not None:
+            tokenizer.pad_token = tokenizer.eos_token
+
+        result = BenchmarkResult(
+            model_ref=model_ref,
+            num_prompts=len(prompts),
+            warmup=warmup,
+            runs=runs,
+            max_new_tokens=max_new_tokens,
+            load_time_s=round(load_time, 2),
+            model_size_gb=memory_mod.module_size_gb(model),
+            environment=capture_environment(hardware),
+        )
+
+        if progress:
+            progress("Measuring latency", 0.4)
+        try:
+            stats = latency_mod.measure_generation_latency(
+                model, tokenizer, prompts[0],
+                max_new_tokens=max_new_tokens, warmup=warmup, runs=runs,
+            )
+            result.latency_ms_mean = stats.latency_ms_mean
+            result.latency_ms_p50 = stats.latency_ms_p50
+            result.tokens_per_sec = stats.tokens_per_sec
+        except Exception as exc:  # pragma: no cover
+            result.notes.append(f"latency measurement failed: {exc}")
+
+        if measure_quality:
+            if progress:
+                progress("Measuring perplexity", 0.7)
+            try:
+                result.perplexity = round(
+                    quality_mod.measure_perplexity(model, tokenizer, eval_texts or prompts), 4
+                )
+            except Exception as exc:  # pragma: no cover
+                result.notes.append(f"perplexity measurement failed: {exc}")
+
+        result.peak_vram_gb = memory_mod.peak_vram_gb()
+        if progress:
+            progress("Benchmark complete", 1.0)
+        del model
+        try:
+            torch.cuda.empty_cache()
+        except Exception:
+            pass
+        return result

zeroquantz/cli/__init__.py

@@ -0,0 +1,7 @@
+"""Typer command-line interface and text REPL."""
+
+from __future__ import annotations
+
+from zeroquantz.cli.app import app, main
+
+__all__ = ["app", "main"]

zeroquantz/cli/app.py

@@ -0,0 +1,98 @@
+"""The ``zeroquantz`` Typer application.
+
+Running ``zeroquantz`` with no subcommand launches the interactive TUI (falling
+back to a text REPL when stdout is not a TTY). Subcommands provide the scriptable,
+non-interactive surface.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+import typer
+
+from zeroquantz import __version__
+from zeroquantz.utils.logging import configure_logging
+
+app = typer.Typer(
+    add_completion=False,
+    no_args_is_help=False,
+    rich_markup_mode="rich",
+    help="Interactive model optimization and quantization from your terminal.",
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"zeroquantz {__version__}")
+        raise typer.Exit()
+
+
+@app.callback(invoke_without_command=True)
+def _main(
+    ctx: typer.Context,
+    version: bool = typer.Option(
+        False, "--version", callback=_version_callback, is_eager=True, help="Show version and exit."
+    ),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose (INFO) console logging."),
+    debug: bool = typer.Option(False, "--debug", help="Debug (DEBUG) console logging."),
+    session: str | None = typer.Option(None, "--session", help="Use a named session."),
+    continue_last: bool = typer.Option(
+        False, "--continue", help="Resume the most recent session."
+    ),
+    no_tui: bool = typer.Option(False, "--no-tui", help="Use the plain text REPL instead of the TUI."),
+) -> None:
+    configure_logging("debug" if debug else ("verbose" if verbose else "quiet"))
+    if ctx.invoked_subcommand is not None:
+        return
+    _launch_interactive(session=session, continue_last=continue_last, no_tui=no_tui)
+
+
+def _launch_interactive(*, session: str | None, continue_last: bool, no_tui: bool) -> None:
+    use_tui = (not no_tui) and sys.stdout.isatty() and sys.stdin.isatty()
+    if use_tui:
+        try:
+            from zeroquantz.tui.app import run_tui
+
+            run_tui(session_name=session, continue_last=continue_last)
+            return
+        except Exception as exc:  # pragma: no cover - environment dependent
+            typer.echo(f"(TUI unavailable: {exc}; falling back to text mode)\n")
+    from zeroquantz.cli.interactive import run_repl
+
+    run_repl(session_name=session, continue_last=continue_last)
+
+
+# Register subcommands.
+from zeroquantz.cli import commands as _commands  # noqa: E402
+
+_commands.register(app)
+
+
+def _setup_stdio() -> None:
+    """Make Unicode output reliable (Windows consoles default to cp1252)."""
+    os.environ.setdefault("HF_HUB_DISABLE_SYMLINKS_WARNING", "1")
+    os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+    # Opt into the Rust hf_transfer download accelerator when it's installed
+    # (safe no-op otherwise; never sets the flag without the package present).
+    from zeroquantz.utils.env import enable_fast_downloads
+
+    enable_fast_downloads()
+    import contextlib
+
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is not None:
+            with contextlib.suppress(Exception):  # pragma: no cover
+                reconfigure(encoding="utf-8")
+
+
+def main() -> None:
+    """Console-script entry point."""
+    _setup_stdio()
+    app()
+
+
+if __name__ == "__main__":
+    main()