otterapi 0.1.2__tar.gz → 0.1.3__tar.gz

{otterapi-0.1.2 → otterapi-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: otterapi
-Version: 0.1.2
+Version: 0.1.3
 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.1.2 → otterapi-0.1.3}/otterapi/codegen/ast_utils.py

@@ -16,6 +16,7 @@ __all__ = [
     '_union_expr',
     '_optional_expr',
     '_argument',
+    '_ann_assign',
     '_assign',
     '_import',
     '_call',
@@ -76,6 +77,13 @@ def _argument(name: str, value: ast.expr | None = None) -> ast.arg:
     )
 
 
+def _ann_assign(target: ast.expr, annotation: ast.expr, value: ast.expr) -> ast.AnnAssign:
+    """Build ``target: annotation = value``."""
+    if isinstance(target, ast.Name):
+        target = ast.Name(id=target.id, ctx=ast.Store())
+    return ast.AnnAssign(target=target, annotation=annotation, value=value, simple=1)
+
+
 def _assign(target: ast.expr, value: ast.expr) -> ast.Assign:
     # Ensure target has Store context
     if isinstance(target, ast.Name):

{otterapi-0.1.2 → otterapi-0.1.3}/otterapi/codegen/client.py

@@ -668,7 +668,7 @@ def generate_base_client_class(
     """
     imports: ImportDict = {
         'httpx': {'Client', 'AsyncClient', 'Response', 'TransportError'},
-        'typing': {'Any', 'TypeVar'},
+        'typing': {'Any'},
         'types': {'UnionType'},
         'pydantic': {'TypeAdapter', 'RootModel'},
         '._retry': {'_backoff_sleep', '_backoff_sleep_async'},
@@ -1126,7 +1126,7 @@ def _build_parse_response_method(
             args=args,
             body=body,
             decorator_list=[],
-            returns=_name('T'),
+            returns=_name('Any'),
         )
     else:
         return ast.FunctionDef(
@@ -1134,7 +1134,7 @@ def _build_parse_response_method(
             args=args,
             body=body,
             decorator_list=[],
-            returns=_name('T'),
+            returns=_name('Any'),
         )
 
 

{otterapi-0.1.2 → otterapi-0.1.3}/otterapi/codegen/codegen.py

@@ -1666,16 +1666,6 @@ class Codegen(OpenAPIProcessor):
         for import_stmt in import_collector.to_ast():
             body.insert(0, import_stmt)
 
-        # Add TypeVar definition: T = TypeVar('T')
-        typevar_def = _assign(
-            _name('T'),
-            _call(
-                func=_name('TypeVar'),
-                args=[ast.Constant(value='T')],
-            ),
-        )
-        body.append(typevar_def)
-
         # Add __all__ export (include the full per-status error hierarchy
         # so users can ``from .<pkg>._client import NotFoundError`` etc.).
         body.append(_all(sorted([base_client_name, *_exported_error_names()])))

{otterapi-0.1.2 → otterapi-0.1.3}/otterapi/codegen/endpoints.py

@@ -227,7 +227,9 @@ class FunctionSignatureBuilder:
             if param.required:
                 self._args.append(arg)
             else:
-                self._kwonlyargs.append(arg)
+                # Wrap annotation in `| None` so the `= None` default is type-safe.
+                optional_annotation = _union_expr([annotation, ast.Constant(value=None)])
+                self._kwonlyargs.append(_argument(param.name_sanitized, optional_annotation))
                 self._kw_defaults.append(ast.Constant(value=None))
 
         return self
@@ -262,7 +264,8 @@ class FunctionSignatureBuilder:
         if body.required:
             self._args.append(body_arg)
         else:
-            self._kwonlyargs.append(body_arg)
+            optional_body_annotation = _union_expr([body_annotation, ast.Constant(value=None)])
+            self._kwonlyargs.append(_argument('body', optional_body_annotation))
             self._kw_defaults.append(ast.Constant(value=None))
 
         return self

{otterapi-0.1.2 → otterapi-0.1.3}/otterapi/codegen/export.py

@@ -188,8 +188,8 @@ def _format_literal_annotation() -> ast.expr:
 
 
 def _output_path_annotation() -> ast.expr:
-    """Build the AST for ``str | Path`` (the wrapper's path argument type)."""
-    return _union_expr([_name('str'), _name('Path')])
+    """Build the AST for ``str | Path | None`` (the wrapper's path argument type)."""
+    return _union_expr([_name('str'), _name('Path'), ast.Constant(value=None)])
 
 
 def _add_export_kwonly_args(

{otterapi-0.1.2 → otterapi-0.1.3}/otterapi/codegen/runtime/_export.py

@@ -23,7 +23,7 @@ from datetime import date, datetime, time
 from decimal import Decimal
 from enum import Enum
 from pathlib import Path
-from typing import TYPE_CHECKING, Annotated, Any, Union, get_args, get_origin
+from typing import TYPE_CHECKING, Annotated, Any, TypeAlias, Union, get_args, get_origin
 from uuid import UUID
 
 from pydantic import BaseModel
@@ -32,8 +32,8 @@ from upath import UPath
 if TYPE_CHECKING:
     import pyarrow as pa
 
-Row = BaseModel | dict
-PathLike = str | Path | UPath
+Row: TypeAlias = BaseModel | dict
+PathLike: TypeAlias = str | Path | UPath
 
 
 # -----------------------------------------------------------------------------
@@ -378,6 +378,7 @@ def _python_type_to_arrow(annotation: Any, pa) -> pa.DataType:
     origin = get_origin(inner)
 
     if isinstance(inner, type) and issubclass(inner, BaseModel):
+        model_cls: type[BaseModel] = inner
         return pa.struct(
             [
                 pa.field(
@@ -385,7 +386,7 @@ def _python_type_to_arrow(annotation: Any, pa) -> pa.DataType:
                     _python_type_to_arrow(field.annotation, pa),
                     nullable=_is_nullable(field.annotation),
                 )
-                for name, field in inner.model_fields.items()
+                for name, field in model_cls.model_fields.items()
             ]
         )
 

{otterapi-0.1.2 → otterapi-0.1.3}/otterapi/codegen/runtime/_pagination.py

@@ -6,7 +6,6 @@ from dataclasses import dataclass
 from typing import Any, TypeVar
 
 T = TypeVar('T')
-PageT = TypeVar('PageT')
 
 
 @dataclass
@@ -118,14 +117,14 @@ def _progress_context(
 
 
 def paginate_offset(
-    fetch_page: Callable[[int, int], PageT],
-    extract_items: Callable[[PageT], list[T]],
-    get_total: Callable[[PageT], int | None] | None = None,
+    fetch_page: Callable[[int, int], Any],
+    extract_items: Callable[[Any], list[T]],
+    get_total: Callable[[Any], int | None] | None = None,
     *,
     start_offset: int = 0,
     page_size: int = 100,
     max_items: int | None = None,
-    progress: bool | str = False,
+    progress: bool | str = True,
 ) -> list[T]:
     """Generic offset-based pagination that returns all items.
 
@@ -182,14 +181,14 @@ def paginate_offset(
 
 
 async def paginate_offset_async(
-    fetch_page: Callable[[int, int], Any],  # Returns Awaitable[PageT]
-    extract_items: Callable[[PageT], list[T]],
-    get_total: Callable[[PageT], int | None] | None = None,
+    fetch_page: Callable[[int, int], Any],  # Returns Awaitable[Any]
+    extract_items: Callable[[Any], list[T]],
+    get_total: Callable[[Any], int | None] | None = None,
     *,
     start_offset: int = 0,
     page_size: int = 100,
     max_items: int | None = None,
-    progress: bool | str = False,
+    progress: bool | str = True,
 ) -> list[T]:
     """Async version of paginate_offset."""
     all_items: list[T] = []
@@ -244,14 +243,14 @@ async def paginate_offset_async(
 
 
 def iterate_offset(
-    fetch_page: Callable[[int, int], PageT],
-    extract_items: Callable[[PageT], list[T]],
-    get_total: Callable[[PageT], int | None] | None = None,
+    fetch_page: Callable[[int, int], Any],
+    extract_items: Callable[[Any], list[T]],
+    get_total: Callable[[Any], int | None] | None = None,
     *,
     start_offset: int = 0,
     page_size: int = 100,
     max_items: int | None = None,
-    progress: bool | str = False,
+    progress: bool | str = True,
 ) -> Iterator[T]:
     """Generic offset-based pagination iterator (streaming).
 
@@ -309,14 +308,14 @@ def iterate_offset(
 
 
 async def iterate_offset_async(
-    fetch_page: Callable[[int, int], Any],  # Returns Awaitable[PageT]
-    extract_items: Callable[[PageT], list[T]],
-    get_total: Callable[[PageT], int | None] | None = None,
+    fetch_page: Callable[[int, int], Any],  # Returns Awaitable[Any]
+    extract_items: Callable[[Any], list[T]],
+    get_total: Callable[[Any], int | None] | None = None,
     *,
     start_offset: int = 0,
     page_size: int = 100,
     max_items: int | None = None,
-    progress: bool | str = False,
+    progress: bool | str = True,
 ) -> AsyncIterator[T]:
     """Async version of iterate_offset."""
     current_offset = start_offset
@@ -376,14 +375,14 @@ async def iterate_offset_async(
 
 
 def paginate_cursor(
-    fetch_page: Callable[[str | None, int], PageT],
-    extract_items: Callable[[PageT], list[T]],
-    get_next_cursor: Callable[[PageT], str | None],
+    fetch_page: Callable[[str | None, int], Any],
+    extract_items: Callable[[Any], list[T]],
+    get_next_cursor: Callable[[Any], str | None],
     *,
     start_cursor: str | None = None,
     page_size: int = 100,
     max_items: int | None = None,
-    progress: bool | str = False,
+    progress: bool | str = True,
 ) -> list[T]:
     """Generic cursor-based pagination that returns all items.
 
@@ -431,14 +430,14 @@ def paginate_cursor(
 
 
 async def paginate_cursor_async(
-    fetch_page: Callable[[str | None, int], Any],  # Returns Awaitable[PageT]
-    extract_items: Callable[[PageT], list[T]],
-    get_next_cursor: Callable[[PageT], str | None],
+    fetch_page: Callable[[str | None, int], Any],  # Returns Awaitable[Any]
+    extract_items: Callable[[Any], list[T]],
+    get_next_cursor: Callable[[Any], str | None],
     *,
     start_cursor: str | None = None,
     page_size: int = 100,
     max_items: int | None = None,
-    progress: bool | str = False,
+    progress: bool | str = True,
 ) -> list[T]:
     """Async version of paginate_cursor."""
     all_items: list[T] = []
@@ -485,14 +484,14 @@ async def paginate_cursor_async(
 
 
 def iterate_cursor(
-    fetch_page: Callable[[str | None, int], PageT],
-    extract_items: Callable[[PageT], list[T]],
-    get_next_cursor: Callable[[PageT], str | None],
+    fetch_page: Callable[[str | None, int], Any],
+    extract_items: Callable[[Any], list[T]],
+    get_next_cursor: Callable[[Any], str | None],
     *,
     start_cursor: str | None = None,
     page_size: int = 100,
     max_items: int | None = None,
-    progress: bool | str = False,
+    progress: bool | str = True,
 ) -> Iterator[T]:
     """Generic cursor-based pagination iterator (streaming).
 
@@ -537,14 +536,14 @@ def iterate_cursor(
 
 
 async def iterate_cursor_async(
-    fetch_page: Callable[[str | None, int], Any],  # Returns Awaitable[PageT]
-    extract_items: Callable[[PageT], list[T]],
-    get_next_cursor: Callable[[PageT], str | None],
+    fetch_page: Callable[[str | None, int], Any],  # Returns Awaitable[Any]
+    extract_items: Callable[[Any], list[T]],
+    get_next_cursor: Callable[[Any], str | None],
     *,
     start_cursor: str | None = None,
     page_size: int = 100,
     max_items: int | None = None,
-    progress: bool | str = False,
+    progress: bool | str = True,
 ) -> AsyncIterator[T]:
     """Async version of iterate_cursor."""
     current_cursor = start_cursor
@@ -593,15 +592,15 @@ async def iterate_cursor_async(
 
 
 def iterate_page(
-    fetch_page: Callable[[int, int], PageT],
-    extract_items: Callable[[PageT], list[T]],
-    get_total_pages: Callable[[PageT], int | None] | None = None,
+    fetch_page: Callable[[int, int], Any],
+    extract_items: Callable[[Any], list[T]],
+    get_total_pages: Callable[[Any], int | None] | None = None,
     *,
     start_page: int = 1,
     page_size: int = 100,
     max_items: int | None = None,
     max_pages: int | None = None,
-    progress: bool | str = False,
+    progress: bool | str = True,
 ) -> Iterator[T]:
     """Generic page-based pagination iterator (streaming).
 
@@ -660,15 +659,15 @@ def iterate_page(
 
 
 async def iterate_page_async(
-    fetch_page: Callable[[int, int], Any],  # Returns Awaitable[PageT]
-    extract_items: Callable[[PageT], list[T]],
-    get_total_pages: Callable[[PageT], int | None] | None = None,
+    fetch_page: Callable[[int, int], Any],  # Returns Awaitable[Any]
+    extract_items: Callable[[Any], list[T]],
+    get_total_pages: Callable[[Any], int | None] | None = None,
     *,
     start_page: int = 1,
     page_size: int = 100,
     max_items: int | None = None,
     max_pages: int | None = None,
-    progress: bool | str = False,
+    progress: bool | str = True,
 ) -> AsyncIterator[T]:
     """Async version of iterate_page."""
     current_page = start_page
@@ -723,15 +722,15 @@ async def iterate_page_async(
 
 
 def paginate_page(
-    fetch_page: Callable[[int, int], PageT],
-    extract_items: Callable[[PageT], list[T]],
-    get_total_pages: Callable[[PageT], int | None] | None = None,
+    fetch_page: Callable[[int, int], Any],
+    extract_items: Callable[[Any], list[T]],
+    get_total_pages: Callable[[Any], int | None] | None = None,
     *,
     start_page: int = 1,
     page_size: int = 100,
     max_items: int | None = None,
     max_pages: int | None = None,
-    progress: bool | str = False,
+    progress: bool | str = True,
 ) -> list[T]:
     """Generic page-based pagination that returns all items.
 
@@ -788,15 +787,15 @@ def paginate_page(
 
 
 async def paginate_page_async(
-    fetch_page: Callable[[int, int], Any],  # Returns Awaitable[PageT]
-    extract_items: Callable[[PageT], list[T]],
-    get_total_pages: Callable[[PageT], int | None] | None = None,
+    fetch_page: Callable[[int, int], Any],  # Returns Awaitable[Any]
+    extract_items: Callable[[Any], list[T]],
+    get_total_pages: Callable[[Any], int | None] | None = None,
     *,
     start_page: int = 1,
     page_size: int = 100,
     max_items: int | None = None,
     max_pages: int | None = None,
-    progress: bool | str = False,
+    progress: bool | str = True,
 ) -> list[T]:
     """Async version of paginate_page."""
     all_items: list[T] = []

{otterapi-0.1.2 → otterapi-0.1.3}/otterapi/codegen/types.py

@@ -983,10 +983,8 @@ class TypeGenerator(OpenAPIProcessor):
 
         self._attach_model_dependencies(type_, base_bases, field_types)
 
-        type_.add_implementation_import(
-            module=BaseModel.__module__, name=BaseModel.__name__
-        )
-        type_.add_implementation_import(module=Field.__module__, name=Field.__name__)
+        type_.add_implementation_import(module='pydantic', name=BaseModel.__name__)
+        type_.add_implementation_import(module='pydantic', name=Field.__name__)
         type_.copy_imports_from_sub_types(field_types)
 
         type_ = self.add_type(type_, base_name=base_name)