whoopapi 0.0.1__py3-none-any.whl

whoopapi/parsers/http_headers.py

@@ -0,0 +1,160 @@
+import re
+from urllib.parse import parse_qs, urlparse
+
+
+def strip_string(string: str):
+    return string.strip()
+
+
+# def parse_header_line_(header_line):
+#     """
+#     Parses an HTTP header line with multiple components.
+#     Handles headers like:
+#     Content-Type: text/html; charset=utf-8
+#     Cache-Control: no-cache, no-store, must-revalidate
+#     """
+#
+#     pattern = r"""
+#         ^(:?[^:\s]+)              # Header name (group 1) - can start with colon for pseudo-headers
+#         \s*:\s*                   # Colon with optional whitespace
+#         ([^\x00]*)                # Value (group 2) - no NUL characters allowed
+#         ((?:\s*[;,]\s*[^\x00;,]+)*)?  # Additional parameters (group 3, optional)
+#         \s*$                      # Trailing whitespace
+#     """
+#
+#     match = re.fullmatch(pattern, header_line, re.VERBOSE)
+#     if not match:
+#         return None
+#
+#     header_name = match.group(1).strip().lower()
+#     primary_value = match.group(2).strip()
+#
+#     is_pseudo = header_name.startswith(":")
+#     params = {} if not is_pseudo else None
+#
+#     if not is_pseudo and match.group(3):
+#         param_pairs = re.split(r"\s*[;,]\s*", match.group(3).strip())
+#         for pair in param_pairs:
+#             if "=" in pair:
+#                 key, value = pair.split("=", 1)
+#                 params[key.strip().lower()] = (
+#                     value.strip()
+#                 )  # Param names also lowercase
+#             elif pair:
+#                 params[pair.lower()] = True
+#
+#     return {
+#         "name": header_name,
+#         "value": primary_value,
+#         "params": params,
+#         "is_pseudo": is_pseudo,
+#     }
+
+
+def parse_header_line(header_line):
+    """
+    Parses an HTTP header line with multiple components.
+    Handles headers like:
+    Content-Type: text/html; charset=utf-8
+    Cache-Control: no-cache, no-store, must-revalidate
+    """
+
+    pattern = r"""
+        ^(:?[^:\s]+)              # Header name (group 1) - can start with colon for pseudo-headers
+        \s*:\s*                   # Colon with optional whitespace
+        ([^\x00;,]*)              # Primary value (group 2) - stops at ; or ,
+        \s*                       # Optional whitespace
+        (?:                       # Non-capturing group for parameters
+            [;,]\s*              # Parameter separator (; or ,) with optional whitespace
+            ([^\x00]*)           # All parameters (group 3)
+        )?
+        \s*$                      # Trailing whitespace
+    """
+
+    match = re.fullmatch(pattern, header_line, re.VERBOSE)
+    if not match:
+        return None
+
+    header_name = match.group(1).strip().lower()
+    primary_value = match.group(2).strip()
+    params_string = match.group(3).strip() if match.group(3) else ""
+
+    is_pseudo = header_name.startswith(":")
+    params = {} if not is_pseudo else None
+
+    # Parse parameters
+    if not is_pseudo and params_string:
+        # Split on semicolons or commas, but be careful with quoted values
+        param_pairs = re.split(r"\s*[;,]\s*", params_string)
+        for pair in param_pairs:
+            if not pair:
+                continue
+            if "=" in pair:
+                key, value = pair.split("=", 1)
+                # Remove quotes if present
+                value = value.strip()
+                if (value.startswith('"') and value.endswith('"')) or (
+                    value.startswith("'") and value.endswith("'")
+                ):
+                    value = value[1:-1]
+                params[key.strip().lower()] = value
+            elif pair:
+                params[pair.lower()] = True
+
+    return {
+        "name": header_name,
+        "value": primary_value,
+        "params": params,
+        "is_pseudo": is_pseudo,
+    }
+
+
+def parse_headers(data: bytes):
+    ENCODING = "utf-8"
+    HEADER_BREAK = "\r\n"
+    stringified = str(data, ENCODING)
+    entries = stringified.split(HEADER_BREAK)
+    start_line = entries[0].strip()
+    split_start_line = start_line.split(" ")
+    request_info = {}
+
+    if len(split_start_line) > 2:
+        request_info["method"] = strip_string(split_start_line[0])
+
+        request_path = strip_string(split_start_line[1])
+        parsed_path = urlparse(url=request_path)
+        request_info["path"] = parsed_path.path
+
+        query_params = parse_qs(parsed_path.query)
+        request_info["query_params"] = {
+            k: v[0] if len(v) == 1 else v for k, v in query_params.items()
+        }
+
+        split_version_info = strip_string(split_start_line[2]).split("/")
+        request_info["protocol"] = strip_string(strip_string(split_version_info[0]))
+        request_info["protocol_version"] = strip_string(split_version_info[1])
+
+    else:
+        raise Exception("Invalid headers.")
+
+    entries = entries[1:]
+    headers = {}
+    header_params = {}
+
+    for entry in entries:
+        parsed_line = parse_header_line(header_line=entry)
+        if not parsed_line:
+            continue
+
+        key = parsed_line["name"]
+        value = parsed_line["value"]
+        details = parsed_line["params"]
+        header_params[key] = details
+
+        headers[key] = value
+
+    return {
+        "request_info": request_info,
+        "headers": headers,
+        "header_params": header_params,
+    }

whoopapi/protocol_handlers/__init__.py

@@ -0,0 +1,3 @@
+# flake8: noqa
+from .http import RequestHandler, StaticFileHandler
+from .websocket import WebsocketHandler

whoopapi/protocol_handlers/http.py

@@ -0,0 +1,162 @@
+import inspect
+import os
+from typing import Any, Callable, Optional
+
+from ..constants import HttpContentTypes, HttpHeaders, HttpStatusCodes
+from ..logging import LOG_ERROR, LOG_INFO
+from ..responses import DEFAULT_404_PAGE
+from ..wrappers import HttpRequest, HttpResponse
+
+
+class RequestHandler:
+    def __init__(self):
+        self.route = ""
+
+    def get_handler_for_method_(self, method: str) -> Callable[[HttpRequest], Any]:
+        handler_ = {
+            "get": self.get,
+            "post": self.post,
+            "put": self.put,
+            "patch": self.patch,
+            "delete": self.delete,
+        }.get(method, None)
+
+        if not handler_:
+            raise Exception(f"Unable to get handler for method : {method}.")
+
+        return handler_
+
+    def get(self, request: HttpRequest) -> Optional[Any]:
+        pass
+
+    def post(self, request: HttpRequest) -> Optional[Any]:
+        pass
+
+    def put(self, request: HttpRequest) -> Optional[Any]:
+        pass
+
+    def patch(self, request: HttpRequest) -> Optional[Any]:
+        pass
+
+    def delete(self, request: HttpRequest) -> Optional[Any]:
+        pass
+
+
+def path_matches_route(path: str, route: str):
+    route_ = route.strip("/ ")
+    path_ = path.strip("/ ")
+    return path_.startswith(route_)
+
+
+def handle_http_client_request(
+    request: HttpRequest,
+    middlewares: list[Callable],
+    http_routes: list[tuple[str, Callable | RequestHandler]],
+    log_handler=True,
+):
+    for action in middlewares:
+        action(request)
+
+    response = None
+    wrapped_response = None
+    request_method = request.method.lower()
+    request_path = request.path
+    request_protocol = request.protocol
+    response_code = HttpStatusCodes.C_200
+
+    handler_found = False
+    for route, handler_function in http_routes:
+        if isinstance(handler_function, RequestHandler):
+            handler = handler_function
+            handler.route = route
+            handler_function_ = handler_function.get_handler_for_method_(
+                method=request_method
+            )
+
+        elif inspect.isclass(handler_function) and issubclass(
+            handler_function, RequestHandler
+        ):
+            handler = handler_function()
+            handler.route = route
+            handler_function_ = handler.get_handler_for_method_(method=request_method)
+
+        elif inspect.isfunction(handler_function):
+            handler_function_ = handler_function
+
+        else:
+            raise Exception(
+                "Invalid websocket handler. Must be Class_(RequestHandler), or instance of."
+            )
+
+        if path_matches_route(path=request_path, route=route):
+            handler_found = True
+
+            try:
+                response = handler_function_(request)
+
+            except Exception as e:
+                LOG_ERROR(e)
+                response = HttpResponse()
+                response.set_status_code(HttpStatusCodes.C_500)
+                response.set_html(DEFAULT_404_PAGE)
+                response_code = response.status_code
+
+            break
+
+    if isinstance(response, HttpResponse):
+        response_code = response.status_code
+        wrapped_response = response
+
+    elif isinstance(response, str):
+        text_response = HttpResponse()
+        text_response.set_header(HttpHeaders.CONTENT_TYPE, HttpContentTypes.TEXT_PLAIN)
+        text_response.set_body(response)
+        wrapped_response = text_response
+
+    elif isinstance(response, dict) or isinstance(response, list):
+        json_response = HttpResponse()
+        json_response.set_json(response)
+        wrapped_response = json_response
+
+    elif (not handler_found) or (not response):
+        response = HttpResponse()
+        response.set_status_code(HttpStatusCodes.C_404)
+        response.set_html(DEFAULT_404_PAGE)
+        response_code = response.status_code
+        wrapped_response = response
+
+    if log_handler:
+        log_message = f"{request_method.upper()} {request_protocol.upper()}://{request.host}{request_path} {response_code}"
+        LOG_INFO(log_message)
+
+    return wrapped_response
+
+
+class StaticFileHandler(RequestHandler):
+    def __init__(self, directories: list[str] = None):
+        super().__init__()
+        self.directories = directories or []
+
+    def get_file_path(self, path: str):
+        file_path = path[len(self.route) + 1 :]
+
+        for directory in self.directories:
+            file_path = os.path.join(directory, file_path)
+            if os.path.exists(file_path):
+                return file_path
+
+        return None
+
+    def get(self, request: HttpRequest):
+        file_path = self.get_file_path(request.path)
+        if file_path:
+            file = open(file_path, "rb")
+            data = file.read()
+            file.close()
+            response = HttpResponse()
+            response.set_file(f"{file_path.split(os.path.sep)[-1]}", data)
+
+            return response
+
+        else:
+            return None

whoopapi/protocol_handlers/websocket.py

@@ -0,0 +1,239 @@
+import base64 as BASE64
+import hashlib as HASHLIB
+import inspect
+import socket as SOCKET
+import struct as STRUCT
+from typing import Callable
+
+from ..constants import (
+    DEFAULT_STRING_ENCODING,
+    WEBSOCKET_ACCEPT_SUFFIX,
+    HttpHeaders,
+    HttpStatusCodes,
+)
+from ..logging import LOG_INFO
+from ..wrappers import HttpRequest, HttpResponse
+
+
+def mask_data(mask: bytes, data: bytes):
+    masked_data = b""
+
+    for index in range(0, len(data)):
+        x = data[index]
+        y = mask[index % 4]
+        masked_data = masked_data + STRUCT.pack("B", x ^ y)
+
+    return masked_data
+
+
+def send_websocket_message(socket: SOCKET.socket, message: bytes | str):
+    frame_size = 64
+    # mask=RANDOM.randbytes(4)
+    payloads = []
+    index = 0
+
+    while True:
+        end = index + frame_size
+        if end >= len(message):
+            end = len(message)
+            payloads.append(message[index:end])
+
+            break
+
+        else:
+            payloads.append(message[index:end])
+
+        index = end
+
+    frames = []
+    for payload_index in range(0, len(payloads)):
+        payload = payloads[payload_index]
+        if isinstance(payload, str):
+            payload = bytes(payload, DEFAULT_STRING_ENCODING)
+        # payload=mask_data(mask,payload)
+        fin_bit = 0x8000 if payload_index >= len(payloads) - 1 else 0x0000
+        rsv_bits = 0x0000
+
+        if payload_index == 0:
+            opcode_bits = 0x0200 if isinstance(message, bytes) else 0x0100
+
+        else:
+            opcode_bits = 0x0000
+        # opcode_bits=0x0200 if payload_index==0 else 0x0000
+        # mask_bit=0x0080
+
+        mask_bit = 0x0000
+        header = fin_bit | rsv_bits | opcode_bits | mask_bit | len(payload)
+        frame = STRUCT.pack(">H", header)
+        # frame=frame+mask+payload
+        frame = frame + payload
+        frames.append(frame)
+
+    for frame in frames:
+        socket.sendall(frame)
+
+
+def read_websocket_message(socket: SOCKET.socket):
+    buffer = b""
+
+    while True:
+        header = socket.recv(2)
+        if header and len(header) == 2:
+            header = STRUCT.unpack(">H", header)[0]
+            fin = header >> 15
+            # opcode = (header << 4) >> 16
+            # rsv = (header << 1) >> 13
+            mask = (header << 8) >> 15
+            payload_length = (header << 9) >> 9
+            data_mask = None
+            frame_data = None
+
+            if mask > 0:
+                data_mask = socket.recv(4)
+                if not data_mask:
+                    pass
+
+            if payload_length > 0:
+                frame_data = socket.recv(payload_length)
+                if frame_data:
+                    if mask and data_mask:
+                        decoded_frame_data = mask_data(data_mask, frame_data)
+                        buffer = buffer + decoded_frame_data
+
+                    else:
+                        buffer = buffer + frame_data
+
+                else:
+                    pass
+
+            if fin > 0:
+                break
+
+        else:
+            pass
+
+    return buffer
+
+
+class WebsocketHandler:
+    def __init__(self):
+        self.route = ""
+        self.DEFAULT_ENCODING = "utf-8"
+        self.socket = None
+        self.running = False
+
+    def set_socket(self, socket: SOCKET.socket):
+        self.socket = socket
+
+    def close(self):
+        try:
+            self.socket.close()
+            self.on_close()
+
+        except Exception as e:
+            LOG_INFO(e)
+
+    def run(self, timeout=None):
+        if not self.socket:
+            raise Exception("Socket not set.")
+
+        while True:
+            try:
+                message = read_websocket_message(self.socket)
+                if message:
+                    self.on_message(message)
+
+            except Exception as e:
+                self.on_error(e)
+                self.close()
+
+    def send(self, message: str | bytes):
+        try:
+            send_websocket_message(self.socket, message)
+
+        except Exception as e:
+            self.on_error(e)
+            self.close()
+
+    def on_connect(self, request: HttpRequest):
+        pass
+
+    def on_message(self, message: bytes):
+        pass
+
+    def on_close(self):
+        pass
+
+    def on_error(self, exception):
+        pass
+
+
+def path_matches_route(path: str, route: str):
+    route_ = route.strip("/ ")
+    path_ = path.strip("/ ")
+    return path_.startswith(route_)
+
+
+def handle_websocket_client_request(
+    socket: SOCKET.socket,
+    request: HttpRequest,
+    middlewares: list[Callable],
+    websocket_routes: list[tuple[str, Callable | WebsocketHandler]],
+):
+    request_path = request.path
+    handler_found = False
+
+    for action in middlewares:
+        action(request)
+
+    for route, handler_function in websocket_routes:
+        if isinstance(handler_function, WebsocketHandler):
+            handler = handler_function
+
+        elif inspect.isclass(handler_function) and issubclass(
+            handler_function, WebsocketHandler
+        ):
+            handler = handler_function()
+
+        else:
+            raise Exception(
+                "Invalid websocket handler. Must be Class_(WebsocketHandler), or instance of."
+            )
+
+        if path_matches_route(path=request_path, route=route):
+            handler_found = True
+            handler.route = route
+            handler.set_socket(socket)
+            handler.on_connect(request)
+            handler.run(timeout=1000)
+
+    if not handler_found:
+        socket.close()
+
+
+def generate_websocket_accept_key(websocket_key: str):
+    accept_key = f"{websocket_key}{WEBSOCKET_ACCEPT_SUFFIX}"
+    accept_key = HASHLIB.sha1(accept_key.encode()).digest()
+    accept_key = BASE64.b64encode(accept_key).decode("utf-8")
+
+    return accept_key
+
+
+def perform_websocket_handshake(socket: SOCKET.socket, headers: dict):
+    websocket_key = headers.get(HttpHeaders.SEC_WEBSOCKET_KEY, "")
+    # websocket_version = headers.get(CONSTANTS.HttpHeaders.SEC_WEBSOCKET_VERSION, 13)
+
+    if websocket_key:
+        accept_key = generate_websocket_accept_key(websocket_key)
+        response = HttpResponse()
+        response.set_header(HttpHeaders.CONNECTION, "Upgrade")
+        response.set_header(HttpHeaders.UPGRADE, "websocket")
+        response.set_header(HttpHeaders.SEC_WEBSOCKET_ACCEPT, accept_key)
+        response.set_status_code(HttpStatusCodes.C_101)
+        result = response.build()
+        socket.sendall(result)
+
+        return True
+
+    else:
+        return False

whoopapi/responses.py

@@ -0,0 +1,11 @@
+DEFAULT_404_PAGE = """
+<div style="display:flex;flex-direction:row;justify-content:center;align-items:center;margin:50px">
+    <h1><b>404 Error! This resource is not available.</b></h1>
+</div>
+"""
+
+DEFAULT_500_PAGE = """
+<div style="display:flex;flex-direction:row;justify-content:center;align-items:center;margin:50px">
+    <h1><b>500 Error! Internal server error.</b></h1>
+</div>
+"""