hypern 0.3.10__tar.gz → 0.3.12__tar.gz

hypern-0.3.12/.github/workflows/release-CI.yml

@@ -0,0 +1,143 @@
+# This file is autogenerated by maturin v1.8.1
+# To update, run
+#
+#    maturin generate-ci -m Cargo.toml github
+#
+name: CI
+
+on:
+  push:
+    tags:
+      - 'v*'
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+
+  linux:
+    runs-on: "ubuntu-latest"
+    strategy:
+      matrix:
+        target: [x86_64, x86, aarch64, armv7, s390x, ppc64le]
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: -i python${{ matrix.python-version }} --release --sdist --out dist
+          sccache: 'true'
+          manylinux: auto
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-linux-${{ matrix.target }}-${{ matrix.python-version }}
+          path: dist
+
+  musllinux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64, x86, aarch64, armv7]
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: -i python${{ matrix.python-version }} --release --sdist --out dist
+          sccache: 'true'
+          manylinux: musllinux_1_2
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-musllinux-${{ matrix.target }}-${{ matrix.python-version }}
+          path: dist
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        target: [x64, x86]
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          architecture: ${{ matrix.target }}
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: -i python --release --sdist --out dist
+          sccache: 'true'
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-windows-${{ matrix.target }}-${{ matrix.python-version }}
+          path: dist
+
+  macos:
+    runs-on: ${{ matrix.platform.runner }}
+    strategy:
+      matrix:
+        platform:
+          - runner: macos-13
+            target: x86_64
+          - runner: macos-14
+            target: aarch64
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.platform.target }}
+          args: --release --out dist -i python --sdist
+          sccache: 'true'
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-macos-${{ matrix.platform.target }}-${{ matrix.python-version }}
+          path: dist
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
+    needs: [musllinux, linux, windows, macos]
+    permissions:
+      # Use to sign the release artifacts
+      id-token: write
+      # Used to upload release artifacts
+      contents: write
+      # Used to generate artifact attestation
+      attestations: write
+    steps:
+      - uses: actions/download-artifact@v4
+      - name: Generate artifact attestation
+        uses: actions/attest-build-provenance@v1
+        with:
+          subject-path: 'wheels-*/*'
+      - name: Publish to PyPI
+        if: ${{ startsWith(github.ref, 'refs/tags/') }}
+        uses: PyO3/maturin-action@v1
+        env:
+          MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_PASSWORD }}
+        with:
+          command: upload
+          args: --non-interactive --skip-existing wheels-*/*

{hypern-0.3.10 → hypern-0.3.12}/.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.10 → hypern-0.3.12}/Cargo.lock

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

{hypern-0.3.10 → hypern-0.3.12}/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "hypern"
-version = "0.3.10"
+version = "0.3.12"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
 name = "hypern"
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "staticlib"]
 
 [dependencies]
 pyo3 = { version = "0.20.0", features = ["extension-module"] }
@@ -47,3 +47,4 @@ strip = true
 
 [package.metadata.maturin]
 name = "hypern"
+python-source = "hypern"

{hypern-0.3.10 → hypern-0.3.12}/PKG-INFO

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

{hypern-0.3.10 → hypern-0.3.12}/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.10 → hypern-0.3.12}/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.10 → hypern-0.3.12}/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.10 → hypern-0.3.12}/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.10 → hypern-0.3.12}/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.10 → hypern-0.3.12}/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.10 → hypern-0.3.12}/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.10 → hypern-0.3.12}/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.10 → hypern-0.3.12}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 
 [project]
 name = "hypern"
-version = "0.3.10"
+version = "0.3.12"
 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.10"
+version = "0.3.12"
 description = "A Fast Async Python backend with a Rust runtime."
 authors = ["Martin Dang <vannghiem848@gmail.com>"]
 

{hypern-0.3.10 → hypern-0.3.12}/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.12/src/router/mod.rs

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

hypern-0.3.12/src/router/radix.rs

@@ -0,0 +1,160 @@
+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,
+        }
+    }
+
+    pub fn insert(&mut self, path: &str, route: Route) {
+        // Normalize the path first
+        let normalized_path = if path == "/" {
+            String::new()
+        } else {
+            path.trim_end_matches('/').to_string()
+        };
+
+        // For root path or empty path after normalization
+        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];
+        
+        // For parameter segments
+        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;
+        }
+
+        // For static segments
+        let first_char = segment.chars().next().unwrap();
+        let node = self.children
+            .entry(first_char)
+            .or_insert_with(|| {
+                let mut node = RadixNode::new();
+                node.path = segment.to_string();
+                node
+            });
+
+        if node.path == segment {
+            node._insert_segments(segments, index + 1, route);
+        } else {
+            // Create new node for different path
+            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];
+
+        // Try exact static match first
+        for (_, child) in self.children.iter() {
+            if child.path == segment {
+                if let Some(result) = child._find_segments(segments, index + 1, method, params) {
+                    return Some(result);
+                }
+            }
+        }
+
+        // Try parameter match
+        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.10 → hypern-0.3.12}/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
+    }
 }