fastapi-service-client 1.0.0__tar.gz

fastapi_service_client-1.0.0/.gitignore

@@ -0,0 +1,13 @@
+.venv/
+__pycache__/
+*.pyc
+*.pyo
+build/
+dist/
+*.egg-info/
+.idea/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/

fastapi_service_client-1.0.0/CHANGELOG.md

@@ -0,0 +1,11 @@
+# CHANGELOG
+
+<!-- version list -->
+
+## v1.0.0
+
+- Initial public release.
+- `BaseServiceClient` with raw / JSON / bytes / typed / model request helpers.
+- `HttpxSettings` for outbound request configuration.
+- Upstream exception hierarchy (`UpstreamError` and subclasses).
+- Structured request/response logging via event hooks.

fastapi_service_client-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maxim Kovalev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fastapi_service_client-1.0.0/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: fastapi-service-client
+Version: 1.0.0
+Summary: Shared httpx client and BaseServiceClient for typed service-to-service HTTP calls
+Project-URL: Homepage, https://github.com/mkovalev-dev/fastapi-service-client
+Project-URL: Repository, https://github.com/mkovalev-dev/fastapi-service-client
+Project-URL: Issues, https://github.com/mkovalev-dev/fastapi-service-client/issues
+Project-URL: Changelog, https://github.com/mkovalev-dev/fastapi-service-client/blob/main/CHANGELOG.md
+Author-email: Maxim Kovalev <makccom0@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: async,fastapi,http-client,httpx,microservices,pydantic
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Requires-Dist: httpx>=0.28
+Requires-Dist: pydantic>=2.0
+Description-Content-Type: text/markdown
+
+# fastapi-service-client
+
+Shared `httpx` client and `BaseServiceClient` for typed service-to-service HTTP calls. Eliminates copy-pasting HTTP transport boilerplate across microservices: structured logging, typed responses via Pydantic, and a clean exception hierarchy for upstream failures.
+
+## Installation
+
+```bash
+pip install fastapi-service-client
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add fastapi-service-client
+```
+
+## Quick start
+
+### 1. Add settings to your app
+
+```python
+from pydantic_settings import BaseSettings
+from fastapi_service_client import HttpxSettings
+
+class AppSettings(BaseSettings):
+    httpx: HttpxSettings = HttpxSettings()
+```
+
+### 2. Implement a service client
+
+```python
+from fastapi_service_client import BaseServiceClient, HttpxSettings
+
+class CryptoServiceClient(BaseServiceClient):
+    service_name = "crypto-service"
+
+    def __init__(self, base_url: str, settings: HttpxSettings) -> None:
+        super().__init__(base_url=base_url, settings=settings)
+
+    async def get_key(self, key_id: str) -> dict:
+        return await self._request_json("GET", f"/keys/{key_id}")
+```
+
+### 3. Use in your endpoint / use case
+
+```python
+client = CryptoServiceClient(
+    base_url=settings.crypto_service_url,
+    settings=settings.httpx,
+)
+result = await client.get_key("abc123")
+```
+
+## API
+
+### `HttpxSettings`
+
+Pydantic model to include in your app settings.
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `ssl_verify` | `bool` | `True` | Verify SSL certificates. Set to `False` only for trusted internal services with self-signed certificates. |
+
+### `BaseServiceClient`
+
+Base class for outbound HTTP clients.
+
+**Constructor:**
+
+```python
+BaseServiceClient(*, base_url: str = "", settings: HttpxSettings | None = None)
+```
+
+**Methods** (all protected, call from subclass):
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `_request_raw(method, url, ...)` | `httpx.Response` | Raw response |
+| `_request_json(method, url, ...)` | `Any` | Parsed JSON |
+| `_request_bytes(method, url, ...)` | `bytes` | Response body as bytes |
+| `_request_typed(adapter, method, url, ...)` | `T` | Validated via `TypeAdapter[T]` |
+| `_request_model(model, method, url, ...)` | `TModel` | Validated Pydantic model |
+
+All methods accept:
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `headers` | `dict[str, str] \| None` | `None` | Extra request headers |
+| `cookies` | `dict[str, str] \| None` | `None` | Request cookies |
+| `expected_status` | `int` | `200` | Raises `UpstreamResponseError` on mismatch |
+| `detail_on_bad_status` | `str` | `"Upstream request failed"` | Error message on bad status |
+| `**kwargs` | | | Passed through to `httpx.AsyncClient.request` |
+
+**Class attribute:**
+
+```python
+class MyClient(BaseServiceClient):
+    service_name = "my-service"  # used in exception messages and logs
+```
+
+### Exceptions
+
+```python
+from fastapi_service_client import (
+    UpstreamError,               # base
+    UpstreamUnavailableError,    # network error / timeout
+    UpstreamResponseError,       # unexpected HTTP status
+    UpstreamInvalidResponseError # unparseable response body
+)
+```
+
+All inherit from `UpstreamError`. Catch the base to handle any upstream failure:
+
+```python
+try:
+    result = await client.get_key("abc")
+except UpstreamUnavailableError:
+    raise HTTPException(status_code=503)
+except UpstreamResponseError as exc:
+    raise HTTPException(status_code=exc.status_code, detail=exc.detail)
+```
+
+## Logging
+
+The library logs via standard Python `logging`. Each outbound request and response is logged at `INFO` level under the `fastapi_service_client` namespace:
+
+```json
+{"event": "http_out_request", "method": "GET", "url": "http://..."}
+{"event": "http_out_response", "status": 200, "url": "http://...", "duration_ms": 42.1}
+```
+
+Configure in your app's logging setup as usual.
+
+## Versioning
+
+Releases are automated via [python-semantic-release](https://python-semantic-release.readthedocs.io/) on every push to `main`. Version bumps follow [Conventional Commits](https://www.conventionalcommits.org/):
+
+| Commit prefix | Version bump |
+|---------------|-------------|
+| `fix:` | patch (`1.0.0` → `1.0.1`) |
+| `feat:` | minor (`1.0.0` → `1.1.0`) |
+| `feat!:` / `BREAKING CHANGE:` | major (`1.0.0` → `2.0.0`) |
+
+## License
+
+[MIT](LICENSE)

fastapi_service_client-1.0.0/README.md

@@ -0,0 +1,146 @@
+# fastapi-service-client
+
+Shared `httpx` client and `BaseServiceClient` for typed service-to-service HTTP calls. Eliminates copy-pasting HTTP transport boilerplate across microservices: structured logging, typed responses via Pydantic, and a clean exception hierarchy for upstream failures.
+
+## Installation
+
+```bash
+pip install fastapi-service-client
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add fastapi-service-client
+```
+
+## Quick start
+
+### 1. Add settings to your app
+
+```python
+from pydantic_settings import BaseSettings
+from fastapi_service_client import HttpxSettings
+
+class AppSettings(BaseSettings):
+    httpx: HttpxSettings = HttpxSettings()
+```
+
+### 2. Implement a service client
+
+```python
+from fastapi_service_client import BaseServiceClient, HttpxSettings
+
+class CryptoServiceClient(BaseServiceClient):
+    service_name = "crypto-service"
+
+    def __init__(self, base_url: str, settings: HttpxSettings) -> None:
+        super().__init__(base_url=base_url, settings=settings)
+
+    async def get_key(self, key_id: str) -> dict:
+        return await self._request_json("GET", f"/keys/{key_id}")
+```
+
+### 3. Use in your endpoint / use case
+
+```python
+client = CryptoServiceClient(
+    base_url=settings.crypto_service_url,
+    settings=settings.httpx,
+)
+result = await client.get_key("abc123")
+```
+
+## API
+
+### `HttpxSettings`
+
+Pydantic model to include in your app settings.
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `ssl_verify` | `bool` | `True` | Verify SSL certificates. Set to `False` only for trusted internal services with self-signed certificates. |
+
+### `BaseServiceClient`
+
+Base class for outbound HTTP clients.
+
+**Constructor:**
+
+```python
+BaseServiceClient(*, base_url: str = "", settings: HttpxSettings | None = None)
+```
+
+**Methods** (all protected, call from subclass):
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `_request_raw(method, url, ...)` | `httpx.Response` | Raw response |
+| `_request_json(method, url, ...)` | `Any` | Parsed JSON |
+| `_request_bytes(method, url, ...)` | `bytes` | Response body as bytes |
+| `_request_typed(adapter, method, url, ...)` | `T` | Validated via `TypeAdapter[T]` |
+| `_request_model(model, method, url, ...)` | `TModel` | Validated Pydantic model |
+
+All methods accept:
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `headers` | `dict[str, str] \| None` | `None` | Extra request headers |
+| `cookies` | `dict[str, str] \| None` | `None` | Request cookies |
+| `expected_status` | `int` | `200` | Raises `UpstreamResponseError` on mismatch |
+| `detail_on_bad_status` | `str` | `"Upstream request failed"` | Error message on bad status |
+| `**kwargs` | | | Passed through to `httpx.AsyncClient.request` |
+
+**Class attribute:**
+
+```python
+class MyClient(BaseServiceClient):
+    service_name = "my-service"  # used in exception messages and logs
+```
+
+### Exceptions
+
+```python
+from fastapi_service_client import (
+    UpstreamError,               # base
+    UpstreamUnavailableError,    # network error / timeout
+    UpstreamResponseError,       # unexpected HTTP status
+    UpstreamInvalidResponseError # unparseable response body
+)
+```
+
+All inherit from `UpstreamError`. Catch the base to handle any upstream failure:
+
+```python
+try:
+    result = await client.get_key("abc")
+except UpstreamUnavailableError:
+    raise HTTPException(status_code=503)
+except UpstreamResponseError as exc:
+    raise HTTPException(status_code=exc.status_code, detail=exc.detail)
+```
+
+## Logging
+
+The library logs via standard Python `logging`. Each outbound request and response is logged at `INFO` level under the `fastapi_service_client` namespace:
+
+```json
+{"event": "http_out_request", "method": "GET", "url": "http://..."}
+{"event": "http_out_response", "status": 200, "url": "http://...", "duration_ms": 42.1}
+```
+
+Configure in your app's logging setup as usual.
+
+## Versioning
+
+Releases are automated via [python-semantic-release](https://python-semantic-release.readthedocs.io/) on every push to `main`. Version bumps follow [Conventional Commits](https://www.conventionalcommits.org/):
+
+| Commit prefix | Version bump |
+|---------------|-------------|
+| `fix:` | patch (`1.0.0` → `1.0.1`) |
+| `feat:` | minor (`1.0.0` → `1.1.0`) |
+| `feat!:` / `BREAKING CHANGE:` | major (`1.0.0` → `2.0.0`) |
+
+## License
+
+[MIT](LICENSE)

fastapi_service_client-1.0.0/pyproject.toml

@@ -0,0 +1,72 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fastapi-service-client"
+version = "1.0.0"
+description = "Shared httpx client and BaseServiceClient for typed service-to-service HTTP calls"
+readme = "README.md"
+requires-python = ">=3.14"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Maxim Kovalev", email = "makccom0@gmail.com" },
+]
+keywords = ["httpx", "fastapi", "microservices", "http-client", "pydantic", "async"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = [
+    "httpx>=0.28",
+    "pydantic>=2.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/mkovalev-dev/fastapi-service-client"
+Repository = "https://github.com/mkovalev-dev/fastapi-service-client"
+Issues = "https://github.com/mkovalev-dev/fastapi-service-client/issues"
+Changelog = "https://github.com/mkovalev-dev/fastapi-service-client/blob/main/CHANGELOG.md"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fastapi_service_client"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/fastapi_service_client",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+    "respx>=0.22",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.semantic_release]
+version_toml = ["pyproject.toml:project.version"]
+build_command = "pip install uv && uv build"
+commit_message = "chore(release): v{version} [skip ci]"
+tag_format = "v{version}"
+
+[tool.semantic_release.branches.main]
+match = "main"
+prerelease = false
+
+[tool.semantic_release.publish]
+upload_to_vcs_release = true

fastapi_service_client-1.0.0/src/fastapi_service_client/__init__.py

@@ -0,0 +1,19 @@
+from .client import create_httpx_client
+from .exceptions import (
+    UpstreamError,
+    UpstreamInvalidResponseError,
+    UpstreamResponseError,
+    UpstreamUnavailableError,
+)
+from .service_client import BaseServiceClient
+from .settings import HttpxSettings
+
+__all__ = [
+    "BaseServiceClient",
+    "HttpxSettings",
+    "UpstreamError",
+    "UpstreamInvalidResponseError",
+    "UpstreamResponseError",
+    "UpstreamUnavailableError",
+    "create_httpx_client",
+]

fastapi_service_client-1.0.0/src/fastapi_service_client/client.py

@@ -0,0 +1,23 @@
+import logging
+
+import httpx
+
+from .event_hooks import (
+    request_logger_event_hook,
+    response_logger_event_hook,
+)
+from .settings import HttpxSettings
+
+logger = logging.getLogger(__name__)
+
+
+def create_httpx_client(settings: HttpxSettings) -> httpx.AsyncClient:
+    """Create a stateless HTTPX client for a single outbound request."""
+    logger.info("Creating HTTPX client for outbound request")
+    return httpx.AsyncClient(
+        verify=settings.ssl_verify,
+        event_hooks={
+            "request": [request_logger_event_hook],
+            "response": [response_logger_event_hook],
+        },
+    )

fastapi_service_client-1.0.0/src/fastapi_service_client/event_hooks.py

@@ -0,0 +1,30 @@
+import logging
+import time
+
+from httpx import Request, Response
+
+logger = logging.getLogger(__name__)
+
+
+async def request_logger_event_hook(request: Request) -> None:
+    request.extensions["start_time"] = time.perf_counter()
+    logger.info(
+        {
+            "event": "http_out_request",
+            "method": request.method,
+            "url": str(request.url),
+        }
+    )
+
+
+async def response_logger_event_hook(response: Response) -> None:
+    start = response.request.extensions.get("start_time")
+    duration = round((time.perf_counter() - start) * 1000, 2) if start else None
+    logger.info(
+        {
+            "event": "http_out_response",
+            "status": response.status_code,
+            "url": str(response.request.url),
+            "duration_ms": duration,
+        }
+    )

fastapi_service_client-1.0.0/src/fastapi_service_client/exceptions.py

@@ -0,0 +1,30 @@
+class UpstreamError(Exception):
+    """Base upstream service integration error."""
+
+
+class UpstreamUnavailableError(UpstreamError):
+    """Upstream service is unavailable or did not respond."""
+
+    def __init__(self, service_name: str) -> None:
+        detail = f"{service_name} is temporarily unavailable. Try again later."
+        super().__init__(detail)
+        self.service_name = service_name
+
+
+class UpstreamResponseError(UpstreamError):
+    """Upstream service returned an unexpected HTTP status."""
+
+    def __init__(self, service_name: str, status_code: int, detail: str) -> None:
+        super().__init__(detail)
+        self.service_name = service_name
+        self.status_code = status_code
+        self.detail = detail
+
+
+class UpstreamInvalidResponseError(UpstreamError):
+    """Upstream service returned an invalid or unparseable response."""
+
+    def __init__(self, service_name: str, detail: str) -> None:
+        super().__init__(detail)
+        self.service_name = service_name
+        self.detail = detail

fastapi_service_client-1.0.0/src/fastapi_service_client/service_client.py

@@ -0,0 +1,195 @@
+import hashlib
+import http
+import logging
+from typing import Any, TypeVar
+from urllib.parse import urlsplit
+
+import httpx
+from pydantic import BaseModel, TypeAdapter
+
+from .client import create_httpx_client
+from .exceptions import (
+    UpstreamInvalidResponseError,
+    UpstreamResponseError,
+    UpstreamUnavailableError,
+)
+from .settings import HttpxSettings
+
+logger = logging.getLogger(__name__)
+
+TModel = TypeVar("TModel", bound=BaseModel)
+T = TypeVar("T")
+
+
+class BaseServiceClient:
+    service_name: str = "external service"
+
+    def __init__(
+        self,
+        *,
+        base_url: str = "",
+        settings: HttpxSettings | None = None,
+    ) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._settings = settings or HttpxSettings()
+
+    def _get_default_headers(self) -> dict[str, str]:
+        parsed_url = urlsplit(self._base_url)
+        hostname = (parsed_url.hostname or "").replace("_", "-")
+        if not hostname:
+            return {}
+        return {"Host": hostname}
+
+    @staticmethod
+    def _build_session_fingerprint(session: str) -> str:
+        session_hash = hashlib.sha256(session.encode("utf-8")).hexdigest()
+        return session_hash[:12]
+
+    def _build_url(self, url: str) -> str:
+        if url.startswith(("http://", "https://")):
+            return url
+        if not self._base_url:
+            return url
+        return f"{self._base_url}/{url.lstrip('/')}"
+
+    async def _request_raw(
+        self,
+        method: str,
+        url: str,
+        *,
+        headers: dict[str, str] | None = None,
+        cookies: dict[str, str] | None = None,
+        expected_status: int = http.HTTPStatus.OK,
+        detail_on_bad_status: str = "Upstream request failed",
+        **kwargs: Any,
+    ) -> httpx.Response:
+        merged_headers = {**self._get_default_headers(), **(headers or {})}
+        request_url = self._build_url(url)
+
+        try:
+            async with create_httpx_client(self._settings) as client:
+                response = await client.request(
+                    method,
+                    request_url,
+                    headers=merged_headers or None,
+                    cookies=cookies,
+                    **kwargs,
+                )
+        except httpx.RequestError as exc:
+            logger.exception("%s request error: %s", self.service_name, exc)
+            raise UpstreamUnavailableError(self.service_name) from exc
+
+        if response.status_code != expected_status:
+            logger.warning(
+                "%s non-%s: %s %s",
+                self.service_name,
+                expected_status,
+                response.status_code,
+                response.text,
+            )
+            raise UpstreamResponseError(
+                self.service_name,
+                response.status_code,
+                detail_on_bad_status,
+            )
+
+        return response
+
+    async def _request_json(
+        self,
+        method: str,
+        url: str,
+        *,
+        headers: dict[str, str] | None = None,
+        cookies: dict[str, str] | None = None,
+        expected_status: int = http.HTTPStatus.OK,
+        detail_on_bad_status: str = "Upstream request failed",
+        **kwargs: Any,
+    ) -> Any:
+        response = await self._request_raw(
+            method,
+            url,
+            headers=headers,
+            cookies=cookies,
+            expected_status=expected_status,
+            detail_on_bad_status=detail_on_bad_status,
+            **kwargs,
+        )
+        try:
+            if not response.content:
+                return None
+            return response.json()
+        except ValueError as exc:
+            logger.exception("Invalid JSON from %s: %s", self.service_name, exc)
+            raise UpstreamInvalidResponseError(
+                self.service_name,
+                f"Invalid response from {self.service_name}",
+            ) from exc
+
+    async def _request_bytes(
+        self,
+        method: str,
+        url: str,
+        *,
+        headers: dict[str, str] | None = None,
+        cookies: dict[str, str] | None = None,
+        expected_status: int = http.HTTPStatus.OK,
+        detail_on_bad_status: str = "Upstream request failed",
+        **kwargs: Any,
+    ) -> bytes:
+        response = await self._request_raw(
+            method,
+            url,
+            headers=headers,
+            cookies=cookies,
+            expected_status=expected_status,
+            detail_on_bad_status=detail_on_bad_status,
+            **kwargs,
+        )
+        return response.content
+
+    async def _request_typed(
+        self,
+        adapter: TypeAdapter[T],
+        method: str,
+        url: str,
+        *,
+        headers: dict[str, str] | None = None,
+        cookies: dict[str, str] | None = None,
+        expected_status: int = http.HTTPStatus.OK,
+        detail_on_bad_status: str = "Upstream request failed",
+        **kwargs: Any,
+    ) -> T:
+        data = await self._request_json(
+            method,
+            url,
+            headers=headers,
+            cookies=cookies,
+            expected_status=expected_status,
+            detail_on_bad_status=detail_on_bad_status,
+            **kwargs,
+        )
+        return adapter.validate_python(data)
+
+    async def _request_model(
+        self,
+        model: type[TModel],
+        method: str,
+        url: str,
+        *,
+        headers: dict[str, str] | None = None,
+        cookies: dict[str, str] | None = None,
+        expected_status: int = http.HTTPStatus.OK,
+        detail_on_bad_status: str = "Upstream request failed",
+        **kwargs: Any,
+    ) -> TModel:
+        data = await self._request_json(
+            method,
+            url,
+            headers=headers,
+            cookies=cookies,
+            expected_status=expected_status,
+            detail_on_bad_status=detail_on_bad_status,
+            **kwargs,
+        )
+        return TypeAdapter(model).validate_python(data)

fastapi_service_client-1.0.0/src/fastapi_service_client/settings.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class HttpxSettings(BaseModel):
+    """Settings for outbound HTTP requests. Include this in your app settings."""
+
+    ssl_verify: bool = True