Radio station track uploads.

revert Switch to synchronous Python.

Signed-off-by: Abdulkadir Furkan Şanlı <me@abdulocra.cy>

Dockerfile

@@ -1,12 +1,19 @@
-FROM python:3
+FROM python:3.14
+
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
 
 ENV PYTHONUNBUFFERED=1
 
 WORKDIR /usr/src/app
 
-COPY main.py parker.gif requirements.txt ./
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends curl ffmpeg yt-dlp && \
+    rm -rf /var/lib/apt/lists/*
 
-RUN pip install --no-cache-dir -r requirements.txt
+COPY requirements.txt ./
+RUN uv pip install --system --no-cache -r requirements.txt
+
+COPY main.py parker.gif ./
 
 USER 1000:1000
 

README.md

@@ -1,16 +1,17 @@
 # ParkerBot
 
 ParkerBot is a Matrix bot that monitors a channel for YouTube links and
-generates weekly playlists from them.
+generates weekly playlists from them. It also sends YouTube link titles to the
+channel it's in.
 
 ## Running locally
 
 1. Clone the repo
 2. Install the dependencies, preferably in a venv:
    ```shell
-   python3 -m venv venv
-   source ./venv/bin/activate
-   pip3 install -r requirements.txt
+   uv venv --python 3.14 --seed
+   source .venv/bin/activate
+   uv pip install -r requirements.txt
    ```
 3. Copy [example.env](example.env) to `.env`, customize it.
 4. Source `.env`:

example.env

@@ -12,3 +12,9 @@ MATRIX_PASSWORD = ""
 YOUTUBE_PLAYLIST_TITLE = ""
 # YouTube API client secret json path.
 YOUTUBE_CLIENT_SECRETS_FILE = ""
+# AzuraCast API key.
+AZURACAST_API_KEY = ""
+# AzuraCast API URL.
+AZURACAST_URL = ""
+# AzuraCast station ID.
+AZURACAST_STATION_ID = ""

main.py

@@ -4,7 +4,9 @@
 import argparse
 import asyncio
 import datetime
+import glob
 import html
+import json
 import os
 import pickle
 import re
@@ -30,6 +32,10 @@ MATRIX_PASSWORD = os.getenv("MATRIX_PASSWORD")
 YOUTUBE_CLIENT_SECRETS_FILE = os.getenv("YOUTUBE_CLIENT_SECRETS_FILE")
 YOUTUBE_PLAYLIST_TITLE = os.getenv("YOUTUBE_PLAYLIST_TITLE")
 
+AZURACAST_API_KEY = os.getenv("AZURACAST_API_KEY")
+AZURACAST_URL = os.getenv("AZURACAST_URL")
+AZURACAST_STATION_ID = os.getenv("AZURACAST_STATION_ID")
+
 
 def connect_db():
     """Connect to DB and return connection and cursor."""
@@ -274,7 +280,8 @@ async def message_callback(conn, cursor, youtube, client, room, event):
         )
 
         timestamp_sec = datetime.datetime.fromtimestamp(
-            event.server_timestamp / 1000, datetime.UTC  # millisec to sec
+            event.server_timestamp / 1000,
+            datetime.UTC,  # millisec to sec
         )
         current_time = datetime.datetime.now(datetime.UTC)
 
@@ -308,13 +315,15 @@ async def message_callback(conn, cursor, youtube, client, room, event):
             # Send the title to the channel so people know what the link is
             # Only do this for recent messages to prevent spam during backwards-sync
             if recent:
-                plain_text = f"🎵 {title}"
+                plain_text = f"{title}"
                 if channel:
                     plain_text += f" - {channel}"
 
                 # Escape HTML characters to prevent broken rendering in Matrix
                 escaped_text = html.escape(plain_text)
-                html_text = f"<em><span data-mx-color='#808080'>{escaped_text}</span></em>"
+                html_text = (
+                    f"<em><span data-mx-color='#808080'>{escaped_text}</span></em>"
+                )
 
                 await client.room_send(
                     room_id=room.room_id,
@@ -323,7 +332,7 @@ async def message_callback(conn, cursor, youtube, client, room, event):
                         "msgtype": "m.text",
                         "body": plain_text,
                         "format": "org.matrix.custom.html",
-                        "formatted_body": html_text
+                        "formatted_body": html_text,
                     },
                 )
 
@@ -345,6 +354,8 @@ async def message_callback(conn, cursor, youtube, client, room, event):
                             (playlist_id, message_id, video_id),
                         )
                     print(f"Added track to this week's playlist: {link}")
+                    if recent:
+                        asyncio.create_task(process_radio_track(link, video_id, title))
 
 
 def in_playlist(cursor, video_id, playlist_id):
@@ -431,6 +442,93 @@ async def backwards_sync(conn, cursor, youtube, client, room, start_token):
         from_token = response.end
 
 
+async def process_radio_track(video_link, video_id, title):
+    """Downloads native audio and pushes it to AzuraCast API in the background."""
+    if not AZURACAST_API_KEY:
+        return
+
+    # Sanitize title for the local filesystem
+    safe_title = "".join(c for c in title if c.isalnum() or c in " -_").strip()
+    base_filename = f"{safe_title}_{video_id}"
+    base_filepath = os.path.join(DATA_DIR, base_filename)
+
+    print(f"📻 Downloading audio for radio: {title}")
+
+    # 1. Download with yt-dlp (Keeping native AAC/Opus format)
+    dl_cmd = [
+        "yt-dlp",
+        "--extract-audio",
+        "--output",
+        f"{base_filepath}.%(ext)s",
+        video_link,
+    ]
+
+    process = await asyncio.create_subprocess_exec(
+        *dl_cmd, stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.DEVNULL
+    )
+    await process.communicate()
+
+    # Check for the file using glob since the extension (.m4a, .webm, .opus) is dynamic
+    downloaded_files = glob.glob(f"{base_filepath}.*")
+
+    if not downloaded_files:
+        print(f"❌ Failed to download audio for {title}")
+        return
+
+    filepath = downloaded_files[0]
+
+    print(f"📻 Uploading to AzuraCast: {title}")
+
+    # 2. Upload to AzuraCast using curl
+    upload_cmd = [
+        "curl",
+        "-s",
+        "-X",
+        "POST",
+        f"{AZURACAST_URL}/api/station/{AZURACAST_STATION_ID}/files",
+        "-H",
+        f"X-API-Key: {AZURACAST_API_KEY}",
+        "-F",
+        f"file=@{filepath}",
+    ]
+
+    curl_proc = await asyncio.create_subprocess_exec(
+        *upload_cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+    )
+    stdout, _ = await curl_proc.communicate()
+
+    # 3. Extract unique_id and push to the live queue
+    try:
+        response = json.loads(stdout.decode())
+        unique_id = response.get("unique_id")
+
+        if unique_id:
+            req_cmd = [
+                "curl",
+                "-s",
+                "-X",
+                "POST",
+                f"{AZURACAST_URL}/api/station/{AZURACAST_STATION_ID}/request/{unique_id}",
+                "-H",
+                f"X-API-Key: {AZURACAST_API_KEY}",
+            ]
+            req_proc = await asyncio.create_subprocess_exec(
+                *req_cmd,
+                stdout=asyncio.subprocess.DEVNULL,
+                stderr=asyncio.subprocess.DEVNULL,
+            )
+            await req_proc.communicate()
+            print(f"✅ Queued on radio: {title}")
+        else:
+            print(f"⚠️ Uploaded, but no unique_id returned. Response: {stdout.decode()}")
+    except json.JSONDecodeError:
+        print(f"❌ Failed to parse AzuraCast response: {stdout.decode()}")
+
+    # Cleanup the local file so your container doesn't bloat
+    if os.path.exists(filepath):
+        os.remove(filepath)
+
+
 async def main():
     """Get DB and Matrix client ready, and start syncing."""
     args = parse_arguments()

requirements.txt

@@ -1,3 +1,3 @@
 matrix-nio == 0.24.0
-google-auth-oauthlib
-google-api-python-client
+google-auth-oauthlib == 1.3.1
+google-api-python-client == 2.194.0