fastapi-async-db-plugin 0.1.0__tar.gz

fastapi_async_db_plugin-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Your Name
+
+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_async_db_plugin-0.1.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: fastapi-async-db-plugin
+Version: 0.1.0
+Summary: A production-grade async SQLAlchemy database plugin for FastAPI.
+Author-email: vaibhav734 <vaibhav734@users.noreply.github.com>
+Project-URL: Homepage, https://github.com/vaibhav734/astapi-async-db-plugin
+Project-URL: Bug Tracker, https://github.com/vaibhav734/astapi-async-db-plugin/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: FastAPI
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Database
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: sqlalchemy[asyncio]>=2.0.0
+Requires-Dist: asyncpg>=0.28.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Dynamic: license-file
+
+# FastAPI Async DB Plugin
+
+A reusable, boilerplate-free async database plugin for FastAPI using SQLAlchemy 2.0 and asyncpg.
+
+## Installation
+
+```bash
+pip install fastapi-async-db-plugin
+```
+
+## Setup & Usage
+
+Simply import the plugin functions into your FastAPI app and provide a `.env` file with `DATABASE_URL`:
+
+```env
+DATABASE_URL=postgresql+asyncpg://user:password@localhost:5432/dbname
+```
+
+### Example `main.py`
+```python
+from fastapi import FastAPI, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from fastapi_db_plugin import get_db_session, register_db_events
+from fastapi_db_plugin.models_example import User
+
+app = FastAPI(title="Reusable DB App Example")
+
+# Automatically wire up connection pools and dispose them on shutdown.
+register_db_events(app, create_all=True)
+
+@app.post("/users/")
+async def create_user(username: str, email: str, db: AsyncSession = Depends(get_db_session)):
+    new_user = User(username=username, email=email)
+    db.add(new_user)
+    
+    await db.commit()
+    await db.refresh(new_user)
+    
+    return {"id": new_user.id, "username": new_user.username, "email": new_user.email}
+
+@app.get("/users/")
+async def list_users(db: AsyncSession = Depends(get_db_session)):
+    result = await db.execute(select(User))
+    users = result.scalars().all()
+    return [{"id": u.id, "username": u.username, "email": u.email} for u in users]
+```

fastapi_async_db_plugin-0.1.0/README.md

@@ -0,0 +1,48 @@
+# FastAPI Async DB Plugin
+
+A reusable, boilerplate-free async database plugin for FastAPI using SQLAlchemy 2.0 and asyncpg.
+
+## Installation
+
+```bash
+pip install fastapi-async-db-plugin
+```
+
+## Setup & Usage
+
+Simply import the plugin functions into your FastAPI app and provide a `.env` file with `DATABASE_URL`:
+
+```env
+DATABASE_URL=postgresql+asyncpg://user:password@localhost:5432/dbname
+```
+
+### Example `main.py`
+```python
+from fastapi import FastAPI, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from fastapi_db_plugin import get_db_session, register_db_events
+from fastapi_db_plugin.models_example import User
+
+app = FastAPI(title="Reusable DB App Example")
+
+# Automatically wire up connection pools and dispose them on shutdown.
+register_db_events(app, create_all=True)
+
+@app.post("/users/")
+async def create_user(username: str, email: str, db: AsyncSession = Depends(get_db_session)):
+    new_user = User(username=username, email=email)
+    db.add(new_user)
+    
+    await db.commit()
+    await db.refresh(new_user)
+    
+    return {"id": new_user.id, "username": new_user.username, "email": new_user.email}
+
+@app.get("/users/")
+async def list_users(db: AsyncSession = Depends(get_db_session)):
+    result = await db.execute(select(User))
+    users = result.scalars().all()
+    return [{"id": u.id, "username": u.username, "email": u.email} for u in users]
+```

fastapi_async_db_plugin-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fastapi-async-db-plugin"
+version = "0.1.0"
+authors = [
+  { name="vaibhav734", email="vaibhav734@users.noreply.github.com" },
+]
+description = "A production-grade async SQLAlchemy database plugin for FastAPI."
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Framework :: FastAPI",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Database",
+]
+dependencies = [
+    "fastapi>=0.100.0",
+    "sqlalchemy[asyncio]>=2.0.0",
+    "asyncpg>=0.28.0",
+    "pydantic>=2.0.0",
+    "pydantic-settings>=2.0.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/vaibhav734/astapi-async-db-plugin"
+"Bug Tracker" = "https://github.com/vaibhav734/astapi-async-db-plugin/issues"

fastapi_async_db_plugin-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fastapi_async_db_plugin-0.1.0/src/fastapi_async_db_plugin.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: fastapi-async-db-plugin
+Version: 0.1.0
+Summary: A production-grade async SQLAlchemy database plugin for FastAPI.
+Author-email: vaibhav734 <vaibhav734@users.noreply.github.com>
+Project-URL: Homepage, https://github.com/vaibhav734/astapi-async-db-plugin
+Project-URL: Bug Tracker, https://github.com/vaibhav734/astapi-async-db-plugin/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: FastAPI
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Database
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: sqlalchemy[asyncio]>=2.0.0
+Requires-Dist: asyncpg>=0.28.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Dynamic: license-file
+
+# FastAPI Async DB Plugin
+
+A reusable, boilerplate-free async database plugin for FastAPI using SQLAlchemy 2.0 and asyncpg.
+
+## Installation
+
+```bash
+pip install fastapi-async-db-plugin
+```
+
+## Setup & Usage
+
+Simply import the plugin functions into your FastAPI app and provide a `.env` file with `DATABASE_URL`:
+
+```env
+DATABASE_URL=postgresql+asyncpg://user:password@localhost:5432/dbname
+```
+
+### Example `main.py`
+```python
+from fastapi import FastAPI, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from fastapi_db_plugin import get_db_session, register_db_events
+from fastapi_db_plugin.models_example import User
+
+app = FastAPI(title="Reusable DB App Example")
+
+# Automatically wire up connection pools and dispose them on shutdown.
+register_db_events(app, create_all=True)
+
+@app.post("/users/")
+async def create_user(username: str, email: str, db: AsyncSession = Depends(get_db_session)):
+    new_user = User(username=username, email=email)
+    db.add(new_user)
+    
+    await db.commit()
+    await db.refresh(new_user)
+    
+    return {"id": new_user.id, "username": new_user.username, "email": new_user.email}
+
+@app.get("/users/")
+async def list_users(db: AsyncSession = Depends(get_db_session)):
+    result = await db.execute(select(User))
+    users = result.scalars().all()
+    return [{"id": u.id, "username": u.username, "email": u.email} for u in users]
+```

fastapi_async_db_plugin-0.1.0/src/fastapi_async_db_plugin.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/fastapi_async_db_plugin.egg-info/PKG-INFO
+src/fastapi_async_db_plugin.egg-info/SOURCES.txt
+src/fastapi_async_db_plugin.egg-info/dependency_links.txt
+src/fastapi_async_db_plugin.egg-info/requires.txt
+src/fastapi_async_db_plugin.egg-info/top_level.txt
+src/fastapi_db_plugin/__init__.py
+src/fastapi_db_plugin/config.py
+src/fastapi_db_plugin/models_example.py
+src/fastapi_db_plugin/session.py

fastapi_async_db_plugin-0.1.0/src/fastapi_async_db_plugin.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fastapi_async_db_plugin-0.1.0/src/fastapi_async_db_plugin.egg-info/requires.txt

@@ -0,0 +1,5 @@
+fastapi>=0.100.0
+sqlalchemy[asyncio]>=2.0.0
+asyncpg>=0.28.0
+pydantic>=2.0.0
+pydantic-settings>=2.0.0

fastapi_async_db_plugin-0.1.0/src/fastapi_async_db_plugin.egg-info/top_level.txt

@@ -0,0 +1 @@
+fastapi_db_plugin

fastapi_async_db_plugin-0.1.0/src/fastapi_db_plugin/__init__.py

@@ -0,0 +1,9 @@
+from .config import DatabaseSettings
+from .session import Base, get_db_session, register_db_events
+
+__all__ = [
+    "DatabaseSettings",
+    "Base",
+    "get_db_session",
+    "register_db_events",
+]

fastapi_async_db_plugin-0.1.0/src/fastapi_db_plugin/config.py

@@ -0,0 +1,18 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+class DatabaseSettings(BaseSettings):
+    # E.g., postgresql+asyncpg://user:password@localhost:5432/dbname
+    DATABASE_URL: str
+    
+    # SQLAlchemy engine pool parameters
+    pool_size: int = 5
+    max_overflow: int = 10
+    pool_recycle: int = 3600
+    pool_pre_ping: bool = True
+    echo: bool = False
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore"
+    )

fastapi_async_db_plugin-0.1.0/src/fastapi_db_plugin/models_example.py

@@ -0,0 +1,14 @@
+from sqlalchemy import String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .session import Base
+
+class User(Base):
+    __tablename__ = "users"
+
+    id: Mapped[int] = mapped_column(primary_key=True, index=True, autoincrement=True)
+    username: Mapped[str] = mapped_column(String(50), unique=True, index=True, nullable=False)
+    email: Mapped[str] = mapped_column(String(255), unique=True, index=True, nullable=False)
+
+    def __repr__(self) -> str:
+        return f"<User(id={self.id}, username='{self.username}', email='{self.email}')>"

fastapi_async_db_plugin-0.1.0/src/fastapi_db_plugin/session.py

@@ -0,0 +1,93 @@
+import logging
+from typing import AsyncGenerator
+
+from fastapi import FastAPI
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+from sqlalchemy.orm import declarative_base
+
+from .config import DatabaseSettings
+
+logger = logging.getLogger(__name__)
+
+Base = declarative_base()
+
+class DatabaseManager:
+    def __init__(self) -> None:
+        self.engine: AsyncEngine | None = None
+        self.session_factory: async_sessionmaker[AsyncSession] | None = None
+
+    def init_db(self, settings: DatabaseSettings) -> None:
+        """Initialize the global async engine and session factory."""
+        if self.engine is None:
+            self.engine = create_async_engine(
+                settings.DATABASE_URL,
+                pool_size=settings.pool_size,
+                max_overflow=settings.max_overflow,
+                pool_recycle=settings.pool_recycle,
+                pool_pre_ping=settings.pool_pre_ping,
+                echo=settings.echo,
+            )
+            self.session_factory = async_sessionmaker(
+                bind=self.engine,
+                class_=AsyncSession,
+                expire_on_commit=False,
+                autoflush=False,
+                autocommit=False,
+            )
+
+    async def close_db(self) -> None:
+        """Dispose of the global async engine."""
+        if self.engine is not None:
+            await self.engine.dispose()
+            self.engine = None
+            self.session_factory = None
+
+# Global instance holding the engine state
+db_manager = DatabaseManager()
+
+async def get_db_session() -> AsyncGenerator[AsyncSession, None]:
+    """
+    FastAPI dependency that provides a safe per-request database session.
+    Automatically rolls back transactions if an exception occurs routing.
+    """
+    if db_manager.session_factory is None:
+        raise RuntimeError("Database is not initialized. Call register_db_events(app) on startup.")
+
+    async with db_manager.session_factory() as session:
+        try:
+            yield session
+        except Exception:
+            await session.rollback()
+            raise
+        finally:
+            await session.close()
+
+
+def register_db_events(app: FastAPI, create_all: bool = False) -> None:
+    """
+    Register startup and shutdown events for the database lifecycle.
+    Attaches engine initialization and teardown securely to the app.
+    """
+    settings = DatabaseSettings()
+
+    @app.on_event("startup")
+    async def on_startup() -> None:
+        logger.info("Initializing database connection...")
+        db_manager.init_db(settings)
+        
+        if create_all:
+            if db_manager.engine is None:
+                raise RuntimeError("Engine initialization failed.")
+            logger.info("Creating database tables...")
+            async with db_manager.engine.begin() as conn:
+                await conn.run_sync(Base.metadata.create_all)
+
+    @app.on_event("shutdown")
+    async def on_shutdown() -> None:
+        logger.info("Closing database connection...")
+        await db_manager.close_db()