rilweb 0.1.0__py3-none-any.whl

rilweb/__init__.py

@@ -0,0 +1,3 @@
+from .rilweb import RilWeb
+from .response import HTTPResponse, JSONResponse
+from .request import HTTPRequest

rilweb/cookies.py

@@ -0,0 +1,30 @@
+import hmac
+import hashlib
+import base64
+
+
+def sign_cookie(value: str, secret: str) -> str:
+    signature = hmac.new(
+        secret.encode(),
+        value.encode(),
+        hashlib.sha256
+    ).digest()
+
+    signature = base64.urlsafe_b64encode(signature).decode().rstrip("=")
+
+    return f"{value}.{signature}"
+
+
+def unsign_cookie(signed_value: str, secret: str):
+    try:
+        value, signature = signed_value.rsplit(".", 1)
+
+        expected = sign_cookie(value, secret).rsplit(".", 1)[1]
+
+        if not hmac.compare_digest(signature, expected):
+            return None
+
+        return value
+
+    except (ValueError, AttributeError):
+        return None

rilweb/proto.py

@@ -0,0 +1,30 @@
+# === IMPORTS ===
+from typing import Dict, List, Optional, Protocol, Self, Callable
+
+# === REQUEST ===
+
+class RequestLike(Protocol):
+    method: str
+    path: str
+    headers: Dict[str, str]
+    query: Dict[str, List[str]]
+    body: Optional[bytes]
+
+    @classmethod
+    def from_raw(cls, data: bytes) -> Self:
+        ...
+
+# === RESPONSE ===
+
+class ResponseLike(Protocol):
+    status_code: int
+    body: bytes
+    headers: Optional[Dict[str, str]]
+    
+    def to_bytes(self) -> bytes:
+        ...
+
+# === MIDDLEWARE ===
+
+class MiddlewareLike(Protocol):
+    async def __call__(self, request: RequestLike, call_next: Callable) -> Optional[ResponseLike]: ...

rilweb/request.py

@@ -0,0 +1,58 @@
+# === IMPORTS ===
+from dataclasses import dataclass, field
+from typing import Dict, List, Self, Optional
+from urllib.parse import urlsplit, parse_qs
+
+# === HTTP REQUEST ===
+
+@dataclass
+class HTTPRequest:
+    method: str
+    path: str
+    headers: Dict[str, str]
+    query: Dict[str, List[str]]
+    body: Optional[bytes]
+    cookies: Dict[str, str] = field(default_factory=dict)
+
+    @classmethod
+    def from_raw(cls, data: bytes) -> Self:
+        header_part, _, body = data.partition(b'\r\n\r\n')
+        lines = header_part.split(b'\r\n')
+
+        req_line_parts = lines[0].split(b' ')
+
+        try:
+            method = req_line_parts[0].decode()
+            url = req_line_parts[1].decode()
+            urlsplitted = urlsplit(url)
+
+        except (IndexError, UnicodeDecodeError):
+            raise ValueError("Invalid HTTP request line")
+
+        headers = {}
+
+        for line in lines[1:]:
+            if b':' in line:
+                key, val = line.split(b':', 1)
+
+                headers[key.decode('latin-1').strip().lower()] = val.decode('latin-1').strip()
+
+
+        return cls(
+            method=method,
+            path=urlsplitted.path,
+            headers=headers,
+            query=parse_qs(urlsplitted.query) if urlsplitted.query else {},
+            body=body if body else None,
+            cookies=cls._parse_cookies(headers)
+        )
+
+    @staticmethod
+    def _parse_cookies(headers: Dict[str, str]) -> Dict[str, str]:
+        cookies = {}
+        cookie_header = headers.get("cookie", "")
+        if cookie_header:
+            for cookie in cookie_header.split(";"):
+                name, _, value = cookie.strip().partition("=")
+                cookies[name] = value
+        return cookies

rilweb/response.py

@@ -0,0 +1,82 @@
+# === IMPORTS ===
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+import json
+    
+# === HTTP RESPONSE ===
+
+@dataclass
+class HTTPResponse:
+    status_code: int
+    body: bytes
+    headers: Optional[Dict[str, str]] = None
+
+    def __post_init__(self):
+        if self.headers is None:
+            self.headers = {}
+        self.cookies = {}
+
+    def to_bytes(self) -> bytes:
+        headers = self.headers.copy()
+
+        if self.body is not None:
+            headers.setdefault("Content-Length", str(len(self.body)))
+        else:
+            headers.setdefault("Content-Length", "0")
+
+        headers.setdefault("Connection", "close")
+
+        status_line = f"HTTP/1.1 {self.status_code}\r\n"
+
+        header_lines = list((
+            f"{key}: {value}\r\n"
+            for key, value in headers.items()
+        ))
+
+        for name, (value, options) in self.cookies.items():
+            cookie = f"{name}={value}"
+            if "expires" in options:
+                cookie += f"; Expires={options['expires']}"
+            if "max_age" in options:
+                cookie += f"; Max-Age={options['max_age']}"
+            if "domain" in options:
+                cookie += f"; Domain={options['domain']}"
+            if "path" in options:
+                cookie += f"; Path={options['path']}"
+            if "samesite" in options:
+                cookie += f"; SameSite={options['samesite']}"
+            if options.get("secure"):
+                cookie += "; Secure"
+            if options.get("httponly"):
+                cookie += "; HttpOnly"
+            
+            header_lines.append(f"Set-Cookie: {cookie}\r\n")
+
+        return (
+            status_line.encode("ascii")
+            + "".join(header_lines).encode("latin-1")
+            + b"\r\n"
+            + (self.body or b"")
+        )
+
+    @classmethod
+    def from_file(cls, file_path: str, **kw) -> "HTTPResponse":
+        with open(file_path, "rb") as f:
+            body = f.read()
+
+        kw['body'] = body
+        return cls(**kw)
+
+    def set_cookie(self, name: str, value: str, **options):
+        if not all([option in ("expires", "max_age", "domain", "path", "secure", "httponly") for option in options]):
+            raise ValueError("Invalid cookie option")
+
+        self.cookies[name] = (value, options)
+
+class JSONResponse(HTTPResponse):
+    def __init__(self, status_code: int, headers: Dict[str, str], body: Any, **json_kw):
+        headers = headers.copy()
+        headers.setdefault("Content-Type", "application/json; charset=utf-8")
+        
+        body = json.dumps(body, **json_kw).encode("utf-8")
+        super().__init__(status_code, body, headers)

rilweb/rilweb.py

@@ -0,0 +1,284 @@
+# === IMPORTS ===
+import socket
+from .proto import ResponseLike, MiddlewareLike
+from .request import HTTPRequest
+from .response import HTTPResponse
+from typing import Callable, Tuple, Dict, Awaitable, TypeAlias, Optional
+from pathlib import Path
+import traceback
+import asyncio
+from .cookies import sign_cookie as _sign_cookie, unsign_cookie as _unsign_cookie
+
+# === TYPES ===
+
+Handler: TypeAlias = Callable[[HTTPRequest], Awaitable[ResponseLike]]
+
+# === MAIN CLASS ===
+
+class RilWeb:
+    def __init__(self, host: str, port: int, dev: bool = False, secret_key: Optional[str] = None):
+        """
+        :param host: The host address to bind the server to.
+        :param port: The port number to bind the server to.
+        :param dev: Whether to run the server in development mode (default is False).
+        """
+        self.host = host
+        self.port = port
+        self.dev = dev
+        self.secret_key = secret_key
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # create and configure
+        # socket options
+        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # allow reuse of the address
+        self.sock.bind((self.host, self.port))
+        self.routes: Dict[Tuple[str, str], Handler] = {}
+        self.error_handlers: Dict[int, Handler] = {}
+        self.middlewares: list[MiddlewareLike] = []
+
+        self.tasks: set[asyncio.Task] = set()
+
+        self.set_error_handler(404, self._404) # set up default error handlers
+        self.set_error_handler(500, self._500)
+
+    # route management
+
+    def add_route(self, path: str, handler: Handler, method: str = "GET"):
+        """
+        :param path: The URL path to route.
+        :param handler: The handler function to call for this route.
+        :param method: The HTTP method for this route (default is "GET").
+        """
+        self.routes[(path, method)] = handler
+
+    def route(self, path: str, method: str = "GET"):
+        """
+        Decorator to add a route to the server.
+
+        :param path: The URL path to route.
+        :param method: The HTTP method for this route (default is "GET").
+        """
+        def decorator(handler):
+            self.add_route(path, handler, method)
+            return handler
+        return decorator
+
+    # error handlers
+
+    def set_error_handler(self, status_code: int, handler: Handler):
+        """
+        Set an error handler for a specific HTTP status code.
+
+        :param status_code: The HTTP status code to handle.
+        :param handler: The handler function to call for this error.
+        """
+        self.error_handlers[status_code] = handler
+
+    def error_handler(self, status_code: int):
+        """
+        Decorator to set an error handler for a specific HTTP status code.
+
+        :param status_code: The HTTP status code to handle.
+        """
+        def decorator(handler):
+            self.set_error_handler(status_code, handler)
+            return handler
+        return decorator
+
+    # default error handler helpers
+
+    async def _404(self, request: HTTPRequest) -> ResponseLike:
+        html_path = Path(__file__).parent / "404.html"
+        return HTTPResponse.from_file(str(html_path), status_code=404)
+
+    async def _500(self, request: HTTPRequest) -> ResponseLike:
+        html_path = Path(__file__).parent / "500.html"
+        return HTTPResponse.from_file(str(html_path), status_code=500)
+
+    async def _make_500(self, request, traceback_str):
+        if self.dev and self.error_handlers[500] is self._500:
+            return HTTPResponse(500, traceback_str.encode())
+
+        return await self.error_handlers[500](request)
+
+    
+    # request handling
+
+    async def _handle_req(self, request: HTTPRequest, client_addr: str, client_port: int) -> ResponseLike:
+        key = (request.path, request.method)
+        handler = self.routes.get(key)
+
+        print(f'[INCOMING] from {client_addr}:{client_port}')
+
+        # 404 handling
+        if handler is None:
+            res =  await self.error_handlers[404](request)
+            print(f'[{res.status_code}] {request.method} to {request.path}') # logging
+            return res
+
+        # define middleware caller
+
+        async def call_middleware(index: int, req: HTTPRequest):
+            if index >= len(self.middlewares):
+                return await handler(req)
+
+            middleware = self.middlewares[index]
+
+            return await middleware(
+                req,
+                lambda r: call_middleware(index + 1, r)
+            )
+
+        # run the route handler
+        try:
+            res = await call_middleware(0, request)
+        except Exception:
+            traceback.print_exc()
+            res = await self._make_500(request, traceback.format_exc())
+
+        print(f'[{res.status_code}] {request.method} to {request.path!r}') # logging
+
+        return res
+
+    # low-level request reception
+    async def _receive_request(self, client_sock: socket.socket) -> bytes:
+        loop = asyncio.get_running_loop()
+        data = bytearray()
+
+        # define constants
+
+        MAX_HEADER_SIZE = 64 * 1024
+        MAX_BODY_SIZE = 10 * 1024 * 1024
+
+        # read http headers
+
+        while b"\r\n\r\n" not in data:
+            chunk = await loop.sock_recv(client_sock, 4096)
+
+            if not chunk:
+                raise ConnectionError("Client disconnected before sending headers")
+
+            data.extend(chunk)
+
+            if len(data) > MAX_HEADER_SIZE:
+                raise ValueError("HTTP headers are too large")
+
+        header_end = data.index(b"\r\n\r\n")
+        header_data = bytes(data[:header_end])
+
+        content_length = 0
+
+        # parse headers
+
+        for line in header_data.split(b"\r\n")[1:]:
+            name, separator, value = line.partition(b":")
+
+            if not separator:
+                continue
+
+            name = name.strip().lower()
+            value = value.strip()
+
+            if name == b"transfer-encoding":
+                raise NotImplementedError("Chunked transfer encoding is not supported yet")
+
+            if name == b"content-length":
+                content_length = int(value)
+
+                if content_length < 0:
+                    raise ValueError("Invalid Content-Length")
+
+        if content_length > MAX_BODY_SIZE:
+            raise ValueError("HTTP request body is too large")
+
+        body_start = header_end + 4
+        body_end = body_start + content_length
+
+        while len(data) < body_end:
+            chunk = await loop.sock_recv(client_sock, 4096)
+
+            if not chunk:
+                raise ConnectionError("Client disconnected before sending the complete body")
+
+            data.extend(chunk)
+
+        return bytes(data[:body_end])
+
+    # internal run function
+    
+    async def _run(self):
+        self.sock.setblocking(False)
+        self.sock.listen(5)
+
+        loop = asyncio.get_running_loop()
+        self.tasks = set()
+
+        try:
+            while True:
+                client_sock, client_addr = await loop.sock_accept(self.sock)
+
+                task = asyncio.create_task(
+                    self._handle_client(client_sock, client_addr)
+                )
+
+                self.tasks.add(task)
+                task.add_done_callback(self.tasks.discard)
+
+        finally:
+            self.sock.close()
+
+            for task in self.tasks:
+                task.cancel()
+
+            await asyncio.gather(*self.tasks, return_exceptions=True)
+            self.tasks.clear()
+
+    # client handling
+
+    async def _handle_client(self, client_sock, client_addr):
+        client_sock.setblocking(False)
+
+        try:
+            loop = asyncio.get_running_loop()
+
+            request_data = await self._receive_request(client_sock)
+            request = HTTPRequest.from_raw(request_data)
+
+            response = await self._handle_req(request, *client_addr)
+
+            await loop.sock_sendall(client_sock, response.to_bytes())
+
+        except Exception:
+            traceback.print_exc()
+
+        finally:
+            client_sock.close()
+
+    # redirects
+    def redirect(self, url: str, status_code: int = 302):
+        return HTTPResponse(status_code, b"", headers={"Location": url})
+
+    # middleware management
+
+    def add_middleware(self, middleware: MiddlewareLike):
+        self.middlewares.append(middleware)
+
+    def run(self):
+        try:
+            asyncio.run(self._run())
+        except KeyboardInterrupt:
+            print("\nRilweb: server stopped.")
+
+    def sign_cookie(self, value: str) -> str:
+        if self.secret_key is None:
+            raise RuntimeError("Secret key is not set")
+
+        return _sign_cookie(value, self.secret_key)
+
+    def verify_cookie(self, request: HTTPRequest, name: str):
+        if self.secret_key is None:
+            raise RuntimeError("Secret key is not set")
+
+        signed_value = request.cookies.get(name)
+        if not signed_value:
+            return None
+
+        return _unsign_cookie(signed_value, self.secret_key)

rilweb/templating.py

@@ -0,0 +1,34 @@
+try:
+    import jinja2
+except ImportError as e:
+    raise RuntimeError(
+        "Jinja2 is not installed. "
+        "Please install it with `pip install jinja2` "
+        "to use templating features."
+    ) from e
+
+from .response import HTTPResponse
+from typing import Optional, Dict
+
+
+class TemplateResponse(HTTPResponse):
+    def __init__(
+        self,
+        fp: str,
+        status_code: int = 200,
+        headers: Optional[Dict[str, str]] = None,
+        **context
+    ):
+        env = jinja2.Environment(
+            loader=jinja2.FileSystemLoader("."),
+            autoescape=True
+        )
+
+        template = env.get_template(fp)
+        rendered = template.render(**context)
+
+        super().__init__(
+            status_code,
+            rendered.encode("utf-8"),
+            headers=headers
+        )

rilweb-0.1.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: rilweb
+Version: 0.1.0
+Summary: A simple http framework built in python using `socket` and `asyncio`.
+Author-email: Arlo Talkington <mongpod67@gmail.com>
+License-Expression: MIT
+Keywords: example,package,template
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Provides-Extra: templating
+Requires-Dist: jinja2>=3.1.2; extra == "templating"

rilweb-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+rilweb/__init__.py,sha256=KCnbpSn2v8Me506_2tGT7CRMZPabQAlCQtR66br4DtY,110
+rilweb/cookies.py,sha256=lIXuAap78JAVm_3SCQYBP_clSCjyW7jSjJ4C6hhjiek,690
+rilweb/proto.py,sha256=s0nMC-EdzH6poF-r60Nx45oGZd7t67-Rsl2tw4NkOD8,685
+rilweb/request.py,sha256=YXsExbtJJxWSMyo2P1OpB_Okef9Z6jAGjoMK1SiFsu0,1773
+rilweb/response.py,sha256=gvSGiYIt03wokb3uNHBKFg61t8p0ugWNtUj0Dv_BXw4,2741
+rilweb/rilweb.py,sha256=kpk54U2K_l1fxKIJkK9xrWYQVyhTjMl6eOBulxrZNOQ,9239
+rilweb/templating.py,sha256=fiYvxkYJXXuxUSwj8lzRaJjRmi8WDR1MUaKfsAY4-L4,848
+rilweb-0.1.0.dist-info/METADATA,sha256=SiBrUIOGjp_C_df5jSIi6zteui4_Lev-lhgCa12Ruac,494
+rilweb-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+rilweb-0.1.0.dist-info/top_level.txt,sha256=H4yJFVQTb11llvNoivbTV7ogOF_p4jsRAKYiMrqdYvY,7
+rilweb-0.1.0.dist-info/RECORD,,

rilweb-0.1.0.dist-info/WHEEL

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

rilweb-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+rilweb