otterapi 0.1.3__tar.gz → 0.1.4__tar.gz

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

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

@@ -77,7 +77,9 @@ 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:
+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())

{otterapi-0.1.3 → 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'},
-        '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')),
     ]

{otterapi-0.1.3 → 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

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

@@ -228,8 +228,12 @@ class FunctionSignatureBuilder:
                 self._args.append(arg)
             else:
                 # 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))
+                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
@@ -264,7 +268,9 @@ class FunctionSignatureBuilder:
         if body.required:
             self._args.append(body_arg)
         else:
-            optional_body_annotation = _union_expr([body_annotation, ast.Constant(value=None)])
+            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))
 

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.3 → 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.3 → 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(

{otterapi-0.1.3 → 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.3 → 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.3/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))