menzoapi 0.0.2__tar.gz → 1.0.0__tar.gz

menzoapi-1.0.0/PKG-INFO

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: menzoapi
+Version: 1.0.0
+Summary: A lightweight FastAPI-inspired framework
+Home-page: https://github.com/menzoapi/menzoapi
+Author: MenzoAPI Contributors
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
+
+# README.md
+# MenzoAPI v1.0.0
+
+A lightweight FastAPI-inspired framework for Python 3.10+ with zero external dependencies.
+
+## Features
+
+- **Routing**: GET, POST, PUT, DELETE, PATCH
+- **Route Parameters**: `/users/{id}`
+- **Query Parameters**: `/search?q=test&page=1`
+- **Request Object**: headers, body, json, params, query, method, path
+- **Response Object**: status, body, headers
+- **JSON Responses**: Automatic serialization
+- **Middleware System**: Multiple middleware support
+- **Exception Handlers**: Custom exception handling
+- **Built-in Docs**: `/docs` endpoint with auto-listed routes
+- **Async Support**: Full async endpoint support
+- **Thread-Safe Routing**: Safe for concurrent requests
+- **Automatic JSON Parsing**: Request body parsing
+- **Automatic Status Codes**: Smart response status detection
+- **Static File Serving**: Serve static files
+- **CORS Support**: Cross-Origin Resource Sharing
+- **Logging**: Built-in logging
+- **Type Hints**: Complete type annotations everywhere
+- **Zero Dependencies**: Pure Python standard library
+
+## Installation
+
+```bash
+pip install menzoapi
+```
+Quick Start
+```python
+from menzoapi import MenzoAPI, Server
+
+app = MenzoAPI()
+
+@app.get("/")
+def home(request):
+    return {"message": "Hello, MenzoAPI!"}
+
+@app.get("/users/{id}")
+def get_user(request):
+    user_id = request.params["id"]
+    return {"id": user_id, "name": "User " + user_id}
+
+@app.post("/users")
+async def create_user(request):
+    data = await request.json
+    return {"created": True, "data": data}
+
+Server(app).run()
+```
+Advanced Usage
+Middleware
+```python
+from menzoapi import MenzoAPI
+from menzoapi.middleware import LoggerMiddleware, CORSMiddleware
+
+app = MenzoAPI()
+app.use(LoggerMiddleware())
+app.use(CORSMiddleware(origins=["*"]))
+```
+Exception Handling
+```python
+from menzoapi.exceptions import NotFoundException
+
+@app.exception_handler(NotFoundException)
+def handle_not_found(exc):
+    return {"error": str(exc)}, 404
+```
+Static Files
+```python
+app.static("/static", "./public")
+```
+CORS
+```python
+app.enable_cors(
+    origins=["https://example.com"],
+    methods=["GET", "POST"],
+    headers=["Content-Type"]
+)
+```
+API Reference
+MenzoAPI
+```python
+@app.get(path) - GET route
+
+@app.post(path) - POST route
+
+@app.put(path) - PUT route
+
+@app.delete(path) - DELETE route
+
+@app.patch(path) - PATCH route
+
+app.use(middleware) - Add middleware
+
+app.exception_handler(type) - Add exception handler
+
+app.enable_cors() - Enable CORS
+
+app.static(path, directory) - Serve static files
+Request
+request.method - HTTP method
+
+request.path - Request path
+
+request.headers - Headers dict
+
+request.query - Query parameters
+
+request.params - Route parameters
+
+await request.body - Raw body
+
+await request.json - JSON body
+
+Response
+Response(status, body, headers) - Create response
+
+response.json(data, status) - JSON response
+```
+Server
+```python
+from menzoapi import Server
+
+Server(app, host="0.0.0.0", port=8000, workers=4).run()
+host - Bind address (default: 127.0.0.1)
+```
+
+# ENDING PART
+port - Bind port (default: 8000)
+
+workers - Number of worker processes (default: 1)
+Documentation
+Visit /docs endpoint in your browser to see auto-generated API documentation.
+
+License
+MIT
+---
+<h1> By Sarthak Kamat </h1>
+---

menzoapi-1.0.0/README.md

@@ -0,0 +1,143 @@
+# README.md
+# MenzoAPI v1.0.0
+
+A lightweight FastAPI-inspired framework for Python 3.10+ with zero external dependencies.
+
+## Features
+
+- **Routing**: GET, POST, PUT, DELETE, PATCH
+- **Route Parameters**: `/users/{id}`
+- **Query Parameters**: `/search?q=test&page=1`
+- **Request Object**: headers, body, json, params, query, method, path
+- **Response Object**: status, body, headers
+- **JSON Responses**: Automatic serialization
+- **Middleware System**: Multiple middleware support
+- **Exception Handlers**: Custom exception handling
+- **Built-in Docs**: `/docs` endpoint with auto-listed routes
+- **Async Support**: Full async endpoint support
+- **Thread-Safe Routing**: Safe for concurrent requests
+- **Automatic JSON Parsing**: Request body parsing
+- **Automatic Status Codes**: Smart response status detection
+- **Static File Serving**: Serve static files
+- **CORS Support**: Cross-Origin Resource Sharing
+- **Logging**: Built-in logging
+- **Type Hints**: Complete type annotations everywhere
+- **Zero Dependencies**: Pure Python standard library
+
+## Installation
+
+```bash
+pip install menzoapi
+```
+Quick Start
+```python
+from menzoapi import MenzoAPI, Server
+
+app = MenzoAPI()
+
+@app.get("/")
+def home(request):
+    return {"message": "Hello, MenzoAPI!"}
+
+@app.get("/users/{id}")
+def get_user(request):
+    user_id = request.params["id"]
+    return {"id": user_id, "name": "User " + user_id}
+
+@app.post("/users")
+async def create_user(request):
+    data = await request.json
+    return {"created": True, "data": data}
+
+Server(app).run()
+```
+Advanced Usage
+Middleware
+```python
+from menzoapi import MenzoAPI
+from menzoapi.middleware import LoggerMiddleware, CORSMiddleware
+
+app = MenzoAPI()
+app.use(LoggerMiddleware())
+app.use(CORSMiddleware(origins=["*"]))
+```
+Exception Handling
+```python
+from menzoapi.exceptions import NotFoundException
+
+@app.exception_handler(NotFoundException)
+def handle_not_found(exc):
+    return {"error": str(exc)}, 404
+```
+Static Files
+```python
+app.static("/static", "./public")
+```
+CORS
+```python
+app.enable_cors(
+    origins=["https://example.com"],
+    methods=["GET", "POST"],
+    headers=["Content-Type"]
+)
+```
+API Reference
+MenzoAPI
+```python
+@app.get(path) - GET route
+
+@app.post(path) - POST route
+
+@app.put(path) - PUT route
+
+@app.delete(path) - DELETE route
+
+@app.patch(path) - PATCH route
+
+app.use(middleware) - Add middleware
+
+app.exception_handler(type) - Add exception handler
+
+app.enable_cors() - Enable CORS
+
+app.static(path, directory) - Serve static files
+Request
+request.method - HTTP method
+
+request.path - Request path
+
+request.headers - Headers dict
+
+request.query - Query parameters
+
+request.params - Route parameters
+
+await request.body - Raw body
+
+await request.json - JSON body
+
+Response
+Response(status, body, headers) - Create response
+
+response.json(data, status) - JSON response
+```
+Server
+```python
+from menzoapi import Server
+
+Server(app, host="0.0.0.0", port=8000, workers=4).run()
+host - Bind address (default: 127.0.0.1)
+```
+
+# ENDING PART
+port - Bind port (default: 8000)
+
+workers - Number of worker processes (default: 1)
+Documentation
+Visit /docs endpoint in your browser to see auto-generated API documentation.
+
+License
+MIT
+---
+<h1> By Sarthak Kamat </h1>
+---

menzoapi-1.0.0/menzoapi/__init__.py

@@ -0,0 +1,32 @@
+# menzoapi/__init__.py
+from menzoapi.app import MenzoAPI
+from menzoapi.server import Server
+from menzoapi.types import Request, Response
+from menzoapi.middleware import Middleware, LoggerMiddleware, CORSMiddleware
+from menzoapi.exceptions import (
+    HTTPException,
+    NotFoundException,
+    MethodNotAllowedException,
+    BadRequestException,
+    UnauthorizedException,
+    ForbiddenException,
+    InternalServerErrorException,
+)
+
+__version__ = "1.0.0"
+__all__ = [
+    "MenzoAPI",
+    "Server",
+    "Request",
+    "Response",
+    "Middleware",
+    "LoggerMiddleware",
+    "CORSMiddleware",
+    "HTTPException",
+    "NotFoundException",
+    "MethodNotAllowedException",
+    "BadRequestException",
+    "UnauthorizedException",
+    "ForbiddenException",
+    "InternalServerErrorException",
+]

menzoapi-1.0.0/menzoapi/app.py

@@ -0,0 +1,290 @@
+# menzoapi/app.py
+import asyncio
+import inspect
+import json
+import logging
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from urllib.parse import parse_qs
+
+from menzoapi.types import Request, Response
+from menzoapi.middleware import Middleware
+from menzoapi.exceptions import HTTPException, NotFoundException, MethodNotAllowedException
+from menzoapi.static import StaticFileHandler
+
+logger = logging.getLogger(__name__)
+
+
+class MenzoAPI:
+    __slots__ = (
+        "_routes",
+        "_middlewares",
+        "_exception_handlers",
+        "_static_handlers",
+        "_cors_enabled",
+        "_cors_origins",
+        "_cors_methods",
+        "_cors_headers",
+    )
+
+    def __init__(self) -> None:
+        self._routes: Dict[str, Dict[str, Callable]] = {}
+        self._middlewares: List[Middleware] = []
+        self._exception_handlers: Dict[type, Callable] = {}
+        self._static_handlers: List[StaticFileHandler] = []
+        self._cors_enabled: bool = False
+        self._cors_origins: List[str] = []
+        self._cors_methods: List[str] = []
+        self._cors_headers: List[str] = []
+
+    def _add_route(self, path: str, method: str, handler: Callable) -> None:
+        self._routes.setdefault(path, {})[method] = handler
+
+    def get(self, path: str) -> Callable:
+        def decorator(handler: Callable) -> Callable:
+            self._add_route(path, "GET", handler)
+            return handler
+        return decorator
+
+    def post(self, path: str) -> Callable:
+        def decorator(handler: Callable) -> Callable:
+            self._add_route(path, "POST", handler)
+            return handler
+        return decorator
+
+    def put(self, path: str) -> Callable:
+        def decorator(handler: Callable) -> Callable:
+            self._add_route(path, "PUT", handler)
+            return handler
+        return decorator
+
+    def delete(self, path: str) -> Callable:
+        def decorator(handler: Callable) -> Callable:
+            self._add_route(path, "DELETE", handler)
+            return handler
+        return decorator
+
+    def patch(self, path: str) -> Callable:
+        def decorator(handler: Callable) -> Callable:
+            self._add_route(path, "PATCH", handler)
+            return handler
+        return decorator
+
+    def use(self, middleware: Middleware) -> None:
+        self._middlewares.append(middleware)
+
+    def exception_handler(self, exception_type: type) -> Callable:
+        def decorator(handler: Callable) -> Callable:
+            self._exception_handlers[exception_type] = handler
+            return handler
+        return decorator
+
+    def enable_cors(
+        self,
+        origins: Optional[List[str]] = None,
+        methods: Optional[List[str]] = None,
+        headers: Optional[List[str]] = None,
+    ) -> None:
+        self._cors_enabled = True
+        self._cors_origins = origins or ["*"]
+        self._cors_methods = methods or ["GET", "POST", "PUT", "DELETE", "PATCH"]
+        self._cors_headers = headers or ["Content-Type", "Authorization"]
+
+    def static(self, path: str, directory: str) -> None:
+        self._static_handlers.append(StaticFileHandler(path, directory))
+
+    def _parse_path_params(self, route_path: str, actual_path: str) -> Dict[str, str]:
+        route_parts = route_path.strip("/").split("/")
+        actual_parts = actual_path.strip("/").split("/")
+        if len(route_parts) != len(actual_parts):
+            return {}
+
+        params = {}
+        for rp, ap in zip(route_parts, actual_parts):
+            if rp.startswith("{") and rp.endswith("}"):
+                params[rp[1:-1]] = ap
+            elif rp != ap:
+                return {}
+        return params
+
+    def _match_route(self, path: str, method: str) -> Tuple[Optional[Callable], Dict[str, str]]:
+        for route_path, methods in self._routes.items():
+            if route_path == path:
+                return (methods.get(method), {}) if method in methods else (None, {})
+            if "{" in route_path:
+                params = self._parse_path_params(route_path, path)
+                if params and method in methods:
+                    return methods[method], params
+        return None, {}
+
+    def _handle_exception(self, exc: Exception) -> Response:
+        for exc_type, handler in self._exception_handlers.items():
+            if isinstance(exc, exc_type):
+                result = handler(exc)
+                if inspect.iscoroutine(result):
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    result = loop.run_until_complete(result)
+                    loop.close()
+                return result if isinstance(result, Response) else self._normalize_response(result)
+
+        if isinstance(exc, NotFoundException):
+            return Response(404, json.dumps({"error": "Not Found"}), {"Content-Type": "application/json"})
+        if isinstance(exc, MethodNotAllowedException):
+            return Response(405, json.dumps({"error": "Method Not Allowed"}), {"Content-Type": "application/json"})
+        if isinstance(exc, HTTPException):
+            return Response(exc.status_code, json.dumps({"error": exc.detail}), {"Content-Type": "application/json"})
+
+        logger.error(f"Unhandled exception: {exc}", exc_info=True)
+        return Response(500, json.dumps({"error": "Internal Server Error"}), {"Content-Type": "application/json"})
+
+    def _cors_headers(self) -> Dict[str, str]:
+        if not self._cors_enabled:
+            return {}
+        return {
+            "Access-Control-Allow-Origin": "*" if "*" in self._cors_origins else ", ".join(self._cors_origins),
+            "Access-Control-Allow-Methods": ", ".join(self._cors_methods),
+            "Access-Control-Allow-Headers": ", ".join(self._cors_headers),
+        }
+
+    def _prepare_request(self, scope: Dict[str, Any], receive: Callable) -> Request:
+        query_string = scope.get("query_string", b"").decode()
+        headers = {}
+        for k, v in scope.get("headers", []):
+            headers[k.decode().lower()] = v.decode()
+
+        return Request(
+            method=scope.get("method", "GET"),
+            path=scope.get("path", "/"),
+            headers=headers,
+            query=parse_qs(query_string),
+            scope=scope,
+            receive=receive,
+        )
+
+    async def _apply_middleware(self, request: Request, handler: Callable) -> Response:
+        async def process(idx: int) -> Response:
+            if idx >= len(self._middlewares):
+                return await self._call_handler(handler, request)
+            return await self._middlewares[idx].process(request, lambda req: process(idx + 1))
+        return await process(0)
+
+    async def _call_handler(self, handler: Callable, request: Request) -> Response:
+        result = await handler(request) if inspect.iscoroutinefunction(handler) else handler(request)
+        return result if isinstance(result, Response) else self._normalize_response(result)
+
+    def _normalize_response(self, result: Any) -> Response:
+        if result is None:
+            return Response(204, b"")
+        if isinstance(result, dict):
+            return Response(200, json.dumps(result), {"Content-Type": "application/json"})
+        if isinstance(result, (str, bytes)):
+            content_type = "text/plain" if isinstance(result, str) else "application/octet-stream"
+            return Response(200, result.encode() if isinstance(result, str) else result, {"Content-Type": content_type})
+        return Response(200, json.dumps({"result": str(result)}), {"Content-Type": "application/json"})
+
+    def _docs_routes(self) -> List[Dict[str, Any]]:
+        return [
+            {"path": p, "method": m, "handler": h.__name__}
+            for p, methods in self._routes.items()
+            for m, h in methods.items()
+        ]
+
+    async def _serve_static(self, path: str) -> Optional[Response]:
+        for handler in self._static_handlers:
+            if path.startswith(handler.path_prefix):
+                return await handler.serve(path)
+        return None
+
+    async def _handle_request(self, scope: Dict[str, Any], receive: Callable) -> Response:
+        path = scope.get("path", "/")
+        method = scope.get("method", "GET")
+
+        if method == "OPTIONS" and self._cors_enabled:
+            return Response(200, b"", self._cors_headers())
+
+        if path == "/docs":
+            return Response(200, self._docs_html().encode(), {"Content-Type": "text/html"})
+
+        static_resp = await self._serve_static(path)
+        if static_resp:
+            return static_resp
+
+        request = self._prepare_request(scope, receive)
+        handler, path_params = self._match_route(path, method)
+
+        if not handler:
+            if path in self._routes:
+                raise MethodNotAllowedException(f"Method {method} not allowed for {path}")
+            raise NotFoundException(f"Route {path} not found")
+
+        request.params = path_params
+
+        try:
+            response = await self._apply_middleware(request, handler)
+            if self._cors_enabled:
+                response.headers.update(self._cors_headers())
+            return response
+        except Exception as e:
+            return self._handle_exception(e)
+
+    def _docs_html(self) -> str:
+        routes = self._docs_routes()
+        rows = "".join(
+            f"""
+                <tr>
+                    <td><span class="method method-{r['method'].lower()}">{r['method']}</span></td>
+                    <td><code>{r['path']}</code></td>
+                    <td>{r['handler']}</td>
+                </tr>"""
+            for r in routes
+        )
+
+        return f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="utf-8">
+            <title>MenzoAPI Documentation</title>
+            <style>
+                body {{ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; max-width: 1200px; margin: 40px auto; padding: 0 20px; }}
+                h1 {{ color: #333; border-bottom: 2px solid #eee; padding-bottom: 10px; }}
+                table {{ width: 100%; border-collapse: collapse; margin-top: 20px; }}
+                th {{ text-align: left; padding: 12px; background: #f5f5f5; font-weight: 600; }}
+                td {{ padding: 12px; border-bottom: 1px solid #eee; }}
+                .method {{ display: inline-block; padding: 4px 12px; border-radius: 4px; font-weight: 600; font-size: 14px; }}
+                .method-get {{ background: #61affe; color: white; }}
+                .method-post {{ background: #49cc90; color: white; }}
+                .method-put {{ background: #fca130; color: white; }}
+                .method-delete {{ background: #f93e3e; color: white; }}
+                .method-patch {{ background: #50e3c2; color: white; }}
+                code {{ background: #f5f5f5; padding: 2px 6px; border-radius: 3px; font-size: 14px; }}
+                .info {{ margin-top: 20px; padding: 15px; background: #f8f9fa; border-radius: 4px; }}
+            </style>
+        </head>
+        <body>
+            <h1>MenzoAPI v1.0.0 Documentation</h1>
+            <div class="info"><strong>Total Routes:</strong> {len(routes)}</div>
+            <table>
+                <thead><tr><th>Method</th><th>Path</th><th>Handler</th></tr></thead>
+                <tbody>{rows}</tbody>
+            </table>
+        </body>
+        </html>
+        """
+
+    async def __call__(self, scope: Dict[str, Any], receive: Callable, send: Callable) -> None:
+        if scope["type"] != "http":
+            return
+
+        try:
+            response = await self._handle_request(scope, receive)
+            headers = [(k.encode(), v.encode()) for k, v in response.headers.items()]
+
+            await send({"type": "http.response.start", "status": response.status, "headers": headers})
+            body = response.body if isinstance(response.body, bytes) else response.body.encode()
+            await send({"type": "http.response.body", "body": body})
+
+        except Exception as e:
+            logger.error(f"Error processing request: {e}", exc_info=True)
+            await send({"type": "http.response.start", "status": 500, "headers": [(b"content-type", b"application/json")]})
+            await send({"type": "http.response.body", "body": b'{"error": "Internal Server Error"}'})

menzoapi-1.0.0/menzoapi/exceptions.py

@@ -0,0 +1,38 @@
+# menzoapi/exceptions.py
+class HTTPException(Exception):
+    __slots__ = ("status_code", "detail")
+
+    def __init__(self, status_code: int, detail: str = "") -> None:
+        self.status_code = status_code
+        self.detail = detail
+        super().__init__(detail or f"HTTP {status_code}")
+
+
+class NotFoundException(HTTPException):
+    def __init__(self, detail: str = "Not Found") -> None:
+        super().__init__(404, detail)
+
+
+class MethodNotAllowedException(HTTPException):
+    def __init__(self, detail: str = "Method Not Allowed") -> None:
+        super().__init__(405, detail)
+
+
+class BadRequestException(HTTPException):
+    def __init__(self, detail: str = "Bad Request") -> None:
+        super().__init__(400, detail)
+
+
+class UnauthorizedException(HTTPException):
+    def __init__(self, detail: str = "Unauthorized") -> None:
+        super().__init__(401, detail)
+
+
+class ForbiddenException(HTTPException):
+    def __init__(self, detail: str = "Forbidden") -> None:
+        super().__init__(403, detail)
+
+
+class InternalServerErrorException(HTTPException):
+    def __init__(self, detail: str = "Internal Server Error") -> None:
+        super().__init__(500, detail)