pax_global_header00006660000000000000000000000064145344544660014531gustar00rootroot0000000000000052 comment=dce32745cb51531c6736c9329ad5df3f5c175460 MusicBoxAPI-0.2.0/000077500000000000000000000000001453445446600136135ustar00rootroot00000000000000MusicBoxAPI-0.2.0/.env.dist000066400000000000000000000002201453445446600153400ustar00rootroot00000000000000CONTAINER_NAME=music_box_api IMAGE_NAME=music_box EXPOSED_PORT=8000 SPOTIFY_CLIENT_ID=spotifyclientid SPOTIFY_CLIENT_SECRET=spotifyclientsecretMusicBoxAPI-0.2.0/.gitignore000066400000000000000000000060051453445446600156040ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .nox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover *.py,cover .hypothesis/ .pytest_cache/ cover/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py db.sqlite3 db.sqlite3-journal # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder .pybuilder/ target/ # Jupyter Notebook .ipynb_checkpoints # IPython profile_default/ ipython_config.py # pyenv # For a library or package, you might want to ignore these files since the code is # intended to run in multiple environments; otherwise, check them in: # .python-version # pipenv # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. # However, in case of collaboration, if having platform-specific dependencies or dependencies # having no cross-platform support, pipenv may install dependencies that don't work, or not # install all needed dependencies. #Pipfile.lock # poetry # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. # This is especially recommended for binary packages to ensure reproducibility, and is more # commonly ignored for libraries. # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control #poetry.lock # pdm # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. #pdm.lock # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it # in version control. # https://pdm.fming.dev/#use-with-ide .pdm.toml # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm __pypackages__/ # Celery stuff celerybeat-schedule celerybeat.pid # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ .dmypy.json dmypy.json # Pyre type checker .pyre/ # pytype static type analyzer .pytype/ # Cython debug symbols cython_debug/ # PyCharm # JetBrains specific template is maintained in a separate JetBrains.gitignore that can # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. .idea/ MusicBoxAPI-0.2.0/Dockerfile000066400000000000000000000002561453445446600156100ustar00rootroot00000000000000FROM python:3.10-slim WORKDIR /code COPY ./requirements.txt /code/requirements.txt RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt COPY ./app /code/app MusicBoxAPI-0.2.0/README.md000066400000000000000000000000131453445446600150640ustar00rootroot00000000000000# MusicBox MusicBoxAPI-0.2.0/app/000077500000000000000000000000001453445446600143735ustar00rootroot00000000000000MusicBoxAPI-0.2.0/app/container.py000066400000000000000000000011021453445446600167210ustar00rootroot00000000000000from dependency_injector import containers, providers from app.spotify.service import SpotifyService class Container(containers.DeclarativeContainer): wiring_config = containers.WiringConfiguration( packages=[ "app", ] ) config = providers.Configuration( ini_files=["config.ini"], strict=True ) spotify_service = providers.Singleton( SpotifyService, client_id=config.spotify.client_id, client_secret=config.spotify.client_secret, redirect_uri=config.spotify.redirect_uri ) MusicBoxAPI-0.2.0/app/main.py000066400000000000000000000015441453445446600156750ustar00rootroot00000000000000from dotenv import load_dotenv from fastapi import FastAPI from pydantic import TypeAdapter from app.container import Container from app.spotify.router import spotify_router from app.system.router import system_router load_dotenv() container = Container() def create_application() -> FastAPI: application = FastAPI( title="MusicBox API", debug=True ) application.include_router(system_router) application.include_router(spotify_router) return application if __name__ == "__main__": import uvicorn uvicorn.run( "app.main:create_application", factory=True, host=container.config.uvicorn.host(), port=int(container.config.uvicorn.port()), log_level=container.config.uvicorn.log_level(), reload=TypeAdapter(bool).validate_python(container.config.uvicorn.reload()), ) MusicBoxAPI-0.2.0/app/spotify/000077500000000000000000000000001453445446600160705ustar00rootroot00000000000000MusicBoxAPI-0.2.0/app/spotify/__init__.py000066400000000000000000000000001453445446600201670ustar00rootroot00000000000000MusicBoxAPI-0.2.0/app/spotify/exceptions.py000066400000000000000000000010561453445446600206250ustar00rootroot00000000000000class SpotifyError(Exception): """Base class for exceptions in this module.""" pass class TrackNotFoundError(SpotifyError): """Exception raised when a track is not found. Attributes: message -- explanation of the error """ def __init__(self, message: str): self.message = message class DeviceNotFoundError(SpotifyError): """Exception raised when a device is not found. Attributes: message -- explanation of the error """ def __init__(self, message: str): self.message = message MusicBoxAPI-0.2.0/app/spotify/router.py000066400000000000000000000044111453445446600177620ustar00rootroot00000000000000from dependency_injector.wiring import inject, Provide from fastapi import APIRouter, Depends from app.container import Container from app.spotify.exceptions import TrackNotFoundError, DeviceNotFoundError from app.spotify.schemas import Device, CurrentDevice, Track from app.spotify.service import SpotifyService spotify_router = APIRouter() @spotify_router.get("/device") @inject def get_current_device( spotify_service: SpotifyService = Depends(Provide[Container.spotify_service]) ) -> CurrentDevice | dict: spotify_service.refresh_devices() current_device = spotify_service.get_current_device() if current_device is None: return {} return CurrentDevice( device=current_device, index=spotify_service.get_current_device_index(), total=spotify_service.get_devices_count() ) @spotify_router.post("/device/next") @inject def next_device( spotify_service: SpotifyService = Depends(Provide[Container.spotify_service]) ) -> CurrentDevice | dict: spotify_service.refresh_devices() spotify_service.next_device() current_device = spotify_service.get_current_device() if current_device is None: return {} return CurrentDevice( device=current_device, index=spotify_service.get_current_device_index(), total=spotify_service.get_devices_count() ) @spotify_router.post("/device/previous") @inject def previous_device( spotify_service: SpotifyService = Depends(Provide[Container.spotify_service]) ) -> CurrentDevice | dict: spotify_service.refresh_devices() spotify_service.previous_device() current_device = spotify_service.get_current_device() if current_device is None: return {} return CurrentDevice( device=current_device, index=spotify_service.get_current_device_index(), total=spotify_service.get_devices_count() ) @spotify_router.post("/play") @inject def play( track: Track, spotify_service: SpotifyService = Depends(Provide[Container.spotify_service]) ) -> Device | dict: try: spotify_service.play(track) except TrackNotFoundError: return {"error": "Track not found"} except DeviceNotFoundError: return {"error": "Device not found"} return {"status": "ok"} MusicBoxAPI-0.2.0/app/spotify/schemas.py000066400000000000000000000006421453445446600200670ustar00rootroot00000000000000from pydantic import BaseModel class Device(BaseModel): id: str is_active: bool is_private_session: bool is_restricted: bool name: str supports_volume: bool type: str volume_percent: int class CurrentDevice(BaseModel): device: Device index: int total: int class Track(BaseModel): id: str @property def uri(self): return f"spotify:track:{self.id}" MusicBoxAPI-0.2.0/app/spotify/service.py000066400000000000000000000053151453445446600201060ustar00rootroot00000000000000import spotipy from app.spotify.exceptions import DeviceNotFoundError, TrackNotFoundError from app.spotify.schemas import Device, Track class SpotifyService: def __init__( self, client_id: str, client_secret: str, redirect_uri: str ) -> None: self.__api = spotipy.Spotify( auth_manager=spotipy.SpotifyOAuth( client_id=client_id, client_secret=client_secret, redirect_uri=redirect_uri, scope="user-read-playback-state,user-modify-playback-state" ) ) self.__devices = self.__get_devices_from_api() self.__current_device_index = 0 def play(self, track: Track) -> None: current_device = self.get_current_device() if current_device is None: raise DeviceNotFoundError("No device found") try: self.__api.transfer_playback( device_id=current_device.id, force_play=False ) self.__api.start_playback( device_id=current_device.id, uris=[track.uri] ) except spotipy.exceptions.SpotifyException as e: if "Device not found" in e.msg: raise DeviceNotFoundError(e.msg) elif "Invalid track uri" in e.msg: raise TrackNotFoundError(e.msg) def refresh_devices(self) -> list[Device]: devices_from_api = self.__get_devices_from_api() if devices_from_api != self.__devices: self.__devices = devices_from_api self.__current_device_index = 0 return self.__devices def next_device(self) -> Device | None: if len(self.__devices) == 0: return None self.__current_device_index = (self.__current_device_index + 1) % len(self.__devices) return self.get_current_device() def previous_device(self) -> Device | None: if len(self.__devices) == 0: return None self.__current_device_index = (self.__current_device_index - 1) % len(self.__devices) return self.get_current_device() def get_current_device(self) -> Device | None: if len(self.__devices) == 0: return None return self.__devices[self.__current_device_index] def get_current_device_index(self) -> int: return self.__current_device_index def get_devices(self) -> list[Device]: return self.__devices def get_devices_count(self) -> int: return len(self.__devices) def __get_devices_from_api(self) -> list[Device]: devices_json = self.__api.devices()["devices"] return [Device(**device) for device in devices_json] MusicBoxAPI-0.2.0/app/system/000077500000000000000000000000001453445446600157175ustar00rootroot00000000000000MusicBoxAPI-0.2.0/app/system/__init__.py000066400000000000000000000000001453445446600200160ustar00rootroot00000000000000MusicBoxAPI-0.2.0/app/system/router.py000066400000000000000000000006721453445446600176160ustar00rootroot00000000000000from fastapi import APIRouter, status from starlette.responses import JSONResponse system_router = APIRouter() @system_router.get("/", include_in_schema=False) async def root() -> dict[str, str]: return {"message": "MusicBox API"} @system_router.get("/health", include_in_schema=False) async def health() -> JSONResponse: data = {"music-box-api": status.HTTP_200_OK} return JSONResponse(data, status_code=status.HTTP_200_OK) MusicBoxAPI-0.2.0/config.ini000066400000000000000000000002771453445446600155670ustar00rootroot00000000000000[spotify] client_id = ${SPOTIFY_CLIENT_ID} client_secret = ${SPOTIFY_CLIENT_SECRET} redirect_uri = http://localhost:8080 [uvicorn] host = 0.0.0.0 port = 8000 log_level = debug reload = falseMusicBoxAPI-0.2.0/docker-compose.yml000066400000000000000000000004401453445446600172460ustar00rootroot00000000000000version: '3.8' services: fastapi-app: container_name: ${CONTAINER_NAME:-fastapi-app} image: ${IMAGE_NAME:-fastapi} build: context: . volumes: - .:/code ports: - ${EXPOSED_PORT:-8000}:${UVICORN_PORT:-8000} command: ["python", "-m", "app.main"] MusicBoxAPI-0.2.0/requirements.txt000066400000000000000000000001551453445446600171000ustar00rootroot00000000000000spotipy==2.23.0 python-dotenv==1.0.0 fastapi[all]==0.104.1 typing_inspect==0.9.0 dependency-injector==4.41.0