clientele 2.1.0__tar.gz → 2.2.0__tar.gz

{clientele-2.1.0 → clientele-2.2.0}/.claude/settings.local.json

@@ -24,7 +24,8 @@
       "Bash(uv pip *)",
       "Bash(.venv/bin/pytest *)",
       "Bash(.venv/bin/python *)",
-      "Bash(pip list *)"
+      "Bash(pip list *)",
+      "Bash(git *)"
     ]
   }
 }

{clientele-2.1.0 → clientele-2.2.0}/.github/workflows/ci.yml

@@ -1,13 +1,17 @@
 name: CI - Lint and Test
 
-on: [push]
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
 
 jobs:
   build:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15-dev"]
     steps:
       #----------------------------------------------
       #       check-out repo and set-up python

{clientele-2.1.0 → clientele-2.2.0}/CHANGELOG.md

@@ -1,6 +1,14 @@
 # Change log
 
-## 2.1.0 UNRELEASED
+## 2.2.0
+
+- Support OpenAPI `default` and `const` in schema generation ([#247](https://github.com/phalt/clientele/pull/247)).
+- Fix `$ref` parameter types and double-nullable handling in client generation ([#247](https://github.com/phalt/clientele/pull/247)).
+- Fix array response schemas being emitted as plain type aliases (`list[...]`) which pydantic rejects in `response_map` — they are now emitted as `clientele.schemas.ListResponse` subclasses, which support `len()`, indexing, and iteration directly ([#248](https://github.com/phalt/clientele/issues/248)).
+- Fix generated `config.py` documenting `API_BASE_URL` as the environment variable name when pydantic-settings reads `BASE_URL` — the example now uses the correct name ([#248](https://github.com/phalt/clientele/issues/248)).
+- Initial CI support for Python 3.15
+
+## 2.1.0
 
 - Introduce `RequestsHTTPBackend` for making HTTP requests using the `requests` library.
   - This backend implements synchronous HTTP requests only.

{clientele-2.1.0 → clientele-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clientele
-Version: 2.1.0
+Version: 2.2.0
 Summary: Clientele is a different way to build Python API Clients
 Project-URL: Homepage, https://clientele.dev
 Project-URL: Changelog, https://docs.clientele.dev/CHANGELOG/

{clientele-2.1.0 → clientele-2.2.0}/SECURITY.md

@@ -4,8 +4,8 @@
 
 | Version       | Supported          |
 | --------------| ------------------ |
-| 2.1.0         | :white_check_mark: |
-| 2.0.0 or less | :x:                |
+| 2.2.0         | :white_check_mark: |
+| 2.1.0 or less | :x:                |
 
 ## Reporting a Vulnerability
 

{clientele-2.1.0 → clientele-2.2.0}/clientele/generators/api/templates/config_py.jinja2

@@ -19,14 +19,12 @@ class Config(clientele_api.BaseConfig):
 
     Example:
         # From environment variables
-        export API_BASE_URL="https://api.example.com"
-        export BEARER_TOKEN="my-secret-token"
+        export BASE_URL="https://api.example.com"
         config = Config()
 
         # Direct instantiation
         config = Config(
-            api_base_url="https://api.example.com",
-            bearer_token="my-token",
+            base_url="https://api.example.com",
             timeout=10.0
         )
     """

clientele-2.2.0/clientele/generators/api/templates/schema_root_model.jinja2

@@ -0,0 +1,4 @@
+
+
+class {{class_name}}(ListResponse[{{inner_type}}]):
+    pass

{clientele-2.1.0 → clientele-2.2.0}/clientele/generators/api/templates/schemas_py.jinja2

@@ -6,3 +6,5 @@ import decimal
 import enum
 
 import pydantic
+
+from clientele.schemas import ListResponse  # noqa

{clientele-2.1.0 → clientele-2.2.0}/clientele/generators/base_clients.py

@@ -143,16 +143,20 @@ class BaseClientsGenerator:
             required = param.get("required", False) or in_ != "query"
             if in_ == "query":
                 # URL query string values
+                param_type = utils.resolve_forward_refs_for_client(utils.get_type(param["schema"]))
                 if required:
-                    query_args[clean_key] = utils.get_type(param["schema"])
+                    query_args[clean_key] = param_type
                 else:
-                    query_args[clean_key] = f"typing.Optional[{utils.get_type(param['schema'])}]"
+                    param_type = utils.strip_none_from_type(param_type)
+                    query_args[clean_key] = f"typing.Optional[{param_type}]"
             elif in_ == "path":
                 # Function arguments
+                param_type = utils.resolve_forward_refs_for_client(utils.get_type(param["schema"]))
                 if required:
-                    path_args[clean_key] = utils.get_type(param["schema"])
+                    path_args[clean_key] = param_type
                 else:
-                    path_args[clean_key] = f"typing.Optional[{utils.get_type(param['schema'])}]"
+                    param_type = utils.strip_none_from_type(param_type)
+                    path_args[clean_key] = f"typing.Optional[{param_type}]"
             elif in_ == "header":
                 # Header object arguments
                 headers_args[param["name"]] = utils.get_type(param["schema"])

{clientele-2.1.0 → clientele-2.2.0}/clientele/generators/cicerone_compat.py

@@ -191,6 +191,14 @@ def schema_to_dict(schema) -> dict:
     if hasattr(schema, "__pydantic_extra__") and schema.__pydantic_extra__ and "enum" in schema.__pydantic_extra__:
         result["enum"] = schema.__pydantic_extra__["enum"]
 
+    # Handle default - it's in the extra fields; use "in" check since defaults can be falsy
+    if hasattr(schema, "__pydantic_extra__") and schema.__pydantic_extra__ and "default" in schema.__pydantic_extra__:
+        result["default"] = schema.__pydantic_extra__["default"]
+
+    # Handle const - it's in the extra fields
+    if hasattr(schema, "__pydantic_extra__") and schema.__pydantic_extra__ and "const" in schema.__pydantic_extra__:
+        result["const"] = schema.__pydantic_extra__["const"]
+
     # Handle properties
     if hasattr(schema, "properties") and schema.properties:
         result["properties"] = {k: schema_to_dict(v) for k, v in schema.properties.items()}

{clientele-2.1.0 → clientele-2.2.0}/clientele/generators/shared/generators/schemas.py

@@ -54,12 +54,19 @@ class SchemasGenerator:
             sanitized_arg = utils.snake_case_prop(arg)
             arg_type = utils.get_type(arg_details)
             is_optional = required and arg not in required
+            has_default = "default" in arg_details
 
             needs_alias = sanitized_arg != arg
             if needs_alias:
                 has_aliases = True
 
-            if is_optional and not arg_type.startswith("typing.Optional["):
+            if has_default:
+                py_default = repr(arg_details["default"])
+                if needs_alias:
+                    type_string = f'{arg_type} = pydantic.Field(default={py_default}, alias="{arg}")'
+                else:
+                    type_string = f"{arg_type} = {py_default}"
+            elif is_optional and not arg_type.startswith("typing.Optional["):
                 if needs_alias:
                     type_string = f'typing.Optional[{arg_type}] = pydantic.Field(default=None, alias="{arg}")'
                 else:
@@ -128,10 +135,15 @@ class SchemasGenerator:
             return
 
         if schema.get("type") == "array":
-            array_type = utils.get_type(schema)
-            array_type = utils.remove_forward_ref_quotes(array_type)
-            template = self.writer.templates.get_template("schema_type_alias.jinja2")
-            content = template.render(class_name=schema_key, union_type=array_type)
+            # Emit a pydantic.RootModel subclass rather than a plain type alias.
+            # list[...] is a GenericAlias, not a type, so pydantic rejects it
+            # when it appears in response_map: dict[int, type[Any]].  A RootModel
+            # subclass is a proper class and satisfies that constraint.
+            items_schema = schema.get("items") or {}
+            item_type = utils.get_type(items_schema) if items_schema else "typing.Any"
+            item_type = utils.remove_forward_ref_quotes(item_type)
+            template = self.writer.templates.get_template("schema_root_model.jinja2")
+            content = template.render(class_name=schema_key, inner_type=item_type)
             self.writer.write_to_schemas(content, output_dir=self.output_dir)
             self.schemas[schema_key] = ""
             return

{clientele-2.1.0 → clientele-2.2.0}/clientele/generators/shared/utils.py

@@ -97,6 +97,9 @@ def get_func_name(operation: dict, path: str) -> str:
 
 
 def get_type(t):
+    if "const" in t:
+        return f"typing.Literal[{repr(t['const'])}]"
+
     t_type = t.get("type")
     t_format = t.get("format")
     t_nullable = t.get("nullable", False)
@@ -277,8 +280,21 @@ def remove_forward_ref_quotes(type_string: str) -> str:
     This is used for type aliases where forward references are not needed
     because all types are defined in the same module and model_rebuild() is called.
     """
-    import re
-
-    # Replace quoted strings within type annotations
-    # Pattern: matches quoted strings that are type names (alphanumeric + underscore)
     return re.sub(r'"([A-Za-z_][A-Za-z0-9_]*)"', r"\1", type_string)
+
+
+def resolve_forward_refs_for_client(type_string: str) -> str:
+    """Replace forward references with schemas module references for client.py context."""
+    return re.sub(r'"([A-Za-z_][A-Za-z0-9_]*)"', r"schemas.\1", type_string)
+
+
+def strip_none_from_type(type_string: str) -> str:
+    """Strip None/Optional wrapping so the caller can re-wrap without duplication."""
+    if type_string.startswith("typing.Optional[") and type_string.endswith("]"):
+        return type_string[len("typing.Optional[") : -1]
+    m = re.match(r"^typing\.Union\[(.+),\s*None\]$", type_string)
+    if m:
+        return m.group(1)
+    if type_string.endswith(" | None"):
+        return type_string[: -len(" | None")]
+    return type_string

clientele-2.2.0/clientele/schemas.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import typing
+
+import pydantic
+
+_Item = typing.TypeVar("_Item")
+
+
+class ListResponse(pydantic.RootModel[list[_Item]]):
+    """Base class for array response schemas. Provides list-like access to the root list."""
+
+    def __len__(self) -> int:
+        return len(self.root)
+
+    def __getitem__(self, index: int) -> _Item:
+        return self.root[index]
+
+    def __iter__(self) -> typing.Iterator[_Item]:  # ty: ignore[invalid-method-override]
+        return iter(self.root)

{clientele-2.1.0 → clientele-2.2.0}/clientele/settings.py

@@ -1,6 +1,6 @@
 import platform
 
-VERSION = "2.1.0"
+VERSION = "2.2.0"
 
 
 def split_ver():

{clientele-2.1.0 → clientele-2.2.0}/docs/CHANGELOG.md

@@ -1,6 +1,14 @@
 # Change log
 
-## 2.1.0 UNRELEASED
+## 2.2.0
+
+- Support OpenAPI `default` and `const` in schema generation ([#247](https://github.com/phalt/clientele/pull/247)).
+- Fix `$ref` parameter types and double-nullable handling in client generation ([#247](https://github.com/phalt/clientele/pull/247)).
+- Fix array response schemas being emitted as plain type aliases (`list[...]`) which pydantic rejects in `response_map` — they are now emitted as `clientele.schemas.ListResponse` subclasses, which support `len()`, indexing, and iteration directly ([#248](https://github.com/phalt/clientele/issues/248)).
+- Fix generated `config.py` documenting `API_BASE_URL` as the environment variable name when pydantic-settings reads `BASE_URL` — the example now uses the correct name ([#248](https://github.com/phalt/clientele/issues/248)).
+- Initial CI support for Python 3.15
+
+## 2.1.0
 
 - Introduce `RequestsHTTPBackend` for making HTTP requests using the `requests` library.
   - This backend implements synchronous HTTP requests only.

{clientele-2.1.0 → clientele-2.2.0}/docs/api-overview.md

@@ -26,7 +26,7 @@ How Clientele works:
 - Path parameters inside `{}` are filled from the function arguments (e.g. `user_id`).
 - Any remaining keyword arguments (like `include_details` above) become query parameters, but you can also provide a dict function parameter `query={...}` instead.
 - The **`result` parameter is mandatory** and its type annotation (`User`) drives response parsing.
-- Your function is injected with the `result` parameter - this is the response payload hydrated into your `result` parameter's type.
+- Your function is injected with the `result` parameter - this is the response payload hydrated into your `result` parameter's type. Callers never supply it; Clientele injects it after the HTTP response arrives.
 - The function's return value is independent - you can return the result directly, transform it, or return something completely different.
 
 ## HTTP POST example
@@ -147,31 +147,9 @@ Clientele will inject the following parameters into your function once an http r
 - `result`: an instance of the type specified in the `result` parameter annotation. This parameter is **mandatory** and its type annotation determines how the response is parsed. Can be a Pydantic model or a TypedDict.
 - `response`: the `httpx.Response` - useful for logging, debugging etc. (optional)
 
-**Both `result` and `response` must be declared first in your function signature**, before any caller-supplied parameters (path params, query params, `data`). This is required for type checker support (see below).
+**Both `result` and `response` must be declared first in your function signature**, before any caller-supplied parameters (path params, query params, `data`).
 
-## Typing support for injected parameters
-
-Clientele does some Python typing magic to give type checkers (mypy, pyright, ty) a correct view of your decorated functions.
-
-The decorator type signature says: *"I accept a function whose first parameter(s) are injected values, and I return a new callable with those parameters removed."* This means type checkers see the public API — for example `get_user` is typed as `(user_id: int) -> User`, with `result` invisible to callers.
-
-For this to work, **`result` and `response` must appear first** in the parameter list:
-
-```python
-# Correct — injected params first, type checker sees: (user_id: int) -> User
-@client.get("/users/{user_id}")
-def get_user(result: User, user_id: int) -> User:
-    return result
-
-# Incorrect — result is not first, typing will not work correctly
-@client.get("/users/{user_id}")
-def get_user(user_id: int, result: User) -> User:
-    return result
-```
-
-At runtime, Clientele also patches the function's signature to hide `result` and `response` from introspection tools (IDEs, `inspect.signature()`, the cache key generator). This uses the same ordering rule: injected params are identified by name, stripped from the public signature, and injected automatically when the HTTP response arrives.
-
-If you use the [mypy plugin](mypy.md), mypy will also strip injected parameters by name regardless of position — but for other type checkers (pyright, ty) the position-first rule is required.
+For a full explanation of why this constraint exists, how Clientele hides these parameters from callers and type checkers, and how to configure mypy support, see [Injected parameters & typing](injected-parameters.md).
 
 ## Response parsing rules
 

clientele-2.2.0/docs/injected-parameters.md

@@ -0,0 +1,135 @@
+# Injected parameters & typing
+
+## The problem they solve
+
+When you decorate a function with `@client.get(...)`, Clientele needs to hand back the parsed HTTP response to your function body. The natural way to do that is through a parameter, but that creates an awkward situation:
+
+```python
+@client.get("/users/{user_id}")
+def get_user(result: User, user_id: int) -> User:
+    return result
+```
+
+From *inside* the function, `result` is essential because it holds the `User` parsed from the response. But from the *caller's* perspective, `result` makes no sense: callers supply `user_id`, not a `User` they already have. If Clientele exposed `result` in the public signature, every call site would look broken:
+
+```python
+# Without injection stripping the callers would need to provide result themselves:
+get_user(result=???, user_id=42)
+```
+
+Injected parameters are how Clientele resolves this: `result` (and the optional `response`) live in the function definition for *your* use, but Clientele **strips them from the public signature** so callers never see them.
+
+---
+
+## What callers and IDEs see
+
+Clientele uses Python's `typing.Concatenate` and `typing.ParamSpec` to express this contract to type checkers at the decorator level. The decorator signature says: *"I accept a function whose first N parameters are injected values, and I return a new callable with those parameters removed."*
+
+The result is that your IDE and type checker see the **public API**, not the implementation detail:
+
+```
+# What you write:
+def get_user(result: User, user_id: int) -> User
+
+# What your IDE and type checker see after decoration:
+get_user(user_id: int) -> User
+```
+
+So autocomplete shows `user_id`, not `result`. Passing `user_id=42` produces no type error. Passing `result=...` produces an error, because `result` isn't in the public signature at all.
+
+```python
+get_user(user_id=42)        # ✅ correct
+get_user(result=my_user, user_id=42)  # ❌ type error: unknown argument
+```
+
+At runtime, Clientele also patches the function's `__signature__` so that `inspect.signature()`, IDEs using runtime introspection, and Clientele's own cache key generator all agree with what the type checker sees.
+
+---
+
+## Injected parameters
+
+Clientele injects the following parameters:
+
+| Parameter  | Type                       | Required | Description                                                         |
+|------------|----------------------------|----------|---------------------------------------------------------------------|
+| `result`   | Your annotated type        | Yes      | The HTTP response body, parsed and validated into the declared type |
+| `response` | `http.Response`            | No       | The raw `http.Response`, useful for headers, status, debugging     |
+
+```python
+from pydantic import BaseModel
+from clientele import api as clientele_api
+
+client = clientele_api.APIClient(base_url="https://api.example.com")
+
+class User(BaseModel):
+    id: int
+    name: str
+
+# result only — the common case
+@client.get("/users/{user_id}")
+def get_user(result: User, user_id: int) -> User:
+    return result
+
+# result + response — when you need headers or status
+@client.get("/users/{user_id}")
+def get_user_with_meta(result: User, response: httpx.Response, user_id: int) -> tuple[User, int]:
+    return result, response.status_code
+```
+
+---
+
+## Ordering requirement
+
+**`result` and `response` must appear first in the parameter list**, before any caller-supplied parameters (path params, query params, `data`).
+
+This is required because the `Concatenate` trick works by stripping parameters from the *front* of the signature. If injected params appear anywhere else, the type math breaks and type checkers will see the wrong signature.
+
+```python
+# ✅ Correct: injected params first
+# Type checker sees: get_user(user_id: int) -> User
+@client.get("/users/{user_id}")
+def get_user(result: User, user_id: int) -> User:
+    return result
+
+# ❌ Incorrect: result is not first
+# Type checker sees: get_user(user_id: int, result: User) -> User
+@client.get("/users/{user_id}")
+def get_user(user_id: int, result: User) -> User:
+    return result
+```
+
+The runtime injection works regardless of position (Clientele finds injected params by name), but **correct typing requires them first**.
+
+---
+
+## Mypy plugin
+
+Mypy does not natively support the `Concatenate`-based approach for stripping positional parameters. Clientele ships a mypy plugin that teaches mypy the same rule explicitly:
+
+- Removes `result` and `response` from decorated function signatures during type checking
+- Allows `dict` types to be passed where Pydantic models are expected (TypedDict ergonomics)
+
+### Setup
+
+The plugin is installed automatically with Clientele. Add it to your mypy configuration:
+
+=== "mypy.ini / setup.cfg"
+
+    ```ini
+    [mypy]
+    plugins = clientele.mypy
+    ```
+
+=== "pyproject.toml"
+
+    ```toml
+    [tool.mypy]
+    plugins = ["clientele.mypy"]
+    ```
+
+With the plugin active, mypy behaves the same as pyright and ty: `result` and `response` are invisible to callers.
+
+!!! note
+    If you use **pyright** or **ty**, no plugin is needed — the `Concatenate`-based decorator signature is supported natively. Just ensure injected params appear first (see above).
+
+---

{clientele-2.1.0 → clientele-2.2.0}/docs/install.md

@@ -47,7 +47,7 @@ Once installed, you can run `clientele version` to confirm:
 
 ```sh
 > clientele version
-clientele 2.1.0
+clientele 2.2.0
 ```
 
 ## Next steps

clientele-2.2.0/example_openapi_specs/issue_248.json

@@ -0,0 +1,85 @@
+{
+  "openapi": "3.0.2",
+  "info": {
+    "title": "Issue 248 Reproduction",
+    "description": "Reproduces Bug 2 (array RootModel) and Bug 3 (config env var name) from issue #248",
+    "version": "1.0.0"
+  },
+  "servers": [
+    {"url": "https://api.example.com"}
+  ],
+  "paths": {
+    "/faces": {
+      "get": {
+        "summary": "Get Faces",
+        "operationId": "get_faces",
+        "parameters": [
+          {
+            "name": "faces_type",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "type": "array",
+              "items": {"$ref": "#/components/schemas/FaceTypeEnum"}
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {"$ref": "#/components/schemas/FaceItem"}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/upload-faces": {
+      "post": {
+        "summary": "Upload Faces",
+        "operationId": "upload_faces",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {"$ref": "#/components/schemas/FaceItem"}
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {"$ref": "#/components/schemas/FaceItem"}
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "FaceTypeEnum": {
+        "type": "string",
+        "enum": ["FRONT", "SIDE", "BACK"],
+        "title": "FaceTypeEnum"
+      },
+      "FaceItem": {
+        "type": "object",
+        "title": "FaceItem",
+        "properties": {
+          "id": {"type": "integer"},
+          "name": {"type": "string"}
+        },
+        "required": ["id", "name"]
+      }
+    }
+  }
+}

{clientele-2.1.0 → clientele-2.2.0}/mkdocs.yml

@@ -49,7 +49,7 @@ nav:
     - 🪵 Logging: api-logging.md
     - 🧪 Testing: api-testing.md
     - 🎯 Direct requests: api-direct-requests.md
-    - 🥧 Mypy support: mypy.md
+    - 💉 Injected parameters & typing: injected-parameters.md
   - 📟 Command line tools:
     - 🏗️ Client creator: openapi-cli.md
   - ⚡️ API Server Integrations:

{clientele-2.1.0 → clientele-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "clientele"
-version = "2.1.0"
+version = "2.2.0"
 description = "Clientele is a different way to build Python API Clients"
 authors = [{ name = "Paul Hallett", email = "paulandrewhallett@gmail.com" }]
 license = { text = "MIT" }

{clientele-2.1.0 → clientele-2.2.0}/server_examples/django_ninja/client/MANIFEST.md

@@ -16,7 +16,7 @@ uv add clientele
 
 API VERSION: 1.0.0
 OPENAPI VERSION: 3.1.0
-CLIENTELE VERSION: 2.1.0
+CLIENTELE VERSION: 2.2.0
 
 Regenerate using this command:
 

{clientele-2.1.0 → clientele-2.2.0}/server_examples/django_ninja/client/schemas.py

@@ -5,6 +5,8 @@ import typing
 
 import pydantic
 
+from clientele.schemas import ListResponse  # noqa
+
 
 class UserOut(pydantic.BaseModel):
     id: int
@@ -19,7 +21,8 @@ class UserIn(pydantic.BaseModel):
     age: int
 
 
-Response = list[UserOut]
+class Response(ListResponse[UserOut]):
+    pass
 
 
 def get_subclasses_from_same_file() -> list[typing.Type[pydantic.BaseModel]]:

{clientele-2.1.0 → clientele-2.2.0}/server_examples/django_rest_framework/client/MANIFEST.md

@@ -16,7 +16,7 @@ uv add clientele
 
 API VERSION: 1.0.0
 OPENAPI VERSION: 3.0.3
-CLIENTELE VERSION: 2.1.0
+CLIENTELE VERSION: 2.2.0
 
 Regenerate using this command:
 

{clientele-2.1.0 → clientele-2.2.0}/server_examples/django_rest_framework/client/schemas.py

@@ -5,6 +5,8 @@ import typing
 
 import pydantic
 
+from clientele.schemas import ListResponse  # noqa
+
 
 class PatchedUser(pydantic.BaseModel):
     id: int
@@ -25,7 +27,8 @@ class UserRequest(pydantic.BaseModel):
     email: str
 
 
-ListUsers200Response = list[User]
+class ListUsers200Response(ListResponse[User]):
+    pass
 
 
 def get_subclasses_from_same_file() -> list[typing.Type[pydantic.BaseModel]]:

{clientele-2.1.0 → clientele-2.2.0}/server_examples/fastapi/client/MANIFEST.md

@@ -16,7 +16,7 @@ uv add clientele
 
 API VERSION: 1.0.0
 OPENAPI VERSION: 3.1.0
-CLIENTELE VERSION: 2.1.0
+CLIENTELE VERSION: 2.2.0
 
 Regenerate using this command:
 

{clientele-2.1.0 → clientele-2.2.0}/server_examples/fastapi/client/schemas.py

@@ -5,6 +5,8 @@ import typing
 
 import pydantic
 
+from clientele.schemas import ListResponse  # noqa
+
 
 class CreateUserRequest(pydantic.BaseModel):
     name: str
@@ -29,7 +31,8 @@ class ValidationError(pydantic.BaseModel):
     model_config = pydantic.ConfigDict(populate_by_name=True)
 
 
-ResponseListUsers = list[UserResponse]
+class ResponseListUsers(ListResponse[UserResponse]):
+    pass
 
 
 def get_subclasses_from_same_file() -> list[typing.Type[pydantic.BaseModel]]: