whoopapi 0.0.1__py3-none-any.whl

whoopapi/utilities.py

@@ -0,0 +1,289 @@
+import socket as SOCKET
+import ssl as SSL
+import sys
+import threading as THREADING
+from typing import Callable, List
+from urllib.parse import urlparse
+
+from .constants import HttpHeaders, HttpMethods, WebProtocols
+from .logging import LOG_ERROR, LOG_PRETTY
+from .parsers.http_body import parse_body
+from .parsers.http_headers import parse_headers
+from .protocol_handlers.http import RequestHandler, handle_http_client_request
+from .protocol_handlers.websocket import (
+    WebsocketHandler,
+    handle_websocket_client_request,
+    perform_websocket_handshake,
+)
+from .wrappers import HttpRequest
+
+
+def read_http_client_request_body(socket: SOCKET.socket, body_size: int):
+    LOW_THRESHOLD = 1024
+    buffer = b""
+    if body_size == 0:
+        return buffer
+
+    if body_size < 0:
+        body_size = sys.maxsize
+
+    if body_size <= LOW_THRESHOLD:
+        return socket.recv(body_size)
+
+    else:
+        buffer = b""
+        bytes_read = 0
+        bytes_remaining = body_size
+
+        while True:
+            if bytes_remaining < LOW_THRESHOLD:
+                buffer = buffer + socket.recv(bytes_remaining)
+
+                break
+
+            else:
+                chunk = socket.recv(LOW_THRESHOLD)
+                if len(chunk) < LOW_THRESHOLD:
+                    bytes_remaining = 0
+
+                buffer = buffer + chunk
+                bytes_read = bytes_read + LOW_THRESHOLD
+                bytes_remaining = body_size - bytes_read
+
+        return buffer
+
+
+def read_http_client_request_headers(socket: SOCKET.socket):
+    HEADERS_BREAK = b"\r\n\r\n"
+    buffer = b""
+    while True:
+        data = socket.recv(1)
+        if data:
+            buffer = buffer + data
+            if buffer.endswith(HEADERS_BREAK):
+                break
+
+    return buffer[: -len(HEADERS_BREAK)]
+
+
+def read_http_client_request(socket: SOCKET.socket):
+    try:
+        headers_data = read_http_client_request_headers(socket=socket)
+        parsed_headers = parse_headers(headers_data)
+
+        headers = parsed_headers["headers"]
+        header_params = parsed_headers["header_params"]
+        request_info = parsed_headers["request_info"]
+
+        if request_info.get("method", "get").lower() == HttpMethods.GET:
+            body_size = 0
+
+        else:
+            body_size = int(headers.get(HttpHeaders.CONTENT_LENGTH, -1))
+
+        body_data = read_http_client_request_body(socket, body_size)
+        parsed_body = parse_body(headers, header_params, body_data)
+
+        http_request = HttpRequest(
+            request_info=request_info,
+            request_header_params=header_params,
+            request_headers=headers,
+            request_body=parsed_body,
+        )
+
+        return http_request, None
+
+    except Exception as e:
+        return None, f"{e}"
+
+
+def parse_route_path(path: str):
+    parsed = urlparse(url=path)
+    return parsed.path
+
+
+class Application:
+    def __init__(self):
+        self.middlewares = []
+        self.http_routes = []
+        self.websocket_routes = []
+        self.ssl_cert_file = None
+        self.ssl_key_file = None
+
+    def set_ssl(self, cert_file: str, key_file: str):
+        self.ssl_cert_file = cert_file
+        self.ssl_key_file = key_file
+
+    def add_middleware(self, *middlewares: Callable):
+        self.middlewares = [*self.middlewares, *middlewares]
+
+    def route_http(self, handler: Callable | RequestHandler, path: str):
+        self.http_routes = [*self.http_routes, (parse_route_path(path=path), handler)]
+
+    def route_websocket(self, handler: Callable | WebsocketHandler, path: str):
+        self.websocket_routes = [
+            *self.websocket_routes,
+            (parse_route_path(path=path), handler),
+        ]
+
+    def route(self, path: str, methods: List[str] = None):
+        def wrapper_(handler_: Callable):
+            if methods:
+
+                def wrapped_handler_(request_: HttpRequest):
+                    if request_.method.upper() in methods:
+                        return handler_(request_)
+
+                    return None
+
+                self.route_http(handler=wrapped_handler_, path=path)
+
+                return wrapped_handler_
+
+            else:
+                self.route_http(handler=handler_, path=path)
+
+                return handler_
+
+        return wrapper_
+
+    def route_ws(self, path: str):
+        def wrapper_(handler_: Callable | WebsocketHandler):
+            self.route_websocket(handler=handler_, path=path)
+
+            return handler_
+
+        return wrapper_
+
+    def clear_middlewares(self):
+        self.middlewares = []
+
+    def clear_http_routes(self):
+        self.http_routes = []
+
+    def clear_websocket_routes(self):
+        self.websocket_routes = []
+
+    def execute_request(self, request: HttpRequest):
+        handle_http_client_request(
+            request=request, middlewares=self.middlewares, http_routes=self.http_routes
+        )
+
+    def listen(self, port: int | str = 8000, on_start: Callable = None):
+        bind_address = ("", int(port))
+
+        start_application(
+            bind_address=bind_address,
+            application=self,
+            on_start=on_start,
+            ssl_cert_file=self.ssl_cert_file,
+            ssl_key_file=self.ssl_key_file,
+        )
+
+
+def handle_client_connection(
+    socket: SOCKET.socket,
+    application: Application,
+):
+    http_request, error = read_http_client_request(socket)
+    if error:
+        LOG_ERROR(error)
+        socket.close()
+
+    else:
+        request_protocol = http_request.protocol.lower()
+
+        if request_protocol.lower() in [
+            WebProtocols.HTTP,
+            WebProtocols.HTTPS,
+        ]:
+            request_headers = http_request.headers
+
+            connection = request_headers.get(HttpHeaders.CONNECTION, "")
+            upgrade = request_headers.get(HttpHeaders.UPGRADE, "")
+
+            handler_response = None
+            if connection and connection.lower() == "upgrade":
+                if upgrade and upgrade.lower() == "websocket":
+                    handshake_successful = perform_websocket_handshake(
+                        socket, request_headers
+                    )
+                    if handshake_successful:
+                        handle_websocket_client_request(
+                            socket=socket,
+                            request=http_request,
+                            middlewares=application.middlewares,
+                            websocket_routes=application.websocket_routes,
+                        )
+
+                    else:
+                        handler_response = handle_http_client_request(
+                            request=http_request,
+                            middlewares=application.middlewares,
+                            http_routes=application.http_routes,
+                        )
+
+            else:
+                handler_response = handle_http_client_request(
+                    request=http_request,
+                    middlewares=application.middlewares,
+                    http_routes=application.http_routes,
+                )
+
+            if handler_response:
+                result = handler_response.build(request_headers=request_headers)
+                socket.sendall(result)
+                socket.close()
+
+            else:
+                try:
+                    socket.close()
+
+                except Exception as e:
+                    LOG_ERROR(e)
+
+        else:
+            socket.close()
+
+
+def start_application(
+    bind_address: tuple[str, int],
+    application: Application,
+    on_start: Callable = None,
+    ssl_cert_file: str = None,
+    ssl_key_file: str = None,
+):
+    application.http_routes.sort(key=lambda x: len(x[0]), reverse=True)
+    application.websocket_routes.sort(key=lambda x: len(x[0]), reverse=True)
+
+    server_socket = SOCKET.socket(SOCKET.AF_INET, SOCKET.SOCK_STREAM)
+    server_socket.bind(bind_address)
+    server_socket.listen(1000)
+
+    if callable(on_start):
+        on_start(bind_address)
+
+    else:
+        LOG_ERROR(f"Server running on port {bind_address[1]}")
+
+    while True:
+        client_socket, client_address = server_socket.accept()
+        if ssl_cert_file and ssl_key_file:
+            ssl_context = SSL.SSLContext(SSL.PROTOCOL_TLS_SERVER)
+            ssl_context.load_cert_chain(certfile=ssl_cert_file, keyfile=ssl_key_file)
+
+            try:
+                client_socket = ssl_context.wrap_socket(client_socket, server_side=True)
+
+            except Exception as e:
+                LOG_PRETTY(e)
+
+        try:
+            client_thread = THREADING.Thread(
+                target=handle_client_connection,
+                args=(client_socket, application),
+            )
+            client_thread.start()
+
+        except Exception as e:
+            LOG_PRETTY(e)

whoopapi/wrappers.py

@@ -0,0 +1,193 @@
+import gzip
+import json as JSON
+import zlib
+from typing import Optional
+
+import brotli
+
+from .constants import (
+    HttpContentTypes,
+    HttpHeaders,
+    HttpStatusCodes,
+    get_content_type_from_filename,
+    get_default_headers,
+    get_http_status_code_message,
+)
+
+
+class HttpRequestBody:
+    def __init__(self, **kwargs):
+        self.json = kwargs.get("json", None)
+        self.form_data = kwargs.get("form_data", None)
+        self.files = kwargs.get("files", None)
+        self.raw = kwargs.get("raw", None)
+
+
+class HttpRequest:
+    def __init__(
+        self,
+        request_info: Optional[dict] = None,
+        request_headers: Optional[dict] = None,
+        request_header_params: Optional[dict] = None,
+        request_body: Optional[dict] = None,
+    ):
+        request_info = request_info or {}
+        self.protocol = request_info.get("protocol", "")
+        self.protocol_version = request_info.get("protocol_version", "")
+        self.method = request_info.get("method", "")
+        self.path = request_info.get("path", "")
+        self.query_params = request_info.get("query_params", {})
+        self.host = request_headers.get("host", "")
+
+        self.headers = request_headers or {}
+        self.header_params = request_header_params
+
+        request_body = request_body or {}
+        self.body = HttpRequestBody(**request_body)
+        self.files = self.body.files
+
+        self.context = {}
+
+    def set_context_key(self, key: str, value):
+        self.context[key] = value
+        return self
+
+    def update_context(self, update: dict):
+        self.context.update(update)
+        return self
+
+    def set_context(self, context: dict):
+        self.context = context
+        return self
+
+    def get_context(self):
+        return self.context
+
+    def get_headers(self):
+        return self.headers
+
+
+class HttpResponse:
+    def __init__(self):
+        self.headers = get_default_headers()
+        self.body = b""
+        self.http_version = "HTTP/1.1"
+        self.status_code = HttpStatusCodes.C_200
+        self.DEFAULT_ENCODING = "utf-8"
+
+    def set_http_version(self, version: str):
+        self.http_version = (
+            f"HTTP/{version}" if not version.startswith("HTTP") else version
+        )
+
+        return self
+
+    def set_status_code(self, code: int | str):
+        if isinstance(code, str):
+            self.status_code = f"{code}"
+
+        else:
+            self.status_code = f"{code} {get_http_status_code_message(code)}"
+
+        return self
+
+    def set_header(self, header: str, value: str):
+        self.headers[header] = value
+
+        return self
+
+    def set_headers(self, headers: dict[str, str]):
+        self.headers.update(headers)
+
+        return self
+
+    def set_json(self, data: dict | list):
+        self.set_header(
+            HttpHeaders.CONTENT_TYPE,
+            HttpContentTypes.APPLICATION_JSON,
+        )
+        self.body = bytes(JSON.dumps(data), self.DEFAULT_ENCODING)
+
+        return self
+
+    def set_body(self, body: bytes | str):
+        self.body = (
+            body if isinstance(body, bytes) else bytes(body, self.DEFAULT_ENCODING)
+        )
+
+        return self
+
+    def set_html(self, html: str):
+        self.set_body(html)
+        self.set_header(HttpHeaders.CONTENT_TYPE, HttpContentTypes.TEXT_HTML)
+
+        return self
+
+    def set_file(self, filename: str, data: bytes, as_attachment: bool = True):
+        self.set_body(data)
+        self.set_header(
+            HttpHeaders.CONTENT_DISPOSITION,
+            f"{'attachment' if as_attachment else 'inline'} filename={filename}",
+        )
+        self.set_header(
+            HttpHeaders.CONTENT_TYPE,
+            f"{get_content_type_from_filename(filename)}",
+        )
+
+        return self
+
+    def set_text(self, text: str):
+        self.set_body(text)
+        self.set_header(HttpHeaders.CONTENT_TYPE, HttpContentTypes.TEXT_PLAIN)
+
+        return self
+
+    def build_client_supported_compressions(
+        self,
+        request_headers: dict = None,
+    ):
+        accepted_compressions = request_headers.get(HttpHeaders.ACCEPT_ENCODING, "")
+
+        if accepted_compressions:
+            accepted_compressions = [
+                t.strip() for t in accepted_compressions.split(",")
+            ]
+
+            if "gzip" in accepted_compressions:
+                self.set_header(HttpHeaders.CONTENT_ENCODING, "gzip")
+
+                return gzip.compress(self.body)
+
+            elif "deflate" in accepted_compressions:
+                self.set_header(HttpHeaders.CONTENT_ENCODING, "deflate")
+
+                return zlib.compress(self.body)
+
+            elif "br" in accepted_compressions:
+                self.set_header(HttpHeaders.CONTENT_ENCODING, "br")
+
+                return brotli.compress(self.body)
+
+        return self.body
+
+    def build_headers(self):
+        items = [f"{self.http_version} {self.status_code}"]
+        for key, value in self.headers.items():
+            items.append(f"{key}: {value}")
+
+        return bytes("\r\n".join(items), self.DEFAULT_ENCODING)
+
+    def build(self, request_headers: dict = None):
+        body = (
+            self.build_client_supported_compressions(request_headers=request_headers)
+            if request_headers
+            else self.body
+        )
+
+        result = b""
+        self.set_header(HttpHeaders.CONTENT_LENGTH, str(len(body)))
+        result = result + self.build_headers()
+        result = result + b"\r\n\r\n"
+        result = result + body
+
+        return result

whoopapi-0.0.1.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: whoopapi
+Version: 0.0.1
+Summary: A lightweight web API framework.
+Author-email: Derrick Wafula <derrickwafula@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/DerrohXy/WhoopAPI
+Project-URL: Issues, https://github.com/DerrohXy/WhoopAPI/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: brotli>=1.1.0
+Dynamic: license-file
+
+# Simple lightweight web API framework

whoopapi-0.0.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+whoopapi/__init__.py,sha256=--0GIIKpi_qAlGEwSW6yH8kRgrClj7jkrMFBvUAYvy8,308
+whoopapi/constants.py,sha256=mhq7BkL44CUoJzJ-n-iKz_xi3l4veg6u5uzgAowM6uA,11857
+whoopapi/logging.py,sha256=KHoPlodJuZt2mi_MtA0vA1LrO03MRc_Z7ARgtlhroac,267
+whoopapi/responses.py,sha256=YuIPsXWc5iTFdqjvkY-74HKiwPJT9eH1r5RaiTwnfqo,386
+whoopapi/utilities.py,sha256=VAuyc8cqC6hFyAxna9Yx7NmwlTkl5g2y1VouZ0JG3yE,8711
+whoopapi/wrappers.py,sha256=oPfoUJO7ku8A9u_v0ijKUryYOHfK1MAGcCVe-ogWUhE,5481
+whoopapi/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+whoopapi/parsers/http_body.py,sha256=wO3Fs_hSyVL6k1BOrSi7K9ol8IO6lJ557gQTEDiekho,8317
+whoopapi/parsers/http_headers.py,sha256=sVCNgAe66M4IFNfw-z10_uvTO5ck40rxcUDnQ0NpPgE,5278
+whoopapi/protocol_handlers/__init__.py,sha256=42tgIMu4D4EGxwlUH6O_FdCyZXALlQhO_CLizZRGZck,107
+whoopapi/protocol_handlers/http.py,sha256=wWiGM86cnTUCzXx6WTRC8WLqjaTVdBStkpQYWuD7kGk,4926
+whoopapi/protocol_handlers/websocket.py,sha256=q3q1YtYufKl5TtPeWIJPAYCU8Mjg-qWOFFxtJlK9pHA,6421
+whoopapi-0.0.1.dist-info/licenses/LICENSE,sha256=7w1_gfAIaRj6QAY0GKY1P-Q1J9ycz90QOl7gIzEESms,1072
+whoopapi-0.0.1.dist-info/METADATA,sha256=dGHwwNp5bt3pEI-j74XgWJDWtKsahPYAdF--VRsFhgM,569
+whoopapi-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+whoopapi-0.0.1.dist-info/top_level.txt,sha256=QuIAitoyEjEvjZVujGbDfWEb08tGXnNBm2ttm_TvPXI,9
+whoopapi-0.0.1.dist-info/RECORD,,

whoopapi-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

whoopapi-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Derrick Wafula
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

whoopapi-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+whoopapi