universal-common-net-http 1.0.0__py3-none-any.whl

universal_common_net_http/__init__.py

@@ -0,0 +1,1134 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import gzip
+import http.client
+import http.cookiejar
+import json
+import socket
+import ssl
+import threading
+import time
+import zlib
+from typing import Any, AsyncIterator, Callable, Iterable, Optional, Union
+from urllib.parse import urlencode, urljoin, urlparse
+
+class HttpMethod:
+    GET = "GET"
+    POST = "POST"
+    PUT = "PUT"
+    DELETE = "DELETE"
+    HEAD = "HEAD"
+    OPTIONS = "OPTIONS"
+    TRACE = "TRACE"
+    PATCH = "PATCH"
+
+class HttpStatusCode:
+    CONTINUE = 100
+    SWITCHING_PROTOCOLS = 101
+    PROCESSING = 102
+    EARLY_HINTS = 103
+    OK = 200
+    CREATED = 201
+    ACCEPTED = 202
+    NON_AUTHORITATIVE_INFORMATION = 203
+    NO_CONTENT = 204
+    RESET_CONTENT = 205
+    PARTIAL_CONTENT = 206
+    MULTI_STATUS = 207
+    ALREADY_REPORTED = 208
+    IM_USED = 226
+    MULTIPLE_CHOICES = 300
+    AMBIGUOUS = 300
+    MOVED_PERMANENTLY = 301
+    MOVED = 301
+    FOUND = 302
+    REDIRECT = 302
+    SEE_OTHER = 303
+    REDIRECT_METHOD = 303
+    NOT_MODIFIED = 304
+    USE_PROXY = 305
+    UNUSED = 306
+    TEMPORARY_REDIRECT = 307
+    REDIRECT_KEEP_VERB = 307
+    PERMANENT_REDIRECT = 308
+    BAD_REQUEST = 400
+    UNAUTHORIZED = 401
+    PAYMENT_REQUIRED = 402
+    FORBIDDEN = 403
+    NOT_FOUND = 404
+    METHOD_NOT_ALLOWED = 405
+    NOT_ACCEPTABLE = 406
+    PROXY_AUTHENTICATION_REQUIRED = 407
+    REQUEST_TIMEOUT = 408
+    CONFLICT = 409
+    GONE = 410
+    LENGTH_REQUIRED = 411
+    PRECONDITION_FAILED = 412
+    REQUEST_ENTITY_TOO_LARGE = 413
+    REQUEST_URI_TOO_LONG = 414
+    UNSUPPORTED_MEDIA_TYPE = 415
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416
+    EXPECTATION_FAILED = 417
+    IM_A_TEAPOT = 418
+    MISDIRECTED_REQUEST = 421
+    UNPROCESSABLE_ENTITY = 422
+    LOCKED = 423
+    FAILED_DEPENDENCY = 424
+    TOO_EARLY = 425
+    UPGRADE_REQUIRED = 426
+    PRECONDITION_REQUIRED = 428
+    TOO_MANY_REQUESTS = 429
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451
+    INTERNAL_SERVER_ERROR = 500
+    NOT_IMPLEMENTED = 501
+    BAD_GATEWAY = 502
+    SERVICE_UNAVAILABLE = 503
+    GATEWAY_TIMEOUT = 504
+    HTTP_VERSION_NOT_SUPPORTED = 505
+    VARIANT_ALSO_NEGOTIATES = 506
+    INSUFFICIENT_STORAGE = 507
+    LOOP_DETECTED = 508
+    NOT_EXTENDED = 510
+    NETWORK_AUTHENTICATION_REQUIRED = 511
+
+class HttpVersion:
+    """HTTP protocol versions recognized by HttpRequestMessage.version.
+
+    Only HTTP/1.0 and HTTP/1.1 are actually sendable: Python's standard library
+    (http.client) implements nothing above HTTP/1.1. HTTP/2 requires binary framing,
+    HPACK header compression, and multiplexed stream state (see the third-party 'h2'
+    package); HTTP/3 additionally requires QUIC over UDP (see 'aioquic'). The 2.0/3.0
+    constants exist so callers can refer to them symbolically; using them raises
+    NotImplementedError at send time rather than silently downgrading or hanging.
+    """
+
+    HTTP_1_0 = "1.0"
+    HTTP_1_1 = "1.1"
+    HTTP_2_0 = "2.0"
+    HTTP_3_0 = "3.0"
+
+_SUPPORTED_HTTP_VERSIONS = {
+    HttpVersion.HTTP_1_0: (10, "HTTP/1.0"),
+    HttpVersion.HTTP_1_1: (11, "HTTP/1.1"),
+}
+
+class HttpCompletionOption:
+    """Mirrors System.Net.Http.HttpCompletionOption."""
+
+    RESPONSE_CONTENT_READ = "response_content_read"
+    RESPONSE_HEADERS_READ = "response_headers_read"
+
+class HttpHeaders:
+    """Case-insensitive, multi-value header collection, matching the semantics of System.Net.Http.Headers.HttpHeaders."""
+
+    def __init__(self, items: Optional[Iterable[tuple[str, str]]] = None):
+        self._entries: list[tuple[str, str]] = []
+        if items:
+            self.update(items)
+
+    @staticmethod
+    def _normalize(name: str) -> str:
+        return name.lower()
+
+    def add(self, name: str, value: str):
+        self._entries.append((name, value))
+
+    def get_all(self, name: str) -> list[str]:
+        key = self._normalize(name)
+        return [value for entry_name, value in self._entries if self._normalize(entry_name) == key]
+
+    def get(self, name: str, default: Optional[str] = None) -> Optional[str]:
+        values = self.get_all(name)
+        return values[0] if values else default
+
+    def remove(self, name: str):
+        key = self._normalize(name)
+        self._entries = [entry for entry in self._entries if self._normalize(entry[0]) != key]
+
+    def pop(self, name: str, default: Optional[str] = None) -> Optional[str]:
+        values = self.get_all(name)
+        self.remove(name)
+        return values[0] if values else default
+
+    def update(self, other):
+        if other is None:
+            return
+        pairs = other.items() if hasattr(other, "items") else other
+        for name, value in pairs:
+            self.add(name, value)
+
+    def items(self) -> list[tuple[str, str]]:
+        return list(self._entries)
+
+    def keys(self) -> list[str]:
+        return list(self)
+
+    def __setitem__(self, name: str, value: str):
+        self.remove(name)
+        self.add(name, value)
+
+    def __getitem__(self, name: str) -> str:
+        values = self.get_all(name)
+        if not values:
+            raise KeyError(name)
+        return values[0]
+
+    def __delitem__(self, name: str):
+        self.remove(name)
+
+    def __contains__(self, name: str) -> bool:
+        return bool(self.get_all(name))
+
+    def __iter__(self):
+        seen = []
+        for name, _ in self._entries:
+            key = self._normalize(name)
+            if key not in seen:
+                seen.append(key)
+                yield name
+
+    def __len__(self) -> int:
+        return len(list(iter(self)))
+
+    def __repr__(self) -> str:
+        return f"HttpHeaders({self._entries!r})"
+
+def _decompress_content(data: bytes, content_encoding: Optional[str]) -> bytes:
+    if not content_encoding:
+        return data
+
+    encoding = content_encoding.lower()
+    if encoding == "gzip":
+        return gzip.decompress(data)
+    if encoding == "deflate":
+        try:
+            return zlib.decompress(data)
+        except zlib.error:
+            return zlib.decompress(data, -zlib.MAX_WBITS)
+    return data
+
+def _read_bounded(response: http.client.HTTPResponse, max_size: Optional[int]) -> bytes:
+    if max_size is None:
+        return response.read()
+
+    chunks = []
+    total = 0
+    while True:
+        chunk = response.read(65536)
+        if not chunk:
+            break
+        total += len(chunk)
+        if total > max_size:
+            raise ValueError(f"Response content exceeded the configured maximum buffer size of {max_size} bytes.")
+        chunks.append(chunk)
+    return b"".join(chunks)
+
+class _StreamDecompressor:
+    """Incremental counterpart to _decompress_content, for streamed response bodies."""
+
+    def __init__(self, content_encoding: Optional[str]):
+        encoding = (content_encoding or "").lower()
+        if encoding == "gzip":
+            self._decompressor = zlib.decompressobj(zlib.MAX_WBITS | 16)
+        elif encoding == "deflate":
+            self._decompressor = zlib.decompressobj()
+        else:
+            self._decompressor = None
+
+    def decompress(self, chunk: bytes) -> bytes:
+        return self._decompressor.decompress(chunk) if self._decompressor else chunk
+
+    def flush(self) -> bytes:
+        return self._decompressor.flush() if self._decompressor else b""
+
+class _ConnectionPool:
+    """Thread-safe pool of idle keep-alive connections, keyed by destination.
+
+    Also tracks connections currently in flight so HttpClientHandler.cancel_pending_requests()
+    can forcibly abort them.
+    """
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._idle: dict[tuple, list] = {}  # key -> list of (connection, idle_since)
+        self._in_flight: set = set()
+
+    def acquire(self, key: tuple, idle_timeout: Optional[float] = None, lifetime: Optional[float] = None):
+        while True:
+            with self._lock:
+                idle = self._idle.get(key)
+                if not idle:
+                    return None
+                connection, idle_since = idle.pop()
+
+            now = time.monotonic()
+            created_at = getattr(connection, "_created_at", now)
+            expired = (idle_timeout is not None and now - idle_since > idle_timeout) or (
+                lifetime is not None and now - created_at > lifetime
+            )
+            if expired:
+                try:
+                    connection.close()
+                except Exception:
+                    pass
+                continue
+
+            with self._lock:
+                self._in_flight.add(connection)
+            return connection
+
+    def track(self, connection):
+        with self._lock:
+            self._in_flight.add(connection)
+
+    def untrack(self, connection):
+        with self._lock:
+            self._in_flight.discard(connection)
+
+    def discard(self, connection):
+        self.untrack(connection)
+        try:
+            connection.close()
+        except Exception:
+            pass
+
+    def release(self, key: tuple, connection):
+        self.untrack(connection)
+        with self._lock:
+            self._idle.setdefault(key, []).append((connection, time.monotonic()))
+
+    def close_all(self):
+        with self._lock:
+            all_connections = [c for entries in self._idle.values() for c, _ in entries] + list(self._in_flight)
+            self._idle.clear()
+            self._in_flight.clear()
+        for connection in all_connections:
+            try:
+                connection.close()
+            except Exception:
+                pass
+
+    def cancel_in_flight(self):
+        with self._lock:
+            in_flight = list(self._in_flight)
+        for connection in in_flight:
+            sock = getattr(connection, "sock", None)
+            if sock is not None:
+                try:
+                    sock.shutdown(socket.SHUT_RDWR)
+                except OSError:
+                    pass
+            try:
+                connection.close()
+            except Exception:
+                pass
+
+class HttpMessageHandler:
+    async def send_async(
+        self,
+        request: HttpRequestMessage,
+        timeout: Optional[float] = None,
+        completion_option: str = HttpCompletionOption.RESPONSE_CONTENT_READ,
+    ) -> HttpResponseMessage:
+        raise NotImplementedError("Derived classes must implement send_async")
+
+    def close(self):
+        pass
+
+    def cancel_pending_requests(self):
+        pass
+
+class DelegatingHandler(HttpMessageHandler):
+    """Wraps another HttpMessageHandler to add cross-cutting behavior (logging, retries,
+    metrics, ...) around it, mirroring System.Net.Http.DelegatingHandler. Subclass and
+    override send_async, calling self.inner_handler.send_async(...) to continue the chain.
+    """
+
+    def __init__(self, inner_handler: HttpMessageHandler):
+        self.inner_handler = inner_handler
+
+    async def send_async(
+        self,
+        request: HttpRequestMessage,
+        timeout: Optional[float] = None,
+        completion_option: str = HttpCompletionOption.RESPONSE_CONTENT_READ,
+    ) -> HttpResponseMessage:
+        return await self.inner_handler.send_async(request, timeout=timeout, completion_option=completion_option)
+
+    def close(self):
+        self.inner_handler.close()
+
+    def cancel_pending_requests(self):
+        self.inner_handler.cancel_pending_requests()
+
+class _CookieJarRequestAdapter:
+    """Minimal adapter so http.cookiejar.CookieJar can inspect/mutate an HttpRequestMessage.
+
+    Implements the duck-typed "request" interface CookieJar.add_cookie_header/extract_cookies
+    expect (the same interface urllib.request.Request satisfies natively).
+    """
+
+    def __init__(self, request: HttpRequestMessage):
+        self._request = request
+        target = urlparse(request.request_uri)
+        self.host = target.hostname
+        self.type = target.scheme
+        self.origin_req_host = target.hostname
+        self.unverifiable = False
+
+    def get_full_url(self):
+        return self._request.request_uri
+
+    def has_header(self, name: str) -> bool:
+        return name in self._request.headers
+
+    def get_header(self, name: str, default=None):
+        return self._request.headers.get(name, default)
+
+    def header_items(self):
+        return self._request.headers.items()
+
+    def add_unredirected_header(self, name: str, value: str):
+        self._request.headers[name] = value
+
+class _CookieJarResponseAdapter:
+    """Minimal adapter so http.cookiejar.CookieJar can read Set-Cookie headers from an HttpHeaders collection."""
+
+    def __init__(self, headers: HttpHeaders):
+        self._headers = headers
+
+    def info(self):
+        return self
+
+    def get_all(self, name: str, default=None):
+        values = self._headers.get_all(name)
+        return values if values else (default if default is not None else [])
+
+_REDIRECT_STATUS_CODES = {
+    HttpStatusCode.MOVED_PERMANENTLY,
+    HttpStatusCode.FOUND,
+    HttpStatusCode.SEE_OTHER,
+    HttpStatusCode.TEMPORARY_REDIRECT,
+    HttpStatusCode.PERMANENT_REDIRECT,
+}
+_METHOD_DOWNGRADE_STATUS_CODES = {HttpStatusCode.MOVED_PERMANENTLY, HttpStatusCode.FOUND, HttpStatusCode.SEE_OTHER}
+_BODY_PRESERVING_REDIRECT_STATUS_CODES = {HttpStatusCode.TEMPORARY_REDIRECT, HttpStatusCode.PERMANENT_REDIRECT}
+# Cookie is always recomputed fresh per hop by the cookie jar rather than carried forward.
+_ALWAYS_STRIP_REDIRECT_HEADERS = {"cookie"}
+_CROSS_HOST_STRIP_REDIRECT_HEADERS = {"authorization", "proxy-authorization"}
+
+class HttpClientHandler(HttpMessageHandler):
+    def __init__(self):
+        # Each entry is (certfile, keyfile) or (certfile, keyfile, password).
+        self.client_certificates: list[tuple[str, ...]] = []
+        # (username, password); sent preemptively as HTTP Basic auth.
+        self.credentials: Optional[tuple[str, str]] = None
+        self.use_proxy = False
+        self.proxy: Optional[str] = None
+        self.allow_auto_redirect = True
+        self.max_automatic_redirects = 50
+        self.use_cookies = True
+        self.cookies = http.cookiejar.CookieJar()
+        # Called with (der_encoded_cert, ssl.SSLSocket) -> bool. When set, built-in certificate
+        # verification (including hostname checking) is skipped entirely and this callback is
+        # the sole authority on whether to keep the connection - e.g. certificate pinning, or
+        # accepting a self-signed cert in a dev/test environment. Mirrors the responsibility
+        # shift of .NET's ServerCertificateCustomValidationCallback.
+        self.server_certificate_custom_validation: Optional[Callable[[bytes, ssl.SSLSocket], bool]] = None
+        # None means unbounded; matches the practical effect of .NET's ~2GB default.
+        self.max_response_content_buffer_size: Optional[int] = None
+        self.pooled_connection_idle_timeout: Optional[float] = 90.0
+        self.pooled_connection_lifetime: Optional[float] = None
+        self.max_connections_per_server: Optional[int] = None
+        self._pool = _ConnectionPool()
+        self._semaphores: dict[tuple, asyncio.Semaphore] = {}
+
+    def _build_ssl_context(self) -> ssl.SSLContext:
+        context = ssl.create_default_context()
+        if self.server_certificate_custom_validation is not None:
+            context.check_hostname = False
+            context.verify_mode = ssl.CERT_NONE
+        for certificate in self.client_certificates:
+            certfile, keyfile = certificate[0], certificate[1]
+            password = certificate[2] if len(certificate) > 2 else None
+            context.load_cert_chain(certfile, keyfile, password)
+        return context
+
+    def _apply_credentials(self, request: HttpRequestMessage):
+        if self.credentials and "Authorization" not in request.headers:
+            username, password = self.credentials
+            token = base64.b64encode(f"{username}:{password}".encode("utf-8")).decode("ascii")
+            request.headers["Authorization"] = f"Basic {token}"
+
+    def _resolve_proxy(self) -> Optional[tuple[str, int]]:
+        if not (self.use_proxy and self.proxy):
+            return None
+        proxy_url = self.proxy if "://" in self.proxy else f"http://{self.proxy}"
+        proxy = urlparse(proxy_url)
+        return proxy.hostname, proxy.port or (443 if proxy.scheme == "https" else 80)
+
+    def _connection_key_and_path(self, target, use_ssl: bool, path: str) -> tuple[tuple, str]:
+        proxy = self._resolve_proxy()
+        if proxy:
+            proxy_host, proxy_port = proxy
+            if use_ssl:
+                return ("proxy-tunnel", proxy_host, proxy_port, target.hostname, target.port or 443), path
+            return ("proxy-plain", proxy_host, proxy_port), target.geturl()
+        return ("direct", target.scheme, target.hostname, target.port or (443 if use_ssl else 80)), path
+
+    def _get_semaphore(self, pool_key: tuple) -> Optional[asyncio.Semaphore]:
+        if self.max_connections_per_server is None:
+            return None
+        semaphore = self._semaphores.get(pool_key)
+        if semaphore is None:
+            semaphore = asyncio.Semaphore(self.max_connections_per_server)
+            self._semaphores[pool_key] = semaphore
+        return semaphore
+
+    def _create_connection(self, target, use_ssl: bool, timeout: Optional[float]):
+        proxy = self._resolve_proxy()
+        if proxy:
+            proxy_host, proxy_port = proxy
+            if use_ssl:
+                conn = http.client.HTTPSConnection(proxy_host, proxy_port, timeout=timeout, context=self._build_ssl_context())
+                conn.set_tunnel(target.hostname, target.port or 443)
+            else:
+                conn = http.client.HTTPConnection(proxy_host, proxy_port, timeout=timeout)
+        elif use_ssl:
+            conn = http.client.HTTPSConnection(target.hostname, target.port or 443, timeout=timeout, context=self._build_ssl_context())
+        else:
+            conn = http.client.HTTPConnection(target.hostname, target.port or 80, timeout=timeout)
+
+        if use_ssl and self.server_certificate_custom_validation is not None:
+            conn.connect()
+            der_cert = conn.sock.getpeercert(binary_form=True)
+            if not self.server_certificate_custom_validation(der_cert, conn.sock):
+                conn.close()
+                raise ssl.SSLCertVerificationError("Server certificate was rejected by server_certificate_custom_validation.")
+
+        conn._created_at = time.monotonic()
+        return conn
+
+    def _build_streaming_response(self, conn, response: http.client.HTTPResponse, pool_key: tuple) -> HttpResponseMessage:
+        message = HttpResponseMessage(response.status)
+        message.headers.update(response.headers)
+        message.reason_phrase = response.reason
+        message.version = f"{response.version // 10}.{response.version % 10}"
+
+        content_encoding = response.getheader("Content-Encoding")
+        if content_encoding:
+            message.headers.remove("Content-Encoding")
+            message.headers.remove("Content-Length")
+
+        def on_complete(aborted: bool):
+            if aborted or response.will_close:
+                self._pool.discard(conn)
+            else:
+                self._pool.release(pool_key, conn)
+
+        message.content = _ResponseStreamContent(response, content_encoding, on_complete)
+        return message
+
+    def _send_sync(
+        self,
+        target,
+        use_ssl: bool,
+        method: str,
+        path: str,
+        headers: HttpHeaders,
+        body,
+        chunked: bool,
+        version: str,
+        timeout: Optional[float],
+        completion_option: str,
+        is_streamed_upload: bool,
+    ) -> HttpResponseMessage:
+        pool_key, request_path = self._connection_key_and_path(target, use_ssl, path)
+
+        # A streamed (non-rewindable) upload body can't be safely retried on a stale
+        # pooled connection, so it always gets a fresh one.
+        conn = None if is_streamed_upload else self._pool.acquire(
+            pool_key, idle_timeout=self.pooled_connection_idle_timeout, lifetime=self.pooled_connection_lifetime
+        )
+        reused = conn is not None
+        if reused and getattr(conn, "sock", None) is not None:
+            conn.sock.settimeout(timeout)
+        if conn is None:
+            conn = self._create_connection(target, use_ssl, timeout)
+            self._pool.track(conn)
+
+        http_vsn, http_vsn_str = _SUPPORTED_HTTP_VERSIONS[version]
+
+        def do_request(connection):
+            connection._http_vsn, connection._http_vsn_str = http_vsn, http_vsn_str
+            connection.request(method, request_path, body=body, headers=headers, encode_chunked=chunked)
+            return connection.getresponse()
+
+        try:
+            try:
+                response = do_request(conn)
+            except (http.client.RemoteDisconnected, ConnectionError, OSError):
+                if not reused:
+                    raise
+                self._pool.discard(conn)
+                conn = self._create_connection(target, use_ssl, timeout)
+                self._pool.track(conn)
+                response = do_request(conn)
+
+            if completion_option == HttpCompletionOption.RESPONSE_HEADERS_READ:
+                return self._build_streaming_response(conn, response, pool_key)
+
+            message = HttpResponseMessage.from_http_response(response, max_size=self.max_response_content_buffer_size)
+            if response.will_close:
+                self._pool.discard(conn)
+            else:
+                self._pool.release(pool_key, conn)
+            return message
+        except Exception:
+            self._pool.discard(conn)
+            raise
+
+    async def _send_once_async(
+        self,
+        request: HttpRequestMessage,
+        timeout: Optional[float],
+        completion_option: str,
+    ) -> HttpResponseMessage:
+        version = request.version or HttpVersion.HTTP_1_1
+        if version not in _SUPPORTED_HTTP_VERSIONS:
+            raise NotImplementedError(
+                f"HTTP/{version} is not supported. Python's standard library (http.client) only "
+                "implements HTTP/1.0 and HTTP/1.1. HTTP/2 requires binary framing, HPACK header compression, "
+                "and multiplexed stream state (see the third-party 'h2' package); HTTP/3 additionally requires "
+                "QUIC over UDP (see 'aioquic'). Neither is implementable with the standard library alone."
+            )
+
+        target = urlparse(request.request_uri)
+        use_ssl = target.scheme == "https"
+
+        self._apply_credentials(request)
+        if self.use_cookies:
+            self.cookies.add_cookie_header(_CookieJarRequestAdapter(request))
+        if "Accept-Encoding" not in request.headers:
+            request.headers["Accept-Encoding"] = "gzip, deflate"
+
+        is_streamed_upload = isinstance(request.content, StreamContent)
+        if is_streamed_upload and request.content.is_chunked and version != HttpVersion.HTTP_1_1:
+            raise ValueError("Chunked transfer encoding (StreamContent without a known length) requires HTTP/1.1.")
+
+        outgoing_headers = HttpHeaders()
+        outgoing_headers.update(request.headers)
+        if request.content is not None:
+            outgoing_headers.update(request.content.headers)
+
+        body = await request.content._open_wire_body() if request.content else None
+        chunked = bool(request.content and request.content.is_chunked)
+        path = (target.path or "/") + ("?" + target.query if target.query else "")
+
+        def send_request():
+            return self._send_sync(target, use_ssl, request.method, path, outgoing_headers, body, chunked, version, timeout, completion_option, is_streamed_upload)
+
+        pool_key, _ = self._connection_key_and_path(target, use_ssl, path)
+        semaphore = self._get_semaphore(pool_key)
+        if semaphore is not None:
+            await semaphore.acquire()
+        try:
+            message = await asyncio.get_event_loop().run_in_executor(None, send_request)
+        finally:
+            if semaphore is not None:
+                semaphore.release()
+
+        message.request_message = request
+        if self.use_cookies:
+            self.cookies.extract_cookies(_CookieJarResponseAdapter(message.headers), _CookieJarRequestAdapter(request))
+        return message
+
+    async def send_async(
+        self,
+        request: HttpRequestMessage,
+        timeout: Optional[float] = None,
+        completion_option: str = HttpCompletionOption.RESPONSE_CONTENT_READ,
+    ) -> HttpResponseMessage:
+        current_request = request
+        response = None
+
+        for _ in range(self.max_automatic_redirects + 1):
+            response = await self._send_once_async(current_request, timeout, completion_option)
+
+            if not self.allow_auto_redirect or response.status_code not in _REDIRECT_STATUS_CODES:
+                return response
+
+            location = response.headers.get("Location")
+            if not location:
+                return response
+
+            if response.content is not None:
+                await response.content.dispose_async()
+
+            next_uri = urljoin(current_request.request_uri, location)
+            current_scheme = urlparse(current_request.request_uri).scheme
+            if current_scheme == "https" and urlparse(next_uri).scheme == "http":
+                return response  # refuse to silently downgrade from HTTPS to plaintext
+
+            next_method = current_request.method
+            next_content = current_request.content
+            if response.status_code in _METHOD_DOWNGRADE_STATUS_CODES and current_request.method not in (HttpMethod.GET, HttpMethod.HEAD):
+                next_method = HttpMethod.GET
+                next_content = None
+            elif response.status_code in _BODY_PRESERVING_REDIRECT_STATUS_CODES and isinstance(next_content, StreamContent):
+                raise RuntimeError(
+                    f"Cannot automatically replay a StreamContent request body across a {response.status_code} "
+                    "redirect; the stream has already been consumed and cannot be rewound. Disable "
+                    "allow_auto_redirect or avoid streamed request bodies against redirect-prone endpoints."
+                )
+
+            next_request = HttpRequestMessage(next_method, next_uri, next_content, current_request.version)
+            same_host = urlparse(next_uri).hostname == urlparse(current_request.request_uri).hostname
+            for name in current_request.headers:
+                lower = name.lower()
+                if lower in _ALWAYS_STRIP_REDIRECT_HEADERS:
+                    continue
+                if not same_host and lower in _CROSS_HOST_STRIP_REDIRECT_HEADERS:
+                    continue
+                for value in current_request.headers.get_all(name):
+                    next_request.headers.add(name, value)
+
+            current_request = next_request
+
+        return response
+
+    def close(self):
+        self._pool.close_all()
+
+    def cancel_pending_requests(self):
+        self._pool.cancel_in_flight()
+
+class HttpClient:
+    def __init__(self, handler: HttpMessageHandler = None):
+        self.base_address: Optional[str] = None
+        self.default_request_headers = HttpHeaders()
+        # None means each new HttpRequestMessage falls back to HttpVersion.HTTP_1_1.
+        self.default_request_version: Optional[str] = None
+        self.timeout: Optional[float] = 100.0
+        self.handler = handler or HttpClientHandler()
+
+    async def send_async(
+        self,
+        request: HttpRequestMessage,
+        completion_option: str = HttpCompletionOption.RESPONSE_CONTENT_READ,
+    ) -> HttpResponseMessage:
+        if self.base_address:
+            request.request_uri = urljoin(self.base_address, request.request_uri)
+
+        if request.version is None:
+            request.version = self.default_request_version
+
+        for name in self.default_request_headers:
+            if name not in request.headers:
+                for value in self.default_request_headers.get_all(name):
+                    request.headers.add(name, value)
+
+        if self.timeout is None:
+            return await self.handler.send_async(request, timeout=None, completion_option=completion_option)
+
+        try:
+            return await asyncio.wait_for(
+                self.handler.send_async(request, timeout=self.timeout, completion_option=completion_option),
+                timeout=self.timeout,
+            )
+        except asyncio.TimeoutError as exc:
+            raise TimeoutError(f"The request timed out after {self.timeout} seconds.") from exc
+
+    async def get_async(self, request_uri: str) -> HttpResponseMessage:
+        request = HttpRequestMessage(HttpMethod.GET, request_uri)
+        return await self.send_async(request)
+
+    async def get_byte_array_async(self, request_uri: str) -> bytes:
+        response = await self.get_async(request_uri)
+        return await response.content.read_as_bytes_async()
+
+    async def get_string_async(self, request_uri: str) -> str:
+        response = await self.get_async(request_uri)
+        return await response.content.read_as_string_async()
+
+    async def get_stream_async(self, request_uri: str) -> AsyncIterator[bytes]:
+        request = HttpRequestMessage(HttpMethod.GET, request_uri)
+        response = await self.send_async(request, completion_option=HttpCompletionOption.RESPONSE_HEADERS_READ)
+        async for chunk in response.content.stream_async():
+            yield chunk
+
+    async def post_async(self, request_uri: str, content: Optional[HttpContent] = None) -> HttpResponseMessage:
+        request = HttpRequestMessage(HttpMethod.POST, request_uri, content)
+        return await self.send_async(request)
+
+    async def put_async(self, request_uri: str, content: Optional[HttpContent] = None) -> HttpResponseMessage:
+        request = HttpRequestMessage(HttpMethod.PUT, request_uri, content)
+        return await self.send_async(request)
+
+    async def delete_async(self, request_uri: str) -> HttpResponseMessage:
+        request = HttpRequestMessage(HttpMethod.DELETE, request_uri)
+        return await self.send_async(request)
+
+    def set_base_address(self, url: str):
+        self.base_address = url
+
+    def default_request_headers_add(self, name: str, value: str):
+        self.default_request_headers.add(name, value)
+
+    def cancel_pending_requests(self):
+        self.handler.cancel_pending_requests()
+
+    def close(self):
+        self.handler.close()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+class HttpContent:
+    def __init__(self):
+        self.headers = HttpHeaders()
+
+    @property
+    def is_chunked(self) -> bool:
+        return False
+
+    async def read_as_bytes_async(self) -> bytes:
+        raise NotImplementedError("Derived classes must implement read_as_bytes_async")
+
+    async def read_as_string_async(self) -> str:
+        return (await self.read_as_bytes_async()).decode("utf-8")
+
+    async def read_as_json_async(self) -> Any:
+        return json.loads(await self.read_as_string_async())
+
+    async def dispose_async(self):
+        pass
+
+    async def _open_wire_body(self):
+        """What to hand http.client as the request body: raw bytes by default."""
+        return await self.read_as_bytes_async()
+
+class ByteArrayContent(HttpContent):
+    def __init__(self, data: bytes, media_type: str = "application/octet-stream"):
+        super().__init__()
+        self._data = bytes(data)
+        self.headers["Content-Type"] = media_type
+        self.headers["Content-Length"] = str(len(self._data))
+
+    async def read_as_bytes_async(self) -> bytes:
+        return self._data
+
+    def get_length(self) -> int:
+        return len(self._data)
+
+class StringContent(ByteArrayContent):
+    def __init__(self, text: str, media_type: str = "text/plain", encoding: str = "utf-8"):
+        super().__init__(text.encode(encoding), f"{media_type}; charset={encoding}")
+
+class JsonContent(ByteArrayContent):
+    def __init__(self, value: Any, encoding: str = "utf-8"):
+        super().__init__(json.dumps(value).encode(encoding), f"application/json; charset={encoding}")
+
+    @classmethod
+    def create(cls, value: Any) -> JsonContent:
+        return cls(value)
+
+class FormUrlEncodedContent(ByteArrayContent):
+    def __init__(self, data: Union[dict, list]):
+        pairs = data.items() if isinstance(data, dict) else data
+        super().__init__(urlencode(list(pairs)).encode("ascii"), "application/x-www-form-urlencoded")
+
+class StreamContent(HttpContent):
+    """Content backed by a file-like object or byte-chunk iterable, sent without fully
+    buffering it in memory first (mirrors System.Net.Http.StreamContent).
+
+    If length is omitted, the body is sent with Transfer-Encoding: chunked, which
+    requires HTTP/1.1. A StreamContent instance can only be sent once - the underlying
+    stream can't be rewound for retries or 307/308 redirect replay.
+    """
+
+    def __init__(self, stream, media_type: str = "application/octet-stream", length: Optional[int] = None):
+        super().__init__()
+        self._stream = stream
+        self.headers["Content-Type"] = media_type
+        if length is not None:
+            self.headers["Content-Length"] = str(length)
+
+    @property
+    def is_chunked(self) -> bool:
+        return "Content-Length" not in self.headers
+
+    async def read_as_bytes_async(self) -> bytes:
+        data = self._stream.read()
+        return data if isinstance(data, bytes) else bytes(data)
+
+    async def _open_wire_body(self):
+        return self._stream
+
+class _ResponseStreamContent(HttpContent):
+    """HttpContent backed by a live, not-yet-fully-read HTTPResponse.
+    Produced when HttpCompletionOption.RESPONSE_HEADERS_READ is used. Not part of the
+    public API - callers only see it as an HttpContent via HttpResponseMessage.content.
+    """
+
+    def __init__(self, response: http.client.HTTPResponse, content_encoding: Optional[str], on_complete: Callable[[bool], None]):
+        super().__init__()
+        self._response = response
+        self._decompressor = _StreamDecompressor(content_encoding)
+        self._on_complete = on_complete
+        self._done = False
+
+    def _finish(self, aborted: bool):
+        if not self._done:
+            self._done = True
+            self._on_complete(aborted)
+
+    async def stream_async(self, chunk_size: int = 8192) -> AsyncIterator[bytes]:
+        loop = asyncio.get_event_loop()
+        aborted = True
+        try:
+            while True:
+                raw = await loop.run_in_executor(None, self._response.read, chunk_size)
+                if not raw:
+                    break
+                data = self._decompressor.decompress(raw)
+                if data:
+                    yield data
+            tail = self._decompressor.flush()
+            if tail:
+                yield tail
+            aborted = False
+        finally:
+            self._finish(aborted)
+
+    async def read_as_bytes_async(self) -> bytes:
+        chunks = [chunk async for chunk in self.stream_async()]
+        return b"".join(chunks)
+
+    async def dispose_async(self):
+        self._finish(aborted=True)
+
+class HttpRequestMessage:
+    def __init__(
+        self,
+        method: str = HttpMethod.GET,
+        request_uri: Optional[str] = None,
+        content: Optional[HttpContent] = None,
+        version: Optional[str] = None,
+    ):
+        self.method = method
+        self.request_uri = request_uri
+        self._content: Optional[HttpContent] = None
+        self.headers = HttpHeaders()
+        # None means "resolve to HttpClient.default_request_version, else HTTP/1.1" at send time.
+        self.version = version
+        # Free-form per-request metadata bag for custom handlers/middleware to use.
+        self.options: dict[str, Any] = {}
+        self.set_content(content)
+
+    @property
+    def content(self) -> Optional[HttpContent]:
+        return self._content
+
+    def set_content(self, content: Optional[HttpContent]):
+        if content is not None and not isinstance(content, HttpContent):
+            raise TypeError("content must be an HttpContent instance (e.g. StringContent, JsonContent, ByteArrayContent) or None.")
+        self._content = content
+
+    @property
+    def request_uri(self) -> Optional[str]:
+        return self._request_uri
+
+    @request_uri.setter
+    def request_uri(self, value: str):
+        self._request_uri = value
+        if value:
+            parsed = urlparse(value)
+            if parsed.scheme and parsed.netloc:
+                self._request_uri = value
+            else:
+                self._request_uri = parsed.path + ("?" + parsed.query if parsed.query else "")
+
+    def headers_get(self, name: str) -> Optional[str]:
+        return self.headers.get(name)
+
+    def headers_add(self, name: str, value: str):
+        self.headers.add(name, value)
+
+    def headers_remove(self, name: str):
+        self.headers.remove(name)
+
+    def to_string(self) -> str:
+        parts = [
+            f"{self.method} {self.request_uri or '/'} HTTP/{self.version or HttpVersion.HTTP_1_1}",
+            *[f"{k}: {v}" for k, v in self.headers.items()],
+            "",
+            str(self.content) if self.content else ""
+        ]
+        return "\r\n".join(parts)
+
+class HttpResponseMessage:
+    @classmethod
+    def from_http_response(cls, response: http.client.HTTPResponse, max_size: Optional[int] = None) -> HttpResponseMessage:
+        message = cls(response.status)
+        raw_body = _read_bounded(response, max_size)
+        content_encoding = response.getheader("Content-Encoding")
+
+        message.headers.update(response.headers)
+        if content_encoding:
+            raw_body = _decompress_content(raw_body, content_encoding)
+            message.headers.remove("Content-Encoding")
+            message.headers.remove("Content-Length")
+
+        message.content = ByteArrayContent(raw_body)
+        message.reason_phrase = response.reason
+        message.version = f"{response.version // 10}.{response.version % 10}"
+        return message
+
+    def __init__(self, status_code: int = HttpStatusCode.OK):
+        self.status_code = status_code
+        self.content: Optional[HttpContent] = None
+        self.headers = HttpHeaders()
+        self.reason_phrase: Optional[str] = None
+        self.version: str = HttpVersion.HTTP_1_1
+        self.request_message: Optional[HttpRequestMessage] = None
+
+    def is_success_status_code(self) -> bool:
+        return 200 <= self.status_code < 300
+
+    def ensure_success_status_code(self):
+        if not self.is_success_status_code():
+            raise HttpRequestException(self)
+
+    def __str__(self):
+        return f"HTTP/{self.version} {self.status_code} {self.reason_phrase}"
+
+class HttpRequestException(Exception):
+    def __init__(self, response: HttpResponseMessage):
+        self.response = response
+        super().__init__(f"Response status code does not indicate success: {response.status_code} ({response.reason_phrase})")
+
+class HttpResponseReceivedEventArgs:
+    def __init__(self, response: HttpResponseMessage):
+        self.response = response
+
+class HttpServiceClient:
+    def __init__(self):
+        self._http_client: Optional[HttpClient] = None
+        self.http_response_received: Optional[Callable[[HttpResponseMessage], None]] = None
+
+    @property
+    def http_client(self) -> HttpClient:
+        if self._http_client is None:
+            self._http_client = self.create_http_client()
+        return self._http_client
+
+    def create_http_client(self) -> HttpClient:
+        return HttpClient()
+
+    async def pre_process_http_request_message_async(self, request: HttpRequestMessage):
+        pass
+
+    async def post_process_http_request_message_async(self, request: HttpRequestMessage):
+        pass
+
+    async def process_http_response_message_async(self, response: HttpResponseMessage):
+        pass
+
+    async def handle_success_status_code_async(self, response: HttpResponseMessage):
+        pass
+
+    async def handle_non_success_status_code_async(self, response: HttpResponseMessage):
+        pass
+
+    async def get_async(self, request_uri: str) -> HttpResponseMessage:
+        return await self.execute_async(HttpMethod.GET, request_uri)
+
+    async def get_byte_array_async(self, request_uri: str) -> bytes:
+        response = await self.get_async(request_uri)
+        return await response.content.read_as_bytes_async()
+
+    async def get_string_async(self, request_uri: str) -> str:
+        response = await self.get_async(request_uri)
+        return await response.content.read_as_string_async()
+
+    async def get_stream_async(self, request_uri: str) -> AsyncIterator[bytes]:
+        response = await self.execute_async(HttpMethod.GET, request_uri, completion_option=HttpCompletionOption.RESPONSE_HEADERS_READ)
+        async for chunk in response.content.stream_async():
+            yield chunk
+
+    async def post_async(self, request_uri: str, content: Optional[HttpContent] = None) -> HttpResponseMessage:
+        return await self.execute_async(HttpMethod.POST, request_uri, content)
+
+    async def put_async(self, request_uri: str, content: Optional[HttpContent] = None) -> HttpResponseMessage:
+        return await self.execute_async(HttpMethod.PUT, request_uri, content)
+
+    async def patch_async(self, request_uri: str, content: Optional[HttpContent] = None) -> HttpResponseMessage:
+        return await self.execute_async(HttpMethod.PATCH, request_uri, content)
+
+    async def delete_async(self, request_uri: str, content: Optional[HttpContent] = None) -> HttpResponseMessage:
+        return await self.execute_async(HttpMethod.DELETE, request_uri, content)
+
+    async def execute_async(
+        self,
+        method: str,
+        request_uri: str,
+        content: Optional[HttpContent] = None,
+        http_request_message_modifier: Optional[Callable[[HttpRequestMessage], None]] = None,
+        completion_option: str = HttpCompletionOption.RESPONSE_CONTENT_READ,
+    ) -> HttpResponseMessage:
+        request = HttpRequestMessage(method, request_uri, content)
+
+        await self.pre_process_http_request_message_async(request)
+        if http_request_message_modifier:
+            http_request_message_modifier(request)
+        await self.post_process_http_request_message_async(request)
+
+        response = await self.http_client.send_async(request, completion_option=completion_option)
+
+        if self.http_response_received:
+            self.http_response_received(HttpResponseReceivedEventArgs(response))
+
+        await self.process_http_response_message_async(response)
+
+        if response.is_success_status_code():
+            await self.handle_success_status_code_async(response)
+        else:
+            await self.handle_non_success_status_code_async(response)
+
+        return response
+
+    async def send_async(
+        self,
+        request: HttpRequestMessage,
+        completion_option: str = HttpCompletionOption.RESPONSE_CONTENT_READ,
+    ) -> HttpResponseMessage:
+        await self.pre_process_http_request_message_async(request)
+        await self.post_process_http_request_message_async(request)
+
+        response = await self.http_client.send_async(request, completion_option=completion_option)
+
+        if self.http_response_received:
+            self.http_response_received(HttpResponseReceivedEventArgs(response))
+
+        await self.process_http_response_message_async(response)
+
+        if response.is_success_status_code():
+            await self.handle_success_status_code_async(response)
+        else:
+            await self.handle_non_success_status_code_async(response)
+
+        return response
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self._http_client is not None:
+            self._http_client.close()

universal_common_net_http-1.0.0.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: universal-common-net-http
+Version: 1.0.0
+Summary: Library for HTTP operations.
+Author-email: Andrew Ong <ong.andrew@gmail.com>
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-asyncio; extra == 'test'

universal_common_net_http-1.0.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+universal_common_net_http/__init__.py,sha256=nSntwpGzJ5-BWw6rak_iqfQw3pSo5969X1_fXmUA3Es,43701
+universal_common_net_http-1.0.0.dist-info/METADATA,sha256=TEatbSzwi7aZkC2h0oncDYYggjPIG_FoAByk3VzWiXc,534
+universal_common_net_http-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+universal_common_net_http-1.0.0.dist-info/licenses/LICENSE,sha256=oZ1YqqsVxNABnladHAc9G1KG_dN9vu56WKfRrnYEWuE,7167
+universal_common_net_http-1.0.0.dist-info/RECORD,,

universal_common_net_http-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

universal_common_net_http-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.