http-config 0.1.4__tar.gz

http_config-0.1.4/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.3
+Name: http-config
+Version: 0.1.4
+Summary: A shared config to control HTTP clients
+Author: Kalle M. Krog Aagaard
+Author-email: Kalle M. Krog Aagaard <git@k-moeller.dk>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: pydantic-merge>=0.1.3
+Requires-Dist: httpx>=0.28.1 ; extra == 'httpx'
+Maintainer: Kalle M. Krog Aagaard
+Maintainer-email: Kalle M. Krog Aagaard <git@k-moeller.dk>
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/KalleDK/py-http-config
+Project-URL: Documentation, https://github.com/KalleDK/py-http-config
+Project-URL: Repository, https://github.com/KalleDK/py-http-config.git
+Provides-Extra: httpx
+Description-Content-Type: text/markdown
+
+# HTTP Config
+
+Shared, typed configuration for Python HTTP clients. Keep proxy, timeout, connection-limit, TLS, and request
+logging settings in one Pydantic model and reuse them across client integrations.
+
+The core configuration models are client-library independent. The project currently provides an integration
+for [HTTPX](https://www.python-httpx.org/), with support for additional HTTP libraries planned for the future.
+
+## Installation
+
+Using `uv`:
+
+```console
+uv add "http-config[httpx]"
+```
+
+Using `pip`:
+
+```console
+python -m pip install "http-config[httpx]"
+```
+
+The `httpx` extra installs the current HTTPX integration. The configuration models are available without any
+client-library extra, allowing future integrations to be added independently.
+
+## Quick Start
+
+```python
+from datetime import timedelta
+
+from http_config import HTTPConfig, LimitConfig, TimeoutConfig
+from http_config.httpx import sync_client
+
+
+config = HTTPConfig(
+    timeout=TimeoutConfig(
+        timeout=timedelta(seconds=10),
+        connect_timeout=timedelta(seconds=3),
+    ),
+    limits=LimitConfig(
+        max_connections=50,
+        max_keepalive_connections=10,
+    ),
+)
+
+with sync_client(config) as client:
+    response = client.get("https://httpbin.org/get")
+    response.raise_for_status()
+    print(response.json())
+```
+
+For asynchronous code, use `async_client`:
+
+```python
+from http_config.httpx import async_client
+
+
+async def fetch() -> dict:
+    async with async_client() as client:
+        response = await client.get("https://httpbin.org/get")
+        response.raise_for_status()
+        return response.json()
+```
+
+## Configuration
+
+`HTTPConfig` supports these settings:
+
+| Setting | Type | Description |
+| --- | --- | --- |
+| `proxy` | `str \| None` | Proxy URL passed to the active client integration. |
+| `timeout` | `timedelta \| False \| TimeoutConfig \| None` | Overall or per-operation timeout. `False` disables the timeout. |
+| `limits` | `LimitConfig \| None` | Maximum open and keep-alive connections. |
+| `ssl` | `bool \| SSLConfig \| None` | TLS verification mode and custom certificate sources. |
+| `log_path` | `Path \| None` | Directory where request and response files are recorded by supported integrations. |
+
+### Merging Configuration
+
+The configuration models use [`pydantic-merge`](https://github.com/tylerjamesyoung/pydantic-merge). Use
+`model_merge()` to create a validated copy with updates applied recursively. Nested configuration is merged
+instead of replaced, so an update to one timeout value preserves the other timeout values:
+
+```python
+from datetime import timedelta
+
+from http_config import HTTPConfig, TimeoutConfig
+
+
+base = HTTPConfig(
+    timeout=TimeoutConfig(
+        timeout=timedelta(seconds=10),
+        read_timeout=timedelta(seconds=5),
+    ),
+)
+updated = base.model_merge(
+    HTTPConfig(
+        timeout=TimeoutConfig(connect_timeout=timedelta(seconds=3)),
+    )
+)
+
+assert updated.timeout.timeout == timedelta(seconds=10)
+assert updated.timeout.read_timeout == timedelta(seconds=5)
+assert updated.timeout.connect_timeout == timedelta(seconds=3)
+```
+
+### TLS
+
+The default is normal certificate verification. Set `ssl=False` to disable verification, or provide a
+custom CA file, directory, or certificate data with `SSLConfig`:
+
+If [certifi](https://github.com/certifi/python-certifi) is installed, its CA bundle is used automatically
+when no explicit `cafile` is configured. Install it separately with `uv add certifi` or
+`python -m pip install certifi`. An explicit `cafile` takes precedence; set `ignore_certifi=True` to opt out
+of the automatic certifi fallback.
+
+```python
+from pathlib import Path
+
+from http_config import HTTPConfig, SSLConfig
+
+
+config = HTTPConfig(
+    ssl=SSLConfig(
+        cafile=Path("certificates/ca.pem"),
+    ),
+)
+```
+
+To disable the automatic certifi fallback:
+
+```python
+from http_config import HTTPConfig, SSLConfig
+
+
+config = HTTPConfig(ssl=SSLConfig(ignore_certifi=True))
+```
+
+`SSLConfig.create()` is useful when settings come from optional application configuration:
+
+```python
+ssl_setting = SSLConfig.create(insecure=False, cafile=Path("ca.pem"))
+```
+
+### Request Logging
+
+Set `log_path` to enable file-based transport logging. The directory is created automatically. Each request
+gets JSON header files and body files when a body is present, paired by a timestamp-based prefix and request
+index.
+
+```python
+from pathlib import Path
+
+from http_config import HTTPConfig
+from http_config.httpx import sync_client
+
+
+config = HTTPConfig(log_path=Path("http-logs"))
+with sync_client(config) as client:
+    client.get("https://httpbin.org/get")
+```
+
+## HTTPX Middleware and Authentication
+
+The current HTTPX client factories accept an optional transport middleware function and either an HTTPX auth
+object or a factory that receives the client:
+
+```python
+import httpx
+
+from http_config.httpx import sync_client
+
+
+def middleware(transport: httpx.BaseTransport) -> httpx.BaseTransport:
+    return transport
+
+
+with sync_client(
+    middleware=middleware,
+    auth=httpx.BasicAuth("user", "password"),
+) as client:
+    response = client.get("https://example.com")
+```
+
+## Development
+
+Install the test dependencies and run the suite with:
+
+```console
+uv sync --group test
+uv run pytest
+uv run ruff check
+```
+
+## License
+
+This project is available under the [MIT License](LICENSE).

http_config-0.1.4/README.md

@@ -0,0 +1,196 @@
+# HTTP Config
+
+Shared, typed configuration for Python HTTP clients. Keep proxy, timeout, connection-limit, TLS, and request
+logging settings in one Pydantic model and reuse them across client integrations.
+
+The core configuration models are client-library independent. The project currently provides an integration
+for [HTTPX](https://www.python-httpx.org/), with support for additional HTTP libraries planned for the future.
+
+## Installation
+
+Using `uv`:
+
+```console
+uv add "http-config[httpx]"
+```
+
+Using `pip`:
+
+```console
+python -m pip install "http-config[httpx]"
+```
+
+The `httpx` extra installs the current HTTPX integration. The configuration models are available without any
+client-library extra, allowing future integrations to be added independently.
+
+## Quick Start
+
+```python
+from datetime import timedelta
+
+from http_config import HTTPConfig, LimitConfig, TimeoutConfig
+from http_config.httpx import sync_client
+
+
+config = HTTPConfig(
+    timeout=TimeoutConfig(
+        timeout=timedelta(seconds=10),
+        connect_timeout=timedelta(seconds=3),
+    ),
+    limits=LimitConfig(
+        max_connections=50,
+        max_keepalive_connections=10,
+    ),
+)
+
+with sync_client(config) as client:
+    response = client.get("https://httpbin.org/get")
+    response.raise_for_status()
+    print(response.json())
+```
+
+For asynchronous code, use `async_client`:
+
+```python
+from http_config.httpx import async_client
+
+
+async def fetch() -> dict:
+    async with async_client() as client:
+        response = await client.get("https://httpbin.org/get")
+        response.raise_for_status()
+        return response.json()
+```
+
+## Configuration
+
+`HTTPConfig` supports these settings:
+
+| Setting | Type | Description |
+| --- | --- | --- |
+| `proxy` | `str \| None` | Proxy URL passed to the active client integration. |
+| `timeout` | `timedelta \| False \| TimeoutConfig \| None` | Overall or per-operation timeout. `False` disables the timeout. |
+| `limits` | `LimitConfig \| None` | Maximum open and keep-alive connections. |
+| `ssl` | `bool \| SSLConfig \| None` | TLS verification mode and custom certificate sources. |
+| `log_path` | `Path \| None` | Directory where request and response files are recorded by supported integrations. |
+
+### Merging Configuration
+
+The configuration models use [`pydantic-merge`](https://github.com/tylerjamesyoung/pydantic-merge). Use
+`model_merge()` to create a validated copy with updates applied recursively. Nested configuration is merged
+instead of replaced, so an update to one timeout value preserves the other timeout values:
+
+```python
+from datetime import timedelta
+
+from http_config import HTTPConfig, TimeoutConfig
+
+
+base = HTTPConfig(
+    timeout=TimeoutConfig(
+        timeout=timedelta(seconds=10),
+        read_timeout=timedelta(seconds=5),
+    ),
+)
+updated = base.model_merge(
+    HTTPConfig(
+        timeout=TimeoutConfig(connect_timeout=timedelta(seconds=3)),
+    )
+)
+
+assert updated.timeout.timeout == timedelta(seconds=10)
+assert updated.timeout.read_timeout == timedelta(seconds=5)
+assert updated.timeout.connect_timeout == timedelta(seconds=3)
+```
+
+### TLS
+
+The default is normal certificate verification. Set `ssl=False` to disable verification, or provide a
+custom CA file, directory, or certificate data with `SSLConfig`:
+
+If [certifi](https://github.com/certifi/python-certifi) is installed, its CA bundle is used automatically
+when no explicit `cafile` is configured. Install it separately with `uv add certifi` or
+`python -m pip install certifi`. An explicit `cafile` takes precedence; set `ignore_certifi=True` to opt out
+of the automatic certifi fallback.
+
+```python
+from pathlib import Path
+
+from http_config import HTTPConfig, SSLConfig
+
+
+config = HTTPConfig(
+    ssl=SSLConfig(
+        cafile=Path("certificates/ca.pem"),
+    ),
+)
+```
+
+To disable the automatic certifi fallback:
+
+```python
+from http_config import HTTPConfig, SSLConfig
+
+
+config = HTTPConfig(ssl=SSLConfig(ignore_certifi=True))
+```
+
+`SSLConfig.create()` is useful when settings come from optional application configuration:
+
+```python
+ssl_setting = SSLConfig.create(insecure=False, cafile=Path("ca.pem"))
+```
+
+### Request Logging
+
+Set `log_path` to enable file-based transport logging. The directory is created automatically. Each request
+gets JSON header files and body files when a body is present, paired by a timestamp-based prefix and request
+index.
+
+```python
+from pathlib import Path
+
+from http_config import HTTPConfig
+from http_config.httpx import sync_client
+
+
+config = HTTPConfig(log_path=Path("http-logs"))
+with sync_client(config) as client:
+    client.get("https://httpbin.org/get")
+```
+
+## HTTPX Middleware and Authentication
+
+The current HTTPX client factories accept an optional transport middleware function and either an HTTPX auth
+object or a factory that receives the client:
+
+```python
+import httpx
+
+from http_config.httpx import sync_client
+
+
+def middleware(transport: httpx.BaseTransport) -> httpx.BaseTransport:
+    return transport
+
+
+with sync_client(
+    middleware=middleware,
+    auth=httpx.BasicAuth("user", "password"),
+) as client:
+    response = client.get("https://example.com")
+```
+
+## Development
+
+Install the test dependencies and run the suite with:
+
+```console
+uv sync --group test
+uv run pytest
+uv run ruff check
+```
+
+## License
+
+This project is available under the [MIT License](LICENSE).

http_config-0.1.4/pyproject.toml

@@ -0,0 +1,92 @@
+[project]
+name = "http-config"
+version = "0.1.4"
+description = "A shared config to control HTTP clients"
+readme = "README.md"
+requires-python = ">=3.13"
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "pydantic>=2.13.4",
+    "pydantic-merge>=0.1.3",
+]
+
+[[project.authors]]
+name = "Kalle M. Krog Aagaard"
+email = "git@k-moeller.dk"
+
+[[project.maintainers]]
+name = "Kalle M. Krog Aagaard"
+email = "git@k-moeller.dk"
+
+[project.urls]
+Homepage = "https://github.com/KalleDK/py-http-config"
+Documentation = "https://github.com/KalleDK/py-http-config"
+Repository = "https://github.com/KalleDK/py-http-config.git"
+
+[project.optional-dependencies]
+httpx = ["httpx>=0.28.1"]
+
+[dependency-groups]
+test = [
+    "pytest>=9.1.1",
+    "pytest-cov>=7.1.0",
+]
+stubs = []
+
+[build-system]
+requires = ["uv_build>=0.12.4,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "http_config"
+
+[tool.pyright]
+include = [
+    "src",
+    "tests",
+    "examples",
+]
+typeCheckingMode = "strict"
+pythonVersion = "3.13"
+
+[tool.ruff]
+line-length = 120
+target-version = "py313"
+
+[tool.ruff.lint]
+extend-select = [
+    "E4",
+    "E7",
+    "E9",
+    "F",
+    "I",
+    "UP",
+    "B",
+    "SIM",
+    "RUF",
+    "T20",
+    "RET",
+    "S",
+    "ANN",
+    "TC",
+    "FA",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = ["S101"]
+"examples/**/*.py" = [
+    "S101",
+    "T20",
+]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+line-ending = "lf"
+
+[tool.pytest.ini_options]
+addopts = "-v --cov=http_config --cov-report=term-missing --cov-report=xml"
+testpaths = ["tests"]

http_config-0.1.4/pyproject.toml.orig

@@ -0,0 +1,87 @@
+[project]
+name = "http-config"
+version = "0.1.4"
+description = "A shared config to control HTTP clients"
+readme = "README.md"
+requires-python = ">=3.13"
+authors = [
+    {name = "Kalle M. Krog Aagaard", email = "git@k-moeller.dk"},
+]
+maintainers = [
+    {name = "Kalle M. Krog Aagaard", email = "git@k-moeller.dk"},
+]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "pydantic>=2.13.4",
+    "pydantic-merge>=0.1.3",
+]
+
+[project.urls]
+Homepage = "https://github.com/KalleDK/py-http-config"
+Documentation = "https://github.com/KalleDK/py-http-config"
+Repository = "https://github.com/KalleDK/py-http-config.git"
+
+[project.optional-dependencies]
+httpx = [
+    "httpx>=0.28.1",
+]
+
+[dependency-groups]
+test = [
+    "pytest>=9.1.1",
+    "pytest-cov>=7.1.0",
+]
+stubs = []
+
+[build-system]
+requires = ["uv_build>=0.12.4,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "http_config"
+
+[tool.pyright]
+include = ["src", "tests", "examples"]
+typeCheckingMode = "strict"
+pythonVersion = "3.13"
+
+
+[tool.ruff]
+line-length = 120
+target-version = "py313"
+
+[tool.ruff.lint]
+extend-select = [
+    "E4",    # Import and indentation errors
+    "E7",    # Statement errors
+    "E9",    # Runtime and syntax errors
+    "F",     # Pyflakes correctness checks
+    "I",     # Import sorting
+    "UP",    # Python syntax and API upgrades
+    "B",     # Common bug patterns
+    "SIM",   # Simplifiable code
+    "RUF",   # Ruff-specific improvements
+    "T20",   # See if print or pprint is used in code
+    "RET",   # Return statements
+    "S",     # Security issues
+    "ANN",   # Type annotation issues
+    "TC",    # Type checking issues
+    "FA",    # Future annotations issues
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = ["S101"]
+"examples/**/*.py" = ["S101", "T20"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+line-ending = "lf"
+
+
+[tool.pytest.ini_options]
+addopts = "-v --cov=http_config --cov-report=term-missing --cov-report=xml"
+testpaths = ["tests"]

http_config-0.1.4/src/http_config/__init__.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from http_config.config import HTTPConfig as HTTPConfig
+from http_config.config import LimitConfig as LimitConfig
+from http_config.config import SSLConfig as SSLConfig
+from http_config.config import TimeoutConfig as TimeoutConfig
+
+__version__ = "0.1.4"
+
+
+__all__ = [
+    "HTTPConfig",
+    "LimitConfig",
+    "SSLConfig",
+    "TimeoutConfig",
+]

http_config-0.1.4/src/http_config/_ssl.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import ssl as _ssl
+
+from http_config.config import CERTIFI_PATH, SSLConfig
+
+# region SSL
+
+
+def create_insecure_ssl_context() -> _ssl.SSLContext:
+    ctx = _ssl.SSLContext(_ssl.PROTOCOL_TLS_CLIENT)
+    ctx.check_hostname = False
+    ctx.verify_mode = _ssl.CERT_NONE
+    return ctx
+
+
+def create_ssl_context(ssl_config: SSLConfig | bool | None) -> _ssl.SSLContext:
+    match ssl_config:
+        case None:
+            return _ssl.create_default_context()
+        case SSLConfig() as _ssl_config:
+            return _ssl.create_default_context(
+                cafile=_ssl_config.cafile_normalized,
+                capath=_ssl_config.capath,
+                cadata=_ssl_config.cadata,
+            )
+
+        case bool():
+            if ssl_config is False:
+                return create_insecure_ssl_context()
+            return _ssl.create_default_context(
+                cafile=CERTIFI_PATH,
+            )
+
+
+# endregion

http_config-0.1.4/src/http_config/config.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import pathlib
+from datetime import timedelta  # noqa: TC003
+from typing import Literal
+
+from pydantic_merge import BaseModel
+
+# region SSL
+
+
+def load_certifi() -> pathlib.Path | None:
+    try:
+        import certifi
+
+        return pathlib.Path(certifi.where())
+    except ImportError:
+        return None
+
+
+CERTIFI_PATH: pathlib.Path | None = load_certifi()
+
+
+class SSLConfig(BaseModel):
+    cafile: pathlib.Path | None = None
+    capath: pathlib.Path | None = None
+    cadata: str | bytes | None = None
+    ignore_certifi: bool | None = None
+
+    @property
+    def cafile_normalized(self) -> pathlib.Path | None:
+        if self.cafile is not None:
+            return self.cafile
+
+        if self.ignore_certifi is True:
+            return None
+
+        return CERTIFI_PATH
+
+    @classmethod
+    def create(
+        cls,
+        insecure: bool | None = None,
+        cafile: pathlib.Path | None = None,
+        capath: pathlib.Path | None = None,
+        cadata: str | bytes | None = None,
+    ) -> SSLConfig | bool | None:
+        if insecure is True:
+            return False
+
+        if cafile is None and capath is None and cadata is None:
+            if insecure is None:
+                return None
+            return True
+
+        return cls(cafile=cafile, capath=capath, cadata=cadata)
+
+
+# endregion
+
+
+# region Timeout
+
+
+class TimeoutConfig(BaseModel):
+    timeout: timedelta | Literal[False] | None = None
+    read_timeout: timedelta | Literal[False] | None = None
+    write_timeout: timedelta | Literal[False] | None = None
+    connect_timeout: timedelta | Literal[False] | None = None
+
+
+# endregion
+
+# region Limits
+
+
+class LimitConfig(BaseModel):
+    max_connections: int | None = None
+    max_keepalive_connections: int | None = None
+
+
+# endregion
+
+
+class HTTPConfig(BaseModel):
+    proxy: str | None = None
+    timeout: timedelta | Literal[False] | TimeoutConfig | None = None
+    limits: LimitConfig | None = None
+    ssl: bool | SSLConfig | None = None
+    log_path: pathlib.Path | None = None

http_config-0.1.4/src/http_config/httpx/__init__.py

@@ -0,0 +1,7 @@
+from http_config.httpx.client import create_async_client as async_client
+from http_config.httpx.client import create_sync_client as sync_client
+
+__all__ = [
+    "async_client",
+    "sync_client",
+]

http_config-0.1.4/src/http_config/httpx/client.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import TYPE_CHECKING, Literal, NotRequired, TypedDict
+
+import httpx
+
+from http_config._ssl import create_ssl_context
+from http_config.config import HTTPConfig, LimitConfig, TimeoutConfig
+from http_config.httpx.logger import AsyncTransportLogger, SyncTransportLogger
+
+if TYPE_CHECKING:
+    import ssl
+    from collections.abc import Callable
+
+__version__ = "0.1.0"
+
+
+# region Timeout
+
+
+class TimeoutDict(TypedDict):
+    timeout: NotRequired[float | None]
+    read: NotRequired[float | None]
+    write: NotRequired[float | None]
+    connect: NotRequired[float | None]
+
+
+def create_timeout(value: timedelta | Literal[False] | TimeoutConfig | None) -> httpx.Timeout | None:
+    match value:
+        case None:
+            return None
+        case TimeoutConfig() as v:
+            if v.timeout is None and v.read_timeout is None and v.write_timeout is None and v.connect_timeout is None:
+                return None
+
+            timeout_dct: TimeoutDict = {}
+            if v.timeout is not None:
+                timeout_dct["timeout"] = None if v.timeout is False else v.timeout.total_seconds()
+            if v.read_timeout is not None:
+                timeout_dct["read"] = None if v.read_timeout is False else v.read_timeout.total_seconds()
+            if v.write_timeout is not None:
+                timeout_dct["write"] = None if v.write_timeout is False else v.write_timeout.total_seconds()
+            if v.connect_timeout is not None:
+                timeout_dct["connect"] = None if v.connect_timeout is False else v.connect_timeout.total_seconds()
+            return httpx.Timeout(**timeout_dct)
+        case timedelta():
+            return httpx.Timeout(timeout=value.total_seconds())
+        case False:
+            return httpx.Timeout(timeout=None)
+
+
+# endregion
+
+# region Limits
+
+
+def create_limits(value: LimitConfig | None) -> httpx.Limits | None:
+    if value is None:
+        return None
+    return httpx.Limits(
+        max_connections=value.max_connections,
+        max_keepalive_connections=value.max_keepalive_connections,
+    )
+
+
+# endregion
+
+# region Transport
+
+
+class TransportDict(TypedDict):
+    verify: ssl.SSLContext
+    proxy: NotRequired[str]
+    limits: NotRequired[httpx.Limits]
+
+
+def create_transport_dct(http_config: HTTPConfig | None) -> TransportDict:
+    if http_config is None:
+        http_config = HTTPConfig()
+
+    transport_dct: TransportDict = {
+        "verify": create_ssl_context(http_config.ssl),
+    }
+
+    if (proxy := http_config.proxy) is not None:
+        transport_dct["proxy"] = proxy
+
+    if (limits := create_limits(http_config.limits)) is not None:
+        transport_dct["limits"] = limits
+
+    return transport_dct
+
+
+def create_async_transport(
+    http_config: HTTPConfig | None = None,
+    middleware: Callable[[httpx.AsyncBaseTransport], httpx.AsyncBaseTransport] | None = None,
+) -> httpx.AsyncBaseTransport:
+
+    transport = httpx.AsyncHTTPTransport(**create_transport_dct(http_config))
+    if http_config is not None and http_config.log_path is not None:
+        transport = AsyncTransportLogger(transport, http_config.log_path)
+    if middleware is not None:
+        transport = middleware(transport)
+    return transport
+
+
+def create_sync_transport(
+    http_config: HTTPConfig | None = None,
+    middleware: Callable[[httpx.BaseTransport], httpx.BaseTransport] | None = None,
+) -> httpx.BaseTransport:
+
+    transport = httpx.HTTPTransport(**create_transport_dct(http_config))
+    if http_config is not None and http_config.log_path is not None:
+        transport = SyncTransportLogger(transport, http_config.log_path)
+    if middleware is not None:
+        transport = middleware(transport)
+
+    return transport
+
+
+# endregion
+
+# region Client
+
+
+class ClientDict(TypedDict):
+    timeout: NotRequired[httpx.Timeout]
+
+
+def _create_client_dict(config: HTTPConfig) -> ClientDict:
+    dct: ClientDict = {}
+    if (timeout := create_timeout(config.timeout)) is not None:
+        dct["timeout"] = timeout
+    return dct
+
+
+def create_async_client(
+    http_config: HTTPConfig | None = None,
+    middleware: Callable[[httpx.AsyncBaseTransport], httpx.AsyncBaseTransport] | None = None,
+    auth: Callable[[httpx.AsyncClient], httpx.Auth] | httpx.Auth | None = None,
+) -> httpx.AsyncClient:
+
+    if http_config is None:
+        http_config = HTTPConfig()
+
+    client_dct = _create_client_dict(http_config)
+
+    client = httpx.AsyncClient(**client_dct, transport=create_async_transport(http_config, middleware=middleware))
+
+    if isinstance(auth, httpx.Auth):
+        client.auth = auth
+    elif auth is not None:
+        client.auth = auth(client)
+    return client
+
+
+def create_sync_client(
+    http_config: HTTPConfig | None = None,
+    middleware: Callable[[httpx.BaseTransport], httpx.BaseTransport] | None = None,
+    auth: Callable[[httpx.Client], httpx.Auth] | httpx.Auth | None = None,
+) -> httpx.Client:
+
+    if http_config is None:
+        http_config = HTTPConfig()
+
+    client_dct = _create_client_dict(http_config)
+
+    client = httpx.Client(**client_dct, transport=create_sync_transport(http_config, middleware=middleware))
+
+    if isinstance(auth, httpx.Auth):
+        client.auth = auth
+    elif auth is not None:
+        client.auth = auth(client)
+    return client
+
+
+# endregion

http_config-0.1.4/src/http_config/httpx/logger.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import contextlib
+import dataclasses
+import json
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+import httpx
+
+if TYPE_CHECKING:
+    import pathlib
+    from collections.abc import Generator
+    from zoneinfo import ZoneInfo
+
+
+# region Logger
+
+TZ: ZoneInfo | None = None
+
+
+def now() -> datetime:
+    return datetime.now(TZ)
+
+
+@dataclasses.dataclass
+class FileSession:
+    log_dir: pathlib.Path
+    prefix: str
+    suffix: str
+    idx: int
+
+    def _write_req_headers(self, request: httpx.Request) -> None:
+        data = {
+            "method": request.method,
+            "url": str(request.url),
+            "headers": dict(request.headers),
+        }
+        self.log_dir.joinpath(f"{self.prefix}_{self.idx:04d}_REQ_HEADERS.json").write_text(json.dumps(data, indent=2))
+
+    def _write_req_body(self, data: bytes) -> None:
+        if not data:
+            return
+        self.log_dir.joinpath(f"{self.prefix}_{self.idx:04d}_REQ_BODY{self.suffix}").write_bytes(data)
+
+    def _write_res_headers(self, response: httpx.Response) -> None:
+        data = {
+            "status_code": response.status_code,
+            "headers": dict(response.headers),
+        }
+        self.log_dir.joinpath(f"{self.prefix}_{self.idx:04d}_RES_HEADERS.json").write_text(json.dumps(data, indent=2))
+
+    def _write_res_body(self, data: bytes) -> None:
+        if not data:
+            return
+        self.log_dir.joinpath(f"{self.prefix}_{self.idx:04d}_RES_BODY{self.suffix}").write_bytes(data)
+
+    async def awrite_request(self, request: httpx.Request) -> None:
+        self._write_req_headers(request)
+        self._write_req_body(await request.aread())
+
+    async def awrite_response(self, response: httpx.Response) -> None:
+        self._write_res_headers(response)
+        self._write_res_body(await response.aread())
+
+    def write_request(self, request: httpx.Request) -> None:
+        self._write_req_headers(request)
+        self._write_req_body(request.read())
+
+    def write_response(self, response: httpx.Response) -> None:
+        self._write_res_headers(response)
+        self._write_res_body(response.read())
+
+
+class FileLogger:
+    def __init__(self, log_dir: pathlib.Path, suffix: str = ".txt", create_dir: bool = True) -> None:
+        if not log_dir.is_dir():
+            if log_dir.exists():
+                raise RuntimeError("log_dir is not a directory")
+            if not create_dir:
+                raise RuntimeError("log_dir does not exists")
+            log_dir.mkdir(parents=True)
+
+        self.log_dir = log_dir
+        self.prefix = now().strftime("%Y%m%d_%H%M%S")
+        self.suffix = suffix
+        self._idx = 0
+
+    def get_idx(self) -> int:
+        idx = self._idx
+        self._idx += 1
+        return idx
+
+    @contextlib.contextmanager
+    def session(self) -> Generator[FileSession, Any]:
+        yield FileSession(self.log_dir, self.prefix, self.suffix, self.get_idx())
+
+
+class AsyncTransportLogger(httpx.AsyncBaseTransport):
+    def __init__(self, transport: httpx.AsyncBaseTransport, log_dir: pathlib.Path, suffix: str = ".txt") -> None:
+        self._logger = FileLogger(log_dir, suffix=suffix)
+        self.transport = transport
+
+    async def handle_async_request(
+        self,
+        request: httpx.Request,
+    ) -> httpx.Response:
+        with self._logger.session() as session:
+            await session.awrite_request(request)
+            response = await self.transport.handle_async_request(request)
+            await session.awrite_response(response)
+            return response
+
+
+class SyncTransportLogger(httpx.BaseTransport):
+    def __init__(self, transport: httpx.BaseTransport, log_dir: pathlib.Path, suffix: str = ".txt") -> None:
+        self._logger = FileLogger(log_dir, suffix=suffix)
+        self.transport = transport
+
+    def handle_request(
+        self,
+        request: httpx.Request,
+    ) -> httpx.Response:
+        with self._logger.session() as session:
+            session.write_request(request)
+            response = self.transport.handle_request(request)
+            session.write_response(response)
+            return response
+
+
+# endregion