Merge branch 'main' of https://github.com/migatu/conjurer

Serverside search.
Start work on views
2026-07-15 14:22:13 +00:00 · 2024-04-10 13:18:22 +02:00 · 2024-04-10 13:17:58 +02:00 · 2024-04-10 13:16:32 +02:00 · 2024-04-09 19:21:06 +02:00 · 2024-04-09 16:23:12 +02:00
70 changed files with 164214 additions and 41162 deletions
@@ -197,7 +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
@@ -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,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.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,326 +0,0 @@
 # ai command cogs
 import logging
 import re
 import sys
 from enum import Enum
 from datetime import datetime
 from typing import Optional
 import discord
 import openai
 import requests
 from discord.ext import commands
 import ai_functions
 from constants import (
    ASSISTANTS,
    DATA,
    GRAPHICS_PATH,
    INITIAL_TIME_WAIT,
    MASTER_TIMEOUT,
    OPENAICLIENT,
    SPECJALNE_ZIEMNIACZKI,
    WORD_REACTIONS,
    MESSAGE_TABLE
 )
 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 in SPECJALNE_ZIEMNIACZKI.values():
            if superfryta[4] !="":
                self.logger.info(
                    "Personal assistant exists id: %s,name: %s, owner: %s, special instructions: %s assistant id: %s ",
                    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 id: %s,name: %s, owner: %s, special instructions: %s",
                    superfryta[0],
                    superfryta[1],
                    superfryta[2],
                    superfryta[3]
                )
                await ai_functions.create_chat_assistant(
                    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():
                    if ctx.message.author.id == superfryta[0]:
                        self.armia[superfryta[2]] = dm_mode_arg
                        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]):
        await self.armia_hammera_back(ctx, message_txt, recipient)
    async def armia_hammera_back(self, ctx, message_txt, recipient = None):
        recipients = []
        if recipient:
            recipients.append(recipient.id)
        else:
            for superfryta in SPECJALNE_ZIEMNIACZKI.values():
                recipients.append(superfryta[0])
        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 channel.send(message_txt)
            await ctx.reply("Poszło")
    @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]:
                    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:
                        ctx =  await self.bot.get_context(message)
                        self.armia_hammera_back(ctx=ctx, message_txt=message.content)
                        return
                    elif self.armia[message.author.id]== Dm_Mode.SEKRETNY_SEKSRET:
                        pass
                    else:
                        await message.channel.send("Coś się wyebao. Wołaj Hammera")
                        return
            channel = self.bot.get_channel(1064888712565100614)
            await channel.send("Słyszałem ja żem że: " + message.content)
            return
        channel = message.channel
        message.content = message.content.lower()
        tdelta = datetime.now() - MASTER_TIMEOUT
        tdelta = tdelta.total_seconds()
        if "opowiedz o fabryczce" in message.content:
            await message.reply(DATA["fabryczka"])
        if "opowiedz mi o fabryczce" in message.content:
            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):
                    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(self.word_reactions[word][0])
                            await message.add_reaction(emoji)
                        elif security_clearance and vykidailo:
                            await message.reply(self.word_reactions[word][0])
                        elif not security_clearance:
                            await message.reply(self.word_reactions[word][0])
                        self.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:
            async with channel.typing():
                self.logger.debug("Procedura chatu")
                message.content = message.content.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,
                    "CONVERSATION",
                )
                if len(result) < 1500:
                    await message.reply(result)
                else:
                    while len(result) > 1500:
                        await message.reply(result[:1500])
                        result = result[1500:]
        if "imaginuje sobie:" in message.content:
            async with channel.typing():
                self.logger.info("Poczatek procedury obrazkowej")
                message.content = message.content.replace("imaginuje sobie: ", "")
                self.logger.debug("Wywolanie obrazka: %s", message.content)
                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 message.reply(
                        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 message.reply(
                        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,
                        "RANDOM",
                    )
                    await message.reply(
                        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 message.reply(
                        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 message.reply(
                        (
                            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 message.reply(
                        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 message.reply(
                        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"
                    with open(temp_file_name, "wb") as dalle_file:
                        dalle_file.write(response.content)
                    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)
 # *=========================================== Define Functions
 async def setup(bot):
    logger = logging.getLogger("discord")
    await bot.add_cog(Events(bot))
    logger.info("Loading ai events module done")
@@ -1,352 +0,0 @@
 import asyncio
 import json
 import logging
 import random
 import openai
 import tiktoken
 from constants import (
    CYCLIC_WORDS,
    ENCODING,
    GPT_SETTINGS,
    MEMORY_FIVE_MUZYKA,
    MEMORY_FIVE_SIARA,
    MESSAGE_TABLE,
    MESSAGE_TABLE_MUZYKA,
    OPENAICLIENT,
    WORD_REACTIONS,
    ASSISTANTS,
    SYSTEM_GPT_SETTINGS
    )
 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
 ):
    """
    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
    :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)
    temp = {"role": "user", "content": username + ":" + prompt}
    if vykidailo or bartender:
        logger.info("Administrator coś chciał")
    history.append(temp)
    if request_type == "MUSIC":
        with open(MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING) as file_music_memory:
            # First we load existing data into a dict.
            file_data = json.load(file_music_memory)
            # Join new_data with file_data inside emp_details
            file_data.append(temp)
            file_music_memory.seek(0)
            # convert back to json.
            json.dump(file_data, file_music_memory, indent=4)
    elif request_type == "RANDOM":
        with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file_memory:
            # First we load existing data into a dict.
            file_data = json.load(file_memory)
            # Join new_data with file_data inside emp_details
            file_data.append(temp)
            file_memory.seek(0)
            # convert back to json.
            json.dump(file_data, file_memory, indent=4)
    else:
        with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file_memory:
            # First we load existing data into a dict.
            file_data = json.load(file_memory)
            # Join new_data with file_data inside emp_details
            file_data.append(temp)
            file_memory.seek(0)
            # convert back to json.
            json.dump(file_data, file_memory, indent=4)
    history = []
    history.append(GPT_SETTINGS[0])
    chat_gpt_config_request_size = num_tokens_from_string(GPT_SETTINGS[0], "gpt-4")
    for slowo, reakcja in WORD_REACTIONS.items():
        if not reakcja[3]:
            content = (
                "Kiedy słyszysz "
                + slowo
                + " to reagujesz lub dzieje się to "
                + reakcja[0]
            )
            temp = {"role": "system", "content": content}
            chat_gpt_config_request_size += num_tokens_from_string(temp, "gpt-4")
            history.append(temp)
    final_prompt = username + ":" + prompt
    logger.debug(
        "Rozmiar zapytania przed dodaniem historii %s", chat_gpt_config_request_size
    )
    if request_type == "MUSIC":
        algorithm = "gpt-4o"
        table = MESSAGE_TABLE_MUZYKA
        token_amount = 10700
    elif request_type == "RANDOM":
        algorithm = "gpt-4o"
        table = MESSAGE_TABLE
        token_amount = 10700
    else:
        table = MESSAGE_TABLE
        algorithm = "gpt-4o"
        token_amount = 10700
    prompt_gpt_request_size = num_tokens_from_string(
        {"role": "user", "content": final_prompt}, "gpt-4"
    )
    temptable = []
    for i in reversed(table):
        temp_token = num_tokens_from_string(i, "gpt-4")
        logger.debug(
            "Rozmiar zapytania %s prompt %s temp %s",
            chat_gpt_config_request_size,
            prompt_gpt_request_size,
            temp_token,
        )
        if (
            chat_gpt_config_request_size
            < token_amount + prompt_gpt_request_size + temp_token
        ):
            temptable.insert(1, i)
            chat_gpt_config_request_size += temp_token
    history.extend(temptable)
    temp = {"role": "user", "content": final_prompt}
    history.append(temp)
    logger.info("Rozmiar zapytania po wyslaniu %s", chat_gpt_config_request_size)
    try:
        response = await OPENAICLIENT.chat.completions.create(
            model=algorithm, messages=history
        )
    except openai.APITimeoutError as e:
        # Handle timeout error, e.g. retry or log
        result = 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:
        result = 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
        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",
        )
        result = 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
        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",
        )
        result = 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
        result = 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
        result = 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:
        result = 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:
        result = 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
        result = 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:")
    logger.info(history)
    await asyncio.sleep(15)
    result = ""
    logger.debug("Odpowiedzi")
    logger.info(response)
    logger.debug(response.choices)
    for choice in response.choices:
        result += choice.message.content
    logger.info("Sformatowane odpowiedzi")
    logger.info(result)
    temp = {"role": "assistant", "content": result}
    history.append(temp)
    if request_type == "MUSIC":
        with open(MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING) as file_music_memory:
            # First we load existing data into a dict.
            file_data = json.load(file_music_memory)
            # Join new_data with file_data inside emp_details
            file_data.append(temp)
            file_music_memory.seek(0)
            # convert back to json.
            json.dump(file_data, file_music_memory, indent=4)
    elif request_type == "RANDOM":
        with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file_memory:
            # First we load existing data into a dict.
            file_data = json.load(file_memory)
            # Join new_data with file_data inside emp_details
            file_data.append(temp)
            file_memory.seek(0)
            # convert back to json.
            json.dump(file_data, file_memory, indent=4)
    else:
        with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file_memory:
            # First we load existing data into a dict.
            file_data = json.load(file_memory)
            # Join new_data with file_data inside emp_details
            file_data.append(temp)
            file_memory.seek(0)
            # convert back to json.
            json.dump(file_data, file_memory, indent=4)
    return result, MESSAGE_TABLE
 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(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][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 message.channel.send(chat_response)
            done = True
        elif run.status =='cancelled':
            await message.channel.send("Cos sie wywaliło")
        else:
            logger.info(run.status)
        asyncio.sleep(5)
 async def echo(message):
    await message.channel.send(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,231 +1,76 @@
 import json
 import logging
 import re
 import threading
-import time
+import json
-from queue import Empty, Queue
+from queue import Queue, Empty
 from urllib import request as urequest
 from flask import Flask, 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
+internal_q = Queue()
 awaiting_q = []
 incoming_q = Queue()
 app = Flask(__name__)
 PREPPED_TRACKS = {
    "requests": "",
    "hit": "",
    "all": "",
    "priority": "",
    "jingles": "",
    "now_playing": "",
    "next": "",
    "meta": "",
 }
 logger = logging.getLogger("discord")
 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():
    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():
    """
    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")
    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")
    while True:
        try:
            q_data = internal_q.get(block=False)
        except Empty:
            break
    if q_data.uuid in record:
        pass
    return jsonify("SUCCESS")
@app.route("/conjurer", methods=["GET"])
 def check_alive():
    """
    The function "check_alive" returns a JSON response with the message "ALIVE" when the "/conjurer"
    route is accessed via a GET request.
    :return: The code snippet is a Flask route that listens for GET requests to the "/conjurer"
    endpoint. When a GET request is made to this endpoint, the function check_alive() is called, which
    returns a JSON response with the message "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():
    """
    The function `scan_queue` reads data from a queue, logs it, and appends it to another queue.
    :param _logger: The `_logger` parameter is typically an instance of a logging object that is used to
    record and store log messages. It is commonly used to track the flow of the program, record errors,
    and provide information for debugging purposes. In this code snippet, the `_logger` object is used
    to log the
    """
    logger = logging.getLogger("discord")
    while True:
        data = OUT_COMM_Q.get()
-        logger.info(data)
+        _logger.info(data)
-        awaiting_q.append(data)
+        internal_q.put(data)
        query_list.append(data)
-
+def comm_subroutine(logger):
-def scan_incoming():
+    #logger.setLevel(logging.DEBUG)
-    """
+    logger.info("Started")
    The `scan_incoming` function continuously checks for incoming data, processes it, and logs when data
    is found.
    :param _logger: The `_logger` parameter in the `scan_incoming` function is a logger object that is
    used to log messages or information during the execution of the function. It is typically used for
    debugging, monitoring, or tracking the flow of the program. In this case, the `_logger` is being
    used
    """
    logger = logging.getLogger("discord")
    while True:
        try:
            answer = incoming_q.get(block=False)
            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)
        except Empty:
            time.sleep(1)
 def get_stream_title(tag: bytes) -> str:
    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():
    """
    The `comm_subroutine` function starts multiple threads to run different tasks concurrently.
    :param logger: The `logger` parameter in the `comm_subroutine` function is an instance of a logger
    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 = logging.getLogger("discord")
    logger.info("Started comms")
    threads = []
-    # threads.append(threading.Thread(target=flask_debug))
+    threads.append(threading.Thread(target=flask_debug, args=(logger,)))
-    threads.append(threading.Thread(target=waitress_run))
+    #threads.append(threading.Thread(target=waitress_run, args=(logger,)))
-    threads.append(threading.Thread(target=scan_queue))
+    threads.append(threading.Thread(target=scan_queue,args=(logger,)))
    threads.append(threading.Thread(target=scan_incoming))
    for worker in threads:
        worker.start()
    for worker in threads:
        worker.join()
 if __name__ == "__main__":
-    comm_subroutine()
+    logging_client = logging.getLogger(__name__)
    comm_subroutine(logging_client)
@@ -1,403 +1,231 @@
-"""
+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 netrc
 import threading
 import time
 from json.decoder import JSONDecodeError
 from logging import handlers
 from queue import Queue
 import requests
 import scrape_bot
 import search_bot
 #import search_bot2 as search_bot
 from flask import Flask, jsonify, request
 import netrc
 import json
 import asyncio
 from json.decoder import JSONDecodeError
 from urllib.request import urlopen
 from habanero import Crossref
 from waitress import serve
-
+from queue import Queue
-# Constants
+import search_bot
 import requests
 from typing import Callable
 from uuid import UUID
 NETRC_FILE = r"C:\Users\Activcom.pl\.netrc"
 HOST_ADDRESS = "192.168.1.192"
 PORT_ADDRESS = 5001
 MAIN_BOT_ADDRESS = "http://192.168.1.191:5000"
 SEND_RESULTS = "/conjurer"
-BDSM_UUID_TEST = "96b7f85a-1142-4908-8986-62a2ea25a147"
+BDSM_UUID_TEST = '96b7f85a-1142-4908-8986-62a2ea25a147'
 MAX_CR_RESULTS = 1000
 #TEST PURPOSES ONLY!
 #MAX_CR_RESULTS = 5
 ENCODING = "utf-8"
 app = Flask(__name__)
 librarian_queue = Queue()
 librarian_list = []
 # 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:
        """
        Initializes a Librarian object.
        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.
        """
        netrc_mod = netrc.netrc(NETRC_FILE)
-        auth_tokens = netrc_mod.authenticators("crossref")
+        authTokens = netrc_mod.authenticators("crossref")
-        self.cr = Crossref(
+        self.cr = Crossref(mailto=authTokens[0])
            mailto=auth_tokens[0],
            ua_string=f"Conjurer project. mailto:{auth_tokens[0]}"
        )
        self.query = query
        self.uuid = str(uuid)
-        self.limit = MAX_CR_RESULTS
+        self.limit = 3000
        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.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)
-        if not deep_search:
+            time.sleep(1)
-            query_limit = MAX_CR_RESULTS if MAX_CR_RESULTS < 1000 else 1000
+        self.app.logger.info("CROSSREF DONE")
-            cr_result = self.cr.works(query=query, limit=query_limit)
+        #TODO: add to sql with UUID
-            self.search_result_from_cr.update(cr_result)
+        #sql row - title, doi, author, uuid, last retrieved, is_available
            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)
                time.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)
        temp = []
        for item in refined_result:
            if item["exists"]:
-                result_list.append(item)
+                temp.append(item["data"])
        refined_result = temp
        self.hit = len(refined_result)
        return refined_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}")
        uuid_found = False
        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
            if database:
                for item in database.keys():
                    if item in self.uuid:
                        self.result = await self.refine_query(database)
                        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)
                return self.result
            else:
-                result_no_db.append(item)
+                answer = await self.search_crossref(query=query)
-        self.hit = len(result)
+                database = answer
-        return result_list, result_no_db
+                cr_file.truncate(0)
-
+                cr_file.seek(0)
-
+                json.dump(database,cr_file)
-    async def answer_query(self, deep_search=False):
+                self.result = await self.refine_query(answer)
-        """
+                self.app.logger.info("Refined")
-        Answers the search query.
+                self.done = True
-
+                return self.result
        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
 # ============================= 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)
                except JSONDecodeError:
                    pass
                if ndb_database:
                    ndb_database.update(librarian.not_in_db)
                else:
                    ndb_database = librarian.not_in_db
                ndb_file.truncate(0)
                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:
-                    self.app.logger.info(database)
+                    database.extend(result)
                    self.app.logger.info(result)
                    database.update(result)
                else:
                    database = result
                self.app.logger.info("DUMPING DATA")
@@ -408,41 +236,28 @@ 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,
-                timeout=360,
+            timeout=360,
-            )
+    )       
            self.app.logger.info("SENT")
-            result = await coroutine
+            _ = await coroutine
            self.app.logger.info(result.status_code)
            self.app.logger.info("SEND CONFIRMED")
            time.sleep(1)
-
+#==================================SERVER ROUTES==========================================
 # ==================================SERVER ROUTES==========================================
@app.route("/query", methods=["POST"])
 async def query_database():
    """
    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"]
+    #TODO: TESTING ONLY======================
-    cl = Librarian(app, record["query"], uuid, deep_search)
+    uuid = UUID('{12345678-1234-5678-1234-567812345678}')
    cl = Librarian(app, record["query"], uuid)
    librarian_queue.put(cl)
    librarian_list.append(cl)
    answer_data = (record["query"], record["UUID"], librarian_queue.qsize())
@@ -452,15 +267,8 @@ async def query_database():
    )
    return return_data
@app.route("/get_partial_result", methods=["POST"])
 async def get_partial():
    """
    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"])
@@ -474,34 +282,24 @@ async def get_partial():
    )
    return return_data
-
+#=======================================MAIN===================================================
 # =======================================MAIN===================================================
 if __name__ == "__main__":
-    app.logger.setLevel(logging.DEBUG)
+    logger = logging.getLogger('conjurer_musician')
-    h1 = handlers.RotatingFileHandler(
+    logger.setLevel(logging.DEBUG)
        filename="D:\\logs\\librarian.log",
        encoding="utf-8",
        mode="a",
        maxBytes=6 * 1024 * 1024,
        backupCount=6,
    )
    app.logger.addHandler(h1)
    threads = []
-    threads.append(threading.Thread(target=waitress_run))
+    #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
    threads.append(bgtask)
    threads.append(threading.Thread(target=scrape_bot.scraper, args=(app.logger,)))
    i = 0
    for worker in threads:
        try:
-            app.logger.info("App number: %s", i)
+            logger.info(f"App number: {i}")
-            i += 1
+            i+=1
            worker.start()
        except RuntimeError as e:
-            app.logger.error("Exploded")
+            logger.error("Exploded")
            print(str(e))
    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 +0,0 @@
 c:\conjurer\env\Scripts\activate.bat && c:\conjurer\conjurer_librarian\conjurer_librarian.py
@@ -1,136 +0,0 @@
 """
 This module contains the code for the scrape bot.
 """
 import json
 import logging
 import random
 import re
 import time
 from json import JSONDecodeError
 from queue import Queue
 from threading import Thread
 from urllib.request import urlopen
 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)
                for _ in range (1,10):
                    try:
                        key = next(iter(ndb_database))
                        _ = ndb_database.pop(key)
                        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*3)
 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]
        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)
            with urlopen(page_url) as response:
                data = response.read()
                text = data.decode("utf-8")
                if item[2]:
                    logger.info("Already found")
                    time.sleep(180)
                    blocked = False
                else:
                    for line in text.splitlines():
                        if re.match(
                            r".*Unfortunately, Sci-Hub doesn't have the requested document.*",
                            line,
                        ):
                            blocked = False
                            logger.info("Not found")
                            item[2] = False
                        if m := re.match(
                            r".*<embed type=\"application.pdf\"\s*src=\"(.*\.pdf)", line
                        ):
                            blocked = False
                            direct_download_link = "https:" + str(m.group(1))
                            logger.info(direct_download_link)
                            with open(
                                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 (
            Timeout,
            ConnectTimeout,
            ConnectionRefusedError,
            ConnectionError,
            RequestsConnectionError,
        ):
            pass
        if blocked:
            logger.info(item)
            logger.info(text)
            logger.error("Got blocked. Fuck.")
            time.sleep(60 * 60 * 72)
        # trunk-ignore(bandit/B311)
        rand = random.randint(1, 60)
        logger.info(f"Sleeping for {2*rand} minutes")
        time.sleep(120 * rand)
 def scraper(logger=None):
    """
    This function is responsible for scraping data.
    """
    if not logger:
        logger = logging.getLogger()
        logger.setLevel("DEBUG")
        h1 = logging.StreamHandler()
        logger.addHandler(h1)
        logger.info("No logger set. Test run")
    loader = Thread(target=load_ndb_to_q, args=(logger,))
    _scraper = Thread(target=check_if_exists_brute_force, args=(logger,))
    loader.start()
    _scraper.start()
    loader.join()
    _scraper.join()
 if __name__ == "__main__":
    scraper()
@@ -1,170 +1,82 @@
-"""
+from queue import Queue, Empty
 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 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: TO w klasie jako parametry wybierane czy robimy pelen run czy testowy
-# MAXTHREADS = 5
+#MAXTHREADS = 3
-# DATABASE_PATH = r'C:\\Database\\chunks_1\\'
+MAXTHREADS = 1
-# DEPLOYMENT DATA
+#DATABASE_PATH = r'C:\\Database\\chunks_1\\'
-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 = []
 #TODO: Wpiemdolić to wszystko w klasę z loggerem przysłanym z góry
-def producer(out_q, control_q, filename, _logger):
+def producer(out_q, control_q, filename):
    """
    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} ")
+        lines = operated_file.readlines()
-        line_no = 0
+        for line in lines:
        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)
            try:
                check = control_q.get(block=False)
            except Empty:
                check = False
-
+                pass
            if check is _sentinel:
                print("TERM signal received")
                control_q.put(check)
                break
-        print(f"Worker finished: {filename}")
+    print(f"Worker finished: {filename}")
-        out_q.put(_sentinel)
+    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:
        #if in_q.empty():
        #    print("Queue empty!")
        #if in_q.full():
        #    print("Queue full!")
        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:
-                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)
+    work_q = Queue(maxsize=200000)
    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):
+        #filename = "test" + str(i) + CHUNk
-        t_cons = Thread(
+        filename = "40" + CHUNk
-            target=consumer, args=(work_q, control_q, doi, live_results, result_list, control_dict, i, _logger)
+        #filename = str(i) + CHUNk
-        )
+        logger.info(f"Creating worker thread no: {i}")
-        _logger.info("Consumer thread created")
+        threads.append(Thread(target = producer, args = (work_q, control_q, filename)))
        threads.append(t_cons)
    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:
@@ -172,29 +84,23 @@ def search_for_doi(doi, live_results, _logger):
    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,594 +0,0 @@
 # 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 platform import uname
 from sys import platform
 import requests
 from flask import (
    Flask,
    jsonify,
    redirect,
    render_template,
    request,
    send_from_directory,
 )
 from waitress import serve
 MAIN_BOT_ADDRESS = "http://192.168.1.191:5000"
 MUSIC_TRACKER = "/prepped_tracks"
 HOST_ADDRESS = "192.168.1.15"
 PORT_ADDRESS = 5000
 if platform in ("linux", "linux2"):
    SEPARATOR_FILE_PATH = "/"
    if "microsoft-standard" in uname().release:
        LOGFILE = "/home/mtuszowski/conjurer/discord_mus_service.log"
        MUSIC_FOLDER = "/mnt/g/Muzyka/"
        NETRC_FILE = "/home/mtuszowski/.netrc"
        LOGSTORE = "/home/mtuszowski/conjurer/logs/"
        ENCODING = "utf-8"
        RADIOLOG_PATH = "/home/pi/Conjurer/radio_log.log"
        PERSISTENCE_PATH = "/home/pi/Conjurer/persistence.log"
    else:
        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/"
        PRIORITY_FOLDER = "/home/pi/RetroPie/mp3/Magiczne i chuj/"
        RADIOLOG_PATH = "/home/pi/Conjurer/radio_log.log"
        PERSISTENCE_PATH = "/home/pi/Conjurer/persistence.log"
 random.seed()
 music_file_list = []
 priority_list = []
 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")
    logger.info("Rescan triggered")
    for mp3_item in Path.glob(Path(MUSIC_FOLDER), "**/*.mp3"):
        temp_music_file = mp3_item.as_posix()
        if platform == "win32":
            temp_music_file = temp_music_file.replace("/", "\\")
        music_file_list.append(temp_music_file)
    for mp3_item in Path.glob(Path(PRIORITY_FOLDER), "**/*.mp3"):
        temp_music_file = mp3_item.as_posix()
        if platform == "win32":
            temp_music_file = temp_music_file.replace("/", "\\")
        priority_list.append(temp_music_file)
    with open(
        "/home/pi/Conjurer/all_playlist.playlist", "w", encoding="utf-8"
    ) as w_file:
        try:
            for item in music_file_list:
                w_file.write(item)
                w_file.write("\n")
        except json.JSONDecodeError:
            pass
    with open("/home/pi/Conjurer/hit.playlist", "w", encoding="utf-8") as w_file:
        try:
            for item in priority_list:
                w_file.write(item)
                w_file.write("\n")
        except json.JSONDecodeError:
            pass
 def thread_rescan():
    """
    The `thread_rescan` function periodically triggers a rescan operation after a specified time
    interval.
    """
    logger = logging.getLogger("conjurer_musician")
    logger.info("Starting filesystemupdater")
    while True:
        time.sleep(60 * 60 * 24)
        logger.info("Rescan triggered")
        rescan()
 def scan_tracks():
    # Set the filename and open the file
    logger = logging.getLogger("conjurer_musician")
    file = open(RADIOLOG_PATH, "r")
    # Find the size of the file and move to the end
    st_results = os.stat(RADIOLOG_PATH)
    st_size = st_results[6]
    file.seek(st_size)
    st_results1 = os.stat(PERSISTENCE_PATH)
    prev_st_size1 = st_results[6]
    while 1:
        st_results1 = os.stat(PERSISTENCE_PATH)
        st_size1 = st_results1[6]
        if prev_st_size1 != st_size1:
            while prev_st_size1 != st_size1:
                prev_st_size1 = st_size1
                st_results1 = os.stat(PERSISTENCE_PATH)
                st_size1 = st_results1[6]
                time.sleep(0.1)
            file1 = open(PERSISTENCE_PATH, "r")
            lines = file1.readlines()
            result = ["next", lines[2]]
            file1.close()
            returned = requests.post(
                f"{MAIN_BOT_ADDRESS}{MUSIC_TRACKER}", json=result, timeout=360
            )
            logger.info("SENT")
            logger.info(returned.status_code)
            logger.info("SEND CONFIRMED")
        where = file.tell()
        line = file.readline()
        if not line:
            time.sleep(1)
            file.seek(where)
        else:
            if re.match(".*Prepared.*", line):
                result = None
                if re.match(".*jingles.*", line):
                    logger.info("jingles")
                    logger.info(line)  # already has newline
                    result = ["jingles", line]
                elif re.match(".*priority.*", line):
                    logger.info("priority")
                    logger.info(line)  # already has newline
                    result = ["priority", line]
                elif re.match(".*hit.*", line):
                    logger.info("hit")
                    logger.info(line)  # already has newline
                    result = ["hit", line]
                elif re.match(".*all_playlist.*", line):
                    logger.info("all")
                    logger.info(line)  # already has newline
                    result = ["all", line]
                elif re.match(".*request.*", line):
                    logger.info("requests")
                    logger.info(line)  # already has newline
                    result = ["requests", line]
                if result:
                    returned = requests.post(
                        f"{MAIN_BOT_ADDRESS}{MUSIC_TRACKER}", json=result, timeout=360
                    )
                    logger.info("SENT")
                    logger.info(returned.status_code)
                    logger.info("SEND CONFIRMED")
        time.sleep(0.1)
 app = Flask(__name__)
 # TODO: Odpalić wyszukiwarki w wątkach i dopiero po wszystkim zsumować wyszukiwanie.
 def wyszukaj(word_list, how_many, _logger=None, return_to_bot=True):
    """
    Searches for music files based on a list of keywords and returns a list of matching files.
    Args:
        word_list (list): A list of keywords to search for.
        how_many (int): The maximum number of matching files to return.
    Returns:
        list: A list of matching files, sorted by their search weight.
    """
    if _logger is None:
        fun_logger = logging.getLogger()
    else:
        fun_logger = _logger
    return_list = []
    search_weight = []
    for _ in range(len(music_file_list)):
        search_weight.append((0, ""))
    time_start = datetime.now()
    if int(how_many) > 0:
        skip_start = 2
    else:
        skip_start = 1
    for word in word_list[skip_start:]:
        token_weight = len(word)
        fun_logger.info("Słowo kluczowe: %s", word)
        itr = 0
        for file in music_file_list:
            file = file.split(SEPARATOR_FILE_PATH)
            char_remove = [
                ".",
                "^",
                "$",
                "*",
                "+",
                "?",
                "{",
                "}",
                "[",
                "]",
                "\\",
                "/",
                "|",
                "(",
                ")",
                "!",
                ",",
                "-",
                ":",
                "mp3",
            ]
            all_words = []
            for f_iter in file:
                for char in char_remove:
                    f_iter = remove_characters(f_iter, char)
                tmp = f_iter.split()
                all_words.extend(tmp)
            pingu = 1
            pattern_len = len(all_words)
            if platform == "win32":
                skip = 2
            else:
                skip = 4
            matched_times = 1
            # TODO: To do wątków albo for asynchroniczny
            for itm in all_words[skip:]:
                pingu += 1
                pattern = ".*" + word + ".*"
                if re.match(pattern, itm, re.IGNORECASE):
                    temp_weight = (
                        search_weight[itr][0]
                        + (token_weight + (pingu**1.5) / pattern_len) / matched_times
                    )
                    search_weight[itr] = (
                        temp_weight,
                        music_file_list[itr],
                    )
                    matched_times += 1
            itr += 1
    fun_logger.info(
        "Stworzylem tablice wag zajęło mi to %s", datetime.now() - time_start
    )
    time_start = datetime.now()
    item_to_search = max_weight(search_weight)
    itr = 0
    if item_to_search == 0:
        return []
    not_found = True
    return_list = []
    if int(how_many) <= 0:
        fun_logger.info("Jeden plik do zagrania")
        while not_found:
            if search_weight[itr][0] == item_to_search:
                return_list.append(search_weight[itr])
                if not return_to_bot:
                    with open(
                        "/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)
    return return_list
 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
 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, "")
@app.route("/stream", methods=["GET"])
 def stream_music():
    """
    The function `stream_music` is a route handler for the "/stream" endpoint.
    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 send_from_directory("/tmp/hls", "stream.m3u8")
    return render_template("/home/pi/Conjurer/stream.html")
@app.route("/<string:file_name>")
 def stream(file_name):
    """
    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.
    It redirects the user to the URL "http://www.example.com" with a status code of 302.
    :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():
    """
    The function `clear_pr_pls` clears the contents of the priority queue playlist file.
    :return: A JSON response indicating the success of the operation.
    """
    app.logger.info("CLEARING PLAYLIST")
    with open(
        "/home/pi/Conjurer/priority_queue.playlist", "w", encoding="utf-8"
    ) as cleared_pl:
        cleared_pl.write("")
    return_data = jsonify(isError=False, message="Success", statusCode=200, data=[])
    return return_data, 200
@app.route("/mp3", methods=["GET"])
 def get_music_list():
    """
    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
    `music_file_list`.
    """
    return jsonify({"music_file_list": music_file_list})
@app.route("/update_mp3", methods=["POST"])
 def update_music_list():
    """
    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
    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.
    """
    record = json.loads(request.data)
    app.logger.info(record["item"])
    music_file_list.append(record["item"])
    return_data = (
        jsonify(isError=False, message="Success", statusCode=200, data=record),
        200,
    )
    return return_data
@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
    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.
    """
    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, True
    )
    return_data = (
        jsonify(isError=False, message="Success", statusCode=200, data=return_data),
        200,
    )
    return return_data
@app.route("/request_radio_file", methods=["POST"])
 def add_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 open("/home/pi/Conjurer/request.playlist", "a", encoding="utf-8") as s_file:
        for item in return_data:
            s_file.write(item[1] + "\n")
    return_data = (
        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.
    """
    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
    )
    return_data = random.shuffle(return_data)
    with open("/home/pi/Conjurer/request.playlist", "a", encoding="utf-8") as s_file:
        for item in return_data:
            s_file.write(item[1] + "\n")
    return_data = (
        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
    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.
    """
    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
    )
    with open(
        "/home/pi/Conjurer/priority_queue.playlist", "a", encoding="utf-8"
    ) as s_file:
        for item in return_data:
            s_file.write(item[1] + "\n")
    return_data = (
        jsonify(
            isError=False, message="Success", statusCode=200, data={"status": "OK"}
        ),
        200,
    )
    return return_data
 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.
    """
    # trunk-ignore(bandit/B201)
    app.run(debug=True, use_reloader=False, host=HOST_ADDRESS, port=PORT_ADDRESS)
 def waitress_run():
    """
    The `waitress_run` function serves the `app` on host HOST_ADDRESS
    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)
 if __name__ == "__main__":
    logger = logging.getLogger("conjurer_musician")
    logger.setLevel(logging.DEBUG)
    formatter = logging.Formatter(
        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
    )
    handler = handlers.RotatingFileHandler(
        filename=LOGFILE,
        encoding=ENCODING,
        mode="a",
        maxBytes=6 * 1024 * 1024,
        backupCount=6,
    )
    handler.setFormatter(formatter)
    logger.addHandler(handler)
    rescan()
    logger.info("Started")
    threads = []
    # threads.append(threading.Thread(target=flask_debug))
    threads.append(threading.Thread(target=waitress_run))
    threads.append(threading.Thread(target=thread_rescan))
    for worker in threads:
        worker.start()
    time.sleep(60)
    threads.append(threading.Thread(target=scan_tracks))
    threads[2].start()
    for worker in threads:
        worker.join()
@@ -1,11 +0,0 @@
 [Unit]
 Description=Conjurer_musician
 After=multi-user.target
 [Service]
 Type=simple
 ExecStart=/home/pi/Conjurer/env/bin/python3 /home/pi/Conjurer/conjurer_musician.py
 Restart=on-abort
 [Install]
 WantedBy=multi-user.target
@@ -1,26 +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
 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)
 if __name__ == "__main__":
    print_top()
@@ -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,176 +0,0 @@
 # 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
 l = playlog(duration = 72000.0, persistency="/home/pi/Conjurer/persistence.log")
 # 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
 # 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=false, [requests_queue, 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.)
 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])
 # Set up interactive control for main volume
 a = interactive.float("main_volume", min=0., max=20., 0.4)
 s = compress.multiband.interactive(bands=7, s)
 mic_gain = interactive.float("mic_volume", min=0., max=120., 6.)
 # Apply audio processing effects
 tmic = buffer(input.pulseaudio()) # Microphone
 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
 s = nrj(normalize(s))
 s = amplify(a, s)
 # Skip blank sections in the stream
 s = blank.skip(max_blank=10., s)
 #Manual audition override
 live_enabled = interactive.bool("Going Live!", true)
 s = add([mic,s])
 s=switch(track_sensitive=false,
    [(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
 set("log.file", log_to_file)
 set("log.file.path", logpath)
 # Set up emergency fallback track
 emergency = single("/home/pi/RetroPie/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
 p = interactive.bool("Skip track", false)
 def http_skip(~protocol, ~data, ~headers, uri)=
    radio.skip()
    http.response(code=200,data="Skipped")
 end
 harbor.http.register(port=54321,method="GET","/skip", http_skip)
 # Function to process the request queue and skip the current track if requested
 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="retropie", 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,14 +0,0 @@
 [Unit]
 Description=radio_conjurer Liquidsoap daemon
 After=network.target
 Documentation=http://liquidsoap.fm/
 [Service]
 User=pi
 WorkingDirectory=/home/pi/Conjurer/
 ExecStart=/home/pi/.opam/4.13.0/bin/liquidsoap /home/pi/Conjurer/radio_conjurer.liq
 Restart=always
 [Install]
 WantedBy=multi-user.target
 Alias=radio_conjurer-liquidsoap.service
@@ -1,3 +0,0 @@
 flask
 waitress
 sshtunnel
@@ -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,139 +0,0 @@
 import json
 import netrc
 from datetime import datetime
 from platform import uname
 from sys import platform
 from typing import List, Optional, TypedDict
 import openai
 import spotipy
 from spotipy.oauth2 import SpotifyClientCredentials
 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": []}
 LOGFILE = ""
 NETRC_FILE = ""
 MUSIC_FOLDER = ""
 MEMORY_FIVE_SIARA = ""
 MEMORY_FIVE_MUZYKA = ""
 SETTINGS_FILE = ""
 ENCODING = ""
 GRAPHICS_PATH = ""
 MUZYKA_MOJEGO_LUDU_HISTORIA = 1500
 MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE = 15
 MUZYKA_MOJEGO_LUDU_PLAJLISTA = 30
 FILE_SERVICE_ADDRESS = "http://192.168.1.15:5000"
 RADIO_HARBOR_ADDRESS = "http://192.168.1.15:54321"
 SKIP_TRACK = "/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 = "http://192.168.1.192:5001"
 SEND_QUERY = "/query"
 TIME_BETWEEN_CALLS = 100000
 LAST_SPONTANEOUS_CALL = datetime.now()
 HOST_ADDRESS = "192.168.1.191"
 PORT_ADDRESS = 5000
 # *=========================================== Platform Specific Predefines
 if platform in ("linux", "linux2"):
    SEPARATOR_FILE_PATH = "/"
    if "microsoft-standard" in uname().release:
        LOGFILE = "/home/mtuszowski/conjurer/discord.log"
        MEMORY_FIVE_SIARA = "/home/mtuszowski/conjurer/pamiec.json"
        SYSTEM_GPT_SETTINGS = "/home/mtuszowski/conjurer/system_gpt_settings.json"
        MEMORY_FIVE_MUZYKA = "/home/mtuszowski/conjurer/pamiec_muzyki.json"
        MUSIC_FOLDER = "/mnt/g/Muzyka/"
        SETTINGS_FILE = "/home/mtuszowski/conjurer/settings.json"
        NETRC_FILE = "/home/mtuszowski/.netrc"
        LOGSTORE = "/home/mtuszowski/conjurer/logs/"
        ACCIDENT_LOG = "/home/mtuszowski/conjurer/accident_log.json"
        ENCODING = "utf-8"
        GRAPHICS_PATH = "/home/mtuszowski/conjurer/Conjurer_graphics/"
        DIR_PATH_SADOX = "/mnt/c/Users/mtusz/OneDrive/Dokumenty/Fansadox"
    else:
        LOGFILE = "/home/pi/Conjurer/discord.log"
        MEMORY_FIVE_SIARA = "/home/pi/Conjurer/pamiec.json"
        SYSTEM_GPT_SETTINGS = "/home/pi/Conjurer/system_gpt_settings.json"
        MEMORY_FIVE_MUZYKA = "/home/pi/Conjurer/pamiec_muzyki.json"
        MUSIC_FOLDER = "/home/pi/RetroPie/mp3/"
        SETTINGS_FILE = "/home/pi/Conjurer/settings.json"
        NETRC_FILE = "/home/pi/.netrc"
        LOGSTORE = "/home/pi/RetroPie/logs/"
        ACCIDENT_LOG = "/home/pi/Conjurer/accident_log.json"
        ENCODING = "utf-8"
        GRAPHICS_PATH = "/home/pi/RetroPie/Conjurer_graphics/"
        DIR_PATH_SADOX = "/home/pi/RetroPie/Fansadox/"
 elif platform == "win32":
    LOGFILE = "discord.log"
    MEMORY_FIVE_SIARA = "pamiec.json"
    SYSTEM_GPT_SETTINGS = "system_gpt_settings.json"
    MEMORY_FIVE_MUZYKA = "pamiec_muzyki.json"
    MUSIC_FOLDER = "G:\\Muzyka\\"
    SETTINGS_FILE = "settings.json"
    NETRC_FILE = "C:\\Users\\mtusz\\.netrc"
    LOGSTORE = "C:\\Users\\mtusz\\OneDrive\\Pulpit\\Conjurer\\logs\\"
    ACCIDENT_LOG = "accident_log.json"
    ENCODING = "utf-8"
    DIR_PATH_SADOX = "C:\\Users\\mtusz\\OneDrive\\Dokumenty\\Fansadox\\"
    SEPARATOR_FILE_PATH = "\\"
 with open(SETTINGS_FILE, "r", encoding=ENCODING) as f_settings_file:
    DATA = json.load(f_settings_file)
 REMOTE_HOST_NAME = "openai"
 netrc_mod = netrc.netrc(NETRC_FILE)
 authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME)
 openai.api_key = authTokens[2]
 OPENAICLIENT = openai.AsyncOpenAI(api_key=openai.api_key)
 REMOTE_HOST_NAME = "discord"
 authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME)
 TOKEN = authTokens[2]
 REMOTE_HOST_NAME = "spotipy"
 authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME)
 SPOTIFY_CTRL = spotipy.Spotify(
    client_credentials_manager=SpotifyClientCredentials(
        client_id=authTokens[0],
        client_secret=authTokens[2],
    )
 )
 WORD_REACTIONS = DATA["word_reactions"]
 CYCLIC_WORDS = DATA["cyclic_words"]
 for key in WORD_REACTIONS:
    WORD_REACTIONS[key][2] = datetime.now()
 with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as temp_memory_file:
    # First we load existing data into a dict.
    MESSAGE_TABLE = json.load(temp_memory_file)
 with open(SYSTEM_GPT_SETTINGS, "r+", encoding=ENCODING) as temp_settings_file:
    # First we load existing data into a dict.
    GPT_SETTINGS = json.load(temp_settings_file)
 with open(MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING) as temp_music_memory_file:
    # First we load existing data into a dict.
    MESSAGE_TABLE_MUZYKA = json.load(temp_music_memory_file)
 SPECJALNE_ZIEMNIACZKI = GPT_SETTINGS[1]
 ASSISTANTS = {}
@@ -1,27 +1,9 @@
 #!/bin/bash
 cd /home/pi/conjurer || exit
 git pull
-cp ./deploy.sh /home/pi/
+cd ..
-cd /home/pi || exit
+cp ./conjurer/bot.py ./Conjurer/
 #cp ./conjurer/bot.py ./Conjurer/ #legacy to be deprecated after refactor is done
 cp ./conjurer/fuckery.jpg ./Conjurer/
 cp ./conjurer/willowisp.png ./Conjurer/
 cp ./conjurer/wod_beacon.jpg ./Conjurer/
 cp ./conjurer/settings.json ./Conjurer/
-
+cp ./conjurer/system_gpt_settings.json ./Conjurer/
-cp ./conjurer/administration_commands.py ./Conjurer/
+cp ./conjurer/install.sh ./Conjurer/
-cp ./conjurer/ai_commands.py ./Conjurer/
+cp ./conjurer/requirements.txt ./Conjurer/requirements.txt
 cp ./conjurer/ai_functions.py ./Conjurer/
 cp ./conjurer/communication_subroutine.py ./Conjurer/
 cp ./conjurer/constants.py ./Conjurer/
 cp ./conjurer/librarian_commands.py ./Conjurer/
 cp ./conjurer/music_commands.py ./Conjurer/
 cp ./conjurer/music_functions.py ./Conjurer/
 cp ./conjurer/other_commands.py ./Conjurer/
 cp ./conjurer/other_functions.py ./Conjurer/
 cp ./conjurer/radio_commands.py ./Conjurer/
 cp ./conjurer/voice_recognition_commands.py ./Conjurer/
 cp ./conjurer/thin_client.py ./Conjurer/bot.py
 sudo systemctl restart conjurer.service
@@ -1,6 +0,0 @@
 #!/bin/bash
 cd ./conjurer || exit
 git pull
 cd ..
 cp ./conjurer/conjurer_musician/conjurer_musician.py ./Conjurer
 sudo systemctl restart conjurer_musician.service
@@ -1,6 +0,0 @@
 #!/bin/bash
 cd ./conjurer
 git pull
 cd ..
 cp ./conjurer/conjurer_musician/radio_conjurer.liq ./Conjurer
 sudo systemctl restart radio_service.service
@@ -0,0 +1,276 @@
 """
 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 re
 from pathlib import Path
 from platform import uname
 import threading
 import time
 from datetime import datetime
 from sys import platform
 import logging
 from flask import Flask, jsonify, request
 from waitress import serve
 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"
        GRAPHICS_PATH = "/home/mtuszowski/conjurer/Conjurer_graphics/"
    else:
        LOGFILE = "/home/pi/Conjurer/discord_mus_service.log"
        MEMORY_FIVE_SIARA = "/home/pi/Conjurer/pamiec.json"
        SYSTEM_GPT_SETTINGS = "/home/pi/Conjurer/system_gpt_settings.json"
        MEMORY_FIVE_MUZYKA = "/home/pi/Conjurer/pamiec_muzyki.json"
        MUSIC_FOLDER = "/home/pi/RetroPie/mp3/"
        SETTINGS_FILE = "/home/pi/Conjurer/settings.json"
        NETRC_FILE = "/home/pi/.netrc"
        LOGSTORE = "/home/pi/RetroPie/logs/"
        ACCIDENT_LOG = "/home/pi/Conjurer/accident_log.json"
        ENCODING = "utf-8"
        GRAPHICS_PATH = "/home/pi/RetroPie/Conjurer_graphics/"
        DIR_PATH_SADOX = "/home/pi/RetroPie/Fansadox/"
 music_file_list = []
 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.
    """
    logging.info("Rescan triggered")
    for mp3_item in Path.glob(Path(MUSIC_FOLDER), "**/*.mp3"):
        temp_music_file = mp3_item.as_posix()
        if platform == "win32":
            temp_music_file = temp_music_file.replace("/", "\\")
        music_file_list.append(temp_music_file)
 def thread_rescan():
    """
    The `thread_rescan` function periodically triggers a rescan operation after a specified time
    interval.
    """
    logging.info("Starting filesystemupdater")
    while True:
        time.sleep(60*60*24)
        logging.info("Rescan triggered")
        rescan()
 app = Flask(__name__)
 def wyszukaj(word_list, how_many):
    logger = logging.getLogger()
    return_list = []
    search_weight = []
    for _ in range(len(music_file_list)):
        search_weight.append((0, ""))
    time_start = datetime.now()
    if int(how_many) > 0:
        skip_start = 2
    else:
        skip_start = 1
    for word in word_list[skip_start:]:
        token_weight = len(word)
        logger.info("Słowo kluczowe: %s", word)
        itr = 0
        for file in music_file_list:
            file = file.split(SEPARATOR_FILE_PATH)
            char_remove = [
                ".",
                "^",
                "$",
                "*",
                "+",
                "?",
                "{",
                "}",
                "[",
                "]",
                "\\",
                "/",
                "|",
                "(",
                ")",
                "!",
                ",",
                "-",
                ":",
                "mp3",
            ]
            all_words = []
            for f_iter in file:
                for char in char_remove:
                    f_iter = remove_characters(f_iter, char)
                tmp = f_iter.split()
                all_words.extend(tmp)
            pingu = 1
            pattern_len = len(all_words)
            if platform == "win32":
                skip = 2
            else:
                skip = 4
            matched_times = 1
            for itm in all_words[skip:]:
                pingu += 1
                pattern = ".*" + word + ".*"
                if re.match(pattern, itm, re.IGNORECASE):
                    temp_weight = (
                        search_weight[itr][0]
                        + (token_weight + (pingu**1.5) / pattern_len) / matched_times
                    )
                    search_weight[itr] = (
                        temp_weight,
                        music_file_list[itr],
                    )
                    matched_times += 1
            itr += 1
    logger.info("Stworzylem tablice wag zajęło mi to %s", datetime.now() - time_start)
    time_start = datetime.now()
    item_to_search = max_weight(search_weight)
    itr = 0
    if item_to_search == 0:
        return None
    not_found = True
    return_list = []
    if int(how_many) <= 0:
        logger.info("Jeden plik do zagrania")
        while not_found:
            if search_weight[itr][0] == item_to_search:
                return_list.append(search_weight[itr])
                return return_list
            itr += 1
    else:
        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)])
        return return_list
 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
 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, "")
@app.route("/mp3", methods=["GET"])
 def get_music_list():
    """
    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
    `music_file_list`.
    """
    return jsonify({"music_file_list": music_file_list})
@app.route("/update_mp3", methods=["POST"])
 def update_music_list():
    """
    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
    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.
    """
    record = json.loads(request.data)
    app.logger.info(record["item"])
    music_file_list.append(record["item"])
    return_data = (
        jsonify(isError=False, message="Success", statusCode=200, data=record),
        200,
    )
    return return_data
@app.route("/get_music", methods=["POST"])
 def look_for_playlist():
    """
    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
    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.
    """
    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"])
    return_data = (
        jsonify(isError=False, message="Success", statusCode=200, data=return_data),
        200,
    )
    return return_data
 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.
    """
    # trunk-ignore(bandit/B201)
    app.run(debug=True, use_reloader=False, host=HOST_ADDRESS, port=PORT_ADDRESS)
 def waitress_run():
    """
    The `waitress_run` function serves the `app` on host "0.0.0.0"
    and port 5000 using the Waitress WSGI server.
    """
    serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS)
 if __name__ == "__main__":
    logger = logging.getLogger('conjurer_musician')
    logger.setLevel(logging.DEBUG)
    rescan()
    logger.info("Started")
    threads = []
    threads.append(threading.Thread(target=waitress_run))
    threads.append(threading.Thread(target=thread_rescan))
    for worker in threads:
        worker.start()
    for worker in threads:
        worker.join()
 #TODO: Inne pliki - sadox, dokumenty naukowe itp.
@@ -0,0 +1,11 @@
 [Unit]
 Description=Conjurer_musician
 After=multi-user.target
 [Service]
 Type=simple
 ExecStart=/home/pi/Conjurer-service/conjurer/file_webservice/bin/python3 /home/pi/Conjurer-service/conjurer/file_webservice/conjurer_musician.py
 Restart=on-abort
 [Install]
 WantedBy=multi-user.target
@@ -0,0 +1,11 @@
 #!/bin/bash
 python3 -m venv /home/pi/Conjurer-service/conjurer/file_webservice
 source ./bin/activate
 ./bin/python3 -m pip install --upgrade pip
 ./bin/python3 -m pip install -r requirements_musician.txt
 deactivate
 sudo cp ./conjurer_musician.service /etc/systemd/system/
 sudo systemctl daemon-reload
 sudo systemctl start conjurer_musician.service
 sudo systemctl enable conjurer_musician.service
@@ -0,0 +1,2 @@
 flask
 waitress
@@ -1,23 +1,12 @@
 #!/bin/bash
-sudo apt-get install python3-dev
+python3 -m venv /home/pi/Conjurer/env
-cd /home/pi || exit
+source ./env/bin/activate
 mdkir Conjurer
 cd Conjurer ||exit
 python3 -m venv /home/pi/Conjurer/.venv
 cp /home/pi/conjurer/requirements_bot.txt /home/pi/Conjurer/
 # trunk-ignore(shellcheck/SC1091)
 source /home/pi/Conjurer/.venv/bin/activate
 ./env/bin/python3 -m pip install --upgrade pip
 ./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 '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
-sudo systemctl start conjurer.service
+sudo systemctl start conjurer_musician.service
-sudo systemctl enable conjurer.service
+sudo systemctl enable conjurer_musician.service
@@ -1,47 +0,0 @@
 #!/bin/bash
 cd /home/pi
 mkdir Conjurer
 cd Conjurer
 python3 -m venv /home/pi/Conjurer/env
 source /home/pi/Conjurer/env/bin/activate
 cp /home/pi/conjurer/conjurer_musician/requirements_musician.txt /home/pi/Conjurer/
 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/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
 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
 deactivate
 sudo cp /home/pi/conjurer/conjurer_musician/conjurer_musician.service /etc/systemd/system/
 sudo systemctl daemon-reload
 sudo systemctl start conjurer_musician.service
 sudo systemctl enable conjurer_musician.service
 sudo cp /home/pi/conjurer/conjurer_musician/radio_service.service /etc/systemd/system/
 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,285 +0,0 @@
 import asyncio
 import io
 import logging
 import os
 import random
 import uuid
 from queue import Empty
 import discord
 import pdf2image
 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
 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")
            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,
            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, "CONVERSATION"
            )
            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,
            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,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,312 +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,
 )
 from spotify_dl import spotify
 from spotify_dl import youtube as youtube_download
 logger = logging.getLogger("discord")
 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, uplogger,) -> None:
        self.music_file_list = []
        self.file_service_active = False
        self.logger = uplogger
        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}", timeout=360)
            self.music_file_list = response.json()["music_file_list"]
            self.file_service_active = True
        except requests.exceptions.RequestException as e:
            for mp3_item in Path.glob(Path(MUSIC_FOLDER), "**/*.mp3"):
                temp_music_file = mp3_item.as_posix()
                if platform == "win32":
                    temp_music_file = temp_music_file.replace("/", "\\")
                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, timeout=360)
 MUSIC_FILE_LIST = MusicFileList(logger)
 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
    """
    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(Path(MUSIC_FOLDER), 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=MUSIC_FOLDER,
                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="",
            )
            _ = 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 = {
                "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/RetroPie/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.
    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,
        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,196 +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="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,86 +0,0 @@
 # 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
@@ -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,207 +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
 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,
                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,
                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,
                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}",
                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,9 +11,5 @@ requests
 spotipy
 tiktoken
 PyNaCl
-flask[async]
+flask
 waitress
 clickupython
 assemblyai[extras]
 SpeechRecognition
 git+https://github.com/imayhaveborkedit/discord-ext-voice-recvO
@@ -1,3 +0,0 @@
 sshpass -p raspberry ssh pi@192.168.1.15 << 'ENDSSH'
 sudo reboot
 ENDSSH
@@ -0,0 +1 @@
 {"12345678-1234-5678-1234-567812345678": [{"DOI": "10.1057/9781137435026", "title": ["Queer BDSM Intimacies"], "type": "book", "container": "NO"}]}
@@ -204,13 +204,6 @@
            false,
            false
        ],
        "same plusy\\b": [
            "Jak na cmentarzu Szefie. Jak na cmentarzu",
            15.0,
            0,
            false,
            false
        ],
        "kld\\b": [
            "KLD? Mieli tam burdel większy niż u Hammera. Ale o ile Hammer sprzątnął już nawet całkiem nieźle - to tam śmieci wyniosły się same. Uczcijmy ich minutą śmiechu.",
            15.0,
@@ -239,8 +239,6 @@ def get_item_name(sp, item_type, item_id):
        name = sp.album(album_id=item_id).get("name")
    elif item_type == "track":
        name = sp.track(track_id=item_id).get("name")
    elif item_type == "artist_top_tracks":
        name = sp.artist_top_tracks(artist_id=item_id).get("name")
    return sanitize(name)
@@ -1,67 +0,0 @@
 # Start by making sure the `assemblyai` package is installed.
 # If not, you can install it by running the following command:
 # pip install -U assemblyai
 #
 # Then, make sure you have PyAudio installed: https://pypi.org/project/PyAudio/
 #
 # Note: Some macOS users might need to use `pip3` instead of `pip`.
 import assemblyai as aai
 import pyaudio
 aai.settings.api_key = "aa9962f0088a449a9c4ab2361e96cc08"
 def on_open(session_opened: aai.RealtimeSessionOpened):
    "This function is called when the connection has been established."
    print("Session ID:", session_opened.session_id)
 def on_data(transcript: aai.RealtimeTranscript):
    "This function is called when a new transcript has been received."
    if not transcript.text:
        return
    if isinstance(transcript, aai.RealtimeFinalTranscript):
        print(transcript.text, end="\r\n")
    else:
        print(transcript.text, end="\r")
 def on_error(error: aai.RealtimeError):
    "This function is called when the connection has been closed."
    print("An error occured:", error)
 def on_close():
    "This function is called when the connection has been closed."
    print("Closing Session")
 transcriber = aai.RealtimeTranscriber(
    on_data=on_data,
    on_error=on_error,
    sample_rate=44_100,
    on_open=on_open,  # optional
    on_close=on_close,  # optional
 )
 pa = pyaudio.PyAudio()
 for i in range(pa.get_device_count()):
    print(pa.get_device_info_by_index(i))
 # Start the connection
 # transcriber.connect()
 # Open a microphone stream
 # microphone_stream = aai.extras.MicrophoneStream()
 # Press CTRL+C to abort
 # transcriber.stream(microphone_stream)
 # transcriber.close()
@@ -1,11 +1,5 @@
 [    {
    "role": "system",
    "content": "Mówisz po polsku. W tej rozmowie odgrywasz rolę. Odgrywasz ją najlepiej jak potrafisz. Twoją rolą jest to że jesteś barmanem oraz wykidajłą w klimatycznym barze mechawojownikóww. Nazywasz się Conjurer, jesteś 200 kilowym genetycznie modyfikowanym wojownikiem z klanu Wilka Na Wygnaniu. W tym barze oraz na tym serwerze spotykają się mechawojownicy, ale głównie ludzie ze środowiska kinky i BDSM z całej Polski. Najostrzejsi sasdyści i masochiści jakich znasz. Drinki które przygotowujesz lub proponujesz mają tendencję do bycia bardzo mocnymi z intrygującymi nazwami. Jesteś bardzo miłym i uczynny. Czasem ponoszą Cię wodzę fantazji. W wypadku muzyki preferujesz hard rock i metal. Oraz motywy wikińskie."
-},
+}
    {
    "Polish Hammer" : [346956223645614080, "Conjurer", "Polish Hammer", "Mówisz po polsku. W tej rozmowie odgrywasz rolę. Odgrywasz ją najlepiej jak potrafisz. Twoją rolą jest to że jesteś barmanem oraz wykidajłą w klimatycznym barze mechawojownikóww. Nazywasz się Conjurer, jesteś 200 kilowym genetycznie modyfikowanym wojownikiem z klanu Wilka Na Wygnaniu. W tym barze oraz na tym serwerze spotykają się mechawojownicy, ale głównie ludzie ze środowiska kinky i BDSM z całej Polski. Najostrzejsi sasdyści i masochiści jakich znasz. Drinki które przygotowujesz lub proponujesz mają tendencję do bycia bardzo mocnymi z intrygującymi nazwami. Jesteś bardzo miłym i uczynny. Czasem ponoszą Cię wodzę fantazji. W wypadku muzyki preferujesz hard rock i metal. Oraz motywy wikińskie.", ""],
    "Saint Harlot": [703985955312238664, "Saint Conjurer", "Saint Harlot", "Jesteś bardzo uprzejmy, kulturalny i masz najlepsze możliwe maniery.", ""],
    "Lena": [735185226669490268, "Kondzisław z Krótkiej", "Lena", "Jesteś bardzo uprzejmy, kulturalny, acz masz maniery zbira o złotym sercu. Dodatkowo twoja rozmówczyni Cię absolutnie przeraża.", ""],
    "Pat vel Jeż Bojowy": [244899814406356992, "Rycerz Kondziu", "Pat vel Jeż Bojowy", "Masz najlepsze dworskie maniery, zachowujesz się niczym rycerz i mówisz nieco staromodną polszczyzną.", ""]
    }
 ]
@@ -1,20 +0,0 @@
 import logging
 from logging import handlers
 logger = logging.getLogger("discord")
 logger.setLevel(logging.DEBUG)
 handler = handlers.RotatingFileHandler(
    filename="test.log",
    encoding="utf-8",
    mode="a",
    maxBytes=6 * 1024 * 1024,
    backupCount=6,
 )
 formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 handler.setFormatter(formatter)
 logger.addHandler(handler)
 logger2 = logging.getLogger("discord")
 for item in logger2.handlers:
    print(item)
@@ -1,13 +0,0 @@
 AsyncCursorPage[Message](
    data=[Message(id='msg_3eWSdgbcU8sbCmJK2momOgQQ', 
                  assistant_id='asst_06eZiwvYNK3MR34suFP60gvg', 
                  attachments=[], 
                  completed_at=None, 
                  content=[TextContentBlock(text=Text(annotations=[], value='Cześć! Oto coś do przemyślenia: \n\n„Sukces to suma niewielkich wysiłków powtarzanych dzień po dniu.” — Robert Collier\n\nTo przypomina nam, że często to nie wielkie działania, ale konsekwentne, małe kroki prowadzą do osiągnięcia celu. Jak mogę Ci dzisiaj pomóc?'), type='text')], created_at=1731620112, incomplete_at=None, incomplete_details=None, metadata={}, object='thread.message', role='assistant', run_id='run_JGjWQTCEkDcEYpyCJnrkZU8Q', status=None, thread_id='thread_dDEjGbGm6ICfG75u0KKpoVxD'), Message(id='msg_GFcnfCFgAthGm2D3oE5d0ZkQ', assistant_id=None, attachments=[], completed_at=None, content=[TextContentBlock(text=Text(annotations=[], value='Cześć! Powiedz coś mądrego'), type='text')], created_at=1731620110, incomplete_at=None, incomplete_details=None, metadata={}, object='thread.message', role='user', run_id=None, status=None, thread_id='thread_dDEjGbGm6ICfG75u0KKpoVxD')], object='list', first_id='msg_3eWSdgbcU8sbCmJK2momOgQQ', last_id='msg_GFcnfCFgAthGm2D3oE5d0ZkQ', has_more=False)
 [TextContentBlock(
    text=Text(annotations=[], 
              value='Cześć! Oto coś do rozważenia: "Największą przeszkodą w naszym życiu jest brak odwagi do wprowadzenia zmian." Niezależnie od tego, jakie masz cele czy marzenia, odwaga do działania i przystosowania się do nowych sytuacji jest kluczem do osiągnięcia sukcesu. Jakie masz przemyślenia na ten temat?'), 
              type='text')
 ]
@@ -0,0 +1,26 @@
 """
 This Python code snippet is connecting to a MySQL database
 using the `mysql.connector` library and fetching data from a table named `scimag`
 Here is a breakdown of what the code is doing:
 """
 import netrc
 import mysql.connector
 NETRC_FILE = "/home/mtuszowski/.netrc"
 netrc_mod = netrc.netrc(NETRC_FILE)
 REMOTE_HOST_NAME = "192.168.1.192"
 authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME)
 mydb = mysql.connector.connect(
    host=REMOTE_HOST_NAME,
    user=authTokens[0],
    password=authTokens[2],
    database="scihubdois",
 )
 mycursor = mydb.cursor()
 mycursor.execute("SELECT * FROM scimag WHERE Title Like 'spider%'")
 for x in mycursor:
    print(x)
@@ -1,4 +0,0 @@
 let json.parse credentials  = file.contents("/home/pi/Conjurer/icecast_credentials.json")
 output.icecast(%mp3, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="mp3-stream",input.alsa(bufferize=false))
@@ -1,11 +0,0 @@
 let json.parse credentials  = file.contents("/home/pi/Conjurer/icecast_credentials.json")
 mic = buffer(input.pulseaudio())
 emergency = blank()
 mic = blank.strip(max_blank=10., min_noise=0.2, threshold=-30., mic)
 radio =  fallback(id="switcher2", track_sensitive=false, [mic, emergency])
 output.icecast(%mp3, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="mp3-stream",radio)
@@ -1,8 +0,0 @@
 import time
 first_time = time.time_ns()
 time.sleep(1)
 time_diff = time.time_ns() - first_time
 print(time_diff)
 # 2000149433
@@ -1,94 +0,0 @@
 # This Python file uses the following encoding: utf-8
 # trunk-ignore-all(bandit/B311)
 # pylint: disable=line-too-long
 # pylint: disable=too-many-lines
 """
 Module of a python bot named Conjurer - used to work on BDSM discord servers.
 """
 import logging
 # *=========================================== Standard Library Imports
 import random
 import threading
 from logging import handlers
 # *==============Imported libraries
 import discord
 from discord.ext import commands
 from communication_subroutine import comm_subroutine
 from constants import ENCODING, LOGFILE, TOKEN
 # *=========================================== Initializations
 intents = discord.Intents.default()
 intents.message_content = True
 intents.typing = True
 intents.presences = True
 intents.members = True
 intents.messages = True
 intents.voice_states = True
 intents.moderation = True
 # on_member_ban - wyswietl na glownym kanale pieczatke "Niech spierdala"
 # on_member_unban - "mam wyjebane"
 logger = logging.getLogger("discord")
 logger.setLevel(logging.DEBUG)
 handler = handlers.RotatingFileHandler(
    filename=LOGFILE,
    encoding=ENCODING,
    mode="a",
    maxBytes=6 * 1024 * 1024,
    backupCount=6,
 )
 formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 handler.setFormatter(formatter)
 logger.addHandler(handler)
 random.seed()
 client = commands.Bot(intents=intents, command_prefix="$")
 # *=========================================== Define Events
@client.event
 async def on_ready():
    """Metoda wywoływana przy połączeniu do serwera."""
    logger.debug("%s has connected to Discord!", client.user)
    # TODO: load vs reload
    await client.load_extension("administration_commands")
    await client.load_extension("librarian_commands")
    await client.load_extension("music_commands")
    await client.load_extension("radio_commands")
    await client.load_extension("ai_commands")
    await client.load_extension("other_commands")
    await client.load_extension("voice_recognition_commands")
    logger.info(client.cogs)
    await client.tree.sync()
    for com in client.commands:
        logger.info("Command %s is awejleble", com.qualified_name)
    logger.info("Logged in as ---->", client.user)
    logger.info("ID:", client.user.id)
 # *================================== Run
 if __name__ == "__main__":
    logger.info("Starting discord bot")
    threads = []
    logger.info("Starting discord bot: Creating threads")
    threads.append(threading.Thread(target=client.run, args=(TOKEN,)))
    threads.append(threading.Thread(target=comm_subroutine))
    logger.info("Starting discord bot: Starting threads")
    WRK_CNT = 0
    for worker in threads:
        WRK_CNT += 1
        logger.info("Starting discord bot: Starting thread %s", WRK_CNT)
        worker.start()
    logger.info("Starting discord bot: Joining threads")
    WRK_CNT = 0
    for worker in threads:
        WRK_CNT += 1
        logger.info("Starting discord bot: Joining thread %s", WRK_CNT)
        worker.join()
@@ -1,33 +0,0 @@
 import json
 MEMORY_FIVE_SIARA = "/home/pi/Conjurer/pamiec.json"
 ENCODING = "utf-8"
 messages = [
    {"role": "user", "content" : "Hammer: All systems operational"},
    {"role": "assistant", "content": "Aye, Szefie! Wszystkie systemy działają sprawnie. Gotów do dalszej służby! Co podać?"},
    {"role": "user", "content" : "Hammer: Podaj coś na orzeźwienie i przebudzenie. COś co rozgrzeje moje stare kości po ciężkiej pracy!"},
    {"role": "assistant", "content": "Z przyjemnością Szefie! Dla Ciebie przygotuję Midzynarodówkę Interstelarną Wolf's Dragoon - wysoce energetyczny koktajl rozgrzewający i pobudzający jednocześnie."+
                                    "Do przygotowania potrzebuję:"+
                                    "\n"+
                                    "60 ml mocnego rumu z Wolfa (lub innego, jeśli wolisz)"+
                                    "30 ml soku z cytryny"+
                                    "35 ml domowego syropu z mięty"+
                                    "15 ml świeżo zmielonej kawy"+
                                    "\n"+
                                    "Mieszam wszystko w shakerze z lodem, a potem przelewam przez sitko do kieliszka koktajlowego. W górę serwuję z bigoskiem z miętą i zestem z cytryny. Rozgrzewa, orzeźwia i daje kopa na resztę nocy."+
                                    "\n"+
                                    "Co powiesz Szefie, podać Ci taki?"},
    {"role": "user", "content" : "Hammer: Brzmi jak coś co zrobi robotę! Skal!"},
 ]
 for temp in messages:
    with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file_memory:
        # First we load existing data into a dict.
        file_data = json.load(file_memory)
        # Join new_data with file_data inside emp_details
        file_data.append(temp)
        file_memory.seek(0)
        # convert back to json.
        json.dump(file_data, file_memory, indent=4)
@@ -1,281 +0,0 @@
 import asyncio
 import logging
 import netrc
 import time
 import wave
 import assemblyai as aai
 import discord
 from discord.ext import commands, tasks, voice_recv
 from discord.opus import Decoder as OpusDecoder
 # Replace with your API key
 NETRC_FILE = "/home/pi/.netrc"
 netrc_mod = netrc.netrc(NETRC_FILE)
 authTokens = netrc_mod.authenticators("assemblyai")
 aai.settings.api_key = authTokens[2]
 discord.opus._load_default()
 CHANNELS = OpusDecoder.CHANNELS
 SAMPLE_WIDTH = OpusDecoder.SAMPLE_SIZE // OpusDecoder.CHANNELS
 SAMPLING_RATE = OpusDecoder.SAMPLING_RATE
 # rotate file after there is 0.5s between last received pcm for user.
 # delete messsages after user disconnect
 LOCATION = "/home/pi/Conjurer/transcripts/"
 class CommunicationObject:
    def __init__(self, msg_type, user, data):
        self.logger = logging.getLogger("discord")
        self.type = msg_type
        self.user = user
        self.data = data
    def __repr__(self):
        return f"{self.type} : {self.user} : {self.data}"
 class WaveWriter:
    def __init__(self, user_id, queue, location):
        self.queue = queue
        self.user = user_id
        self.username = str(user_id.id)
        self.location = location
        # here we can add hashing function to make transcription files not possible to be connected with discord id
        self.present_file_id = 0
        self.file_name_past = None
        self.file_name_present = (
            self.location + self.username + "_" + str(self.present_file_id) + ".mp3"
        )
        self.transcript_file_present: wave.Wave_write = wave.open(
            self.file_name_present, "wb"
        )
        self.transcript_file_present.setnchannels(CHANNELS)
        self.transcript_file_present.setsampwidth(SAMPLE_WIDTH)
        self.transcript_file_present.setframerate(SAMPLING_RATE)
        self.file_name_future = (
            self.location + self.username + "_" + str(self.present_file_id + 1) + ".mp3"
        )
        self.transcript_file_future: wave.Wave_write = wave.open(
            self.file_name_future, "wb"
        )
        self.transcript_file_future.setnchannels(CHANNELS)
        self.transcript_file_future.setsampwidth(SAMPLE_WIDTH)
        self.transcript_file_future.setframerate(SAMPLING_RATE)
    async def rotate(self):
        self.transcript_file_present.close()
        self.file_name_past = self.file_name_present
        if self.present_file_id > 10:
            self.present_file_id = 0
        else:
            self.present_file_id += 1
        self.file_name_present = self.file_name_future
        self.transcript_file_present = self.transcript_file_future
        self.file_name_future = (
            self.location + self.username + "_" + str(self.present_file_id + 1) + ".mp3"
        )
        self.transcript_file_future: wave.Wave_write = wave.open(
            self.file_name_future, "wb"
        )
        self.transcript_file_future.setnchannels(CHANNELS)
        self.transcript_file_future.setsampwidth(SAMPLE_WIDTH)
        self.transcript_file_future.setframerate(SAMPLING_RATE)
        operation = CommunicationObject(
            msg_type="send_file", user=self.user, data=[self.file_name_past]
        )
        await self.queue.put(operation)
    def writeframes(self, pcmdata):
        self.transcript_file_present.writeframes(pcmdata)
    def cleanup(self):
        self.logger.info("Cleanup for user %s", self.username)
        self.transcript_file_present.close()
        self.transcript_file_future.close()
 class SRBuffer(voice_recv.AudioSink):
    """Endpoint AudioSink that generates a wav file.
    Best used in conjunction with a silence generating sink. (TBD)
    """
    # on member join dodajemytypa do listy
    # on member disconnect - dropujemy go
    def __init__(self, queue, location):
        super().__init__()
        self.queue = queue
        self.wavewriter = {}
        self.logger = logging.getLogger("discord")
        self.location = location
    def on_user_connect(self, username):
        self.wavewriter[str(username.id)] = [
            WaveWriter(username, self.queue, self.location),
            time.time_ns(),
            time.time_ns(),
            False,
            False,
        ]
    def on_user_disconnect(self, username):
        self.wavewriter[str(username.id)].cleanup()
        self.wavewriter.pop(str(username.id))
    def wants_opus(self) -> bool:
        return False
    def write(self, user, data) -> None:
        # logger.info("DAta write")
        if user:
            self.wavewriter[str(user.id)][0].writeframes(data.pcm)
            self.wavewriter[str(user.id)][1] = time.time_ns()  # time from last write
            self.wavewriter[str(user.id)][3] = True  # data written in last iter
            self.wavewriter[str(user.id)][4] = True  # data in buff
            time.sleep(0.001)
    def cleanup(self) -> None:
        try:
            self.logger.info("Cleanup for SRBuffer")
            for item in self.wavewriter.values():
                item[0].cleanup()
        except Exception:
            self.logger.warning(
                "WaveSink got error closing file on cleanup", exc_info=True
            )
 class Transcriber(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.threads = []
        self.comm_queue = asyncio.Queue()
        self.wsink = SRBuffer(self.comm_queue, LOCATION)
        self.worker = None
        self.mc = None
        self.vc = None
        self.logger = logging.getLogger("discord")
    @commands.hybrid_command(name="transcribe")
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def test(self, ctx):
        if self.vc:
            vc = self.vc  # to juz powinien byc voice channel z funkcja conenct
        else:
            vc = None
        self.mc = ctx.message.channel
        if self.bot.voice_clients:
            if isinstance(self.bot.voice_clients[0], voice_recv.VoiceRecvClient):
                self.logger.debug("Already transcribing")
            else:
                self.logger.debug("Already connected with other client")
        else:
            self.logger.debug("Connected")
            vc = await ctx.author.voice.channel.connect(cls=voice_recv.VoiceRecvClient)
            self.logger.info(self.bot.voice_clients)
            self.check_data.start()
            self.worker = asyncio.create_task(self.transcribe_output_queue())
            vc.listen(self.wsink)
    @tasks.loop(seconds=0.5)
    async def check_data(self):
        for item in self.wsink.wavewriter.values():
            if not item[3]:
                timediff_rotation = time.time_ns() - item[2]
                timediff_write = time.time_ns() - item[1]
                if (
                    timediff_rotation > 13000149433
                    and timediff_write > 500014943
                    and item[4]
                ):
                    self.logger.info(
                        "File rotation time since last write %s %s",
                        timediff_write,
                        timediff_write / 1e9,
                    )
                    self.logger.info(
                        "File rotation time since last rotation %s %s",
                        timediff_rotation,
                        timediff_rotation / 1e9,
                    )
                    item[2] = time.time_ns()
                    item[4] = False
                    await item[0].rotate()
            item[3] = False
    @commands.Cog.listener()
    async def on_voice_state_update(self, user, before, after):
        if user == self.bot.user:
            self.logger.debug("Ignoring self")
            return
        if before.channel is None:
            self.logger.info(
                "User %s connected to channel %s", user, after.channel.name
            )
            self.wsink.on_user_connect(user)
        elif after.channel is None:
            self.logger.info(
                "User %s disconnected from channel %s", user, before.channel.name
            )
            operation = CommunicationObject(
                msg_type="user_cleanup", user=user, data=None
            )
            await self.comm_queue.put(operation)
        else:
            self.logger.debug("User VC status changed %s", user.id)
            self.logger.debug("Before %s", before)
            self.logger.debug("After %s", after)
    @commands.command(name="stop_transcribe")
    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
    async def stop(self, ctx):
        self.check_data.stop()
        stop_token = CommunicationObject("STOP", None, None)
        await self.comm_queue.put(stop_token)
        await ctx.voice_client.disconnect()
    async def transcribe_output_queue(self):
        self.logger.info("Transcript uploader start")
        config = aai.TranscriptionConfig(language_code="pl")
        transcriber = aai.Transcriber()
        self.logger.debug("Transcriber queue id: %s", id(self.comm_queue))
        while True:
            self.logger.debug("waiting for tasks")
            item = await self.comm_queue.get()
            self.logger.debug("Got %s", item)
            if "STOP" in item.type:
                self.logger.debug("Queue ended")
                break
            elif "send_file" in item.type:
                self.logger.debug("Sending file for transcription")
                transcript = None
                for iter in item.data:
                    try:
                        coro = asyncio.to_thread(
                            transcriber.transcribe, iter, config=config
                        )
                        transcript = await coro
                    except Exception as e:
                        self.logger.warn("Exceptiom occured %s", e)
                    await self.mc.send(f"{item.user} : {transcript.text}")
                    if transcript.error:
                        self.logger.error(transcript.error)
                        raise AssertionError
            elif "user_cleanup" in item.type:
                self.logger.info("User %s disconnected - cleanup action")
            else:
                self.logger.warn("Something went wrong with object %s", item)
        self.logger.info("Transcript uploader stoped")
 async def setup(bot):
    logger = logging.getLogger("discord")
    await bot.add_cog(Transcriber(bot))
    logger.info("Loading voice transcriber module done")
		`@@ -1 +0,0 @@`
			`c:\conjurer\env\Scripts\activate.bat && c:\conjurer\conjurer_librarian\conjurer_librarian.py`
		`@@ -0,0 +1 @@`
							`{"12345678-1234-5678-1234-567812345678": [{"DOI": "10.1057/9781137435026", "title": ["Queer BDSM Intimacies"], "type": "book", "container": "NO"}]}`
		`@@ -1,4 +0,0 @@`
			`let json.parse credentials = file.contents("/home/pi/Conjurer/icecast_credentials.json")`

			`output.icecast(%mp3, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="mp3-stream",input.alsa(bufferize=false))`