httpdex 0.1.0__tar.gz

httpdex-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+.coverage
+__pycache__/
+*.pyc
+dist/
+target/
+.venv/

httpdex-0.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: httpdex
+Version: 0.1.0
+Summary: A modern Python HTTP client. Drop-in replacement for httpx.
+Author: Marcelo Trylesinski
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: anyio>=4.0
+Requires-Dist: certifi
+Requires-Dist: httpdex-cookies>=0.1.0
+Requires-Dist: httpdex-core>=0.1.0
+Description-Content-Type: text/markdown
+
+# httpdex
+
+Drop-in replacement for `httpx` with HTTP/1.1, HTTP/2, and HTTP/3 support.
+
+## Highlights
+
+- `httpx`-compatible API
+- Async and sync clients
+- HTTP/2 via `http2=True`, HTTP/3 via `http3=True`
+- Request helpers: `httpdex.get()`, `httpdex.post()`, etc.
+- Cookie storage via `CookieStore`
+- ASGI-native testing with `ASGITransport` and `MockTransport`
+
+## Usage
+
+```python
+import httpdex
+
+# Simple request
+response = httpdex.get("https://example.com")
+
+# Client with connection reuse
+with httpdex.Client() as client:
+    response = client.get("https://example.com")
+
+# HTTP/2
+with httpdex.Client(http2=True) as client:
+    response = client.get("https://example.com")
+
+# Async
+async with httpdex.AsyncClient() as client:
+    response = await client.get("https://example.com")
+
+# Streaming
+with httpdex.Client() as client:
+    with client.stream("GET", "https://example.com/large") as response:
+        for chunk in response.iter_bytes():
+            process(chunk)
+```
+
+## Related Packages
+
+- `httpdex-core` - connection pool and transport layer
+- `httpdex-parse` - sans-I/O HTTP/1.1 parsing
+- `httpdex-h2` - HTTP/2 framing and HPACK
+- `httpdex-h3` - HTTP/3 over QUIC
+- `httpdex-cookies` - RFC 6265 cookie parsing and storage

httpdex-0.1.0/README.md

@@ -0,0 +1,47 @@
+# httpdex
+
+Drop-in replacement for `httpx` with HTTP/1.1, HTTP/2, and HTTP/3 support.
+
+## Highlights
+
+- `httpx`-compatible API
+- Async and sync clients
+- HTTP/2 via `http2=True`, HTTP/3 via `http3=True`
+- Request helpers: `httpdex.get()`, `httpdex.post()`, etc.
+- Cookie storage via `CookieStore`
+- ASGI-native testing with `ASGITransport` and `MockTransport`
+
+## Usage
+
+```python
+import httpdex
+
+# Simple request
+response = httpdex.get("https://example.com")
+
+# Client with connection reuse
+with httpdex.Client() as client:
+    response = client.get("https://example.com")
+
+# HTTP/2
+with httpdex.Client(http2=True) as client:
+    response = client.get("https://example.com")
+
+# Async
+async with httpdex.AsyncClient() as client:
+    response = await client.get("https://example.com")
+
+# Streaming
+with httpdex.Client() as client:
+    with client.stream("GET", "https://example.com/large") as response:
+        for chunk in response.iter_bytes():
+            process(chunk)
+```
+
+## Related Packages
+
+- `httpdex-core` - connection pool and transport layer
+- `httpdex-parse` - sans-I/O HTTP/1.1 parsing
+- `httpdex-h2` - HTTP/2 framing and HPACK
+- `httpdex-h3` - HTTP/3 over QUIC
+- `httpdex-cookies` - RFC 6265 cookie parsing and storage

httpdex-0.1.0/demo.py

@@ -0,0 +1,56 @@
+"""Demo: httpdex HTTP client - drop-in httpx replacement.
+
+Run with: python demo.py
+"""
+
+from __future__ import annotations
+
+import httpdex
+
+
+def demo_sync() -> None:
+    print("=== httpdex Sync Client Demo ===\n")
+
+    # Simple GET request (like httpx.get)
+    response = httpdex.get("https://httpbin.org/get")
+    print(f"GET /get -> {response.status_code}")
+    print(f"  Content-Type: {response.headers['content-type']}")
+    print(f"  Body length: {len(response.content)} bytes")
+    print(f"  Elapsed: {response.elapsed.total_seconds():.3f}s")
+    print()
+
+    # POST with JSON
+    response = httpdex.post("https://httpbin.org/post", json={"hello": "world"})
+    print(f"POST /post -> {response.status_code}")
+    data = response.json()
+    print(f"  Echoed JSON: {data['json']}")
+    print()
+
+    # Using Client for connection reuse
+    with httpdex.Client() as client:
+        for path in ["/get", "/headers", "/user-agent"]:
+            response = client.get(f"https://httpbin.org{path}")
+            print(f"GET {path} -> {response.status_code}")
+    print()
+
+
+async def demo_async() -> None:
+    print("=== httpdex Async Client Demo ===\n")
+
+    async with httpdex.AsyncClient() as client:
+        response = await client.get("https://httpbin.org/get")
+        print(f"GET /get -> {response.status_code}")
+
+        response = await client.post("https://httpbin.org/post", json={"async": True})
+        print(f"POST /post -> {response.status_code}")
+        data = response.json()
+        print(f"  Echoed JSON: {data['json']}")
+    print()
+
+
+if __name__ == "__main__":
+    demo_sync()
+
+    import anyio
+
+    anyio.run(demo_async)

httpdex-0.1.0/httpdex/__init__.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from httpdex._api import delete, get, head, options, patch, post, put, request
+from httpdex._auth import BasicAuth, DigestAuth
+from httpdex._client import AsyncClient, Client
+from httpdex._cookies import CookieStore
+from httpdex._exceptions import (
+    CloseError,
+    ConnectError,
+    ConnectTimeout,
+    DecodingError,
+    HTTPError,
+    HTTPStatusError,
+    InvalidURL,
+    NetworkError,
+    PoolTimeout,
+    ReadError,
+    ReadTimeout,
+    RequestError,
+    RequestNotRead,
+    ResponseNotRead,
+    StreamClosed,
+    StreamConsumed,
+    StreamError,
+    TimeoutException,
+    TooManyRedirects,
+    TransportError,
+    UnsupportedProtocol,
+    WriteError,
+    WriteTimeout,
+)
+from httpdex._headers import Headers
+from httpdex._models import Request, Response
+from httpdex._status_codes import codes
+from httpdex._timeout import Timeout
+from httpdex._transports import ASGITransport, MockTransport
+from httpdex._url import URL, QueryParams
+
+__all__ = [
+    "ASGITransport",
+    "AsyncClient",
+    "BasicAuth",
+    "Client",
+    "CloseError",
+    "CookieStore",
+    "ConnectError",
+    "ConnectTimeout",
+    "DecodingError",
+    "DigestAuth",
+    "HTTPError",
+    "HTTPStatusError",
+    "Headers",
+    "InvalidURL",
+    "MockTransport",
+    "NetworkError",
+    "PoolTimeout",
+    "QueryParams",
+    "ReadError",
+    "ReadTimeout",
+    "Request",
+    "RequestError",
+    "RequestNotRead",
+    "Response",
+    "ResponseNotRead",
+    "StreamClosed",
+    "StreamConsumed",
+    "StreamError",
+    "Timeout",
+    "TimeoutException",
+    "TooManyRedirects",
+    "TransportError",
+    "URL",
+    "UnsupportedProtocol",
+    "WriteError",
+    "WriteTimeout",
+    "codes",
+    "delete",
+    "get",
+    "head",
+    "options",
+    "patch",
+    "post",
+    "put",
+    "request",
+]

httpdex-0.1.0/httpdex/_api.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from httpdex._client import Client
+from httpdex._headers import Headers
+from httpdex._models import Response
+from httpdex._url import URL
+
+
+def request(
+    method: str,
+    url: URL | str,
+    *,
+    params: Mapping[str, str] | Sequence[tuple[str, str]] | None = None,
+    content: str | bytes | None = None,
+    data: Mapping[str, Any] | None = None,
+    json: Any | None = None,
+    headers: Headers | Mapping[str, str] | Sequence[tuple[str, str]] | None = None,
+    cookies: dict[str, str] | None = None,
+    follow_redirects: bool = False,
+    timeout: float | None = 5.0,
+) -> Response:
+    with Client() as client:
+        return client.request(
+            method,
+            url,
+            params=params,
+            content=content,
+            data=data,
+            json=json,
+            headers=headers,
+            cookies=cookies,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+        )
+
+
+def get(url: URL | str, **kwargs: Any) -> Response:
+    return request("GET", url, **kwargs)
+
+
+def post(url: URL | str, **kwargs: Any) -> Response:
+    return request("POST", url, **kwargs)
+
+
+def put(url: URL | str, **kwargs: Any) -> Response:
+    return request("PUT", url, **kwargs)
+
+
+def patch(url: URL | str, **kwargs: Any) -> Response:
+    return request("PATCH", url, **kwargs)
+
+
+def delete(url: URL | str, **kwargs: Any) -> Response:
+    return request("DELETE", url, **kwargs)
+
+
+def head(url: URL | str, **kwargs: Any) -> Response:
+    return request("HEAD", url, **kwargs)
+
+
+def options(url: URL | str, **kwargs: Any) -> Response:
+    return request("OPTIONS", url, **kwargs)

httpdex-0.1.0/httpdex/_api_test.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import httpdex_core
+
+import httpdex
+
+
+def _ok_handler(raw_request: bytes) -> bytes:
+    body = b'{"ok": true}'
+    return (
+        b"HTTP/1.1 200 OK\r\n"
+        b"Content-Type: application/json\r\n"
+        b"Content-Length: " + str(len(body)).encode() + b"\r\n"
+        b"\r\n" + body
+    )
+
+
+def _patch_client_backend(client: httpdex.Client) -> None:
+    client._pool._backend = httpdex_core.MockSyncBackend(_ok_handler)  # type: ignore[assignment]
+
+
+def test_get() -> None:
+    with patch.object(httpdex._api, "Client") as MockClient:
+        real_client = httpdex.Client()
+        _patch_client_backend(real_client)
+        MockClient.return_value.__enter__ = lambda self: real_client
+        MockClient.return_value.__exit__ = lambda self, *args: real_client.close()
+        response = httpdex.get("http://example.com/")
+        assert response.status_code == 200
+
+
+def test_post() -> None:
+    with patch.object(httpdex._api, "Client") as MockClient:
+        real_client = httpdex.Client()
+        _patch_client_backend(real_client)
+        MockClient.return_value.__enter__ = lambda self: real_client
+        MockClient.return_value.__exit__ = lambda self, *args: real_client.close()
+        response = httpdex.post("http://example.com/", json={"key": "value"})
+        assert response.status_code == 200
+
+
+def test_all_methods() -> None:
+    with patch.object(httpdex._api, "Client") as MockClient:
+        real_client = httpdex.Client()
+        _patch_client_backend(real_client)
+        MockClient.return_value.__enter__ = lambda self: real_client
+        MockClient.return_value.__exit__ = lambda self, *args: real_client.close()
+        for func in [httpdex.put, httpdex.patch, httpdex.delete, httpdex.head, httpdex.options]:
+            response = func("http://example.com/")
+            # Client is reused, connection gets reused or recreated.
+            assert response is not None

httpdex-0.1.0/httpdex/_auth.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import base64
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from httpdex._models import Request
+
+
+class BasicAuth:
+    """HTTP Basic authentication."""
+
+    def __init__(self, username: str | bytes, password: str | bytes) -> None:
+        if isinstance(username, str):
+            username = username.encode("latin-1")
+        if isinstance(password, str):
+            password = password.encode("latin-1")
+        self._username = username
+        self._password = password
+
+    def __call__(self, request: Request) -> Request:
+        credentials = base64.b64encode(self._username + b":" + self._password).decode("ascii")
+        request.headers._raw.append((b"authorization", f"Basic {credentials}".encode("latin-1")))
+        return request
+
+
+class DigestAuth:
+    """HTTP Digest authentication (stub)."""
+
+    def __init__(self, username: str | bytes, password: str | bytes) -> None:
+        if isinstance(username, str):
+            username = username.encode("latin-1")
+        if isinstance(password, str):
+            password = password.encode("latin-1")
+        self._username = username
+        self._password = password
+
+    def __call__(self, request: Request) -> Request:
+        # TODO: implement digest auth challenge-response
+        raise NotImplementedError("DigestAuth is not yet implemented")

httpdex-0.1.0/httpdex/_auth_test.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from httpdex._auth import BasicAuth, DigestAuth
+from httpdex._models import Request
+
+
+def test_basic_auth_str_credentials() -> None:
+    auth = BasicAuth(username="user", password="pass")
+    req = Request("GET", "https://example.com/")
+    req = auth(req)
+    assert "authorization" in req.headers
+    assert req.headers["authorization"].startswith("Basic ")
+
+
+def test_basic_auth_bytes_credentials() -> None:
+    auth = BasicAuth(username=b"user", password=b"pass")
+    req = Request("GET", "https://example.com/")
+    req = auth(req)
+    assert "authorization" in req.headers
+    assert req.headers["authorization"].startswith("Basic ")
+
+
+def test_basic_auth_mixed_credentials() -> None:
+    auth = BasicAuth(username="user", password=b"pass")
+    req = Request("GET", "https://example.com/")
+    req = auth(req)
+    assert "authorization" in req.headers
+
+
+def test_digest_auth_init_str() -> None:
+    auth = DigestAuth(username="user", password="pass")
+    assert auth._username == b"user"
+    assert auth._password == b"pass"
+
+
+def test_digest_auth_init_bytes() -> None:
+    auth = DigestAuth(username=b"user", password=b"pass")
+    assert auth._username == b"user"
+    assert auth._password == b"pass"