dynamicapiclient 0.1.2__tar.gz

dynamicapiclient-0.1.2/.cursor/rules/test-coverage.mdc

@@ -0,0 +1,10 @@
+---
+description: Keep total test coverage at or above 90% for pyapiclient
+alwaysApply: true
+---
+
+# Test coverage
+
+- **Target:** total coverage for the `pyapiclient` package must stay **≥ 90%** (pytest-cov with branch coverage enabled, same settings as `pyproject.toml`).
+- **Scope:** all modules under `src/pyapiclient/` — when adding or changing code, add or extend tests so new branches and lines remain covered. Do not lower `--cov-fail-under` to “make CI green” without restoring coverage.
+- **Check locally:** `pytest -q --cov=pyapiclient --cov-fail-under=90` (or `pre-commit run --all-files` after hooks are installed).

dynamicapiclient-0.1.2/.github/workflows/ci.yml

@@ -0,0 +1,46 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: pip install --upgrade pip && pip install -e ".[dev]"
+
+      - name: Run tests with coverage
+        run: >
+          pytest -q
+          --cov=pyapiclient
+          --cov-report=xml
+          --cov-report=term-missing
+          --cov-fail-under=90
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          use_oidc: true
+          files: coverage.xml
+          flags: py${{ matrix.python-version }}
+          name: Python-${{ matrix.python-version }}
+          fail_ci_if_error: true

dynamicapiclient-0.1.2/.github/workflows/publish-pypi.yml

@@ -0,0 +1,48 @@
+# Publish dynamicapiclient to PyPI when a GitHub Release is published.
+# Auto-created releases use release-from-version.yml, which publishes to PyPI
+# in the same job (GitHub does not chain workflows for GITHUB_TOKEN events).
+#
+# The value of [project].name in pyproject.toml must match the PyPI project name
+# configured for trusted publishing, or uploads fail with HTTP 400.
+#
+# Trusted publishing (recommended): https://docs.pypi.org/trusted-publishers/
+#   PyPI → Your project → Publishing → Add a pending publisher
+#   Provider: GitHub, repo, workflow file: publish-pypi.yml (environment name optional).
+#
+# Token fallback: add a repo secret PYPI_API_TOKEN (PyPI → Account → API tokens) and set:
+#   with:
+#     password: ${{ secrets.PYPI_API_TOKEN }}
+#
+# Manual run: Actions → this workflow → Run workflow (pick branch; default main).
+
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: pip install --upgrade build
+
+      - name: Build sdist and wheel
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true

dynamicapiclient-0.1.2/.github/workflows/release-from-version.yml

@@ -0,0 +1,83 @@
+# When [project].version changes on main (any edit to pyproject.toml), create a
+# GitHub Release and tag v{version} if that tag does not exist yet, then publish
+# to PyPI in this same workflow.
+#
+# GitHub does not run other workflows in response to events raised with the
+# default GITHUB_TOKEN (e.g. creating a release here), so publish-pypi.yml would
+# never fire for bot-created releases. Manual releases from the UI still trigger
+# publish-pypi.yml normally.
+
+name: Release from pyproject version
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "pyproject.toml"
+
+permissions:
+  contents: write
+  id-token: write
+
+jobs:
+  maybe-release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Read version from pyproject.toml
+        id: version
+        run: |
+          VERSION=$(python3 <<'PY'
+          import tomllib
+          from pathlib import Path
+          with Path("pyproject.toml").open("rb") as f:
+              print(tomllib.load(f)["project"]["version"])
+          PY
+          )
+          echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
+
+      - name: Fetch tags
+        run: git fetch origin --tags
+
+      - name: Check if tag already exists
+        id: tag
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          TAG="v${VERSION}"
+          if git rev-parse -q --verify "refs/tags/${TAG}" >/dev/null; then
+            echo "exists=true" >> "$GITHUB_OUTPUT"
+            echo "Tag ${TAG} already exists; skipping release."
+          else
+            echo "exists=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Create GitHub Release
+        if: steps.tag.outputs.exists == 'false'
+        uses: softprops/action-gh-release@153bb8e04406b158c6c84fc1615b65b24149a1fe
+        with:
+          tag_name: v${{ steps.version.outputs.version }}
+          name: v${{ steps.version.outputs.version }}
+          generate_release_notes: true
+
+      - uses: actions/setup-python@v5
+        if: steps.tag.outputs.exists == 'false'
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        if: steps.tag.outputs.exists == 'false'
+        run: pip install --upgrade build
+
+      - name: Build sdist and wheel
+        if: steps.tag.outputs.exists == 'false'
+        run: python -m build
+
+      - name: Publish to PyPI
+        if: steps.tag.outputs.exists == 'false'
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true

dynamicapiclient-0.1.2/.gitignore

@@ -0,0 +1,15 @@
+.venv/
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+.coverage
+coverage.xml
+htmlcov/
+dist/
+*.egg-info/
+.eggs/
+*.egg
+.mypy_cache/
+.ruff_cache/
+.DS_Store

dynamicapiclient-0.1.2/.pre-commit-config.yaml

@@ -0,0 +1,15 @@
+# See https://pre-commit.com for usage: pip install pre-commit && pre-commit install
+
+repos:
+  - repo: local
+    hooks:
+      - id: pytest
+        name: pytest (coverage ≥90%)
+        entry: python -m pytest
+        language: system
+        pass_filenames: false
+        always_run: true
+        args:
+          - -q
+          - --cov=pyapiclient
+          - --cov-fail-under=90

dynamicapiclient-0.1.2/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: dynamicapiclient
+Version: 0.1.2
+Summary: pyAPIClient: Django-like dynamic ORM models generated from OpenAPI 2/3 or GraphQL schemas
+Author: pyAPIClient contributors
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: pyyaml>=6
+Provides-Extra: dev
+Requires-Dist: graphql-core<4,>=3.2; extra == 'dev'
+Requires-Dist: pre-commit>=4; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Provides-Extra: graphql
+Requires-Dist: graphql-core<4,>=3.2; extra == 'graphql'
+Description-Content-Type: text/markdown
+
+# pyAPIClient
+
+[![CI](https://github.com/stuart23/pyapiclient/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/stuart23/pyapiclient/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/stuart23/pyapiclient/graph/badge.svg?branch=main)](https://codecov.io/gh/stuart23/pyapiclient)
+
+Generate **Django-like** model classes from an **OpenAPI 2** or **OpenAPI 3** document, or a **GraphQL schema** (SDL or introspection JSON), as a URL or local file. OpenAPI schemas under `definitions` (v2) or `components.schemas` (v3) become models with `.objects` wired to REST paths. GraphQL **object types** become models whose `.objects` issues `query` / `mutation` operations against a single HTTP endpoint (default `POST /graphql`).
+
+## Install
+
+The **PyPI distribution** is [`dynamicapiclient`](https://pypi.org/project/dynamicapiclient/) (`pip install dynamicapiclient`). The **Python import package** remains `pyapiclient` (`import pyapiclient`). This project is referred to as **pyAPIClient** in documentation.
+
+```bash
+pip install -e .
+# or, with dev dependencies:
+pip install -e ".[dev]"
+# GraphQL support (graphql-core):
+pip install -e ".[graphql]"
+```
+
+Requires Python 3.10+. GraphQL requires the optional `graphql` extra (`graphql-core`).
+
+### Tests, coverage, and pre-commit
+
+CI-style checks use **≥90%** coverage on `pyapiclient` (see `pyproject.toml`). Run:
+
+```bash
+pytest -q --cov=pyapiclient --cov-fail-under=90
+```
+
+[GitHub Actions](https://github.com/stuart23/pyapiclient/actions/workflows/ci.yml) runs the same suite on Python 3.10–3.13 and uploads coverage to [**Codecov**](https://codecov.io/gh/stuart23/pyapiclient) via **OIDC** (no `CODECOV_TOKEN` needed on the main repo). Add the project in Codecov once so the badge and graphs populate. Forks or private mirrors may need a **`CODECOV_TOKEN`** secret—see [Codecov’s docs](https://docs.codecov.com/docs/codecov-tokens).
+
+With a **Git** checkout, install [`pre-commit`](https://pre-commit.com/) (`pip install pre-commit` or use the `dev` extra) and run `pre-commit install` so commits run the same pytest command via [`.pre-commit-config.yaml`](.pre-commit-config.yaml).
+
+## Quick start (fixture spec)
+
+This repo includes a sample OpenAPI 3 spec at [`tests/fixtures/library_oas3.yaml`](tests/fixtures/library_oas3.yaml). It describes a small “library” API with `Author` and `Book` schemas and paths under `https://api.example.com/v1`.
+
+Load the spec from disk and build the API object:
+
+```python
+from pathlib import Path
+
+from pyapiclient import api_make  # or: from pyapiclient import apiMake
+
+spec_path = Path("tests/fixtures/library_oas3.yaml")
+# Or an absolute path on your machine.
+
+MyAPI = api_make(spec_path)
+```
+
+Discover generated models (works well in a REPL):
+
+```python
+dir(MyAPI.models)          # ['Author', 'Book']
+list(MyAPI.models)         # model classes
+MyAPI.models.model_names() # ('Author', 'Book')
+```
+
+The spec’s `servers[0].url` is used as the HTTP base URL unless you override it:
+
+```python
+MyAPI = api_make(spec_path, base_url="http://localhost:8000/v1")
+```
+
+### Creating and reading resources
+
+The fixture marks `name` and `email` as required on `Author`, and `title` and `author_id` on `Book`. **Your server must actually implement** the described paths (`POST /authors`, `GET /authors/{author_id}`, `POST /books`, etc.); the YAML file is only the contract.
+
+```python
+author = MyAPI.models.Author.objects.create(
+    name="J.R.R. Tolkien",
+    email="tolkien@example.com",
+)
+
+book = MyAPI.models.Book.objects.create(
+    title="The Hobbit",
+    author_id=author.pk,
+)
+```
+
+**Note:** In `library_oas3.yaml`, `Book` only defines `id`, `title`, and `author_id`. Pass only fields that appear in the schema (extra fields raise validation errors). This fixture uses an integer `author_id`, not a nested `author=` relation object.
+
+Other useful calls:
+
+```python
+same = MyAPI.models.Author.objects.get(pk=author.pk)
+for a in MyAPI.models.Author.objects.filter(name="J.R.R. Tolkien"):
+    print(a.pk, a._data["email"])
+
+MyAPI.models.Author.objects.update(same, email="tolkien@tolkien.estate")
+MyAPI.models.Author.objects.delete(same)
+```
+
+Close the underlying HTTP client when you are done (optional but good practice):
+
+```python
+MyAPI.close()
+# or: with api_make(...) as MyAPI: ...
+```
+
+### Headers (e.g. auth)
+
+```python
+MyAPI = api_make(
+    spec_path,
+    headers={"Authorization": "Bearer YOUR_TOKEN"},
+)
+```
+
+### Loading from a URL
+
+```python
+MyAPI = api_make("https://example.com/openapi.yaml")
+```
+
+### Swagger 2 example
+
+[`tests/fixtures/swagger2_library.json`](tests/fixtures/swagger2_library.json) defines a `Widget` model. Load it the same way; Swagger 2 uses `host` + `basePath` + `schemes` for the base URL, or pass `base_url=...` explicitly.
+
+## GraphQL schema (SDL or introspection JSON)
+
+Install `graphql-core` (`pip install "dynamicapiclient[graphql]"`). Point `api_make` at a `.graphql` / `.gql` file, a JSON introspection export (`data.__schema` or bare `__schema`), or a URL whose body looks like GraphQL SDL or introspection. You **must** pass `base_url=` to the HTTP server root; SDL does not carry a server URL.
+
+```python
+from pathlib import Path
+
+from pyapiclient import api_make
+
+schema_path = Path("tests/fixtures/library.graphql")
+GQL = api_make(
+    schema_path,
+    base_url="https://api.example.com",
+    graphql_path="/graphql",  # default; POST JSON { "query", "variables" }
+)
+author = GQL.models.Author.objects.create(name="Ada", email="ada@example.com")
+```
+
+pyAPIClient infers operations using common patterns:
+
+- **List**: a `Query` field whose return type is a list of the object type (e.g. `authors: [Author!]!`), optional `filter()` args match declared GraphQL arguments on that field.
+- **Get**: a `Query` field returning the type with an `id: ID!` (or `authorId`-style) argument.
+- **Create / update / delete**: `Mutation` fields whose names start with `create` / `add`, `update` / `edit`, or `delete` / `remove`, with `input` arguments for writes and `ID` arguments where needed.
+
+If your API uses different names, pyAPIClient may not find an operation; you will get a clear `PyAPIClientModelError`.
+
+## How it works (short)
+
+- Schemas become Python types on `api.models.<Name>`.
+- **OpenAPI**: CRUD routes are **inferred** from paths whose bodies or responses reference that schema.
+- **GraphQL**: CRUD maps to `query` / `mutation` documents sent to `graphql_path`, using the heuristics described above.
+- If the spec does not expose a clear operation for a model, calling the missing operation raises a clear `PyAPIClientModelError`.
+
+For full behavior and edge cases, see the test suite under `tests/`.

dynamicapiclient-0.1.2/README.md

@@ -0,0 +1,153 @@
+# pyAPIClient
+
+[![CI](https://github.com/stuart23/pyapiclient/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/stuart23/pyapiclient/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/stuart23/pyapiclient/graph/badge.svg?branch=main)](https://codecov.io/gh/stuart23/pyapiclient)
+
+Generate **Django-like** model classes from an **OpenAPI 2** or **OpenAPI 3** document, or a **GraphQL schema** (SDL or introspection JSON), as a URL or local file. OpenAPI schemas under `definitions` (v2) or `components.schemas` (v3) become models with `.objects` wired to REST paths. GraphQL **object types** become models whose `.objects` issues `query` / `mutation` operations against a single HTTP endpoint (default `POST /graphql`).
+
+## Install
+
+The **PyPI distribution** is [`dynamicapiclient`](https://pypi.org/project/dynamicapiclient/) (`pip install dynamicapiclient`). The **Python import package** remains `pyapiclient` (`import pyapiclient`). This project is referred to as **pyAPIClient** in documentation.
+
+```bash
+pip install -e .
+# or, with dev dependencies:
+pip install -e ".[dev]"
+# GraphQL support (graphql-core):
+pip install -e ".[graphql]"
+```
+
+Requires Python 3.10+. GraphQL requires the optional `graphql` extra (`graphql-core`).
+
+### Tests, coverage, and pre-commit
+
+CI-style checks use **≥90%** coverage on `pyapiclient` (see `pyproject.toml`). Run:
+
+```bash
+pytest -q --cov=pyapiclient --cov-fail-under=90
+```
+
+[GitHub Actions](https://github.com/stuart23/pyapiclient/actions/workflows/ci.yml) runs the same suite on Python 3.10–3.13 and uploads coverage to [**Codecov**](https://codecov.io/gh/stuart23/pyapiclient) via **OIDC** (no `CODECOV_TOKEN` needed on the main repo). Add the project in Codecov once so the badge and graphs populate. Forks or private mirrors may need a **`CODECOV_TOKEN`** secret—see [Codecov’s docs](https://docs.codecov.com/docs/codecov-tokens).
+
+With a **Git** checkout, install [`pre-commit`](https://pre-commit.com/) (`pip install pre-commit` or use the `dev` extra) and run `pre-commit install` so commits run the same pytest command via [`.pre-commit-config.yaml`](.pre-commit-config.yaml).
+
+## Quick start (fixture spec)
+
+This repo includes a sample OpenAPI 3 spec at [`tests/fixtures/library_oas3.yaml`](tests/fixtures/library_oas3.yaml). It describes a small “library” API with `Author` and `Book` schemas and paths under `https://api.example.com/v1`.
+
+Load the spec from disk and build the API object:
+
+```python
+from pathlib import Path
+
+from pyapiclient import api_make  # or: from pyapiclient import apiMake
+
+spec_path = Path("tests/fixtures/library_oas3.yaml")
+# Or an absolute path on your machine.
+
+MyAPI = api_make(spec_path)
+```
+
+Discover generated models (works well in a REPL):
+
+```python
+dir(MyAPI.models)          # ['Author', 'Book']
+list(MyAPI.models)         # model classes
+MyAPI.models.model_names() # ('Author', 'Book')
+```
+
+The spec’s `servers[0].url` is used as the HTTP base URL unless you override it:
+
+```python
+MyAPI = api_make(spec_path, base_url="http://localhost:8000/v1")
+```
+
+### Creating and reading resources
+
+The fixture marks `name` and `email` as required on `Author`, and `title` and `author_id` on `Book`. **Your server must actually implement** the described paths (`POST /authors`, `GET /authors/{author_id}`, `POST /books`, etc.); the YAML file is only the contract.
+
+```python
+author = MyAPI.models.Author.objects.create(
+    name="J.R.R. Tolkien",
+    email="tolkien@example.com",
+)
+
+book = MyAPI.models.Book.objects.create(
+    title="The Hobbit",
+    author_id=author.pk,
+)
+```
+
+**Note:** In `library_oas3.yaml`, `Book` only defines `id`, `title`, and `author_id`. Pass only fields that appear in the schema (extra fields raise validation errors). This fixture uses an integer `author_id`, not a nested `author=` relation object.
+
+Other useful calls:
+
+```python
+same = MyAPI.models.Author.objects.get(pk=author.pk)
+for a in MyAPI.models.Author.objects.filter(name="J.R.R. Tolkien"):
+    print(a.pk, a._data["email"])
+
+MyAPI.models.Author.objects.update(same, email="tolkien@tolkien.estate")
+MyAPI.models.Author.objects.delete(same)
+```
+
+Close the underlying HTTP client when you are done (optional but good practice):
+
+```python
+MyAPI.close()
+# or: with api_make(...) as MyAPI: ...
+```
+
+### Headers (e.g. auth)
+
+```python
+MyAPI = api_make(
+    spec_path,
+    headers={"Authorization": "Bearer YOUR_TOKEN"},
+)
+```
+
+### Loading from a URL
+
+```python
+MyAPI = api_make("https://example.com/openapi.yaml")
+```
+
+### Swagger 2 example
+
+[`tests/fixtures/swagger2_library.json`](tests/fixtures/swagger2_library.json) defines a `Widget` model. Load it the same way; Swagger 2 uses `host` + `basePath` + `schemes` for the base URL, or pass `base_url=...` explicitly.
+
+## GraphQL schema (SDL or introspection JSON)
+
+Install `graphql-core` (`pip install "dynamicapiclient[graphql]"`). Point `api_make` at a `.graphql` / `.gql` file, a JSON introspection export (`data.__schema` or bare `__schema`), or a URL whose body looks like GraphQL SDL or introspection. You **must** pass `base_url=` to the HTTP server root; SDL does not carry a server URL.
+
+```python
+from pathlib import Path
+
+from pyapiclient import api_make
+
+schema_path = Path("tests/fixtures/library.graphql")
+GQL = api_make(
+    schema_path,
+    base_url="https://api.example.com",
+    graphql_path="/graphql",  # default; POST JSON { "query", "variables" }
+)
+author = GQL.models.Author.objects.create(name="Ada", email="ada@example.com")
+```
+
+pyAPIClient infers operations using common patterns:
+
+- **List**: a `Query` field whose return type is a list of the object type (e.g. `authors: [Author!]!`), optional `filter()` args match declared GraphQL arguments on that field.
+- **Get**: a `Query` field returning the type with an `id: ID!` (or `authorId`-style) argument.
+- **Create / update / delete**: `Mutation` fields whose names start with `create` / `add`, `update` / `edit`, or `delete` / `remove`, with `input` arguments for writes and `ID` arguments where needed.
+
+If your API uses different names, pyAPIClient may not find an operation; you will get a clear `PyAPIClientModelError`.
+
+## How it works (short)
+
+- Schemas become Python types on `api.models.<Name>`.
+- **OpenAPI**: CRUD routes are **inferred** from paths whose bodies or responses reference that schema.
+- **GraphQL**: CRUD maps to `query` / `mutation` documents sent to `graphql_path`, using the heuristics described above.
+- If the spec does not expose a clear operation for a model, calling the missing operation raises a clear `PyAPIClientModelError`.
+
+For full behavior and edge cases, see the test suite under `tests/`.

dynamicapiclient-0.1.2/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dynamicapiclient"
+version = "0.1.2"
+description = "pyAPIClient: Django-like dynamic ORM models generated from OpenAPI 2/3 or GraphQL schemas"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "pyAPIClient contributors" }]
+dependencies = [
+  "httpx>=0.27,<1",
+  "PyYAML>=6",
+]
+
+[project.optional-dependencies]
+graphql = [
+  "graphql-core>=3.2,<4",
+]
+dev = [
+  "pytest>=8",
+  "pytest-cov>=5",
+  "respx>=0.21",
+  "graphql-core>=3.2,<4",
+  "pre-commit>=4",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pyapiclient"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "-q --cov=pyapiclient --cov-report=term-missing --cov-fail-under=90"
+
+[tool.coverage.run]
+branch = true
+source_pkgs = ["pyapiclient"]
+
+[tool.coverage.report]
+exclude_lines = [
+  "pragma: no cover",
+  "if TYPE_CHECKING:",
+]

dynamicapiclient-0.1.2/src/pyapiclient/__init__.py

@@ -0,0 +1,24 @@
+"""Dynamic ORM-style API clients from OpenAPI 2/3 or GraphQL schemas."""
+
+from pyapiclient.api import api_make
+from pyapiclient.exceptions import (
+    PyAPIClientConfigurationError,
+    PyAPIClientError,
+    PyAPIClientHTTPError,
+    PyAPIClientModelError,
+    PyAPIClientSpecError,
+    PyAPIClientValidationError,
+)
+
+__all__ = [
+    "api_make",
+    "PyAPIClientError",
+    "PyAPIClientSpecError",
+    "PyAPIClientConfigurationError",
+    "PyAPIClientHTTPError",
+    "PyAPIClientValidationError",
+    "PyAPIClientModelError",
+]
+
+# Django-style alias (user-facing example uses camelCase apiMake)
+apiMake = api_make