hypern 0.3.11__tar.gz → 0.3.13__tar.gz

{hypern-0.3.11 → hypern-0.3.13}/.github/workflows/security-scan.yml

@@ -21,6 +21,7 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           pip install poetry poetry-plugin-export
+          poetry lock
           poetry export --without-hashes --format=requirements.txt > requirements.txt
           
       - name: Install dependencies

{hypern-0.3.11 → hypern-0.3.13}/Cargo.lock

@@ -985,7 +985,7 @@ dependencies = [
 
 [[package]]
 name = "hypern"
-version = "0.3.11"
+version = "0.3.13"
 dependencies = [
  "bytes",
  "chrono",

{hypern-0.3.11 → hypern-0.3.13}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hypern"
-version = "0.3.11"
+version = "0.3.13"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

{hypern-0.3.11 → hypern-0.3.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypern
-Version: 0.3.11
+Version: 0.3.13
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{hypern-0.3.11 → hypern-0.3.13}/hypern/__init__.py

@@ -5,6 +5,9 @@ from hypern.ws import WebsocketRoute, WebSocketSession
 from .application import Hypern
 from .hypern import Request, Response
 from .response import FileResponse, HTMLResponse, JSONResponse, PlainTextResponse, RedirectResponse
+from .hypern import BackgroundTask
+from .hypern import BackgroundTasks
+from .hypern import Scheduler
 
 __all__ = [
     "Hypern",
@@ -21,4 +24,7 @@ __all__ = [
     "PlainTextResponse",
     "RedirectResponse",
     "logger",
+    "BackgroundTask",
+    "BackgroundTasks",
+    "Scheduler",
 ]

{hypern-0.3.11 → hypern-0.3.13}/hypern/application.py

@@ -10,8 +10,9 @@ import psutil
 from typing_extensions import Annotated, Doc
 
 from hypern.args_parser import ArgsConfig
-from hypern.datastructures import Contact, HTTPMethod, Info, License
-from hypern.hypern import DatabaseConfig, FunctionInfo, MiddlewareConfig, Router, Server, WebsocketRouter
+from hypern.datastructures import Contact, Info, License
+from hypern.enum import HTTPMethod
+from hypern.hypern import DatabaseConfig, FunctionInfo, MiddlewareConfig, Router, Server, WebsocketRouter, Scheduler
 from hypern.hypern import Route as InternalRoute
 from hypern.logging import logger
 from hypern.middleware import Middleware
@@ -19,7 +20,6 @@ from hypern.openapi import SchemaGenerator, SwaggerUI
 from hypern.processpool import run_processes
 from hypern.response import HTMLResponse, JSONResponse
 from hypern.routing import Route
-from hypern.scheduler import Scheduler
 from hypern.ws import WebsocketRoute
 
 AppType = TypeVar("AppType", bound="Hypern")
@@ -243,7 +243,7 @@ class Hypern:
         self.thread_config = ThreadConfigurator().get_config()
 
         for route in routes or []:
-            self.router.extend_route(route(app=self).routes)
+            self.router.extend_route(route())
 
         for websocket_route in websockets or []:
             for route in websocket_route.routes:
@@ -438,6 +438,7 @@ class Hypern:
             self.args.max_blocking_threads = self.thread_config.max_blocking_threads
 
         if self.args.http2:
+            logger.info("HTTP/2 enabled")
             server.enable_http2()
 
         run_processes(

{hypern-0.3.11 → hypern-0.3.13}/hypern/datastructures.py

@@ -1,5 +1,4 @@
 from typing import Optional
-from enum import Enum
 from pydantic import BaseModel, AnyUrl
 
 
@@ -26,15 +25,3 @@ class Info(BaseModelWithConfig):
     contact: Optional[Contact] = None
     license: Optional[License] = None
     version: str
-
-
-class HTTPMethod(Enum):
-    GET = "GET"
-    POST = "POST"
-    PUT = "PUT"
-    DELETE = "DELETE"
-    PATCH = "PATCH"
-    OPTIONS = "OPTIONS"
-    HEAD = "HEAD"
-    TRACE = "TRACE"
-    CONNECT = "CONNECT"

{hypern-0.3.11 → hypern-0.3.13}/hypern/enum.py

@@ -11,3 +11,15 @@ class ErrorCode(Enum):
     METHOD_NOT_ALLOW = "METHOD_NOT_ALLOW"
     UNAUTHORIZED = "UNAUTHORIZED"
     VALIDATION_ERROR = "VALIDATION_ERROR"
+
+
+class HTTPMethod(Enum):
+    GET = "GET"
+    POST = "POST"
+    PUT = "PUT"
+    DELETE = "DELETE"
+    PATCH = "PATCH"
+    OPTIONS = "OPTIONS"
+    HEAD = "HEAD"
+    TRACE = "TRACE"
+    CONNECT = "CONNECT"

{hypern-0.3.11 → hypern-0.3.13}/hypern/processpool.py

@@ -120,8 +120,6 @@ def initialize_event_loop(max_blocking_threads: int = 100) -> asyncio.AbstractEv
         loop = uvloop.new_event_loop()
         asyncio.set_event_loop(loop)
 
-    loop.slow_callback_duration = 0.1  # Log warnings for slow callbacks
-    loop.set_debug(False)  # Disable debug mode
     return loop
 
 

{hypern-0.3.11 → hypern-0.3.13}/hypern/response/response.py

@@ -2,12 +2,10 @@ from __future__ import annotations
 
 import typing
 from urllib.parse import quote
-from hypern.hypern import Response as InternalResponse, Header
+from hypern.hypern import Response as InternalResponse, Header, BackgroundTask, BackgroundTasks
 import orjson
 import msgpack
 
-from hypern.background import BackgroundTask, BackgroundTasks
-
 
 class BaseResponse:
     media_type = None

{hypern-0.3.11 → hypern-0.3.13}/hypern/routing/parser.py

@@ -36,7 +36,7 @@ class ParamParser:
         return {k: v[0] for k, v in query_params.items()}
 
     def _parse_path_params(self) -> dict:
-        return lambda: dict(self.request.path_params.items())
+        return dict(self.request.path_params.items())
 
     def _parse_form_data(self) -> dict:
         return self.request.json()

{hypern-0.3.11 → hypern-0.3.13}/hypern/routing/route.py

@@ -9,8 +9,10 @@ from pydantic import BaseModel
 from pydantic.fields import FieldInfo
 
 from hypern.auth.authorization import Authorization
-from hypern.datastructures import HTTPMethod
-from hypern.hypern import FunctionInfo, Request, Router
+
+from hypern.enum import HTTPMethod
+from hypern.hypern import FunctionInfo, Request
+
 from hypern.hypern import Route as InternalRoute
 
 from .dispatcher import dispatch
@@ -20,6 +22,16 @@ def get_field_type(field):
     return field.outer_type_
 
 
+def join_url_paths(*parts):
+    first = parts[0]
+    parts = [part.strip("/") for part in parts]
+    starts_with_slash = first.startswith("/") if first else False
+    joined = "/".join(part for part in parts if part)
+    if starts_with_slash:
+        joined = "/" + joined
+    return joined
+
+
 def pydantic_to_swagger(model: type[BaseModel] | dict):
     if isinstance(model, dict):
         # Handle the case when a dict is passed instead of a Pydantic model
@@ -216,18 +228,16 @@ class Route:
         func_info = FunctionInfo(handler=handler, is_async=is_async)
         return InternalRoute(path=path, function=func_info, method=method)
 
-    def __call__(self, app, *args: Any, **kwds: Any) -> Any:
-        router = Router(self.path)
+    def __call__(self, *args: Any, **kwds: Any) -> Any:
+        routes = []
 
         # Validate handlers
         if not self.endpoint and not self.functional_handlers:
             raise ValueError(f"No handler found for route: {self.path}")
 
         # Handle functional routes
-        for route in self.functional_handlers:
-            router.add_route(route=route)
         if not self.endpoint:
-            return router
+            return self.functional_handlers
 
         # Handle class-based routes
         for name, func in self.endpoint.__dict__.items():
@@ -235,15 +245,15 @@ class Route:
                 sig = inspect.signature(func)
                 doc = self.swagger_generate(sig, func.__doc__)
                 endpoint_obj = self.endpoint()
-                route = self.make_internal_route(path="/", handler=endpoint_obj.dispatch, method=name.upper())
+                route = self.make_internal_route(path=self.path, handler=endpoint_obj.dispatch, method=name.upper())
                 route.doc = doc
-                router.add_route(route=route)
+                routes.append(route)
                 del endpoint_obj  # free up memory
-        return router
+        return routes
 
     def add_route(
         self,
-        path: str,
+        func_path: str,
         method: str,
     ) -> Callable:
         def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
@@ -251,7 +261,7 @@ class Route:
                 return await dispatch(func, request, inject)
 
             sig = inspect.signature(func)
-            route = self.make_internal_route(path=path, handler=functional_wrapper, method=method.upper())
+            route = self.make_internal_route(path=join_url_paths(self.path, func_path), handler=functional_wrapper, method=method.upper())
             route.doc = self.swagger_generate(sig, func.__doc__)
 
             self.functional_handlers.append(route)

{hypern-0.3.11 → hypern-0.3.13}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 
 [project]
 name = "hypern"
-version = "0.3.11"
+version = "0.3.13"
 description = "A Fast Async Python backend with a Rust runtime."
 authors = [{ name = "Martin Dang", email = "vannghiem848@gmail.com" }]
 requires-python = ">=3.10"
@@ -37,7 +37,7 @@ module-name = "hypern"
 
 [tool.poetry]
 name = "hypern"
-version = "0.3.11"
+version = "0.3.13"
 description = "A Fast Async Python backend with a Rust runtime."
 authors = ["Martin Dang <vannghiem848@gmail.com>"]
 

{hypern-0.3.11 → hypern-0.3.13}/src/lib.rs

@@ -11,7 +11,6 @@ mod ws;
 mod executor;
 mod middlewares;
 mod database;
-mod mem_pool;
 mod di;
 
 #[pymodule]
@@ -28,7 +27,6 @@ fn hypern(_py: Python<'_>, m: &PyModule) -> PyResult<()>  {
     m.add_class::<server::Server>()?;
     m.add_class::<router::route::Route>()?;
     m.add_class::<router::router::Router>()?;
-    m.add_class::<types::http::HttpMethod>()?;
     m.add_class::<types::function_info::FunctionInfo>()?;
     m.add_class::<types::response::PyResponse>()?;
     m.add_class::<types::header::Header>()?;

hypern-0.3.13/src/router/mod.rs

@@ -0,0 +1,3 @@
+pub mod route;
+pub mod router;
+pub mod radix;

hypern-0.3.13/src/router/radix.rs

@@ -0,0 +1,226 @@
+use crate::router::route::Route;
+use pyo3::prelude::*;
+use std::collections::HashMap;
+
+#[derive(Debug)]
+#[pyclass]
+#[derive(Clone)]
+pub struct RadixNode {
+    pub path: String,
+    pub children: HashMap<char, RadixNode>,
+    pub is_endpoint: bool,
+    pub routes: HashMap<String, Route>,
+    pub param_name: Option<String>,
+}
+
+impl Default for RadixNode {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl RadixNode {
+    pub fn new() -> Self {
+        Self {
+            path: String::new(),
+            children: HashMap::new(),
+            is_endpoint: false,
+            routes: HashMap::new(),
+            param_name: None,
+        }
+    }
+
+    fn find_common_prefix(a: &str, b: &str) -> String {
+        a.chars()
+            .zip(b.chars())
+            .take_while(|(ac, bc)| ac == bc)
+            .map(|(c, _)| c)
+            .collect()
+    }
+
+    pub fn insert(&mut self, path: &str, route: Route) {
+        let normalized_path = if path == "/" {
+            String::new()
+        } else {
+            path.trim_end_matches('/').to_string()
+        };
+
+        if normalized_path.is_empty() {
+            self.is_endpoint = true;
+            self.routes.insert(route.method.to_uppercase(), route);
+            return;
+        }
+
+        let segments: Vec<&str> = normalized_path.split('/')
+            .filter(|s| !s.is_empty())
+            .collect();
+        
+        self._insert_segments(&segments, 0, route);
+    }
+
+    fn _insert_segments(&mut self, segments: &[&str], index: usize, route: Route) {
+        if index >= segments.len() {
+            self.is_endpoint = true;
+            self.routes.insert(route.method.to_uppercase(), route);
+            return;
+        }
+
+        let segment = segments[index];
+        
+        if segment.starts_with(':') {
+            let param_name = segment[1..].to_string();
+            let param_node = self.children
+                .entry(':')
+                .or_insert_with(|| {
+                    let mut node = RadixNode::new();
+                    node.param_name = Some(param_name.clone());
+                    node
+                });
+            param_node._insert_segments(segments, index + 1, route);
+            return;
+        }
+
+        let first_char = match segment.chars().next() {
+            Some(c) => c,
+            None => return, // Empty segment, shouldn't happen due to normalization
+        };
+
+        if let Some(existing_node) = self.children.get_mut(&first_char) {
+            let common_prefix = Self::find_common_prefix(&existing_node.path, segment);
+            
+            if common_prefix == existing_node.path {
+                // Full match of existing node's path, check remaining segment
+                let remaining = &segment[common_prefix.len()..];
+                if remaining.is_empty() {
+                    // Exact match, proceed to next segment
+                    existing_node._insert_segments(segments, index + 1, route);
+                } else {
+                    // Split remaining part and insert
+                    let mut new_node = RadixNode::new();
+                    new_node.path = remaining.to_string();
+                    new_node._insert_segments(segments, index + 1, route);
+                    existing_node.children
+                        .entry(remaining.chars().next().unwrap())
+                        .or_insert(new_node);
+                }
+            } else if !common_prefix.is_empty() {
+                // Split existing node and insert new path
+                let existing_remaining = existing_node.path[common_prefix.len()..].to_string();
+                let new_remaining = segment[common_prefix.len()..].to_string();
+
+                // Create new parent node with common prefix
+                let mut new_parent = RadixNode::new();
+                new_parent.path = common_prefix;
+
+                // Modify existing node to hold remaining path
+                let mut existing_child = RadixNode::new();
+                existing_child.path = existing_remaining;
+                existing_child.children = existing_node.children.clone();
+                existing_child.is_endpoint = existing_node.is_endpoint;
+                existing_child.routes = existing_node.routes.clone();
+                existing_child.param_name = existing_node.param_name.clone();
+
+                // Create new node for the new remaining path
+                let mut new_child = RadixNode::new();
+                new_child.path = new_remaining;
+                new_child._insert_segments(segments, index + 1, route);
+
+                // Attach children to new parent
+                if let Some(c) = existing_child.path.chars().next() {
+                    new_parent.children.insert(c, existing_child);
+                }
+                if let Some(c) = new_child.path.chars().next() {
+                    new_parent.children.insert(c, new_child);
+                }
+
+                // Replace existing node with new parent
+                *existing_node = new_parent;
+            } else {
+                // No common prefix, create new sibling node
+                let mut new_node = RadixNode::new();
+                new_node.path = segment.to_string();
+                new_node._insert_segments(segments, index + 1, route);
+                self.children.insert(first_char, new_node);
+            }
+        } else {
+            // No existing node, create new
+            let mut new_node = RadixNode::new();
+            new_node.path = segment.to_string();
+            new_node._insert_segments(segments, index + 1, route);
+            self.children.insert(first_char, new_node);
+        }
+    }
+
+    pub fn find(&self, path: &str, method: &str) -> Option<(&Route, HashMap<String, String>)> {
+        let normalized_path = if path == "/" {
+            String::new()
+        } else {
+            path.trim_end_matches('/').to_string()
+        };
+
+        let mut params = HashMap::new();
+        if normalized_path.is_empty() {
+            return if self.is_endpoint {
+                self.routes.get(&method.to_uppercase()).map(|r| (r, params))
+            } else {
+                None
+            };
+        }
+
+        let segments: Vec<&str> = normalized_path.split('/')
+            .filter(|s| !s.is_empty())
+            .collect();
+
+        self._find_segments(&segments, 0, method, &mut params)
+    }
+
+    fn _find_segments<'a>(
+        &'a self,
+        segments: &[&str],
+        index: usize,
+        method: &str,
+        params: &mut HashMap<String, String>,
+    ) -> Option<(&'a Route, HashMap<String, String>)> {
+        if index >= segments.len() {
+            return if self.is_endpoint {
+                self.routes.get(&method.to_uppercase()).map(|r| (r, params.clone()))
+            } else {
+                None
+            };
+        }
+
+        let segment = segments[index];
+
+        // Check static nodes
+        if let Some(first_char) = segment.chars().next() {
+            if let Some(child) = self.children.get(&first_char) {
+                if let Some(remaining) = segment.strip_prefix(&child.path) {
+                    if remaining.is_empty() {
+                        // Full match, proceed to next segment
+                        if let Some(result) = child._find_segments(segments, index + 1, method, params) {
+                            return Some(result);
+                        }
+                    } else {
+                        // Check if remaining part matches any child
+                        if let Some(result) = child._find_segments(&[remaining], 0, method, params) {
+                            return Some(result);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Check parameter node
+        if let Some(param_node) = self.children.get(&':') {
+            if let Some(param_name) = &param_node.param_name {
+                params.insert(param_name.clone(), segment.to_string());
+                if let Some(result) = param_node._find_segments(segments, index + 1, method, params) {
+                    return Some(result);
+                }
+                params.remove(param_name);
+            }
+        }
+
+        None
+    }
+}

{hypern-0.3.11 → hypern-0.3.13}/src/router/route.rs

@@ -41,11 +41,6 @@ impl Route {
             self.path, self.method))
     }
 
-    // Check if route matches given path and method
-    pub fn matches(&self, path: &str, method: &str) -> bool {
-        self.path == path && self.method.to_uppercase() == method.to_uppercase()
-    }
-
     // Update the route path
     pub fn update_path(&mut self, new_path: &str) {
         self.path = new_path.to_string();
@@ -109,4 +104,29 @@ impl Route {
             _ => 99
         }
     }
+
+    pub fn matches(&self, path: &str, method: &str) -> bool {
+        if self.method.to_uppercase() != method.to_uppercase() {
+            return false;
+        }
+
+        let route_parts: Vec<&str> = self.path.split('/')
+            .filter(|s| !s.is_empty())
+            .collect();
+        let path_parts: Vec<&str> = path.split('/')
+            .filter(|s| !s.is_empty())
+            .collect();
+
+        if route_parts.len() != path_parts.len() {
+            return false;
+        }
+
+        for (route_part, path_part) in route_parts.iter().zip(path_parts.iter()) {
+            if !route_part.starts_with(':') && route_part != path_part {
+                return false;
+            }
+        }
+
+        true
+    }
 }