vayuapi 0.2.1__tar.gz → 0.2.2__tar.gz

{vayuapi-0.2.1 → vayuapi-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vayuapi
-Version: 0.2.1
+Version: 0.2.2
 Summary: The fastest Python async API framework for rapid development with AI/ML support
 Home-page: https://github.com/vayuapi/vayuapi
 Author: VayuAPI Team

{vayuapi-0.2.1 → vayuapi-0.2.2}/pyproject.toml

@@ -6,7 +6,7 @@ include = ["vayuapi*"]
 
 [project]
 name = "vayuapi"
-version = "0.2.1"
+version = "0.2.2"
 description = "The fastest Python async API framework for rapid development with AI/ML support"
 readme = "README.md"
 requires-python = ">=3.11,<3.16"

{vayuapi-0.2.1 → vayuapi-0.2.2}/setup.py

@@ -7,7 +7,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="vayuapi",
-    version="0.2.1",
+    version="0.2.2",
     author="VayuAPI Team",
     author_email="codeswithalok@gmail.com",
     description="The fastest Python async API framework for rapid development with AI/ML support",

{vayuapi-0.2.1 → vayuapi-0.2.2}/vayuapi/core/application.py

@@ -237,51 +237,75 @@ class VayuAPI:
             return func
         return decorator
 
-    def add_middleware(self, middleware_or_class, **options):
+    def add_middleware(self, middleware_class: Type, **options) -> None:
         """
         Add middleware to the application.
 
-        Accepts either:
-        - A VayuAPI ``Middleware`` instance (custom middleware with
-          ``process_request`` / ``process_response`` hooks)
-        - A Starlette-compatible ASGI middleware **class** plus keyword
-          arguments that will be forwarded to its constructor.
+        Identical API to FastAPI / Starlette — always pass a **class** and
+        optional keyword arguments.  VayuAPI supports three kinds:
+
+        1. **ASGI / Starlette middleware** (``CORSMiddleware``,
+           ``GZipMiddleware``, ``SessionMiddleware``, …) — any class whose
+           constructor accepts ``(app, **options)``.
+
+        2. **BaseHTTPMiddleware subclasses** — override ``dispatch(request,
+           call_next)``; pass the class without instantiating it.
+
+        3. **VayuAPI Middleware subclasses** — override
+           ``process_request`` / ``process_response``; pass the class without
+           instantiating it (or pass an instance for backwards compatibility).
 
         Examples::
 
-            # VayuAPI custom middleware
-            app.add_middleware(MyMiddleware())
+            from vayuapi.middleware import CORSMiddleware, GZipMiddleware
+            from vayuapi.middleware import SessionMiddleware, HTTPSRedirectMiddleware
 
-            # Starlette-style middleware class with options
-            from vayuapi.middleware import CORSMiddleware
-            app.add_middleware(
-                CORSMiddleware,
-                allow_origins=["*"],
-                allow_methods=["*"],
-            )
+            app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"])
+            app.add_middleware(GZipMiddleware, minimum_size=1000)
+            app.add_middleware(SessionMiddleware, secret_key="supersecret")
+            app.add_middleware(HTTPSRedirectMiddleware)
 
-            from vayuapi.middleware import SessionMiddleware
-            app.add_middleware(SessionMiddleware, secret_key="secret")
+            # BaseHTTPMiddleware subclass
+            from vayuapi.middleware import BaseHTTPMiddleware
+            class TimingMiddleware(BaseHTTPMiddleware):
+                async def dispatch(self, request, call_next):
+                    import time
+                    start = time.time()
+                    response = await call_next(request)
+                    response.headers["X-Process-Time"] = str(time.time() - start)
+                    return response
+            app.add_middleware(TimingMiddleware)
+
+            # VayuAPI custom Middleware subclass
+            from vayuapi.middleware import Middleware
+            class LogMiddleware(Middleware):
+                async def process_request(self, request):
+                    print(request.method, request.url)
+            app.add_middleware(LogMiddleware)
         """
-        if isinstance(middleware_or_class, Middleware):
-            # VayuAPI Middleware instance
-            if options:
-                raise TypeError(
-                    "Keyword arguments are not accepted when passing a "
-                    "Middleware instance. Pass the options to the constructor instead."
-                )
-            self.middleware_stack.add(middleware_or_class)
-        elif isinstance(middleware_or_class, type):
-            # Starlette-style middleware class
-            self._starlette_middleware.append(
-                StarletteMiddleware(middleware_or_class, **options)
-            )
-        else:
+        from starlette.middleware.base import BaseHTTPMiddleware as _StarletteBaseHTTPMiddleware
+
+        # Backward-compat: accept a Middleware *instance* as well as a class
+        if isinstance(middleware_class, Middleware):
+            self.middleware_stack.add(middleware_class)
+            return
+
+        if not isinstance(middleware_class, type):
             raise TypeError(
-                "add_middleware expects a Middleware instance or a middleware class, "
-                f"got {type(middleware_or_class)!r}"
+                "add_middleware expects a middleware class, "
+                f"got {type(middleware_class)!r}"
             )
 
+        # VayuAPI Middleware subclass (process_request / process_response style)
+        if issubclass(middleware_class, Middleware):
+            self.middleware_stack.add(middleware_class(**options))
+            return
+
+        # BaseHTTPMiddleware subclass or any ASGI middleware class
+        self._starlette_middleware.append(
+            StarletteMiddleware(middleware_class, **options)
+        )
+
     def add_starlette_middleware(self, middleware_class: Type, **options):
         """Alias for add_middleware with a middleware class. Kept for backward compatibility."""
         self.add_middleware(middleware_class, **options)