pax_global_header 0000666 0000000 0000000 00000000064 14535307367 0014527 g ustar 00root root 0000000 0000000 52 comment=ffcc5227bebcf39ca762a20f4be1c10fc781788f
MusicBoxAPI-0.2.2/ 0000775 0000000 0000000 00000000000 14535307367 0013613 5 ustar 00root root 0000000 0000000 MusicBoxAPI-0.2.2/.env.dist 0000664 0000000 0000000 00000000220 14535307367 0015340 0 ustar 00root root 0000000 0000000 CONTAINER_NAME=music_box_api
IMAGE_NAME=music_box
EXPOSED_PORT=8000
SPOTIFY_CLIENT_ID=spotifyclientid
SPOTIFY_CLIENT_SECRET=spotifyclientsecret MusicBoxAPI-0.2.2/.gitignore 0000664 0000000 0000000 00000006005 14535307367 0015604 0 ustar 00root root 0000000 0000000 # 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.2/Dockerfile 0000664 0000000 0000000 00000000256 14535307367 0015610 0 ustar 00root root 0000000 0000000 FROM 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.2/README.md 0000664 0000000 0000000 00000001606 14535307367 0015075 0 ustar 00root root 0000000 0000000 Music Box API
## 🛠️ Installation
1. Clone the repository `git clone https://github.com/MusicBoxRaspberryPi/MusicBoxAPI`
2. Rename `.env.dist` to `.env`
3. Edit `.env` to your needs
4. Install dependencies `pip install -r requirements.txt`
5. [Create Spotify App](https://developer.spotify.com/dashboard) with redirect URIs: `http://localhost:8080`
6. Copy **Client ID** and **Client Secret** from _Spotify App -> Settings -> View client secret_ to `.env`
7. Run `python -m app.spotify.service`, webpage should open in your browser and `.cache` file should be created
## 🚀 Usage
- With Docker: `docker compose up`
- Without Docker: `python -m app.main`
MusicBoxAPI-0.2.2/app/ 0000775 0000000 0000000 00000000000 14535307367 0014373 5 ustar 00root root 0000000 0000000 MusicBoxAPI-0.2.2/app/container.py 0000664 0000000 0000000 00000001102 14535307367 0016721 0 ustar 00root root 0000000 0000000 from 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.2/app/main.py 0000664 0000000 0000000 00000001544 14535307367 0015675 0 ustar 00root root 0000000 0000000 from 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.2/app/spotify/ 0000775 0000000 0000000 00000000000 14535307367 0016070 5 ustar 00root root 0000000 0000000 MusicBoxAPI-0.2.2/app/spotify/__init__.py 0000664 0000000 0000000 00000000000 14535307367 0020167 0 ustar 00root root 0000000 0000000 MusicBoxAPI-0.2.2/app/spotify/exceptions.py 0000664 0000000 0000000 00000001056 14535307367 0020625 0 ustar 00root root 0000000 0000000 class 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.2/app/spotify/router.py 0000664 0000000 0000000 00000004663 14535307367 0017773 0 ustar 00root root 0000000 0000000 from 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(
reset: bool = False,
spotify_service: SpotifyService = Depends(Provide[Container.spotify_service])
) -> CurrentDevice | dict:
spotify_service.refresh_devices()
if reset:
spotify_service.reset_current_device_index()
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:
updated = spotify_service.refresh_devices()
if not updated:
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:
updated = spotify_service.refresh_devices()
if not updated:
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.2/app/spotify/schemas.py 0000664 0000000 0000000 00000000642 14535307367 0020067 0 ustar 00root root 0000000 0000000 from 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.2/app/spotify/service.py 0000664 0000000 0000000 00000006521 14535307367 0020106 0 ustar 00root root 0000000 0000000 import 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) -> bool:
"""
Refreshes the devices from the API and returns whether the devices have changed
:return: Whether the devices have changed
"""
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 True
return False
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 reset_current_device_index(self) -> None:
self.__current_device_index = 0
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]
if __name__ == "__main__":
import dotenv
from app.container import Container
dotenv.load_dotenv()
container = Container()
SpotifyService(
client_id=container.config.spotify.client_id(),
client_secret=container.config.spotify.client_secret(),
redirect_uri=container.config.spotify.redirect_uri()
)
print(".cache file created")
MusicBoxAPI-0.2.2/app/system/ 0000775 0000000 0000000 00000000000 14535307367 0015717 5 ustar 00root root 0000000 0000000 MusicBoxAPI-0.2.2/app/system/__init__.py 0000664 0000000 0000000 00000000000 14535307367 0020016 0 ustar 00root root 0000000 0000000 MusicBoxAPI-0.2.2/app/system/router.py 0000664 0000000 0000000 00000000672 14535307367 0017616 0 ustar 00root root 0000000 0000000 from 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.2/config.ini 0000664 0000000 0000000 00000000277 14535307367 0015567 0 ustar 00root root 0000000 0000000 [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 = false MusicBoxAPI-0.2.2/docker-compose.yml 0000664 0000000 0000000 00000000440 14535307367 0017246 0 ustar 00root root 0000000 0000000 version: '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.2/requirements.txt 0000664 0000000 0000000 00000000155 14535307367 0017100 0 ustar 00root root 0000000 0000000 spotipy==2.23.0
python-dotenv==1.0.0
fastapi[all]==0.104.1
typing_inspect==0.9.0
dependency-injector==4.41.0