wip

Author: Sanielia

pyproject.toml

@@ -7,6 +7,7 @@ dependencies = [
     "discord-py>=2.6.3",
     "dotenv>=0.9.9",
     "fastapi[standard]>=0.117.1",
+    "hikari>=2.4.1",
     "pre-commit>=4.3.0",
     "pytest>=8.4.2",
     "requests>=2.32.5",

src/bot.py

@@ -1,9 +1,8 @@
 import asyncio
 import os
+from hikari import GuildForumChannel, GuildPublicThread, ForumTag, RESTApp
 from copy import deepcopy
-from threading import Lock
 
-import discord
 
 from src.utils.data_types import (
     ProjectItemEditedAssignees,
@@ -14,60 +13,47 @@
     SimpleProjectItemEvent,
 )
 from src.utils.error import ForumChannelNotFound
-from src.utils.utils import add_tag_to_thread, get_post_id, retrieve_discord_id
+from src.utils.utils import get_post_id, retrieve_discord_id
 
+async def run(state: dict[str, bool | list[ProjectItemEvent]]):
+    discord_rest = RESTApp()
+    await discord_rest.start()
 
-class DiscordClient(discord.Client):
-    bg_task: asyncio.Task
-
-    def __init__(self, *, state, lock, **kwargs):
-        super().__init__(**kwargs)
-        self.state: dict[str, bool | list[ProjectItemEvent]] = state
-        self.lock: Lock = lock
-
-    async def on_ready(self):
-        print(f"Logged on as {self.user}!")
-        self.bg_task = self.loop.create_task(self.process_updates())
-
-    async def process_updates(self):
+    async with discord_rest.acquire(os.getenv("DISCORD_TOKEN")) as client:
         forum_channel_id = int(os.getenv("FORUM_CHANNEL_ID"))
-        forum_channel: discord.ForumChannel = self.get_channel(forum_channel_id)
-        if forum_channel is None:
+        forum_channel = await client.fetch_channel(forum_channel_id)
+        if forum_channel is None or not isinstance(forum_channel, GuildForumChannel):
             raise ForumChannelNotFound(f"Forum channel with ID {forum_channel_id} not found.")
-        local_queue_copy: list[ProjectItemEvent] = []
 
-        while True:
-            with self.lock:
-                if self.state["update-received"]:
-                    local_queue_copy = deepcopy(self.state["update-queue"])
-                    self.state["update-queue"].clear()
-                    self.state["update-received"] = False
+        if state["update-received"]:
+            local_queue_copy: list[ProjectItemEvent] = deepcopy(state["update-queue"])
+            state["update-queue"].clear()
+            state["update-received"] = False
 
             for event in local_queue_copy:
-                post_id = await get_post_id(event.name, forum_channel)
+                post_id = await get_post_id(event.name, forum_channel_id, client)
                 author_discord_id = retrieve_discord_id(event.sender)
                 if post_id is None:
                     message = f"Nowy task stworzony {event.name} przez <@{author_discord_id}>"
-                    await forum_channel.create_thread(name=event.name, content=message, auto_archive_duration=10080)
-                    post_id = await get_post_id(event.name, forum_channel)
-                thread: discord.Thread = forum_channel.get_thread(int(post_id)) or await self.fetch_channel(
-                    int(post_id)
-                )
-                if thread is None:
+                    post: GuildPublicThread = await client.create_forum_post(forum_channel, event.name, message, auto_archive_duration=10080)
+                else:
+                    post = await client.fetch_channel(post_id)
+
+                if not isinstance(post, GuildPublicThread):
                     continue
 
                 if isinstance(event, SimpleProjectItemEvent):
                     match event.event_type.value:
                         case "archived":
                             message = f"Task zarchiwizowany przez <@{author_discord_id}>."
-                            await thread.send(message)
-                            await thread.edit(archived=True)
+                            await client.create_message(post.id, message)
+                            await client.edit_channel(post.id, archived=True)
                         case "restored":
                             message = f"Task przywrócony przez <@{author_discord_id}>."
-                            await thread.send(message)
-                            await thread.edit(archived=False)
+                            await client.create_message(post.id, message)
+                            await client.edit_channel(post.id, archived=False)
                         case "deleted":
-                            await thread.delete()
+                            await client.delete_channel(post.id)
                 elif isinstance(event, ProjectItemEditedAssignees):
                     assignee_mentions: list[str] = []
                     if event.new_assignees:
@@ -81,29 +67,34 @@ async def process_updates(self):
                     message = (
                         f"Osoby przypisane do taska edytowane, aktualni przypisani: {', '.join(assignee_mentions)}"
                     )
-                    await thread.send(message)
+                    await client.create_message(post.id, message)
                 elif isinstance(event, ProjectItemEditedBody):
                     message = f"Opis taska zaktualizowany przez <@{author_discord_id}>. Nowy opis: {event.new_body}"
-                    await thread.send(message)
+                    await client.create_message(post.id, message)
                 elif isinstance(event, ProjectItemEditedTitle):
-                    await thread.edit(name=event.new_title)
+                    await client.edit_channel(post.id, name=event.new_title)
                 elif isinstance(event, ProjectItemEditedSingleSelect):
-                    thread_tags = list(thread.applied_tags)
-                    for tag in thread_tags:
-                        if tag.name.startswith(f"{event.value_type.value}: "):
-                            await thread.remove_tags(tag)
+                    current_tag_ids = list(post.applied_tag_ids)
+                    available_tags = list(forum_channel.available_tags)
 
-                    await add_tag_to_thread(
-                        thread, forum_channel, f"{event.value_type.value}: {event.new_value}", event.value_type.value
+                    for tag in available_tags:
+                        if tag.id in current_tag_ids and tag.name.startswith(f"{event.value_type.value}: "):
+                            current_tag_ids.remove(tag.id)
+
+                    new_tag_name = f"{event.value_type.value}: {event.new_value}"
+                    new_tag = next(
+                        (tag for tag in available_tags if tag.name == new_tag_name),
+                        None
                     )
 
-            local_queue_copy.clear()
+                    if new_tag is None:
+                        new_tag = ForumTag(name=new_tag_name)
+                        await client.edit_channel(forum_channel.id, available_tags=available_tags.append(new_tag))
 
-            await asyncio.sleep(1)
+                    current_tag_ids.append(new_tag.id)
 
+                    await client.edit_channel(post.id, applied_tag_ids=current_tag_ids)
 
-def run(state, lock):
-    intents = discord.Intents.default()
+            local_queue_copy.clear()
 
-    client = DiscordClient(intents=intents, state=state, lock=lock)
-    client.run(os.getenv("DISCORD_BOT_TOKEN"))
+            await asyncio.sleep(1)

src/main.py

@@ -7,7 +7,7 @@
 def main():
     dotenv.load_dotenv()
     host, port = os.getenv("IP_ADDRESS", "0.0.0.0:8000").split(":")
-    uvicorn.run("src.server:src", host=host, port=int(port), reload=True)
+    uvicorn.run("src.server:app", host=host, port=int(port), reload=True)
 
 
 if __name__ == "__main__":

src/server.py

@@ -1,5 +1,6 @@
+import asyncio
 import os
-import threading
+from contextlib import asynccontextmanager
 from typing import Any
 
 from fastapi import FastAPI, Request
@@ -18,12 +19,23 @@
 )
 from src.utils.utils import fetch_assignees, fetch_item_name, fetch_single_select_value, get_item_name
 
-app = FastAPI()
 
 state: dict[str, bool | list[ProjectItemEvent]] = {"update-received": False, "update-queue": []}
-lock: threading.Lock = threading.Lock()
-threading.Thread(target=run, args=(state, lock), daemon=True).start()
 
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # startup
+    task = asyncio.create_task(run(state))
+    yield
+    # shutdown
+    task.cancel()
+    try:
+        await task
+    except asyncio.CancelledError:
+        pass
+
+
+app = FastAPI(lifespan=lifespan)
 
 @app.post("/webhook_endpoint")
 async def webhook_endpoint(request: Request):
@@ -49,10 +61,9 @@ async def webhook_endpoint(request: Request):
             body["action"], item_name, body.get("sender", {}).get("login", "Unknown")
         )
 
-    with lock:
-        if project_item_event is not None:
-            state["update-queue"].append(project_item_event)
-            state["update-received"] = True
+    if project_item_event is not None:
+        state["update-queue"].append(project_item_event)
+        state["update-received"] = True
 
     return
 

src/utils/utils.py

@@ -3,7 +3,7 @@
 import shelve
 
 import requests
-from discord import ForumChannel, ForumTag, Thread
+from hikari.impl import RESTClientImpl
 
 
 async def get_item_name(item_node_id: str) -> str | None:
@@ -139,18 +139,18 @@ def fetch_single_select_value(item_node_id: str | None, field_name: str | None)
     return name
 
 
-async def get_post_id(name: str, forum_channel: ForumChannel) -> int | None:
+async def get_post_id(name: str, forum_channel_id: int, rest_client: RESTClientImpl) -> int | None:
     with shelve.open("post_id.db") as db:
         try:
             post_id: str = db[name]
             return int(post_id)
         except KeyError:
             pass
-        for thread in forum_channel.threads:
+        for thread in await rest_client.fetch_active_threads(forum_channel_id):
             if thread.name == name:
                 db[name] = thread.id
                 return thread.id
-        async for thread in forum_channel.archived_threads():
+        for thread in await rest_client.fetch_public_archived_threads(forum_channel_id):
             if thread.name == name:
                 db[name] = thread.id
                 return thread.id
@@ -165,22 +165,3 @@ def retrieve_discord_id(username: str) -> str | None:
         mapping: dict[str, str] = json.loads("".join(file.readlines()))
 
         return mapping.get(username, None)
-
-
-def get_tags_for_single_select_type(section: str, tags: list[ForumTag]) -> list[ForumTag]:
-    tags_for_single_select_type: list[ForumTag] = []
-    for tag in tags:
-        if tag.name.startswith(section + ": "):
-            tags_for_single_select_type.append(tag)
-
-    return tags_for_single_select_type
-
-
-async def add_tag_to_thread(thread: Thread, forum_channel: ForumChannel, tag_name: str, single_select_type: str):
-    tags = get_tags_for_single_select_type(single_select_type, list(forum_channel.available_tags))
-    for tag in tags:
-        if tag.name == tag_name:
-            await thread.add_tags(tag)
-            return
-    await forum_channel.create_tag(name=tag_name)
-    await add_tag_to_thread(thread, forum_channel, tag_name, single_select_type)