otterapi 0.0.0__tar.gz → 0.0.2__tar.gz

{otterapi-0.0.0 → otterapi-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: otterapi
-Version: 0.0.0
+Version: 0.0.2
 Summary: A cute little companion that generates type-safe clients from OpenAPI documents.
 Project-URL: Source, https://github.com/danplischke/otter
 Author: Dan Plischke

otterapi-0.0.2/otterapi/__main__.py

@@ -0,0 +1,4 @@
+from otterapi.cli import app
+
+if __name__ == '__main__':
+    app()

otterapi-0.0.2/otterapi/cli.py

@@ -0,0 +1,84 @@
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from otterapi.codegen.generator import Codegen
+from otterapi.config import get_config
+
+console = Console()
+app = typer.Typer(
+    name='otterapi',
+    help='Generate Python client code from OpenAPI specifications',
+    no_args_is_help=True,
+)
+
+
+@app.command()
+def generate(
+    config: Annotated[
+        str | None,
+        typer.Option(
+            '--config', '-c', help='Path to configuration file (YAML or JSON)'
+        ),
+    ] = None,
+) -> None:
+    """Generate Python client code from configuration.
+
+    If no config file is specified, will look for default config files
+    in the current directory or use environment variables.
+
+    Examples:
+        otterapi generate
+        otterapi generate --config my-config.yaml
+        otterapi generate -c config.json
+    """
+    config = get_config(config)
+
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn('[progress.description]{task.description}'),
+            console=console,
+        ) as progress:
+            for document_config in config.documents:
+                task = progress.add_task(
+                    f'Generating code for {document_config.source} in {document_config.output}...',
+                    total=None,
+                )
+
+                codegen = Codegen(document_config)
+                codegen.generate()
+
+                console.print(
+                    f"[green]✓[/green] Successfully generated code in '{document_config.output}'"
+                )
+                console.print('[dim]Generated files:[/dim]')
+                console.print(
+                    f'  - {document_config.output}/{document_config.models_file}'
+                )
+                console.print(
+                    f'  - {document_config.output}/{document_config.endpoints_file}'
+                )
+
+            progress.update(task, description='Code generation completed!')
+
+    except Exception as e:
+        console.print(f'[red]Error:[/red] {str(e)}')
+        raise typer.Exit(1)
+
+
+@app.command()
+def version() -> None:
+    """Show the version of otterapi."""
+    try:
+        from otterapi._version import version
+
+        console.print(f'otterapi version: {version}')
+    except ImportError:
+        console.print('otterapi version: unknown')
+
+
+if __name__ == '__main__':
+    generate('/Users/PLISCD/Downloads/otterapi.yml')

otterapi-0.0.2/otterapi/codegen/ast_utils.py

@@ -0,0 +1,118 @@
+import ast
+from collections.abc import Iterable
+
+
+def _name(name: str) -> ast.Name:
+    return ast.Name(id=name, ctx=ast.Load())
+
+
+def _attr(value: str | ast.expr, attr: str) -> ast.Attribute:
+    return ast.Attribute(
+        value=_name(value) if isinstance(value, str) else value, attr=attr
+    )
+
+
+def _subscript(generic: str, inner: ast.expr) -> ast.Subscript:
+    return ast.Subscript(value=_name(generic), slice=inner)
+
+
+def _union_expr(types: list[ast.expr]) -> ast.Subscript:
+    # Union[A, B, C]
+    return _subscript('Union', ast.Tuple(elts=types))
+
+
+def _optional_expr(inner: ast.expr) -> ast.Subscript:
+    return _subscript('Optional', inner)
+
+
+def _argument(name: str, value: ast.expr | None = None) -> ast.arg:
+    return ast.arg(
+        arg=name,
+        annotation=value,
+    )
+
+
+def _assign(target: ast.expr, value: ast.expr) -> ast.Assign:
+    return ast.Assign(
+        targets=[target],
+        value=value,
+    )
+
+
+def _import(module: str, names: list[str]) -> ast.ImportFrom:
+    return ast.ImportFrom(
+        module=module,
+        names=[ast.alias(name=name) for name in names],
+        level=0,
+    )
+
+
+def _call(
+    func: ast.expr,
+    args: list[ast.expr] | None = None,
+    keywords: list[ast.keyword] | None = None,
+) -> ast.Call:
+    return ast.Call(
+        func=func,
+        args=args or [],
+        keywords=keywords or [],
+    )
+
+
+def _func(
+    name: str,
+    args: list[ast.arg],
+    body: list[ast.stmt],
+    returns: ast.expr | None = None,
+    kwargs: ast.arg = None,
+    kwonlyargs: list[ast.arg] = None,
+    kw_defaults: list[ast.expr] = None,
+) -> ast.FunctionDef:
+    return ast.FunctionDef(
+        name=name,
+        args=ast.arguments(
+            posonlyargs=[],
+            args=args,
+            kwarg=kwargs,
+            kwonlyargs=kwonlyargs or [],
+            kw_defaults=kw_defaults or [],
+            defaults=[],
+        ),
+        body=body,
+        decorator_list=[],
+        returns=returns,
+    )
+
+
+def _async_func(
+    name: str,
+    args: list[ast.arg],
+    body: list[ast.stmt],
+    returns: ast.expr | None = None,
+    kwargs: ast.arg = None,
+    kwonlyargs: list[ast.arg] = None,
+    kw_defaults: list[ast.expr] = None,
+) -> ast.AsyncFunctionDef:
+    return ast.AsyncFunctionDef(
+        name=name,
+        args=ast.arguments(
+            posonlyargs=[],
+            args=args,
+            kwarg=kwargs,
+            kwonlyargs=kwonlyargs or [],
+            kw_defaults=kw_defaults or [],
+            defaults=[],
+        ),
+        body=body,
+        decorator_list=[],
+        returns=returns,
+    )
+
+
+def _all(names: Iterable[str]) -> ast.Assign:
+    return _assign(
+        target=_name('__all__'),
+        value=ast.Tuple(
+            elts=[ast.Constant(value=name) for name in names], ctx=ast.Load()
+        ),
+    )