Code refactoring. Add support genres and actors to routes

database/__init__.py

@@ -1,7 +1,4 @@
 from .crud import *
 from .schemas import *
-from .database import get_session as get_session, \
-                        drop_all as drop_all, \
-                        create_all as create_all, \
-                        recreate_all as recreate_all
-from .crud import *
+from .database import Database
+from .crud import *

database/crud/__init__.py

@@ -1,4 +1,11 @@
-from .games import *
-from .movies import *
-from .audiobooks import *
-from .users import *
+from .games import GamesCRUD as GamesCRUD
+from .game_genres import GameGenresCRUD as GameGenresCRUD
+
+from .movies import MoviesCRUD as MoviesCRUD
+from .movie_actors import MovieActorsCRUD as MovieActorsCRUD
+from .movie_genres import MovieGenresCRUD as MovieGenresCRUD
+
+from .audiobooks import AudiobooksCRUD as AudiobooksCRUD
+from .audiobook_genres import AudiobookGenresCRUD as AudiobookGenresCRUD
+
+from .users import UsersCRUD as UsersCRUD

database/crud/audiobook_genres.py

@@ -0,0 +1,19 @@
+from time import strftime
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.database import Database, EntityCRUD
+
+from .. import models as mdl
+from .. import schemas as sch
+
+
+class AudiobookGenresCRUD(EntityCRUD[mdl.AudiobookGenre]):
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.AudiobookGenre)
+
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.AudiobookGenreCreate):
+        audiobook_genre = mdl.AudiobookGenre(**info.model_dump())
+        return await Database.add(db, audiobook_genre)

database/crud/audiobooks.py

@@ -1,45 +1,46 @@
 from time import strftime
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.future import select
+
+from database.crud.audiobook_genres import AudiobookGenresCRUD
+from database.database import Database, EntityCRUD
 
 from .. import models as mdl
 from .. import schemas as sch
-from ..database import add_transaction
 
 
-async def get_audiobooks(db: AsyncSession):
-    return (await db.execute(select(mdl.Audiobook))).scalars().all()
+class AudiobooksCRUD(EntityCRUD[mdl.Audiobook]):
+    @staticmethod
+    async def get(db: AsyncSession, id: int):
+        return await Database.get(db, mdl.Audiobook, id)
 
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.Audiobook)
 
-async def get_audiobook(db: AsyncSession, audiobook_id: int):
-    return await db.get(mdl.Audiobook, audiobook_id)
+    @staticmethod
+    async def change_genres(db: AsyncSession, audiobook: mdl.Audiobook, info: sch.AudiobookCreate):
+        audiobook_genres = await AudiobookGenresCRUD.get_all(db)
+        if (info.genres):
+            audiobook.genres = [
+                genre for genre in audiobook_genres if genre.id in info.genres]
 
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.AudiobookCreate,
+                  owner_id: int):
+        audiobook = mdl.Audiobook(**info.model_dump(),
+                                  update_date=strftime("%Y-%m-%d %H:%M:%S"),
+                                  owner_id=owner_id)
+        await AudiobooksCRUD.change_genres(db, audiobook, info)
+        return await Database.add(db, audiobook)
 
-async def add_audiobook(db: AsyncSession,
-                        audiobook_info: sch.AudiobookCreate,
-                        user_id: int):
-    audiobook = mdl.Audiobook(**audiobook_info.model_dump(),
-                              update_date=strftime("%Y-%m-%d %H:%M:%S"),
-                              upload_date=strftime("%Y-%m-%d %H:%M:%S"),
-                              owner_id=user_id)
-    return await add_transaction(db, audiobook)
+    @staticmethod
+    async def change(db: AsyncSession,
+                     id: int,
+                     info: sch.AudiobookCreate):
+        return await Database.change(db, mdl.Audiobook, id, info, AudiobooksCRUD.change_genres)
 
-
-async def edit_audiobook(db: AsyncSession,
-                         audiobook_id: int,
-                         audiobook_info: sch.AudiobookCreate):
-    audiobook = await db.get(mdl.Audiobook, audiobook_id)
-    for key, value in vars(audiobook_info).items():
-        if (getattr(audiobook, key) != value):
-            setattr(audiobook, key, value)
-    setattr(audiobook, "update_date", strftime("%Y-%m-%d %H:%M:%S"))
-    await db.commit()
-    return audiobook
-
-
-async def delete_audiobook(db: AsyncSession,
-                           audiobook_id: int):
-    audiobook = await get_audiobook(db, audiobook_id)
-    await db.delete(audiobook)
-    await db.commit()
-    return audiobook
+    @staticmethod
+    async def delete(db: AsyncSession,
+                     id: int):
+        return await Database.delete(db, mdl.Audiobook, id)

database/crud/game_genres.py

@@ -0,0 +1,20 @@
+from time import strftime
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.database import Database, EntityCRUD
+
+from .. import models as mdl
+from .. import schemas as sch
+
+
+class GameGenresCRUD(EntityCRUD[mdl.GameGenre]):
+
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.GameGenre)
+
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.GameGenreCreate):
+        game_genre = mdl.GameGenre(**info.model_dump())
+        return await Database.add(db, game_genre)

database/crud/games.py

@@ -1,46 +1,46 @@
 from time import strftime
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.future import select
-from sqlalchemy.orm import selectinload
+
+from database.crud.game_genres import GameGenresCRUD
+from database.database import Database, EntityCRUD
 
 from .. import models as mdl
 from .. import schemas as sch
-from ..database import add_transaction
 
 
-async def get_games(db: AsyncSession):
-    return (await db.execute(select(mdl.Game))).scalars().all()
+class GamesCRUD(EntityCRUD[mdl.Game]):
+    @staticmethod
+    async def get(db: AsyncSession, id: int):
+        return await Database.get(db, mdl.Game, id)
 
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.Game)
 
-async def get_game(db: AsyncSession, game_id: int):
-    return await db.get(mdl.Game, game_id)
+    @staticmethod
+    async def change_genres(db: AsyncSession, game: mdl.Game, info: sch.GameCreate):
+        game_genres = await GameGenresCRUD.get_all(db)
+        if (info.genres):
+            game.genres = [
+                genre for genre in game_genres if genre.id in info.genres]
 
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.GameCreate,
+                  owner_id: int):
+        game = mdl.Game(**info.model_dump(),
+                        update_date=strftime("%Y-%m-%d %H:%M:%S"),
+                        owner_id=owner_id)
+        await GamesCRUD.change_genres(db, game, info)
+        return await Database.add(db, game)
 
-async def add_game(db: AsyncSession,
-                   game_info: sch.GameCreate,
-                   user_id: int):
-    game = mdl.Game(**game_info.model_dump(),
-                    update_date=strftime("%Y-%m-%d %H:%M:%S"),
-                    upload_date=strftime("%Y-%m-%d %H:%M:%S"),
-                    owner_id=user_id)
-    return await add_transaction(db, game)
+    @staticmethod
+    async def change(db: AsyncSession,
+                     id: int,
+                     info: sch.GameCreate):
+        return await Database.change(db, mdl.Game, id, info, GamesCRUD.change_genres)
 
-
-async def edit_game(db: AsyncSession,
-                    game_id: int,
-                    game_info: sch.GameCreate):
-    game = await db.get(mdl.Game, game_id)
-    for key, value in vars(game_info).items():
-        if (getattr(game, key) != value):
-            setattr(game, key, value)
-    setattr(game, "update_date", strftime("%Y-%m-%d %H:%M:%S"))
-    await db.commit()
-    return game
-
-
-async def delete_game(db: AsyncSession,
-                      game_id: int):
-    game = await get_game(db, game_id)
-    await db.delete(game)
-    await db.commit()
-    return game
+    @staticmethod
+    async def delete(db: AsyncSession,
+                     id: int):
+        return await Database.delete(db, mdl.Game, id)

database/crud/movie_actors.py

@@ -0,0 +1,19 @@
+from time import strftime
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.database import Database, EntityCRUD
+
+from .. import models as mdl
+from .. import schemas as sch
+
+
+class MovieActorsCRUD(EntityCRUD[mdl.MovieActor]):
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.MovieActor)
+
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.MovieActorCreate):
+        movie_actor = mdl.MovieActor(**info.model_dump())
+        return await Database.add(db, movie_actor)

database/crud/movie_genres.py

@@ -0,0 +1,19 @@
+from time import strftime
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.database import Database, EntityCRUD
+
+from .. import models as mdl
+from .. import schemas as sch
+
+
+class MovieGenresCRUD(EntityCRUD[mdl.MovieGenre]):
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.MovieGenre)
+
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.MovieGenreCreate):
+        movie_genre = mdl.MovieGenre(**info.model_dump())
+        return await Database.add(db, movie_genre)

database/crud/movies.py

@@ -1,45 +1,58 @@
 from time import strftime
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.future import select
+
+from database.crud.movie_actors import MovieActorsCRUD
+from database.crud.movie_genres import MovieGenresCRUD
+from database.database import Database, EntityCRUD
 
 from .. import models as mdl
 from .. import schemas as sch
-from ..database import add_transaction
 
 
-async def get_movies(db: AsyncSession):
-    return (await db.execute(select(mdl.Movie))).scalars().all()
+class MoviesCRUD(EntityCRUD[mdl.Movie]):
+    @staticmethod
+    async def get(db: AsyncSession, id: int):
+        return await Database.get(db, mdl.Movie, id)
 
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.Movie)
 
-async def get_movie(db: AsyncSession, movie_id: int):
-    return await db.get(mdl.Movie, movie_id)
+    @staticmethod
+    async def change_actors(db: AsyncSession, movie: mdl.Movie, info: sch.MovieCreate):
+        movie_actors = await MovieActorsCRUD.get_all(db)
+        if (info.actors):
+            movie.actors = [
+                actor for actor in movie_actors if actor.id in info.actors]
 
+    @staticmethod
+    async def change_genres(db: AsyncSession, movie: mdl.Movie, info: sch.MovieCreate):
+        movie_genres = await MovieGenresCRUD.get_all(db)
+        if (info.genres):
+            movie.genres = [
+                genre for genre in movie_genres if genre.id in info.genres]
 
-async def add_movie(db: AsyncSession,
-                    movie_info: sch.MovieCreate,
-                    user_id: int):
-    movie = mdl.Movie(**movie_info.model_dump(),
-                      update_date=strftime("%Y-%m-%d %H:%M:%S"),
-                      upload_date=strftime("%Y-%m-%d %H:%M:%S"),
-                      owner_id=user_id)
-    return await add_transaction(db, movie)
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.MovieCreate,
+                  owner_id: int):
+        movie = mdl.Movie(**info.model_dump(),
+                          update_date=strftime("%Y-%m-%d %H:%M:%S"),
+                          owner_id=owner_id)
+        await MoviesCRUD.change_genres(db, movie, info)
+        await MoviesCRUD.change_actors(db, movie, info)
+        return await Database.add(db, movie)
 
+    @staticmethod
+    async def change(db: AsyncSession,
+                     id: int,
+                     info: sch.MovieCreate):
+        async def additional_change(db: AsyncSession, movie: mdl.Movie, info: sch.MovieCreate):
+            await MoviesCRUD.change_genres(db, movie, info)
+            await MoviesCRUD.change_actors(db, movie, info)
+        return await Database.change(db, mdl.Movie, id, info, additional_change)
 
-async def edit_movie(db: AsyncSession,
-                     movie_id: int,
-                     movie_info: sch.MovieCreate):
-    movie = await db.get(mdl.Movie, movie_id)
-    for key, value in vars(movie_info).items():
-        if (getattr(movie, key) != value):
-            setattr(movie, key, value)
-    setattr(movie, "update_date", strftime("%Y-%m-%d %H:%M:%S"))
-    await db.commit()
-    return movie
-
-
-async def delete_movie(db: AsyncSession,
-                       movie_id: int):
-    movie = await get_movie(db, movie_id)
-    await db.delete(movie)
-    await db.commit()
-    return movie
+    @staticmethod
+    async def delete(db: AsyncSession,
+                     id: int):
+        return await Database.delete(db, mdl.Movie, id)

database/crud/users.py

@@ -1,26 +1,45 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
 
+from database.database import Database, EntityCRUD
+
 from .. import models as mdl
 from .. import schemas as sch
-from ..database import add_transaction
 
 
-async def get_user(db: AsyncSession, username: str):
-    return (await db.execute(select(mdl.User).where(mdl.User.name == username))).scalar()
+class UsersCRUD(EntityCRUD[mdl.User]):
+    @staticmethod
+    async def get(db: AsyncSession, username: str):
+        return (await db.execute(select(mdl.User).where(mdl.User.name == username))).scalar()
 
+    @staticmethod
+    async def get_all(db: AsyncSession):
+        return await Database.get_all(db, mdl.User)
 
-async def add_user(db: AsyncSession,
-                   user_data: sch.UserCreate, hash_of_password: str):
-    user_data_db = \
-        {k: v for k, v in user_data.model_dump().items()
-         if k != "password"}
-    user = mdl.User(**user_data_db,
-                    hash_of_password=hash_of_password)
-    return await add_transaction(db, user)
+    @staticmethod
+    async def add(db: AsyncSession,
+                  info: sch.UserCreate,
+                  hash_of_password: str):
+        user_data_db = \
+            {k: v for k, v in info.model_dump().items()
+             if k != "password"}
+        user = mdl.User(**user_data_db,
+                        hash_of_password=hash_of_password)
+        return await Database.add(db, user)
 
+    @staticmethod
+    async def change(db: AsyncSession,
+                     id: int,
+                     info: sch.UserCreate):
+        return await Database.change(db, mdl.User, id, info)
 
-async def check_email(db: AsyncSession, email: str):
-    users = (await db.execute(select(mdl.User)
-                              .where(mdl.User.email == email))).scalars().all()
-    return True if len(users) == 0 else False
+    @staticmethod
+    async def delete_user(db: AsyncSession,
+                          id: int):
+        return await Database.delete(db, mdl.User, id)
+
+    @staticmethod
+    async def check_email(db: AsyncSession, email: str):
+        users = (await db.execute(select(mdl.User)
+                                  .where(mdl.User.email == email))).scalars().all()
+        return True if len(users) == 0 else False

database/database.py

@@ -1,4 +1,8 @@
+from abc import ABC, abstractmethod
+from time import strftime
+from typing import Any, Callable, Coroutine, Generic, Type
 from sqlalchemy.orm import sessionmaker
+from sqlalchemy.future import select
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
 
@@ -15,32 +19,103 @@ async_session = sessionmaker(  # type: ignore
 Base = declarative_base()
 
 
-async def get_session() -> AsyncSession:  # type: ignore
-    async with async_session() as session:  # type: ignore
-        yield session                       # type: ignore
+class Database:
+    @staticmethod
+    async def get_session() -> AsyncSession:  # type: ignore
+        async with async_session() as session:  # type: ignore
+            yield session                       # type: ignore
+
+    @staticmethod
+    async def drop_all():
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.drop_all)
+
+    @staticmethod
+    async def create_all():
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+
+    @staticmethod
+    async def recreate_all():
+        await Database.drop_all()
+        await Database.create_all()
+
+    @staticmethod
+    async def get[T](db: AsyncSession, typeof_entity: Type[T], entity_id: int) -> T | None:
+        return await db.get(typeof_entity, entity_id)
+
+    @staticmethod
+    async def get_all[T](db: AsyncSession, typeof_entity: Type[T]) -> list[T]:
+        return list((await db.execute(select(typeof_entity))).scalars().all())
+
+    @staticmethod
+    async def add[T](db: AsyncSession, entity: T) -> T:
+        try:
+            db.add(entity)
+            await db.commit()
+            await db.refresh(entity)
+            return entity
+        except Exception as ex:
+            await db.rollback()
+            raise ex
+
+    @staticmethod
+    async def change[T, U](db: AsyncSession, typeof_entity: Type[T],
+                           entity_id: int, info: U,
+                           additional_change: Callable[[AsyncSession, T, U], Coroutine[Any, Any, None]] | None = None) -> T:
+        try:
+            entity = await db.get(typeof_entity, entity_id)
+            if (entity is None):
+                raise ValueError(f"Can't change entity. " +
+                                 f"{str(typeof_entity)} with id={entity_id} not found")
+            for key, value in vars(info).items():
+                try:
+                    if (getattr(entity, key) != value):
+                        setattr(entity, key, value)
+                except:
+                    ...
+            setattr(entity, "update_date", strftime("%Y-%m-%d %H:%M:%S"))
+            if (additional_change):
+                await additional_change(db, entity, info)
+            await db.commit()
+            return entity
+        except Exception as ex:
+            await db.rollback()
+            raise ex
+
+    @staticmethod
+    async def delete[T](db: AsyncSession, typeof_entity: Type[T], entity_id: int) -> T:
+        try:
+            entity = await db.get(typeof_entity, entity_id)
+            if (entity is None):
+                raise ValueError(f"Can't delete entity. " +
+                                 f"{str(typeof_entity)} with id={entity_id} not found")
+            await db.delete(entity)
+            await db.commit()
+            return entity
+        except Exception as ex:
+            await db.rollback()
+            raise ex
 
 
-async def drop_all():
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.drop_all)
+class EntityCRUD[T](ABC):
+    @staticmethod
+    @abstractmethod
+    async def get(db: AsyncSession, id: int) -> T | None: ...
 
+    @staticmethod
+    @abstractmethod
+    async def get_all(db: AsyncSession) -> list[T]: ...
 
-async def create_all():
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
+    @staticmethod
+    @abstractmethod
+    async def add(db: AsyncSession, entity: T,
+                  owner_id: int | None = None) -> T: ...
 
+    @staticmethod
+    @abstractmethod
+    async def change(db: AsyncSession, entity_id: int, info: object) -> T: ...
 
-async def recreate_all():
-    await drop_all()
-    await create_all()
-
-
-async def add_transaction[T](db: AsyncSession, entity: T) -> T:
-    try:
-        db.add(entity)
-        await db.commit()
-        await db.refresh(entity)
-        return entity
-    except Exception as ex:
-        await db.rollback()
-        raise ex
+    @staticmethod
+    @abstractmethod
+    async def delete(db: AsyncSession, entity_id: int) -> T: ...

database/models/audiobook_genres.py

@@ -11,7 +11,7 @@ class AudiobookGenre(Base):
     genre = Column(String, nullable=False, unique=True)
 
     audiobooks = relationship("Audiobook", secondary="audiobook_to_genre",
-                              lazy="selectin")
+                              lazy="selectin", viewonly=True)
 
 
 class AudiobookToGenre(Base):

database/models/audiobooks.py

@@ -27,3 +27,4 @@ class Audiobook(Base):
                           lazy="selectin")
 
     owner_id = Column(Integer, ForeignKey("users.id"))
+    owner = relationship("User", lazy="selectin", viewonly=True)

database/models/game_genres.py

@@ -11,7 +11,7 @@ class GameGenre(Base):
     genre = Column(String, nullable=False, unique=True)
 
     games = relationship("Game", secondary="game_to_genre",
-                         lazy="selectin")
+                         lazy="selectin", viewonly=True)
 
 
 class GameToGenre(Base):

database/models/movie_actors.py

@@ -10,8 +10,8 @@ class MovieActor(Base):
     id = Column(Integer, primary_key=True)
     actor = Column(String, nullable=False, unique=True)
 
-    movies = relationship("Movies", secondary="movie_to_actor",
-                          lazy="selectin")
+    movies = relationship("Movie", secondary="movie_to_actor",
+                          lazy="selectin", viewonly=True)
 
 
 class MovieToActor(Base):

database/models/movie_genres.py

@@ -10,8 +10,8 @@ class MovieGenre(Base):
     id = Column(Integer, primary_key=True)
     genre = Column(String, nullable=False, unique=True)
 
-    movies = relationship("Movies", secondary="movie_to_genre",
-                          lazy="selectin")
+    movies = relationship("Movie", secondary="movie_to_genre",
+                          lazy="selectin", viewonly=True)
 
 
 class MovieToGenre(Base):

database/models/movies.py

@@ -32,3 +32,4 @@ class Movie(Base):
                           lazy="selectin")
 
     owner_id = Column(Integer, ForeignKey("users.id"))
+    owner = relationship("User", lazy="selectin", viewonly=True)