PyPI - bustapi - Versions diffs - 0.1.0__cp311-cp311-win_amd64.whl → 0.1.5__cp311-cp311-win_amd64.whl - Mend

bustapi 0.1.0__cp311-cp311-win_amd64.whl → 0.1.5__cp311-cp311-win_amd64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of bustapi might be problematic. Click here for more details.

Files changed (19) hide show

bustapi/__init__.py +10 -5
bustapi/app.py +338 -41
bustapi/bustapi_core.cp311-win_amd64.pyd +0 -0
bustapi/helpers.py +28 -8
bustapi/logging.py +468 -0
bustapi/openapi/__init__.py +33 -0
bustapi/openapi/const.py +3 -0
bustapi/openapi/docs.py +269 -0
bustapi/openapi/models.py +128 -0
bustapi/openapi/utils.py +158 -0
bustapi/templating.py +30 -0
bustapi/testing.py +2 -1
bustapi-0.1.5.dist-info/METADATA +324 -0
bustapi-0.1.5.dist-info/RECORD +23 -0
{bustapi-0.1.0.dist-info → bustapi-0.1.5.dist-info}/licenses/LICENSE +1 -1
bustapi-0.1.0.dist-info/METADATA +0 -233
bustapi-0.1.0.dist-info/RECORD +0 -16
{bustapi-0.1.0.dist-info → bustapi-0.1.5.dist-info}/WHEEL +0 -0
{bustapi-0.1.0.dist-info → bustapi-0.1.5.dist-info}/entry_points.txt +0 -0

bustapi/openapi/docs.py ADDED Viewed

@@ -0,0 +1,269 @@
+"""
+BustAPI OpenAPI Documentation UI
+Custom implementation for Swagger UI and ReDoc documentation interfaces.
+"""
+import json
+from typing import Any, Dict, Optional
+try:
+    from starlette.responses import HTMLResponse
+except ImportError:
+    # Fallback if Starlette is not available
+    class HTMLResponse:
+        def __init__(
+            self,
+            content: str,
+            status_code: int = 200,
+            headers: Optional[Dict[str, str]] = None,
+        ):
+            self.content = content
+            self.status_code = status_code
+            self.headers = headers or {}
+def jsonable_encoder(obj: Any) -> Any:
+    """Simple JSON encoder fallback."""
+    if hasattr(obj, "dict"):
+        return obj.dict()
+    elif hasattr(obj, "__dict__"):
+        return obj.__dict__
+    else:
+        return obj
+# BustAPI Swagger UI default parameters
+swagger_ui_default_parameters: Dict[str, Any] = {
+    "dom_id": "#swagger-ui",
+    "layout": "BaseLayout",
+    "deepLinking": True,
+    "showExtensions": True,
+    "showCommonExtensions": True,
+}
+def get_swagger_ui_html(
+    *,
+    openapi_url: str,
+    title: str,
+    swagger_js_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js",
+    swagger_css_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css",
+    swagger_favicon_url: str = (
+        "data:image/svg+xml;base64,"
+        "PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZpZXdCb3g9IjAgMCAzMiAzMiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjMyIiBoZWlnaHQ9IjMyIiByeD0iOCIgZmlsbD0iIzAwN0FGRiIvPgo8cGF0aCBkPSJNOCAxNkMxMiAxNiAxNiAxMiAxNiA4QzE2IDEyIDIwIDE2IDI0IDE2QzIwIDE2IDE2IDIwIDE2IDI0QzE2IDIwIDEyIDE2IDggMTZaIiBmaWxsPSJ3aGl0ZSIvPgo8L3N2Zz4K"
+    ),
+    oauth2_redirect_url: Optional[str] = None,
+    init_oauth: Optional[Dict[str, Any]] = None,
+    swagger_ui_parameters: Optional[Dict[str, Any]] = None,
+) -> HTMLResponse:
+    """
+    Generate and return the HTML that loads Swagger UI for the interactive
+    API docs (normally served at `/docs`).
+    This is BustAPI's custom implementation with BustAPI branding and optimizations.
+    """
+    current_swagger_ui_parameters = swagger_ui_default_parameters.copy()
+    if swagger_ui_parameters:
+        current_swagger_ui_parameters.update(swagger_ui_parameters)
+    html = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="utf-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <link type="text/css" rel="stylesheet" href="{swagger_css_url}">
+        <link rel="shortcut icon" href="{swagger_favicon_url}">
+        <title>{title}</title>
+        <style>
+            .swagger-ui .topbar {{ display: none; }}
+            .swagger-ui .info .title {{ color: #007AFF; }}
+            .swagger-ui .info .title:after {{
+                content: " - Powered by BustAPI";
+                font-size: 14px;
+                color: #666;
+                font-weight: normal;
+            }}
+        </style>
+    </head>
+    <body>
+        <div id="swagger-ui"></div>
+        <script src="{swagger_js_url}"></script>
+        <script>
+        const ui = SwaggerUIBundle({{
+            url: '{openapi_url}',
+    """
+    for key, value in current_swagger_ui_parameters.items():
+        html += f"{json.dumps(key)}: {json.dumps(jsonable_encoder(value))},\n"
+    if oauth2_redirect_url:
+        html += f"oauth2RedirectUrl: window.location.origin + '{oauth2_redirect_url}',"
+    html += """
+            presets: [
+                SwaggerUIBundle.presets.apis,
+                SwaggerUIBundle.SwaggerUIStandalonePreset
+            ],
+            plugins: [
+                SwaggerUIBundle.plugins.DownloadUrl
+            ]
+        }});"""
+    if init_oauth:
+        html += f"""
+        ui.initOAuth({json.dumps(jsonable_encoder(init_oauth))});
+        """
+    html += """
+        </script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(html)
+def get_redoc_html(
+    *,
+    openapi_url: str,
+    title: str,
+    redoc_js_url: str = "https://cdn.jsdelivr.net/npm/redoc@2/bundles/redoc.standalone.js",
+    redoc_favicon_url: str = (
+        "data:image/svg+xml;base64,"
+        "PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZpZXdCb3g9IjAgMCAzMiAzMiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjMyIiBoZWlnaHQ9IjMyIiByeD0iOCIgZmlsbD0iIzAwN0FGRiIvPgo8cGF0aCBkPSJNOCAxNkMxMiAxNiAxNiAxMiAxNiA4QzE2IDEyIDIwIDE2IDI0IDE2QzIwIDE2IDE2IDIwIDE2IDI0QzE2IDIwIDEyIDE2IDggMTZaIiBmaWxsPSJ3aGl0ZSIvPgo8L3N2Zz4K"
+    ),
+    with_google_fonts: bool = True,
+) -> HTMLResponse:
+    """
+    Generate and return the HTML that loads ReDoc for the alternative
+    automatic interactive documentation.
+    This is BustAPI's custom implementation with BustAPI branding.
+    """
+    html = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+    <title>{title}</title>
+    <!-- needed for adaptive design -->
+    <meta charset="utf-8"/>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    """
+    if with_google_fonts:
+        html += """
+    <link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">
+    """
+    html += f"""
+    <link rel="shortcut icon" href="{redoc_favicon_url}">
+    <!--
+    ReDoc doesn't change outer page styles
+    -->
+    <style>
+      body {{
+        margin: 0;
+        padding: 0;
+      }}
+    </style>
+    </head>
+    <body>
+    <noscript>
+        ReDoc requires Javascript to function. Please enable it to browse the documentation.
+    </noscript>
+    <redoc spec-url="{openapi_url}"></redoc>
+    <script src="{redoc_js_url}"> </script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(html)
+def get_swagger_ui_oauth2_redirect_html() -> HTMLResponse:
+    """
+    Generate the HTML response with the OAuth2 redirection for Swagger UI.
+    You normally don't need to use or change this.
+    """
+    # copied from https://github.com/swagger-api/swagger-ui/blob/v4.14.0/dist/oauth2-redirect.html
+    html = """
+    <!doctype html>
+    <html lang="en-US">
+    <head>
+        <title>Swagger UI: OAuth2 Redirect</title>
+    </head>
+    <body>
+    <script>
+        'use strict';
+        function run () {
+            var oauth2 = window.opener.swaggerUIRedirectOauth2;
+            var sentState = oauth2.state;
+            var redirectUrl = oauth2.redirectUrl;
+            var isValid, qp, arr;
+            if (/code|token|error/.test(window.location.hash)) {
+                qp = window.location.hash.substring(1).replace('?', '&');
+            } else {
+                qp = location.search.substring(1);
+            }
+            arr = qp.split("&");
+            arr.forEach(function (v,i,_arr) { _arr[i] = '"' + v.replace('=', '":"') + '"';});
+            qp = qp ? JSON.parse('{' + arr.join() + '}',
+                    function (key, value) {
+                        return key === "" ? value : decodeURIComponent(value);
+                    }
+            ) : {};
+            isValid = qp.state === sentState;
+            if ((
+              oauth2.auth.schema.get("flow") === "accessCode" ||
+              oauth2.auth.schema.get("flow") === "authorizationCode" ||
+              oauth2.auth.schema.get("flow") === "authorization_code"
+            ) && !oauth2.auth.code) {
+                if (!isValid) {
+                    oauth2.errCb({
+                        authId: oauth2.auth.name,
+                        source: "auth",
+                        level: "warning",
+                        message: "Authorization may be unsafe, passed state was changed in server. The passed state wasn't returned from auth server."
+                    });
+                }
+                if (qp.code) {
+                    delete oauth2.state;
+                    oauth2.auth.code = qp.code;
+                    oauth2.callback({auth: oauth2.auth, redirectUrl: redirectUrl});
+                } else {
+                    let oauthErrorMsg;
+                    if (qp.error) {
+                        oauthErrorMsg = "["+qp.error+"]: " +
+                            (qp.error_description ? qp.error_description+ ". " : "no accessCode received from the server. ") +
+                            (qp.error_uri ? "More info: "+qp.error_uri : "");
+                    }
+                    oauth2.errCb({
+                        authId: oauth2.auth.name,
+                        source: "auth",
+                        level: "error",
+                        message: oauthErrorMsg || "[Authorization failed]: no accessCode received from the server."
+                    });
+                }
+            } else {
+                oauth2.callback({auth: oauth2.auth, token: qp, isValid: isValid, redirectUrl: redirectUrl});
+            }
+            window.close();
+        }
+        if (document.readyState !== 'loading') {
+            run();
+        } else {
+            document.addEventListener('DOMContentLoaded', function () {
+                run();
+            });
+        }
+    </script>
+    </body>
+    </html>
+        """
+    return HTMLResponse(content=html)

bustapi/openapi/models.py ADDED Viewed

@@ -0,0 +1,128 @@
+"""
+BustAPI OpenAPI Models
+Simplified OpenAPI 3.1.0 specification models for BustAPI.
+Custom implementation optimized for BustAPI's needs.
+"""
+from typing import Any, Dict, List, Optional
+class OpenAPIInfo:
+    """API information for OpenAPI spec."""
+    def __init__(self, title: str, version: str, description: Optional[str] = None):
+        self.title = title
+        self.version = version
+        self.description = description
+class OpenAPIServer:
+    """Server information for OpenAPI spec."""
+    def __init__(self, url: str, description: Optional[str] = None):
+        self.url = url
+        self.description = description
+class OpenAPIResponse:
+    """Response information for OpenAPI spec."""
+    def __init__(self, description: str, content: Optional[Dict[str, Any]] = None):
+        self.description = description
+        self.content = content or {}
+class OpenAPIOperation:
+    """Operation information for OpenAPI spec."""
+    def __init__(
+        self,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        operation_id: Optional[str] = None,
+        responses: Optional[Dict[str, OpenAPIResponse]] = None,
+        tags: Optional[List[str]] = None,
+    ):
+        self.summary = summary
+        self.description = description
+        self.operationId = operation_id
+        self.responses = responses or {"200": OpenAPIResponse("Successful response")}
+        self.tags = tags or []
+class OpenAPIPathItem:
+    """Path item for OpenAPI spec."""
+    def __init__(self):
+        self.get: Optional[OpenAPIOperation] = None
+        self.post: Optional[OpenAPIOperation] = None
+        self.put: Optional[OpenAPIOperation] = None
+        self.delete: Optional[OpenAPIOperation] = None
+        self.patch: Optional[OpenAPIOperation] = None
+        self.head: Optional[OpenAPIOperation] = None
+        self.options: Optional[OpenAPIOperation] = None
+class OpenAPISpec:
+    """Complete OpenAPI specification."""
+    def __init__(
+        self,
+        info: OpenAPIInfo,
+        servers: Optional[List[OpenAPIServer]] = None,
+        paths: Optional[Dict[str, OpenAPIPathItem]] = None,
+    ):
+        self.openapi = "3.1.0"
+        self.info = info
+        self.servers = servers or []
+        self.paths = paths or {}
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        result = {
+            "openapi": self.openapi,
+            "info": {
+                "title": self.info.title,
+                "version": self.info.version,
+            },
+            "paths": {},
+        }
+        if self.info.description:
+            result["info"]["description"] = self.info.description
+        if self.servers:
+            result["servers"] = [
+                {"url": server.url, "description": server.description}
+                for server in self.servers
+            ]
+        for path, path_item in self.paths.items():
+            path_dict = {}
+            for method in ["get", "post", "put", "delete", "patch", "head", "options"]:
+                operation = getattr(path_item, method, None)
+                if operation:
+                    op_dict = {
+                        "responses": {
+                            code: {"description": resp.description}
+                            for code, resp in operation.responses.items()
+                        }
+                    }
+                    if operation.summary:
+                        op_dict["summary"] = operation.summary
+                    if operation.description:
+                        op_dict["description"] = operation.description
+                    if operation.operationId:
+                        op_dict["operationId"] = operation.operationId
+                    if operation.tags:
+                        op_dict["tags"] = operation.tags
+                    path_dict[method] = op_dict
+            if path_dict:
+                result["paths"][path] = path_dict
+        return result

bustapi/openapi/utils.py ADDED Viewed

@@ -0,0 +1,158 @@
+"""
+BustAPI OpenAPI Utils
+Utilities for generating OpenAPI specifications for BustAPI applications.
+"""
+from typing import Any, Dict, List, Optional
+from .models import (
+    OpenAPIInfo,
+    OpenAPIOperation,
+    OpenAPIPathItem,
+    OpenAPIResponse,
+    OpenAPIServer,
+    OpenAPISpec,
+)
+def get_openapi_spec(
+    title: str,
+    version: str,
+    description: Optional[str] = None,
+    routes: Optional[List[Any]] = None,
+    servers: Optional[List[Dict[str, str]]] = None,
+) -> Dict[str, Any]:
+    """
+    Generate OpenAPI specification for BustAPI application.
+    Args:
+        title: API title
+        version: API version
+        description: API description
+        routes: List of routes to document
+        servers: List of server configurations
+    Returns:
+        OpenAPI specification as dictionary
+    """
+    # Create info object
+    info = OpenAPIInfo(title=title, version=version, description=description)
+    # Create servers
+    server_objects = []
+    if servers:
+        for server in servers:
+            server_objects.append(
+                OpenAPIServer(
+                    url=server.get("url", "/"), description=server.get("description")
+                )
+            )
+    # Create paths from routes
+    paths = {}
+    if routes:
+        for route in routes:
+            path_item = create_path_item_from_route(route)
+            if path_item:
+                paths[route.get("path", "/")] = path_item
+    # Create OpenAPI spec
+    spec = OpenAPISpec(info=info, servers=server_objects, paths=paths)
+    return spec.to_dict()
+def create_path_item_from_route(route: Dict[str, Any]) -> Optional[OpenAPIPathItem]:
+    """
+    Create OpenAPI path item from route information.
+    Args:
+        route: Route information dictionary
+    Returns:
+        OpenAPI path item or None
+    """
+    if not route:
+        return None
+    path_item = OpenAPIPathItem()
+    methods = route.get("methods", ["GET"])
+    handler = route.get("handler")
+    for method in methods:
+        method_lower = method.lower()
+        if hasattr(path_item, method_lower):
+            operation = create_operation_from_handler(handler, method)
+            setattr(path_item, method_lower, operation)
+    return path_item
+def create_operation_from_handler(handler: Any, method: str) -> OpenAPIOperation:
+    """
+    Create OpenAPI operation from route handler.
+    Args:
+        handler: Route handler function
+        method: HTTP method
+    Returns:
+        OpenAPI operation
+    """
+    if not handler:
+        return OpenAPIOperation()
+    # Extract information from handler
+    summary = None
+    description = None
+    operation_id = None
+    if hasattr(handler, "__name__"):
+        operation_id = f"{method.lower()}_{handler.__name__}"
+    if hasattr(handler, "__doc__") and handler.__doc__:
+        doc_lines = handler.__doc__.strip().split("\n")
+        if doc_lines:
+            summary = doc_lines[0].strip()
+            if len(doc_lines) > 1:
+                description = "\n".join(line.strip() for line in doc_lines[1:]).strip()
+    # Create default responses
+    responses = {
+        "200": OpenAPIResponse("Successful response"),
+        "422": OpenAPIResponse("Validation Error"),
+    }
+    return OpenAPIOperation(
+        summary=summary,
+        description=description,
+        operation_id=operation_id,
+        responses=responses,
+    )
+def extract_route_info(app) -> List[Dict[str, Any]]:
+    """
+    Extract route information from BustAPI application.
+    Args:
+        app: BustAPI application instance
+    Returns:
+        List of route information dictionaries
+    """
+    routes = []
+    # Try to get routes from the app
+    if hasattr(app, "_routes"):
+        for path, route_info in app._routes.items():
+            routes.append(
+                {
+                    "path": path,
+                    "methods": route_info.get("methods", ["GET"]),
+                    "handler": route_info.get("handler"),
+                }
+            )
+    return routes

bustapi/templating.py ADDED Viewed

@@ -0,0 +1,30 @@
+"""Simple Jinja2-based templating helpers for BustAPI.
+This module provides a small wrapper around Jinja2 Environment creation and
+rendering so the application can call `render_template` similarly to Flask.
+"""
+from typing import Any, Dict, Optional
+try:
+    import jinja2
+except Exception:  # pragma: no cover - optional dependency
+    jinja2 = None
+def create_jinja_env(template_folder: Optional[str] = None):
+    if jinja2 is None:
+        raise RuntimeError(
+            "Jinja2 is not installed. Add 'jinja2' to your dependencies."
+        )
+    loader = jinja2.FileSystemLoader(template_folder or "templates")
+    env = jinja2.Environment(loader=loader, autoescape=True)
+    return env
+def render_template(
+    env, template_name: str, context: Optional[Dict[str, Any]] = None
+) -> str:
+    context = context or {}
+    template = env.get_template(template_name)
+    return template.render(**context)

bustapi/testing.py CHANGED Viewed

@@ -92,7 +92,8 @@ class TestResponse:
         return "application/json" in content_type.lower()
     def __repr__(self) -> str:
-        return f'<TestResponse {self.status_code} [{self.headers.get("Content-Type", "")}]>'
+        content_type = self.headers.get("Content-Type", "")
+        return f"<TestResponse {self.status_code} [{content_type}]>"
 class TestClient: