vayuapi 0.1.2__tar.gz → 0.1.4__tar.gz

{vayuapi-0.1.2 → vayuapi-0.1.4}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: vayuapi
-Version: 0.1.2
+Version: 0.1.4
 Summary: The fastest Python async API framework for rapid development with AI/ML support
 Home-page: https://github.com/vayuapi/vayuapi
 Author: VayuAPI Team
-Author-email: VayuAPI Team <team@vayuapi.dev>
-Maintainer-email: VayuAPI Team <team@vayuapi.dev>
+Author-email: VayuAPI Team <codeswithalok@gmail.com>
+Maintainer-email: VayuAPI Team <codeswithalok@gmail.com>
 License: MIT
 Project-URL: Homepage, https://vayuapi.amrits.in
 Project-URL: Documentation, https://vayuapi.amrits.in/pages/documentation.html
@@ -88,8 +88,18 @@ Requires-Dist: sentence-transformers>=2.3.0; extra == "rag"
 Requires-Dist: tiktoken>=0.6.0; extra == "rag"
 Provides-Extra: scheduler
 Requires-Dist: apscheduler>=3.10.0; extra == "scheduler"
-Requires-Dist: celery>=5.3.0; extra == "scheduler"
-Requires-Dist: redis>=5.0.0; extra == "scheduler"
+Provides-Extra: celery
+Requires-Dist: celery>=5.3.0; extra == "celery"
+Requires-Dist: redis>=5.0.0; extra == "celery"
+Requires-Dist: kombu>=5.3.0; extra == "celery"
+Provides-Extra: arq
+Requires-Dist: arq>=0.25.0; extra == "arq"
+Requires-Dist: redis>=5.0.0; extra == "arq"
+Provides-Extra: grpc
+Requires-Dist: grpcio>=1.60.0; extra == "grpc"
+Requires-Dist: grpcio-tools>=1.60.0; extra == "grpc"
+Requires-Dist: grpcio-reflection>=1.60.0; extra == "grpc"
+Requires-Dist: protobuf>=4.25.0; extra == "grpc"
 Provides-Extra: security
 Requires-Dist: cryptography>=41.0.0; extra == "security"
 Requires-Dist: pyjwt>=2.8.0; extra == "security"
@@ -104,7 +114,7 @@ Requires-Dist: pytest-asyncio>=0.23.0; extra == "test"
 Requires-Dist: pytest-cov>=4.1.0; extra == "test"
 Requires-Dist: httpx>=0.26.0; extra == "test"
 Provides-Extra: all
-Requires-Dist: vayuapi[ai,django,http,nosql,orm,rag,scheduler,security,sqlalchemy,vector]; extra == "all"
+Requires-Dist: vayuapi[ai,arq,celery,django,grpc,http,nosql,orm,rag,scheduler,security,sqlalchemy,vector]; extra == "all"
 Provides-Extra: dev
 Requires-Dist: vayuapi[test]; extra == "dev"
 Requires-Dist: black>=24.0.0; extra == "dev"

{vayuapi-0.1.2 → vayuapi-0.1.4}/pyproject.toml

@@ -6,7 +6,7 @@ include = ["vayuapi*"]
 
 [project]
 name = "vayuapi"
-version = "0.1.2"
+version = "0.1.4"
 description = "The fastest Python async API framework for rapid development with AI/ML support"
 readme = "README.md"
 requires-python = ">=3.11,<3.16"
@@ -17,10 +17,10 @@ keywords = [
     "ai", "ml", "langchain", "rag", "pydantic", "admin", "security"
 ]
 authors = [
-    {name = "VayuAPI Team", email = "team@vayuapi.dev"}
+    {name = "VayuAPI Team", email = "codeswithalok@gmail.com"}
 ]
 maintainers = [
-    {name = "VayuAPI Team", email = "team@vayuapi.dev"}
+    {name = "VayuAPI Team", email = "codeswithalok@gmail.com"}
 ]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -124,8 +124,27 @@ rag = [
 # Task scheduling
 scheduler = [
     "apscheduler>=3.10.0",
+]
+
+# Celery distributed task queue
+celery = [
     "celery>=5.3.0",
     "redis>=5.0.0",
+    "kombu>=5.3.0",
+]
+
+# ARQ async task queue
+arq = [
+    "arq>=0.25.0",
+    "redis>=5.0.0",
+]
+
+# gRPC support
+grpc = [
+    "grpcio>=1.60.0",
+    "grpcio-tools>=1.60.0",
+    "grpcio-reflection>=1.60.0",
+    "protobuf>=4.25.0",
 ]
 
 # Security
@@ -152,7 +171,7 @@ test = [
 
 # All dependencies
 all = [
-    "vayuapi[django,orm,sqlalchemy,nosql,vector,ai,rag,scheduler,security,http]",
+    "vayuapi[django,orm,sqlalchemy,nosql,vector,ai,rag,scheduler,celery,arq,grpc,security,http]",
 ]
 
 # Development dependencies (testing + linting only)

{vayuapi-0.1.2 → vayuapi-0.1.4}/setup.py

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

{vayuapi-0.1.2 → vayuapi-0.1.4}/vayuapi/__init__.py

@@ -26,9 +26,21 @@ from vayuapi.core.params import (
     File,
 )
 
-# Dependency injection
+# Dependency injection (basic Depends/Security)
 from vayuapi.core.dependencies import Depends, Security
 
+# IoC / DI Container
+from vayuapi.di import (
+    DIContainer,
+    ServiceLifetime,
+    ServiceDescriptor,
+    ServiceScope,
+    ServiceProvider,
+    injectable,
+    inject,
+)
+from vayuapi.di.injectable import register_injectables
+
 # File uploads
 from vayuapi.core.uploads import UploadFile
 
@@ -107,9 +119,18 @@ __all__ = [
     "Body",
     "Form",
     "File",
-    # Dependencies
+    # Dependency injection (basic)
     "Depends",
     "Security",
+    # IoC DI Container
+    "DIContainer",
+    "ServiceLifetime",
+    "ServiceDescriptor",
+    "ServiceScope",
+    "ServiceProvider",
+    "injectable",
+    "inject",
+    "register_injectables",
     # File uploads
     "UploadFile",
     # Concurrency & Low Overhead

vayuapi-0.1.4/vayuapi/di/__init__.py

@@ -0,0 +1,23 @@
+"""
+VayuAPI Dependency Injection Container
+Full IoC container with Singleton, Transient, and Scoped lifetimes.
+"""
+
+from vayuapi.di.container import (
+    DIContainer,
+    ServiceLifetime,
+    ServiceDescriptor,
+    ServiceScope,
+)
+from vayuapi.di.injectable import injectable, inject
+from vayuapi.di.provider import ServiceProvider
+
+__all__ = [
+    "DIContainer",
+    "ServiceLifetime",
+    "ServiceDescriptor",
+    "ServiceScope",
+    "ServiceProvider",
+    "injectable",
+    "inject",
+]

vayuapi-0.1.4/vayuapi/di/container.py

@@ -0,0 +1,311 @@
+"""
+DI Container — IoC container with Singleton, Transient, and Scoped lifetimes.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import typing
+from enum import Enum
+from typing import Any, Callable, Dict, Generic, List, Optional, Type, TypeVar
+
+T = TypeVar("T")
+
+
+class ServiceLifetime(Enum):
+    """Service lifetime options."""
+    SINGLETON = "singleton"   # One instance for the entire application
+    TRANSIENT = "transient"   # New instance every time
+    SCOPED = "scoped"         # One instance per scope (e.g. per request)
+
+
+class ServiceDescriptor:
+    """Describes how to create a service."""
+
+    def __init__(
+        self,
+        service_type: Type,
+        lifetime: ServiceLifetime,
+        implementation_type: Optional[Type] = None,
+        factory: Optional[Callable] = None,
+        instance: Optional[Any] = None,
+    ):
+        if sum([implementation_type is not None, factory is not None, instance is not None]) != 1:
+            raise ValueError("Exactly one of implementation_type, factory, or instance must be provided.")
+
+        self.service_type = service_type
+        self.lifetime = lifetime
+        self.implementation_type = implementation_type
+        self.factory = factory
+        self.instance = instance
+
+    def __repr__(self) -> str:
+        return (
+            f"ServiceDescriptor(type={self.service_type.__name__}, "
+            f"lifetime={self.lifetime.value})"
+        )
+
+
+class ServiceScope:
+    """
+    A resolution scope. Scoped services are created once per scope.
+    Use as a context manager for per-request scopes.
+    """
+
+    def __init__(self, container: "DIContainer"):
+        self._container = container
+        self._scoped_instances: Dict[Type, Any] = {}
+        self._async_generators: List[Any] = []
+        self._sync_generators: List[Any] = []
+
+    async def resolve(self, service_type: Type[T]) -> T:
+        return await self._container._resolve(service_type, scope=self)
+
+    async def __aenter__(self) -> "ServiceScope":
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        await self._cleanup()
+
+    async def _cleanup(self):
+        for gen in reversed(self._async_generators):
+            try:
+                await gen.aclose()
+            except Exception:
+                pass
+        for gen in reversed(self._sync_generators):
+            try:
+                gen.close()
+            except Exception:
+                pass
+        self._scoped_instances.clear()
+        self._async_generators.clear()
+        self._sync_generators.clear()
+
+
+class DIContainer:
+    """
+    Inversion of Control container for VayuAPI.
+
+    Supports three service lifetimes:
+    - SINGLETON: created once, shared across all requests
+    - TRANSIENT: new instance for every resolution
+    - SCOPED: one instance per scope (request)
+
+    Example::
+
+        container = DIContainer()
+
+        # Register by type
+        container.add_singleton(Database)
+        container.add_transient(IEmailService, SmtpEmailService)
+        container.add_scoped(UnitOfWork)
+
+        # Register with a factory
+        container.add_singleton_factory(Config, lambda c: Config.from_env())
+
+        # Register an existing instance
+        container.add_instance(Config, Config.from_env())
+
+        # Resolve
+        async with container.create_scope() as scope:
+            db = await scope.resolve(Database)
+    """
+
+    def __init__(self):
+        self._descriptors: Dict[Type, ServiceDescriptor] = {}
+        self._singletons: Dict[Type, Any] = {}
+        # Tracks types currently being created to detect circular dependencies.
+        self._creating: set = set()
+
+    # ------------------------------------------------------------------
+    # Registration helpers
+    # ------------------------------------------------------------------
+
+    def register(self, descriptor: ServiceDescriptor) -> "DIContainer":
+        self._descriptors[descriptor.service_type] = descriptor
+        return self
+
+    def add_singleton(
+        self,
+        service_type: Type[T],
+        implementation_type: Optional[Type[T]] = None,
+    ) -> "DIContainer":
+        impl = implementation_type or service_type
+        return self.register(ServiceDescriptor(service_type, ServiceLifetime.SINGLETON, implementation_type=impl))
+
+    def add_singleton_factory(
+        self,
+        service_type: Type[T],
+        factory: Callable[["DIContainer"], T],
+    ) -> "DIContainer":
+        return self.register(ServiceDescriptor(service_type, ServiceLifetime.SINGLETON, factory=factory))
+
+    def add_instance(self, service_type: Type[T], instance: T) -> "DIContainer":
+        return self.register(ServiceDescriptor(service_type, ServiceLifetime.SINGLETON, instance=instance))
+
+    def add_transient(
+        self,
+        service_type: Type[T],
+        implementation_type: Optional[Type[T]] = None,
+    ) -> "DIContainer":
+        impl = implementation_type or service_type
+        return self.register(ServiceDescriptor(service_type, ServiceLifetime.TRANSIENT, implementation_type=impl))
+
+    def add_transient_factory(
+        self,
+        service_type: Type[T],
+        factory: Callable[["DIContainer"], T],
+    ) -> "DIContainer":
+        return self.register(ServiceDescriptor(service_type, ServiceLifetime.TRANSIENT, factory=factory))
+
+    def add_scoped(
+        self,
+        service_type: Type[T],
+        implementation_type: Optional[Type[T]] = None,
+    ) -> "DIContainer":
+        impl = implementation_type or service_type
+        return self.register(ServiceDescriptor(service_type, ServiceLifetime.SCOPED, implementation_type=impl))
+
+    def add_scoped_factory(
+        self,
+        service_type: Type[T],
+        factory: Callable[["DIContainer"], T],
+    ) -> "DIContainer":
+        return self.register(ServiceDescriptor(service_type, ServiceLifetime.SCOPED, factory=factory))
+
+    # ------------------------------------------------------------------
+    # Scope factory
+    # ------------------------------------------------------------------
+
+    def create_scope(self) -> ServiceScope:
+        return ServiceScope(self)
+
+    # ------------------------------------------------------------------
+    # Internal resolution
+    # ------------------------------------------------------------------
+
+    async def _resolve(self, service_type: Type[T], scope: Optional[ServiceScope] = None) -> T:
+        descriptor = self._descriptors.get(service_type)
+        if descriptor is None:
+            raise LookupError(
+                f"Service '{service_type.__name__}' is not registered in the container."
+            )
+
+        if descriptor.lifetime == ServiceLifetime.SINGLETON:
+            return await self._resolve_singleton(descriptor, scope)
+        elif descriptor.lifetime == ServiceLifetime.TRANSIENT:
+            return await self._create_instance(descriptor, scope)
+        elif descriptor.lifetime == ServiceLifetime.SCOPED:
+            if scope is None:
+                raise RuntimeError(
+                    f"Cannot resolve scoped service '{service_type.__name__}' outside of a scope."
+                )
+            if service_type not in scope._scoped_instances:
+                instance = await self._create_instance(descriptor, scope)
+                scope._scoped_instances[service_type] = instance
+            return scope._scoped_instances[service_type]
+
+    async def _resolve_singleton(self, descriptor: ServiceDescriptor, scope: Optional[ServiceScope]) -> Any:
+        if descriptor.service_type in self._singletons:
+            return self._singletons[descriptor.service_type]
+
+        if descriptor.service_type in self._creating:
+            raise RuntimeError(
+                f"Circular dependency detected while creating '{descriptor.service_type.__name__}'."
+            )
+
+        self._creating.add(descriptor.service_type)
+        try:
+            instance = await self._create_instance(descriptor, scope)
+        finally:
+            self._creating.discard(descriptor.service_type)
+
+        # Store only if not already stored (concurrent tasks are not possible in
+        # single-threaded asyncio, but guard for completeness).
+        if descriptor.service_type not in self._singletons:
+            self._singletons[descriptor.service_type] = instance
+        return self._singletons[descriptor.service_type]
+
+    async def _create_instance(self, descriptor: ServiceDescriptor, scope: Optional[ServiceScope]) -> Any:
+        if descriptor.instance is not None:
+            return descriptor.instance
+
+        if descriptor.factory is not None:
+            result = descriptor.factory(self)
+            if asyncio.iscoroutine(result):
+                result = await result
+            elif inspect.isasyncgen(result):
+                instance = await result.__anext__()
+                if scope is not None:
+                    scope._async_generators.append(result)
+                return instance
+            elif inspect.isgenerator(result):
+                instance = next(result)
+                if scope is not None:
+                    scope._sync_generators.append(result)
+                return instance
+            return result
+
+        impl_type = descriptor.implementation_type
+        # Auto-wire constructor dependencies
+        kwargs = await self._autowire(impl_type, scope)
+        return impl_type(**kwargs)
+
+    async def _autowire(self, impl_type: Type, scope: Optional[ServiceScope]) -> Dict[str, Any]:
+        # Use get_type_hints to properly resolve string annotations
+        # (PEP 563 / from __future__ import annotations in caller modules).
+        try:
+            hints = typing.get_type_hints(impl_type.__init__)
+        except Exception:
+            hints = {}
+
+        sig = inspect.signature(impl_type.__init__)
+        kwargs: Dict[str, Any] = {}
+
+        for name, param in sig.parameters.items():
+            if name == "self":
+                continue
+            # Prefer resolved hint; fall back to raw annotation on the Parameter.
+            annotation = hints.get(name, param.annotation)
+            if annotation is inspect.Parameter.empty:
+                if param.default is not inspect.Parameter.empty:
+                    continue  # has default, skip
+                raise TypeError(
+                    f"Cannot auto-wire parameter '{name}' in '{impl_type.__name__}': "
+                    f"no type annotation and no default value."
+                )
+            if annotation in self._descriptors:
+                kwargs[name] = await self._resolve(annotation, scope)
+            elif param.default is not inspect.Parameter.empty:
+                continue  # use default, skip
+            # else: unknown / primitive type — skip silently, constructor
+            # will raise if it was required (gives a clear Python TypeError).
+
+        return kwargs
+
+    # ------------------------------------------------------------------
+    # Direct resolve (no scope — for singletons / root resolution)
+    # ------------------------------------------------------------------
+
+    async def resolve(self, service_type: Type[T]) -> T:
+        return await self._resolve(service_type, scope=None)
+
+    def is_registered(self, service_type: Type) -> bool:
+        return service_type in self._descriptors
+
+    def __contains__(self, service_type: Type) -> bool:
+        return self.is_registered(service_type)
+
+    def __repr__(self) -> str:
+        names = [d.service_type.__name__ for d in self._descriptors.values()]
+        return f"DIContainer(services=[{', '.join(names)}])"
+
+
+__all__ = [
+    "DIContainer",
+    "ServiceLifetime",
+    "ServiceDescriptor",
+    "ServiceScope",
+]

vayuapi-0.1.4/vayuapi/di/injectable.py

@@ -0,0 +1,136 @@
+"""
+@injectable and @inject decorators for VayuAPI DI.
+"""
+
+from __future__ import annotations
+
+import functools
+import inspect
+from typing import Any, Callable, Optional, Type, TypeVar
+
+T = TypeVar("T")
+
+# Registry of injectable classes (used for auto-discovery)
+_INJECTABLE_REGISTRY: dict[Type, dict] = {}
+
+
+def injectable(
+    lifetime: str = "transient",
+    *,
+    alias: Optional[Type] = None,
+):
+    """
+    Mark a class as injectable so it can be auto-registered in a DIContainer.
+
+    Args:
+        lifetime: 'singleton', 'transient', or 'scoped'  (default 'transient')
+        alias: Optional interface/base-class to register the service under.
+
+    Example::
+
+        @injectable(lifetime="singleton")
+        class Database:
+            def __init__(self, config: Config):
+                self.url = config.db_url
+
+        @injectable(lifetime="scoped", alias=IUserRepository)
+        class UserRepository(IUserRepository):
+            def __init__(self, db: Database):
+                self.db = db
+    """
+    from vayuapi.di.container import ServiceLifetime
+
+    lifetime_map = {
+        "singleton": ServiceLifetime.SINGLETON,
+        "transient": ServiceLifetime.TRANSIENT,
+        "scoped": ServiceLifetime.SCOPED,
+    }
+
+    def decorator(cls: Type[T]) -> Type[T]:
+        sl = lifetime_map.get(lifetime.lower())
+        if sl is None:
+            raise ValueError(
+                f"Invalid lifetime '{lifetime}'. Use 'singleton', 'transient', or 'scoped'."
+            )
+        _INJECTABLE_REGISTRY[cls] = {
+            "lifetime": sl,
+            "alias": alias,
+        }
+        cls.__injectable_lifetime__ = sl
+        cls.__injectable_alias__ = alias
+        return cls
+
+    return decorator
+
+
+def inject(container_attr: str = "container"):
+    """
+    Decorator that auto-resolves constructor parameters from a DIContainer
+    attached to ``self.<container_attr>``.
+
+    Mainly useful for class-based views / handlers that hold a reference
+    to the application's container.
+
+    Example::
+
+        class UserService:
+            container: DIContainer
+
+            @inject()
+            async def __init__(self, repo: UserRepository):
+                self.repo = repo
+    """
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        async def wrapper(self, *args, **kwargs):
+            container = getattr(self, container_attr, None)
+            if container is None:
+                return await func(self, *args, **kwargs)
+
+            sig = inspect.signature(func)
+            resolved: dict[str, Any] = {}
+
+            for name, param in sig.parameters.items():
+                if name in ("self", *kwargs):
+                    continue
+                annotation = param.annotation
+                if annotation is inspect.Parameter.empty:
+                    continue
+                if container.is_registered(annotation):
+                    resolved[name] = await container.resolve(annotation)
+
+            return await func(self, *args, **{**resolved, **kwargs})
+
+        return wrapper
+
+    return decorator
+
+
+def register_injectables(container) -> None:
+    """
+    Register all classes decorated with @injectable into the given container.
+
+    Call this once during application startup after all modules are imported.
+
+    Example::
+
+        from vayuapi.di.injectable import register_injectables
+        register_injectables(app.container)
+    """
+    from vayuapi.di.container import ServiceDescriptor
+
+    for cls, meta in _INJECTABLE_REGISTRY.items():
+        service_type = meta["alias"] if meta["alias"] is not None else cls
+        descriptor = ServiceDescriptor(
+            service_type=service_type,
+            lifetime=meta["lifetime"],
+            implementation_type=cls,
+        )
+        container.register(descriptor)
+
+
+__all__ = [
+    "injectable",
+    "inject",
+    "register_injectables",
+]

vayuapi-0.1.4/vayuapi/di/provider.py

@@ -0,0 +1,56 @@
+"""
+ServiceProvider — thin wrapper that exposes resolve() for use inside
+request handlers and middleware via the VayuAPI `Depends` mechanism.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional, Type, TypeVar
+
+T = TypeVar("T")
+
+
+class ServiceProvider:
+    """
+    High-level API for resolving services from a DIContainer within a
+    request scope.
+
+    VayuAPI creates one ServiceProvider per request and injects it when
+    a handler declares ``provider: ServiceProvider`` as a parameter or
+    uses ``Depends(get_service_provider)``.
+
+    Example::
+
+        from vayuapi.di import ServiceProvider
+
+        @app.get("/users")
+        async def list_users(provider: ServiceProvider = Depends(get_provider)):
+            repo = await provider.get(UserRepository)
+            return await repo.all()
+    """
+
+    def __init__(self, container, scope=None):
+        from vayuapi.di.container import DIContainer, ServiceScope
+        self._container: DIContainer = container
+        self._scope: Optional[ServiceScope] = scope
+
+    async def get(self, service_type: Type[T]) -> T:
+        if self._scope is not None:
+            return await self._scope.resolve(service_type)
+        return await self._container.resolve(service_type)
+
+    async def __aenter__(self) -> "ServiceProvider":
+        if self._scope is None:
+            self._scope = self._container.create_scope()
+            await self._scope.__aenter__()
+        return self
+
+    async def __aexit__(self, *args) -> None:
+        if self._scope is not None:
+            await self._scope.__aexit__(*args)
+
+    def __repr__(self) -> str:
+        return f"ServiceProvider(container={self._container!r})"
+
+
+__all__ = ["ServiceProvider"]