gyomu-cli 0.4.0__tar.gz

gyomu_cli-0.4.0/.gitignore

@@ -0,0 +1,29 @@
+venv/
+.idea/
+
+/build/
+/dist/
+/src/gyomu.egg-info/
+/.coverage
+/htmlcov/
+__pycache__/
+*.py[cod]
+
+.env
+.env.*
+!.env.example
+
+.mypy_cache/
+.ruff_cache/
+htmlcov/
+*.egg-info/
+log/
+
+
+# gyomu ai related
+**/.gyomu/cache
+**/.gyomu/snapshot
+**/.gyomu/checkpoint
+
+# snapshot
+__snapshots__

gyomu_cli-0.4.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.5
+Name: gyomu-cli
+Version: 0.4.0
+Summary: Gyomu CLI
+Requires-Python: >=3.13
+Requires-Dist: gyomu-infra
+Requires-Dist: gyomu-schema
+Requires-Dist: gyomu-workflow
+Requires-Dist: returns
+Requires-Dist: typer>=0.27.2
+Description-Content-Type: text/markdown
+
+# gyomu-cli
+
+cli application for Gyomu Python.

gyomu_cli-0.4.0/README.md

@@ -0,0 +1,3 @@
+# gyomu-cli
+
+cli application for Gyomu Python.

gyomu_cli-0.4.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "gyomu-cli"
+dynamic = ["version"]
+description = "Gyomu CLI"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "gyomu-schema",
+    "gyomu-infra",
+    "returns",
+    "gyomu-workflow",
+    "typer>=0.27.2",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[tool.uv.sources]
+gyomu-schema = { workspace = true }
+gyomu-infra = { workspace = true }
+gyomu-workflow = { workspace = true }
+
+[tool.hatch.version]
+path = "../../version/__about__.py"
+
+[project.scripts]
+gyomu = "gyomu_cli.main:app"

gyomu_cli-0.4.0/src/gyomu_cli/main.py

@@ -0,0 +1,119 @@
+import asyncio
+
+import typer
+from gyomu_ai.provider.pydantic_ai.google import (
+    create_default_pydantic_ai_model_registry,
+)
+from gyomu_ai.provider.pydantic_ai.route_registry import AiConfiguration, initialize_ai
+from gyomu_ai.provider.pydantic_ai.routing import (
+    ModelRoute,
+    ModelRouteId,
+    ModelRoutes,
+    RouteNode,
+)
+from gyomu_ai_compiler.pipelines.docstring_update import DocstringRouteId
+from gyomu_infra.logger import logger
+from gyomu_schema.option.retry import RetryObserver
+from gyomu_workflow.snapshot.models import (
+    DocstringExecutionOption,
+    FileFilter,
+    SnapshotActionOption,
+    SnapshotExecutionOption,
+    SnapshotTargetOption,
+)
+from gyomu_workflow.snapshot.run import run_snapshot
+from gyomu_workflow.snapshot.translate import translate_snapshot_request
+from gyomu_workflow.snapshot.validate import validate_snapshot_request
+from returns.result import Failure
+
+app = typer.Typer()
+
+hello_app = typer.Typer()
+app.add_typer(hello_app, name="hello")
+
+
+# @hello_app.command()
+@app.command()
+def greet(name: str = "World") -> None:
+    print(f"Hello, {name}!")
+
+
+@app.command()
+def greet2(name: str = "World") -> None:
+    print(f"Hello, {name}!")
+
+
+@hello_app.command("greet")
+def greet3(name: str = "World") -> None:
+    print(f"Hello, {name}!")
+
+
+def register_google_routing(
+    route_id_list: list[ModelRouteId],
+    retry_observer: RetryObserver | None = None,
+) -> None:
+    route: RouteNode = RouteNode(registry=create_default_pydantic_ai_model_registry())
+    routes: dict[ModelRouteId, ModelRoute] = {}
+    for route_id in route_id_list:
+        routes[route_id] = ModelRoute((route,))
+    initialize_ai(
+        AiConfiguration(
+            model_routes=ModelRoutes(routes=routes), retry_observer=retry_observer
+        )
+    )
+
+
+@app.command()
+def snapshot(
+    package: str,
+    docstring: bool = True,
+    all: bool = False,
+    commit: bool = True,
+    filter: str | None = None,
+    log_keyword: str | None = None,
+) -> None:
+    register_google_routing(route_id_list=[DocstringRouteId])
+    option = SnapshotExecutionOption(
+        commit=commit,
+        target=SnapshotTargetOption(
+            all=all,
+            file_filter=FileFilter(pattern=filter) if filter is not None else None,
+        ),
+        action=SnapshotActionOption(
+            docstring=DocstringExecutionOption(
+                enabled=docstring, log_keyword=log_keyword
+            ),
+        ),
+    )
+    request_result = translate_snapshot_request(package, option)
+    if isinstance(request_result, Failure):
+        logger.error_object(request_result.failure())
+        return
+    request = request_result.unwrap()
+    logger.info(
+        f"commit: {request.option.commit}, "
+        f"docstring:{request.option.action.docstring.enabled}, "
+        f"all={request.option.target.all}"
+    )
+    if filter:
+        assert option.target.file_filter
+        logger.info(f"filter: {option.target.file_filter.pattern}")
+    if log_keyword:
+        logger.info(f"log_keyword: {request.option.action.docstring.log_keyword}")
+
+    validation_result = validate_snapshot_request(request)
+    if isinstance(validation_result, Failure):
+        logger.error_object(validation_result.failure())
+        return
+
+    snapshot_result = asyncio.run(run_snapshot(request))
+    if isinstance(snapshot_result, Failure):
+        logger.error_object(snapshot_result.failure())
+        return
+
+    logger.info("Done")
+    # logger.error_object(request.unwrap(), 3)
+
+
+if __name__ == "__main__":
+    app()

gyomu_cli-0.4.0/tests/integration/test_snapshot.py

@@ -0,0 +1,186 @@
+from pathlib import Path
+
+import pytest
+from gyomu_cli.main import app
+from gyomu_python_analysis.project.context import ProjectContext
+from gyomu_schema.error.gyomu import GyomuError
+from gyomu_schema.schemas.types import FullPath
+from gyomu_workflow.snapshot.models import (
+    DocstringExecutionOption,
+    SnapshotActionOption,
+    SnapshotExecutionOption,
+    SnapshotRequest,
+    SnapshotTargetOption,
+)
+from pytest_mock import MockerFixture
+from returns.result import Failure, Success
+from typer.testing import CliRunner
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def snapshot_request(mocker: MockerFixture) -> SnapshotRequest:
+    return SnapshotRequest(
+        repository_root_path=FullPath(Path("/tmp")),
+        project_context=mocker.Mock(spec=ProjectContext),
+        option=SnapshotExecutionOption(
+            commit=True,
+            action=SnapshotActionOption(
+                docstring=DocstringExecutionOption(enabled=True),
+            ),
+            target=SnapshotTargetOption(),
+        ),
+    )
+
+
+def test_snapshot_success(mocker: MockerFixture, snapshot_request: SnapshotRequest):
+    mocker.patch(
+        "gyomu_cli.main.register_google_routing",
+        return_value=None,
+    )
+    mocker.patch(
+        "gyomu_cli.main.translate_snapshot_request",
+        return_value=Success(snapshot_request),
+    )
+    mocker.patch(
+        "gyomu_cli.main.validate_snapshot_request",
+        return_value=Success(None),
+    )
+    run_snapshot = mocker.patch(
+        "gyomu_cli.main.run_snapshot",
+        return_value=Success(None),
+    )
+
+    result = runner.invoke(
+        app,
+        [
+            "snapshot",
+            "test-package",
+            "--docstring",
+            "--all",
+            "--commit",
+            "--log-keyword",
+            "test",
+        ],
+    )
+
+    assert result.exit_code == 0
+
+    run_snapshot.assert_awaited_once_with(snapshot_request)
+
+
+def test_snapshot_translate_failure(
+    mocker: MockerFixture,
+):
+
+    error = GyomuError(
+        message="translate failed",
+        domain="test",
+        operation="translate",
+        reason="invalid_input",
+    )
+
+    mocker.patch(
+        "gyomu_cli.main.register_google_routing",
+        return_value=None,
+    )
+    mocker.patch(
+        "gyomu_cli.main.translate_snapshot_request",
+        return_value=Failure(error),
+    )
+    validate_snapshot_request = mocker.patch(
+        "gyomu_cli.main.validate_snapshot_request",
+    )
+    run_snapshot = mocker.patch(
+        "gyomu_cli.main.run_snapshot",
+    )
+
+    result = runner.invoke(
+        app,
+        [
+            "snapshot",
+            "test-package",
+        ],
+    )
+
+    assert result.exit_code == 0
+
+    validate_snapshot_request.assert_not_called()
+    run_snapshot.assert_not_called()
+
+
+def test_snapshot_validation_failure(
+    mocker: MockerFixture, snapshot_request: SnapshotRequest
+):
+
+    error = GyomuError(
+        message="validation failed",
+        domain="test",
+        operation="validate",
+        reason="invalid_input",
+    )
+
+    mocker.patch(
+        "gyomu_cli.main.register_google_routing",
+        return_value=None,
+    )
+    mocker.patch(
+        "gyomu_cli.main.translate_snapshot_request",
+        return_value=Success(snapshot_request),
+    )
+    mocker.patch(
+        "gyomu_cli.main.validate_snapshot_request",
+        return_value=Failure(error),
+    )
+    run_snapshot = mocker.patch(
+        "gyomu_cli.main.run_snapshot",
+    )
+
+    result = runner.invoke(
+        app,
+        [
+            "snapshot",
+            "test-package",
+        ],
+    )
+
+    assert result.exit_code == 0
+
+    run_snapshot.assert_not_called()
+
+
+def test_snapshot_run_failure(mocker: MockerFixture, snapshot_request: SnapshotRequest):
+
+    error = GyomuError(
+        message="run failed",
+        domain="test",
+        operation="run",
+        reason="invalid_input",
+    )
+    mocker.patch(
+        "gyomu_cli.main.register_google_routing",
+        return_value=None,
+    )
+    mocker.patch(
+        "gyomu_cli.main.translate_snapshot_request",
+        return_value=Success(snapshot_request),
+    )
+    mocker.patch(
+        "gyomu_cli.main.validate_snapshot_request",
+        return_value=Success(None),
+    )
+    mocker.patch(
+        "gyomu_cli.main.run_snapshot",
+        return_value=Failure(error),
+    )
+
+    result = runner.invoke(
+        app,
+        [
+            "snapshot",
+            "test-package",
+        ],
+    )
+
+    assert result.exit_code == 0