whoopapi 0.0.1__py3-none-any.whl

whoopapi/__init__.py

@@ -0,0 +1,8 @@
+# flake8: noqa
+
+from .logging import LOG_CRITICAL, LOG_ERROR, LOG_INFO, LOG_PRETTY, LOG_WARNING
+from .protocol_handlers import RequestHandler, StaticFileHandler, WebsocketHandler
+from .utilities import Application, start_application
+from .wrappers import HttpRequest, HttpResponse
+
+# TODO : Document the src

whoopapi/constants.py

@@ -0,0 +1,319 @@
+WEBSOCKET_ACCEPT_SUFFIX = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+WEBSOCKET_FRAME_MASK = b"abcd"
+DEFAULT_STRING_ENCODING = "utf-8"
+
+
+class HttpHeaders:
+    ACCEPT = "accept"
+    ACCEPT_CH = "accept-ch"
+    ACCEPT_CHARSET = "accept-charset"
+    ACCEPT_ENCODING = "accept-encoding"
+    ACCEPT_LANGUAGE = "accept-language"
+    ACCEPT_PATCH = "accept-patch"
+    ACCEPT_POST = "accept-post"
+    ACCEPT_RANGES = "accept-ranges"
+    ACCESS_CONTROL_ALLOW_CREDENTIALS = "access-control-allow-credentials"
+    ACCESS_CONTROL_ALLOW_HEADERS = "access-control-allow-headers"
+    ACCESS_CONTROL_ALLOW_METHODS = "access-control-allow-methods"
+    ACCESS_CONTROL_ALLOW_ORIGIN = "access-control-allow-origin"
+    ACCESS_CONTROL_EXPOSE_HEADERS = "access-control-expose-headers"
+    ACCESS_CONTROL_MAX_AGE = "access-control-max-age"
+    ACCESS_CONTROL_REQUEST_HEADERS = "access-control-request-headers"
+    ACCESS_CONTROL_REQUEST_METHOD = "access-control-request-method"
+    AGE = "age"
+    ALLOW = "allow"
+    ALT_SVC = "alt-svc"
+    ALT_USED = "alt-used"
+    ATTRIBUTION_REPORTING_ELIGIBLE = "attribution-reporting-eligible"
+    ATTRIBUTION_REPORTING_REGISTER_SOURCE = "attribution-reporting-register-source"
+    ATTRIBUTION_REPORTING_REGISTER_TRIGGER = "attribution-reporting-register-trigger"
+    AUTHORIZATION = "authorization"
+    CACHE_CONTROL = "cache-control"
+    CLEAR_SITE_DATA = "clear-site-data"
+    CONNECTION = "connection"
+    CONTENT_DIGEST = "content-digest"
+    CONTENT_DISPOSITION = "content-disposition"
+    CONTENT_DPR = "content-dpr"
+    CONTENT_ENCODING = "content-encoding"
+    CONTENT_LANGUAGE = "content-language"
+    CONTENT_LENGTH = "content-length"
+    CONTENT_LOCATION = "content-location"
+    CONTENT_RANGE = "content-range"
+    CONTENT_SECURITY_POLICY = "content-security-policy"
+    CONTENT_SECURITY_POLICY_REPORT_ONLY = "content-security-policy-report-only"
+    CONTENT_TYPE = "content-type"
+    COOKIE = "cookie"
+    CRITICAL_CH = "critical-ch"
+    CROSS_ORIGIN_EMBEDDER_POLICY = "cross-origin-embedder-policy"
+    CROSS_ORIGIN_OPENER_POLICY = "cross-origin-opener-policy"
+    CROSS_ORIGIN_RESOURCE_POLICY = "cross-origin-resource-policy"
+    DATE = "date"
+    DEVICE_MEMORY = "device-memory"
+    DIGEST = "digest"
+    DNT = "dnt"
+    DOWNLINK = "downlink"
+    DPR = "dpr"
+    EARLY_DATA = "early-data"
+    ECT = "ect"
+    ETAG = "etag"
+    EXPECT = "expect"
+    EXPECT_CT = "expect-ct"
+    EXPIRES = "expires"
+    FORWARDED = "forwarded"
+    FROM = "from"
+    HOST = "host"
+    IF_MATCH = "if-match"
+    IF_MODIFIED_SINCE = "if-modified-since"
+    IF_NONE_MATCH = "if-none-match"
+    IF_RANGE = "if-range"
+    IF_UNMODIFIED_SINCE = "if-unmodified-since"
+    KEEP_ALIVE = "keep-alive"
+    LAST_MODIFIED = "last-modified"
+    LINK = "link"
+    LOCATION = "location"
+    MAX_FORWARDS = "max-forwards"
+    NEL = "nel"
+    NO_VARY_SEARCH = "no-vary-search"
+    OBSERVE_BROWSING_TOPICS = "observe-browsing-topics"
+    ORIGIN = "origin"
+    ORIGIN_AGENT_CLUSTER = "origin-agent-cluster"
+    PERMISSIONS_POLICY = "permissions-policy"
+    PRAGMA = "pragma"
+    PRIORITY = "priority"
+    PROXY_AUTHENTICATE = "proxy-authenticate"
+    PROXY_AUTHORIZATION = "proxy-authorization"
+    RANGE = "range"
+    REFERER = "referer"
+    REFERRER_POLICY = "referrer-policy"
+    REPORTING_ENDPOINTS = "reporting-endpoints"
+    REPR_DIGEST = "repr-digest"
+    RETRY_AFTER = "retry-after"
+    RTT = "rtt"
+    SAVE_DATA = "save-data"
+    SEC_BROWSING_TOPICS = "sec-browsing-topics"
+    SEC_CH_PREFERS_COLOR_SCHEME = "sec-ch-prefers-color-scheme"
+    SEC_CH_PREFERS_REDUCED_MOTION = "sec-ch-prefers-reduced-motion"
+    SEC_CH_PREFERS_REDUCED_TRANSPARENCY = "sec-ch-prefers-reduced-transparency"
+    SEC_CH_UA = "sec-ch-ua"
+    SEC_CH_UA_ARCH = "sec-ch-ua-arch"
+    SEC_CH_UA_BITNESS = "sec-ch-ua-bitness"
+    SEC_CH_UA_FULL_VERSION = "sec-ch-ua-full-version"
+    SEC_CH_UA_FULL_VERSION_LIST = "sec-ch-ua-full-version-list"
+    SEC_CH_UA_MOBILE = "sec-ch-ua-mobile"
+    SEC_CH_UA_MODEL = "sec-ch-ua-model"
+    SEC_CH_UA_PLATFORM = "sec-ch-ua-platform"
+    SEC_CH_UA_PLATFORM_VERSION = "sec-ch-ua-platform-version"
+    SEC_FETCH_DEST = "sec-fetch-dest"
+    SEC_FETCH_MODE = "sec-fetch-mode"
+    SEC_FETCH_SITE = "sec-fetch-site"
+    SEC_FETCH_USER = "sec-fetch-user"
+    SEC_GPC = "sec-gpc"
+    SEC_PURPOSE = "sec-purpose"
+    SEC_WEBSOCKET_ACCEPT = "sec-websocket-accept"
+    SEC_WEBSOCKET_KEY = "sec-websocket-key"
+    SEC_WEBSOCKET_VERSION = "sec-websocket-version"
+    SERVER = "server"
+    SERVER_TIMING = "server-timing"
+    SERVICE_WORKER_NAVIGATION_PRELOAD = "service-worker-navigation-preload"
+    SET_COOKIE = "set-cookie"
+    SET_LOGIN = "set-login"
+    SOURCEMAP = "sourcemap"
+    SPECULATION_RULES = "speculation-rules"
+    STRICT_TRANSPORT_SECURITY = "strict-transport-security"
+    SUPPORTS_LOADING_MODE = "supports-loading-mode"
+    TE = "te"
+    TIMING_ALLOW_ORIGIN = "timing-allow-origin"
+    TK = "tk"
+    TRAILER = "trailer"
+    TRANSFER_ENCODING = "transfer-encoding"
+    UPGRADE = "upgrade"
+    UPGRADE_INSECURE_REQUESTS = "upgrade-insecure-requests"
+    USER_AGENT = "user-agent"
+    VARY = "vary"
+    VIA = "via"
+    VIEWPORT_WIDTH = "viewport-width"
+    WANT_CONTENT_DIGEST = "want-content-digest"
+    WANT_DIGEST = "want-digest"
+    WANT_REPR_DIGEST = "want-repr-digest"
+    WARNING = "warning"
+    WIDTH = "width"
+    WWW_AUTHENTICATE = "www-authenticate"
+    X_CONTENT_TYPE_OPTIONS = "x-content-type-options"
+    X_DNS_PREFETCH_CONTROL = "x-dns-prefetch-control"
+    X_FORWARDED_FOR = "x-forwarded-for"
+    X_FORWARDED_HOST = "x-forwarded-host"
+    X_FORWARDED_PROTO = "x-forwarded-proto"
+    X_FRAME_OPTIONS = "x-frame-options"
+    X_XSS_PROTECTION = "x-xss-protection"
+
+
+class HttpMethods:
+    GET = "get"
+    POST = "post"
+    PUT = "put"
+    DELETE = "delete"
+    PATCH = "patch"
+
+
+class HttpContentTypes:
+    APPLICATION_OCTET_STREAM = "application/octet-stream"
+    APPLICATION_JSON = "application/json"
+    MULTIPART_FORM_DATA = "multipart/form-data"
+    TEXT_HTML = "text/html"
+    TEXT_PLAIN = "text/plain"
+
+
+class WebProtocols:
+    HTTP = "http"
+    WS = "ws"
+    HTTPS = "https"
+    WSS = "wss"
+
+
+class HttpStatusCodes_:
+    def __init__(self):
+        self.C_100 = "100 Continue"
+        self.C_101 = "101 Switching Protocols"
+        self.C_102 = "102 Processing"
+        self.C_200 = "200 OK"
+        self.C_201 = "201 Created"
+        self.C_202 = "202 Accepted"
+        self.C_203 = "203 Non-Authoritative Information"
+        self.C_204 = "204 No Content"
+        self.C_205 = "205 Reset Content"
+        self.C_206 = "206 Partial Content"
+        self.C_207 = "207 Multi-Status"
+        self.C_208 = "208 Already Reported"
+        self.C_226 = "226 IM Used"
+        self.C_300 = "300 Multiple Choices"
+        self.C_301 = "301 Moved Permanently"
+        self.C_302 = "302 Found"
+        self.C_303 = "303 See Other"
+        self.C_304 = "304 Not Modified"
+        self.C_305 = "305 Use Proxy"
+        self.C_306 = "306 Reserved"
+        self.C_307 = "307 Temporary Redirect"
+        self.C_308 = "308 Permanent Redirect"
+        self.C_400 = "400 Bad Request"
+        self.C_401 = "401 Unauthorized"
+        self.C_402 = "402 Payment Required"
+        self.C_403 = "403 Forbidden"
+        self.C_404 = "404 Not Found"
+        self.C_405 = "405 Method Not Allowed"
+        self.C_406 = "406 Not Acceptable"
+        self.C_407 = "407 Proxy Authentication Required"
+        self.C_408 = "408 Request Timeout"
+        self.C_409 = "409 Conflict"
+        self.C_410 = "410 Gone"
+        self.C_411 = "411 Length Required"
+        self.C_412 = "412 Precondition Failed"
+        self.C_413 = "413 Request Entity Too Large"
+        self.C_414 = "414 Request-URI Too Long"
+        self.C_415 = "415 Unsupported Media Type"
+        self.C_416 = "416 Requested Range Not Satisfiable"
+        self.C_417 = "417 Expectation Failed"
+        self.C_422 = "422 Unprocessable Entity"
+        self.C_423 = "423 Locked"
+        self.C_424 = "424 Failed Dependency"
+        self.C_426 = "426 Upgrade Required"
+        self.C_428 = "428 Precondition Required"
+        self.C_429 = "429 Too Many Requests"
+        self.C_431 = "431 Request Header Fields Too Large"
+        self.C_500 = "500 Internal Server Error"
+        self.C_501 = "501 Not Implemented"
+        self.C_502 = "502 Bad Gateway"
+        self.C_503 = "503 Service Unavailable"
+        self.C_504 = "504 Gateway Timeout"
+        self.C_505 = "505 HTTP Version Not Supported"
+        self.C_506 = "506 Variant Also Negotiates (Experimental)"
+        self.C_507 = "507 Insufficient Storage"
+        self.C_508 = "508 Loop Detected"
+        self.C_510 = "510 Not Extended"
+        self.C_511 = "511 Network Authentication Required"
+
+
+HttpStatusCodes = HttpStatusCodes_()
+
+
+def get_http_status_code_message(code: int):
+    for item in HttpStatusCodes.__dict__.values():
+        if isinstance(item, str) and item.startswith(f"{code} "):
+            return item[item.index(" ") + 1]
+
+    return "Unknown"
+
+
+def get_default_headers():
+    return {"Server": "WhoopAPI"}
+
+
+def get_content_type_from_filename(filename: str):
+    extension = filename.split(".")[-1] if "." in filename else None
+    content_type = None
+
+    if extension:
+        content_type = {
+            "aac": "audio/aac",
+            "abw": "application/x-abiword",
+            "arc": "application/octet-stream",
+            "avi": "video/x-msvideo",
+            "azw": "application/vnd.amazon.ebook",
+            "bin": "application/octet-stream",
+            "bz": "application/x-bzip",
+            "bz2": "application/x-bzip2",
+            "csh": "application/x-csh",
+            "css": "text/css",
+            "csv": "text/csv",
+            "doc": "application/msword",
+            "epub": "application/epub+zip",
+            "gif": "image/gif",
+            "htm": "text/html",
+            "html": "text/html",
+            "ico": "image/x-icon",
+            "ics": "text/calendar",
+            "jar": "application/java-archive",
+            "jpeg": "image.jpeg",
+            "jpg": "image/jpeg",
+            "js": "application/javascript",
+            "json": "application/json",
+            "mid": "audio/midi",
+            "midi": "audio/midi",
+            "mpeg": "video/mpeg",
+            "mpkg": "application/vnd.apple.installer+xml",
+            "odp": "application/vnd.oasis.opendocument.presentation",
+            "ods": "application/vnd.oasis.opendocument.spreadsheet",
+            "odt": "application/vnd.oasis.opendocument.text",
+            "oga": "audio/ogg",
+            "ogv": "video/ogg",
+            "ogx": "application/ogg",
+            "pdf": "application/pdf",
+            "ppt": "application/vnd.ms-powerpoint",
+            "rar": "application/x-rar-compressed",
+            "rtf": "application/rtf",
+            "sh": "application/x-sh",
+            "svg": "image/svg+xml",
+            "swf": "application/x-shockwave-flash",
+            "tar": "application/x-tar",
+            "tif": "image/tiff",
+            "tiff": "image/tiff",
+            "ttf": "font/ttf",
+            "vsd": "application/vnd.visio",
+            "wav": "audio/x-wav",
+            "weba": "audio/webm",
+            "webm": "video/webm",
+            "webp": "image/webp",
+            "woff": "font/woff",
+            "woff2": "font/woff2",
+            "xhtml": "application/xhtml+xml",
+            "xls": "application/vnd.ms-excel",
+            "xml": "application/xml",
+            "xul": "application/vnd.mozilla.xul+xml",
+            "zip": "application/zip",
+            "3gp": "video/3gpp",
+            # "audio/3gpp if it doesn't contain video": "",
+            "3g2": "video/3gpp2",
+            # "audio/3gpp2 if it doesn't contain video": "",
+            "7z": "application/x-7z-compressed",
+        }.get(extension, None)
+
+    return content_type if content_type else HttpContentTypes.APPLICATION_OCTET_STREAM

whoopapi/logging.py

@@ -0,0 +1,21 @@
+import pprint
+
+
+def LOG_INFO(*args):
+    return print(*args)
+
+
+def LOG_WARNING(*args):
+    return print(*args)
+
+
+def LOG_ERROR(*args):
+    return print(*args)
+
+
+def LOG_CRITICAL(*args):
+    return print(*args)
+
+
+def LOG_PRETTY(*args):
+    return pprint.pprint(*args)

whoopapi/parsers/http_body.py

@@ -0,0 +1,251 @@
+import gzip
+import json
+import re
+import zlib
+from email.parser import BytesParser
+from email.policy import HTTP
+
+import brotli
+
+from ..constants import HttpContentTypes, HttpHeaders
+
+
+def parse_multipart_with_regex(boundary: str, body: bytes, charset: str = "utf-8"):
+    """
+    Parse multipart/form-data using regular expressions only.
+    Note: This is less reliable than the email library version.
+    Args:
+        boundary: The multipart boundary string
+        body: The raw request body bytes
+        charset: Character encoding for text fields
+    Returns:
+        Dictionary with form fields and file data
+    """
+    # Convert boundary to bytes and prepare pattern
+    boundary_bytes = boundary.encode("ascii")
+    pattern = re.compile(
+        b"--"
+        + re.escape(boundary_bytes)
+        + b"\r\n"
+        + b"((?:.|\r\n)*?)\r\n\r\n"  # Headers
+        + b"((?:.|\r\n)*?)"  # Content
+        + b"(?=\r\n--"
+        + re.escape(boundary_bytes)
+        + b"(?:--)?\r\n)",
+        re.DOTALL,
+    )
+
+    form_data = {}
+    files = {}
+
+    for match in pattern.finditer(body):
+        headers_part, content = match.groups()
+
+        # Parse headers
+        headers = {}
+        for header_line in headers_part.split(b"\r\n"):
+            if b":" in header_line:
+                name, value = header_line.split(b":", 1)
+                headers[name.strip().lower()] = value.strip()
+
+        # Get field name
+        content_disposition = headers.get(b"content-disposition", b"")
+        name_match = re.search(rb'name="([^"]+)"', content_disposition)
+        if not name_match:
+            continue
+
+        name = name_match.group(1).decode("ascii")
+
+        # Check for filename
+        filename_match = re.search(rb'filename="([^"]+)"', content_disposition)
+        if filename_match:
+            # File upload
+            files[name] = {
+                "filename": filename_match.group(1).decode("ascii"),
+                "content_type": headers.get(
+                    b"content-type", b"application/octet-stream"
+                ).decode("ascii"),
+                "data": content,
+                "size": len(content),
+            }
+        else:
+            # Regular form field
+            try:
+                form_data[name] = content.decode(charset)
+            except UnicodeDecodeError:
+                form_data[name] = content
+
+    return form_data, files
+
+
+def parse_multipart_enhanced(
+    content_type: str, boundary: str, body: bytes
+) -> tuple[dict, dict]:
+    """
+    Parse multipart/form-data body into a dictionary of form fields.
+    Uses email library
+    Args:
+        content_type: The Content-Type header value
+        boundary: The boundary value from content type
+        body: The raw request body bytes
+    Returns:
+        Dictionary with field names as keys and field values (str for text, bytes for files)
+    """
+    combined_content_type = f"{content_type}; boundary={boundary}"
+    headers = {"Content-Type": combined_content_type, "Content-Length": str(len(body))}
+    msg = BytesParser(policy=HTTP).parsebytes(
+        b"\r\n".join([f"{k}: {v}".encode("ascii") for k, v in headers.items()])
+        + b"\r\n\r\n"
+        + body
+    )
+
+    form_data = {}
+    files = {}
+
+    for part in msg.iter_parts():
+        disposition = part.get("Content-Disposition", "")
+        name_match = re.search(r'name="([^"]+)"', disposition)
+        if not name_match:
+            continue
+
+        name = name_match.group(1)
+        filename_match = re.search(r'filename="([^"]+)"', disposition)
+        payload = part.get_payload(decode=True)
+
+        if filename_match:
+            # Handle file upload
+            file_info = {
+                "filename": filename_match.group(1),
+                "content_type": part.get_content_type(),
+                "data": payload,
+                "size": len(payload),
+            }
+
+            # Handle multiple files with same name
+            if name in files:
+                if isinstance(files[name], list):
+                    files[name].append(file_info)
+                else:
+                    files[name] = [files[name], file_info]
+            else:
+                files[name] = file_info
+        else:
+            # Handle regular form field
+            try:
+                form_data[name] = payload.decode("utf-8")
+            except UnicodeDecodeError:
+                form_data[name] = payload
+
+    return form_data, files
+
+
+def parse_json(content_type: str, data: bytes):
+    return json.loads(data)
+
+
+def handle_compression(headers: dict, body: bytes) -> tuple[dict, bytes]:
+    """
+    Detects compression and decompresses HTTP request body.
+    Returns tuple of (modified_headers, decompressed_body).
+
+    Args:
+        headers: Dictionary of HTTP request headers (case-insensitive keys)
+        body: Raw request body as bytes
+
+    Returns:
+        Tuple of (headers with removed content-encoding, decompressed body)
+    """
+    decompressed_body = body
+
+    if "content-encoding" in headers:
+        encodings = [e.strip().lower() for e in headers["content-encoding"].split(",")]
+
+        # Apply decompressions in reverse order (as per RFC 7231)
+        for encoding in reversed(encodings):
+            try:
+                if encoding == "gzip" or encoding == "x-gzip":
+                    decompressed_body = gzip.decompress(decompressed_body)
+
+                elif encoding == "deflate":
+                    try:
+                        decompressed_body = zlib.decompress(decompressed_body)
+                    except zlib.error:
+                        # Some servers send raw deflate without zlib header
+                        decompressed_body = zlib.decompress(
+                            decompressed_body, -zlib.MAX_WBITS
+                        )
+
+                elif encoding == "br":
+                    decompressed_body = brotli.decompress(decompressed_body)
+
+                elif encoding == "compress" or encoding == "x-compress":
+                    raise NotImplementedError("compress encoding not supported")
+
+            except Exception as e:
+                raise ValueError(f"Decompression failed for {encoding}: {str(e)}")
+
+        # Remove content-encoding header
+        new_headers = headers.copy()
+        del new_headers["content-encoding"]
+        return new_headers, decompressed_body
+
+    if len(body) >= 2:
+        try:
+            # Check for gzip magic number (1f 8b)
+            if body[:2] == b"\x1f\x8b":
+                decompressed_body = gzip.decompress(body)
+                return headers, decompressed_body
+
+            # Check for zlib header (78 01, 78 9C, 78 DA)
+            elif body[0] == 0x78 and body[1] in {0x01, 0x9C, 0xDA}:
+                decompressed_body = zlib.decompress(body)
+                return headers, decompressed_body
+
+            # Check for brotli (starts with CE 2F or 1E)
+            elif len(body) > 3 and body[0] in {0xCE, 0x1E} and body[1] == 0x2F:
+                decompressed_body = brotli.decompress(body)
+                return headers, decompressed_body
+
+        except Exception as e:
+            raise ValueError(
+                f"Auto-detected compression but decompression failed: {str(e)}"
+            )
+
+    return headers, body
+
+
+def parse_body(headers: dict, header_params: dict, data: bytes):
+    headers, data = handle_compression(headers=headers, body=data)
+
+    content_type = headers.get(HttpHeaders.CONTENT_TYPE, HttpContentTypes.TEXT_PLAIN)
+
+    json_data = None
+    form_data = None
+    files = None
+    text = None
+
+    if content_type in [
+        HttpContentTypes.TEXT_PLAIN,
+        HttpContentTypes.TEXT_HTML,
+    ]:
+        text = data.decode(encoding="utf8")
+
+    if content_type == HttpContentTypes.APPLICATION_JSON:
+        json_data = parse_json(content_type=content_type, data=data)
+
+    elif content_type == HttpContentTypes.MULTIPART_FORM_DATA:
+        boundary = header_params.get(HttpHeaders.CONTENT_TYPE, {}).get("boundary", "")
+        if not boundary:
+            raise Exception("Invalid multipart boundary.")
+
+        form_data, files = parse_multipart_enhanced(
+            content_type=content_type, boundary=boundary, body=data
+        )
+
+    return {
+        "json": json_data,
+        "form_data": form_data,
+        "files": files,
+        "text": text,
+        "raw": data,
+    }