codepot-gen 0.1.0__tar.gz

codepot_gen-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: codepot-gen
+Version: 0.1.0
+Summary: General OpenAPI inference and multi-language code generation engine
+Author: Codepot
+Keywords: openapi,codegen,generator,typescript,dart
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12.5
+Requires-Dist: rich>=13.9.0
+Requires-Dist: questionary>=2.0.0
+Requires-Dist: pydantic>=2.8.0
+Requires-Dist: pydantic-settings>=2.4.0
+Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: jinja2>=3.1.4
+Requires-Dist: pluralizer>=2.0.0
+
+Codepot Gen
+===========
+
+OpenAPI inference and template-driven code generation for TypeScript, Dart, and
+debug output.
+
+Installation
+------------
+
+```bash
+pip install codepot-gen
+```
+
+CLI Usage
+---------
+
+```bash
+codepot-gen emit \
+  --input openapi.yaml \
+  --language typescript \
+  --output ./generated
+```
+
+Short aliases are also installed:
+
+```bash
+apigen --help
+codepot --help
+```
+
+Bundled templates are included in the package. You can still override them:
+
+```bash
+codepot-gen emit \
+  --input openapi.yaml \
+  --language dart \
+  --output ./sdk \
+  --templates ./templates/dart
+```
+
+Python Usage
+------------
+
+```python
+from codepot_gen import GeneratorApp
+
+app = GeneratorApp()
+```
+
+Build And Publish
+-----------------
+
+Install build tools:
+
+```bash
+python -m pip install build twine
+```
+
+Build locally:
+
+```bash
+python -m build
+```
+
+Check the package:
+
+```bash
+python -m twine check dist/*
+```
+
+Publish to TestPyPI first:
+
+```bash
+python -m twine upload --repository testpypi dist/*
+```
+
+Publish to PyPI:
+
+```bash
+python -m twine upload dist/*
+```

codepot_gen-0.1.0/README.md

@@ -0,0 +1,81 @@
+Codepot Gen
+===========
+
+OpenAPI inference and template-driven code generation for TypeScript, Dart, and
+debug output.
+
+Installation
+------------
+
+```bash
+pip install codepot-gen
+```
+
+CLI Usage
+---------
+
+```bash
+codepot-gen emit \
+  --input openapi.yaml \
+  --language typescript \
+  --output ./generated
+```
+
+Short aliases are also installed:
+
+```bash
+apigen --help
+codepot --help
+```
+
+Bundled templates are included in the package. You can still override them:
+
+```bash
+codepot-gen emit \
+  --input openapi.yaml \
+  --language dart \
+  --output ./sdk \
+  --templates ./templates/dart
+```
+
+Python Usage
+------------
+
+```python
+from codepot_gen import GeneratorApp
+
+app = GeneratorApp()
+```
+
+Build And Publish
+-----------------
+
+Install build tools:
+
+```bash
+python -m pip install build twine
+```
+
+Build locally:
+
+```bash
+python -m build
+```
+
+Check the package:
+
+```bash
+python -m twine check dist/*
+```
+
+Publish to TestPyPI first:
+
+```bash
+python -m twine upload --repository testpypi dist/*
+```
+
+Publish to PyPI:
+
+```bash
+python -m twine upload dist/*
+```

codepot_gen-0.1.0/cli/__init__.py

@@ -0,0 +1,7 @@
+"""
+Command-line interface package.
+
+This package provides the CLI entry point, argument parsing, and command definitions
+for the generator. It orchestrates the runtime application but does not contain
+core generator logic.
+"""

codepot_gen-0.1.0/cli/bootstrap.py

@@ -0,0 +1,24 @@
+"""CLI import bootstrap.
+
+This keeps `python -m cli.main` working during local development when the
+engine packages live under src/ and the CLI package lives at repository root.
+Installed console scripts do not depend on this being special.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def ensure_src_on_path() -> None:
+    """Add the src directory to sys.path when running the CLI from source."""
+    project_root = Path(__file__).resolve().parents[1]
+    src_path = project_root / "src"
+
+    if not src_path.exists():
+        return
+
+    src_text = str(src_path)
+    if src_text not in sys.path:
+        sys.path.insert(0, src_text)

codepot_gen-0.1.0/cli/commands/__init__.py

@@ -0,0 +1,6 @@
+"""
+CLI command definitions package.
+
+This package contains the individual command implementations for inspect, infer, emit,
+and validate operations. Each command maps to a runtime application method.
+"""

codepot_gen-0.1.0/cli/commands/emit.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from cli.constants.constants import (
+    HELP_DEBUG,
+    HELP_DRY_RUN,
+    HELP_INPUT,
+    HELP_INTERACTIVE,
+    HELP_LANGUAGE,
+    HELP_OUTPUT,
+    HELP_QUIET,
+    HELP_TEMPLATES_PATH,
+    HELP_VERBOSE,
+    OPT_DEBUG,
+    OPT_DRY_RUN,
+    OPT_INPUT,
+    OPT_INTERACTIVE,
+    OPT_LANGUAGE,
+    OPT_OUTPUT,
+    OPT_QUIET,
+    OPT_TEMPLATES,
+    OPT_VERBOSE,
+)
+from cli.presentation.core.console import print_error, print_header
+from cli.presentation.core.interactive import (
+    ask_dry_run,
+    ask_input_path,
+    ask_language,
+    ask_output_path,
+    ask_templates_path,
+    should_prompt,
+)
+from cli.paths import normalize_cli_path
+from cli.presentation.emit.renderer import render_emit_result
+
+
+def emit_command(
+    ctx: typer.Context,
+    input_file: Path | None = typer.Option(
+        None,
+        f"--{OPT_INPUT}",
+        "-i",
+        help=HELP_INPUT,
+        exists=False,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+    ),
+    language: str | None = typer.Option(
+        None,
+        f"--{OPT_LANGUAGE}",
+        "-l",
+        help=HELP_LANGUAGE,
+    ),
+    output: Path | None = typer.Option(
+        None,
+        f"--{OPT_OUTPUT}",
+        "-o",
+        help=HELP_OUTPUT,
+    ),
+    templates_path: Path | None = typer.Option(
+        None,
+        f"--{OPT_TEMPLATES}",
+        "-t",
+        help=HELP_TEMPLATES_PATH,
+    ),
+    dry_run: bool = typer.Option(False, f"--{OPT_DRY_RUN}", help=HELP_DRY_RUN),
+    interactive: bool = typer.Option(
+        False,
+        f"--{OPT_INTERACTIVE}",
+        "-I",
+        help=HELP_INTERACTIVE,
+    ),
+    debug: bool = typer.Option(False, f"--{OPT_DEBUG}", help=HELP_DEBUG),
+    verbose: bool = typer.Option(False, f"--{OPT_VERBOSE}", "-v", help=HELP_VERBOSE),
+    quiet: bool = typer.Option(False, f"--{OPT_QUIET}", "-q", help=HELP_QUIET),
+) -> None:
+    """Emit output for a target language."""
+    try:
+        from cli.main import get_runtime
+
+        resolved_input = input_file
+        resolved_language = language
+        resolved_output = output
+        resolved_templates_path = templates_path
+        resolved_dry_run = dry_run
+
+        prompt = should_prompt(interactive)
+
+        if resolved_input is None and prompt:
+            resolved_input = ask_input_path()
+
+        if resolved_language is None and prompt:
+            resolved_language = ask_language()
+
+        if resolved_output is None and prompt:
+            resolved_output = ask_output_path()
+
+        if resolved_templates_path is None and interactive:
+            resolved_templates_path = ask_templates_path()
+
+        if not dry_run and interactive:
+            resolved_dry_run = ask_dry_run()
+
+        if resolved_input is None:
+            raise ValueError("missing required option: --input")
+        if resolved_language is None:
+            raise ValueError("missing required option: --language")
+        if resolved_output is None:
+            raise ValueError("missing required option: --output")
+
+        resolved_input = normalize_cli_path(resolved_input)
+        resolved_output = normalize_cli_path(resolved_output)
+        resolved_templates_path = normalize_cli_path(resolved_templates_path)
+
+        if not quiet:
+            print_header("Emit", f"{resolved_language} -> {resolved_output}")
+
+        runtime = get_runtime(ctx)
+        result = runtime.emit(
+            input_path=resolved_input,
+            language=resolved_language,
+            output_path=resolved_output,
+            dry_run=resolved_dry_run,
+            templates_path=resolved_templates_path,
+        )
+
+        if not quiet:
+            render_emit_result(result, verbose=verbose)
+
+    except Exception as exc:
+        print_error(str(exc))
+        if debug:
+            raise
+        raise typer.Exit(1) from exc

codepot_gen-0.1.0/cli/commands/infer.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from cli.constants.constants import (
+    HELP_DEBUG,
+    HELP_INPUT,
+    HELP_INTERACTIVE,
+    HELP_OUTPUT_INFERENCE,
+    HELP_QUIET,
+    HELP_VERBOSE,
+    OPT_DEBUG,
+    OPT_INPUT,
+    OPT_INTERACTIVE,
+    OPT_OUTPUT,
+    OPT_QUIET,
+    OPT_VERBOSE,
+)
+from cli.presentation.core.console import print_error, print_header
+from cli.presentation.core.interactive import (
+    ask_input_path,
+    ask_optional_output_path,
+    should_prompt,
+)
+from cli.presentation.infer.renderer import render_infer_result
+
+
+def infer_command(
+    ctx: typer.Context,
+    input_file: Path | None = typer.Option(
+        None,
+        f"--{OPT_INPUT}",
+        "-i",
+        help=HELP_INPUT,
+        exists=False,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+    ),
+    output: Path | None = typer.Option(
+        None,
+        f"--{OPT_OUTPUT}",
+        "-o",
+        help=HELP_OUTPUT_INFERENCE,
+    ),
+    interactive: bool = typer.Option(
+        False,
+        f"--{OPT_INTERACTIVE}",
+        "-I",
+        help=HELP_INTERACTIVE,
+    ),
+    debug: bool = typer.Option(False, f"--{OPT_DEBUG}", help=HELP_DEBUG),
+    verbose: bool = typer.Option(False, f"--{OPT_VERBOSE}", "-v", help=HELP_VERBOSE),
+    quiet: bool = typer.Option(False, f"--{OPT_QUIET}", "-q", help=HELP_QUIET),
+) -> None:
+    """Run OpenAPI inference."""
+    try:
+        from cli.main import get_runtime
+
+        resolved_input = input_file
+        resolved_output = output
+
+        prompt = should_prompt(interactive)
+
+        if resolved_input is None and prompt:
+            resolved_input = ask_input_path()
+
+        if resolved_output is None and interactive:
+            resolved_output = ask_optional_output_path()
+
+        if resolved_input is None:
+            raise ValueError("missing required option: --input")
+
+        if not quiet:
+            print_header("Infer", str(resolved_input))
+
+        runtime = get_runtime(ctx)
+        result = runtime.infer(
+            input_path=resolved_input,
+            output_path=resolved_output,
+        )
+
+        if not quiet:
+            render_infer_result(result, verbose=verbose)
+
+    except Exception as exc:
+        print_error(str(exc))
+        if debug:
+            raise
+        raise typer.Exit(1) from exc

codepot_gen-0.1.0/cli/commands/inspect.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from cli.constants.constants import (
+    HELP_DEBUG,
+    HELP_INPUT,
+    HELP_INTERACTIVE,
+    HELP_QUIET,
+    HELP_VERBOSE,
+    OPT_DEBUG,
+    OPT_INPUT,
+    OPT_INTERACTIVE,
+    OPT_QUIET,
+    OPT_VERBOSE,
+)
+from cli.presentation.core.console import print_error, print_header
+from cli.presentation.core.interactive import ask_input_path, should_prompt
+from cli.presentation.inspect.renderer import render_inspect_result
+
+
+def inspect_command(
+    ctx: typer.Context,
+    input_file: Path | None = typer.Option(
+        None,
+        f"--{OPT_INPUT}",
+        "-i",
+        help=HELP_INPUT,
+        exists=False,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+    ),
+    interactive: bool = typer.Option(
+        False,
+        f"--{OPT_INTERACTIVE}",
+        "-I",
+        help=HELP_INTERACTIVE,
+    ),
+    debug: bool = typer.Option(False, f"--{OPT_DEBUG}", help=HELP_DEBUG),
+    verbose: bool = typer.Option(False, f"--{OPT_VERBOSE}", "-v", help=HELP_VERBOSE),
+    quiet: bool = typer.Option(False, f"--{OPT_QUIET}", "-q", help=HELP_QUIET),
+) -> None:
+    """Inspect an OpenAPI document."""
+    try:
+        from cli.main import get_runtime
+
+        resolved_input = input_file
+
+        prompt = should_prompt(interactive)
+
+        if resolved_input is None and prompt:
+            resolved_input = ask_input_path()
+
+        if resolved_input is None:
+            raise ValueError("missing required option: --input")
+
+        if not quiet:
+            print_header("Inspect", str(resolved_input))
+
+        runtime = get_runtime(ctx)
+        result = runtime.inspect(input_path=resolved_input)
+
+        if not quiet:
+            render_inspect_result(result, verbose=verbose)
+
+    except Exception as exc:
+        print_error(str(exc))
+        if debug:
+            raise
+        raise typer.Exit(1) from exc

codepot_gen-0.1.0/cli/commands/validate.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from cli.constants.constants import (
+    HELP_DEBUG,
+    HELP_INPUT,
+    HELP_INTERACTIVE,
+    HELP_QUIET,
+    HELP_VERBOSE,
+    OPT_DEBUG,
+    OPT_INPUT,
+    OPT_INTERACTIVE,
+    OPT_QUIET,
+    OPT_VERBOSE,
+)
+from cli.presentation.core.console import print_error, print_header
+from cli.presentation.core.interactive import ask_input_path, should_prompt
+from cli.presentation.validate.renderer import render_validate_result
+
+
+def validate_command(
+    ctx: typer.Context,
+    input_file: Path | None = typer.Option(
+        None,
+        f"--{OPT_INPUT}",
+        "-i",
+        help=HELP_INPUT,
+        exists=False,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+    ),
+    interactive: bool = typer.Option(
+        False,
+        f"--{OPT_INTERACTIVE}",
+        "-I",
+        help=HELP_INTERACTIVE,
+    ),
+    debug: bool = typer.Option(False, f"--{OPT_DEBUG}", help=HELP_DEBUG),
+    verbose: bool = typer.Option(False, f"--{OPT_VERBOSE}", "-v", help=HELP_VERBOSE),
+    quiet: bool = typer.Option(False, f"--{OPT_QUIET}", "-q", help=HELP_QUIET),
+) -> None:
+    """Validate an OpenAPI document."""
+    try:
+        from cli.main import get_runtime
+
+        resolved_input = input_file
+
+        prompt = should_prompt(interactive)
+
+        if resolved_input is None and prompt:
+            resolved_input = ask_input_path()
+
+        if resolved_input is None:
+            raise ValueError("missing required option: --input")
+
+        if not quiet:
+            print_header("Validate", str(resolved_input))
+
+        runtime = get_runtime(ctx)
+        result = runtime.validate(input_path=resolved_input)
+
+        if not quiet:
+            render_validate_result(result, verbose=verbose)
+
+    except Exception as exc:
+        print_error(str(exc))
+        if debug:
+            raise
+        raise typer.Exit(1) from exc

codepot_gen-0.1.0/cli/constants/__init__.py

@@ -0,0 +1,6 @@
+"""CLI constants and help text.
+
+This package contains CLI-related constants including command names, option names,
+and help text descriptions. It is owned by the CLI adapter. Runtime and engine
+modules must not import from it.
+"""

codepot_gen-0.1.0/cli/constants/constants.py

@@ -0,0 +1,42 @@
+"""CLI constants and help text.
+
+This module is owned by the CLI adapter. Runtime and engine modules must not
+import from it.
+"""
+
+APP_NAME = "codepot-gen"
+APP_DESCRIPTION = "Template-driven OpenAPI generator."
+APP_VERSION = "0.1.0"
+
+CMD_EMIT = "emit"
+CMD_INFER = "infer"
+CMD_INSPECT = "inspect"
+CMD_VALIDATE = "validate"
+
+OPT_INPUT = "input"
+OPT_OUTPUT = "output"
+OPT_LANGUAGE = "language"
+OPT_TEMPLATES = "templates"
+OPT_DRY_RUN = "dry-run"
+OPT_INTERACTIVE = "interactive"
+OPT_DEBUG = "debug"
+OPT_VERBOSE = "verbose"
+OPT_QUIET = "quiet"
+OPT_VERSION = "version"
+
+HELP_INPUT = "Input OpenAPI document."
+HELP_OUTPUT = "Output directory or file, depending on the command."
+HELP_OUTPUT_INFERENCE = "Optional inference JSON output path."
+HELP_LANGUAGE = "Target language, for example debug, dart, or typescript."
+HELP_TEMPLATES_PATH = "Custom template root. Defaults to templates/{language}."
+HELP_DRY_RUN = "Plan output without writing generated files."
+HELP_INTERACTIVE = "Prompt for missing command options interactively."
+HELP_DEBUG = "Show traceback when an error occurs."
+HELP_VERBOSE = "Show detailed CLI output."
+HELP_QUIET = "Suppress normal CLI output."
+HELP_VERSION = "Show version and exit."
+
+HELP_EMIT = "Emit output for a target language."
+HELP_INFER = "Run inference and optionally write inference JSON."
+HELP_INSPECT = "Inspect an OpenAPI document."
+HELP_VALIDATE = "Validate an OpenAPI document."

codepot_gen-0.1.0/cli/constants/defaults.py

@@ -0,0 +1,41 @@
+"""Presentation layer constants."""
+
+from __future__ import annotations
+
+# Language choices for interactive prompts
+LANGUAGE_CHOICES = ["debug", "dart", "typescript"]
+
+# Default file names
+DEFAULT_INFERENCE_OUTPUT = "inference.json"
+
+# Default boolean prompt values
+DEFAULT_CONFIRM = False
+DEFAULT_DRY_RUN = True
+DEFAULT_USE_CUSTOM_TEMPLATES = False
+DEFAULT_WRITE_OUTPUT = False
+
+# Acronym replacements for table key formatting
+ACRONYM_REPLACEMENTS = {
+    "Api": "API",
+    "Openapi": "OpenAPI",
+    "Http": "HTTP",
+    "Json": "JSON",
+    "Yaml": "YAML",
+    "Url": "URL",
+    "Uri": "URI",
+    "Id": "ID",
+    "Dto": "DTO",
+    "Sdk": "SDK",
+}
+
+# Tokens that indicate a numeric column for table formatting
+NUMERIC_COLUMN_TOKENS = (
+    "count",
+    "total",
+    "files",
+    "operations",
+    "schemas",
+    "paths",
+    "refs",
+    "value",
+)