Merge branch 'release/4.0' into refactor/frontend-vue
# Conflicts: # .gitignore # web.py
This commit is contained in:
71 files changed
+3173
-1673
No files matched your search
@@ -0,0 +1,96 @@
|
||||
name: Backend
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
paths:
|
||||
- "**.py"
|
||||
- "requirements*.txt"
|
||||
- "pyproject.toml"
|
||||
- "Dockerfile"
|
||||
- ".gitea/workflows/backend.yaml"
|
||||
pull_request:
|
||||
paths:
|
||||
- "**.py"
|
||||
- "requirements*.txt"
|
||||
- "pyproject.toml"
|
||||
- "Dockerfile"
|
||||
- ".gitea/workflows/backend.yaml"
|
||||
workflow_dispatch:
|
||||
|
||||
env:
|
||||
PYTHON_VERSION: "3.13"
|
||||
RUFF_VERSION: "0.16.4"
|
||||
|
||||
jobs:
|
||||
lint:
|
||||
name: Lint i formatowanie
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- uses: actions/setup-python@v5
|
||||
with:
|
||||
python-version: ${{ env.PYTHON_VERSION }}
|
||||
|
||||
- name: Instalacja ruff
|
||||
run: pip install --no-cache-dir "ruff==${RUFF_VERSION}"
|
||||
|
||||
- name: Reguły lintera
|
||||
run: ruff check --output-format=github .
|
||||
|
||||
- name: Zgodność z formatterem
|
||||
run: ruff format --check --diff .
|
||||
|
||||
test:
|
||||
name: Testy i kontrakt API
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- uses: actions/setup-python@v5
|
||||
with:
|
||||
python-version: ${{ env.PYTHON_VERSION }}
|
||||
cache: pip
|
||||
|
||||
# Zależności instalują się z gotowych kółek - kompilator nie jest
|
||||
# potrzebny. ffmpeg i libopus są wymagane dopiero przy odtwarzaniu,
|
||||
# a testy nie dotykają warstwy audio.
|
||||
- name: Instalacja zależności
|
||||
run: pip install -r requirements.txt
|
||||
|
||||
- name: Testy jednostkowe
|
||||
run: python -m unittest discover -s tests -t . -v
|
||||
|
||||
- name: Kontrola składni całego pakietu
|
||||
run: python -m compileall -q zyrarbot main.py
|
||||
|
||||
image:
|
||||
name: Testowy build obrazu
|
||||
runs-on: ubuntu-latest
|
||||
needs: [lint, test]
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Budowa obrazu backendu
|
||||
run: docker build --tag zyrarbot-api:ci .
|
||||
|
||||
# Sam start procesu to za mało - panel łączy się z API po sieci, więc
|
||||
# sprawdzamy, że kontener faktycznie odpowiada. Zapytanie leci z jego
|
||||
# wnętrza, żeby nie zależeć od narzędzi zainstalowanych na runnerze.
|
||||
- name: Kontener odpowiada na API
|
||||
run: |
|
||||
docker run -d --name zyrarbot-ci -e DISCORD_TOKEN=ci-dummy zyrarbot-api:ci
|
||||
probe="import json,urllib.request;json.load(urllib.request.urlopen('http://localhost:8000/api/status',timeout=2))"
|
||||
for i in $(seq 1 30); do
|
||||
if docker exec zyrarbot-ci python -c "$probe" 2>/dev/null; then
|
||||
echo "API odpowiedziało po ${i}s"
|
||||
docker rm -f zyrarbot-ci
|
||||
exit 0
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
echo "::error::API nie odpowiedziało w ciągu 30 sekund"
|
||||
docker logs zyrarbot-ci
|
||||
docker rm -f zyrarbot-ci
|
||||
exit 1
|
||||
@@ -6,6 +6,9 @@ downloads/
|
||||
config/
|
||||
uploads/
|
||||
|
||||
# Cache narzędzi deweloperskich
|
||||
.ruff_cache/
|
||||
|
||||
# Panel budowany jest z frontend/ i trafia do własnego obrazu.
|
||||
node_modules/
|
||||
frontend/dist/
|
||||
@@ -0,0 +1,84 @@
|
||||
# ŻyrarBOT
|
||||
|
||||
Bot muzyczny Discord z panelem webowym: kolejka odtwarzania, historia, serwerowa
|
||||
baza plików i sterowanie na żywo przez WebSocket.
|
||||
|
||||
## Uruchomienie
|
||||
|
||||
```bash
|
||||
pip install -r requirements.txt
|
||||
python main.py # albo: python -m zyrarbot
|
||||
```
|
||||
|
||||
Wymagane zmienne środowiskowe (plik `.env`):
|
||||
|
||||
| Zmienna | Opis |
|
||||
| --------------- | ----------------------------------------------------------- |
|
||||
| `DISCORD_TOKEN` | Token bota Discord. |
|
||||
| `GUILD_ID` | Opcjonalnie - synchronizuje komendy tylko z jednym serwerem. |
|
||||
|
||||
Panel działa pod `http://localhost:8000`. W Dockerze: `docker compose up --build`.
|
||||
|
||||
## Testy
|
||||
|
||||
```bash
|
||||
python -m unittest discover -s tests -t .
|
||||
```
|
||||
|
||||
## Struktura pakietu
|
||||
|
||||
Każda klasa mieszka w osobnym pliku, a pliki są pogrupowane w przestrzenie nazw
|
||||
odpowiadające warstwom aplikacji:
|
||||
|
||||
```
|
||||
zyrarbot/
|
||||
├── settings.py Settings - konfiguracja ze zmiennych środowiskowych
|
||||
├── application.py Application - korzeń kompozycji, spina bota i API
|
||||
├── storage/ Warstwa trwałości (pliki JSON, katalog uploadów)
|
||||
│ ├── json_file_store.py JsonFileStore
|
||||
│ ├── guild_config_repository.py GuildConfigRepository
|
||||
│ ├── history_repository.py HistoryRepository
|
||||
│ ├── uploads_repository.py UploadsRepository
|
||||
│ └── upload_file_info.py UploadFileInfo
|
||||
├── audio/ Pozyskiwanie dźwięku
|
||||
│ ├── ytdl_options.py YtdlOptions
|
||||
│ ├── ytdl_source.py YTDLSource
|
||||
│ ├── media_probe.py MediaProbe
|
||||
│ └── track_factory.py TrackFactory
|
||||
├── music/ Domena odtwarzania
|
||||
│ ├── loop_mode.py LoopMode
|
||||
│ ├── history_entry.py HistoryEntry
|
||||
│ ├── guild_music_state.py GuildMusicState
|
||||
│ ├── track_embed_factory.py TrackEmbedFactory
|
||||
│ ├── notification_channel_resolver.py NotificationChannelResolver
|
||||
│ └── music_player.py MusicPlayer
|
||||
└── ui/ Warstwa interfejsów użytkownika
|
||||
├── api/ API panelu (FastAPI)
|
||||
│ ├── factory.py mount_api - konfiguracja i routery API
|
||||
│ ├── connection_manager.py ConnectionManager
|
||||
│ ├── status_service.py StatusService
|
||||
│ ├── status_broadcaster.py StatusBroadcaster
|
||||
│ ├── dependencies.py wstrzykiwanie zależności z app.state
|
||||
│ ├── requests/ modele żądań - jeden na plik
|
||||
│ └── routers/ trasy pogrupowane tematycznie
|
||||
└── bot/ Warstwa Discorda
|
||||
├── client.py MusicBot
|
||||
├── guild_resolver.py GuildResolver
|
||||
└── cogs/ komendy i listenery Discorda
|
||||
├── common.py wspólne zależności i helpery
|
||||
├── playback_cog.py PlaybackCog
|
||||
├── queue_cog.py QueueCog
|
||||
├── control_cog.py ControlCog
|
||||
├── voice_cog.py VoiceCog
|
||||
└── settings_cog.py SettingsCog
|
||||
```
|
||||
|
||||
### Zasady
|
||||
|
||||
- **`MusicPlayer` jest jedynym właścicielem stanu odtwarzania.** Zarówno komendy
|
||||
Discorda, jak i endpointy panelu operują wyłącznie przez niego - nie ma już
|
||||
dwóch niezależnych ścieżek modyfikujących kolejkę.
|
||||
- **Kolejka jest nieusuwalna, pozycję śledzi indeks** (`GuildMusicState.index`),
|
||||
dzięki czemu działa przeskakiwanie i przewijanie w tył.
|
||||
- **Zależności wędrują przez konstruktory**, a w API przez `app.state`
|
||||
i funkcje z `api/dependencies.py`. Nie ma globalnych singletonów.
|
||||
@@ -1,800 +0,0 @@
|
||||
import discord
|
||||
from discord import app_commands
|
||||
from discord.ext import commands
|
||||
import asyncio
|
||||
import os
|
||||
from typing import Optional
|
||||
from dotenv import load_dotenv
|
||||
from ytdl import YTDLSource
|
||||
|
||||
# Load environment variables
|
||||
load_dotenv()
|
||||
TOKEN = os.getenv('DISCORD_TOKEN')
|
||||
GUILD_ID = os.getenv('GUILD_ID')
|
||||
|
||||
|
||||
class MusicBot(commands.Cog):
|
||||
def __init__(self, bot):
|
||||
self.bot = bot
|
||||
self.queues = {} # guild_id -> list
|
||||
self.currents = {} # guild_id -> player
|
||||
self.volumes = {} # guild_id -> volume float
|
||||
self.loop_currents = {} # guild_id -> bool
|
||||
self.loop_playlists = {} # guild_id -> bool
|
||||
self.last_channels = {} # guild_id -> text channel
|
||||
self.history = {} # guild_id -> list of dicts
|
||||
self.queue_indices = {} # guild_id -> int
|
||||
self.jump_flag = {} # guild_id -> bool
|
||||
self.default_plays = self.get_default_plays()
|
||||
self.on_state_change_callback = None
|
||||
|
||||
def load_history(self, guild_id: int):
|
||||
if guild_id in self.history:
|
||||
return self.history[guild_id]
|
||||
config_path = "config/history.json"
|
||||
if os.path.exists(config_path):
|
||||
try:
|
||||
import json
|
||||
with open(config_path, "r") as f:
|
||||
data = json.load(f)
|
||||
raw_history = data.get(str(guild_id), [])
|
||||
unique_history = []
|
||||
seen = set()
|
||||
for item in raw_history:
|
||||
key = (item.get("title", ""), item.get("url", ""))
|
||||
if key not in seen:
|
||||
seen.add(key)
|
||||
unique_history.append(item)
|
||||
self.history[guild_id] = unique_history
|
||||
except Exception as e:
|
||||
print(f"Error loading history: {e}")
|
||||
self.history[guild_id] = []
|
||||
else:
|
||||
self.history[guild_id] = []
|
||||
return self.history[guild_id]
|
||||
|
||||
def save_history(self, guild_id: int):
|
||||
config_path = "config/history.json"
|
||||
try:
|
||||
import json
|
||||
os.makedirs(os.path.dirname(config_path), exist_ok=True)
|
||||
data = {}
|
||||
if os.path.exists(config_path):
|
||||
with open(config_path, "r") as f:
|
||||
data = json.load(f)
|
||||
data[str(guild_id)] = self.history.get(guild_id, [])
|
||||
with open(config_path, "w") as f:
|
||||
json.dump(data, f, indent=4)
|
||||
except Exception as e:
|
||||
print(f"Error saving history: {e}")
|
||||
|
||||
def add_to_history(self, guild_id: int, player):
|
||||
if not player or not player.title:
|
||||
return
|
||||
history = self.load_history(guild_id)
|
||||
entry = {
|
||||
"id": player.id,
|
||||
"title": player.title,
|
||||
"url": player.data.get("webpage_url") or player.url,
|
||||
"duration": player.duration,
|
||||
"is_local": player.data.get("is_local", False),
|
||||
"filepath": player.data.get("filepath")
|
||||
}
|
||||
history = [h for h in history if h.get("title") != entry["title"] and (not entry.get("url") or h.get("url") != entry["url"])]
|
||||
history.insert(0, entry)
|
||||
self.history[guild_id] = history[:50]
|
||||
self.save_history(guild_id)
|
||||
|
||||
def get_queue(self, guild_id: int):
|
||||
if guild_id not in self.queues:
|
||||
self.queues[guild_id] = []
|
||||
return self.queues[guild_id]
|
||||
|
||||
def get_current(self, guild_id: int):
|
||||
return self.currents.get(guild_id)
|
||||
|
||||
def set_current(self, guild_id: int, player):
|
||||
self.currents[guild_id] = player
|
||||
|
||||
def get_volume(self, guild_id: int):
|
||||
return self.volumes.get(guild_id, 1.0)
|
||||
|
||||
def set_volume(self, guild_id: int, volume: float):
|
||||
self.volumes[guild_id] = volume
|
||||
|
||||
def get_loop_current(self, guild_id: int):
|
||||
return self.loop_currents.get(guild_id, False)
|
||||
|
||||
def set_loop_current(self, guild_id: int, loop: bool):
|
||||
self.loop_currents[guild_id] = loop
|
||||
|
||||
def get_loop_playlist(self, guild_id: int):
|
||||
return self.loop_playlists.get(guild_id, False)
|
||||
|
||||
def set_loop_playlist(self, guild_id: int, loop: bool):
|
||||
self.loop_playlists[guild_id] = loop
|
||||
|
||||
def get_queue_index(self, guild_id: int):
|
||||
return self.queue_indices.get(guild_id, -1)
|
||||
|
||||
def set_queue_index(self, guild_id: int, index: int):
|
||||
self.queue_indices[guild_id] = index
|
||||
|
||||
def clear_queue(self, guild_id: int):
|
||||
self.get_queue(guild_id).clear()
|
||||
self.set_current(guild_id, None)
|
||||
self.set_queue_index(guild_id, -1)
|
||||
|
||||
async def get_fresh_player(self, track):
|
||||
if track.data.get('is_local'):
|
||||
new_player = await YTDLSource.from_file(track.data['filepath'], loop=self.bot.loop, title=track.title)
|
||||
else:
|
||||
url = track.data.get('webpage_url') or track.url
|
||||
new_player = await YTDLSource.from_url(url, loop=self.bot.loop, stream=True)
|
||||
new_player.id = track.id
|
||||
new_player.plays_left = getattr(track, 'plays_left', self.get_default_plays())
|
||||
return new_player
|
||||
|
||||
async def enqueue_track(self, guild_id: int, player, channel=None, from_web=False):
|
||||
if channel:
|
||||
self.last_channels[guild_id] = channel
|
||||
|
||||
if getattr(player, 'plays_left', None) is None:
|
||||
player.plays_left = self.get_default_plays()
|
||||
|
||||
queue = self.get_queue(guild_id)
|
||||
queue.append(player)
|
||||
|
||||
voice_client = discord.utils.get(self.bot.voice_clients, guild__id=guild_id)
|
||||
is_playing = voice_client and (voice_client.is_playing() or voice_client.is_paused())
|
||||
|
||||
url = player.data.get('webpage_url') or player.url
|
||||
title_clean = discord.utils.escape_markdown(player.title or "Nieznany tytuł")
|
||||
is_http = url and str(url).startswith("http")
|
||||
|
||||
if is_playing:
|
||||
embed = discord.Embed(
|
||||
title=f"🎵 {title_clean}" if not player.data.get('is_local') else f"📁 {title_clean}",
|
||||
url=url if is_http else None,
|
||||
description=f"[Kliknij tutaj, aby otworzyć link]({url})" if is_http else "Plik lokalny / brak linku",
|
||||
color=discord.Color.blue()
|
||||
)
|
||||
if from_web:
|
||||
embed.set_author(name="Dodano do kolejki z panelu Web", icon_url="https://cdn-icons-png.flaticon.com/512/3844/3844724.png")
|
||||
else:
|
||||
embed.set_author(name="Dodano do kolejki", icon_url="https://cdn-icons-png.flaticon.com/512/3844/3844724.png")
|
||||
if player.duration:
|
||||
mins, secs = divmod(int(player.duration), 60)
|
||||
embed.add_field(name="Czas trwania", value=f"{mins}:{secs:02d}", inline=True)
|
||||
embed.set_footer(text=f"Pozycja w kolejce: {len(queue)}")
|
||||
await self.send_to_last_channel(guild_id, embed=embed)
|
||||
await self.trigger_state_change()
|
||||
return {"status": "queued", "title": player.title}
|
||||
else:
|
||||
await self.play_next(guild_id, advance=False)
|
||||
return {"status": "playing", "title": player.title}
|
||||
|
||||
@commands.Cog.listener()
|
||||
async def on_voice_state_update(self, member, before, after):
|
||||
if member.id == self.bot.user.id and before.channel is not None and after.channel is None:
|
||||
guild_id = before.channel.guild.id
|
||||
self.clear_queue(guild_id)
|
||||
await self.trigger_state_change()
|
||||
|
||||
async def trigger_state_change(self):
|
||||
if self.on_state_change_callback:
|
||||
try:
|
||||
if asyncio.iscoroutinefunction(self.on_state_change_callback):
|
||||
await self.on_state_change_callback()
|
||||
else:
|
||||
self.on_state_change_callback()
|
||||
except Exception as e:
|
||||
print(f"Error executing on_state_change_callback: {e}")
|
||||
|
||||
def load_saved_channel_id(self, guild_id: int):
|
||||
config_path = "config/config.json"
|
||||
if os.path.exists(config_path):
|
||||
try:
|
||||
import json
|
||||
with open(config_path, "r") as f:
|
||||
data = json.load(f)
|
||||
val = data.get(str(guild_id))
|
||||
return int(val) if val is not None else None
|
||||
except Exception as e:
|
||||
print(f"Error loading config: {e}")
|
||||
return None
|
||||
|
||||
def save_channel_id(self, guild_id: int, channel_id: Optional[int]):
|
||||
config_path = "config/config.json"
|
||||
try:
|
||||
import json
|
||||
os.makedirs(os.path.dirname(config_path), exist_ok=True)
|
||||
data = {}
|
||||
if os.path.exists(config_path):
|
||||
with open(config_path, "r") as f:
|
||||
data = json.load(f)
|
||||
if channel_id is None:
|
||||
if str(guild_id) in data:
|
||||
del data[str(guild_id)]
|
||||
else:
|
||||
data[str(guild_id)] = channel_id
|
||||
with open(config_path, "w") as f:
|
||||
json.dump(data, f, indent=4)
|
||||
except Exception as e:
|
||||
print(f"Error saving config: {e}")
|
||||
|
||||
def get_default_plays(self) -> int:
|
||||
config_path = "config/config.json"
|
||||
if os.path.exists(config_path):
|
||||
try:
|
||||
import json
|
||||
with open(config_path, "r") as f:
|
||||
data = json.load(f)
|
||||
val = data.get("default_plays")
|
||||
if val is not None:
|
||||
return int(val)
|
||||
except Exception as e:
|
||||
print(f"Error loading default_plays: {e}")
|
||||
return 5
|
||||
|
||||
def set_default_plays(self, val: int):
|
||||
config_path = "config/config.json"
|
||||
try:
|
||||
import json
|
||||
os.makedirs(os.path.dirname(config_path), exist_ok=True)
|
||||
data = {}
|
||||
if os.path.exists(config_path):
|
||||
with open(config_path, "r") as f:
|
||||
data = json.load(f)
|
||||
data["default_plays"] = int(val)
|
||||
with open(config_path, "w") as f:
|
||||
json.dump(data, f, indent=4)
|
||||
self.default_plays = int(val)
|
||||
except Exception as e:
|
||||
print(f"Error saving default_plays: {e}")
|
||||
|
||||
def get_notification_channel(self, guild_id: int):
|
||||
if self.last_channels.get(guild_id):
|
||||
return self.last_channels[guild_id]
|
||||
|
||||
saved_id = self.load_saved_channel_id(guild_id)
|
||||
if saved_id:
|
||||
channel = self.bot.get_channel(int(saved_id))
|
||||
if channel:
|
||||
self.last_channels[guild_id] = channel
|
||||
return channel
|
||||
|
||||
# Fallback to the first accessible channel in the guild
|
||||
guild = self.bot.get_guild(guild_id)
|
||||
if guild:
|
||||
for tc in guild.text_channels:
|
||||
if tc.permissions_for(guild.me).send_messages:
|
||||
self.last_channels[guild_id] = tc
|
||||
return tc
|
||||
|
||||
return None
|
||||
|
||||
async def ensure_voice(self, interaction):
|
||||
if not interaction.user.voice:
|
||||
await interaction.response.send_message(
|
||||
"Nie jesteś połączony z kanałem głosowym.",
|
||||
ephemeral=True
|
||||
)
|
||||
return False
|
||||
|
||||
if interaction.guild.voice_client is None:
|
||||
await interaction.user.voice.channel.connect()
|
||||
elif interaction.guild.voice_client.channel != interaction.user.voice.channel:
|
||||
await interaction.response.send_message(
|
||||
"Jestem już połączony z innym kanałem głosowym.",
|
||||
ephemeral=True
|
||||
)
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
@app_commands.command(name="play", description="Odtwórz utwór z YouTube")
|
||||
@app_commands.describe(query="Link YouTube lub zapytanie wyszukiwania")
|
||||
async def play(self, interaction: discord.Interaction, query: str):
|
||||
"""Odtwórz utwór z YouTube"""
|
||||
if not await self.ensure_voice(interaction):
|
||||
return
|
||||
|
||||
await interaction.response.defer()
|
||||
guild_id = interaction.guild.id
|
||||
self.last_channels[guild_id] = interaction.channel
|
||||
|
||||
try:
|
||||
filepath = os.path.join("uploads", os.path.basename(query))
|
||||
if os.path.exists(filepath) and not query.startswith("http"):
|
||||
player = await YTDLSource.from_file(filepath, loop=self.bot.loop)
|
||||
else:
|
||||
player = await YTDLSource.from_url(query, loop=self.bot.loop, stream=True)
|
||||
|
||||
res = await self.enqueue_track(guild_id, player, channel=interaction.channel, from_web=False)
|
||||
if res["status"] == "queued":
|
||||
await interaction.followup.send(
|
||||
f"Dodano do kolejki: {discord.utils.escape_markdown(player.title)}",
|
||||
ephemeral=False
|
||||
)
|
||||
else:
|
||||
await interaction.followup.send(
|
||||
f"Teraz odtwarzane: {discord.utils.escape_markdown(player.title)}",
|
||||
ephemeral=False
|
||||
)
|
||||
except Exception as e:
|
||||
await interaction.followup.send(
|
||||
f"Wystąpił błąd: {e}",
|
||||
ephemeral=True
|
||||
)
|
||||
|
||||
async def uploads_autocomplete(
|
||||
self,
|
||||
interaction: discord.Interaction,
|
||||
current: str,
|
||||
) -> list[app_commands.Choice[str]]:
|
||||
uploads_dir = "uploads"
|
||||
if not os.path.exists(uploads_dir):
|
||||
return []
|
||||
files = [f for f in os.listdir(uploads_dir) if os.path.isfile(os.path.join(uploads_dir, f)) and not f.startswith(".")]
|
||||
filtered = [f for f in files if current.lower() in f.lower()][:25]
|
||||
return [app_commands.Choice(name=f, value=f) for f in filtered]
|
||||
|
||||
@app_commands.command(name="playfile", description="Odtwórz plik przesłany na serwer")
|
||||
@app_commands.describe(filename="Wybierz plik z listy przesłanych")
|
||||
@app_commands.autocomplete(filename=uploads_autocomplete)
|
||||
async def playfile(self, interaction: discord.Interaction, filename: str):
|
||||
"""Odtwórz plik przesłany na serwer"""
|
||||
if not await self.ensure_voice(interaction):
|
||||
return
|
||||
|
||||
await interaction.response.defer()
|
||||
guild_id = interaction.guild.id
|
||||
self.last_channels[guild_id] = interaction.channel
|
||||
|
||||
filepath = os.path.join("uploads", os.path.basename(filename))
|
||||
if not os.path.exists(filepath):
|
||||
await interaction.followup.send("Nie znaleziono pliku na serwerze.", ephemeral=True)
|
||||
return
|
||||
|
||||
try:
|
||||
player = await YTDLSource.from_file(filepath, loop=self.bot.loop)
|
||||
|
||||
res = await self.enqueue_track(guild_id, player, channel=interaction.channel, from_web=False)
|
||||
if res["status"] == "queued":
|
||||
await interaction.followup.send(
|
||||
f"Dodano do kolejki: {discord.utils.escape_markdown(player.title)}",
|
||||
ephemeral=False
|
||||
)
|
||||
else:
|
||||
await interaction.followup.send(
|
||||
f"Teraz odtwarzane: {discord.utils.escape_markdown(player.title)}",
|
||||
ephemeral=False
|
||||
)
|
||||
except Exception as e:
|
||||
await interaction.followup.send(
|
||||
f"Wystąpił błąd: {e}",
|
||||
ephemeral=True
|
||||
)
|
||||
|
||||
async def play_next(self, guild_id: int, advance: bool = True):
|
||||
voice_client = discord.utils.get(self.bot.voice_clients, guild__id=guild_id)
|
||||
if not voice_client:
|
||||
self.set_current(guild_id, None)
|
||||
return
|
||||
|
||||
if self.jump_flag.get(guild_id, False):
|
||||
self.jump_flag[guild_id] = False
|
||||
advance = False
|
||||
|
||||
queue = self.get_queue(guild_id)
|
||||
if len(queue) == 0:
|
||||
self.set_queue_index(guild_id, -1)
|
||||
self.set_current(guild_id, None)
|
||||
return
|
||||
|
||||
idx = self.get_queue_index(guild_id)
|
||||
if idx == -1 and len(queue) > 0:
|
||||
idx = 0
|
||||
|
||||
if not advance:
|
||||
if 0 <= idx < len(queue) and self.get_current(guild_id) is not None:
|
||||
next_idx = idx
|
||||
else:
|
||||
next_idx = len(queue) - 1
|
||||
else:
|
||||
if self.get_loop_current(guild_id):
|
||||
next_idx = idx
|
||||
elif self.get_loop_playlist(guild_id):
|
||||
next_idx = (idx + 1) % len(queue)
|
||||
else:
|
||||
next_idx = idx + 1
|
||||
|
||||
if next_idx >= len(queue):
|
||||
self.set_queue_index(guild_id, next_idx)
|
||||
self.set_current(guild_id, None)
|
||||
await self.trigger_state_change()
|
||||
await self.send_to_last_channel(guild_id, "Kolejka zakończona.")
|
||||
return
|
||||
|
||||
self.set_queue_index(guild_id, next_idx)
|
||||
track = queue[next_idx]
|
||||
|
||||
if getattr(track, 'played', False):
|
||||
try:
|
||||
player = await self.get_fresh_player(track)
|
||||
except Exception as e:
|
||||
print(f"Error getting fresh player for track {track.title}: {e}")
|
||||
await self.send_to_last_channel(guild_id, f"⚠️ Nie udało się odtworzyć: {track.title} ({e}). Pomijam.")
|
||||
return await self.play_next(guild_id, advance=True)
|
||||
else:
|
||||
player = track
|
||||
|
||||
player.played = True
|
||||
current_plays = getattr(player, 'plays_left', self.get_default_plays())
|
||||
player.plays_left = current_plays - 1
|
||||
|
||||
if player.plays_left <= 0:
|
||||
queue.pop(next_idx)
|
||||
self.set_queue_index(guild_id, next_idx - 1)
|
||||
if self.get_loop_current(guild_id):
|
||||
self.set_loop_current(guild_id, False)
|
||||
else:
|
||||
queue[next_idx] = player
|
||||
|
||||
self.set_current(guild_id, player)
|
||||
self.add_to_history(guild_id, player)
|
||||
await self.trigger_state_change()
|
||||
|
||||
voice_client.play(
|
||||
player,
|
||||
after=lambda e: asyncio.run_coroutine_threadsafe(
|
||||
self.play_next(guild_id, advance=True),
|
||||
self.bot.loop
|
||||
)
|
||||
)
|
||||
|
||||
url = player.data.get('webpage_url') or player.url
|
||||
title_clean = discord.utils.escape_markdown(player.title or "Nieznany tytuł")
|
||||
is_http = url and str(url).startswith("http")
|
||||
|
||||
embed = discord.Embed(
|
||||
title=f"▶️ {title_clean}" if not player.data.get('is_local') else f"📁 {title_clean}",
|
||||
url=url if is_http else None,
|
||||
description=f"[Kliknij tutaj, aby otworzyć link]({url})" if is_http else "Plik lokalny / brak linku",
|
||||
color=discord.Color.green()
|
||||
)
|
||||
if player.duration:
|
||||
mins, secs = divmod(int(player.duration), 60)
|
||||
embed.add_field(name="Czas trwania", value=f"{mins}:{secs:02d}", inline=True)
|
||||
embed.set_footer(text=f"Pozycja w kolejce: {next_idx + 1} / {len(queue)}")
|
||||
await self.send_to_last_channel(guild_id, embed=embed)
|
||||
|
||||
async def send_to_last_channel(self, guild_id: int, text: str = None, embed: discord.Embed = None):
|
||||
channel = self.get_notification_channel(guild_id)
|
||||
if channel:
|
||||
try:
|
||||
await channel.send(content=text if text else None, embed=embed)
|
||||
except Exception as e:
|
||||
print(f"Failed to send message: {e}")
|
||||
|
||||
@app_commands.command(name="queue", description="Pokaż aktualną kolejkę")
|
||||
async def show_queue(self, interaction: discord.Interaction):
|
||||
"""Pokaż aktualną kolejkę"""
|
||||
guild_id = interaction.guild.id
|
||||
queue = self.get_queue(guild_id)
|
||||
if not queue:
|
||||
await interaction.response.send_message(
|
||||
"Kolejka jest pusta.",
|
||||
ephemeral=True
|
||||
)
|
||||
return
|
||||
|
||||
lines = []
|
||||
current_idx = self.get_queue_index(guild_id)
|
||||
current_playing = self.get_current(guild_id)
|
||||
if current_playing and (current_idx < 0 or current_idx >= len(queue)):
|
||||
plays = getattr(current_playing, 'plays_left', 0)
|
||||
lines.append(f"▶️ **{discord.utils.escape_markdown(current_playing.title)}** (obecnie odtwarzane - ostatnie odtworzenie) [🔁 {plays}]\n---")
|
||||
for i, item in enumerate(queue):
|
||||
prefix = "▶️ **" if i == current_idx else f"{i + 1}. "
|
||||
suffix = "** (obecnie odtwarzane)" if i == current_idx else ""
|
||||
plays = getattr(item, 'plays_left', self.get_default_plays())
|
||||
lines.append(f"{prefix}{discord.utils.escape_markdown(item.title)}{suffix} [🔁 {plays}]")
|
||||
queue_list = "\n".join(lines[:30])
|
||||
if len(lines) > 30:
|
||||
queue_list += f"\n... i {len(lines) - 30} więcej."
|
||||
await interaction.response.send_message(
|
||||
f"Aktualna kolejka:\n{queue_list}",
|
||||
ephemeral=False
|
||||
)
|
||||
|
||||
async def history_autocomplete(
|
||||
self,
|
||||
interaction: discord.Interaction,
|
||||
current: str,
|
||||
) -> list[app_commands.Choice[str]]:
|
||||
guild_id = interaction.guild.id
|
||||
history = self.load_history(guild_id)
|
||||
filtered = [h for h in history if current.lower() in h["title"].lower()][:25]
|
||||
return [app_commands.Choice(name=h["title"][:100], value=str(h["id"])) for h in filtered]
|
||||
|
||||
@app_commands.command(name="history", description="Pokaż historię ostatnio odtwarzanych utworów")
|
||||
async def show_history(self, interaction: discord.Interaction):
|
||||
"""Pokaż historię odtwarzania"""
|
||||
guild_id = interaction.guild.id
|
||||
history = self.load_history(guild_id)
|
||||
if not history:
|
||||
await interaction.response.send_message(
|
||||
"Historia odtwarzania jest pusta.",
|
||||
ephemeral=True
|
||||
)
|
||||
return
|
||||
|
||||
history_list = "\n".join([f"{i + 1}. {discord.utils.escape_markdown(item['title'])}" for i, item in enumerate(history[:15])])
|
||||
await interaction.response.send_message(
|
||||
f"📜 Historia odtwarzania (ostatnie 15):\n{history_list}",
|
||||
ephemeral=False
|
||||
)
|
||||
|
||||
@app_commands.command(name="replay", description="Odtwórz ponownie utwór z historii")
|
||||
@app_commands.describe(track_id="Wybierz utwór z historii odtwarzania")
|
||||
@app_commands.autocomplete(track_id=history_autocomplete)
|
||||
async def replay(self, interaction: discord.Interaction, track_id: str):
|
||||
"""Odtwórz z historii"""
|
||||
if not await self.ensure_voice(interaction):
|
||||
return
|
||||
|
||||
await interaction.response.defer()
|
||||
guild_id = interaction.guild.id
|
||||
self.last_channels[guild_id] = interaction.channel
|
||||
|
||||
history = self.load_history(guild_id)
|
||||
entry = next((item for item in history if str(item["id"]) == track_id), None)
|
||||
|
||||
# If not found by ID, maybe user typed an index number 1..15
|
||||
if not entry and track_id.isdigit():
|
||||
idx = int(track_id) - 1
|
||||
if 0 <= idx < len(history):
|
||||
entry = history[idx]
|
||||
|
||||
if not entry:
|
||||
await interaction.followup.send("Nie znaleziono utworu w historii.", ephemeral=True)
|
||||
return
|
||||
|
||||
try:
|
||||
if entry.get("is_local"):
|
||||
filepath = entry.get("filepath") or entry.get("url")
|
||||
if not os.path.exists(filepath):
|
||||
await interaction.followup.send("Plik lokalny z historii już nie istnieje na serwerze.", ephemeral=True)
|
||||
return
|
||||
player = await YTDLSource.from_file(filepath, loop=self.bot.loop, title=entry["title"])
|
||||
else:
|
||||
player = await YTDLSource.from_url(entry["url"], loop=self.bot.loop, stream=True)
|
||||
|
||||
res = await self.enqueue_track(guild_id, player, channel=interaction.channel, from_web=False)
|
||||
if res["status"] == "queued":
|
||||
await interaction.followup.send(
|
||||
f"Dodano do kolejki z historii: {discord.utils.escape_markdown(player.title)}",
|
||||
ephemeral=False
|
||||
)
|
||||
else:
|
||||
await interaction.followup.send(
|
||||
f"Teraz odtwarzane z historii: {discord.utils.escape_markdown(player.title)}",
|
||||
ephemeral=False
|
||||
)
|
||||
except Exception as e:
|
||||
await interaction.followup.send(f"Wystąpił błąd: {e}", ephemeral=True)
|
||||
|
||||
@app_commands.command(name="skip", description="Pomiń aktualny utwór")
|
||||
async def skip(self, interaction: discord.Interaction):
|
||||
"""Pomiń aktualny utwór"""
|
||||
guild_id = interaction.guild.id
|
||||
if self.get_loop_current(guild_id):
|
||||
self.set_loop_current(guild_id, False)
|
||||
if interaction.guild.voice_client and (interaction.guild.voice_client.is_playing() or interaction.guild.voice_client.is_paused()):
|
||||
interaction.guild.voice_client.stop()
|
||||
await self.trigger_state_change()
|
||||
await interaction.response.send_message(
|
||||
"Pominięto aktualny utwór.",
|
||||
ephemeral=False
|
||||
)
|
||||
else:
|
||||
await interaction.response.send_message(
|
||||
"Nic nie jest odtwarzane.",
|
||||
ephemeral=True
|
||||
)
|
||||
|
||||
@app_commands.command(name="pause", description="Wstrzymaj odtwarzanie")
|
||||
async def pause(self, interaction: discord.Interaction):
|
||||
"""Wstrzymaj odtwarzanie"""
|
||||
if interaction.guild.voice_client.is_playing():
|
||||
interaction.guild.voice_client.pause()
|
||||
await self.trigger_state_change()
|
||||
await interaction.response.send_message(
|
||||
"Odtwarzanie wstrzymane.",
|
||||
ephemeral=False
|
||||
)
|
||||
else:
|
||||
await interaction.response.send_message(
|
||||
"Nic nie jest odtwarzane.",
|
||||
ephemeral=True
|
||||
)
|
||||
|
||||
@app_commands.command(name="resume", description="Wznów odtwarzanie")
|
||||
async def resume(self, interaction: discord.Interaction):
|
||||
"""Wznów odtwarzanie"""
|
||||
if interaction.guild.voice_client.is_paused():
|
||||
interaction.guild.voice_client.resume()
|
||||
await self.trigger_state_change()
|
||||
await interaction.response.send_message(
|
||||
"Odtwarzanie wznowione.",
|
||||
ephemeral=False
|
||||
)
|
||||
else:
|
||||
await interaction.response.send_message(
|
||||
"Odtwarzanie nie jest wstrzymane.",
|
||||
ephemeral=True
|
||||
)
|
||||
|
||||
@app_commands.command(name="stop", description="Zatrzymaj odtwarzanie i wyczyść kolejkę")
|
||||
async def stop(self, interaction: discord.Interaction):
|
||||
"""Zatrzymaj odtwarzanie i wyczyść kolejkę"""
|
||||
guild_id = interaction.guild.id
|
||||
if interaction.guild.voice_client.is_playing():
|
||||
interaction.guild.voice_client.stop()
|
||||
self.clear_queue(guild_id)
|
||||
await self.trigger_state_change()
|
||||
await interaction.response.send_message(
|
||||
"Zatrzymano odtwarzanie i wyczyszczono kolejkę.",
|
||||
ephemeral=False
|
||||
)
|
||||
|
||||
@app_commands.command(name="volume", description="Zmień głośność odtwarzacza")
|
||||
@app_commands.describe(volume="Poziom głośności (1-100)")
|
||||
async def volume(self, interaction: discord.Interaction, volume: int):
|
||||
"""Zmień głośność odtwarzacza"""
|
||||
guild_id = interaction.guild.id
|
||||
if interaction.guild.voice_client is None:
|
||||
return await interaction.response.send_message(
|
||||
"Nie połączono z kanałem głosowym.",
|
||||
ephemeral=True
|
||||
)
|
||||
|
||||
if 0 < volume <= 100:
|
||||
self.set_volume(guild_id, volume / 100)
|
||||
interaction.guild.voice_client.source.volume = self.get_volume(guild_id)
|
||||
await self.trigger_state_change()
|
||||
await interaction.response.send_message(
|
||||
f"Zmieniono głośność na {volume}%",
|
||||
ephemeral=False
|
||||
)
|
||||
return None
|
||||
else:
|
||||
await interaction.response.send_message(
|
||||
"Wprowadź wartość z przedziału od 1 do 100.",
|
||||
ephemeral=True
|
||||
)
|
||||
return None
|
||||
|
||||
@app_commands.command(name="nowplaying", description="Pokaż aktualnie odtwarzany utwór")
|
||||
async def now_playing(self, interaction: discord.Interaction):
|
||||
"""Pokaż aktualnie odtwarzany utwór"""
|
||||
guild_id = interaction.guild.id
|
||||
current = self.get_current(guild_id)
|
||||
if current:
|
||||
await interaction.response.send_message(
|
||||
f"Teraz odtwarzane: {discord.utils.escape_markdown(current.title)}",
|
||||
ephemeral=False
|
||||
)
|
||||
else:
|
||||
await interaction.response.send_message(
|
||||
"Nic nie jest obecnie odtwarzane.",
|
||||
ephemeral=True
|
||||
)
|
||||
|
||||
@app_commands.command(name="leave", description="Odłącz bota od kanału głosowego")
|
||||
async def leave(self, interaction: discord.Interaction):
|
||||
"""Odłącz bota od kanału głosowego"""
|
||||
guild_id = interaction.guild.id
|
||||
if interaction.guild.voice_client is not None:
|
||||
await interaction.guild.voice_client.disconnect()
|
||||
self.clear_queue(guild_id)
|
||||
await interaction.response.send_message(
|
||||
"Rozłączono z kanału głosowego.",
|
||||
ephemeral=False
|
||||
)
|
||||
else:
|
||||
await interaction.response.send_message(
|
||||
"Nie jestem na kanale głosowym.",
|
||||
ephemeral=True
|
||||
)
|
||||
|
||||
@app_commands.command(name="loop", description="Zmień tryb zapętlania (Wyłączone -> Cała kolejka -> Jeden utwór)")
|
||||
async def loop_command(self, interaction: discord.Interaction):
|
||||
"""Zmień tryb zapętlania jak w YT Music/Spotify"""
|
||||
guild_id = interaction.guild.id
|
||||
loop_current = self.get_loop_current(guild_id)
|
||||
loop_pl = self.get_loop_playlist(guild_id)
|
||||
|
||||
if not loop_current and not loop_pl:
|
||||
self.set_loop_playlist(guild_id, True)
|
||||
self.set_loop_current(guild_id, False)
|
||||
msg = "🔁 Tryb zapętlania: **Cała kolejka (playlista)**"
|
||||
elif loop_pl and not loop_current:
|
||||
self.set_loop_playlist(guild_id, False)
|
||||
self.set_loop_current(guild_id, True)
|
||||
msg = "🔂 Tryb zapętlania: **Jeden utwór**"
|
||||
else:
|
||||
self.set_loop_playlist(guild_id, False)
|
||||
self.set_loop_current(guild_id, False)
|
||||
msg = "➡️ Tryb zapętlania: **Wyłączone**"
|
||||
|
||||
await interaction.response.send_message(msg, ephemeral=False)
|
||||
|
||||
@app_commands.command(name="loopplaylist", description="Włącz/wyłącz zapętlanie całej kolejki (tryb playlisty)")
|
||||
async def loopplaylist_command(self, interaction: discord.Interaction):
|
||||
"""Włącz/wyłącz zapętlanie całej kolejki"""
|
||||
guild_id = interaction.guild.id
|
||||
loop_pl = not self.get_loop_playlist(guild_id)
|
||||
self.set_loop_playlist(guild_id, loop_pl)
|
||||
if loop_pl:
|
||||
self.set_loop_current(guild_id, False)
|
||||
state = "włączone (utwory po zakończeniu wracają na koniec kolejki)" if loop_pl else "wyłączone"
|
||||
await interaction.response.send_message(
|
||||
f"🔁 Zapętlanie całej kolejki: **{state}**.",
|
||||
ephemeral=False
|
||||
)
|
||||
|
||||
@app_commands.command(name="defaultplays", description="Ustaw domyślną liczbę odtworzeń dla nowych utworów w kolejce")
|
||||
@app_commands.describe(count="Domyślna liczba odtworzeń (1-999)")
|
||||
async def default_plays_cmd(self, interaction: discord.Interaction, count: int):
|
||||
if count < 1 or count > 999:
|
||||
await interaction.response.send_message("❌ Liczba odtworzeń musi być z przedziału 1-999.", ephemeral=True)
|
||||
return
|
||||
self.set_default_plays(count)
|
||||
await self.trigger_state_change()
|
||||
await interaction.response.send_message(f"✅ Domyślna liczba odtworzeń dla nowych utworów została ustawiona na: **{count}**.")
|
||||
|
||||
@app_commands.command(name="trackplays", description="Zmień liczbę odtworzeń dla utworu w kolejce")
|
||||
@app_commands.describe(index="Pozycja w kolejce (od 1)", count="Nowa liczba odtworzeń (1-999)")
|
||||
async def track_plays_cmd(self, interaction: discord.Interaction, index: int, count: int):
|
||||
guild_id = interaction.guild.id
|
||||
queue = self.get_queue(guild_id)
|
||||
if index < 1 or index > len(queue):
|
||||
await interaction.response.send_message("❌ Nieprawidłowy numer utworu w kolejce.", ephemeral=True)
|
||||
return
|
||||
if count < 1 or count > 999:
|
||||
await interaction.response.send_message("❌ Liczba odtworzeń musi być z przedziału 1-999.", ephemeral=True)
|
||||
return
|
||||
track = queue[index - 1]
|
||||
track.plays_left = count
|
||||
await self.trigger_state_change()
|
||||
await interaction.response.send_message(f"✅ Ustawiono liczbę odtworzeń dla utworu **{discord.utils.escape_markdown(track.title)}** na **{count}**.")
|
||||
|
||||
|
||||
class MyBot(commands.Bot):
|
||||
def __init__(self):
|
||||
intents = discord.Intents.default()
|
||||
intents.message_content = True
|
||||
intents.voice_states = True
|
||||
super().__init__(command_prefix="!", intents=intents)
|
||||
|
||||
async def setup_hook(self):
|
||||
await self.add_cog(MusicBot(self))
|
||||
|
||||
if GUILD_ID:
|
||||
guild = discord.Object(id=int(GUILD_ID))
|
||||
self.tree.copy_global_to(guild=guild)
|
||||
await self.tree.sync(guild=guild)
|
||||
print(f"Synced commands to guild {GUILD_ID}")
|
||||
else:
|
||||
await self.tree.sync()
|
||||
print("Synced commands globally")
|
||||
|
||||
async def on_ready(self):
|
||||
print(f'Logged in as {self.user.name} ({self.user.id})')
|
||||
print('------')
|
||||
|
||||
|
||||
bot = MyBot()
|
||||
@@ -1,28 +1,6 @@
|
||||
import asyncio
|
||||
import uvicorn
|
||||
from bot import bot, TOKEN
|
||||
from web import app
|
||||
|
||||
|
||||
async def main():
|
||||
async with bot:
|
||||
config = uvicorn.Config(app, host="0.0.0.0", port=8000, log_level="info")
|
||||
server = uvicorn.Server(config)
|
||||
server_task = asyncio.create_task(server.serve())
|
||||
try:
|
||||
await bot.start(TOKEN)
|
||||
except Exception as e:
|
||||
print(f"Error starting Discord bot: {e}")
|
||||
print("Keep running FastAPI web server...")
|
||||
while not server.should_exit:
|
||||
try:
|
||||
await asyncio.sleep(1)
|
||||
except asyncio.CancelledError:
|
||||
break
|
||||
finally:
|
||||
server.should_exit = True
|
||||
await server_task
|
||||
"""Punkt wejścia aplikacji - cała logika mieszka w pakiecie ``zyrarbot``."""
|
||||
|
||||
from zyrarbot.__main__ import main
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
main()
|
||||
@@ -0,0 +1,48 @@
|
||||
[project]
|
||||
name = "zyrarbot"
|
||||
version = "4.0.0"
|
||||
description = "Bot muzyczny Discord z panelem webowym"
|
||||
requires-python = ">=3.13"
|
||||
dynamic = ["dependencies"]
|
||||
|
||||
[tool.setuptools.dynamic]
|
||||
dependencies = { file = ["requirements.txt"] }
|
||||
|
||||
[tool.setuptools.packages.find]
|
||||
include = ["zyrarbot*"]
|
||||
|
||||
[tool.ruff]
|
||||
target-version = "py313"
|
||||
line-length = 100
|
||||
extend-exclude = ["frontend"]
|
||||
|
||||
[tool.ruff.lint]
|
||||
select = [
|
||||
"E", # pycodestyle - błędy
|
||||
"W", # pycodestyle - ostrzeżenia
|
||||
"F", # pyflakes
|
||||
"I", # isort - kolejność importów
|
||||
"N", # pep8-naming
|
||||
"UP", # pyupgrade
|
||||
"B", # bugbear
|
||||
"C4", # comprehensions
|
||||
"SIM", # uproszczenia
|
||||
"TID", # zakaz importów względnych
|
||||
"BLE", # przechwytywanie ogólnych wyjątków
|
||||
"RUF",
|
||||
]
|
||||
|
||||
[tool.ruff.lint.flake8-bugbear]
|
||||
# Wstrzykiwanie zależności w FastAPI opiera się na wywołaniach w wartościach
|
||||
# domyślnych argumentów - to idiom biblioteki, nie pomyłka.
|
||||
extend-immutable-calls = ["fastapi.Depends", "fastapi.File", "fastapi.Query"]
|
||||
|
||||
[tool.ruff.lint.flake8-tidy-imports]
|
||||
ban-relative-imports = "all"
|
||||
|
||||
[tool.ruff.lint.isort]
|
||||
known-first-party = ["zyrarbot", "tests"]
|
||||
|
||||
[tool.ruff.lint.per-file-ignores]
|
||||
# Testy sięgają po prywatne pola atrap i celowo łamią kilka konwencji.
|
||||
"tests/*" = ["SLF001"]
|
||||
@@ -0,0 +1 @@
|
||||
"""Testy regresyjne - uruchamiane przez ``python -m unittest``."""
|
||||
@@ -0,0 +1,81 @@
|
||||
"""Atrapy pozwalające testować ``MusicPlayer`` bez Discorda i ffmpeg."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
|
||||
|
||||
class FakeTrack:
|
||||
"""Odpowiednik ``YTDLSource`` o tym samym interfejsie, ale bez audio."""
|
||||
|
||||
def __init__(self, track_id: str):
|
||||
self.id = track_id
|
||||
self.title = track_id
|
||||
self.data: dict = {}
|
||||
self.url = None
|
||||
self.duration = 10
|
||||
self.elapsed = 0.0
|
||||
self.plays_left: int | None = None
|
||||
self.played = False
|
||||
self.volume = 0.5
|
||||
self.is_local = False
|
||||
self.filepath = None
|
||||
self.display_url = None
|
||||
self.has_web_link = False
|
||||
|
||||
|
||||
class FakeVoiceClient:
|
||||
"""Klient głosowy, który zapamiętuje odtwarzane źródło zamiast je grać.
|
||||
|
||||
Nie wywołuje zwrotnie ``after`` - w testach kolejny utwór uruchamiamy ręcznie,
|
||||
tak jak zrobiłaby to biblioteka discord.py po zakończeniu ścieżki.
|
||||
"""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.playing = None
|
||||
self.after = None
|
||||
self.source = None
|
||||
|
||||
def is_playing(self) -> bool:
|
||||
return self.playing is not None
|
||||
|
||||
def is_paused(self) -> bool:
|
||||
return False
|
||||
|
||||
def play(self, source, after=None) -> None:
|
||||
self.playing = source
|
||||
self.source = source
|
||||
self.after = after
|
||||
|
||||
def stop(self) -> None:
|
||||
self.playing = None
|
||||
|
||||
|
||||
def build_player(default_plays: int = 5) -> tuple[MusicPlayer, FakeVoiceClient]:
|
||||
bot = MagicMock()
|
||||
bot.loop = asyncio.get_event_loop()
|
||||
voice_client = FakeVoiceClient()
|
||||
|
||||
async def recreate(track, loop=None):
|
||||
fresh = FakeTrack(track.id)
|
||||
fresh.plays_left = track.plays_left
|
||||
return fresh
|
||||
|
||||
tracks = MagicMock()
|
||||
tracks.recreate = recreate
|
||||
|
||||
history = MagicMock()
|
||||
history.list.return_value = []
|
||||
|
||||
config = MagicMock()
|
||||
config.get_default_plays.return_value = default_plays
|
||||
|
||||
channels = MagicMock()
|
||||
channels.resolve.return_value = None
|
||||
|
||||
player = MusicPlayer(bot, tracks, history, config, channels)
|
||||
player.voice_client = lambda guild_id: voice_client # type: ignore[method-assign]
|
||||
return player, voice_client
|
||||
@@ -0,0 +1,73 @@
|
||||
"""Przypina powierzchnię API - panel jest osobnym klientem, więc kontrakt musi być stabilny."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from zyrarbot.application import Application
|
||||
from zyrarbot.settings import Settings
|
||||
|
||||
EXPECTED_ENDPOINTS = {
|
||||
("get", "/api/status"),
|
||||
("post", "/api/play"),
|
||||
("post", "/api/play_file"),
|
||||
("post", "/api/pause"),
|
||||
("post", "/api/resume"),
|
||||
("post", "/api/skip"),
|
||||
("post", "/api/stop"),
|
||||
("post", "/api/volume"),
|
||||
("post", "/api/loop"),
|
||||
("post", "/api/loop_playlist"),
|
||||
("post", "/api/loop_cycle"),
|
||||
("post", "/api/jump"),
|
||||
("post", "/api/remove"),
|
||||
("post", "/api/reorder"),
|
||||
("post", "/api/queue/plays"),
|
||||
("get", "/api/uploads"),
|
||||
("post", "/api/upload"),
|
||||
("delete", "/api/uploads/{filename}"),
|
||||
("post", "/api/connect"),
|
||||
("post", "/api/disconnect"),
|
||||
("post", "/api/settings/text_channel"),
|
||||
("post", "/api/settings/default_plays"),
|
||||
}
|
||||
|
||||
|
||||
class ApiSurfaceTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls) -> None:
|
||||
cls._workdir = tempfile.TemporaryDirectory()
|
||||
settings = Settings(
|
||||
discord_token="test",
|
||||
config_dir=f"{cls._workdir.name}/config",
|
||||
uploads_dir=f"{cls._workdir.name}/uploads",
|
||||
static_dir=f"{cls._workdir.name}/static",
|
||||
)
|
||||
cls.spec = Application(settings).web.openapi()
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls) -> None:
|
||||
cls._workdir.cleanup()
|
||||
|
||||
def _declared(self) -> set[tuple[str, str]]:
|
||||
return {
|
||||
(method, path)
|
||||
for path, operations in self.spec["paths"].items()
|
||||
for method in operations
|
||||
}
|
||||
|
||||
def test_all_expected_endpoints_are_declared(self):
|
||||
self.assertEqual(set(), EXPECTED_ENDPOINTS - self._declared())
|
||||
|
||||
def test_no_endpoint_added_without_updating_this_test(self):
|
||||
# Panel jest odrębnym klientem - nowa trasa powinna trafić tu świadomie.
|
||||
self.assertEqual(set(), self._declared() - EXPECTED_ENDPOINTS)
|
||||
|
||||
def test_openapi_document_is_well_formed(self):
|
||||
self.assertTrue(self.spec["openapi"].startswith("3."))
|
||||
self.assertIn("ŻyrarBOT", self.spec["info"]["title"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,180 @@
|
||||
"""Sprawdza, że wskaźnikowa kolejka zachowuje się tak jak przed refaktorem."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import unittest
|
||||
|
||||
from tests.fakes import FakeTrack, build_player
|
||||
from zyrarbot.music.loop_mode import LoopMode
|
||||
|
||||
GUILD = 1
|
||||
|
||||
|
||||
class MusicPlayerQueueTest(unittest.IsolatedAsyncioTestCase):
|
||||
async def _queue_abc(self, default_plays: int = 5):
|
||||
player, voice_client = build_player(default_plays=default_plays)
|
||||
for track_id in "abc":
|
||||
await player.enqueue(GUILD, FakeTrack(track_id))
|
||||
return player, voice_client, player.state(GUILD)
|
||||
|
||||
async def test_enqueue_on_idle_guild_starts_playback(self):
|
||||
player, voice_client = build_player()
|
||||
track = FakeTrack("a")
|
||||
await player.enqueue(GUILD, track)
|
||||
|
||||
self.assertIs(voice_client.playing, track)
|
||||
self.assertEqual(player.state(GUILD).index, 0)
|
||||
|
||||
async def test_last_play_remains_pointed_to_until_playback_finishes(self):
|
||||
player, _ = build_player(default_plays=1)
|
||||
track = FakeTrack("a")
|
||||
await player.enqueue(GUILD, track)
|
||||
|
||||
state = player.state(GUILD)
|
||||
self.assertEqual(state.queue, [track])
|
||||
self.assertEqual(state.index, 0)
|
||||
self.assertIs(state.current, track)
|
||||
|
||||
await player.play_next(GUILD, advance=True)
|
||||
|
||||
self.assertEqual(state.queue, [])
|
||||
self.assertEqual(state.index, -1)
|
||||
self.assertIsNone(state.current)
|
||||
|
||||
async def test_last_play_of_recreated_track_is_removed_after_callback(self):
|
||||
player, _, state = await self._queue_abc(default_plays=2)
|
||||
state.loop_mode = LoopMode.TRACK
|
||||
|
||||
await player.play_next(GUILD, advance=True)
|
||||
self.assertEqual([track.id for track in state.queue], ["a", "b", "c"])
|
||||
self.assertEqual(state.index, 0)
|
||||
self.assertEqual(state.current.plays_left, 0)
|
||||
|
||||
await player.play_next(GUILD, advance=True)
|
||||
|
||||
self.assertEqual([track.id for track in state.queue], ["b", "c"])
|
||||
self.assertEqual(state.index, 0)
|
||||
self.assertEqual(state.current.id, "b")
|
||||
|
||||
async def test_enqueue_while_playing_only_appends(self):
|
||||
_, _, state = await self._queue_abc()
|
||||
|
||||
self.assertEqual([track.id for track in state.queue], ["a", "b", "c"])
|
||||
self.assertEqual(state.index, 0)
|
||||
self.assertEqual(state.current.id, "a")
|
||||
|
||||
async def test_advance_moves_one_position_forward(self):
|
||||
player, _, state = await self._queue_abc()
|
||||
await player.play_next(GUILD, advance=True)
|
||||
|
||||
self.assertEqual(state.index, 1)
|
||||
self.assertEqual(state.current.id, "b")
|
||||
|
||||
async def test_loop_track_replays_same_index(self):
|
||||
player, _, state = await self._queue_abc()
|
||||
await player.play_next(GUILD, advance=True)
|
||||
state.loop_mode = LoopMode.TRACK
|
||||
await player.play_next(GUILD, advance=True)
|
||||
|
||||
self.assertEqual(state.index, 1)
|
||||
self.assertEqual(state.current.id, "b")
|
||||
|
||||
async def test_loop_queue_wraps_to_start(self):
|
||||
player, _, state = await self._queue_abc()
|
||||
state.loop_mode = LoopMode.QUEUE
|
||||
state.index = 2
|
||||
await player.play_next(GUILD, advance=True)
|
||||
|
||||
self.assertEqual(state.index, 0)
|
||||
|
||||
async def test_queue_end_clears_current_track(self):
|
||||
player, _, state = await self._queue_abc()
|
||||
state.index = 2
|
||||
await player.play_next(GUILD, advance=True)
|
||||
|
||||
self.assertIsNone(state.current)
|
||||
self.assertEqual(state.index, 3)
|
||||
|
||||
async def test_jump_selects_target_without_advancing_past_it(self):
|
||||
player, _, state = await self._queue_abc()
|
||||
await player.jump(GUILD, 2)
|
||||
await player.play_next(GUILD, advance=True) # discord.py: zwrotka `after`
|
||||
|
||||
self.assertEqual(state.index, 2)
|
||||
self.assertEqual(state.current.id, "c")
|
||||
|
||||
async def test_removing_earlier_track_shifts_index_back(self):
|
||||
player, _, state = await self._queue_abc()
|
||||
await player.jump(GUILD, 2)
|
||||
await player.play_next(GUILD, advance=True)
|
||||
|
||||
self.assertTrue(await player.remove(GUILD, "a"))
|
||||
self.assertEqual([track.id for track in state.queue], ["b", "c"])
|
||||
self.assertEqual(state.index, 1)
|
||||
|
||||
async def test_removing_playing_track_plays_the_next_one(self):
|
||||
player, _, state = await self._queue_abc()
|
||||
await player.jump(GUILD, 1)
|
||||
await player.play_next(GUILD, advance=True)
|
||||
|
||||
self.assertTrue(await player.remove(GUILD, "b"))
|
||||
await player.play_next(GUILD, advance=True)
|
||||
|
||||
self.assertEqual([track.id for track in state.queue], ["a", "c"])
|
||||
self.assertEqual(state.index, 1)
|
||||
self.assertEqual(state.current.id, "c")
|
||||
|
||||
async def test_removing_unknown_track_reports_failure(self):
|
||||
player, _, _ = await self._queue_abc()
|
||||
self.assertFalse(await player.remove(GUILD, "nope"))
|
||||
|
||||
async def test_reorder_keeps_index_on_playing_track(self):
|
||||
player, _, state = await self._queue_abc()
|
||||
await player.jump(GUILD, 0)
|
||||
await player.play_next(GUILD, advance=True)
|
||||
|
||||
player.reorder(GUILD, ["c", "b", "a"])
|
||||
|
||||
self.assertEqual([track.id for track in state.queue], ["c", "b", "a"])
|
||||
self.assertEqual(state.index, 2)
|
||||
self.assertIs(state.queue[state.index], state.current)
|
||||
|
||||
async def test_guild_volume_applies_to_new_track(self):
|
||||
player, _ = build_player()
|
||||
player.set_volume(GUILD, 0.25)
|
||||
|
||||
track = FakeTrack("v")
|
||||
await player.enqueue(GUILD, track)
|
||||
|
||||
self.assertEqual(track.volume, 0.25)
|
||||
|
||||
async def test_broken_tracks_stop_instead_of_looping_forever(self):
|
||||
player, _, state = await self._queue_abc()
|
||||
|
||||
async def always_fails(track, loop=None):
|
||||
raise RuntimeError("brak dostępu do źródła")
|
||||
|
||||
player._tracks.recreate = always_fails
|
||||
for track in state.queue:
|
||||
track.played = True
|
||||
|
||||
state.loop_mode = LoopMode.QUEUE
|
||||
await player.play_next(GUILD, advance=True)
|
||||
|
||||
self.assertIsNone(state.current)
|
||||
|
||||
|
||||
class LoopModeTest(unittest.TestCase):
|
||||
def test_cycle_order(self):
|
||||
self.assertIs(LoopMode.OFF.next(), LoopMode.QUEUE)
|
||||
self.assertIs(LoopMode.QUEUE.next(), LoopMode.TRACK)
|
||||
self.assertIs(LoopMode.TRACK.next(), LoopMode.OFF)
|
||||
|
||||
def test_api_values_match_panel_contract(self):
|
||||
self.assertEqual(LoopMode.OFF.value, "off")
|
||||
self.assertEqual(LoopMode.QUEUE.value, "playlist")
|
||||
self.assertEqual(LoopMode.TRACK.value, "single")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,756 +0,0 @@
|
||||
from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect, UploadFile, File
|
||||
from pydantic import BaseModel
|
||||
from typing import List, Optional
|
||||
import asyncio
|
||||
import discord
|
||||
import os
|
||||
import shutil
|
||||
|
||||
# Import bot instance and YTDL class
|
||||
from bot import bot
|
||||
from ytdl import YTDLSource
|
||||
|
||||
# Initialize FastAPI application.
|
||||
# The service exposes the API only - the web panel is a separate container.
|
||||
app = FastAPI(title="ŻyrarBOT API")
|
||||
|
||||
# FastAPI Request Models
|
||||
class PlayRequest(BaseModel):
|
||||
query: str
|
||||
|
||||
class VolumeRequest(BaseModel):
|
||||
volume: int
|
||||
|
||||
class LoopRequest(BaseModel):
|
||||
loop: bool
|
||||
|
||||
class RemoveRequest(BaseModel):
|
||||
id: str
|
||||
|
||||
class ReorderRequest(BaseModel):
|
||||
queue_ids: List[str]
|
||||
|
||||
class JumpRequest(BaseModel):
|
||||
index: int
|
||||
|
||||
class ConnectRequest(BaseModel):
|
||||
channel_id: str
|
||||
|
||||
class TextChannelRequest(BaseModel):
|
||||
channel_id: str
|
||||
guild_id: Optional[str] = None
|
||||
|
||||
class PlayFileRequest(BaseModel):
|
||||
filename: str
|
||||
|
||||
class DefaultPlaysRequest(BaseModel):
|
||||
default_plays: int
|
||||
|
||||
class TrackPlaysRequest(BaseModel):
|
||||
id: str
|
||||
plays: int
|
||||
|
||||
# Connection Manager for WebSockets
|
||||
class ConnectionManager:
|
||||
def __init__(self):
|
||||
self.active_connections: List[WebSocket] = []
|
||||
|
||||
async def connect(self, websocket: WebSocket):
|
||||
await websocket.accept()
|
||||
self.active_connections.append(websocket)
|
||||
|
||||
def disconnect(self, websocket: WebSocket):
|
||||
if websocket in self.active_connections:
|
||||
self.active_connections.remove(websocket)
|
||||
|
||||
async def broadcast(self, message: dict):
|
||||
for connection in list(self.active_connections):
|
||||
try:
|
||||
await connection.send_json(message)
|
||||
except Exception:
|
||||
self.disconnect(connection)
|
||||
|
||||
manager = ConnectionManager()
|
||||
|
||||
# Helper to determine active guild
|
||||
def get_active_guild():
|
||||
voice_client = bot.voice_clients[0] if bot.voice_clients else None
|
||||
if voice_client:
|
||||
return voice_client.guild
|
||||
elif bot.guilds:
|
||||
return bot.guilds[0]
|
||||
return None
|
||||
|
||||
# FastAPI Endpoints
|
||||
@app.get("/")
|
||||
async def root():
|
||||
"""Service descriptor - the panel is served by its own container."""
|
||||
return {
|
||||
"service": "zyrarbot-api",
|
||||
"docs": "/docs",
|
||||
"status": "/api/status",
|
||||
"websocket": "/ws",
|
||||
}
|
||||
|
||||
@app.get("/api/health")
|
||||
async def health():
|
||||
return {"status": "ok", "discord_ready": bot.is_ready()}
|
||||
|
||||
@app.get("/api/status")
|
||||
async def get_status():
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
return {"error": "MusicBot cog not loaded"}
|
||||
|
||||
all_guilds = []
|
||||
for g in bot.guilds:
|
||||
g_tc = []
|
||||
for tc in g.text_channels:
|
||||
if tc.permissions_for(g.me).send_messages:
|
||||
g_tc.append({
|
||||
"channel_id": str(tc.id),
|
||||
"channel_name": tc.name
|
||||
})
|
||||
active_notif = music_cog.get_notification_channel(g.id)
|
||||
all_guilds.append({
|
||||
"guild_id": str(g.id),
|
||||
"guild_name": g.name,
|
||||
"text_channels": g_tc,
|
||||
"active_notification_channel_id": str(active_notif.id) if active_notif else None
|
||||
})
|
||||
|
||||
all_voice_channels = []
|
||||
for g in bot.guilds:
|
||||
for vc in g.voice_channels:
|
||||
all_voice_channels.append({
|
||||
"guild_name": g.name,
|
||||
"guild_id": str(g.id),
|
||||
"channel_name": vc.name,
|
||||
"channel_id": str(vc.id)
|
||||
})
|
||||
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
return {
|
||||
"playing": False,
|
||||
"paused": False,
|
||||
"loop_single": False,
|
||||
"loop_playlist": False,
|
||||
"volume": 100,
|
||||
"current": None,
|
||||
"queue": [],
|
||||
"history": [],
|
||||
"voice_channels": all_voice_channels,
|
||||
"active_voice_channel": None,
|
||||
"text_channels": [],
|
||||
"active_text_channel_id": None,
|
||||
"guilds": all_guilds,
|
||||
"default_plays": music_cog.get_default_plays() if music_cog else 5
|
||||
}
|
||||
|
||||
guild_id = guild.id
|
||||
|
||||
# Active voice channel
|
||||
voice_client = discord.utils.get(bot.voice_clients, guild__id=guild_id)
|
||||
active_vc = None
|
||||
if voice_client and voice_client.channel:
|
||||
active_vc = {
|
||||
"channel_name": voice_client.channel.name,
|
||||
"channel_id": str(voice_client.channel.id),
|
||||
"guild_name": voice_client.channel.guild.name,
|
||||
"guild_id": str(voice_client.channel.guild.id)
|
||||
}
|
||||
|
||||
# Gather text channels available to the bot on this active guild where it can write
|
||||
text_channels = []
|
||||
for channel in guild.text_channels:
|
||||
if channel.permissions_for(guild.me).send_messages:
|
||||
text_channels.append({
|
||||
"guild_name": guild.name,
|
||||
"guild_id": str(guild.id),
|
||||
"channel_name": channel.name,
|
||||
"channel_id": str(channel.id)
|
||||
})
|
||||
|
||||
active_tc_id = None
|
||||
active_tc = music_cog.get_notification_channel(guild_id)
|
||||
if active_tc:
|
||||
active_tc_id = str(active_tc.id)
|
||||
|
||||
playing = voice_client.is_playing() if voice_client else False
|
||||
paused = voice_client.is_paused() if voice_client else False
|
||||
|
||||
current_track = music_cog.get_current(guild_id)
|
||||
queue = music_cog.get_queue(guild_id)
|
||||
|
||||
return {
|
||||
"playing": playing,
|
||||
"paused": paused,
|
||||
"loop_single": music_cog.get_loop_current(guild_id),
|
||||
"loop_playlist": music_cog.get_loop_playlist(guild_id),
|
||||
"volume": int(music_cog.get_volume(guild_id) * 100),
|
||||
"current": {
|
||||
"title": current_track.title,
|
||||
"url": current_track.data.get("webpage_url") or current_track.url,
|
||||
"id": current_track.id,
|
||||
"duration": current_track.duration,
|
||||
"elapsed": round(current_track.elapsed, 1),
|
||||
"plays_left": getattr(current_track, 'plays_left', music_cog.get_default_plays())
|
||||
} if current_track else None,
|
||||
"queue": [
|
||||
{
|
||||
"title": item.title,
|
||||
"url": item.data.get("webpage_url") or item.url,
|
||||
"id": item.id,
|
||||
"plays_left": getattr(item, 'plays_left', music_cog.get_default_plays())
|
||||
} for item in queue
|
||||
],
|
||||
"queue_index": music_cog.get_queue_index(guild_id),
|
||||
"default_plays": music_cog.get_default_plays(),
|
||||
"voice_channels": all_voice_channels,
|
||||
"active_voice_channel": active_vc,
|
||||
"text_channels": text_channels,
|
||||
"active_text_channel_id": active_tc_id,
|
||||
"guilds": all_guilds,
|
||||
"history": [
|
||||
{
|
||||
"id": item["id"],
|
||||
"title": item["title"],
|
||||
"url": item["url"],
|
||||
"duration": item.get("duration"),
|
||||
"is_local": item.get("is_local", False),
|
||||
"filepath": item.get("filepath")
|
||||
} for item in music_cog.load_history(guild_id)[:20]
|
||||
]
|
||||
}
|
||||
|
||||
@app.websocket("/ws")
|
||||
async def websocket_endpoint(websocket: WebSocket):
|
||||
await manager.connect(websocket)
|
||||
try:
|
||||
# Immediately send status upon connection
|
||||
status = await get_status()
|
||||
await websocket.send_json(status)
|
||||
|
||||
while True:
|
||||
# Maintain connection, listen for disconnect
|
||||
await websocket.receive_text()
|
||||
except WebSocketDisconnect:
|
||||
manager.disconnect(websocket)
|
||||
except Exception as e:
|
||||
print(f"WS connection error: {e}")
|
||||
manager.disconnect(websocket)
|
||||
|
||||
async def broadcast_status():
|
||||
if not manager.active_connections:
|
||||
return
|
||||
try:
|
||||
status = await get_status()
|
||||
await manager.broadcast(status)
|
||||
except Exception as e:
|
||||
print(f"Error in broadcast_status: {e}")
|
||||
|
||||
@app.post("/api/play")
|
||||
async def api_play(req: PlayRequest):
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
raise HTTPException(status_code=500, detail="MusicBot cog not loaded")
|
||||
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
|
||||
guild_id = guild.id
|
||||
voice_client = discord.utils.get(bot.voice_clients, guild__id=guild_id)
|
||||
if not voice_client:
|
||||
raise HTTPException(status_code=400, detail="Bot is not connected to a voice channel on this server")
|
||||
|
||||
try:
|
||||
filepath = os.path.join("uploads", os.path.basename(req.query))
|
||||
if os.path.exists(filepath) and not req.query.startswith("http"):
|
||||
player = await YTDLSource.from_file(filepath, loop=bot.loop)
|
||||
else:
|
||||
player = await YTDLSource.from_url(req.query, loop=bot.loop, stream=True)
|
||||
|
||||
res = await music_cog.enqueue_track(guild_id, player, from_web=True)
|
||||
await broadcast_status()
|
||||
return res
|
||||
except Exception as e:
|
||||
raise HTTPException(status_code=500, detail=str(e))
|
||||
|
||||
@app.post("/api/pause")
|
||||
async def api_pause():
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
|
||||
voice_client = discord.utils.get(bot.voice_clients, guild__id=guild.id)
|
||||
if voice_client and voice_client.is_playing():
|
||||
voice_client.pause()
|
||||
await broadcast_status()
|
||||
return {"status": "paused"}
|
||||
raise HTTPException(status_code=400, detail="Bot is not playing on this server")
|
||||
|
||||
@app.post("/api/resume")
|
||||
async def api_resume():
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
|
||||
voice_client = discord.utils.get(bot.voice_clients, guild__id=guild.id)
|
||||
if voice_client and voice_client.is_paused():
|
||||
voice_client.resume()
|
||||
await broadcast_status()
|
||||
return {"status": "resumed"}
|
||||
raise HTTPException(status_code=400, detail="Bot is not paused on this server")
|
||||
|
||||
@app.post("/api/skip")
|
||||
async def api_skip():
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
|
||||
if music_cog and music_cog.get_loop_current(guild.id):
|
||||
music_cog.set_loop_current(guild.id, False)
|
||||
|
||||
voice_client = discord.utils.get(bot.voice_clients, guild__id=guild.id)
|
||||
if voice_client and (voice_client.is_playing() or voice_client.is_paused()):
|
||||
voice_client.stop()
|
||||
await broadcast_status()
|
||||
return {"status": "skipped"}
|
||||
raise HTTPException(status_code=400, detail="Bot is not playing anything on this server")
|
||||
|
||||
@app.post("/api/jump")
|
||||
async def api_jump(req: JumpRequest):
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
raise HTTPException(status_code=500, detail="MusicBot cog not loaded")
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
guild_id = guild.id
|
||||
queue = music_cog.get_queue(guild_id)
|
||||
if req.index < 0 or req.index >= len(queue):
|
||||
raise HTTPException(status_code=400, detail="Invalid track index")
|
||||
|
||||
if music_cog.get_loop_current(guild_id):
|
||||
music_cog.set_loop_current(guild_id, False)
|
||||
|
||||
music_cog.set_queue_index(guild_id, req.index)
|
||||
music_cog.jump_flag[guild_id] = True
|
||||
|
||||
voice_client = discord.utils.get(bot.voice_clients, guild__id=guild_id)
|
||||
if voice_client and (voice_client.is_playing() or voice_client.is_paused()):
|
||||
voice_client.stop()
|
||||
else:
|
||||
await music_cog.play_next(guild_id, advance=False)
|
||||
|
||||
await broadcast_status()
|
||||
return {"status": "jumped"}
|
||||
|
||||
@app.post("/api/stop")
|
||||
async def api_stop():
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
raise HTTPException(status_code=500, detail="MusicBot cog not loaded")
|
||||
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
return {"status": "stopped"}
|
||||
|
||||
guild_id = guild.id
|
||||
voice_client = discord.utils.get(bot.voice_clients, guild__id=guild_id)
|
||||
if voice_client and (voice_client.is_playing() or voice_client.is_paused()):
|
||||
voice_client.stop()
|
||||
|
||||
music_cog.clear_queue(guild_id)
|
||||
await broadcast_status()
|
||||
return {"status": "stopped"}
|
||||
|
||||
@app.post("/api/volume")
|
||||
async def api_volume(req: VolumeRequest):
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
raise HTTPException(status_code=500, detail="MusicBot cog not loaded")
|
||||
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
|
||||
guild_id = guild.id
|
||||
if 0 <= req.volume <= 100:
|
||||
music_cog.set_volume(guild_id, req.volume / 100)
|
||||
voice_client = discord.utils.get(bot.voice_clients, guild__id=guild_id)
|
||||
if voice_client and voice_client.source:
|
||||
voice_client.source.volume = music_cog.get_volume(guild_id)
|
||||
await broadcast_status()
|
||||
return {"status": "success", "volume": req.volume}
|
||||
raise HTTPException(status_code=400, detail="Volume must be between 0 and 100")
|
||||
|
||||
@app.post("/api/loop")
|
||||
async def api_loop(req: LoopRequest):
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
raise HTTPException(status_code=500, detail="MusicBot cog not loaded")
|
||||
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
|
||||
music_cog.set_loop_current(guild.id, req.loop)
|
||||
if req.loop:
|
||||
music_cog.set_loop_playlist(guild.id, False)
|
||||
await broadcast_status()
|
||||
return {"status": "success", "loop": req.loop}
|
||||
|
||||
@app.post("/api/loop_playlist")
|
||||
async def api_loop_playlist():
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
raise HTTPException(status_code=500, detail="MusicBot cog not loaded")
|
||||
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
|
||||
current_state = music_cog.get_loop_playlist(guild.id)
|
||||
new_state = not current_state
|
||||
music_cog.set_loop_playlist(guild.id, new_state)
|
||||
if new_state:
|
||||
music_cog.set_loop_current(guild.id, False)
|
||||
await broadcast_status()
|
||||
return {"status": "success", "loop_playlist": new_state}
|
||||
|
||||
@app.post("/api/loop_cycle")
|
||||
async def api_loop_cycle():
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
raise HTTPException(status_code=500, detail="MusicBot cog not loaded")
|
||||
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
|
||||
loop_current = music_cog.get_loop_current(guild.id)
|
||||
loop_pl = music_cog.get_loop_playlist(guild.id)
|
||||
|
||||
if not loop_current and not loop_pl:
|
||||
music_cog.set_loop_playlist(guild.id, True)
|
||||
music_cog.set_loop_current(guild.id, False)
|
||||
mode = "playlist"
|
||||
elif loop_pl and not loop_current:
|
||||
music_cog.set_loop_playlist(guild.id, False)
|
||||
music_cog.set_loop_current(guild.id, True)
|
||||
mode = "single"
|
||||
else:
|
||||
music_cog.set_loop_playlist(guild.id, False)
|
||||
music_cog.set_loop_current(guild.id, False)
|
||||
mode = "off"
|
||||
|
||||
await broadcast_status()
|
||||
return {"status": "success", "mode": mode}
|
||||
|
||||
@app.post("/api/remove")
|
||||
async def api_remove(req: RemoveRequest):
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
raise HTTPException(status_code=500, detail="MusicBot cog not loaded")
|
||||
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
|
||||
guild_id = guild.id
|
||||
queue = music_cog.get_queue(guild_id)
|
||||
current_idx = music_cog.get_queue_index(guild_id)
|
||||
|
||||
removed_idx = -1
|
||||
for idx, item in enumerate(queue):
|
||||
if item.id == req.id:
|
||||
removed_idx = idx
|
||||
break
|
||||
|
||||
if removed_idx == -1:
|
||||
raise HTTPException(status_code=404, detail="Track not found in queue")
|
||||
|
||||
if removed_idx == current_idx:
|
||||
new_queue = [item for idx, item in enumerate(queue) if idx != removed_idx]
|
||||
music_cog.queues[guild_id] = new_queue
|
||||
music_cog.set_queue_index(guild_id, current_idx)
|
||||
music_cog.jump_flag[guild_id] = True
|
||||
voice_client = discord.utils.get(bot.voice_clients, guild__id=guild_id)
|
||||
if voice_client and (voice_client.is_playing() or voice_client.is_paused()):
|
||||
voice_client.stop()
|
||||
else:
|
||||
await music_cog.play_next(guild_id, advance=False)
|
||||
else:
|
||||
new_queue = [item for idx, item in enumerate(queue) if idx != removed_idx]
|
||||
music_cog.queues[guild_id] = new_queue
|
||||
if removed_idx < current_idx:
|
||||
music_cog.set_queue_index(guild_id, current_idx - 1)
|
||||
|
||||
await broadcast_status()
|
||||
return {"status": "removed"}
|
||||
|
||||
@app.post("/api/reorder")
|
||||
async def api_reorder(req: ReorderRequest):
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
raise HTTPException(status_code=500, detail="MusicBot cog not loaded")
|
||||
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
|
||||
guild_id = guild.id
|
||||
queue = music_cog.get_queue(guild_id)
|
||||
current_idx = music_cog.get_queue_index(guild_id)
|
||||
curr_item = queue[current_idx] if 0 <= current_idx < len(queue) else None
|
||||
|
||||
queue_map = {item.id: item for item in queue}
|
||||
|
||||
new_queue = []
|
||||
for track_id in req.queue_ids:
|
||||
if track_id in queue_map:
|
||||
new_queue.append(queue_map[track_id])
|
||||
|
||||
# Retain any items not present in the reordered IDs list
|
||||
for item in queue:
|
||||
if item.id not in req.queue_ids:
|
||||
new_queue.append(item)
|
||||
|
||||
music_cog.queues[guild_id] = new_queue
|
||||
if curr_item:
|
||||
try:
|
||||
music_cog.set_queue_index(guild_id, new_queue.index(curr_item))
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
await broadcast_status()
|
||||
return {"status": "success"}
|
||||
|
||||
@app.get("/api/uploads")
|
||||
async def get_uploads():
|
||||
uploads_dir = "uploads"
|
||||
os.makedirs(uploads_dir, exist_ok=True)
|
||||
files = []
|
||||
for f in os.listdir(uploads_dir):
|
||||
filepath = os.path.join(uploads_dir, f)
|
||||
if os.path.isfile(filepath) and not f.startswith("."):
|
||||
size_mb = round(os.path.getsize(filepath) / (1024 * 1024), 2)
|
||||
mtime = os.path.getmtime(filepath)
|
||||
files.append({
|
||||
"filename": f,
|
||||
"size_mb": size_mb,
|
||||
"mtime": mtime
|
||||
})
|
||||
files.sort(key=lambda x: x["mtime"], reverse=True)
|
||||
return {"files": files}
|
||||
|
||||
@app.post("/api/upload")
|
||||
async def api_upload_file(file: UploadFile = File(...)):
|
||||
uploads_dir = "uploads"
|
||||
os.makedirs(uploads_dir, exist_ok=True)
|
||||
|
||||
filename = os.path.basename(file.filename)
|
||||
filepath = os.path.join(uploads_dir, filename)
|
||||
|
||||
try:
|
||||
with open(filepath, "wb") as buffer:
|
||||
shutil.copyfileobj(file.file, buffer)
|
||||
return {"status": "success", "filename": filename}
|
||||
except Exception as e:
|
||||
raise HTTPException(status_code=500, detail=f"Błąd zapisu pliku: {e}")
|
||||
|
||||
@app.delete("/api/uploads/{filename}")
|
||||
async def api_delete_file(filename: str):
|
||||
uploads_dir = "uploads"
|
||||
filepath = os.path.join(uploads_dir, os.path.basename(filename))
|
||||
if os.path.exists(filepath):
|
||||
try:
|
||||
os.remove(filepath)
|
||||
return {"status": "deleted"}
|
||||
except Exception as e:
|
||||
raise HTTPException(status_code=500, detail=str(e))
|
||||
raise HTTPException(status_code=404, detail="Plik nie istnieje")
|
||||
|
||||
@app.post("/api/play_file")
|
||||
async def api_play_file(req: PlayFileRequest):
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
raise HTTPException(status_code=500, detail="MusicBot cog not loaded")
|
||||
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
|
||||
guild_id = guild.id
|
||||
voice_client = discord.utils.get(bot.voice_clients, guild__id=guild_id)
|
||||
if not voice_client:
|
||||
raise HTTPException(status_code=400, detail="Bot is not connected to a voice channel on this server")
|
||||
|
||||
filepath = os.path.join("uploads", os.path.basename(req.filename))
|
||||
if not os.path.exists(filepath):
|
||||
raise HTTPException(status_code=404, detail="Plik nie istnieje na serwerze")
|
||||
|
||||
try:
|
||||
os.utime(filepath, None)
|
||||
player = await YTDLSource.from_file(filepath, loop=bot.loop)
|
||||
res = await music_cog.enqueue_track(guild_id, player, from_web=True)
|
||||
await broadcast_status()
|
||||
return res
|
||||
except Exception as e:
|
||||
raise HTTPException(status_code=500, detail=str(e))
|
||||
|
||||
@app.post("/api/connect")
|
||||
async def api_connect(req: ConnectRequest):
|
||||
try:
|
||||
channel_id = int(req.channel_id)
|
||||
except ValueError:
|
||||
raise HTTPException(status_code=400, detail="Invalid channel ID")
|
||||
|
||||
channel = bot.get_channel(channel_id)
|
||||
if not channel:
|
||||
raise HTTPException(status_code=404, detail="Voice channel not found")
|
||||
|
||||
guild_id = channel.guild.id
|
||||
|
||||
# Only disconnect voice clients from the SAME guild!
|
||||
for vc in bot.voice_clients:
|
||||
if vc.guild.id == guild_id:
|
||||
await vc.disconnect()
|
||||
|
||||
await channel.connect()
|
||||
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if music_cog and not music_cog.get_notification_channel(guild_id):
|
||||
# Save first accessible text channel to send updates
|
||||
for tc in channel.guild.text_channels:
|
||||
if tc.permissions_for(channel.guild.me).send_messages:
|
||||
music_cog.last_channels[guild_id] = tc
|
||||
break
|
||||
|
||||
await broadcast_status()
|
||||
return {"status": "connected", "channel": channel.name}
|
||||
|
||||
@app.post("/api/disconnect")
|
||||
async def api_disconnect():
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
|
||||
guild_id = guild.id
|
||||
voice_client = discord.utils.get(bot.voice_clients, guild__id=guild_id)
|
||||
if voice_client:
|
||||
await voice_client.disconnect()
|
||||
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if music_cog:
|
||||
music_cog.clear_queue(guild_id)
|
||||
|
||||
await broadcast_status()
|
||||
return {"status": "disconnected"}
|
||||
raise HTTPException(status_code=400, detail="Bot not connected to voice on this server")
|
||||
|
||||
@app.post("/api/settings/text_channel")
|
||||
async def api_set_text_channel(req: TextChannelRequest):
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
raise HTTPException(status_code=500, detail="MusicBot cog not loaded")
|
||||
|
||||
if not req.channel_id or req.channel_id == "0" or req.channel_id == "":
|
||||
if not req.guild_id:
|
||||
raise HTTPException(status_code=400, detail="guild_id required to reset channel")
|
||||
guild_id = int(req.guild_id)
|
||||
if guild_id in music_cog.last_channels:
|
||||
del music_cog.last_channels[guild_id]
|
||||
music_cog.save_channel_id(guild_id, None)
|
||||
await broadcast_status()
|
||||
return {"status": "success", "channel_id": None, "guild_id": str(guild_id)}
|
||||
|
||||
channel = bot.get_channel(int(req.channel_id))
|
||||
if not channel:
|
||||
raise HTTPException(status_code=404, detail="Text channel not found")
|
||||
|
||||
guild_id = channel.guild.id
|
||||
if req.guild_id and int(req.guild_id) != guild_id:
|
||||
raise HTTPException(status_code=400, detail="Channel does not belong to the specified guild")
|
||||
|
||||
music_cog.last_channels[guild_id] = channel
|
||||
music_cog.save_channel_id(guild_id, int(req.channel_id))
|
||||
|
||||
# Send test message to confirm
|
||||
try:
|
||||
await channel.send(f"🔔 Ten kanał został ustawiony jako główny kanał powiadomień dla ŻyrarBOT na serwerze **{channel.guild.name}** z panelu webowego.")
|
||||
except Exception as e:
|
||||
print(f"Failed to send test message: {e}")
|
||||
|
||||
await broadcast_status()
|
||||
return {"status": "success", "channel_id": req.channel_id, "guild_id": str(guild_id)}
|
||||
|
||||
@app.post("/api/settings/default_plays")
|
||||
async def api_set_default_plays(req: DefaultPlaysRequest):
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
raise HTTPException(status_code=500, detail="MusicBot cog not loaded")
|
||||
if req.default_plays < 1 or req.default_plays > 999:
|
||||
raise HTTPException(status_code=400, detail="Invalid default plays value")
|
||||
music_cog.set_default_plays(req.default_plays)
|
||||
await broadcast_status()
|
||||
return {"status": "success", "default_plays": req.default_plays}
|
||||
|
||||
@app.post("/api/queue/plays")
|
||||
async def api_set_track_plays(req: TrackPlaysRequest):
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if not music_cog:
|
||||
raise HTTPException(status_code=500, detail="MusicBot cog not loaded")
|
||||
guild = get_active_guild()
|
||||
if not guild:
|
||||
raise HTTPException(status_code=400, detail="Bot has no active server context")
|
||||
guild_id = guild.id
|
||||
queue = music_cog.get_queue(guild_id)
|
||||
if req.plays < 1 or req.plays > 999:
|
||||
raise HTTPException(status_code=400, detail="Invalid plays value")
|
||||
found = False
|
||||
for item in queue:
|
||||
if item.id == req.id:
|
||||
item.plays_left = req.plays
|
||||
found = True
|
||||
break
|
||||
if not found:
|
||||
raise HTTPException(status_code=404, detail="Track not found in queue")
|
||||
await broadcast_status()
|
||||
return {"status": "success", "id": req.id, "plays": req.plays}
|
||||
|
||||
# WebSocket Background Loop and Startup Hook
|
||||
async def status_broadcast_loop():
|
||||
while True:
|
||||
try:
|
||||
await asyncio.sleep(1)
|
||||
if manager.active_connections:
|
||||
await broadcast_status()
|
||||
except asyncio.CancelledError:
|
||||
break
|
||||
except Exception as e:
|
||||
print(f"Error in status_broadcast_loop: {e}")
|
||||
|
||||
async def wait_and_register_callback():
|
||||
for _ in range(30): # Try for 30 seconds
|
||||
await asyncio.sleep(1)
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if music_cog:
|
||||
music_cog.on_state_change_callback = broadcast_status
|
||||
print("Registered WebSocket state change callback on MusicBot cog (delayed)")
|
||||
break
|
||||
|
||||
@app.on_event("startup")
|
||||
async def startup_event():
|
||||
music_cog = bot.get_cog("MusicBot")
|
||||
if music_cog:
|
||||
music_cog.on_state_change_callback = broadcast_status
|
||||
print("Registered WebSocket state change callback on MusicBot cog")
|
||||
else:
|
||||
asyncio.create_task(wait_and_register_callback())
|
||||
|
||||
asyncio.create_task(status_broadcast_loop())
|
||||
@@ -1,92 +0,0 @@
|
||||
import discord
|
||||
import yt_dlp as youtube_dl
|
||||
import asyncio
|
||||
import uuid
|
||||
import os
|
||||
|
||||
ytdl_format_options = {
|
||||
'format': 'bestaudio/best',
|
||||
'outtmpl': '%(extractor)s-%(id)s-%(title)s.%(ext)s',
|
||||
'restrictfilenames': True,
|
||||
'noplaylist': True,
|
||||
'nocheckcertificate': True,
|
||||
'ignoreerrors': False,
|
||||
'logtostderr': False,
|
||||
'quiet': True,
|
||||
'no_warnings': True,
|
||||
'default_search': 'auto',
|
||||
'source_address': '0.0.0.0',
|
||||
}
|
||||
|
||||
ffmpeg_options = {
|
||||
'options': '-vn',
|
||||
'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5'
|
||||
}
|
||||
|
||||
ytdl = youtube_dl.YoutubeDL(ytdl_format_options)
|
||||
|
||||
|
||||
async def get_file_duration(filepath):
|
||||
try:
|
||||
proc = await asyncio.create_subprocess_exec(
|
||||
'ffprobe', '-v', 'error', '-show_entries', 'format=duration',
|
||||
'-of', 'default=noprint_wrappers=1:nokey=1', filepath,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, _ = await proc.communicate()
|
||||
if proc.returncode == 0:
|
||||
return float(stdout.decode().strip())
|
||||
except Exception as e:
|
||||
print(f"Error getting duration with ffprobe: {e}")
|
||||
return 0.0
|
||||
|
||||
|
||||
class YTDLSource(discord.PCMVolumeTransformer):
|
||||
def __init__(self, source, *, data, volume=0.5):
|
||||
super().__init__(source, volume)
|
||||
self.data = data
|
||||
self.title = data.get('title')
|
||||
self.url = data.get('url')
|
||||
self.id = uuid.uuid4().hex # Unique track identifier
|
||||
self.duration = data.get('duration') # Duration in seconds
|
||||
self.elapsed = 0.0 # Elapsed time in seconds
|
||||
self.plays_left = data.get('plays_left', None) # Remaining plays in queue
|
||||
|
||||
def read(self):
|
||||
data = super().read()
|
||||
if data:
|
||||
self.elapsed += 0.02 # 20ms frames read
|
||||
return data
|
||||
|
||||
@classmethod
|
||||
async def from_url(cls, url, *, loop=None, stream=False):
|
||||
loop = loop or asyncio.get_event_loop()
|
||||
data = await loop.run_in_executor(None, lambda: ytdl.extract_info(url, download=not stream))
|
||||
|
||||
if 'entries' in data:
|
||||
data = data['entries'][0]
|
||||
|
||||
filename = data['url'] if stream else ytdl.prepare_filename(data)
|
||||
return cls(discord.FFmpegPCMAudio(filename, **ffmpeg_options), data=data)
|
||||
|
||||
@classmethod
|
||||
async def from_file(cls, filepath, *, loop=None, title=None):
|
||||
loop = loop or asyncio.get_event_loop()
|
||||
duration = await get_file_duration(filepath)
|
||||
filename_only = os.path.basename(filepath)
|
||||
display_title = title or os.path.splitext(filename_only)[0]
|
||||
|
||||
data = {
|
||||
'title': display_title,
|
||||
'url': filepath,
|
||||
'webpage_url': None,
|
||||
'duration': duration,
|
||||
'is_local': True,
|
||||
'filepath': filepath
|
||||
}
|
||||
|
||||
local_ffmpeg_options = {
|
||||
'options': '-vn'
|
||||
}
|
||||
return cls(discord.FFmpegPCMAudio(filepath, **local_ffmpeg_options), data=data)
|
||||
@@ -0,0 +1,5 @@
|
||||
"""ŻyrarBOT - bot muzyczny Discord z panelem webowym."""
|
||||
|
||||
__all__ = ["__version__"]
|
||||
|
||||
__version__ = "4.0.0"
|
||||
@@ -0,0 +1,18 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
|
||||
from zyrarbot.application import Application
|
||||
|
||||
|
||||
def main() -> None:
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s %(levelname)-8s %(name)s: %(message)s",
|
||||
)
|
||||
asyncio.run(Application().run())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,117 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
import os
|
||||
from collections.abc import AsyncIterator
|
||||
from contextlib import asynccontextmanager
|
||||
|
||||
import uvicorn
|
||||
from fastapi import FastAPI
|
||||
from fastapi.staticfiles import StaticFiles
|
||||
|
||||
from zyrarbot.audio.media_probe import MediaProbe
|
||||
from zyrarbot.audio.track_factory import TrackFactory
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
from zyrarbot.music.notification_channel_resolver import NotificationChannelResolver
|
||||
from zyrarbot.music.track_embed_factory import TrackEmbedFactory
|
||||
from zyrarbot.settings import Settings
|
||||
from zyrarbot.storage.guild_config_repository import GuildConfigRepository
|
||||
from zyrarbot.storage.history_repository import HistoryRepository
|
||||
from zyrarbot.storage.json_file_store import JsonFileStore
|
||||
from zyrarbot.storage.uploads_repository import UploadsRepository
|
||||
from zyrarbot.ui.api.factory import mount_api
|
||||
from zyrarbot.ui.bot.client import MusicBot
|
||||
from zyrarbot.ui.bot.guild_resolver import GuildResolver
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class Application:
|
||||
"""Korzeń kompozycji: składa wszystkie zależności i prowadzi bota razem z API."""
|
||||
|
||||
def __init__(self, settings: Settings | None = None):
|
||||
self.settings = settings or Settings.from_env()
|
||||
|
||||
self.config = GuildConfigRepository(
|
||||
JsonFileStore(self.settings.config_file),
|
||||
fallback_plays=self.settings.default_plays,
|
||||
)
|
||||
self.history = HistoryRepository(
|
||||
JsonFileStore(self.settings.history_file), limit=self.settings.history_limit
|
||||
)
|
||||
self.uploads = UploadsRepository(self.settings.uploads_dir)
|
||||
self.tracks = TrackFactory(self.uploads, MediaProbe())
|
||||
|
||||
self.bot = MusicBot(self.settings, self.tracks, self.uploads)
|
||||
self.guilds = GuildResolver(self.bot)
|
||||
self.player = MusicPlayer(
|
||||
bot=self.bot,
|
||||
track_factory=self.tracks,
|
||||
history=self.history,
|
||||
config=self.config,
|
||||
channels=NotificationChannelResolver(self.bot, self.config),
|
||||
embeds=TrackEmbedFactory(),
|
||||
)
|
||||
self.bot.player = self.player
|
||||
|
||||
self.web = FastAPI(title="ŻyrarBOT")
|
||||
broadcaster = mount_api(
|
||||
self.web,
|
||||
settings=self.settings,
|
||||
player=self.player,
|
||||
guilds=self.guilds,
|
||||
tracks=self.tracks,
|
||||
uploads=self.uploads,
|
||||
config=self.config,
|
||||
)
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
|
||||
self.player.on_state_change = broadcaster.broadcast
|
||||
broadcaster.start()
|
||||
logger.info("Panel webowy gotowy, rozgłaszanie stanu uruchomione")
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
self.player.on_state_change = None
|
||||
await broadcaster.stop()
|
||||
|
||||
self.web.router.lifespan_context = lifespan
|
||||
|
||||
os.makedirs(self.settings.static_dir, exist_ok=True)
|
||||
self.web.mount(
|
||||
"/", StaticFiles(directory=self.settings.static_dir, html=True), name="static"
|
||||
)
|
||||
|
||||
async def run(self) -> None:
|
||||
"""Startuje serwer web, a następnie bota; panel działa też bez Discorda."""
|
||||
config = uvicorn.Config(
|
||||
self.web,
|
||||
host=self.settings.web_host,
|
||||
port=self.settings.web_port,
|
||||
log_level="info",
|
||||
)
|
||||
server = uvicorn.Server(config)
|
||||
|
||||
async with self.bot:
|
||||
server_task = asyncio.create_task(server.serve())
|
||||
try:
|
||||
if not self.settings.discord_token:
|
||||
raise RuntimeError("Brak DISCORD_TOKEN w środowisku")
|
||||
await self.bot.start(self.settings.discord_token)
|
||||
except Exception as error: # noqa: BLE001 - panel ma przetrwać awarię bota
|
||||
logger.error("Nie udało się wystartować bota Discord: %s", error)
|
||||
logger.info("Serwer webowy działa dalej...")
|
||||
await self._wait_for_shutdown(server)
|
||||
finally:
|
||||
server.should_exit = True
|
||||
await server_task
|
||||
|
||||
@staticmethod
|
||||
async def _wait_for_shutdown(server: uvicorn.Server) -> None:
|
||||
while not server.should_exit:
|
||||
try:
|
||||
await asyncio.sleep(1)
|
||||
except asyncio.CancelledError:
|
||||
break
|
||||
@@ -0,0 +1 @@
|
||||
"""Warstwa audio: pozyskiwanie źródeł dźwięku (yt-dlp, pliki lokalne)."""
|
||||
@@ -0,0 +1,31 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class MediaProbe:
|
||||
"""Odczyt metadanych pliku multimedialnego przy pomocy ffprobe."""
|
||||
|
||||
async def duration(self, filepath: str) -> float:
|
||||
try:
|
||||
process = await asyncio.create_subprocess_exec(
|
||||
"ffprobe",
|
||||
"-v",
|
||||
"error",
|
||||
"-show_entries",
|
||||
"format=duration",
|
||||
"-of",
|
||||
"default=noprint_wrappers=1:nokey=1",
|
||||
filepath,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE,
|
||||
)
|
||||
stdout, _ = await process.communicate()
|
||||
if process.returncode == 0:
|
||||
return float(stdout.decode().strip())
|
||||
except (OSError, ValueError) as error:
|
||||
logger.error("ffprobe nie odczytał długości pliku %s: %s", filepath, error)
|
||||
return 0.0
|
||||
@@ -0,0 +1,76 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
from typing import Any
|
||||
|
||||
import discord
|
||||
import yt_dlp
|
||||
|
||||
from zyrarbot.audio.media_probe import MediaProbe
|
||||
from zyrarbot.audio.ytdl_options import YtdlOptions
|
||||
from zyrarbot.audio.ytdl_source import YTDLSource
|
||||
from zyrarbot.storage.uploads_repository import UploadsRepository
|
||||
|
||||
|
||||
class TrackFactory:
|
||||
"""Buduje odtwarzalne źródła audio z zapytań, adresów URL i plików lokalnych."""
|
||||
|
||||
def __init__(self, uploads: UploadsRepository, probe: MediaProbe | None = None):
|
||||
self._uploads = uploads
|
||||
self._probe = probe or MediaProbe()
|
||||
self._ytdl = yt_dlp.YoutubeDL(YtdlOptions.EXTRACTOR)
|
||||
|
||||
async def resolve(
|
||||
self, query: str, *, loop: asyncio.AbstractEventLoop | None = None
|
||||
) -> YTDLSource:
|
||||
"""Rozpoznaje, czy zapytanie wskazuje wgrany plik, czy zasób sieciowy."""
|
||||
if not query.startswith("http") and self._uploads.exists(query):
|
||||
return await self.from_file(self._uploads.resolve(query))
|
||||
return await self.from_url(query, loop=loop)
|
||||
|
||||
async def from_url(
|
||||
self,
|
||||
url: str,
|
||||
*,
|
||||
loop: asyncio.AbstractEventLoop | None = None,
|
||||
stream: bool = True,
|
||||
) -> YTDLSource:
|
||||
loop = loop or asyncio.get_running_loop()
|
||||
data = await loop.run_in_executor(
|
||||
None, lambda: self._ytdl.extract_info(url, download=not stream)
|
||||
)
|
||||
if "entries" in data:
|
||||
data = data["entries"][0]
|
||||
|
||||
filename = data["url"] if stream else self._ytdl.prepare_filename(data)
|
||||
source = discord.FFmpegPCMAudio(filename, **YtdlOptions.STREAM_FFMPEG)
|
||||
return YTDLSource(source, data=data)
|
||||
|
||||
async def from_file(self, filepath: str, *, title: str | None = None) -> YTDLSource:
|
||||
duration = await self._probe.duration(filepath)
|
||||
data: dict[str, Any] = {
|
||||
"title": title or os.path.splitext(os.path.basename(filepath))[0],
|
||||
"url": filepath,
|
||||
"webpage_url": None,
|
||||
"duration": duration,
|
||||
"is_local": True,
|
||||
"filepath": filepath,
|
||||
}
|
||||
source = discord.FFmpegPCMAudio(filepath, **YtdlOptions.LOCAL_FFMPEG)
|
||||
return YTDLSource(source, data=data)
|
||||
|
||||
async def recreate(
|
||||
self,
|
||||
track: YTDLSource,
|
||||
*,
|
||||
loop: asyncio.AbstractEventLoop | None = None,
|
||||
) -> YTDLSource:
|
||||
"""Tworzy świeże źródło dla już odtworzonego utworu, zachowując jego tożsamość."""
|
||||
if track.is_local:
|
||||
player = await self.from_file(track.filepath or "", title=track.title)
|
||||
else:
|
||||
player = await self.from_url(track.display_url or "", loop=loop)
|
||||
player.id = track.id
|
||||
player.plays_left = track.plays_left
|
||||
return player
|
||||
@@ -0,0 +1,30 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any, Final
|
||||
|
||||
|
||||
class YtdlOptions:
|
||||
"""Zbiór opcji dla yt-dlp oraz FFmpeg używanych przy tworzeniu źródeł audio."""
|
||||
|
||||
EXTRACTOR: Final[dict[str, Any]] = {
|
||||
"format": "bestaudio/best",
|
||||
"outtmpl": "%(extractor)s-%(id)s-%(title)s.%(ext)s",
|
||||
"restrictfilenames": True,
|
||||
"noplaylist": True,
|
||||
"nocheckcertificate": True,
|
||||
"ignoreerrors": False,
|
||||
"logtostderr": False,
|
||||
"quiet": True,
|
||||
"no_warnings": True,
|
||||
"default_search": "auto",
|
||||
"source_address": "0.0.0.0",
|
||||
}
|
||||
|
||||
STREAM_FFMPEG: Final[dict[str, str]] = {
|
||||
"options": "-vn",
|
||||
"before_options": "-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5",
|
||||
}
|
||||
|
||||
LOCAL_FFMPEG: Final[dict[str, str]] = {
|
||||
"options": "-vn",
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import uuid
|
||||
from typing import Any
|
||||
|
||||
import discord
|
||||
|
||||
FRAME_LENGTH_SECONDS = 0.02
|
||||
|
||||
|
||||
class YTDLSource(discord.PCMVolumeTransformer):
|
||||
"""Źródło audio (strumień YouTube lub plik lokalny) z metadanymi utworu."""
|
||||
|
||||
def __init__(self, source: discord.AudioSource, *, data: dict[str, Any], volume: float = 0.5):
|
||||
super().__init__(source, volume)
|
||||
self.data = data
|
||||
self.title: str | None = data.get("title")
|
||||
self.url: str | None = data.get("url")
|
||||
self.id: str = uuid.uuid4().hex
|
||||
self.duration: float | None = data.get("duration")
|
||||
self.elapsed: float = 0.0
|
||||
self.plays_left: int | None = data.get("plays_left")
|
||||
self.played: bool = False
|
||||
|
||||
@property
|
||||
def is_local(self) -> bool:
|
||||
return bool(self.data.get("is_local", False))
|
||||
|
||||
@property
|
||||
def filepath(self) -> str | None:
|
||||
return self.data.get("filepath")
|
||||
|
||||
@property
|
||||
def display_url(self) -> str | None:
|
||||
return self.data.get("webpage_url") or self.url
|
||||
|
||||
@property
|
||||
def has_web_link(self) -> bool:
|
||||
url = self.display_url
|
||||
return bool(url and str(url).startswith("http"))
|
||||
|
||||
def read(self) -> bytes:
|
||||
data = super().read()
|
||||
if data:
|
||||
self.elapsed += FRAME_LENGTH_SECONDS
|
||||
return data
|
||||
@@ -0,0 +1 @@
|
||||
"""Domena odtwarzania: stan kolejki, tryby zapętlania i silnik odtwarzacza."""
|
||||
@@ -0,0 +1,43 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
import discord
|
||||
|
||||
from zyrarbot.audio.ytdl_source import YTDLSource
|
||||
from zyrarbot.music.loop_mode import LoopMode
|
||||
|
||||
|
||||
@dataclass
|
||||
class GuildMusicState:
|
||||
"""Stan odtwarzania jednego serwera Discord.
|
||||
|
||||
Kolejka jest nieusuwalna przy odtwarzaniu - pozycję śledzi ``index``,
|
||||
dzięki czemu można swobodnie przeskakiwać i przewijać w tył.
|
||||
"""
|
||||
|
||||
guild_id: int
|
||||
queue: list[YTDLSource] = field(default_factory=list)
|
||||
current: YTDLSource | None = None
|
||||
index: int = -1
|
||||
volume: float = 1.0
|
||||
loop_mode: LoopMode = LoopMode.OFF
|
||||
jump_pending: bool = False
|
||||
notification_channel: discord.abc.Messageable | None = None
|
||||
|
||||
def reset(self) -> None:
|
||||
self.queue.clear()
|
||||
self.current = None
|
||||
self.index = -1
|
||||
|
||||
def find(self, track_id: str) -> YTDLSource | None:
|
||||
return next((track for track in self.queue if track.id == track_id), None)
|
||||
|
||||
def position_of(self, track_id: str) -> int:
|
||||
return next((idx for idx, track in enumerate(self.queue) if track.id == track_id), -1)
|
||||
|
||||
def consume_jump(self) -> bool:
|
||||
"""Zwraca i czyści flagę przeskoku ustawioną przez panel webowy."""
|
||||
pending = self.jump_pending
|
||||
self.jump_pending = False
|
||||
return pending
|
||||
@@ -0,0 +1,46 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from typing import Any
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class HistoryEntry:
|
||||
"""Pojedynczy wpis historii odtwarzania zapisywany w history.json."""
|
||||
|
||||
id: str
|
||||
title: str
|
||||
url: str | None = None
|
||||
duration: float | None = None
|
||||
is_local: bool = False
|
||||
filepath: str | None = None
|
||||
|
||||
def is_same_track_as(self, other: HistoryEntry) -> bool:
|
||||
"""Wpisy uznajemy za ten sam utwór przy zgodnym tytule albo adresie."""
|
||||
return self.title == other.title or bool(other.url and self.url == other.url)
|
||||
|
||||
@property
|
||||
def replay_source(self) -> str | None:
|
||||
"""Ścieżka lub adres, z którego wpis można odtworzyć ponownie."""
|
||||
return (self.filepath or self.url) if self.is_local else self.url
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"id": self.id,
|
||||
"title": self.title,
|
||||
"url": self.url,
|
||||
"duration": self.duration,
|
||||
"is_local": self.is_local,
|
||||
"filepath": self.filepath,
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, data: dict[str, Any]) -> HistoryEntry:
|
||||
return cls(
|
||||
id=str(data.get("id", "")),
|
||||
title=data.get("title", ""),
|
||||
url=data.get("url"),
|
||||
duration=data.get("duration"),
|
||||
is_local=bool(data.get("is_local", False)),
|
||||
filepath=data.get("filepath"),
|
||||
)
|
||||
@@ -0,0 +1,31 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from enum import Enum
|
||||
|
||||
|
||||
class LoopMode(Enum):
|
||||
"""Tryb zapętlania w cyklu: wyłączone -> cała kolejka -> jeden utwór."""
|
||||
|
||||
OFF = "off"
|
||||
QUEUE = "playlist"
|
||||
TRACK = "single"
|
||||
|
||||
@property
|
||||
def loops_track(self) -> bool:
|
||||
return self is LoopMode.TRACK
|
||||
|
||||
@property
|
||||
def loops_queue(self) -> bool:
|
||||
return self is LoopMode.QUEUE
|
||||
|
||||
def next(self) -> LoopMode:
|
||||
order = (LoopMode.OFF, LoopMode.QUEUE, LoopMode.TRACK)
|
||||
return order[(order.index(self) + 1) % len(order)]
|
||||
|
||||
@property
|
||||
def label(self) -> str:
|
||||
return {
|
||||
LoopMode.OFF: "➡️ Tryb zapętlania: **Wyłączone**",
|
||||
LoopMode.QUEUE: "🔁 Tryb zapętlania: **Cała kolejka (playlista)**",
|
||||
LoopMode.TRACK: "🔂 Tryb zapętlania: **Jeden utwór**",
|
||||
}[self]
|
||||
@@ -0,0 +1,324 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
from collections.abc import Awaitable, Callable
|
||||
from typing import Any
|
||||
|
||||
import discord
|
||||
from discord.ext import commands
|
||||
|
||||
from zyrarbot.audio.track_factory import TrackFactory
|
||||
from zyrarbot.audio.ytdl_source import YTDLSource
|
||||
from zyrarbot.music.guild_music_state import GuildMusicState
|
||||
from zyrarbot.music.history_entry import HistoryEntry
|
||||
from zyrarbot.music.loop_mode import LoopMode
|
||||
from zyrarbot.music.notification_channel_resolver import NotificationChannelResolver
|
||||
from zyrarbot.music.track_embed_factory import TrackEmbedFactory
|
||||
from zyrarbot.storage.guild_config_repository import GuildConfigRepository
|
||||
from zyrarbot.storage.history_repository import HistoryRepository
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
StateChangeHook = Callable[[], Awaitable[None] | None]
|
||||
|
||||
|
||||
class MusicPlayer:
|
||||
"""Silnik odtwarzania: kolejki, przechodzenie między utworami i powiadomienia.
|
||||
|
||||
Jest wspólny dla komend Discorda i panelu webowego - obie warstwy operują
|
||||
wyłącznie na tym obiekcie, nigdy bezpośrednio na stanie serwerów.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
bot: commands.Bot,
|
||||
track_factory: TrackFactory,
|
||||
history: HistoryRepository,
|
||||
config: GuildConfigRepository,
|
||||
channels: NotificationChannelResolver,
|
||||
embeds: TrackEmbedFactory | None = None,
|
||||
):
|
||||
self._bot = bot
|
||||
self._tracks = track_factory
|
||||
self._history = history
|
||||
self._config = config
|
||||
self._channels = channels
|
||||
self._embeds = embeds or TrackEmbedFactory()
|
||||
self._states: dict[int, GuildMusicState] = {}
|
||||
self.on_state_change: StateChangeHook | None = None
|
||||
|
||||
# --- Stan ---------------------------------------------------------------
|
||||
|
||||
def state(self, guild_id: int) -> GuildMusicState:
|
||||
if guild_id not in self._states:
|
||||
self._states[guild_id] = GuildMusicState(guild_id=guild_id, volume=1.0)
|
||||
return self._states[guild_id]
|
||||
|
||||
@property
|
||||
def default_plays(self) -> int:
|
||||
return self._config.get_default_plays()
|
||||
|
||||
def set_default_plays(self, value: int) -> None:
|
||||
self._config.set_default_plays(value)
|
||||
|
||||
def plays_left(self, track: YTDLSource) -> int:
|
||||
return track.plays_left if track.plays_left is not None else self.default_plays
|
||||
|
||||
def history(self, guild_id: int) -> list[HistoryEntry]:
|
||||
return self._history.list(guild_id)
|
||||
|
||||
def find_history_entry(self, guild_id: int, entry_id: str) -> HistoryEntry | None:
|
||||
return self._history.find(guild_id, entry_id)
|
||||
|
||||
def voice_client(self, guild_id: int) -> discord.VoiceClient | None:
|
||||
return discord.utils.get(self._bot.voice_clients, guild__id=guild_id)
|
||||
|
||||
def is_active(self, guild_id: int) -> bool:
|
||||
voice_client = self.voice_client(guild_id)
|
||||
return bool(voice_client and (voice_client.is_playing() or voice_client.is_paused()))
|
||||
|
||||
def clear(self, guild_id: int) -> None:
|
||||
self.state(guild_id).reset()
|
||||
|
||||
def set_volume(self, guild_id: int, volume: float) -> None:
|
||||
self.state(guild_id).volume = volume
|
||||
voice_client = self.voice_client(guild_id)
|
||||
if voice_client and voice_client.source:
|
||||
voice_client.source.volume = volume
|
||||
|
||||
def set_loop_mode(self, guild_id: int, mode: LoopMode) -> None:
|
||||
self.state(guild_id).loop_mode = mode
|
||||
|
||||
def cycle_loop_mode(self, guild_id: int) -> LoopMode:
|
||||
state = self.state(guild_id)
|
||||
state.loop_mode = state.loop_mode.next()
|
||||
return state.loop_mode
|
||||
|
||||
def notification_channel(self, guild_id: int) -> discord.abc.Messageable | None:
|
||||
state = self.state(guild_id)
|
||||
channel = self._channels.resolve(guild_id, state.notification_channel)
|
||||
state.notification_channel = channel
|
||||
return channel
|
||||
|
||||
def set_notification_channel(
|
||||
self, guild_id: int, channel: discord.abc.Messageable | None
|
||||
) -> None:
|
||||
self.state(guild_id).notification_channel = channel
|
||||
|
||||
# --- Kolejka ------------------------------------------------------------
|
||||
|
||||
async def enqueue(
|
||||
self,
|
||||
guild_id: int,
|
||||
track: YTDLSource,
|
||||
*,
|
||||
channel: discord.abc.Messageable | None = None,
|
||||
from_web: bool = False,
|
||||
) -> dict[str, Any]:
|
||||
state = self.state(guild_id)
|
||||
if channel:
|
||||
state.notification_channel = channel
|
||||
if track.plays_left is None:
|
||||
track.plays_left = self.default_plays
|
||||
|
||||
state.queue.append(track)
|
||||
|
||||
if not self.is_active(guild_id):
|
||||
await self.play_next(guild_id, advance=False)
|
||||
return {"status": "playing", "title": track.title}
|
||||
|
||||
embed = self._embeds.queued(track, position=len(state.queue), from_web=from_web)
|
||||
await self.notify(guild_id, embed=embed)
|
||||
await self.trigger_state_change()
|
||||
return {"status": "queued", "title": track.title}
|
||||
|
||||
async def remove(self, guild_id: int, track_id: str) -> bool:
|
||||
"""Usuwa utwór z kolejki; usunięcie odtwarzanego przechodzi do następnego."""
|
||||
state = self.state(guild_id)
|
||||
position = state.position_of(track_id)
|
||||
if position == -1:
|
||||
return False
|
||||
|
||||
state.queue.pop(position)
|
||||
if position < state.index:
|
||||
state.index -= 1
|
||||
elif position == state.index:
|
||||
# Indeks zostaje - wskazuje teraz utwór, który wskoczył na zwolnione miejsce.
|
||||
state.jump_pending = True
|
||||
await self._restart_playback(guild_id)
|
||||
return True
|
||||
|
||||
def reorder(self, guild_id: int, track_ids: list[str]) -> None:
|
||||
state = self.state(guild_id)
|
||||
playing = state.queue[state.index] if 0 <= state.index < len(state.queue) else None
|
||||
|
||||
by_id = {track.id: track for track in state.queue}
|
||||
reordered = [by_id[track_id] for track_id in track_ids if track_id in by_id]
|
||||
reordered += [track for track in state.queue if track.id not in track_ids]
|
||||
|
||||
state.queue = reordered
|
||||
if playing is not None and playing in reordered:
|
||||
state.index = reordered.index(playing)
|
||||
|
||||
async def jump(self, guild_id: int, index: int) -> None:
|
||||
state = self.state(guild_id)
|
||||
if state.loop_mode.loops_track:
|
||||
state.loop_mode = LoopMode.OFF
|
||||
state.index = index
|
||||
state.jump_pending = True
|
||||
await self._restart_playback(guild_id)
|
||||
|
||||
async def _restart_playback(self, guild_id: int) -> None:
|
||||
voice_client = self.voice_client(guild_id)
|
||||
if voice_client and (voice_client.is_playing() or voice_client.is_paused()):
|
||||
voice_client.stop() # `after` wywoła play_next, flaga przeskoku zablokuje advance
|
||||
else:
|
||||
await self.play_next(guild_id, advance=False)
|
||||
|
||||
# --- Odtwarzanie --------------------------------------------------------
|
||||
|
||||
async def play_next(self, guild_id: int, advance: bool = True, _failures: int = 0) -> None:
|
||||
"""Przechodzi do kolejnego utworu; ``_failures`` chroni przed pętlą pomijania."""
|
||||
state = self.state(guild_id)
|
||||
voice_client = self.voice_client(guild_id)
|
||||
if not voice_client:
|
||||
state.current = None
|
||||
return
|
||||
|
||||
if state.consume_jump():
|
||||
advance = False
|
||||
|
||||
# Utwór z ostatnim odtworzeniem musi pozostać w kolejce do chwili
|
||||
# zakończenia źródła. W przeciwnym razie panel dostaje `current`, ale
|
||||
# `queue_index` wskazuje pozycję spoza kolejki podczas faktycznego
|
||||
# odtwarzania ostatniej kopii.
|
||||
retired_index: int | None = None
|
||||
if advance and state.current is not None and 0 <= state.index < len(state.queue):
|
||||
current = state.queue[state.index]
|
||||
if current is state.current and self.plays_left(current) <= 0:
|
||||
retired_index = state.index
|
||||
state.queue.pop(state.index)
|
||||
state.index -= 1
|
||||
|
||||
if not state.queue:
|
||||
state.index = -1
|
||||
state.current = None
|
||||
await self.trigger_state_change()
|
||||
return
|
||||
|
||||
if retired_index is not None:
|
||||
next_index = retired_index
|
||||
if state.loop_mode.loops_queue:
|
||||
next_index %= len(state.queue)
|
||||
else:
|
||||
next_index = self._next_index(state, advance=advance)
|
||||
if next_index >= len(state.queue):
|
||||
state.index = next_index
|
||||
state.current = None
|
||||
await self.trigger_state_change()
|
||||
await self.notify(guild_id, "Kolejka zakończona.")
|
||||
return
|
||||
|
||||
state.index = next_index
|
||||
track = state.queue[next_index]
|
||||
|
||||
if track.played:
|
||||
try:
|
||||
track = await self._tracks.recreate(track, loop=self._bot.loop)
|
||||
except Exception as error: # noqa: BLE001 - dowolny błąd sieci/ffmpeg pomija utwór
|
||||
logger.error("Nie udało się odświeżyć utworu %s: %s", track.title, error)
|
||||
await self.notify(
|
||||
guild_id, f"⚠️ Nie udało się odtworzyć: {track.title} ({error}). Pomijam."
|
||||
)
|
||||
await self._skip_failed(guild_id, _failures + 1)
|
||||
return
|
||||
|
||||
track.played = True
|
||||
track.plays_left = self.plays_left(track) - 1
|
||||
track.volume = state.volume
|
||||
|
||||
state.queue[next_index] = track
|
||||
if track.plays_left <= 0 and state.loop_mode.loops_track:
|
||||
# Usunięcie nastąpi dopiero po callbacku discord.py, po tym jak
|
||||
# ostatnie odtworzenie rzeczywiście się zakończy.
|
||||
state.loop_mode = LoopMode.OFF
|
||||
|
||||
state.current = track
|
||||
self._record_history(guild_id, track)
|
||||
await self.trigger_state_change()
|
||||
|
||||
voice_client.play(track, after=lambda error: self._schedule_next(guild_id, error))
|
||||
|
||||
total = len(state.queue)
|
||||
embed = self._embeds.now_playing(track, position=next_index + 1, total=total)
|
||||
await self.notify(guild_id, embed=embed)
|
||||
|
||||
async def _skip_failed(self, guild_id: int, failures: int) -> None:
|
||||
"""Pomija niedziałający utwór, ale zatrzymuje się, gdy zawiodła cała kolejka."""
|
||||
state = self.state(guild_id)
|
||||
if failures >= max(len(state.queue), 1):
|
||||
state.current = None
|
||||
await self.trigger_state_change()
|
||||
await self.notify(
|
||||
guild_id, "⛔ Nie udało się odtworzyć żadnego utworu z kolejki. Zatrzymuję."
|
||||
)
|
||||
return
|
||||
await self.play_next(guild_id, advance=True, _failures=failures)
|
||||
|
||||
def _next_index(self, state: GuildMusicState, *, advance: bool) -> int:
|
||||
index = state.index if state.index != -1 else 0
|
||||
|
||||
if not advance:
|
||||
if 0 <= index < len(state.queue) and state.current is not None:
|
||||
return index
|
||||
return len(state.queue) - 1
|
||||
|
||||
if state.loop_mode.loops_track:
|
||||
return index
|
||||
if state.loop_mode.loops_queue:
|
||||
return (index + 1) % len(state.queue)
|
||||
return index + 1
|
||||
|
||||
def _schedule_next(self, guild_id: int, error: Exception | None) -> None:
|
||||
if error:
|
||||
logger.error("Odtwarzanie zakończone błędem na serwerze %s: %s", guild_id, error)
|
||||
asyncio.run_coroutine_threadsafe(self.play_next(guild_id, advance=True), self._bot.loop)
|
||||
|
||||
def _record_history(self, guild_id: int, track: YTDLSource) -> None:
|
||||
if not track.title:
|
||||
return
|
||||
self._history.add(
|
||||
guild_id,
|
||||
HistoryEntry(
|
||||
id=track.id,
|
||||
title=track.title,
|
||||
url=track.display_url,
|
||||
duration=track.duration,
|
||||
is_local=track.is_local,
|
||||
filepath=track.filepath,
|
||||
),
|
||||
)
|
||||
|
||||
# --- Powiadomienia ------------------------------------------------------
|
||||
|
||||
async def notify(
|
||||
self, guild_id: int, text: str | None = None, embed: discord.Embed | None = None
|
||||
) -> None:
|
||||
channel = self.notification_channel(guild_id)
|
||||
if not channel:
|
||||
return
|
||||
try:
|
||||
await channel.send(content=text, embed=embed)
|
||||
except discord.DiscordException as error:
|
||||
logger.error("Nie udało się wysłać powiadomienia: %s", error)
|
||||
|
||||
async def trigger_state_change(self) -> None:
|
||||
if not self.on_state_change:
|
||||
return
|
||||
try:
|
||||
result = self.on_state_change()
|
||||
if asyncio.iscoroutine(result):
|
||||
await result
|
||||
except Exception as error: # noqa: BLE001 - hook nie może przerwać odtwarzania
|
||||
logger.error("Błąd hooka on_state_change: %s", error)
|
||||
@@ -0,0 +1,48 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import discord
|
||||
from discord.ext import commands
|
||||
|
||||
from zyrarbot.storage.guild_config_repository import GuildConfigRepository
|
||||
|
||||
|
||||
class NotificationChannelResolver:
|
||||
"""Wskazuje kanał tekstowy, na który trafiają powiadomienia o odtwarzaniu.
|
||||
|
||||
Kolejność: kanał zapamiętany w stanie -> kanał z konfiguracji -> pierwszy
|
||||
kanał serwera, na którym bot może pisać.
|
||||
"""
|
||||
|
||||
def __init__(self, bot: commands.Bot, config: GuildConfigRepository):
|
||||
self._bot = bot
|
||||
self._config = config
|
||||
|
||||
def resolve(
|
||||
self, guild_id: int, remembered: discord.abc.Messageable | None
|
||||
) -> discord.abc.Messageable | None:
|
||||
if remembered:
|
||||
return remembered
|
||||
|
||||
saved_id = self._config.get_notification_channel_id(guild_id)
|
||||
if saved_id:
|
||||
channel = self._bot.get_channel(saved_id)
|
||||
if channel:
|
||||
return channel
|
||||
|
||||
return self.first_writable(self._bot.get_guild(guild_id))
|
||||
|
||||
@staticmethod
|
||||
def first_writable(guild: discord.Guild | None) -> discord.TextChannel | None:
|
||||
for channel in NotificationChannelResolver.writable_channels(guild):
|
||||
return channel
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def writable_channels(guild: discord.Guild | None) -> list[discord.TextChannel]:
|
||||
if not guild or not guild.me:
|
||||
return []
|
||||
return [
|
||||
channel
|
||||
for channel in guild.text_channels
|
||||
if channel.permissions_for(guild.me).send_messages
|
||||
]
|
||||
@@ -0,0 +1,45 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import discord
|
||||
|
||||
from zyrarbot.audio.ytdl_source import YTDLSource
|
||||
|
||||
AUTHOR_ICON = "https://cdn-icons-png.flaticon.com/512/3844/3844724.png"
|
||||
|
||||
|
||||
class TrackEmbedFactory:
|
||||
"""Buduje osadzenia Discorda opisujące utwór dodany do kolejki lub odtwarzany."""
|
||||
|
||||
def queued(self, track: YTDLSource, *, position: int, from_web: bool) -> discord.Embed:
|
||||
embed = self._base(track, discord.Color.blue())
|
||||
source = "Dodano do kolejki z panelu Web" if from_web else "Dodano do kolejki"
|
||||
embed.set_author(name=source, icon_url=AUTHOR_ICON)
|
||||
embed.set_footer(text=f"Pozycja w kolejce: {position}")
|
||||
return embed
|
||||
|
||||
def now_playing(self, track: YTDLSource, *, position: int, total: int) -> discord.Embed:
|
||||
embed = self._base(track, discord.Color.green(), prefix="▶️")
|
||||
embed.set_footer(text=f"Pozycja w kolejce: {position} / {total}")
|
||||
return embed
|
||||
|
||||
def _base(
|
||||
self, track: YTDLSource, color: discord.Color, *, prefix: str = "🎵"
|
||||
) -> discord.Embed:
|
||||
title = discord.utils.escape_markdown(track.title or "Nieznany tytuł")
|
||||
url = track.display_url
|
||||
icon = "📁" if track.is_local else prefix
|
||||
description = (
|
||||
f"[Kliknij tutaj, aby otworzyć link]({url})"
|
||||
if track.has_web_link
|
||||
else "Plik lokalny / brak linku"
|
||||
)
|
||||
embed = discord.Embed(
|
||||
title=f"{icon} {title}",
|
||||
url=url if track.has_web_link else None,
|
||||
description=description,
|
||||
color=color,
|
||||
)
|
||||
if track.duration:
|
||||
minutes, seconds = divmod(int(track.duration), 60)
|
||||
embed.add_field(name="Czas trwania", value=f"{minutes}:{seconds:02d}", inline=True)
|
||||
return embed
|
||||
@@ -0,0 +1,43 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
from dataclasses import dataclass
|
||||
|
||||
from dotenv import load_dotenv
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Settings:
|
||||
"""Konfiguracja aplikacji odczytana ze zmiennych środowiskowych."""
|
||||
|
||||
discord_token: str | None = None
|
||||
guild_id: int | None = None
|
||||
config_dir: str = "config"
|
||||
uploads_dir: str = "uploads"
|
||||
static_dir: str = "static"
|
||||
web_host: str = "0.0.0.0"
|
||||
web_port: int = 8000
|
||||
default_plays: int = 5
|
||||
history_limit: int = 50
|
||||
min_plays: int = 1
|
||||
max_plays: int = 999
|
||||
|
||||
@classmethod
|
||||
def from_env(cls) -> Settings:
|
||||
load_dotenv()
|
||||
raw_guild_id = os.getenv("GUILD_ID")
|
||||
return cls(
|
||||
discord_token=os.getenv("DISCORD_TOKEN"),
|
||||
guild_id=int(raw_guild_id) if raw_guild_id else None,
|
||||
)
|
||||
|
||||
@property
|
||||
def config_file(self) -> str:
|
||||
return os.path.join(self.config_dir, "config.json")
|
||||
|
||||
@property
|
||||
def history_file(self) -> str:
|
||||
return os.path.join(self.config_dir, "history.json")
|
||||
|
||||
def is_valid_plays(self, value: int) -> bool:
|
||||
return self.min_plays <= value <= self.max_plays
|
||||
@@ -0,0 +1 @@
|
||||
"""Trwałe składowanie danych: pliki JSON oraz katalog uploadów."""
|
||||
@@ -0,0 +1,43 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
|
||||
from zyrarbot.storage.json_file_store import JsonFileStore
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class GuildConfigRepository:
|
||||
"""Dostęp do config.json: kanały powiadomień per serwer + globalne ustawienia."""
|
||||
|
||||
DEFAULT_PLAYS_KEY = "default_plays"
|
||||
|
||||
def __init__(self, store: JsonFileStore, fallback_plays: int = 5):
|
||||
self._store = store
|
||||
self._fallback_plays = fallback_plays
|
||||
|
||||
def get_notification_channel_id(self, guild_id: int) -> int | None:
|
||||
value = self._store.get(str(guild_id))
|
||||
if value is None:
|
||||
return None
|
||||
try:
|
||||
return int(value)
|
||||
except (TypeError, ValueError):
|
||||
logger.error("Nieprawidłowe ID kanału w konfiguracji serwera %s: %r", guild_id, value)
|
||||
return None
|
||||
|
||||
def set_notification_channel_id(self, guild_id: int, channel_id: int | None) -> None:
|
||||
self._store.set(str(guild_id), channel_id)
|
||||
|
||||
def get_default_plays(self) -> int:
|
||||
value = self._store.get(self.DEFAULT_PLAYS_KEY)
|
||||
if value is None:
|
||||
return self._fallback_plays
|
||||
try:
|
||||
return int(value)
|
||||
except (TypeError, ValueError):
|
||||
logger.error("Nieprawidłowa wartość %s: %r", self.DEFAULT_PLAYS_KEY, value)
|
||||
return self._fallback_plays
|
||||
|
||||
def set_default_plays(self, value: int) -> None:
|
||||
self._store.set(self.DEFAULT_PLAYS_KEY, int(value))
|
||||
@@ -0,0 +1,45 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from zyrarbot.music.history_entry import HistoryEntry
|
||||
from zyrarbot.storage.json_file_store import JsonFileStore
|
||||
|
||||
|
||||
class HistoryRepository:
|
||||
"""Historia odtwarzania per serwer, buforowana w pamięci i utrwalana w history.json."""
|
||||
|
||||
def __init__(self, store: JsonFileStore, limit: int = 50):
|
||||
self._store = store
|
||||
self._limit = limit
|
||||
self._cache: dict[int, list[HistoryEntry]] = {}
|
||||
|
||||
def list(self, guild_id: int) -> list[HistoryEntry]:
|
||||
if guild_id not in self._cache:
|
||||
self._cache[guild_id] = self._load(guild_id)
|
||||
return self._cache[guild_id]
|
||||
|
||||
def add(self, guild_id: int, entry: HistoryEntry) -> None:
|
||||
if not entry.title:
|
||||
return
|
||||
entries = [item for item in self.list(guild_id) if not item.is_same_track_as(entry)]
|
||||
entries.insert(0, entry)
|
||||
self._cache[guild_id] = entries[: self._limit]
|
||||
self._persist(guild_id)
|
||||
|
||||
def find(self, guild_id: int, entry_id: str) -> HistoryEntry | None:
|
||||
return next((item for item in self.list(guild_id) if item.id == entry_id), None)
|
||||
|
||||
def _load(self, guild_id: int) -> list[HistoryEntry]:
|
||||
raw_entries = self._store.get(str(guild_id), []) or []
|
||||
entries: list[HistoryEntry] = []
|
||||
seen: set[tuple[str, str | None]] = set()
|
||||
for raw in raw_entries:
|
||||
entry = HistoryEntry.from_dict(raw)
|
||||
key = (entry.title, entry.url)
|
||||
if key in seen:
|
||||
continue
|
||||
seen.add(key)
|
||||
entries.append(entry)
|
||||
return entries
|
||||
|
||||
def _persist(self, guild_id: int) -> None:
|
||||
self._store.set(str(guild_id), [entry.to_dict() for entry in self._cache.get(guild_id, [])])
|
||||
@@ -0,0 +1,53 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
from typing import Any
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class JsonFileStore:
|
||||
"""Prosty magazyn słownika w pliku JSON, odporny na brakujący/uszkodzony plik."""
|
||||
|
||||
def __init__(self, path: str):
|
||||
self._path = path
|
||||
|
||||
@property
|
||||
def path(self) -> str:
|
||||
return self._path
|
||||
|
||||
def read(self) -> dict[str, Any]:
|
||||
if not os.path.exists(self._path):
|
||||
return {}
|
||||
try:
|
||||
with open(self._path, encoding="utf-8") as handle:
|
||||
data = json.load(handle)
|
||||
except (OSError, ValueError) as error:
|
||||
logger.error("Nie udało się odczytać %s: %s", self._path, error)
|
||||
return {}
|
||||
return data if isinstance(data, dict) else {}
|
||||
|
||||
def write(self, data: dict[str, Any]) -> bool:
|
||||
directory = os.path.dirname(self._path)
|
||||
try:
|
||||
if directory:
|
||||
os.makedirs(directory, exist_ok=True)
|
||||
with open(self._path, "w", encoding="utf-8") as handle:
|
||||
json.dump(data, handle, indent=4, ensure_ascii=False)
|
||||
except OSError as error:
|
||||
logger.error("Nie udało się zapisać %s: %s", self._path, error)
|
||||
return False
|
||||
return True
|
||||
|
||||
def set(self, key: str, value: Any) -> bool:
|
||||
data = self.read()
|
||||
if value is None:
|
||||
data.pop(key, None)
|
||||
else:
|
||||
data[key] = value
|
||||
return self.write(data)
|
||||
|
||||
def get(self, key: str, default: Any = None) -> Any:
|
||||
return self.read().get(key, default)
|
||||
@@ -0,0 +1,16 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from typing import Any
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class UploadFileInfo:
|
||||
"""Metadane pliku znajdującego się w serwerowej bazie plików."""
|
||||
|
||||
filename: str
|
||||
size_mb: float
|
||||
mtime: float
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {"filename": self.filename, "size_mb": self.size_mb, "mtime": self.mtime}
|
||||
@@ -0,0 +1,64 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import shutil
|
||||
from typing import BinaryIO
|
||||
|
||||
from zyrarbot.storage.upload_file_info import UploadFileInfo
|
||||
|
||||
|
||||
class UploadsRepository:
|
||||
"""Katalog z plikami wgranymi na serwer; nazwy zawsze sprowadzane do basename."""
|
||||
|
||||
def __init__(self, directory: str):
|
||||
self._directory = directory
|
||||
|
||||
@property
|
||||
def directory(self) -> str:
|
||||
return self._directory
|
||||
|
||||
def resolve(self, filename: str) -> str:
|
||||
return os.path.join(self._directory, os.path.basename(filename))
|
||||
|
||||
def exists(self, filename: str) -> bool:
|
||||
return os.path.isfile(self.resolve(filename))
|
||||
|
||||
def list(self) -> list[UploadFileInfo]:
|
||||
os.makedirs(self._directory, exist_ok=True)
|
||||
files = []
|
||||
for name in os.listdir(self._directory):
|
||||
path = os.path.join(self._directory, name)
|
||||
if not os.path.isfile(path) or name.startswith("."):
|
||||
continue
|
||||
files.append(
|
||||
UploadFileInfo(
|
||||
filename=name,
|
||||
size_mb=round(os.path.getsize(path) / (1024 * 1024), 2),
|
||||
mtime=os.path.getmtime(path),
|
||||
)
|
||||
)
|
||||
files.sort(key=lambda item: item.mtime, reverse=True)
|
||||
return files
|
||||
|
||||
def search(self, query: str, limit: int = 25) -> list[str]:
|
||||
needle = query.lower()
|
||||
return [item.filename for item in self.list() if needle in item.filename.lower()][:limit]
|
||||
|
||||
def save(self, filename: str, source: BinaryIO) -> str:
|
||||
os.makedirs(self._directory, exist_ok=True)
|
||||
name = os.path.basename(filename)
|
||||
with open(self.resolve(name), "wb") as target:
|
||||
shutil.copyfileobj(source, target)
|
||||
return name
|
||||
|
||||
def delete(self, filename: str) -> bool:
|
||||
path = self.resolve(filename)
|
||||
if not os.path.isfile(path):
|
||||
return False
|
||||
os.remove(path)
|
||||
return True
|
||||
|
||||
def touch(self, filename: str) -> None:
|
||||
path = self.resolve(filename)
|
||||
if os.path.isfile(path):
|
||||
os.utime(path, None)
|
||||
@@ -0,0 +1 @@
|
||||
"""Komunikacja użytkownika z odtwarzaczem"""
|
||||
@@ -0,0 +1 @@
|
||||
"""Panel webowy: FastAPI, WebSocket i modele żądań."""
|
||||
@@ -0,0 +1,31 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from fastapi import WebSocket
|
||||
|
||||
|
||||
class ConnectionManager:
|
||||
"""Rejestr aktywnych połączeń WebSocket panelu webowego."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._connections: list[WebSocket] = []
|
||||
|
||||
@property
|
||||
def has_listeners(self) -> bool:
|
||||
return bool(self._connections)
|
||||
|
||||
async def connect(self, websocket: WebSocket) -> None:
|
||||
await websocket.accept()
|
||||
self._connections.append(websocket)
|
||||
|
||||
def disconnect(self, websocket: WebSocket) -> None:
|
||||
if websocket in self._connections:
|
||||
self._connections.remove(websocket)
|
||||
|
||||
async def broadcast(self, message: dict[str, Any]) -> None:
|
||||
for connection in list(self._connections):
|
||||
try:
|
||||
await connection.send_json(message)
|
||||
except Exception: # noqa: BLE001 - zerwane połączenie po prostu usuwamy
|
||||
self.disconnect(connection)
|
||||
@@ -0,0 +1,64 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import discord
|
||||
from fastapi import HTTPException, Request, WebSocket
|
||||
|
||||
from zyrarbot.audio.track_factory import TrackFactory
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
from zyrarbot.settings import Settings
|
||||
from zyrarbot.storage.guild_config_repository import GuildConfigRepository
|
||||
from zyrarbot.storage.uploads_repository import UploadsRepository
|
||||
from zyrarbot.ui.api.connection_manager import ConnectionManager
|
||||
from zyrarbot.ui.api.status_broadcaster import StatusBroadcaster
|
||||
from zyrarbot.ui.api.status_service import StatusService
|
||||
from zyrarbot.ui.bot.guild_resolver import GuildResolver
|
||||
|
||||
NO_GUILD_DETAIL = "Bot has no active server context"
|
||||
|
||||
|
||||
def get_player(request: Request) -> MusicPlayer:
|
||||
return request.app.state.player
|
||||
|
||||
|
||||
def get_guilds(request: Request) -> GuildResolver:
|
||||
return request.app.state.guilds
|
||||
|
||||
|
||||
def get_uploads(request: Request) -> UploadsRepository:
|
||||
return request.app.state.uploads
|
||||
|
||||
|
||||
def get_tracks(request: Request) -> TrackFactory:
|
||||
return request.app.state.tracks
|
||||
|
||||
|
||||
def get_settings(request: Request) -> Settings:
|
||||
return request.app.state.settings
|
||||
|
||||
|
||||
def get_config(request: Request) -> GuildConfigRepository:
|
||||
return request.app.state.config
|
||||
|
||||
|
||||
def get_status_service(request: Request) -> StatusService:
|
||||
return request.app.state.status_service
|
||||
|
||||
|
||||
def get_broadcaster(request: Request) -> StatusBroadcaster:
|
||||
return request.app.state.broadcaster
|
||||
|
||||
|
||||
def get_connections(websocket: WebSocket) -> ConnectionManager:
|
||||
return websocket.app.state.connections
|
||||
|
||||
|
||||
def get_socket_status_service(websocket: WebSocket) -> StatusService:
|
||||
return websocket.app.state.status_service
|
||||
|
||||
|
||||
def get_active_guild(request: Request) -> discord.Guild:
|
||||
"""Serwer, którym steruje panel; brak kontekstu kończy się błędem 400."""
|
||||
guild = get_guilds(request).active_guild()
|
||||
if guild is None:
|
||||
raise HTTPException(status_code=400, detail=NO_GUILD_DETAIL)
|
||||
return guild
|
||||
@@ -0,0 +1,63 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import FastAPI
|
||||
|
||||
from zyrarbot.audio.track_factory import TrackFactory
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
from zyrarbot.settings import Settings
|
||||
from zyrarbot.storage.guild_config_repository import GuildConfigRepository
|
||||
from zyrarbot.storage.uploads_repository import UploadsRepository
|
||||
from zyrarbot.ui.api.connection_manager import ConnectionManager
|
||||
from zyrarbot.ui.api.routers import (
|
||||
playback_router,
|
||||
queue_router,
|
||||
settings_router,
|
||||
status_router,
|
||||
uploads_router,
|
||||
voice_router,
|
||||
websocket_router,
|
||||
)
|
||||
from zyrarbot.ui.api.status_broadcaster import StatusBroadcaster
|
||||
from zyrarbot.ui.api.status_service import StatusService
|
||||
from zyrarbot.ui.bot.guild_resolver import GuildResolver
|
||||
|
||||
ROUTERS = (
|
||||
status_router.router,
|
||||
playback_router.router,
|
||||
queue_router.router,
|
||||
voice_router.router,
|
||||
uploads_router.router,
|
||||
settings_router.router,
|
||||
websocket_router.router,
|
||||
)
|
||||
|
||||
|
||||
def mount_api(
|
||||
app: FastAPI,
|
||||
*,
|
||||
settings: Settings,
|
||||
player: MusicPlayer,
|
||||
guilds: GuildResolver,
|
||||
tracks: TrackFactory,
|
||||
uploads: UploadsRepository,
|
||||
config: GuildConfigRepository,
|
||||
) -> StatusBroadcaster:
|
||||
"""Konfiguruje stan API i podmontowuje jego routery do aplikacji."""
|
||||
connections = ConnectionManager()
|
||||
status_service = StatusService(player, guilds)
|
||||
broadcaster = StatusBroadcaster(status_service, connections)
|
||||
|
||||
app.state.settings = settings
|
||||
app.state.player = player
|
||||
app.state.guilds = guilds
|
||||
app.state.tracks = tracks
|
||||
app.state.uploads = uploads
|
||||
app.state.config = config
|
||||
app.state.connections = connections
|
||||
app.state.status_service = status_service
|
||||
app.state.broadcaster = broadcaster
|
||||
|
||||
for router in ROUTERS:
|
||||
app.include_router(router)
|
||||
|
||||
return broadcaster
|
||||
@@ -0,0 +1 @@
|
||||
"""Modele żądań przyjmowanych przez API - jeden model na plik."""
|
||||
@@ -0,0 +1,7 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class ConnectRequest(BaseModel):
|
||||
"""Podłączenie bota do kanału głosowego."""
|
||||
|
||||
channel_id: str
|
||||
@@ -0,0 +1,7 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class DefaultPlaysRequest(BaseModel):
|
||||
"""Domyślna liczba odtworzeń przypisywana nowym utworom."""
|
||||
|
||||
default_plays: int
|
||||
@@ -0,0 +1,7 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class JumpRequest(BaseModel):
|
||||
"""Przeskok do wskazanej pozycji w kolejce."""
|
||||
|
||||
index: int
|
||||
@@ -0,0 +1,7 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class LoopRequest(BaseModel):
|
||||
"""Włączenie lub wyłączenie zapętlania pojedynczego utworu."""
|
||||
|
||||
loop: bool
|
||||
@@ -0,0 +1,7 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class PlayFileRequest(BaseModel):
|
||||
"""Dodanie do kolejki pliku z serwerowej bazy plików."""
|
||||
|
||||
filename: str
|
||||
@@ -0,0 +1,7 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class PlayRequest(BaseModel):
|
||||
"""Dodanie utworu do kolejki na podstawie linku lub frazy wyszukiwania."""
|
||||
|
||||
query: str
|
||||
@@ -0,0 +1,7 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class RemoveRequest(BaseModel):
|
||||
"""Usunięcie utworu z kolejki po jego identyfikatorze."""
|
||||
|
||||
id: str
|
||||
@@ -0,0 +1,7 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class ReorderRequest(BaseModel):
|
||||
"""Nowa kolejność utworów wyrażona listą identyfikatorów."""
|
||||
|
||||
queue_ids: list[str]
|
||||
@@ -0,0 +1,8 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class TextChannelRequest(BaseModel):
|
||||
"""Ustawienie kanału powiadomień; puste ``channel_id`` czyści ustawienie."""
|
||||
|
||||
channel_id: str
|
||||
guild_id: str | None = None
|
||||
@@ -0,0 +1,8 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class TrackPlaysRequest(BaseModel):
|
||||
"""Zmiana pozostałej liczby odtworzeń konkretnego utworu w kolejce."""
|
||||
|
||||
id: str
|
||||
plays: int
|
||||
@@ -0,0 +1,7 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class VolumeRequest(BaseModel):
|
||||
"""Zmiana głośności odtwarzacza w skali 0-100."""
|
||||
|
||||
volume: int
|
||||
@@ -0,0 +1 @@
|
||||
"""Routery FastAPI pogrupowane według obszaru odpowiedzialności."""
|
||||
@@ -0,0 +1,189 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from typing import Any
|
||||
|
||||
import discord
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
|
||||
from zyrarbot.audio.track_factory import TrackFactory
|
||||
from zyrarbot.music.loop_mode import LoopMode
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
from zyrarbot.storage.uploads_repository import UploadsRepository
|
||||
from zyrarbot.ui.api.dependencies import (
|
||||
get_active_guild,
|
||||
get_broadcaster,
|
||||
get_player,
|
||||
get_tracks,
|
||||
get_uploads,
|
||||
)
|
||||
from zyrarbot.ui.api.requests.loop_request import LoopRequest
|
||||
from zyrarbot.ui.api.requests.play_file_request import PlayFileRequest
|
||||
from zyrarbot.ui.api.requests.play_request import PlayRequest
|
||||
from zyrarbot.ui.api.requests.volume_request import VolumeRequest
|
||||
from zyrarbot.ui.api.status_broadcaster import StatusBroadcaster
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
router = APIRouter(prefix="/api", tags=["playback"])
|
||||
|
||||
|
||||
def _require_voice(player: MusicPlayer, guild: discord.Guild) -> None:
|
||||
if player.voice_client(guild.id) is None:
|
||||
raise HTTPException(
|
||||
status_code=400, detail="Bot is not connected to a voice channel on this server"
|
||||
)
|
||||
|
||||
|
||||
@router.post("/play")
|
||||
async def play(
|
||||
request: PlayRequest,
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
tracks: TrackFactory = Depends(get_tracks),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, Any]:
|
||||
_require_voice(player, guild)
|
||||
try:
|
||||
track = await tracks.resolve(request.query)
|
||||
result = await player.enqueue(guild.id, track, from_web=True)
|
||||
except Exception as error:
|
||||
logger.error("Nie udało się dodać utworu z panelu: %s", error)
|
||||
raise HTTPException(status_code=500, detail=str(error)) from error
|
||||
|
||||
await broadcaster.broadcast()
|
||||
return result
|
||||
|
||||
|
||||
@router.post("/play_file")
|
||||
async def play_file(
|
||||
request: PlayFileRequest,
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
tracks: TrackFactory = Depends(get_tracks),
|
||||
uploads: UploadsRepository = Depends(get_uploads),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, Any]:
|
||||
_require_voice(player, guild)
|
||||
if not uploads.exists(request.filename):
|
||||
raise HTTPException(status_code=404, detail="Plik nie istnieje na serwerze")
|
||||
|
||||
try:
|
||||
# Odświeżenie mtime utrzymuje plik na szczycie listy ostatnio używanych.
|
||||
uploads.touch(request.filename)
|
||||
track = await tracks.from_file(uploads.resolve(request.filename))
|
||||
result = await player.enqueue(guild.id, track, from_web=True)
|
||||
except Exception as error:
|
||||
logger.error("Nie udało się odtworzyć pliku z panelu: %s", error)
|
||||
raise HTTPException(status_code=500, detail=str(error)) from error
|
||||
|
||||
await broadcaster.broadcast()
|
||||
return result
|
||||
|
||||
|
||||
@router.post("/pause")
|
||||
async def pause(
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, str]:
|
||||
voice_client = player.voice_client(guild.id)
|
||||
if not voice_client or not voice_client.is_playing():
|
||||
raise HTTPException(status_code=400, detail="Bot is not playing on this server")
|
||||
voice_client.pause()
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "paused"}
|
||||
|
||||
|
||||
@router.post("/resume")
|
||||
async def resume(
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, str]:
|
||||
voice_client = player.voice_client(guild.id)
|
||||
if not voice_client or not voice_client.is_paused():
|
||||
raise HTTPException(status_code=400, detail="Bot is not paused on this server")
|
||||
voice_client.resume()
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "resumed"}
|
||||
|
||||
|
||||
@router.post("/skip")
|
||||
async def skip(
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, str]:
|
||||
state = player.state(guild.id)
|
||||
if state.loop_mode.loops_track:
|
||||
state.loop_mode = LoopMode.OFF
|
||||
|
||||
if not player.is_active(guild.id):
|
||||
raise HTTPException(status_code=400, detail="Bot is not playing anything on this server")
|
||||
|
||||
player.voice_client(guild.id).stop()
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "skipped"}
|
||||
|
||||
|
||||
@router.post("/stop")
|
||||
async def stop(
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, str]:
|
||||
if player.is_active(guild.id):
|
||||
player.voice_client(guild.id).stop()
|
||||
player.clear(guild.id)
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "stopped"}
|
||||
|
||||
|
||||
@router.post("/volume")
|
||||
async def set_volume(
|
||||
request: VolumeRequest,
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, Any]:
|
||||
if not 0 <= request.volume <= 100:
|
||||
raise HTTPException(status_code=400, detail="Volume must be between 0 and 100")
|
||||
player.set_volume(guild.id, request.volume / 100)
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "success", "volume": request.volume}
|
||||
|
||||
|
||||
@router.post("/loop")
|
||||
async def set_loop(
|
||||
request: LoopRequest,
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, Any]:
|
||||
player.set_loop_mode(guild.id, LoopMode.TRACK if request.loop else LoopMode.OFF)
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "success", "loop": request.loop}
|
||||
|
||||
|
||||
@router.post("/loop_playlist")
|
||||
async def toggle_loop_playlist(
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, Any]:
|
||||
enabled = not player.state(guild.id).loop_mode.loops_queue
|
||||
player.set_loop_mode(guild.id, LoopMode.QUEUE if enabled else LoopMode.OFF)
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "success", "loop_playlist": enabled}
|
||||
|
||||
|
||||
@router.post("/loop_cycle")
|
||||
async def cycle_loop(
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, Any]:
|
||||
mode = player.cycle_loop_mode(guild.id)
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "success", "mode": mode.value}
|
||||
@@ -0,0 +1,84 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
import discord
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
from zyrarbot.settings import Settings
|
||||
from zyrarbot.ui.api.dependencies import (
|
||||
get_active_guild,
|
||||
get_broadcaster,
|
||||
get_player,
|
||||
get_settings,
|
||||
)
|
||||
from zyrarbot.ui.api.requests.jump_request import JumpRequest
|
||||
from zyrarbot.ui.api.requests.remove_request import RemoveRequest
|
||||
from zyrarbot.ui.api.requests.reorder_request import ReorderRequest
|
||||
from zyrarbot.ui.api.requests.track_plays_request import TrackPlaysRequest
|
||||
from zyrarbot.ui.api.status_broadcaster import StatusBroadcaster
|
||||
|
||||
router = APIRouter(prefix="/api", tags=["queue"])
|
||||
|
||||
|
||||
@router.post("/jump")
|
||||
async def jump(
|
||||
request: JumpRequest,
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, str]:
|
||||
queue = player.state(guild.id).queue
|
||||
if not 0 <= request.index < len(queue):
|
||||
raise HTTPException(status_code=400, detail="Invalid track index")
|
||||
|
||||
await player.jump(guild.id, request.index)
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "jumped"}
|
||||
|
||||
|
||||
@router.post("/remove")
|
||||
async def remove(
|
||||
request: RemoveRequest,
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, str]:
|
||||
if not await player.remove(guild.id, request.id):
|
||||
raise HTTPException(status_code=404, detail="Track not found in queue")
|
||||
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "removed"}
|
||||
|
||||
|
||||
@router.post("/reorder")
|
||||
async def reorder(
|
||||
request: ReorderRequest,
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, str]:
|
||||
player.reorder(guild.id, request.queue_ids)
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "success"}
|
||||
|
||||
|
||||
@router.post("/queue/plays")
|
||||
async def set_track_plays(
|
||||
request: TrackPlaysRequest,
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
settings: Settings = Depends(get_settings),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, Any]:
|
||||
if not settings.is_valid_plays(request.plays):
|
||||
raise HTTPException(status_code=400, detail="Invalid plays value")
|
||||
|
||||
track = player.state(guild.id).find(request.id)
|
||||
if track is None:
|
||||
raise HTTPException(status_code=404, detail="Track not found in queue")
|
||||
|
||||
track.plays_left = request.plays
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "success", "id": request.id, "plays": request.plays}
|
||||
@@ -0,0 +1,82 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from typing import Any
|
||||
|
||||
import discord
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
from zyrarbot.settings import Settings
|
||||
from zyrarbot.storage.guild_config_repository import GuildConfigRepository
|
||||
from zyrarbot.ui.api.dependencies import (
|
||||
get_broadcaster,
|
||||
get_config,
|
||||
get_guilds,
|
||||
get_player,
|
||||
get_settings,
|
||||
)
|
||||
from zyrarbot.ui.api.requests.default_plays_request import DefaultPlaysRequest
|
||||
from zyrarbot.ui.api.requests.text_channel_request import TextChannelRequest
|
||||
from zyrarbot.ui.api.status_broadcaster import StatusBroadcaster
|
||||
from zyrarbot.ui.bot.guild_resolver import GuildResolver
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
router = APIRouter(prefix="/api/settings", tags=["settings"])
|
||||
|
||||
|
||||
@router.post("/text_channel")
|
||||
async def set_text_channel(
|
||||
request: TextChannelRequest,
|
||||
guilds: GuildResolver = Depends(get_guilds),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
config: GuildConfigRepository = Depends(get_config),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, Any]:
|
||||
if request.channel_id in ("", "0"):
|
||||
if not request.guild_id:
|
||||
raise HTTPException(status_code=400, detail="guild_id required to reset channel")
|
||||
guild_id = int(request.guild_id)
|
||||
player.set_notification_channel(guild_id, None)
|
||||
config.set_notification_channel_id(guild_id, None)
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "success", "channel_id": None, "guild_id": str(guild_id)}
|
||||
|
||||
channel = guilds.channel(int(request.channel_id))
|
||||
if not isinstance(channel, discord.TextChannel):
|
||||
raise HTTPException(status_code=404, detail="Text channel not found")
|
||||
|
||||
guild_id = channel.guild.id
|
||||
if request.guild_id and int(request.guild_id) != guild_id:
|
||||
raise HTTPException(
|
||||
status_code=400, detail="Channel does not belong to the specified guild"
|
||||
)
|
||||
|
||||
player.set_notification_channel(guild_id, channel)
|
||||
config.set_notification_channel_id(guild_id, channel.id)
|
||||
|
||||
try:
|
||||
await channel.send(
|
||||
"🔔 Ten kanał został ustawiony jako główny kanał powiadomień dla ŻyrarBOT "
|
||||
f"na serwerze **{channel.guild.name}** z panelu webowego."
|
||||
)
|
||||
except discord.DiscordException as error:
|
||||
logger.error("Nie udało się wysłać wiadomości testowej: %s", error)
|
||||
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "success", "channel_id": request.channel_id, "guild_id": str(guild_id)}
|
||||
|
||||
|
||||
@router.post("/default_plays")
|
||||
async def set_default_plays(
|
||||
request: DefaultPlaysRequest,
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
settings: Settings = Depends(get_settings),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, Any]:
|
||||
if not settings.is_valid_plays(request.default_plays):
|
||||
raise HTTPException(status_code=400, detail="Invalid default plays value")
|
||||
player.set_default_plays(request.default_plays)
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "success", "default_plays": request.default_plays}
|
||||
@@ -0,0 +1,15 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from fastapi import APIRouter, Depends
|
||||
|
||||
from zyrarbot.ui.api.dependencies import get_status_service
|
||||
from zyrarbot.ui.api.status_service import StatusService
|
||||
|
||||
router = APIRouter(prefix="/api", tags=["status"])
|
||||
|
||||
|
||||
@router.get("/status")
|
||||
async def get_status(status: StatusService = Depends(get_status_service)) -> dict[str, Any]:
|
||||
return status.snapshot()
|
||||
@@ -0,0 +1,41 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
|
||||
|
||||
from zyrarbot.storage.uploads_repository import UploadsRepository
|
||||
from zyrarbot.ui.api.dependencies import get_uploads
|
||||
|
||||
router = APIRouter(prefix="/api", tags=["uploads"])
|
||||
|
||||
|
||||
@router.get("/uploads")
|
||||
async def list_uploads(uploads: UploadsRepository = Depends(get_uploads)) -> dict[str, Any]:
|
||||
return {"files": [item.to_dict() for item in uploads.list()]}
|
||||
|
||||
|
||||
@router.post("/upload")
|
||||
async def upload(
|
||||
file: UploadFile = File(...),
|
||||
uploads: UploadsRepository = Depends(get_uploads),
|
||||
) -> dict[str, str]:
|
||||
try:
|
||||
filename = uploads.save(file.filename or "plik", file.file)
|
||||
except OSError as error:
|
||||
raise HTTPException(status_code=500, detail=f"Błąd zapisu pliku: {error}") from error
|
||||
return {"status": "success", "filename": filename}
|
||||
|
||||
|
||||
@router.delete("/uploads/{filename}")
|
||||
async def delete_upload(
|
||||
filename: str,
|
||||
uploads: UploadsRepository = Depends(get_uploads),
|
||||
) -> dict[str, str]:
|
||||
if not uploads.exists(filename):
|
||||
raise HTTPException(status_code=404, detail="Plik nie istnieje")
|
||||
try:
|
||||
uploads.delete(filename)
|
||||
except OSError as error:
|
||||
raise HTTPException(status_code=500, detail=str(error)) from error
|
||||
return {"status": "deleted"}
|
||||
@@ -0,0 +1,67 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import discord
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
from zyrarbot.music.notification_channel_resolver import NotificationChannelResolver
|
||||
from zyrarbot.ui.api.dependencies import (
|
||||
get_active_guild,
|
||||
get_broadcaster,
|
||||
get_guilds,
|
||||
get_player,
|
||||
)
|
||||
from zyrarbot.ui.api.requests.connect_request import ConnectRequest
|
||||
from zyrarbot.ui.api.status_broadcaster import StatusBroadcaster
|
||||
from zyrarbot.ui.bot.guild_resolver import GuildResolver
|
||||
|
||||
router = APIRouter(prefix="/api", tags=["voice"])
|
||||
|
||||
|
||||
@router.post("/connect")
|
||||
async def connect(
|
||||
request: ConnectRequest,
|
||||
guilds: GuildResolver = Depends(get_guilds),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, str]:
|
||||
try:
|
||||
channel_id = int(request.channel_id)
|
||||
except ValueError as error:
|
||||
raise HTTPException(status_code=400, detail="Invalid channel ID") from error
|
||||
|
||||
channel = guilds.channel(channel_id)
|
||||
if not isinstance(channel, discord.VoiceChannel):
|
||||
raise HTTPException(status_code=404, detail="Voice channel not found")
|
||||
|
||||
guild_id = channel.guild.id
|
||||
# Rozłączamy wyłącznie na tym samym serwerze - inne serwery grają dalej.
|
||||
existing = guilds.voice_client(guild_id)
|
||||
if existing:
|
||||
await existing.disconnect()
|
||||
|
||||
await channel.connect()
|
||||
|
||||
if not player.notification_channel(guild_id):
|
||||
player.set_notification_channel(
|
||||
guild_id, NotificationChannelResolver.first_writable(channel.guild)
|
||||
)
|
||||
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "connected", "channel": channel.name}
|
||||
|
||||
|
||||
@router.post("/disconnect")
|
||||
async def disconnect(
|
||||
guild: discord.Guild = Depends(get_active_guild),
|
||||
player: MusicPlayer = Depends(get_player),
|
||||
broadcaster: StatusBroadcaster = Depends(get_broadcaster),
|
||||
) -> dict[str, str]:
|
||||
voice_client = player.voice_client(guild.id)
|
||||
if not voice_client:
|
||||
raise HTTPException(status_code=400, detail="Bot not connected to voice on this server")
|
||||
|
||||
await voice_client.disconnect()
|
||||
player.clear(guild.id)
|
||||
await broadcaster.broadcast()
|
||||
return {"status": "disconnected"}
|
||||
@@ -0,0 +1,32 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
|
||||
from fastapi import APIRouter, Depends, WebSocket, WebSocketDisconnect
|
||||
|
||||
from zyrarbot.ui.api.connection_manager import ConnectionManager
|
||||
from zyrarbot.ui.api.dependencies import get_connections, get_socket_status_service
|
||||
from zyrarbot.ui.api.status_service import StatusService
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.websocket("/ws")
|
||||
async def websocket_endpoint(
|
||||
websocket: WebSocket,
|
||||
connections: ConnectionManager = Depends(get_connections),
|
||||
status: StatusService = Depends(get_socket_status_service),
|
||||
) -> None:
|
||||
await connections.connect(websocket)
|
||||
try:
|
||||
await websocket.send_json(status.snapshot())
|
||||
while True:
|
||||
# Klient nic nie wysyła - czekamy wyłącznie na rozłączenie.
|
||||
await websocket.receive_text()
|
||||
except WebSocketDisconnect:
|
||||
connections.disconnect(websocket)
|
||||
except Exception as error: # noqa: BLE001
|
||||
logger.error("Błąd połączenia WebSocket: %s", error)
|
||||
connections.disconnect(websocket)
|
||||
@@ -0,0 +1,51 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import contextlib
|
||||
import logging
|
||||
|
||||
from zyrarbot.ui.api.connection_manager import ConnectionManager
|
||||
from zyrarbot.ui.api.status_service import StatusService
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
BROADCAST_INTERVAL_SECONDS = 1.0
|
||||
|
||||
|
||||
class StatusBroadcaster:
|
||||
"""Rozgłasza stan bota po WebSocketach - zarówno cyklicznie, jak i na żądanie."""
|
||||
|
||||
def __init__(self, status: StatusService, connections: ConnectionManager):
|
||||
self._status = status
|
||||
self._connections = connections
|
||||
self._task: asyncio.Task[None] | None = None
|
||||
|
||||
async def broadcast(self) -> None:
|
||||
if not self._connections.has_listeners:
|
||||
return
|
||||
try:
|
||||
await self._connections.broadcast(self._status.snapshot())
|
||||
except Exception as error: # noqa: BLE001 - rozgłaszanie nie może ubić pętli
|
||||
logger.error("Błąd rozgłaszania stanu: %s", error)
|
||||
|
||||
def start(self) -> None:
|
||||
if self._task is None or self._task.done():
|
||||
self._task = asyncio.create_task(self._loop())
|
||||
|
||||
async def stop(self) -> None:
|
||||
if self._task is None:
|
||||
return
|
||||
self._task.cancel()
|
||||
with contextlib.suppress(asyncio.CancelledError):
|
||||
await self._task
|
||||
self._task = None
|
||||
|
||||
async def _loop(self) -> None:
|
||||
while True:
|
||||
try:
|
||||
await asyncio.sleep(BROADCAST_INTERVAL_SECONDS)
|
||||
await self.broadcast()
|
||||
except asyncio.CancelledError:
|
||||
break
|
||||
except Exception as error: # noqa: BLE001
|
||||
logger.error("Błąd pętli rozgłaszania stanu: %s", error)
|
||||
@@ -0,0 +1,151 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
import discord
|
||||
|
||||
from zyrarbot.audio.ytdl_source import YTDLSource
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
from zyrarbot.music.notification_channel_resolver import NotificationChannelResolver
|
||||
from zyrarbot.ui.bot.guild_resolver import GuildResolver
|
||||
|
||||
HISTORY_PAYLOAD_LIMIT = 50
|
||||
|
||||
|
||||
class StatusService:
|
||||
"""Składa pełny obraz stanu bota wysyłany do panelu przez REST i WebSocket."""
|
||||
|
||||
def __init__(self, player: MusicPlayer, guilds: GuildResolver):
|
||||
self._player = player
|
||||
self._guilds = guilds
|
||||
|
||||
def snapshot(self) -> dict[str, Any]:
|
||||
payload: dict[str, Any] = {
|
||||
"guilds": self._guilds_payload(),
|
||||
"voice_channels": self._voice_channels_payload(),
|
||||
"default_plays": self._player.default_plays,
|
||||
}
|
||||
|
||||
guild = self._guilds.active_guild()
|
||||
if guild is None:
|
||||
payload.update(self._idle_payload())
|
||||
return payload
|
||||
|
||||
payload.update(self._guild_payload(guild))
|
||||
return payload
|
||||
|
||||
# --- Fragmenty odpowiedzi ----------------------------------------------
|
||||
|
||||
def _idle_payload(self) -> dict[str, Any]:
|
||||
return {
|
||||
"playing": False,
|
||||
"paused": False,
|
||||
"loop_single": False,
|
||||
"loop_playlist": False,
|
||||
"volume": 100,
|
||||
"current": None,
|
||||
"queue": [],
|
||||
"queue_index": -1,
|
||||
"history": [],
|
||||
"active_voice_channel": None,
|
||||
"text_channels": [],
|
||||
"active_text_channel_id": None,
|
||||
}
|
||||
|
||||
def _guild_payload(self, guild: discord.Guild) -> dict[str, Any]:
|
||||
state = self._player.state(guild.id)
|
||||
voice_client = self._guilds.voice_client(guild.id)
|
||||
notification_channel = self._player.notification_channel(guild.id)
|
||||
|
||||
return {
|
||||
"playing": bool(voice_client and voice_client.is_playing()),
|
||||
"paused": bool(voice_client and voice_client.is_paused()),
|
||||
"loop_single": state.loop_mode.loops_track,
|
||||
"loop_playlist": state.loop_mode.loops_queue,
|
||||
"volume": int(state.volume * 100),
|
||||
"current": self._current_payload(state.current),
|
||||
"queue": [self._track_payload(track) for track in state.queue],
|
||||
"queue_index": state.index,
|
||||
"active_voice_channel": self._active_voice_payload(voice_client),
|
||||
"text_channels": [
|
||||
self._channel_payload(guild, channel)
|
||||
for channel in NotificationChannelResolver.writable_channels(guild)
|
||||
],
|
||||
"active_text_channel_id": (
|
||||
str(notification_channel.id) if notification_channel else None
|
||||
),
|
||||
"history": [
|
||||
entry.to_dict() for entry in self._player.history(guild.id)[:HISTORY_PAYLOAD_LIMIT]
|
||||
],
|
||||
}
|
||||
|
||||
def _current_payload(self, track: YTDLSource | None) -> dict[str, Any] | None:
|
||||
if track is None:
|
||||
return None
|
||||
return {
|
||||
"title": track.title,
|
||||
"url": track.display_url,
|
||||
"id": track.id,
|
||||
"duration": track.duration,
|
||||
"elapsed": round(track.elapsed, 1),
|
||||
"plays_left": self._player.plays_left(track),
|
||||
}
|
||||
|
||||
def _track_payload(self, track: YTDLSource) -> dict[str, Any]:
|
||||
return {
|
||||
"title": track.title,
|
||||
"url": track.display_url,
|
||||
"id": track.id,
|
||||
"plays_left": self._player.plays_left(track),
|
||||
}
|
||||
|
||||
def _active_voice_payload(
|
||||
self, voice_client: discord.VoiceClient | None
|
||||
) -> dict[str, Any] | None:
|
||||
if not voice_client or not voice_client.channel:
|
||||
return None
|
||||
channel = voice_client.channel
|
||||
return {
|
||||
"channel_name": channel.name,
|
||||
"channel_id": str(channel.id),
|
||||
"guild_name": channel.guild.name,
|
||||
"guild_id": str(channel.guild.id),
|
||||
}
|
||||
|
||||
def _voice_channels_payload(self) -> list[dict[str, Any]]:
|
||||
return [
|
||||
{
|
||||
"guild_name": guild.name,
|
||||
"guild_id": str(guild.id),
|
||||
"channel_name": channel.name,
|
||||
"channel_id": str(channel.id),
|
||||
}
|
||||
for guild in self._guilds.guilds()
|
||||
for channel in guild.voice_channels
|
||||
]
|
||||
|
||||
def _guilds_payload(self) -> list[dict[str, Any]]:
|
||||
payload = []
|
||||
for guild in self._guilds.guilds():
|
||||
active = self._player.notification_channel(guild.id)
|
||||
payload.append(
|
||||
{
|
||||
"guild_id": str(guild.id),
|
||||
"guild_name": guild.name,
|
||||
"text_channels": [
|
||||
{"channel_id": str(channel.id), "channel_name": channel.name}
|
||||
for channel in NotificationChannelResolver.writable_channels(guild)
|
||||
],
|
||||
"active_notification_channel_id": str(active.id) if active else None,
|
||||
}
|
||||
)
|
||||
return payload
|
||||
|
||||
@staticmethod
|
||||
def _channel_payload(guild: discord.Guild, channel: discord.TextChannel) -> dict[str, Any]:
|
||||
return {
|
||||
"guild_name": guild.name,
|
||||
"guild_id": str(guild.id),
|
||||
"channel_name": channel.name,
|
||||
"channel_id": str(channel.id),
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
"""Warstwa Discorda: klient bota, cogi i komendy ukośnikowe."""
|
||||
@@ -0,0 +1,69 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
|
||||
import discord
|
||||
from discord.ext import commands
|
||||
|
||||
from zyrarbot.audio.track_factory import TrackFactory
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
from zyrarbot.settings import Settings
|
||||
from zyrarbot.storage.uploads_repository import UploadsRepository
|
||||
from zyrarbot.ui.bot.cogs.control_cog import ControlCog
|
||||
from zyrarbot.ui.bot.cogs.playback_cog import PlaybackCog
|
||||
from zyrarbot.ui.bot.cogs.queue_cog import QueueCog
|
||||
from zyrarbot.ui.bot.cogs.settings_cog import SettingsCog
|
||||
from zyrarbot.ui.bot.cogs.voice_cog import VoiceCog
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class MusicBot(commands.Bot):
|
||||
"""Klient Discorda rejestrujący cog muzyczny i synchronizujący komendy.
|
||||
|
||||
``player`` przypisuje kompozycja aplikacji tuż po utworzeniu klienta -
|
||||
odtwarzacz potrzebuje bota, a bot odtwarzacza, więc pętlę domykamy tutaj.
|
||||
"""
|
||||
|
||||
def __init__(self, settings: Settings, tracks: TrackFactory, uploads: UploadsRepository):
|
||||
intents = discord.Intents.default()
|
||||
intents.message_content = True
|
||||
intents.voice_states = True
|
||||
super().__init__(command_prefix="!", intents=intents)
|
||||
|
||||
self.settings = settings
|
||||
self.tracks = tracks
|
||||
self.uploads = uploads
|
||||
self.player: MusicPlayer | None = None
|
||||
|
||||
def _create_music_cogs(self) -> tuple[commands.Cog, ...]:
|
||||
if self.player is None:
|
||||
raise RuntimeError("MusicPlayer musi zostać przypisany przed utworzeniem Cogów")
|
||||
|
||||
return (
|
||||
PlaybackCog(self, self.player, self.tracks, self.uploads),
|
||||
QueueCog(self, self.player, self.settings),
|
||||
ControlCog(self, self.player),
|
||||
VoiceCog(self, self.player),
|
||||
SettingsCog(self, self.player, self.settings),
|
||||
)
|
||||
|
||||
async def setup_hook(self) -> None:
|
||||
if self.player is None:
|
||||
raise RuntimeError("MusicPlayer musi zostać przypisany przed startem bota")
|
||||
|
||||
for cog in self._create_music_cogs():
|
||||
await self.add_cog(cog)
|
||||
|
||||
if self.settings.guild_id:
|
||||
guild = discord.Object(id=self.settings.guild_id)
|
||||
self.tree.copy_global_to(guild=guild)
|
||||
await self.tree.sync(guild=guild)
|
||||
logger.info("Zsynchronizowano komendy z serwerem %s", self.settings.guild_id)
|
||||
else:
|
||||
await self.tree.sync()
|
||||
logger.info("Zsynchronizowano komendy globalnie")
|
||||
|
||||
async def on_ready(self) -> None:
|
||||
if self.user:
|
||||
logger.info("Zalogowano jako %s (%s)", self.user.name, self.user.id)
|
||||
@@ -0,0 +1 @@
|
||||
"""Cogi rejestrowane w kliencie Discorda."""
|
||||
@@ -0,0 +1,39 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import discord
|
||||
from discord.ext import commands
|
||||
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
|
||||
|
||||
class MusicCogBase(commands.Cog):
|
||||
"""Wspólne zależności i pomocnicze operacje dla muzycznych Cogów."""
|
||||
|
||||
def __init__(self, bot: commands.Bot, player: MusicPlayer):
|
||||
self.bot = bot
|
||||
self.player = player
|
||||
|
||||
async def _ensure_voice(self, interaction: discord.Interaction) -> bool:
|
||||
if not interaction.user.voice:
|
||||
await interaction.response.send_message(
|
||||
"Nie jesteś połączony z kanałem głosowym.", ephemeral=True
|
||||
)
|
||||
return False
|
||||
|
||||
voice_client = interaction.guild.voice_client
|
||||
if voice_client is None:
|
||||
await interaction.user.voice.channel.connect()
|
||||
elif voice_client.channel != interaction.user.voice.channel:
|
||||
await interaction.response.send_message(
|
||||
"Jestem już połączony z innym kanałem głosowym.", ephemeral=True
|
||||
)
|
||||
return False
|
||||
return True
|
||||
|
||||
async def _enqueue_and_reply(
|
||||
self, interaction: discord.Interaction, track, *, prefix: str = ""
|
||||
) -> None:
|
||||
result = await self.player.enqueue(interaction.guild.id, track, channel=interaction.channel)
|
||||
title = discord.utils.escape_markdown(track.title or "Nieznany tytuł")
|
||||
action = "Dodano do kolejki" if result["status"] == "queued" else "Teraz odtwarzane"
|
||||
await interaction.followup.send(f"{action}{prefix}: {title}")
|
||||
@@ -0,0 +1,84 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import discord
|
||||
from discord import app_commands
|
||||
|
||||
from zyrarbot.music.loop_mode import LoopMode
|
||||
from zyrarbot.ui.bot.cogs.common import MusicCogBase
|
||||
|
||||
|
||||
class ControlCog(MusicCogBase, name="Control"):
|
||||
"""Komendy bezpośredniego sterowania odtwarzaniem."""
|
||||
|
||||
@app_commands.command(name="skip", description="Pomiń aktualny utwór")
|
||||
async def skip(self, interaction: discord.Interaction) -> None:
|
||||
guild_id = interaction.guild.id
|
||||
state = self.player.state(guild_id)
|
||||
if state.loop_mode.loops_track:
|
||||
state.loop_mode = LoopMode.OFF
|
||||
if not self.player.is_active(guild_id):
|
||||
await interaction.response.send_message("Nic nie jest odtwarzane.", ephemeral=True)
|
||||
return
|
||||
interaction.guild.voice_client.stop()
|
||||
await self.player.trigger_state_change()
|
||||
await interaction.response.send_message("Pominięto aktualny utwór.")
|
||||
|
||||
@app_commands.command(name="pause", description="Wstrzymaj odtwarzanie")
|
||||
async def pause(self, interaction: discord.Interaction) -> None:
|
||||
voice_client = interaction.guild.voice_client
|
||||
if not voice_client or not voice_client.is_playing():
|
||||
await interaction.response.send_message("Nic nie jest odtwarzane.", ephemeral=True)
|
||||
return
|
||||
voice_client.pause()
|
||||
await self.player.trigger_state_change()
|
||||
await interaction.response.send_message("Odtwarzanie wstrzymane.")
|
||||
|
||||
@app_commands.command(name="resume", description="Wznów odtwarzanie")
|
||||
async def resume(self, interaction: discord.Interaction) -> None:
|
||||
voice_client = interaction.guild.voice_client
|
||||
if not voice_client or not voice_client.is_paused():
|
||||
await interaction.response.send_message(
|
||||
"Odtwarzanie nie jest wstrzymane.", ephemeral=True
|
||||
)
|
||||
return
|
||||
voice_client.resume()
|
||||
await self.player.trigger_state_change()
|
||||
await interaction.response.send_message("Odtwarzanie wznowione.")
|
||||
|
||||
@app_commands.command(name="stop", description="Zatrzymaj odtwarzanie i wyczyść kolejkę")
|
||||
async def stop(self, interaction: discord.Interaction) -> None:
|
||||
guild_id = interaction.guild.id
|
||||
voice_client = interaction.guild.voice_client
|
||||
if voice_client and voice_client.is_playing():
|
||||
voice_client.stop()
|
||||
self.player.clear(guild_id)
|
||||
await self.player.trigger_state_change()
|
||||
await interaction.response.send_message("Zatrzymano odtwarzanie i wyczyszczono kolejkę.")
|
||||
|
||||
@app_commands.command(name="volume", description="Zmień głośność odtwarzacza")
|
||||
@app_commands.describe(volume="Poziom głośności (1-100)")
|
||||
async def volume(self, interaction: discord.Interaction, volume: int) -> None:
|
||||
if interaction.guild.voice_client is None:
|
||||
await interaction.response.send_message(
|
||||
"Nie połączono z kanałem głosowym.", ephemeral=True
|
||||
)
|
||||
return
|
||||
if not 0 < volume <= 100:
|
||||
await interaction.response.send_message(
|
||||
"Wprowadź wartość z przedziału od 1 do 100.", ephemeral=True
|
||||
)
|
||||
return
|
||||
self.player.set_volume(interaction.guild.id, volume / 100)
|
||||
await self.player.trigger_state_change()
|
||||
await interaction.response.send_message(f"Zmieniono głośność na {volume}%")
|
||||
|
||||
@app_commands.command(name="nowplaying", description="Pokaż aktualnie odtwarzany utwór")
|
||||
async def now_playing(self, interaction: discord.Interaction) -> None:
|
||||
current = self.player.state(interaction.guild.id).current
|
||||
if not current:
|
||||
await interaction.response.send_message(
|
||||
"Nic nie jest obecnie odtwarzane.", ephemeral=True
|
||||
)
|
||||
return
|
||||
title = discord.utils.escape_markdown(current.title or "")
|
||||
await interaction.response.send_message(f"Teraz odtwarzane: {title}")
|
||||
@@ -0,0 +1,111 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
|
||||
import discord
|
||||
from discord import app_commands
|
||||
from discord.ext import commands
|
||||
|
||||
from zyrarbot.audio.track_factory import TrackFactory
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
from zyrarbot.storage.uploads_repository import UploadsRepository
|
||||
from zyrarbot.ui.bot.cogs.common import MusicCogBase
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
AUTOCOMPLETE_LIMIT = 25
|
||||
|
||||
|
||||
class PlaybackCog(MusicCogBase, name="Playback"):
|
||||
"""Komendy dodawania i ponownego odtwarzania utworów."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
bot: commands.Bot,
|
||||
player: MusicPlayer,
|
||||
tracks: TrackFactory,
|
||||
uploads: UploadsRepository,
|
||||
):
|
||||
super().__init__(bot, player)
|
||||
self._tracks = tracks
|
||||
self._uploads = uploads
|
||||
|
||||
async def _uploads_autocomplete(
|
||||
self, interaction: discord.Interaction, current: str
|
||||
) -> list[app_commands.Choice[str]]:
|
||||
names = self._uploads.search(current, limit=AUTOCOMPLETE_LIMIT)
|
||||
return [app_commands.Choice(name=name, value=name) for name in names]
|
||||
|
||||
async def _history_autocomplete(
|
||||
self, interaction: discord.Interaction, current: str
|
||||
) -> list[app_commands.Choice[str]]:
|
||||
entries = self.player.history(interaction.guild.id)
|
||||
matches = [entry for entry in entries if current.lower() in entry.title.lower()]
|
||||
return [
|
||||
app_commands.Choice(name=entry.title[:100], value=entry.id)
|
||||
for entry in matches[:AUTOCOMPLETE_LIMIT]
|
||||
]
|
||||
|
||||
@app_commands.command(name="play", description="Odtwórz utwór z YouTube")
|
||||
@app_commands.describe(query="Link YouTube lub zapytanie wyszukiwania")
|
||||
async def play(self, interaction: discord.Interaction, query: str) -> None:
|
||||
if not await self._ensure_voice(interaction):
|
||||
return
|
||||
await interaction.response.defer()
|
||||
try:
|
||||
track = await self._tracks.resolve(query, loop=self.bot.loop)
|
||||
await self._enqueue_and_reply(interaction, track)
|
||||
except Exception as error: # noqa: BLE001
|
||||
logger.error("Komenda /play nie powiodła się: %s", error)
|
||||
await interaction.followup.send(f"Wystąpił błąd: {error}", ephemeral=True)
|
||||
|
||||
@app_commands.command(name="playfile", description="Odtwórz plik przesłany na serwer")
|
||||
@app_commands.describe(filename="Wybierz plik z listy przesłanych")
|
||||
@app_commands.autocomplete(filename=_uploads_autocomplete)
|
||||
async def playfile(self, interaction: discord.Interaction, filename: str) -> None:
|
||||
if not await self._ensure_voice(interaction):
|
||||
return
|
||||
await interaction.response.defer()
|
||||
if not self._uploads.exists(filename):
|
||||
await interaction.followup.send("Nie znaleziono pliku na serwerze.", ephemeral=True)
|
||||
return
|
||||
try:
|
||||
track = await self._tracks.from_file(self._uploads.resolve(filename))
|
||||
await self._enqueue_and_reply(interaction, track)
|
||||
except Exception as error: # noqa: BLE001
|
||||
logger.error("Komenda /playfile nie powiodła się: %s", error)
|
||||
await interaction.followup.send(f"Wystąpił błąd: {error}", ephemeral=True)
|
||||
|
||||
@app_commands.command(name="replay", description="Odtwórz ponownie utwór z historii")
|
||||
@app_commands.describe(track_id="Wybierz utwór z historii odtwarzania")
|
||||
@app_commands.autocomplete(track_id=_history_autocomplete)
|
||||
async def replay(self, interaction: discord.Interaction, track_id: str) -> None:
|
||||
if not await self._ensure_voice(interaction):
|
||||
return
|
||||
await interaction.response.defer()
|
||||
guild_id = interaction.guild.id
|
||||
entries = self.player.history(guild_id)
|
||||
entry = self.player.find_history_entry(guild_id, track_id)
|
||||
if entry is None and track_id.isdigit():
|
||||
position = int(track_id) - 1
|
||||
if 0 <= position < len(entries):
|
||||
entry = entries[position]
|
||||
if entry is None:
|
||||
await interaction.followup.send("Nie znaleziono utworu w historii.", ephemeral=True)
|
||||
return
|
||||
try:
|
||||
if entry.is_local:
|
||||
filepath = entry.replay_source or ""
|
||||
if not self._uploads.exists(filepath):
|
||||
await interaction.followup.send(
|
||||
"Plik lokalny z historii już nie istnieje na serwerze.", ephemeral=True
|
||||
)
|
||||
return
|
||||
track = await self._tracks.from_file(
|
||||
self._uploads.resolve(filepath), title=entry.title
|
||||
)
|
||||
else:
|
||||
track = await self._tracks.from_url(entry.url or "", loop=self.bot.loop)
|
||||
await self._enqueue_and_reply(interaction, track, prefix=" z historii")
|
||||
except Exception as error: # noqa: BLE001
|
||||
logger.error("Komenda /replay nie powiodła się: %s", error)
|
||||
await interaction.followup.send(f"Wystąpił błąd: {error}", ephemeral=True)
|
||||
@@ -0,0 +1,99 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import discord
|
||||
from discord import app_commands
|
||||
from discord.ext import commands
|
||||
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
from zyrarbot.settings import Settings
|
||||
from zyrarbot.ui.bot.cogs.common import MusicCogBase
|
||||
|
||||
QUEUE_PREVIEW_LIMIT = 30
|
||||
HISTORY_PREVIEW_LIMIT = 15
|
||||
AUTOCOMPLETE_LIMIT = 25
|
||||
|
||||
|
||||
class QueueCog(MusicCogBase, name="Queue"):
|
||||
"""Komendy podglądu kolejki i historii odtwarzania."""
|
||||
|
||||
def __init__(self, bot: commands.Bot, player: MusicPlayer, settings: Settings):
|
||||
super().__init__(bot, player)
|
||||
self._settings = settings
|
||||
|
||||
@app_commands.command(name="queue", description="Pokaż aktualną kolejkę")
|
||||
async def show_queue(self, interaction: discord.Interaction) -> None:
|
||||
state = self.player.state(interaction.guild.id)
|
||||
if not state.queue:
|
||||
await interaction.response.send_message("Kolejka jest pusta.", ephemeral=True)
|
||||
return
|
||||
lines: list[str] = []
|
||||
if state.current and not 0 <= state.index < len(state.queue):
|
||||
title = discord.utils.escape_markdown(state.current.title or "")
|
||||
plays = self.player.plays_left(state.current)
|
||||
lines.append(
|
||||
f"▶️ **{title}** (obecnie odtwarzane - ostatnie odtworzenie) [🔁 {plays}]\n---"
|
||||
)
|
||||
for position, track in enumerate(state.queue):
|
||||
is_current = position == state.index
|
||||
prefix = "▶️ **" if is_current else f"{position + 1}. "
|
||||
suffix = "** (obecnie odtwarzane)" if is_current else ""
|
||||
title = discord.utils.escape_markdown(track.title or "")
|
||||
lines.append(f"{prefix}{title}{suffix} [🔁 {self.player.plays_left(track)}]")
|
||||
preview = "\n".join(lines[:QUEUE_PREVIEW_LIMIT])
|
||||
if len(lines) > QUEUE_PREVIEW_LIMIT:
|
||||
preview += f"\n... i {len(lines) - QUEUE_PREVIEW_LIMIT} więcej."
|
||||
await interaction.response.send_message(f"Aktualna kolejka:\n{preview}")
|
||||
|
||||
async def _history_autocomplete(
|
||||
self, interaction: discord.Interaction, current: str
|
||||
) -> list[app_commands.Choice[str]]:
|
||||
entries = self.player.history(interaction.guild.id)
|
||||
matches = [entry for entry in entries if current.lower() in entry.title.lower()]
|
||||
return [
|
||||
app_commands.Choice(name=entry.title[:100], value=entry.id)
|
||||
for entry in matches[:AUTOCOMPLETE_LIMIT]
|
||||
]
|
||||
|
||||
@app_commands.command(
|
||||
name="history", description="Pokaż historię ostatnio odtwarzanych utworów"
|
||||
)
|
||||
async def show_history(self, interaction: discord.Interaction) -> None:
|
||||
entries = self.player.history(interaction.guild.id)
|
||||
if not entries:
|
||||
await interaction.response.send_message(
|
||||
"Historia odtwarzania jest pusta.", ephemeral=True
|
||||
)
|
||||
return
|
||||
listing = "\n".join(
|
||||
f"{position + 1}. {discord.utils.escape_markdown(entry.title)}"
|
||||
for position, entry in enumerate(entries[:HISTORY_PREVIEW_LIMIT])
|
||||
)
|
||||
await interaction.response.send_message(
|
||||
f"📜 Historia odtwarzania (ostatnie {HISTORY_PREVIEW_LIMIT}):\n{listing}"
|
||||
)
|
||||
|
||||
@app_commands.command(
|
||||
name="trackplays", description="Zmień liczbę odtworzeń dla utworu w kolejce"
|
||||
)
|
||||
@app_commands.describe(index="Pozycja w kolejce (od 1)", count="Nowa liczba odtworzeń (1-999)")
|
||||
async def track_plays_command(
|
||||
self, interaction: discord.Interaction, index: int, count: int
|
||||
) -> None:
|
||||
queue = self.player.state(interaction.guild.id).queue
|
||||
if not 1 <= index <= len(queue):
|
||||
await interaction.response.send_message(
|
||||
"❌ Nieprawidłowy numer utworu w kolejce.", ephemeral=True
|
||||
)
|
||||
return
|
||||
if not self._settings.is_valid_plays(count):
|
||||
await interaction.response.send_message(
|
||||
"❌ Liczba odtworzeń musi być z przedziału 1-999.", ephemeral=True
|
||||
)
|
||||
return
|
||||
track = queue[index - 1]
|
||||
track.plays_left = count
|
||||
await self.player.trigger_state_change()
|
||||
title = discord.utils.escape_markdown(track.title or "")
|
||||
await interaction.response.send_message(
|
||||
f"✅ Ustawiono liczbę odtworzeń dla utworu **{title}** na **{count}**."
|
||||
)
|
||||
@@ -0,0 +1,56 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import discord
|
||||
from discord import app_commands
|
||||
from discord.ext import commands
|
||||
|
||||
from zyrarbot.music.loop_mode import LoopMode
|
||||
from zyrarbot.music.music_player import MusicPlayer
|
||||
from zyrarbot.settings import Settings
|
||||
from zyrarbot.ui.bot.cogs.common import MusicCogBase
|
||||
|
||||
|
||||
class SettingsCog(MusicCogBase, name="Settings"):
|
||||
"""Komendy zmieniające ustawienia odtwarzacza."""
|
||||
|
||||
def __init__(self, bot: commands.Bot, player: MusicPlayer, settings: Settings):
|
||||
super().__init__(bot, player)
|
||||
self._settings = settings
|
||||
|
||||
@app_commands.command(
|
||||
name="loop", description="Zmień tryb zapętlania (Wyłączone -> Cała kolejka -> Jeden utwór)"
|
||||
)
|
||||
async def loop_command(self, interaction: discord.Interaction) -> None:
|
||||
mode = self.player.cycle_loop_mode(interaction.guild.id)
|
||||
await self.player.trigger_state_change()
|
||||
await interaction.response.send_message(mode.label)
|
||||
|
||||
@app_commands.command(
|
||||
name="loopplaylist", description="Włącz/wyłącz zapętlanie całej kolejki (tryb playlisty)"
|
||||
)
|
||||
async def loopplaylist_command(self, interaction: discord.Interaction) -> None:
|
||||
guild_id = interaction.guild.id
|
||||
enabled = not self.player.state(guild_id).loop_mode.loops_queue
|
||||
self.player.set_loop_mode(guild_id, LoopMode.QUEUE if enabled else LoopMode.OFF)
|
||||
await self.player.trigger_state_change()
|
||||
description = (
|
||||
"włączone (utwory po zakończeniu wracają na koniec kolejki)" if enabled else "wyłączone"
|
||||
)
|
||||
await interaction.response.send_message(f"🔁 Zapętlanie całej kolejki: **{description}**.")
|
||||
|
||||
@app_commands.command(
|
||||
name="defaultplays",
|
||||
description="Ustaw domyślną liczbę odtworzeń dla nowych utworów w kolejce",
|
||||
)
|
||||
@app_commands.describe(count="Domyślna liczba odtworzeń (1-999)")
|
||||
async def default_plays_command(self, interaction: discord.Interaction, count: int) -> None:
|
||||
if not self._settings.is_valid_plays(count):
|
||||
await interaction.response.send_message(
|
||||
"❌ Liczba odtworzeń musi być z przedziału 1-999.", ephemeral=True
|
||||
)
|
||||
return
|
||||
self.player.set_default_plays(count)
|
||||
await self.player.trigger_state_change()
|
||||
await interaction.response.send_message(
|
||||
f"✅ Domyślna liczba odtworzeń dla nowych utworów została ustawiona na: **{count}**."
|
||||
)
|
||||
@@ -0,0 +1,38 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import discord
|
||||
from discord.ext import commands
|
||||
|
||||
from zyrarbot.ui.bot.cogs.common import MusicCogBase
|
||||
|
||||
|
||||
class VoiceCog(MusicCogBase, name="Voice"):
|
||||
"""Obsługa zdarzeń i rozłączania z kanałów głosowych."""
|
||||
|
||||
@commands.Cog.listener()
|
||||
async def on_voice_state_update(
|
||||
self,
|
||||
member: discord.Member,
|
||||
before: discord.VoiceState,
|
||||
after: discord.VoiceState,
|
||||
) -> None:
|
||||
is_bot_leaving = (
|
||||
self.bot.user
|
||||
and member.id == self.bot.user.id
|
||||
and before.channel is not None
|
||||
and after.channel is None
|
||||
)
|
||||
if is_bot_leaving:
|
||||
self.player.clear(before.channel.guild.id)
|
||||
await self.player.trigger_state_change()
|
||||
|
||||
@discord.app_commands.command(name="leave", description="Odłącz bota od kanału głosowego")
|
||||
async def leave(self, interaction: discord.Interaction) -> None:
|
||||
if interaction.guild.voice_client is None:
|
||||
await interaction.response.send_message(
|
||||
"Nie jestem na kanale głosowym.", ephemeral=True
|
||||
)
|
||||
return
|
||||
await interaction.guild.voice_client.disconnect()
|
||||
self.player.clear(interaction.guild.id)
|
||||
await interaction.response.send_message("Rozłączono z kanału głosowego.")
|
||||
@@ -0,0 +1,26 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import discord
|
||||
from discord.ext import commands
|
||||
|
||||
|
||||
class GuildResolver:
|
||||
"""Ustala kontekst serwera dla panelu webowego, który nie zna interakcji Discorda."""
|
||||
|
||||
def __init__(self, bot: commands.Bot):
|
||||
self._bot = bot
|
||||
|
||||
def active_guild(self) -> discord.Guild | None:
|
||||
"""Serwer z aktywnym połączeniem głosowym, a w razie jego braku - pierwszy znany."""
|
||||
if self._bot.voice_clients:
|
||||
return self._bot.voice_clients[0].guild
|
||||
return self._bot.guilds[0] if self._bot.guilds else None
|
||||
|
||||
def guilds(self) -> list[discord.Guild]:
|
||||
return list(self._bot.guilds)
|
||||
|
||||
def channel(self, channel_id: int) -> discord.abc.GuildChannel | None:
|
||||
return self._bot.get_channel(channel_id)
|
||||
|
||||
def voice_client(self, guild_id: int) -> discord.VoiceClient | None:
|
||||
return discord.utils.get(self._bot.voice_clients, guild__id=guild_id)
|
||||
Reference in new issue
Block a user