Enhance examples

Author: vsdudakov

Makefile

@@ -8,11 +8,11 @@ clean:
 .PHONY: fix
 fix:
 	@echo "Run ruff"
-	@exec poetry run ruff --fix fastadmin tests docs
+	@exec poetry run ruff --fix fastadmin tests docs examples
 	@echo "Run isort"
-	@exec poetry run isort fastadmin tests docs
+	@exec poetry run isort fastadmin tests docs examples
 	@echo "Run black"
-	@exec poetry run black fastadmin tests docs
+	@exec poetry run black fastadmin tests docs examples
 	@echo "Run mypy"
 	@exec poetry run mypy -p fastadmin -p docs
 	@echo "Run frontend linters"
@@ -21,11 +21,11 @@ fix:
 .PHONY: lint
 lint:
 	@echo "Run ruff"
-	@exec poetry run ruff fastadmin tests docs
+	@exec poetry run ruff fastadmin tests docs examples
 	@echo "Run isort"
-	@exec poetry run isort --check-only fastadmin tests docs
+	@exec poetry run isort --check-only fastadmin tests docs examples
 	@echo "Run black"
-	@exec poetry run black --check --diff fastadmin tests docs
+	@exec poetry run black --check --diff fastadmin tests docs examples
 	@echo "Run mypy"
 	@exec poetry run mypy -p fastadmin -p docs
 	@echo "Run frontend linters"

docs/build.py

@@ -39,6 +39,12 @@ def read_cls_docstring(cls):
 
 def get_versions():
     return [
+        {
+            "version": "0.2.8",
+            "changes": [
+                "Fix sqlalchemy delete functionality. Add more examples.",
+            ],
+        },
         {
             "version": "0.2.7",
             "changes": [

docs/index.html

@@ -0,0 +1,9 @@
+import os
+import sys
+from pathlib import Path
+
+os.environ["ADMIN_USER_MODEL"] = "User"
+os.environ["ADMIN_USER_MODEL_USERNAME_FIELD"] = "username"
+os.environ["ADMIN_SECRET_KEY"] = "secret"
+
+sys.path.append(str(Path(__file__).resolve().parent))

examples/fastapi_sqlalchemy/__init__.py

@@ -1,43 +1,86 @@
-from typing import List
-
 from fastapi import FastAPI
-from sqlalchemy import Boolean, Integer, String, select, ForeignKey
-from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+from models import Base, BaseEvent, Event, Tournament, User, sqlalchemy_engine, sqlalchemy_sessionmaker
+from sqlalchemy import select, update
 
-from fastadmin import SqlAlchemyModelAdmin, register, fastapi_app as admin_app
+from fastadmin import SqlAlchemyInlineModelAdmin, SqlAlchemyModelAdmin, action, display
+from fastadmin import fastapi_app as admin_app
+from fastadmin import register
 
 
-sqlalchemy_engine = create_async_engine("sqlite+aiosqlite:///:memory:", echo=True)
-sqlalchemy_sessionmaker = async_sessionmaker(sqlalchemy_engine, expire_on_commit=False)
+@register(User, sqlalchemy_sessionmaker=sqlalchemy_sessionmaker)
+class UserModelAdmin(SqlAlchemyModelAdmin):
+    exclude = ("password",)
+    list_display = ("id", "username", "is_superuser")
+    list_display_links = ("id", "username")
+    list_filter = ("id", "username", "is_superuser")
+    search_fields = ("username",)
 
+    async def authenticate(self, username, password):
+        sessionmaker = self.get_sessionmaker()
+        async with sessionmaker() as session:
+            query = select(self.model_cls).filter_by(username=username, password=password, is_superuser=True)
+            result = await session.scalars(query)
+            obj = result.first()
+            if not obj:
+                return None
+            return obj.id
+
+    async def change_password(self, user_id, password):
+        sessionmaker = self.get_sessionmaker()
+        async with sessionmaker() as session:
+            # use hash password for real usage
+            query = update(self.model_cls).where(User.id.in_([user_id])).values(password=password)
+            await session.execute(query)
+            await session.commit()
+
+
+class EventInlineModelAdmin(SqlAlchemyInlineModelAdmin):
+    model = Event
 
-class Base(DeclarativeBase):
-    pass
 
+@register(Tournament, sqlalchemy_sessionmaker=sqlalchemy_sessionmaker)
+class TournamentModelAdmin(SqlAlchemyModelAdmin):
+    list_display = ("id", "name")
+    inlines = (EventInlineModelAdmin,)
 
-class User(Base):
-    __tablename__ = "user"
 
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, nullable=False)
-    username: Mapped[str] = mapped_column(String(length=255), nullable=False)
-    password: Mapped[str] = mapped_column(String(length=255), nullable=False)
-    is_superuser: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
-    is_active: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+@register(BaseEvent, sqlalchemy_sessionmaker=sqlalchemy_sessionmaker)
+class BaseEventModelAdmin(SqlAlchemyModelAdmin):
+    pass
 
-    transactions: Mapped[List["Transaction"]] = relationship(back_populates="user")
 
-    def __str__(self):
-        return self.username
+@register(Event, sqlalchemy_sessionmaker=sqlalchemy_sessionmaker)
+class EventModelAdmin(SqlAlchemyModelAdmin):
+    actions = ("make_is_active", "make_is_not_active")
+    list_display = ("id", "name_with_price", "rating", "event_type", "is_active", "started")
+    raw_id_fields = ("base",)
 
+    @action(description="Make user active")
+    async def make_is_active(self, ids):
+        sessionmaker = self.get_sessionmaker()
+        async with sessionmaker() as session:
+            query = update(Event).where(Event.id.in_(ids)).values(is_active=True)
+            await session.execute(query)
+            await session.commit()
 
-class Transaction(Base):
-    __tablename__ = "transaction"
+    @action
+    async def make_is_not_active(self, ids):
+        sessionmaker = self.get_sessionmaker()
+        async with sessionmaker() as session:
+            query = update(Event).where(Event.id.in_(ids)).values(is_active=False)
+            await session.execute(query)
+            await session.commit()
 
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, nullable=False)
-    user_id: Mapped[int] = mapped_column(ForeignKey("user.id"))
+    @display
+    async def started(self, obj):
+        return bool(obj.start_time)
 
-    user: Mapped["User"] = relationship(back_populates="transactions")
+    @display()
+    async def name_with_price(self, obj):
+        return f"{obj.name} - {obj.price}"
+
+
+app = FastAPI()
 
 
 async def init_db():
@@ -52,43 +95,11 @@ async def create_superuser():
             username="admin",
             password="admin",
             is_superuser=True,
-            is_active=True,
         )
         s.add(user)
         await s.commit()
 
 
-@register(User, sqlalchemy_sessionmaker=sqlalchemy_sessionmaker)
-class UserAdmin(SqlAlchemyModelAdmin):
-    exclude = ("password",)
-    list_display = ("id", "username", "is_superuser", "is_active")
-    list_display_links = ("id", "username")
-    list_filter = ("id", "username", "is_superuser", "is_active")
-    search_fields = ("username",)
-
-    async def authenticate(self, username, password):
-        sessionmaker = self.get_sessionmaker()
-        async with sessionmaker() as session:
-            query = select(User).filter_by(
-                username=username, password=password, is_superuser=True
-            )
-            result = await session.scalars(query)
-            user = result.first()
-            if not user:
-                return None
-            if password != user.password:
-                return None
-            return user.id
-
-@register(Transaction, sqlalchemy_sessionmaker=sqlalchemy_sessionmaker)
-class TransactionAdmin(SqlAlchemyModelAdmin):
-    list_display = ("id", "user")
-    raw_id_fields = ("user",)
-
-
-app = FastAPI()
-
-
 @app.on_event("startup")
 async def startup():
     await init_db()

examples/fastapi_sqlalchemy/example.py

@@ -0,0 +1,109 @@
+import datetime
+import typing as tp
+from decimal import Decimal
+from enum import Enum
+
+from sqlalchemy import JSON, Boolean, Column, Date, DateTime, Float, ForeignKey, Integer, String, Table, Text, Time
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+
+sqlalchemy_engine = create_async_engine("sqlite+aiosqlite:///:memory:", echo=True)
+sqlalchemy_sessionmaker = async_sessionmaker(sqlalchemy_engine, expire_on_commit=False)
+
+
+class EventTypeEnum(str, Enum):
+    PRIVATE = "PRIVATE"
+    PUBLIC = "PUBLIC"
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class BaseModel(Base):
+    __abstract__ = True
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, nullable=False)
+    created_at: Mapped[datetime.datetime] = mapped_column(
+        DateTime, nullable=False, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow
+    )
+    updated_at: Mapped[datetime.datetime] = mapped_column(
+        DateTime, nullable=False, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow
+    )
+
+    @classmethod
+    def get_model_name(cls):
+        return f"sqlalchemy.{cls.__name__}"
+
+
+user_m2m_event = Table(
+    "event_participants",
+    Base.metadata,
+    Column("event_id", ForeignKey("event.id"), primary_key=True),
+    Column("user_id", ForeignKey("user.id"), primary_key=True),
+)
+
+
+class User(BaseModel):
+    __tablename__ = "user"
+
+    username: Mapped[str] = mapped_column(String(length=255), nullable=False)
+    password: Mapped[str] = mapped_column(String(length=255), nullable=False)
+    is_superuser: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+
+    events: Mapped[list["Event"]] = relationship(secondary=user_m2m_event, back_populates="participants")
+
+    async def __str__(self):
+        return self.username
+
+
+class Tournament(BaseModel):
+    __tablename__ = "tournament"
+
+    name: Mapped[str] = mapped_column(String(length=255), nullable=False)
+
+    events: Mapped[list["Event"]] = relationship(back_populates="tournament")
+
+    async def __str__(self):
+        return self.name
+
+
+class BaseEvent(BaseModel):
+    __tablename__ = "base_event"
+
+    name: Mapped[str] = mapped_column(String(length=255), nullable=False)
+    event: Mapped[tp.Optional["Event"]] = relationship(back_populates="base")
+
+    async def __str__(self):
+        return self.name
+
+
+class Event(BaseModel):
+    __tablename__ = "event"
+
+    base_id: Mapped[int | None] = mapped_column(ForeignKey("base_event.id"), nullable=True)
+    base: Mapped[tp.Optional["BaseEvent"]] = relationship(back_populates="event")
+
+    name: Mapped[str] = mapped_column(String(length=255), nullable=False)
+
+    tournament_id: Mapped[int | None] = mapped_column(ForeignKey("tournament.id"), nullable=False)
+    tournament: Mapped[tp.Optional["Tournament"]] = relationship(back_populates="events")
+
+    participants: Mapped[list["User"]] = relationship(secondary=user_m2m_event, back_populates="events")
+
+    rating: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
+    description: Mapped[str | None] = mapped_column(Text, nullable=False)
+    event_type: Mapped[EventTypeEnum] = mapped_column(default=EventTypeEnum.PUBLIC)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+    start_time: Mapped[datetime.time | None] = mapped_column(Time, nullable=True)
+    date: Mapped[datetime.date | None] = mapped_column(Date, nullable=True)
+    latitude: Mapped[float | None] = mapped_column(Float, nullable=True)
+    longitude: Mapped[float | None] = mapped_column(Float, nullable=True)
+    price: Mapped[Decimal | None] = mapped_column(
+        Float(asdecimal=True), nullable=True
+    )  # max_digits=10, decimal_places=2
+
+    json: Mapped[dict | None] = mapped_column(JSON, nullable=True)
+
+    async def __str__(self):
+        return self.name

examples/fastapi_sqlalchemy/models.py

@@ -0,0 +1,9 @@
+all: install run
+
+.PHONY: fastapi
+run:
+	poetry run fastapi dev --reload --port=8090 example.py
+
+.PHONY: install
+install:
+	poetry install

examples/fastapi_tortoiseorm/Makefile

@@ -0,0 +1,12 @@
+## FastAPI + Tortoise ORM Example
+
+- Uses in-memory SQLite 3 instance
+- Creates User mode
+- Creates "admin/admin" superuser
+
+```bash
+make install  # Creates virtualenv with Poetry
+make run      # Runs fastapi dev
+```
+
+So open `http://127.0.0.1:8090/admin/` and have a fun!

examples/fastapi_tortoiseorm/README.md

@@ -0,0 +1,9 @@
+import os
+import sys
+from pathlib import Path
+
+os.environ["ADMIN_USER_MODEL"] = "User"
+os.environ["ADMIN_USER_MODEL_USERNAME_FIELD"] = "username"
+os.environ["ADMIN_SECRET_KEY"] = "secret"
+
+sys.path.append(str(Path(__file__).resolve().parent))