otterapi 0.1.2__tar.gz → 0.1.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: otterapi
-Version: 0.1.2
+Version: 0.1.4
 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.4}/otterapi/codegen/_features.py

@@ -64,16 +64,44 @@ class FeatureModule(ABC):
             .read_text('utf-8')
         )
 
-    def write(self, output_dir: Path | UPath) -> Path | UPath:
+    def transform_content(self, content: str, config: DocumentConfig) -> str:
+        """Optionally transform the module source before writing.
+
+        The default implementation returns *content* unchanged.  Subclasses
+        override this to perform pydantic-version-specific (or other
+        config-driven) rewrites of the static template source.
+
+        Args:
+            content: Raw source text read from ``otterapi.codegen.runtime``.
+            config: The active :class:`~otterapi.config.DocumentConfig`.
+
+        Returns:
+            The (possibly transformed) source text to write to disk.
+        """
+        return content
+
+    def write(
+        self, output_dir: Path | UPath, config: DocumentConfig | None = None
+    ) -> Path | UPath:
         """Write :pyattr:`module_content` into ``output_dir``.
 
         Always opens with UTF-8 encoding; relying on the platform locale
         broke the export module on Windows in PR #2.
+
+        Args:
+            output_dir: Directory where the module file is written.
+            config: Optional :class:`~otterapi.config.DocumentConfig` passed to
+                :pymeth:`transform_content`.  When *None*, no transformation is
+                applied (backwards-compatible for callers that do not yet pass
+                config, e.g. ``generate_dataframe_module``).
         """
         output_dir = UPath(output_dir)
         output_dir.mkdir(parents=True, exist_ok=True)
+        content = self.module_content
+        if config is not None:
+            content = self.transform_content(content, config)
         target = output_dir / self.module_filename
-        target.write_text(self.module_content, encoding='utf-8')
+        target.write_text(content, encoding='utf-8')
         return target
 
 
@@ -84,7 +112,9 @@ def write_enabled_features(
 ) -> list[Path | UPath]:
     """Write every enabled feature's runtime module. Returns the written paths."""
     return [
-        feature.write(output_dir) for feature in features if feature.is_enabled(config)
+        feature.write(output_dir, config)
+        for feature in features
+        if feature.is_enabled(config)
     ]
 
 
@@ -114,7 +144,12 @@ class PaginationFeature(FeatureModule):
 
 
 class DataFrameFeature(FeatureModule):
-    """Emits ``_dataframe.py`` (pandas / polars converters)."""
+    """Emits ``_dataframe.py`` (pandas / polars converters).
+
+    When ``config.pydantic_version == 1`` the emitted helper uses ``obj.dict()``
+    (the Pydantic v1 serialisation method).  For Pydantic v2 (the default) it
+    uses ``obj.model_dump()`` and removes the dead v1 fallback branch.
+    """
 
     module_filename = '_dataframe.py'
 
@@ -123,6 +158,45 @@ class DataFrameFeature(FeatureModule):
             bool(config.dataframe.pandas) or bool(config.dataframe.polars)
         )
 
+    def transform_content(self, content: str, config: DocumentConfig) -> str:
+        """Rewrite ``_to_dict`` and ``_normalize_data`` for the target Pydantic version."""
+        if config.pydantic_version == 1:
+            return (
+                content.replace(
+                    # Remove model_dump branch and make dict() the only call path
+                    "if hasattr(obj, 'model_dump'):\n        return obj.model_dump()\n"
+                    "    elif hasattr(obj, 'dict'):\n        # Pydantic v1 compatibility\n"
+                    '        return obj.dict()',
+                    "# Pydantic v1\n    if hasattr(obj, 'dict'):\n        return obj.dict()",
+                )
+                .replace(
+                    # _normalize_data: replace the model_dump / dict check with dict only
+                    "if hasattr(first, 'model_dump') or hasattr(first, 'dict'):",
+                    "if hasattr(first, 'dict'):",
+                )
+                .replace(
+                    # single-item path
+                    "if hasattr(data, 'model_dump') or hasattr(data, 'dict'):",
+                    "if hasattr(data, 'dict'):",
+                )
+            )
+        # pydantic_version == 2 (default): strip the dead v1 .dict() fallback branch
+        return (
+            content.replace(
+                "    elif hasattr(obj, 'dict'):\n        # Pydantic v1 compatibility\n"
+                '        return obj.dict()\n',
+                '',
+            )
+            .replace(
+                "if hasattr(first, 'model_dump') or hasattr(first, 'dict'):",
+                "if hasattr(first, 'model_dump'):",
+            )
+            .replace(
+                "if hasattr(data, 'model_dump') or hasattr(data, 'dict'):",
+                "if hasattr(data, 'model_dump'):",
+            )
+        )
+
 
 class ExportFeature(FeatureModule):
     """Emits ``_export.py`` (streaming CSV / TSV / JSONL / Parquet writers)."""

{otterapi-0.1.2 → otterapi-0.1.4}/otterapi/codegen/ast_utils.py

@@ -16,6 +16,7 @@ __all__ = [
     '_union_expr',
     '_optional_expr',
     '_argument',
+    '_ann_assign',
     '_assign',
     '_import',
     '_call',
@@ -76,6 +77,15 @@ 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.4}/otterapi/codegen/client.py

@@ -652,6 +652,7 @@ def generate_base_client_class(
     class_name: str,
     default_base_url: str,
     default_timeout: float = 30.0,
+    pydantic_version: int = 2,
 ) -> tuple[ast.ClassDef, ImportDict]:
     """Generate a BaseClient class with only request infrastructure.
 
@@ -662,17 +663,28 @@ def generate_base_client_class(
         class_name: Name for the generated class (e.g., 'BasePetStoreClient').
         default_base_url: Default base URL from the OpenAPI spec.
         default_timeout: Default request timeout in seconds.
+        pydantic_version: Target Pydantic version (1 or 2).  Affects which
+            response-unwrapping pattern is emitted in ``_parse_response``.
 
     Returns:
         Tuple of (class AST node, required imports).
     """
-    imports: ImportDict = {
-        'httpx': {'Client', 'AsyncClient', 'Response', 'TransportError'},
-        'typing': {'Any', 'TypeVar'},
-        'types': {'UnionType'},
-        'pydantic': {'TypeAdapter', 'RootModel'},
-        '._retry': {'_backoff_sleep', '_backoff_sleep_async'},
-    }
+    if pydantic_version == 1:
+        imports: ImportDict = {
+            'httpx': {'Client', 'AsyncClient', 'Response', 'TransportError'},
+            'typing': {'Any'},
+            'types': {'UnionType'},
+            'pydantic': {'TypeAdapter'},
+            '._retry': {'_backoff_sleep', '_backoff_sleep_async'},
+        }
+    else:
+        imports = {
+            'httpx': {'Client', 'AsyncClient', 'Response', 'TransportError'},
+            'typing': {'Any'},
+            'types': {'UnionType'},
+            'pydantic': {'TypeAdapter', 'RootModel'},
+            '._retry': {'_backoff_sleep', '_backoff_sleep_async'},
+        }
 
     # Build __init__ method
     init_method = _build_init_method(default_base_url, default_timeout)
@@ -696,10 +708,14 @@ def generate_base_client_class(
     validate_response_method = _build_validate_response_method()
 
     # Build _parse_response method (sync)
-    parse_response_method = _build_parse_response_method(is_async=False)
+    parse_response_method = _build_parse_response_method(
+        is_async=False, pydantic_version=pydantic_version
+    )
 
     # Build _parse_response_async method (async)
-    async_parse_response_method = _build_parse_response_method(is_async=True)
+    async_parse_response_method = _build_parse_response_method(
+        is_async=True, pydantic_version=pydantic_version
+    )
 
     # Build class body
     class_body: list[ast.stmt] = [
@@ -1049,10 +1065,19 @@ def _build_validate_response_method() -> ast.FunctionDef:
 
 def _build_parse_response_method(
     is_async: bool,
+    pydantic_version: int = 2,
 ) -> ast.FunctionDef | ast.AsyncFunctionDef:
     """Build the _parse_response or _parse_response_async method.
 
     This method handles JSON parsing and Pydantic validation of responses.
+
+    Args:
+        is_async: Whether to generate the async variant.
+        pydantic_version: Target Pydantic version (1 or 2).  For v2, the method
+            emits an ``isinstance(validated, RootModel)`` check and returns
+            ``validated.root``.  For v1, RootModel does not exist; instead the
+            method checks ``hasattr(validated, '__root__')`` and returns
+            ``validated.__root__``.
     """
     method_name = '_parse_response_async' if is_async else '_parse_response'
 
@@ -1073,14 +1098,8 @@ def _build_parse_response_method(
         defaults=[],
     )
 
-    # Build the method body:
-    # data = response.json()
-    # validated = TypeAdapter(response_type).validate_python(data)
-    # self._validate_response(response, validated)
-    # if isinstance(validated, RootModel):
-    #     return validated.root
-    # return validated
-    body: list[ast.stmt] = [
+    # Common statements: parse JSON, validate with TypeAdapter, call hook
+    common: list[ast.stmt] = [
         # data = response.json()
         _assign(
             _name('data'),
@@ -1107,15 +1126,33 @@ def _build_parse_response_method(
                 args=[_name('response'), _name('validated')],
             )
         ),
-        # if isinstance(validated, RootModel): return validated.root
-        ast.If(
+    ]
+
+    if pydantic_version == 1:
+        # Pydantic v1: RootModel does not exist; use hasattr(validated, '__root__')
+        # if hasattr(validated, '__root__'): return validated.__root__
+        unwrap_stmt = ast.If(
+            test=_call(
+                func=_name('hasattr'),
+                args=[_name('validated'), ast.Constant(value='__root__')],
+            ),
+            body=[ast.Return(value=_attr('validated', '__root__'))],
+            orelse=[],
+        )
+    else:
+        # Pydantic v2: if isinstance(validated, RootModel): return validated.root
+        unwrap_stmt = ast.If(
             test=_call(
                 func=_name('isinstance'),
                 args=[_name('validated'), _name('RootModel')],
             ),
             body=[ast.Return(value=_attr('validated', 'root'))],
             orelse=[],
-        ),
+        )
+
+    body: list[ast.stmt] = [
+        *common,
+        unwrap_stmt,
         # return validated
         ast.Return(value=_name('validated')),
     ]
@@ -1126,7 +1163,7 @@ def _build_parse_response_method(
             args=args,
             body=body,
             decorator_list=[],
-            returns=_name('T'),
+            returns=_name('Any'),
         )
     else:
         return ast.FunctionDef(
@@ -1134,7 +1171,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.4}/otterapi/codegen/codegen.py

@@ -19,7 +19,6 @@ from otterapi.codegen.ast_utils import (
     ImportCollector,
     _all,
     _assign,
-    _call,
     _name,
     _union_expr,
 )
@@ -159,7 +158,9 @@ class Codegen(OpenAPIProcessor):
             SchemaValidationError: If the schema is not valid OpenAPI.
         """
         self.openapi = self._schema_loader.load(self.config.source)
-        self.typegen = TypeGenerator(self.openapi)
+        self.typegen = TypeGenerator(
+            self.openapi, pydantic_version=self.config.pydantic_version
+        )
 
     def _extract_response_info(self, operation: Operation) -> dict[int, ResponseInfo]:
         """Extract response information including content type from an operation.
@@ -1278,7 +1279,17 @@ class Codegen(OpenAPIProcessor):
 
         all_names: set[str] = set(endpoint_names)
         if self.config.reexport_models:
-            all_names |= import_collector._imports.get(MODELS_MODULE, set())
+            model_names = import_collector._imports.get(MODELS_MODULE, set())
+            if self.config.reexport_model_exclude_patterns:
+                model_names = {
+                    n
+                    for n in model_names
+                    if not any(
+                        fnmatch.fnmatch(n, pat)
+                        for pat in self.config.reexport_model_exclude_patterns
+                    )
+                }
+            all_names |= model_names
         final_body.append(_all(sorted(all_names)))
         final_body.extend(body)
 
@@ -1584,6 +1595,7 @@ class Codegen(OpenAPIProcessor):
             response_unwrap_config=self.config.response_unwrap,
             export_config=self.config.export,
             reexport_models=self.config.reexport_models,
+            reexport_model_exclude_patterns=self.config.reexport_model_exclude_patterns,
         )
 
         emitted = emitter.emit(
@@ -1653,6 +1665,7 @@ class Codegen(OpenAPIProcessor):
             class_name=base_client_name,
             default_base_url=base_url,
             default_timeout=30.0,
+            pydantic_version=self.config.pydantic_version,
         )
 
         # Build the _client.py file
@@ -1666,16 +1679,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.4}/otterapi/codegen/endpoints.py

@@ -227,7 +227,13 @@ 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 +268,10 @@ 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.4}/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.4}/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.4}/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.4/otterapi/codegen/runtime/_retry.py

@@ -0,0 +1,74 @@
+"""Retry and backoff helpers for OtterAPI generated clients."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def _backoff_sleep(attempt: int, factor: float, response: Any) -> None:
+    """Sleep before a retry, honouring the Retry-After header when present."""
+    status = getattr(response, 'status_code', None) if response is not None else None
+    if response is not None:
+        retry_after = response.headers.get('Retry-After')
+        if retry_after is not None:
+            try:
+                delay = float(retry_after)
+                logger.warning(
+                    'Retry-After header present; sleeping %.1fs before retry attempt %d '
+                    '(status=%s)',
+                    delay,
+                    attempt + 1,
+                    status,
+                )
+                time.sleep(delay)
+                return
+            except ValueError:
+                logger.debug(
+                    'Unrecognised Retry-After value %r; falling back to exponential backoff',
+                    retry_after,
+                )
+    delay = min(factor * (2**attempt), 60.0)
+    logger.debug(
+        'Retry attempt %d: sleeping %.1fs (status=%s)',
+        attempt + 1,
+        delay,
+        status,
+    )
+    time.sleep(delay)
+
+
+async def _backoff_sleep_async(attempt: int, factor: float, response: Any) -> None:
+    """Async variant of :func:`_backoff_sleep`."""
+    status = getattr(response, 'status_code', None) if response is not None else None
+    if response is not None:
+        retry_after = response.headers.get('Retry-After')
+        if retry_after is not None:
+            try:
+                delay = float(retry_after)
+                logger.warning(
+                    'Retry-After header present; sleeping %.1fs before retry attempt %d '
+                    '(status=%s)',
+                    delay,
+                    attempt + 1,
+                    status,
+                )
+                await asyncio.sleep(delay)
+                return
+            except ValueError:
+                logger.debug(
+                    'Unrecognised Retry-After value %r; falling back to exponential backoff',
+                    retry_after,
+                )
+    delay = min(factor * (2**attempt), 60.0)
+    logger.debug(
+        'Retry attempt %d: sleeping %.1fs (status=%s)',
+        attempt + 1,
+        delay,
+        status,
+    )
+    await asyncio.sleep(delay)

{otterapi-0.1.2 → otterapi-0.1.4}/otterapi/codegen/splitting.py

@@ -608,6 +608,7 @@ class SplitModuleEmitter:
         response_unwrap_config: ResponseUnwrapConfig | None = None,
         export_config: ExportConfig | None = None,
         reexport_models: bool = False,
+        reexport_model_exclude_patterns: list[str] | None = None,
     ):
         """Initialize the split module emitter.
 
@@ -622,6 +623,7 @@ class SplitModuleEmitter:
             response_unwrap_config: Optional response unwrap configuration.
             export_config: Optional export configuration.
             reexport_models: Whether to include model names in __all__.
+            reexport_model_exclude_patterns: Glob patterns of model names to exclude.
         """
         self.config = config
         self.output_dir = UPath(output_dir)
@@ -633,6 +635,9 @@ class SplitModuleEmitter:
         self.response_unwrap_config = response_unwrap_config
         self.export_config = export_config
         self.reexport_models = reexport_models
+        self.reexport_model_exclude_patterns: list[str] = (
+            reexport_model_exclude_patterns or []
+        )
         self._emitted_modules: list[EmittedModule] = []
         self._typegen_types: dict[str, Type] = {}
 
@@ -1302,8 +1307,17 @@ class SplitModuleEmitter:
 
         all_names = list(endpoint_names)
         if self.reexport_models:
-            model_names = sorted(import_collector._imports.get(MODELS_MODULE, set()))
-            all_names = sorted(set(all_names) | set(model_names))
+            model_names = import_collector._imports.get(MODELS_MODULE, set())
+            if self.reexport_model_exclude_patterns:
+                model_names = {
+                    n
+                    for n in model_names
+                    if not any(
+                        fnmatch.fnmatch(n, pat)
+                        for pat in self.reexport_model_exclude_patterns
+                    )
+                }
+            all_names = sorted(set(all_names) | model_names)
 
         final_body.append(_all(sorted(all_names)))
         final_body.extend(body)

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

@@ -402,6 +402,7 @@ def _binop_includes_none(node: ast.expr) -> bool:
 @dataclasses.dataclass
 class TypeGenerator(OpenAPIProcessor):
     types: dict[str, Type] = dataclasses.field(default_factory=dict)
+    pydantic_version: int = 2
 
     @staticmethod
     def _rename_type(type_: Type, new_name: str) -> None:
@@ -770,9 +771,7 @@ class TypeGenerator(OpenAPIProcessor):
                 keywords=field_keywords,
             )
 
-            field_type.add_implementation_import(
-                module=Field.__module__, name=Field.__name__
-            )
+            field_type.add_implementation_import(module='pydantic', name=Field.__name__)
 
         return ast.AnnAssign(
             target=_name(field_name),
@@ -853,7 +852,7 @@ class TypeGenerator(OpenAPIProcessor):
                 ctx=ast.Load(),
             )
             extra_imports['typing'] = {'Annotated'}
-            extra_imports.setdefault(Field.__module__, set()).add(Field.__name__)
+            extra_imports.setdefault('pydantic', set()).add(Field.__name__)
         else:
             annotation_ast = union_ast
 
@@ -900,27 +899,42 @@ class TypeGenerator(OpenAPIProcessor):
             field_types.append(type_)
         return body, field_types
 
-    @staticmethod
     def _prepend_model_config_and_docstring(
-        body: list[ast.stmt], schema: Schema, name: str
+        self, body: list[ast.stmt], schema: Schema, name: str
     ) -> list[ast.stmt]:
         """Prepend ``model_config``/deprecation-docstring statements to a model body.
 
-        When the schema declares ``additionalProperties: false``, this mirrors
-        that constraint via Pydantic's ``model_config = {'extra': 'forbid'}`` so
-        generated models actually reject unexpected fields at runtime. The
-        deprecation docstring (if any) is prepended after ``model_config`` so it
-        stays the first statement in the class body.
+        For Pydantic v2 (default), mirrors ``additionalProperties: false`` via
+        ``model_config = {'extra': 'forbid'}``.  For Pydantic v1, emits the
+        equivalent nested ``class Config: extra = 'forbid'`` form instead.
         """
         if schema.additionalProperties is False:
-            model_config_assign = ast.Assign(
-                targets=[_name('model_config')],
-                value=ast.Dict(
-                    keys=[ast.Constant(value='extra')],
-                    values=[ast.Constant(value='forbid')],
-                ),
-            )
-            body = [model_config_assign] + body
+            if self.pydantic_version == 1:
+                # Pydantic v1: class Config: extra = 'forbid'
+                config_class = ast.ClassDef(
+                    name='Config',
+                    bases=[],
+                    keywords=[],
+                    body=[
+                        ast.Assign(
+                            targets=[_name('extra')],
+                            value=ast.Constant(value='forbid'),
+                        )
+                    ],
+                    decorator_list=[],
+                    type_params=[],
+                )
+                body = [config_class] + body
+            else:
+                # Pydantic v2: model_config = {'extra': 'forbid'}
+                model_config_assign = ast.Assign(
+                    targets=[_name('model_config')],
+                    value=ast.Dict(
+                        keys=[ast.Constant(value='extra')],
+                        values=[ast.Constant(value='forbid')],
+                    ),
+                )
+                body = [model_config_assign] + body
 
         if schema.deprecated:
             deprecation_doc = ast.Expr(
@@ -983,10 +997,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)

{otterapi-0.1.2 → otterapi-0.1.4}/otterapi/config.py

@@ -1012,6 +1012,26 @@ class DocumentConfig(BaseModel):
         ),
     )
 
+    reexport_model_exclude_patterns: list[str] = Field(
+        default_factory=list,
+        description=(
+            'Glob patterns of model names to exclude from re-export when '
+            '``reexport_models`` is True. For example, '
+            '``["*Envelope*", "*ErrorResponse"]`` hides pagination wrappers '
+            'and error response bodies from the public API surface.'
+        ),
+    )
+
+    pydantic_version: Literal[1, 2] = Field(
+        default=2,
+        description=(
+            'Target Pydantic version (1 or 2). '
+            'Controls generated model syntax (model_config dict vs nested class Config, '
+            'model_dump() vs dict()), the RootModel / __root__ pattern in the '
+            'generated client, and the emitted _dataframe.py helper.'
+        ),
+    )
+
     module_split: ModuleSplitConfig = Field(
         default_factory=ModuleSplitConfig,
         description='Configuration for splitting endpoints into submodules.',

{otterapi-0.1.2 → otterapi-0.1.4}/pyproject.toml

@@ -53,6 +53,8 @@ otter = "otterapi.__main__:app"
 
 [dependency-groups]
 dev = [
+    "pytest>=9.0.2",
+    "pytest-asyncio>=1.3.0",
     "ruff>=0.14.2",
     "twine>=6.2.0",
     "vulture>=2.14",

otterapi-0.1.2/otterapi/codegen/runtime/_retry.py

@@ -1,33 +0,0 @@
-"""Retry and backoff helpers for OtterAPI generated clients."""
-
-from __future__ import annotations
-
-import asyncio
-import time
-from typing import Any
-
-
-def _backoff_sleep(attempt: int, factor: float, response: Any) -> None:
-    """Sleep before a retry, honouring the Retry-After header when present."""
-    if response is not None:
-        retry_after = response.headers.get('Retry-After')
-        if retry_after is not None:
-            try:
-                time.sleep(float(retry_after))
-                return
-            except ValueError:
-                pass
-    time.sleep(min(factor * (2**attempt), 60.0))
-
-
-async def _backoff_sleep_async(attempt: int, factor: float, response: Any) -> None:
-    """Async variant of :func:`_backoff_sleep`."""
-    if response is not None:
-        retry_after = response.headers.get('Retry-After')
-        if retry_after is not None:
-            try:
-                await asyncio.sleep(float(retry_after))
-                return
-            except ValueError:
-                pass
-    await asyncio.sleep(min(factor * (2**attempt), 60.0))