Update README.

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

Dockerfile

@@ -1,12 +1,15 @@
-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 ./
+COPY requirements.txt ./
+RUN uv pip install --system --no-cache -r requirements.txt
 
-RUN pip install --no-cache-dir -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`:

main.py

@@ -2,8 +2,8 @@
 """ParkerBot"""
 
 import argparse
-import asyncio
 import datetime
+import html
 import os
 import pickle
 import re
@@ -14,7 +14,7 @@ from google.auth.transport.requests import Request
 from google_auth_oauthlib.flow import InstalledAppFlow
 from googleapiclient.discovery import build
 from googleapiclient import errors
-from nio import AsyncClient, RoomMessageText, SyncResponse, UploadResponse
+from nio import HttpClient, RoomMessageText, SyncResponse, UploadResponse
 
 DATA_DIR = os.getenv("DATA_DIR", "./")
 DB_PATH = os.path.join(DATA_DIR, "parkerbot.sqlite3")
@@ -178,25 +178,40 @@ def add_video_to_playlist(youtube, playlist_id, video_id, retry_count=6):
             raise error
 
 
-def is_music(youtube, video_id):
-    """Check whether a YouTube video is music."""
-    video_details = youtube.videos().list(id=video_id, part="snippet").execute()
+def get_video_info(youtube, video_id):
+    """Check whether a YouTube video is music and return its title and channel."""
+    try:
+        video_details = youtube.videos().list(id=video_id, part="snippet").execute()
 
-    # Check if the video category is Music (typically category ID 10)
-    return video_details["items"][0]["snippet"]["categoryId"] in (
-        "10",  # music
-        "24",  # entertainment
-    )
+        # Check if the video actually exists/is accessible
+        if not video_details.get("items"):
+            return False, "[Video unavailable or private]", ""
+
+        snippet = video_details["items"][0]["snippet"]
+
+        # Check if the video category is Music (10) or Entertainment (24)
+        is_music = snippet.get("categoryId") in ("10", "24")
+        title = snippet.get("title", "[Unknown Title]")
+        channel = snippet.get("channelTitle", "[Unknown Channel]")
+
+        return is_music, title, channel
+
+    except errors.HttpError as error:
+        print(f"YouTube API error fetching info for {video_id}: {error}")
+        return False, "[Error fetching title]", ""
+    except Exception as e:
+        print(f"Unexpected error fetching info for {video_id}: {e}")
+        return False, "[Error fetching title]", ""
 
 
-async def send_intro_message(client, sender, room_id):
+def send_intro_message(client, sender, room_id):
     """Sends introduction message in reply to sender, in room with room_id."""
     intro_message = (
         f"Hi {sender}, I'm ParkerBot! I generate YouTube playlists from links "
         "sent to this channel. You can find my source code here: "
         "https://git.abdulocra.cy/abdulocracy/parkerbot"
     )
-    await client.room_send(
+    client.room_send(
         room_id=room_id,
         message_type="m.room.message",
         content={"msgtype": "m.text", "body": intro_message},
@@ -204,11 +219,11 @@ async def send_intro_message(client, sender, room_id):
 
     # TODO: Figure out how to properly send GIF, this is broken as shit.
     with open("./parker.gif", "rb") as gif_file:
-        response = await client.upload(gif_file, content_type="image/gif")
+        response = client.upload(gif_file, content_type="image/gif")
     if isinstance(response, UploadResponse):
         print("Image was uploaded successfully to server. ")
         gif_uri = response.content_uri
-        await client.room_send(
+        client.room_send(
             room_id=room_id,
             message_type="m.room.message",
             content={
@@ -222,29 +237,29 @@ async def send_intro_message(client, sender, room_id):
         print(f"Failed to upload image. Failure response: {response}")
 
 
-async def send_playlist_of_week(client, sender, room_id, playlist_id):
+def send_playlist_of_week(client, sender, room_id, playlist_id):
     """Sends playlist of the week in reply to sender, in room with room_id."""
     playlist_link = f"https://www.youtube.com/playlist?list={playlist_id}"
     reply_msg = f"{sender}, here's the playlist of the week: {playlist_link}"
-    await client.room_send(
+    client.room_send(
         room_id=room_id,
         message_type="m.room.message",
         content={"msgtype": "m.text", "body": reply_msg},
     )
 
 
-async def send_playlist_of_all(client, sender, room_id, playlist_id):
+def send_playlist_of_all(client, sender, room_id, playlist_id):
     """Sends playlist of all time in reply to sender, in room with room_id."""
     playlist_link = f"https://www.youtube.com/playlist?list={playlist_id}"
     reply_msg = f"{sender}, here's the playlist of all time: {playlist_link}"
-    await client.room_send(
+    client.room_send(
         room_id=room_id,
         message_type="m.room.message",
         content={"msgtype": "m.text", "body": reply_msg},
     )
 
 
-async def message_callback(conn, cursor, youtube, client, room, event):
+def message_callback(conn, cursor, youtube, client, room, event):
     """Event handler for received messages."""
     sender = event.sender
     if sender != MATRIX_USER:
@@ -258,21 +273,24 @@ 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)
-        recent = current_time - timestamp_sec < datetime.timedelta(seconds=30)
+
+        # Account for up to 5 minutes of clock drift
+        recent = abs(current_time - timestamp_sec) < datetime.timedelta(minutes=5)
 
         if body == "!parkerbot" and recent:
-            await send_intro_message(client, sender, room.room_id)
+            send_intro_message(client, sender, room.room_id)
             return
 
         if body == "!week" and recent:
-            await send_playlist_of_week(client, sender, room.room_id, playlist_id)
+            send_playlist_of_week(client, sender, room.room_id, playlist_id)
             return
 
         if body == "!all" and recent:
-            await send_playlist_of_all(client, sender, room.room_id, all_playlist_id)
+            send_playlist_of_all(client, sender, room.room_id, all_playlist_id)
             return
 
         youtube_link_pattern = (
@@ -283,7 +301,36 @@ async def message_callback(conn, cursor, youtube, client, room, event):
 
         for link in youtube_links:
             video_id = link.split("v=")[-1].split("&")[0].split("/")[-1]
-            if is_music(youtube, video_id):
+
+            # Safely fetch the category check, title, and channel
+            is_music_vid, title, channel = get_video_info(youtube, video_id)
+
+            # 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}"
+                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>"
+                )
+
+                client.room_send(
+                    room_id=room.room_id,
+                    message_type="m.room.message",
+                    content={
+                        "msgtype": "m.text",
+                        "body": plain_text,
+                        "format": "org.matrix.custom.html",
+                        "formatted_body": html_text,
+                    },
+                )
+
+            # Only add to the playlist if it's categorized as music/entertainment
+            if is_music_vid:
                 message_id = record_message(conn, cursor, sender, link, timestamp)
                 if in_playlist(cursor, video_id, playlist_id):
                     print(f"Track is already in this week's playlist: {link}")
@@ -335,7 +382,7 @@ def record_message(conn, cursor, sender, link, timestamp):
     return cursor.fetchone()[0]
 
 
-async def sync_callback(response):
+def sync_callback(response):
     """Saves Matrix sync token."""
     with open(TOKEN_PATH, "w", encoding="utf-8") as f:
         f.write(response.next_batch)
@@ -350,9 +397,9 @@ def load_sync_token():
         return None
 
 
-async def get_client(conn, cursor, youtube):
+def get_client(conn, cursor, youtube):
     """Returns configured and logged in Matrix client."""
-    client = AsyncClient(MATRIX_SERVER, MATRIX_USER)
+    client = HttpClient(MATRIX_SERVER, MATRIX_USER)
     client.add_event_callback(
         lambda room, event: message_callback(
             conn, cursor, youtube, client, room, event
@@ -360,23 +407,23 @@ async def get_client(conn, cursor, youtube):
         RoomMessageText,
     )
     client.add_response_callback(sync_callback, SyncResponse)
-    print(await client.login(MATRIX_PASSWORD))
+    print(client.login(MATRIX_PASSWORD))
     return client
 
 
-async def backwards_sync(conn, cursor, youtube, client, room, start_token):
+def backwards_sync(conn, cursor, youtube, client, room, start_token):
     """Fetch and process historical messages from a given room."""
     print("Starting to process channel log...")
     from_token = start_token
     room_id = room.room_id
     while True:
         # Fetch room messages
-        response = await client.room_messages(room_id, from_token, direction="b")
+        response = client.room_messages(room_id, from_token, direction="b")
 
         # Process each message
         for event in response.chunk:
             if isinstance(event, RoomMessageText):
-                await message_callback(conn, cursor, youtube, client, room, event)
+                message_callback(conn, cursor, youtube, client, room, event)
 
         # Break if there are no more messages to fetch
         if not response.end or response.end == from_token:
@@ -386,23 +433,30 @@ async def backwards_sync(conn, cursor, youtube, client, room, start_token):
         from_token = response.end
 
 
-async def main():
+def main():
     """Get DB and Matrix client ready, and start syncing."""
     args = parse_arguments()
     conn, cursor = connect_db()
     define_tables(conn, cursor)
     youtube = get_authenticated_service()
-    client = await get_client(conn, cursor, youtube)
+    client = get_client(conn, cursor, youtube)
     sync_token = load_sync_token()
 
     # This is incredibly dumb and most probably will exceed your YouTube API quota.
     if args.backwards_sync:
-        init_sync = await client.sync(30000)
-        room = await client.room_resolve_alias(MATRIX_ROOM)
-        await backwards_sync(conn, cursor, youtube, client, room, init_sync.next_batch)
+        init_sync = client.sync(30000)
+        room = client.room_resolve_alias(MATRIX_ROOM)
+        backwards_sync(conn, cursor, youtube, client, room, init_sync.next_batch)
 
-    await client.sync_forever(30000, full_state=True, since=sync_token)
+    print("Started syncing...")
+    while True:
+        try:
+            client.sync(timeout=30000, full_state=True, since=sync_token)
+            sync_token = load_sync_token()
+        except Exception as e:
+            print(f"Sync error: {e}")
+            time.sleep(5)
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    main()

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