organize

app.py

@@ -1,6 +1,7 @@
 from fastapi import FastAPI
 from pydantic import BaseModel
 import uvicorn
+
 from controllers import album
 
 # Initialize the app

controllers/album.py

@@ -2,8 +2,7 @@ from fastapi import APIRouter, Depends, HTTPException
 from fastapi_utils.cbv import cbv
 from sqlalchemy.orm import Session
 
-from models.album import get_all_albums, create_album, get_album_by_id, update_album, delete_album, AlbumException
+import models
-from models.schemas import Album, CreateAndUpdateAlbum, PaginatedAlbum
 
 from database import get_db
 
@@ -15,42 +14,41 @@ class Albums:
     session: Session = Depends(get_db)
 
     # API to get the list of album info
-    @router.get("/albums", response_model=PaginatedAlbum)
+    @router.get("/albums", response_model=models.schemas.PaginatedAlbum)
     def list_albums(self, limit: int = 10, offset: int = 0):
 
-        albums_list = get_all_albums(self.session, limit, offset)
+        albums_list = models.album.get_all_albums(self.session, limit, offset)
         response = {"limit": limit, "offset": offset, "data": albums_list}
 
         return response
 
     # API endpoint to add an album to the database
     @router.post("/albums")
-    def add_album(self, album: CreateAndUpdateAlbum):
+    def add_album(self, album: models.schemas.AlbumBase):
-
         try:
-            album = create_album(self.session, album)
+            album = models.album.create_album(self.session, album)
             return album
-        except AlbumException as ex:
+        except models.exceptions.AlbumException as ex:
             raise HTTPException(**ex.__dict__)
 
 
 # API endpoint to get info of a particular album
-@router.get("/albums/{album_id}", response_model=Album)
+@router.get("/albums/{album_id}", response_model=models.schemas.Album)
 def get_album(album_id: int, session: Session = Depends(get_db)):
     try:
-        album = get_album_by_id(session, album_id)
+        album = models.album.get_album_by_id(session, album_id)
         return album
-    except AlbumException as ex:
+    except models.exceptions.AlbumException as ex:
         raise HTTPException(**ex.__dict__)
 
 
 # API to update a existing album info
-@router.put("/albums/{album_id}", response_model=Album)
+@router.put("/albums/{album_id}", response_model=models.schemas.Album)
-def update_album(album_id: int, new_info: CreateAndUpdateAlbum, session: Session = Depends(get_db)):
+def update_album(album_id: int, new_info: models.schemas.AlbumBase, session: Session = Depends(get_db)):
     try:
-        album = update_album(session, album_id, new_info)
+        album = models.album.update_album(session, album_id, new_info)
         return album
-    except AlbumException as ex:
+    except models.exceptions.AlbumException as ex:
         raise HTTPException(**ex.__dict__)
 
 
@@ -58,6 +56,6 @@ def update_album(album_id: int, new_info: CreateAndUpdateAlbum, session: Session
 @router.delete("/albums/{album_id}")
 def delete_album(album_id: int, session: Session = Depends(get_db)):
     try:
-        return delete_album(session, album_id)
+        return models.album.delete_album(session, album_id)
-    except AlbumException as ex:
+    except models.exceptions.AlbumException as ex:
         raise HTTPException(**ex.__dict__)

models/album.py

@@ -1,9 +1,12 @@
 from sqlalchemy.schema import Column
 from sqlalchemy.types import String, Integer, Float
-from database import Base
 from typing import List
 from sqlalchemy.orm import Session
-from models.schemas import CreateAndUpdateAlbum
+
+from models import schemas
+
+from database import Base
+from models.exceptions import AlbumNotFoundError, AlbumAlreadyExistError
 
 
 class Album(Base):
@@ -15,22 +18,6 @@ class Album(Base):
     price = Column(Float)
 
 
-class AlbumException(Exception):
-    ...
-
-
-class AlbumNotFoundError(AlbumException):
-    def __init__(self):
-        self.status_code = 404
-        self.detail = "Album  Not Found"
-
-
-class AlbumAlreadyExistError(AlbumException):
-    def __init__(self):
-        self.status_code = 409
-        self.detail = "Album  Already Exists"
-
-
 # Function to get list of album info
 def get_all_albums(session: Session, limit: int, offset: int) -> List[Album]:
     return session.query(Album).offset(offset).limit(limit).all()
@@ -47,7 +34,7 @@ def get_album_by_id(session: Session, _id: int) -> Album:
 
 
 # Function to add a new album info to the database
-def create_album(session: Session, album: CreateAndUpdateAlbum) -> Album:
+def create_album(session: Session, album: schemas.AlbumBase) -> Album:
     album_details = session.query(Album).filter(Album.title == album.title, Album.artist == album.artist).first()
     if album_details is not None:
         raise AlbumAlreadyExistError
@@ -60,7 +47,7 @@ def create_album(session: Session, album: CreateAndUpdateAlbum) -> Album:
 
 
 # Function to update details of the album
-def update_album(session: Session, _id: int, info_update: CreateAndUpdateAlbum) -> Album:
+def update_album(session: Session, _id: int, info_update: schemas.AlbumBase) -> Album:
     album = get_album_by_id(session, _id)
 
     if album is None:

models/exceptions.py

@@ -0,0 +1,14 @@
+class AlbumException(Exception):
+    ...
+
+
+class AlbumNotFoundError(AlbumException):
+    def __init__(self):
+        self.status_code = 404
+        self.detail = "Album  Not Found"
+
+
+class AlbumAlreadyExistError(AlbumException):
+    def __init__(self):
+        self.status_code = 409
+        self.detail = "Album  Already Exists"

models/schemas.py

@@ -3,14 +3,14 @@ from typing import Optional, List
 
 
 # TO support creation and update APIs
-class CreateAndUpdateAlbum(BaseModel):
+class AlbumBase(BaseModel):
     title: str
     artist: str
     price: float
 
 
 # TO support list and get APIs
-class Album(CreateAndUpdateAlbum):
+class Album(AlbumBase):
     id: int
 
     class Config: