nyxa-speedups 0.1.1b0__tar.gz

nyxa_speedups-0.1.1b0/Cargo.lock

@@ -0,0 +1,132 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "libc"
+version = "0.2.190"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78"
+
+[[package]]
+name = "nyxa-speedups"
+version = "0.1.0"
+dependencies = [
+ "pyo3",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.29.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "700d18fa267b73b9b521fd7e13580e2f446916f176cacee1ab63fcc8191f1655"
+dependencies = [
+ "libc",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.29.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b3fc0c4d08f6bb10e71fe39dfb9e2f59c6eb6854e22ec8092f50c69a4499adb"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.29.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfc0b8e19df29aad7086cf977bb0c2a2f143e30567eb113e9cf72b62ca698330"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.29.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6100e8a4b5eba53afaa5ed078364851a0b2499c553a44c31026b929049b49dc6"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.29.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6143877a16e82b5a727b7127ff4cd86858a24a28d745d72f43e6f227c7b1bdb3"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"

nyxa_speedups-0.1.1b0/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "nyxa-speedups"
+version = "0.1.0"
+edition = "2021"
+description = "Optional native accelerators for the Nyxa framework"
+license = "MIT"
+publish = false
+
+[lib]
+name = "nyxa_speedups"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = { version = "0.29", features = ["extension-module", "abi3-py313"] }
+
+[profile.release]
+lto = "fat"
+codegen-units = 1
+opt-level = 3

nyxa_speedups-0.1.1b0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: nyxa-speedups
+Version: 0.1.1b0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Summary: Optional native accelerators for the Nyxa framework (install via nyxa[speed])
+Author-email: Al-Amin Islam Nerob <alamin@aincoder.com>
+License: MIT
+Requires-Python: >=3.13

nyxa_speedups-0.1.1b0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["maturin>=1.5,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "nyxa-speedups"
+version = "0.1.1-beta"
+description = "Optional native accelerators for the Nyxa framework (install via nyxa[speed])"
+authors = [{ name = "Al-Amin Islam Nerob", email = "alamin@aincoder.com" }]
+license = { text = "MIT" }
+requires-python = ">=3.13"
+classifiers = ["Programming Language :: Rust", "Programming Language :: Python :: Implementation :: CPython"]
+
+[tool.maturin]
+module-name = "nyxa_speedups"
+
+# Rebuild in the parent project's env when the Rust sources change
+[tool.uv]
+cache-keys = [{ file = "pyproject.toml" }, { file = "Cargo.toml" }, { file = "src/**/*.rs" }]

nyxa_speedups-0.1.1b0/src/lib.rs

@@ -0,0 +1,342 @@
+//! Native accelerators for Nyxa's request path (`nyxa[speed]`).
+//!
+//! Pure data work only. Every function mirrors a Python reference in
+//! `nyxa._speedups`; inputs outside the fast path return `None` so the caller
+//! falls back to Python, keeping results identical.
+
+use std::borrow::Cow;
+use std::collections::HashMap;
+
+use pyo3::prelude::*;
+use pyo3::types::{PyBytes, PyDict, PyList, PyString};
+
+// -- path matcher ----------------------------------------------------------------
+
+struct Edge {
+    name: Py<PyString>,
+    pattern: Option<Py<PyAny>>,
+    child: usize,
+}
+
+#[derive(Default)]
+struct Node {
+    statics: HashMap<String, usize>,
+    params: Vec<Edge>,
+    wildcard: Option<usize>,
+    handlers: Vec<(Vec<String>, Py<PyAny>)>,
+}
+
+/// Mirror of `nyxa.routing.tree.RouteTree` built node by node from Python.
+///
+/// `find` returns the same route and params as the Python walk: static edge,
+/// then param edges in order (constraints call the compiled Python pattern),
+/// then the wildcard; at a terminal node the first handler serving the
+/// method wins (`HEAD` falls back to `GET`).
+#[pyclass(module = "nyxa_speedups", frozen)]
+struct Matcher {
+    nodes: std::sync::RwLock<Vec<Node>>,
+    wildcard: Py<PyString>,
+}
+
+fn accepts(methods: &[String], method: &str) -> bool {
+    methods.iter().any(|m| m == method) || (method == "HEAD" && methods.iter().any(|m| m == "GET"))
+}
+
+struct Search<'n, 'p> {
+    nodes: &'n [Node],
+    segs: Vec<&'p str>,
+    method: &'p str,
+    caps: Vec<(usize, usize, &'p str)>,
+    wildcard: Option<String>,
+}
+
+impl Search<'_, '_> {
+    /// `(node, handler index)` of the first route serving the method below `node`.
+    fn find(&mut self, py: Python<'_>, node: usize, i: usize) -> PyResult<Option<(usize, usize)>> {
+        let nodes = self.nodes;
+        let n = &nodes[node];
+        if i == self.segs.len() {
+            let method = self.method;
+            return Ok(n
+                .handlers
+                .iter()
+                .position(|(methods, _)| accepts(methods, method))
+                .map(|k| (node, k)));
+        }
+        let seg = self.segs[i];
+        if let Some(&child) = n.statics.get(seg) {
+            if let Some(hit) = self.find(py, child, i + 1)? {
+                return Ok(Some(hit));
+            }
+        }
+        for (k, edge) in n.params.iter().enumerate() {
+            let ok = match &edge.pattern {
+                None => true,
+                Some(p) => !p.bind(py).call_method1("fullmatch", (seg,))?.is_none(),
+            };
+            if ok {
+                self.caps.push((node, k, seg));
+                if let Some(hit) = self.find(py, edge.child, i + 1)? {
+                    return Ok(Some(hit));
+                }
+                self.caps.pop();
+            }
+        }
+        if let Some(child) = n.wildcard {
+            let len = self.segs.len();
+            if let Some(hit) = self.find(py, child, len)? {
+                self.wildcard = Some(self.segs[i..].join("/"));
+                return Ok(Some(hit));
+            }
+        }
+        Ok(None)
+    }
+}
+
+#[pymethods]
+impl Matcher {
+    #[new]
+    fn new(py: Python<'_>) -> Self {
+        Self {
+            nodes: std::sync::RwLock::new(vec![Node::default()]),
+            wildcard: PyString::intern(py, "wildcard").unbind(),
+        }
+    }
+
+    /// Create an empty node; returns its id (the root is 0).
+    fn add_node(&self) -> usize {
+        let mut nodes = self.nodes.write().unwrap();
+        nodes.push(Node::default());
+        nodes.len() - 1
+    }
+
+    fn add_static(&self, parent: usize, segment: String, child: usize) {
+        self.nodes.write().unwrap()[parent]
+            .statics
+            .insert(segment, child);
+    }
+
+    /// Param edge; `pattern` is a compiled Python regex (``fullmatch``) or ``None``.
+    #[pyo3(signature = (parent, name, pattern, child))]
+    fn add_param(
+        &self,
+        parent: usize,
+        name: Py<PyString>,
+        pattern: Option<Py<PyAny>>,
+        child: usize,
+    ) {
+        self.nodes.write().unwrap()[parent].params.push(Edge {
+            name,
+            pattern,
+            child,
+        });
+    }
+
+    fn set_wildcard(&self, parent: usize, child: usize) {
+        self.nodes.write().unwrap()[parent].wildcard = Some(child);
+    }
+
+    /// Append a terminal handler (walk order) serving `methods`.
+    fn add_handler(&self, node: usize, methods: Vec<String>, route: Py<PyAny>) {
+        self.nodes.write().unwrap()[node]
+            .handlers
+            .push((methods, route));
+    }
+
+    /// ``(route, params)`` for the first route serving ``method``, else ``None``.
+    fn find<'py>(
+        &self,
+        py: Python<'py>,
+        method: &str,
+        path: &str,
+    ) -> PyResult<Option<(Bound<'py, PyAny>, Bound<'py, PyDict>)>> {
+        let nodes = self.nodes.read().unwrap();
+        let trimmed = path.trim_matches('/');
+        let segs = if trimmed.is_empty() {
+            Vec::new()
+        } else {
+            trimmed.split('/').collect()
+        };
+        let mut search = Search {
+            nodes: &nodes,
+            segs,
+            method,
+            caps: Vec::with_capacity(4),
+            wildcard: None,
+        };
+        let Some((node, k)) = search.find(py, 0, 0)? else {
+            return Ok(None);
+        };
+        let route = nodes[node].handlers[k].1.bind(py).clone();
+        let params = PyDict::new(py);
+        for (node, k, value) in &search.caps {
+            params.set_item(nodes[*node].params[*k].name.bind(py), *value)?;
+        }
+        if let Some(joined) = search.wildcard {
+            params.set_item(self.wildcard.bind(py), joined)?;
+        }
+        Ok(Some((route, params)))
+    }
+}
+
+// -- query string ------------------------------------------------------------------
+
+fn hex(b: u8) -> Option<u8> {
+    match b {
+        b'0'..=b'9' => Some(b - b'0'),
+        b'a'..=b'f' => Some(b - b'a' + 10),
+        b'A'..=b'F' => Some(b - b'A' + 10),
+        _ => None,
+    }
+}
+
+/// `parse_qsl` unquoting (`+` → space, `%XX`); `None` when the result isn't UTF-8.
+fn unquote_plus(raw: &str) -> Option<Cow<'_, str>> {
+    if !raw.bytes().any(|b| b == b'%' || b == b'+') {
+        return Some(Cow::Borrowed(raw));
+    }
+    let bytes = raw.as_bytes();
+    let mut out = Vec::with_capacity(bytes.len());
+    let mut i = 0;
+    while i < bytes.len() {
+        let b = bytes[i];
+        if b == b'+' {
+            out.push(b' ');
+        } else if b == b'%' && i + 2 < bytes.len() {
+            if let (Some(h), Some(l)) = (hex(bytes[i + 1]), hex(bytes[i + 2])) {
+                out.push(h * 16 + l);
+                i += 3;
+                continue;
+            }
+            out.push(b);
+        } else {
+            out.push(b);
+        }
+        i += 1;
+    }
+    String::from_utf8(out).ok().map(Cow::Owned)
+}
+
+/// `dict(parse_qsl(qs, keep_blank_values=True))`, or `None` to fall back.
+#[pyfunction]
+fn parse_query<'py>(py: Python<'py>, qs: &str) -> PyResult<Option<Bound<'py, PyDict>>> {
+    let out = PyDict::new(py);
+    for piece in qs.split('&') {
+        if piece.is_empty() {
+            continue;
+        }
+        let (k, v) = piece.split_once('=').unwrap_or((piece, ""));
+        let (Some(k), Some(v)) = (unquote_plus(k), unquote_plus(v)) else {
+            return Ok(None);
+        };
+        out.set_item(k.as_ref(), v.as_ref())?;
+    }
+    Ok(Some(out))
+}
+
+// -- cookies ---------------------------------------------------------------------------
+
+fn cookie_name_char(b: u8) -> bool {
+    b.is_ascii_alphanumeric() || b"!#$%&'*+-.^_`|~:".contains(&b)
+}
+
+fn cookie_value_char(b: u8) -> bool {
+    b.is_ascii_alphanumeric() || b"!#%&'~_`><@,:/$*+-.^|)(?}{=".contains(&b)
+}
+
+const RESERVED: [&str; 9] = [
+    "expires", "path", "comment", "domain", "max-age", "secure", "httponly", "version", "samesite",
+];
+
+/// Plain `name=value; ...` cookie headers as `SimpleCookie` reads them; `None`
+/// for anything else (quotes, attributes, `$` keys, non-ASCII, stray `;`).
+#[pyfunction]
+fn parse_cookies<'py>(py: Python<'py>, header: &str) -> PyResult<Option<Bound<'py, PyDict>>> {
+    let out = PyDict::new(py);
+    let mut pieces = header.split(';').peekable();
+    while let Some(piece) = pieces.next() {
+        let piece = piece.trim_matches(|c: char| c == ' ' || c == '\t');
+        if piece.is_empty() {
+            // SimpleCookie stops at an empty segment; only a trailing one is harmless
+            if pieces.peek().is_some() {
+                return Ok(None);
+            }
+            continue;
+        }
+        let Some((name, value)) = piece.split_once('=') else {
+            return Ok(None);
+        };
+        let (name, value) = (name.trim_end(), value.trim_start());
+        if name.is_empty()
+            || name.starts_with('$')
+            || !name.bytes().all(cookie_name_char)
+            || !value.bytes().all(cookie_value_char)
+            || RESERVED.iter().any(|r| name.eq_ignore_ascii_case(r))
+        {
+            return Ok(None);
+        }
+        out.set_item(name, value)?;
+    }
+    Ok(Some(out))
+}
+
+// -- ASGI headers ------------------------------------------------------------------------
+
+/// `(x-request-id value | None, declares_body)` in one pass over ASGI request
+/// headers; `None` when an item isn't a `(bytes, value)` pair.
+#[pyfunction]
+fn scan_headers<'py>(
+    headers: &Bound<'py, PyAny>,
+) -> PyResult<Option<(Option<Bound<'py, PyAny>>, bool)>> {
+    let mut rid = None;
+    let mut declared = false;
+    for item in headers.try_iter()? {
+        let item = item?;
+        let Ok(name) = item.get_item(0) else {
+            return Ok(None);
+        };
+        let Ok(name) = name.cast::<PyBytes>() else {
+            return Ok(None);
+        };
+        let name = name.as_bytes();
+        if name == b"x-request-id" {
+            rid = Some(item.get_item(1)?);
+        } else if name == b"content-length" || name == b"transfer-encoding" {
+            declared = true;
+        }
+    }
+    Ok(Some((rid, declared)))
+}
+
+/// ASGI response header list for an all-ASCII `dict[str, str]`; `None` to fall back.
+#[pyfunction]
+fn encode_headers<'py>(
+    py: Python<'py>,
+    headers: &Bound<'py, PyDict>,
+) -> PyResult<Option<Bound<'py, PyList>>> {
+    let out = PyList::empty(py);
+    for (k, v) in headers.iter() {
+        let (Ok(k), Ok(v)) = (k.cast::<PyString>(), v.cast::<PyString>()) else {
+            return Ok(None);
+        };
+        let (k, v) = (k.to_str()?, v.to_str()?);
+        if !k.is_ascii() || !v.is_ascii() {
+            return Ok(None);
+        }
+        out.append((
+            PyBytes::new(py, k.as_bytes()),
+            PyBytes::new(py, v.as_bytes()),
+        ))?;
+    }
+    Ok(Some(out))
+}
+
+#[pymodule]
+fn nyxa_speedups(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<Matcher>()?;
+    m.add_function(wrap_pyfunction!(parse_query, m)?)?;
+    m.add_function(wrap_pyfunction!(parse_cookies, m)?)?;
+    m.add_function(wrap_pyfunction!(scan_headers, m)?)?;
+    m.add_function(wrap_pyfunction!(encode_headers, m)?)?;
+    Ok(())
+}