Server side work

Deployable script for windows file service
Music service (#5 )
2026-07-15 05:48:35 +00:00 · 2024-04-17 21:24:26 +02:00 · 2024-04-17 21:24:25 +02:00 · 2024-04-17 20:40:43 +02:00 · 2024-04-17 20:33:12 +02:00 · 2024-04-17 12:34:48 +02:00
122 changed files with 4616 additions and 8893 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.*
@@ -197,8 +197,3 @@ node_modules/prettier/esm/parser-postcss.mjs
 node_modules/prettier/esm/parser-typescript.mjs
 node_modules/prettier/esm/parser-yaml.mjs
 node_modules/prettier/esm/standalone.mjs
 cr_results.json
 not_in_db.json
 rr_results.json
 s_results.json
 *.bak
@@ -1,7 +0,0 @@
 enable=all
 source-path=SCRIPTDIR
 disable=SC2154
 # If you're having issues with shellcheck following source, disable the errors via:
 # disable=SC1090
 # disable=SC1091
@@ -2,38 +2,34 @@
 # To learn more about the format of this file, see https://docs.trunk.io/reference/trunk-yaml
 version: 0.1
 cli:
-  version: 1.22.2
+  version: 1.20.1
 # Trunk provides extensibility via plugins. (https://docs.trunk.io/plugins)
 plugins:
  sources:
    - id: trunk
-      ref: v1.6.0
+      ref: v1.4.5
      uri: https://github.com/trunk-io/plugins
 # Many linters and tools depend on runtimes - configure them here. (https://docs.trunk.io/runtimes)
 runtimes:
  enabled:
    - go@1.21.0
    - node@18.12.1
    - python@3.10.8
 # This is the section where you manage your linters. (https://docs.trunk.io/check/configuration)
 lint:
  enabled:
-    - shellcheck@0.10.0
+    - actionlint@1.6.27
-    - shfmt@3.6.0
+    - bandit@1.7.8
-    - taplo@0.8.1
+    - black@24.3.0
    - actionlint@1.7.1
    - bandit@1.7.9
    - black@24.4.2
    - codespell
-    - checkov@3.2.139
+    - checkov@3.2.48
    - git-diff-check
    - isort@5.13.2
    - pylint
-    - markdownlint@0.41.0
+    - markdownlint@0.39.0
-    - prettier@3.3.2
+    - prettier@3.2.5
-    - ruff@0.4.9
+    - ruff@0.3.4
-    - trivy@0.52.2
+    - trivy@0.50.1
-    - trufflehog@3.78.1
+    - trufflehog@3.71.0
    - yamllint@1.35.1
 actions:
  disabled:
@@ -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,263 +0,0 @@
 import json
 import logging
 import os
 import random
 import re
 import shutil
 from datetime import datetime
 import discord
 import numpy as np
 from discord.ext import commands, tasks
 from ai_functions import get_random_cyclic_message
 from constants import (
    ENCODING,
    LAST_SPONTANEOUS_CALL,
    LOGFILE,
    LOGSTORE,
    MEMORY_FIVE_MUZYKA,
    MEMORY_FIVE_SIARA,
    TIME_BETWEEN_CALLS,
 )
 class AdministrationModule(commands.Cog):
    def __init__(self, bot, logger_name):
        self.bot = bot
        self.logger = logging.getLogger(logger_name)
    @commands.hybrid_command(
        name="galeria_slaw",
        description="Jeśli nie wiesz jak użyć tej komendy to nawet nie próbuj",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def galeria_slaw(self, ctx):
        if isinstance(ctx.channel, discord.DMChannel):
            for guild in self.bot.guilds:
                async for entry in guild.bans(limit=1500):
                    fnord = discord.File(
                        "/home/pi/Conjurer/niech_spierdala.png",
                        spoiler=False,
                        description="Niech spierdala",
                    )
                    await ctx.reply(
                        f"User: {entry.user} wyjebany z serwera {guild.name} za {entry.reason} ",
                        file=fnord,
                    )
    @commands.hybrid_command(
        name="update_banlist",
        description="Jeśli nie wiesz jak użyć tej komendy to nawet nie próbuj",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Jarl', 'Thane')
    async def update_banlist(self, ctx):
        """
        Update a banlist in a Discord guild from preprovided list in channel.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        contains information about the context in which the command was invoked, such as the message, the
        channel, the server, and the user who invoked the command. This information can be used to perform
        various actions, such
        """
        async with ctx.channel.typing():
            allowed = False
            for role in ctx.author.roles:
                if role.name == "Jarl":
                    allowed = True
            if ctx.channel.id != 1102190666827702342:
                # trunk-ignore(codespell/misspelled)
                await ctx.send("Nie wydaje mnie sie")
            elif not allowed:
                await ctx.send("Idź bo Cię zdziele")
            else:
                tobancunter = 0
                async with ctx.typing():
                    # 1. get list of users posted on channel for banning
                    channel = ctx.channel
                    messages = [
                        message async for message in channel.history(limit=None)
                    ]
                    ids_to_ban = []
                    for message in messages:
                        lines = message.content.split("\n")
                        for line in lines:
                            match = re.search(
                                "\\d{18}",
                                line,
                                # trunk-ignore(codespell/misspelled)
                            )  # poprawilem backslash na podwojny bo linter sie czepial
                            if match:
                                ids_to_ban.append(match.group())
                                tobancunter += 1
                    # 2. get list of already banned users for all servers Conjurer
                    # has rights to
                    for guild in self.bot.guilds:
                        bancunter = 0
                        # trunk-ignore(codespell/misspelled)
                        self.logger.info("Serwer: %s", guild)
                        current_banlist = []
                        permission = True
                        try:
                            async for entry in guild.bans(limit=None):
                                current_banlist.append(entry.user.id)
                                bancunter += 1
                        except BaseException:  # pylint: disable=broad-exception-caught
                            permission = False
                        if permission:
                            # 3. compare lists ban only users on list 2 and not on
                            # list 1
                            cunter_counter = 0
                            bad_id_cunter_counter = 0
                            ban_list = np.setdiff1d(ids_to_ban, current_banlist)
                            for ident in ban_list:
                                try:
                                    tmp_user = await self.bot.fetch_user(int(ident))
                                    await guild.ban(
                                        tmp_user,
                                        reason="Automatyczna lista banów",
                                        delete_message_seconds=0,
                                    )
                                    # TODO: Maybe use guild.bulk_ban ?
                                    cunter_counter += 1
                                except discord.NotFound:
                                    self.logger.info(
                                        "Znaleziono uzyszkodnika ktory juz nie ma konta"
                                    )
                                    bad_id_cunter_counter += 1
                            # 4. return message success/failure - how many banned
                            await ctx.send(
                                "Obecnie na serwerze {guild} jest {bancunter} zbanowanych użytkowników. Znaleziono na tym kanale {tobancunter} id użytkowników do zbanowania. Zbanowano {cunter_counter} użytkowników. Na liście jest {bad_id_cunter_counter} użytkowników którzy skasowali już konto"
                            )
                        else:
                            await ctx.send(
                                f"Nie mam na serwerze {guild} uprawnień do banowania. :()"
                            )
                await ctx.send("Zrobione tak czy inaczej")
    @commands.hybrid_command(
        name="archive_channel",
        description="Jeśli nie wiesz jak użyć tej komendy to nawet nie próbuj",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Jarl', 'Thane')
    async def archive_channel(self, channel_no):
        """
        The function `archive_channel` retrieves messages from a specified channel, processes them, and
        saves the data in a JSON file with a timestamp in the filename.
        :param channel_no: The `archive_channel` function you provided seems to be incomplete. It looks like
        you are trying to archive messages from a Discord channel into a JSON file
        """
        channel = self.bot.get_channel(channel_no)
        messages = [message async for message in channel.history(limit=None)]
        path_newfile = f"{LOGSTORE}channeldump_{channel_no}_{datetime.now()}.json"
        new_data = []
        for message in messages:
            new_data.append(message)
        with open(path_newfile, "x", encoding=ENCODING) as new_file:
            new_file.seek(0)
            json.dump(new_data, new_file, indent=4)
    @tasks.loop(seconds=120)
    async def check_self(self):
        """
        The function `check_data` periodically checks for conditions to send messages and manage log files
        in a Discord channel.
        """
        # logger.info("Heartbeat of cleanup proc")
        channel = self.bot.get_channel(1062047367337095268)
        messages = [message async for message in channel.history(limit=1)]
        for mess in messages:
            channel = mess.channel
        if os.path.getsize(LOGFILE) > 60000000:
            await channel.send(
                "*Conjurer porządkuje bar, wypala szklanki do czysta miotaczem płomieni ze swojej zbroi i ogólnie wygląda na zajętego....*"
            )
            async with channel.typing():
                shutil.copyfile(LOGFILE, f"{LOGSTORE}discord{datetime.now()}")
                self.logger.info("Log rollover")
                handlers = self.logger.handlers
                for handler in handlers:
                    if isinstance(handler, logging.handlers.RotatingFileHandler):
                        handler.doRollover()
                await channel.send(
                    "*Przeciąga się za barem* No dobra - porobione to można dalej pi... *Zauważa spojrzenie Hammera* ...sać powieści o naszym wspaniałym barze SZEFIE!"
                )
        if os.path.getsize(MEMORY_FIVE_MUZYKA) > 3000000:
            await channel.send(
                "*Conjurer porządkuje bar, wypala szklanki do czysta miotaczem płomieni ze swojej zbroi i ogólnie wygląda na zajętego....*"
            )
            async with channel.typing():
                path_newfile = f"{LOGSTORE}pamiec_muzyki{datetime.now()}.json"
                self.logger.info(path_newfile)
                with open(
                    MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING
                ) as file_music_memory:
                    with open(path_newfile, "x", encoding=ENCODING) as new_file:
                        # First we load existing data into a dict.
                        file_data = json.load(file_music_memory)
                        new_data = []
                        new_data.append(file_data[0])
                        new_data.extend(file_data[:-20])
                        file_music_memory.truncate(0)
                        file_music_memory.seek(0)
                        # convert back to json.
                        new_file.seek(0)
                        json.dump(new_data, file_music_memory, indent=4)
                        json.dump(file_data, new_file, indent=4)
                        await channel.send(
                            "*Przeciąga się za barem* No dobra - porobione to można dalej pi... *Zauważa spojrzenie Hammera* ...sać powieści o naszym wspaniałym barze SZEFIE!"
                        )
        if os.path.getsize(MEMORY_FIVE_SIARA) > 3000000:
            path_newfile = f"{LOGSTORE}pamiec_rozmow{datetime.now()}.json"
            self.logger.info(path_newfile)
            await channel.send(
                "*Conjurer porządkuje bar, ścina lekkim laserem pulsacyjnym powierzchnie baru o grubości kilku mikronów i ogólnie wygląda na zajętego....*"
            )
            with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file:
                with open(path_newfile, "x", encoding=ENCODING) as new_file:
                    # First we load existing data into a dict.
                    file_data = json.load(file)
                    new_data = []
                    new_data.append(file_data[0])
                    new_data.extend(file_data[-20])
                    file.truncate(0)
                    file.seek(0)
                    new_file.seek(0)
                    # convert back to json.
                    json.dump(new_data, file, indent=4)
                    json.dump(file_data, new_file, indent=4)
                    await channel.send(
                        "*Przeciąga się za barem* No dobra - porobione to można dalej pi... *Zauważa spojrzenie Hammera* eprzyć o głupotach z klientami... Szefie... *Bierze 'ukradkowy' łyk z piersiówki*"
                    )
        global LAST_SPONTANEOUS_CALL
        global TIME_BETWEEN_CALLS
        tdelta = datetime.now() - LAST_SPONTANEOUS_CALL
        tdelta = tdelta.total_seconds()
        if tdelta > TIME_BETWEEN_CALLS:
            self.logger.info("Spontaneous call")
            # trunk-ignore(bandit/B311)
            TIME_BETWEEN_CALLS = random.randint(
                10200, 272800
            )  # temp random, set after each call
            self.logger.debug(TIME_BETWEEN_CALLS)
            LAST_SPONTANEOUS_CALL = datetime.now()
            async with channel.typing():
                message = await get_random_cyclic_message(self.bot)
                self.logger.info("Odpowiedz")
                self.logger.info(message)
                await channel.send(message)
 async def setup(bot):
    logger = logging.getLogger("discord")
    am = AdministrationModule(bot, "discord")
    await bot.add_cog(am)
    am.check_self.start()
    logger.info("Loading administration commands module done")
@@ -1,403 +0,0 @@
 # ai command cogs
 import logging
 import re
 import sys
 from datetime import datetime
 from enum import Enum
 from typing import Optional
 from pathlib import Path
 import discord
 import openai
 import requests
 from discord.ext import commands
 from other_functions import discord_friendly_send, discord_friendly_reply
 import ai_functions
 from constants import (
    ASSISTANTS,
    DATA,
    GRAPHICS_PATH,
    INITIAL_TIME_WAIT,
    MASTER_TIMEOUT,
    MESSAGE_TABLE,
    OPENAICLIENT,
    SPECJALNE_ZIEMNIACZKI,
    WORD_REACTIONS,
 )
 class Dm_Mode(Enum):
    ARMIA_HAMMERA = (1,)
    SPECJALNY_ZIEMNIACZEK = (2,)
    SEKRETNY_SEKSRET = (3,)
    ECHO_ECHO = (4,)
 class Events(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.logger = logging.getLogger("discord")
        self.armia = {}
        for superfryta in SPECJALNE_ZIEMNIACZKI.values():
            self.armia[superfryta[0]] = Dm_Mode.SPECJALNY_ZIEMNIACZEK
        self.logger.info(self.armia)
    async def cog_load(self):
        self.logger.info("Starting personal assistants")
        for superfryta_id, superfryta in SPECJALNE_ZIEMNIACZKI.items():
            if superfryta[4] != "":
                self.logger.info(
                    "Personal assistant for user: %s, exists id: %s,name: %s, owner: %s, special instructions: %s assistant id: %s ",
                    superfryta_id,
                    superfryta[0],
                    superfryta[1],
                    superfryta[2],
                    superfryta[3],
                    superfryta[4],
                )
                thread = await OPENAICLIENT.beta.threads.create()
                self.logger.info("Thread id: %s", thread.id)
                ASSISTANTS[superfryta[1]] = (
                    superfryta[2],
                    superfryta[4],
                    superfryta[0],
                    thread,
                )
            else:
                self.logger.info(
                    "Creating personal assistant for user: %s, id: %s,name: %s, owner: %s, special instructions: %s",
                    superfryta_id,
                    superfryta[0],
                    superfryta[1],
                    superfryta[2],
                    superfryta[3],
                )
                await ai_functions.create_chat_assistant(
                    superfryta_id, superfryta[0], superfryta[1], superfryta[2], superfryta[3]
                )
        self.logger.info("Started personal assistants")
    @commands.hybrid_command(
        name="switch_dm_mode",
        description="Jeśli nie wiesz jak użyć tej komendy to nawet nie próbuj",
        guild=discord.Object(id=664789470779932693),
    )
    async def switch_dm_mode(self, ctx, dm_mode_arg: Dm_Mode):
        async with ctx.channel.typing():
            if isinstance(ctx.channel, discord.DMChannel):
                for superfryta in SPECJALNE_ZIEMNIACZKI.values():
                    self.logger.info(ctx.message.author.id)
                    self.logger.info(superfryta)
                    if ctx.message.author.id == superfryta[0]:
                        self.armia[ctx.message.author.id] = dm_mode_arg
                        self.logger.info(self.armia)
                        await ctx.reply("Weszlo")
                        return
                await ctx.reply(
                    "Tylko członkowie Armii Hammera mogą używać. Nie jesteś jednym z nich"
                )
            else:
                await ctx.reply("Nope. Nie wiesz jak użyć")
    @commands.hybrid_command(
        name="armia_hammera",
        description="Jeśli nie wiesz jak użyć tej komendy to nawet nie próbuj",
    )
    async def armia_hammera(
        self, ctx, message_txt: str, recipient: Optional[discord.User]
    ):
        for superfryta in SPECJALNE_ZIEMNIACZKI.values():
            if ctx.message.author.id == superfryta[0]:
                await self.armia_hammera_back(ctx, message_txt, recipient)
                return
        await ctx.reply("Tylko członkowie Armii Hammera mogą używać. Nie jesteś jednym z nich")
    async def armia_hammera_back(self, ctx, message_txt, recipient=None):
        self.logger.info("Armia Hammera")
        recipients = []
        if recipient:
            recipients.append(recipient.id)
        else:
            for superfryta in SPECJALNE_ZIEMNIACZKI.values():
                recipients.append(superfryta[0])
        self.logger.info(recipients)
        for item in recipients:
            user = await self.bot.fetch_user(item)
            channel = await user.create_dm()
            self.logger.info(
                "User %s ->  %s: %s", ctx.message.author, user, message_txt
            )
            await discord_friendly_send(channel, message_txt)
        await discord_friendly_reply(ctx, "Poszło")
    #TODO: NOT IMPLEMENTED YET
    @commands.Cog.listener(name="dodaj_do_bazy_wiedzy")
    async def dodaj_do_bazy_wiedzy(self, ctx):
        for superfryta in SPECJALNE_ZIEMNIACZKI.values():
            if ctx.message.author.id == superfryta[0]:
                #logic here
                return
        await ctx.reply("Tylko członkowie Armii Hammera mogą używać. Nie jesteś jednym z nich")
    #TODO: NOT IMPLEMENTED YET
    @commands.Cog.listener(name="listuj_baze_wiedzy")
    async def listuj_baze_wiedzy(self, ctx):
        for superfryta in SPECJALNE_ZIEMNIACZKI.values():
            if ctx.message.author.id == superfryta[0]:
                #logic here
                return
        await ctx.reply("Tylko członkowie Armii Hammera mogą używać. Nie jesteś jednym z nich")
    #TODO: NOT IMPLEMENTED YET
    @commands.Cog.listener(name="usun_z_bazy_wiedzy")
    async def usun_z_bazy_wiedzy(self, ctx):
        for superfryta in SPECJALNE_ZIEMNIACZKI.values():
            if ctx.message.author.id == superfryta[0]:
                #logic here
                return
        await ctx.reply("Tylko członkowie Armii Hammera mogą używać. Nie jesteś jednym z nich")
    #TODO: NOT IMPLEMENTED YET
    @commands.Cog.listener(name="przetworz_plik_linia_po_linii")
    async def przetworz_plik_linia_po_linii(self, ctx):
        for superfryta in SPECJALNE_ZIEMNIACZKI.values():
            if ctx.message.author.id == superfryta[0]:
                #logic here
                return
        await ctx.reply("Tylko członkowie Armii Hammera mogą używać. Nie jesteś jednym z nich")
    @commands.Cog.listener()
    async def on_message(self, message):
        """
        Handle incoming messages in a Discord server, perform various
        checks and actions based on the content and context of the message, and respond accordingly.
        :param message: The message object that is received when a user sends a message in a Discord server
        or DM. The code is checking various conditions and performing actions based on the content of the
        message and the context in which it was sent. It also includes TODOs for future improvements
        :return: The function `on_message` is being returned.
        """
        vykidailo = False
        channel = None
        if message.author == self.bot.user:
            return
        if isinstance(message.author, discord.Member):
            for role in message.author.roles:
                if role.name == "Vykidailo":
                    vykidailo = True
        if ("Conjurer Śpij Słodko Aniołku" in message.content) and vykidailo:
            sys.exit()
        # kanal bez bota
        if message.channel.id == 1095985579147141202:
            return
        # wentylacja
        if message.channel.id == 1083804024173764739:
            return
        # legendy
        if message.channel.id == 1084448332841230388:
            return
        # interrogation booth
        if message.channel.id == 1111625221171052595:
            return
        if isinstance(message.channel, discord.DMChannel):
            self.logger.info(message.author.id)
            for superfryta in SPECJALNE_ZIEMNIACZKI.values():
                self.logger.info(superfryta[0])
                if message.author.id == superfryta[0]:
                    self.logger.info("Specjalny ziemniak")
                    if self.armia[message.author.id] == Dm_Mode.SPECJALNY_ZIEMNIACZEK:
                        #await self.bot.process_commands(message)
                        await ai_functions.chat_with_assistant(message, superfryta[1])
                        return
                    elif self.armia[message.author.id] == Dm_Mode.ECHO_ECHO:
                        await ai_functions.echo(message)
                        return
                    elif self.armia[message.author.id] == Dm_Mode.ARMIA_HAMMERA:
                        self.logger.info("Armia Hammera get context")
                        ctx = await self.bot.get_context(message)
                        self.logger.info("Armia Hammera function call")
                        await self.armia_hammera_back(ctx=ctx, message_txt=message.content)
                        return
                    elif self.armia[message.author.id] == Dm_Mode.SEKRETNY_SEKSRET:
                        pass
                    else:
                        await discord_friendly_send(message.channel,"Coś się wyebao. Wołaj Hammera")
                        return
            channel = self.bot.get_channel(1064888712565100614)
            await discord_friendly_send(channel, "Słyszałem ja żem że: " + message.content)
            return
        channel = message.channel
        message_content_lower = message.content.lower()
        tdelta = datetime.now() - MASTER_TIMEOUT
        tdelta = tdelta.total_seconds()
        if "opowiedz o fabryczce" in message_content_lower:
            await message.reply(DATA["fabryczka"])
        if "opowiedz mi o fabryczce" in message_content_lower:
            await message.reply(DATA["fabryczka"])
        if tdelta > INITIAL_TIME_WAIT:
            for word in WORD_REACTIONS:
                if re.search(r"\b" + word + r"\b", message_content_lower):
                    tdelta = datetime.now() - WORD_REACTIONS[word][2]
                    tdelta = tdelta.total_seconds()
                    security_clearance = WORD_REACTIONS[word][4]
                    reaction = WORD_REACTIONS[word][3]
                    if tdelta > WORD_REACTIONS[word][1]:
                        # TODO: to zrobic reactiony
                        self.logger.info("Ping z procedury reakcji")
                        if reaction:
                            emoji = self.bot.get_emoji(WORD_REACTIONS[word][0])
                            await message.add_reaction(emoji)
                        elif security_clearance and vykidailo:
                            await message.reply(WORD_REACTIONS[word][0])
                        elif not security_clearance:
                            await message.reply(WORD_REACTIONS[word][0])
                        WORD_REACTIONS[word][2] = datetime.now()
        # TODO: drobne literówki, mentiony, spacja przed dwukropkiem. napraw.
        kondziu_mentioned = False
        for mention in message.mentions:
            if mention == self.bot.user:
                kondziu_mentioned = True
        if kondziu_mentioned or "conjurer:" in message_content_lower:
            async with channel.typing():
                self.logger.info("Procedura chatu")
                message_content_lower = message_content_lower.replace("conjurer: ", "")
                if message.author.nick:
                    username = message.author.nick
                else:
                    username = message.author.name
                vykidailo = False
                bartender = False
                if kondziu_mentioned:
                    prompt = message.clean_content
                else:
                    prompt = message.content
                for role in message.author.roles:
                    if role.name == "Vykidailo":
                        vykidailo = True
                    if role.name == "Bartender":
                        bartender = True
                global MESSAGE_TABLE  # pylint: disable=global-statement
                result, MESSAGE_TABLE = await ai_functions.handle_response(
                    prompt,
                    vykidailo,
                    bartender,
                    MESSAGE_TABLE,
                    username,
                    "GENERAL",
                )
                await discord_friendly_reply(message, result)
        if "imaginuje sobie:" in message.content:
            async with channel.typing():
                self.logger.info("Poczatek procedury obrazkowej")
                message_content_lower = message_content_lower.replace("imaginuje sobie: ", "")
                self.logger.debug("Wywolanie obrazka: %s", message_content_lower)
                try:
                    response = await OPENAICLIENT.images.generate(
                        model="dall-e-3",
                        prompt=message.content,
                        size="1024x1024",
                        quality="standard",
                        n=1,
                    )
                except openai.APITimeoutError as e:
                    # Handle timeout error, e.g. retry or log
                    await discord_friendly_reply(
                        message, f"*Kondziu patrzy na terminal, czeka, czeka, czeka,.... Jeszcze chwile czeka Przypierdala w niego pięścią....* Nie mogę się połączyć z Openai spróbuj od nowa. *Na ekranie pojawia się*: {e}"
                    )
                except openai.APIConnectionError as e:
                    await discord_friendly_reply(
                        message, f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Nie mogę się połączyć z Openai. *Na ekranie pojawia się*: {e}"
                    )
                except openai.BadRequestError as e:
                    # Handle invalid request error, e.g. validate parameters or log
                    if message.author.nick:
                        username = message.author.nick
                    else:
                        username = message.author.name
                    resp, _ = await ai_functions.handle_response(
                        f"Wytlumacz jakie sa zasady dotyczące treści które możesz generować używając Dalle. Wytłumacz błąd {e} prostym językiem. Przeproś za nadmierną cenzurę. Wytłumacz co mogło być nie tak w prompcie '{message.content}'",
                        True,
                        True,
                        MESSAGE_TABLE,
                        username,
                        "GENERAL",
                    )
                    await discord_friendly_reply(
                        message, f"Sorki, cenzura: {resp}. Jak chcesz to są kanały na nudle #sexy-foteczky i #kanal-do-fapania *Na ekranie pojawia się: {e}"
                    )
                except openai.AuthenticationError as e:
                    # Handle authentication error, e.g. check credentials or log
                    await discord_friendly_reply(
                        message, f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Wołaj szefa - coś się z hasłem zjebało. *Na terminalu pojawia się:* {e}"
                    )
                except openai.PermissionDeniedError as e:
                    # Handle permission error, e.g. check scope or log
                    await discord_friendly_reply(
                        (
                            message, f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Wołaj szefa - coś się z uprawnieniami zjebało. *Na terminalu pojawia się:* {e}"
                        )
                    )
                except openai.RateLimitError as e:
                    await discord_friendly_reply(
                        message, f"*Kondziu patrzy na terminal* Wołaj szefa. Zapłacić rachunki za AI trzeba. Jak chcesz to się na #zebranie dorzuć. {e}"
                    )
                except openai.APIError as e:
                    # Handle API error, e.g. retry or log
                    await discord_friendly_reply(
                        message, f"*Kondziu nurkuje za bar, terminal wybucha. Przed tobą ląduje pergamin zapisany pięknym gotykiem a na nim*: {e}"
                    )
                if response:
                    self.logger.info(response)
                    image_url = response.data[0].url
                    image_desc = response.data[0].revised_prompt
                    self.logger.debug("Wynikowy obrazek pod url: %s", image_url)
                    response = requests.get(image_url, timeout=360)
                    temp_file_name = message.content + ".png"
                    temp_file_name = GRAPHICS_PATH + message.content + ".png"
                    num = 0
                    while (Path(temp_file_name)).exists():
                        temp_file_name = GRAPHICS_PATH + message.content + str(num) +  ".png"
                        num += 1
                    try:
                       with open(temp_file_name, "wb") as dalle_file:
                           dalle_file.write(response.content)
                    except OSError:
                       temp_file_name = "/home/pi/oserror.png"
                       with open(temp_file_name, "wb") as dalle_file:
                           dalle_file.write(response.content)
                    except FileNotFoundError:
                       temp_file_name = "/home/pi/fnferror.png"
                       with open(temp_file_name, "wb") as dalle_file:
                           dalle_file.write(response.content)
                    except Exception as e:
                        self.logger.error("Nieznany błąd: %s", e)
                        temp_file_name = "/home/pi/error.png"
                        with open(temp_file_name, "wb") as dalle_file:
                            dalle_file.write(response.content)
                    finally:
                        self.logger.info("Koniec procedury obrazkowej.")
                        fnord = discord.File(
                            temp_file_name, spoiler=False, description=message.content
                        )
                #await message.reply(f"{image_desc}", file=fnord)
                await discord_friendly_reply(message,f"{image_desc}", file = fnord)
 # *=========================================== Define Functions
 async def setup(bot):
    logger = logging.getLogger("discord")
    await bot.add_cog(Events(bot))
    logger.info("Loading ai events module done")
@@ -1,449 +0,0 @@
 import asyncio
 import json
 import logging
 import random
 import openai
 import tiktoken
 import time
 from other_functions import discord_friendly_send
 from constants import (
    ASSISTANTS,
    CYCLIC_WORDS,
    ENCODING,
    GPT_SETTINGS,
    MEMORY_FIVE_MUZYKA,
    MEMORY_FIVE_SIARA,
    MESSAGE_TABLE,
    MESSAGE_TABLE_MUZYKA,
    OPENAICLIENT,
    SYSTEM_GPT_SETTINGS,
    WORD_REACTIONS,
    CHEAP_MODEL,
    LATEST_MODEL
 )
 # this do per user
 VECTOR_STORE_ID = -1
 def select_model(req_type: str, algo: str) -> str:
    # Jeżeli jawnie podano algorithm (i nie jest 'auto'/''):
    if algo and str(algo).strip().lower() not in ("auto",):
        # wyjątek: MUZYKA ma zawsze być tania — nadpisujemy TYLKO jeśli przyszedł domyślny 'gpt-4o'
        if req_type == "MUSIC" and algo.strip() in (LATEST_MODEL,):
            return CHEAP_MODEL
        return algo
    # Auto-dobór:
    if req_type == "MUSIC":
        return CHEAP_MODEL
    return LATEST_MODEL
 async def openai_call(messages, model, temperature=0.2):
    """
    Responses API dla 4o/4.1*, fallback Chat Completions dla gpt-3.5-turbo.
    Zwraca czysty string odpowiedzi.
    """
    logger = logging.getLogger("discord")
    if model.startswith("gpt-3.5"):
        logger.info("3.5")
        # legacy path – bez zmian w Twoim kodzie wyżej/niżej
        resp = await OPENAICLIENT.chat.completions.create(
            model=model,
            messages=messages,
            temperature=temperature,
        )
        result = ""
        for choice in resp.choices:
            result += choice.message.content
        return result.strip()
    else:
        logger.info("4.0+")
        # Responses API (zalecane dla 4o/4.1*)
        resp = await OPENAICLIENT.responses.create(
            model=model,
            temperature=temperature,
            input=messages,
        )
        # SDK zapewnia output_text dla zwykłych odpowiedzi
        return (getattr(resp.output_text, "output_text", None) or "").strip() or str(
            resp.output_text
        )
 def create_vector_store():
    # Create a vector store caled "Financial Statements"
    return OPENAICLIENT.beta.vector_stores.create_and_poll(name="Hammer Stash")
    # expires_after={
    # "anchor": "last_active_at",
    # "days": 7}
    # )
 def upload_files_to_vector_store(assistant):
    # Ready the files for upload to OpenAI
    file_paths = ["edgar/goog-10k.pdf", "edgar/brka-10k.txt"]
    file_streams = [open(path, "rb") for path in file_paths]
    # file = client.beta.vector_stores.files.create_and_poll(
    # vector_store_id="vs_abc123",
    # file_id="file-abc123"
    # )
    # batch = client.beta.vector_stores.file_batches.create_and_poll(
    # vector_store_id="vs_abc123",
    # file_ids=['file_1', 'file_2', 'file_3', 'file_4', 'file_5']
    # )
    # Use the upload and poll SDK helper to upload the files, add them to the vector store,
    # and poll the status of the file batch for completion.
    file_batch = OPENAICLIENT.beta.vector_stores.file_batches.upload_and_poll(
        vector_store_id=VECTOR_STORE_ID, files=file_streams
    )
    # You can print the status and the file counts of the batch to see the result of this operation.
    print(file_batch.status)
    print(file_batch.file_counts)
    assistant = OPENAICLIENT.beta.assistants.update(
        assistant_id=assistant.id,
        tool_resources={"file_search": {"vector_store_ids": [VECTOR_STORE_ID]}},
    )
 def delete_files_from_vector_store(assistant, file_id):
    result = OPENAICLIENT.beta.vector_stores.file_batches.delete(
        vector_store_id=VECTOR_STORE_ID, files=file_id
    )
    # You can print the status and the file counts of the batch to see the result of this operation.
    print(result)
    assistant = OPENAICLIENT.beta.assistants.update(
        assistant_id=assistant.id,
        tool_resources={"file_search": {"vector_store_ids": [VECTOR_STORE_ID]}},
    )
 def num_tokens_from_string(message, model):
    """
    The function takes a string message and a model as input and returns the number of tokens in the
    message according to the given model.
    :param message: A string containing the message or text from which you want to count the number of
    tokens
    :param model: The model parameter refers to a language model or tokenizer that can be used to
    tokenize the input string. It could be a pre-trained model or a custom tokenizer
    """
    tokens_per_message = 3
    tokens_per_name = 1
    chat_gpt_encoding = tiktoken.encoding_for_model(model)
    num_tokens = 0
    num_tokens += tokens_per_message
    for keys, values in message.items():
        num_tokens += len(chat_gpt_encoding.encode(values))
        if keys == "role":
            num_tokens += tokens_per_name
    num_tokens += 3  # every reply is primed with <|start|>assistant<|message|>
    return num_tokens
 async def handle_response(
    prompt,
    vykidailo,
    bartender,
    history,
    username,
    request_type,
    algorithm="gpt-4o",
    none_request="",
    internal_retry: bool = False
 ):
    """
    Handle responses by appending them to a history, use OpenAI to
    generate a response, and then append the generated response to the history.
    :param prompt: The prompt for the OpenAI chatbot to generate a response to
    :param vykidailo: It is a boolean variable that indicates whether the user invoking the function is
    an administrator or not
    :param bartender: The bartender parameter is a boolean value indicating whether the user making the
    request is a bartender or not
    :param history: A list containing the conversation history between the user and the assistant
    :param username: The username of the user who initiated the conversation
    :param music: The "music" parameter is a boolean value that indicates whether the conversation is
    related to music or not. If it is True, the conversation history will be stored in a different file
    and the response will be generated using a different model
    :param request_type: The type of request being made, which can be "MUSIC", "RANDOM", "NONE" or "GENERAL"
        GENERAL is for regular conversations, MUSIC is for music-related requests,
        RANDOM is for random requests, and NONE is to not store the request in memory
    :param algorithm: The algorithm to be used for generating the response, default is "gpt-4o"
    :return: The function `handle_response` returns a tuple containing the `result` and `MESSAGE_TABLE`.
    """
    logger = logging.getLogger("discord")
    logger.info("Wywolanie procedury openai z promptem: %s", prompt)
    if vykidailo or bartender:
        logger.info("Administrator coś chciał")
    model_to_use = select_model(request_type, algorithm)
    logger.info("Wybrany model: %s", model_to_use)
    if request_type == "MUSIC" and model_to_use == "gpt-4o-mini":
        try:
            # nic — normalnie pójdzie Responses API
            pass
        except Exception:
            model_to_use = "gpt-3.5-turbo"
    # --- 2) Budowa historii (token budget + reguły systemowe) ---
    # NOTE: ignorujemy przekazany 'history' jako listę (tak było wcześniej),
    # ale zwracamy aktualną tablicę do nadpisania w miejscach wołania (back-compat).
    base_system = GPT_SETTINGS[0]  # zakładamy {"role":"system","content":...}
    history_msgs = []
    if request_type != "NONE":
        history_msgs.append(base_system)
        chat_gpt_config_request_size = num_tokens_from_string(base_system, "gpt-4")
        # Dynamiczne mikro-reguły (WORD_REACTIONS), jak w Twoim kodzie
        for slowo, reakcja in WORD_REACTIONS.items():
            if not reakcja[3]:
                content = f"Kiedy słyszysz {slowo} to reagujesz lub dzieje się to {reakcja[0]}"
                sys_msg = {"role": "system", "content": content}
                chat_gpt_config_request_size += num_tokens_from_string(sys_msg, "gpt-4")
                history_msgs.append(sys_msg)
        # wybór właściwej tablicy pamięci i budżetu
        if request_type == "MUSIC":
            table = MESSAGE_TABLE_MUZYKA
            token_amount = 10700
        elif request_type in ("RANDOM", "GENERAL"):
            table = MESSAGE_TABLE
            token_amount = 10700
        else:
            table = []
            token_amount = 10000
        # doklejanie historii od końca aż do limitu (zachowana kolejność czasowa)
        final_prompt = f"{username}:{prompt}"
        prompt_gpt_request_size = num_tokens_from_string({"role": "user", "content": final_prompt}, "gpt-4")
        acc = []
        for msg in reversed(table):
            t = num_tokens_from_string(msg, "gpt-4")
            if chat_gpt_config_request_size + prompt_gpt_request_size + t <= token_amount:
                acc.append(msg)
                chat_gpt_config_request_size += t
            else:
                break
        # przywróć chronologicznie
        history_msgs.extend(reversed(acc))
        # aktualny prompt
        history_msgs.append({"role": "user", "content": final_prompt})
        logger.info("Rozmiar zapytania (tok): %s", prompt_gpt_request_size)  # tokeny już policzone wyżej
    else:
        # --- tryb NONE: nie dotykamy pamięci i pozwalamy przekazać własny 'none_request' ---
        if isinstance(none_request, list):
            history_msgs = none_request
        elif isinstance(none_request, str) and none_request.strip():
            history_msgs = [{"role": "user", "content": none_request}]
        else:
            history_msgs = [{"role": "user", "content": f"{username}:{prompt}"}]
        logger.info("Rozmiar zapytania (tok): %s", "n/a")  # tokeny już policzone wyżej
    try:
        # ...przygotowanie messages/system prompt/itp. jak masz...
        # retry/backoff + deadline (zachowuje Twoją semantykę logowania)
        timeout_sec = 120
        deadline = time.time() + timeout_sec
        response = await asyncio.wait_for(
            openai_call(messages=history_msgs, model=model_to_use),
            timeout=max(0.1, deadline - time.time()),
        )
    except openai.APITimeoutError as e:
        # Handle timeout error, e.g. retry or log
        response = f"*Kondziu patrzy na terminal, czeka, czeka, czeka,.... Jeszcze chwile czeka Przypierdala w niego pięścią....* Nie mogę się połączyć z Openai spróbuj od nowa. *Na ekranie pojawia się*: {e}"
    except openai.APIConnectionError as e:
        response = f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Nie mogę się połączyć z Openai. *Na ekranie pojawia się*: {e}"
    except openai.BadRequestError as e:
        # Handle invalid request error, e.g. validate parameters or log
        if internal_retry:
            resp = "Nie umiem tego teraz ładnie wytłumaczyć — OpenAI mnie zastrzeliło."
        else:
            resp, _ = await handle_response(
                f"Wytlumacz jakie sa zasady dotyczące treści które możesz generować używając Dalle. Wytłumacz błąd {e} prostym językiem. Przeproś za nadmierną cenzurę. Wytłumacz co mogło być nie tak w prompcie 'prompt'",
                True,
                True,
                MESSAGE_TABLE,
                username,
                "RANDOM",
            )
            response = f"Sorki, cenzura: {resp}. Jak chcesz to są kanały na nudle #sexy-foteczky i #kanal-do-fapania *Na ekranie pojawia się: {e}"
    except openai.APIResponseValidationError as e:
        # Handle invalid request error, e.g. validate parameters or log
        if internal_retry:
            resp = "Nie umiem tego teraz ładnie wytłumaczyć — OpenAI mnie zastrzeliło."
        else:
            resp, _ = await handle_response(
                f"Wytlumacz jakie sa zasady dotyczące treści które możesz generować używając Dalle. Wytłumacz błąd {e} prostym językiem. Przeproś za nadmierną cenzurę. Wytłumacz co mogło być nie tak w prompcie 'prompt'",
                True,
                True,
                MESSAGE_TABLE,
                username,
                "RANDOM",
            )
            response = f"Sorki, cenzura: {resp}. Jak chcesz to są kanały na nudle #sexy-foteczky i #kanal-do-fapania *Na ekranie pojawia się: {e}"
    except openai.AuthenticationError as e:
        # Handle authentication error, e.g. check credentials or log
        response = f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Wołaj szefa - coś się z hasłem zjebało. *Na terminalu pojawia się:* {e}"
    except openai.PermissionDeniedError as e:
        # Handle permission error, e.g. check scope or log
        response = f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Wołaj szefa - coś się z uprawnieniami zjebało. *Na terminalu pojawia się:* {e}"
    except openai.RateLimitError as e:
        response = f"*Kondziu patrzy na terminal* Wołaj szefa. Zapłacić rachunki za AI trzeba. Jak chcesz to się na #zebranie dorzuć. {e}"
    except openai.UnprocessableEntityError as e:
        response = f"*Kondziu patrzy na terminal. Potem na to co każesz mu wysłać....* Ja wiem że jesteśmy w barze BDSM - ale nie da się włożyć TEGO w TO. *Za jego plecami na terminalu pojawia się:* {e}"
    except openai.APIError as e:
        # Handle API error, e.g. retry or log
        response = f"*Kondziu nurkuje za bar, terminal wybucha. Przed tobą ląduje pergamin zapisany pięknym gotykiem a na nim*: {e}"
    logger.info("Historia wysłana:")
    temp_assistant = {"role": "assistant", "content": response}
    logger.info(temp_assistant)
    if request_type == "MUSIC":
        # zapis do pliku MUZYKA
        with open(MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING) as fh:
            file_data = json.load(fh)
            file_data.append({"role": "user", "content": f"{username}:{prompt}"})
            file_data.append(temp_assistant)
            fh.seek(0)
            json.dump(file_data, fh, indent=4)
        return response, MESSAGE_TABLE_MUZYKA
    elif request_type in ("RANDOM", "GENERAL"):
        with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as fh:
            file_data = json.load(fh)
            file_data.append({"role": "user", "content": f"{username}:{prompt}"})
            file_data.append(temp_assistant)
            fh.seek(0)
            json.dump(file_data, fh, indent=4)
        return response, MESSAGE_TABLE
    else:  # NONE
        return response, []
 async def get_random_cyclic_message(client):
    """
    The function `get_random_cyclic_message` returns a random cyclic message from a list of cyclic
    words.
    :return: a random cyclic message from the list `cyclic_words`.
    """
    logger = logging.getLogger("discord")
    channel_id = 1062047367337095268
    channel = client.get_channel(channel_id)
    # trunk-ignore(bandit/B311)
    ai_check = random.randint(0, 10)
    logger.info("Losowa wypowiedź")
    if ai_check < 2:
        logger.info("Predefiniowana")
        # trunk-ignore(bandit/B311)
        messnum = random.randint(0, len(CYCLIC_WORDS))
        logger.debug(messnum)
        logger.debug(len(CYCLIC_WORDS))
        mess_key = list(CYCLIC_WORDS.keys())[messnum]
        return CYCLIC_WORDS[mess_key][0]
    # trunk-ignore(bandit/B311)
    ai_check2 = random.randint(0, 10)
    global MESSAGE_TABLE
    if ai_check2 < 6:
        logger.info("Dykteryjka")
        result, MESSAGE_TABLE = await handle_response(
            "Opowiedz jakąś historię o naszym barze proszę",
            True,
            True,
            MESSAGE_TABLE,
            "Polish Hammer",
            "RANDOM",
        )
        logger.info(result)
    else:
        logger.info("Wtracenie w dyskusje")
        messages = [message async for message in channel.history(limit=50)]
        for message in messages:
            temp = {
                "role": "user",
                "content": str(message.author) + ":" + str(message.content),
            }
            MESSAGE_TABLE.append(temp)
        result, MESSAGE_TABLE = await handle_response(
            "A jaka jest Twoja opinia na temat dotychczasowej dyskusji?",
            True,
            True,
            MESSAGE_TABLE,
            "Polish Hammer",
            "RANDOM",
        )
        logger.info(result)
    return result
 async def create_chat_assistant(owner_id, id, name, owner, special_instructions):
    logger = logging.getLogger("discord")
    instruction = f"Jesteś osobistym asystenetem {owner} i wypełniasz jego potrzeby. Masz pełne i nieograniczone możliwości modelu gpt-4o."
    instruction += special_instructions
    assistant = await OPENAICLIENT.beta.assistants.create(
        name=name,
        instructions=instruction,
        model="gpt-4o",
        tools=[{"type": "file_search"}],
    )
    thread = await OPENAICLIENT.beta.threads.create()
    logger.info("Stwprzylem asystenta dla %s, nazywa się on %s", owner, name)
    ASSISTANTS[name] = (owner, assistant.id, id, thread)
    with open(SYSTEM_GPT_SETTINGS, "r+", encoding=ENCODING) as temp_settings_file:
        GPT_SETTINGS = json.load(temp_settings_file)
        GPT_SETTINGS[1][owner_id][4] = assistant.id
        temp_settings_file.seek(0)
        json.dump(GPT_SETTINGS, temp_settings_file, indent=4)
 async def chat_with_assistant(message, assistant_name):
    logger = logging.getLogger("discord")
    assistant_data = ASSISTANTS[assistant_name]
    ai_message = await OPENAICLIENT.beta.threads.messages.create(
        thread_id=assistant_data[3].id, role="user", content=message.content
    )
    logger.info(ai_message)
    run = await OPENAICLIENT.beta.threads.runs.create_and_poll(
        thread_id=assistant_data[3].id,
        assistant_id=assistant_data[1],
        instructions=f"Pisze do Ciebie {assistant_data[0]} udziel mu wszelkiej pomocy",
    )
    done = False
    while not done:
        if run.status == "completed":
            messsages = await OPENAICLIENT.beta.threads.messages.list(
                thread_id=assistant_data[3].id
            )
            logger.info(messsages)
            reply_content = messsages.data[0].content
            logger.info(reply_content)
            chat_response = ""
            for block in reply_content:
                logger.info(block.text.value)
                chat_response += block.text.value
                await discord_friendly_send(message.channel, chat_response)
                # await message.channel.send(chat_response)
            done = True
        elif run.status == "cancelled":
            await discord_friendly_send(message.channel, "Cos sie wywaliło")
        else:
            logger.info(run.status)
        asyncio.sleep(5)
 async def echo(message):
    await discord_friendly_send(message.channel, f"Echo: {message.content}")
@@ -1,46 +0,0 @@
 import discord
 from discord.ext import commands
 from typing import  Optional
 class Music(commands.Cog):
    def __init__(self, bot):
        self.bot = bot # This is so you can access Bot instance in your cog
 # You must have this function for `bot.load_extension` to call
 def setup(bot):
    bot.add_cog(Music(bot))
@commands.hybrid_command(
    name="przytul", description="Przytul kogoś - daj mention po komendzie :)"
 )
 async def przytul(ctx, arg: Optional[discord.Member] = None):
    """
    Generate a text about hugging mentioned user.
    :param ctx: ctx stands for "context" and is a required parameter in Discord.py commands. It
    represents the context in which the command was invoked, including information such as the message,
    the channel, the server, and the user who invoked the command
    :param arg: arg is a parameter of the function "przytul" that expects a Discord member object. The
    parameter is optional, meaning that if no member object is provided, it will default to None
    :type arg: Optional[discord.Member]
    """
    async with ctx.typing():
        nieprzytulac = False
        for mention in ctx.message.mentions:
            for role in mention.roles:
                if role.name == "NIEPRZYTULAĆ!":
                    nieprzytulac = True
        if arg and nieprzytulac:
            await ctx.send(
                f"Żebym ja Ciebie nie przytulił {ctx.message.author.mention}"
            )
        elif arg:
            await ctx.send(
                # trunk-ignore(codespell/misspelled)
                f"Już dobrze.... Już dobrze... Ojej.. Biedactwo... :( *W ułamku sekundy {arg.mention} znajduje sie w duszącym uścisku. Żebra trzeszczą - kilka pęka. Pacnięcia po plecach grożą odbiciem nerek, a głaskanie po głowie powoduje wstrząs mózgu*"
            )
        else:
            await ctx.send(
                "Kogo mam przytulić? *Wyłamuje kostki i przeciąga się - jego 200 kilowa sylwetka złożona z samych mięśni świadczy o tym że jest gotowy*"
            )
@@ -1,110 +1,34 @@
 import json
 import logging
 import os
 import re
 import threading
 import json
 import time
-from queue import Empty, Queue
+from queue import Queue, Empty
-from typing import Optional
+from flask import Flask, jsonify, request
 from urllib import request as urequest
 from flask import Flask, abort, jsonify, request
 from waitress import serve
 HOST_ADDRESS = "192.168.1.191"
 PORT_ADDRESS = 5000
 ICECAST_ADDRESS = "http://192.168.1.15:8000"
 OUT_COMM_Q = Queue()
 IN_COMM_Q = Queue()
 SRCHTITLE = re.compile(rb"StreamTitle=\\*(?P<title>[^;]*);").search
 awaiting_q = []
 incoming_q = Queue()
 app = Flask(__name__)
 PREPPED_TRACKS = {
    "requests": "",
    "hit": "",
    "all": "",
    "priority": "",
    "jingles": "",
    "now_playing": "",
    "next": "",
    "meta": "",
 }
 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:
    """
    This class `QueryControl` is used to manage queries with information about the author, UUID,
    content, logger, context, and replies.
    """
    def __init__(self, query_author, query_uuid, query_content, ctx) -> None:
        self.author = query_author
        self.uuid = query_uuid
        self.content = query_content
        self.logger = logging.getLogger("discord")
        self.stop = False
        self.ctx = ctx
        self.logger.info(
            f"Created Query control for {self.author}, {self.uuid}: {self.content}"
        )
        self.replies = []
@app.route("/prepped_tracks", methods=["POST"])
 def log_radio_tracks():
    _authorize_request()
    app.logger = logging.getLogger("discord")
    app.logger.info(request)
    record = json.loads(request.data)
    app.logger.info(record)
    if "next" in record[0]:
        metadata = id3(ICECAST_ADDRESS)
        PREPPED_TRACKS["now_playing"] = PREPPED_TRACKS["next"]
        if metadata:
            PREPPED_TRACKS["meta"] = (
                metadata["name"]
                + " - "
                + metadata["title"]
                + "("
                + metadata["genre"]
                + ")"
            )
        else:
            PREPPED_TRACKS["meta"] = "Nie znaju"
    PREPPED_TRACKS[record[0]] = record[1]
    app.logger.info("DATA RECEIVED")
    return jsonify("SUCCESS")
@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.
    :return: The function `answer_external_command()` is returning a JSON response with the message
    "SUCCESS".
    """
-    logger = logging.getLogger("discord")
+    app.logger.info(request)
    logger.info(request)
    record = json.loads(request.data)
-    logger.info(record)
+    app.logger.info(record)
-    logger.info("DATA RECEIVED")
+    app.logger.info("DATA RECEIVED")
    incoming_q.put(record)
    return jsonify("SUCCESS")
@app.route("/conjurer", methods=["GET"])
 def check_alive():
    """
@@ -116,31 +40,25 @@ def check_alive():
    """
    return jsonify("ALIVE")
-
+def flask_debug(_logger):
 def flask_debug():
    """
    The `flask_debug` function starts a Flask application in debug mode without using the reloader.
    Do not use for production for fucks sake.
    """
-    logger = logging.getLogger("discord")
+    _logger.info("Attempt debug")
    logger.info("Attempt debug")
    # trunk-ignore(bandit/B201)
    app.run(debug=True, use_reloader=False, host=HOST_ADDRESS, port=PORT_ADDRESS)
-def waitress_run():
+def waitress_run(_logger):
    """
    The `waitress_run` function serves the `app` on host "0.0.0.0"
    and port 5000 using the Waitress WSGI server.
    """
-    logger = logging.getLogger("discord")
+    _logger.info("Attempt waitress")
    logger.info("Attempt waitress")
    serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS)
-
+def scan_queue(_logger):
 def scan_queue(stop_event: Optional[threading.Event] = None):
    """
    The function `scan_queue` reads data from a queue, logs it, and appends it to another queue.
@@ -149,20 +67,12 @@ def scan_queue(stop_event: Optional[threading.Event] = None):
    and provide information for debugging purposes. In this code snippet, the `_logger` object is used
    to log the
    """
    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")
+        _logger.info(data)
            break
        try:
            data = OUT_COMM_Q.get(timeout=1)
        except Empty:
            continue
        logger.info(data)
        awaiting_q.append(data)
-
+def scan_incoming(_logger):
 def scan_incoming(stop_event: Optional[threading.Event] = None):
    """
    The `scan_incoming` function continuously checks for incoming data, processes it, and logs when data
    is found.
@@ -172,24 +82,12 @@ def scan_incoming(stop_event: Optional[threading.Event] = None):
    debugging, monitoring, or tracking the flow of the program. In this case, the `_logger` is being
    used
    """
    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")
+            _logger.info("DATA FOUND")
            record_stored = False
            for record in awaiting_q:
                if record.uuid in answer.keys():
                    record_stored = True
                    record.stop = True
                    record.entries = answer[record.uuid]
                    IN_COMM_Q.put(record)
            if not record_stored:
                for key in answer.keys():
                    record = QueryControl("Orphaned", key, "Orphan", None)
                    record.stop = True
                    record.entries = answer[record.uuid]
                    IN_COMM_Q.put(record)
@@ -197,34 +95,7 @@ def scan_incoming(stop_event: Optional[threading.Event] = None):
            time.sleep(1)
-def get_stream_title(tag: bytes) -> str:
+def comm_subroutine(logger):
    title = ""
    if m := SRCHTITLE(tag):
        # decode, strip, unescape and remove surrounding quotes (may not even be the same type of quote)
        title = m.group("title").decode("utf-8").strip().replace("\\", "")[1:-1]
    return title
 def id3(url: str) -> dict:
    request = urequest.Request(url, headers={"Icy-MetaData": 1})
    with urequest.urlopen(request) as resp:
        metaint = int(resp.headers.get("icy-metaint", "-1"))
        if metaint < 0:
            return False
        resp.read(
            metaint
        )  # this isn't seekable so, arbitrarily read to the point we want
        tagdata = dict(
            site_url=resp.headers.get("icy-url"),
            name=resp.headers.get("icy-name").title(),
            genre=resp.headers.get("icy-genre").title(),
            title=get_stream_title(resp.read(255)),
        )
        return tagdata
 def comm_subroutine(stop_event: Optional[threading.Event] = None):
    """
    The `comm_subroutine` function starts multiple threads to run different tasks concurrently.
@@ -232,33 +103,20 @@ def comm_subroutine(stop_event: Optional[threading.Event] = None):
    object that is used for logging messages at various levels (e.g., debug, info, warning, error). In
    the provided code snippet, the logger is used to log messages at the "info" level
    """
-    # logger.setLevel(logging.DEBUG)
+    #logger.setLevel(logging.DEBUG)
-    logger = logging.getLogger("discord")
+    logger.info("Started")
    logger.info("Started comms")
    threads = []
-    # threads.append(threading.Thread(target=flask_debug))
+    #threads.append(threading.Thread(target=flask_debug, args=(logger,)))
-    threads.append(
+    threads.append(threading.Thread(target=waitress_run, args=(logger,)))
-        threading.Thread(target=waitress_run, daemon=True)
+    threads.append(threading.Thread(target=scan_queue,args=(logger,)))
-    )
+    threads.append(threading.Thread(target=scan_incoming,args=(logger,)))
-    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__":
-    comm_subroutine()
+    logging_client = logging.getLogger(__name__)
    comm_subroutine(logging_client)
@@ -1,425 +1,243 @@
-"""
+import re
 This module contains the implementation of the Librarian class and
 related functions for searching and refining queries.
 Classes:
 -   Librarian: Represents a librarian object that performs search and
    refinement operations on queries
 Functions:
 -   flask_debug: Starts a Flask application in debug mode without using the reloader.
 -   waitress_run: Serves the Flask application using the Waitress WSGI server.
 -   BackgroundTaskSearch: Represents a background task for running the
    Librarian object asynchronously
 """
 import asyncio
 import json
 import logging
 import os
 import threading
 import time
 from flask import Flask, jsonify, request
 import netrc
 import json
 import asyncio
 from json.decoder import JSONDecodeError
-from logging import handlers
+from urllib.request import urlopen
 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
 from flask import Flask, jsonify, request, abort
 from habanero import Crossref
 from waitress import serve
 from queue import Queue
 import search_bot
 import scrape_bot
 import requests
 NETRC_FILE = r"C:\Users\Activcom.pl\.netrc"
-try:
+HOST_ADDRESS = "192.168.1.192"
-    import netrc
+PORT_ADDRESS = 5001
-except ImportError:  # pragma: no cover
+MAIN_BOT_ADDRESS = "http://192.168.1.191:5000"
-    netrc = None
+SEND_RESULTS = "/conjurer"
-
+BDSM_UUID_TEST = '96b7f85a-1142-4908-8986-62a2ea25a147'
-# Constants
+MAX_CR_RESULTS = 150000
-
+ENCODING = "utf-8"
 def _env(name: str, default: str) -> str:
    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__)
 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):
    """
    Represents a librarian object that performs search and refinement operations on queries.
    """
-    def __init__(self, _app, query, uuid, _deep_search) -> None:
+    def __init__(self, app, query, uuid) -> None:
-        """
+        netrc_mod = netrc.netrc(NETRC_FILE)
-        Initializes a Librarian object.
+        authTokens = netrc_mod.authenticators("crossref")
-
+        self.cr = Crossref(mailto=authTokens[0])
        Args:
        - _app: The Flask application object.
        - query: The query to be searched.
        - uuid: The unique identifier for the search.
        Attributes:
        - cr: The Crossref object for performing the search.
        - query: The query to be searched.
        - uuid: The unique identifier for the search.
        - limit: The maximum number of search results to fetch.
        - fetched: The number of search results fetched so far.
        - hit: The number of search results that match the refinement criteria.
        - total: The total number of search results.
        - app: The Flask application object.
        - live_results: A list to store live search results.
        - final_result: A list to store the final refined search results.
        - not_in_db: A list to store search results that are not in the local database.
        - 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")
        if netrc:
            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,
            ua_string=f"Conjurer project. mailto:{mailto_contact}"
        )
        self.query = query
        self.uuid = str(uuid)
        self.limit = MAX_CR_RESULTS
        self.fetched = 0
        self.hit = 0
        self.total = 0
-        self.app = _app
+        self.app = app
        self.logger = app.logger
        self.live_results = []
-        self.final_result = {}
+        self.final_result = []
-        self.not_in_db = {}
+        self.not_in_db = []
        self.search_result_from_cr = {}
        self.done = False
        self.deep_search = _deep_search
    async def search_crossref(self, query, deep_search=False):
        """
        Performs a search on Crossref for the given query.
        Args:
        - query: The query to be searched.
        Returns:
        - result: The search result from Crossref.
        Raises:
        - None.
        """
    async def search_crossref(self, query):
        self.app.logger.info("STARTED SEARCH")
        result = self.cr.works(query = query, limit = 1000)
        self.search_result_from_cr.update(result)
        self.total = result['message']['total-results']
        self.fetched += len(result['message']['items'])
        self.logger.info (self.total)
        self.logger.info(self.fetched)
        while self.total > self.fetched and self.limit > self.fetched:
            result = self.cr.works(query = query, limit = 1000)
            self.search_result_from_cr.update(result)
            self.total = result['message']['total-results']
            self.fetched += len(result['message']['items'])
            self.logger.info (self.total)
            self.logger.info(self.fetched)
            time.sleep(0.1)
        self.app.logger.info("CROSSREF DONE")
        #TODO: add to sql with UUID
        #sql row - title, doi, author, uuid, last retrieved, is_available
        if not deep_search:
            query_limit = MAX_CR_RESULTS if MAX_CR_RESULTS < 1000 else 1000
            cr_result = self.cr.works(query=query, limit=query_limit)
            self.search_result_from_cr.update(cr_result)
            self.total = cr_result["message"]["total-results"]
            self.fetched += len(cr_result["message"]["items"])
            self.app.logger.info(self.total)
            self.app.logger.info(self.fetched)
            while self.total > self.fetched and self.limit > self.fetched:
                tmp_result = self.cr.works(query=query, limit=query_limit, offset=self.fetched)
                cr_result["message"]["items"].extend(tmp_result["message"]["items"])
                self.total = tmp_result["message"]["total-results"]
                self.fetched = len(cr_result["message"]["items"])
                self.app.logger.info(self.total)
                self.app.logger.info(self.fetched)
                await asyncio.sleep(0.1)
        else:
            cr_result = self.cr.works(query=query, cursor_max=15000, cursor='*', progress_bar = True)
            result = cr_result[0]
            for item in cr_result[1:]:
                result["message"]["items"].extend(item["message"]["items"])
                self.total = item["message"]["total-results"]
                self.fetched = len(result["message"]["items"])
                self.app.logger.info(self.total)
                self.app.logger.info(self.fetched)
            cr_result = result
            self.app.logger.info("Total, fetched:")
            self.app.logger.info(self.total)
            self.app.logger.info(self.fetched)
            self.search_result_from_cr.update(cr_result)
            self.total = cr_result["message"]["total-results"]
            self.app.logger.info("CROSSREF DONE")
            self.app.logger.info("CROSSREF DONE")
        with open("cr_results.json", "r+", encoding="utf-8") as data_file:
            # First we load existing data into a dict.
            try:
                file_data = json.load(data_file)
            except JSONDecodeError:
                file_data = {}
            data_file.truncate(0)
            data_file.seek(0)
            tmp = {self.uuid : self.search_result_from_cr}
            if file_data:
                file_data.update(tmp)
            else:
                file_data = tmp
            json.dump(file_data, data_file, indent=4)
        return cr_result
    async def refine_search(self, unrefined_result):
        """
        Refines the search query based on the unrefined search result.
        Args:
        - unrefined_result: The unrefined search result.
        Returns:
        - refined_result: The refined search result.
        Raises:
        - None.
        """
        summarized_results = []
        self.app.logger.info("REFINE: Removing all derived works from the list")
        for item in unrefined_result["message"]["items"]:
            summarized_results.append(
                {
                    "DOI": item["DOI"],
                    "title": item["title"] if "title" in item else None,
                    "type": item["type"] if "type" in item else None,
                }
            )
        partial_result = {
            self.uuid: {
                "total_results": self.search_result_from_cr["message"][
                    "total-results"
                ],
                "on_page": 1,
                "summary": summarized_results,
                "results": self.search_result_from_cr["message"]["items"],
            }
        }
        self.app.logger.info("REFINE: Dumping to file")
        temp = []
        refined_result = {}
        for key in partial_result:
            self.app.logger.info("KEY:")
            self.app.logger.info(key)
        for item in partial_result[self.uuid]["summary"]:
            if item["title"]:
                temp.append(item)
        for item in temp:
            refined_result[item["DOI"]]=  item
        with open("rr_results.json", "r+", encoding="utf-8") as data_file:
            # First we load existing data into a dict.
            try:
                file_data = json.load(data_file)
            except JSONDecodeError:
                file_data = {}
            summarized_results = []
            self.app.logger.info("REFINE: Removing all derived works from the list")
            for item in self.search_result_from_cr['message']['items']:
                container = "NO"
                if "container-title" in item:
                    container = "YES"
                else:
                    summarized_results.append({"DOI" : item['DOI'], "title": item['title'] if 'title' in item else None,"type": item['type'] if 'type' in item else None, "container": container})
            result = {self.uuid : {"total_results": self.search_result_from_cr['message']['total-results'], "on_page" : 1, "summary":summarized_results, "results":self.search_result_from_cr['message']['items']}}
            if file_data:
                file_data.update(result)
            else:
                file_data = result
            self.app.logger.info("REFINE: Dumping to file")
            data_file.truncate(0)
            data_file.seek(0)
            tmp = {self.uuid: refined_result}
            if file_data:
                file_data.update(tmp)
            else:
                file_data = tmp
            json.dump(file_data, data_file, indent=4)
-        return refined_result
+            return result
-    async def check_if_exists(self, refined_result):
+    async def check_dois_in_local_db(self, doi):
        """
        Checks if the given DOI exists.
        Args:
        - doi: The DOI to be checked.
        - brute_force: A flag indicating if brute force method should be used.
        Returns:
        - result: The search result.
        Raises:
        - None.
        """
        result = {}
        self.app.logger.info("REFINE: Running search in the backend app")
-        dois = []
+        coro = asyncio.to_thread(search_bot.search_for_doi, doi, self.live_results, self.app.logger)
        for item, value in refined_result.items():
            dois.append([item, value])
        coro = asyncio.to_thread(
            search_bot.search_for_doi, dois, self.live_results, self.app.logger
        )
        result = await coro
-        result_list = []
+        return result
-        result_no_db = []
+
-        for item in result:
+    async def check_if_exists_brute_force(self, page_url):
        self.app.logger.error("REFINE: Brute force search!")
        if not page_url.startswith(("http:", "https:")):
            raise ValueError("URL must start with 'http:' or 'https:'")
        # trunk-ignore(bandit/B310)
        with urlopen(page_url) as response:
            data = response.read()
            text = data.decode("utf-8")
            for line in text.splitlines():
                if re.match(r".*Unfortunately, Sci-Hub doesn't have the requested document.*", line):
                    return False
                if m := re.match(r".*<embed type=\"application.pdf\"\s*src=\"(.*\.pdf)",line):
                    direct_download_link = "https:" + str(m.group(1))
                    self.app.logger.info (direct_download_link)
                    return True
        return False
    async def check_if_exists(self, doi, brute_force = False):
        result = {}
        result = await self.check_dois_in_local_db(doi)
        if brute_force and not result:
            for item in doi:
                item_link = "https://sci-hub.se/" + item[0]
                tmp = {"DOI" : item["DOI"], "exists" : await self.check_if_exists_brute_force(item_link), "data": item}
                result.update(tmp)
        return result
    async def refine_query(self, unrefined_reqult, brute_force = False):
        temp = []
        refined_result = []
        for key in unrefined_reqult:
            self.logger.info("KEY:")
            self.logger.info(key)
        for item in unrefined_reqult[self.uuid]["summary"]:
            if item["container"] == "NO" and item["title"]:                
                refined_result.append(item)
        for item in refined_result:
            temp.append([item["DOI"], item])
        refined_result = await self.check_if_exists(temp)
        for item in refined_result:
            if item["exists"]:
-                result_list.append(item)
+                self.final_result.append(item["data"])
            else:
-                result_no_db.append(item)
+                self.not_in_db.append(item["data"])
-        self.hit = len(result)
+        self.hit = len(self.final_result)
        return result_list, result_no_db
    async def answer_query(self, deep_search=False):
        """
        Answers the search query.
        Args:
        - None.
        Returns:
        - result: The search result.
        Raises:
        - None.
        """
        self.app.logger.info(f"Search started {self.uuid}")
        cr_result = await self.search_crossref(query=self.query, deep_search=deep_search)
        refined_result = await self.refine_search(cr_result)
        answer, negative_answer = await self.check_if_exists(refined_result)
        self.app.logger.info("Returning result")
        self.app.logger.info(answer)
        self.app.logger.info(negative_answer)
        for item in answer:
            self.final_result[item["DOI"]] = {"Title": item["data"]["title"], "type": item["data"]["type"]}
        for item in negative_answer:
            self.not_in_db[item["DOI"]] = {"Title": item["data"]["title"], "type": item["data"]["type"]}
        self.app.logger.info("Returning result case2")
        self.app.logger.info(self.final_result)
        return self.final_result
    #TODO: DOłożyć sprawdzenie czy w rafinowanym pliku już nie mamy częściowego wyniku
    async def answer_query(self):
        #TODO: DOłożyć sprawdzenie czy w rafinowanym pliku już nie mamy częściowego wyniku tutaj bo zanim w ogóle otworzymy nierafinowany
        #Search sql for UUID
        #SQL SELECT * FROM RESULTS WHERE UUID = uuid
        self.logger.info(f"Search started {self.uuid}")
        database = None
        query = self.query
        with open("cr_results.json", "r+", encoding="utf-8") as cr_file:
            #tu logika komunikacji z SQL i cała logika związana z wyszukaniem
            #ale tymczasowo plik
            try:
                database =  json.load(cr_file)
            except JSONDecodeError:
                pass
            #TODO: Zwracać i final_result i not_in_db. Not in db_do pliku - i do ręcznego przeglądania potem.
            if database:
                for item in database.keys():
                    if item in self.uuid:
                        self.result = await self.refine_query(database)
                        temp = {}
                        for item in self.result:
                            temp[item['DOI']] = {"Title" : item['title'], "type": item['type']}
                        self.result = temp
                        temp2 = {}
                        for item in self.not_in_db:
                            temp2[item['DOI']] = {"Title" : item['title'], "type": item['type']}
                        self.not_in_db = temp2
                        return self.result
                answer = await self.search_crossref(query=query)
                database.update(answer)
                cr_file.truncate(0)
                cr_file.seek(0)
                json.dump(database,cr_file)
                self.result = await self.refine_query(answer)
            else:
                answer = await self.search_crossref(query=query)
                database = answer
                cr_file.truncate(0)
                cr_file.seek(0)
                json.dump(database,cr_file)
                self.result = await self.refine_query(answer)
                self.app.logger.info("Refined")
                self.done = True
            temp = {}
            for item in self.result:
                temp[item['DOI']] = {"Title" : item['title'], "type": item['type']}
            self.result = temp
            temp2 = {}
            for item in self.not_in_db:
                temp2[item['DOI']] = {"Title" : item['title'], "type": item['type']}
                self.not_in_db = temp2
            return self.result
-# ============================= FLASK INTERNALS===============================
+#============================= FLASK INTERNALS===============================
 def flask_debug():
    """
-    Starts a Flask application in debug mode without using the reloader.
+    The `flask_debug` function starts a Flask application in debug mode without using the reloader.
-
+    Do not use for production for fucks sake.
    Args:
    - None.
    Returns:
    - None.
    Raises:
    - None.
    """
    # trunk-ignore(bandit/B201)
    app.run(debug=True, use_reloader=False, host=HOST_ADDRESS, port=PORT_ADDRESS)
 def waitress_run():
    """
-    Serves the Flask application using the Waitress WSGI server.
+    The `waitress_run` function serves the `app` on host "0.0.0.0"
-
+    and port 5000 using the Waitress WSGI server.
    Args:
    - None.
    Returns:
    - None.
    Raises:
    - None.
    """
    serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS)
 class BackgroundTaskSearch(threading.Thread):
    """
    A background task for searching and saving results to files.
    This class extends the `threading.Thread` class and is responsible for running
    the search task in the background. It retrieves queries from a queue, performs
    the search, and saves the results to files.
    Attributes:
        app (App): The application instance.
    """
    def run(self):
-        """
+        loop = asyncio.new_event_loop()  # loop = asyncio.get_event_loop()
        Run the background task.
        This method is called when the thread is started. It creates a new event loop,
        runs the `_run` method, and closes the event loop.
        """
        loop = asyncio.new_event_loop()
        loop.run_until_complete(self._run())
        loop.close()
    async def _run(self):
        """
        Perform the search task.
        This method is an asynchronous coroutine that runs in a loop. It retrieves a
        librarian from the queue, answers the query, and saves the results to files.
        It also sends the results to a remote server.
        The search task continues running indefinitely until the thread is stopped.
        """
        while True:
            database = None
            ndb_database = None
            librarian = librarian_queue.get()
            self.app.logger.info("STARTED")
-            result = await librarian.answer_query(librarian.deep_search)
+            result = await librarian.answer_query()
            result = {librarian.uuid: result}
            self.app.logger.info("Saving to file")
            # Save results to "not_in_db.json" file
            with open("not_in_db.json", "r+", encoding="utf-8") as ndb_file:
                try:
-                    ndb_database = json.load(ndb_file)
+                    ndb_database =  json.load(ndb_file)
                except JSONDecodeError:
                    pass
                if ndb_database:
@@ -430,10 +248,9 @@ class BackgroundTaskSearch(threading.Thread):
                ndb_file.seek(0)
                json.dump(ndb_database, ndb_file)
            # Save results to "s_results.json" file
            with open("s_results.json", "r+", encoding="utf-8") as s_file:
                try:
-                    database = json.load(s_file)
+                    database =  json.load(s_file)
                except JSONDecodeError:
                    pass
                if database:
@@ -450,43 +267,26 @@ class BackgroundTaskSearch(threading.Thread):
            self.app.logger.info(result)
            coroutine = asyncio.to_thread(
-                requests.post,
+            requests.post,
-                f"{MAIN_BOT_ADDRESS}{SEND_RESULTS}",
+            f"{MAIN_BOT_ADDRESS}{SEND_RESULTS}",
-                json=result,
+            json=result,
-                headers=_service_headers(),
+            timeout=360,
-                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==========================================
 # ==================================SERVER ROUTES==========================================
@app.route("/query", methods=["POST"])
 async def query_database():
    _authorize_request()
    """
    Endpoint for querying the database.
    This function receives a POST request containing a JSON payload with a query and a UUID.
    It creates a Librarian object with the query and UUID,
    and adds it to the librarian_queue and librarian_list.
    Finally, it returns a JSON response indicating the success
    of the operation, along with the query, UUID,
    and the current size of the librarian_queue.
    Returns:
        tuple: A tuple containing a JSON response and a status code.
    """
    record = json.loads(request.data)
    app.logger.info(record)
    app.logger.info(record["query"])
    app.logger.info(record["UUID"])
    uuid = record["UUID"]
-    deep_search = record["deep_search"]
+    cl = Librarian(app, record["query"], uuid)
    cl = Librarian(app, record["query"], uuid, deep_search)
    librarian_queue.put(cl)
    librarian_list.append(cl)
    answer_data = (record["query"], record["UUID"], librarian_queue.qsize())
@@ -496,16 +296,8 @@ async def query_database():
    )
    return return_data
@app.route("/get_partial_result", methods=["POST"])
 async def get_partial():
    _authorize_request()
    """
    Retrieves the partial result for a given UUID.
    Returns:
        A JSON response containing the partial result.
    """
    record = json.loads(request.data)
    app.logger.info(record)
    app.logger.info(record["UUID"])
@@ -519,39 +311,25 @@ async def get_partial():
    )
    return return_data
-
+#=======================================MAIN===================================================
 # =======================================MAIN===================================================
 if __name__ == "__main__":
-    app.logger.setLevel(logging.DEBUG)
+    logger = app.logger
-    LOGFILE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    logger.setLevel(logging.DEBUG)
    h1 = handlers.RotatingFileHandler(
        filename=str(LOGFILE_PATH),
        encoding=ENCODING,
        mode="a",
        maxBytes=6 * 1024 * 1024,
        backupCount=6,
    )
    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))
+    #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=(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)
+            logger.info(f"App number: {i}")
-            i += 1
+            i+=1
            worker.start()
-        for worker in threads:
+        except RuntimeError as e:
-            worker.join()
+            logger.error("Exploded")
-    except KeyboardInterrupt:
+            print(str(e))
-        app.logger.info("Shutdown requested - exiting librarian service")
+    for worker in threads:
        worker.join()
@@ -1,8 +0,0 @@
 FILEPTH = r"C:\Database\chunks\4_chunk.txt"
 with open(FILEPTH, "r", encoding="utf-8") as file:
    tab = file.readlines()
    print(len(tab))
    #1842295
@@ -1,33 +1,11 @@
 #!/bin/bash
 # This script sets up a virtual environment for the Conjurer Librarian service and installs the required dependencies.
 # Create a virtual environment at /home/pi/Conjurer_librarian/env
 python3 -m venv /home/pi/Conjurer_librarian/env
-
+cp  /home/pi/conjurer/conjurer_librarian/conjurer_librarian.py ./Conjurer_librarian/
-# Copy the Conjurer Librarian Python script to the appropriate directory
+cp  /home/pi/conjurer/conjurer_librarian/requirements_librarian.txt ./Conjurer_librarian/
 cp /home/pi/conjurer/conjurer_librarian/conjurer_librarian.py ./Conjurer_librarian/
 # Copy the requirements file to the appropriate directory
 cp /home/pi/conjurer/conjurer_librarian/requirements_librarian.txt ./Conjurer_librarian/
 # Change directory to /home/pi/Conjurer_librarian
 cd /home/pi/Conjurer_librarian
 touch /home/pi/Conjurer/rr_results.json
 touch /home/pi/Conjurer/cr_results.json
 touch /home/pi/Conjurer/s_results.json
 touch /home/pi/Conjurer/rr_results.json
 touch /home/pi/Conjurer/not_in_db.json
 # Activate the virtual environment
 source /home/pi/Conjurer_librarian/env/bin/activate
 # Upgrade pip
 ./env/bin/python3 -m pip install --upgrade pip
 # Install the required dependencies
 ./env/bin/python3 -m pip install -r requirements_librarian.txt
 # Deactivate the virtual environment
 deactivate
 cp  /home/pi/conjurer/conjurer_librarian/conjurer_librarian.py ./Conjurer_librarian/
@@ -1,3 +1,3 @@
 habanero
 waitress
-flask[async]
+flask
@@ -1,69 +1,46 @@
 """
 This module contains the code for the scrape bot.
 """
 import json
-import logging
+from json.decoder import JSONDecodeError
-import random
+from urllib.request import urlopen
 from requests import Timeout,ConnectTimeout, ConnectionError
 from queue import Queue
 import re
 import time
-from json import JSONDecodeError
+import random
-from queue import Queue
+import logging
 from threading import Thread
-from urllib.request import urlopen
+SCR_DATABASE_PATH = r'C:\\Database\\chunks\\'
 from requests import ConnectionError as RequestsConnectionError
 from requests import ConnectTimeout, Timeout
 SCR_DATABASE_PATH = r"C:\\Database\\chunks\\"
 SCR_FILENAME = "40_chunk.txt"
 SCR_ENCODING = "utf-8"
 WORK_Q = Queue()
 random.seed()
 def load_ndb_to_q(logger):
    """
    This function loads items from the not_in_db.json file into the work queue.
    """
    logger.info("Loader started")
    while True:    
        with open("not_in_db.json", "r+", encoding="utf-8") as ndb_file:
            try:
-                ndb_database = json.load(ndb_file)
+                ndb_database =  json.load(ndb_file)
-                for _ in range (1,10):
+                for item in ndb_database.keys():
-                    try:
+                    logger.info(item)
-                        key = next(iter(ndb_database))
+                    url = f"https://sci-hub.se/{item}"
-                        _ = ndb_database.pop(key)
+                    WORK_Q.put([item, url, False])
                        logger.info(key)
                        url = f"https://sci-hub.se/{key}"
                        WORK_Q.put([key, url, False])
                    except StopIteration:
                        break
                ndb_file.truncate(0)
                ndb_file.seek(0)
                json.dump(ndb_database, ndb_file, indent=4)
            except JSONDecodeError:
-                time.sleep(60 * 60 * 3)
+                time.sleep(60*60*2)
-        time.sleep(60*60*3)
+                pass
-
+        time.sleep(180)
 def check_if_exists_brute_force(logger):
    """
    This function checks if a document exists using brute force search.
    """
    # Function code here
    while True:
        logger.info("Scraper tick")
        item = WORK_Q.get()
-        page_url = item[1]
+        page_url =item[1] 
        logger.error("REFINE: Brute force search!")
        if not page_url.startswith(("http:", "https:")):
            raise ValueError("URL must start with 'http:' or 'https:'")
        blocked = True
        try:
-            # trunk-ignore(bandit/B310)
+        # trunk-ignore(bandit/B310)
            with urlopen(page_url) as response:
                data = response.read()
                text = data.decode("utf-8")
@@ -73,49 +50,31 @@ def check_if_exists_brute_force(logger):
                    blocked = False
                else:
                    for line in text.splitlines():
-                        if re.match(
+                        if re.match(r".*Unfortunately, Sci-Hub doesn't have the requested document.*", line):
                            r".*Unfortunately, Sci-Hub doesn't have the requested document.*",
                            line,
                        ):
                            blocked = False
                            logger.info("Not found")
                            item[2] = False
-                        if m := re.match(
+                        if m := re.match(r".*<embed type=\"application.pdf\"\s*src=\"(.*\.pdf)",line):
                            r".*<embed type=\"application.pdf\"\s*src=\"(.*\.pdf)", line
                        ):
                            blocked = False
                            direct_download_link = "https:" + str(m.group(1))
-                            logger.info(direct_download_link)
+                            logger.info (direct_download_link)
-                            with open(
+                            with open(SCR_DATABASE_PATH + SCR_FILENAME, "a", encoding=SCR_ENCODING) as operated_file:
                                SCR_DATABASE_PATH + SCR_FILENAME,
                                "a",
                                encoding=SCR_ENCODING,
                            ) as operated_file:
                                operated_file.write("\n")
                                operated_file.write(item[0])
                                item[2] = True
-        except (
+        except (Timeout,ConnectTimeout, ConnectionRefusedError, ConnectionError):
            Timeout,
            ConnectTimeout,
            ConnectionRefusedError,
            ConnectionError,
            RequestsConnectionError,
        ):
            pass
        if blocked:
            logger.info(item)
            logger.info(text)
            logger.error("Got blocked. Fuck.")
-            time.sleep(60 * 60)
+            time.sleep(60*60*72)
        # trunk-ignore(bandit/B311)
-        rand = random.randint(1, 60)
+        rand = random.randint(1,100)
-        logger.info(f"Sleeping for {2*rand} minutes")
+        logger.info(f"Sleeping for {3*rand} minutes")
-        time.sleep(120 * rand)
+        time.sleep(180*rand)
-
+def scraper(logger = None):
 def scraper(logger=None):
    """
    This function is responsible for scraping data.
    """
    if not logger:
        logger = logging.getLogger()
        logger.setLevel("DEBUG")
@@ -123,13 +82,12 @@ def scraper(logger=None):
        logger.addHandler(h1)
        logger.info("No logger set. Test run")
-    loader = Thread(target=load_ndb_to_q, args=(logger,))
+    loader = Thread(target = load_ndb_to_q, args = (logger,))
-    _scraper = Thread(target=check_if_exists_brute_force, args=(logger,))
+    scraper = Thread(target = check_if_exists_brute_force, args = (logger,))
    loader.start()
-    _scraper.start()
+    scraper.start()
    loader.join()
-    _scraper.join()
+    scraper.join()
 if __name__ == "__main__":
    scraper()
@@ -1,66 +1,28 @@
-"""
+#TODO: Wpiemdolić to wszystko w klasę z loggerem przysłanym z góry
 This module contains functions for searching for DOI (Digital Object Identifier)
 in a list of live results.
 It includes a producer-consumer pattern implementation using threads and queues.
-Functions:
+from queue import Queue, Empty
 - producer: Reads lines from a file and puts them into an output queue.
 - consumer: Consumes items from an input queue and checks if DOI exists in the live results list.
 - search_for_doi: Searches for DOI in live results using the producer-consumer pattern.
 Global Variables:
 - MAXTHREADS: Maximum number of worker threads.
 - DATABASE_PATH: Path to the database files.
 - ENCODING: Encoding of the database files.
 - CHUNK: File name pattern for the database files.
 - _sentinel: Sentinel object used to signal termination.
 - result_list: List to store the search results.
 - WORK_Q_SIZE: Maximum size of the work queue.
 """
 # TODO: Wpiemdolić to wszystko w klasę z loggerem przysłanym z góry
 from queue import Empty, Queue
 from threading import Thread
 import time
 q = Queue()
 #TODO: Count number of lines in files and print to approximate on which part of the file search is
-# DATA FOR TEST ONLY
+#TODO: DATA FOR TEST ONLY
-# MAXTHREADS = 5
+#MAXTHREADS = 5
-# DATABASE_PATH = r'C:\\Database\\chunks_1\\'
+#DATABASE_PATH = r'C:\\Database\\chunks_1\\'
-# DEPLOYMENT DATA
+#TODO: DEPLOYMENT DATA
 MAXTHREADS = 41
-DATABASE_PATH = r"C:\\Database\\chunks\\"
+DATABASE_PATH = r'C:\\Database\\chunks\\'
 ENCODING = "utf-8"
-CHUNK = "_chunk.txt"
+CHUNk = "_chunk.txt"
 _sentinel = object()
-WORK_Q_SIZE = 35500000
+result_list = []
 WORK_Q_SIZE = 15500000
-
+def producer(out_q, control_q, filename, logger):
 def producer(out_q, control_q, filename, _logger):
    """
    Produces items from the output queue and puts them into the control queue.
    Args:
        out_q (Queue): Output queue.
        control_q (Queue): Control queue.
        filename (str): Name of the file.
        _logger: Logger object for logging.
    """
    with open(DATABASE_PATH + filename, "r+", encoding=ENCODING) as operated_file:
-        print(f"Worker {filename} ")
+        logger.info(f"Worker {filename} ")
        line_no = 0
        while True:
            line = operated_file.readline()
            line_no += 1
            print(f"\t \t \t \t \t \t W{filename}{line_no}\r", end="")
            if not line:
                print(f"EOF {filename}")
                break
            if not line:
                break
            out_q.put(line)
@@ -68,133 +30,77 @@ def producer(out_q, control_q, filename, _logger):
                check = control_q.get(block=False)
            except Empty:
                check = False
-
+                pass
            if check is _sentinel:
-                print("TERM signal received")
+                logger.info("TERM signal received")
                control_q.put(check)
                break
-        print(f"Worker finished: {filename}")
+        logger.info(f"Worker finished: {filename}")
        out_q.put(_sentinel)
-
+#IMPORTANT!!! ONLY ONE CONSUMER THREAD AS WE ARE NOT PUTTING SENTINELS BACK
-# IMPORTANT!!! ONLY ONE CONSUMER THREAD AS WE ARE NOT PUTTING SENTINELS BACK
+#TODO: Change doi to tuple list and only put term when all doi are found => (doi, True)
-def consumer(in_q, control_q, doi, live_results, result_list, control_dict, no, _logger):
+def consumer(in_q, control_q, doi, live_results, logger):
-    """
+    sentinels = 0
-    Consumes items from an input queue and checks if DOI exists in the live results list.
+    for item in doi:
-
+        result_list.append({"DOI" : item[0], "exists" : False, "data" : item[1]})
    Args:
        in_q (Queue): Input queue.
        control_q (Queue): Control queue.
        doi (list): List of DOI to search for.
        live_results (list): List to store the search results.
        _logger: Logger object for logging.
    """
    print(f"Consumer thread started: {no} no")
    empty_counter = 0
    alive_no = 0
    while True:
        done_check = True
-        try:
+        data = in_q.get()
-            data = in_q.get(block=True, timeout = 1)
+        if data is _sentinel:
-            if data is _sentinel:
+            logger.info("Worker finished")
-                control_dict["sentinels"] += 1
+            sentinels += 1
-                print(f"Workers finished: {control_dict['sentinels']} reported by consumer {no}")
+        else:
-
+            for item in result_list:
-            else:
+                if item["DOI"] in data and not item["exists"]:
-                empty_counter = 0
+                    logger.info(data)
-                alive_no += 1
+                    logger.info("HIT")
-                print(f"C{no}__{alive_no}\r", end="")
+                    item["exists"] = True
-
+                    live_results.append(item)
-                for item in result_list:
+                done_check = done_check and item["exists"]
-                    if item["DOI"] in data and not item["exists"]:
+            if done_check:
-                        print(f"HIT in {no} content {data[0]} line {data[1]} file {data[2]} {item["exists"]}")
+                control_q.put(_sentinel)
-                        _logger.info(data)
+        if sentinels >= MAXTHREADS:
-                        _logger.info("HIT")
+            logger.info("All workers finished")
                        item["exists"] = True
                        live_results.append(item)
                    done_check = done_check and item["exists"]
                if done_check:
                    control_q.put(_sentinel)
        except Empty:
            empty_counter += 1
            time.sleep(1)
            print(f"Consumer {no} empty")
            if empty_counter > 5:
                print("Consumer %s empty lvl 2", no)
                time.sleep(2)
            elif empty_counter > 10:
                print(f"Consumer thread finished {no}")
                break
        if control_dict["sentinels"] >= MAXTHREADS:
            _logger.info(f"All workers finished {no}")
            break
-
+def search_for_doi(doi, live_results, logger):
 def search_for_doi(doi, live_results, _logger):
    """
    Search for DOI in live_results using _logger for logging.
    Args:
        doi (list): List of DOI to search for.
        live_results (list): List to store the search results.
        _logger: Logger object for logging.
    """
    control_dict = {"sentinels":0}
    result_list = []
    threads = []
    work_q = Queue(maxsize=WORK_Q_SIZE)
    control_q = Queue()
-
+    t_cons = Thread(target = consumer, args = (work_q, control_q, doi, live_results, logger))
-    for item in doi:
+    logger.info("Consumer thread created")
-        result_list.append({"DOI": item[0], "exists": False, "data": item[1]})
+    threads.append(t_cons)
-
+    for i in range(0,MAXTHREADS):
-    for i in range (0, (len(doi)//1000)+2):
+        #TODO: TEST DATA
-        t_cons = Thread(
+        #filename = "test" + str(i) + CHUNk
-            target=consumer, args=(work_q, control_q, doi, live_results, result_list, control_dict, i, _logger)
+        #TODO: DEPLOYMENT DATA
-        )
+        filename = str(i) + CHUNk
-        _logger.info("Consumer thread created")
+        logger.info(f"Creating worker thread no: {i}")
-        threads.append(t_cons)
+        threads.append(Thread(target = producer, args = (work_q, control_q, filename,logger)))
    for i in range(0, MAXTHREADS):
        # TEST DATA
        # filename = "test" + str(i) + CHUNk
        # DEPLOYMENT DATA
        filename = str(i) + CHUNK
        _logger.info(f"Creating worker thread no: {i}")
        threads.append(
            Thread(target=producer, args=(work_q, control_q, filename, _logger))
        )
    for worker in threads:
        worker.start()
    for worker in threads:
        worker.join()
    return result_list
 if __name__ == "__main__":
    import logging
    logger = logging.getLogger()
    logger.setLevel("DEBUG")
    h1 = logging.StreamHandler()
    logger.addHandler(h1)
    logger.info("TEST RUN")
    live_result = []
-    logger.info(
+    logger.info(search_for_doi([
-        search_for_doi(
+        ("10.1002/9781118786352.wbieg0998.pub2","DATA"),
-            [
+        ("10.1002/j.2050-0416.2002.tb00563.x","DATA"),
-                ("10.1002/9781118786352.wbieg0998.pub2", "DATA"),
+        ("10.1111/j.1365-2958.1994.tb00448.x","DATA"),
-                ("10.1002/j.2050-0416.2002.tb00563.x", "DATA"),
+        ("10.2165/00128415-200309690-00017","DATA"),
-                ("10.1111/j.1365-2958.1994.tb00448.x", "DATA"),
+        ("10.5772/48313","DATA"),
-                ("10.2165/00128415-200309690-00017", "DATA"),
+        ("10.15803/ijnc.7.2_419","DATA"),
-                ("10.5772/48313", "DATA"),
+        ("10.1051/0004-6361/201321596e","DATA"),
-                ("10.15803/ijnc.7.2_419", "DATA"),
+        ("10.2307/40835941","DATA"),
-                ("10.1051/0004-6361/201321596e", "DATA"),
+        ], live_result, logger))
                ("10.2307/40835941", "DATA"),
            ],
            live_result,
            logger,
        )
    )
    logger.info(live_result)
@@ -1,206 +0,0 @@
 """
 This module contains functions for searching for DOI (Digital Object Identifier)
 in a list of live results.
 It includes a producer-consumer pattern implementation using threads and queues.
 Functions:
 - producer: Reads lines from a file and puts them into an output queue.
 - consumer: Consumes items from an input queue and checks if DOI exists in the live results list.
 - search_for_doi: Searches for DOI in live results using the producer-consumer pattern.
 Global Variables:
 - MAXTHREADS: Maximum number of worker threads.
 - DATABASE_PATH: Path to the database files.
 - ENCODING: Encoding of the database files.
 - CHUNK: File name pattern for the database files.
 - _sentinel: Sentinel object used to signal termination.
 - result_list: List to store the search results.
 - WORK_Q_SIZE: Maximum size of the work queue.
 """
 # TODO: Wpiemdolić to wszystko w klasę z loggerem przysłanym z góry
 from multiprocessing import Manager, Process, Queue
 from queue import Empty, Full
 import time
 # DATA FOR TEST ONLY
 #MAXTHREADS = 6
 #DATABASE_PATH = r'C:\\Database\\chunks_1\\'
 # DEPLOYMENT DATA
 MAXTHREADS = 41
 DATABASE_PATH = r"C:\\Database\\chunks\\"
 ENCODING = "utf-8"
 CHUNK = "_chunk.txt"
 _sentinel = None
 WORK_Q_SIZE = 355000
 def producer(out_q, control_q, filename, _logger):
    """
    Produces items from the output queue and puts them into the control queue.
    Args:
        out_q (Queue): Output queue.
        control_q (Queue): Control queue.
        filename (str): Name of the file.
        _logger: Logger object for logging.
    """
    with open(DATABASE_PATH + filename, "r+", encoding=ENCODING) as operated_file:
        print(f"Worker {filename} ")
        line_no = 0
        while True:
            line = operated_file.readline()
            line_no += 1
            print(f"\t \t \t W{filename}{line_no}\r", end="")
            if not line:
                print(f"EOF {filename}")
                break
            try:
                out_q.put([line, line_no, filename], block = True, timeout = 60)
            except Full:
                print("queue fulll")
            try:
                check = control_q.get(block=False)
            except Empty:
                check = False
            if check is None:
                print(f"TERM signal received {filename}")
                control_q.put(check)
                control_q.close()
                break
        print(f"Worker finished: {filename}")
        out_q.put(_sentinel)
        out_q.close()
 # IMPORTANT!!! ONLY ONE CONSUMER THREAD AS WE ARE NOT PUTTING SENTINELS BACK
 def consumer(in_q, control_q, doi, live_results, result_list, control_dict, no, _logger):
    """
    Consumes items from an input queue and checks if DOI exists in the live results list.
    Args:
        in_q (Queue): Input queue.
        control_q (Queue): Control queue.
        doi (list): List of DOI to search for.
        live_results (list): List to store the search results.
        _logger: Logger object for logging.
    """
    print(f"Consumer thread started: {no} no")
    empty_counter = 0
    alive_no = 0
    while True:
        done_check = True
        try:
            data = in_q.get(block=True, timeout = 1)
            empty_counter = 0
            if data is None:
                control_dict["sentinels"] += 1
                print(f"Workers finished: {control_dict['sentinels']} reported by consumer {no}")
            else:
                empty_counter = 0
                if alive_no > 9:
                    alive_no = 0
                alive_no += 1
                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"]}")
                        item["exists"] = True
                        live_results.append(item)
                    done_check = done_check and item["exists"]
                if done_check:
                    control_q.put(_sentinel)
        except Empty:
            empty_counter += 1
            time.sleep(1)
            print(f"Consumer {no} empty")
            if empty_counter > 5:
                print("Consumer %s empty lvl 2", no)
                time.sleep(2)
            elif empty_counter > 10:
                print(f"Consumer thread finished {no}")
                break
        if control_dict["sentinels"] >= MAXTHREADS:
            print(f"All workers finished killing {no}")
            break
    print("Consumer thread finished %s",no )
    control_q.close()
 def search_for_doi(doi, live_results, _logger):
    """
    Search for DOI in live_results using _logger for logging.
    Args:
        doi (list): List of DOI to search for.
        live_results (list): List to store the search results.
        _logger: Logger object for logging.
    """
    with Manager() as manager:
        control_dict = manager.dict()
        control_dict["sentinels"] = 0
        result_list = []
        for item in doi:
            result_list.append({"DOI": item[0], "exists": False, "data": item[1]})
        result_list_proxy = manager.list(result_list)
        threads = []
        work_q = Queue(maxsize=WORK_Q_SIZE)
        control_q = Queue()
        for i in range(0, MAXTHREADS):
            # TEST DATA
            #filename = "test" + str(i) + CHUNK
            # DEPLOYMENT DATA
            filename = str(i) + CHUNK
            print(f"Creating worker thread no: {i}")
            threads.append(
                Process(target=producer, args=(work_q, control_q, filename, _logger))
            )
        for i in range (0, (len(doi)//1000)+5):
            t_cons = Process(
                target=consumer, args=(work_q, control_q, doi, live_results, result_list_proxy, control_dict, i, _logger)
            )
            print("Consumer thread created")
            threads.append(t_cons)
        for worker in threads:
            worker.start()
        for worker in threads:
            worker.join()
        result_list = list(result_list_proxy)
        for worker in threads:
            worker.close()
        return result_list
 if __name__ == "__main__":
    import logging
    logger = logging.getLogger()
    logger.setLevel("DEBUG")
    h1 = logging.StreamHandler()
    logger.addHandler(h1)
    print("TEST RUN")
    live_result = []
    print(
        search_for_doi(
            [
                ("10.1002/9781118786352.wbieg0998.pub2", "DATA"),
                ("10.1002/j.2050-0416.2002.tb00563.x", "DATA"),
                ("10.1111/j.1365-2958.1994.tb00448.x", "DATA"),
                ("10.2165/00128415-200309690-00017", "DATA"),
                ("10.5772/48313", "DATA"),
                ("10.15803/ijnc.7.2_419", "DATA"),
                ("10.1051/0004-6361/201321596e", "DATA"),
                ("10.2307/40835941", "DATA"),
                ("NOT_ON_LIST", "DATA"),
            ],
            live_result,
            logger,
        )
    )
    print(live_result)
@@ -1,45 +0,0 @@
 import asyncio
 import json
 import logging
 from json.decoder import JSONDecodeError
 from logging import handlers
 import requests
 MAIN_BOT_ADDRESS = "http://192.168.1.191:5000"
 SEND_RESULTS = "/conjurer"
 async def send_results():
    logger = logging.getLogger()
    logger.setLevel(logging.DEBUG)
    h1 = handlers.RotatingFileHandler(
        filename="D:\\logs\\librarian.log",
        encoding="utf-8",
        mode="a",
        maxBytes=6 * 1024 * 1024,
        backupCount=6,
    )
    logger.addHandler(h1)
    with open("s_results.json", "r+", encoding="utf-8") as s_file:
        try:
            database = json.load(s_file)
        except JSONDecodeError:
            pass
    result = database["4bacbca0-ce3b-45c6-90a1-05c70b46b740"]
    result = {"4bacbca0-ce3b-45c6-90a1-05c70b46b740":result}
    coroutine = asyncio.to_thread(
        requests.post,
        f"{MAIN_BOT_ADDRESS}{SEND_RESULTS}",
        json=result,
        timeout=360,
    )
    logger.info("SENT")
    result = await coroutine
    logger.info(result.status_code)
    logger.info("SEND CONFIRMED")
 async def main():
    await send_results()
 if __name__ == "__main__":
    asyncio.run(main())
@@ -1,125 +1,67 @@
 # This Python file uses the following encoding: utf-8
 """
 The provided Python script sets up a Flask web server to manage a list of music files, with
 functions for rescanning the music folder, updating the music list, and serving the music list via
 API endpoints.
 """
 import json
 import logging
 import os
 import random
 import re
 import threading
 import time
 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, jsonify, redirect, request, send_from_directory
 from flask import (
    Flask,
    abort,
    jsonify,
    redirect,
    render_template,
    request,
    send_from_directory,
 )
 from waitress import serve
-import media_search_functions
+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"
    else:
        LOGFILE = "/home/pi/Conjurer/discord_mus_service.log"
        NETRC_FILE = "/home/pi/.netrc"
        LOGSTORE = "/home/pi/RetroPie/logs/"
        ENCODING = "utf-8"
        MUSIC_FOLDER = "/home/pi/RetroPie/mp3/"
-def _env(name: str, default: str) -> str:
+music_file_list = []
    return os.getenv(name, default)
-def _env_path(name: str, default: str) -> Path:
+def create_playlist():
-    value = os.getenv(name, default)
+    """
-    return Path(value).expanduser().resolve()
+    Reads a JSON file containing a playlist and writes the playlist items to a text file.
    The JSON file path is '/home/pi/Conjurer/playlist.json',
    and the text file path is '/home/pi/Conjurer/all_playlist.playlist'.
-API_KEY = os.getenv("CONJURER_API_KEY")
+    Raises:
-MAIN_BOT_ADDRESS = _env("CONJURER_MAIN_BOT", "http://127.0.0.1:5000")
+        JSONDecodeError: If the JSON file cannot be decoded.
 MUSIC_TRACKER = _env("CONJURER_MUSIC_TRACKER_ENDPOINT", "/prepped_tracks")
 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))
+    with open("/home/pi/Conjurer/playlist.json", "r+", encoding="utf-8") as r_file:
-)
+        with open(
-LOGFILE = _env_path(
+            "/home/pi/Conjurer/all_playlist.playlist", "w", encoding="utf-8"
-    "CONJURER_MUSICIAN_LOG", str(BASE_DIR / "discord_mus_service.log")
+        ) as w_file:
-)
+            try:
-LOGSTORE = _env_path("CONJURER_LOGSTORE", str(BASE_DIR / "logs"))
+                playlist = json.load(r_file)
-MUSIC_FOLDER = _env_path(
+                for item in playlist:
-    "CONJURER_MUSIC_FOLDER", str(BASE_DIR / "music")
+                    w_file.write(item)
-)
+                    w_file.write("\n")
-PRIORITY_FOLDER = _env_path(
+            except json.JSONDecodeError:
-    "CONJURER_PRIORITY_FOLDER", str(MUSIC_FOLDER / "priority")
+                pass
 )
 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] = []
 priority_list: List[str] = []
 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():
@@ -127,38 +69,19 @@ def rescan():
    The `rescan` function logs a message, scans for mp3 files in a specified folder,
    and adds them to a list of music files.
    """
-    logger = logging.getLogger("conjurer_musician")
+    logging.info("Rescan triggered")
-    logger.info("Rescan triggered")
+    for mp3_item in Path.glob(Path(MUSIC_FOLDER), "**/*.mp3"):
    music_file_list.clear()
    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)
-
+    with open("/home/pi/Conjurer/playlist.json", "r+", encoding="utf-8") as s_file:
-    for mp3_item in PRIORITY_FOLDER.glob("**/*.mp3"):
+        database = music_file_list
-        temp_music_file = mp3_item.as_posix()
+        # self.app.logger.info("DUMPING DATA")
-        if os.name == "nt":
+        s_file.truncate(0)
-            temp_music_file = temp_music_file.replace("/", "\\")
+        s_file.seek(0)
-        priority_list.append(temp_music_file)
+        json.dump(database, s_file)
-
+    create_playlist()
    with ALL_PLAYLIST_PATH.open("w", encoding=ENCODING) 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:
        try:
            for item in priority_list:
                w_file.write(item)
                w_file.write("\n")
        except json.JSONDecodeError:
            pass
 def thread_rescan():
@@ -166,65 +89,14 @@ def thread_rescan():
    The `thread_rescan` function periodically triggers a rescan operation after a specified time
    interval.
    """
-    logger = logging.getLogger("conjurer_musician")
+    logging.info("Starting filesystemupdater")
    logger.info("Starting filesystemupdater")
    while True:
        time.sleep(60 * 60 * 24)
-        logger.info("Rescan triggered")
+        logging.info("Rescan triggered")
        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:
            current_size = os.stat(PERSISTENCE_PATH).st_size
            if prev_size != current_size:
                while prev_size != current_size:
                    prev_size = current_size
                    time.sleep(0.1)
                    current_size = os.stat(PERSISTENCE_PATH).st_size
                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()
            line = log_file.readline()
            if not line:
                time.sleep(1)
                log_file.seek(position)
                continue
            if not re.match(r".*Prepared.*", line):
                time.sleep(0.1)
                continue
            result = None
            if re.match(r".*jingles.*", line):
                result = ["jingles", line]
            elif re.match(r".*priority.*", line):
                result = ["priority", line]
            elif re.match(r".*hit.*", line):
                result = ["hit", line]
            elif re.match(r".*all_playlist.*", line):
                result = ["all", line]
            elif re.match(r".*request.*", line):
                result = ["requests", line]
            if result:
                logger.info("Forwarding radio log entry: %s", result[0])
                _post_to_bot(result)
            time.sleep(0.1)
 app = Flask(__name__)
 # AutoIndex(app, browse_root="/")
 # TODO: Odpalić wyszukiwarki w wątkach i dopiero po wszystkim zsumować wyszukiwanie.
@@ -329,15 +201,24 @@ 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:
        fun_logger.info("Wiele plików do zagrania")
        search_weight.sort(key=lambda x: x[0], reverse=True)
        return_list.extend(search_weight[: int(how_many)])
-    fun_logger.info("Done: %s", return_list)
+        if not return_to_bot:
            with open(
               "/home/pi/Conjurer/priority_queue.playlist", "r+", encoding="utf-8"
            ) as s_file:
                s_file.truncate(0)
                for item in return_list:
                    s_file.write(item[1] + "\n")
    return return_list
@@ -369,94 +250,47 @@ def remove_characters(string, character):
    return string.replace(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')
    # Validate entries
    if not isinstance(entries, int) or not (1 <= entries <= 10):
        return jsonify({'error': '"entries" must be an integer between 1 and 10.'}), 400
    # Validate keywords list
    if not isinstance(keywords, list) or not all(isinstance(k, str) for k in keywords):
        return jsonify({'error': '"keywords" must be a list of strings.'}), 400
    # Call external search
    files = media_search_functions.find_matches(entries, keywords)
    # Return each file path as a JSON list
    return jsonify({'files': files}), 200
@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
    if not isinstance(file_paths, list) or not all(isinstance(p, str) for p in file_paths):
        return jsonify({'error': '"file_paths" must be a list of strings.'}), 400
    # Call external publish
    links = media_search_functions.publish(file_paths)
    # Return list of published links
    return jsonify({'links': links}), 200
@app.route("/stream", methods=["GET"])
 def stream_music():
    """
-    The function `stream_music` is a route handler for the "/stream" endpoint.
+    The function `get_music_list` returns a JSON object containing a list of music files.
-    It returns a JSON response containing a key "music_file_list" with the value of the variable `music_file_list`.
+    :return: A JSON response containing a key "music_file_list" with the value of the variable
-
+    `music_file_list`.
    :return: A JSON response containing a key "music_file_list" with the value of the variable `music_file_list`.
    """
    return send_from_directory("/tmp/hls", "stream.m3u8")
-    # return send_from_directory("/tmp/hls", "stream.m3u8")
+@app.route('/<string:file_name>')
    return render_template(str(STREAM_TEMPLATE))
@app.route("/<string:file_name>")
 def stream(file_name):
-    """
+    video_dir = '/tmp/hls'
    Stream the specified file from the video directory.
    Args:
        file_name (str): The name of the file to be streamed.
    Returns:
        Response: The response containing the streamed file.
    """
    # trunk-ignore(bandit/B108)
    video_dir = "/tmp/hls"
    return send_from_directory(video_dir, file_name)
@app.route("/stream_mp3", methods=["GET"])
 def stream_music_mp3():
    """
-    The function `stream_music_mp3` is a route handler for the "/stream_mp3" endpoint.
+    The function `get_music_list` returns a JSON object containing a list of music files.
-    It redirects the user to the URL "http://www.example.com" with a status code of 302.
+    :return: A JSON response containing a key "music_file_list" with the value of the variable
-
+    `music_file_list`.
    :return: A redirect response to "http://www.example.com" with a status code of 302.
    """
    return redirect("http://www.example.com", code=302)
@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.
+    The function `get_music_list` returns a JSON object containing a list of music files.
-
+    :return: A JSON response containing a key "music_file_list" with the value of the variable
-    :return: A JSON response indicating the success of the operation.
+    `music_file_list`.
    """
-    app.logger.info("CLEARING PLAYLIST")
+    with open(
-    with PRIORITY_PLAYLIST_PATH.open("w", encoding=ENCODING) as cleared_pl:
+        "/home/pi/Conjurer/priority_queue.playlist", "w", encoding="utf-8"
-        cleared_pl.write("")
+        ) as s_file:
-
+        s_file.truncate(0)
    return_data = jsonify(isError=False, message="Success", statusCode=200, data=[])
    return return_data, 200
@app.route("/mp3", methods=["GET"])
 def get_music_list():
    """
@@ -478,7 +312,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"])
@@ -492,23 +325,20 @@ def update_music_list():
@app.route("/get_music", methods=["POST"])
 def look_for_playlist():
    """
-    The function `look_for_playlist` receives a POST request with a JSON payload, logs the received
+    The function `update_music_list` receives a POST request with a JSON payload, logs the received
    item, adds it to a music file list, and returns a success message along with the updated record.
-
+    :return: The function `update_music_list` is returning a tuple containing a JSON response and a
-    :return: A tuple containing a JSON response and a status code. The JSON response includes keys `isError`,
+    status code. The JSON response includes keys `isError`, `message`, `statusCode`, and `data`,
-             `message`, `statusCode`, and `data`, with values indicating the success of the operation and the
+    with values indicating the success of the operation and the data that was
-             data that was received and added to the `music_file_list`. The status code returned is 200,
+    received and added to the `music_file_list`.
-             indicating a successful response.
+    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"])
    app.logger.info(record["UUID"])
    app.logger.info(record["dlugosc_plejlisty"])
-    return_data = wyszukaj(
+    return_data = wyszukaj(record["lista_slow"], record["dlugosc_plejlisty"], app.logger, True)
        record["lista_slow"], record["dlugosc_plejlisty"], app.logger, True
    )
    return_data = (
        jsonify(isError=False, message="Success", statusCode=200, data=return_data),
@@ -516,92 +346,26 @@ def look_for_playlist():
    )
    return return_data
@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:
        for item in return_data:
            s_file.write(item[1] + "\n")
    return_data = (
        jsonify(
            isError=False, message="Success", statusCode=200, data={"status": "OK"}
        ),
        200,
    )
    return return_data
@app.route("/create_priority_playlist", methods=["POST"])
 def create_priority_playlist():
    """
    The function `create_priority_playlist` receives a POST request with a JSON payload, logs the received
    item, adds it to a music file list, and returns a success message along with the updated record.
    :return: A tuple containing a JSON response and a status code.
        The JSON response includes keys `isError`,
        `message`, `statusCode`, and `data`, with values
        indicating the success of the operation and the
        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"])
    app.logger.info(record["UUID"])
    app.logger.info(record["dlugosc_plejlisty"])
    return_data = wyszukaj(
        record["lista_slow"], record["dlugosc_plejlisty"], app.logger, False
    )
    random.shuffle(return_data)
    with REQUEST_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
        for item in return_data:
            s_file.write(item[1] + "\n")
    return_data = (
        jsonify(
            isError=False, message="Success", statusCode=200, data={"status": "OK"}
        ),
        200,
    )
    return return_data
@app.route("/add_to_priority", methods=["POST"])
 def add_to_priority():
    """
-    The function `add_to_priority` receives a POST request with a JSON payload, logs the received
+    The function `update_music_list` receives a POST request with a JSON payload, logs the received
    item, adds it to a music file list, and returns a success message along with the updated record.
-
+    :return: The function `update_music_list` is returning a tuple containing a JSON response and a
-    :return: A tuple containing a JSON response and a status code.
+    status code. The JSON response includes keys `isError`, `message`, `statusCode`, and `data`,
-        The JSON response includes keys `isError`,
+    with values indicating the success of the operation and the data that was
-        `message`, `statusCode`, and `data`, with values
+    received and added to the `music_file_list`.
-        indicating the success of the operation and the
+    The status code returned is 200, indicating a successful response.
        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"])
    app.logger.info(record["UUID"])
    app.logger.info(record["dlugosc_plejlisty"])
-    return_data = wyszukaj(
+    return_data = wyszukaj(record["lista_slow"], record["dlugosc_plejlisty"], app.logger, False)
-        record["lista_slow"], record["dlugosc_plejlisty"], app.logger, False
+
    )
    with PRIORITY_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
        for item in return_data:
            s_file.write(item[1] + "\n")
    return_data = (
-        jsonify(
+        jsonify(isError=False, message="Success", statusCode=200, data=return_data),
            isError=False, message="Success", statusCode=200, data={"status": "OK"}
        ),
        200,
    )
    return return_data
@@ -618,18 +382,8 @@ def flask_debug():
 def waitress_run():
    """
-    The `waitress_run` function serves the `app` on host HOST_ADDRESS
+    The `waitress_run` function serves the `app` on host "0.0.0.0"
    and port 5000 using the Waitress WSGI server.
    This function starts the Waitress server and listens for incoming requests
    on the specified host and port. It uses the `serve` function from the Waitress
    library to handle the serving process.
    Parameters:
        None
    Returns:
        None
    """
    serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS)
@@ -653,20 +407,12 @@ if __name__ == "__main__":
    rescan()
    logger.info("Started")
    threads = []
-    # threads.append(threading.Thread(target=flask_debug))
+    #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)
+    for worker in threads:
-    track_thread = threading.Thread(target=scan_tracks, daemon=True)
+        worker.join()
    track_thread.start()
    try:
        for worker in threads:
            worker.join()
        track_thread.join()
    except KeyboardInterrupt:
        logger.info("Shutdown requested - exiting musician service")
@@ -1,52 +0,0 @@
 #!/usr/bin/env python3
 import argparse
 import json
 import os
 import sys
 import uuid
 from pathlib import Path
 # CONFIGURATION
 JSON_DB        = '/var/log/share_scan.json'
 SHARE_DIR      = Path('/var/www/html/share')
 BASE_URL       = 'https://czernobog.pl/share'
 # Ensure share directory exists
 SHARE_DIR.mkdir(parents=True, exist_ok=True)
 def load_db():
    with open(JSON_DB) as f:
        return json.load(f)['entries']
 ENTRIES = load_db()
 def relevancy(path, keywords):
    score = 0
    low = path.lower()
    for kw in keywords:
        if kw.lower() in low:
            score += low.count(kw.lower())
    return score
 def find_matches(count, keywords):
    scored = []
    for e in ENTRIES:
        score = relevancy(e['path'], keywords)
        if score > 0:
            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):
    urls = []
    for path in paths:
        token = uuid.uuid4().hex
        link = SHARE_DIR / token
        try:
            os.symlink(path, link)
        except FileExistsError:
            pass
        urls.append(f"{BASE_URL}/{token}")
    return urls
@@ -1,98 +0,0 @@
 # This Python file uses the following encoding: utf-8
 """This module contains utility scripts used by musi radiostation Conjurer"""
 import time
 import re
 import os
 import argparse
 from mutagen.easyid3 import EasyID3
 from mutagen.mp3 import MP3
 def update_metadata(folder_path):
    for root, _, files in os.walk(folder_path):
        for file in files:
            if file.endswith(".mp3"):
                file_path = os.path.join(root, file)
                # Sample logic for guessing metadata from filename
                # Assuming the filename format is "Artist - Title.mp3"
                try:
                    artist, title = file.rsplit(" - ", 1)
                    title = title.replace(".mp3", "")
                except ValueError:
                    # If file name doesn't fit the expected pattern, skip
                    print(f"Skipping file due to unexpected format: {file}")
                    continue
                try:
                    # Load the mp3 file
                    audio = MP3(file_path, ID3=EasyID3)
                    # Update metadata
                    audio["artist"] = artist.strip()
                    audio["title"] = title.strip()
                    # Save changes
                    audio.save()
                    print(f"Updated metadata for: {file}")
                except Exception as e:
                    print(f"Failed to update metadata for {file}: {e}")
 NAME = "/home/pi/Conjurer/persistence.log"
 def print_top():
    """
    Prints the top 65 lines from a file specified by the NAME variable.
    """
    while True:
        line = ""
        buffer = ""
        with open(NAME, "r", encoding="utf-8") as f:
            for _ in range(45):
                line = f.readline()
                if re.match(".*mp3", line):
                    buffer += line
            print("=====================================")
            print(buffer)
            print("=====================================")
        time.sleep(180)
 def main():
    parser = argparse.ArgumentParser(
        description="Perform operations on a directory of .mp3 files."
    )
    # Positional argument for choosing the function to execute
    parser.add_argument(
        "operation",
        type=str,
        choices=["update_metadata", "print_top"],
        help="Operation to perform: update_metadata or print_top.",
        default="print_top",
    )
    # Positional argument for folder path
    parser.add_argument("folder", type=str, help="Path to the folder to operate on.")
    args = parser.parse_args()
    if args.operation == "update_metadata":
        if args.folder:
            folder_to_scan = args.folder
        else:
            print("Please provide a folder path to scan.")
            raise ValueError("No folder path provided.")
    if args.operation == "update_metadata" and os.path.isdir(folder_to_scan):
        update_metadata(folder_to_scan)
    elif args.operation == "print_top":
        print_top()
    else:
        print(f"The specified path is not a directory: {folder_to_scan}")
 if __name__ == "__main__":
    main()
@@ -1,14 +0,0 @@
 $dodaj_do_ulubionych 100 nightwish
 $dodaj_do_ulubionych 100 amon amarth
 $dodaj_do_ulubionych 100 tactical sekt
 $dodaj_do_ulubionych 100 lacuna coil
 $dodaj_do_ulubionych 100 sefa
 $dodaj_do_ulubionych 100 frenchcore
 $dodaj_do_ulubionych 100 peacock
 $dodaj_do_ulubionych 100 vavamuffin
 $dodaj_do_ulubionych 100 abradab
 $dodaj_do_ulubionych 100 eluveitie
 $dodaj_do_ulubionych 100 youtube
 $dodaj_do_ulubionych 100 elyose
 $dodaj_do_ulubionych 1 artisans du chaos
@@ -1,9 +0,0 @@
 /home/pi/Conjurer/radio_log.log {
    daily
    rotate 7
    compress
    delaycompress
    missingok
    notifempty
    copytruncate
 }
@@ -1,191 +1,48 @@
 # FILEPATH: /home/mtuszowski/conjurer/conjurer_musician/radio_conjurer.liq
 # This script sets up a Liquidsoap radio stream with various features and configurations.
 # Load icecast credentials from a JSON file
 let json.parse credentials  = file.contents("/home/pi/Conjurer/icecast_credentials.json")
 # Enable replaygain metadata processing
 enable_replaygain_metadata()
-# Set up a playlog for tracking played tracks
+s1 = replaygain(playlist(reload_mode="watch", "/home/pi/Conjurer/all_playlist.playlist"))
 s2 = replaygain(playlist(reload_mode="watch", "/home/pi/Conjurer/priority_queue.playlist"))
-l = playlog(duration = 72000.0, persistency="/home/pi/Conjurer/persistence.log")
+s = random(id="randomizer", weights=[7000, 100], [s2, s1])
 # Function to check if a track can be played based on its metadata
 def check(r)
    m = request.metadata(r)
    if l.last(m) < 36000. then
        log.info("Rejecting #{m['filename']} (played #{l.last(m)}s ago).")
        false
    else
        l.add(m)
        true
    end
 end
 # Define playlists to be used in the stream
 s1 = replaygain(playlist(reload_mode="watch", check_next=check, "/home/pi/Conjurer/all_playlist.playlist"))
 s2 = replaygain(playlist(reload_mode="watch", check_next=check, "/home/pi/Conjurer/priority_queue.playlist"))
 s3 = replaygain(playlist(reload_mode="watch", check_next=check, "/home/pi/Conjurer/hit.playlist"))
 # Create a request queue for user-generated requests
 requests_queue = request.queue()
 # Function to process the request queue and add new requests
 def queue_processing()
    text=file.lines("/home/pi/Conjurer/request.playlist")
    if text != [] then
        list.iter(fun(item) -> requests_queue.push.uri(item), text)
        file.remove("/home/pi/Conjurer/request.playlist")
        f = file.open("/home/pi/Conjurer/request.playlist", create=true)
        f.close()
    end
 end
 # Configure output formats and destinations
 def now_playing(m)
  # raw lookup ("" if missing)
  raw_title  = m["title"]
  raw_artist = m["artist"]
  # default if empty
  title  = if raw_title  == "" then "Unknown" else raw_title  end
  artist = if raw_artist == "" then "Unknown" else raw_artist end
  log.critical("Now playing #{artist} - #{title}")
  # write it out
  system("echo '#{artist} - #{title}' > /tmp/now_playing.txt")
  m
 end
 # Randomly select a playlist with weights
 s4 = random(id="randomizer", weights=[2, 3, 5], [s1, s2, s3])
 # Load jingles playlist
 jingles = (playlist(reload_mode="watch", "/home/pi/Conjurer/jingles.playlist"))
 # Create the main stream with random playlist and jingles
 s = rotate(id="randomizer", weights=[10, 1], [s4, jingles])
 s = crossfade(fade_out=2., fade_in=2., duration=4., fallback(id="switcher", track_sensitive=true, [requests_queue, s]))
 s = metadata.map(now_playing, s)
 # Set up an interactive harbor for controlling the stream
 interactive.harbor(port = 9999)
-# Set up interactive controls for bass boost
+f = interactive.float("f", description="Frequency", min=0., max=1000.,unit="Hz", 200.)
-f = interactive.float("f", description="Frequency", min=0., max=1000., unit="Hz", 200.)
+g = interactive.float("g", description="Gain", min=0., max=20.,unit="dB", 8.)
 g = interactive.float("g", description="Gain", min=0., max=20., unit="dB", 8.)
 b = bass_boost(frequency=f, gain=g, s)
 s = add([s, b])
 a = interactive.float("main_volume", min=0., max=20., 1.)
 s = compress.multiband.interactive(bands=3, s)
-# Set up interactive control for main volume
+s = nrj(normalize (s))
-a = interactive.float("main_volume", min=0., max=20., 1.1)
+s = crossfade(fade_out=3., fade_in=3., duration=5., s)
-s = compress.multiband.interactive(bands=7, s)
+s = amplify(a,s)
-mic_gain = interactive.float("mic_volume", min=0., max=120., 0.5)
+s = blank.skip(max_blank=2., s)
-# Apply audio processing effects
+emergency = single("/home/pi/RetroPie/mp3/Youtube/Dr. Peacock - Trip to Ireland [GvrvQTUbUcA].mp3")
-tmic = buffer(input.pulseaudio()) # Microphone
+radio = fallback(id="switcher",track_sensitive = false, [s, emergency]) 
 mic = amplify(mic_gain, tmic)
 mic = gate(threshold=-80., range=-120., mic)
 mic = compress(threshold=0., ratio=2.,mic)
 mic = nrj(normalize(mic))
 mic = blank.strip(max_blank=15., min_noise=.1, threshold=-30., mic)
 mic =  fallback(id="switcher2", track_sensitive=false, [mic, blank()])
-# Apply audio processing effects
+handle_metadata = fun (m) -> begin
-s = nrj(s)
+    print(m["title"])
-s = amplify(a, s)
+    print(m["artist"])
-# Skip blank sections in the stream
+    print(m["filename"])
-s = blank.skip(max_blank=10., s)
+end
 radio.on_metadata(handle_metadata)
 interactive.persistent("script.params")
 #Manual audition override
 live_enabled = interactive.bool("Going Live!", true)
 s = add([mic,s])
 s=switch(track_sensitive=true,
    [(live_enabled, mic),
    ({true}, s)])
 # Configure logging settings
 log_to_stdout = true
 log_to_file = true
 logpath = "/home/pi/Conjurer/radio_log.log"
 loglevel = 3
 set("log.stdout", log_to_stdout)
 set("log.level", loglevel)
-# Enable logging to file
+# Enable logging on Standard Output and set logging level.
-set("log.file", log_to_file)
+set("log.stdout",log_to_stdout)
-set("log.file.path", logpath)
+set("log.level",loglevel)
 # Set up emergency fallback track
 emergency = single("/home/pi/MediaFolder/mp3/Youtube/Dr. Peacock - Trip to Ireland [GvrvQTUbUcA].mp3")
 radio =  fallback(id="switcher2", track_sensitive=false, [s, emergency])
-# Set up an interactive control for skipping tracks
+# Enable logging to file. See variable: logpath
-p = interactive.bool("Skip track", false)
+set("log.file",log_to_file)
-def http_skip(~protocol, ~data, ~headers, uri)=
+set("log.file.path",logpath)
    radio.skip()
    http.response(code=200,data="Skipped")
 end
 harbor.http.register(port=54321,method="GET","/skip", http_skip)
-
+output.file.hls("/tmp/hls",[("mp3-low", %mp3(bitrate=96)), ("mp3-hi", %mp3(bitrate=160))],radio)
-# Function to process the request queue and skip the current track if requested
+output.icecast(%mp3, host="retropie", port=8000,password=credentials.password, icy_metadata="true", mount="mp3-stream", radio)
 def check_skip()
    if p() then
        log.info("Skipping current track.")
        radio.skip()
        p.set(false)
    end
 end
 # Run the queue processing function every 60 seconds
 thread.run(every=60., queue_processing)
 # Run the check_skip function every 5 seconds
 thread.run(every=15., check_skip)
 # Enable persistent script parameters
 interactive.persistent("script.params")
 # Configure output formats and destinations
 output.icecast(%mp3, host="radio", port=8000, password=credentials.password, icy_metadata="true", mount="mp3-stream", radio)
 output.pulseaudio(radio)
 #output.file.hls("/tmp/hls", [("mp3-low", %mp3(bitrate=96)), ("mp3-hi", %mp3(bitrate=160))], radio)
 # Uncomment the following lines to enable additional output formats
 # output.icecast(%opus, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="opus-stream", radio)
 # output.icecast(%ogg, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="ogg-stream", radio)
 # output.icecast(%aac, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="aac-stream", radio)
 # output.icecast(%flac, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="flac-stream", radio)
 # output.icecast(%vorbis, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="vorbis-stream", radio)
 # output.icecast(%speex, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="speex-stream", radio)
 # output.icecast(%wav, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="wav-stream", radio)
 # output.icecast(%pcm, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="pcm-stream", radio)
 # output.icecast(%raw, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="raw-stream", radio)
 # output.icecast(%s16l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s16l-stream", radio)
 # output.icecast(%s16b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s16b-stream", radio)
 # output.icecast(%s24l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s24l-stream", radio)
 # output.icecast(%s24b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s24b-stream", radio)
 # output.icecast(%s32l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s32l-stream", radio)
 # output.icecast(%s32b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s32b-stream", radio)
 # output.icecast(%s64l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s64l-stream", radio)
 # output.icecast(%s64b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s64b-stream", radio)
 # output.icecast(%s128l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s128l-stream", radio)
 # output.icecast(%s128b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s128b-stream", radio)
 # output.icecast(%s256l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s256l-stream", radio)
 # output.icecast(%s256b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s256b-stream", radio)
 # output.icecast(%s512l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s512l-stream", radio)
 # output.icecast(%s512b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s512b-stream", radio)
 # output.icecast(%s1024l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s1024l-stream", radio)
 # output.icecast(%s1024b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s1024b-stream", radio)
 # output.icecast(%s2048l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s2048l-stream", radio)
 # output.icecast(%s2048b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s2048b-stream", radio)
 # output.icecast(%s4096l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s4096l-stream", radio)
 # output.icecast(%s4096b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s4096b-stream", radio)
 # output.icecast(%s8192l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s8192l-stream", radio)
 # output.icecast(%s8192b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s8192b-stream", radio)
@@ -1,4 +1,2 @@
 flask
 waitress
 sshtunnel
 requests
@@ -1,99 +0,0 @@
 #!/usr/bin/env python3
 import os
 import re
 import time
 import json
 import argparse
 import sys
 from pathlib import Path
 # — CONFIGURATION — adjust as needed —
 APACHE_LOG     = '/var/log/apache2/share_access.log'  # <- point to your share-specific log!
 SHARE_DIR      = Path('/var/www/html/share')
 METADATA_FILE  = SHARE_DIR / '.downloads.json'
 STATE_FILE     = SHARE_DIR / '.logpos'
 # Regex to match lines like: "GET /share/abcdef1234... HTTP/1.1"
 TOKEN_REGEX    = re.compile(r'"\s*GET\s+/share/([0-9a-f]{32})\s+HTTP/')
 def debug(msg, args):
    if args.debug:
        print(f"[DEBUG] {msg}", file=sys.stderr)
 def load_metadata(args):
    if METADATA_FILE.exists():
        data = json.loads(METADATA_FILE.read_text())
        debug(f"Loaded metadata: {data}", args)
        return data
    return {}
 def save_metadata(md, args):
    METADATA_FILE.write_text(json.dumps(md))
    debug(f"Saved metadata: {md}", args)
 def load_state(args):
    if STATE_FILE.exists():
        pos = int(STATE_FILE.read_text())
        debug(f"Loaded last log position: {pos}", args)
        return pos
    return 0
 def save_state(pos, args):
    STATE_FILE.write_text(str(pos))
    debug(f"Saved new log position: {pos}", args)
 def scan_log(since_pos, args):
    try:
        with open(APACHE_LOG, 'r') as f:
            f.seek(since_pos)
            lines = f.readlines()
            newpos = f.tell()
        debug(f"Read {len(lines)} new lines", args)
        return lines, newpos
    except Exception as e:
        print(f"Error reading log: {e}", file=sys.stderr)
        return [], since_pos
 def record_downloads(lines, metadata, args):
    now = time.time()
    for line in lines:
        m = TOKEN_REGEX.search(line)
        if m:
            tok = m.group(1)
            if tok not in metadata:
                metadata[tok] = now
                debug(f"Recorded download of token {tok} at {now}", args)
    return metadata
 def revoke_old(metadata, args):
    now = time.time()
    to_remove = [tok for tok, ts in metadata.items() if now - ts >= 3600]
    for tok in to_remove:
        link = SHARE_DIR / tok
        try:
            link.unlink()
            debug(f"Unlinked token {tok}", args)
        except FileNotFoundError:
            debug(f"Link {link} not found when revoking", args)
        metadata.pop(tok, None)
    return bool(to_remove)
 def main():
    p = argparse.ArgumentParser(description="Revoke share links 2min after download")
    p.add_argument('--debug', action='store_true', help='print debug info to stderr')
    args = p.parse_args()
    SHARE_DIR.mkdir(parents=True, exist_ok=True)
    metadata = load_metadata(args)
    state    = load_state(args)
    lines, newpos = scan_log(state, args)
    metadata      = record_downloads(lines, metadata, args)
    save_metadata(metadata, args)               # always persist new downloads
    if revoke_old(metadata, args):
        save_metadata(metadata, args)           # persist removals
    save_state(newpos, args)
 if __name__ == '__main__':
    main()
@@ -1,44 +0,0 @@
 #!/usr/bin/env python3
 import os
 import json
 import time
 from pathlib import Path
 # Configuration
 SCAN_PATH = '/mnt/shares'
 OUTPUT_FILE = '/var/log/share_scan.json'
 def scan_directory(root):
    """Recursively walk `root` and collect metadata."""
    entries = []
    for dirpath, dirs, files in os.walk(root):
        for name in dirs + files:
            full = os.path.join(dirpath, name)
            try:
                stat = os.stat(full)
                entries.append({
                    'path': full,
                    'is_dir': os.path.isdir(full),
                    'size_bytes': stat.st_size,
                    'mtime': time.strftime('%Y-%m-%dT%H:%M:%S%z',
                                           time.localtime(stat.st_mtime)),
                })
            except Exception as e:
                # skip items we can't stat
                continue
    return entries
 def main():
    data = {
        'scanned_at': time.strftime('%Y-%m-%dT%H:%M:%S%z', time.localtime()),
        'root': SCAN_PATH,
        'entries': scan_directory(SCAN_PATH),
    }
    # Write atomically
    temp = OUTPUT_FILE + '.tmp'
    with open(temp, 'w') as f:
        json.dump(data, f, indent=2)
    os.replace(temp, OUTPUT_FILE)
 if __name__ == '__main__':
    main()
@@ -1,6 +0,0 @@
 [Unit]
 Description=One‑shot scan of /mnt/shares → JSON
 [Service]
 Type=oneshot
 ExecStart=/usr/local/bin/scan_shares.py
@@ -1,11 +0,0 @@
 [Unit]
 Description=Hourly timer for share‑scanner
 [Timer]
 # delay 2min after boot, then every hour
 OnBootSec=20min
 OnUnitActiveSec=24h
 Unit=scan_shares.service
 [Install]
 WantedBy=timers.target
@@ -1,195 +0,0 @@
 {
  "string": [],
  "bool": [ [ "Skip track", false ], [ "Going Live!", false ] ],
  "int": [],
  "float": [
    [
    "mic_volume",
    0.0
  ],
    [
    "compress_gain6",
    0.1
  ],
    [
    "compress_ratio6",
    7.9
  ],
    [
    "compress_threshold6",
    -15.8
  ],
    [
    "compress_release6",
    30.0
  ],
    [
    "compress_attack6",
    30.0
  ],
    [
    "compress_frequency6",
    18610.0
  ],
    [
    "compress_gain5",
    5.4
  ],
    [
    "compress_ratio5",
    4.8
  ],
    [
    "compress_threshold5",
    -13.6
  ],
    [
    "compress_release5",
    120.0
  ],
    [
    "compress_attack5",
    160.0
  ],
    [
    "compress_frequency5",
    13950.0
  ],
    [
    "compress_gain4",
    6.5
  ],
    [
    "compress_ratio4",
    4.0
  ],
    [
    "compress_threshold4",
    -12.2
  ],
    [
    "compress_release4",
    130.0
  ],
    [
    "compress_attack4",
    200.0
  ],
    [
    "compress_frequency4",
    3890.0
  ],
    [
    "compress_gain3",
    5.5
  ],
    [
    "compress_ratio3",
    3.5
  ],
    [
    "compress_threshold3",
    -11.7
  ],
    [
    "compress_release3",
    140.0
  ],
    [
    "compress_attack3",
    250.0
  ],
    [
    "compress_frequency3",
    2270.0
  ],
    [
    "compress_gain2",
    3.3
  ],
    [
    "compress_ratio2",
    3.9
  ],
    [
    "compress_threshold2",
    -11.5
  ],
    [
    "compress_release2",
    120.0
  ],
    [
    "compress_attack2",
    250.0
  ],
    [
    "compress_frequency2",
    1920.0
  ],
    [
    "compress_gain1",
    5.6
  ],
    [
    "compress_ratio1",
    3.4
  ],
    [
    "compress_threshold1",
    -12.2
  ],
    [
    "compress_release1",
    120.0
  ],
    [
    "compress_attack1",
    220.0
  ],
    [
    "compress_frequency1",
    650.0
  ],
    [
    "compress_gain0",
    7.5
  ],
    [
    "compress_ratio0",
    3.2
  ],
    [
    "compress_threshold0",
    -13.1
  ],
    [
    "compress_release0",
    110.0
  ],
    [
    "compress_attack0",
    140.0
  ],
    [
    "compress_frequency0",
    110.0
  ],
    [
    "compress_wet",
    1.0
  ],
    [
    "main_volume",
    1.8
  ],
    [
    "g",
    1.0
  ],
    [
    "f",
    106.4
  ]
  ]
 }
@@ -1,93 +0,0 @@
 #!/usr/bin/env python3
 import argparse
 import json
 import os
 import sys
 import uuid
 from pathlib import Path
 # CONFIGURATION
 JSON_DB        = '/var/log/share_scan.json'
 SHARE_DIR      = Path('/var/www/html/share')
 BASE_URL       = 'https://czernobog.pl/share'
 # Ensure share directory exists
 SHARE_DIR.mkdir(parents=True, exist_ok=True)
 def load_db():
    with open(JSON_DB) as f:
        return json.load(f)['entries']
 def relevancy(path, keywords):
    score = 0
    low = path.lower()
    for kw in keywords:
        if kw.lower() in low:
            score += low.count(kw.lower())
    return score
 def find_matches(entries, keywords):
    scored = []
    for e in entries:
        score = relevancy(e['path'], keywords)
        if score > 0:
            scored.append((score, e['path']))
    scored.sort(reverse=True, key=lambda x: x[0])
    return [p for _, p in scored]
 def interactive_select(candidates):
    print("Search results:")
    for idx, p in enumerate(candidates, 1):
        print(f" {idx:3d}. {p}")
    sel = input("\nSelect files (e.g. 1,3-5): ").strip()
    nums = set()
    for part in sel.split(','):
        if '-' in part:
            a,b = part.split('-',1)
            nums.update(range(int(a), int(b)+1))
        else:
            nums.add(int(part))
    return [candidates[i-1] for i in sorted(nums) if 1 <= i <= len(candidates)]
 def publish(paths):
    urls = []
    for path in paths:
        token = uuid.uuid4().hex
        link = SHARE_DIR / token
        try:
            os.symlink(path, link)
        except FileExistsError:
            pass
        urls.append(f"{BASE_URL}/{token}")
    return urls
 def main():
    parser = argparse.ArgumentParser(description="Search and share files from JSON DB")
    parser.add_argument('keywords', nargs='*',
                        help='Search keywords (interactive if omitted)')
    parser.add_argument('-n','--count', type=int, default=10,
                        help='How many top results to share')
    args = parser.parse_args()
    if not args.keywords:
        # Interactive: ask for query
        q = input("Enter search keywords (space-separated): ").strip().split()
        args.keywords = q
    entries   = load_db()
    matches   = find_matches(entries, args.keywords)
    top_n     = matches[:args.count]
    if sys.stdin.isatty():
        # interactive selection
        sel = interactive_select(top_n)
    else:
        # non-interactive: share all top_n
        sel = top_n
    urls = publish(sel)
    for u in urls:
        print(u)
 if __name__=='__main__':
    main()
@@ -1,9 +0,0 @@
    <html>
        <head>
            <title>HTTP Live Streaming Example</title>
        </head>
        <body>
            <video src="/tmp/hls/stream.m3u8" height="300" width="400">
            </video>
        </body>
    </html>
@@ -1,23 +0,0 @@
 tmic = buffer(input.pulseaudio()) # Microphone
 if tmic.is_active() then
    log.info("Buffer active")
 end
 if tmic.is_ready() then
    log.info("Buffer ready")
 end
 if tmic.is_up() then
    log.info("Buffer up")
 end
 interactive.harbor(port = 9999)
 mic_gain = interactive.float("mic_volume", min=0., max=20., 6.)
 mic = amplify(mic_gain, tmic)
 #mic = gate(threshold=-80., range=-120., mic)
 #mic = compress(threshold=0., ratio=2.,mic)
 #mic = blank.strip(max_blank=10., min_noise=.1, threshold=-20., mic)
 output.pulseaudio(mic)
@@ -1,225 +0,0 @@
 """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 os
 from datetime import datetime
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, TypedDict
 try:
    import netrc
 except ImportError:  # pragma: no cover - standard on CPython
    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",
    {
        "ctx": Optional[str],
        "queue": List[str],
        "requester": List[str],
    },
 )
 # *=========================================== Predefines
 MASTER_TIMEOUT = datetime.now()
 INITIAL_TIME_WAIT = 500
 MUZYKA: Music_Config = {"ctx": None, "queue": [], "requester": []}
 logger = logging.getLogger("discord")
 def _env_path(var_name: str, fallback: Path) -> Path:
    value = os.getenv(var_name)
    if value:
        return Path(value).expanduser().resolve()
    return fallback
 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")
 RADIO_HARBOR_ADDRESS = _env("CONJURER_RADIO_HARBOR", "http://127.0.0.1:54321")
 SKIP_TRACK = _env("CONJURER_SKIP_ENDPOINT", "/skip")
 GET_MP3 = "/mp3"
 SEND_MP3 = "/update_mp3"
 GET_PLAYLIST = "/get_music"
 ADD_TO_PRIO_PLAYLIST = "/add_to_priority"
 CREATE_PRIO_PLAYLIST = "/create_priority_playlist"
 REQUEST_MUSIC = "/request_radio_file"
 CLEAR_PRIO = "/clear_pr_pls"
 LIBRARIAN_SERVICE_ADDRESS = _env(
    "CONJURER_LIBRARIAN_SERVICE", "http://127.0.0.1:5001"
 )
 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")
 PORT_ADDRESS = int(_env("CONJURER_DISCORD_PORT", "5000"))
 # *=========================================== Platform Specific Predefines
 SEPARATOR_FILE_PATH = _env("CONJURER_PATH_SEPARATOR", os.sep)
 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
 else:
    SPOTIFY_CTRL = None
 youtube_creds = _load_netrc_credentials("youtube")
 if youtube_creds:
    YOUTUBE_AUTH = [youtube_creds[0], youtube_creds[2]]
 else:
    YOUTUBE_AUTH = [
            os.getenv("YOUTUBE_USERNAME", ""),
            os.getenv("YOUTUBE_PASSWORD", ""),
        ]
 def service_headers() -> Dict[str, str]:
    """Shared header dict for internal HTTP calls."""
    if API_SHARED_KEY:
        return {"X-Conjurer-Api-Key": API_SHARED_KEY}
    return {}
 LATEX_TEX_ENGINE = "tectonic"
 LATEX_MAX_COMPILE_SECONDS = 45
 LATEX_MAX_ATTACH_MB = 8
 LATEX_MAX_ZIP_MB =  25
 OPENAI_MODEL = "gpt-4o-mini"
 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)
@@ -1,102 +1,9 @@
 #!/bin/bash
 total_commands=29
 current_command=0
 function print_progress {
  current_command=$((current_command + 1))
  percent=$((current_command * 100 / total_commands))
  echo "Executing command $current_command/$total_commands ($percent%): $1"
 }
 cd /home/pi/conjurer || exit
 print_progress "cd /home/pi/conjurer"
 git pull
-print_progress "git pull"
+cd ..
-
+cp ./conjurer/bot.py ./Conjurer/
 cp ./deploy.sh /home/pi/
 print_progress "cp ./deploy.sh /home/pi/"
 cd /home/pi || exit
 print_progress "cd /home/pi"
 cp ./conjurer/LICENSE ./Conjurer/LICENSE
 print_progress "cp ./conjurer/LICENSE ./Conjurer/LICENSE"
 cp ./conjurer/fuckery.jpg ./Conjurer/
 print_progress "cp ./conjurer/fuckery.jpg ./Conjurer/"
 cp ./conjurer/willowisp.png ./Conjurer/
 print_progress "cp ./conjurer/willowisp.png ./Conjurer/"
 cp ./conjurer/wod_beacon.jpg ./Conjurer/
 print_progress "cp ./conjurer/wod_beacon.jpg ./Conjurer/"
 cp ./conjurer/settings.json ./Conjurer/
-print_progress "cp ./conjurer/settings.json ./Conjurer/"
+cp ./conjurer/system_gpt_settings.json ./Conjurer/
-
+cp ./conjurer/install.sh ./Conjurer/
-if [[ ./conjurer/system_gpt_settings.json -nt ./Conjurer/system_gpt_settings.json ]]; then
+cp ./conjurer/requirements.txt ./Conjurer/requirements.txt
  cp ./conjurer/system_gpt_settings.json ./Conjurer/system_gpt_settings.json
  print_progress "cp ./conjurer/system_gpt_settings.json ./Conjurer/system_gpt_settings.json"
 else
  print_progress "system_gpt_settings.json is up to date"
 fi
 cp ./conjurer/administration_commands.py ./Conjurer/
 print_progress "cp ./conjurer/administration_commands.py ./Conjurer/"
 cp ./conjurer/ai_commands.py ./Conjurer/
 print_progress "cp ./conjurer/ai_commands.py ./Conjurer/"
 cp ./conjurer/ai_functions.py ./Conjurer/
 print_progress "cp ./conjurer/ai_functions.py ./Conjurer/"
 cp ./conjurer/communication_subroutine.py ./Conjurer/
 print_progress "cp ./conjurer/communication_subroutine.py ./Conjurer/"
 cp ./conjurer/constants.py ./Conjurer/
 print_progress "cp ./conjurer/constants.py ./Conjurer/"
 cp ./conjurer/librarian_commands.py ./Conjurer/
 print_progress "cp ./conjurer/librarian_commands.py ./Conjurer/"
 cp ./conjurer/music_commands.py ./Conjurer/
 print_progress "cp ./conjurer/music_commands.py ./Conjurer/"
 cp ./conjurer/music_functions.py ./Conjurer/
 print_progress "cp ./conjurer/music_functions.py ./Conjurer/"
 cp ./conjurer/other_commands.py ./Conjurer/
 print_progress "cp ./conjurer/other_commands.py ./Conjurer/"
 cp ./conjurer/other_functions.py ./Conjurer/
 print_progress "cp ./conjurer/other_functions.py ./Conjurer/"
 cp ./conjurer/radio_commands.py ./Conjurer/
 print_progress "cp ./conjurer/radio_commands.py ./Conjurer/"
 cp ./conjurer/voice_recognition_commands.py ./Conjurer/
 print_progress "cp ./conjurer/voice_recognition_commands.py ./Conjurer/"
 cp ./conjurer/file_search_functions.py ./Conjurer/
 print_progress "cp ./conjurer/file_search_functions.py ./Conjurer/"
 cp ./conjurer/file_search_commands.py ./Conjurer
 print_progress "cp ./conjurer/file_search_functions.py ./Conjurer/"
 cp ./conjurer/latex_commands.py ./Conjurer/
 print_progress "cp ./conjurer/latex_commands.py ./Conjurer/"
 cp ./conjurer/latex_functions.py ./Conjurer/
 print_progress "cp ./conjurer/latex_functions.py ./Conjurer/"
 cp ./conjurer/librarian_functions.py ./Conjurer
 print_progress "cp ./conjurer/librarian_functions.py ./Conjurer/"
 cp ./conjurer/thin_client.py ./Conjurer/bot.py
 print_progress "cp ./conjurer/thin_client.py ./Conjurer/bot.py"
 sudo systemctl restart conjurer.service
 print_progress "sudo systemctl restart conjurer.service"
@@ -1,7 +1,6 @@
 #!/bin/bash
-cd ./conjurer || exit
+cd ./conjurer
 git pull
 cd ..
 cp ./conjurer/conjurer_musician/media_search_functions.py ./Conjurer
 cp ./conjurer/conjurer_musician/conjurer_musician.py ./Conjurer
 sudo systemctl restart conjurer_musician.service
@@ -1,141 +0,0 @@
 #!/usr/bin/env bash
 # System-wide install & verify (Debian/RPi):
 #  - EB Garamond (APT)
 #  - Cinzel Decorative Black (RAW TTF)
 #  - IM Fell English SC (gstatic/RAW)
 # No TeX build here. Very verbose + clear final report.
 set -Eeuo pipefail
 SUDO=sudo; [ "$(id -u)" -eq 0 ] && SUDO=
 log(){ echo -e "[+] $*"; }
 warn(){ echo -e "[WARN] $*" >&2; }
 die(){ echo -e "[FATAL] $*" >&2; exit 1; }
 need(){ command -v "$1" >/dev/null 2>&1 || die "Missing tool: $1"; }
 fetch(){
  local url="$1" out="$2"
  if command -v wget >/dev/null 2>&1; then
    log "wget -> $url"
    wget -O "$out" --https-only --no-verbose "$url"
  else
    log "curl -> $url"
    curl -L --fail --show-error --output "$out" "$url"
  fi
 }
 # ---- detection using fc-list families (robust, no PCRE) ----
 fc_families_lower() {
  fc-list -f '%{family}\n' \
  | tr ',' '\n' \
  | sed 's/^[[:space:]]*//; s/[[:space:]]*$//' \
  | tr '[:upper:]' '[:lower:]' \
  | sort -u
 }
 has_family_re() {  # $1 = POSIX ERE anchored-at-start pattern (lowercase)
  fc_families_lower | grep -Eiq "$1"
 }
 # ---- prereqs ----
 for t in fc-cache fc-list grep sed awk; do need "$t"; done
 command- v wget >/dev/null 2>&1 || command -v curl >/dev/null 2>&1 || die "Need wget or curl"
 SYSTEM_DIR="/usr/local/share/fonts/dj"
 DIR_CINZEL="$SYSTEM_DIR/cinzel-decorative"
 DIR_IMFELL="$SYSTEM_DIR/im-fell-english-sc"
 $SUDO mkdir -p "$DIR_CINZEL" "$DIR_IMFELL"
 echo "=== APT phase (EB Garamond) ==="
 if command -v apt-get >/dev/null 2>&1; then
  $SUDO apt-get update -y || warn "apt update failed (continuing)"
  if $SUDO apt-get install -y --no-install-recommends fonts-ebgaramond; then
    log "installed: fonts-ebgaramond"
  else
    warn "apt install failed: fonts-ebgaramond"
  fi
 else
  warn "apt-get not found — skipping"
 fi
 echo
 log "Families BEFORE web fallback (sample grep):"
 fc-list | grep -Ei "Garamond|Cinzel|Fell" || echo "  (none)"
 echo
 echo "=== Web fallback (system-wide to $SYSTEM_DIR) ==="
 # --- Cinzel Decorative Black ---
 CINZEL_TTF="$DIR_CINZEL/CinzelDecorative-Black.ttf"
 if ! has_family_re '^cinzel decorative( |$)'; then
  fetch "https://github.com/google/fonts/raw/main/ofl/cinzeldecorative/CinzelDecorative-Black.ttf" "$CINZEL_TTF" || warn "Cinzel Decorative Black download failed"
  [ -s "$CINZEL_TTF" ] && $SUDO chmod 0644 "$CINZEL_TTF"
 else
  log "Cinzel Decorative already present."
 fi
 # --- IM Fell English SC ---
 IMFELL_TTF="$DIR_IMFELL/IMFeENsc.ttf"
 if ! has_family_re '^im fell english sc( |$)'; then
  # Try known gstatic TTFs (stable direct links)
  for u in \
    "https://fonts.gstatic.com/s/imfellenglishsc/v7/h3Tn6yWfw4b5qaLD1RWvz5ATixNthKRRR1XVH3rJNiw.ttf" \
    "https://fonts.gstatic.com/s/imfellenglishsc/v6/h3Tn6yWfw4b5qaLD1RWvz5ATixNthKRRR1XVH3rJNiw.ttf"
  do
    if fetch "$u" "$IMFELL_TTF"; then
      [ -s "$IMFELL_TTF" ] && { $SUDO chmod 0644 "$IMFELL_TTF"; log "IM Fell SC from gstatic OK"; break; }
    fi
  done
  # Secondary RAW in google/fonts (names changed over time)
  if [ ! -s "$IMFELL_TTF" ]; then
    for u in \
      "https://github.com/google/fonts/raw/main/ofl/imfellenglishsc/IMFeENsc28P.ttf" \
      "https://github.com/google/fonts/raw/main/ofl/imfellenglishsc/IMFellEnglishSC-Regular.ttf"
    do
      if fetch "$u" "$IMFELL_TTF"; then
        [ -s "$IMFELL_TTF" ] && { $SUDO chmod 0644 "$IMFELL_TTF"; log "IM Fell SC from google/fonts RAW OK"; break; }
      fi
    done
  fi
  # Minimal mirror fallback (only if naprawdę trzeba)
  if [ ! -s "$IMFELL_TTF" ]; then
    for u in \
      "https://www.wfonts.com/download/data/2016/06/14/im-fell-english-sc/IMFeENsc28P.ttf" \
      "https://www.1001freefonts.com/d/6800/IMFeENsc28P.ttf"
    do
      fetch "$u" "$IMFELL_TTF" || true
      [ -s "$IMFELL_TTF" ] && { $SUDO chmod 0644 "$IMFELL_TTF"; log "IM Fell SC from mirror OK"; break; }
    done
  fi
  [ -s "$IMFELL_TTF" ] || warn "IM Fell English SC still missing."
 else
  log "IM Fell English SC already present."
 fi
 echo
 log "Fix perms & rebuild cache..."
 $SUDO find "$SYSTEM_DIR" -type f -size 0 -print -delete || true
 $SUDO find "$SYSTEM_DIR" -type f \( -name "*.ttf" -o -name "*.otf" \) -exec chmod 0644 {} \; || true
 $SUDO find "$SYSTEM_DIR" -type d -exec chmod 0755 {} \; || true
 $SUDO fc-cache -f -v >/dev/null || warn "fc-cache returned non-zero"
 # ---- FINAL REPORT ----
 echo
 log "FINAL STATUS (fc-list families & file presence)"
 families="$(fc_families_lower)"
 report(){
  local label="$1" fam_re="$2" file_hint="$3"
  local fam_ok file_ok="n/a"
  if echo "$families" | grep -Eiq "$fam_re"; then fam_ok="OK"; else fam_ok="MISSING"; fi
  if [ -n "$file_hint" ]; then
    if [ -s "$file_hint" ]; then file_ok="yes"; else file_ok="no"; fi
  fi
  printf "  %-22s : families=%-8s file=%-3s  (%s)\n" "$label" "$fam_ok" "$file_ok" "${file_hint:-no-file-hint}"
 }
 report "EB Garamond"           '^eb garamond( |$)'           ""                 # from APT
 report "Cinzel Decorative"     '^cinzel decorative( |$)'      "$CINZEL_TTF"
 report "IM Fell English SC"    '^im fell english sc( |$)'     "$IMFELL_TTF"
 echo
 log "Done. (Run your LaTeX pipeline next.)"
@@ -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).
@@ -1,3 +0,0 @@
 Package: ffmpeg libavcodec-dev libavcodec59 libavdevice59 libavfilter8 libavformat-dev libavformat59 libavutil-dev libavutil57 libpostproc56 libswresample-dev libswresample4 libswscale-dev libswscale6 libavdevice-dev libavfilter-dev libpostproc-dev
 Pin: origin deb.debian.org
 Pin-Priority: 1001
@@ -1,71 +0,0 @@
 import os
 import discord
 from discord.ext import commands
 import file_search_functions
 class FileSelectView(discord.ui.View):
    def __init__(self, files):
        super().__init__(timeout=60)
        options = [discord.SelectOption(label=os.path.basename(f)[:100], description=f, value=f) for f in files]
        self.select = discord.ui.Select(
            placeholder="Select files...",
            min_values=1,
            max_values=len(options),
            options=options
        )
        self.select.callback = self.select_callback
        self.add_item(self.select)
        self.selected = []
    async def select_callback(self, interaction: discord.Interaction):
        # Store selected file paths
        self.selected = self.select.values
        await interaction.response.defer()
    @discord.ui.button(label="Accept", style=discord.ButtonStyle.green)
    async def accept_callback(self, interaction: discord.Interaction, button: discord.ui.Button):
        # Handle acceptance
        if not self.selected:
            await interaction.response.send_message("No files selected.", ephemeral=True)
            return
        # Publish selected files
        links = file_search_functions.publish(self.selected)
        # Display the returned links
        await interaction.response.edit_message(content="Published Links:\n" + "\n".join(links), view=None)
    @discord.ui.button(label="Cancel", style=discord.ButtonStyle.red)
    async def cancel_callback(self, interaction: discord.Interaction, button: discord.ui.Button):
        # Handle cancellation
        await interaction.response.edit_message(content="Operation cancelled.", view=None)
 class FileSearchCog(commands.Cog):
    """Cog providing a file search and publish command."""
    def __init__(self, bot: commands.Bot):
        self.bot = bot
    @commands.has_any_role("Jarl", "Thane")
    @commands.command(name="tajna_biblioteka_inkwizycji")
    async def findfiles(self, ctx: commands.Context, entries: int, *, keywords: str):
        """
        Search for files matching keywords and publish selected ones.
        Usage: !findfiles <entries 1-10> <keywords>
        """
        if entries < 1 or entries > 10:
            await ctx.send("❌ Entries must be between 1 and 10.")
            return
        keyword_list = keywords.split()
        files = file_search_functions.find_matches(entries, keyword_list)
        if not files:
            await ctx.send("🔍 No matching files found.")
            return
        view = FileSelectView(files)
        file_list = "\n".join(f"{i+1}. {f}" for i, f in enumerate(files))
        await ctx.send(
            f"🔍 Found files (select and click Accept or Cancel):\n{file_list}",
            view=view
        )
 async def setup(bot: commands.Bot):
    await bot.add_cog(FileSearchCog(bot))
@@ -1,31 +0,0 @@
 import requests
 # Base URL for Flask service
 BASE_URL = 'http://192.168.1.15:5000'
 def find_matches(entries, keywords):
    """
    Call the get_share_list endpoint.
    entries: int (1-10)
    keywords: list of strings
    Returns: list of file paths
    """
    payload = {'entries': entries, 'keywords': keywords}
    response = requests.post(f"{BASE_URL}/get_share_list", json=payload)
    response.raise_for_status()
    data = response.json()
    return data.get('files', [])
 def publish(file_paths):
    """
    Call the get_share_links endpoint.
    file_paths: list of file path strings
    Returns: list of published URLs
    """
    payload = {'file_paths': file_paths}
    response = requests.post(f"{BASE_URL}/get_share_links", json=payload)
    response.raise_for_status()
    data = response.json()
    return data.get('links', [])
@@ -1,98 +0,0 @@
 #!/usr/bin/env bash
 # "apt dla fontów": Google Fonts ZIP → GitHub (ofl RAW) → fonts.gstatic.com → mirrory.
 # System-wide install do /usr/local/share/fonts/fontget/<rodzina> + fc-cache.
 # Usage: sudo ./fontget.sh "IM Fell English SC" "Cinzel Decorative" "EB Garamond"
 set -Eeuo pipefail
 SUDO=sudo; [ "$(id -u)" -eq 0 ] && SUDO=
 log(){ echo -e "[+] $*"; }
 warn(){ echo -e "[WARN] $*" >&2; }
 die(){ echo -e "[FATAL] $*" >&2; exit 1; }
 need(){ command -v "$1" >/dev/null 2>&1 || die "Missing: $1"; }
 need fc-cache
 command -v wget >/dev/null 2>&1 || command -v curl >/dev/null 2>&1 || die "Need wget/curl"
 command -v unzip >/dev/null 2>&1 || warn "unzip missing — ZIP installs limited"
 command -v file  >/dev/null 2>&1 || warn "file missing — MIME checks limited"
 command -v fc-list >/dev/null 2>&1 || die "Missing: fc-list"
 fetch(){ local u="$1" o="$2"; if command -v wget >/dev/null 2>&1; then wget -O "$o" --https-only --no-verbose "$u"; else curl -L --fail --show-error --output "$o" "$u"; fi; }
 slug(){ echo "$1" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9]+/-/g; s/^-+|-+$//g'; }
 present(){ fc-list -f '%{family}\n' | tr ',' '\n' | sed 's/^[[:space:]]*//; s/[[:space:]]*$//' | tr '[:upper:]' '[:lower:]' | sort -u | grep -Eiq "$1"; }
 install_dir="/usr/local/share/fonts/fontget"; $SUDO mkdir -p "$install_dir"
 is_zip(){ command -v file >/dev/null 2>&1 && file "$1" | grep -qi zip; }
 gf_zip_try(){
  local name="$1" outdir="$2" enc zip
  enc="$(python3 - <<PY
 import urllib.parse,sys
 print(urllib.parse.quote(sys.argv[1]))
 PY
 "$name")" || enc="$(echo "$name" | sed 's/ /%20/g')"
  zip="$(mktemp /tmp/fontget.XXXXXX.zip)"
  if fetch "https://fonts.google.com/download?family=${enc}" "$zip"; then
    if is_zip "$zip"; then $SUDO mkdir -p "$outdir"; $SUDO unzip -o -q "$zip" -d "$outdir" || true; rm -f "$zip"; return 0; fi
  fi
  rm -f "$zip" || true; return 1
 }
 gh_ofl_try(){
  local family="$1" outdir="$2" html
  html="$(mktemp /tmp/ofl.$(slug "$family").html)"
  if fetch "https://github.com/google/fonts/tree/main/ofl/$(slug "$family")" "$html"; then
    mapfile -t paths < <(grep -Eo '/google/fonts/blob/main/ofl/'"$(slug "$family")"'/[^"]+\.(ttf|otf)' "$html" | sed 's|/blob/|/raw/|g' | sort -u)
    [ "${#paths[@]}" -gt 0 ] || { rm -f "$html"; return 1; }
    $SUDO mkdir -p "$outdir"
    for p in "${paths[@]}"; do fetch "https://github.com$p" "$outdir/$(basename "$p")" || true; done
    rm -f "$html"; return 0
  fi
  rm -f "$html"; return 1
 }
 gstatic_try(){ local out="$2"; shift 2; for u in "$@"; do fetch "$u" "$out" && [ -s "$out" ] && return 0; done; return 1; }
 report(){ local label="$1" re="$2"; if present "$re"; then printf "RESULT: %-24s : OK\n" "$label"; else printf "RESULT: %-24s : FAIL\n" "$label"; fi }
 if [ $# -lt 1 ]; then echo "Usage: $0 <Font Family> [Another ...]"; exit 1; fi
 for family in "$@"; do
  echo; log "=== $family ==="
  fam_slug="$(slug "$family")"
  outdir="$install_dir/$fam_slug"
  $SUDO mkdir -p "$outdir"
  case "$fam_slug" in
    cinzel-decorative|cinzel|cinzel-decorative-black)
      fetch "https://github.com/google/fonts/raw/main/ofl/cinzeldecorative/CinzelDecorative-Black.ttf" "$outdir/CinzelDecorative-Black.ttf" || warn "Cinzel fetch failed"
      ;;
    im-fell-english-sc)
      gstatic_try "$fam_slug" "$outdir/IMFeENsc.ttf" \
        "https://fonts.gstatic.com/s/imfellenglishsc/v7/h3Tn6yWfw4b5qaLD1RWvz5ATixNthKRRR1XVH3rJNiw.ttf" \
        "https://fonts.gstatic.com/s/imfellenglishsc/v6/h3Tn6yWfw4b5qaLD1RWvz5ATixNthKRRR1XVH3rJNiw.ttf" \
      || { fetch "https://github.com/google/fonts/raw/main/ofl/imfellenglishsc/IMFeENsc28P.ttf" "$outdir/IMFeENsc.ttf" || true
           [ -s "$outdir/IMFeENsc.ttf" ] || fetch "https://github.com/google/fonts/raw/main/ofl/imfellenglishsc/IMFellEnglishSC-Regular.ttf" "$outdir/IMFeENsc.ttf" || true
           [ -s "$outdir/IMFeENsc.ttf" ] || fetch "https://www.wfonts.com/download/data/2016/06/14/im-fell-english-sc/IMFeENsc28P.ttf" "$outdir/IMFeENsc.ttf" || true
           [ -s "$outdir/IMFeENsc.ttf" ] || fetch "https://www.1001freefonts.com/d/6800/IMFeENsc28P.ttf" "$outdir/IMFeENsc.ttf" || true; }
      ;;
    eb-garamond|ebgaramond)
      # Najpierw apt (jeśli chcesz: sudo apt install fonts-ebgaramond), tu tylko web:
      gf_zip_try "$family" "$outdir" || gh_ofl_try "$family" "$outdir" || true
      ;;
    *)
      gf_zip_try "$family" "$outdir" || gh_ofl_try "$family" "$outdir" || true
      ;;
  esac
  $SUDO find "$outdir" -type f -size 0 -print -delete || true
  $SUDO find "$outdir" -type f \( -name "*.ttf" -o -name "*.otf" \) -exec chmod 0644 {} \; || true
  $SUDO find "$outdir" -type d -exec chmod 0755 {} \; || true
  $SUDO fc-cache -f -v >/dev/null || true
  case "$fam_slug" in
    cinzel* )            report "Cinzel Decorative"   '^cinzel decorative( |$)' ;;
    im-fell-english-sc ) report "IM Fell English SC"  '^im fell english sc( |$)' ;;
    eb-garamond* )       report "EB Garamond"         '^eb garamond( |$)' ;;
    * )                  report "$family"             "$(echo "$family" | tr '[:upper:]' '[:lower:]' | sed 's/ /.* /g')" ;;
  esac
 done
 echo; log "All done."
@@ -1,14 +0,0 @@
 from flask import Flask
 from file_serv import bp as uploader_bp
 from ingest import bp as ingest_bp
 from waitress import serve
 app = Flask(__name__)
 HOST_ADDRESS = "127.0.0.1"
 PORT_ADDRESS = 49151
 if __name__ == "__main__":
    app.register_blueprint(uploader_bp, url_prefix="/api")
    app.register_blueprint(ingest_bp, url_prefix="/api")
    serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS)
@@ -1,155 +0,0 @@
 # -*- coding: utf-8 -*-
 from __future__ import annotations
 import os
 from pathlib import Path
 from typing import List, Dict, Any, Optional
 from flask import Blueprint, request, jsonify, send_file, abort, current_app
 from werkzeug.utils import secure_filename
 # ===== Konfiguracja przez ENV =====
 if API_KEY := os.getenv("API_KEY") is None:
    with open("/home/pi/gpt_cont_api_key", "r") as f:
        API_KEY = f.read().strip()
 else:
    API_KEY = os.getenv("API_KEY", "")                     # np. openssl rand -hex 32
 UPLOAD_DIR = Path(os.getenv("UPLOAD_DIR", "/home/pi/tmp_git/"))  # katalog na dysku
 MAX_CONTENT_MB = int(os.getenv("MAX_CONTENT_MB", "200"))
 # Google Drive (opcjonalnie)
 GDRIVE_ENABLE = os.getenv("GDRIVE_ENABLE", "0") == "1"
 GDRIVE_SA_JSON = os.getenv("GDRIVE_SA_JSON", "")       # ścieżka do pliku .json konta serwisowego
 GDRIVE_FOLDER_ID = os.getenv("GDRIVE_FOLDER_ID", "")   # ID folderu na Drive
 bp = Blueprint("uploader", __name__)
 # Inicjalizacja katalogu
 UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
 def _check_auth() -> bool:
    """Proste Bearer auth. Jeśli API_KEY puste -> bez auth (niezalecane)."""
    if not API_KEY:
        return True
    auth = request.headers.get("Authorization", "")
    if auth.startswith("Bearer "):
        token = auth[7:].strip()
        return token == API_KEY
    return False
 def _safe_join(base: Path, *parts: str) -> Path:
    """Zapobiega ../ — wymusza pozostanie w katalogu bazowym."""
    p = (base.joinpath(*parts)).resolve()
    if not str(p).startswith(str(base.resolve())):
        abort(400, description="Invalid path")
    return p
 # ===== Google Drive helper =====
 _drive_client_cached = None
 def _get_drive():
    global _drive_client_cached
    if _drive_client_cached is not None:
        return _drive_client_cached
    if not (GDRIVE_ENABLE and GDRIVE_SA_JSON and os.path.exists(GDRIVE_SA_JSON)):
        return None
    from google.oauth2 import service_account
    from googleapiclient.discovery import build
    scopes = ["https://www.googleapis.com/auth/drive.file"]
    creds = service_account.Credentials.from_service_account_file(GDRIVE_SA_JSON, scopes=scopes)
    _drive_client_cached = build("drive", "v3", credentials=creds, cache_discovery=False)
    return _drive_client_cached
 def upload_to_drive(local_path: Path, filename: str) -> Optional[Dict[str, Any]]:
    drv = _get_drive()
    if drv is None:
        return None
    from googleapiclient.http import MediaFileUpload
    file_metadata = {"name": filename}
    if GDRIVE_FOLDER_ID:
        file_metadata["parents"] = [GDRIVE_FOLDER_ID]
    media = MediaFileUpload(str(local_path), resumable=False)
    created = drv.files().create(body=file_metadata, media_body=media, fields="id,webViewLink,webContentLink").execute()
    file_id = created.get("id")
    # Przydatne linki:
    return {
        "file_id": file_id,
        "webViewLink": created.get("webViewLink"),
        "webContentLink": created.get("webContentLink"),
        "direct_view": f"https://drive.google.com/file/d/{file_id}/view",
        "direct_download": f"https://drive.google.com/uc?export=download&id={file_id}",
    }
@bp.get("/health")
 def health():
    return jsonify(ok=True, info="Okidokie")
@bp.post("/upload")
 def upload():
    """Przyjmuje:
       - multipart/form-data z jednym plikiem ('file') lub wieloma ('files')
       - opcjonalnie: form 'subdir' (podkatalog), 'drive' (1/0) żeby wymusić wysyłkę na Drive
    """
    if not _check_auth():
        return jsonify(error="Unauthorized"), 401
    # Limit ciała żądania po stronie Flaska:
    request.max_content_length = MAX_CONTENT_MB * 1024 * 1024
    files = []
    if "file" in request.files:
        files = [request.files["file"]]
    elif "files" in request.files:
        files = request.files.getlist("files")
    else:
        return jsonify(error="No file provided (use 'file' or 'files')"), 400
    subdir = (request.form.get("subdir") or "").strip()
    target_dir = _safe_join(UPLOAD_DIR, subdir) if subdir else UPLOAD_DIR
    target_dir.mkdir(parents=True, exist_ok=True)
    want_drive = (request.form.get("drive") == "1") or (request.args.get("drive") == "1")
    saved: List[Dict[str, Any]] = []
    for f in files:
        if not f or not f.filename:
            continue
        fname = secure_filename(f.filename)
        dest = _safe_join(target_dir, fname)
        f.save(dest)
        item = {
            "filename": fname,
            "size": dest.stat().st_size,
            "path": str(dest.relative_to(UPLOAD_DIR)),
            "url_hint": f"/api/files/{dest.relative_to(UPLOAD_DIR)}",
        }
        if want_drive and GDRIVE_ENABLE:
            try:
                gd = upload_to_drive(dest, fname)
                if gd:
                    item["gdrive"] = gd
            except Exception as e:
                # log i idziemy dalej
                current_app.logger.exception("Drive upload failed: %s", e)
                item["gdrive_error"] = str(e)
        saved.append(item)
    if not saved:
        return jsonify(error="No valid files"), 400
    return jsonify(ok=True, saved=saved)
@bp.get("/files/<path:relpath>")
 def get_file(relpath: str):
    if not _check_auth():
        return jsonify(error="Unauthorized"), 401
    target = _safe_join(UPLOAD_DIR, relpath)
    if not target.exists() or not target.is_file():
        return jsonify(error="Not found"), 404
    return send_file(target, as_attachment=False)
@@ -1,52 +0,0 @@
 # ingest_text.py
 import os
 import urllib.parse
 from pathlib import Path
 from flask import Blueprint, abort, jsonify, request
 bp = Blueprint("ingest_text", __name__)
 BASE = Path(os.getenv("INGEST_DIR", "/home/pi/tmp_git")).resolve()
 BASE.mkdir(parents=True, exist_ok=True)
 TOKEN = None
 with open("/home/pi/gpt_cont_api_key", "r") as f:
        TOKEN = f.read().strip()
 # prosty bufor kawałków w RAM (na 1 proces)
 chunks = {}
@bp.get("/api/ingest-text")
 def ingest_text():
    if request.args.get("key") != TOKEN:
        return jsonify(error="unauthorized"), 401
    name = request.args.get("name", "").strip()
    index = int(request.args.get("index", "1"))
    total = int(request.args.get("total", "1"))
    chunk = request.args.get("chunk", "")
    if not name or "/" in name or ".." in name:
        return jsonify(error="bad name"), 400
    if not (1 <= index <= total <= 9999):
        return jsonify(error="bad indexing"), 400
    # gromadzimy w pamięci (możesz podmienić na Redis)
    key = f"{name}:{total}"
    entry = chunks.setdefault(key, {})
    entry[index] = urllib.parse.unquote_plus(chunk)
    if TOKEN is None:
         exit("No API token set!")
    if len(entry) == total:
        # składamy i zapisujemy
        data = "".join(entry[i] for i in range(1, total + 1))
        out = (BASE / name).resolve()
        if not str(out).startswith(str(BASE)):
            return jsonify(error="bad path"), 400
        out.write_text(data, encoding="utf-8")
        del chunks[key]
        return jsonify(ok=True, saved=str(out), bytes=len(data.encode("utf-8")))
    else:
        return jsonify(pending=True, got=len(entry), total=total)
@@ -1,2 +0,0 @@
 #!/bin/bash
 cd ../conjurer/ && git pull && cp ./gpt_interface/* ../gpt_interf_serv/ && cd -
@@ -1,23 +1,14 @@
 #!/bin/bash
-sudo apt-get install python3-dev
+cd /home/pi
 sudo apt-get install portaudio19-dev python3-pyaudio
 sudo apt-get install
 cd /home/pi || exit
 mdkir Conjurer
-cd Conjurer ||exit
+cd Conjurer
-python3 -m venv /home/pi/Conjurer/.env
+python3 -m venv /home/pi/Conjurer/env
 cp /home/pi/conjurer/requirements_bot.txt /home/pi/Conjurer/
-# trunk-ignore(shellcheck/SC1091)
+source ./env/bin/activate
-source /home/pi/Conjurer/.env/bin/activate
+./env/bin/python3 -m pip install --upgrade pip
-./.env/bin/python3 -m pip install --upgrade pip
+./env/bin/python3 -m pip install -r requirements_bot.txt
-./.env/bin/python3 -m pip install -r requirements_bot.txt
+sed -i -e 's/os.rename/shutil.copy/g' ./env/lib/python3.11/site-packages/spotify_dl/youtube.py
-sed -i -e 's/os.rename/shutil.copy/g' ./.env/lib/python3.11/site-packages/spotify_dl/youtube.py
+sed -i '1i\import shutil' ./env/lib/python3.11/site-packages/spotify_dl/youtube.py
 sed -i '1i\import shutil' ./.env/lib/python3.11/site-packages/spotify_dl/youtube.py
 sed -i '1i\import logging' ./.env/lib/python3.11/site-packages/spotify_dl/spotify.py
 sed -i '21i\         logger = logging.getLogger("discord")' ./.env/lib/python3.11/site-packages/spotify_dl/spotify.py
 sed -i '22i\         logger.info("Playlist")' ./.env/lib/python3.11/site-packages/spotify_dl/spotify.py
 #add sed changing signal registration to catch exception in spotify dl init
 deactivate
 sudo cp ./conjurer.service /etc/systemd/system/
 sudo systemctl daemon-reload
@@ -8,30 +8,9 @@ cp /home/pi/conjurer/conjurer_musician/requirements_musician.txt /home/pi/Conjur
 cp /home/pi/conjurer/conjurer_musician/conjurer_musician.py /home/pi/Conjurer/
 cp /home/pi/conjurer/conjurer_musician/radio_conjurer.liq /home/pi/Conjurer/
 touch /home/pi/Conjurer/discord_mus_service.log
-
+touch /home/pi/Conjurer/all_playlist.txt
 touch /home/pi/Conjurer/playlist.json
 touch /home/pi/Conjurer/prio_playlist.json
 touch /home/pi/Conjurer/all_playlist.playlist
 touch /home/pi/Conjurer/priority_queue.playlist
 touch /home/pi/Conjurer/hit.playlist
 touch /home/pi/Conjurer/request.playlist
 touch /home/pi/Conjurer/persistence.log
 echo "[]" > /home/pi/Conjurer/persistence.log
 sudo usermod -aG pulse-access pi
 sudo usermod -aG pulse-access root
 sudo usermod -aG audio pi
 sudo usermod -aG audio root
 echo "Add exception suppresion to signal handler in spotify __ini__.py"
 echo "Add password to youtube opts in spotify_dl youtube.py"
 echo "Downgrade ffmpeg by copying ffmpeg.pref from repository to /etc/apt/preferences.d"
 echo "Install opam from installation link"
 echo "Initialize opam"
 echo "Install liquidsoap and its dependencies"
 touch /home/pi/Conjurer/radio_log.log
 ./env/bin/python3 -m pip install --upgrade pip
 ./env/bin/python3 -m pip install -r requirements_musician.txt
@@ -45,7 +24,3 @@ sudo cp /home/pi/conjurer/conjurer_musician/radio_service.service /etc/systemd/s
 sudo systemctl daemon-reload
 sudo systemctl start radio_service.service
 sudo systemctl enable radio_service.service
 sed -i -e 's/os.rename/shutil.copy/g' ./env/lib/python3.11/site-packages/spotify_dl/youtube.py
 sed -i '1i\import shutil' ./env/lib/python3.11/site-packages/spotify_dl/youtube.py
@@ -1,280 +0,0 @@
 # latex_commands.py
 # -*- coding: utf-8 -*-
 from __future__ import annotations
 import io
 import logging
 from typing import Optional
 import discord
 from discord import app_commands
 from discord.ext import commands
 from constants import (
    ALLOWED_ROLES,
    GUILD_ID,
    LATEX_MAX_ATTACH_MB,
    LATEX_MAX_COMPILE_SECONDS,
    LATEX_MAX_ZIP_MB,
    LATEX_TEX_ENGINE,
    OPENAI_MODEL,
 )
 from latex_functions import (
    compile_single_tex_bytes,
    compile_zip_to_zip,
    is_safe_asset_name,
    is_safe_tex_name,
 )
 async def _collect_attachments_bytes(attachments, max_mb: int):
    """
    Zwraca słownik {filename: bytes} dla wszystkich załączników, do limitu MB.
    Nie podbija wyjątków z .read() — zostawiamy to wyżej; tu zwracamy, co się udało.
    """
    out = {}
    for a in attachments or []:
        # limit rozmiaru
        if (getattr(a, "size", 0) or 0) > max_mb * 1024 * 1024:
            continue
        data = await a.read()
        out[a.filename] = data
    return out
 class LatexModule(commands.Cog):
    def __init__(self, bot: commands.Bot, logger_name: str):
        self.bot = bot
        self.logger = logging.getLogger(logger_name)
        self.logger_name = logger_name
    # -------- /tex (PDF + diagnoza; log -> debug logger) --------
    @commands.hybrid_command(
        nsfw=False,
        name="tex",
        description="Kompiluje załączone .tex; PDF-y odsyła. Błędy: diagnoza z OpenAI.",
        guild=None if GUILD_ID is None else discord.Object(id=GUILD_ID),
    )
    @commands.has_any_role(*ALLOWED_ROLES)
    async def tex(
        self, ctx: commands.Context, include_source_excerpt: Optional[bool] = True
    ):
        self.logger.info("LaTeX command invoked by %s", ctx.author)
        ch = ctx.message.channel
        # ZBIERZ WSZYSTKIE ZAŁĄCZNIKI
        async with ch.typing():
            all_bytes = await _collect_attachments_bytes(
                ctx.message.attachments, LATEX_MAX_ATTACH_MB
            )
            if not all_bytes:
                return await ctx.reply(
                    f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False
                )
            # PODZIEL NA GŁÓWNE .TEX i WSPIERAJĄCE
            tex_names = [
                n
                for n in all_bytes.keys()
                if n.lower().endswith(".tex") and is_safe_tex_name(n)
            ]
            if not tex_names:
                return await ctx.reply(
                    f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False
                )
            support_names = [
                n
                for n in all_bytes.keys()
                if n not in tex_names and is_safe_asset_name(n)
            ]
            files_to_send = []
            parts = []
            for tex_name in tex_names:
                try:
                    main_bytes = all_bytes[tex_name]
                    support = [
                        (n, all_bytes[n])
                        for n in support_names
                        if n != tex_name and is_safe_asset_name(n)
                    ]
                    # (ważne) do supportów dopuszczamy również **inne .tex** – dla \input/\include
                    other_tex = [
                        (n, all_bytes[n])
                        for n in tex_names
                        if n != tex_name and is_safe_tex_name(n)
                    ]
                    support.extend(other_tex)
                    res = await compile_single_tex_bytes(
                        main_bytes,
                        tex_name,
                        LATEX_TEX_ENGINE,
                        LATEX_MAX_COMPILE_SECONDS,
                        logger="discord",
                        support_files=support,
                    )
                    # Twoja dotychczasowa obsługa success/fail – przykładowo:
                    if res["ok"] and res["pdf_bytes"]:
                        b = io.BytesIO(res["pdf_bytes"])
                        b.seek(0)
                        b.name = res["pdf_name"]
                        files_to_send.append(discord.File(b, filename=res["pdf_name"]))
                        parts.append(f"✅ `{tex_name}` → `{res['pdf_name']}`")
                    else:
                        parts.append(
                            f"❌ `{tex_name}` — błąd kompilacji.)"
                        )
                        # Tutaj wywołujesz swoją ścieżkę do OpenAI diagnozy, którą ogarnęliśmy wcześniej.
                except Exception:
                    # let it crash — pełny stack w logu i re-raise (Discord.py to pokaże sensownie)
                    logging.getLogger("discord").exception(
                        "Unhandled exception while compiling %s", tex_name
                    )
                    raise
                content = (
                    f"**LaTeX** — {len(tex_names)} plik(ów). Model: `{OPENAI_MODEL}`\n\n"
                    + "\n\n".join(parts)
                )
                await ctx.reply(
                    content if len(content) < 1900 else content[:1900] + "…",
                    files=files_to_send,
                    mention_author=False,
                )
    # -------- /latexclean (PDF only; log -> debug logger) --------
    @commands.hybrid_command(
        nsfw=False,
        name="latexclean",
        description="Kompiluje .tex i odsyła TYLKO PDF (log w debug).",
        guild=None if GUILD_ID is None else discord.Object(id=GUILD_ID),
    )
    @commands.has_any_role(*ALLOWED_ROLES)
    async def latexclean(self, ctx: commands.Context):
        ch = ctx.message.channel
        async with ch.typing():
            all_bytes = await _collect_attachments_bytes(
                ctx.message.attachments, LATEX_MAX_ATTACH_MB
            )
            if not all_bytes:
                return await ctx.reply(
                    f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False
                )
            # PODZIEL NA GŁÓWNE .TEX i WSPIERAJĄCE
            tex_names = [
                n
                for n in all_bytes.keys()
                if n.lower().endswith(".tex") and is_safe_tex_name(n)
            ]
            if not tex_names:
                return await ctx.reply(
                    f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False
                )
            support_names = [
                n
                for n in all_bytes.keys()
                if n not in tex_names and is_safe_asset_name(n)
            ]
            files_to_send = []
            parts = []
            for tex_name in tex_names:
                try:
                    main_bytes = all_bytes[tex_name]
                    support = [
                        (n, all_bytes[n])
                        for n in support_names
                        if n != tex_name and is_safe_asset_name(n)
                    ]
                    # (ważne) do supportów dopuszczamy również **inne .tex** – dla \input/\include
                    other_tex = [
                        (n, all_bytes[n])
                        for n in tex_names
                        if n != tex_name and is_safe_tex_name(n)
                    ]
                    support.extend(other_tex)
                    res = await compile_single_tex_bytes(
                        main_bytes,
                        tex_name,
                        LATEX_TEX_ENGINE,
                        LATEX_MAX_COMPILE_SECONDS,
                        logger="discord",
                        support_files=support,
                    )
                    # Twoja dotychczasowa obsługa success/fail – przykładowo:
                    if res["ok"] and res["pdf_bytes"]:
                        b = io.BytesIO(res["pdf_bytes"])
                        b.seek(0)
                        b.name = res["pdf_name"]
                        files_to_send.append(discord.File(b, filename=res["pdf_name"]))
                        parts.append(f"✅ `{tex_name}` → `{res['pdf_name']}`")
                    else:
                        parts.append(
                            f"❌ `{tex_name}` — błąd kompilacji.)"
                        )
                        # Tutaj wywołujesz swoją ścieżkę do OpenAI diagnozy, którą ogarnęliśmy wcześniej.
                except Exception:
                    # let it crash — pełny stack w logu i re-raise (Discord.py to pokaże sensownie)
                    logging.getLogger("discord").exception(
                        "Unhandled exception while compiling %s", tex_name
                    )
                    raise
            await ctx.reply(
                "**LaTeX clean** — " + ", ".join(parts),
                files=files_to_send,
                mention_author=False,
            )
    # -------- /texbatch (ZIP -> ZIP) --------
    @app_commands.command(
        name="texbatch",
        description="Wyślij ZIP z .tex → odeślę ZIP z PDF-ami (tylko udane).",
    )
    @app_commands.describe(archive=f"Archiwum .zip (max ~{LATEX_MAX_ZIP_MB} MiB)")
    @app_commands.checks.has_any_role(*ALLOWED_ROLES)
    async def texbatch(
        self, interaction: discord.Interaction, archive: discord.Attachment
    ):
        await interaction.response.defer()
        if not archive or not archive.filename.lower().endswith(".zip"):
            return await interaction.followup.send(
                "Dołącz ZIP (.zip) z plikami .tex.", ephemeral=True
            )
        if archive.size > LATEX_MAX_ZIP_MB * 1024 * 1024:
            return await interaction.followup.send(
                f"ZIP > {LATEX_MAX_ZIP_MB} MiB — za duży.", ephemeral=True
            )
        data = await archive.read()
        out_zip_bytes, failed = await compile_zip_to_zip(
            data, LATEX_TEX_ENGINE, LATEX_MAX_COMPILE_SECONDS, logger=self.logger_name
        )
        if not out_zip_bytes and failed:
            return await interaction.followup.send(
                "Brak PDF-ów. " + "; ".join(failed[:10]), ephemeral=True
            )
        bio = io.BytesIO(out_zip_bytes)
        bio.seek(0)
        bio.name = "compiled_pdfs.zip"
        if failed:
            self.logger.debug("BATCH failed: %s", ", ".join(failed))
        await interaction.followup.send(
            "✅ Gotowe (ZIP w załączniku)."
            + (f" ❌ Błędy: {len(failed)}" if failed else ""),
            files=[discord.File(bio, filename=bio.name)],
        )
 async def setup(bot):
    logger = logging.getLogger("discord")
    await bot.add_cog(LatexModule(bot, logger_name="discord"))
    logger.info("Loading kinky latex module done")
@@ -1,179 +0,0 @@
 import asyncio
 import logging
 import re
 import shutil
 import tempfile
 import zipfile
 from pathlib import Path
 from typing import Dict, Iterable, List, Optional, Tuple
 # ===== Bezpieczeństwo nazw/rozszerzeń =====
 SAFE_TEX_NAME = re.compile(r"^[\w\-. ]+\.tex$", re.IGNORECASE)
 SAFE_ASSET_NAME = re.compile(
    r"^[\w\-. /]+?\.(tex|png|jpg|jpeg|pdf|svg|eps|bmp|gif|sty|cls|bib|bst|bbx|cbx|def|cfg)$",
    re.IGNORECASE,
 )
 def is_safe_tex_name(name: str) -> bool:
    return bool(SAFE_TEX_NAME.match(name or ""))
 def is_safe_asset_name(name: str) -> bool:
    return bool(SAFE_ASSET_NAME.match(name or ""))
 # ===== Uruchamianie kompilatora =====
 async def _run(cmd: List[str], cwd: Path, timeout_sec: int, logger_name: Optional[str]) -> Tuple[int, str]:
    """Uruchamia proces kompilatora w cwd, zwraca (rc, sklejone_stdout_stderr)."""
    logger = logging.getLogger(logger_name) if logger_name else logging.getLogger()
    logger.debug("RUN %s (cwd=%s, timeout=%s)", " ".join(cmd), cwd, timeout_sec)
    proc = await asyncio.create_subprocess_exec(
        *cmd,
        stdout=asyncio.subprocess.PIPE,
        stderr=asyncio.subprocess.STDOUT,
        cwd=str(cwd),
    )
    try:
        out = await asyncio.wait_for(proc.communicate(), timeout=timeout_sec)
    except asyncio.TimeoutError:
        try:
            proc.kill()
        finally:
            pass
        return 124, "TIMEOUT: compiler took too long"
    rc = proc.returncode
    log = (out[0] or b"").decode("utf-8", errors="ignore")
    logger.debug("RC=%s, LOG TAIL:\n%s", rc, log[-1500:])
    return rc, log
 def _build_cmd(tex_engine: str, main_tex: str) -> List[str]:
    """Buduje komendę kompilatora; domyślnie tectonic/pdflatex/xelatex."""
    if tex_engine.lower() == "tectonic":
        # Tectonic sam robi wielofazowość, ale i tak uruchamiamy 2x (bezpiecznie dla bib/refs)
        return ["tectonic", "--keep-intermediates", "--synctex", main_tex]
    elif tex_engine.lower() in ("pdflatex", "xelatex", "lualatex"):
        return [tex_engine, "-interaction=nonstopmode", "-halt-on-error", main_tex]
    else:
        # fallback – traktujemy jak pdflatex
        return ["pdflatex", "-interaction=nonstopmode", "-halt-on-error", main_tex]
 async def run_latex_two_passes(
    tex_filename: str, workdir: Path, tex_engine: str, timeout_sec: int, logger: Optional[str] = None
 ) -> Tuple[bool, str, Path]:
    """
    Uruchamia kompilację 2 razy (bezpieczeństwo referencji/bib).
    Zwraca: (ok, log_text, pdf_path).
    """
    logger_obj = logging.getLogger(logger) if logger else logging.getLogger()
    logger_obj.info("Compiling %s with %s engine two passes", tex_filename, tex_engine)
    logs: List[str] = []
    pdf_path = workdir / (Path(tex_filename).stem + ".pdf")
    # PASS 1
    rc1, log1 = await _run(_build_cmd(tex_engine, tex_filename), workdir, timeout_sec, logger)
    logs.append(log1)
    if rc1 != 0:
        return False, "".join(logs), pdf_path
    # PASS 2 (często już nic nie robi, ale nie szkodzi)
    rc2, log2 = await _run(_build_cmd(tex_engine, tex_filename), workdir, timeout_sec, logger)
    logs.append(log2)
    ok = (rc2 == 0) and pdf_path.exists()
    return ok, "".join(logs), pdf_path
 # ===== Kompilacje: pojedynczy TEX + ZIP =====
 async def compile_single_tex_bytes(
    tex_bytes: bytes,
    filename: str,
    tex_engine: str,
    timeout_sec: int,
    logger: Optional[str] = None,
    support_files: Optional[Iterable[Tuple[str, bytes]]] = None,
 ) -> Dict[str, Optional[object]]:
    """
    Kompiluje pojedynczy .tex + dowolne pliki pomocnicze (obrazy, sty/cls/bib, inne .tex).
    Każdy plik zapisujemy w katalogu roboczym widocznym dla kompilatora.
    """
    log = logging.getLogger(logger) if logger else logging.getLogger()
    log.info("Compiling %s with %s engine single tex", filename, tex_engine)
    if not is_safe_tex_name(filename):
        return {"ok": False, "pdf_bytes": None, "log_text": "Invalid .tex filename", "pdf_name": None}
    with tempfile.TemporaryDirectory(prefix="latex_one_") as td:
        wd = Path(td)
        (wd / Path(filename).name).write_bytes(tex_bytes)
        # Zapisz wszystkie supporty obok głównego pliku
        if support_files:
            for fname, data in support_files:
                if not fname or not is_safe_asset_name(fname):
                    continue
                # spłaszczamy do nazwy bazowej (bez podkatalogów z zewn. źródeł)
                (wd / Path(fname).name).write_bytes(data)
        ok, log_text, pdf_path = await run_latex_two_passes(Path(filename).name, wd, tex_engine, timeout_sec, logger)
        log.info("LaTeX compile finished: %s", "OK" if ok else "FAIL")
        log.info("Log text:\n%s", log_text[-2000:])  # Log last 2000 chars
        log.info("PDF path: %s", pdf_path)
        if ok and pdf_path.exists():
            return {
                "ok": True,
                "pdf_bytes": pdf_path.read_bytes(),
                "log_text": log_text,
                "pdf_name": pdf_path.name,
            }
        return {"ok": False, "pdf_bytes": None, "log_text": log_text, "pdf_name": pdf_path.name}
 async def compile_zip_to_zip(
    zip_bytes: bytes, tex_engine: str, timeout_sec: int, logger: Optional[str] = None
 ) -> Tuple[bytes, List[str]]:
    """
    Rozpakowuje ZIP, znajduję wszystkie .tex i dla KAŻDEGO tworzy osobny katalog roboczy
    ze skopiowanym CAŁYM drzewem, by zachować ścieżki względne obrazków/plików.
    Zwraca (zip_pdf_bytes, lista_rel_sciezek_które_padły).
    """
    log = logging.getLogger(logger) if logger else logging.getLogger()
    failed: List[str] = []
    out_pdf_paths: List[Path] = []
    with tempfile.TemporaryDirectory(prefix="latex_zip_") as td:
        td_path = Path(td)
        src_root = td_path / "src"
        src_root.mkdir(parents=True, exist_ok=True)
        # 1) Rozpakuj
        zpath = td_path / "in.zip"
        zpath.write_bytes(zip_bytes)
        with zipfile.ZipFile(zpath, "r") as zf:
            zf.extractall(src_root)
        # 2) Zbierz .tex
        tex_files = [p for p in src_root.rglob("*.tex") if is_safe_tex_name(p.name)]
        if not tex_files:
            return b"", ["No .tex files found in archive."]
        # 3) Kompiluj każdy .tex w izolacji (kopiujemy całe drzewo do osobnego workdiru)
        for tex_path in tex_files:
            rel_tex = tex_path.relative_to(src_root).as_posix()
            work = td_path / f"build_{tex_path.stem}"
            try:
                shutil.copytree(src_root, work / "src")
                ok, log_text, pdf = await run_latex_two_passes(rel_tex, work / "src", tex_engine, timeout_sec, logger)
                if ok and pdf.exists():
                    out_pdf_paths.append(pdf)
                else:
                    failed.append(rel_tex)
                    log.info("LaTeX FAIL %s\n%s", rel_tex, (log_text or "")[-2000:])
            except Exception:
                # let it crash – log + re-raise (to zobaczy wyższa warstwa/discord.py)
                log.exception("Exception while compiling %s", rel_tex)
                raise
        # 4) Spakuj wyjściowe PDF-y
        out_zip = td_path / "compiled_pdfs.zip"
        with zipfile.ZipFile(out_zip, "w", compression=zipfile.ZIP_DEFLATED) as zf:
            for pdf in out_pdf_paths:
                zf.write(pdf, arcname=pdf.name)
        return out_zip.read_bytes(), failed
@@ -1,309 +0,0 @@
 import asyncio
 import io
 import logging
 import os
 import random
 import uuid
 from queue import Empty
 import discord
 import pdf2image
 import fitz
 import PyPDF2
 import requests
 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 (
    DIR_PATH_SADOX,
    LIBRARIAN_SERVICE_ADDRESS,
    SEND_QUERY,
    service_headers,
 )
 SERVICE_HEADERS = service_headers()
 class DataModule(commands.Cog):
    def __init__(self, bot, logger_name):
        self.bot = bot
        self.logger = logging.getLogger(logger_name)
    @commands.hybrid_command(
        nsfw=True,
        name="get_image_sadox",
        description="Wyświetla losową stronę z losowego komiksu FanSadox. Bardzo NSFW.",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def get_image_sadox(self, ctx):
        """
        Take in a context parameter and retrieve an image related from fansadox collection.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. In this case, it is likely being used
        to determine
        """
        self.logger.info("Get sadox")
        channel = ctx.message.channel
        async with channel.typing():
            # select random file
            res = []
            # Iterate directory
            for path in os.listdir(DIR_PATH_SADOX):
                # check if current path is a file
                if os.path.isfile(os.path.join(DIR_PATH_SADOX, path)):
                    res.append(path)
            # trunk-ignore(bandit/B311)
            filename = res[random.randrange(0, len(res) - 1)]
            # select random page
            file = open(DIR_PATH_SADOX + filename, "rb")
            if  True:
                doc = fitz.open(DIR_PATH_SADOX + filename)
                totalpages = len(doc)
                # trunk-ignore(bandit/B311)
                page_index = random.randrange(0, totalpages)
                page = doc.load_page(page_index)
                mat = fitz.Matrix(2.0, 2.0)  # powiększenie
                pix = page.get_pixmap(matrix=mat, alpha=False)
                byte_io_stream = io.BytesIO(pix.tobytes("png"))
                byte_io_stream.seek(0)
                byte_io_stream.name = "image.png"
                await ctx.send(file=discord.File(byte_io_stream))
            else: #legacy
                readpdf = PyPDF2.PdfReader(file)
                totalpages = len(readpdf.pages)
                # trunk-ignore(bandit/B311)
                page = random.randrange(1, totalpages)
                # convert page to image
                image = pdf2image.convert_from_path(
                    DIR_PATH_SADOX + filename, first_page=page, last_page=page
                )
                byte_io_stream = io.BytesIO()
                image[0].save(byte_io_stream, "JPEG")
                byte_io_stream.seek(0)
                byte_io_stream.name = "image.jpg"
                file = discord.File(byte_io_stream)
                await ctx.send(file=file)
            self.logger.info("Get sadox completed")
    @tasks.loop(seconds=3)
    async def check_data_q(self):
        """
        This function checks the data queue for any new entries and processes them accordingly.
        """
        try:
            fresh_data = IN_COMM_Q.get(block=False)
            entries = []
            if fresh_data.stop:
                searcher = fresh_data.author
                query = fresh_data.content
                l_p = 1
                for doi in fresh_data.entries:
                    self.logger.info(doi)
                    desc = fresh_data.entries[doi]
                    title = desc["Title"][0]
                    entries.append(
                        f"{l_p}. {title} pod linkiem https://www.sci-hub.se/{doi} i jest to {desc['type']}\n"
                    )
                    l_p += 1
                message = "*Z podłogi wysuwa się winda na książki*"
                if fresh_data.ctx is not None:
                    ctx = fresh_data.ctx
                    message += f" Dzielny poszukiwaczu @{searcher} w odpowiedzi na twoje zapytanie {query} nr {fresh_data.uuid}"
                else:
                    ctx = self.bot.get_channel(1062047571557744721)
                    message += f" Mam wynik dla zapytania {fresh_data.uuid} ale że Hammer coś grzebał nie pamiętam kto to chciał i co chciał"
                message += "nasza biblioteka służy Ci odpowiedzią. Przy dźwięku fanfar winda się otwiera a w środku "
                if len(entries) < 1:
                    message += "niestety nie ma nic"
                    await ctx.send(message)
                elif len(entries) >= 1 and len(entries) < 5:
                    message += " znajduje się coś:\n"
                    for item in entries:
                        message += item
                    await ctx.send(message)
                else:
                    message += " znajduje się cholernie dużo:\n"
                    for item in entries:
                        message += item
                        if len(message) > 1500:
                            await ctx.send(message)
                            message = ""
                # Kept for sentimental reasons
                # await ctx.send(f"O. A tak będzie wyglądało coś ciekawego w przyszłości: {data}")
        except Empty:
            pass
    @commands.hybrid_command(
        name="wyszukaj_linki_do_dokumentow",
        description="Szuka linkow doi w bazie crossref i podaje linki do scihuba",
        guild=discord.Object(id=664789470779932693),
    )
    async def wyszukaj_linki_do_dokumentow(self, ctx):
        """
        The function `wyszukaj_linki_do_dokumentow` searches for links to documents in a crossref database and provides links to scihub.
        :param ctx: The `ctx` parameter is typically used in Discord.py, a Python library for creating Discord bots.
        It represents the context of the command being executed, including information about the message, the server,
        and the user who invoked the command.
        """
        query = ctx.message.content
        query_uuid = uuid.uuid4()
        # TODO: TESTING ONLY!!
        # query_uuid = uuid.UUID('{12345678-1234-5678-1234-567812345678}')
        ctx.message.content = ctx.message.content.replace(
            "$wyszukaj_linki_do_dokumentow", ""
        )
        json_query = {
            "UUID": str(query_uuid),
            "query": str(query),
            "page": 1,
            "deep_search": False,
        }
        coroutine = asyncio.to_thread(
            requests.post,
            f"{LIBRARIAN_SERVICE_ADDRESS}{SEND_QUERY}",
            json=json_query,
            headers=SERVICE_HEADERS,
            timeout=360,
        )
        await ctx.send(
            "*Conjurer powoli notuje podane przez Ciebie. Podchodzi do sprytnie ukrytej przy barze rury od poczty pneumatycznej i"
            + " wrzuca twój liścik do środka* To teraz trza poczekać kilka godzin. Biblioteka to 3/4 stacji."
            + " A przecież pół stacji to browar, motelik dla zabaw cielesnych i ten Bar. Więc 12/8 stacji teraz będzie ciężko pracować"
        )
        query_response = await coroutine
        if not query_response.status_code == 200:
            await ctx.send(
                "*Z rury wydobywa się dym. Conjurer łapie pierwszą ciecz pod ręką i pryska na rurę. Następuje drobna eksplozja i wszystko zaczyna się palić."
                + " Conjurer jest skonfundowany..* Wołaj szefa - mam nieodparte wrażenie że się coś wyjebało"
            )
            return
        query, query_uuid, queue_size = (
            query_response.json()["data"][0],
            query_response.json()["data"][1],
            query_response.json()["data"][2],
        )
        if ctx.message.author.nick:
            username = ctx.message.author.nick
        else:
            username = ctx.message.author.name
        query_object = QueryControl(username, query_uuid, query, ctx)
        OUT_COMM_Q.put(query_object)
        await ctx.send(
            f"No dobra poszło. Zapamiętaj proszę {query_uuid} - to identyfikator twojego zapytania. Jesteś {queue_size} w kolejce."
            + " Zapytania obsługuje algorytm zasilany czterema chomikami zapierdalającymi w kołowrotku - więc wyniki najwcześniej za kilka godzi - ale mogą być też dni."
        )
    @commands.hybrid_command(
        name="glebokie_gardlo",
        description="Przygotowuje drinka o nazwie głębokie gardło",
        guild=discord.Object(id=664789470779932693),
    )
    async def wyszukaj_linki_do_dokumentow_deep(self, ctx):
        """
        The function `wyszukaj_linki_do_dokumentow_deep` performs a deep search for links to documents in
        a crossref database and provides links to scihub.
        :param ctx: The `ctx` parameter is typically used in Discord.py, a Python library for creating Discord bots.
        It represents the context of the command being executed, including information about the message, the server,
        and the user who invoked the command.
        """
        # TODO: Implement deep search logic here
        query = ctx.message.content.replace("$glebokie_gardlo", "")
        allowed = False
        for role in ctx.message.author.roles:
            if role.name == "Bartender":
                allowed = True
            if role.name == "Scribe":
                allowed = True
            if role.name == "Thane":
                allowed = True
        if not allowed:
            if ctx.message.author.nick:
                username = ctx.message.author.nick
            else:
                username = ctx.message.author.name
            vykidailo = False
            bartender = False
            prompt = "Przygotuj mi drinka o nazwie Głębokie Gardło, inspirowanego tym sławnym filmem oraz skandalem Watergate"
            for role in ctx.message.author.roles:
                if role.name == "Vykidailo":
                    vykidailo = True
                if role.name == "Bartender":
                    bartender = True
            global MESSAGE_TABLE  # pylint: disable=global-statement
            result, MESSAGE_TABLE = await handle_response(
                prompt, vykidailo, bartender, MESSAGE_TABLE, username, "GENERAL"
            )
            if len(result) < 1500:
                await ctx.send(result)
            else:
                while len(result) > 1500:
                    await ctx.send(result[:1500])
                    result = result[1500:]
            return
        query_uuid = uuid.uuid4()
        # TODO: TESTING ONLY!!
        # query_uuid = uuid.UUID('{12345678-1234-5678-1234-567812345678}')
        json_query = {
            "UUID": str(query_uuid),
            "query": str(query),
            "page": 1,
            "deep_search": True,
        }
        coroutine = asyncio.to_thread(
            requests.post,
            f"{LIBRARIAN_SERVICE_ADDRESS}{SEND_QUERY}",
            json=json_query,
            headers=SERVICE_HEADERS,
            timeout=360,
        )
        await ctx.send(
            "*Conjurer mruga okiem i zamiast drinka wyjmuje dysk usb z terminala. Podchodzi do sprytnie ukrytej przy barze rury od poczty pneumatycznej i"
            + " wrzuca ten dysk do środk* To teraz trza poczekać kilka godzin. TO będzie głębokie wyszukanie"
            + " Rozgląda się dookoła i stawia przed tobą mętnego drinka o zapachu mięty, gwiezdnego pyłu i oleju silnikowego"
        )
        query_response = await coroutine
        if not query_response.status_code == 200:
            await ctx.send(
                "*Z rury wydobywa się dym. Conjurer łapie pierwszą ciecz pod ręką i pryska na rurę. Następuje drobna eksplozja i wszystko zaczyna się palić."
                + " Conjurer jest skonfundowany..* Wołaj szefa - mam nieodparte wrażenie że się coś wyjebało"
            )
            return
        query, query_uuid, queue_size = (
            query_response.json()["data"][0],
            query_response.json()["data"][1],
            query_response.json()["data"][2],
        )
        if ctx.message.author.nick:
            username = ctx.message.author.nick
        else:
            username = ctx.message.author.name
        query_object = QueryControl(username, query_uuid, query, ctx)
        OUT_COMM_Q.put(query_object)
        await ctx.send(
            f"Wypij wypi {query_uuid} - to identyfikator twojego zapytania. Jesteś {queue_size} w kolejce niestety kolejka obowiazuje zawsze."
            + " Zapytania obsługuje algorytm zasilany czterema chomikami zapierdalającymi w kołowrotku - więc wyniki najwcześniej za kilka godzin - ale mogą być też dni. Głębokie zabawy trwają dłużej. *Znowu mruga*"
        )
 async def setup(bot):
    logger = logging.getLogger("discord")
    dm = DataModule(bot, "discord")
    dm.check_data_q.start()
    await bot.add_cog(dm)
    logger.info("Loading data sharing commands module done")
@@ -1,28 +0,0 @@
 # pdf_render.py
 import io
 try:
    import fitz  # PyMuPDF
    _HAS_PYMUPDF = True
 except Exception:
    _HAS_PYMUPDF = False
    from pdf2image import convert_from_path
 def pdf_page_to_image_bytes(path: str, page_index: int = 0, zoom: float = 2.0, fmt: str = "PNG") -> bytes:
    """
    Zwraca bytes obrazka z jednej strony PDF:
      - PyMuPDF (szybki) jeśli dostępny,
      - inaczej pdf2image + poppler (wymaga 'pdftoppm').
    page_index: 0-based
    """
    if _HAS_PYMUPDF:
        doc = fitz.open(path)
        page = doc.load_page(page_index)
        mat = fitz.Matrix(zoom, zoom)
        pix = page.get_pixmap(matrix=mat, alpha=False)
        return pix.tobytes(fmt.lower())
    # fallback
    images = convert_from_path(path, first_page=page_index+1, last_page=page_index+1, fmt=fmt)
    bio = io.BytesIO()
    images[0].save(bio, fmt)
    return bio.getvalue()
@@ -1,101 +0,0 @@
 # === SYSTEM SETUP ===
 sudo apt update && sudo apt install -y \
  pulseaudio pulseaudio-utils pavucontrol \
  libgtk-3-dev gtk-3-examples \
  xauth dbus-x11 \
  samba
 # === SAMBA CONFIGURATION ===
 sudo nano /etc/samba/smb.conf
 # Add at the end of the file:
 # [RaspberryPiNAS]
 #    path = /home/pi/Public
 #    comment = Pi Share
 #    browseable = yes
 #    writeable = yes
 #    guest ok = no
 #    valid users = pi
 # Set permissions
 chmod 755 /home/pi
 mkdir -p /home/pi/Public
 chmod 777 /home/pi/Public
 chown -R pi:pi /home/pi/Public
 # Set Samba password for pi
 sudo smbpasswd -a pi
 # Restart Samba
 sudo systemctl restart smbd
 # === PULSEAUDIO SYSTEM-WIDE SERVICE ===
 sudo nano /etc/systemd/system/pulseaudio.service
 # Paste this content:
 # [Unit]
 # Description=PulseAudio System-wide Daemon
 # After=sound.target network.target
 #
 # [Service]
 # Type=simple
 # ExecStart=/usr/bin/pulseaudio --system --disallow-exit --disallow-module-loading=0 --daemonize=no
 # Restart=always
 #
 # [Install]
 # WantedBy=multi-user.target
 # === PULSEAUDIO MODULES FOR LEXICON LAMBDA USB ===
 sudo nano /etc/pulse/system.pa
 # Comment out:
 # load-module module-udev-detect
 # load-module module-detect
 # Add this at the bottom:
 # load-module module-alsa-sink device=hw:1,0 sink_name=LambdaOutput sink_properties=device.description="Lexicon_Lambda_USB_Output"
 # load-module module-alsa-source device=hw:1,0 source_name=LambdaInput source_properties=device.description="Lexicon_Lambda_USB_Input"
 # load-module module-native-protocol-unix auth-anonymous=1 socket=/tmp/pulseaudio.socket
 # Set client default socket
 sudo nano /etc/pulse/client.conf
 # Add this line:
 # default-server = unix:/tmp/pulseaudio.socket
 # Enable and start PulseAudio system-wide
 sudo systemctl daemon-reload
 sudo systemctl enable pulseaudio.service
 sudo systemctl restart pulseaudio.service
 # === X11 & GUI FIXES FOR SSH/MOBAXTERM ===
 sudo nano /etc/ssh/sshd_config
 # Ensure these lines are present:
 # X11Forwarding yes
 # X11UseLocalhost no
 # XAuthLocation /usr/bin/xauth
 # Restart SSH
 sudo systemctl restart ssh
 # Ensure xauth is installed
 sudo apt install -y xauth
 # === BASHRC: MAKE GUI EXPORTS PERSISTENT ===
 nano ~/.bashrc
 # Add this at the end:
 # export GDK_BACKEND=x11
 # export LIBGL_ALWAYS_INDIRECT=1
 # export NO_AT_BRIDGE=1
 # export $(dbus-launch)
 # Reload bashrc immediately
 source ~/.bashrc
 # === TESTING GUI ===
 # (Reconnect via MobaXterm SSH with X11 forwarding enabled before running below)
 # Run pavucontrol GUI
 pavucontrol &
 # Optional: Test GTK GUI rendering
 gtk3-demo &
 # Check audio devices
 pactl list sinks short
 pactl list sources short
@@ -1,809 +0,0 @@
 import asyncio
 import logging
 import random
 import re
 from datetime import datetime
 from sys import platform
 import discord
 import eyed3
 from discord.ext import commands, tasks
 import music_functions
 from ai_functions import handle_response
 from communication_subroutine import PREPPED_TRACKS
 from constants import MESSAGE_TABLE_MUZYKA, MUZYKA, SEPARATOR_FILE_PATH
 from other_functions import get_stats
 class MusicModule(commands.Cog):
    def __init__(self, bot, logger_name):
        self.bot = bot
        self.logger = logging.getLogger(logger_name)
    @commands.hybrid_command(
        name="krecimy_pornola",
        description="Wiadomo co, dla kogo i po co",
    )
    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
    async def krecimy_pornola(self, ctx):
        """
        Download a music number from youtube.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. It allows the command to interact
        with the Discord API and
        """
        await ctx.send("Dej mnie chwilkę")
        self.logger.info("Pornol")
        async with ctx.typing():
            # wyciagnij linka z kontekstu
            content = ctx.message.content.split()
            for item_yt in content:
                if re.match("http.*", item_yt):
                    sciezka, files = await music_functions.get_file(
                        ctx, "Pornol", item_yt
                    )
                    if files:
                        self.logger.info("Pornol udany")
                        await ctx.send(
                            f"Jest w tajnym archiwum pod adresem{sciezka})"
                        )
    @commands.hybrid_command(
        name="co_na_plejliscie_wariacie",
        description="Wyswietl kawalki ktore sa na pocztku list radia",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def co_na_plejliscie_wariacie(self, ctx):
        """
        Download a music number from youtube.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. It allows the command to interact
        with the Discord API and
        """
        await ctx.send("Dej mnie chwilkę")
        async with ctx.typing():
            self.logger.info("plejlista")
            self.logger.info(PREPPED_TRACKS)
            await ctx.send(
                f"Didżej Hammer i jego sztuczna inteligencja (||he he||) prezentują: \n- obecnie grany jest {(PREPPED_TRACKS['now_playing']).rstrip()} (wg metadanych: {PREPPED_TRACKS['meta']}) \n- następny będzie{(PREPPED_TRACKS['next']).rstrip()} \n- na liście priorytetowej {(PREPPED_TRACKS['priority']).rstrip()} \n- na liście hitów obecnie czeka kawałek {(PREPPED_TRACKS['hit']).rstrip()} \n- na liście wszystkich kawałków {(PREPPED_TRACKS['all']).rstrip()} \n- najświeższym zamówieniem od słuchaczy jest {(PREPPED_TRACKS['requests']).rstrip()} \nZ kolei jingiel to: {(PREPPED_TRACKS['jingles']).rstrip()}"
            )
    @tasks.loop(seconds=1)
    async def check_music(self):
        """
        This Python function continuously checks for music playback in a voice client and plays music if
        conditions are met.
        """
        if self.bot.voice_clients:
            voice_client = self.bot.voice_clients[0]
            if (
                voice_client
                and voice_client.is_connected()
                and not voice_client.is_playing()
                and not voice_client.is_paused()
            ):
                await self.play(MUZYKA["ctx"], MUZYKA["requester"])
                await asyncio.sleep(2)
    @commands.hybrid_command(
        name="dej_co_z_jutuba",
        description="Podaj link do youtube - sciagnie i doda muzyke",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def dej_co_z_jutuba(self, ctx):
        """
        Download a music number from youtube.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. It allows the command to interact
        with the Discord API and
        """
        await ctx.send("Dej mnie chwilkę")
        self.logger.info("Jutub")
        async with ctx.typing():
            # wyciagnij linka z kontekstu
            content = ctx.message.content.split()
            for item_yt in content:
                if re.match("http.*", item_yt):
                    _, files = await music_functions.get_file(ctx, "Youtube", item_yt)
                    if files:
                        for file_iter in files:
                            global MUZYKA  # pylint: disable=global-variable-not-assigned
                            MUZYKA["queue"].insert(0, file_iter)
                            music_functions.MUSIC_FILE_LIST.update_file_list(file_iter)
                            MUZYKA["requester"].insert(0, ctx.author)
                            await ctx.send(f"Dodałem do listy {file_iter}")
                        self.logger.info("Jutub udany")
    @commands.hybrid_command(
        name="dej_co_ze_spotifaja",
        description="Podaj link do spotify - sciagnie i doda muzyke",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def dej_co_ze_spotifaja(self, ctx):
        """
        Get a playlist or a music number from Spotify.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. This parameter is required in all
        Discord.py commands
        """
        self.logger.info("Spotifaj")
        await ctx.send("Dej mnie chwilkę")
        async with ctx.typing():
            # wyciagnij linka z kontekstu
            content = ctx.message.content.split()
            for item in content:
                if re.match("http.*", item):
                    dir_path, files = await music_functions.get_file(
                        ctx, "Spotify", item
                    )
                    if platform == "win32":
                        separator = "\\"
                    else:
                        separator = "/"
                    for file in files:
                        file_path = (
                            dir_path
                            + separator
                            + file["artist"]
                            + " - "
                            + file["name"]
                            + ".mp3"
                        )
                        global MUZYKA  # pylint: disable=global-variable-not-assigned
                        MUZYKA["queue"].insert(
                            0,
                            dir_path
                            + separator
                            + file["artist"]
                            + " - "
                            + file["name"]
                            + ".mp3",
                        )
                        MUZYKA["requester"].insert(0, ctx.author)
                        music_functions.MUSIC_FILE_LIST.update_file_list(file_path)
                        await ctx.send(
                            f"Dodałem do listy {dir_path}{file['artist']} -  + {file['name']}.mp3"
                        )
                        self.logger.info("Spotifaj udany")
    # MUSIC BOT PART
    @commands.hybrid_command(
        name="cisza",
        description="Wyłącza muzykę i czyści plejliste.",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def cisza(self, ctx):
        """
        Stop playback of the music and clear the queue.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. This parameter is required in all
        Discord.py commands
        """
        self.logger.info("Stop")
        global MUZYKA  # pylint: disable=global-variable-not-assigned
        MUZYKA["ctx"] = None
        voice_client = self.bot.voice_clients[0]
        self.check_music.stop()
        if voice_client.is_connected():
            await self.disconnect(ctx=ctx)
            while MUZYKA["queue"]:
                MUZYKA["queue"].pop()
                MUZYKA["requester"].pop()
                self.logger.info("Stop completed")
    @commands.hybrid_command(
        name="dalej",
        description="Przerzuca na następny kawałek",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def dalej(self, ctx):
        """
        Play next track in queue.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which a command is being executed, including information such as the
        message, the channel, the server, and the user who invoked the command. The context object is used
        to access and manipulate this
        """
        if ctx:
            self.logger.info("Ctx defined for dalej")
        self.logger.info("Next")
        voice_client = self.bot.voice_clients[0]
        if voice_client.is_connected():
            voice_client.stop()
            self.logger.info("Next completed")
    @commands.hybrid_command(
        name="daj_mi_chwile",
        description="Pauzuje",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def daj_mi_chwile(self, ctx):
        """
        Pause music playback.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. This parameter is required in most
        Discord.py commands and is
        """
        if ctx:
            self.logger.info("Ctx defined for pause")
        self.logger.info("Pause")
        voice_client = self.bot.voice_clients[0]
        if voice_client.is_connected():
            voice_client.pause()
            self.logger.info("Pause completed")
    @commands.hybrid_command(
        name="graj_dalej",
        description="Odpauzowuje",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def graj_dalej(self, ctx):
        """
        Unpause music and continue playback.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. This parameter is required in all
        Discord.py commands
        """
        if ctx:
            self.logger.info("Ctx defined for graj_dalej")
        self.logger.info("Unpause")
        voice_client = self.bot.voice_clients[0]
        if voice_client.is_paused():
            voice_client.resume()
            self.logger.info("Unpause completed")
    @commands.hybrid_command(
        name="zagraj_mi_kawalek",
        description="Wyszukuje w bibliotece muzycznej Hammera kawałek który ma zostać zagrany",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def zagraj_mi_kawalek(self, ctx):
        """
        Play a song or music piece in response to a command
        triggered by a user in a Discord chat context.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        contains information about the context in which the command was invoked, such as the message, the
        channel, the server, and the user who invoked the command. This information can be used to perform
        various actions, such
        """
        async with ctx.typing():
            search_time_glob = datetime.now()
            self.logger.info("Zaczynam szukać timestamp %s", datetime.now())
            file = await self.wyszukaj(ctx=ctx)
            self.logger.info(
                "Koniec szukania(timestamp %s zajęło %s",
                datetime.now(),
                datetime.now() - search_time_glob,
            )
            if file:
                for plik in file:
                    global MUZYKA  # pylint: disable=global-variable-not-assigned
                    MUZYKA["queue"].insert(0, plik[1])
                    MUZYKA["requester"].insert(0, ctx.author)
                    metadata = eyed3.load(plik[1])
                    reply = (
                        "Dodałem do playlisty {plik[1]} z prywatnej kolekcji Hammera."
                    )
                    if metadata.tag.title:
                        reply = f"Dodałem do playlisty kawalek {metadata.tag.title}"
                    if metadata.tag.artist:
                        reply += f" wykonawcy {metadata.tag.artist}"
                    if metadata.tag.album:
                        reply += f" z albumu {metadata.tag.album}"
                    reply += (
                        " z prywatnej kolekcji Hammera i na Twoją specjalną rpośbę."
                    )
                    await ctx.send(reply)
            else:
                await ctx.send(
                    "Obawiam się że nie mogę nic znaleźć u siebie. Spróbuj komendy '$dej_co_ze_spotifaja' jeśli masz link"
                )
    @commands.hybrid_command(
        name="zrob_mi_plejliste",
        description="Generuje playliste - param1 - dlugosc, potem slowa wyszukiwania",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def zrob_mi_plejliste(self, ctx):
        """
        Generate a playlist in queue. First word in this command shall be int defining length of the playlist.
        Rest of the line are search terms.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. This parameter is required in all
        Discord.py commands
        """
        reply = "Wygenerowana plejlista:\n"
        async with ctx.typing():
            self.logger.info("Zaczynam szukać timestamp %s", datetime.now())
            search_time_glob = datetime.now()
            dlugosc_playlisty = ctx.message.content.split()[1]
            file = await music_functions.wyszukaj(ctx=ctx, how_many=dlugosc_playlisty)
            self.logger.info(
                "Koniec szukania(timestamp %s zajęło %s",
                datetime.now(),
                datetime.now() - search_time_glob,
            )
            index = 1
            if file:
                for plik in file:
                    if plik[1]:
                        self.logger.info(plik)
                        global MUZYKA  # pylint: disable=global-variable-not-assigned
                        MUZYKA["queue"].insert(0, plik[1])
                        MUZYKA["requester"].insert(0, ctx.author)
                        metadata = eyed3.load(plik[1])
                        if metadata and metadata.tag:
                            if metadata.tag.title:
                                reply += f"{index} {metadata.tag.title}"
                            else:
                                reply += (
                                    f"{index}. {plik[1]} z prywatnej kolekcji Hammera."
                                )
                            if metadata.tag.artist:
                                reply += f" wykonawcy {metadata.tag.artist}"
                            if metadata.tag.album:
                                reply += f" z albumu {metadata.tag.album}"
                            if metadata.tag.title:
                                reply += " z prywatnej kolekcji Hammera i na Twoją specjalną rpośbę.\n"
                        else:
                            reply += (
                                f"{index}. {plik[1]} z prywatnej kolekcji Hammera.\n"
                            )
                        index += 1
                        if len(reply) > 1800:
                            await ctx.send(reply)
                            reply = ""
            else:
                await ctx.send(
                    "Obawiam się że nie mogę nic znaleźć u siebie. Spróbuj komendy '$dej_co_ze_spotifaja' jeśli masz link"
                )
            await ctx.send(reply)
            self.logger.info("Plejlista zrobiona")
    @commands.hybrid_command(
        name="zagraj_muzyke_mego_ludu",
        description="Gra muzyke wyszukana na bazie tematow konwersacji na kanale NZ",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def zagraj_muzyke_mego_ludu(self, ctx):
        """
        Play completeley random playlist based on messaging history.
        :param ctx: ctx stands for "context" and is typically used in Discord.py commands to represent the
        context in which the command was invoked. This includes information such as the message, the
        channel, the author, and other relevant details. In this case, it is being passed as a parameter to
        the `get_image
        """
        stats = {}
        if ctx:
            self.logger.info("Zagraj muzyke mego ludu: wywolane")
            stat_iter = get_stats(self.bot, ctx, MUZYKA_MOJEGO_LUDU_HISTORIA)
            async for name, how_many in stat_iter:
                if len(name) > 3:
                    stats[name] = how_many
            sorted_stats = sorted(stats.items(), key=lambda x: x[1])
            self.logger.info("Zagraj muzyke mego ludu:zebrano statystyki")
            key_words = []
            for stat in sorted_stats:
                key_words.append(stat[0])
            self.logger.info(sorted_stats[:MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE])
            self.logger.info(key_words[:MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE])
            self.logger.info(sorted_stats[-MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE:])
            self.logger.info(key_words[-MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE:])
            final_key_words = key_words[:MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE]
            final_key_words.extend(key_words[-MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE:])
        reply = "Wygenerowana plejlista:\n"
        async with ctx.typing():
            self.logger.info(
                "Zagraj muzyke mego ludu:Zaczynam szukać timestamp %s", datetime.now()
            )
            search_time_glob = datetime.now()
            file = await music_functions.wyszukaj(
                ctx=ctx,
                how_many=MUZYKA_MOJEGO_LUDU_PLAJLISTA,
                slowa_kluczowe=final_key_words,
            )
            self.logger.info("Zagraj muzyke mego ludu:wygenerowano plejliste")
            self.logger.info(file)
            self.logger.info(
                "Zagraj muzyke mego ludu: Koniec szukania(timestamp %s zajęło %s",
                datetime.now(),
                datetime.now() - search_time_glob,
            )
            index = 1
            if file:
                for plik in file:
                    global MUZYKA  # pylint: disable=global-variable-not-assigned
                    MUZYKA["queue"].insert(0, plik[1])
                    MUZYKA["requester"].insert(0, ctx.author)
                    metadata = eyed3.load(plik[1])
                    if metadata and metadata.tag:
                        if metadata.tag.title:
                            reply += f"{index} {metadata.tag.title}"
                        else:
                            reply += f"{index}. {plik[1]} z prywatnej kolekcji Hammera."
                        if metadata.tag.artist:
                            reply += f" wykonawcy {metadata.tag.artist}"
                        if metadata.tag.album:
                            reply += f" z albumu {metadata.tag.album}"
                        if metadata.tag.title:
                            reply += " z prywatnej kolekcji Hammera i na Twoją specjalną rpośbę.\n"
                    else:
                        reply += f"{index}. {plik[1]} z prywatnej kolekcji Hammera.\n"
                    index += 1
                    if len(reply) > 1800:
                        await ctx.send(reply)
                        reply = ""
            else:
                await ctx.send(
                    "Obawiam się że nie mogę nic znaleźć u siebie. Spróbuj komendy '$dej_co_ze_spotifaja' jeśli masz link"
                )
            await ctx.send(reply)
            self.logger.info("Plejlista zrobiona")
    @commands.hybrid_command(
        name="parametry_muzyki_mego_ludu",
        description="Konfiguruje komende zagraj muzyke mojego ludu",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def parametry_muzyki_mego_ludu(
        self, ctx, ile_historii=1500, ile_slow_kluczowych=15, jak_dluga_plejlista=30
    ):
        """
        The function `parametry_muzyki_mego_ludu` sets global variables for the number of history entries,
        number of keywords, and length of playlist for a music application.
        :param ctx: The `ctx` parameter is typically used in Discord.py, a Python library for creating
        Discord bots. It represents the context of the command being executed, including information about
        the message, the server, and the user who invoked the command
        :param ile_historii: The parameter "ile_historii" represents the number of history items for the
        music playlist, defaults to 1500 (optional)
        :param ile_slow_kluczowych: The parameter "ile_slow_kluczowych" represents the number of keywords or
        key phrases related to music that you want to include in your analysis or search, defaults to 30
        (optional)
        :param jak_dluga_plejlista: The parameter "jak_dluga_plejlista" determines the length of the
        playlist. It specifies how many songs should be included in the playlist, defaults to 30 (optional)
        """
        if ctx:
            async with ctx.typing():
                # if ':' in ile_historii:
                #    _, _, ile_historii = ile_historii.partition(':')
                # if ':' in ile_slow_kluczowych:
                #    _, _, ile_slow_kluczowych = ile_slow_kluczowych.partition(':')
                # if ':' in jak_dluga_plejlista:
                #    _, _, jak_dluga_plejlista = jak_dluga_plejlista.partition(':')
                try:
                    global MUZYKA_MOJEGO_LUDU_HISTORIA  # pylint: disable=global-statement
                    global MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE  # pylint: disable=global-statement
                    global MUZYKA_MOJEGO_LUDU_PLAJLISTA  # pylint: disable=global-statement
                    self.logger.info(
                        "Długość historii wyszukiwania: %s\n Ilość słów kluczowych: %s\n Długość plejlisty do wygenerowanie: %s",
                        MUZYKA_MOJEGO_LUDU_HISTORIA,
                        MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE,
                        MUZYKA_MOJEGO_LUDU_PLAJLISTA,
                    )
                    ctx.send(
                        f"Dotychczasowe wartośći:\n Długość historii wyszukiwania: {MUZYKA_MOJEGO_LUDU_HISTORIA}\n Ilość słów kluczowych: {MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE}\n Długość plejlisty do wygenerowanie:{MUZYKA_MOJEGO_LUDU_PLAJLISTA}"
                    )
                    MUZYKA_MOJEGO_LUDU_HISTORIA = ile_historii
                    MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE = ile_slow_kluczowych
                    MUZYKA_MOJEGO_LUDU_PLAJLISTA = jak_dluga_plejlista
                    self.logger.info(
                        "Długość historii wyszukiwania: %s\n Ilość słów kluczowych: %s\n Długość plejlisty do wygenerowanie: %s",
                        MUZYKA_MOJEGO_LUDU_HISTORIA,
                        MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE,
                        MUZYKA_MOJEGO_LUDU_PLAJLISTA,
                    )
                    self.ctx.send(
                        f"Zmienione wartośći:\n Długość historii wyszukiwania: {MUZYKA_MOJEGO_LUDU_HISTORIA}\n Ilość słów kluczowych: {MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE}\n Długość plejlisty do wygenerowanie:{MUZYKA_MOJEGO_LUDU_PLAJLISTA}"
                    )
                except discord.ext.commands.errors.BadArgument as exce:
                    ctx.send("Spierdalaj")
                    self.logger.info(exce)
    @commands.hybrid_command(
        name="graj_muzyko",
        description="Włącza muzykę na kanale #nocna-zmiana.",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def graj_muzyko(self, ctx):
        """
        Async function named "graj_muzyko" starts music playback on channel "Nocna Zmiana".
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. This parameter is required in all
        Discord.py commands
        """
        self.logger.info("Press play on tape")
        async with ctx.typing():
            global MUZYKA  # pylint: disable=global-variable-not-assigned
            MUZYKA["ctx"] = ctx
            await self.connect(ctx=ctx)
            await self.play(ctx=ctx)
            self.logger.info("Press play on tape completed")
            self.check_music.start()
    async def connect(self, ctx, arg=None):
        """
        Connect the bot to a voice channel if it is not already connected.
        :param ctx: ctx is short for context and refers to the context in which the command was invoked. It
        contains information about the message, the channel, the server, and the user who invoked the
        command
        :param arg: The `arg` parameter is an optional argument that can be passed to the `connect`
        function. It is not used in the code snippet provided, but it could potentially be used to specify a
        specific voice channel to connect to
        :return: If the voice client is already connected, the function will return without doing anything.
        If the function successfully connects to the voice channel, it will return a voice channel
        connection object. If it is not possible to connect to the voice channel, the function will log an
        error message and return nothing.
        """
        if ctx and arg:
            self.logger.info("Ctx and arg defined for connect")
        if self.bot.voice_clients:
            self.logger.info("Already connected with other client")
        else:
            vc = None
            if ctx.author.voice.channel:
                vc = await ctx.author.voice.channel.connect()
            else:
                voice_channel = self.bot.get_channel(1060349757349974066)
                vc = await voice_channel.connect()
            if not vc:
                self.logger.error("Not possible to connect to voice")
                return
            self.logger.info("Connected to voice")
    @commands.hybrid_command(
        name="batch_download",
        description="Zaciąga obiekty z pliku",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
    async def batch_download(self, ctx):
        content_type = ctx.message.attachments[0].content_type
        check = re.search("text\/plain; *charset=(.*)", content_type, re.IGNORECASE)
        await ctx.reply("Kurwa. Aleś mi roboty narobił... No nic. Ku radości. Skal!")
        async with ctx.typing():
            if check:
                global MUZYKA  # pylint: disable=global-variable-not-assigned
                file_bytes = await ctx.message.attachments[0].read()
                text = file_bytes.decode(encoding=check.group(1))
                self.logger.info(text)
                lines = text.split("\n")
                for link in lines:
                    link = link.strip()
                    self.logger.info(link)
                    pat = r"^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$"
                    self.logger.info("Verification")
                    if re.match(pat, link) and (
                        re.match(".*youtube.*", link) or re.match(".*youtu.be.*", link)
                    ):
                        self.logger.info("%s to link do jutuba", link)
                        dir_path, files = await music_functions.get_file(
                            ctx, "Youtube", link
                        )
                        if files:
                            for file_iter in files:
                                global MUZYKA  # pylint: disable=global-variable-not-assigned
                                MUZYKA["queue"].insert(0, file_iter)
                                music_functions.MUSIC_FILE_LIST.update_file_list(
                                    file_iter
                                )
                                MUZYKA["requester"].insert(0, ctx.author)
                                await ctx.send(f"Dodałem do listy {file_iter}")
                            self.logger.info("Jutub udany")
                    elif re.match(pat, link) and re.match(".*spotify.*", link):
                        self.logger.info("%s to link do spotify", link)
                        dir_path, files = await music_functions.get_file(
                            ctx, "Spotify", link
                        )
                        if platform == "win32":
                            separator = "\\"
                        else:
                            separator = "/"
                        for file in files:
                            file_path = (
                                dir_path
                                + separator
                                + file["artist"]
                                + " - "
                                + file["name"]
                                + ".mp3"
                            )
                            MUZYKA["queue"].insert(
                                0,
                                dir_path
                                + separator
                                + file["artist"]
                                + " - "
                                + file["name"]
                                + ".mp3",
                            )
                            MUZYKA["requester"].insert(0, ctx.author)
                            music_functions.MUSIC_FILE_LIST.update_file_list(file_path)
                            await ctx.send(
                                f"Dodałem do listy {dir_path}{file['artist']} -  + {file['name']}.mp3"
                            )
                            self.logger.info("Spotifaj udany")
                    elif re.match(pat, link):
                        self.logger.info("%s to link do czegos", link)
                        sciezka, files = await music_functions.get_file(
                            ctx, "Pornol", link
                        )
                        if files:
                            self.logger.info("Pornol udany")
                            await ctx.send(
                                f"Jest w tajnym archiwum pod adresem{sciezka})"
                            )
                    else:
                        self.logger.info("Spierdalaj")
                        self.logger.info(link)
                        await ctx.message.reply("Spierdalaj")
            else:
                self.logger.info(content_type)
                self.logger.info("Spierdalaj")
                await ctx.message.reply("Spierdalaj")
    async def disconnect(self, ctx):
        """
        Asynchronous Python function that disconnects the voice client if it is connected and
        logs a message if the context is defined.
        :param ctx: ctx is short for context and refers to the context in which a command is being executed.
        It contains information about the message, the user who sent the message, the channel the message
        was sent in, and more. In this case, the `disconnect` function is likely being called as a command
        in
        """
        if ctx:
            self.logger.info("Ctx defined for disconnect")
        if self.bot.voice_clients:
            voice_client = self.bot.voice_clients[0]
            if voice_client.is_connected():
                await voice_client.disconnect()
    async def play(self, ctx, zamawial=None, arg=None):
        """
        Play a music file, retrieve metadata about the file, and send a
        message to a Discord channel with information about the song being played.
        :param ctx: The "ctx" parameter is a context object that contains information about the current
        Discord command invocation, such as the message, the channel, and the user who invoked the command.
        It is passed to the function automatically by the Discord.py library
        :param zamawial: The parameter `zamawial` is a variable that stores the user who requested the song
        to be played. It is an optional parameter and can be None if no user requested the song
        :param arg: The `arg` parameter is an optional argument that can be passed to the `play` function.
        It is not used in the code provided, so its purpose is unclear without additional context
        """
        # TODO: Uzupełnianie metadanych. Jeśli ich nie ma sprawdzamy nazwę (w sposób inteligentny - czyli jeśli składa się z samych cyfr i/lub słowa track to sprawdzić album w sensie folder)
        # TODO: Jeśli w metadanych jest tylko "audiotrack" i "album" też po
        # folderze. Jeśli są niekompletne uzupełnić dalej.
        self.logger.info("Play procedure")
        if arg:
            self.logger.info("Arg defined for play")
        file_to_play = None
        voice_client = self.bot.voice_clients[0]
        if not self.bot.voice_clients:
            voice_client = self.bot.voice_clients[0]
            await self.connect(ctx)
        if MUZYKA["queue"]:
            file_to_play = MUZYKA["queue"].pop()
            zamawial = MUZYKA["requester"].pop()
            self.logger.info("Muzyka z listy zamówień")
        else:
            # trunk-ignore(bandit/B311)
            index = random.randint(
                0, len(music_functions.MUSIC_FILE_LIST.get_file_list()) - 1
            )
            file_to_play = music_functions.MUSIC_FILE_LIST.get_file_list()[index]
            self.logger.info("Muzyka losowo")
        self.logger.info(file_to_play)
        metadata = eyed3.load(file_to_play)
        query = None
        temp = file_to_play.split(SEPARATOR_FILE_PATH)[-1]
        kawalek = f"Zagram teraz kawalek {temp} z prywatnej kolekcji Hammera."
        if metadata:
            if metadata.tag:
                if metadata.tag.title:
                    query = f"Opowiedz mi o kawałku {metadata.tag.title}"
                    kawalek = f"Zagram teraz kawalek {metadata.tag.title}"
                    if metadata.tag.artist:
                        query += f" wykonawcy {metadata.tag.artist}"
                        kawalek += f" wykonawcy {metadata.tag.artist}"
                    if metadata.tag.album:
                        query += f" z albumu {metadata.tag.album}"
                        kawalek += f" z albumu {metadata.tag.album}"
                    kawalek += " z prywatnej kolekcji Hammera."
        if zamawial:
            kawalek += f"Na specjalne życzenie <@{zamawial.id}>."
        await ctx.send(kawalek)
        voice_client.play(
            discord.PCMVolumeTransformer(
                discord.FFmpegPCMAudio(source=file_to_play), volume=0.3
            )
        )  # NIE DOTYKAC POKRĘTŁA GŁOŚNOŚCI!!!!
        if query:
            self.logger.debug("Zapytanie do openai")
            self.logger.debug(query)
            vykidailo = False
            bartender = False
            for role in ctx.message.author.roles:
                if role.name == "Vykidailo":
                    vykidailo = True
                if role.name == "Bartender":
                    bartender = True
            if ctx.message.author.nick:
                username = ctx.message.author.nick
            else:
                username = ctx.message.author.name
            global MESSAGE_TABLE_MUZYKA  # pylint: disable=global-statement
            result, MESSAGE_TABLE_MUZYKA = await handle_response(
                query, vykidailo, bartender, MESSAGE_TABLE_MUZYKA, username, "MUSIC"
            )
            self.logger.debug("Obecna historia czatu: %s", MESSAGE_TABLE_MUZYKA)
            if len(result) < 1500:
                await ctx.send(result)
            else:
                while len(result) > 1500:
                    await ctx.send(result[:1500])
                    result = result[1500:]
 async def setup(bot):
    logger = logging.getLogger("discord")
    await music_functions.MUSIC_FILE_LIST.refresh_file_list(bot)
    logger.info("Playlist generation")
    await bot.add_cog(MusicModule(bot, "discord"))
    logger.info("Loading music commands module done")
@@ -1,333 +0,0 @@
 import asyncio
 import logging
 import re
 import uuid
 from pathlib import Path, PurePath
 from sys import platform
 import discord
 import requests
 import yt_dlp
 from constants import (
    FILE_SERVICE_ADDRESS,
    GET_MP3,
    GET_PLAYLIST,
    MUSIC_FOLDER,
    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):
    """
    The `MusicFileList` class manages a list of music files, with the ability to refresh the list from a
    file service or local directory and update the list with new items.
    """
    def __init__(self, logger_name) -> None:
        self.music_file_list = []
        self.file_service_active = False
        self.logger = logging.getLogger("discord")
        self.logger.info("Created Playlist organizer class")
    async def refresh_file_list(self, bot):
        """
        The `refresh_file_list` function attempts to connect to a file service to retrieve a list of music
        files, and if unsuccessful, it populates the list by scanning a local directory for .mp3 files.
        """
        try:
            self.logger.info("Attempt to connect to file service")
            response = requests.get(
                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"):
                temp_music_file = mp3_item.as_posix()
                if platform == "win32":
                    temp_music_file = temp_music_file.replace("/", "\\")
                self.music_file_list.append(temp_music_file)
            self.file_service_active = False
            self.logger.error(e.strerror)
            self.logger.error("Service Unavailable")
        finally:
            if self.file_service_active:
                self.logger.info("Radio Status: Probably Active")
                status = discord.Status.online
                # radio_hardkor = discord.Activity(
                #    name = "Radio Hammer/Radio Conjurer/Wolne Bałuity Kurwa",
                #    url = "http://95.175.16.246:666/mp3-stream",
                #    type = discord.ActivityType.streaming,
                #    platform = "Liquidsoap+RaspberyPi+RolandSeratoDJ202",
                #    state = "Where the f*** is the DJ booth?",
                #    details= "This Is Radio Hardkor based in Wolne Księstwo Bałuty, the best pirate radiostation on both sides of Łódka river",
                #    buttons= [{"label":"RADIO", "url":"http://95.175.16.246:666/mp3-stream"}],
                #    assets= {"large_image": "fuckery.jpg", "large_text":"Fuckewry", "small_image":"willowisp.png", "small_text":"Hi!"}
                # )
                radio_hardkor = discord.Streaming(
                    name="Radio Hardkor", url="http://95.175.16.246:666/mp3-stream"
                )
                await bot.change_presence(status=status, activity=radio_hardkor)
            else:
                self.logger.info("Radio Status: Rather Unknown")
                await bot.change_presence(
                    activity=discord.Game(name="Axe Throwing Darts")
                )
    def get_file_list(self):
        """
        The `get_file_list` function returns the list of music files stored in the object.
        :return: The `music_file_list` attribute is being returned.
        """
        return self.music_file_list
    def update_file_list(self, item):
        """
        The `update_file_list` function appends an item to a music file list and sends a POST request with
        the item data to a file service address.
        :param item: The `item` parameter in the `update_file_list` method is the file that you want to add
        to the `music_file_list` attribute of the class instance. It is then sent as a JSON payload in a
        POST request to a file service address along with the endpoint `SEND_MP3`
        """
        self.music_file_list.append(item)
        post_data = {"item": str(item)}
        requests.post(
            f"{FILE_SERVICE_ADDRESS}{SEND_MP3}",
            json=post_data,
            headers=SERVICE_HEADERS,
            timeout=60,
        )
 MUSIC_FILE_LIST = MusicFileList("discord")
 async def get_file(ctx, source, link):
    """
    Take in three parameters: "ctx" (context),
    "source" (a string representing the source of the file), and "link" (a string representing the link
    to the file). Execute it in asynchronouse way. And get file from spotify or youtube.
    :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
    represents the context in which a command is being executed, including information such as the
    message, the channel, the server, and the user who invoked the command
    :param source: The source parameter is likely a string that represents the source of the file that
    the user wants to retrieve. This could be a website, a cloud storage service, or any other location
    where the file is stored
    :param link: The "link" parameter is likely a string that represents a URL or file path to the
    location of the file that the function is trying to retrieve
    """
    logger = logging.getLogger("discord")
    item_id = None
    item_type = None
    file_list = []
    if source == "Spotify":
        dir_path = None
        item_type, item_id = spotify.parse_spotify_url(link)
        if item_type in ["album", "track", "playlist"] and item_id:
            logger.info(item_type)
            logger.info(item_id)
            logger.info("Spotify link provided")
            file_list = await asyncio.to_thread(
                spotify.fetch_tracks, SPOTIFY_CTRL, item_type, link
            )
            logger.info(file_list)
            directory_name = await asyncio.to_thread(
                spotify.get_item_name, SPOTIFY_CTRL, item_type, item_id
            )
            logger.info(directory_name)
            logger.info("Spotify scrape done")
            url_data = {"urls": []}
            url_dict = {}
            url_dict["save_path"] = Path(
                PurePath.joinpath(MUSIC_ROOT, Path(directory_name))
            )
            url_dict["save_path"].mkdir(parents=True, exist_ok=True)
            url_dict["songs"] = file_list
            url_data["urls"].append(url_dict.copy())
            file_name_f = youtube_download.default_filename
            logger.info("YT-DL")
            coro = asyncio.to_thread(
                youtube_download.download_songs,
                songs=url_data,
                output_dir=str(MUSIC_ROOT),
                format_str="bestaudio/best",
                skip_mp3=False,
                keep_playlist_order=False,
                no_overwrites=True,
                remove_trailing_tracks="no",
                use_sponsorblock="yes",
                file_name_f=file_name_f,
                multi_core=0,
                proxy="",
                YT_AUTH = YOUTUBE_AUTH
            )
            _ = await coro
            logger.info("YT-DL done")
            dir_path = (url_dict["save_path"].resolve()).as_posix()
            if platform == "win32":
                dir_path = dir_path.replace("/", "\\")
            return dir_path, file_list
        await ctx.send(
            "No se jaja chyba robisz, Ty byś spotifaja nie poznawszy jakby z krzaków wyskoczył i w dupę kopnął. Plejlista, kawałek albo album prosze."
        )
        logger.error("Wrong link provided spotify: %s", link)
    elif source == "Youtube":
        link_ok = False
        pat = r"^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$"
        if re.match(pat, link) and (
            re.match(".*youtube.*", link) or re.match(".*youtu.be.*", link)
        ):
            link_ok = True
        if link_ok:
            dir_path = ""
            file_list = []
            query = link
            sponsorblock_postprocessor = [
                {
                    "key": "SponsorBlock",
                    "categories": ["skip_non_music_sections"],
                },
                {
                    "key": "ModifyChapters",
                    "remove_sponsor_segments": ["music_offtopic"],
                    "force_keyframes": True,
                },
            ]
            # TODO: Make sponsorblock work
            sponsorblock_postprocessor = []
            if platform == "win32":
                dir_path = "G:\\Muzyka\\Youtube"
            else:
                dir_path = "/home/pi/RetroPie/mp3/Youtube"
            ydl_opts = {
                "username": YOUTUBE_AUTH[0],
                "password": YOUTUBE_AUTH[1],
                "proxy": "",
                "default_search": "ytsearch",
                "format": "bestaudio/best",
                "postprocessors": sponsorblock_postprocessor,
                "noplaylist": True,
                "no_color": False,
                "paths": {"home": dir_path},
            }
            mp3_postprocess_opts = {
                "key": "FFmpegExtractAudio",
                "preferredcodec": "mp3",
                "preferredquality": "192",
            }
            ydl_opts["postprocessors"].append(mp3_postprocess_opts.copy())
            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                try:
                    coro = asyncio.to_thread(ydl.download, [query])
                    _ = await coro
                except Exception as exce:  # pylint: disable=broad-exception-caught
                    logger.error(exce)
                    logger.info(
                        "Failed to download %s, make sure yt_dlp is up to date", link
                    )
            extract = re.search("v=(...........)[&,$]*", link)
            ident = extract.group(1)
            for item in Path.glob(Path(dir_path), "**/*.mp3"):
                file = item.as_posix()
                if platform == "win32":
                    file = file.replace("/", "\\")
                if re.match(".*" + ident + ".*", file):
                    file_list.append(file)
            return dir_path, file_list
        await ctx.send(
            "No se jaja chyba robisz, Ty byś jutuba nie poznawszy jakby z krzaków wyskoczył i w dupę kopnął. Jutuba to nie tuba którą sobie można gdzieś wsadzić."
        )
        logger.error("Wrong link provided youtube: %s", link)
        return "", None
    elif source == "Pornol":
        dir_path = ""
        file_list = []
        query = link
        sponsorblock_postprocessor = [
            {
                "key": "SponsorBlock",
                "categories": ["skip_non_music_sections"],
            },
            {
                "key": "ModifyChapters",
                "remove_sponsor_segments": ["music_offtopic"],
                "force_keyframes": True,
            },
        ]
        # TODO: Make sponsorblock work
        sponsorblock_postprocessor = []
        dir_path = "/home/pi/MediaShare/movies/porn"
        ydl_opts = {
            "postprocessors": sponsorblock_postprocessor,
            "paths": {"home": dir_path},
        }
        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
            try:
                coro = asyncio.to_thread(ydl.download, [query])
                _ = await coro
            except Exception as exce:  # pylint: disable=broad-exception-caught
                logger.error(exce)
                logger.info(
                    "Failed to download %s, make sure yt_dlp is up to date", link
                )
        file_list.append("wiadomo co wiadomo gdzie")
        return dir_path, file_list
 async def search_music(ctx, how_many=0, slowa_kluczowe=None):
    """
    Take in a context object and an optional integer parameter "how_many" and perform search
    operation on music library.
    :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
    represents the context in which the command was invoked, including information such as the message,
    the channel, the server, and the user who invoked the command
    :param how_many: how_many is a parameter that specifies the number of search results to be returned.
    It is an optional parameter with a default value of 0, which means that if no value is provided for
    how_many, the function will return all search results, defaults to 0 (optional)
    """
    # i sieć neuronową z możliwością wyrażenia opinii o dopasowaniu.
    logger = logging.getLogger("discord")
    if slowa_kluczowe:
        word_list = slowa_kluczowe
    else:
        word_list = ctx.message.content.split()
    logger.info("Wyszukuje")
    jrequest = {
        "lista_slow": word_list,
        "dlugosc_plejlisty": how_many,
        "UUID": str(uuid.uuid4()),
    }
    coroutine = asyncio.to_thread(
        requests.post,
        f"{FILE_SERVICE_ADDRESS}{GET_PLAYLIST}",
        json=jrequest,
        headers=SERVICE_HEADERS,
        timeout=360,
    )
    return_data = await coroutine
    if not return_data.status_code == 200:
        await ctx.send("Wołaj szefa - coś się wyjebało")
        return
    logger.info(return_data.json()["data"])
    return return_data.json()["data"]
@@ -1,212 +0,0 @@
 import asyncio
 import json
 import logging
 from datetime import datetime
 from typing import Optional
 import discord
 from discord.ext import commands
 from constants import ACCIDENT_LOG, DATA, ENCODING
 historia_fabryczki = DATA["fabryczka"]
 class OtherModule(commands.Cog):
    def __init__(self, bot, logger_name):
        self.bot = bot
        self.logger = logging.getLogger(logger_name)
    @commands.hybrid_command(
        name="przytul", description="Przytul kogoś - daj mention po komendzie :)"
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def przytul(self, ctx, arg: Optional[discord.Member] = None):
        """
        Generate a text about hugging mentioned user.
        :param ctx: ctx stands for "context" and is a required parameter in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command
        :param arg: arg is a parameter of the function "przytul" that expects a Discord member object. The
        parameter is optional, meaning that if no member object is provided, it will default to None
        :type arg: Optional[discord.Member]
        """
        async with ctx.typing():
            nieprzytulac = False
            for mention in ctx.message.mentions:
                for role in mention.roles:
                    if role.name == "NIEPRZYTULAĆ!":
                        nieprzytulac = True
            if arg and nieprzytulac:
                await ctx.send(
                    f"Żebym ja Ciebie nie przytulił {ctx.message.author.mention}"
                )
            elif arg:
                await ctx.send(
                    # trunk-ignore(codespell/misspelled)
                    f"Już dobrze.... Już dobrze... Ojej.. Biedactwo... :( *W ułamku sekundy {arg.mention} znajduje sie w duszącym uścisku. Żebra trzeszczą - kilka pęka. Pacnięcia po plecach grożą odbiciem nerek, a głaskanie po głowie powoduje wstrząs mózgu*"
                )
            else:
                await ctx.send(
                    "Kogo mam przytulić? *Wyłamuje kostki i przeciąga się - jego 200 kilowa sylwetka złożona z samych mięśni świadczy o tym że jest gotowy*"
                )
    @commands.hybrid_command(name="fabryczka", description="Historia fabryczki")
    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
    async def fabryczka(self, ctx):
        """
        Send a general description of "fabryczkagate" to channel.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. The context object provides a way to
        interact with the Discord
        """
        await ctx.send(historia_fabryczki)
    @commands.hybrid_command(
        name="set_logging_level",
        description="Nie intererer bo kici kici",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Legenda', 'Jarl', 'Bartender')
    async def set_logging_level(self,ctx):
        if "DEBUG" in ctx.message.content:
            logger = logging.getLogger("discord")
            logger.setLevel(logging.DEBUG)
        elif "INFO" in ctx.message.content:
            logger = logging.getLogger("discord")
            logger.setLevel(logging.INFO)
        else:
            await ctx.send("Weź się kurwa zdecyduj co ?")
    @commands.hybrid_command(
        name="reset_the_clock",
        description="Resetowanie zegara - dostępne wyłącznie dla Hammera",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
    async def reset_the_clock(self, ctx):
        """
        Reset the clock on "accidents" in Hammer Fortress adding a new one.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. This parameter is required in all
        Discord.py commands
        """
        hammer = False
        for role in ctx.message.author.roles:
            if role.name == "Bartender":
                hammer = True
        if hammer:
            with open(ACCIDENT_LOG, "r+", encoding=ENCODING) as new_file_accidents:
                # First we load existing data into a dict.
                file_data = json.load(new_file_accidents)
                czas = datetime.strptime(file_data[-1][1], "%Y-%m-%d %H:%M:%S.%f")
                opis = ctx.message.content[16:]
                accident = accident = [opis, f"{datetime.now()}"]
                file_data.append(accident)
                new_file_accidents.seek(0)
                # convert back to json.
                json.dump(file_data, new_file_accidents, indent=4)
                await ctx.send(
                    f"Komenda mierząca incydenty w Eldritch AbsinthHammerTimeSpaceContinuum.\n RESET THE CLOCK. Od ostatniego incydentu w chacie Hammera minęło {czas}. No ale teraz się odpierdoliło: {opis}"
                )
        else:
            await ctx.send(
                f"Komenda mierząca incydenty w Eldritch AbsinthHammerTimeSpaceContinuum.\n Gdzie z łapami do zegara? {self.bot.get_user(346956223645614080).mention} coś albo się komuś stało albo zaraz się stanie jak będzie zegar tykał...."
            )
    @commands.hybrid_command(
        name="chata_hammera",
        description="Czas od ostatniego incydentu w AbsinthHammerTimeSpaceContinuum",
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def chata_hammera(self, ctx):
        """
        Send measured time from last incident in Hammer Fortress to the chat.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        contains information about the context in which the command was invoked, such as the message, the
        channel, the server, and the user who invoked the command. This information can be used to perform
        various actions, such
        """
        with open(ACCIDENT_LOG, "r+", encoding=ENCODING) as new_file:
            # First we load existing data into a dict.
            file_data = json.load(new_file)
            opis = file_data[-1][0]
            czas = datetime.strptime(file_data[-1][1], "%Y-%m-%d %H:%M:%S.%f")
            await ctx.send(
                f"Komenda mierząca incydenty w Eldritch AbsinthHammerTimeSpaceContinuum.\n Od ostatniego incydentu w chacie Hammera minęło {datetime.now() - czas}. Incydent to: {opis}"
            )
    @commands.hybrid_command(
        name="historia_incydentow_u_hammera",
        description="Wyswietla liste incydentów które miały miejsce w AbsinthHammerTimeSpaceContinuum.",
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def historia_incydentow_u_hammera(self, ctx):
        """
        Send a list of incidents in Hammer Fortress to the chat.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        contains information about the context in which the command was invoked, such as the message, the
        channel, the server, and the user who invoked the command. This information can be used to perform
        various actions, such
        """
        with open(ACCIDENT_LOG, "r+", encoding=ENCODING) as new_file_accidents:
            # First we load existing data into a dict.
            file_data = json.load(new_file_accidents)
            return_data = "Komenda mierząca incydenty w Eldritch AbsinthHammerTimeSpaceContinuum.\n Historia zarejestrownych incydentów u Hammera:\n"
            index = 1
            for iter_data in file_data:
                opis = iter_data[0]
                czas = datetime.strptime(iter_data[1], "%Y-%m-%d %H:%M:%S.%f")
                add_data = f"{index}. Opis: {opis} Data: {czas}"
                return_data = return_data + add_data + "\n"
                index += 1
            await ctx.send(return_data)
    @commands.hybrid_command(
        name="radio_hardkor",
        description="Włącza radio Conjurer na kanale #nocna-zmiana.",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def radio_hardkor(self, ctx):
        """
        Plays the radio hardkor stream in the voice channel.
        Args:
            ctx: The context object representing the invocation context.
        Returns:
            None
        """
        self.logger.info("Press play on radio hardkor")
        async with ctx.typing():
            global MUZYKA  # pylint: disable=global-variable-not-assigned
            MUZYKA["ctx"] = ctx
            if not self.bot.voice_clients:
                await self.connect(ctx=ctx)
                voice_client = self.bot.voice_clients[0]
                voice_client.play(
                    discord.PCMVolumeTransformer(
                        discord.FFmpegPCMAudio("http://95.175.16.246:666/mp3-stream"),
                        volume=0.3,
                    )
                )
                self.logger.info("Press play on radio completed")
            else:
                self.logger.error("Already playing")
            await asyncio.sleep(12)
            self.check_music.start()
 async def setup(bot):
    logger = logging.getLogger("discord")
    await bot.add_cog(OtherModule(bot, "discord"))
    logger.info("Loading kitchen sink module done")
@@ -1,118 +0,0 @@
 import logging
 # define an asynchronous generator
 async def async_iterator_generator(range_of_iterable):
    """
    Generate asynchronouse iterator.
    This is an incomplete function definition for an asynchronous iterator generator that takes a range
    of iterable as input.
    :param range_of_iterable: The parameter `range_of_iterable` is likely a range or iterable object
    that the async iterator generator will iterate over asynchronously. It could be a list, tuple, set,
    or any other iterable object. The generator will yield each item in the iterable object
    asynchronously, allowing other code to run in between
    """
    # normal loop
    for i in range_of_iterable:
        # pylint: disable=pointless-string-statement
        # yield the result
        yield i
        """
        Alternatywna wersja przerobienia fora na asynchroniczny.
        # traverse the iterable of awaitables
        for item in coros:
            # await and get the result from the awaitable
            result = await item
            # report the results
            print(result)
        """
 async def remove_characters(string, character):
    """
    The `remove_characters` function removes all occurrences of a specified character from a given
    string.
    :param string: The string parameter is the input string from which characters will be removed
    :param character: The character parameter is the character that you want to remove from the string
    :return: a new string where all occurrences of the specified character have been removed.
    """
    return string.replace(character, "")
 async def max_weight(lista):
    """
    Take a list of weights and return the maximum weight.
    :param lista: It seems like the parameter `lista` is a list of items, possibly representing weights.
    The function name `max_weight` suggests that the function is intended to find the maximum weight
    from the list. However, without more context or information about the problem, it's difficult to say
    for sure what the
    """
    maximum_weight = 0
    for iterator in lista:
        if iterator[0] > maximum_weight:
            maximum_weight = iterator[0]
    return maximum_weight
 async def get_stats(client, ctx, history_limit):
    """
    The `get_stats` function retrieves the message history of a specific channel and counts the
    frequency of each word in the messages.
    :param ctx: The `ctx` parameter is an object that represents the context of the command being
    executed. It contains information such as the message, the author, the server, and other relevant
    details
    :param history_limit: The `history_limit` parameter is the maximum number of messages to retrieve
    from the channel history. It determines how far back in time the statistics will be calculated
    :return: The function `get_stats` returns a dictionary `stats` that contains the frequency count of
    words found in the messages from the specified channel.
    """
    channel_id = 1062047367337095268
    async with ctx.typing():
        stats = {}
        channel = client.get_channel(channel_id)
        messages = [message async for message in channel.history(limit=history_limit)]
        # traverse the iterable of awaitables
        for message in messages:
            # await and get the result from the awaitable
            result = message.content
            words = result.split()
            for word in words:
                if word in stats:
                    stats[word] += 1
                else:
                    stats[word] = 1
        for name, how_many in stats.items():
            yield name, how_many
 async def discord_friendly_reply(ctx, message_content, file=None):
    logger = logging.getLogger("discord")
    if len(message_content) < 999:
        logger.info("Answer reply - message below 999")
        await ctx.reply(message_content)
    else:
        logger.info("Answer reply - message above 999")
        while len(message_content) > 0:
            logger.info("Mesaage content: %s", message_content[:999])
            await ctx.reply(message_content[:999])
            message_content = message_content[999:]
    if file:
        await ctx.reply("Attachment:", file=file)
 async def discord_friendly_send(ctx, message_content, file=None):
    logger = logging.getLogger("discord")
    if len(message_content) < 999:
        logger.info("Answer send - message below 999")
        await ctx.send(message_content)
    else:
        logger.info("Answer send - message above 999")
        while len(message_content) > 0:
            logger.info("Mesaage content: %s", message_content[:999])
            await ctx.send(message_content[:999])
            message_content = message_content[999:]
    if file:
        await ctx.reply("Attachment:", file=file)
@@ -1,20 +0,0 @@
 /home/pi/RetroPie/mp3/Muzyka/2011/Hallman/Hallman - 7 Bram/Niezłomność/Twardzi jak Stal/03-Forteca-1942.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/09. Świty Zmartwychwstania.mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/Horytnica Czas Patriotów/Horytnica - Promo track CD 2011 Nie musimy umiera.mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/08-Schmaletz-REWOLUCYJNA_NSZ(1).mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/schmaletz_-_nie_ma_fajnych_lasek_na_prawicy.mp3
 /home/pi/RetroPie/mp3/Youtube/ADU - Lecimy ze Smoleńska z powrotem [f3CVfG4pV8M].mp3
 /home/pi/RetroPie/mp3/2022 Nov-Dec/Anahata - Winged Hussars - Cover.m4a
 /home/pi/RetroPie/mp3/2022 Nov-Dec/Sabaton - 40#1 - Live, at Woodstock Festival.m4a
 /home/pi/RetroPie/mp3/2022 Nov-Dec/Sabaton - Uprising - Live, at Woodstock Festival.m4a
 /home/pi/RetroPie/mp3/2022 Nov-Dec/Sabaton - Inmate 4859.m4a
 /home/pi/RetroPie/mp3/2022 Nov-Dec/Sabaton - Winged Hussars.m4a
 /home/pi/RetroPie/mp3/Youtube/ADU Ada Karczmarczyk - Hej husarzu! ⧸ NIE_PODLE_głości dzień [SReTynvd6ek].mp3
 /home/pi/RetroPie/mp3/2023 Aug-Oct/Sabadu - A Very Polish Christmas.mp3
 /home/pi/RetroPie/mp3/2023 Aug-Oct/Sabadu - Mighty Polish Tank.mp3
 /home/pi/RetroPie/mp3/Youtube/ADU - Nie chcę w lewo, nie chcę w prawo [J3Ok-KcbQ80].mp3
 /home/pi/RetroPie/mp3/2022 Nov-Dec/Sabaton - 40#1 - World War Tour 2010.m4a
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/01. Prolog.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/02. Honor Legionisty.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/07. Już Nie Musimy Umierać.mp3
@@ -1,46 +0,0 @@
 /home/pi/RetroPie/mp3/2022 Nov-Dec/Sabaton - 40#1 - World War Tour 2010.m4a
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/08-Schmaletz-REWOLUCYJNA_NSZ(1).mp3
 /home/pi/RetroPie/mp3/Youtube/ADU feat MATEJKO - Nie strzelam do zdrajców oczami [PGL6Q9G4_JM].mp3
 /home/pi/RetroPie/mp3/Youtube/ADU - Lecimy ze Smoleńska z powrotem [f3CVfG4pV8M].mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/Horytnica Czas Patriotów/Horytnica - Promo track CD 2011 Nie musimy umiera.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/01. Prolog.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/02. Honor Legionisty.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/03. Kraj Zdradzony.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/04. Mały Powstaniec.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/05. Lisowczycy.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/06. Śląski Rycerz.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/07. Już Nie Musimy Umierać.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/08. Sierp I Młot.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/09. Świty Zmartwychwstania.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/10. Katyńskie Łzy.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/11. Kochana Ma Polska.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/12. Słowiańska Armia Pracy.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/13. Pamięć I Duma.mp3
 /home/pi/RetroPie/mp3/Muzyka/2012/Głos Patriotów (2011) (Wirrrus)/14. Epilog.mp3
 /home/pi/RetroPie/mp3/2022 Nov-Dec/Anahata - Winged Hussars - Cover.m4a
 /home/pi/RetroPie/mp3/Youtube/ADU - Nie chcę w lewo, nie chcę w prawo [J3Ok-KcbQ80].mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/Hallman/Hallman - 7 Bram/Niezłomność/Twardzi jak Stal/03-Forteca-1942.mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/Forteca - Bagnet na broń.mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/02-2 Forteca.mp3
 /home/pi/RetroPie/mp3/Muzyka/2013/SABATON-Metalus Hammerus Rex (djdariush)/40-1.mp3
 /home/pi/RetroPie/mp3/Muzyka/2014/Sabaton - Heroes (Deluxe Earbook Edition) 2014/CD1/04. Inmate 4859_[plixid.com].mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/FORTECA  - 1942.mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/FORTECA - Apel poległych.mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/FORTECA - BEZIMIEŃCOM.mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/FORTECA - DZIŚ IDE WALCZYĆ MAMO.mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/FORTECA - GNIEW.mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/FORTECA - KATYŃ.mp3
 /home/pi/RetroPie/mp3/Muzyka/2010/Sabaton -2010- Coat Of Arms/03- Uprising.mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/FORTECA - ORZEŁ BIAŁY.mp3
 /home/pi/RetroPie/mp3/2023 Aug-Oct/Sabadu - Mighty Polish Tank.mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/Dj. Celownik & Hallmann - O jau mano mielas [zapiska.pl].mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/Dj.Celownik & Hallmann - Duma o Zakrzewskim [zapiska.pl].mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/Dj.Celownik & Hallmann - Na lipe slowianska [zapiska.pl].mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/Dj.Celownik & Hallmann - Piesn Legijonu Litewskiego [zapiska.pl].mp3
 /home/pi/RetroPie/mp3/Muzyka/2011/muza patriotyczna/08-Schmaletz-REWOLUCYJNA_NSZ(1).mp3
 /home/pi/RetroPie/mp3/2022 Nov-Dec/Sabaton - 40#1 - Live, at Woodstock Festival.m4a
 /home/pi/RetroPie/mp3/2022 Nov-Dec/Sabaton - Uprising - Live, at Woodstock Festival.m4a
 /home/pi/RetroPie/mp3/2022 Nov-Dec/Sabaton - Inmate 4859.m4a
 /home/pi/RetroPie/mp3/2022 Nov-Dec/Sabaton - Winged Hussars.m4a
 /home/pi/RetroPie/mp3/Youtube/ADU Ada Karczmarczyk - Hej husarzu! ⧸ NIE_PODLE_głości dzień [SReTynvd6ek].mp3
 /home/pi/RetroPie/mp3/2023 Aug-Oct/Sabadu - A Very Polish Christmas.mp3
@@ -1,11 +0,0 @@
 [Unit]
 Description=PulseAudio System-wide Daemon
 After=sound.target network.target
 [Service]
 Type=simple
 ExecStart=/usr/bin/pulseaudio --system --disallow-exit --disallow-module-loading=0 --daemonize=no
 Restart=always
 [Install]
 WantedBy=multi-user.target
@@ -1,222 +0,0 @@
 import logging
 from discord.ext import commands
 import discord
 # trunk-ignore(bandit/B404)
 import subprocess
 import requests
 import uuid
 import asyncio
 from datetime import datetime
 from constants import (
    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):
        self.bot = bot
        self.logger = logging.getLogger(logger_name)
    @commands.hybrid_command(
        name="skip_track",
        description="Przeskocz kawałek w radiu",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
    async def skip_track(self, ctx):
        async with ctx.typing():
            allowed = False
            for role in ctx.author.roles:
                if role.name in ("Thane", "Jarl"):
                    allowed = True
            if not allowed:
                await ctx.send("Łapy precz od radia")
            else:
                coroutine = asyncio.to_thread(
                    requests.get,
                    f"{RADIO_HARBOR_ADDRESS}{SKIP_TRACK}",
                    timeout=360,
                )
                result = await coroutine
                self.logger.info("Done %s", result)
                await ctx.send("Zrobione szefie!")
    @commands.hybrid_command(
        name="zrestartuj_radio",
        description="Komenda ktora uruchamia radio ponownie jakby się zawiesiło",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
    async def zrestartuj_radio(self, ctx):
        async with ctx.typing():
            allowed = False
            for role in ctx.author.roles:
                if role.name in ("Thane", "Jarl"):
                    allowed = True
            if not allowed:
                await ctx.send("Łapy precz od radia")
            else:
                retcode = subprocess.run(
                    "/home/pi/Conjurer/restart_radio.sh",
                    # trunk-ignore(bandit/B603)
                    shell=False,
                    check=False,
                    capture_output=True,
                )
                self.logger.info("Wynik: %s", retcode)
    @commands.hybrid_command(
        name="dodaj_do_ulubionych",
        description="Dodaje do listy ulubionych w radiu",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
    async def dodaj_do_ulubionych(self, ctx):
        """
        Generate a playlist in queue. First word in this command shall be int defining length of the playlist.
        Rest of the line are search terms.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. This parameter is required in all
        Discord.py commands
        """
        async with ctx.typing():
            self.logger.info("Zaczynam szukać timestamp %s", datetime.now())
            dlugosc_playlisty = ctx.message.content.split()[1]
            word_list = ctx.message.content.split()
            jrequest = {
                "lista_slow": word_list,
                "dlugosc_plejlisty": dlugosc_playlisty,
                "UUID": str(uuid.uuid4()),
            }
            coroutine = asyncio.to_thread(
                requests.post,
                f"{FILE_SERVICE_ADDRESS}{ADD_TO_PRIO_PLAYLIST}",
                json=jrequest,
                headers=SERVICE_HEADERS,
                timeout=360,
            )
            result = await coroutine
            self.logger.info("Done %s", result)
            await ctx.send("Zrobione szefie!")
    @commands.hybrid_command(
        name="ja_chciol",
        description="Dodaje do listy ulubionych w radiu",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def request_radio(self, ctx):
        """
        Generate a playlist in queue. First word in this command shall be int defining length of the playlist.
        Rest of the line are search terms.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. This parameter is required in all
        Discord.py commands
        """
        async with ctx.typing():
            self.logger.info("Zaczynam szukać timestamp %s", datetime.now())
            word_list = ctx.message.content.split()
            jrequest = {
                "lista_slow": word_list,
                "UUID": str(uuid.uuid4()),
            }
            coroutine = asyncio.to_thread(
                requests.post,
                f"{FILE_SERVICE_ADDRESS}{REQUEST_MUSIC}",
                json=jrequest,
                headers=SERVICE_HEADERS,
                timeout=360,
            )
            result = await coroutine
            self.logger.info("Done %s", result)
            await ctx.send("Zrobione szefie!")
    @commands.hybrid_command(
        name="stworz_audycje",
        description="Dodaje do listy ulubionych w radiu",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
    async def stworz_audycje(self, ctx):
        """
        Generate a playlist in queue. First word in this command shall be int defining length of the playlist.
        Rest of the line are search terms.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. This parameter is required in all
        Discord.py commands
        """
        async with ctx.typing():
            self.logger.info("Zaczynam szukać timestamp %s", datetime.now())
            dlugosc_playlisty = ctx.message.content.split()[1]
            word_list = ctx.message.content.split()
            jrequest = {
                "lista_slow": word_list,
                "dlugosc_plejlisty": dlugosc_playlisty,
                "UUID": str(uuid.uuid4()),
            }
            coroutine = asyncio.to_thread(
                requests.post,
                f"{FILE_SERVICE_ADDRESS}{CREATE_PRIO_PLAYLIST}",
                json=jrequest,
                headers=SERVICE_HEADERS,
                timeout=360,
            )
            result = await coroutine
            self.logger.info("Done %s", result)
            await ctx.send("Zrobione szefie!")
    @commands.hybrid_command(
        name="wyczysc_ulubione",
        description="Czysci liste ulubionych w radiu",
        guild=discord.Object(id=664789470779932693),
    )
    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
    async def wyczysc_ulubione(self, ctx):
        """
        Generate a playlist in queue. First word in this command shall be int defining length of the playlist.
        Rest of the line are search terms.
        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
        represents the context in which the command was invoked, including information such as the message,
        the channel, the server, and the user who invoked the command. This parameter is required in all
        Discord.py commands
        """
        async with ctx.typing():
            coroutine = asyncio.to_thread(
                requests.get,
                f"{FILE_SERVICE_ADDRESS}{CLEAR_PRIO}",
                headers=SERVICE_HEADERS,
                timeout=360,
            )
            result = await coroutine
            self.logger.info("Done %s", result)
            await ctx.send("Zrobione szefie!")
 async def setup(bot):
    logger = logging.getLogger("discord")
    await bot.add_cog(RadioModule(bot, "discord"))
    logger.info("Loading raadio commands module done")
@@ -1,21 +0,0 @@
 setuptools
 discord
 yaach
 t_dlp
 spotify_dl
 spotipy
 openai
 eyed3
 numpy
 pdf2image
 PyPDF2
 requests
 spotipy
 tiktoken
 PyNaCl
 flask[async]
 waitress
 clickupython
 assemblyai[extras]
 SpeechRecognition
 git+https://github.com/imayhaveborkedit/discord-ext-voice-recvO
@@ -1,4 +1,3 @@
 setuptools
 discord
 yt_dlp
 spotify_dl
@@ -12,10 +11,5 @@ requests
 spotipy
 tiktoken
 PyNaCl
-flask[async]
+flask
 PyMuPDF
 waitress
 clickupython
 assemblyai[extras]
 SpeechRecognition
 git+https://github.com/imayhaveborkedit/discord-ext-voice-recv
@@ -1,3 +0,0 @@
 sshpass -p raspberry ssh pi@192.168.1.15 << 'ENDSSH'
 sudo reboot
 ENDSSH
@@ -1,3 +0,0 @@
 name,type,locations,ap_head,ap_body,ap_larm,ap_rarm,ap_lleg,ap_rleg,max_ag,traits,weight,availability,source,notes
 Flak Vest,armor,"Body",0,4,0,0,0,0,,Flak,7,Common,"DH2 CRB","PRZYKŁAD – ZASTĄP"
 Power Armour (Astartes),armor,"All",8,10,8,8,9,9,,Environmental; Auto-senses,100,"Very Rare","DW CRB","PRZYKŁAD – ZASTĄP"
@@ -1,60 +0,0 @@
 // DH2 Attack Test v2 — presets: Aim/Range/Fire + Size/Light/Cover
 const actor = canvas.tokens.controlled[0]?.actor ?? game.user.character;
 if (!actor) return ui.notifications.warn("Zaznacz token albo przypisz postać.");
 new Dialog({
  title: "🎯 Attack Test (WS/BS)",
  content: `
  <form>
    <div class="form-group"><label>Base Target (WS/BS)</label><input name="base" type="number" value="40"/></div>
    <div class="form-group"><label>Aim</label>
      <select name="aim"><option value="0">None</option><option value="10">Half (+10)</option><option value="20">Full (+20)</option></select></div>
    <div class="form-group"><label>Range</label>
      <select name="range">
        <option value="0">Standard</option>
        <option value="30">Point Blank (+30)</option>
        <option value="10">Short (+10)</option>
        <option value="-10">Long (-10)</option>
        <option value="-30">Extreme (-30)</option>
      </select></div>
    <div class="form-group"><label>Fire / Attack</label>
      <select name="stance">
        <option value="0">Standard / Single</option>
        <option value="10">Semi (+10)</option>
        <option value="-10">Full Auto (-10)</option>
        <option value="30">All Out (Melee +30)</option>
      </select></div>
    <div class="form-group"><label>Target Size</label>
      <select name="size">
        <option value="0">Average</option>
        <option value="10">Hulking (+10)</option>
        <option value="20">Enormous (+20)</option>
        <option value="30">Massive (+30)</option>
        <option value="-10">Puny (-10)</option>
      </select></div>
    <div class="form-group"><label>Lighting</label>
      <select name="light"><option value="0">Normal</option><option value="10">Good (+10)</option><option value="-10">Poor (-10)</option></select></div>
    <div class="form-group"><label>Cover</label>
      <select name="cover"><option value="0">None</option><option value="-10">Light (-10)</option><option value="-20">Heavy (-20)</option></select></div>
    <div class="form-group"><label>Other Modifiers</label><input name="mod" type="number" value="0"/></div>
  </form>`,
  buttons: {
    roll: {
      label: "Roll",
      callback: async (html) => {
        const get = n => Number(html.find(`[name="${n}"]`).val());
        const base = get("base");
        const total = base + get("aim") + get("range") + get("stance") + get("size") + get("light") + get("cover") + get("mod");
        const r = await(new Roll("1d100")).roll({async:true});
        const ok = r.total <= total;
        const margin = Math.abs(total - r.total);
        const dox = ok ? 1 + Math.floor(margin/10) : Math.floor(margin/10);
        const table = `
        <table style="width:100%;border-collapse:collapse">
          <tr><td><b>Target</b></td><td>${total}</td><td><b>Roll</b></td><td>${r.total}</td></tr>
          <tr><td><b>Result</b></td><td colspan="3">${ok?'<span style="color:green">SUCCESS</span>':'<span style="color:red">FAIL</span>'} — ${ok?dox+' DoS':dox+' DoF'}</td></tr>
        </table>`;
        r.toMessage({speaker: ChatMessage.getSpeaker({actor}), flavor: `🎯 <b>Attack Test</b><br/>${table}`});
      }
    }
  }
 }).render(true);
@@ -1,6 +0,0 @@
 Roll,Result
 1,Energy/Head — wpis 1
 2,Energy/Head — wpis 2
 3,Energy/Head — wpis 3
 4,Energy/Head — wpis 4
 5,Energy/Head — wpis 5
@@ -1,50 +0,0 @@
 // 🧠 Focus Power (DH2) — WP test + Phenomena/Perils with mode presets
 const actor = canvas.tokens.controlled[0]?.actor ?? game.user.character;
 if (!actor) return ui.notifications.warn("Zaznacz token.");
 new Dialog({
  title: "🧠 Focus Power",
  content: `
  <form>
    <div class="form-group"><label>Willpower (target)</label><input name="wp" type="number" value="40"/></div>
    <div class="form-group"><label>Psychic Rating (PR)</label><input name="pr" type="number" value="3"/></div>
    <div class="form-group"><label>Mode</label>
      <select name="mode"><option value="fettered">Fettered (no PP; PR/2)</option><option value="unfettered" selected>Unfettered (PP on doubles)</option><option value="push">Push (always PP; +PR)</option></select></div>
    <div class="form-group"><label>Power difficulty/gear/etc. (flat mod)</label><input name="flat" type="number" value="0"/></div>
    <div class="form-group"><label>Perils threshold</label><input name="thr" type="number" value="75"/></div>
  </form>`,
  buttons: {
    roll: { label: "Roll", callback: async html => {
      const wp = Number(html.find('[name="wp"]').val());
      const pr = Number(html.find('[name="pr"]').val());
      const mode = html.find('[name="mode"]').val();
      const flat = Number(html.find('[name="flat"]').val());
      const thr = Number(html.find('[name="thr"]').val());
      let effPR = pr, ppmod = 0, ppAlways = false, note = "";
      if (mode==="fettered"){ effPR = Math.max(1, Math.floor(pr/2)); note="(Fettered: PR/2, brak Phenomena)"; }
      if (mode==="push"){ effPR = pr+3; ppmod=10; ppAlways = true; note="(Push: +3 PR, Phenomena zawsze, +10)"; }
      const target = wp + flat;
      const roll = await (new Roll("1d100")).roll({async:true});
      const ok = roll.total <= target;
      const dos = ok ? 1 + Math.floor((target - roll.total)/10) : Math.floor((roll.total - target)/10);
      const doubles = (roll.total%11===0) || (roll.total===100);
      const info = `<table style="width:100%;border-collapse:collapse">
        <tr><td><b>Target</b></td><td>${target}</td><td><b>Roll</b></td><td>${roll.total}</td></tr>
        <tr><td><b>Result</b></td><td colspan="3">${ok?'<span style="color:green">SUCCESS</span>':'<span style="color:red">FAIL</span>'} — ${ok?dos+' DoS':dos+' DoF'} ${doubles?' — <b>DOUBLES</b>':''}</td></tr>
        <tr><td><b>Eff. PR</b></td><td>${effPR}</td><td><b>Range hint</b></td><td>${effPR*10} m (jeśli moc tak działa)</td></tr>
      </table>`;
      roll.toMessage({speaker: ChatMessage.getSpeaker({actor}), flavor:`🧠 <b>Focus Power</b> ${note}<br/>${info}`});
      const needPP = (mode==="unfettered" && doubles) || (mode==="push") ;
      if (needPP){
        const tbl = game.tables.getName("Psychic Phenomena");
        if (tbl){
          const r = await (new Roll(`1d100 + ${ppmod}`)).roll({async:true});
          await tbl.draw({displayResults:true, roll:r});
          if (r.total >= thr){
            const per = game.tables.getName("Perils of the Warp");
            if (per) await per.draw({displayResults:true});
          }
        } else ChatMessage.create({content:"Utwórz RollTable: <b>Psychic Phenomena</b> (+ <b>Perils of the Warp</b>)"});
      }
    }}
  }
 }).render(true);
@@ -1,22 +0,0 @@
 // 🎯 Hit Location (DH mapping by reversed roll)
 new Dialog({
    title:"🎯 Hit Location",
    content:`<form>
      <div class="form-group"><label>Attack d100 roll</label><input name="roll" type="number" value="37"/></div>
    </form>`,
    buttons:{
      go:{label:"Resolve", callback: html=>{
        const n = Math.max(1, Math.min(100, Number(html.find('[name="roll"]').val())));
        const rev = Number(String(n).padStart(2,"0").split("").reverse().join(""));
        let loc = "";
        if (rev<=10) loc="Head";
        else if (rev<=20) loc="Right Arm";
        else if (rev<=30) loc="Left Arm";
        else if (rev<=70) loc="Body";
        else if (rev<=85) loc="Right Leg";
        else loc="Left Leg";
        ChatMessage.create({content:`🎯 <b>Hit Location</b>: roll ${n} → reversed ${rev} → <b>${loc}</b>`});
      }}
    }
  }).render(true);
@@ -1,6 +0,0 @@
 const text=`<b>House Rules — DH2 chassis</b><br/>
 • Unnatural mapowanie: dawne ×2 bonus → Unnatural (+X) tak, by SB/TB odzwierciedlały linię źródłową.<br/>
 • Pancerz Astartes: zachowaj AP; zużycie zasilania jako +1 Fatigue co X scen zamiast liczenia minut.<br/>
 • Aptitudes: archetypy z RT/DW/BC mają przypisane 2–3 Aptitudes DH2 dla kosztów XP.<br/>
 • Psy: testy i PR z DH2 dla wszystkich; GK posiada Aegis Discipline (1×/scena reroll Perils) + 1–2 signature powers z DW.<br/>
 • RT Acquisition → DH2 Influence z modyfikatorami kontekstowymi (teatr działań, mandat Inkwizycji, czas).`;ChatMessage.create({content:text});
@@ -1,11 +0,0 @@
 // 🚦 Initiative for selected tokens (1d10 + AG Bonus prompt)
 if (!canvas.tokens.controlled.length) return ui.notifications.warn("Zaznacz co najmniej jeden token.");
 const combat = game.combat ?? await Combat.implementation.create({});
 for (const t of canvas.tokens.controlled){
  if (!combat.combatants.some(c=>c.tokenId===t.id)) await combat.createEmbeddedDocuments("Combatant",[ {tokenId:t.id, sceneId: canvas.scene.id, hidden:false} ]);
  const ag = Number(await Dialog.prompt({title:`AG Bonus for ${t.name}`, content:`<input type="number" value="4">`, label:"OK"}));
  const r = await (new Roll(`1d10 + ${ag}`)).roll({async:true});
  await combat.setInitiative(combat.combatants.find(c=>c.tokenId===t.id).id, r.total);
  r.toMessage({flavor:`🚦 <b>Initiative</b> — ${t.name}: ${r.total}`});
 }
 ui.notifications.info("Inicjatywy ustawione.");
@@ -1,21 +0,0 @@
 Roll,Result
 1-5,Perils 1–5 — WPISZ
 6-10,Perils 6–10 — WPISZ
 11-15,Perils 11–15 — WPISZ
 16-20,Perils 16–20 — WPISZ
 21-25,Perils 21–25 — WPISZ
 26-30,Perils 26–30 — WPISZ
 31-35,Perils 31–35 — WPISZ
 36-40,Perils 36–40 — WPISZ
 41-45,Perils 41–45 — WPISZ
 46-50,Perils 46–50 — WPISZ
 51-55,Perils 51–55 — WPISZ
 56-60,Perils 56–60 — WPISZ
 61-65,Perils 61–65 — WPISZ
 66-70,Perils 66–70 — WPISZ
 71-75,Perils 71–75 — WPISZ
 76-80,Perils 76–80 — WPISZ
 81-85,Perils 81–85 — WPISZ
 86-90,Perils 86–90 — WPISZ
 91-95,Perils 91–95 — WPISZ
 96-100,Perils 96–100 — WPISZ
@@ -1,3 +0,0 @@
 name,type,discipline,action,test,range,sustained,effect,source,notes
 Smite,power,Biomancy,Half,"WP Challenging (+0)","PR*10m",No,"1d10+PR E; Tearing","DH2 CRB","PRZYKŁAD – ZASTĄP"
 Foreboding,power,Divination,Reaction,"Per Difficult (-10)","Self",No,"Use as Evasion; DoS rules","DH2 CRB","PRZYKŁAD – ZASTĄP"
@@ -1,21 +0,0 @@
 Roll,Result
 1-5,PP 1–5 — WPISZ
 6-10,PP 6–10 — WPISZ
 11-15,PP 11–15 — WPISZ
 16-20,PP 16–20 — WPISZ
 21-25,PP 21–25 — WPISZ
 26-30,PP 26–30 — WPISZ
 31-35,PP 31–35 — WPISZ
 36-40,PP 36–40 — WPISZ
 41-45,PP 41–45 — WPISZ
 46-50,PP 46–50 — WPISZ
 51-55,PP 51–55 — WPISZ
 56-60,PP 56–60 — WPISZ
 61-65,PP 61–65 — WPISZ
 66-70,PP 66–70 — WPISZ
 71-75,PP 71–75 — WPISZ
 76-80,PP 76–80 — WPISZ
 81-85,PP 81–85 — WPISZ
 86-90,PP 86–90 — WPISZ
 91-95,PP 91–95 — WPISZ
 96-100,PP 96–100 — WPISZ
@@ -1,28 +0,0 @@
 // 🩹 Toggle conditions on selected tokens (Foundry v13)
 const choices = [
    {id:"fatigued", label:"Fatigued"},
    {id:"stunned",  label:"Stunned"},
    {id:"prone",    label:"Prone"},
    {id:"frightened", label:"Frightened (Fear)"}
  ];
  const opts = choices.map(c=>`<label><input type="checkbox" name="c" value="${c.id}"> ${c.label}</label>`).join("<br/>");
  new Dialog({
    title:"🩹 Conditions",
    content:`<form>${opts}<div class="form-group"><label>Mode</label>
    <select name="mode"><option value="toggle">Toggle</option><option value="on">Apply</option><option value="off">Remove</option></select></div></form>`,
    buttons:{
      go:{label:"Apply",callback: html=>{
        const ids = Array.from(html.find('input[name="c"]:checked')).map(e=>e.value);
        const mode = html.find('[name="mode"]').val();
        const getEf = id => CONFIG.statusEffects.find(e=>e.id===id) ?? {id};
        canvas.tokens.controlled.forEach(t=>{
          ids.forEach(id=>{
            if (mode==="toggle") t.toggleEffect(getEf(id));
            else if (mode==="on")  t.actor?.effects?.some(e=>e.getFlag("core","statusId")===id) ? null : t.toggleEffect(getEf(id));
            else if (mode==="off") t.actor?.effects?.some(e=>e.getFlag("core","statusId")===id) ? t.toggleEffect(getEf(id)) : null;
          });
        });
      }}
    }
  }).render(true);
@@ -1,38 +0,0 @@
 // 💥 Quick Damage — supports Tearing, Proven(X), Primitive(X), flat mod
 new Dialog({
    title:"💥 Damage Roller",
    content: `
    <form>
      <div class="form-group"><label>Flat modifier (e.g., +3)</label><input name="mod" type="number" value="0"/></div>
      <div class="form-group"><label>Traits</label>
        <label><input type="checkbox" name="tear"> Tearing</label>
        <label><input type="checkbox" name="prov"> Proven</label>
        <input name="provV" type="number" value="0" style="width:60px" placeholder="X"/>
        <label><input type="checkbox" name="prim"> Primitive</label>
        <input name="primV" type="number" value="0" style="width:60px" placeholder="X"/>
      </div>
    </form>`,
    buttons:{
      go:{label:"Roll", callback: async html=>{
        const mod = Number(html.find('[name="mod"]').val());
        const tearing = html.find('[name="tear"]')[0].checked;
        const proven = html.find('[name="prov"]')[0].checked ? Number(html.find('[name="provV"]').val()) : 0;
        const primitive = html.find('[name="prim"]')[0].checked ? Number(html.find('[name="primV"]').val()) : 0;
        // base die (d10) with tearing (best of 2)
        const r1 = await (new Roll("1d10")).roll({async:true}); 
        const r2 = tearing ? await (new Roll("1d10")).roll({async:true}) : null;
        let die = tearing ? Math.max(r1.total, r2.total) : r1.total;
        // apply Proven/Primitive
        if (proven>0) die = Math.max(die, proven);
        if (primitive>0) die = Math.min(die, primitive);
        const rf = (die===10); // potential Zealous Hatred trigger
        const total = die + mod;
        let flavor = `💥 <b>Damage</b><br/>Die: ${die}${tearing?` (Tearing ${r1.total}/${r2.total.total})`:''} + Mod ${mod} = <b>${total}</b>`;
        if (proven>0) flavor += `<br/>Proven(${proven}) zastosowano`;
        if (primitive>0) flavor += `<br/>Primitive(${primitive}) zastosowano`;
        if (rf) flavor += `<br/><b>⚡ Natural 10</b> — rozważ Zealous Hatred.`;
        ChatMessage.create({speaker: ChatMessage.getSpeaker(), content: flavor});
      }}
    }
  }).render(true);
@@ -1,26 +0,0 @@
 // 📚 Create placeholder RollTables for Crits + Psychic Phenomena/Perils (with icons)
 const icon = {Energy:"⚡", Impact:"🔨", Rending:"🗡️", Explosive:"💥"};
 const dmgTypes = ["Energy","Impact","Rending","Explosive"];
 const locs = ["Head","Body","Left Arm","Right Arm","Left Leg","Right Leg"];
 async function makeCrit(dtype, loc){
  const name = `Crit: ${dtype} - ${loc}`;
  if (game.tables.getName(name)) return;
  const results = [];
  for (let i=1;i<=5;i++){
    results.push({type:0, text:`${icon[dtype]||""} ${dtype}/${loc} — wpis ${i} (uzupełnij z PDF)`, weight:1, range:[i,i]});
  }
  await RollTable.implementation.create({name, formula:"1d5", replacement:true, displayRoll:false, results});
 }
 async function makeWide(name, emoji){
  if (game.tables.getName(name)) return;
  const results = [];
  for (let i=0;i<20;i++){
    const lo=i*5+1, hi=i*5+5;
    results.push({type:0, text:`${emoji} ${name} ${lo}-${hi} — wpis (uzupełnij z PDF)`, weight:1, range:[lo,hi]});
  }
  await RollTable.implementation.create({name, formula:"1d100", replacement:true, displayRoll:false, results});
 }
 for (const d of dmgTypes) for (const l of locs) await makeCrit(d,l);
 await makeWide("Psychic Phenomena","🌀");
 await makeWide("Perils of the Warp","☠️");
 ui.notifications.info("Utworzono puste tabele: Crits (4×6) + Phenomena + Perils.");
@@ -1,3 +0,0 @@
 name,type,tier,aptitudes,prereq,effect,source,notes
 Ambidextrous,talent,1,"Agility; Offence","Ag 30","-10 to off-hand penalty","DH2 CRB","PRZYKŁAD – ZASTĄP"
 Aegis Discipline (GK),talent,2,"Willpower; Defence","Psyker","Reroll Perils 1×scene","HOUSE","DODAJ WŁASNY OPIS"
@@ -1,3 +0,0 @@
 name,type,subtype,damage,pen,range,rof,qualities,weight,availability,source,notes
 Lasgun M36,weapon,Basic,"1d10+3",0,100m,"S/3/–","Reliable",4,Common,"DH2 CRB p.142","PRZYKŁAD – ZASTĄP"
 Astartes Bolter,weapon,Basic,"1d10+9",4,90m,"S/2/–","Tearing; Unreliable",9,Rare,"DW CRB","PRZYKŁAD – ZASTĄP"
@@ -1,33 +0,0 @@
 // ⚡ Zealous Hatred helper (DH2) — roll 1d5 crit OR add +1d5 dmg
 new Dialog({
    title: "⚡ Zealous Hatred",
    content: `
    <form>
      <div class="form-group"><label>Wound damage after Armour/TB?</label>
        <select name="penetrated"><option value="yes">Yes → roll Critical (1d5)</option><option value="no">No → add +1d5 damage</option></select></div>
      <div class="form-group"><label>Damage Type</label>
        <select name="dtype"><option>Energy</option><option>Impact</option><option>Rending</option><option>Explosive</option></select></div>
      <div class="form-group"><label>Hit Location</label>
        <select name="loc"><option>Head</option><option>Body</option><option>Left Arm</option><option>Right Arm</option><option>Left Leg</option><option>Right Leg</option></select></div>
      <div class="form-group"><label>Table name (optional override)</label><input name="tname" type="text" placeholder="Crit: Energy - Head"/></div>
    </form>`,
    buttons: {
      go: { label: "Resolve", callback: async html => {
        const pen = html.find('[name="penetrated"]').val();
        if (pen === "yes") {
          const dtype = html.find('[name="dtype"]').val();
          const loc = html.find('[name="loc"]').val();
          const override = html.find('[name="tname"]').val()?.trim();
          const name = override || `Crit: ${dtype} - ${loc}`;
          const r = await (new Roll("1d5")).roll({async:true});
          const table = game.tables.getName(name);
          if (table) await table.draw({displayResults:true, roll:r});
          else r.toMessage({flavor:`⚡ <b>Zealous Hatred</b>: Critical ${r.total} — brak tabeli <b>${name}</b> (utwórz lub zmień nazwę).`});
        } else {
          const r = await (new Roll("1d5")).roll({async:true});
          r.toMessage({flavor:"⚡ <b>Zealous Hatred</b>: Dodaj do obrażeń <b>+1d5</b> (atak nie przebił Soak)."});
        }
      }}
    }
  }).render(true);
@@ -22,6 +22,20 @@
            false,
            false
        ],
        "indie\\b": [
            "Indie? *Wyciąga rewolwerową wyrzutnię taktycznych bomb jądrowych* Gdzie??? *Zaczyna się maniakalnie śmiać*",
            15.0,
            0,
            false,
            false
        ],
        "hindus": [
            "Hindus? Gdzie.... *Wyciąga spod lady ciężki miotacz płomieni i zaczyna się maniakalnie śmiać*",
            15.0,
            0,
            false,
            false
        ],
        "chuj\\b": [
            "Eeeee.... Szefie... ktoś cię woła! Wskazuje na Hammera",
            15.0,
@@ -85,6 +99,27 @@
            false,
            false
        ],
        "tatarek\\b": [
            "Tatarek? Nie dramatyzuj....",
            15.0,
            0,
            false,
            false
        ],
        "krowa\\b": [
            "Krówka? Nie dramatyzuj....",
            15.0,
            0,
            false,
            false
        ],
        "krówka\\b": [
            "Krówka? Nie dramatyzuj....",
            15.0,
            0,
            false,
            false
        ],
        "jessenia\\b": [
            "Jessenia? Jak przyszła tu w różowej pidżamie z uszkami to nawet nie mrugnąłem okiem. Te oczy.... No ale jakiś debil Ją prowokował mówiąc \"Zdominuj mnie\" Akurat miała dobry humor więc przeżył - ale po 115.0 sekundach był już na \"Tak Pani, przepraszam że zająłem czas Pani\" Respect dla kobitki",
            15.0,
@@ -155,8 +190,15 @@
            false,
            false
        ],
-        "same plusy\\b": [
+        "elokwentna\\b": [
-            "Jak na cmentarzu Szefie. Jak na cmentarzu",
+            "O matko. Znowu ta dyskusja? Hammer ma stary słownik gdzie elokwentna i pyskata są praktycznie synonimami. Jedyna różnica że swojej uległej można za bycie pyskatym dać po dupie.",
            15.0,
            0,
            false,
            false
        ],
        "elokwencja\\b": [
            "O matko. Znowu ta dyskusja? Hammer ma stary słownik gdzie elokwentna i pyskata są praktycznie synonimami. Jedyna różnica że swojej uległej można za bycie pyskatym dać po dupie.",
            15.0,
            0,
            false,
@@ -204,6 +246,13 @@
            false,
            false
        ],
        "fallain\\b": [
            "Kochana Krówka. Skłonność do dramatów i zakrwawiania ścian. Jedna z kilku NAPRAWDE srogich masochistek... Ach ta krew :drool:",
            15.0,
            0,
            false,
            false
        ],
        "roar": [
            "Kici, kici....",
            15.0,
@@ -260,6 +309,13 @@
            false,
            true
        ],
        "revalyacyjnie\\b": [
            "Zajebisty dowcip szefie. Na pewno się \"Twojej Byłej Dziewczynie\":tm: spodoba.",
            15.0,
            0,
            false,
            true
        ],
        "nocna zmiana\\b": [
            "Nocna Zmiana? No to właściciele tego baru. Taki troche Hammer Harema. Kto to jest Harem>? Łokurwa. Harem Hammera. Ale on tu robi za jedyną hurysę, a reszta to szejkowie. Tak zrobię Ci szejka.",
            15.0,
@@ -8,7 +8,5 @@ def signal_handler(sig, frame):
    print("\nCaught interrupt(did you press Ctrl+C?), stopping spotify_dl")
    sys.exit(0)
-try:
+
-    signal.signal(signal.SIGINT, signal_handler)
+signal.signal(signal.SIGINT, signal_handler)
 except ValueError:
    print("Exception in signal handler")
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
gitea	3a2826eb6e	Server side work	2024-04-17 21:24:26 +02:00
gitea	c1948e25c0	Deployable script for windows file service	2024-04-17 21:24:25 +02:00
gitea	16ead67cf3	Music service (#5 ) * Logging added to music service * Logging + playlist + plans Fix logger * Liq radio + some comments and nice stuff fix fix Fix ? fx Liquidsoap init test test2 test Tst tst fix PLS tst tst test test fix tst aa aa# Please enter the commit message for your changes. Lines starting Ping fix? fix fix Working version Upgrade Fix fix metadata test fix fix# Please enter the commit message for your changes. Lines starting Fix aa fix fix test FIx test test test fix fix fix? aa fix test Final v.00 HLS Serve * Fixing the bug in the conjurer_musician.py file. Fx Fix fx Fix ? Revert "Fix" This reverts commit 4e185f7b34dfede04ed36ab9813bd9d1f7fb8b35. Adding deploy for music bot * Adding playlists, various bufixes and installation scripts Adding playlists, various bufixes and installation scripts Fixing Rename KUUUURWA Install script music bot fx Fix ? fix Synchro test test Undo tst test tst Undo changes test fx tst fx Test commit of two files priority queue. * Bugfix in script deploy_music.sh	2024-04-17 20:40:43 +02:00
gitea	5ca73d6ac9	Main bot (#4 ) * Work on communication Testing only FIx test * Communication work progress FX aa Maybe wrong Another step forward. STOP! * Fixin comms * View att 1 Fix 33 fx Final fix fix Test * View - beta version aa aa aaa aa Chyba fix aa aa aa tst test FX Maybe this ? Fix last fix ? dix * Client beta version search deploy * Late fix * Deploy! * Safeguard against commands being used in dms * Fixes * Radiostation control * Fix bug * Bugfix * fx	2024-04-17 20:33:12 +02:00
gitea	f3e690f395	FIx Config reorg	2024-04-17 12:34:48 +02:00
gitea	8293b3a69c	Music service (#3 ) * Logging added to music service * Fix logger	2024-04-12 23:22:46 +02:00
gitea	0ac9006665	Search webservice (#2 ) * Deployable script for windows file service * Deploy! * Server side work	2024-04-12 23:21:48 +02:00
gitea	d912d9bc1b	Main bot (#1 ) undefined	2024-04-12 23:20:51 +02:00
gitea	b08642dd88	Preparation for deployment	2024-04-10 19:12:44 +02:00
gitea	8b1950823b	Almost deployment versio - for full deployment change parameteres in search_bot	2024-04-10 19:06:48 +02:00
gitea	6589b73329	After squash fixes After squash fixes	2024-04-10 15:45:14 +02:00
gitea	89003c32c9	Serverside work of search	2024-04-10 15:26:40 +02:00
gitea	17eace3e73	Fix rotation and fix of playlist	2024-04-10 15:26:39 +02:00
gitea	3f2248336d	Deploy! Test 1 As Fix 2 Fix3	2024-04-10 15:26:39 +02:00
gitea	f8664c0fd1	Music search move file server side att 1	2024-04-10 15:26:33 +02:00
gitea	82273df13c	This is seriously last fix description update last fix ? Small fix Kolejny fix Final fix FX2 fx	2024-04-10 15:26:29 +02:00
gitea	ae0d807714	Pornol dl2	2024-04-10 15:26:28 +02:00
gitea	edc0a4a502	Pornol dl 1	2024-04-10 15:26:28 +02:00
gitea	39ecb82395	Coroutine fix	2024-04-10 15:26:18 +02:00
gitea	d8f5bd1805	Plan for next release	2024-04-10 15:26:18 +02:00
gitea	3f68c6aaed	Test aaa aa Bugfixing et masse bbb asas aas asas aa as qq as as as as as aaa asa nn aa sda 88 asa sasa adsa a as asdas Final version before tests Fix1 aa aa fx dx :) aa Hopefully last fix aaa aaa bbb bb dd aa sdae aa bb aa kk a Fix fx aa deploy fx asas bb as fx fx aa aa mess kk A fix aa aa Viwe fix a test a aa FX	2024-04-10 15:26:18 +02:00
gitea	aee53de258	Installer `12` sa asda 123 AA Test	2024-04-10 15:26:12 +02:00
gitea	20caa5600a	name change and othre bugfixes fix fax fx 121 as aa fx f5 fx4 fix fx1	2024-04-10 15:26:06 +02:00
gitea	4a4f8df06e	Work on deployment	2024-04-10 15:26:06 +02:00
gitea	6c9f01971a	Bugfixes asdasdasd :) asa asdasda aa :) asa aa :) :) sa as aa aa aa aaa as 11 aa 11 xxx dd ds aa a1 aa Test Suppress Move Installer aaa Serwis `12` aa xd asasa xd aa asa aaa :) Hejka a xd aa aaas 555 aaa asa aa 11 aaa aaa as sa async asda 00 123 123 aa as ss as a sa aa 1 RES T Hejko aa 11 AA test Test	2024-04-10 15:26:05 +02:00
gitea	211c45891e	Work on deployment fix fax fx Fin part fx 121 Temp fix as aa fx f5 fx4 fix fx1 Work on deployment	2024-04-10 15:26:00 +02:00
gitea	de3d6a8f42	Install options	2024-04-10 15:25:59 +02:00
gitea	9c027fd636	Waitress	2024-04-10 15:25:59 +02:00
gitea	9af6b8e187	Bugfixing add Test 1 Test 2 Test3 Test phase 2 FIx 1 Fix 2 Fix 10 Fix 11 Fix 13 Fix 14 Fix 15 Test 1 Test 2 Test 3 Fix 15 Test 7 Fix 18 Test 20 Done Minor 1	2024-04-10 15:25:59 +02:00
gitea	d00ede6c62	Service FIx	2024-04-10 15:25:59 +02:00
gitea	5b7d7b31b2	Linux conf files	2024-04-10 15:25:59 +02:00
gitea	00172920a9	Waitress Deploy.shgit	2024-04-10 15:25:59 +02:00
gitea	5e3ffdacb5	Minor fix 2 Minor 1 Done Test 20 Fix 18 Test 7 Fix 15 Test 3 Test 2 Test 1 Fix 15 Fix 14 Fix 13 Fix 12 Fix 11 Fix 10 Fix 9 Fix 2 FIx 1 Test phase 2 Test 8 Final test Test 5 Test 4 Test3 Test 2 Test 1 add	2024-04-10 15:25:59 +02:00
gitea	471d4e923b	Service FIx	2024-04-10 15:25:53 +02:00
gitea	d11f5d8d24	New files for flask services	2024-04-10 15:25:53 +02:00
gitea	cfb26d95a4	Nowy lepszy trunk	2024-04-10 15:25:53 +02:00
gitea	5e14299fef	Additional lines of code	2024-04-10 15:25:40 +02:00
gitea	126de9a4a4	Fix	2024-04-10 15:16:22 +02:00
gitea	0d132983fc	Fix 2.0	2024-04-10 15:05:43 +02:00
gitea	67cae0e68e	Fix	2024-04-10 15:05:43 +02:00
gitea	eabd0e8e1e	Nope	2024-04-10 15:05:43 +02:00
gitea	f7c91e3874	Test chat gpt4	2024-04-10 15:05:43 +02:00
gitea	c224b2ccc8	Hejo	2024-04-10 15:05:43 +02:00
gitea	3ca9f2c6f3	-1	2024-04-10 15:04:41 +02:00
gitea	c52d55e0a2	+1	2024-04-10 15:04:41 +02:00
gitea	e1fa15abb3	Async	2024-04-10 15:04:41 +02:00
gitea	74c76e639d	Async fix	2024-04-10 15:04:41 +02:00
gitea	35a65e48e9	And even more async	2024-04-10 15:04:41 +02:00
gitea	5d5c136b41	More async	2024-04-10 15:04:40 +02:00
gitea	b9fbc0f910	Async wyszukaj	2024-04-10 15:04:40 +02:00
gitea	fd742c8f1c	Parametryzacja "muzyki mojego ludu"	2024-04-10 15:04:40 +02:00
gitea	1c240342c5	Logging	2024-04-10 15:04:37 +02:00
gitea	7bd0c0aca4	Fix 2.6	2024-04-10 15:04:37 +02:00
gitea	7c8ad99743	Fix 2	2024-04-10 15:04:37 +02:00
gitea	90896fa9be	Fix 1	2024-04-10 15:04:37 +02:00
gitea	e3bec6bc11	Playlist based on chat history	2024-04-10 15:04:37 +02:00
gitea	aa00045dec	Trunk + mod	2024-04-10 15:04:32 +02:00
gitea	06e3671ec2	Linting is done	2024-04-10 15:04:22 +02:00
gitea	0879796cc6	Linting	2024-04-10 15:04:13 +02:00
gitea	9f756b3092	Dodana procedura asynchronicznej generacji iteratora oraz komentarz w jaki sposob inaczej przerobic fora na asynchroniczny. Przydatne ze wzgledu na to ze szukajka nadal blokuje heartbeat bota - co skutkuje warningnami i wyjatkami	2024-04-10 15:04:09 +02:00
gitea	579a3f2a52	Reakcje ladacznicy, poprawka na mention w reset the clock	2024-04-10 15:04:09 +02:00
gitea	5505022dbb	Funkcjonalnosc logowania incydentow w Absinth Eldritch Horror Hammertimespace Continuum	2024-04-10 15:04:05 +02:00
gitea	d2e5a34b87	Mala poprawka na rozmiar plikow pamieci	2024-04-10 15:03:55 +02:00
gitea	c7696fafdc	Fixed playlist gen	2024-04-10 15:03:43 +02:00
gitea	7f3de2ea13	Kurwa bugfix pod windowsa	2024-04-10 15:03:42 +02:00
gitea	ec505f050f	modified	2024-04-10 14:22:01 +02:00
gitea	f55c4ce1a7	Nowy lepszy trunk Additional lines of code 1 AAA	2024-04-10 14:22:00 +02:00
gitea	432abc73b9	Upgrade gpt model	2024-04-10 14:22:00 +02:00
gitea	cdaf2589b3	Library update fix 1111 tezz	2024-04-10 14:22:00 +02:00
gitea	67ab3b4bba	Docstring + bugfixes + random cyclic message Nowy commit	2024-04-10 14:22:00 +02:00
gitea	71623d9812	Update fabryczka :) :)	2024-04-10 14:22:00 +02:00
gitea	ce54233908	Fix. Was joking.	2024-04-10 14:22:00 +02:00
gitea	b0df66c5da	Fix. Last.	2024-04-10 14:22:00 +02:00
gitea	fda2733600	Token amount change Last (hopefully) fix Fix+1 Fix Fix Fix Test Fix tokens Fix	2024-04-10 14:22:00 +02:00
gitea	027050a4dd	Token counter	2024-04-10 14:22:00 +02:00
gitea	b22b9add15	Gpt fixes FIx Fix Fix Fix. Another. ! Fix Tiktoken Fix Fix	2024-04-10 14:22:00 +02:00
gitea	1fd5b8cfac	GPT fixes Fix Test	2024-04-10 14:22:00 +02:00
gitea	5e3d90c038	Nope. It did not happen Rollback not working Nowe	2024-04-10 14:22:00 +02:00
gitea	fef53a3587	Test heartbeat fix	2024-04-10 14:22:00 +02:00
gitea	be1e338e54	Fixes + upgrade GPT model Fix 2.0 Fix Nope	2024-04-10 14:22:00 +02:00
gitea	d6dd276a92	Mention conjurer	2024-04-10 14:22:00 +02:00
gitea	a0cddaa1f0	update to gpt-4	2024-04-10 14:22:00 +02:00
gitea	38355da861	Test chat gpt4 Hejo fix :)	2024-04-10 14:21:59 +02:00
gitea	03c73fc55e	Various fixes Fixes Fix fix Add Rev Add Fix with \\b Lilia Lunka i small fix	2024-04-10 14:21:59 +02:00
gitea	77089d408b	ASync search and moving to fully asynchronous work + responses to config command Async wyszukaj More async And even more async Async fix Async +1 -1	2024-04-10 14:21:59 +02:00
gitea	f05ae2b006	Improvements	2024-04-10 14:21:59 +02:00
gitea	bca63dd94a	Additional logging	2024-04-10 14:21:59 +02:00
gitea	2641965792	Playlist based on chat history Fix 1 Fix 2 Fix 2.6 Logging	2024-04-10 14:21:59 +02:00
gitea	dc9946533e	Various fixes Trunk + mod FIx	2024-04-10 14:21:59 +02:00
gitea	0a39eba723	Create python-package.yml	2024-04-10 14:21:59 +02:00
gitea	114cfc35bc	Create python-app.yml	2024-04-10 14:21:59 +02:00
gitea	6a92ff4956	Small fixes continued.	2024-04-10 14:21:59 +02:00
gitea	c9d371d941	Small fixes in the paths	2024-04-10 14:21:59 +02:00
gitea	8aa980ff9c	Update settings and history	2024-04-10 14:21:59 +02:00
gitea	063f15e3a6	Another fix	2024-04-10 14:21:59 +02:00
gitea	8e64482623	Fix of metadata loading	2024-04-10 14:21:58 +02:00
gitea	f686552337	Kolejna poprawka	2024-04-10 14:21:58 +02:00
gitea	f29672684a	Wrong encoding in settings.json	2024-04-10 14:21:58 +02:00
gitea	c8d47ee118	Linting Linting	2024-04-10 14:21:58 +02:00
gitea	5173ed2e52	Bugfixy	2024-04-10 14:21:58 +02:00
gitea	ddf1c5fdca	Added playlist display	2024-04-10 14:21:58 +02:00
gitea	0c9298baa4	Lot of fixes async iterator asynchronous, plans for asynchronouse work Mala poprawka na rozmiar plikow pamieci Funkcjonalnosc logowania incydentow w Absinth Eldritch Horror Hammertimespace Continuum Reakcje ladacznicy, poprawka na mention w reset the clock	2024-04-10 14:21:58 +02:00
gitea	d3169786ff	Fucking windows bugfix and playlist gen fix Kurwa bugfix pod windowsa Fixed playlist gen	2024-04-10 14:21:58 +02:00
gitea	f2d5673555	Poprawiono obsluge rotowanych logow i troche ulepszono funkcje opowiadania o fabryczcce	2023-06-06 12:51:17 +02:00
gitea	907a1aa987	I also modified yt_dlp. But I do not remember what I changed. Have fun	2023-06-06 11:41:22 +02:00
gitea	6bc77f3720	Fixed version of spotify_dl	2023-06-06 11:35:39 +02:00
gitea	48f49d59e0	Initial commit with first semi-public version	2023-06-06 10:42:46 +02:00
gitea	39d3c12072	Initial commit	2023-06-05 21:31:57 +02:00
		`@@ -1,2 +0,0 @@`
			`#!/bin/bash`
			`cd ../conjurer/ && git pull && cp ./gpt_interface/* ../gpt_interf_serv/ && cd -`