httpdex 0.1.0__py3-none-any.whl

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/_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/_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/_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/_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"