fastapi-sqlalchemy-ease 0.1.4__py3-none-any.whl

fastapi_sqlalchemy_ease/__init__.py

@@ -0,0 +1,12 @@
+from .core import SQLAlchemy
+from .exceptions import DatabaseError, DatabaseNotInitializedError
+
+__version__='0.1.4'
+
+# when someone call: from fastapi_sqlalchemy import SQLAlchemy
+# only these things are available
+__all__ = [
+    "SQLAlchemy",
+    "DatabaseError",
+    "DatabaseNotInitializedError",
+] 

fastapi_sqlalchemy_ease/core.py

@@ -0,0 +1,143 @@
+from sqlalchemy import (
+    create_engine,
+    Column, Integer, String, Text, Float, Boolean, 
+    Date, DateTime, Time,
+    JSON, LargeBinary, 
+    Numeric,
+    ForeignKey,
+    UniqueConstraint, CheckConstraint,
+    Index, Table
+)
+from sqlalchemy.orm import declarative_base, sessionmaker, Session, relationship
+from typing import Generator, Optional
+from .exceptions import DatabaseNotInitializedError
+
+
+class SQLAlchemy:
+    # Singleton - ensures only one instance exists in the app
+    _instance = None
+
+    # All sqlalchemy types as class attributes
+    '''Data types'''
+    Column = Column
+    String = String
+    Integer = Integer
+    Float = Float
+    Boolean = Boolean
+    Text = Text
+    Date = Date
+    DateTime = DateTime
+    Time = Time
+    JSON = JSON
+    LargeBinary = LargeBinary
+    Numeric = Numeric
+
+    '''Relationships and Constraints'''
+    ForeignKey = ForeignKey
+    UniqueConstraint = UniqueConstraint
+    CheckConstraint = CheckConstraint
+    Index = Index
+    Table = Table
+    relationship = relationship
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+
+    def __init__(self):
+        # Everything starts as None Until db.init_app() is called
+        self.engine = None
+        self._SessionLocal = None
+        self._Model = None
+        self._initialized = False
+
+
+    def init_app(self, DATABASE_URI: str, connect_args: Optional[dict]=None):
+        '''
+        Docstring for init_app
+        
+        used to Initialized database.
+
+        DATABASE_URI: database url, type : string
+        connect_args: used only when initializing sqlite db
+        '''
+
+        engine_kwargs={}
+
+        if connect_args:
+            engine_kwargs['connect_args'] = connect_args # sqlite need this
+        else:
+            engine_kwargs['pool_pre_ping'] = True # Keeps connection alive for PostgreSQL/MySQL
+
+        # Engine connection to database
+        self.engine = create_engine(DATABASE_URI, **engine_kwargs)
+
+        # SessionLocal - Factory data creates new sessions
+        self._SessionLocal = sessionmaker(autoflush=False ,bind=self.engine)
+
+        # Model - base class, all our database models will inherit from
+        self._Model = declarative_base()
+
+        self._initialized = True
+
+
+    @property
+    def Model(self):
+        '''
+        Docstring for Model
+        
+        Base class for creating database models
+        User writes: class User(db.Model):
+        '''
+
+        if not self._initialized:
+            raise DatabaseNotInitializedError('Database not Intialized, call db.init_app() first.')
+        
+        return self._Model
+    
+
+    def create_all(self):
+        '''
+        Docstring for create_all
+        
+        create all tables in the database
+        '''
+
+        if not self._initialized:
+            raise DatabaseNotInitializedError('Database not Intialized, call db.init_app() first.')
+        
+        self._Model.metadata.create_all(self.engine)
+
+
+    def drop_all(self):
+        '''
+        Docstring for drop_all
+        
+        delete all tables from the database.
+        '''
+        if not self._initialized:
+            raise DatabaseNotInitializedError('Database not Intialized, call db.init_app() first.')
+
+        self._Model.metadata.drop_all(self.engine)
+
+
+    def Session(self) -> Generator[Session, None, None]:
+        '''
+        Docstring for Session
+        
+        creates a new session per request.
+        must use with Depends in FastAPI().
+        Auto closes sessions after request is done.
+
+        '''
+
+        if not self._initialized:
+            raise DatabaseNotInitializedError('Database not Intialized, call db.init_app() first.')
+            
+        session = self._SessionLocal()
+        try:
+            yield session # Give session to the route
+        finally:
+            session.close() #always close after one requst

fastapi_sqlalchemy_ease/exceptions.py

@@ -0,0 +1,7 @@
+class DatabaseError(Exception):
+    """Base error - all other errors inherit from this"""
+    pass
+
+class DatabaseNotInitializedError(DatabaseError):
+    """Raised when someone uses db before calling init_app()"""
+    pass

fastapi_sqlalchemy_ease-0.1.4.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: fastapi-sqlalchemy-ease
+Version: 0.1.4
+Summary: A reusable SQLAlchemy extension for FastAPI
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlalchemy>=2.0.0
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# fastapi-sqlalchemy-ease  
+  
+fastapi-sqlalchemy-ease is a singleton-based SQLAlchemy extension for FastAPI. It provides a centralized interface for database initialization, model declaration, and session management, inspired by the simplicity of Flask-SQLAlchemy.  
+  
+## ◽ Key Features  
+  
+- Singleton Design: Ensures a single database instance across your entire FastAPI application.  
+  
+- Consolidated API: Access all SQLAlchemy types (Integer, String, ForeignKey, etc.) directly from the db object.  
+  
+- Auto-Cleanup: Includes a generator-based session handler designed for FastAPI's Depends to ensure sessions are always closed.  
+  
+- Built-in Lifecycle Management: Simple methods for create_all() and drop_all().  
+  
+  
+## ◽ Installation  
+  
+pip install fastapi-sqlalchemy-ease  
+  
+
+
+## ◽ Usage Guide  
+  
+### 1. Basic setup  
+Initialize your database instance in a centralized file (e.g. database.py).  
+  
+
+    from fastapi_sqlalchemy_ease import SQLAlchemy  
+
+    '''Create the singleton instance''' 
+    db = SQLAlchemy()  
+
+    '''Initialize with your URI'''  
+    DATABASE_URI = "sqlite:///./test.db"  
+
+    '''Use connect_args={"check_same_thread": False} for SQLite'''  
+    db.init_app(DATABASE_URI, connect_args={"check_same_thread": False})  
+  
+  
+  
+### 2. Defining Models  
+No need to import types from SQLAlchemy; use the db instance directly.  
+  
+    class User(db.Model):  
+        __tablename__ = "users"  
+
+        id = db.Column(db.Integer, primary_key=True)  
+        username = db.Column(db.String, unique=True, nullable=False)  
+        created_at = db.Column(db.DateTime)  
+  
+  
+  
+### 3. Creating Tables  
+You can trigger table creation easily.  
+  
+    db.create_all()  
+  
+  
+  
+### 3. Database Operations in Routes  
+Use db.Session with FastAPI's Depends to get a clean session for every request.  
+  
+    from fastapi import FastAPI, Depends  
+    from .. import db  
+
+    app = FastAPI()  
+    
+    @app.get("/users")  
+    def read_users(session: Session = Depends(db.Session)):  
+        users = session.query(User).all()  
+        return users  
+  
+  
+  
+## ◽ Available Attributes  
+Your db instance provides easy access to standard SQLAlchemy types and constraints:  
+  
+Category - Available Attributes  
+
+Data Types	-  String, Integer, Float, Boolean, Text, Date, DateTime, JSON, Numeric  
+Constraints	- ForeignKey, UniqueConstraint, CheckConstraint, Index  
+ORM	- relationship, Table, Column  
+  
+  
+  
+## ◽ Error Handling
+The library includes a DatabaseNotInitializedError. If you attempt to access db.Model, db.Session, or lifecycle methods before calling db.init_app(), a clear exception will be raised to help you debug quickly.  
+  
+
+  
+## 📄 License
+Distributed under the MIT License.  
+
+--

fastapi_sqlalchemy_ease-0.1.4.dist-info/RECORD

@@ -0,0 +1,8 @@
+fastapi_sqlalchemy_ease/__init__.py,sha256=iSppUZlZ6IKZuuDzaoc0pjDer-EEg1gtr5PjSMUgm3w,303
+fastapi_sqlalchemy_ease/core.py,sha256=nQSzioMp6TiD7yuKD7niImA2BSL2PQLCKnCzk0eFWrA,3920
+fastapi_sqlalchemy_ease/exceptions.py,sha256=6YU6mJvOGXC9D0mPH99GjMWpj21NA5jD8II7DWEcHaA,222
+fastapi_sqlalchemy_ease-0.1.4.dist-info/licenses/LICENSE,sha256=jVnW2ZK4LFNHmDZE-xj0EyVpbHVMpwO7FcTk_We8qrA,1068
+fastapi_sqlalchemy_ease-0.1.4.dist-info/METADATA,sha256=13RjpemmXPdFHY0tLpQxHN7THFuG1U-WQTxFRcvA71c,3144
+fastapi_sqlalchemy_ease-0.1.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+fastapi_sqlalchemy_ease-0.1.4.dist-info/top_level.txt,sha256=Y9kRilavMJot8bwOZymZ0cRjiBNIzsVqx9EwvXGiq-8,24
+fastapi_sqlalchemy_ease-0.1.4.dist-info/RECORD,,

fastapi_sqlalchemy_ease-0.1.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fastapi_sqlalchemy_ease-0.1.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hardik Soni
+
+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_sqlalchemy_ease-0.1.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+fastapi_sqlalchemy_ease