Apply conversation bot improvements (proto-improvements)

Diff vs working-copy baseline = exactly this session's bot edits:
- constants.py: env-var config, safe JSON loading, optional-dependency
  guards, env->netrc token resolution, API_SHARED_KEY + service_headers()
- communication_subroutine.py: queue get(timeout) + Empty handling,
  daemon threads, cooperative stop_event, inbound _authorize_request()
- bot.py: single asyncio event loop with cooperative shutdown
- music_functions / radio_commands / librarian_commands: send
  X-Conjurer-Api-Key on internal HTTP calls via service_headers()

Musician runtime data overlay dropped; conjurer_musician/.gitignore now
keeps generated playlists/mp3 out of the repo. The 1+2+3 musician code
port already lives in the base conjurer_musician.

Depends on #9: must merge after restructure/working-copy-root.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.github/workflows/ci.yml

@@ -1,54 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: ["main"]
-  pull_request:
-    branches: ["main"]
-
-permissions:
-  contents: read
-
-jobs:
-  compile:
-    # Byte-compile every first-party .py to catch syntax errors. No deps.
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-      - name: py_compile first-party sources
-        run: |
-          git ls-files '*.py' | grep -vE '^(yt_dlp|spotify_dl)/' | xargs python -m py_compile
-          echo "All first-party sources compile."
-
-  unit:
-    # Pure-logic tests; tested modules guard heavy deps, so only pytest needed.
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-      - name: Install test deps
-        run: |
-          python -m pip install --upgrade pip
-          pip install pytest
-      - name: Run unit tests
-        run: pytest tests/unit -v
-
-  integration:
-    # Boot the Flask services and assert the X-Conjurer-Api-Key auth contract.
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-      - name: Install service deps
-        run: |
-          python -m pip install --upgrade pip
-          pip install pytest flask waitress requests
-      - name: Run integration tests
-        run: pytest tests/integration -v

.github/workflows/python-app.yml

@@ -0,0 +1,39 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Python application
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v3
+      with:
+        python-version: "3.10"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install flake8 pytest
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: |
+        pytest

.github/workflows/python-package.yml

@@ -0,0 +1,40 @@
+# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Python package
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install flake8 pytest
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: |
+        pytest

bot.py

@@ -71,7 +71,6 @@ async def on_ready():
     await client.load_extension("voice_recognition_commands")
     await client.load_extension("file_search_commands")
     await client.load_extension("latex_commands")
-    await client.load_extension("conanjurer_commands")
     logger.info("Sensors: online")
 
     logger.info(client.cogs)

conanjurer_commands.py

@@ -1,217 +1,102 @@
-# This Python file uses the following encoding: utf-8
-"""Conan Exiles <-> Discord bridge (cog).
-
-Follows the project convention (cog here, helpers in
-``conanjurer_functions.py``).  The integration is dormant unless configured in
-:mod:`constants`: with no RCON host / channels the background watchers simply
-do not start and the GM commands report that RCON is unavailable, so loading
-this extension is always safe even on hosts without a Conan server.
-"""
+# ai command cogs
+import logging
+import discord
+from discord.ext import commands
+from other_functions import discord_friendly_send, discord_friendly_reply
+from __future__ import annotations
 import asyncio
 import logging
 
-import discord
-from discord.ext import commands
-
-from conanjurer_functions import ConanConfig, Event, RconClient, watch, watch_players
-from constants import (
-    CONAN_CHAT_CHANNEL_ID,
-    CONAN_EVENTS_CHANNEL_ID,
-    CONAN_GM_ROLE_ID,
-    CONAN_JOIN_CHANNEL_ID,
-    CONAN_LOG_MODE,
-    CONAN_LOG_PATH,
-    CONAN_PLAYER_POLL_SECONDS,
-    CONAN_RCON_HOST,
-    CONAN_RCON_PASSWORD,
-    CONAN_RCON_PORT,
-    CONAN_SFTP_HOST,
-    CONAN_SFTP_PASSWORD,
-    CONAN_SFTP_PORT,
-    CONAN_SFTP_USER,
-)
-
+from conanjurer_functions import watch, Event
+log = logging.getLogger("discord")
 
 def is_gm():
-    """Allow only members holding the configured Conan GM role."""
-
     async def predicate(ctx: commands.Context) -> bool:
-        if not CONAN_GM_ROLE_ID:
-            await ctx.reply(
-                "⛔ Rola GM Conana nie jest skonfigurowana.", mention_author=False
-            )
-            return False
-        ok = any(r.id == CONAN_GM_ROLE_ID for r in getattr(ctx.author, "roles", []))
+        role_id = ctx.bot.cfg.gm_role_id
+        ok = any(r.id == role_id for r in getattr(ctx.author, "roles", []))
         if not ok:
             await ctx.reply("⛔ Tylko GM.", mention_author=False)
         return ok
-
     return commands.check(predicate)
 
 
-class ConanModule(commands.Cog):
-    """Bridges a Conan Exiles server with Discord over RCON + log following."""
-
-    def __init__(self, bot, logger_name):
+class FromConan(commands.Cog):
+    def __init__(self, bot: commands.Bot):
         self.bot = bot
-        self.logger = logging.getLogger(logger_name)
-        self.cfg = ConanConfig(
-            rcon_host=CONAN_RCON_HOST,
-            rcon_port=CONAN_RCON_PORT,
-            rcon_password=CONAN_RCON_PASSWORD,
-            log_mode=CONAN_LOG_MODE,
-            log_path=CONAN_LOG_PATH,
-            sftp_host=CONAN_SFTP_HOST,
-            sftp_port=CONAN_SFTP_PORT,
-            sftp_user=CONAN_SFTP_USER,
-            sftp_password=CONAN_SFTP_PASSWORD,
-        )
-        self.rcon = (
-            RconClient(CONAN_RCON_HOST, CONAN_RCON_PORT, CONAN_RCON_PASSWORD)
-            if self.cfg.rcon_enabled
-            else None
-        )
-        self._log_task = None
-        self._player_task = None
+        self._task: asyncio.Task | None = None
 
     async def cog_load(self):
-        # Conan -> Discord chat/event mirroring (only with a log source + target)
-        if self.cfg.log_enabled and (CONAN_CHAT_CHANNEL_ID or CONAN_EVENTS_CHANNEL_ID):
-            self._log_task = asyncio.create_task(self._run_log_watch())
-        else:
-            self.logger.info("Conan: log watch disabled (not configured)")
-
-        # Player-join notifications — disabled when the channel is not defined
-        if CONAN_JOIN_CHANNEL_ID and self.rcon is not None:
-            self._player_task = asyncio.create_task(self._run_player_watch())
-        else:
-            self.logger.info(
-                "Conan: player-join notifications disabled (no channel or RCON)"
-            )
+        self._task = asyncio.create_task(self._run())
 
     async def cog_unload(self):
-        for task in (self._log_task, self._player_task):
-            if task is not None:
-                task.cancel()
-        if self.rcon is not None:
-            await self.rcon.close()
+        if self._task:
+            self._task.cancel()
 
-    # ---------------------------------------------------------------- watchers
-    async def _run_log_watch(self):
+    async def _run(self):
         await self.bot.wait_until_ready()
-        chat_ch = (
-            self.bot.get_channel(CONAN_CHAT_CHANNEL_ID) if CONAN_CHAT_CHANNEL_ID else None
-        )
-        evt_ch = (
-            self.bot.get_channel(CONAN_EVENTS_CHANNEL_ID)
-            if CONAN_EVENTS_CHANNEL_ID
-            else None
-        )
+        cfg = self.bot.cfg
+        chat_ch = self.bot.get_channel(cfg.chan_chat)
+        evt_ch = self.bot.get_channel(cfg.chan_events)
 
-        async def on_event(event: Event):
-            target = chat_ch if event.kind == "chat" else evt_ch
+        async def on_event(e: Event):
+            target = chat_ch if e.kind == "chat" else evt_ch
             if target is not None:
-                await target.send(
-                    event.text, allowed_mentions=discord.AllowedMentions.none()
-                )
+                # allowed_mentions: nie pinguj nikogo treścią z gry
+                await target.send(e.text, allowed_mentions=discord.AllowedMentions.none())
 
-        self.logger.info("Conan: starting log watch (mode=%s)", self.cfg.log_mode)
-        await watch(self.cfg, on_event)
+        log.info("Start obserwacji logu (tryb=%s)", cfg.log_mode)
+        await watch(cfg, on_event)
 
-    async def _run_player_watch(self):
-        """Task 2: announce on a defined channel when a player joins the server."""
-        await self.bot.wait_until_ready()
-        channel = self.bot.get_channel(CONAN_JOIN_CHANNEL_ID)
-        if channel is None:
-            self.logger.warning(
-                "Conan: join channel %s not found — player notifications off",
-                CONAN_JOIN_CHANNEL_ID,
-            )
-            return
-
-        async def on_join(name: str):
-            await channel.send(
-                f"🟢 **{name}** wszedł na serwer Conan",
-                allowed_mentions=discord.AllowedMentions.none(),
-            )
-
-        self.logger.info(
-            "Conan: starting player-join watch (channel=%s, every %ss)",
-            CONAN_JOIN_CHANNEL_ID,
-            CONAN_PLAYER_POLL_SECONDS,
-        )
-        await watch_players(self.rcon, CONAN_PLAYER_POLL_SECONDS, on_join)
-
-    # ----------------------------------------------------- Discord -> Conan
-    async def _require_rcon(self, ctx: commands.Context):
-        if self.rcon is None:
-            await ctx.reply(
-                "⛔ RCON Conana nie jest skonfigurowany/dostępny.",
-                mention_author=False,
-            )
-            return None
-        return self.rcon
+class ToConan(commands.Cog):
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
 
     @commands.command(name="say")
     @is_gm()
     async def say(self, ctx: commands.Context, *, message: str):
         """Discord -> Conan: ogłoszenie widoczne dla wszystkich graczy w grze."""
-        rcon = await self._require_rcon(ctx)
-        if rcon is None:
-            return
-        resp = await rcon.command(f"broadcast {message}")
-        await ctx.reply(
-            f"✅ Wysłano do gry. (serwer: `{resp.strip() or 'OK'}`)",
-            mention_author=False,
-        )
+        resp = await self.bot.rcon.command(f"broadcast {message}")
+        await ctx.reply(f"✅ Wysłano do gry. (serwer: `{resp.strip() or 'OK'}`)",
+                        mention_author=False)
 
     @commands.command(name="players")
     @is_gm()
     async def players(self, ctx: commands.Context):
         """Lista graczy online (RCON listplayers)."""
-        rcon = await self._require_rcon(ctx)
-        if rcon is None:
-            return
-        resp = await rcon.command("listplayers")
-        await ctx.reply(
-            f"```\n{resp.strip() or 'brak danych'}\n```", mention_author=False
-        )
+        resp = await self.bot.rcon.command("listplayers")
+        await ctx.reply(f"```\n{resp.strip() or 'brak danych'}\n```",
+                        mention_author=False)
 
     @commands.command(name="kick")
     @is_gm()
     async def kick(self, ctx: commands.Context, *, who: str):
         """Wyrzuć gracza (po nazwie/charname — zależnie od wersji serwera)."""
-        rcon = await self._require_rcon(ctx)
-        if rcon is None:
-            return
-        resp = await rcon.command(f"kick {who}")
+        resp = await self.bot.rcon.command(f"kick {who}")
         await ctx.reply(f"👢 `{resp.strip() or 'OK'}`", mention_author=False)
 
     @commands.command(name="rcon")
     @is_gm()
     async def raw_rcon(self, ctx: commands.Context, *, cmd: str):
         """Surowa komenda RCON (dla zaawansowanych GM). Używaj ostrożnie."""
-        rcon = await self._require_rcon(ctx)
-        if rcon is None:
-            return
-        resp = await rcon.command(cmd)
+        resp = await self.bot.rcon.command(cmd)
         await ctx.reply(f"```\n{resp.strip() or 'OK'}\n```", mention_author=False)
 
+    # --- HOOK pod przyszły mod mostu (Chat V2 API) ---
     @commands.command(name="ogłoś", aliases=["oglos", "rp"])
     @is_gm()
     async def rp_announce(self, ctx: commands.Context, nadawca: str, *, message: str):
         """Wiadomość RP 'z nadawcą' (np. ogłoszenie w imieniu Króla Khasara).
 
-        Na samym RCON realizujemy to jako sformatowany broadcast.
+        Na samym RCON realizujemy to jako sformatowany broadcast. Gdy dodasz
+        własny mod na Chat V2 API z dedykowaną komendą czatu, podmień tę linię
+        na wywołanie tej komendy (np. 'tot_rp_say <nadawca> <msg>').
         """
-        rcon = await self._require_rcon(ctx)
-        if rcon is None:
-            return
-        resp = await rcon.command(f"broadcast [{nadawca}]: {message}")
+        resp = await self.bot.rcon.command(f"broadcast [{nadawca}]: {message}")
         await ctx.reply(f"📜 Ogłoszono jako **{nadawca}**.", mention_author=False)
 
 
-async def setup(bot):
-    logger = logging.getLogger("discord")
-    await bot.add_cog(ConanModule(bot, "discord"))
-    logger.info("Loading conanjurer commands module done")
+async def setup(bot: commands.Bot):
+    await bot.add_cog(ToConan(bot))
+    await bot.add_cog(FromConan(bot))
+
+

conanjurer_functions.py

@@ -1,73 +1,27 @@
-# This Python file uses the following encoding: utf-8
-"""Helper logic for the Conan Exiles <-> Discord bridge.
-
-Mirrors the project layout: the cog lives in ``conanjurer_commands.py`` and the
-reusable logic lives here.  Configuration comes from :mod:`constants` (env-var
-overridable); optional third-party dependencies (``aiomcrcon``/``asyncssh``)
-are imported defensively so the main bot can still load the extension when the
-Conan integration is not installed or not in use.
-"""
 from __future__ import annotations
-
+import os
+from dataclasses import dataclass
+from dotenv import load_dotenv
 import asyncio
 import logging
-import os
 import re
-from dataclasses import dataclass
-from typing import AsyncIterator, Awaitable, Callable, Optional, Set
-
-try:
+from typing import AsyncIterator, Callable, Awaitable
 from aiomcrcon import Client as _Rcon  # Source RCON over TCP
-except ImportError:  # pragma: no cover - optional component
-    _Rcon = None
-
-try:
 import asyncssh
-except ImportError:  # pragma: no cover - optional component
-    asyncssh = None
-
-logger = logging.getLogger("discord")
 
+load_dotenv()
 
+log = logging.getLogger("discord")
 @dataclass
 class Event:
     kind: str        # "chat" | "login" | "logout" | "death" | "raw"
-    text: str  # ready-to-display text
-    raw: str   # original line (for debugging)
-
-
-@dataclass
-class ConanConfig:
-    """Runtime configuration for the bridge, built from :mod:`constants`."""
-
-    rcon_host: str
-    rcon_port: int
-    rcon_password: str
-    log_mode: str  # "local" | "sftp"
-    log_path: str
-    sftp_host: str
-    sftp_port: int
-    sftp_user: str
-    sftp_password: str
-
-    @property
-    def rcon_enabled(self) -> bool:
-        """RCON usable only when host+password are set and the lib is present."""
-        return bool(self.rcon_host and self.rcon_password and _Rcon is not None)
-
-    @property
-    def log_enabled(self) -> bool:
-        """Log following usable only when its prerequisites are configured."""
-        if not self.log_path:
-            return False
-        if self.log_mode == "sftp":
-            return bool(self.sftp_host and asyncssh is not None)
-        return True
+    text: str        # gotowy do wyświetlenia tekst
+    raw: str         # oryginalna linia (do debugowania)
 
 
 # --- REGEXY DO DOSTROJENIA NA WŁASNYM LOGU ---
-# Conan/Pippi/Tot logują różnie — dopasuj do swojego logu. Linie niepasujące są
-# ignorowane (nie zgadujemy).
+# Poniżej PRZYKŁADOWE wzorce. Conan/Pippi/Tot logują różnie — sprawdź swój log
+# i dopasuj. Jeśli wzorzec nie pasuje, linia trafia jako "raw" tylko do debug.
 _PATTERNS: list[tuple[str, re.Pattern]] = [
     ("chat",   re.compile(r"Chat:\s*(?P<who>.+?):\s*(?P<msg>.+)$", re.I)),
     ("login",  re.compile(r"(?P<who>.+?)\s+(joined|connected|logged in)", re.I)),
@@ -75,29 +29,64 @@ _PATTERNS: list[tuple[str, re.Pattern]] = [
     ("death",  re.compile(r"(?P<who>.+?)\s+was killed by\s+(?P<by>.+)$", re.I)),
 ]
 
+@dataclass(frozen=True)
+class Config:
+    # Discord
+    guild_id: int
+    chan_chat: int
+    chan_events: int
+    gm_role_id: int
+    # RCON
+    rcon_host: str
+    rcon_port: int
+    rcon_password: str
+    # Log
+    log_mode: str          # "local" | "sftp"
+    log_path: str
+    sftp_host: str | None
+    sftp_port: int
+    sftp_user: str | None
+    sftp_password: str | None
+
+    @staticmethod
+    def load() -> "Config":
+        mode = os.getenv("LOG_MODE", "local").lower()
+        return Config(
+            guild_id=int(_req("DISCORD_GUILD_ID")),
+            chan_chat=int(_req("CHAN_CHAT")),
+            chan_events=int(_req("CHAN_EVENTS")),
+            gm_role_id=int(_req("GM_ROLE_ID")),
+            rcon_host=_req("RCON_HOST"),
+            rcon_port=int(os.getenv("RCON_PORT", "25575")),
+            rcon_password=_req("RCON_PASSWORD"),
+            log_mode=mode,
+            log_path=_req("LOG_PATH"),
+            sftp_host=os.getenv("SFTP_HOST"),
+            sftp_port=int(os.getenv("SFTP_PORT", "22")),
+            sftp_user=os.getenv("SFTP_USER"),
+            sftp_password=os.getenv("SFTP_PASSWORD"),
+        )
+
 
 class RconClient:
-    """Thin async wrapper around a Source-RCON connection to the Conan server."""
-
     def __init__(self, host: str, port: int, password: str):
         self._host, self._port, self._pw = host, port, password
-        self._client: Optional["_Rcon"] = None
+        self._client: _Rcon | None = None
         self._lock = asyncio.Lock()
 
-    async def _ensure(self) -> "_Rcon":
-        if _Rcon is None:
-            raise RuntimeError("aiomcrcon not installed — RCON unavailable")
+    async def _ensure(self) -> _Rcon:
         if self._client is None:
-            client = _Rcon(self._host, self._port, self._pw)
-            await client.connect()
-            self._client = client
-            logger.info("RCON connected %s:%s", self._host, self._port)
+            c = _Rcon(self._host, self._port, self._pw)
+            await c.connect()
+            self._client = c
+            log.info("RCON połączony %s:%s", self._host, self._port)
         return self._client
 
     async def command(self, cmd: str) -> str:
-        """Send a command to the Conan server and return its response.
+        """Wyślij komendę do serwera Conana. Zwraca odpowiedź serwera.
 
-        Discord -> Conan channel, e.g. ``command("broadcast Hi!")``.
+        To jest KANAŁ Discord -> Conan. Np. command("broadcast Witajcie!")
+        wyświetli komunikat wszystkim graczom w grze.
         """
         async with self._lock:
             for attempt in (1, 2):
@@ -105,8 +94,8 @@ class RconClient:
                     client = await self._ensure()
                     resp, _ = await client.send_cmd(cmd)
                     return resp
-                except Exception as exc:  # disconnect / server restart
-                    logger.warning("RCON error (attempt %s): %s", attempt, exc)
+                except Exception as e:  # rozłączenie/restart serwera
+                    log.warning("RCON błąd (próba %s): %s", attempt, e)
                     await self.close()
                     if attempt == 2:
                         raise
@@ -117,19 +106,20 @@ class RconClient:
         if self._client is not None:
             try:
                 await self._client.close()
-            except Exception:  # pragma: no cover - best effort
+            except Exception:
                 pass
             self._client = None
 
 
-def parse_line(line: str) -> Optional[Event]:
+
+def parse_line(line: str) -> Event | None:
     line = line.rstrip("\n")
     if not line.strip():
         return None
     for kind, pat in _PATTERNS:
-        match = pat.search(line)
-        if match:
-            g = match.groupdict()
+        m = pat.search(line)
+        if m:
+            g = m.groupdict()
             if kind == "chat":
                 return Event(kind, f"💬 **{g['who']}**: {g['msg']}", line)
             if kind == "login":
@@ -138,98 +128,42 @@ def parse_line(line: str) -> Optional[Event]:
                 return Event(kind, f"⚪ **{g['who']}** opuścił grę", line)
             if kind == "death":
                 return Event(kind, f"💀 **{g['who']}** zginął z ręki {g['by']}", line)
-    return None  # nierozpoznane -> ignoruj
-
-
-def parse_players(listplayers_output: str) -> Set[str]:
-    """Extract the set of connected player char-names from RCON ``listplayers``.
-
-    Conan's table is roughly::
-
-        Idx | Char name | Player name | User ID | Platform ID | Platform Name
-        0   | Conan     | SomeUser    | 12345   | 765...      | Steam
-
-    The char-name column (index 1) is used.  The exact format varies between
-    server builds, so this is best-effort and intentionally tunable.
-    """
-    players: Set[str] = set()
-    for raw in listplayers_output.splitlines():
-        line = raw.strip()
-        if not line or "|" not in line:
-            continue
-        cols = [c.strip() for c in line.split("|")]
-        head = cols[0].lower()
-        # skip the header row and any separator rows (e.g. "---|---")
-        if head in ("idx", "") or set(cols[0]) <= set("-"):
-            continue
-        if len(cols) >= 2 and cols[1]:
-            players.add(cols[1])
-    return players
-
-
-async def watch_players(
-    rcon: RconClient,
-    interval: float,
-    on_join: Callable[[str], Awaitable[None]],
-) -> None:
-    """Poll RCON ``listplayers`` and call *on_join* for each new player.
-
-    The first poll seeds the known-player set without announcing, so restarting
-    the bot does not re-announce everyone already online.  RCON failures are
-    logged and retried on the next tick rather than killing the task.
-    """
-    known: Optional[Set[str]] = None
-    while True:
-        try:
-            response = await rcon.command("listplayers")
-            current = parse_players(response)
-            if known is None:
-                known = current
-            else:
-                for name in current - known:
-                    try:
-                        await on_join(name)
-                    except Exception:  # pragma: no cover - handler guard
-                        logger.exception("Conan: on_join handler failed")
-                known = current
-        except Exception as exc:
-            logger.warning("Conan: player poll failed: %s", exc)
-        await asyncio.sleep(interval)
+    return None  # nierozpoznane -> ignoruj (nie zgadujemy)
 
 
 async def _follow_local(path: str) -> AsyncIterator[str]:
-    """``tail -f`` in pure asyncio, following log rotation."""
+    """tail -f w czystym asyncio, podąża też po rotacji pliku."""
+    import os
     while True:
         try:
-            with open(path, "r", encoding="utf-8", errors="replace") as handle:
-                handle.seek(0, os.SEEK_END)
-                inode = os.fstat(handle.fileno()).st_ino
+            with open(path, "r", encoding="utf-8", errors="replace") as f:
+                f.seek(0, os.SEEK_END)
+                inode = os.fstat(f.fileno()).st_ino
                 while True:
-                    line = handle.readline()
+                    line = f.readline()
                     if line:
                         yield line
                         continue
                     await asyncio.sleep(0.5)
+                    # wykryj rotację logu
                     try:
-                        if os.stat(path).st_ino != inode:  # rotation
+                        if os.stat(path).st_ino != inode:
                             break
                     except FileNotFoundError:
                         break
         except FileNotFoundError:
-            logger.warning("Conan log not present yet: %s", path)
+            log.warning("Log nie istnieje jeszcze: %s", path)
             await asyncio.sleep(3.0)
 
 
-async def _follow_sftp(cfg: ConanConfig) -> AsyncIterator[str]:
-    """Incremental SFTP polling (e.g. Host Havoc): reads only new bytes."""
+async def _follow_sftp(cfg) -> AsyncIterator[str]:
+    """Polling przyrostowy po SFTP (Host Havoc). Czyta tylko nowe bajty."""
     offset = 0
     while True:
         try:
             async with asyncssh.connect(
-                cfg.sftp_host,
-                port=cfg.sftp_port,
-                username=cfg.sftp_user,
-                password=cfg.sftp_password,
+                cfg.sftp_host, port=cfg.sftp_port,
+                username=cfg.sftp_user, password=cfg.sftp_password,
                 known_hosts=None,
             ) as conn:
                 async with conn.start_sftp_client() as sftp:
@@ -237,30 +171,36 @@ async def _follow_sftp(cfg: ConanConfig) -> AsyncIterator[str]:
                         try:
                             attrs = await sftp.stat(cfg.log_path)
                             size = attrs.size or 0
-                            if size < offset:  # rotation
+                            if size < offset:      # rotacja
                                 offset = 0
                             if size > offset:
-                                async with sftp.open(cfg.log_path, "r") as remote:
-                                    await remote.seek(offset)
-                                    chunk = await remote.read()
+                                async with sftp.open(cfg.log_path, "r") as rf:
+                                    await rf.seek(offset)
+                                    chunk = await rf.read()
                                     offset = size
-                                    for line in chunk.splitlines():
-                                        yield line
+                                    for ln in chunk.splitlines():
+                                        yield ln
                         except FileNotFoundError:
-                            logger.warning("SFTP: missing log %s", cfg.log_path)
+                            log.warning("SFTP: brak logu %s", cfg.log_path)
                         await asyncio.sleep(2.0)
-        except Exception as exc:
-            logger.warning("SFTP disconnected: %s — retrying", exc)
+        except Exception as e:
+            log.warning("SFTP rozłączony: %s — ponawiam", e)
             await asyncio.sleep(5.0)
 
 
-async def watch(cfg: ConanConfig, on_event: Callable[[Event], Awaitable[None]]) -> None:
-    """Follow the Conan log and dispatch recognised lines to *on_event*."""
-    source = _follow_local(cfg.log_path) if cfg.log_mode != "sftp" else _follow_sftp(cfg)
+async def watch(cfg, on_event: Callable[[Event], Awaitable[None]]) -> None:
+    source = _follow_local(cfg.log_path) if cfg.log_mode == "local" else _follow_sftp(cfg)
     async for line in source:
-        event = parse_line(line)
-        if event is not None:
+        evt = parse_line(line)
+        if evt is not None:
             try:
-                await on_event(event)
-            except Exception:  # pragma: no cover - handler guard
-                logger.exception("Conan: event handler failed")
+                await on_event(evt)
+            except Exception:
+                log.exception("Błąd obsługi zdarzenia")
+
+def _req(key: str) -> str:
+    val = os.getenv(key)
+    if not val or val.startswith("wklej") or val.startswith("000000"):
+        raise RuntimeError(f"Brak/placeholder w .env: {key}")
+    return val
+

conftest.py

@@ -1,14 +0,0 @@
-"""Pytest bootstrap: make first-party modules importable from the tests.
-
-The bot modules live at the repository root and the musician service lives in
-``conjurer_musician/``; neither is an installable package, so we put both on
-``sys.path`` here.
-"""
-import os
-import sys
-
-_ROOT = os.path.dirname(os.path.abspath(__file__))
-
-for _path in (_ROOT, os.path.join(_ROOT, "conjurer_musician")):
-    if _path not in sys.path:
-        sys.path.insert(0, _path)

conjurer_librarian/search_bot.py

@@ -107,7 +107,7 @@ def consumer(in_q, control_q, doi, live_results, result_list, control_dict, no,
 
                 for item in result_list:
                     if item["DOI"] in data and not item["exists"]:
-                        print(f"HIT in {no} content {data[0]} line {data[1]} file {data[2]} {item['exists']}")
+                        print(f"HIT in {no} content {data[0]} line {data[1]} file {data[2]} {item["exists"]}")
                         _logger.info(data)
                         _logger.info("HIT")
                         item["exists"] = True

conjurer_librarian/search_bot2.py

@@ -108,7 +108,7 @@ def consumer(in_q, control_q, doi, live_results, result_list, control_dict, no,
                 print(f"C{no}{alive_no}\r", end="")
                 for item in result_list:
                     if item["DOI"] in data[0] and not item["exists"]:
-                        print(f"HIT in {no} content {data[0]} line {data[1]} file {data[2]} {item['exists']}")
+                        print(f"HIT in {no} content {data[0]} line {data[1]} file {data[2]} {item["exists"]}")
                         item["exists"] = True
                         live_results.append(item)
                     done_check = done_check and item["exists"]

conjurer_musician/media_search_functions.py

@@ -1,44 +1,24 @@
 #!/usr/bin/env python3
-"""Share-list search/publish helpers for the musician service.
-
-Paths are environment-overridable and the share database / directory are
-accessed lazily, so importing this module has no side effects (the previous
-version ran ``SHARE_DIR.mkdir()`` and read the JSON DB at import time, which
-crashed on any host without the Pi's ``/var/www`` / ``/var/log`` layout — and
-made the service untestable).
-"""
+import argparse
 import json
 import os
+import sys
 import uuid
 from pathlib import Path
 
-# CONFIGURATION (env-overridable)
-JSON_DB = os.getenv("CONJURER_SHARE_DB", "/var/log/share_scan.json")
-SHARE_DIR = Path(os.getenv("CONJURER_SHARE_DIR", "/var/www/html/share"))
-BASE_URL = os.getenv("CONJURER_SHARE_BASE_URL", "https://czernobog.pl/share")
+# CONFIGURATION
+JSON_DB        = '/var/log/share_scan.json'
+SHARE_DIR      = Path('/var/www/html/share')
+BASE_URL       = 'https://czernobog.pl/share'
 
-_entries_cache = None
-
-
-def _ensure_share_dir():
+# Ensure share directory exists
 SHARE_DIR.mkdir(parents=True, exist_ok=True)
 
-
 def load_db():
-    """Load share entries, returning [] when the DB is missing/corrupt."""
-    try:
-        with open(JSON_DB) as handle:
-            return json.load(handle).get("entries", [])
-    except (FileNotFoundError, json.JSONDecodeError):
-        return []
-
-
-def _entries():
-    global _entries_cache
-    if _entries_cache is None:
-        _entries_cache = load_db()
-    return _entries_cache
+    with open(JSON_DB) as f:
+        return json.load(f)['entries']
 
+ENTRIES = load_db()
 
 def relevancy(path, keywords):
     score = 0
@@ -48,20 +28,17 @@ def relevancy(path, keywords):
             score += low.count(kw.lower())
     return score
 
-
 def find_matches(count, keywords):
     scored = []
-    for entry in _entries():
-        score = relevancy(entry["path"], keywords)
+    for e in ENTRIES:
+        score = relevancy(e['path'], keywords)
         if score > 0:
-            scored.append((score, entry["path"]))
+            scored.append((score, e['path']))
     scored.sort(reverse=True, key=lambda x: x[0])
     result = [p for _, p in scored]
     return result[:count]
 
-
 def publish(paths):
-    _ensure_share_dir()
     urls = []
     for path in paths:
         token = uuid.uuid4().hex
@@ -72,3 +49,4 @@ def publish(paths):
             pass
         urls.append(f"{BASE_URL}/{token}")
     return urls
+

constants.py

@@ -297,26 +297,3 @@ ALLOWED_ROLES = ["Nocna Zmiana", "Jarl", "Thane", "Bartender"]
 GUILD_ID = 664789470779932693
 LATEST_MODEL = "gpt-4o"          # najnowszy/do rozmów (możesz zmienić w jednym miejscu)
 CHEAP_MODEL  = "gpt-4o-mini"     # najtańszy (fallback do 3.5 niżej)
-
-
-# *=========================================== Conan Exiles bridge
-# Every value is optional; the conanjurer cog stays dormant unless configured.
-# Channel/role ids default to 0 ("not defined"); RCON host/log path default to
-# "" ("disabled"). See conanjurer_commands.py / conanjurer_functions.py.
-CONAN_GM_ROLE_ID = int(os.getenv("CONAN_GM_ROLE_ID", "0"))
-CONAN_CHAT_CHANNEL_ID = int(os.getenv("CONAN_CHAT_CHANNEL_ID", "0"))
-CONAN_EVENTS_CHANNEL_ID = int(os.getenv("CONAN_EVENTS_CHANNEL_ID", "0"))
-# Player-join notifications: leave at 0 to keep the feature disabled.
-CONAN_JOIN_CHANNEL_ID = int(os.getenv("CONAN_JOIN_CHANNEL_ID", "0"))
-CONAN_PLAYER_POLL_SECONDS = int(os.getenv("CONAN_PLAYER_POLL_SECONDS", "60"))
-
-CONAN_RCON_HOST = os.getenv("CONAN_RCON_HOST", "")
-CONAN_RCON_PORT = int(os.getenv("CONAN_RCON_PORT", "25575"))
-CONAN_RCON_PASSWORD = os.getenv("CONAN_RCON_PASSWORD", "")
-
-CONAN_LOG_MODE = os.getenv("CONAN_LOG_MODE", "local")  # "local" | "sftp"
-CONAN_LOG_PATH = os.getenv("CONAN_LOG_PATH", "")
-CONAN_SFTP_HOST = os.getenv("CONAN_SFTP_HOST", "")
-CONAN_SFTP_PORT = int(os.getenv("CONAN_SFTP_PORT", "22"))
-CONAN_SFTP_USER = os.getenv("CONAN_SFTP_USER", "")
-CONAN_SFTP_PASSWORD = os.getenv("CONAN_SFTP_PASSWORD", "")

docs/deployment/MIGRATION_WORKING_COPY_TO_PROTOTYPE.md

@@ -1,231 +0,0 @@
-# Migracja: „working copy" → „prototype"
-
-Runbook upgrade'u działającego deploymentu bota (Raspberry Pi) z wersji
-**working copy** (kod w roocie repo, bez auth między usługami, bez integracji
-Conan) na wersję **prototype** (konfiguracja przez zmienne środowiskowe,
-opcjonalna autoryzacja wewnętrznych wywołań HTTP, integracja Conan Exiles).
-
-> **Najważniejsze:** upgrade jest **wstecznie kompatybilny**. Bez ustawiania
-> żadnych nowych zmiennych bot działa tak jak dotąd — istniejące tokeny z
-> `~/.netrc` i domyślne ścieżki są zachowane. Wszystkie nowe funkcje
-> (autoryzacja API, most Conan, powiadomienia o graczach) są **opt-in**.
-
----
-
-## 0. Status / warunek wstępny
-
-Pełny kod prototype znajduje się obecnie na branchu **`proto-improvements`**.
-Na `main` jest na razie sama restrukturyzacja (working copy w roocie). Zanim
-zmigrujesz produkcję z `main`, zmerguj prototype do `main`
-(`proto-improvements` → `main`) albo deployuj bezpośrednio z brancha
-`proto-improvements`. Dalsza część zakłada, że prototype jest już dostępny pod
-refem, który checkoutujesz w kroku 2.
-
-**Układ deploymentu (bez zmian):**
-
-| | Ścieżka |
-|---|---|
-| Klon repo | `/home/pi/conjurer` |
-| Runtime bota | `/home/pi/Conjurer` |
-| Virtualenv | `/home/pi/Conjurer/env` (używany przez `conjurer.service`) |
-| Usługa systemd | `conjurer.service` → `ExecStart … /home/pi/Conjurer/bot.py` |
-| Deploy | `deploy.sh` (kopiuje pliki z repo do runtime i restartuje usługę) |
-
----
-
-## 1. Backup i punkt powrotu
-
-```bash
-# zapamiętaj aktualny commit (do ewentualnego rollbacku)
-git -C /home/pi/conjurer rev-parse HEAD > /home/pi/conjurer_rollback_commit.txt
-
-# snapshot runtime (config + dane)
-sudo cp -a /home/pi/Conjurer /home/pi/Conjurer.bak.$(date +%Y%m%d_%H%M%S)
-```
-
-Sekrety nadal pochodzą z `~/.netrc` (Discord/OpenAI/Spotify/YouTube) — upewnij
-się, że ten plik istnieje i jest aktualny. Migracja go nie dotyka.
-
----
-
-## 2. Pobranie kodu prototype
-
-```bash
-cd /home/pi/conjurer
-git fetch --all
-git checkout main && git pull          # gdy prototype jest już w main
-# albo, do czasu merge:  git checkout proto-improvements && git pull
-```
-
----
-
-## 3. Instalacja nowych zależności
-
-Wersja prototype dodaje do `requirements_bot.txt` dwa pakiety używane przez most
-Conan: **`aiomcrcon`** i **`asyncssh`**.
-
-```bash
-source /home/pi/Conjurer/env/bin/activate
-python3 -m pip install -r /home/pi/conjurer/requirements_bot.txt
-deactivate
-```
-
-> Nawet bez tych pakietów bot się uruchomi — importy w module Conan są osłonięte
-> (`try/except ImportError`), a integracja pozostaje uśpiona. Instalacja jest
-> potrzebna tylko jeśli faktycznie używasz mostu Conan.
-
----
-
-## 4. (Opcjonalnie) Konfiguracja zmiennych środowiskowych
-
-Wersja prototype czyta konfigurację ze zmiennych środowiskowych z fallbackiem na
-dotychczasowe wartości. **Pomiń ten krok dla zwykłego upgrade'u** — domyślne
-ścieżki i `~/.netrc` wystarczą. Ustaw zmienne tylko gdy włączasz nową funkcję.
-
-### 4a. Plik środowiskowy dla systemd
-
-```bash
-sudo tee /home/pi/Conjurer/conjurer.env >/dev/null <<'EOF'
-# --- Autoryzacja wewnętrznych wywołań HTTP (opcjonalne) ---
-# Ten sam klucz MUSI być ustawiony na bocie, musicianie i librarianie.
-CONJURER_API_KEY=
-
-# --- Adresy usług wewnętrznych (domyślne wartości jak dotąd) ---
-#CONJURER_FILE_SERVICE=http://192.168.1.15:5000
-#CONJURER_RADIO_HARBOR=http://192.168.1.15:54321
-#CONJURER_LIBRARIAN_SERVICE=http://192.168.1.192:5001
-
-# --- Most Conan Exiles (opcjonalne; puste = wyłączone) ---
-#CONAN_GM_ROLE_ID=0
-#CONAN_RCON_HOST=
-#CONAN_RCON_PORT=25575
-#CONAN_RCON_PASSWORD=
-#CONAN_CHAT_CHANNEL_ID=0
-#CONAN_EVENTS_CHANNEL_ID=0
-# Powiadomienia o wejściu gracza — ustaw id kanału, by włączyć:
-#CONAN_JOIN_CHANNEL_ID=0
-#CONAN_PLAYER_POLL_SECONDS=60
-#CONAN_LOG_MODE=local
-#CONAN_LOG_PATH=
-EOF
-sudo chmod 600 /home/pi/Conjurer/conjurer.env
-```
-
-### 4b. Podłączenie pliku do usługi
-
-Dodaj `EnvironmentFile` do sekcji `[Service]` w `conjurer.service`
-(`/etc/systemd/system/conjurer.service`):
-
-```ini
-[Service]
-Type=simple
-EnvironmentFile=/home/pi/Conjurer/conjurer.env
-ExecStart=/home/pi/Conjurer/env/bin/python3 /home/pi/Conjurer/bot.py
-Restart=on-abort
-```
-
-```bash
-sudo systemctl daemon-reload
-```
-
-> `conjurer.service` w repo również warto zaktualizować o tę linię, ale `deploy.sh`
-> **nie** nadpisuje jednostki systemd przy każdym deployu — wpis robisz raz, ręcznie.
-
----
-
-## 5. Deploy i restart
-
-```bash
-cd /home/pi/conjurer
-./deploy.sh        # kopiuje m.in. bot.py oraz conanjurer_commands/_functions.py do runtime
-```
-
-`deploy.sh` na końcu sam wykonuje `systemctl restart conjurer.service`. Jeśli
-zmieniałeś jednostkę systemd w kroku 4b, wcześniej zrób `daemon-reload`.
-
----
-
-## 6. Weryfikacja
-
-```bash
-journalctl -u conjurer.service -f
-```
-
-Czego szukać w logu (`/home/pi/Conjurer` → plik logu również):
-
-- `Loading … module done` dla kolejnych rozszerzeń, w tym **`Loading conanjurer commands module done`**
-- Gdy most Conan nieskonfigurowany: `Conan: log watch disabled (not configured)`
-  oraz `Conan: player-join notifications disabled (no channel or RCON)` — to
-  oczekiwane, integracja jest uśpiona
-- `All systems: operational`
-
-Szybki test funkcjonalny: bot łączy się z Discordem, dotychczasowe komendy
-działają, radio/biblioteka odpowiadają jak wcześniej.
-
----
-
-## 7. Zmiany zachowania, o których warto wiedzieć
-
-| Obszar | Working copy | Prototype |
-|---|---|---|
-| Konfiguracja | zahardkodowana per-platforma | env-vary z fallbackiem na stare wartości |
-| Tokeny | tylko `~/.netrc` | env-var → fallback `~/.netrc` (stare działa) |
-| Wewnętrzne HTTP (music/radio/librarian) | bez nagłówków | wysyła `X-Conjurer-Api-Key`, **gdy** `CONJURER_API_KEY` ustawione |
-| Endpointy przychodzące bota | bez weryfikacji | `_authorize_request()` zwraca 401 przy złym kluczu (no-op gdy klucz pusty) |
-| Pętla bota | wątki + `join()` | pojedyncza pętla asyncio z czystym shutdownem |
-| Moduł Conan | obecny, **nieładowany** (miał SyntaxError) | naprawiony i ładowany; uśpiony bez konfiguracji |
-
----
-
-## 8. Włączanie funkcji opcjonalnych
-
-### 8a. Autoryzacja wewnętrznych wywołań HTTP
-Ustaw **ten sam** `CONJURER_API_KEY` na **wszystkich** usługach: bocie,
-musicianie (`conjurer_musician`) i librarianie. Po ustawieniu:
-- bot dokleja nagłówek do wywołań do file-service/radia/biblioteki,
-- usługi odrzucają (401) żądania bez poprawnego klucza.
-
-⚠️ Ustawienie klucza tylko po jednej stronie zepsuje komunikację (401). Albo
-wszędzie, albo nigdzie.
-
-### 8b. Most Conan Exiles
-Ustaw `CONAN_RCON_HOST` + `CONAN_RCON_PASSWORD` (komendy GM `say/players/kick/
-rcon/ogłoś`) oraz, dla mirrorowania czatu/zdarzeń, `CONAN_LOG_PATH`
-(+ `CONAN_CHAT_CHANNEL_ID`/`CONAN_EVENTS_CHANNEL_ID`).
-
-### 8c. Powiadomienia o wejściu gracza
-Ustaw **`CONAN_JOIN_CHANNEL_ID`** na id kanału Discord. Funkcja odpytuje RCON
-`listplayers` co `CONAN_PLAYER_POLL_SECONDS` i ogłasza nowych graczy. Pozostaw
-`0`, aby trzymać ją wyłączoną.
-
----
-
-## 9. Rollback
-
-```bash
-cd /home/pi/conjurer
-git checkout "$(cat /home/pi/conjurer_rollback_commit.txt)"
-./deploy.sh
-sudo systemctl restart conjurer.service
-```
-
-W razie potrzeby przywróć snapshot runtime z `/home/pi/Conjurer.bak.*`. Nowe
-zależności (`aiomcrcon`, `asyncssh`) mogą zostać w venv — nie przeszkadzają
-starszej wersji.
-
----
-
-## 10. Migracja usługi musician (jeśli prowadzisz radio)
-
-Stabilny wariant `musician_old` (zahardkodowane adresy) został zastąpiony przez
-`conjurer_musician` (env-driven, domyślnie `127.0.0.1`). Jeśli bot i musician są
-na **różnych** hostach, ustaw na musicianie:
-
-```bash
-CONJURER_MAIN_BOT=http://<ip-bota>:5000      # gdzie bot serwuje /prepped_tracks
-CONJURER_API_KEY=<ten sam sekret co bot>     # jeśli włączasz auth (8a)
-CONJURER_MUSIC_FOLDER=/home/pi/MediaShare/mp3
-```
-
-oraz na bocie `CONJURER_FILE_SERVICE=http://<ip-musiciana>:5000`. Szczegóły
-auth/kontraktu — patrz opis usługi `conjurer_musician`.

pytest.ini

@@ -1,5 +0,0 @@
-[pytest]
-testpaths = tests
-python_files = test_*.py
-python_functions = test_*
-addopts = -ra

requirements_bot.txt

@@ -17,6 +17,4 @@ PyMuPDF
 waitress
 assemblyai[extras]
 SpeechRecognition
-aiomcrcon
-asyncssh
 git+https://github.com/imayhaveborkedit/discord-ext-voice-recv

test.py

@@ -0,0 +1,20 @@
+import logging
+from logging import handlers
+
+logger = logging.getLogger("discord")
+logger.setLevel(logging.DEBUG)
+handler = handlers.RotatingFileHandler(
+    filename="test.log",
+    encoding="utf-8",
+    mode="a",
+    maxBytes=6 * 1024 * 1024,
+    backupCount=6,
+)
+formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+
+logger2 = logging.getLogger("discord")
+for item in logger2.handlers:
+    print(item)

test_ai.py

@@ -0,0 +1,13 @@
+AsyncCursorPage[Message](
+    data=[Message(id='msg_3eWSdgbcU8sbCmJK2momOgQQ', 
+                  assistant_id='asst_06eZiwvYNK3MR34suFP60gvg', 
+                  attachments=[], 
+                  completed_at=None, 
+                  content=[TextContentBlock(text=Text(annotations=[], value='Cześć! Oto coś do przemyślenia: \n\n„Sukces to suma niewielkich wysiłków powtarzanych dzień po dniu.” — Robert Collier\n\nTo przypomina nam, że często to nie wielkie działania, ale konsekwentne, małe kroki prowadzą do osiągnięcia celu. Jak mogę Ci dzisiaj pomóc?'), type='text')], created_at=1731620112, incomplete_at=None, incomplete_details=None, metadata={}, object='thread.message', role='assistant', run_id='run_JGjWQTCEkDcEYpyCJnrkZU8Q', status=None, thread_id='thread_dDEjGbGm6ICfG75u0KKpoVxD'), Message(id='msg_GFcnfCFgAthGm2D3oE5d0ZkQ', assistant_id=None, attachments=[], completed_at=None, content=[TextContentBlock(text=Text(annotations=[], value='Cześć! Powiedz coś mądrego'), type='text')], created_at=1731620110, incomplete_at=None, incomplete_details=None, metadata={}, object='thread.message', role='user', run_id=None, status=None, thread_id='thread_dDEjGbGm6ICfG75u0KKpoVxD')], object='list', first_id='msg_3eWSdgbcU8sbCmJK2momOgQQ', last_id='msg_GFcnfCFgAthGm2D3oE5d0ZkQ', has_more=False)
+
+
+[TextContentBlock(
+    text=Text(annotations=[], 
+              value='Cześć! Oto coś do rozważenia: "Największą przeszkodą w naszym życiu jest brak odwagi do wprowadzenia zmian." Niezależnie od tego, jakie masz cele czy marzenia, odwaga do działania i przystosowania się do nowych sytuacji jest kluczem do osiągnięcia sukcesu. Jakie masz przemyślenia na ten temat?'), 
+              type='text')
+]

test_time.py

@@ -0,0 +1,8 @@
+import time
+
+first_time = time.time_ns()
+
+time.sleep(1)
+time_diff = time.time_ns() - first_time
+print(time_diff)
+# 2000149433

tests/integration/test_comm_auth.py

@@ -1,56 +0,0 @@
-"""Integration: the bot's communication Flask layer enforces the shared key,
-and the key the bot would *send* (constants.service_headers) is accepted.
-"""
-import constants
-import communication_subroutine as cs
-
-
-def _client(key="test-secret"):
-    cs.API_KEY = key
-    return cs.app.test_client()
-
-
-def test_prepped_tracks_rejected_without_key():
-    client = _client()
-    resp = client.post(
-        "/prepped_tracks", data='["all", "x"]', content_type="application/json"
-    )
-    assert resp.status_code == 401
-
-
-def test_prepped_tracks_accepted_with_key():
-    client = _client()
-    resp = client.post(
-        "/prepped_tracks",
-        data='["all", "x"]',
-        headers={"X-Conjurer-Api-Key": "test-secret"},
-        content_type="application/json",
-    )
-    assert resp.status_code == 200
-
-
-def test_conjurer_get_is_open():
-    client = _client()
-    assert client.get("/conjurer").status_code == 200
-
-
-def test_open_when_key_unset():
-    client = _client(key=None)
-    resp = client.post(
-        "/prepped_tracks", data='["all", "x"]', content_type="application/json"
-    )
-    assert resp.status_code == 200
-
-
-def test_bot_service_headers_accepted_by_service(monkeypatch):
-    # End-to-end auth contract: the header constants.service_headers() produces
-    # is exactly what communication_subroutine._authorize_request() expects.
-    monkeypatch.setattr(constants, "API_SHARED_KEY", "shared-xyz")
-    cs.API_KEY = "shared-xyz"
-    resp = cs.app.test_client().post(
-        "/prepped_tracks",
-        data='["all", "x"]',
-        headers=constants.service_headers(),
-        content_type="application/json",
-    )
-    assert resp.status_code == 200

tests/integration/test_musician_auth.py

@@ -1,34 +0,0 @@
-"""Integration: the musician Flask service enforces the shared key on its
-authenticated endpoints while leaving the open ones reachable.
-"""
-import conjurer_musician as m
-
-
-def _client(key="test-secret"):
-    m.API_KEY = key
-    return m.app.test_client()
-
-
-def test_clear_pr_pls_rejected_without_key():
-    client = _client()
-    assert client.get("/clear_pr_pls").status_code == 401
-
-
-def test_clear_pr_pls_accepted_with_key():
-    client = _client()
-    resp = client.get(
-        "/clear_pr_pls", headers={"X-Conjurer-Api-Key": "test-secret"}
-    )
-    assert resp.status_code == 200
-
-
-def test_mp3_list_is_open():
-    client = _client()
-    resp = client.get("/mp3")
-    assert resp.status_code == 200
-    assert "music_file_list" in resp.get_json()
-
-
-def test_open_when_key_unset():
-    client = _client(key=None)
-    assert client.get("/clear_pr_pls").status_code == 200

tests/unit/test_conanjurer_functions.py

@@ -1,63 +0,0 @@
-"""Unit tests for the Conan Exiles bridge helpers (no Discord/RCON needed)."""
-import conanjurer_functions as cf
-
-
-def test_parse_players_basic():
-    out = (
-        "Idx | Char name | Player name | User ID\n"
-        "0 | Conan | SteamGuy | 1\n"
-        "1 | Khasar | OtherGuy | 2\n"
-        "--- | --- | --- | ---"
-    )
-    assert cf.parse_players(out) == {"Conan", "Khasar"}
-
-
-def test_parse_players_empty_inputs():
-    assert cf.parse_players("No players connected.") == set()
-    assert cf.parse_players("") == set()
-
-
-def test_parse_line_login():
-    event = cf.parse_line("SomeGuy joined the server")
-    assert event is not None
-    assert event.kind == "login"
-    assert "SomeGuy" in event.text
-
-
-def test_parse_line_chat():
-    event = cf.parse_line("Chat: Bob: hello there")
-    assert event is not None
-    assert event.kind == "chat"
-    assert "Bob" in event.text and "hello" in event.text
-
-
-def test_parse_line_unrecognised_is_ignored():
-    assert cf.parse_line("random server noise") is None
-
-
-def test_conanconfig_disabled_when_unconfigured():
-    cfg = cf.ConanConfig("", 25575, "", "local", "", "", 22, "", "")
-    assert cfg.rcon_enabled is False
-    assert cfg.log_enabled is False
-
-
-def test_conanconfig_local_log_enabled():
-    cfg = cf.ConanConfig("", 0, "", "local", "/tmp/conan.log", "", 22, "", "")
-    assert cfg.log_enabled is True
-
-
-def test_conanconfig_rcon_enabled_requires_lib(monkeypatch):
-    # Without aiomcrcon installed, rcon stays disabled even when host+pw are set.
-    monkeypatch.setattr(cf, "_Rcon", None)
-    cfg = cf.ConanConfig("1.2.3.4", 25575, "pw", "local", "", "", 22, "", "")
-    assert cfg.rcon_enabled is False
-    # With the lib present, it enables.
-    monkeypatch.setattr(cf, "_Rcon", object)
-    cfg2 = cf.ConanConfig("1.2.3.4", 25575, "pw", "local", "", "", 22, "", "")
-    assert cfg2.rcon_enabled is True
-
-
-def test_conanconfig_sftp_log_requires_asyncssh(monkeypatch):
-    monkeypatch.setattr(cf, "asyncssh", None)
-    cfg = cf.ConanConfig("", 0, "", "sftp", "/log", "sftp.host", 22, "u", "p")
-    assert cfg.log_enabled is False

tests/unit/test_constants.py

@@ -1,35 +0,0 @@
-"""Unit tests for constants helpers (defensive config / auth headers)."""
-import constants
-
-
-def test_service_headers_empty_when_no_key(monkeypatch):
-    monkeypatch.setattr(constants, "API_SHARED_KEY", "")
-    assert constants.service_headers() == {}
-
-
-def test_service_headers_with_key(monkeypatch):
-    monkeypatch.setattr(constants, "API_SHARED_KEY", "s3cr3t")
-    assert constants.service_headers() == {"X-Conjurer-Api-Key": "s3cr3t"}
-
-
-def test_load_json_missing_returns_fallback(tmp_path):
-    missing = tmp_path / "nope.json"
-    assert constants._load_json(str(missing), {"fallback": 1}) == {"fallback": 1}
-
-
-def test_load_json_valid(tmp_path):
-    good = tmp_path / "ok.json"
-    good.write_text('{"a": 2}', encoding="utf-8")
-    assert constants._load_json(str(good), {}) == {"a": 2}
-
-
-def test_load_json_corrupt_returns_fallback(tmp_path):
-    bad = tmp_path / "bad.json"
-    bad.write_text("{ not valid json", encoding="utf-8")
-    assert constants._load_json(str(bad), []) == []
-
-
-def test_conan_defaults_present():
-    # Feature toggles default to "off" so the bridge stays dormant.
-    assert constants.CONAN_JOIN_CHANNEL_ID == 0
-    assert constants.CONAN_RCON_HOST == ""