pyLiveMusic 0.0.1__py3-none-any.whl

pyLiveMusic/__init__.py

@@ -0,0 +1,6 @@
+from .core import pyLiveMusic
+ 
+__version__ = "0.0.1"  # MAJOR.MINOR.PATCH 
+
+__author__ = "github.com/Bakachii"
+__all__ = ["pyLiveMusic"]

pyLiveMusic/_api/_errors.py

@@ -0,0 +1,17 @@
+from aiohttp import web
+
+
+ERROR_STATUS = {
+    "NOT_PLAYING_ANYTHING_CURRENTLY": 409,
+    "INVALID_SEEK_LIMIT": 400,
+    "INVALID_SEEK_SECONDS": 400,
+    "INVALID_VOLUME": 400,
+    "INVALID_REPEAT_MODE": 400,
+    "INVALID_PLAY_ORDER": 400,
+    "INVALID_AUDIO_QUALITY": 400,
+    "TRACK_DURATION_UNKNOWN": 409,
+}
+
+
+def json_error(code):
+    return web.json_response({"error": code}, status=ERROR_STATUS.get(code, 400))

pyLiveMusic/_api/playback.py

@@ -0,0 +1,213 @@
+from aiohttp import web
+
+
+from pyLiveMusic._api._errors import json_error
+
+
+def get_room(request):
+
+    room = request.app["state"].rooms.get(request.match_info["room_id"])
+    if room is None:
+        raise web.HTTPNotFound(text="ROOM_NOT_FOUND")
+
+    return room
+
+
+async def pause(request):
+
+    request.app["auth"]._verify(request)
+    room = get_room(request)
+
+    try:
+        await room.pause()
+    except ValueError as error:
+        return json_error(str(error))
+
+    return web.json_response(room.state())
+
+
+async def resume(request):
+
+    request.app["auth"]._verify(request)
+    room = get_room(request)
+
+    try:
+        await room.resume()
+    except ValueError as error:
+        return json_error(str(error))
+
+    return web.json_response(room.state())
+
+
+async def skip(request):
+    
+    request.app["auth"]._verify(request)
+    room = get_room(request)
+
+    try:
+        await room.skip()
+    except ValueError as error:
+        return json_error(str(error))
+
+    return web.json_response(room.state_or_not_playing())
+
+
+async def volume(request):
+
+    request.app["auth"]._verify(request)
+    room = get_room(request)
+    data = await request.json()
+
+    try:
+        await room.set_volume(data["volume"])
+
+    except (
+        KeyError,
+        ValueError,
+    ) as error:
+
+        code = (
+            str(error)
+            if isinstance(error, ValueError)
+            else "INVALID_VOLUME"
+        )
+
+        return json_error(code)
+
+    return web.json_response(room.state_or_not_playing())
+
+
+async def shuffle(request):
+
+    request.app["auth"]._verify(request)
+    room = get_room(request)
+    data = await request.json()
+
+    await room.set_shuffle(data.get("enabled", False))
+
+    return web.json_response(room.state_or_not_playing())
+
+
+async def repeat(request):
+
+    request.app["auth"]._verify(request)
+    room = get_room(request)
+    data = await request.json()
+
+    try:
+        await room.set_repeat(data["mode"])
+
+    except (
+        KeyError,
+        ValueError,
+    ) as error:
+
+        code = (
+            str(error)
+            if isinstance(error, ValueError)
+            else "INVALID_REPEAT_MODE"
+        )
+
+        return json_error(code)
+
+    return web.json_response(room.state_or_not_playing())
+
+
+async def ascending(request):
+
+    request.app["auth"]._verify(request)
+    room = get_room(request)
+
+    try:
+        await room.set_order("ascending")
+    except ValueError as error:
+        return json_error(str(error))
+
+    return web.json_response(room.state_or_not_playing())
+
+
+async def descending(request):
+
+    request.app["auth"]._verify(request)
+    room = get_room(request)
+
+    try:
+        await room.set_order("descending")
+    except ValueError as error:
+        return json_error(str(error))
+
+    return web.json_response(room.state_or_not_playing())
+
+
+async def seek_front(request):
+
+    request.app["auth"]._verify(request)
+    room = get_room(request)
+    data = await request.json()
+
+    try:
+        await room.seek_front(data["seconds"])
+
+    except (
+        KeyError,
+        ValueError,
+    ) as error:
+
+        code = (
+            str(error)
+            if isinstance(error, ValueError)
+            else "INVALID_SEEK_SECONDS"
+        )
+
+        return json_error(code)
+
+    return web.json_response(room.state())
+
+
+async def seek_back(request):
+
+    request.app["auth"]._verify(request)
+    room = get_room(request)
+    data = await request.json()
+
+    try:
+        await room.seek_back(data["seconds"])
+    except (
+        KeyError,
+        ValueError,
+    ) as error:
+
+        code = (
+            str(error)
+            if isinstance(error, ValueError)
+            else "INVALID_SEEK_SECONDS"
+        )
+
+        return json_error(code)
+
+    return web.json_response(room.state())
+
+
+async def quality(request):
+
+    request.app["auth"]._verify(request)
+    room = get_room(request)
+    data = await request.json()
+
+    try:
+        await room.set_quality(data["quality"])
+
+    except (
+        KeyError,
+        ValueError,
+    ) as error:
+
+        code = (
+            str(error)
+            if isinstance(error, ValueError)
+            else "INVALID_AUDIO_QUALITY"
+        )
+
+        return json_error(code)
+
+    return web.json_response(room.state_or_not_playing())

pyLiveMusic/_api/queue.py

@@ -0,0 +1,106 @@
+from aiohttp import web
+
+
+async def get_queue(request):
+
+    room = request.app["state"].rooms.get(request.match_info["room_id"])
+    if room is None:
+        raise web.HTTPNotFound(text="ROOM_NOT_FOUND")
+
+    return web.json_response({
+        "room_id": room.id,
+        "current":
+            (
+                {
+                    "id": room.current.id,
+                    "title": room.current.title,
+                }
+                if room.current
+                else None
+            ),
+
+        "queue": [
+            {
+                "id": item.id,
+                "title": item.title,
+                "path": item.path,
+            }
+
+            for item in room.queue
+        ],
+    })
+
+
+async def add_track(request):
+
+    request.app["auth"]._verify(request)
+
+    room = request.app["state"].rooms.get(request.match_info["room_id"])
+    if room is None:
+        raise web.HTTPNotFound(text="ROOM_NOT_FOUND")
+
+    data = await request.json()
+
+    item = await room.add_track(
+        title=data["title"],
+        path=data["path"],
+    )
+
+    return web.json_response(
+        {
+            "id": item.id,
+            "title": item.title,
+        },
+        status=201,
+    )
+
+
+async def remove_track(request):
+
+    request.app["auth"]._verify(request)
+
+    room = request.app["state"].rooms.get(request.match_info["room_id"])
+    if room is None:
+        raise web.HTTPNotFound(text="ROOM_NOT_FOUND")
+
+    track_id = request.match_info["track_id"]
+    before = len(room.queue)
+
+    room.queue = [
+        item
+        for item in room.queue
+        if item.id != track_id
+    ]
+
+    if len(room.queue) == before:
+        raise web.HTTPNotFound(text="TRACK_NOT_FOUND")
+
+    return web.json_response(
+        {
+            "queue": [
+                {
+                    "id": item.id,
+                    "title": item.title,
+                }
+
+                for item in room.queue
+            ]
+        }
+    )
+
+
+async def clear_queue(request):
+    request.app["auth"]._verify(request)
+    
+    room = request.app["state"].rooms.get(request.match_info["room_id"])
+    if room is None:
+        raise web.HTTPNotFound(text="ROOM_NOT_FOUND")
+
+    room.queue.clear()
+
+    if room.current is None:
+        room.schedule_delete()
+
+    return web.json_response({
+        "queue": []
+    })

pyLiveMusic/_api/rooms.py

@@ -0,0 +1,51 @@
+from aiohttp import web
+
+
+async def create_room(request):
+    request.app["auth"]._verify(request)
+    user_id = request.app["auth"]._get_auth_key()
+
+    data = await request.json()
+
+    name = data.get(
+        "name",
+        "Private Room",
+    )
+
+    rooms = request.app["state"].rooms
+
+    room = await rooms.create(
+        name=name,
+        controllers={user_id},
+    )
+
+    return web.json_response(
+        room.state(),
+        status=201,
+    )
+
+
+async def get_room(request):
+    room_id = request.match_info["room_id"]
+    room = request.app["state"].rooms.get(room_id)
+
+    if room is None:
+        raise web.HTTPNotFound(text="ROOM_NOT_FOUND")
+
+    return web.json_response(room.state())
+
+
+async def end_room(request):
+    
+    request.app["auth"]._verify(request)
+
+    room_id = request.match_info["room_id"]
+    rooms = request.app["state"].rooms
+    room = rooms.get(room_id)
+
+    if room is None:
+        raise web.HTTPNotFound(text="ROOM_NOT_FOUND")
+
+    await rooms.remove(room_id)
+
+    return web.json_response({"status": "ended"})

pyLiveMusic/_api/signaling.py

@@ -0,0 +1,24 @@
+from aiohttp import web
+
+
+async def offer(request):
+    room_id = request.match_info["room_id"]
+    room = request.app["state"].rooms.get(room_id)
+
+    if room is None:
+        raise web.HTTPNotFound(text="Room not found")
+
+    data = await request.json()
+    peer = await room.add_peer()
+
+    try:
+        answer = await room.offer(peer, data["sdp"])
+    except Exception:
+        await room.remove_peer(peer)
+
+        raise
+
+    return web.json_response({
+        "type": answer.type,
+        "sdp": answer.sdp,
+    })

pyLiveMusic/_core/_core_func/_data_config.py

@@ -0,0 +1,34 @@
+from pyLiveMusic._webrtc.backend import RoomManager
+
+from pyLiveMusic._core._database.mongo._storage import _MongoStorage
+from pyLiveMusic._core._database.mongo._repo import MongoRoomRepository, MongoUserRepository
+from pyLiveMusic._core._database.memory._repo import MemoryRoomRepository, MemoryUserRepository
+
+
+class _core_state:
+    def __init__(self):
+        self.rooms = None
+        self.storage = None
+        self.users = None
+        self.room_repository = None
+
+    def MemoryState(self, storage):
+        self.storage = storage.storage
+        self.users = MemoryUserRepository(self.storage.users)
+        self.room_repository = MemoryRoomRepository(self.storage.rooms)
+        self.rooms = RoomManager(self.room_repository)
+
+    def MongoDBState(self, storage):
+        self.storage = _MongoStorage(
+            storage.db_url,
+            storage.db_name,
+            storage.user_collection,
+            storage.room_collection,
+        )
+
+        self.users = MongoUserRepository(self.storage.users)
+        self.room_repository = MongoRoomRepository(self.storage.rooms)
+        self.rooms = RoomManager(self.room_repository)
+
+    def RedisState(self, storage):
+        raise NotImplementedError("Redis storage is not implemented yet")

pyLiveMusic/_core/_core_func/_state/_data_state.py

@@ -0,0 +1,26 @@
+from pyLiveMusic._core._core_func._data_config import _core_state
+
+from pyLiveMusic.storage import Memory, MongoDB, Redis
+
+
+class _data_state:
+
+    def __init__(self, storage):
+        state_container = _core_state()
+
+        if isinstance(storage, Memory):
+            state_container.MemoryState(storage)
+
+        elif isinstance(storage, MongoDB):
+            state_container.MongoDBState(storage)
+
+        elif isinstance(storage, Redis):
+            state_container.RedisState(storage)
+
+        else:
+            raise TypeError("Unsupported storage type")
+
+        self.rooms = state_container.rooms
+        self.storage = state_container.storage
+        self.users = state_container.users
+        self.room_repository = state_container.room_repository

pyLiveMusic/_core/_database/memory/_repo.py

@@ -0,0 +1,41 @@
+class MemoryRoomRepository:
+
+    def __init__(self, rooms):
+        self.rooms = rooms
+
+    async def create(self, room_id, name, controllers):
+        document = {
+            "_id": room_id,
+            "name": name,
+            "controllers": list(controllers),
+        }
+
+        self.rooms[room_id] = document
+        return document
+
+    async def get(self, room_id):
+        return self.rooms.get(room_id)
+
+    async def list(self):
+        return list(self.rooms.values())
+
+    async def delete(self, room_id):
+        self.rooms.pop(room_id, None)
+
+class MemoryUserRepository:
+
+    def __init__(self, users):
+        self.users = users
+
+    async def get(self, user_id):
+        return self.users.get(user_id)
+
+    async def create(self, user_id, username):
+        document = {
+            "_id": user_id,
+            "username": username
+        }
+
+        self.users[user_id] = document
+
+        return document

pyLiveMusic/_core/_database/memory/_storage.py

@@ -0,0 +1,13 @@
+class _MemoryStorage:
+    def __init__(self):
+        self.users = {}
+        self.rooms = {}
+
+    async def connect(self):
+        print("Memory storage initialized")
+
+    async def close(self):
+        self.users.clear()
+        self.rooms.clear()
+
+        print("Memory storage cleared")

pyLiveMusic/_core/_database/mongo/_repo.py

@@ -0,0 +1,45 @@
+class MongoRoomRepository:
+
+    def __init__(self, collection):
+        self.collection = collection
+
+    async def create(self, room_id, name, controllers):
+        document = {
+            "_id": room_id,
+            "name": name,
+            "controllers": list(controllers),
+        }
+
+        await self.collection.insert_one(document)
+        return document
+
+    async def get(self, room_id):
+        return await self.collection.find_one({"_id": room_id})
+
+    async def list(self):
+        return [document async for document in self.collection.find({})]
+
+    async def delete(self, room_id):
+        await self.collection.delete_one({"_id": room_id})
+
+
+class MongoUserRepository:
+
+    def __init__(self, collection):
+
+        self.collection = collection
+
+    async def get(self, user_id):
+        return await self.collection.find_one({"_id": user_id})
+
+    async def create(
+        self,
+        user_id,
+        username,
+    ):
+
+        document = {"_id": user_id, "username": username}
+
+        await self.collection.insert_one(document)
+
+        return document

pyLiveMusic/_core/_database/mongo/_storage.py

@@ -0,0 +1,31 @@
+class _MongoStorage:
+    from pymongo import AsyncMongoClient
+    
+    def __init__(
+        self,
+        db_url: str,
+        db_name: str,
+        user_collection: str,
+        room_collection: str
+    ):
+        try:
+            from pymongo import AsyncMongoClient
+        except ImportError as exc:
+            raise ImportError(
+                "To use the MongoDB, you must install pyLiveMusic via "
+                "pip install 'pyLiveMusic[mongo]'"
+            ) from exc
+        self.client = AsyncMongoClient(db_url)
+        self.storage = self.client[db_name]
+
+        self.users = self.storage[user_collection]
+        self.rooms = self.storage[room_collection]
+
+        
+    async def connect(self):
+        await self.client.admin.command("ping")
+        print("MongoDB connected")
+
+    async def close(self):
+        await self.client.close()
+        print("MongoDB disconnected")

pyLiveMusic/_core/_database/redis/_repo.py

@@ -0,0 +1,5 @@
+class RedisRoomRepository:
+    pass
+
+class RedisUserRepository:
+    pass

pyLiveMusic/_core/_database/redis/_storage.py

@@ -0,0 +1,3 @@
+class _RedisStorage:
+    def __init__(self):
+        pass

pyLiveMusic/_static/audio.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Live Stream</title>
+</head>
+
+<body>
+    <audio id="audio" controls autoplay playsinline preload="auto" controlslist="nodownload noplaybackrate"></audio>
+    <br>
+    <label for="volume">Volume</label>
+    <input id="volume" type="range" min="0" max="1" step="0.01" value="1">
+    <span id="status">CONNECTING...</span>
+    <script src="/static/audio.js?v=3"></script>
+</body>
+
+</html>