orbit-web-framework 1.0.2__py3-none-any.whl

orbit/core/response.py

@@ -0,0 +1,264 @@
+"""
+Response Builder
+Manual HTTP response construction
+"""
+
+import json
+from typing import Dict, Optional, Union, Iterator
+from datetime import datetime
+
+
+class Response:
+    """
+    HTTP Response builder
+    """
+    
+    # Common status codes
+    STATUS_CODES = {
+        200: 'OK',
+        201: 'Created',
+        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',
+        429: 'Too Many Requests',
+        500: 'Internal Server Error',
+        501: 'Not Implemented',
+        503: 'Service Unavailable'
+    }
+    
+    def __init__(self, body: Union[str, bytes, dict] = '', 
+                 status: int = 200,
+                 headers: Optional[Dict[str, str]] = None,
+                 content_type: str = 'text/html; charset=utf-8'):
+        """
+        Initialize Response
+        
+        Args:
+            body: Response body (str, bytes, or dict for JSON)
+            status: HTTP status code
+            headers: Response headers
+            content_type: Content-Type header
+        """
+        self.status = status
+        self.headers = headers or {}
+        self.content_type = content_type
+        self._body = body
+        
+        # Set default headers
+        if 'Content-Type' not in self.headers:
+            self.headers['Content-Type'] = content_type
+            
+        self.headers['Server'] = 'Orbit/1.0'
+        self.headers['Date'] = self._http_date()
+        
+    def _http_date(self) -> str:
+        """Generate HTTP date string"""
+        return datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT')
+    
+    def set_header(self, name: str, value: str) -> 'Response':
+        """
+        Set response header
+        
+        Args:
+            name: Header name
+            value: Header value
+            
+        Returns:
+            Self for chaining
+        """
+        # Sanitize header value
+        value = str(value).replace('\r', '').replace('\n', '')
+        self.headers[name] = value
+        return self
+    
+    def set_cookie(self, name: str, value: str, max_age: Optional[int] = None,
+                   path: str = '/', domain: Optional[str] = None,
+                   secure: bool = False, httponly: bool = True,
+                   samesite: str = 'Lax') -> 'Response':
+        """
+        Set cookie
+        
+        Args:
+            name: Cookie name
+            value: Cookie value
+            max_age: Max age in seconds
+            path: Cookie path
+            domain: Cookie domain
+            secure: Secure flag
+            httponly: HttpOnly flag
+            samesite: SameSite attribute
+            
+        Returns:
+            Self for chaining
+        """
+        cookie_parts = [f"{name}={value}"]
+        
+        if max_age is not None:
+            cookie_parts.append(f"Max-Age={max_age}")
+            
+        cookie_parts.append(f"Path={path}")
+        
+        if domain:
+            cookie_parts.append(f"Domain={domain}")
+            
+        if secure:
+            cookie_parts.append("Secure")
+            
+        if httponly:
+            cookie_parts.append("HttpOnly")
+            
+        if samesite:
+            cookie_parts.append(f"SameSite={samesite}")
+            
+        self.headers['Set-Cookie'] = '; '.join(cookie_parts)
+        return self
+    
+    def get_body_bytes(self) -> bytes:
+        """
+        Convert body to bytes
+        
+        Returns:
+            Response body as bytes
+        """
+        if isinstance(self._body, bytes):
+            return self._body
+        elif isinstance(self._body, dict):
+            return json.dumps(self._body).encode('utf-8')
+        elif isinstance(self._body, str):
+            return self._body.encode('utf-8')
+        else:
+            return str(self._body).encode('utf-8')
+    
+    def to_http(self) -> bytes:
+        """
+        Convert response to HTTP bytes
+        
+        Returns:
+            Complete HTTP response as bytes
+        """
+        # Status line
+        status_text = self.STATUS_CODES.get(self.status, 'Unknown')
+        status_line = f"HTTP/1.1 {self.status} {status_text}\r\n"
+        
+        # Get body bytes
+        body_bytes = self.get_body_bytes()
+        
+        # Set Content-Length if not already set
+        if 'Content-Length' not in self.headers:
+            self.headers['Content-Length'] = str(len(body_bytes))
+        
+        # Build headers
+        header_lines = []
+        for name, value in self.headers.items():
+            header_lines.append(f"{name}: {value}\r\n")
+        
+        # Combine all parts
+        response = status_line.encode('utf-8')
+        response += ''.join(header_lines).encode('utf-8')
+        response += b'\r\n'
+        response += body_bytes
+        
+        return response
+    
+    @staticmethod
+    def json(data: dict, status: int = 200, **kwargs) -> 'Response':
+        """
+        Create JSON response
+        
+        Args:
+            data: Data to serialize as JSON
+            status: HTTP status code
+            **kwargs: Additional response options
+            
+        Returns:
+            Response object
+        """
+        return Response(
+            body=data,
+            status=status,
+            content_type='application/json',
+            **kwargs
+        )
+    
+    @staticmethod
+    def html(html: str, status: int = 200, **kwargs) -> 'Response':
+        """
+        Create HTML response
+        
+        Args:
+            html: HTML content
+            status: HTTP status code
+            **kwargs: Additional response options
+            
+        Returns:
+            Response object
+        """
+        return Response(
+            body=html,
+            status=status,
+            content_type='text/html; charset=utf-8',
+            **kwargs
+        )
+    
+    @staticmethod
+    def text(text: str, status: int = 200, **kwargs) -> 'Response':
+        """
+        Create plain text response
+        
+        Args:
+            text: Text content
+            status: HTTP status code
+            **kwargs: Additional response options
+            
+        Returns:
+            Response object
+        """
+        return Response(
+            body=text,
+            status=status,
+            content_type='text/plain; charset=utf-8',
+            **kwargs
+        )
+    
+    @staticmethod
+    def redirect(location: str, status: int = 302) -> 'Response':
+        """
+        Create redirect response
+        
+        Args:
+            location: Redirect URL
+            status: HTTP status code (301 or 302)
+            
+        Returns:
+            Response object
+        """
+        response = Response(body='', status=status)
+        response.set_header('Location', location)
+        return response
+    
+    @staticmethod
+    def error(status: int = 500, message: str = None) -> 'Response':
+        """
+        Create error response
+        
+        Args:
+            status: HTTP status code
+            message: Error message
+            
+        Returns:
+            Response object
+        """
+        if message is None:
+            message = Response.STATUS_CODES.get(status, 'Error')
+            
+        return Response.json({
+            'error': True,
+            'status': status,
+            'message': message
+        }, status=status)

orbit/core/router.py

@@ -0,0 +1,183 @@
+"""
+Router System
+Path-tree based routing without decorators
+"""
+
+import re
+from typing import Dict, List, Callable, Optional, Tuple, Any
+
+
+class RouteNode:
+    """Node in the route tree"""
+    
+    def __init__(self):
+        self.handlers: Dict[str, Callable] = {}  # method -> handler
+        self.children: Dict[str, RouteNode] = {}  # static segments
+        self.param_child: Optional[Tuple[str, RouteNode]] = None  # (param_name, node)
+        self.wildcard: bool = False
+        
+
+class Router:
+    """
+    Path-tree based router for efficient route matching
+    """
+    
+    def __init__(self):
+        self.root = RouteNode()
+        self.routes: List[Dict[str, Any]] = []  # For debugging/listing
+        
+    def add_route(self, path: str, methods: List[str], handler: Callable,
+                  name: Optional[str] = None):
+        """
+        Add route to router
+        
+        Args:
+            path: URL path pattern (e.g., '/user/{id}/posts')
+            methods: List of HTTP methods
+            handler: Handler function
+            name: Optional route name
+        """
+        # Normalize path
+        if not path.startswith('/'):
+            path = '/' + path
+            
+        segments = [s for s in path.split('/') if s]
+        
+        # Navigate/create tree
+        node = self.root
+        param_names = []
+        
+        for segment in segments:
+            # Parameter segment
+            if segment.startswith('{') and segment.endswith('}'):
+                param_name = segment[1:-1]
+                param_names.append(param_name)
+                
+                if node.param_child is None:
+                    node.param_child = (param_name, RouteNode())
+                node = node.param_child[1]
+                
+            # Static segment
+            else:
+                if segment not in node.children:
+                    node.children[segment] = RouteNode()
+                node = node.children[segment]
+        
+        # Register handlers for each method
+        for method in methods:
+            method = method.upper()
+            if method in node.handlers:
+                raise ValueError(f"Route already registered: {method} {path}")
+            node.handlers[method] = handler
+            
+        # Store route info
+        self.routes.append({
+            'path': path,
+            'methods': methods,
+            'handler': handler,
+            'name': name,
+            'params': param_names
+        })
+    
+    def match(self, path: str, method: str) -> Optional[Tuple[Callable, Dict[str, str]]]:
+        """
+        Match path to handler
+        
+        Args:
+            path: Request path
+            method: HTTP method
+            
+        Returns:
+            Tuple of (handler, path_params) or None if no match
+        """
+        if not path.startswith('/'):
+            path = '/' + path
+            
+        segments = [s for s in path.split('/') if s]
+        
+        return self._match_recursive(self.root, segments, method, {})
+    
+    def _match_recursive(self, node: RouteNode, segments: List[str],
+                        method: str, params: Dict[str, str]) -> Optional[Tuple[Callable, Dict[str, str]]]:
+        """
+        Recursively match route segments
+        
+        Args:
+            node: Current route node
+            segments: Remaining path segments
+            method: HTTP method
+            params: Accumulated path parameters
+            
+        Returns:
+            Tuple of (handler, params) or None
+        """
+        # No more segments - check for handler
+        if not segments:
+            handler = node.handlers.get(method.upper())
+            if handler:
+                return handler, params
+            return None
+        
+        segment = segments[0]
+        remaining = segments[1:]
+        
+        # Try static match first
+        if segment in node.children:
+            result = self._match_recursive(node.children[segment], remaining, method, params)
+            if result:
+                return result
+        
+        # Try parameter match
+        if node.param_child:
+            param_name, param_node = node.param_child
+            new_params = params.copy()
+            new_params[param_name] = segment
+            result = self._match_recursive(param_node, remaining, method, new_params)
+            if result:
+                return result
+        
+        return None
+    
+    def route(self, path: str, methods: List[str] = None, name: str = None):
+        """
+        Decorator for adding routes (optional alternative to add_route)
+        
+        Args:
+            path: URL path pattern
+            methods: List of HTTP methods
+            name: Optional route name
+            
+        Returns:
+            Decorator function
+        """
+        if methods is None:
+            methods = ['GET']
+            
+        def decorator(handler: Callable) -> Callable:
+            self.add_route(path, methods, handler, name)
+            return handler
+        return decorator
+    
+    def get_routes(self) -> List[Dict[str, Any]]:
+        """Get list of all registered routes"""
+        return self.routes.copy()
+
+
+class RouterGroup:
+    """
+    Route group for organizing routes with common prefix/middleware
+    """
+    
+    def __init__(self, router: Router, prefix: str = ''):
+        self.router = router
+        self.prefix = prefix.rstrip('/')
+        
+    def add_route(self, path: str, methods: List[str], handler: Callable,
+                  name: Optional[str] = None):
+        """Add route with group prefix"""
+        full_path = self.prefix + path
+        self.router.add_route(full_path, methods, handler, name)
+        
+    def group(self, prefix: str) -> 'RouterGroup':
+        """Create sub-group"""
+        return RouterGroup(self.router, self.prefix + prefix)

orbit/http/__init__.py

@@ -0,0 +1 @@
+# HTTP module

orbit/http/parser.py

@@ -0,0 +1,176 @@
+"""
+HTTP Request Parser
+Manual HTTP/1.1 request parsing without external libraries
+"""
+
+import re
+from urllib.parse import parse_qs, unquote
+from typing import Dict, Tuple, Optional
+
+
+class HTTPParser:
+    """Parse raw HTTP requests into structured data"""
+    
+    # HTTP Method validation
+    VALID_METHODS = {'GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'}
+    
+    # Maximum sizes for security
+    MAX_REQUEST_LINE = 8192  # 8KB
+    MAX_HEADERS = 100
+    MAX_HEADER_SIZE = 8192  # 8KB per header
+    
+    @staticmethod
+    def parse_request_line(line: str) -> Tuple[str, str, str]:
+        """
+        Parse HTTP request line
+        
+        Args:
+            line: First line of HTTP request
+            
+        Returns:
+            Tuple of (method, path, version)
+            
+        Raises:
+            ValueError: If request line is malformed
+        """
+        if len(line) > HTTPParser.MAX_REQUEST_LINE:
+            raise ValueError("Request line too long")
+            
+        parts = line.strip().split(' ')
+        if len(parts) != 3:
+            raise ValueError("Malformed request line")
+            
+        method, full_path, version = parts
+        
+        # Validate HTTP method
+        if method.upper() not in HTTPParser.VALID_METHODS:
+            raise ValueError(f"Invalid HTTP method: {method}")
+            
+        # Validate HTTP version
+        if not version.startswith('HTTP/'):
+            raise ValueError(f"Invalid HTTP version: {version}")
+            
+        return method.upper(), full_path, version
+    
+    @staticmethod
+    def parse_path(full_path: str) -> Tuple[str, Dict[str, list]]:
+        """
+        Parse path and query string
+        
+        Args:
+            full_path: Full path including query string
+            
+        Returns:
+            Tuple of (path, query_params)
+        """
+        if '?' in full_path:
+            path, query_string = full_path.split('?', 1)
+            query_params = parse_qs(query_string, keep_blank_values=True)
+        else:
+            path, query_params = full_path, {}
+            
+        # Decode and normalize path
+        path = unquote(path)
+        
+        # Path traversal protection
+        if '..' in path or path.startswith('//'):
+            raise ValueError("Path traversal attempt detected")
+            
+        return path, query_params
+    
+    @staticmethod
+    def parse_headers(header_lines: list) -> Dict[str, str]:
+        """
+        Parse HTTP headers
+        
+        Args:
+            header_lines: List of header lines
+            
+        Returns:
+            Dictionary of headers (lowercase keys)
+        """
+        headers = {}
+        
+        if len(header_lines) > HTTPParser.MAX_HEADERS:
+            raise ValueError("Too many headers")
+            
+        for line in header_lines:
+            if not line.strip():
+                continue
+                
+            if len(line) > HTTPParser.MAX_HEADER_SIZE:
+                raise ValueError("Header too large")
+                
+            if ':' not in line:
+                continue
+                
+            key, value = line.split(':', 1)
+            key = key.strip().lower()
+            value = value.strip()
+            
+            # Prevent header injection
+            if '\r' in value or '\n' in value:
+                raise ValueError("Header injection attempt detected")
+                
+            headers[key] = value
+            
+        return headers
+    
+    @staticmethod
+    def parse_body(body_data: bytes, content_type: Optional[str], 
+                   content_length: int) -> Tuple[bytes, Optional[dict]]:
+        """
+        Parse request body based on content type
+        
+        Args:
+            body_data: Raw body bytes
+            content_type: Content-Type header value
+            content_length: Content-Length header value
+            
+        Returns:
+            Tuple of (raw_body, parsed_data)
+        """
+        # Size validation
+        if content_length > 10 * 1024 * 1024:  # 10MB limit
+            raise ValueError("Request body too large")
+            
+        if not content_type:
+            return body_data, None
+            
+        parsed_data = None
+        
+        # Parse JSON
+        if 'application/json' in content_type:
+            try:
+                import json
+                parsed_data = json.loads(body_data.decode('utf-8'))
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                raise ValueError("Invalid JSON body")
+                
+        # Parse form data
+        elif 'application/x-www-form-urlencoded' in content_type:
+            try:
+                form_str = body_data.decode('utf-8')
+                parsed_data = parse_qs(form_str, keep_blank_values=True)
+                # Convert single-item lists to values
+                parsed_data = {k: v[0] if len(v) == 1 else v 
+                              for k, v in parsed_data.items()}
+            except UnicodeDecodeError:
+                raise ValueError("Invalid form data")
+                
+        return body_data, parsed_data
+    
+    @staticmethod
+    def sanitize_header_value(value: str) -> str:
+        """
+        Sanitize header value to prevent injection attacks
+        
+        Args:
+            value: Header value to sanitize
+            
+        Returns:
+            Sanitized header value
+        """
+        # Remove any newline characters
+        value = value.replace('\r', '').replace('\n', '')
+        return value.strip()