Legacy remove

sa
aaa
2026-07-16 14:52:11 +00:00 · 2025-10-29 13:54:58 +01:00 · 2025-08-23 17:53:08 +02:00 · 2025-08-23 17:49:47 +02:00 · 2025-08-23 17:44:08 +02:00 · 2025-08-23 16:20:16 +02:00
19 changed files with 291 additions and 1231 deletions
@@ -1,32 +0,0 @@
 # Python
 __pycache__
 *.py[cod]
 *.pyo
 *.pyd
 *.so
 # VCS/CI
 .git
 .gitignore
 .gitattributes
 .github
 # Editor
 .vscode
 .idea
 # Python tooling
 .pytest_cache
 .mypy_cache
 .ruff_cache
 .tox
 dist
 build
 *.egg-info
 # Local assets
 logs
 music
 data
 *.env
 *.env.*
@@ -1,23 +1,2 @@
 # conjurer
 Discord.py bot for fun, sex and BDSM
 ## Docker quick start
 Docker definitions live at the repository root and let you run the Discord bot
 (`thin_client.py`), the musician file service, and the librarian search worker as
 separate containers.
 1. **Prepare configuration**
   - Edit the environment files under `docker/env/*.env` and replace the
     placeholders (`replace-me`, `shared-secret`, etc.) with your real tokens.
     Keep `CONJURER_API_KEY` identical across all services.
 2. **Create host directories** listed in `docker-compose.yml` (for example
   `docker/volumes/bot/config`, `docker/volumes/musician/data`, …) and populate
   them with the required JSON settings or media assets.
 3. **Launch the stack**
   ```bash
   docker compose up --build
   ```
 Logs for each container are mounted under `docker/volumes/*` so you can diff the
 runtime JSON and log files in git if needed.
@@ -1,14 +1,12 @@
 import json
 import logging
 import os
 import re
 import threading
 import time
 from queue import Empty, Queue
 from typing import Optional
 from urllib import request as urequest
-from flask import Flask, abort, jsonify, request
+from flask import Flask, jsonify, request
 from waitress import serve
 HOST_ADDRESS = "192.168.1.191"
@@ -33,13 +31,6 @@ PREPPED_TRACKS = {
 }
 logger = logging.getLogger("discord")
 API_KEY = os.getenv("CONJURER_API_KEY")
 def _authorize_request() -> None:
    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
        abort(401)
 class QueryControl:
    """
@@ -62,7 +53,6 @@ class QueryControl:
@app.route("/prepped_tracks", methods=["POST"])
 def log_radio_tracks():
    _authorize_request()
    app.logger = logging.getLogger("discord")
    app.logger.info(request)
@@ -89,7 +79,6 @@ def log_radio_tracks():
@app.route("/conjurer", methods=["POST"])
 def answer_external_command():
    _authorize_request()
    """
    The function `answer_external_command` logs the request data, loads the data as JSON, logs the
    record, and then puts the record into an incoming queue before returning a success message.
@@ -140,7 +129,7 @@ def waitress_run():
    serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS)
-def scan_queue(stop_event: Optional[threading.Event] = None):
+def scan_queue():
    """
    The function `scan_queue` reads data from a queue, logs it, and appends it to another queue.
@@ -151,18 +140,12 @@ def scan_queue(stop_event: Optional[threading.Event] = None):
    """
    logger = logging.getLogger("discord")
    while True:
-        if stop_event and stop_event.is_set():
+        data = OUT_COMM_Q.get()
            logger.info("scan_queue: stop requested")
            break
        try:
            data = OUT_COMM_Q.get(timeout=1)
        except Empty:
            continue
        logger.info(data)
        awaiting_q.append(data)
-def scan_incoming(stop_event: Optional[threading.Event] = None):
+def scan_incoming():
    """
    The `scan_incoming` function continuously checks for incoming data, processes it, and logs when data
    is found.
@@ -174,9 +157,6 @@ def scan_incoming(stop_event: Optional[threading.Event] = None):
    """
    logger = logging.getLogger("discord")
    while True:
        if stop_event and stop_event.is_set():
            logger.info("scan_incoming: stop requested")
            break
        try:
            answer = incoming_q.get(block=False)
            logger.info("DATA FOUND")
@@ -224,7 +204,7 @@ def id3(url: str) -> dict:
        return tagdata
-def comm_subroutine(stop_event: Optional[threading.Event] = None):
+def comm_subroutine():
    """
    The `comm_subroutine` function starts multiple threads to run different tasks concurrently.
@@ -237,27 +217,14 @@ def comm_subroutine(stop_event: Optional[threading.Event] = None):
    logger.info("Started comms")
    threads = []
    # threads.append(threading.Thread(target=flask_debug))
-    threads.append(
+    threads.append(threading.Thread(target=waitress_run))
-        threading.Thread(target=waitress_run, daemon=True)
+    threads.append(threading.Thread(target=scan_queue))
-    )
+    threads.append(threading.Thread(target=scan_incoming))
    threads.append(
        threading.Thread(target=scan_queue, kwargs={"stop_event": stop_event}, daemon=True)
    )
    threads.append(
        threading.Thread(target=scan_incoming, kwargs={"stop_event": stop_event}, daemon=True)
    )
    for worker in threads:
        worker.start()
-
+    for worker in threads:
-    try:
+        worker.join()
        while any(thread.is_alive() for thread in threads):
            if stop_event and stop_event.is_set():
                break
            time.sleep(0.5)
    finally:
        if stop_event:
            stop_event.set()
 if __name__ == "__main__":
@@ -16,52 +16,34 @@ Functions:
 import asyncio
 import json
 import logging
-import os
+import netrc
 import threading
 import time
 from json.decoder import JSONDecodeError
 from logging import handlers
 from pathlib import Path
 from queue import Queue
 from typing import Dict, Optional
 import requests
 import scrape_bot
 import search_bot
-# import search_bot2 as search_bot
+#import search_bot2 as search_bot
-from flask import Flask, jsonify, request, abort
+from flask import Flask, jsonify, request
 from habanero import Crossref
 from waitress import serve
 try:
    import netrc
 except ImportError:  # pragma: no cover
    netrc = None
 # Constants
 NETRC_FILE = r"C:\Users\Activcom.pl\.netrc"
 HOST_ADDRESS = "192.168.1.192"
 PORT_ADDRESS = 5001
 MAIN_BOT_ADDRESS = "http://192.168.1.191:5000"
 SEND_RESULTS = "/conjurer"
 BDSM_UUID_TEST = "96b7f85a-1142-4908-8986-62a2ea25a147"
 MAX_CR_RESULTS = 500
 #TEST PURPOSES ONLY!
 #MAX_CR_RESULTS = 5
-def _env(name: str, default: str) -> str:
+ENCODING = "utf-8"
    return os.getenv(name, default)
 def _env_path(name: str, default: str) -> Path:
    return Path(os.getenv(name, default)).expanduser().resolve()
 BASE_DIR = Path(
    os.getenv("CONJURER_LIBRARIAN_BASE", str(Path(__file__).resolve().parent))
 )
 NETRC_FILE = _env_path("CONJURER_NETRC_FILE", str(Path.home() / ".netrc"))
 HOST_ADDRESS = _env("CONJURER_LIBRARIAN_HOST", "0.0.0.0")
 PORT_ADDRESS = int(_env("CONJURER_LIBRARIAN_PORT", "5001"))
 MAIN_BOT_ADDRESS = _env("CONJURER_MAIN_BOT", "http://127.0.0.1:5000")
 SEND_RESULTS = _env("CONJURER_LIBRARIAN_RESULTS_ENDPOINT", "/conjurer")
 MAX_CR_RESULTS = int(_env("CONJURER_LIBRARIAN_MAX_RESULTS", "500"))
 ENCODING = _env("CONJURER_ENCODING", "utf-8")
 API_KEY = os.getenv("CONJURER_API_KEY")
 LOGFILE_PATH = _env_path(
    "CONJURER_LIBRARIAN_LOG", str(BASE_DIR / "librarian.log")
 )
 app = Flask(__name__)
@@ -69,17 +51,6 @@ librarian_queue = Queue()
 librarian_list = []
 def _service_headers() -> Dict[str, str]:
    if API_KEY:
        return {"X-Conjurer-Api-Key": API_KEY}
    return {}
 def _authorize_request() -> None:
    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
        abort(401)
 # trunk-ignore(pylint/R0902)
 class Librarian(object):
    """
@@ -110,24 +81,11 @@ class Librarian(object):
        - search_result_from_cr: A dictionary to store the search results from Crossref.
        - done: A flag indicating if the search is done.
        """
-        mailto_contact: Optional[str] = os.getenv("CONJURER_CROSSREF_MAILTO")
+        netrc_mod = netrc.netrc(NETRC_FILE)
-        if netrc:
+        auth_tokens = netrc_mod.authenticators("crossref")
            try:
                netrc_mod = netrc.netrc(str(NETRC_FILE))
                auth_tokens = netrc_mod.authenticators("crossref")
                if auth_tokens:
                    mailto_contact = auth_tokens[0]
            except (FileNotFoundError, netrc.NetrcParseError):
                logging.getLogger("conjurer_librarian").warning(
                    "Crossref credentials missing in netrc %s", NETRC_FILE
                )
        if not mailto_contact:
            raise RuntimeError(
                "Crossref credentials not configured. Set CONJURER_CROSSREF_MAILTO or add to netrc."
            )
        self.cr = Crossref(
-            mailto=mailto_contact,
+            mailto=auth_tokens[0],
-            ua_string=f"Conjurer project. mailto:{mailto_contact}"
+            ua_string=f"Conjurer project. mailto:{auth_tokens[0]}"
        )
        self.query = query
        self.uuid = str(uuid)
@@ -174,7 +132,7 @@ class Librarian(object):
                self.fetched = len(cr_result["message"]["items"])
                self.app.logger.info(self.total)
                self.app.logger.info(self.fetched)
-                await asyncio.sleep(0.1)
+                time.sleep(0.1)
        else:
            cr_result = self.cr.works(query=query, cursor_max=15000, cursor='*', progress_bar = True)
@@ -453,20 +411,18 @@ class BackgroundTaskSearch(threading.Thread):
                requests.post,
                f"{MAIN_BOT_ADDRESS}{SEND_RESULTS}",
                json=result,
                headers=_service_headers(),
                timeout=360,
            )
            self.app.logger.info("SENT")
            result = await coroutine
            self.app.logger.info(result.status_code)
            self.app.logger.info("SEND CONFIRMED")
-            await asyncio.sleep(1)
+            time.sleep(1)
 # ==================================SERVER ROUTES==========================================
@app.route("/query", methods=["POST"])
 async def query_database():
    _authorize_request()
    """
    Endpoint for querying the database.
@@ -499,7 +455,6 @@ async def query_database():
@app.route("/get_partial_result", methods=["POST"])
 async def get_partial():
    _authorize_request()
    """
    Retrieves the partial result for a given UUID.
@@ -523,10 +478,9 @@ async def get_partial():
 # =======================================MAIN===================================================
 if __name__ == "__main__":
    app.logger.setLevel(logging.DEBUG)
    LOGFILE_PATH.parent.mkdir(parents=True, exist_ok=True)
    h1 = handlers.RotatingFileHandler(
-        filename=str(LOGFILE_PATH),
+        filename="D:\\logs\\librarian.log",
-        encoding=ENCODING,
+        encoding="utf-8",
        mode="a",
        maxBytes=6 * 1024 * 1024,
        backupCount=6,
@@ -534,24 +488,20 @@ if __name__ == "__main__":
    app.logger.addHandler(h1)
    threads = []
-    threads.append(threading.Thread(target=waitress_run, daemon=True))
+    threads.append(threading.Thread(target=waitress_run))
    # threads.append(threading.Thread(target=flask_debug))
    bgtask = BackgroundTaskSearch()
    bgtask.app = app
    bgtask.daemon = True
    threads.append(bgtask)
-    threads.append(
+    threads.append(threading.Thread(target=scrape_bot.scraper, args=(app.logger,)))
        threading.Thread(
            target=scrape_bot.scraper, args=(app.logger,), daemon=True
        )
    )
    i = 0
-    try:
+    for worker in threads:
-        for worker in threads:
+        try:
            app.logger.info("App number: %s", i)
            i += 1
            worker.start()
-        for worker in threads:
+        except RuntimeError as e:
-            worker.join()
+            app.logger.error("Exploded")
-    except KeyboardInterrupt:
+            print(str(e))
-        app.logger.info("Shutdown requested - exiting librarian service")
+    for worker in threads:
        worker.join()
@@ -11,15 +11,17 @@ import random
 import re
 import threading
 import time
 # from flask_autoindex import AutoIndex
 from datetime import datetime
 from logging import handlers
 from pathlib import Path
-from typing import Dict, List
+from platform import uname
 from sys import platform
 import requests
 from flask import (
    Flask,
    abort,
    jsonify,
    redirect,
    render_template,
@@ -27,99 +29,37 @@ from flask import (
    send_from_directory,
 )
 from waitress import serve
 import media_search_functions
-def _env(name: str, default: str) -> str:
+MAIN_BOT_ADDRESS = "http://192.168.1.191:5000"
-    return os.getenv(name, default)
+MUSIC_TRACKER = "/prepped_tracks"
 HOST_ADDRESS = "192.168.1.15"
 PORT_ADDRESS = 5000
 if platform in ("linux", "linux2"):
    SEPARATOR_FILE_PATH = "/"
    if "microsoft-standard" in uname().release:
        LOGFILE = "/home/mtuszowski/conjurer/discord_mus_service.log"
        MUSIC_FOLDER = "/mnt/g/Muzyka/"
        NETRC_FILE = "/home/mtuszowski/.netrc"
        LOGSTORE = "/home/mtuszowski/conjurer/logs/"
        ENCODING = "utf-8"
        RADIOLOG_PATH = "/home/pi/Conjurer/radio_log.log"
        PERSISTENCE_PATH = "/home/pi/Conjurer/persistence.log"
-
+    else:
-def _env_path(name: str, default: str) -> Path:
+        LOGFILE = "/home/pi/Conjurer/discord_mus_service.log"
-    value = os.getenv(name, default)
+        NETRC_FILE = "/home/pi/.netrc"
-    return Path(value).expanduser().resolve()
+        LOGSTORE = "/home/pi/MediaFolder/logs/"
-
+        ENCODING = "utf-8"
-
+        MUSIC_FOLDER = "/home/pi/MediaFolder/mp3/"
-API_KEY = os.getenv("CONJURER_API_KEY")
+        PRIORITY_FOLDER = "/home/pi/MediaFoldermp3/Magiczne i chuj/"
-MAIN_BOT_ADDRESS = _env("CONJURER_MAIN_BOT", "http://127.0.0.1:5000")
+        RADIOLOG_PATH = "/home/pi/Conjurer/radio_log.log"
-MUSIC_TRACKER = _env("CONJURER_MUSIC_TRACKER_ENDPOINT", "/prepped_tracks")
+        PERSISTENCE_PATH = "/home/pi/Conjurer/persistence.log"
 HOST_ADDRESS = _env("CONJURER_MUSICIAN_HOST", "0.0.0.0")
 PORT_ADDRESS = int(_env("CONJURER_MUSICIAN_PORT", "5000"))
 BASE_DIR = Path(
    os.getenv("CONJURER_MUSICIAN_BASE", str(Path(__file__).resolve().parent))
 )
 LOGFILE = _env_path(
    "CONJURER_MUSICIAN_LOG", str(BASE_DIR / "discord_mus_service.log")
 )
 LOGSTORE = _env_path("CONJURER_LOGSTORE", str(BASE_DIR / "logs"))
 MUSIC_FOLDER = _env_path(
    "CONJURER_MUSIC_FOLDER", str(BASE_DIR / "music")
 )
 PRIORITY_FOLDER = _env_path(
    "CONJURER_PRIORITY_FOLDER", str(MUSIC_FOLDER / "priority")
 )
 RADIOLOG_PATH = _env_path(
    "CONJURER_RADIO_LOG", str(BASE_DIR / "radio_log.log")
 )
 PERSISTENCE_PATH = _env_path(
    "CONJURER_PERSISTENCE_LOG", str(BASE_DIR / "persistence.log")
 )
 ALL_PLAYLIST_PATH = _env_path(
    "CONJURER_ALL_PLAYLIST", str(BASE_DIR / "all_playlist.playlist")
 )
 HIT_PLAYLIST_PATH = _env_path(
    "CONJURER_HIT_PLAYLIST", str(BASE_DIR / "hit.playlist")
 )
 REQUEST_PLAYLIST_PATH = _env_path(
    "CONJURER_REQUEST_PLAYLIST", str(BASE_DIR / "request.playlist")
 )
 PRIORITY_PLAYLIST_PATH = _env_path(
    "CONJURER_PRIORITY_PLAYLIST", str(BASE_DIR / "priority_queue.playlist")
 )
 STREAM_TEMPLATE = _env_path(
    "CONJURER_STREAM_TEMPLATE", str(BASE_DIR / "stream.html")
 )
 ENCODING = _env("CONJURER_ENCODING", "utf-8")
 SEPARATOR_FILE_PATH = os.sep
 for playlist_path in (
    ALL_PLAYLIST_PATH,
    HIT_PLAYLIST_PATH,
    REQUEST_PLAYLIST_PATH,
    PRIORITY_PLAYLIST_PATH,
 ):
    playlist_path.parent.mkdir(parents=True, exist_ok=True)
 random.seed()
-music_file_list: List[str] = []
+music_file_list = []
-priority_list: List[str] = []
+priority_list = []
 def _build_headers() -> Dict[str, str]:
    headers: Dict[str, str] = {}
    if API_KEY:
        headers["X-Conjurer-Api-Key"] = API_KEY
    return headers
 def _authorize_request() -> None:
    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
        abort(401)
 def _post_to_bot(payload: List[str]) -> None:
    response = requests.post(
        f"{MAIN_BOT_ADDRESS}{MUSIC_TRACKER}",
        json=payload,
        headers=_build_headers(),
        timeout=60,
    )
    logger = logging.getLogger("conjurer_musician")
    logger.info("SENT")
    logger.info(response.status_code)
    logger.info("SEND CONFIRMED")
 def rescan():
@@ -130,29 +70,28 @@ def rescan():
    logger = logging.getLogger("conjurer_musician")
    logger.info("Rescan triggered")
-    music_file_list.clear()
+    for mp3_item in Path.glob(Path(MUSIC_FOLDER), "**/*.mp3"):
    priority_list.clear()
    for mp3_item in MUSIC_FOLDER.glob("**/*.mp3"):
        temp_music_file = mp3_item.as_posix()
-        if os.name == "nt":
+        if platform == "win32":
            temp_music_file = temp_music_file.replace("/", "\\")
        music_file_list.append(temp_music_file)
-    for mp3_item in PRIORITY_FOLDER.glob("**/*.mp3"):
+    for mp3_item in Path.glob(Path(PRIORITY_FOLDER), "**/*.mp3"):
        temp_music_file = mp3_item.as_posix()
-        if os.name == "nt":
+        if platform == "win32":
            temp_music_file = temp_music_file.replace("/", "\\")
        priority_list.append(temp_music_file)
-    with ALL_PLAYLIST_PATH.open("w", encoding=ENCODING) as w_file:
+    with open(
        "/home/pi/Conjurer/all_playlist.playlist", "w", encoding="utf-8"
    ) as w_file:
        try:
            for item in music_file_list:
                w_file.write(item)
                w_file.write("\n")
        except json.JSONDecodeError:
            pass
-    with HIT_PLAYLIST_PATH.open("w", encoding=ENCODING) as w_file:
+    with open("/home/pi/Conjurer/hit.playlist", "w", encoding="utf-8") as w_file:
        try:
            for item in priority_list:
                w_file.write(item)
@@ -177,50 +116,72 @@ def thread_rescan():
 def scan_tracks():
    # Set the filename and open the file
    logger = logging.getLogger("conjurer_musician")
    with open(RADIOLOG_PATH, "r", encoding=ENCODING) as log_file:
        log_file.seek(os.stat(RADIOLOG_PATH).st_size)
        prev_size = os.stat(PERSISTENCE_PATH).st_size
-        while True:
+    file = open(RADIOLOG_PATH, "r")
-            current_size = os.stat(PERSISTENCE_PATH).st_size
+    # Find the size of the file and move to the end
-            if prev_size != current_size:
+    st_results = os.stat(RADIOLOG_PATH)
-                while prev_size != current_size:
+    st_size = st_results[6]
-                    prev_size = current_size
+    file.seek(st_size)
-                    time.sleep(0.1)
+    st_results1 = os.stat(PERSISTENCE_PATH)
-                    current_size = os.stat(PERSISTENCE_PATH).st_size
+    prev_st_size1 = st_results[6]
                with open(PERSISTENCE_PATH, "r", encoding=ENCODING) as persistence:
                    lines = persistence.readlines()
                if len(lines) >= 3:
                    _post_to_bot(["next", lines[2]])
-            position = log_file.tell()
+    while 1:
            line = log_file.readline()
            if not line:
                time.sleep(1)
                log_file.seek(position)
                continue
-            if not re.match(r".*Prepared.*", line):
+        st_results1 = os.stat(PERSISTENCE_PATH)
        st_size1 = st_results1[6]
        if prev_st_size1 != st_size1:
            while prev_st_size1 != st_size1:
                prev_st_size1 = st_size1
                st_results1 = os.stat(PERSISTENCE_PATH)
                st_size1 = st_results1[6]
                time.sleep(0.1)
-                continue
+            file1 = open(PERSISTENCE_PATH, "r")
            lines = file1.readlines()
            result = ["next", lines[2]]
            file1.close()
            returned = requests.post(
                f"{MAIN_BOT_ADDRESS}{MUSIC_TRACKER}", json=result, timeout=360
            )
            logger.info("SENT")
            logger.info(returned.status_code)
            logger.info("SEND CONFIRMED")
-            result = None
+        where = file.tell()
-            if re.match(r".*jingles.*", line):
+        line = file.readline()
-                result = ["jingles", line]
+        if not line:
-            elif re.match(r".*priority.*", line):
+            time.sleep(1)
-                result = ["priority", line]
+            file.seek(where)
-            elif re.match(r".*hit.*", line):
+        else:
-                result = ["hit", line]
+            if re.match(".*Prepared.*", line):
-            elif re.match(r".*all_playlist.*", line):
+                result = None
-                result = ["all", line]
+                if re.match(".*jingles.*", line):
-            elif re.match(r".*request.*", line):
+                    logger.info("jingles")
-                result = ["requests", line]
+                    logger.info(line)  # already has newline
-
+                    result = ["jingles", line]
-            if result:
+                elif re.match(".*priority.*", line):
-                logger.info("Forwarding radio log entry: %s", result[0])
+                    logger.info("priority")
-                _post_to_bot(result)
+                    logger.info(line)  # already has newline
-
+                    result = ["priority", line]
-            time.sleep(0.1)
+                elif re.match(".*hit.*", line):
                    logger.info("hit")
                    logger.info(line)  # already has newline
                    result = ["hit", line]
                elif re.match(".*all_playlist.*", line):
                    logger.info("all")
                    logger.info(line)  # already has newline
                    result = ["all", line]
                elif re.match(".*request.*", line):
                    logger.info("requests")
                    logger.info(line)  # already has newline
                    result = ["requests", line]
                if result:
                    returned = requests.post(
                        f"{MAIN_BOT_ADDRESS}{MUSIC_TRACKER}", json=result, timeout=360
                    )
                    logger.info("SENT")
                    logger.info(returned.status_code)
                    logger.info("SEND CONFIRMED")
        time.sleep(0.1)
 app = Flask(__name__)
@@ -329,8 +290,12 @@ def wyszukaj(word_list, how_many, _logger=None, return_to_bot=True):
            if search_weight[itr][0] == item_to_search:
                return_list.append(search_weight[itr])
                if not return_to_bot:
-                    with PRIORITY_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
+                    with open(
-                        s_file.write(search_weight[itr][1] + "\n")
+                        "/home/pi/Conjurer/priority_queue.playlist",
                        "r+",
                        encoding="utf-8",
                    ) as s_file:
                        s_file.write(search_weight[itr][1])
                break
            itr += 1
    else:
@@ -371,7 +336,6 @@ def remove_characters(string, character):
@app.route('/get_share_list', methods=['POST'])
 def get_share_list():
    _authorize_request()
    data = request.get_json()
    entries = data.get('entries')
    keywords = data.get('keywords')
@@ -388,7 +352,6 @@ def get_share_list():
@app.route('/get_share_links', methods=['POST'])
 def get_share_links():
    _authorize_request()
    data = request.get_json()
    file_paths = data.get('file_paths')
    # Validate file_paths list
@@ -411,7 +374,7 @@ def stream_music():
    """
    # return send_from_directory("/tmp/hls", "stream.m3u8")
-    return render_template(str(STREAM_TEMPLATE))
+    return render_template("/home/pi/Conjurer/stream.html")
@app.route("/<string:file_name>")
@@ -443,14 +406,15 @@ def stream_music_mp3():
@app.route("/clear_pr_pls", methods=["GET"])
 def clear_pr_pls():
    _authorize_request()
    """
    The function `clear_pr_pls` clears the contents of the priority queue playlist file.
    :return: A JSON response indicating the success of the operation.
    """
    app.logger.info("CLEARING PLAYLIST")
-    with PRIORITY_PLAYLIST_PATH.open("w", encoding=ENCODING) as cleared_pl:
+    with open(
        "/home/pi/Conjurer/priority_queue.playlist", "w", encoding="utf-8"
    ) as cleared_pl:
        cleared_pl.write("")
    return_data = jsonify(isError=False, message="Success", statusCode=200, data=[])
@@ -478,7 +442,6 @@ def update_music_list():
    received and added to the `music_file_list`.
    The status code returned is 200, indicating a successful response.
    """
    _authorize_request()
    record = json.loads(request.data)
    app.logger.info(record["item"])
    music_file_list.append(record["item"])
@@ -500,7 +463,6 @@ def look_for_playlist():
             data that was received and added to the `music_file_list`. The status code returned is 200,
             indicating a successful response.
    """
    _authorize_request()
    record = json.loads(request.data)
    app.logger.info(record)
    app.logger.info(record["lista_slow"])
@@ -519,14 +481,13 @@ def look_for_playlist():
@app.route("/request_radio_file", methods=["POST"])
 def add_request():
    _authorize_request()
    record = json.loads(request.data)
    app.logger.info(record)
    app.logger.info(record["lista_slow"])
    app.logger.info(record["UUID"])
    return_data = wyszukaj(record["lista_slow"], 0, app.logger, False)
-    with REQUEST_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
+    with open("/home/pi/Conjurer/request.playlist", "a", encoding="utf-8") as s_file:
        for item in return_data:
            s_file.write(item[1] + "\n")
    return_data = (
@@ -551,7 +512,6 @@ def create_priority_playlist():
        data that was received and added to the `music_file_list`.
        The status code returned is 200,indicating a successful response.
    """
    _authorize_request()
    record = json.loads(request.data)
    app.logger.info(record)
    app.logger.info(record["lista_slow"])
@@ -561,7 +521,7 @@ def create_priority_playlist():
        record["lista_slow"], record["dlugosc_plejlisty"], app.logger, False
    )
    random.shuffle(return_data)
-    with REQUEST_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
+    with open("/home/pi/Conjurer/request.playlist", "a", encoding="utf-8") as s_file:
        for item in return_data:
            s_file.write(item[1] + "\n")
    return_data = (
@@ -586,7 +546,6 @@ def add_to_priority():
        data that was received and added to the `music_file_list`.
        The status code returned is 200,indicating a successful response.
    """
    _authorize_request()
    record = json.loads(request.data)
    app.logger.info(record)
    app.logger.info(record["lista_slow"])
@@ -595,7 +554,9 @@ def add_to_priority():
    return_data = wyszukaj(
        record["lista_slow"], record["dlugosc_plejlisty"], app.logger, False
    )
-    with PRIORITY_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
+    with open(
        "/home/pi/Conjurer/priority_queue.playlist", "a", encoding="utf-8"
    ) as s_file:
        for item in return_data:
            s_file.write(item[1] + "\n")
    return_data = (
@@ -654,19 +615,15 @@ if __name__ == "__main__":
    logger.info("Started")
    threads = []
    # threads.append(threading.Thread(target=flask_debug))
-    threads.append(threading.Thread(target=waitress_run, daemon=True))
+    threads.append(threading.Thread(target=waitress_run))
-    threads.append(threading.Thread(target=thread_rescan, daemon=True))
+    threads.append(threading.Thread(target=thread_rescan))
    for worker in threads:
        worker.start()
    time.sleep(60)
-    track_thread = threading.Thread(target=scan_tracks, daemon=True)
+    threads.append(threading.Thread(target=scan_tracks))
-    track_thread.start()
+    threads[2].start()
-    try:
+    for worker in threads:
-        for worker in threads:
+        worker.join()
            worker.join()
        track_thread.join()
    except KeyboardInterrupt:
        logger.info("Shutdown requested - exiting musician service")
@@ -1,36 +1,13 @@
 """Centralised configuration and runtime constants for Conjurer services.
 This module used to perform heavy filesystem and credential reads at import
 time which made the project brittle on hosts that did not mirror the original
 paths.  The current implementation defers that work, reads configuration from
 environment variables (with sensible fallbacks), and protects optional
 dependencies so the main bot can start even when a secondary service is
 offline.
 """
 import json
-import logging
+import netrc
 import os
 from datetime import datetime
-from pathlib import Path
+from platform import uname
-from typing import Dict, List, Optional, Tuple, TypedDict
+from sys import platform
 from typing import List, Optional, TypedDict
-try:
+import openai
-    import netrc
+import spotipy
-except ImportError:  # pragma: no cover - standard on CPython
+from spotipy.oauth2 import SpotifyClientCredentials
    netrc = None
 try:
    import openai
 except ImportError:  # pragma: no cover - optional at runtime
    openai = None
 try:
    import spotipy
    from spotipy.oauth2 import SpotifyClientCredentials
 except ImportError:  # pragma: no cover - optional component
    spotipy = None
    SpotifyClientCredentials = None
 Music_Config = TypedDict(
    "Music_Config",
@@ -47,43 +24,21 @@ MASTER_TIMEOUT = datetime.now()
 INITIAL_TIME_WAIT = 500
 MUZYKA: Music_Config = {"ctx": None, "queue": [], "requester": []}
-logger = logging.getLogger("discord")
+LOGFILE = ""
-
+NETRC_FILE = ""
-
+MUSIC_FOLDER = ""
-def _env_path(var_name: str, fallback: Path) -> Path:
+MEMORY_FIVE_SIARA = ""
-    value = os.getenv(var_name)
+MEMORY_FIVE_MUZYKA = ""
-    if value:
+SETTINGS_FILE = ""
-        return Path(value).expanduser().resolve()
+ENCODING = ""
-    return fallback
+GRAPHICS_PATH = ""
 def _env(var_name: str, fallback: str) -> str:
    return os.getenv(var_name, fallback)
 BASE_DIR = Path(os.getenv("CONJURER_BASE_DIR", Path(__file__).resolve().parent))
 LOGFILE = _env_path("CONJURER_LOG_FILE", BASE_DIR / "discord.log")
 NETRC_FILE = _env_path("CONJURER_NETRC_FILE", Path.home() / ".netrc")
 SETTINGS_FILE = _env_path("CONJURER_SETTINGS_FILE", BASE_DIR / "settings.json")
 MEMORY_FIVE_SIARA = _env_path("CONJURER_MEMORY_FILE", BASE_DIR / "pamiec.json")
 MEMORY_FIVE_MUZYKA = _env_path(
    "CONJURER_MUSIC_MEMORY_FILE", BASE_DIR / "pamiec_muzyki.json"
 )
 GRAPHICS_PATH = _env_path(
    "CONJURER_GRAPHICS_PATH", BASE_DIR / "Conjurer_graphics"
 )
 MUSIC_FOLDER = _env_path("CONJURER_MUSIC_FOLDER", BASE_DIR / "music")
 ENCODING = _env("CONJURER_ENCODING", "utf-8")
 API_SHARED_KEY = os.getenv("CONJURER_API_KEY", "")
 MUZYKA_MOJEGO_LUDU_HISTORIA = 1500
 MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE = 15
 MUZYKA_MOJEGO_LUDU_PLAJLISTA = 30
-FILE_SERVICE_ADDRESS = _env("CONJURER_FILE_SERVICE", "http://127.0.0.1:5000")
+FILE_SERVICE_ADDRESS = "http://192.168.1.15:5000"
-RADIO_HARBOR_ADDRESS = _env("CONJURER_RADIO_HARBOR", "http://127.0.0.1:54321")
+RADIO_HARBOR_ADDRESS = "http://192.168.1.15:54321"
-SKIP_TRACK = _env("CONJURER_SKIP_ENDPOINT", "/skip")
+SKIP_TRACK = "/skip"
 GET_MP3 = "/mp3"
 SEND_MP3 = "/update_mp3"
@@ -93,123 +48,98 @@ CREATE_PRIO_PLAYLIST = "/create_priority_playlist"
 REQUEST_MUSIC = "/request_radio_file"
 CLEAR_PRIO = "/clear_pr_pls"
-LIBRARIAN_SERVICE_ADDRESS = _env(
+LIBRARIAN_SERVICE_ADDRESS = "http://192.168.1.192:5001"
-    "CONJURER_LIBRARIAN_SERVICE", "http://127.0.0.1:5001"
+SEND_QUERY = "/query"
 )
 SEND_QUERY = _env("CONJURER_LIBRARIAN_QUERY_ENDPOINT", "/query")
 TIME_BETWEEN_CALLS = 100000
 LAST_SPONTANEOUS_CALL = datetime.now()
-HOST_ADDRESS = _env("CONJURER_DISCORD_HOST", "0.0.0.0")
+HOST_ADDRESS = "192.168.1.191"
-PORT_ADDRESS = int(_env("CONJURER_DISCORD_PORT", "5000"))
+PORT_ADDRESS = 5000
 # *=========================================== Platform Specific Predefines
-SEPARATOR_FILE_PATH = _env("CONJURER_PATH_SEPARATOR", os.sep)
+if platform in ("linux", "linux2"):
    SEPARATOR_FILE_PATH = "/"
    if "microsoft-standard" in uname().release:
        LOGFILE = "/home/mtuszowski/conjurer/discord.log"
        MEMORY_FIVE_SIARA = "/home/mtuszowski/conjurer/pamiec.json"
        SYSTEM_GPT_SETTINGS = "/home/mtuszowski/conjurer/system_gpt_settings.json"
        MEMORY_FIVE_MUZYKA = "/home/mtuszowski/conjurer/pamiec_muzyki.json"
        MUSIC_FOLDER = "/mnt/g/Muzyka/"
        SETTINGS_FILE = "/home/mtuszowski/conjurer/settings.json"
        NETRC_FILE = "/home/mtuszowski/.netrc"
        LOGSTORE = "/home/mtuszowski/conjurer/logs/"
        ACCIDENT_LOG = "/home/mtuszowski/conjurer/accident_log.json"
        ENCODING = "utf-8"
        GRAPHICS_PATH = "/home/mtuszowski/conjurer/Conjurer_graphics/"
        DIR_PATH_SADOX = "/mnt/c/Users/mtusz/OneDrive/Dokumenty/Fansadox"
 DIR_PATH_SADOX = _env_path(
    "CONJURER_SADOX_DIR", BASE_DIR / "Fansadox"
 )
 SYSTEM_GPT_SETTINGS = _env_path(
    "CONJURER_SYSTEM_GPT_SETTINGS", BASE_DIR / "system_gpt_settings.json"
 )
 LOGSTORE = _env_path("CONJURER_LOGSTORE", BASE_DIR / "logs")
 ACCIDENT_LOG = _env_path(
    "CONJURER_ACCIDENT_LOG", BASE_DIR / "accident_log.json"
 )
 def _load_json(path: Path, fallback) -> object:
    try:
        with path.open("r", encoding=ENCODING) as handle:
            return json.load(handle)
    except FileNotFoundError:
        logger.warning("Missing JSON file at %s – using fallback", path)
        return fallback
    except json.JSONDecodeError:
        logger.warning("Corrupt JSON at %s – resetting to fallback", path)
        return fallback
 DATA = _load_json(SETTINGS_FILE, {})
 WORD_REACTIONS = DATA.get("word_reactions", {})
 CYCLIC_WORDS = DATA.get("cyclic_words", {})
 for key in WORD_REACTIONS:
    if isinstance(WORD_REACTIONS[key], list) and len(WORD_REACTIONS[key]) >= 3:
        WORD_REACTIONS[key][2] = datetime.now()
 MESSAGE_TABLE = _load_json(MEMORY_FIVE_SIARA, {})
 GPT_SETTINGS = _load_json(SYSTEM_GPT_SETTINGS, {})
 MESSAGE_TABLE_MUZYKA = _load_json(MEMORY_FIVE_MUZYKA, {})
 SPECJALNE_ZIEMNIACZKI = GPT_SETTINGS[1] if isinstance(GPT_SETTINGS, list) else {}
 ASSISTANTS: Dict[str, Tuple[str, str, int, object]] = {}
 def _load_netrc_credentials(host: str) -> Optional[Tuple[str, str, str]]:
    if netrc is None:
        return None
    try:
        parsed = netrc.netrc(str(NETRC_FILE))
    except FileNotFoundError:
        logger.warning("netrc file %s not found", NETRC_FILE)
        return None
    except netrc.NetrcParseError:
        logger.warning("netrc file %s is invalid", NETRC_FILE)
        return None
    return parsed.authenticators(host)
 def _resolve_token(host: str, env_var: str) -> Optional[str]:
    env_value = os.getenv(env_var)
    if env_value:
        return env_value
    creds = _load_netrc_credentials(host)
    if creds:
        return creds[2]
    logger.warning("Token for %s not configured", host)
    return None
 OPENAI_API_KEY = _resolve_token("openai", "OPENAI_API_KEY")
 if openai and OPENAI_API_KEY:
    openai.api_key = OPENAI_API_KEY
    OPENAICLIENT = openai.AsyncOpenAI(api_key=OPENAI_API_KEY)
 else:
    OPENAICLIENT = None
 TOKEN = _resolve_token("discord", "DISCORD_TOKEN")
 if spotipy:
    spotify_creds = _load_netrc_credentials("spotipy")
    if spotify_creds and SpotifyClientCredentials:
        SPOTIFY_CTRL = spotipy.Spotify(
            client_credentials_manager=SpotifyClientCredentials(
                client_id=spotify_creds[0],
                client_secret=spotify_creds[2],
            )
        )
    else:
-        SPOTIFY_CTRL = None
+        LOGFILE = "/home/pi/Conjurer/discord.log"
-else:
+        MEMORY_FIVE_SIARA = "/home/pi/Conjurer/pamiec.json"
-    SPOTIFY_CTRL = None
+        SYSTEM_GPT_SETTINGS = "/home/pi/Conjurer/system_gpt_settings.json"
-
+        MEMORY_FIVE_MUZYKA = "/home/pi/Conjurer/pamiec_muzyki.json"
-youtube_creds = _load_netrc_credentials("youtube")
+        MUSIC_FOLDER = "/home/pi/MediaShare/mp3/"
-if youtube_creds:
+        SETTINGS_FILE = "/home/pi/Conjurer/settings.json"
-    YOUTUBE_AUTH = [youtube_creds[0], youtube_creds[2]]
+        NETRC_FILE = "/home/pi/.netrc"
-else:
+        LOGSTORE = "/home/pi/MediaShara/logs/"
-    YOUTUBE_AUTH = [
+        ACCIDENT_LOG = "/home/pi/Conjurer/accident_log.json"
-            os.getenv("YOUTUBE_USERNAME", ""),
+        ENCODING = "utf-8"
-            os.getenv("YOUTUBE_PASSWORD", ""),
+        GRAPHICS_PATH = "/home/pi/MediaShare/Conjurer_graphics/"
-        ]
+        DIR_PATH_SADOX = "/home/pi/MediaShare/Fansadox/"
-def service_headers() -> Dict[str, str]:
+elif platform == "win32":
-    """Shared header dict for internal HTTP calls."""
+    LOGFILE = "discord.log"
-    if API_SHARED_KEY:
+    MEMORY_FIVE_SIARA = "pamiec.json"
-        return {"X-Conjurer-Api-Key": API_SHARED_KEY}
+    SYSTEM_GPT_SETTINGS = "system_gpt_settings.json"
-    return {}
+    MEMORY_FIVE_MUZYKA = "pamiec_muzyki.json"
    MUSIC_FOLDER = "G:\\Muzyka\\"
    SETTINGS_FILE = "settings.json"
    NETRC_FILE = "C:\\Users\\mtusz\\.netrc"
    LOGSTORE = "C:\\Users\\mtusz\\OneDrive\\Pulpit\\Conjurer\\logs\\"
    ACCIDENT_LOG = "accident_log.json"
    ENCODING = "utf-8"
    DIR_PATH_SADOX = "C:\\Users\\mtusz\\OneDrive\\Dokumenty\\Fansadox\\"
    SEPARATOR_FILE_PATH = "\\"
 with open(SETTINGS_FILE, "r", encoding=ENCODING) as f_settings_file:
    DATA = json.load(f_settings_file)
 REMOTE_HOST_NAME = "openai"
 netrc_mod = netrc.netrc(NETRC_FILE)
 authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME)
 openai.api_key = authTokens[2]
 OPENAICLIENT = openai.AsyncOpenAI(api_key=openai.api_key)
 REMOTE_HOST_NAME = "discord"
 authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME)
 TOKEN = authTokens[2]
 REMOTE_HOST_NAME = "spotipy"
 authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME)
 SPOTIFY_CTRL = spotipy.Spotify(
    client_credentials_manager=SpotifyClientCredentials(
        client_id=authTokens[0],
        client_secret=authTokens[2],
    )
 )
 REMOTE_HOST_NAME = "youtube"
 authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME)
 YOUTUBE_AUTH = [authTokens[0],authTokens[2]]
 WORD_REACTIONS = DATA["word_reactions"]
 CYCLIC_WORDS = DATA["cyclic_words"]
 for key in WORD_REACTIONS:
    WORD_REACTIONS[key][2] = datetime.now()
 with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as temp_memory_file:
    # First we load existing data into a dict.
    MESSAGE_TABLE = json.load(temp_memory_file)
 with open(SYSTEM_GPT_SETTINGS, "r+", encoding=ENCODING) as temp_settings_file:
    # First we load existing data into a dict.
    GPT_SETTINGS = json.load(temp_settings_file)
 with open(MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING) as temp_music_memory_file:
    # First we load existing data into a dict.
    MESSAGE_TABLE_MUZYKA = json.load(temp_music_memory_file)
 SPECJALNE_ZIEMNIACZKI = GPT_SETTINGS[1]
 ASSISTANTS = {}
 LATEX_TEX_ENGINE = "tectonic"
@@ -1,45 +0,0 @@
 version: "3.9"
 services:
  bot:
    build:
      context: .
      dockerfile: docker/Dockerfile.bot
    container_name: conjurer-bot
    env_file:
      - docker/env/bot.env
    volumes:
      - ./docker/volumes/bot/config:/data/config
      - ./docker/volumes/bot/logs:/data/logs
    depends_on:
      - musician
      - librarian
    restart: unless-stopped
    ports:
      - "5000:5000"
  musician:
    build:
      context: .
      dockerfile: docker/Dockerfile.musician
    container_name: conjurer-musician
    env_file:
      - docker/env/musician.env
    volumes:
      - ./docker/volumes/musician/data:/data
    restart: unless-stopped
    ports:
      - "5001:5000"
  librarian:
    build:
      context: .
      dockerfile: docker/Dockerfile.librarian
    container_name: conjurer-librarian
    env_file:
      - docker/env/librarian.env
    volumes:
      - ./docker/volumes/librarian/data:/data
    restart: unless-stopped
    ports:
      - "5002:5001"
@@ -1,23 +0,0 @@
 FROM python:3.11-slim
 ENV PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=1
 RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        ffmpeg \
    && rm -rf /var/lib/apt/lists/*
 WORKDIR /app
 COPY requirements_bot.txt /tmp/requirements.txt
 RUN pip install -r /tmp/requirements.txt
 COPY . /app
 RUN useradd --create-home appuser \
    && chown -R appuser:appuser /app
 USER appuser
 CMD ["python", "thin_client.py"]
@@ -1,24 +0,0 @@
 FROM python:3.11-slim
 ENV PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=1
 RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        build-essential \
        poppler-utils \
    && rm -rf /var/lib/apt/lists/*
 WORKDIR /app
 COPY conjurer_librarian/requirements_librarian.txt /tmp/requirements.txt
 RUN pip install -r /tmp/requirements.txt
 COPY . /app
 RUN useradd --create-home appuser \
    && chown -R appuser:appuser /app
 USER appuser
 CMD ["python", "-m", "conjurer_librarian.conjurer_librarian"]
@@ -1,23 +0,0 @@
 FROM python:3.11-slim
 ENV PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=1
 RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        ffmpeg \
    && rm -rf /var/lib/apt/lists/*
 WORKDIR /app
 COPY requirements_bot.txt /tmp/requirements.txt
 RUN pip install -r /tmp/requirements.txt
 COPY . /app
 RUN useradd --create-home appuser \
    && chown -R appuser:appuser /app
 USER appuser
 CMD ["python", "-m", "conjurer_musician.conjurer_musician"]
@@ -1,24 +0,0 @@
 # Discord bot service configuration
 DISCORD_TOKEN=HACKME!
 OPENAI_API_KEY=HACKME!
 CONJURER_API_KEY=HACKME!
 # Internal service endpoints
 CONJURER_FILE_SERVICE=http://conjurer-musician:5000
 CONJURER_LIBRARIAN_SERVICE=http://conjurer-librarian:5001
 # Runtime paths mounted via docker-compose volumes
 CONJURER_BASE_DIR=/data/config
 CONJURER_SETTINGS_FILE=/data/config/settings.json
 CONJURER_MEMORY_FILE=/data/config/pamiec.json
 CONJURER_MUSIC_MEMORY_FILE=/data/config/pamiec_muzyki.json
 CONJURER_SYSTEM_GPT_SETTINGS=/data/config/system_gpt_settings.json
 CONJURER_GRAPHICS_PATH=/data/assets/graphics
 CONJURER_LOG_FILE=/data/logs/discord.log
 CONJURER_LOGSTORE=/data/logs
 # Optional external integrations
 CONJURER_NETRC_FILE=/data/secrets/.netrc
 YOUTUBE_USERNAME=HACKME!
 YOUTUBE_PASSWORD=HACKME!
@@ -1,14 +0,0 @@
 # Librarian service configuration
 CONJURER_API_KEY=HACKME!
 CONJURER_MAIN_BOT=http://conjurer-bot:5000
 CONJURER_LIBRARIAN_HOST=0.0.0.0
 CONJURER_LIBRARIAN_PORT=5001
 CONJURER_LIBRARIAN_MAX_RESULTS=500
 CONJURER_CROSSREF_MAILTO=HACKME!
 CONJURER_LIBRARIAN_LOG=/data/logs/librarian.log
 CONJURER_NETRC_FILE=/data/secrets/.netrc
@@ -1,20 +0,0 @@
 # Musician service configuration
 CONJURER_API_KEY=HACKME!
 CONJURER_MAIN_BOT=http://conjurer-bot:5000
 CONJURER_MUSIC_TRACKER_ENDPOINT=/prepped_tracks
 CONJURER_MUSICIAN_HOST=0.0.0.0
 CONJURER_MUSICIAN_PORT=5000
 CONJURER_MUSIC_FOLDER=/data/music
 CONJURER_PRIORITY_FOLDER=/data/priority
 CONJURER_ALL_PLAYLIST=/data/playlists/all_playlist.playlist
 CONJURER_HIT_PLAYLIST=/data/playlists/hit.playlist
 CONJURER_REQUEST_PLAYLIST=/data/playlists/request.playlist
 CONJURER_PRIORITY_PLAYLIST=/data/playlists/priority_queue.playlist
 CONJURER_STREAM_TEMPLATE=/data/templates/stream.html
 CONJURER_RADIO_LOG=/data/logs/radio.log
 CONJURER_PERSISTENCE_LOG=/data/logs/persistence.log
@@ -1,163 +0,0 @@
 # Conjurer Deployment Guide
 This document walks through deploying the Conjurer stack (Discord bot, music
 service, librarian service) on two Raspberry Pi 4s and one Windows host, first
 with plain Docker Compose, then with a future Kubernetes setup.
 ## 1. Current Hardware Layout
 - **Windows PC**: Stores persistent data (JSON memories, configs, music
  catalogue). Shares folders over the network (SMB) for the Pis.
 - **Raspberry Pi A** (“radio”): Runs the Liquidsoap/liq radio pipeline and the
  musician service (Flask + file watcher).
 - **Raspberry Pi B** (“bot”): Runs the Discord bot, communication bridge, and
  librarian Flask service.
 You can rebalance as follows:
 | Service             | Recommended Host | Notes |
 |---------------------|------------------|-------|
 | Discord bot + comms | Raspberry Pi B   | Needs outbound internet, moderate CPU |
 | Librarian service   | Raspberry Pi B   | CPU-heavy during Crossref queries; keep close to bot |
 | Musician service    | Raspberry Pi A   | Has direct disk access to music, same box as Liquidsoap |
 | Data storage        | Windows          | Expose via SMB; mount inside containers |
 ## 2. Prepare Shared Storage on Windows
 1. Create directories, e.g. `C:\Conjurer\config`, `C:\Conjurer\logs`,
   `C:\Conjurer\music`, `C:\Conjurer\playlists`, `C:\Conjurer\secrets`.
 2. Copy your existing JSON settings (`settings.json`, `pamiec.json`,
   `pamiec_muzyki.json`, `system_gpt_settings.json`, etc.) into `config`.
 3. Create blank placeholder files if they do not exist yet.
 4. Share the root folder (`C:\Conjurer`) over SMB with read/write access for the
   Pi user (create credentials if necessary).
 ## 3. Configure Environment Files
 1. On your workstation, copy the example env files:
   ```bash
   cp docker/env/bot.env.example docker/env/bot.env
   cp docker/env/musician.env.example docker/env/musician.env
   cp docker/env/librarian.env.example docker/env/librarian.env
   ```
 2. Edit each `docker/env/*.env` to replace `HACKME!` with real values:
   - `DISCORD_TOKEN`, `OPENAI_API_KEY`, `CONJURER_API_KEY` (use the same value for
     all services).
   - For musician/librarian, adjust mounts to the SMB paths you will mount on the
     Pis, e.g. `/mnt/conjurer/music`.
   - Set `CONJURER_CROSSREF_MAILTO` to a real email as required by Crossref.
 3. If you rely on `.netrc`, copy it to `C:\Conjurer\secrets\.netrc` and set
   `CONJURER_NETRC_FILE` accordingly.
 ## 4. Install Docker on Raspberry Pis and Windows
 ### Raspberry Pi
 ```bash
 curl -fsSL https://get.docker.com | sh
 sudo usermod -aG docker $USER
 sudo reboot
 # Install docker compose plugin
 sudo apt-get install docker-compose-plugin
 ```
 ### Windows
 - Install **Docker Desktop**.
 - Enable WSL2 backend and expose the shared Windows folders to the containers
  (Docker Desktop settings → Resources → File Sharing).
 ## 5. Deploy Musician Service (Pi A)
 1. SSH into Raspberry Pi A.
 2. Mount the Windows SMB share:
   ```bash
   sudo mkdir -p /mnt/conjurer
   sudo apt-get install cifs-utils
   sudo mount -t cifs //WINDOWS_HOST/Conjurer /mnt/conjurer -o user=YOURUSER
   ```
   Add an entry to `/etc/fstab` for persistence.
 3. Copy the repo to the Pi or `git clone` it.
 4. On Pi A, create override compose file (optional) pointing volumes to
   `/mnt/conjurer`.
 5. Start only the musician service:
   ```bash
   docker compose up --build -d musician
   ```
   Alternatively, duplicate `docker-compose.yml`, strip other services, and run
   `docker compose up -d`.
 ## 6. Deploy Bot + Librarian (Pi B)
 1. Repeat SMB mount on Pi B (same mount path).
 2. Copy repo / pull latest changes.
 3. Create `.env` files with tokens (or copy from control machine).
 4. Start bot and librarian:
   ```bash
   docker compose up -d bot librarian
   ```
 ## 7. Optional: Run Supporting Liquidsoap Radio
 - Keep Liquidsoap on Pi A as-is, using the same music directories. Ensure the
  musician container has read access to those directories (bind mount).
 ## 8. Verifying
 1. `docker ps` on each Pi to confirm containers running.
 2. Inspect logs under the mounted logs directory (`/mnt/conjurer/logs`).
 3. Join Discord server; issue commands to confirm functionality.
 4. Hit health endpoints manually (e.g. `curl http://PIB:5000/conjurer`).
 ## Rebalancing Suggestions
 - If librarian CPU spikes become an issue, move it to Pi A or another host.
 - If you add a dedicated NAS, mount the network share read-only for the musician
  container and read/write for other services.
 ## 9. Future Kubernetes Deployment (Outline)
 ### Hardware Considerations
 - Minimum three nodes for HA: use the existing two Pis plus one additional Pi 4
  (8 GB preferred). Use Windows PC as storage provider via NFS/SMB CSI driver or
  as a data gateway.
 - Consider Pi clusters with USB SSDs for better I/O.
 ### Cluster Setup Steps
 1. Install a lightweight Kubernetes distribution (e.g., k3s) on each Pi:
   ```bash
   curl -sfL https://get.k3s.io | sh -
   # On additional nodes
   curl -sfL https://get.k3s.io | K3S_URL=https://MASTER:6443 K3S_TOKEN=HACKME sh -
   ```
 2. Install MetalLB for load balancer support on LAN.
 3. Configure persistent volumes using:
   - `nfs-subdir-external-provisioner` pointing to Windows share (ensure Windows
     host supports NFS or run an NFS gateway on another machine).
   - Alternatively, attach individual USB drives to each Pi and use
     `local-path-provisioner` for node-local storage.
 4. Create Kubernetes `Secret` objects for tokens (`DISCORD_TOKEN`, etc.).
 5. Define `Deployment` manifests for each service (bot, musician, librarian) and
   associated `Services`.
 6. Expose Discord bot ports via `NodePort` or Ingress.
 7. Use `StatefulSet` if you need stable identity for the musician service (due to
   local storage).
 ### Optimisation Tips
 - Keep CPU-heavy librarian pods optionally on a beefier node; use
  `nodeSelector`/`affinity` to pin workloads.
 - Consider splitting the persistent storage: music on Pi A (USB disk), logs and
  configs on Pi B, backups on Windows.
 - For improved reliability, add at least one extra Pi for quorum and to host the
  communication bridge if the bot node fails.
 ## Summary Checklist
 1. Prepare Windows shares & tokens.
 2. Configure `docker/env/*.env` using `HACKME!` templates as reference.
 3. Install Docker on Pis, mount network shares.
 4. Launch musician on Pi A, bot + librarian on Pi B.
 5. Verify Discord functionality and API endpoints.
 6. Plan Kubernetes migration when ready (k3s + MetalLB + storage provisioner).
@@ -15,14 +15,7 @@ from discord.ext import commands, tasks
 from ai_functions import handle_response
 from communication_subroutine import IN_COMM_Q, OUT_COMM_Q, QueryControl
-from constants import (
+from constants import DIR_PATH_SADOX, LIBRARIAN_SERVICE_ADDRESS, SEND_QUERY
    DIR_PATH_SADOX,
    LIBRARIAN_SERVICE_ADDRESS,
    SEND_QUERY,
    service_headers,
 )
 SERVICE_HEADERS = service_headers()
 class DataModule(commands.Cog):
@@ -172,7 +165,6 @@ class DataModule(commands.Cog):
            requests.post,
            f"{LIBRARIAN_SERVICE_ADDRESS}{SEND_QUERY}",
            json=json_query,
            headers=SERVICE_HEADERS,
            timeout=360,
        )
        await ctx.send(
@@ -268,7 +260,6 @@ class DataModule(commands.Cog):
            requests.post,
            f"{LIBRARIAN_SERVICE_ADDRESS}{SEND_QUERY}",
            json=json_query,
            headers=SERVICE_HEADERS,
            timeout=360,
        )
        await ctx.send(
@@ -17,16 +17,11 @@ from constants import (
    SEND_MP3,
    SPOTIFY_CTRL,
    YOUTUBE_AUTH,
    service_headers,
 )
 from spotify_dl import spotify
 from spotify_dl import youtube as youtube_download
 SERVICE_HEADERS = service_headers()
 MUSIC_ROOT = Path(MUSIC_FOLDER)
 class MusicFileList(object):
    """
@@ -48,15 +43,11 @@ class MusicFileList(object):
        """
        try:
            self.logger.info("Attempt to connect to file service")
-            response = requests.get(
+            response = requests.get(f"{FILE_SERVICE_ADDRESS}{GET_MP3}", timeout=360)
                f"{FILE_SERVICE_ADDRESS}{GET_MP3}",
                headers=SERVICE_HEADERS,
                timeout=60,
            )
            self.music_file_list = response.json()["music_file_list"]
            self.file_service_active = True
        except requests.exceptions.RequestException as e:
-            for mp3_item in MUSIC_ROOT.glob("**/*.mp3"):
+            for mp3_item in Path.glob(Path(MUSIC_FOLDER), "**/*.mp3"):
                temp_music_file = mp3_item.as_posix()
                if platform == "win32":
                    temp_music_file = temp_music_file.replace("/", "\\")
@@ -107,12 +98,7 @@ class MusicFileList(object):
        """
        self.music_file_list.append(item)
        post_data = {"item": str(item)}
-        requests.post(
+        requests.post(f"{FILE_SERVICE_ADDRESS}{SEND_MP3}", json=post_data, timeout=360)
            f"{FILE_SERVICE_ADDRESS}{SEND_MP3}",
            json=post_data,
            headers=SERVICE_HEADERS,
            timeout=60,
        )
 MUSIC_FILE_LIST = MusicFileList("discord")
@@ -156,7 +142,7 @@ async def get_file(ctx, source, link):
            url_data = {"urls": []}
            url_dict = {}
            url_dict["save_path"] = Path(
-                PurePath.joinpath(MUSIC_ROOT, Path(directory_name))
+                PurePath.joinpath(Path(MUSIC_FOLDER), Path(directory_name))
            )
            url_dict["save_path"].mkdir(parents=True, exist_ok=True)
            url_dict["songs"] = file_list
@@ -166,7 +152,7 @@ async def get_file(ctx, source, link):
            coro = asyncio.to_thread(
                youtube_download.download_songs,
                songs=url_data,
-                output_dir=str(MUSIC_ROOT),
+                output_dir=MUSIC_FOLDER,
                format_str="bestaudio/best",
                skip_mp3=False,
                keep_playlist_order=False,
@@ -322,7 +308,6 @@ async def search_music(ctx, how_many=0, slowa_kluczowe=None):
        requests.post,
        f"{FILE_SERVICE_ADDRESS}{GET_PLAYLIST}",
        json=jrequest,
        headers=SERVICE_HEADERS,
        timeout=360,
    )
    return_data = await coroutine
@@ -8,18 +8,7 @@ import uuid
 import asyncio
 from datetime import datetime
-from constants import (
+from constants import RADIO_HARBOR_ADDRESS, SKIP_TRACK, FILE_SERVICE_ADDRESS, ADD_TO_PRIO_PLAYLIST, REQUEST_MUSIC, CREATE_PRIO_PLAYLIST, CLEAR_PRIO
    RADIO_HARBOR_ADDRESS,
    SKIP_TRACK,
    FILE_SERVICE_ADDRESS,
    ADD_TO_PRIO_PLAYLIST,
    REQUEST_MUSIC,
    CREATE_PRIO_PLAYLIST,
    CLEAR_PRIO,
    service_headers,
 )
 SERVICE_HEADERS = service_headers()
 class RadioModule(commands.Cog):
    def __init__(self, bot, logger_name):
@@ -106,7 +95,6 @@ class RadioModule(commands.Cog):
                requests.post,
                f"{FILE_SERVICE_ADDRESS}{ADD_TO_PRIO_PLAYLIST}",
                json=jrequest,
                headers=SERVICE_HEADERS,
                timeout=360,
            )
            result = await coroutine
@@ -142,7 +130,6 @@ class RadioModule(commands.Cog):
                requests.post,
                f"{FILE_SERVICE_ADDRESS}{REQUEST_MUSIC}",
                json=jrequest,
                headers=SERVICE_HEADERS,
                timeout=360,
            )
            result = await coroutine
@@ -180,7 +167,6 @@ class RadioModule(commands.Cog):
                requests.post,
                f"{FILE_SERVICE_ADDRESS}{CREATE_PRIO_PLAYLIST}",
                json=jrequest,
                headers=SERVICE_HEADERS,
                timeout=360,
            )
            result = await coroutine
@@ -208,7 +194,6 @@ class RadioModule(commands.Cog):
            coroutine = asyncio.to_thread(
                requests.get,
                f"{FILE_SERVICE_ADDRESS}{CLEAR_PRIO}",
                headers=SERVICE_HEADERS,
                timeout=360,
            )
            result = await coroutine
@@ -1,296 +0,0 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
 Buduje nową gałąź z "próbkowanych" commitów na podstawie tagów z bieżącej gałęzi,
 a na końcu dodaje stan bieżącego HEAD (jeśli nie jest otagowany).
 Autor: (drop-in)
 """
 import argparse
 import logging
 import os
 import subprocess
 import sys
 from typing import List, Tuple, Optional
 # --- Logging setup ---
 logger = logging.getLogger("tag_branch_builder")
 handler = logging.StreamHandler(sys.stdout)
 formatter = logging.Formatter("%(levelname)s: %(message)s")
 handler.setFormatter(formatter)
 logger.addHandler(handler)
 logger.setLevel(logging.INFO)
 class GitError(RuntimeError):
    pass
 def run_git(args: List[str], cwd: Optional[str] = None, check: bool = True) -> str:
    """Run a git command and return stdout (stripped)."""
    cmd = ["git"] + args
    logger.debug("Running: %s", " ".join(cmd))
    try:
        proc = subprocess.run(
            cmd,
            cwd=cwd,
            check=False,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
        )
    except Exception as e:
        raise Exception("Nie udało się uruchomić gita.") from e
        raise
    if check and proc.returncode != 0:
        logger.error("Git error (%s): %s", " ".join(cmd), proc.stderr.strip())
        raise GitError(proc.stderr.strip())
    return proc.stdout.strip()
 def ensure_git_repo() -> None:
    try:
        run_git(["rev-parse", "--is-inside-work-tree"])
    except Exception:
        logger.exception("To nie wygląda na repozytorium git.")
        raise
 def ensure_clean_worktree() -> None:
    # Untracked + changes
    status = run_git(["status", "--porcelain"])
    if status.strip():
        raise GitError(
            "Drzewo robocze nie jest czyste. Zacommituj/stashuj zmiany i spróbuj ponownie."
        )
 def current_branch() -> str:
    # Returns branch or 'HEAD' when detached
    ref = run_git(["rev-parse", "--abbrev-ref", "HEAD"])
    return ref
 def head_sha() -> str:
    return run_git(["rev-parse", "HEAD"])
 def sha_has_tag(sha: str) -> List[str]:
    # tags pointing at sha
    tags = run_git(["tag", "--points-at", sha])
    return [t for t in tags.splitlines() if t.strip()]
 def tags_merged_into(branch: str) -> List[str]:
    out = run_git(["tag", "--merged", branch])
    return [t for t in out.splitlines() if t.strip()]
 def tag_commit_sha(tag: str) -> str:
    return run_git(["rev-list", "-n", "1", tag])
 def commit_unix_time(sha: str) -> int:
    return int(run_git(["show", "-s", "--format=%ct", sha]))
 def sort_tags_by_commit_time(tags: List[str]) -> List[Tuple[str, str, int]]:
    triples = []
    for t in tags:
        sha = tag_commit_sha(t)
        ts = commit_unix_time(sha)
        triples.append((t, sha, ts))
    triples.sort(key=lambda x: x[2])  # oldest first
    return triples
 def list_intermediate_messages(old_sha: Optional[str], new_sha: str) -> List[str]:
    """
    Zwróć listę komunikatów commitów POŚREDNICH (wyłącznie) od old_sha do new_sha.
    Kolejność: od najstarszego do najnowszego.
    """
    if old_sha is None:
        # Nie ma commitów pośrednich przed pierwszym tagiem
        return []
    # ancestry-path: tylko ścieżka od old_sha do new_sha (jeśli wiele rodziców)
    # Zakres old_sha..new_sha zawiera new_sha, dlatego pominiemy go w output.
    rng = f"{old_sha}..{new_sha}"
    try:
        out = run_git(
            ["log", "--format=%s", "--reverse", "--ancestry-path", rng], check=True
        )
    except GitError:
        # Brak ścieżki (np. tag nie jest potomkiem old_sha) – wtedy nie ma pośrednich
        return []
    msgs = [ln for ln in out.splitlines() if ln.strip()]
    if msgs:
        # Ostatnia pozycja może być new_sha (w praktyce git log na %s nie odróżnia, ale
        # jeśli zakres zwróci message z new_sha na końcu, usuniemy go porównując SHA).
        # Prostsze: usuń ostatni wpis, bo to najnowszy (new_sha).
        msgs = msgs[:-1]
    return msgs
 def checkout_orphan_branch(new_branch: str) -> None:
    run_git(["checkout", "--orphan", new_branch])
    # Usuń wszystko z indeksu i roboczego (z wyjątkiem .git)
    # Najpierw usuń śledzone:
    run_git(["rm", "-r", "--quiet", "--cached", "--force", "."], check=False)
    # Potem pliki robocze:
    for root, dirs, files in os.walk(".", topdown=False):
        # pomiń .git
        if root.startswith("./.git") or root == ".git":
            continue
        for name in files:
            try:
                os.remove(os.path.join(root, name))
            except FileNotFoundError:
                pass
        for name in dirs:
            p = os.path.join(root, name)
            if p == "./.git":
                continue
            try:
                os.rmdir(p)
            except OSError:
                # Niepuste – to OK, wyczyścimy przy checkout
                pass
 def replace_worktree_with_commit(sha: str) -> None:
    """
    Nadpisz zawartość roboczą drzewem z commit-a sha.
    """
    # Najpierw usuń aktualne pliki (również nieśledzone), potem wczytaj tree wybranego commita:
    # 1) git checkout <sha> -- .   (zapisze pliki do working tree + index)
    # 2) git add -A
    # Aby dopilnować usunięć: zrób czyszczenie przez git rm -r ., potem checkout.
    run_git(["rm", "-r", "--quiet", "--ignore-unmatch", "."], check=False)
    # Przywróć pliki ze wskazanego commita:
    # Uwaga: jeśli repo ma submoduły/large files – to wykracza poza zakres, ale zadziała dla standardowych plików.
    run_git(["checkout", sha, "--", "."])
    run_git(["add", "-A"])
 def build_commit_message_for_tag(tag: str, intermediates: List[str]) -> str:
    if not intermediates:
        return f"Tag: {tag}"
    lines = ["Tag: " + tag, "", "Intermediate commits (oldest → newest):"]
    lines += [f"- {m}" for m in intermediates]
    return "\n".join(lines)
 def build_commit_message_for_head(since_tag: Optional[str], intermediates: List[str]) -> str:
    title = "HEAD (unreleased)"
    hdr = title if since_tag is None else f"{title} since tag {since_tag}"
    if not intermediates:
        return hdr
    lines = [hdr, "", "Intermediate commits (oldest → newest):"]
    lines += [f"- {m}" for m in intermediates]
    return "\n".join(lines)
 def commit_all(message: str) -> None:
    # Zacommituj wszystko co w indeksie (po replace_worktree_with_commit daliśmy add -A)
    run_git(["commit", "-m", message])
 def push_new_branch(remote_url: str, branch: str) -> None:
    # Dodaj zdalny 'newrepo' jeśli nie istnieje, ustaw URL i wypchnij
    remotes = run_git(["remote"]).splitlines()
    if "newrepo" not in remotes:
        run_git(["remote", "add", "newrepo", remote_url])
    else:
        # podmień URL na wszelki wypadek
        run_git(["remote", "set-url", "newrepo", remote_url])
    run_git(["push", "-u", "newrepo", f"{branch}:{branch}"])
 def main() -> int:
    parser = argparse.ArgumentParser(
        description="Zbuduj nową gałąź na podstawie tagów z bieżącej gałęzi."
    )
    parser.add_argument("new_branch", help="Nazwa nowej gałęzi do utworzenia")
    parser.add_argument(
        "--new-repo-url",
        dest="new_repo_url",
        default=None,
        help="(Opcjonalnie) adres URL nowego zdalnego repo – zostanie dodany jako 'newrepo' i wykonany push nowej gałęzi.",
    )
    parser.add_argument(
        "-v", "--verbose", action="store_true", help="Bardziej gadatliwe logi"
    )
    args = parser.parse_args()
    if args.verbose:
        logger.setLevel(logging.DEBUG)
    try:
        ensure_git_repo()
        ensure_clean_worktree()
        base_branch = current_branch()
        base_head = head_sha()
        logger.info("Bieżąca gałąź: %s", base_branch)
        logger.info("HEAD: %s", base_head[:12])
        # Zbierz tagi osiągalne z bieżącej gałęzi
        merged_tags = tags_merged_into(base_branch)
        if not merged_tags:
            logger.warning(
                "Nie znaleziono tagów osiągalnych z bieżącej gałęzi. Gałąź zostanie zbudowana tylko z HEAD."
            )
        # Posortuj tagi po czasie commita
        sorted_tags = sort_tags_by_commit_time(merged_tags)
        # Sprawdź czy HEAD jest otagowany
        head_tags = sha_has_tag(base_head)
        head_is_tagged = bool(head_tags)
        # Utwórz orphan branch
        logger.info("Tworzę sierocą gałąź: %s", args.new_branch)
        checkout_orphan_branch(args.new_branch)
        prev_sha: Optional[str] = None
        last_tag_name: Optional[str] = None
        # Dla każdego tagu – commit z jego zawartości
        for tag_name, tag_sha, _ts in sorted_tags:
            logger.info("Przetwarzam tag: %s (%s)", tag_name, tag_sha[:12])
            replace_worktree_with_commit(tag_sha)
            intermediates = list_intermediate_messages(prev_sha, tag_sha)
            msg = build_commit_message_for_tag(tag_name, intermediates)
            commit_all(msg)
            prev_sha = tag_sha
            last_tag_name = tag_name
        # Jeśli HEAD nie jest dokładnie ostatnim tagiem – dorzuć "unreleased"
        if not head_is_tagged:
            logger.info("Dodaję końcowy commit z bieżącego HEAD (unreleased).")
            replace_worktree_with_commit(base_head)
            inter = list_intermediate_messages(prev_sha, base_head)
            msg = build_commit_message_for_head(last_tag_name, inter)
            commit_all(msg)
        else:
            logger.info("HEAD jest oznaczony tagiem – kończę na ostatnim tagu.")
        # Push do nowego repo jeśli podano
        if args.new_repo_url:
            logger.info("Wypycham nową gałąź do: %s", args.new_repo_url)
            push_new_branch(args.new_repo_url, args.new_branch)
        logger.info("Zakończono pomyślnie.")
        return 0
    except GitError as ge:
        logger.error("Błąd gita: %s", ge)
        return 2
    except Exception as e:
        raise Exception("Nieoczekiwany błąd.") from e
        return 1
 if __name__ == "__main__":
    sys.exit(main())
@@ -2,19 +2,17 @@
 # trunk-ignore-all(bandit/B311)
 # pylint: disable=line-too-long
 # pylint: disable=too-many-lines
 """Discord entrypoint for the Conjurer bot.
 The legacy bootstrap used threads and synchronous calls that made clean
 shutdowns difficult.  We now run everything from a single asyncio event loop
 with cooperative shutdown signals so the bot can stop gracefully.
 """
-
+Module of a python bot named Conjurer - used to work on BDSM discord servers.
-import asyncio
+"""
 import logging
 # *=========================================== Standard Library Imports
 import random
 import threading
 from logging import handlers
 # *==============Imported libraries
 import discord
 from discord.ext import commands
@@ -84,40 +82,22 @@ async def on_ready():
    logger.info("All systems: operational")
-async def _run_comm_subroutine(stop_event: threading.Event) -> None:
+# *================================== Run
    await asyncio.to_thread(comm_subroutine, stop_event)
 async def _run_bot(token: str, shutdown_event: asyncio.Event) -> None:
    try:
        await client.start(token, log_handler=None)
    finally:
        shutdown_event.set()
 async def main() -> None:
    if not TOKEN:
        logger.error("Discord token missing – set DISCORD_TOKEN or configure netrc")
        return
    shutdown_event = asyncio.Event()
    comm_stop_event = threading.Event()
    comm_task = asyncio.create_task(_run_comm_subroutine(comm_stop_event))
    bot_task = asyncio.create_task(_run_bot(TOKEN, shutdown_event))
    try:
        await shutdown_event.wait()
    except (KeyboardInterrupt, asyncio.CancelledError):
        logger.info("Shutdown signal received")
        comm_stop_event.set()
        await client.close()
    finally:
        comm_stop_event.set()
        if not client.is_closed():
            await client.close()
        await asyncio.gather(bot_task, comm_task, return_exceptions=True)
 if __name__ == "__main__":
-    asyncio.run(main())
+    logger.info("Starting discord bot")
    threads = []
    logger.info("Starting discord bot: Creating threads")
    threads.append(threading.Thread(target=client.run, args=(TOKEN,),kwargs={"log_handler":None}))
    threads.append(threading.Thread(target=comm_subroutine))
    logger.info("Starting discord bot: Starting threads")
    WRK_CNT = 0
    for worker in threads:
        WRK_CNT += 1
        logger.info("Starting discord bot: Starting thread %s", WRK_CNT)
        worker.start()
    logger.info("Starting discord bot: Joining threads")
    WRK_CNT = 0
    for worker in threads:
        WRK_CNT += 1
        logger.info("Starting discord bot: Joining thread %s", WRK_CNT)
        worker.join()