Preparation for new year of PIC

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.14-slim
+
+# Copy your code
+WORKDIR /app
+RUN pip install --no-cache-dir discord asyncio requests
+
+COPY main.py .
+COPY PICable.py .
+
+# Drop privileges (optional but good practice)
+RUN useradd -m appuser
+USER appuser
+
+# Start the scheduler script
+CMD ["python", "main.py"]

README.md

@@ -1,2 +1,3 @@
 # PICable
+
 Simple script to determine if a project is eligible as the final PIC of LEIC-T.

docker-compose.yml

@@ -0,0 +1,8 @@
+services:
+  picable:
+    build: .
+    container_name: picable
+    environment:
+      - PICABLE_DISCORD_TOKEN=yourdiscordtoken
+      - PICABLE_GITHUB_TOKEN=yourgithubtoken
+    restart: unless-stopped

main.py

@@ -1,5 +1,6 @@
 from asyncio import Condition, Lock, create_task, shield, to_thread, wait_for
 from sys import argv
+from os import getenv
 
 import requests
 from discord import Game, Intents, Interaction, app_commands
@@ -8,107 +9,108 @@ from discord.ext import commands
 from PICable import PICable
 
 MAX_STORAGE_KB = 10 * 1024 * 1024  # 10GB
-current_storage_kb = 0
-storage_condition = Condition()
-current_repositories = set()
-current_repositories_lock = Lock()
 
-if len(argv) != 3:
+if __name__ == "__main__":
-    print("Usage:\n\t" + argv[0] + " <discord_token> <github_token>")
+    current_storage_kb = 0
-    exit(1)
+    storage_condition = Condition()
-discord_token = argv[1]
+    current_repositories = set()
-github_token = argv[2]
+    current_repositories_lock = Lock()
 
-intents = Intents.default()
+    discord_token = getenv("PICABLE_DISCORD_TOKEN")
-intents.message_content = True
+    github_token = getenv("PICABLE_GITHUB_TOKEN")
-client = commands.Bot(command_prefix="/", intents=intents)
+
+    if not discord_token or not github_token:
+        print("Discord or Github tokens not set in env. Use variables PICABLE_DISCORD_TOKEN and PICABLE_GITHUB_TOKEN")
+        exit(1)
+
+    intents = Intents.default()
+    intents.message_content = True
+    client = commands.Bot(command_prefix="/", intents=intents)
+    client.run(discord_token)
 
 
-@client.event
+    @client.event
-async def on_ready():
+    async def on_ready():
-    print(f"We have logged in as {client.user}")
+        print(f"We have logged in as {client.user}")
-    await client.change_presence(activity=Game("with PIC ideas"))
+        await client.change_presence(activity=Game("with PIC ideas"))
-    try:
+        try:
-        synced = await client.tree.sync()
+            synced = await client.tree.sync()
-        print(f"Synced {len(synced)} command(s)")
+            print(f"Synced {len(synced)} command(s)")
-    except Exception as e:
+        except Exception as e:
-        print(f"Failed to sync commands: {e}")
+            print(f"Failed to sync commands: {e}")
 
 
-@client.tree.command(name="ping", description="Check the bot's latency.")
+    @client.tree.command(name="ping", description="Check the bot's latency.")
-async def ping(interaction: Interaction):
+    async def ping(interaction: Interaction):
-    latency = client.latency * 1000
+        latency = client.latency * 1000
-    await interaction.response.send_message(f"Pong! Latency: {latency:.2f}ms")
+        await interaction.response.send_message(f"Pong! Latency: {latency:.2f}ms")
 
 
-async def handle_picable(owner: str, repository: str, repository_size_kb: int, github_token: str):
+    async def handle_picable(owner: str, repository: str, repository_size_kb: int, github_token: str):
-    global current_storage_kb
+        global current_storage_kb
-    async with storage_condition:
+        async with storage_condition:
-        await storage_condition.wait_for(lambda: current_storage_kb + repository_size_kb <= MAX_STORAGE_KB)
+            await storage_condition.wait_for(lambda: current_storage_kb + repository_size_kb <= MAX_STORAGE_KB)
-        current_storage_kb += repository_size_kb
+            current_storage_kb += repository_size_kb
 
-    print(f"Storage is {current_storage_kb / MAX_STORAGE_KB * 100:.2f}% full.")
+        print(f"Storage is {current_storage_kb / MAX_STORAGE_KB * 100:.2f}% full.")
-    return await to_thread(PICable, owner, repository, github_token)
+        return await to_thread(PICable, owner, repository, github_token)
 
 
-@client.tree.command(name="picable", description="Check if a Github repository is eligible for PIC.")
+    @client.tree.command(name="picable", description="Check if a Github repository is eligible for PIC.")
-@app_commands.describe(owner="The owner of the repository", repository="The name of the repository")
+    @app_commands.describe(owner="The owner of the repository", repository="The name of the repository")
-async def picable(interaction: Interaction, owner: str, repository: str):
+    async def picable(interaction: Interaction, owner: str, repository: str):
-    await interaction.response.defer(thinking=True)
+        await interaction.response.defer(thinking=True)
 
-    repository_full_name = f"{owner}/{repository}"
+        repository_full_name = f"{owner}/{repository}"
-    async with current_repositories_lock:
+        async with current_repositories_lock:
-        if repository_full_name in current_repositories:
+            if repository_full_name in current_repositories:
+                await interaction.followup.send(
+                    f"The repository {repository_full_name} is already being analyzed. Please wait for the current analysis to complete. :warning:"
+                )
+                return
+
+            current_repositories.add(repository_full_name)
+
+        url = f"https://api.github.com/repos/{owner}/{repository}"
+        headers = {"Authorization": f"token {github_token}"}
+        response = requests.get(url, headers=headers)
+
+        if not response.status_code == 200:
             await interaction.followup.send(
-                f"The repository {repository_full_name} is already being analyzed. Please wait for the current analysis to complete. :warning:"
+                f"Invalid Repository. Please check the repository name and owner and try again. :x:"
             )
             return
 
-        current_repositories.add(repository_full_name)
+        response.raise_for_status()
+        repo_info = response.json()
+        repository_size_kb = repo_info["size"]
+        print(f"Repository size: {repository_size_kb / 1024} MB")
 
-    url = f"https://api.github.com/repos/{owner}/{repository}"
+        if repository_size_kb > MAX_STORAGE_KB:
-    headers = {"Authorization": f"token {github_token}"}
-    response = requests.get(url, headers=headers)
-
-    if not response.status_code == 200:
-        await interaction.followup.send(
-            f"Invalid Repository. Please check the repository name and owner and try again. :x:"
-        )
-        return
-
-    response.raise_for_status()
-    repo_info = response.json()
-    repository_size_kb = repo_info["size"]
-    print(f"Repository size: {repository_size_kb / 1024} MB")
-
-    if repository_size_kb > MAX_STORAGE_KB:
-        await interaction.followup.send(
-            f"The repository {repository_full_name} is too large to analyze. Please try a smaller repository. :warning:"
-        )
-        current_repositories.remove(repository_full_name)
-        return
-
-    global current_storage_kb
-    try:
-        result_future = create_task(handle_picable(owner, repository, repository_size_kb, github_token))
-        try:
-            result = await wait_for(shield(result_future), timeout=600)
-            await interaction.followup.send(result)
-        except TimeoutError:
             await interaction.followup.send(
-                f"The analysis for {repository_full_name} is still taking place. The results will be posted here once the analysis is complete. :clock4:"
+                f"The repository {repository_full_name} is too large to analyze. Please try a smaller repository. :warning:"
             )
-            result = await result_future
-            await interaction.channel.send(f"{interaction.user.mention}\n{result}")
-    except Exception as e:
-        print(f"Error processing PICable check: {e}")
-        await interaction.channel.send("An error occurred while processing your request. Please try again later.")
-    finally:
-        async with current_repositories_lock:
             current_repositories.remove(repository_full_name)
-        async with storage_condition:
+            return
-            current_storage_kb -= repository_size_kb
-            storage_condition.notify_all()
 
-
+        global current_storage_kb
-client.run(discord_token)
+        try:
+            result_future = create_task(handle_picable(owner, repository, repository_size_kb, github_token))
+            try:
+                result = await wait_for(shield(result_future), timeout=600)
+                await interaction.followup.send(result)
+            except TimeoutError:
+                await interaction.followup.send(
+                    f"The analysis for {repository_full_name} is still taking place. The results will be posted here once the analysis is complete. :clock4:"
+                )
+                result = await result_future
+                await interaction.channel.send(f"{interaction.user.mention}\n{result}")
+        except Exception as e:
+            print(f"Error processing PICable check: {e}")
+            await interaction.channel.send("An error occurred while processing your request. Please try again later.")
+        finally:
+            async with current_repositories_lock:
+                current_repositories.remove(repository_full_name)
+            async with storage_condition:
+                current_storage_kb -= repository_size_kb
+                storage_condition.notify_all()

run.sh

@@ -1 +0,0 @@
-python3 main.py MTM0MzMzNzAzMzkyOTU4ODg5MA.Gx2pEq.uLdXFORUFlYurLUF6Lnsuh_EWFQRI8SAKFebDM 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