pathapi-httpx 0.1.0__tar.gz

pathapi_httpx-0.1.0/.gitignore

@@ -0,0 +1,41 @@
+# Category rule: nothing dot-prefixed at the repo root gets tracked except the
+# files re-included below (a category beats a list). Root-anchored on purpose;
+# nested dotfiles are governed by the specific rules further down.
+/.*
+!/.gitignore
+!/.gitattributes
+!/.github/
+
+# Private agent config. No trailing slash on `.agents` on purpose: it may be a
+# symlink, which git treats as a file, so a directory-only `.agents/` would not
+# match it. These stay even though /.* covers the root: they also catch nested
+# copies. *.local.* is an unshared, machine- or user-specific override and is
+# never committed (it is also excluded from the build in pyproject.toml).
+.agents
+*.local.*
+CLAUDE*
+.claude
+
+# Build/dist output and generated docs site
+build/
+dist/
+site/
+
+# Python
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.hypothesis/
+.mypy_cache/
+.ruff_cache/
+.coverage*
+htmlcov/
+*.egg-info/
+.venv/
+.pyvenv/
+
+# OS/editor
+.DS_Store
+Thumbs.db
+.idea/
+.vscode/

pathapi_httpx-0.1.0/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-17
+
+### Added
+
+- `pathapi_httpx.HttpxTransport` and `pathapi_httpx.AsyncHttpxTransport`, the
+  HTTP transports of `pathapi.http` over `httpx.Client` and `httpx.AsyncClient`,
+  and `pathapi_httpx.__version__`. They need Python 3.9 or newer,
+  `pathapi>=0.1.2,<0.2` and `httpx>=0.28.0,<0.29`.
+- The distribution declares the `httpx` entry of the `pathapi.http_transports`
+  and of the `pathapi.http_async_transports` groups. Installing it is all that
+  `pathapi.http` needs to send through them:
+  `HTTPClient(HttpxTransport(client))`, `AsyncHTTPClient(AsyncHttpxTransport())`,
+  `PATHAPI_HTTP_TRANSPORT=httpx` and `PATHAPI_HTTP_ASYNC_TRANSPORT=httpx` use
+  them, `pathapi.http.get_transport("httpx")` and
+  `pathapi.http.get_async_transport("httpx")` load them, and
+  `pathapi.http.transport_names()` and `async_transport_names()` list them.
+- The tests `pathapi` runs over its own transports run over these
+  (`python -m pathapi.http.testing --http-transports httpx --http-async-transports httpx`)
+  as part of the test suite.
+
+[Unreleased]: https://github.com/jose-pr/pathapi-httpx/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/jose-pr/pathapi-httpx/releases/tag/v0.1.0

pathapi_httpx-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jose A
+
+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.

pathapi_httpx-0.1.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.5
+Name: pathapi-httpx
+Version: 0.1.0
+Summary: The httpx HTTP transports for pathapi: a synchronous one and a native async one, with HTTP/2, your own httpx client and its mounts
+Project-URL: Homepage, https://github.com/jose-pr/pathapi-httpx/
+Project-URL: Documentation, https://jose-pr.github.io/pathapi-httpx/
+Project-URL: Issues, https://github.com/jose-pr/pathapi-httpx/issues
+Author: Jose A
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx<0.29,>=0.28.0
+Requires-Dist: pathapi<0.2,>=0.1.2
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: cryptography; extra == 'dev'
+Requires-Dist: hatchling; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == 'docs'
+Requires-Dist: mkdocs-material; extra == 'docs'
+Requires-Dist: mkdocstrings[python]; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# pathapi-httpx
+
+[![Version](https://img.shields.io/pypi/v/pathapi-httpx.svg)](https://pypi.org/project/pathapi-httpx/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pathapi-httpx.svg)](https://pypi.org/project/pathapi-httpx/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/jose-pr/pathapi-httpx/blob/main/LICENSE)
+[![Docs](https://img.shields.io/badge/docs-latest-blue.svg)](https://jose-pr.github.io/pathapi-httpx/)
+[![CI](https://img.shields.io/github/actions/workflow/status/jose-pr/pathapi-httpx/test.yml)](https://github.com/jose-pr/pathapi-httpx/actions/workflows/test.yml)
+
+**The `httpx` HTTP transports for [`pathapi`](https://github.com/jose-pr/pathapi).**
+`pathapi.http` sends requests with a transport built on the standard library,
+and from an event loop with that transport on worker threads. Install this
+distribution and `HTTPClient` sends through an `httpx.Client`, and
+`AsyncHTTPClient` through an `httpx.AsyncClient` on the caller's loop, with
+nothing to configure. It is documented at
+<https://jose-pr.github.io/pathapi-httpx/>.
+
+## Features
+
+| You want | Built-in transports | These transports |
+| --- | --- | --- |
+| Requests from an event loop without a worker thread per request | No: `ThreadedTransport` runs the standard-library transport on threads | Yes: `AsyncHttpxTransport` |
+| HTTP/2 | No | Yes: `HttpxTransport(http2=True)` with `httpx[http2]` |
+| Your own `httpx.Client` or `httpx.AsyncClient`: mounted transports, limits, proxies, `auth` | No | Yes: `HttpxTransport(client)` |
+| `SSL_CERT_FILE`, `SSL_CERT_DIR` and the certifi bundle | The system trust store, or an `ssl_context=` | Yes |
+| Proxies from the environment, `proxy=` and `mounts=` | `http://` proxies through a provider | Yes, as `httpx` does them |
+
+- **Credentials belong to one server.** The `auth` of a client is sent to the
+  server of the first request and to no other, and the clients of `pathapi.http`
+  never take an `Authorization` header to another server on a redirect.
+- **Exactly the headers it is given.** A client's default headers and cookies
+  are not added: `HTTPClient` and `AsyncHTTPClient` own the headers of a request.
+- **No third-party text in an error.** A failure of `httpx` is a
+  `TimeoutError`, `ConnectionError`, `ssl.SSLError`, `ValueError` or
+  `OSError(EIO)`; what the library says, which can quote a URL, is never passed on.
+- **The same promises as the built-in transports.** The tests `pathapi` runs
+  over its own transports run over these
+  (`python -m pathapi.http.testing --http-transports httpx --http-async-transports httpx`).
+
+## Installation
+
+```bash
+pip install pathapi-httpx
+```
+
+Requires `pathapi` and `httpx`, which pip installs with it. HTTP/2 needs
+`pip install "httpx[http2]"`.
+
+## Quick start
+
+**Send through an `httpx.Client` from threads or a script:**
+
+```python
+import httpx
+from pathapi.http import HTTPClient
+from pathapi_httpx import HttpxTransport
+
+with httpx.Client() as session:
+    with HTTPClient(HttpxTransport(session), timeout=(3, 30)) as client:
+        reply = client.request("GET", "http://files.example.org/reports/today.txt")
+        print(reply.read().decode())
+```
+
+The `httpx.Client` stays yours: neither the client nor the transport closes it.
+
+**Send from an event loop** with `httpx.AsyncClient` on that loop:
+
+```python
+import asyncio
+
+from pathapi.http import AsyncHTTPClient
+from pathapi_httpx import AsyncHttpxTransport
+
+
+async def main():
+    async with AsyncHttpxTransport() as transport:
+        async with AsyncHTTPClient(transport) as client:
+            replies = await asyncio.gather(
+                *(
+                    client.request("GET", f"http://files.example.org/reports/{day}.txt")
+                    for day in ("mon", "tue", "wed")
+                )
+            )
+            print([len(await reply.read()) for reply in replies])
+
+
+asyncio.run(main())
+```
+
+**Choose them for the whole process.** `PATHAPI_HTTP_TRANSPORT=httpx` and
+`PATHAPI_HTTP_ASYNC_TRANSPORT=httpx` make every `HTTPClient` and
+`AsyncHTTPClient` that was given no transport send through a new `httpx` client:
+
+```bash
+PATHAPI_HTTP_ASYNC_TRANSPORT=httpx python -c "from pathapi.http import AsyncHTTPClient; print(type(AsyncHTTPClient().transport))"
+```
+
+## API overview
+
+| Name | Purpose |
+| --- | --- |
+| `pathapi_httpx.HttpxTransport` | The transport: `send()` and `close()` over an `httpx.Client` |
+| `pathapi_httpx.AsyncHttpxTransport` | The async transport: `await send()` and `await aclose()` over an `httpx.AsyncClient` |
+| `pathapi_httpx.__version__` | The installed version |
+
+`pathapi.http` finds the classes through the `httpx` entries of its
+`pathapi.http_transports` and `pathapi.http_async_transports` entry-point
+groups, which this distribution declares. The reference is in the
+[API header](https://github.com/jose-pr/pathapi-httpx/blob/main/src/pathapi_httpx/AGENTS.md)
+that ships with the package.
+
+## Development
+
+```bash
+python -m venv .venv/3.14-posix-x86_64
+.venv/3.14-posix-x86_64/bin/python -m pip install -e ".[dev]"
+.venv/3.14-posix-x86_64/bin/python -m pytest -q -rs
+```
+
+`pathapi` 0.1.2 is a dependency; while it is not on PyPI, install it
+editable from its checkout first (`pip install -e ../pathapi`). The test run
+includes `python -m pathapi.http.testing --http-transports httpx
+--http-async-transports httpx`, the tests `pathapi` runs over its own transports.
+
+### Releasing
+
+This project follows [Semantic Versioning](https://semver.org/) and keeps a
+[`CHANGELOG.md`](CHANGELOG.md). Pushing a tag matching `v*` triggers the release
+workflow: test gate → build (checking the tag names the version built) → a strict
+docs build as a gate → GitHub release → publish. The release workflow never deploys
+the docs site itself: for a final release its last job dispatches the docs workflow
+at the tag, which owns every Pages deploy.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pathapi_httpx-0.1.0/README.md

@@ -0,0 +1,135 @@
+# pathapi-httpx
+
+[![Version](https://img.shields.io/pypi/v/pathapi-httpx.svg)](https://pypi.org/project/pathapi-httpx/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pathapi-httpx.svg)](https://pypi.org/project/pathapi-httpx/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/jose-pr/pathapi-httpx/blob/main/LICENSE)
+[![Docs](https://img.shields.io/badge/docs-latest-blue.svg)](https://jose-pr.github.io/pathapi-httpx/)
+[![CI](https://img.shields.io/github/actions/workflow/status/jose-pr/pathapi-httpx/test.yml)](https://github.com/jose-pr/pathapi-httpx/actions/workflows/test.yml)
+
+**The `httpx` HTTP transports for [`pathapi`](https://github.com/jose-pr/pathapi).**
+`pathapi.http` sends requests with a transport built on the standard library,
+and from an event loop with that transport on worker threads. Install this
+distribution and `HTTPClient` sends through an `httpx.Client`, and
+`AsyncHTTPClient` through an `httpx.AsyncClient` on the caller's loop, with
+nothing to configure. It is documented at
+<https://jose-pr.github.io/pathapi-httpx/>.
+
+## Features
+
+| You want | Built-in transports | These transports |
+| --- | --- | --- |
+| Requests from an event loop without a worker thread per request | No: `ThreadedTransport` runs the standard-library transport on threads | Yes: `AsyncHttpxTransport` |
+| HTTP/2 | No | Yes: `HttpxTransport(http2=True)` with `httpx[http2]` |
+| Your own `httpx.Client` or `httpx.AsyncClient`: mounted transports, limits, proxies, `auth` | No | Yes: `HttpxTransport(client)` |
+| `SSL_CERT_FILE`, `SSL_CERT_DIR` and the certifi bundle | The system trust store, or an `ssl_context=` | Yes |
+| Proxies from the environment, `proxy=` and `mounts=` | `http://` proxies through a provider | Yes, as `httpx` does them |
+
+- **Credentials belong to one server.** The `auth` of a client is sent to the
+  server of the first request and to no other, and the clients of `pathapi.http`
+  never take an `Authorization` header to another server on a redirect.
+- **Exactly the headers it is given.** A client's default headers and cookies
+  are not added: `HTTPClient` and `AsyncHTTPClient` own the headers of a request.
+- **No third-party text in an error.** A failure of `httpx` is a
+  `TimeoutError`, `ConnectionError`, `ssl.SSLError`, `ValueError` or
+  `OSError(EIO)`; what the library says, which can quote a URL, is never passed on.
+- **The same promises as the built-in transports.** The tests `pathapi` runs
+  over its own transports run over these
+  (`python -m pathapi.http.testing --http-transports httpx --http-async-transports httpx`).
+
+## Installation
+
+```bash
+pip install pathapi-httpx
+```
+
+Requires `pathapi` and `httpx`, which pip installs with it. HTTP/2 needs
+`pip install "httpx[http2]"`.
+
+## Quick start
+
+**Send through an `httpx.Client` from threads or a script:**
+
+```python
+import httpx
+from pathapi.http import HTTPClient
+from pathapi_httpx import HttpxTransport
+
+with httpx.Client() as session:
+    with HTTPClient(HttpxTransport(session), timeout=(3, 30)) as client:
+        reply = client.request("GET", "http://files.example.org/reports/today.txt")
+        print(reply.read().decode())
+```
+
+The `httpx.Client` stays yours: neither the client nor the transport closes it.
+
+**Send from an event loop** with `httpx.AsyncClient` on that loop:
+
+```python
+import asyncio
+
+from pathapi.http import AsyncHTTPClient
+from pathapi_httpx import AsyncHttpxTransport
+
+
+async def main():
+    async with AsyncHttpxTransport() as transport:
+        async with AsyncHTTPClient(transport) as client:
+            replies = await asyncio.gather(
+                *(
+                    client.request("GET", f"http://files.example.org/reports/{day}.txt")
+                    for day in ("mon", "tue", "wed")
+                )
+            )
+            print([len(await reply.read()) for reply in replies])
+
+
+asyncio.run(main())
+```
+
+**Choose them for the whole process.** `PATHAPI_HTTP_TRANSPORT=httpx` and
+`PATHAPI_HTTP_ASYNC_TRANSPORT=httpx` make every `HTTPClient` and
+`AsyncHTTPClient` that was given no transport send through a new `httpx` client:
+
+```bash
+PATHAPI_HTTP_ASYNC_TRANSPORT=httpx python -c "from pathapi.http import AsyncHTTPClient; print(type(AsyncHTTPClient().transport))"
+```
+
+## API overview
+
+| Name | Purpose |
+| --- | --- |
+| `pathapi_httpx.HttpxTransport` | The transport: `send()` and `close()` over an `httpx.Client` |
+| `pathapi_httpx.AsyncHttpxTransport` | The async transport: `await send()` and `await aclose()` over an `httpx.AsyncClient` |
+| `pathapi_httpx.__version__` | The installed version |
+
+`pathapi.http` finds the classes through the `httpx` entries of its
+`pathapi.http_transports` and `pathapi.http_async_transports` entry-point
+groups, which this distribution declares. The reference is in the
+[API header](https://github.com/jose-pr/pathapi-httpx/blob/main/src/pathapi_httpx/AGENTS.md)
+that ships with the package.
+
+## Development
+
+```bash
+python -m venv .venv/3.14-posix-x86_64
+.venv/3.14-posix-x86_64/bin/python -m pip install -e ".[dev]"
+.venv/3.14-posix-x86_64/bin/python -m pytest -q -rs
+```
+
+`pathapi` 0.1.2 is a dependency; while it is not on PyPI, install it
+editable from its checkout first (`pip install -e ../pathapi`). The test run
+includes `python -m pathapi.http.testing --http-transports httpx
+--http-async-transports httpx`, the tests `pathapi` runs over its own transports.
+
+### Releasing
+
+This project follows [Semantic Versioning](https://semver.org/) and keeps a
+[`CHANGELOG.md`](CHANGELOG.md). Pushing a tag matching `v*` triggers the release
+workflow: test gate → build (checking the tag names the version built) → a strict
+docs build as a gate → GitHub release → publish. The release workflow never deploys
+the docs site itself: for a final release its last job dispatches the docs workflow
+at the tag, which owns every Pages deploy.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pathapi_httpx-0.1.0/docs/api/transport.md

@@ -0,0 +1,23 @@
+# The transports
+
+`HttpxTransport` implements the HTTP transport contract of `pathapi.http`:
+`send()` makes one request with an `httpx.Client` and returns an
+`HTTPResponse`, and `close()` closes a client the transport made.
+`AsyncHttpxTransport` implements the async contract: `await send()` makes one
+request with an `httpx.AsyncClient` on the running event loop and returns an
+`AsyncHTTPResponse`, and `await aclose()` closes a client the transport made.
+`pathapi.http` finds them through the `httpx` entries of its
+`pathapi.http_transports` and `pathapi.http_async_transports` entry-point
+groups, so `PATHAPI_HTTP_TRANSPORT=httpx`,
+`PATHAPI_HTTP_ASYNC_TRANSPORT=httpx`, `pathapi.http.get_transport("httpx")` and
+`pathapi.http.get_async_transport("httpx")` name them.
+
+::: pathapi_httpx.HttpxTransport
+    options:
+      show_if_no_docstring: true
+      filters: ["!^_"]
+
+::: pathapi_httpx.AsyncHttpxTransport
+    options:
+      show_if_no_docstring: true
+      filters: ["!^_"]

pathapi_httpx-0.1.0/docs/benchmarks.md

@@ -0,0 +1,20 @@
+# Benchmarks
+
+`benchmarks/bench.py` times a batch of concurrent requests through
+`AsyncHTTPClient` against a loopback server that answers each request after a
+fixed delay: with `ThreadedTransport`, the default, which waits for each reply
+on a worker thread, and with `AsyncHttpxTransport`, which waits on the event
+loop. It also times `HTTPClient` with `HttpxTransport` and the built-in
+transport on the same sequential requests.
+
+```bash
+python benchmarks/bench.py            # run the benchmarks
+python benchmarks/bench.py --help     # options; runs nothing
+python benchmarks/bench.py --save     # also write benchmarks/results/<name>.json
+```
+
+Compare two runs on their medians, and only between runs from the same machine
+and interpreter. The result schema is described in
+[`benchmarks/README.md`](https://github.com/jose-pr/pathapi-httpx/blob/main/benchmarks/README.md).
+A run on a developer machine is a sanity check; performance claims come from CI
+runs.

pathapi_httpx-0.1.0/docs/changelog.md

@@ -0,0 +1,3 @@
+# Changelog
+
+--8<-- "CHANGELOG.md"

pathapi_httpx-0.1.0/docs/index.md

@@ -0,0 +1,47 @@
+# pathapi-httpx
+
+The **`httpx` HTTP transports for [`pathapi`](https://jose-pr.github.io/pathapi/)**.
+`pathapi.http` sends requests with a transport built on the standard
+library, and from an event loop with that transport on worker threads. Install
+this distribution and `HTTPClient` sends through an `httpx.Client`, and
+`AsyncHTTPClient` through an `httpx.AsyncClient` on the caller's loop, with
+nothing to configure.
+
+## Installation
+
+```bash
+pip install pathapi-httpx
+```
+
+HTTP/2 needs `pip install "httpx[http2]"`.
+
+## 30-second tour
+
+```python
+import asyncio
+
+from pathapi.http import AsyncHTTPClient
+from pathapi_httpx import AsyncHttpxTransport
+
+
+async def main():
+    async with AsyncHttpxTransport() as transport:
+        async with AsyncHTTPClient(transport) as client:
+            reply = await client.request(
+                "GET", "http://files.example.org/reports/today.txt"
+            )
+            print((await reply.read()).decode())
+
+
+asyncio.run(main())
+```
+
+`PATHAPI_HTTP_TRANSPORT=httpx` and `PATHAPI_HTTP_ASYNC_TRANSPORT=httpx` make
+every `HTTPClient` and `AsyncHTTPClient` that was given no transport send
+through a new `httpx` client.
+
+## Learn more
+
+- [The transports](api/transport.md): `HttpxTransport` and `AsyncHttpxTransport`, their arguments and what they guarantee.
+- [Benchmarks](benchmarks.md): concurrent requests through the thread-backed default and `AsyncHttpxTransport` on loopback.
+- [Changelog](changelog.md)

pathapi_httpx-0.1.0/examples/async_client.py

@@ -0,0 +1,48 @@
+"""Fetch several files at once from an event loop with `AsyncHttpxTransport`.
+
+The script starts a small server on the loopback interface, so it needs no
+network: an `AsyncHTTPClient` over `AsyncHttpxTransport` sends the requests
+together on the running loop, each from the same pool of connections.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import http.server
+import threading
+
+from pathapi.http import AsyncHTTPClient
+from pathapi_httpx import AsyncHttpxTransport
+
+
+class Handler(http.server.BaseHTTPRequestHandler):
+    def do_GET(self):
+        body = f"contents of {self.path}\n".encode()
+        self.send_response(200)
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, *args):
+        pass
+
+
+async def main(base: str) -> None:
+    async with AsyncHttpxTransport() as transport:
+        async with AsyncHTTPClient(transport, timeout=(3, 30)) as client:
+            names = ("a.txt", "b.txt", "c.txt")
+            replies = await asyncio.gather(
+                *(client.request("GET", f"{base}/{name}") for name in names)
+            )
+            for reply in replies:
+                print((await reply.read()).decode(), end="")
+
+
+if __name__ == "__main__":
+    server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    try:
+        asyncio.run(main(f"http://127.0.0.1:{server.server_port}"))
+    finally:
+        server.shutdown()
+        server.server_close()

pathapi_httpx-0.1.0/mkdocs.yml

@@ -0,0 +1,52 @@
+site_name: pathapi-httpx
+site_description: The httpx HTTP transports for pathapi
+site_url: https://jose-pr.github.io/pathapi-httpx/
+repo_url: https://github.com/jose-pr/pathapi-httpx
+repo_name: jose-pr/pathapi-httpx
+edit_uri: edit/main/docs/
+
+# Constrain the scan to docs/ so pymdownx.snippets + strict nav don't trip on
+# repo-level markdown.
+docs_dir: docs
+
+theme:
+  name: material
+  palette:
+    - media: "(prefers-color-scheme: light)"
+      scheme: default
+      toggle:
+        icon: material/brightness-7
+        name: Switch to dark mode
+    - media: "(prefers-color-scheme: dark)"
+      scheme: slate
+      toggle:
+        icon: material/brightness-4
+        name: Switch to light mode
+  features:
+    - navigation.sections
+    - content.code.copy
+
+nav:
+  - Home: index.md
+  - Benchmarks: benchmarks.md
+  - API Reference:
+      - The transports: api/transport.md
+  - Changelog: changelog.md
+
+plugins:
+  - search
+  - mkdocstrings:
+      handlers:
+        python:
+          options:
+            show_source: true
+            show_root_heading: true
+            merge_init_into_class: true
+            show_if_no_docstring: true
+
+markdown_extensions:
+  - admonition
+  - tables
+  - pymdownx.snippets:
+      base_path: ["."]
+  - pymdownx.superfences