fixed codestyle

Author: Tert0

docs/database/insert_delete_modify.md

@@ -7,10 +7,12 @@ With `db.add` you can insert Date into the Database
 ```python
 from fastapi_framework.database import db
 
+
 class MyModel(db.Base):
     # The Model Code
     pass
 
+
 async def main():
     obj: MyModel = MyModel(x=1)
     await db.add(obj)
@@ -23,10 +25,12 @@ With `db.delete` you can delete Data from your Database
 ```python
 from fastapi_framework.database import db, select
 
+
 class MyModel(db.Base):
     # The Model Code
     pass
 
+
 async def main():
     model: MyModel = await select(MyModel).filter_by(x=1)
     await db.delete(model)
@@ -39,10 +43,12 @@ You can modify Data in your Database by change the Model Class Attribute
 ```python
 from fastapi_framework.database import db, select
 
+
 class MyModel(db.Base):
     # The Model Code
     pass
 
+
 async def main():
     model: MyModel = await select(MyModel).filter_by(x=1)
     model.x = 1

docs/database/query.md

@@ -10,12 +10,14 @@ from fastapi_framework.database import select, filter_by
 ```python
 from fastapi_framework.database import db, select
 
+
 class MyModel(db.Base):
     # The Model Code
     pass
 
+
 async def main():
-    query = select(MyModel) # Selects all from the MyModel table
+    query = select(MyModel)  # Selects all from the MyModel table
 ```
 
 ## Filter By
@@ -25,12 +27,14 @@ async def main():
 ```python
 from fastapi_framework.database import db, select, filter_by
 
+
 class MyModel(db.Base):
     # The Model Code
     pass
 
+
 async def main():
-    query = filter_by(MyModel, id=1) # Selects all from the MyModel table where id is 1
+    query = filter_by(MyModel, id=1)  # Selects all from the MyModel table where id is 1
     # Same here:
     query = select(MyModel).filter_by(id=1)
 ```
@@ -45,27 +49,32 @@ Could be `None`
 ```python
 from fastapi_framework.database import db, select
 
+
 class MyModel(db.Base):
     # The Model Code
     pass
 
+
 async def main():
-    query = select(MyModel) # Your Query
+    query = select(MyModel)  # Your Query
     result: MyModel = await db.first(query)
 ```
 
 ### Get All Element
 Returns all results for the query.
 Could be `[]`
+
 ```python
 from fastapi_framework.database import db, select
 
+
 class MyModel(db.Base):
     # The Model Code
     pass
 
+
 async def main():
-    query = select(MyModel) # Your Query
+    query = select(MyModel)  # Your Query
     result: list[MyModel] = await db.all(query)
 ```
 
@@ -76,12 +85,14 @@ Checks if data for this query exists
 ```python
 from fastapi_framework.database import db, select
 
+
 class MyModel(db.Base):
     # The Model Code
     pass
 
+
 async def main():
-    query = select(MyModel) # Your Query
+    query = select(MyModel)  # Your Query
     exists: bool = await db.exists(query)
 ```
 
@@ -92,12 +103,14 @@ Returns count of matching rows for the query
 ```python
 from fastapi_framework.database import db, select
 
+
 class MyModel(db.Base):
     # The Model Code
     pass
 
+
 async def main():
-    query = select(MyModel) # Your Query
+    query = select(MyModel)  # Your Query
     count: int = await db.count(query)
 ```
 

fastapi_framework/config.py

@@ -97,15 +97,15 @@ def __new__(mcs, name, bases, dct):
             if config_key in config.keys():
                 type_hint = config_entries[key].type_hint
                 if type_hint:
-                    value = type_hint(config[config_key]) if config[config_key] is not None else None
+                    cfg_value = type_hint(config[config_key]) if config[config_key] is not None else None
                 else:
-                    value = config[config_key]
+                    cfg_value = config[config_key]
                 for middleware in config_entries[key].middlewares:
-                    value = middleware(value)
-                setattr(config_class, key, value)
+                    cfg_value = middleware(cfg_value)
+                setattr(config_class, key, cfg_value)
             else:
-                value = config_entries[config_key].default_value
-                setattr(config_class, key, value)
+                cfg_value = config_entries[config_key].default_value
+                setattr(config_class, key, cfg_value)
 
         return config_class
 

fastapi_framework/database.py

@@ -1,11 +1,11 @@
 from os import getenv
-from typing import TypeVar, Dict
+from typing import TypeVar, Dict, Type, TypeAlias
 
 from dotenv import load_dotenv
 from sqlalchemy.engine import URL
-from sqlalchemy.ext.asyncio import create_async_engine, AsyncEngine, AsyncSession
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncEngine, AsyncSession, async_sessionmaker
 from sqlalchemy.future import select as sa_select
-from sqlalchemy.orm import DeclarativeMeta, declarative_base, sessionmaker
+from sqlalchemy.orm import DeclarativeMeta, declarative_base, sessionmaker, DeclarativeBase
 from sqlalchemy.pool import NullPool
 from sqlalchemy.sql import Executable
 from sqlalchemy.sql.expression import exists as sa_exists, delete as sa_delete, Delete
@@ -40,26 +40,30 @@ def delete(table) -> Delete:
     return sa_delete(table)
 
 
+class Base(DeclarativeBase):
+    pass
+
+
 class DB:
     """An async SQLAlchemy ORM wrapper"""
 
-    Base: DeclarativeMeta
     _engine: AsyncEngine
     _session: AsyncSession
 
-    def __init__(self, driver: str, options: Dict = {"pool_size": 20, "max_overflow": 20}, **kwargs):
-        url: str = URL.create(drivername=driver, **kwargs)
+    def __init__(self, driver: str, options=None, **kwargs):
+        if options is None:
+            options = {"pool_size": 20, "max_overflow": 20}
+        url = URL.create(drivername=driver, **kwargs)
         self._engine = create_async_engine(url, echo=True, pool_pre_ping=True, pool_recycle=300, **options)
-        self.Base = declarative_base()
-        self._session: AsyncSession = sessionmaker(self._engine, expire_on_commit=False, class_=AsyncSession)()
+        self._session = async_sessionmaker(self._engine, expire_on_commit=False)()
 
     async def create_tables(self):
         """Creates all Model Tables"""
         async with self._engine.begin() as conn:
-            await conn.run_sync(self.Base.metadata.create_all)
+            await conn.run_sync(Base.metadata.create_all)
 
     async def add(self, obj: T) -> T:
-        """Adds an Row to the Database"""
+        """Adds a Row to the Database"""
         self._session.add(obj)
         return obj
 
@@ -153,4 +157,3 @@ async def __call__(self) -> DB:
 
 
 database_dependency: DatabaseDependency = DatabaseDependency()
-Base: DeclarativeMeta = database_dependency.db.Base

fastapi_framework/rate_limit.py

@@ -15,6 +15,8 @@ async def default_callback(headers: Dict):
 
 async def default_get_uuid(request: Request) -> str:
     """Default getter for UUID working with Users IP"""
+    if request.client is None:
+        return "unknown-ip"
     return f"{request.client.host}"
 
 

fastapi_framework/session.py

@@ -68,7 +68,7 @@ def __init__(
         self.session_expire = session_expire
 
         async def _middleware(request: Request, call_next: RequestResponseEndpoint) -> Response:
-            result: Union[Request, Coroutine] = middleware(self, request, call_next)
+            result: Union[Response, Coroutine] = middleware(self, request, call_next)
             if isinstance(result, Coroutine):
                 return await result
             return result

fastapi_framework/settings.py

@@ -1,7 +1,8 @@
 from os import getenv
 from typing import Union, Optional
 
-from sqlalchemy import Column, String
+from sqlalchemy import String
+from sqlalchemy.orm import Mapped, mapped_column
 
 from .redis import redis_dependency, Redis
 from .database import database_dependency, DB, select, Base
@@ -11,8 +12,8 @@
 
 class SettingsModel(Base):
     __tablename__ = "settings"
-    key: Union[str, Column] = Column(String(255), primary_key=True, unique=True)
-    value: Union[str, Column] = Column(String())
+    key: Mapped[str] = mapped_column(String(255), primary_key=True, unique=True)
+    value: Mapped[str] = mapped_column(String())
 
     @staticmethod
     async def create(key: str, value: Union[str, int, float, bool], db: DB) -> "SettingsModel":

tests/test_database.py

@@ -6,6 +6,7 @@
 from fastapi import HTTPException, FastAPI, Depends
 from pydantic import BaseModel, constr, conint
 from sqlalchemy import Column, String, Integer
+from sqlalchemy.orm import mapped_column, Mapped
 
 from fastapi_framework.database import (
     select,
@@ -27,8 +28,8 @@
 
 class User(Base):
     __tablename__ = "users"
-    id: Union[Column, int] = Column(Integer, primary_key=True)
-    name: Union[Column, str] = Column(String(255), unique=True)
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    name: Mapped[str] = mapped_column(String(255), unique=True)
 
     @staticmethod
     async def create(name: str) -> "User":
@@ -48,7 +49,7 @@ class PydanticUser(BaseModel):
 
 @app.get("/users")
 async def get_users(db: DB = Depends(database_dependency)) -> List[PydanticUser]:
-    return list(map(User.to_pydantic_user, await db.all(select(User))))
+    return [user.to_pydantic_user() for user in await db.all(select(User))]
 
 
 @app.get("/users/{name}")