fusion 0.1.0__py3-none-any.whl

fusion/__init__.py

@@ -0,0 +1,5 @@
+from .annotations import Cookie, Header, PathParam, QueryParam, RequestBody
+from .application import Fusion
+from .di import Injectable, factory
+from .endpoints import HttpEndpoint
+from .routing import Route

fusion/annotations.py

@@ -0,0 +1,15 @@
+from typing import Annotated
+
+from fusion.resolvers import (
+    CookieResolver,
+    HeaderResolver,
+    PathParamResolver,
+    QueryParamResolver,
+    RequestBodyResolver,
+)
+
+type PathParam[T] = Annotated[T, {"resolver": PathParamResolver}]
+type QueryParam[T] = Annotated[T, {"resolver": QueryParamResolver}]
+type Header[T] = Annotated[T, {"resolver": HeaderResolver}]
+type Cookie[T] = Annotated[T, {"resolver": CookieResolver}]
+type RequestBody[O] = Annotated[O, {"resolver": RequestBodyResolver}]

fusion/application.py

@@ -0,0 +1,11 @@
+from starlette.applications import Starlette
+
+from fusion.routing import Router
+
+
+class Fusion(Starlette):
+    """Fusion application that integrates dependency injection."""
+
+    def __init__(self, routes, middleware=None, lifespan=None):
+        super().__init__(routes=routes, middleware=middleware, lifespan=lifespan)
+        self.router = Router(routes=routes, lifespan=lifespan)

fusion/context.py

@@ -0,0 +1,28 @@
+from contextlib import AsyncExitStack
+from contextvars import ContextVar, Token
+from typing import Self
+
+from starlette.requests import Request
+
+context: ContextVar["Context"] = ContextVar("context")
+
+
+class Context(AsyncExitStack):
+    _token: Token
+    request: Request
+
+    def __init__(self, request: Request):
+        super().__init__()
+        self.request = request
+
+    async def __aenter__(self) -> Self:
+        if context.get(None) is not None:
+            raise RuntimeError("Nested context is not allowed")
+        self._token = context.set(self)
+        return await super().__aenter__()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:  # type:ignore
+        try:
+            await super().__aexit__(exc_type, exc_val, exc_tb)
+        finally:
+            context.reset(self._token)

fusion/di.py

@@ -0,0 +1,102 @@
+from collections.abc import AsyncIterator
+from contextlib import AbstractAsyncContextManager
+from functools import wraps
+from typing import Any, Callable, ClassVar, Self, TypeVar, get_origin
+
+from msgspec import Struct as Object
+
+from fusion.resolvers import (
+    Constructor,
+    FactoryResolver,
+    InjectableResolver,
+    Resolver,
+    __factories__,
+)
+
+T = TypeVar("T")
+
+
+class Injectable(Object):
+    __resolvers__: ClassVar[list[Resolver]]
+
+    def __init_subclass__(cls, *args, **kwargs):
+        cls.__resolvers__ = build_resolvers(cls.__annotations__)
+        super().__init_subclass__(*args, **kwargs)
+
+    @classmethod
+    async def instance(cls) -> Self:
+        """Create an instance of the class with all dependencies resolved."""
+        params = {}
+        for resolver in cls.__resolvers__:
+            name, value = await resolver.resolve()
+            params[name] = value
+
+        return cls(**params)
+
+
+def factory(func: Constructor) -> Constructor:
+    """Decorator to register a factory function for a type."""
+    if "return" not in func.__annotations__:
+        raise ValueError("Factory function must have a return type annotation")
+    # Register the factory function
+    return_annotation = func.__annotations__["return"]
+    origin = get_origin(return_annotation)
+    return_type = return_annotation.__args__[0] if origin is AsyncIterator else return_annotation
+    __factories__[return_type] = func
+    return func
+
+
+def build_resolvers(annotations: dict[str, Any]) -> list[Resolver]:
+    resolvers = []
+    for name, annotation in annotations.items():
+        origin = get_origin(annotation)
+        if not origin:
+            if issubclass(annotation, Injectable):
+                resolvers.append(InjectableResolver(name=name, typ=annotation))
+            elif annotation in __factories__:
+                resolvers.append(FactoryResolver(name=name, typ=annotation))
+            else:
+                raise ValueError(f"Invalid annotation for {name}: {annotation}")
+            continue
+        # skip if annotation is ClassVar
+        if origin is ClassVar:
+            continue
+
+        if len(annotation.__args__) != 1:
+            raise ValueError(f"Invalid annotation for {name}: {annotation}")
+
+        typ = annotation.__args__[0]
+        annotated = origin.__value__
+        if not annotated:
+            raise ValueError(f"Invalid annotation for {name}: {annotation}")
+
+        if not hasattr(annotated, "__metadata__"):
+            raise ValueError(f"Invalid annotation for {name}: {annotation}")
+
+        metadata = annotated.__metadata__[0]
+        DependencyResolver = metadata.get("resolver", None)
+        if not DependencyResolver:
+            raise ValueError(f"No resolver found for {name}: {annotation}")
+
+        if not issubclass(DependencyResolver, Resolver):
+            raise ValueError(f"Invalid resolver for {name}: {annotation}")
+
+        resolvers.append(DependencyResolver(name=name, typ=typ))
+
+    return resolvers
+
+
+def inject(func: Callable) -> Callable:
+    """Decorator to mark a function as an injector."""
+    resolvers = build_resolvers(func.__annotations__)
+
+    @wraps(func)
+    async def wrapper(self, *args, **kwargs):
+        params = {}
+        for resolver in resolvers:
+            name, value = await resolver.resolve()
+            params[name] = value
+        # Call the original function with resolved parameters
+        return await func(self, **params)
+
+    return wrapper

fusion/endpoints.py

@@ -0,0 +1,17 @@
+from typing import ClassVar
+
+from fusion.di import Injectable, inject
+
+
+class HttpEndpoint(Injectable):
+    methods: ClassVar[list[str]]
+
+    def __init_subclass__(cls, *args, **kwargs):
+        cls.methods = []
+        for http_method in ("GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"):
+            method = getattr(cls, http_method.lower(), None)
+            if callable(method):
+                cls.methods.append(http_method)
+                setattr(cls, http_method.lower(), inject(method))
+
+        super().__init_subclass__(*args, **kwargs)

fusion/exceptions.py

@@ -0,0 +1,2 @@
+class ValidationError(Exception):
+    pass

fusion/resolvers.py

@@ -0,0 +1,140 @@
+from abc import abstractmethod
+from collections.abc import AsyncIterator, Awaitable
+from contextlib import AbstractAsyncContextManager
+from typing import (
+    Callable,
+    Generic,
+    Protocol,
+    Self,
+    Type,
+    TypeVar,
+    get_origin,
+)
+
+import msgspec
+from msgspec import Struct as Object
+
+from fusion.context import context
+
+T = TypeVar("T")
+type Constructor[T] = Callable[[], Awaitable[T] | AbstractAsyncContextManager[T]]
+__factories__: dict[Type, Constructor] = {}
+
+
+class InjectableObject(Protocol):
+    @classmethod
+    async def instance(cls) -> Self:
+        ...
+
+
+class Resolver(Object, Generic[T]):
+    """Base class for resolvers."""
+
+    name: str
+    typ: Type[T]
+
+    @abstractmethod
+    async def resolve(self) -> tuple[str, T | None]:
+        """Resolve the dependency."""
+        raise NotImplementedError("Subclasses must implement this method")
+
+
+class InjectableResolver(Resolver[InjectableObject]):
+    """Resolver for injected dependencies."""
+
+    async def resolve(self) -> tuple[str, InjectableObject]:
+        """Resolve the injected dependency."""
+        ctx = context.get()
+        if not ctx:
+            raise RuntimeError("Request context is not available")
+
+        return self.name, await self.typ.instance()
+
+
+def isasynccontextmanager(func: Callable) -> bool:
+    assert hasattr(func, "__annotations__")
+    ret = func.__annotations__.get("return", None)
+    return get_origin(ret) is AsyncIterator if ret else False
+
+
+class FactoryResolver(Resolver[T]):
+    """Resolver for factory functions."""
+
+    async def resolve(self) -> tuple[str, T]:
+        """Resolve the factory function."""
+        factory: Constructor | None = __factories__.get(self.typ)
+        if factory is None:
+            raise ValueError(f"No factory found for {self.typ}")
+
+        if isasynccontextmanager(factory):
+            ctx = context.get()
+            return self.name, await ctx.enter_async_context(factory())  # type: ignore
+        else:
+            return self.name, await factory()  # type: ignore
+
+
+class QueryParamResolver(Resolver[T]):
+    """Resolver for query parameters."""
+
+    async def resolve(self) -> tuple[str, T | None]:
+        """Resolve the query parameter from the request context."""
+        ctx = context.get()
+        value = ctx.request.query_params.get(self.name, None)
+        if value is not None:
+            value = msgspec.convert(value, self.typ, strict=False)
+        return self.name, value
+
+
+class PathParamResolver(Resolver[T]):
+    """Resolver for path parameters."""
+
+    async def resolve(self) -> tuple[str, T | None]:
+        """Resolve the path parameter from the request context."""
+        ctx = context.get()
+        value = ctx.request.path_params.get(self.name, None)
+        if value is not None:
+            value = msgspec.convert(value, self.typ, strict=False)
+        return self.name, value
+
+
+class RequestBodyResolver(Resolver[T]):
+    """Resolver for request body parameters."""
+
+    async def resolve(self) -> tuple[str, T]:
+        """Resolve the request body from the request context."""
+        ctx = context.get()
+        body = await ctx.request.json()
+        value = msgspec.convert(body, self.typ, strict=True)
+        return self.name, value
+
+
+class HeaderResolver(Resolver[T]):
+    """Resolver for header."""
+
+    async def resolve(self) -> tuple[str, T | None]:
+        """Resolve the header parameter from the request context."""
+        ctx = context.get()
+        headers = {
+            key.lower().replace("-", "_").replace(" ", "_"): value
+            for key, value in ctx.request.headers.items()
+        }
+        value = headers.get(self.name, None)
+        if value is not None:
+            value = msgspec.convert(value, self.typ, strict=False)
+        return self.name, value
+
+
+class CookieResolver(Resolver[T]):
+    """Resolver for cookie."""
+
+    async def resolve(self) -> tuple[str, T | None]:
+        """Resolve the cookie parameter from the request context."""
+        ctx = context.get()
+        cookies = {
+            key.lower().replace("-", "_").replace(" ", "_"): value
+            for key, value in ctx.request.cookies.items()
+        }
+        value = cookies.get(self.name, None)
+        if value is not None:
+            value = msgspec.convert(value, self.typ, strict=False)
+        return self.name, value

fusion/routing.py

@@ -0,0 +1,42 @@
+from typing import Type
+
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.responses import PlainTextResponse
+from starlette.routing import Route as StarletteRoute
+from starlette.routing import Router as StarletteRouter
+from starlette.types import Receive, Scope, Send
+
+from fusion.context import Context
+from fusion.endpoints import HttpEndpoint
+
+
+class Route(StarletteRoute):
+    """Custom route that integrates dependency injection."""
+
+    endpoint: HttpEndpoint
+
+    def __init__(self, path: str, endpoint: Type[HttpEndpoint]):
+        super().__init__(path=path, endpoint=endpoint, methods=endpoint.methods)
+
+    async def handle(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["method"] not in self.endpoint.methods:
+            headers = {"Allow": ", ".join(self.endpoint.methods)}
+            if "app" in scope:
+                raise HTTPException(status_code=405, headers=headers)
+            else:
+                response = PlainTextResponse("Method Not Allowed", status_code=405, headers=headers)
+            await response(scope, receive, send)
+        else:
+            request = Request(scope, receive, send)
+            async with Context(request):
+                endpoint = (
+                    await self.endpoint.instance()
+                )  # initialize the endpoint with dependencies resolved
+                method = getattr(endpoint, scope["method"].lower())
+                response = await method()
+                await response(scope, receive, send)
+
+
+class Router(StarletteRouter):
+    ...

fusion-0.1.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: fusion
+Version: 0.1.0
+Summary: Fusion is a modern ASGI web framework for Python with built-in dependency injection, OpenAPI schema generation, and MCP support.
+Project-URL: Homepage, https://github.com/okanakbulut/fusion
+Author: Okan Akbulut
+License-File: LICENSE.md
+Requires-Python: >=3.12
+Requires-Dist: msgspec==0.19.0
+Requires-Dist: starlette==0.47.0
+Provides-Extra: dev
+Requires-Dist: commitizen==4.8.2; extra == 'dev'
+Requires-Dist: coverage[toml]>=6.5; extra == 'dev'
+Requires-Dist: httpx; extra == 'dev'
+Requires-Dist: ipython; extra == 'dev'
+Requires-Dist: pre-commit==4.2.0; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-mock; extra == 'dev'
+Requires-Dist: ruff==0.11.12; extra == 'dev'

fusion-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+fusion/__init__.py,sha256=L-Z54sAceWBwciSBHzkWtfp5q7pTL6K9J4mXhoMWXOc,207
+fusion/annotations.py,sha256=TRslH-aRxKcnwV8Gb6UW7rNHrisEGdj_7M77LkHh_Xs,500
+fusion/application.py,sha256=2h6_hnfAWjAZqX1c3N9NB2OZnq7trLMWzgkHr05rlk8,384
+fusion/context.py,sha256=pygwcKSZZoRX29vVs6WCL41GCxYay4gvwVIRwRSFg2g,816
+fusion/di.py,sha256=8qS5xD45tbLKiQ0aMiiADEnuIBDzMh7LH8B9Kp7mLiw,3458
+fusion/endpoints.py,sha256=_Q9ob3Ya5rkfAr_QT5jyjawe2GaPY3KfJ4Z-rTDqFa8,561
+fusion/exceptions.py,sha256=ifvhlxVWqvNDv8EGYdTGuvYwVV-s0K_mbbwL7vBZiHk,43
+fusion/resolvers.py,sha256=1mrfymBN3HY0pVUK_3qXaD0Kw9xQwHWUH_D1oUM-2AM,4335
+fusion/routing.py,sha256=eFJKfquk3FJps8NgFESB18aBhDxlzYMyvY52mYHihec,1601
+fusion-0.1.0.dist-info/METADATA,sha256=FCgwJV8OM-YhAeqAMyx9qeDTXQ2P5CM9YLSLRigAEPE,842
+fusion-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fusion-0.1.0.dist-info/licenses/LICENSE.md,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fusion-0.1.0.dist-info/RECORD,,

fusion-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any