wenyi-cli 1.4.2__py3-none-any.whl

wenyi_cli/commands/workflows.py

@@ -0,0 +1,393 @@
+"""Register workflows commands with an invocation context accessor."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+import typer
+from rich.progress import Progress
+from wenyi_core.config import PipelineConfig
+from wenyi_core.errors import WenyiError
+from wenyi_core.timing import load_timing
+
+from wenyi_cli.commands import presentation
+from wenyi_cli.commands import progress as progress_view
+
+from .context import ContextAccessor
+from .machine_output import MachineOutput
+from .validation import (
+    require_input_file,
+    resolve_output_format,
+)
+
+
+class TranslationMode(str, Enum):
+    standard = "standard"
+    best_of_three = "best_of_three"
+
+
+def register_workflows_commands(app: typer.Typer, context: ContextAccessor) -> None:
+    @app.command(rich_help_panel="Main workflow")
+    def parse(
+        input_path: str = typer.Argument(..., help="Source book to parse without AI"),
+    ) -> None:
+        """Parse source chapters and list the contents without AI initialization."""
+        from rich.table import Table
+        from wenyi_core.pipeline.prepare.input_preparation import (
+            locate_input_storage,
+            parse_document,
+        )
+        from wenyi_core.storage.file import FileStorage
+
+        console = context().console
+        try:
+            require_input_file(input_path, console=console)
+            config = context().load_config()
+            store, digest = locate_input_storage(input_path, config, FileStorage)
+            try:
+                with store.lock():
+                    document = parse_document(store, input_path, config, expected_sha256=digest)
+                table = Table("Chapter", "Title", "Paragraphs")
+                for chapter in document.chapters:
+                    table.add_row(
+                        str(chapter.index), chapter.title, str(len(chapter.text_segments))
+                    )
+                console.print(table)
+                console.print(f"State directory: {store.run_dir}", markup=False)
+                console.print("Source parsed. AI preparation has not been run by this command.")
+            finally:
+                store.close()
+        except (WenyiError, ImportError, OSError, ValueError, RuntimeError) as error:
+            console.print(f"[red]Error: {error}[/]")
+            raise typer.Exit(1) from None
+
+    def _translate_impl(
+        input_path: str,
+        *,
+        chapter: int | None = None,
+        fmt: str | None = None,
+        out: str | None = None,
+        polish: bool | None = None,
+        translation_mode: TranslationMode | None = None,
+        review: bool | None = None,
+        mono: bool | None = None,
+        bilingual: bool | None = None,
+        progress_json: str | None = None,
+        result_json: str | None = None,
+    ) -> None:
+        """Run translation and report expected input or configuration errors concisely."""
+        console = context().console
+        machine = None
+        try:
+            machine = MachineOutput(
+                progress_json,
+                result_json,
+                source=input_path,
+                config=context().config_path,
+                output=out,
+            )
+            machine.start()
+            _translate_impl_or_raise(
+                input_path,
+                chapter=chapter,
+                fmt=fmt,
+                out=out,
+                polish=polish,
+                translation_mode=translation_mode,
+                review=review,
+                mono=mono,
+                bilingual=bilingual,
+                machine=machine,
+            )
+        except typer.Exit:
+            raise
+        except (WenyiError, ImportError, OSError, ValueError, RuntimeError) as error:
+            console.print(f"[red]Error: {error}[/]")
+            raise typer.Exit(1) from None
+        finally:
+            # Includes cancellation and unexpected exceptions. Never leave a stale success
+            # receipt, and never replace the original error with a reporting failure.
+            if machine is not None and not machine.completed:
+                try:
+                    machine.failed()
+                except (OSError, WenyiError):
+                    console.print("[red]Could not publish the machine failure receipt.[/]")
+
+    def _translate_impl_or_raise(
+        input_path: str,
+        *,
+        chapter: int | None = None,
+        fmt: str | None = None,
+        out: str | None = None,
+        polish: bool | None = None,
+        translation_mode: TranslationMode | None = None,
+        review: bool | None = None,
+        mono: bool | None = None,
+        bilingual: bool | None = None,
+        machine: MachineOutput,
+    ) -> None:
+        """Run translation; let ``_translate_impl`` convert exceptions to CLI errors."""
+        console = context().console
+        from wenyi_core.pipeline.orchestrator import Orchestrator
+
+        fmt = resolve_output_format(input_path, fmt, console=console)
+        config = context().load_config()
+        pipeline_values = config.pipeline.model_dump()
+        if polish is not None:
+            pipeline_values["polish"] = polish
+        if translation_mode is not None:
+            pipeline_values["translation_mode"] = translation_mode.value
+        try:
+            config.pipeline = PipelineConfig.model_validate(pipeline_values)
+        except ValueError:
+            if (
+                pipeline_values["translation_mode"] == "best_of_three"
+                and not pipeline_values["polish"]
+            ):
+                raise ValueError(
+                    "best_of_three translation mode requires pipeline.polish=true; remove --no-polish"
+                ) from None
+            raise
+        if review is not None:
+            config.pipeline.review = review
+        if mono is not None:
+            config.output.mono = mono
+        if bilingual is not None:
+            config.output.bilingual = bilingual
+        if chapter is not None:
+            ignored: list[str] = []
+            if fmt not in {None, "epub"}:
+                ignored.append("--format")
+            if out is not None:
+                ignored.append("--out")
+            if review is not None:
+                ignored.append("--review/--no-review")
+            if mono is not None:
+                ignored.append("--mono/--no-mono")
+            if bilingual is not None:
+                ignored.append("--bilingual/--no-bilingual")
+            if ignored:
+                raise ValueError(
+                    "--chapter only translates and saves the selected chapter; incompatible finalization options: "
+                    + ", ".join(ignored)
+                )
+
+        if chapter is not None:
+            config.pipeline.review = False
+        context().validate_api_configuration(config, "translate")
+        require_input_file(input_path, console=console)
+        orch = Orchestrator(config, allow_terminology_context=True)
+
+        with (
+            orch.client.interrupt_scope(),
+            Progress(
+                *progress_view.progress_columns(),
+                console=console,
+            ) as prog,
+        ):
+            rich_progress = progress_view.RichProgressBridge(prog, "Preparing…")
+
+            def cb(done: int, total: int, label: str) -> None:
+                rich_progress(done, total, label)
+                machine(done, total, label)
+
+            if chapter is not None:
+                try:
+                    store = orch.run(input_path, only_chapter=chapter, progress=cb)
+                except ValueError as error:
+                    console.print(f"[red]{error}[/]")
+                    raise typer.Exit(2) from error
+                console.print(
+                    f"[green]Translated chapter {chapter}[/], State directory: {store.run_dir}"
+                )
+                presentation.print_usage(console, store.load_usage() or {})
+                presentation.print_timing(console, load_timing(store.run_dir))
+                machine.success([], store.run_dir)
+                return
+
+            result = orch.run_all(
+                input_path,
+                progress=cb,
+                out_format=fmt,
+                out_path=out,
+            )
+
+        store = result["store"]
+        with store.lock(), store.state_lock():
+            chapters = store.load_manifest()["chapters"]
+            chapters_done = sum(chapter["status"] == "done" for chapter in chapters)
+            term_count = store.stats()["terms"]
+        presentation.print_translation_summary(
+            console,
+            chapters_done=chapters_done,
+            chapters_total=len(chapters),
+            terms=term_count,
+        )
+        presentation.print_usage(console, store.load_usage() or {})
+        presentation.print_timing(console, load_timing(store.run_dir))
+        for path in result.get("outputs") or [result["output"]]:
+            console.print(f"Translation: [bold]{path}[/]")
+        if result.get("review_dir"):
+            presentation.print_review_details(
+                console, result.get("review_result"), result["review_dir"]
+            )
+        machine.success(result.get("outputs") or [result["output"]], store.run_dir)
+
+    def _prepare_impl(input_path: str) -> None:
+        """Complete preparation without translating body text or exporting files."""
+        console = context().console
+        from wenyi_core.pipeline.orchestrator import Orchestrator
+
+        try:
+            config = context().load_config()
+            context().validate_api_configuration(config, "prepare")
+            require_input_file(input_path, console=console)
+            orch = Orchestrator(config, allow_terminology_context=True)
+            with (
+                orch.client.interrupt_scope(),
+                Progress(
+                    *progress_view.progress_columns(),
+                    console=console,
+                ) as prog,
+            ):
+                cb = progress_view.RichProgressBridge(prog, "Preparing…")
+                store = orch.prepare_for_translation(input_path, progress=cb)
+        except typer.Exit:
+            raise
+        except (WenyiError, ImportError, OSError, ValueError, RuntimeError) as error:
+            console.print(f"[red]Error: {error}[/]")
+            raise typer.Exit(1) from None
+
+        manifest = store.load_manifest()
+        chapters = manifest.get("chapters", [])
+        analysis = store.load_analysis() or {}
+        digests = sum(
+            bool(store.load_chapter(item["index"]).meta.get("source_digest")) for item in chapters
+        )
+        presentation.print_preparation_summary(
+            console,
+            chapter_count=len(chapters),
+            digest_count=digests,
+            has_synopsis=bool(analysis.get("book_synopsis")),
+            run_dir=store.run_dir,
+        )
+        presentation.print_usage(console, store.load_usage() or {})
+        presentation.print_timing(console, load_timing(store.run_dir))
+
+    @app.command(rich_help_panel="Main workflow")
+    def translate(
+        input: str = typer.Argument(
+            ...,
+            help="Book to translate (EPUB / FB2 / TXT / Markdown / HTML / PDF / DOCX)",
+        ),
+        chapter: int | None = typer.Option(
+            None,
+            "--chapter",
+            min=0,
+            help="Translate and save one chapter (zero-based); skip review and export",
+        ),
+        fmt: str | None = typer.Option(
+            None,
+            "--format",
+            help="Output format: epub / txt / html / markdown / docx / pdf (BabelDOC only); default: pdf for BabelDOC PDF state, docx for .docx input, epub otherwise",
+        ),
+        out: str | None = typer.Option(
+            None,
+            "--out",
+            help="Monolingual output path; defaults to the output directory beside the source",
+        ),
+        polish: bool | None = typer.Option(
+            None,
+            "--polish/--no-polish",
+            help="Override pipeline.polish to enable or disable polishing",
+        ),
+        translation_mode: TranslationMode | None = typer.Option(
+            None,
+            "--translation-mode",
+            help="Book translation mode; best_of_three requires polishing",
+        ),
+        review: bool | None = typer.Option(
+            None,
+            "--review/--no-review",
+            help="Override pipeline.review to enable or disable final whole-book review",
+        ),
+        mono: bool | None = typer.Option(
+            None,
+            "--mono/--no-mono",
+            help="Override output.mono to enable or disable monolingual output",
+        ),
+        bilingual: bool | None = typer.Option(
+            None,
+            "--bilingual/--no-bilingual",
+            help="Override output.bilingual to enable or disable bilingual output",
+        ),
+        progress_json: str | None = typer.Option(
+            None, "--progress-json", help="Atomically publish protocol-1 progress JSON"
+        ),
+        result_json: str | None = typer.Option(
+            None, "--result-json", help="Atomically publish a protocol-1 output receipt"
+        ),
+    ):
+        """Prepare, translate, optionally review and export. Repeat to resume."""
+        _translate_impl(
+            input,
+            chapter=chapter,
+            fmt=fmt,
+            out=out,
+            polish=polish,
+            translation_mode=translation_mode,
+            review=review,
+            mono=mono,
+            bilingual=bilingual,
+            progress_json=progress_json,
+            result_json=result_json,
+        )
+
+    @app.command(rich_help_panel="Main workflow")
+    def prepare(
+        input: str = typer.Argument(
+            ...,
+            help="Book to prepare (EPUB / FB2 / TXT / Markdown / HTML / PDF / DOCX)",
+        ),
+    ) -> None:
+        """Parse, detect language, analyze style and terms, and prescan the book."""
+        _prepare_impl(input)
+
+    @app.command(rich_help_panel="Quality checks")
+    def review(
+        input: str = typer.Argument(..., help="Source file whose entire body has been translated"),
+        autofix: bool | None = typer.Option(
+            None,
+            "--autofix/--no-autofix",
+            help="Override pipeline.review_autofix to publish revisions to formal chapters",
+        ),
+    ):
+        """Run evidence review, shadow revisions and blind rechecks, with optional autofix."""
+        console = context().console
+        from wenyi_core.pipeline.orchestrator import Orchestrator
+
+        try:
+            config = context().load_config()
+            if autofix is not None:
+                config.pipeline.review_autofix = autofix
+            context().validate_api_configuration(config, "review")
+            require_input_file(input, console=console)
+            orch = Orchestrator(config)
+
+            with (
+                orch.client.interrupt_scope(),
+                Progress(
+                    *progress_view.progress_columns(),
+                    console=console,
+                ) as prog,
+            ):
+                cb = progress_view.RichProgressBridge(prog, "Preparing whole-book review…")
+                result = orch.run_review(input, progress=cb)
+        except typer.Exit:
+            raise
+        except (WenyiError, ImportError, OSError, ValueError, RuntimeError) as error:
+            console.print(f"[red]Error: {error}[/]")
+            raise typer.Exit(1) from None
+
+        presentation.print_review_summary(console, result["review_result"], result["review_dir"])
+        presentation.print_timing(console, load_timing(result["store"].run_dir))

wenyi_cli/main.py

@@ -0,0 +1,5 @@
+"""Installed wenyi command entry point."""
+
+from .cli import app, main
+
+__all__ = ["app", "main"]

wenyi_cli/model_commands.py

@@ -0,0 +1,165 @@
+"""Model configuration previews and explicit migration commands."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from pathlib import Path
+
+import typer
+import yaml
+from rich.console import Console
+from rich.table import Table
+from wenyi_core.config import Config
+from wenyi_core.llm.operations import configured_operations, require_operation
+from wenyi_core.llm.routing import resolve_routes
+
+
+def register_model_commands(
+    app: typer.Typer, load_config: Callable[[], Config], console: Console
+) -> None:
+    """Register commands once; operation and provider details come from their registries."""
+    models = typer.Typer(
+        no_args_is_help=True, help="Inspect model routes and manage model settings."
+    )
+    app.add_typer(models, name="models", rich_help_panel="Configuration")
+
+    @models.command("list")
+    def list_models(
+        as_json: bool = typer.Option(False, "--json", help="Print structured routing data"),
+    ):
+        """Show all effective routes without credentials or network requests."""
+        config = load_config()
+        routes = resolve_routes(config.llm)
+        if as_json:
+            typer.echo(
+                json.dumps({key: value.describe() for key, value in routes.items()}, indent=2)
+            )
+            return
+        table = Table(
+            "Operation",
+            "Selection",
+            "Tier",
+            "Profile",
+            "Connection / adapter",
+            "Model",
+            "Output",
+            "Concurrency",
+        )
+        for operation, route in routes.items():
+            connection = config.llm.providers[route.provider]
+            table.add_row(
+                operation,
+                route.origin,
+                route.tier or "direct",
+                route.profile,
+                f"{route.provider} / {route.provider_kind}",
+                route.model,
+                str(route.max_output_tokens or "provider default"),
+                str(connection.max_concurrency or "unlimited"),
+            )
+        console.print(table)
+
+    @models.command("explain")
+    def explain(operation: str = typer.Option(..., "--operation")):
+        """Explain an operation's defaults, effective request and selection origin."""
+        try:
+            spec = require_operation(operation)
+            route = resolve_routes(load_config().llm)[operation]
+            typer.echo(json.dumps({"description": spec.description, **route.describe()}, indent=2))
+        except ValueError as error:
+            raise typer.BadParameter(str(error)) from None
+
+    @models.command("check")
+    def check(
+        workflow: str = typer.Option("translate", "--for", help="prepare, translate or review"),
+    ):
+        """Validate reachable credentials locally; never send a test request."""
+        try:
+            config = load_config()
+            operations = configured_operations(config, workflow)
+            # Imported here so ``--help`` never pays for the provider SDK.
+            from wenyi_core.llm.router import RoutedLLMClient
+
+            RoutedLLMClient(config.llm).validate_credentials(operations)
+            console.print(
+                f"Model configuration valid for {workflow}: {len(operations)} operations."
+            )
+        except (ValueError, RuntimeError) as error:
+            console.print(f"[red]Error: {error}[/]")
+            raise typer.Exit(1) from None
+
+    @models.command("ping")
+    def ping(
+        workflow: str = typer.Option("translate", "--for", help="prepare, translate or review"),
+        timeout: float = typer.Option(
+            30.0, "--timeout", min=0.1, help="Seconds to wait for each provider"
+        ),
+        as_json: bool = typer.Option(False, "--json", help="Print structured probe results"),
+    ):
+        """Send one short live request per reachable model profile; uses a few tokens."""
+        from wenyi_core.llm.connectivity import probe_connections
+
+        try:
+            config = load_config()
+            operations = configured_operations(config, workflow)
+            results = probe_connections(config.llm, operations, timeout=timeout)
+        except (ValueError, RuntimeError) as error:
+            console.print(f"[red]Error: {error}[/]")
+            raise typer.Exit(1) from None
+        if as_json:
+            typer.echo(json.dumps([result.describe() for result in results], indent=2))
+        else:
+            table = Table("Profile", "Connection / adapter", "Model", "Status", "Latency", "Detail")
+            for result in results:
+                table.add_row(
+                    result.profile,
+                    f"{result.connection} / {result.provider}",
+                    result.model,
+                    "[green]ok[/]" if result.ok else f"[red]{result.category}[/]",
+                    "-" if result.latency_ms is None else f"{result.latency_ms} ms",
+                    result.message,
+                )
+            console.print(table)
+        failed = sum(not result.ok for result in results)
+        if failed:
+            if not as_json:
+                console.print(f"[red]{failed} of {len(results)} model profiles unreachable.[/]")
+            raise typer.Exit(1)
+        if not as_json:
+            console.print(f"All {len(results)} model profiles reachable for {workflow}.")
+
+    @models.command("migrate-config")
+    def migrate_config(
+        source: Path = typer.Argument(..., exists=True, dir_okay=False),
+        out: Path = typer.Option(..., "--out", help="New YAML file; must not exist"),
+    ):
+        """Convert a retired configuration into a separate, reviewable YAML file."""
+        from wenyi_core.llm.migration import convert_config
+
+        try:
+            raw = yaml.safe_load(source.read_text(encoding="utf-8"))
+            if not isinstance(raw, dict):
+                raise ValueError("Configuration must be a mapping")
+            converted = convert_config(raw)
+            Config.from_dict(converted)
+            with out.open("x", encoding="utf-8") as file:
+                yaml.safe_dump(converted, file, allow_unicode=True, sort_keys=False)
+            console.print(f"Converted configuration: {out}")
+        except (OSError, ValueError, yaml.YAMLError) as error:
+            console.print(f"[red]Error: {error}[/]")
+            raise typer.Exit(1) from None
+
+    @models.command("migrate-usage")
+    def migrate_usage(run_dir: Path = typer.Argument(..., exists=True, file_okay=False)):
+        """Back up and convert usage ledgers in one selected target run directory."""
+        from wenyi_core.storage.file_migrations import migrate_usage_ledgers
+
+        try:
+            count = migrate_usage_ledgers(run_dir)
+            console.print(
+                f"Converted {count} usage ledgers; original files backed up alongside them."
+            )
+        except (OSError, ValueError) as error:
+            console.print(f"[red]Error: {error}[/]")
+            raise typer.Exit(1) from None

wenyi_cli-1.4.2.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.5
+Name: wenyi-cli
+Version: 1.4.2
+Summary: Local command-line interface for Wenyi's translation engine.
+Project-URL: Repository, https://github.com/BigDawnGhost/wenyi
+Project-URL: Documentation, https://github.com/BigDawnGhost/wenyi/blob/main/docs/cli.md
+Requires-Python: >=3.10
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.12
+Requires-Dist: wenyi-core
+Description-Content-Type: text/markdown
+
+# Wenyi CLI
+
+Local command-line application for multilingual long-form translation, powered
+by `wenyi-core`. It supports terminology management, contextual translation,
+polishing, whole-book review, resumable workflows, and multiple document formats.
+
+Install into an activated Python 3.10+ virtual environment:
+
+```bash
+uv pip install wenyi-cli
+wenyi --version
+wenyi --help
+```
+
+The executable is `wenyi`; the module entry point is `python -m wenyi_cli`.
+The translation engine is installed automatically. API keys are read from
+environment variables; do not put credentials in configuration files.
+
+PDF layout preservation additionally requires an independently installed
+`wenyi-babeldoc-bridge` HTTP service. This package does not install BabelDOC,
+the Web API, or the Desktop application.
+
+- [CLI guide](https://github.com/BigDawnGhost/wenyi/blob/main/docs/cli.md)
+- [Configuration](https://github.com/BigDawnGhost/wenyi/blob/main/docs/configuration.md)
+- [Source and license](https://github.com/BigDawnGhost/wenyi)
+- [简体中文](https://github.com/BigDawnGhost/wenyi/blob/main/docs/zh/cli.md)

wenyi_cli-1.4.2.dist-info/RECORD

@@ -0,0 +1,20 @@
+wenyi_cli/__init__.py,sha256=WOmaRQbKRo7QSfUoy-CGriiK5WrC8qmUkhVAk4XljXI,274
+wenyi_cli/__main__.py,sha256=vBQ82334kX06ImDbFlPFgiBRiLIinwNk3z8Khs6hd74,31
+wenyi_cli/cli.py,sha256=tKpOwEx-pMzf6F8diAoP935qx3fsZZ9y3E6xWmEiaNc,1552
+wenyi_cli/main.py,sha256=YphRUYMjqX4Mjw-Wu8r3XYQwA09DbtQ1xhgAA29WeNc,98
+wenyi_cli/model_commands.py,sha256=nmpO6R0e7aHPkfCsk40KOYIvWmJO7XIbsUMJQOncTrA,6955
+wenyi_cli/commands/__init__.py,sha256=f9cLnOA-FXA1RuQedQ37Y4u4XIk2Gj2tMEKAWBPdeMQ,62
+wenyi_cli/commands/bootstrap.py,sha256=v2RTEi8f-RCbCecaWT5QgdiUFmSpqUafmMBsx4aMunA,3697
+wenyi_cli/commands/context.py,sha256=a0QySybZDGVCVQA2AxNm_IHVPHEqP-1ooumJW7Qiw9E,1739
+wenyi_cli/commands/glossary.py,sha256=w7PpV0OUHmKvpFhFxXlnCgAVHe0Oommx-HvlxBkRr3Q,4265
+wenyi_cli/commands/inspection.py,sha256=by9C3p7LuYSAevaRapKQC_IvMFNCGHOBgkU1sLrbQDg,7415
+wenyi_cli/commands/machine_output.py,sha256=_BJ0G1QV_FsC7ZZ3uASkNYS-Jj4cx09zBnf4HDmmhEg,3519
+wenyi_cli/commands/presentation.py,sha256=um7irPa6f1Enk8UgONUbFj0vau8CjG8GfQkUFwUcq6M,5890
+wenyi_cli/commands/progress.py,sha256=5UnWFSZgljhvW0eut8BwnKY7yL_Qb9iMHP073B6191Y,3272
+wenyi_cli/commands/run_report.py,sha256=ZhLwG0cs-1-rpydylb7RuzRJ0rNe303yPJJq1fB6YOY,3820
+wenyi_cli/commands/validation.py,sha256=FRGfaVHf2MAxluluvVYKveV8ifVVGZiw81AKz-YEZos,3777
+wenyi_cli/commands/workflows.py,sha256=q8xGFIzh1KXRK02x-eMM10q2njxNQmgQdn8y1ISkx6U,15538
+wenyi_cli-1.4.2.dist-info/METADATA,sha256=R3ICtNpttA3j6UfDqOBJy02u7luMXKedRxaKwUlZLbQ,1519
+wenyi_cli-1.4.2.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+wenyi_cli-1.4.2.dist-info/entry_points.txt,sha256=UOuMOGDjQXGrG-03A1dxl2LWBWhdmOHjkqHrZs95m4c,46
+wenyi_cli-1.4.2.dist-info/RECORD,,

wenyi_cli-1.4.2.dist-info/WHEEL

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

wenyi_cli-1.4.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wenyi = wenyi_cli.main:main