otterapi 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

otterapi/__main__.py

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

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()

otterapi/codegen/ast_utils.py

@@ -0,0 +1,121 @@
+import ast
+import keyword
+from collections.abc import Iterable
+
+PYTHON_KEYWORDS = set(keyword.kwlist)
+
+
+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()
+        ),
+    )

otterapi/codegen/endpoints.py

@@ -0,0 +1,501 @@
+import ast
+import textwrap
+
+from otterapi.codegen.ast_utils import (
+    _argument,
+    _assign,
+    _async_func,
+    _attr,
+    _call,
+    _func,
+    _name,
+    _subscript,
+    _union_expr,
+)
+from otterapi.codegen.type_generator import Parameter, Type
+
+
+def clean_docstring(docstring: str) -> str:
+    return textwrap.dedent(f'\n{docstring}\n').strip()
+
+
+def get_base_request_arguments():
+    args = [
+        _argument('method', _name('str')),
+        _argument('path', _name('str')),
+    ]
+    kwonlyargs = [
+        _argument(
+            'response_model',
+            _union_expr([_subscript('Type', _name('T')), ast.Constant(value=None)]),
+        ),
+        _argument('supported_status_codes', _subscript('list', _name('int'))),
+    ]
+    kwargs = _argument('kwargs', _name('dict'))
+
+    return args, kwonlyargs, kwargs
+
+
+def base_request_fn():
+    args, kwonlyargs, kwargs = get_base_request_arguments()
+
+    body = [
+        _assign(
+            target=_name('response'),
+            value=_call(
+                func=_name('request'),
+                args=[
+                    _name('method'),
+                    ast.Expr(
+                        value=ast.JoinedStr(
+                            values=[
+                                ast.FormattedValue(
+                                    value=_name('BASE_URL'), conversion=-1
+                                ),
+                                ast.FormattedValue(value=_name('path'), conversion=-1),
+                            ]
+                        )
+                    ),
+                ],
+                keywords=[ast.keyword(arg=None, value=_name('kwargs'))],
+            ),
+        ),
+        ast.If(
+            test=ast.BoolOp(
+                op=ast.Or(),
+                values=[
+                    ast.UnaryOp(op=ast.Not(), operand=_name('supported_status_codes')),
+                    ast.Compare(
+                        left=_attr('response', 'status_code'),
+                        ops=[ast.NotIn()],
+                        comparators=[_name('supported_status_codes')],
+                    ),
+                ],
+            ),
+            body=[
+                ast.Expr(
+                    value=_call(
+                        func=_attr('response', 'raise_for_status'),
+                    )
+                )
+            ],
+            orelse=[],
+        ),
+        _assign(
+            target=_name('data'),
+            value=_call(
+                func=_attr('response', 'json'),
+            ),
+        ),
+        ast.If(
+            test=ast.UnaryOp(op=ast.Not(), operand=_name('response_model')),
+            body=[ast.Return(value=_name('data'))],
+            orelse=[],
+        ),
+        _assign(
+            target=_name('validated_data'),
+            value=_call(
+                func=_attr(
+                    _call(
+                        func=_name('TypeAdapter'),
+                        args=[_name('response_model')],
+                    ),
+                    'validate_python',
+                ),
+                args=[_name('data')],
+            ),
+        ),
+        ast.If(
+            test=_call(
+                func=_name('isinstance'),
+                args=[_name('validated_data'), _name('RootModel')],
+            ),
+            body=[ast.Return(value=_attr('validated_data', 'root'))],
+            orelse=[],
+        ),
+        ast.Return(value=_name('validated_data')),
+    ]
+
+    return _func(
+        name='request_sync',
+        args=args,
+        body=body,
+        kwargs=kwargs,
+        kwonlyargs=kwonlyargs,
+        kw_defaults=[_name('Json'), ast.Constant(value=None)],
+        returns=_name('T'),
+    ), {
+        'httpx': ['request'],
+        'pydantic': ['TypeAdapter', 'Json', 'RootModel'],
+        'typing': ['Type', 'TypeVar', 'Union'],
+    }
+
+
+def base_async_request_fn():
+    args, kwonlyargs, kwargs = get_base_request_arguments()
+
+    body = [
+        ast.AsyncWith(
+            items=[
+                ast.withitem(
+                    context_expr=_call(func=_name('AsyncClient')),
+                    optional_vars=_name('client'),
+                )
+            ],
+            body=[
+                _assign(
+                    target=_name('response'),
+                    value=ast.Await(
+                        value=_call(
+                            func=_attr('client', 'request'),
+                            args=[
+                                _name('method'),
+                                ast.Expr(
+                                    value=ast.JoinedStr(
+                                        values=[
+                                            ast.FormattedValue(
+                                                value=_name('BASE_URL'), conversion=-1
+                                            ),
+                                            ast.FormattedValue(
+                                                value=_name('path'), conversion=-1
+                                            ),
+                                        ]
+                                    )
+                                ),
+                            ],
+                            keywords=[ast.keyword(arg=None, value=_name('kwargs'))],
+                        )
+                    ),
+                ),
+                ast.If(
+                    test=ast.BoolOp(
+                        op=ast.Or(),
+                        values=[
+                            ast.UnaryOp(
+                                op=ast.Not(), operand=_name('supported_status_codes')
+                            ),
+                            ast.Compare(
+                                left=_attr('response', 'status_code'),
+                                ops=[ast.NotIn()],
+                                comparators=[_name('supported_status_codes')],
+                            ),
+                        ],
+                    ),
+                    body=[
+                        ast.Expr(
+                            value=_call(
+                                func=_attr('response', 'raise_for_status'),
+                            )
+                        )
+                    ],
+                    orelse=[],
+                ),
+                _assign(
+                    target=_name('data'),
+                    value=_call(
+                        func=_attr('response', 'json'),
+                    ),
+                ),
+                ast.If(
+                    test=ast.UnaryOp(op=ast.Not(), operand=_name('response_model')),
+                    body=[ast.Return(value=_name('data'))],
+                    orelse=[],
+                ),
+                _assign(
+                    target=_name('validated_data'),
+                    value=_call(
+                        func=_attr(
+                            _call(
+                                func=_name('TypeAdapter'),
+                                args=[_name('response_model')],
+                            ),
+                            'validate_python',
+                        ),
+                        args=[_name('data')],
+                    ),
+                ),
+                ast.If(
+                    test=_call(
+                        func=_name('isinstance'),
+                        args=[_name('validated_data'), _name('RootModel')],
+                    ),
+                    body=[ast.Return(value=_attr('validated_data', 'root'))],
+                    orelse=[],
+                ),
+                ast.Return(value=_name('validated_data')),
+            ],
+        )
+    ]
+
+    return _async_func(
+        name='request_async',
+        args=args,
+        body=body,
+        kwargs=kwargs,
+        kwonlyargs=kwonlyargs,
+        kw_defaults=[_name('Json'), ast.Constant(value=None)],
+        returns=_name('T'),
+    ), {
+        'httpx': ['AsyncClient'],
+        'pydantic': ['TypeAdapter', 'Json', 'RootModel'],
+        'typing': ['Type', 'TypeVar', 'Union'],
+    }
+
+
+def get_parameters(
+    parameters: list[Parameter],
+) -> tuple[list[ast.arg], list[ast.arg], list[ast.expr], dict[str, set[str]]]:
+    args = []
+    kwonlyargs = []
+    kw_defaults = []
+    imports = {}
+
+    for param in parameters:
+        if param.name == 'user-id':
+            print()
+        param_name = param.name_sanitized
+        param_type = param.type.annotation_ast if param.type else None
+        param_required = param.required
+
+        if param_type is None:
+            param_type = _name('Any')
+            imports.setdefault('typing', set()).add('Any')
+
+        if param_required:
+            # Required parameters go in regular args
+            args.append(_argument(param_name, param_type))
+        else:
+            # Optional parameters go in kwonlyargs with None default
+            kwonlyargs.append(_argument(param_name, param_type))
+            kw_defaults.append(ast.Constant(None))
+
+    return args, kwonlyargs, kw_defaults, imports
+
+
+def get_base_call_keywords(
+    method, path, response_model: Type, supported_status_codes: list | None = None
+) -> list[ast.keyword]:
+    return [
+        ast.keyword(arg='method', value=ast.Constant(value=method)),
+        ast.keyword(arg='path', value=path),
+        ast.keyword(
+            arg='response_model',
+            value=response_model.annotation_ast
+            if response_model
+            else ast.Constant(None),
+        ),
+        ast.keyword(
+            arg='supported_status_codes', value=ast.Constant(supported_status_codes)
+        ),
+    ]
+
+
+def build_header_params(headers: list[Parameter]) -> ast.Dict | None:
+    if not headers:
+        return None
+
+    return ast.Dict(
+        keys=[ast.Constant(value=header.name) for header in headers],
+        values=[_name(header.name_sanitized) for header in headers],
+    )
+
+
+def build_query_params(queries: list[Parameter]) -> ast.Dict | None:
+    if not queries:
+        return None
+
+    return ast.Dict(
+        keys=[ast.Constant(value=query.name) for query in queries],
+        values=[_name(query.name_sanitized) for query in queries],
+    )
+
+
+def build_path_params(
+    paths: list[Parameter], path: str
+) -> ast.JoinedStr | ast.Constant:
+    """Build an f-string AST that interpolates path parameters."""
+    if not paths:
+        return ast.Constant(value=path)
+
+    # Split the path into parts and build the f-string
+    values = []
+    current_pos = 0
+
+    for path_param in paths:
+        param_placeholder = f'{{{path_param.name}}}'
+        param_pos = path.find(param_placeholder, current_pos)
+
+        if param_pos != -1:
+            # Add any literal text before the parameter
+            if param_pos > current_pos:
+                literal_text = path[current_pos:param_pos]
+                values.append(ast.Constant(value=literal_text))
+
+            # Add the formatted value for the parameter
+            values.append(
+                ast.FormattedValue(
+                    value=_name(path_param.name_sanitized),
+                    conversion=-1,  # No conversion (default)
+                )
+            )
+
+            current_pos = param_pos + len(param_placeholder)
+
+    # Add any remaining literal text after the last parameter
+    if current_pos < len(path):
+        remaining_text = path[current_pos:]
+        values.append(ast.Constant(value=remaining_text))
+
+    return ast.JoinedStr(values=values)
+
+
+def build_body_params(body: Parameter | None) -> ast.expr | None:
+    if not body:
+        return None
+
+    if body.type.type == 'model' or body.type.type == 'root_model':
+        return _call(
+            func=_attr(_name(body.name_sanitized), 'model_dump'),
+            args=[],
+        )
+
+    return _name(body.name)
+
+
+def prepare_call_from_parameters(
+    parameters: list[Parameter] | None, path: str
+) -> tuple[ast.expr, ast.expr, ast.expr, ast.expr]:
+    if not parameters:
+        parameters = []
+
+    query_params = [p for p in parameters if p.location == 'query']
+    path_params = [p for p in parameters if p.location == 'path']
+    header_params = [p for p in parameters if p.location == 'header']
+    body_params = [p for p in parameters if p.location == 'body']
+
+    if len(body_params) > 1:
+        raise ValueError('Multiple body parameters are not supported.')
+
+    return (
+        build_query_params(query_params),
+        build_header_params(header_params),
+        build_body_params(body_params[0] if len(body_params) == 1 else None),
+        build_path_params(path_params, path),
+    )
+
+
+def request_fn(
+    name: str,
+    method: str,
+    path: str,
+    response_model: Type,
+    docs: str | None = None,
+    parameters: list | None = None,
+    supported_status_codes: list | None = None,
+):
+    args, kwonlyargs, kw_defaults, imports = get_parameters(parameters)
+
+    query_params, header_params, body_params, processed_path = (
+        prepare_call_from_parameters(parameters, path)
+    )
+    call_keywords = get_base_call_keywords(
+        method, processed_path, response_model, supported_status_codes
+    )
+
+    if query_params:
+        call_keywords.append(ast.keyword(arg='params', value=query_params))
+    if header_params:
+        call_keywords.append(ast.keyword(arg='headers', value=header_params))
+    if body_params:
+        call_keywords.append(ast.keyword(arg='json', value=body_params))
+
+    call_keywords.append(ast.keyword(arg=None, value=_name('kwargs')))
+
+    body = [
+        ast.Return(
+            value=_call(
+                func=_name('request_sync'),
+                args=[],
+                keywords=call_keywords,
+            )
+        )
+    ]
+
+    if docs:
+        docs = textwrap.dedent(f'\n{docs}\n').strip()
+        body.insert(0, ast.Expr(value=ast.Constant(value=docs)))
+
+    response_model_ast = response_model.annotation_ast if response_model else None
+    if not response_model_ast:
+        response_model_ast = _name('Any')
+        imports.setdefault('typing', set()).add('Any')
+
+    return _func(
+        name=name,
+        args=args,
+        body=body,
+        kwargs=_argument('kwargs', _name('dict')),
+        kwonlyargs=kwonlyargs,
+        kw_defaults=kw_defaults,
+        returns=response_model_ast,
+    ), ({'httpx': ['request'], **imports})
+
+
+def async_request_fn(
+    name: str,
+    method: str,
+    path: str,
+    response_model: Type,
+    docs: str | None = None,
+    parameters: list | None = None,
+    supported_status_codes: list | None = None,
+):
+    args, kwonlyargs, kw_defaults, imports = get_parameters(parameters)
+
+    query_params, header_params, body_params, processed_path = (
+        prepare_call_from_parameters(parameters, path)
+    )
+    call_keywords = get_base_call_keywords(
+        method, processed_path, response_model, supported_status_codes
+    )
+
+    if query_params:
+        call_keywords.append(ast.keyword(arg='params', value=query_params))
+    if header_params:
+        call_keywords.append(ast.keyword(arg='headers', value=header_params))
+    if body_params:
+        call_keywords.append(ast.keyword(arg='json', value=body_params))
+
+    # Add **kwargs to the call
+    call_keywords.append(ast.keyword(arg=None, value=_name('kwargs')))
+
+    body = [
+        ast.Return(
+            value=ast.Await(
+                value=_call(
+                    func=_name('request_async'),
+                    args=[],
+                    keywords=call_keywords,
+                )
+            )
+        )
+    ]
+
+    if docs:
+        docs = textwrap.dedent(f'\n{docs}\n').strip()
+        body.insert(0, ast.Expr(value=ast.Constant(value=docs)))
+
+    response_model_ast = response_model.annotation_ast if response_model else None
+    if not response_model_ast:
+        response_model_ast = _name('Any')
+        imports.setdefault('typing', set()).add('Any')
+
+    return _async_func(
+        name=name,
+        args=args,
+        body=body,
+        kwargs=_argument('kwargs', _name('dict')),
+        kwonlyargs=kwonlyargs,
+        kw_defaults=kw_defaults,
+        returns=response_model_ast,
+    ), {'httpx': ['AsyncClient'], **imports}