fastapi-globals 0.1.0__tar.gz

fastapi_globals-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+/build/
+/dist/
+/wheels/
+/*.egg-info
+/uv.lock
+/.coverage
+/.tox
+
+# Virtual environments
+/.venv

fastapi_globals-0.1.0/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2022 TEAM23 GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.

fastapi_globals-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.3
+Name: fastapi-globals
+Version: 0.1.0
+Summary: Use request global variables in FastAPI
+Requires-Python: >=3.9
+Requires-Dist: fastapi<1.0,>=0.100
+Description-Content-Type: text/markdown
+
+# `fastapi-globals`
+
+Allows you to use request global values. Can be used to store request speficic data, like state, database
+connection, etc.
+
+## Installation
+
+Just use `pip install fastapi-globals` to install the library.
+
+**Note:** `fastapi-globals` is compatible with `fastapi` versions `0.100.0` and later on
+Python `3.9`, `3.10`, `3.11`, `3.12` and `3.13`. This is also ensured running all tests on all those versions
+using `tox`.
+
+# Usage
+
+Just import `g` and then access (set/get) attributes of it:
+```python
+from fastapi_globals import g
+
+
+g.foo = "foo"
+
+# In some other code
+assert g.foo == "foo"
+```
+
+Best way to utilize the global `g` in your code is to set the desired
+value in a FastAPI dependency, like so:
+```python
+async def set_global_foo() -> None:
+    g.foo = "foo"
+
+
+@app.get("/test/", dependencies=[Depends(set_global_foo)])
+async def test():
+    assert g.foo == "foo"
+```
+
+# Setup
+
+Add the `GlobalsMiddleware` to your app:
+```python
+app = fastapi.FastAPI(
+    title="Your app API",
+)
+app.add_middleware(GlobalsMiddleware)  # <-- This line is necessary
+```
+
+Then just use it. ;-)
+
+# Default values
+
+You may use `g.set_default("name", some_value)` to set a default value
+for a global variable. This default value will then be used instead of `None`
+when the variable is accessed before it was set.
+
+Note that default values should only be set at startup time, never
+inside dependencies or similar. Otherwise you may run into the issue that
+the value was already used any thus have a value of `None` set already, which
+would result in the default value not being used.

fastapi_globals-0.1.0/README.md

@@ -0,0 +1,60 @@
+# `fastapi-globals`
+
+Allows you to use request global values. Can be used to store request speficic data, like state, database
+connection, etc.
+
+## Installation
+
+Just use `pip install fastapi-globals` to install the library.
+
+**Note:** `fastapi-globals` is compatible with `fastapi` versions `0.100.0` and later on
+Python `3.9`, `3.10`, `3.11`, `3.12` and `3.13`. This is also ensured running all tests on all those versions
+using `tox`.
+
+# Usage
+
+Just import `g` and then access (set/get) attributes of it:
+```python
+from fastapi_globals import g
+
+
+g.foo = "foo"
+
+# In some other code
+assert g.foo == "foo"
+```
+
+Best way to utilize the global `g` in your code is to set the desired
+value in a FastAPI dependency, like so:
+```python
+async def set_global_foo() -> None:
+    g.foo = "foo"
+
+
+@app.get("/test/", dependencies=[Depends(set_global_foo)])
+async def test():
+    assert g.foo == "foo"
+```
+
+# Setup
+
+Add the `GlobalsMiddleware` to your app:
+```python
+app = fastapi.FastAPI(
+    title="Your app API",
+)
+app.add_middleware(GlobalsMiddleware)  # <-- This line is necessary
+```
+
+Then just use it. ;-)
+
+# Default values
+
+You may use `g.set_default("name", some_value)` to set a default value
+for a global variable. This default value will then be used instead of `None`
+when the variable is accessed before it was set.
+
+Note that default values should only be set at startup time, never
+inside dependencies or similar. Otherwise you may run into the issue that
+the value was already used any thus have a value of `None` set already, which
+would result in the default value not being used.

fastapi_globals-0.1.0/fastapi_globals/__init__.py

@@ -0,0 +1,5 @@
+from .globals import (
+    Globals as Globals,
+    GlobalsMiddleware as GlobalsMiddleware,
+    g as g,
+)

fastapi_globals-0.1.0/fastapi_globals/globals.py

@@ -0,0 +1,139 @@
+"""
+Allow to use global variables inside the FastAPI application using async mode.
+
+# Usage
+
+Just import `g` and then access (set/get) attributes of it:
+```python
+from fastapi_globals import g
+
+
+g.foo = "foo"
+
+# In some other code
+assert g.foo == "foo"
+```
+
+Best way to utilize the global `g` in your code is to set the desired
+value in a FastAPI dependency, like so:
+```python
+async def set_global_foo() -> None:
+    g.foo = "foo"
+
+
+@app.get("/test/", dependencies=[Depends(set_global_foo)])
+async def test():
+    assert g.foo == "foo"
+```
+
+# Setup
+
+Add the `GlobalsMiddleware` to your app:
+```python
+app = fastapi.FastAPI(
+    title="Your app API",
+)
+app.add_middleware(GlobalsMiddleware)  # <-- This line is necessary
+```
+
+Then just use it. ;-)
+
+# Default values
+
+You may use `g.set_default("name", some_value)` to set a default value
+for a global variable. This default value will then be used instead of `None`
+when the variable is accessed before it was set.
+
+Note that default values should only be set at startup time, never
+inside dependencies or similar. Otherwise you may run into the issue that
+the value was already used any thus have a value of `None` set already, which
+would result in the default value not being used.
+"""
+from collections.abc import Awaitable, Callable
+from contextvars import ContextVar, copy_context
+from typing import Any
+
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.types import ASGIApp
+
+
+class Globals:
+    __slots__ = ("_vars", "_defaults")
+
+    _vars: dict[str, ContextVar]
+    _defaults: dict[str, Any]
+
+    def __init__(self) -> None:
+        object.__setattr__(self, '_vars', {})
+        object.__setattr__(self, '_defaults', {})
+
+    def set_default(self, name: str, default: Any) -> None:
+        """Set a default value for a variable."""
+
+        # Ignore if default is already set and is the same value
+        if (
+            name in self._defaults
+            and default is self._defaults[name]
+        ):
+            return
+
+        # Ensure we don't have a value set already - the default will have
+        # no effect then
+        if name in self._vars:
+            raise RuntimeError(
+                f"Cannot set default as variable {name} was already set",
+            )
+
+        # Set the default already!
+        self._defaults[name] = default
+
+    def _get_default_value(self, name: str) -> Any:
+        """Get the default value for a variable."""
+
+        default = self._defaults.get(name, None)
+
+        return default() if callable(default) else default
+
+    def _ensure_var(self, name: str) -> None:
+        """Ensure a ContextVar exists for a variable."""
+
+        if name not in self._vars:
+            default = self._get_default_value(name)
+            self._vars[name] = ContextVar(f"globals:{name}", default=default)
+
+    def __getattr__(self, name: str) -> Any:
+        """Get the value of a variable."""
+
+        self._ensure_var(name)
+        return self._vars[name].get()
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Set the value of a variable."""
+
+        self._ensure_var(name)
+        self._vars[name].set(value)
+
+
+async def globals_middleware_dispatch(
+    request: Request,
+    call_next: Callable,
+) -> Response:
+    """Dispatch the request in a new context to allow globals to be used."""
+
+    ctx = copy_context()
+
+    def _call_next() -> Awaitable[Response]:
+        return call_next(request)
+
+    return await ctx.run(_call_next)
+
+
+class GlobalsMiddleware(BaseHTTPMiddleware):
+    """Middleware to setup the globals context using globals_middleware_dispatch()."""
+
+    def __init__(self, app: ASGIApp) -> None:
+        super().__init__(app, globals_middleware_dispatch)
+
+
+g = Globals()

fastapi_globals-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "fastapi-globals"
+version = "0.1.0"
+description = "Use request global variables in FastAPI"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "fastapi>=0.100,<1.0",
+]
+
+[dependency-groups]
+dev = [
+    "trio>=0.27.0",
+    "httpx>=0.27.2",
+    "pytest-cov>=6.0.0",
+    "pytest>=8.3.3",
+    "anyio>=4.6.2.post1",
+    "pyright>=1.1.389",
+    "ruff>=0.8.0",
+    "tox>=4.23.2",
+    "tomlkit>=0.13.2",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+include = [
+    "fastapi_globals",
+]