rnhttp 0.0.1__py3-none-any.whl

rnhttp/__init__.py

@@ -0,0 +1,19 @@
+"""rnhttp - HTTP/1.1 over Reticulum Network Stack."""
+
+from importlib.metadata import version
+
+__version__ = version("rnhttp")
+
+from .client import HttpClient
+from .server import HttpServer
+from .types import (
+    HttpRequest,
+    HttpResponse,
+)
+
+__all__ = [
+    "HttpRequest",
+    "HttpResponse",
+    "HttpServer",
+    "HttpClient",
+]

rnhttp/__whitelist.py

@@ -0,0 +1,21 @@
+_._read_timeout  # unused attribute (rnhttp/client.py:44)
+_.post  # unused method (rnhttp/client.py:189)
+_.put  # unused method (rnhttp/client.py:198)
+_.delete  # unused method (rnhttp/client.py:207)
+_.is_connected  # unused property (rnhttp/client.py:221)
+_._read_timeout  # unused attribute (rnhttp/server.py:52)
+_.route  # unused method (rnhttp/server.py:78)
+_.add_handler  # unused method (rnhttp/server.py:99)
+HttpSerializerError  # unused class (rnhttp/types.py:26)
+_.on_message_begin  # unused method (rnhttp/types.py:42)
+_.on_method  # unused method (rnhttp/types.py:45)
+_.on_url  # unused method (rnhttp/types.py:48)
+_.on_version  # unused method (rnhttp/types.py:51)
+_.on_header  # unused method (rnhttp/types.py:54)
+_.on_body  # unused method (rnhttp/types.py:57)
+_.on_message_begin  # unused method (rnhttp/types.py:71)
+_.on_version  # unused method (rnhttp/types.py:74)
+_.on_status_code  # unused method (rnhttp/types.py:77)
+_.on_reason_phrase  # unused method (rnhttp/types.py:80)
+_.on_header  # unused method (rnhttp/types.py:83)
+_.on_body  # unused method (rnhttp/types.py:86)

rnhttp/_compat.py

@@ -0,0 +1,20 @@
+# pyright: reportUnnecessaryTypeIgnoreComment=none
+from collections.abc import Callable
+from typing import (
+    Any,
+    cast,
+)
+
+try:
+    # Added in python 3.12
+    from typing import (
+        override,  # pyright: ignore[reportUnknownVariableType,reportAttributeAccessIssue,reportUnknownType,reportUnnecessaryTypeIgnoreComment]
+    )
+
+except ImportError:
+    from overrides import (  # pyright: ignore[reportMissingImports,reportUnnecessaryTypeIgnoreComment]
+        override,  # pyright: ignore[reportUnknownVariableType,reportUnnecessaryTypeIgnoreComment]
+    )
+
+override = cast(Callable[[Callable[..., Any]], Callable[..., Any]], override)  # pyright: ignore[reportExplicitAny]
+__all__ = ["override"]

rnhttp/client.py

@@ -0,0 +1,330 @@
+"""HTTP/1.1 client over RNS."""
+
+import argparse
+import asyncio
+import os
+import sys
+import threading
+from typing import (
+    Any,
+    cast,
+)
+
+import RNS
+
+from .types import (
+    HttpRequest,
+    HttpResponse,
+)
+
+
+class TransportError(Exception):
+    """Exception raised for transport errors."""
+
+    pass
+
+
+class HttpClient:
+    """HTTP/1.1 client using RNS for transport."""
+
+    def __init__(
+        self,
+        destination_hash: bytes | str,
+        port: int,
+        identity_path: str | None = None,
+        connect_timeout: float = 30.0,
+        request_timeout: float = 60.0,
+        read_timeout: float = 30.0,
+    ) -> None:
+        if isinstance(destination_hash, str):
+            destination_hash = bytes.fromhex(destination_hash)
+
+        self._destination_hash: bytes = destination_hash
+        self._port: int = port
+        self._identity_path: str = identity_path or self._default_identity_path()
+        self._connect_timeout: float = connect_timeout
+        self._request_timeout: float = request_timeout
+        self._read_timeout: float = read_timeout
+        self._identity: RNS.Identity | None = None
+        self._link: RNS.Link | None = None
+
+    @staticmethod
+    def _default_identity_path() -> str:
+        """Get default identity path."""
+        home = os.path.expanduser("~")
+        return os.path.join(home, ".rnhttp", "identity")
+
+    def _load_or_create_identity(self) -> RNS.Identity:
+        """Load existing identity or create new one."""
+        if self._identity is not None:
+            return self._identity
+
+        if os.path.exists(self._identity_path):
+            self._identity = RNS.Identity.from_file(self._identity_path)  # pyright: ignore[reportUnknownMemberType]
+            if self._identity is not None:
+                return self._identity
+
+        self._identity = RNS.Identity()
+        os.makedirs(os.path.dirname(self._identity_path), exist_ok=True)
+        _ = self._identity.to_file(self._identity_path)  # pyright: ignore[reportUnknownMemberType]
+
+        return self._identity
+
+    async def connect(self) -> None:
+        """Connect to the server."""
+        _ = self._load_or_create_identity()
+        RNS.Transport.request_path(self._destination_hash)  # pyright: ignore[reportUnknownMemberType]
+        if not RNS.Transport.has_path(self._destination_hash):  # pyright: ignore[reportUnknownMemberType]
+            if not RNS.Transport.await_path(  # pyright: ignore[reportUnknownMemberType]
+                self._destination_hash, self._connect_timeout
+            ):
+                raise TransportError("Timeout waiting for path to server")
+
+        server_identity = RNS.Identity.recall(self._destination_hash)  # pyright: ignore[reportUnknownMemberType]
+        if server_identity is None:
+            raise TransportError("Could not recall server identity")
+
+        dest = RNS.Destination(
+            server_identity,
+            RNS.Destination.OUT,
+            RNS.Destination.SINGLE,
+            "HTTP",
+            str(self._port),
+        )
+
+        connected = threading.Event()
+
+        def on_established(_link: RNS.Link) -> None:
+            nonlocal connected
+            connected.set()
+
+        self._link = RNS.Link(dest, on_established)
+        if not connected.wait(self._connect_timeout):
+            if self._link is not None:  # pyright: ignore[reportUnnecessaryComparison]
+                self._link.teardown()
+                self._link = None
+
+            raise TransportError("Connection timeout")
+
+    async def request(
+        self,
+        path: str,
+        method: str = "GET",
+        headers: dict[str, str] | None = None,
+        body: bytes | None = None,
+    ) -> HttpResponse:
+        """Send an HTTP request.
+
+        Args:
+            path: Request path
+            method: HTTP method (GET, POST, etc.)
+            headers: Additional headers
+            body: Request body
+
+        Returns:
+            HttpResponse object
+
+        Raises:
+            TransportError: If request fails
+        """
+        if self._link is None:
+            await self.connect()
+
+        if self._link is None:
+            raise TransportError("Not connected")
+
+        request = HttpRequest(
+            method=method,
+            path=path,
+            headers=headers or {},
+            body=body,
+        )
+
+        response_data = await self._send_request(bytes(request))
+        return HttpResponse.parse(response_data)
+
+    async def _send_request(self, data: bytes) -> bytes:
+        """Send request data and wait for response."""
+        if self._link is None:
+            raise TransportError("Not connected")
+
+        channel = self._link.get_channel()
+
+        response_event = threading.Event()
+        response_data: bytes | None = None
+        response_error: Exception | None = None
+
+        def on_reader_ready(ready: int) -> None:
+            nonlocal response_data, response_error, response_event, buffer
+            try:
+                response_data = buffer.read(ready)
+                response_event.set()
+
+            except Exception as e:
+                response_error = e
+                response_event.set()
+
+        buffer = RNS.Buffer.create_bidirectional_buffer(1, 0, channel, on_reader_ready)
+        _ = buffer.write(data)
+        buffer.flush()
+
+        if not response_event.wait(self._request_timeout):
+            raise TransportError("Request timeout")
+
+        if response_error is not None:
+            raise TransportError(  # pyright: ignore[reportUnreachable]
+                f"Request failed: {response_error}"
+            ) from response_error
+
+        if response_data is None:
+            raise TransportError("No response received")
+
+        return response_data  # pyright: ignore[reportUnreachable]
+
+    async def get(
+        self,
+        path: str,
+        headers: dict[str, str] | None = None,
+    ) -> HttpResponse:
+        """Send GET request."""
+        return await self.request(path, "GET", headers)
+
+    async def post(
+        self,
+        path: str,
+        body: bytes | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> HttpResponse:
+        """Send POST request."""
+        return await self.request(path, "POST", headers, body)
+
+    async def put(
+        self,
+        path: str,
+        body: bytes | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> HttpResponse:
+        """Send PUT request."""
+        return await self.request(path, "PUT", headers, body)
+
+    async def delete(
+        self,
+        path: str,
+        headers: dict[str, str] | None = None,
+    ) -> HttpResponse:
+        """Send DELETE request."""
+        return await self.request(path, "DELETE", headers)
+
+    async def close(self) -> None:
+        """Close the connection."""
+        if self._link is not None:
+            self._link.teardown()
+            self._link = None
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if client is connected."""
+        return self._link is not None
+
+    async def __aenter__(self) -> "HttpClient":
+        """Async context manager entry."""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, _exc_type: Any, _exc_val: Any, _exc_tb: Any) -> None:  # pyright: ignore[reportAny, reportExplicitAny]  # noqa: ANN401
+        """Async context manager exit."""
+        await self.close()
+
+
+async def main():
+    parser = argparse.ArgumentParser(description="HTTP/1.1 client over Reticulum")
+    _ = parser.add_argument("destination", type=str, help="Server destination hash")
+    _ = parser.add_argument("port", type=int, help="Server port")
+    _ = parser.add_argument("method", type=str, default="GET", help="HTTP method")
+    _ = parser.add_argument("path", type=str, default="/", help="Request path")
+    _ = parser.add_argument("--config", type=str, help="RNS config directory")
+    _ = parser.add_argument("--identity", type=str, help="Identity file path")
+    _ = parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Enable verbose logging",
+        dest="verbose",
+    )
+    _ = parser.add_argument(
+        "-H", "--header", action="append", help="Add header (Format: Name: Value)"
+    )
+    _ = parser.add_argument("--body", type=str, help="Request body")
+    _ = parser.add_argument(
+        "-r",
+        "--response-code",
+        action="store_true",
+        help="Print the response code and exit",
+        dest="response_code",
+    )
+    args = parser.parse_args()
+
+    assert isinstance(args.config, str | None)  # pyright: ignore[reportAny]
+    config_path = args.config
+    if config_path is None:
+        config_path = os.environ.get("RNS_CONFIG_PATH", None)
+
+    assert isinstance(args.verbose, bool)  # pyright: ignore[reportAny]
+    _ = RNS.Reticulum(config_path, RNS.LOG_VERBOSE if args.verbose else RNS.LOG_WARNING)
+
+    headers: dict[str, str] = {}
+    assert isinstance(args.header, list | None)  # pyright: ignore[reportAny]
+    if args.header is not None:  # pyright: ignore[reportUnknownMemberType]
+        for header in cast(list[str], args.header):
+            if "=" in header:
+                name, value = header.split("=", 1)
+                headers[name] = value
+
+    assert isinstance(args.body, str | None)  # pyright: ignore[reportAny]
+    body = args.body.encode("utf-8") if args.body else None
+
+    assert isinstance(args.destination, str)  # pyright: ignore[reportAny]
+    assert isinstance(args.port, int)  # pyright: ignore[reportAny]
+    assert isinstance(args.identity, str | None)  # pyright: ignore[reportAny]
+    client = HttpClient(
+        destination_hash=args.destination,
+        port=args.port,
+        identity_path=args.identity,
+    )
+
+    assert isinstance(args.method, str)  # pyright: ignore[reportAny]
+    assert isinstance(args.path, str)  # pyright: ignore[reportAny]
+    try:
+        async with client:
+            response = await client.request(
+                path=args.path,
+                method=args.method.upper(),
+                headers=headers,
+                body=body,
+            )
+            assert isinstance(args.response_code, bool)  # pyright: ignore[reportAny]
+            if args.response_code:
+                print(response.status)
+
+            else:
+                _ = sys.stdout.write(
+                    f"{response.version} {response.status} {response.reason}\n"
+                )
+                for name, value in response.headers.items():
+                    _ = sys.stdout.write(f"{name}: {value}\n")
+
+                _ = sys.stdout.write("\n")
+                if response.body:
+                    _ = sys.stdout.buffer.write(response.body)
+
+                _ = sys.stdout.buffer.flush()
+
+            sys.exit(0 if response.status < 400 else 1)
+
+    except TransportError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

rnhttp/server.py

@@ -0,0 +1,312 @@
+"""HTTP/1.1 server over RNS."""
+
+import argparse
+import asyncio
+import io
+import os
+import sys
+from collections.abc import (
+    Awaitable,
+    Callable,
+)
+from typing import TypeVar
+
+import RNS
+
+from .types import (
+    HttpRequest,
+    HttpResponse,
+)
+
+HandlerType = (
+    Callable[[HttpRequest], HttpResponse]
+    | Callable[[HttpRequest], Awaitable[HttpResponse]]
+)
+
+T = TypeVar("T")
+
+
+def await_in_sync(awaitable: Awaitable[T]) -> T:
+    """Run any awaitable from synchronous code safely."""
+    try:
+        loop = asyncio.get_running_loop()
+        return loop.run_until_complete(awaitable)
+
+    except RuntimeError:
+        return asyncio.run(awaitable)  # pyright: ignore[reportUnknownVariableType, reportArgumentType]
+
+
+class HttpServer:
+    """HTTP/1.1 server using RNS for transport."""
+
+    def __init__(
+        self,
+        port: int,
+        identity_path: str | None = None,
+        request_timeout: float = 60.0,
+        read_timeout: float = 30.0,
+    ) -> None:
+        self._port: int = port
+        self._identity_path: str = identity_path or self._default_identity_path()
+        self._request_timeout: float = request_timeout
+        self._read_timeout: float = read_timeout
+        self._destination: RNS.Destination | None = None
+        self._handlers: dict[tuple[str, str], HandlerType] = {}
+        self._default_handler: HandlerType | None = None
+        self._running: bool = False
+        self._links: dict[int, tuple[RNS.Link, io.BufferedRWPair]] = {}
+
+    @staticmethod
+    def _default_identity_path() -> str:
+        """Get default identity path."""
+        home = os.path.expanduser("~")
+        return os.path.join(home, ".rnhttp", "identity")
+
+    def _load_or_create_identity(self) -> RNS.Identity:
+        """Load existing identity or create new one."""
+        if os.path.exists(self._identity_path):
+            identity = RNS.Identity.from_file(self._identity_path)  # pyright: ignore[reportUnknownMemberType]
+            if identity is not None:
+                return identity
+
+        identity = RNS.Identity()
+        os.makedirs(os.path.dirname(self._identity_path), exist_ok=True)
+        _ = identity.to_file(self._identity_path)  # pyright: ignore[reportUnknownMemberType]
+
+        return identity
+
+    def route(
+        self, path: str, method: str = "GET"
+    ) -> Callable[[HandlerType], HandlerType]:
+        """Decorator to register a handler for a path and method.
+
+        Usage:
+            @server.route("/api/data")
+            def handle_request(request: HttpRequest) -> HttpResponse:
+                return HttpResponse(status=200, body=b"OK")
+
+            @server.route("/api/data", method="POST")
+            def handle_post(request: HttpRequest) -> HttpResponse:
+                return HttpResponse(status=200, body=b"OK")
+        """
+
+        def decorator(handler: HandlerType) -> HandlerType:
+            self._handlers[(method.upper(), path)] = handler
+            return handler
+
+        return decorator
+
+    def add_handler(self, path: str, handler: HandlerType, method: str = "GET") -> None:
+        """Add a handler for a path and method."""
+        self._handlers[(method.upper(), path)] = handler
+
+    def set_default_handler(self, handler: HandlerType) -> None:
+        """Set a default handler for all requests."""
+        self._default_handler = handler
+
+    async def start(self) -> None:
+        """Start the HTTP server."""
+        identity = self._load_or_create_identity()
+
+        self._destination = RNS.Destination(
+            identity,
+            RNS.Destination.IN,
+            RNS.Destination.SINGLE,
+            "HTTP",
+            str(self._port),
+        )
+
+        self._running = True
+        _ = self._destination.accepts_links(True)  # pyright: ignore[reportUnknownMemberType]
+        self._destination.set_link_established_callback(self._on_link)  # pyright: ignore[reportUnknownMemberType]
+        _ = self._destination.announce()  # pyright: ignore[reportUnknownMemberType]
+
+    async def stop(self) -> None:
+        """Stop the HTTP server."""
+        self._running = False
+        for link, _ in list(self._links.values()):
+            link.teardown()
+
+        self._links.clear()
+        if self._destination is not None:
+            _ = self._destination.accepts_links(False)  # pyright: ignore[reportUnknownMemberType]
+
+    def _on_link(self, link: RNS.Link) -> None:
+        """Handle incoming link."""
+        if not self._running:
+            link.teardown()
+            return
+
+        print(f"Connected: {link}")
+
+        def _on_reader_ready(ready: int) -> None:
+            """Handle incoming data on reader."""
+            nonlocal link
+            print(f"Reader ready {link}: {ready}")
+            _, buffer = self._links.get(id(link), (None, None))
+            if buffer is None:
+                return
+
+            request: HttpRequest | Awaitable[HttpRequest] | None = None
+            response: HttpResponse | Awaitable[HttpResponse] | None = None
+            try:
+                request = HttpRequest.parse(buffer.read(ready))
+
+            except Exception as e:
+                response = HttpResponse(
+                    status=400,
+                    body=str(e).encode("utf-8"),
+                )
+
+            if response is None:
+                assert request is not None
+                try:
+                    response = self._handle_request(link, request)
+
+                except Exception as e:
+                    response = HttpResponse(
+                        status=500,
+                        body=str(e).encode("utf-8"),
+                    )
+
+            await_in_sync(self._send_response(buffer, response))
+
+        link.set_link_closed_callback(self._on_close)  # pyright: ignore[reportUnknownMemberType]
+        channel = link.get_channel()
+        buffer = RNS.Buffer.create_bidirectional_buffer(0, 1, channel, _on_reader_ready)
+        self._links[id(link)] = (link, buffer)
+
+    async def _send_response(
+        self,
+        writer: io.BufferedRWPair,
+        response: HttpResponse | Awaitable[HttpResponse],
+    ) -> None:
+        """Send response back on the link."""
+        if isinstance(response, Awaitable):
+            response = await response
+
+        try:
+            _ = writer.write(bytes(response))
+            writer.flush()
+
+        except Exception:  # TODO narrow this to actual exception
+            link_id = None
+            for lid, (_, buffer) in self._links.items():
+                if buffer is writer:
+                    link_id = lid
+                    break
+
+            if link_id is not None:
+                link, _ = self._links.pop(link_id, (None, None))
+                if link is not None:
+                    link.teardown()
+
+    def _on_close(self, link: RNS.Link) -> None:
+        """Handle link close."""
+        _ = self._links.pop(id(link), None)
+
+    def _handle_request(
+        self, link: RNS.Link, request: HttpRequest
+    ) -> HttpResponse | Awaitable[HttpResponse]:
+        """Handle incoming HTTP request."""
+        path = request.path
+        method = request.method.upper()
+        print(f"{link} {method} {path}")
+
+        key = (method, path)
+        if key in self._handlers:
+            return self._handlers[key](request)
+
+        for (_, p), handler in self._handlers.items():
+            if self._match_pattern(p, path):
+                return handler(request)
+
+        if self._default_handler:
+            return self._default_handler(request)
+
+        return HttpResponse(
+            status=404,
+            reason="Not Found",
+            body=b"Not Found",
+        )
+
+    def _match_pattern(self, pattern: str, path: str) -> bool:
+        """Simple pattern matching for routes."""
+        if pattern.endswith("*"):
+            return path.startswith(pattern[:-1])
+        return path == pattern
+
+    @property
+    def port(self) -> int:
+        """Get the server port."""
+        return self._port
+
+    @property
+    def destination_hash(self) -> str | None:
+        """Get the server destination hash as hex string."""
+        if self._destination is None:
+            return None
+
+        assert isinstance(self._destination.hexhash, str | None)  # pyright: ignore[reportAny]
+        return self._destination.hexhash
+
+    @property
+    def is_running(self) -> bool:
+        """Check if server is running."""
+        return self._running
+
+
+async def main():
+    parser = argparse.ArgumentParser(description="HTTP/1.1 server over Reticulum")
+    _ = parser.add_argument("port", type=int, help="Port number")
+    _ = parser.add_argument("--config", type=str, help="RNS config directory")
+    _ = parser.add_argument("--identity", type=str, help="Identity file path")
+    _ = parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Enable verbose logging",
+        dest="verbose",
+    )
+    args = parser.parse_args()
+
+    assert isinstance(args.config, str | None)  # pyright: ignore[reportAny]
+    config_path = args.config
+    if config_path is None:
+        config_path = os.environ.get("RNS_CONFIG_PATH", None)
+
+    assert isinstance(args.verbose, bool)  # pyright: ignore[reportAny]
+    _ = RNS.Reticulum(config_path, RNS.LOG_VERBOSE if args.verbose else RNS.LOG_WARNING)
+
+    assert isinstance(args.identity, str | None)  # pyright: ignore[reportAny]
+    assert isinstance(args.port, int)  # pyright: ignore[reportAny]
+    server = HttpServer(
+        port=args.port,
+        identity_path=args.identity,
+    )
+
+    def default_handler(_request: HttpRequest) -> HttpResponse:
+        return HttpResponse(
+            status=200,
+            body=b"Hello world!",
+        )
+
+    server.set_default_handler(default_handler)
+
+    await server.start()
+    print(f"Server listening on HTTP.{server.port}", file=sys.stderr, flush=True)
+    print(f"Destination hash: {server.destination_hash}", file=sys.stderr, flush=True)
+
+    try:
+        while server.is_running:
+            await asyncio.sleep(1)
+
+    except KeyboardInterrupt:
+        pass
+
+    finally:
+        await server.stop()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

rnhttp/types.py

@@ -0,0 +1,336 @@
+"""HTTP/1.1 protocol parser and serializer.
+
+Based on RFC 9112 - HTTP/1.1 Message Syntax and Routing (June 2022)
+Uses httptools for parsing."""
+
+from typing import final
+
+from httptools import (
+    HttpParserError as HttptoolsParserError,
+)
+from httptools import (
+    HttpRequestParser,
+    HttpResponseParser,
+)
+
+from ._compat import override
+
+
+class HttpParserError(Exception):
+    """Exception raised for HTTP parsing errors."""
+
+    pass
+
+
+class HttpSerializerError(Exception):
+    """Exception raised for HTTP serialization errors."""
+
+    pass
+
+
+class RequestCallbacks:
+    """Callback handler for request parsing."""
+
+    def __init__(self) -> None:
+        self.method: bytes = b""
+        self.url: bytes = b""
+        self.version: bytes = b"HTTP/1.1"
+        self.headers: dict[bytes, bytes] = {}
+        self.body_chunks: list[bytes] = []
+
+    def on_message_begin(self) -> None:
+        pass
+
+    def on_method(self, method: bytes) -> None:
+        self.method = method
+
+    def on_url(self, url: bytes) -> None:
+        self.url = url
+
+    def on_version(self, version: bytes) -> None:
+        self.version = version
+
+    def on_header(self, name: bytes, value: bytes) -> None:
+        self.headers[name] = value
+
+    def on_body(self, body: bytes) -> None:
+        self.body_chunks.append(body)
+
+
+class ResponseCallbacks:
+    """Callback handler for response parsing."""
+
+    def __init__(self) -> None:
+        self.version: bytes = b"HTTP/1.1"
+        self.status: int = 0
+        self.reason: bytes = b""
+        self.headers: dict[bytes, bytes] = {}
+        self.body_chunks: list[bytes] = []
+
+    def on_message_begin(self) -> None:
+        pass
+
+    def on_version(self, version: bytes) -> None:
+        self.version = version
+
+    def on_status_code(self, status_code: bytes) -> None:
+        self.status = int(status_code)
+
+    def on_reason_phrase(self, reason: bytes) -> None:
+        self.reason = reason
+
+    def on_header(self, name: bytes, value: bytes) -> None:
+        self.headers[name] = value
+
+    def on_body(self, body: bytes) -> None:
+        self.body_chunks.append(body)
+
+
+def encode_chunked(body: bytes) -> bytes:
+    """Encode body using chunked transfer encoding.
+
+    Args:
+        body: Body bytes to encode
+
+    Returns:
+        Chunked encoded body bytes
+    """
+    offset = 0
+    data: bytes = b""
+    while offset < len(body):
+        chunk = body[offset : offset + 4096]
+        data += f"{len(chunk):x}".encode() + b"\r\n" + chunk + b"\r\n"
+        offset += len(chunk)
+
+    return data + b"0" + b"\r\n\r\n"
+
+
+@final
+class HttpRequest:
+    """Represents an HTTP/1.1 request."""
+
+    __slots__ = ("method", "path", "version", "headers", "body")
+
+    def __init__(
+        self,
+        method: str,
+        path: str,
+        version: str = "HTTP/1.1",
+        headers: dict[str, str] | None = None,
+        body: bytes | None = None,
+    ) -> None:
+        self.method = method
+        self.path = path
+        self.version = version
+        self.headers = headers if headers is not None else {}
+        self.body = body
+
+    @staticmethod
+    def parse(data: bytes) -> "HttpRequest":
+        if not data:
+            raise HttpParserError("Incomplete request")
+
+        callbacks = RequestCallbacks()
+        parser = HttpRequestParser(callbacks)
+
+        try:
+            parser.feed_data(data)  # pyright: ignore[reportUnknownMemberType]
+
+        except HttptoolsParserError as e:
+            raise HttpParserError(str(e)) from e
+
+        method = parser.get_method()
+        if not method:
+            raise HttpParserError("Incomplete request")
+
+        version = parser.get_http_version()
+
+        return HttpRequest(
+            method=method.decode("utf-8"),
+            path=callbacks.url.decode("utf-8") if callbacks.url else "/",
+            version=f"HTTP/{version}" if version else "HTTP/1.1",
+            headers={
+                k.decode("utf-8").lower(): v.decode("utf-8")
+                for k, v in callbacks.headers.items()
+            },
+            body=b"".join(callbacks.body_chunks) if callbacks.body_chunks else None,
+        )
+
+    @override
+    def __repr__(self) -> str:
+        body_len = len(self.body) if self.body else 0
+        return (
+            f"HttpRequest(method={self.method!r}, path={self.path!r}, "
+            f"version={self.version!r}, body_len={body_len})"
+        )
+
+    @override
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, HttpRequest):
+            return NotImplemented
+        return (
+            self.method == other.method
+            and self.path == other.path
+            and self.version == other.version
+            and self.headers == other.headers
+            and self.body == other.body
+        )
+
+    def __bytes__(self) -> bytes:
+        status_line = (f"{self.method} {self.path} {self.version}").encode() + b"\r\n"
+
+        headers = dict(self.headers)
+        body = self.body
+        if body is not None:
+            if headers.get("Transfer-Encoding", "").lower() == "chunked":
+                body = encode_chunked(body)
+                headers["Transfer-Encoding"] = "chunked"
+                _ = headers.pop("Content-Length", None)
+
+            elif "Content-Length" not in headers:
+                headers["Content-Length"] = str(len(body))
+
+        header_bytes = (
+            b"\r\n".join([f"{k}: {v}".encode() for k, v in headers.items()])
+            + b"\r\n"
+            + b"\r\n"
+        )
+        if body is None:
+            return status_line + header_bytes
+
+        return status_line + header_bytes + body
+
+
+def reason_text(status: int) -> str:
+    """Return default reason phrase for status code."""
+    reasons = {
+        100: "Continue",
+        101: "Switching Protocols",
+        200: "OK",
+        201: "Created",
+        202: "Accepted",
+        204: "No Content",
+        301: "Moved Permanently",
+        302: "Found",
+        304: "Not Modified",
+        400: "Bad Request",
+        401: "Unauthorized",
+        403: "Forbidden",
+        404: "Not Found",
+        405: "Method Not Allowed",
+        408: "Request Timeout",
+        409: "Conflict",
+        413: "Payload Too Large",
+        414: "URI Too Long",
+        500: "Internal Server Error",
+        501: "Not Implemented",
+        502: "Bad Gateway",
+        503: "Service Unavailable",
+        504: "Gateway Timeout",
+    }
+    return reasons.get(status, "Unknown")
+
+
+@final
+class HttpResponse:
+    """Represents an HTTP/1.1 response."""
+
+    __slots__ = ("version", "status", "reason", "headers", "body")
+
+    def __init__(
+        self,
+        status: int,
+        reason: str | None = None,
+        version: str = "HTTP/1.1",
+        headers: dict[str, str] | None = None,
+        body: bytes | None = None,
+    ) -> None:
+        self.version = version
+        self.status = status
+        self.reason = reason if reason is not None else reason_text(status)
+        self.headers = headers if headers is not None else {}
+        self.body = body
+
+    @staticmethod
+    def parse(data: bytes) -> "HttpResponse":
+        """Parse an HTTP/1.1 response from raw bytes.
+
+        Args:
+            data: Raw HTTP response bytes
+
+        Returns:
+            HttpResponse object
+
+        Raises:
+            HttpParserError: If response is malformed
+        """
+        if not data:
+            raise HttpParserError("Incomplete response")
+
+        callbacks = ResponseCallbacks()
+        parser = HttpResponseParser(callbacks)
+
+        try:
+            parser.feed_data(data)  # pyright: ignore[reportUnknownMemberType]
+
+        except HttptoolsParserError as e:
+            raise HttpParserError(str(e)) from e
+
+        status = parser.get_status_code()
+        if not status:
+            raise HttpParserError("Incomplete response")
+
+        version = parser.get_http_version()
+        return HttpResponse(
+            version=f"HTTP/{version}" if version else "HTTP/1.1",
+            status=status,
+            reason=callbacks.reason.decode("utf-8") if callbacks.reason else None,
+            headers={
+                k.decode("utf-8").lower(): v.decode("utf-8")
+                for k, v in callbacks.headers.items()
+            },
+            body=b"".join(callbacks.body_chunks) if callbacks.body_chunks else None,
+        )
+
+    @override
+    def __repr__(self) -> str:
+        body_len = len(self.body) if self.body else 0
+        return (
+            f"HttpResponse(status={self.status}, reason={self.reason!r}, "
+            f"version={self.version!r}, body_len={body_len})"
+        )
+
+    @override
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, HttpResponse):
+            return NotImplemented
+        return (
+            self.version == other.version
+            and self.status == other.status
+            and self.reason == other.reason
+            and self.headers == other.headers
+            and self.body == other.body
+        )
+
+    def __bytes__(self) -> bytes:
+        status_line = (f"{self.version} {self.status} {self.reason}").encode() + b"\r\n"
+        headers = dict(self.headers)
+        body = self.body
+        if body is not None:
+            if headers.get("Transfer-Encoding", "").lower() == "chunked":
+                body = encode_chunked(body)
+                headers["Transfer-Encoding"] = "chunked"
+                _ = headers.pop("Content-Length", None)
+
+            elif "Content-Length" not in headers:
+                headers["Content-Length"] = str(len(body))
+
+        header_bytes = (
+            b"\r\n".join([f"{k}: {v}".encode() for k, v in headers.items()])
+            + b"\r\n"
+            + b"\r\n"
+        )
+        if body is None:
+            return status_line + header_bytes
+
+        return status_line + header_bytes + body

rnhttp-0.0.1.dist-info/METADATA

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: rnhttp
+Version: 0.0.1
+Summary: HTTP/1.1 over Reticulum Network Stack
+Author-email: Eeems <eeems@eeems.email>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rns>=1.1.0
+Requires-Dist: httptools>=0.7.1
+Requires-Dist: overrides==7.7.0; python_version < "3.12"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: basedpyright; extra == "dev"
+Requires-Dist: vulture; extra == "dev"
+Requires-Dist: dodgy; extra == "dev"
+Requires-Dist: pyroma; extra == "dev"
+Dynamic: license-file
+
+rnhttp
+======
+
+Library for HTTP/1.1 over Reticulum. It provides both a server and client library as well as an example server. You can run `python -m rnhttp.client` to make web requests against an arbirary server. The servers have a concept of the port they are hosting on as well. This will allow building applications over RNS that use the HTTP stack without having to build any sort of netowrk proxying.

rnhttp-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+rnhttp/__init__.py,sha256=OkVTVa6Gzss84w1oMytfQrKpK3e_76XWsyg0MpLCzT0,338
+rnhttp/__whitelist.py,sha256=2cIzViibk4ixv9IX-qqz8rp-GOkvG4YICS18ZTuiZ50,1093
+rnhttp/_compat.py,sha256=8wBuTnFCiW0hj9tEZHds3Dcv33DRwQX5uaGIRkIaJv4,708
+rnhttp/client.py,sha256=SWAvaqcoQl5BWq-CuVTtZLyC1w77dpNDE7OPd-emHUU,10914
+rnhttp/server.py,sha256=LwrnW_YqgFlb4RdqcQNDjAsUsJZpGKB7ytKoKzSbYnA,10106
+rnhttp/types.py,sha256=zsnf0OKiHFZjCbd8hfHoPcIc4T7Fm6jJFlVu9tLAaDI,9758
+rnhttp-0.0.1.dist-info/licenses/LICENSE,sha256=KYPeRZiMx0-RtlpktedIUotMEOaCVwCrDyMjoltMR0A,1085
+rnhttp-0.0.1.dist-info/METADATA,sha256=bHTlrYbv3bYZ8RZCWuoZNC0VD7r8gcxrThxbLrXXmHA,1583
+rnhttp-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+rnhttp-0.0.1.dist-info/top_level.txt,sha256=iHiIPAxfH20gf73yOIEly96aecVVFFNXOYAgKwNEPR4,7
+rnhttp-0.0.1.dist-info/RECORD,,

rnhttp-0.0.1.dist-info/WHEEL

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

rnhttp-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nathaniel "Eeems" van Diepen
+
+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.

rnhttp-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+rnhttp