django-bolt 0.2.4__tar.gz → 0.2.5__tar.gz

{django_bolt-0.2.4 → django_bolt-0.2.5}/Cargo.lock

@@ -599,7 +599,7 @@ dependencies = [
 
 [[package]]
 name = "django-bolt"
-version = "0.2.4"
+version = "0.2.5"
 dependencies = [
  "actix-cors",
  "actix-files",

{django_bolt-0.2.4 → django_bolt-0.2.5}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "django-bolt"
-version = "0.2.4"
+version = "0.2.5"
 edition = "2021"
 readme = "README.md"
 

{django_bolt-0.2.4 → django_bolt-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-bolt
-Version: 0.2.4
+Version: 0.2.5
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{django_bolt-0.2.4 → django_bolt-0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "django-bolt"
-version = "0.2.4"
+version = "0.2.5"
 description = "High-performance API framework for Django with Rust-powered endpoints delivering 60k+ RPS"
 readme = "README.md"
 requires-python = ">=3.10"

{django_bolt-0.2.4 → django_bolt-0.2.5}/python/django_bolt/management/commands/runbolt.py

@@ -22,7 +22,7 @@ class Command(BaseCommand):
             "--processes", type=int, default=1, help="Number of processes (default: 1)"
         )
         parser.add_argument(
-            "--workers", type=int, default=2, help="Workers per process (default: 2)"
+            "--workers", type=int, default=1, help="Workers per process (default: 1)"
         )
         parser.add_argument(
             "--no-admin",
@@ -34,6 +34,12 @@ class Command(BaseCommand):
             action="store_true",
             help="Enable auto-reload on file changes (development mode)"
         )
+        parser.add_argument(
+            "--backlog",
+            type=int,
+            default=1024,
+            help="Socket listen backlog size (default: 1024)"
+        )
 
     def handle(self, *args, **options):
         processes = options['processes']
@@ -246,9 +252,10 @@ class Command(BaseCommand):
         else:
             self.stdout.write(self.style.SUCCESS(f"[django-bolt] Starting server on http://{options['host']}:{options['port']}"))
             self.stdout.write(f"[django-bolt] Workers: {options['workers']}, Processes: {options['processes']}")
-        # Set environment variable for Rust to read worker count
+        # Set environment variable for Rust to read worker count and backlog
         import os
         os.environ['DJANGO_BOLT_WORKERS'] = str(options['workers'])
+        os.environ['DJANGO_BOLT_BACKLOG'] = str(options['backlog'])
 
         # Determine compression config (server-level in Actix)
         # Priority: Django setting > first API with compression config

{django_bolt-0.2.4 → django_bolt-0.2.5}/src/direct_stream.rs

@@ -20,11 +20,11 @@ impl PythonDirectStream {
     pub fn new(content: Py<PyAny>) -> Self {
         // Determine if we should collect or stream
         let collect_threshold = 8192; // 8KB threshold for SSE
-        
+
         // Resolve iterator and check if async
         let (iterator, is_async) = Python::attach(|py| {
             let obj = content.bind(py);
-            
+
             // If callable, call it to get iterator
             let target = if obj.is_callable() {
                 match obj.call0() {
@@ -34,11 +34,11 @@ impl PythonDirectStream {
             } else {
                 content.clone_ref(py)
             };
-            
+
             let bound = target.bind(py);
-            let is_async = bound.hasattr("__aiter__").unwrap_or(false) 
+            let is_async = bound.hasattr("__aiter__").unwrap_or(false)
                 || bound.hasattr("__anext__").unwrap_or(false);
-            
+
             // For sync iterators, get the iterator object
             let iter = if !is_async {
                 if bound.hasattr("__next__").unwrap_or(false) {
@@ -62,10 +62,10 @@ impl PythonDirectStream {
                     target
                 }
             };
-            
+
             (iter, is_async)
         });
-        
+
         Self {
             iterator: Some(iterator),
             is_async,
@@ -75,20 +75,20 @@ impl PythonDirectStream {
             collect_threshold,
         }
     }
-    
+
     /// Try to collect small responses for optimization
     pub fn try_collect_small(&mut self) -> Option<Bytes> {
         if self.is_async || self.exhausted {
             return None;
         }
-        
+
         let mut collected = Vec::new();
         let mut total_size = 0usize;
-        
+
         Python::attach(|py| {
             if let Some(ref iter) = self.iterator {
                 let bound = iter.bind(py);
-                
+
                 // Try to collect up to threshold
                 while total_size < self.collect_threshold {
                     match bound.call_method0("__next__") {
@@ -109,7 +109,7 @@ impl PythonDirectStream {
                 }
             }
         });
-        
+
         if self.exhausted && total_size < self.collect_threshold {
             // Small response - return all as one
             let mut result = Vec::with_capacity(total_size);
@@ -129,24 +129,24 @@ impl PythonDirectStream {
 
 impl Stream for PythonDirectStream {
     type Item = Result<Bytes, std::io::Error>;
-    
+
     fn poll_next(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         if self.exhausted && self.buffer.is_empty() {
             return Poll::Ready(None);
         }
-        
+
         // Return buffered items first
         if !self.buffer.is_empty() {
             return Poll::Ready(Some(Ok(self.buffer.remove(0))));
         }
-        
+
         if self.is_async {
             // Async iterators not supported in direct stream yet
             // This should have been handled by try_collect_small or fallback
             self.exhausted = true;
             return Poll::Ready(None);
         }
-        
+
         // Sync iterator - get next chunk directly
         let next = Python::attach(|py| {
             if let Some(ref iter) = self.iterator {
@@ -164,7 +164,7 @@ impl Stream for PythonDirectStream {
                 None
             }
         });
-        
+
         match next {
             Some(bytes) => Poll::Ready(Some(Ok(bytes))),
             None => {
@@ -174,7 +174,7 @@ impl Stream for PythonDirectStream {
                 } else {
                     Poll::Ready(Some(Err(std::io::Error::new(
                         std::io::ErrorKind::Other,
-                        "Iterator error"
+                        "Iterator error",
                     ))))
                 }
             }
@@ -188,28 +188,28 @@ fn convert_to_bytes(value: &Bound<'_, PyAny>) -> Option<Bytes> {
     if let Ok(s) = value.downcast::<PyString>() {
         return Some(Bytes::from(s.to_string_lossy().into_owned()));
     }
-    
+
     if let Ok(b) = value.downcast::<PyBytes>() {
         return Some(Bytes::copy_from_slice(b.as_bytes()));
     }
-    
+
     // Try extract string
     if let Ok(s) = value.extract::<String>() {
         return Some(Bytes::from(s));
     }
-    
+
     // Try __bytes__ method
     if let Ok(bobj) = value.call_method0("__bytes__") {
         if let Ok(b) = bobj.downcast::<PyBytes>() {
             return Some(Bytes::copy_from_slice(b.as_bytes()));
         }
     }
-    
+
     // Last resort: str()
     if let Ok(s) = value.str() {
         return Some(Bytes::from(s.to_string()));
     }
-    
+
     None
 }
 
@@ -218,9 +218,9 @@ pub fn create_sse_response(
     content: Py<PyAny>,
 ) -> Result<actix_web::HttpResponse, actix_web::Error> {
     use actix_web::HttpResponse;
-    
+
     let mut stream = PythonDirectStream::new(content);
-    
+
     // Try to collect small responses
     if let Some(body) = stream.try_collect_small() {
         // Small response - send as single body
@@ -230,11 +230,11 @@ pub fn create_sse_response(
             .append_header(("X-Accel-Buffering", "no"))
             .body(body));
     }
-    
+
     // Large response - use streaming
     Ok(HttpResponse::Ok()
         .content_type("text/event-stream")
         .append_header(("Cache-Control", "no-cache"))
         .append_header(("X-Accel-Buffering", "no"))
         .streaming(Box::pin(stream)))
-}
+}

{django_bolt-0.2.4 → django_bolt-0.2.5}/src/error.rs

@@ -1,21 +1,27 @@
-use actix_web::{HttpResponse, http::StatusCode};
+use actix_web::{http::StatusCode, HttpResponse};
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
 /// Extract error information from a Python HTTPException
-pub fn extract_http_exception(_py: Python, exc: &Bound<PyAny>) -> Option<(u16, String, Vec<(String, String)>, Option<Py<PyAny>>)> {
+pub fn extract_http_exception(
+    _py: Python,
+    exc: &Bound<PyAny>,
+) -> Option<(u16, String, Vec<(String, String)>, Option<Py<PyAny>>)> {
     // Try to extract HTTPException fields
-    let status_code: u16 = exc.getattr("status_code")
+    let status_code: u16 = exc
+        .getattr("status_code")
         .ok()
         .and_then(|v| v.extract().ok())
         .unwrap_or(500);
 
-    let detail: String = exc.getattr("detail")
+    let detail: String = exc
+        .getattr("detail")
         .ok()
         .and_then(|v| v.extract().ok())
         .unwrap_or_else(|| "Internal Server Error".to_string());
 
-    let headers: Vec<(String, String)> = exc.getattr("headers")
+    let headers: Vec<(String, String)> = exc
+        .getattr("headers")
         .ok()
         .and_then(|h| {
             if let Ok(dict) = h.downcast::<PyDict>() {
@@ -32,9 +38,10 @@ pub fn extract_http_exception(_py: Python, exc: &Bound<PyAny>) -> Option<(u16, S
         })
         .unwrap_or_else(|| Vec::new());
 
-    let extra: Option<Py<PyAny>> = exc.getattr("extra")
-        .ok()
-        .and_then(|e| if e.is_none() { None } else { Some(e.unbind()) });
+    let extra: Option<Py<PyAny>> =
+        exc.getattr("extra")
+            .ok()
+            .and_then(|e| if e.is_none() { None } else { Some(e.unbind()) });
 
     Some((status_code, detail, headers, extra))
 }
@@ -45,7 +52,8 @@ pub fn is_http_exception(py: Python, exc: &Bound<PyAny>) -> bool {
         let exceptions_module = py.import("django_bolt.exceptions")?;
         let http_exc_class = exceptions_module.getattr("HTTPException")?;
         exc.is_instance(&http_exc_class)
-    })().unwrap_or(false)
+    })()
+    .unwrap_or(false)
 }
 
 /// Check if a Python exception is a ValidationError
@@ -55,7 +63,8 @@ pub fn is_validation_error(py: Python, exc: &Bound<PyAny>) -> bool {
         let msgspec = py.import("msgspec")?;
         let val_err_class = msgspec.getattr("ValidationError")?;
         exc.is_instance(&val_err_class)
-    })().unwrap_or(false);
+    })()
+    .unwrap_or(false);
 
     if is_msgspec {
         return true;
@@ -66,7 +75,8 @@ pub fn is_validation_error(py: Python, exc: &Bound<PyAny>) -> bool {
         let exceptions_module = py.import("django_bolt.exceptions")?;
         let val_exc_class = exceptions_module.getattr("ValidationException")?;
         exc.is_instance(&val_exc_class)
-    })().unwrap_or(false)
+    })()
+    .unwrap_or(false)
 }
 
 /// Build an error response from exception information
@@ -120,7 +130,8 @@ pub fn handle_python_exception(
         let django_conf = py.import("django.conf")?;
         let settings = django_conf.getattr("settings")?;
         settings.getattr("DEBUG")?.extract::<bool>()
-    })().unwrap_or(debug);
+    })()
+    .unwrap_or(debug);
     // Check if it's an HTTPException
     if is_http_exception(py, exc) {
         if let Some((status_code, detail, headers, extra)) = extract_http_exception(py, exc) {
@@ -137,15 +148,20 @@ pub fn handle_python_exception(
             let response_tuple = handle_exception.call1((exc, debug))?;
 
             // Extract (status_code, headers, body)
-            if let Ok((status, headers, body)) = response_tuple.extract::<(u16, Vec<(String, String)>, Vec<u8>)>() {
-                let status_code = StatusCode::from_u16(status).unwrap_or(StatusCode::UNPROCESSABLE_ENTITY);
+            if let Ok((status, headers, body)) =
+                response_tuple.extract::<(u16, Vec<(String, String)>, Vec<u8>)>()
+            {
+                let status_code =
+                    StatusCode::from_u16(status).unwrap_or(StatusCode::UNPROCESSABLE_ENTITY);
                 let mut response = HttpResponse::build(status_code);
                 for (k, v) in headers {
                     response.append_header((k, v));
                 }
                 Ok(response.body(body))
             } else {
-                Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>("Invalid response format"))
+                Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
+                    "Invalid response format",
+                ))
             }
         })();
 
@@ -156,7 +172,10 @@ pub fn handle_python_exception(
 
     // Generic exception handling
     let exc_str = exc.to_string();
-    let exc_type = exc.get_type().name().ok()
+    let exc_type = exc
+        .get_type()
+        .name()
+        .ok()
         .map(|s| s.to_string())
         .unwrap_or_else(|| "Exception".to_string());
 
@@ -170,7 +189,8 @@ pub fn handle_python_exception(
             let tb = format_exception.call1((exc_type, exc, tb_attr))?;
             let tb_list: Vec<String> = tb.extract()?;
             Ok(tb_list.join(""))
-        })().unwrap_or_else(|_| "Traceback unavailable".to_string());
+        })()
+        .unwrap_or_else(|_| "Traceback unavailable".to_string());
 
         (
             format!("{}: {}", exc_type, exc_str),
@@ -181,14 +201,18 @@ pub fn handle_python_exception(
                 escape_json(&traceback),
                 escape_json(path),
                 escape_json(method),
-            ))
+            )),
         )
     } else {
         ("Internal Server Error".to_string(), None)
     };
 
     let body = if let Some(extra) = extra_info {
-        format!(r#"{{"detail":"{}","extra":{}}}"#, escape_json(&detail), extra)
+        format!(
+            r#"{{"detail":"{}","extra":{}}}"#,
+            escape_json(&detail),
+            extra
+        )
     } else {
         format!(r#"{{"detail":"{}"}}"#, escape_json(&detail))
     };

{django_bolt-0.2.4 → django_bolt-0.2.5}/src/handler.rs

@@ -53,9 +53,10 @@ fn add_cors_headers_rust(
 
             // Add exposed headers using cached HeaderValue
             if let Some(ref cached_val) = cors_config.expose_headers_header {
-                response
-                    .headers_mut()
-                    .insert(actix_web::http::header::ACCESS_CONTROL_EXPOSE_HEADERS, cached_val.clone());
+                response.headers_mut().insert(
+                    actix_web::http::header::ACCESS_CONTROL_EXPOSE_HEADERS,
+                    cached_val.clone(),
+                );
             }
             return true; // Origin allowed
         }
@@ -65,15 +66,17 @@ fn add_cors_headers_rust(
 
     // Handle allow_all_origins (wildcard) without credentials
     if cors_config.allow_all_origins {
-        response
-            .headers_mut()
-            .insert(actix_web::http::header::ACCESS_CONTROL_ALLOW_ORIGIN, HeaderValue::from_static("*"));
+        response.headers_mut().insert(
+            actix_web::http::header::ACCESS_CONTROL_ALLOW_ORIGIN,
+            HeaderValue::from_static("*"),
+        );
 
         // Add exposed headers using cached HeaderValue
         if let Some(ref cached_val) = cors_config.expose_headers_header {
-            response
-                .headers_mut()
-                .insert(actix_web::http::header::ACCESS_CONTROL_EXPOSE_HEADERS, cached_val.clone());
+            response.headers_mut().insert(
+                actix_web::http::header::ACCESS_CONTROL_EXPOSE_HEADERS,
+                cached_val.clone(),
+            );
         }
         return true; // Origin allowed (wildcard)
     }
@@ -99,10 +102,16 @@ fn add_cors_headers_rust(
 
     // Check regex match using route-level regexes, then global regexes
     let regex_match = if !cors_config.compiled_origin_regexes.is_empty() {
-        cors_config.compiled_origin_regexes.iter().any(|re| re.is_match(req_origin))
+        cors_config
+            .compiled_origin_regexes
+            .iter()
+            .any(|re| re.is_match(req_origin))
     } else {
         !state.cors_origin_regexes.is_empty()
-            && state.cors_origin_regexes.iter().any(|re| re.is_match(req_origin))
+            && state
+                .cors_origin_regexes
+                .iter()
+                .any(|re| re.is_match(req_origin))
     };
 
     // Origin not allowed
@@ -133,9 +142,10 @@ fn add_cors_headers_rust(
 
     // Add exposed headers using cached HeaderValue (zero allocations)
     if let Some(ref cached_val) = cors_config.expose_headers_header {
-        response
-            .headers_mut()
-            .insert(actix_web::http::header::ACCESS_CONTROL_EXPOSE_HEADERS, cached_val.clone());
+        response.headers_mut().insert(
+            actix_web::http::header::ACCESS_CONTROL_EXPOSE_HEADERS,
+            cached_val.clone(),
+        );
     }
 
     true // Origin allowed
@@ -145,23 +155,26 @@ fn add_cors_headers_rust(
 fn add_cors_preflight_headers(response: &mut HttpResponse, cors_config: &CorsConfig) {
     // Use cached HeaderValue for methods (zero allocations)
     if let Some(ref cached_val) = cors_config.methods_header {
-        response
-            .headers_mut()
-            .insert(actix_web::http::header::ACCESS_CONTROL_ALLOW_METHODS, cached_val.clone());
+        response.headers_mut().insert(
+            actix_web::http::header::ACCESS_CONTROL_ALLOW_METHODS,
+            cached_val.clone(),
+        );
     }
 
     // Use cached HeaderValue for headers (zero allocations)
     if let Some(ref cached_val) = cors_config.headers_header {
-        response
-            .headers_mut()
-            .insert(actix_web::http::header::ACCESS_CONTROL_ALLOW_HEADERS, cached_val.clone());
+        response.headers_mut().insert(
+            actix_web::http::header::ACCESS_CONTROL_ALLOW_HEADERS,
+            cached_val.clone(),
+        );
     }
 
     // Use cached HeaderValue for max_age (zero allocations)
     if let Some(ref cached_val) = cors_config.max_age_header {
-        response
-            .headers_mut()
-            .insert(actix_web::http::header::ACCESS_CONTROL_MAX_AGE, cached_val.clone());
+        response.headers_mut().insert(
+            actix_web::http::header::ACCESS_CONTROL_MAX_AGE,
+            cached_val.clone(),
+        );
     }
 
     // Add Vary headers for preflight requests
@@ -220,12 +233,8 @@ pub async fn handle_request(
                                     req.headers().get("origin").and_then(|v| v.to_str().ok());
 
                                 // Validate origin and add CORS headers
-                                let origin_allowed = add_cors_headers_rust(
-                                    &mut response,
-                                    origin,
-                                    cors_cfg,
-                                    &state,
-                                );
+                                let origin_allowed =
+                                    add_cors_headers_rust(&mut response, origin, cors_cfg, &state);
 
                                 // CRITICAL: Only add preflight headers if origin was validated
                                 // Per RFC 6454, preflight must validate origin before granting access
@@ -590,12 +599,7 @@ pub async fn handle_request(
                     if let Some(ref route_meta) = route_metadata {
                         if let Some(ref cors_cfg) = route_meta.cors_config {
                             let origin = req.headers().get("origin").and_then(|v| v.to_str().ok());
-                            let _ = add_cors_headers_rust(
-                                &mut response,
-                                origin,
-                                cors_cfg,
-                                &state,
-                            );
+                            let _ = add_cors_headers_rust(&mut response, origin, cors_cfg, &state);
                         }
                     }
 
@@ -719,12 +723,8 @@ pub async fn handle_request(
                             if let Some(ref cors_cfg) = route_meta.cors_config {
                                 let origin =
                                     req.headers().get("origin").and_then(|v| v.to_str().ok());
-                                let _ = add_cors_headers_rust(
-                                    &mut response,
-                                    origin,
-                                    cors_cfg,
-                                    &state,
-                                );
+                                let _ =
+                                    add_cors_headers_rust(&mut response, origin, cors_cfg, &state);
                             }
                         }
                         return response;

{django_bolt-0.2.4 → django_bolt-0.2.5}/src/json.rs

@@ -1,2 +1,2 @@
 // This module contains JSON serialization utilities that are currently unused
-// but kept for potential future optimizations
+// but kept for potential future optimizations

{django_bolt-0.2.4 → django_bolt-0.2.5}/src/metadata.rs

@@ -109,10 +109,14 @@ impl CorsConfig {
 
         // Compile origin regex patterns at startup
         config.origin_regexes = origin_regexes.clone();
-        config.compiled_origin_regexes = origin_regexes.iter()
+        config.compiled_origin_regexes = origin_regexes
+            .iter()
             .filter_map(|pattern| {
                 Regex::new(pattern).ok().or_else(|| {
-                    eprintln!("[django-bolt] Warning: Invalid route-level CORS origin regex pattern: {}", pattern);
+                    eprintln!(
+                        "[django-bolt] Warning: Invalid route-level CORS origin regex pattern: {}",
+                        pattern
+                    );
                     None
                 })
             })
@@ -331,7 +335,10 @@ fn parse_cors_config(dict: &HashMap<String, Py<PyAny>>, py: Python) -> Option<Co
 }
 
 /// Parse rate limiting configuration from middleware dict
-fn parse_rate_limit_config(dict: &HashMap<String, Py<PyAny>>, py: Python) -> Option<RateLimitConfig> {
+fn parse_rate_limit_config(
+    dict: &HashMap<String, Py<PyAny>>,
+    py: Python,
+) -> Option<RateLimitConfig> {
     let mut config = RateLimitConfig::default();
 
     // Parse rps (required)