bustapi 0.11.1__tar.gz → 0.12.0__tar.gz

{bustapi-0.11.1 → bustapi-0.12.0}/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented here.
 
+## [0.12.0] - 2026-04-27
+
+### Added
+- **Auto DOCS Enhancements**:
+  - **Path Merging**: Multiple HTTP methods (e.g., GET and POST) on the same path are now correctly merged in OpenAPI documentation.
+  - **Rich Schema Extraction**: Added support for `Body(..., schema={...})` and `Query(...)` parameters. OpenAPI documentation now includes property descriptions, examples, and validation constraints.
+  - **Standardized Types**: Improved mapping of internal types to standard OpenAPI types (integer, string, boolean, etc.).
+
+### Fixed
+- **Hot-Reload Stability**: Fixed an infinite restart loop in the file watcher by ignoring noisy directories (`__pycache__`, `.git`, `.venv`) and filtering by file extension.
+- **Custom Error Handlers** ([#18](https://github.com/RUSTxPY/BustAPI/issues/18)): Fixed a bug where custom 404 error handlers were ignored by the Rust backend.
+- **Response Formatting**: Fixed a bug where pre-formatted response objects returned in tuples were being incorrectly stringified.
+
 ## [0.11.1] - 2026-04-23
 
 ### Added

{bustapi-0.11.1 → bustapi-0.12.0}/Cargo.lock

@@ -438,7 +438,7 @@ checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
 
 [[package]]
 name = "bustapi_core"
-version = "0.11.1"
+version = "0.12.0"
 dependencies = [
  "actix-files",
  "actix-http",
@@ -497,9 +497,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.60"
+version = "1.2.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
+checksum = "d16d90359e986641506914ba71350897565610e87ce0ad9e6f28569db3dd5c6d"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -1124,9 +1124,9 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "hybrid-array"
-version = "0.4.10"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3944cf8cf766b40e2a1a333ee5e9b563f854d5fa49d6a8ca2764e97c6eddb214"
+checksum = "08d46837a0ed51fe95bd3b05de33cd64a1ee88fc797477ca48446872504507c5"
 dependencies = [
  "typenum",
 ]
@@ -1392,9 +1392,9 @@ checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
 
 [[package]]
 name = "libc"
-version = "0.2.185"
+version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
 [[package]]
 name = "libmimalloc-sys"

{bustapi-0.11.1 → bustapi-0.12.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bustapi_core"
-version = "0.11.1"
+version = "0.12.0"
 edition = "2021"
 readme = "README.md"
 

{bustapi-0.11.1 → bustapi-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bustapi
-Version: 0.11.1
+Version: 0.12.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{bustapi-0.11.1 → bustapi-0.12.0}/docs/changelog.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented here.
 
+## [0.12.0] - 2026-04-27
+
+### Added
+- **Auto DOCS Enhancements**:
+  - **Path Merging**: Multiple HTTP methods (e.g., GET and POST) on the same path are now correctly merged in OpenAPI documentation.
+  - **Rich Schema Extraction**: Added support for `Body(..., schema={...})` and `Query(...)` parameters. OpenAPI documentation now includes property descriptions, examples, and validation constraints.
+  - **Standardized Types**: Improved mapping of internal types to standard OpenAPI types (integer, string, boolean, etc.).
+
+### Fixed
+- **Hot-Reload Stability**: Fixed an infinite restart loop in the file watcher by ignoring noisy directories (`__pycache__`, `.git`, `.venv`) and filtering by file extension.
+- **Custom Error Handlers** ([#18](https://github.com/RUSTxPY/BustAPI/issues/18)): Fixed a bug where custom 404 error handlers were ignored by the Rust backend.
+- **Response Formatting**: Fixed a bug where pre-formatted response objects returned in tuples were being incorrectly stringified.
+
 ## [0.11.1] - 2026-04-23
 
 ### Added

{bustapi-0.11.1 → bustapi-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "bustapi"
-version = "0.11.1"
+version = "0.12.0"
 description = "High-performance Python web framework with Rust backend"
 authors = [
     {name = "GrandpaEJ", email = ""}

{bustapi-0.11.1 → bustapi-0.12.0}/python/bustapi/__init__.py

@@ -22,7 +22,7 @@ import platform
 import sys
 from http import HTTPStatus
 
-__version__ = "0.11.1"
+__version__ = "0.12.0"
 __author__ = "BustAPI"  # with GrandpaEJ
 __email__ = ""
 

{bustapi-0.11.1 → bustapi-0.12.0}/python/bustapi/app.py

@@ -166,6 +166,9 @@ class BustAPI(
         self._rust_app = None
         self._init_rust_backend()
 
+        # Register default 404 fallback
+        self._rust_app.set_not_found_handler(self._dispatch_not_found)
+
     def _init_rust_backend(self):
         """Initialize the Rust backend application."""
         try:
@@ -260,14 +263,46 @@ class BustAPI(
             if isinstance(exc_class_or_code, type) and isinstance(
                 exception, exc_class_or_code
             ):
-                return self._make_response(handler(exception))
+                rv = handler(exception)
+                return (
+                    self._make_response(*rv)
+                    if isinstance(rv, tuple)
+                    else self._make_response(rv)
+                )
             elif isinstance(exc_class_or_code, int):
                 if hasattr(exception, "code") and exception.code == exc_class_or_code:
-                    return self._make_response(handler(exception))
+                    rv = handler(exception)
+                    return (
+                        self._make_response(*rv)
+                        if isinstance(rv, tuple)
+                        else self._make_response(rv)
+                    )
 
         status = getattr(exception, "code", 500) if hasattr(exception, "code") else 500
         return Response(f"Internal Server Error: {str(exception)}", status=status)
 
+    def _dispatch_not_found(self, rust_request, params=None):
+        """Internal handler called by Rust when no route matches."""
+        from .core.exceptions import NotFound
+
+        # Create request context if not already present
+        # This is needed because this might be called directly from Rust
+        # without going through the usual wrapper if it's a 404
+        try:
+            request = Request._from_rust_request(rust_request)
+            request.app = self
+            token = _request_ctx.set(request)
+
+            try:
+                # Handle via the normal exception handling logic
+                response = self._handle_exception(NotFound())
+                return self._response_to_rust_format(response)
+            finally:
+                _request_ctx.reset(token)
+        except Exception as e:
+            self.logger.error(f"Error in 404 fallback: {e}")
+            return ("Not Found", 404, {"Content-Type": "text/plain"})
+
     def _response_to_rust_format(self, response: Response) -> Union[tuple, Response]:
         """Convert Python Response object to format expected by Rust."""
         # Check for FileResponse (has path attribute)

{bustapi-0.11.1 → bustapi-0.12.0}/python/bustapi/documentation/generator.py

@@ -326,32 +326,68 @@ class BustAPIDocs:
                 # Extract query parameters
                 query_vals = self.app.query_validators.get((rule, method))
                 if query_vals:
+                    from ..params import Query
+
                     if "parameters" not in operation:
                         operation["parameters"] = []
                     for q_name, (q_default, q_anno) in query_vals.items():
-                        q_type = "string"
-                        if q_anno is int:
-                            q_type = "integer"
-                        elif q_anno is float:
-                            q_type = "number"
-                        elif q_anno is bool:
-                            q_type = "boolean"
-
-                        operation["parameters"].append(
-                            {
-                                "name": q_name,
-                                "in": "query",
-                                "required": q_default is inspect.Parameter.empty,
-                                "schema": {"type": q_type},
-                            }
-                        )
+                        if isinstance(q_default, Query):
+                            q_type = "string"
+                            if q_anno is int:
+                                q_type = "integer"
+                            elif q_anno is float:
+                                q_type = "number"
+                            elif q_anno is bool:
+                                q_type = "boolean"
+
+                            param_obj = q_default.to_openapi_parameter(
+                                q_name,
+                                q_type,
+                                required=q_default.default is inspect.Parameter.empty,
+                            )
+                            operation["parameters"].append(param_obj)
+                        else:
+                            q_type = "string"
+                            if q_anno is int:
+                                q_type = "integer"
+                            elif q_anno is float:
+                                q_type = "number"
+                            elif q_anno is bool:
+                                q_type = "boolean"
+
+                            operation["parameters"].append(
+                                {
+                                    "name": q_name,
+                                    "in": "query",
+                                    "required": q_default is inspect.Parameter.empty,
+                                    "schema": {"type": q_type},
+                                }
+                            )
 
                 # Extract request body
                 body_vals = self.app.body_validators.get((rule, method))
                 if body_vals:
-                    # Check if single Struct parameter
+                    from ..params import Body
+
+                    # Check if single Struct or Body parameter
                     if len(body_vals) == 1:
                         b_name, (b_default, b_anno) = list(body_vals.items())[0]
+
+                        # Handle Body objects
+                        if isinstance(b_default, Body):
+                            schema_ref = b_default.to_json_schema()
+                            operation["requestBody"] = {
+                                "required": b_default.default
+                                is inspect.Parameter.empty,
+                                "content": {"application/json": {"schema": schema_ref}},
+                            }
+                            if b_default.description:
+                                operation["requestBody"][
+                                    "description"
+                                ] = b_default.description
+                            path_item[method_lower] = operation
+                            continue
+
                         try:
                             from ..safe.types import Struct
 
@@ -372,19 +408,25 @@ class BustAPIDocs:
                     props = {}
                     required_props = []
                     for b_name, (b_default, b_anno) in body_vals.items():
-                        b_type_str = "string"
-                        if b_anno is int:
-                            b_type_str = "integer"
-                        elif b_anno is float:
-                            b_type_str = "number"
-                        elif b_anno is bool:
-                            b_type_str = "boolean"
-                        elif hasattr(b_anno, "__annotations__"):
-                            b_type_str = "object"
-
-                        props[b_name] = {"type": b_type_str}
-                        if b_default is inspect.Parameter.empty:
-                            required_props.append(b_name)
+                        if isinstance(b_default, Body):
+                            prop = b_default.to_json_schema()
+                            props[b_name] = prop
+                            if b_default.default is inspect.Parameter.empty:
+                                required_props.append(b_name)
+                        else:
+                            b_type_str = "string"
+                            if b_anno is int:
+                                b_type_str = "integer"
+                            elif b_anno is float:
+                                b_type_str = "number"
+                            elif b_anno is bool:
+                                b_type_str = "boolean"
+                            elif hasattr(b_anno, "__annotations__"):
+                                b_type_str = "object"
+
+                            props[b_name] = {"type": b_type_str}
+                            if b_default is inspect.Parameter.empty:
+                                required_props.append(b_name)
 
                     schema_ref = {"type": "object", "properties": props}
                     if required_props:
@@ -398,7 +440,10 @@ class BustAPIDocs:
                 path_item[method_lower] = operation
 
             if path_item:
-                schema["paths"][openapi_path] = path_item
+                if openapi_path in schema["paths"]:
+                    schema["paths"][openapi_path].update(path_item)
+                else:
+                    schema["paths"][openapi_path] = path_item
 
         self._schema_cache = schema
         return schema

{bustapi-0.11.1 → bustapi-0.12.0}/python/bustapi/http/response.py

@@ -281,14 +281,24 @@ def make_response(*args) -> Response:
         rv, status_or_headers = args
         if isinstance(status_or_headers, (int, str)):
             # (response, status)
+            if isinstance(rv, Response):
+                rv.status_code = int(status_or_headers)
+                return rv
             return Response(rv, status=status_or_headers)
         else:
             # (response, headers)
+            if isinstance(rv, Response):
+                rv.headers.update(status_or_headers)
+                return rv
             return Response(rv, headers=status_or_headers)
 
     if len(args) == 3:
         # (response, status, headers)
         rv, status, headers = args
+        if isinstance(rv, Response):
+            rv.status_code = int(status)
+            rv.headers.update(headers)
+            return rv
         return Response(rv, status=status, headers=headers)
 
     raise TypeError(f"make_response() takes 1 to 3 arguments ({len(args)} given)")

{bustapi-0.11.1 → bustapi-0.12.0}/python/bustapi/params.py

@@ -148,7 +148,16 @@ class Path:
         Returns:
             JSON Schema dictionary compatible with OpenAPI 3.0
         """
-        schema: Dict[str, Any] = {"type": param_type}
+        # Map Python types to OpenAPI types
+        type_map = {
+            "int": "integer",
+            "float": "number",
+            "number": "number",
+            "str": "string",
+            "string": "string",
+        }
+        actual_type = type_map.get(param_type, param_type)
+        schema: Dict[str, Any] = {"type": actual_type}
 
         # Add title and description
         if self.title:
@@ -412,7 +421,18 @@ class Query:
         Returns:
             JSON Schema dictionary compatible with OpenAPI 3.0
         """
-        schema: Dict[str, Any] = {"type": param_type}
+        # Map Python types to OpenAPI types
+        type_map = {
+            "int": "integer",
+            "float": "number",
+            "number": "number",
+            "str": "string",
+            "string": "string",
+            "bool": "boolean",
+            "boolean": "boolean",
+        }
+        actual_type = type_map.get(param_type, param_type)
+        schema: Dict[str, Any] = {"type": actual_type}
 
         # Add title and description
         if self.title:
@@ -730,7 +750,20 @@ class Body:
                     continue
 
                 field_type = field_schema.get("type", "string")
-                prop = {"type": field_type}
+                # Map Python types to OpenAPI types
+                type_map = {
+                    "int": "integer",
+                    "float": "number",
+                    "number": "number",
+                    "str": "string",
+                    "string": "string",
+                    "bool": "boolean",
+                    "boolean": "boolean",
+                    "dict": "object",
+                    "list": "array",
+                }
+                actual_type = type_map.get(field_type, field_type)
+                prop = {"type": actual_type}
 
                 if "description" in field_schema:
                     prop["description"] = field_schema["description"]

{bustapi-0.11.1 → bustapi-0.12.0}/src/bindings/app.rs

@@ -277,6 +277,19 @@ impl PyBustApp {
         Ok(())
     }
 
+    /// Set a fallback handler for 404 Not Found errors
+    pub fn set_not_found_handler(&self, handler: Py<PyAny>) -> PyResult<()> {
+        let py_handler = crate::bindings::handlers::PyRouteHandler::new(handler);
+        let state = self.state.clone();
+
+        self.runtime.block_on(async {
+            let mut routes = state.routes.write().await;
+            routes.not_found_handler = Some(Arc::new(py_handler));
+        });
+
+        Ok(())
+    }
+
     /// Run the server
     pub fn run(
         &self,

{bustapi-0.11.1 → bustapi-0.12.0}/src/router/handlers.rs

@@ -140,6 +140,7 @@ pub struct Router {
     pub(crate) routes: HashMap<(Method, String), Arc<dyn RouteHandler>>,
     pub(crate) middleware: Vec<Arc<dyn super::middleware::Middleware>>,
     pub(crate) redirect_slashes: bool,
+    pub not_found_handler: Option<Arc<dyn RouteHandler>>,
 }
 
 impl Router {
@@ -151,6 +152,7 @@ impl Router {
             routes: HashMap::new(),
             middleware: Vec::new(),
             redirect_slashes: true,
+            not_found_handler: None,
         }
     }
 
@@ -239,7 +241,11 @@ impl Router {
         } else {
             // Not found - check for redirect if enabled
             self.try_redirect(&req_data).unwrap_or_else(|| {
-                ResponseData::error(http::StatusCode::NOT_FOUND, Some("Not Found"))
+                if let Some(ref handler) = self.not_found_handler {
+                    handler.handle(req_data.clone())
+                } else {
+                    ResponseData::error(http::StatusCode::NOT_FOUND, Some("Not Found"))
+                }
             })
         };
 

{bustapi-0.11.1 → bustapi-0.12.0}/src/watcher.rs

@@ -31,13 +31,27 @@ pub fn enable_hot_reload(path_str: String) {
                     paths,
                     ..
                 })) => {
-                    // Filter out non-python files if needed, but for now watch all
-                    // Simple debounce: Wait a bit to avoid multiple restarts for one save
+                    // Filter out noise and irrelevant files
                     if let Some(path) = paths.first() {
-                        println!("Using: {}", path.display());
+                        let path_str = path.to_string_lossy();
+                        if path_str.contains("__pycache__")
+                            || path_str.contains(".git")
+                            || path_str.contains(".venv")
+                            || path_str.contains(".egg-info")
+                        {
+                            continue;
+                        }
+
+                        // Check extension
+                        let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
+                        if !["py", "rs", "html", "css", "js", "json", "toml"].contains(&ext) {
+                            continue;
+                        }
+
+                        println!("Using: {}", path_str);
+                        println!("🔄 Restarting...");
+                        restart_process();
                     }
-                    println!("🔄 Restarting...");
-                    restart_process();
                 }
                 Ok(Err(e)) => eprintln!("watch error: {:?}", e),
                 Err(e) => eprintln!("watch channel error: {:?}", e),

bustapi-0.12.0/tests/test_issue_18.py

@@ -0,0 +1,63 @@
+import os
+import shutil
+
+import pytest
+from bustapi import BustAPI, render_template
+
+
+@pytest.fixture
+def app():
+    app = BustAPI(import_name="test_app")
+
+    # Setup templates
+    template_dir = os.path.join(os.getcwd(), "templates_test_18")
+    os.makedirs(template_dir, exist_ok=True)
+    with open(os.path.join(template_dir, "err.html"), "w") as f:
+        f.write(
+            "<html><body><h1>Error {{ status_code }}</h1><p>{{ message }}</p></body></html>"
+        )
+
+    app.template_folder = template_dir
+
+    @app.errorhandler(404)
+    def page_not_found(e):
+        return (
+            render_template(
+                "err.html", **{"status_code": 404, "message": "Custom 404 Page"}
+            ),
+            404,
+        )
+
+    @app.route("/")
+    def index():
+        return "Home"
+
+    yield app
+
+    # Cleanup
+    shutil.rmtree(template_dir, ignore_errors=True)
+
+
+def test_custom_404_handler(app):
+    with app.test_client() as client:
+        # Test valid route
+        resp = client.get("/")
+        assert resp.status_code == 200
+        assert resp.text == "Home"
+
+        # Test invalid route - should trigger custom handler
+        resp = client.get("/non-existent")
+        assert resp.status_code == 404
+        assert "Custom 404 Page" in resp.text
+        assert "<h1>Error 404</h1>" in resp.text
+
+
+def test_default_500_handler(app):
+    @app.route("/error")
+    def cause_error():
+        raise ValueError("Something went wrong")
+
+    with app.test_client() as client:
+        resp = client.get("/error")
+        assert resp.status_code == 500
+        assert "Internal Server Error" in resp.text