fusion 0.1.0__tar.gz

fusion-0.1.0/.github/workflows/pypi-publish.yml

@@ -0,0 +1,71 @@
+# This workflow will upload a Python Package using Twine when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build release distributions
+        run: |
+          # NOTE: put your own distribution build steps here.
+          python -m pip install build
+          python -m build
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+
+    needs:
+      - release-build
+
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
+
+    #environment:
+    #  name: testpypi
+    #  url: https://test.pypi.org/p/fusion
+    environment:
+       name: pypi
+       url: https://pypi.org/p/fusion
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Publish release distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      #- name: Publish release distributions to TestPyPI
+      #  uses: pypa/gh-action-pypi-publish@release/v1
+      #  with:
+      #    repository-url: https://test.pypi.org/legacy/

fusion-0.1.0/.gitignore

@@ -0,0 +1,168 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.vscode/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# ruff
+.ruff_cache/
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Zed code editor
+# pyright
+pyrightconfig.json

fusion-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,49 @@
+default_language_version:
+  python: "3.12"
+repos:
+  - hooks:
+      - args:
+          - --strict
+          - feat
+          - fix
+          - chore
+          - test
+          - bump
+        id: conventional-pre-commit
+        stages:
+          - commit-msg
+    repo: https://github.com/compilerla/conventional-pre-commit
+    rev: v3.0.0
+  - hooks:
+      - id: check-yaml
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+    repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.3.0
+  - hooks:
+      - args:
+          - --fix
+        id: ruff
+      - id: ruff-format
+    repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.1.8
+  - hooks:
+      - additional_dependencies:
+          - bandit[toml]
+        args:
+          - -c
+          - pyproject.toml
+          - --exclude
+          - tests/*
+        id: bandit
+    repo: https://github.com/PyCQA/bandit
+    rev: 1.7.6
+
+  - repo: local
+    hooks:
+      - id: pytest-check
+        name: pytest-check
+        entry: pytest --cov
+        language: system
+        pass_filenames: false
+        always_run: true

fusion-0.1.0/PKG-INFO

@@ -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/pyproject.toml

@@ -0,0 +1,106 @@
+[project]
+name = "fusion"
+version = "0.1.0"
+description = "Fusion is a modern ASGI web framework for Python with built-in dependency injection, OpenAPI schema generation, and MCP support."
+readme = "README.md"
+requires-python = ">=3.12"
+license = { file = "LICENSE.md" }
+authors = [
+  { name="Okan Akbulut" }
+]
+dependencies = [
+  "msgspec==0.19.0",
+  "starlette==0.47.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/okanakbulut/fusion"
+
+
+[project.optional-dependencies]
+dev = [
+    "coverage[toml]>=6.5",
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "pytest-mock",
+    "pre-commit==4.2.0",
+    "ruff==0.11.12",
+    "commitizen==4.8.2",
+    "ipython",
+    "httpx",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.ruff]
+line-length = 100
+indent-width = 4
+target-version = "py312"
+src = ["src", "tests"]
+unfixable = ["F401"]
+
+
+[tool.ruff.lint]
+fixable = ["ALL"]
+extend-select = ["C90", "I", "F", "E", "ASYNC"]
+extend-ignore = ["F401"]
+
+[tool.ruff.per-file-ignores]
+"**/__init__.py" = ["F401"]
+"**/tests/**" = ["D101", "D102", "D103", "F", "E501"]
+"**/tests/sql/**" = ["E501"]
+
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.mccabe]
+# Flag errors (`C901`) whenever the complexity level exceeds 15.
+max-complexity = 15
+
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+tag_format = "v$version"
+version_scheme = "semver"
+version_provider = "pep621"
+update_changelog_on_bump = true
+major_version_zero = true
+
+[tool.pytest.ini_options]
+addopts = [
+    "--import-mode=importlib",
+    "--doctest-modules",
+    "--quiet",
+    "--tb=long",
+]
+testpaths = ["tests", "src/fusion"]
+
+[tool.coverage.run]
+branch = true
+omit = ["tests/*"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "def __str__",
+    "if self.debug",
+    "if settings.DEBUG",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if 0:",
+    "if __name__ == .__main__.:",
+]
+#fail_under = 100
+#show_missing = true
+#skip_covered = true
+
+[tool.pyright]
+venvPath = "/Users/okanakbulut/.virtualenvs"
+venv = "fusion"
+pythonVersion = "3.12"
+exclude = ["**/__init__.py", "**/__pycache__"]

fusion-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/fusion/exceptions.py

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

fusion-0.1.0/src/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-0.1.0/src/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):
+    ...