feat: add music licensing challenge backend example

examples/music-licensing-challenge/Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "src.app.main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]

examples/music-licensing-challenge/Pipfile

@@ -0,0 +1,19 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+fastapi = "==0.104.1"
+uvicorn = "==0.24.0"
+sqlalchemy = "==2.0.23"
+psycopg2-binary = "==2.9.9"
+python-dotenv = "==1.0.0"
+pydantic = "==2.5.2"
+python-multipart = "==0.0.6"
+alembic = "==1.12.1"
+
+[dev-packages]
+
+[requires]
+python_version = "3.12"

examples/music-licensing-challenge/README.md

@@ -0,0 +1,90 @@
+
+# Music Licensing Platform Backend
+
+This is the backend service for the Music Licensing Workflow application. It provides both REST and GraphQL APIs, along with WebSocket support for real-time updates.
+
+This application is built using **FastAPI**, **Strawberry GraphQL**, **SQLAlchemy**, **Pydantic**, and **PostgreSQL**.
+
+## Key Features
+
+* **REST API**: Comprehensive set of RESTful endpoints for CRUD operations on movies, songs, scenes, and licenses.
+* **GraphQL API**: A flexible GraphQL API that allows for detailed queries and mutations, enhancing data retrieval and manipulation.
+* **WebSocket Support**: Real-time updates for license statuses, ensuring that clients are always up-to-date with the latest changes.
+* **Database Integration**: Robust PostgreSQL database to store and manage all application data.
+* **Docker Support**: Containerized deployment with Docker and Docker Compose for easy setup and scalability.
+
+## Tech Stack
+
+* **Python 3.11**: The core programming language for the backend.
+* **FastAPI**: High-performance web framework for building APIs.
+* **Strawberry GraphQL**: Library for creating GraphQL APIs in Python.
+* **SQLAlchemy**: Powerful ORM for database interaction.
+* **Pydantic**: Data validation and settings management using Python type annotations.
+* **PostgreSQL**: Robust relational database management system.
+* **WebSockets**: For real-time communication and updates.
+
+## Project Structure
+
+The project is organized as follows:
+
+## Setup
+
+- Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+- Set up environment variables:
+
+```bash
+cp env.example .env
+# Edit .env with your configuration
+```
+
+- Run the application:
+
+```bash
+uvicorn src.main:app --reload
+```
+
+## API Documentation
+
+- REST API: <http://localhost:8000/docs>
+- GraphQL Playground: <http://localhost:8000/api/graphql>
+
+## Docker
+
+To run the application using Docker:
+
+```bash
+docker-compose up --build
+```
+
+## API Endpoints
+
+### REST API
+
+- `GET /api/movies` - List all movies
+- `GET /api/movies/?id={id}` - Get movie details
+- `GET /api/movies/scenes` - Get all scenes
+- `GET /api/movies/scenes/?id={id}` - Get scene details
+
+### GraphQL
+
+#### Queries
+
+- allMovies: [Movie!]!
+- movie(id: ID!): Movie
+- scene(id: ID!): Scene
+- allScenes: [Scene!]!
+- allLicenseStatus: [LicenseStatus!]!
+ -song(id: ID!): Song
+
+#### Mutations
+
+- updateSong(id: ID!, licenseStatus: LicenseStatusEnum = null): Song
+
+### WebSocket
+
+- `ws://localhost:8000/api/graphql` - example WebSocket endpoint for real-time license status updates

examples/music-licensing-challenge/docker-compose.yml

@@ -0,0 +1,27 @@
+version: '3.8'
+
+services:
+  backend:
+    build: .
+    ports:
+      - "8000:8000"
+    environment:
+      - DATABASE_URL=postgresql://postgres:postgres@db:5432/music_licensing
+    depends_on:
+      - db
+    volumes:
+      - ./:/app
+
+  db:
+    image: postgres:15
+    ports:
+      - "5432:5432"
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=music_licensing
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+volumes:
+  postgres_data:

examples/music-licensing-challenge/env.example

@@ -0,0 +1 @@
+DATABASE_URL=postgresql://postgres:postgres@localhost:5432/music_licensing

examples/music-licensing-challenge/requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+sqlalchemy==2.0.23
+psycopg2-binary==2.9.9
+python-dotenv==1.0.0
+pydantic==2.5.2
+python-multipart==0.0.6
+alembic==1.12.1 
+strawberry-graphql==0.208.0
+websockets==11.0.3

examples/music-licensing-challenge/src/app/api/__init__.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+from .movies import router as movies_router
+from .scenes import router as scenes_router
+from .graphql import router as graphql_app
+
+router = APIRouter()
+
+router.include_router(movies_router, prefix="/movies", tags=["movies"])
+router.include_router(scenes_router, prefix="/movies/scenes", tags=["scenes"])
+router.include_router(graphql_app, prefix="/graphql", tags=["graphql"])

examples/music-licensing-challenge/src/app/api/graphql.py

@@ -0,0 +1,4 @@
+from strawberry.fastapi import GraphQLRouter
+from ..graphql.schema import schema
+
+router = GraphQLRouter(schema)

examples/music-licensing-challenge/src/app/api/movies.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import List, Optional
+from ..db.database import get_db
+from ..models.movie import Movie
+from ..schemas.movies import MovieWithAllData
+from ..repository.movies import MovieRepository
+
+router = APIRouter()
+
+
+@router.get("/", response_model=List[MovieWithAllData] | MovieWithAllData)
+def read_movies(
+    id: Optional[str] = None,
+    db: Session = Depends(get_db),
+):
+    if id is None:
+        movies = MovieRepository(db)
+        return movies.get_all_movies_with_details()
+    else:
+        movie = db.query(Movie).filter(Movie.id == id).first()
+        if movie is None:
+            raise HTTPException(status_code=404, detail="Movie not found")
+        return movie

examples/music-licensing-challenge/src/app/api/scenes.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import List, Optional
+from ..db.database import get_db
+from ..models.scene import Scene
+from ..schemas.scenes import SceneWithAllData
+from ..repository.scenes import SceneRepository
+
+router = APIRouter()
+
+
+@router.get("/", response_model=List[SceneWithAllData] | SceneWithAllData)
+def read_scenes(
+    id: Optional[str] = None,
+    db: Session = Depends(get_db),
+):
+    if id is None:
+        scenes = SceneRepository(db)
+        return scenes.get_all_scenes_with_details()
+    else:
+        scene = db.query(Scene).filter(Scene.id == id).first()
+        if scene is None:
+            raise HTTPException(status_code=404, detail="Scene not found")
+        return scene

examples/music-licensing-challenge/src/app/db/database.py

@@ -0,0 +1,19 @@
+import os
+from dotenv import load_dotenv
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+load_dotenv()
+
+SQLALCHEMY_DATABASE_URL = os.getenv("DATABASE_URL", "")
+
+engine = create_engine(SQLALCHEMY_DATABASE_URL, future=True)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        return db
+    finally:
+        db.close()

examples/music-licensing-challenge/src/app/graphql/mutations.py

@@ -0,0 +1,28 @@
+from typing import Optional
+
+from sqlalchemy.orm import Session
+from strawberry import ID, mutation, type
+
+from ..db.database import get_db
+from ..repository.songs import SongRepository
+from ..schemas.songs import LicenseStatusEnum
+from .pubsub import trigger_license_change_subscription
+from .types.song import Song
+
+
+@type
+class Mutations:
+    @mutation
+    async def update_song(
+        self,
+        id: ID,
+        license_status: Optional[LicenseStatusEnum] = None,
+    ) -> Optional[Song]:
+        db: Session = get_db()
+        song_repository = SongRepository(db)
+        song = song_repository.update_song(id, license_status)
+        if song is None:
+            return None
+        if license_status:
+            await trigger_license_change_subscription(song)
+        return Song.from_model(song)

examples/music-licensing-challenge/src/app/graphql/pubsub.py

@@ -0,0 +1,10 @@
+import asyncio
+
+from .types.song import Song
+
+song_update_queue: asyncio.Queue[Song] = asyncio.Queue()
+
+
+async def trigger_license_change_subscription(song_model):
+    song = Song.from_model(song_model)
+    await song_update_queue.put(song)

examples/music-licensing-challenge/src/app/graphql/queries.py

@@ -0,0 +1,52 @@
+from typing import List, Optional
+
+from strawberry import ID, field, type
+
+from ..db.database import get_db
+from ..repository.licenses import LicenseRepository
+from ..repository.movies import MovieRepository
+from ..repository.scenes import SceneRepository
+from ..repository.songs import SongRepository
+from .types.movie import Movie
+from .types.scene import Scene
+from .types.song import Song
+from .types.song import LicenseStatus
+
+
+@type
+class Query:
+    @field
+    def all_movies(self) -> List[Movie]:
+        db = get_db()
+        movies = MovieRepository(db).get_all_movies_with_details()
+        return [Movie.from_model(m) for m in movies]
+
+    @field
+    def movie(self, id: ID) -> Optional[Movie]:
+        db = get_db()
+        movie = MovieRepository(db).get_movie_by_id_with_details(id)
+        return Movie.from_model(movie) if movie else None
+
+    @field
+    def scene(self, id: ID) -> Optional[Scene]:
+        db = get_db()
+        scene = SceneRepository(db).get_scene_by_id_with_details(id)
+        return Scene.from_model(scene) if scene else None
+
+    @field
+    def all_scenes(self) -> List[Scene]:
+        db = get_db()
+        scenes = SceneRepository(db).get_all_scenes_with_details()
+        return [Scene.from_model(s) for s in scenes]
+
+    @field
+    def all_license_status(self) -> List[LicenseStatus]:
+        db = get_db()
+        licenses = LicenseRepository(db).get_all_licenses()
+        return [LicenseStatus.from_model(s) for s in licenses]
+
+    @field
+    def song(self, id: ID) -> Optional[Song]:
+        db = get_db()
+        song = SongRepository(db).get_song_by_id(id)
+        return Song.from_model(song) if song else None

examples/music-licensing-challenge/src/app/graphql/schema.py

@@ -0,0 +1,7 @@
+import strawberry
+
+from .mutations import Mutations
+from .queries import Query
+from .subscriptions import Subscription
+
+schema = strawberry.Schema(query=Query, mutation=Mutations, subscription=Subscription)

examples/music-licensing-challenge/src/app/graphql/subscriptions.py

@@ -0,0 +1,15 @@
+from typing import AsyncGenerator
+
+import strawberry
+
+from .pubsub import song_update_queue
+from .types.song import Song
+
+
+@strawberry.type
+class Subscription:
+    @strawberry.subscription
+    async def license_changed(self) -> AsyncGenerator[Song, None]:
+        while True:
+            song = await song_update_queue.get()
+            yield song

examples/music-licensing-challenge/src/app/graphql/types/genre.py

@@ -0,0 +1,16 @@
+import strawberry
+
+from ...models.genre import Genre as GenreModel
+
+
+@strawberry.type
+class Genre:
+    id: int
+    name: str
+
+    @classmethod
+    def from_model(cls, model: GenreModel) -> "Genre":
+        return cls(
+            id=model.id,
+            name=model.name,
+        )