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

jaki sposob inaczej przerobic fora na asynchroniczny. Przydatne ze
wzgledu na to ze szukajka nadal blokuje heartbeat bota - co skutkuje
warningnami i wyjatkami

.gitignore

@@ -197,8 +197,3 @@ node_modules/prettier/esm/parser-postcss.mjs
 node_modules/prettier/esm/parser-typescript.mjs
 node_modules/prettier/esm/parser-yaml.mjs
 node_modules/prettier/esm/standalone.mjs
-cr_results.json
-not_in_db.json
-rr_results.json
-s_results.json
-*.bak

.trunk/configs/.shellcheckrc

@@ -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

.trunk/trunk.yaml

@@ -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
-    - shfmt@3.6.0
-    - taplo@0.8.1
-    - actionlint@1.7.1
-    - bandit@1.7.9
-    - black@24.4.2
+    - actionlint@1.6.27
+    - bandit@1.7.8
+    - black@24.3.0
     - codespell
-    - checkov@3.2.139
+    - checkov@3.2.48
     - git-diff-check
     - isort@5.13.2
     - pylint
-    - markdownlint@0.41.0
-    - prettier@3.3.2
-    - ruff@0.4.9
-    - trivy@0.52.2
-    - trufflehog@3.78.1
+    - markdownlint@0.39.0
+    - prettier@3.2.5
+    - ruff@0.3.4
+    - trivy@0.50.1
+    - trufflehog@3.71.0
     - yamllint@1.35.1
 actions:
   disabled:

administration_commands.py

@@ -1,263 +0,0 @@
-import json
-import logging
-import os
-import random
-import re
-import shutil
-from datetime import datetime
-
-import discord
-import numpy as np
-from discord.ext import commands, tasks
-
-from ai_functions import get_random_cyclic_message
-from constants import (
-    ENCODING,
-    LAST_SPONTANEOUS_CALL,
-    LOGFILE,
-    LOGSTORE,
-    MEMORY_FIVE_MUZYKA,
-    MEMORY_FIVE_SIARA,
-    TIME_BETWEEN_CALLS,
-)
-
-
-class AdministrationModule(commands.Cog):
-    def __init__(self, bot, logger_name):
-        self.bot = bot
-        self.logger = logging.getLogger(logger_name)
-
-    @commands.hybrid_command(
-        name="galeria_slaw",
-        description="Jeśli nie wiesz jak użyć tej komendy to nawet nie próbuj",
-        guild=discord.Object(id=664789470779932693),
-    )
-    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
-    async def galeria_slaw(self, ctx):
-        if isinstance(ctx.channel, discord.DMChannel):
-            for guild in self.bot.guilds:
-                async for entry in guild.bans(limit=1500):
-                    fnord = discord.File(
-                        "/home/pi/Conjurer/niech_spierdala.png",
-                        spoiler=False,
-                        description="Niech spierdala",
-                    )
-                    await ctx.reply(
-                        f"User: {entry.user} wyjebany z serwera {guild.name} za {entry.reason} ",
-                        file=fnord,
-                    )
-
-    @commands.hybrid_command(
-        name="update_banlist",
-        description="Jeśli nie wiesz jak użyć tej komendy to nawet nie próbuj",
-        guild=discord.Object(id=664789470779932693),
-    )
-    @commands.has_any_role('Jarl', 'Thane')
-
-    async def update_banlist(self, ctx):
-        """
-        Update a banlist in a Discord guild from preprovided list in channel.
-
-        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-        contains information about the context in which the command was invoked, such as the message, the
-        channel, the server, and the user who invoked the command. This information can be used to perform
-        various actions, such
-        """
-        async with ctx.channel.typing():
-            allowed = False
-            for role in ctx.author.roles:
-                if role.name == "Jarl":
-                    allowed = True
-
-            if ctx.channel.id != 1102190666827702342:
-                # trunk-ignore(codespell/misspelled)
-                await ctx.send("Nie wydaje mnie sie")
-            elif not allowed:
-                await ctx.send("Idź bo Cię zdziele")
-            else:
-                tobancunter = 0
-                async with ctx.typing():
-                    # 1. get list of users posted on channel for banning
-                    channel = ctx.channel
-                    messages = [
-                        message async for message in channel.history(limit=None)
-                    ]
-                    ids_to_ban = []
-                    for message in messages:
-                        lines = message.content.split("\n")
-                        for line in lines:
-                            match = re.search(
-                                "\\d{18}",
-                                line,
-                                # trunk-ignore(codespell/misspelled)
-                            )  # poprawilem backslash na podwojny bo linter sie czepial
-                            if match:
-                                ids_to_ban.append(match.group())
-                                tobancunter += 1
-                    # 2. get list of already banned users for all servers Conjurer
-                    # has rights to
-                    for guild in self.bot.guilds:
-                        bancunter = 0
-                        # trunk-ignore(codespell/misspelled)
-                        self.logger.info("Serwer: %s", guild)
-                        current_banlist = []
-                        permission = True
-                        try:
-                            async for entry in guild.bans(limit=None):
-                                current_banlist.append(entry.user.id)
-                                bancunter += 1
-                        except BaseException:  # pylint: disable=broad-exception-caught
-                            permission = False
-                        if permission:
-                            # 3. compare lists ban only users on list 2 and not on
-                            # list 1
-                            cunter_counter = 0
-                            bad_id_cunter_counter = 0
-                            ban_list = np.setdiff1d(ids_to_ban, current_banlist)
-                            for ident in ban_list:
-                                try:
-                                    tmp_user = await self.bot.fetch_user(int(ident))
-                                    await guild.ban(
-                                        tmp_user,
-                                        reason="Automatyczna lista banów",
-                                        delete_message_seconds=0,
-                                    )
-                                    # TODO: Maybe use guild.bulk_ban ?
-                                    cunter_counter += 1
-                                except discord.NotFound:
-                                    self.logger.info(
-                                        "Znaleziono uzyszkodnika ktory juz nie ma konta"
-                                    )
-                                    bad_id_cunter_counter += 1
-                            # 4. return message success/failure - how many banned
-                            await ctx.send(
-                                "Obecnie na serwerze {guild} jest {bancunter} zbanowanych użytkowników. Znaleziono na tym kanale {tobancunter} id użytkowników do zbanowania. Zbanowano {cunter_counter} użytkowników. Na liście jest {bad_id_cunter_counter} użytkowników którzy skasowali już konto"
-                            )
-                        else:
-                            await ctx.send(
-                                f"Nie mam na serwerze {guild} uprawnień do banowania. :()"
-                            )
-                await ctx.send("Zrobione tak czy inaczej")
-    @commands.hybrid_command(
-        name="archive_channel",
-        description="Jeśli nie wiesz jak użyć tej komendy to nawet nie próbuj",
-        guild=discord.Object(id=664789470779932693),
-    )
-    @commands.has_any_role('Jarl', 'Thane')
-
-    async def archive_channel(self, channel_no):
-        """
-        The function `archive_channel` retrieves messages from a specified channel, processes them, and
-        saves the data in a JSON file with a timestamp in the filename.
-
-        :param channel_no: The `archive_channel` function you provided seems to be incomplete. It looks like
-        you are trying to archive messages from a Discord channel into a JSON file
-        """
-        channel = self.bot.get_channel(channel_no)
-        messages = [message async for message in channel.history(limit=None)]
-        path_newfile = f"{LOGSTORE}channeldump_{channel_no}_{datetime.now()}.json"
-        new_data = []
-        for message in messages:
-            new_data.append(message)
-        with open(path_newfile, "x", encoding=ENCODING) as new_file:
-            new_file.seek(0)
-            json.dump(new_data, new_file, indent=4)
-
-    @tasks.loop(seconds=120)
-    async def check_self(self):
-        """
-        The function `check_data` periodically checks for conditions to send messages and manage log files
-        in a Discord channel.
-        """
-        # logger.info("Heartbeat of cleanup proc")
-        channel = self.bot.get_channel(1062047367337095268)
-        messages = [message async for message in channel.history(limit=1)]
-        for mess in messages:
-            channel = mess.channel
-        if os.path.getsize(LOGFILE) > 60000000:
-            await channel.send(
-                "*Conjurer porządkuje bar, wypala szklanki do czysta miotaczem płomieni ze swojej zbroi i ogólnie wygląda na zajętego....*"
-            )
-            async with channel.typing():
-                shutil.copyfile(LOGFILE, f"{LOGSTORE}discord{datetime.now()}")
-                self.logger.info("Log rollover")
-                handlers = self.logger.handlers
-                for handler in handlers:
-                    if isinstance(handler, logging.handlers.RotatingFileHandler):
-                        handler.doRollover()
-                await channel.send(
-                    "*Przeciąga się za barem* No dobra - porobione to można dalej pi... *Zauważa spojrzenie Hammera* ...sać powieści o naszym wspaniałym barze SZEFIE!"
-                )
-
-        if os.path.getsize(MEMORY_FIVE_MUZYKA) > 3000000:
-            await channel.send(
-                "*Conjurer porządkuje bar, wypala szklanki do czysta miotaczem płomieni ze swojej zbroi i ogólnie wygląda na zajętego....*"
-            )
-            async with channel.typing():
-                path_newfile = f"{LOGSTORE}pamiec_muzyki{datetime.now()}.json"
-                self.logger.info(path_newfile)
-                with open(
-                    MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING
-                ) as file_music_memory:
-                    with open(path_newfile, "x", encoding=ENCODING) as new_file:
-                        # First we load existing data into a dict.
-                        file_data = json.load(file_music_memory)
-                        new_data = []
-                        new_data.append(file_data[0])
-                        new_data.extend(file_data[:-20])
-                        file_music_memory.truncate(0)
-                        file_music_memory.seek(0)
-                        # convert back to json.
-                        new_file.seek(0)
-                        json.dump(new_data, file_music_memory, indent=4)
-                        json.dump(file_data, new_file, indent=4)
-                        await channel.send(
-                            "*Przeciąga się za barem* No dobra - porobione to można dalej pi... *Zauważa spojrzenie Hammera* ...sać powieści o naszym wspaniałym barze SZEFIE!"
-                        )
-        if os.path.getsize(MEMORY_FIVE_SIARA) > 3000000:
-            path_newfile = f"{LOGSTORE}pamiec_rozmow{datetime.now()}.json"
-            self.logger.info(path_newfile)
-            await channel.send(
-                "*Conjurer porządkuje bar, ścina lekkim laserem pulsacyjnym powierzchnie baru o grubości kilku mikronów i ogólnie wygląda na zajętego....*"
-            )
-            with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file:
-                with open(path_newfile, "x", encoding=ENCODING) as new_file:
-                    # First we load existing data into a dict.
-                    file_data = json.load(file)
-                    new_data = []
-                    new_data.append(file_data[0])
-                    new_data.extend(file_data[-20])
-                    file.truncate(0)
-                    file.seek(0)
-                    new_file.seek(0)
-                    # convert back to json.
-                    json.dump(new_data, file, indent=4)
-                    json.dump(file_data, new_file, indent=4)
-                    await channel.send(
-                        "*Przeciąga się za barem* No dobra - porobione to można dalej pi... *Zauważa spojrzenie Hammera* eprzyć o głupotach z klientami... Szefie... *Bierze 'ukradkowy' łyk z piersiówki*"
-                    )
-        global LAST_SPONTANEOUS_CALL
-        global TIME_BETWEEN_CALLS
-        tdelta = datetime.now() - LAST_SPONTANEOUS_CALL
-        tdelta = tdelta.total_seconds()
-        if tdelta > TIME_BETWEEN_CALLS:
-            self.logger.info("Spontaneous call")
-            # trunk-ignore(bandit/B311)
-            TIME_BETWEEN_CALLS = random.randint(
-                10200, 272800
-            )  # temp random, set after each call
-            self.logger.debug(TIME_BETWEEN_CALLS)
-            LAST_SPONTANEOUS_CALL = datetime.now()
-            async with channel.typing():
-                message = await get_random_cyclic_message(self.bot)
-                self.logger.info("Odpowiedz")
-                self.logger.info(message)
-                await channel.send(message)
-
-
-async def setup(bot):
-    logger = logging.getLogger("discord")
-    am = AdministrationModule(bot, "discord")
-    await bot.add_cog(am)
-    am.check_self.start()
-    logger.info("Loading administration commands module done")

ai_commands.py

@@ -1,403 +0,0 @@
-# ai command cogs
-import logging
-import re
-import sys
-from datetime import datetime
-from enum import Enum
-from typing import Optional
-from pathlib import Path
-import discord
-import openai
-import requests
-from discord.ext import commands
-from other_functions import discord_friendly_send, discord_friendly_reply
-
-
-import ai_functions
-from constants import (
-    ASSISTANTS,
-    DATA,
-    GRAPHICS_PATH,
-    INITIAL_TIME_WAIT,
-    MASTER_TIMEOUT,
-    MESSAGE_TABLE,
-    OPENAICLIENT,
-    SPECJALNE_ZIEMNIACZKI,
-    WORD_REACTIONS,
-)
-
-
-class Dm_Mode(Enum):
-    ARMIA_HAMMERA = (1,)
-    SPECJALNY_ZIEMNIACZEK = (2,)
-    SEKRETNY_SEKSRET = (3,)
-    ECHO_ECHO = (4,)
-
-
-class Events(commands.Cog):
-    def __init__(self, bot):
-        self.bot = bot
-        self.logger = logging.getLogger("discord")
-        self.armia = {}
-        for superfryta in SPECJALNE_ZIEMNIACZKI.values():
-            self.armia[superfryta[0]] = Dm_Mode.SPECJALNY_ZIEMNIACZEK
-        self.logger.info(self.armia)
-
-    async def cog_load(self):
-        self.logger.info("Starting personal assistants")
-        for superfryta_id, superfryta in SPECJALNE_ZIEMNIACZKI.items():
-
-            if superfryta[4] != "":
-                self.logger.info(
-                    "Personal assistant for user: %s, exists id: %s,name: %s, owner: %s, special instructions: %s assistant id: %s ",
-                    superfryta_id,
-                    superfryta[0],
-                    superfryta[1],
-                    superfryta[2],
-                    superfryta[3],
-                    superfryta[4],
-                )
-                thread = await OPENAICLIENT.beta.threads.create()
-                self.logger.info("Thread id: %s", thread.id)
-                ASSISTANTS[superfryta[1]] = (
-                    superfryta[2],
-                    superfryta[4],
-                    superfryta[0],
-                    thread,
-                )
-            else:
-                self.logger.info(
-                    "Creating personal assistant for user: %s, id: %s,name: %s, owner: %s, special instructions: %s",
-                    superfryta_id,
-                    superfryta[0],
-                    superfryta[1],
-                    superfryta[2],
-                    superfryta[3],
-                )
-                await ai_functions.create_chat_assistant(
-                    superfryta_id, superfryta[0], superfryta[1], superfryta[2], superfryta[3]
-                )
-        self.logger.info("Started personal assistants")
-
-    @commands.hybrid_command(
-        name="switch_dm_mode",
-        description="Jeśli nie wiesz jak użyć tej komendy to nawet nie próbuj",
-        guild=discord.Object(id=664789470779932693),
-    )
-    async def switch_dm_mode(self, ctx, dm_mode_arg: Dm_Mode):
-        async with ctx.channel.typing():
-            if isinstance(ctx.channel, discord.DMChannel):
-                for superfryta in SPECJALNE_ZIEMNIACZKI.values():
-                    self.logger.info(ctx.message.author.id)
-                    self.logger.info(superfryta)
-                    if ctx.message.author.id == superfryta[0]:
-                        self.armia[ctx.message.author.id] = dm_mode_arg
-                        self.logger.info(self.armia)
-                        await ctx.reply("Weszlo")
-                        return
-                await ctx.reply(
-                    "Tylko członkowie Armii Hammera mogą używać. Nie jesteś jednym z nich"
-                )
-            else:
-                await ctx.reply("Nope. Nie wiesz jak użyć")
-
-    @commands.hybrid_command(
-        name="armia_hammera",
-        description="Jeśli nie wiesz jak użyć tej komendy to nawet nie próbuj",
-    )
-    async def armia_hammera(
-        self, ctx, message_txt: str, recipient: Optional[discord.User]
-    ):
-        for superfryta in SPECJALNE_ZIEMNIACZKI.values():
-            if ctx.message.author.id == superfryta[0]:
-                await self.armia_hammera_back(ctx, message_txt, recipient)
-                return
-        await ctx.reply("Tylko członkowie Armii Hammera mogą używać. Nie jesteś jednym z nich")
-
-    async def armia_hammera_back(self, ctx, message_txt, recipient=None):
-        self.logger.info("Armia Hammera")
-        recipients = []
-        if recipient:
-            recipients.append(recipient.id)
-        else:
-            for superfryta in SPECJALNE_ZIEMNIACZKI.values():
-                recipients.append(superfryta[0])
-        self.logger.info(recipients)
-        for item in recipients:
-            user = await self.bot.fetch_user(item)
-            channel = await user.create_dm()
-            self.logger.info(
-                "User %s ->  %s: %s", ctx.message.author, user, message_txt
-            )
-            await discord_friendly_send(channel, message_txt)
-        await discord_friendly_reply(ctx, "Poszło")
-
-    #TODO: NOT IMPLEMENTED YET
-    @commands.Cog.listener(name="dodaj_do_bazy_wiedzy")
-    async def dodaj_do_bazy_wiedzy(self, ctx):
-        for superfryta in SPECJALNE_ZIEMNIACZKI.values():
-            if ctx.message.author.id == superfryta[0]:
-                #logic here
-                return
-        await ctx.reply("Tylko członkowie Armii Hammera mogą używać. Nie jesteś jednym z nich")
-
-    #TODO: NOT IMPLEMENTED YET
-    @commands.Cog.listener(name="listuj_baze_wiedzy")
-    async def listuj_baze_wiedzy(self, ctx):
-        for superfryta in SPECJALNE_ZIEMNIACZKI.values():
-            if ctx.message.author.id == superfryta[0]:
-                #logic here
-                return
-        await ctx.reply("Tylko członkowie Armii Hammera mogą używać. Nie jesteś jednym z nich")
-
-    #TODO: NOT IMPLEMENTED YET
-    @commands.Cog.listener(name="usun_z_bazy_wiedzy")
-    async def usun_z_bazy_wiedzy(self, ctx):
-        for superfryta in SPECJALNE_ZIEMNIACZKI.values():
-            if ctx.message.author.id == superfryta[0]:
-                #logic here
-                return
-        await ctx.reply("Tylko członkowie Armii Hammera mogą używać. Nie jesteś jednym z nich")
-
-    #TODO: NOT IMPLEMENTED YET
-    @commands.Cog.listener(name="przetworz_plik_linia_po_linii")
-    async def przetworz_plik_linia_po_linii(self, ctx):
-        for superfryta in SPECJALNE_ZIEMNIACZKI.values():
-            if ctx.message.author.id == superfryta[0]:
-                #logic here
-                return
-        await ctx.reply("Tylko członkowie Armii Hammera mogą używać. Nie jesteś jednym z nich")
-
-    @commands.Cog.listener()
-    async def on_message(self, message):
-        """
-        Handle incoming messages in a Discord server, perform various
-        checks and actions based on the content and context of the message, and respond accordingly.
-
-        :param message: The message object that is received when a user sends a message in a Discord server
-        or DM. The code is checking various conditions and performing actions based on the content of the
-        message and the context in which it was sent. It also includes TODOs for future improvements
-        :return: The function `on_message` is being returned.
-        """
-        vykidailo = False
-        channel = None
-        if message.author == self.bot.user:
-            return
-
-        if isinstance(message.author, discord.Member):
-            for role in message.author.roles:
-                if role.name == "Vykidailo":
-                    vykidailo = True
-
-        if ("Conjurer Śpij Słodko Aniołku" in message.content) and vykidailo:
-            sys.exit()
-        # kanal bez bota
-        if message.channel.id == 1095985579147141202:
-            return
-        # wentylacja
-        if message.channel.id == 1083804024173764739:
-            return
-        # legendy
-        if message.channel.id == 1084448332841230388:
-            return
-        # interrogation booth
-        if message.channel.id == 1111625221171052595:
-            return
-        if isinstance(message.channel, discord.DMChannel):
-            self.logger.info(message.author.id)
-            for superfryta in SPECJALNE_ZIEMNIACZKI.values():
-                self.logger.info(superfryta[0])
-
-                if message.author.id == superfryta[0]:
-                    self.logger.info("Specjalny ziemniak")
-                    if self.armia[message.author.id] == Dm_Mode.SPECJALNY_ZIEMNIACZEK:
-                        #await self.bot.process_commands(message)
-                        await ai_functions.chat_with_assistant(message, superfryta[1])
-                        return
-                    elif self.armia[message.author.id] == Dm_Mode.ECHO_ECHO:
-                        await ai_functions.echo(message)
-                        return
-                    elif self.armia[message.author.id] == Dm_Mode.ARMIA_HAMMERA:
-                        self.logger.info("Armia Hammera get context")
-                        ctx = await self.bot.get_context(message)
-                        self.logger.info("Armia Hammera function call")
-                        await self.armia_hammera_back(ctx=ctx, message_txt=message.content)
-                        return
-                    elif self.armia[message.author.id] == Dm_Mode.SEKRETNY_SEKSRET:
-                        pass
-                    else:
-                        await discord_friendly_send(message.channel,"Coś się wyebao. Wołaj Hammera")
-                        return
-            channel = self.bot.get_channel(1064888712565100614)
-            await discord_friendly_send(channel, "Słyszałem ja żem że: " + message.content)
-            return
-        channel = message.channel
-        message_content_lower = message.content.lower()
-
-        tdelta = datetime.now() - MASTER_TIMEOUT
-        tdelta = tdelta.total_seconds()
-        if "opowiedz o fabryczce" in message_content_lower:
-            await message.reply(DATA["fabryczka"])
-        if "opowiedz mi o fabryczce" in message_content_lower:
-            await message.reply(DATA["fabryczka"])
-
-        if tdelta > INITIAL_TIME_WAIT:
-            for word in WORD_REACTIONS:
-                if re.search(r"\b" + word + r"\b", message_content_lower):
-                    tdelta = datetime.now() - WORD_REACTIONS[word][2]
-                    tdelta = tdelta.total_seconds()
-                    security_clearance = WORD_REACTIONS[word][4]
-                    reaction = WORD_REACTIONS[word][3]
-                    if tdelta > WORD_REACTIONS[word][1]:
-                        # TODO: to zrobic reactiony
-                        self.logger.info("Ping z procedury reakcji")
-                        if reaction:
-                            emoji = self.bot.get_emoji(WORD_REACTIONS[word][0])
-                            await message.add_reaction(emoji)
-                        elif security_clearance and vykidailo:
-                            await message.reply(WORD_REACTIONS[word][0])
-                        elif not security_clearance:
-                            await message.reply(WORD_REACTIONS[word][0])
-                        WORD_REACTIONS[word][2] = datetime.now()
-
-        # TODO: drobne literówki, mentiony, spacja przed dwukropkiem. napraw.
-        kondziu_mentioned = False
-        for mention in message.mentions:
-            if mention == self.bot.user:
-                kondziu_mentioned = True
-
-        if kondziu_mentioned or "conjurer:" in message_content_lower:
-            async with channel.typing():
-                self.logger.info("Procedura chatu")
-
-                message_content_lower = message_content_lower.replace("conjurer: ", "")
-                if message.author.nick:
-                    username = message.author.nick
-                else:
-                    username = message.author.name
-                vykidailo = False
-                bartender = False
-                if kondziu_mentioned:
-                    prompt = message.clean_content
-                else:
-                    prompt = message.content
-                for role in message.author.roles:
-                    if role.name == "Vykidailo":
-                        vykidailo = True
-                    if role.name == "Bartender":
-                        bartender = True
-                global MESSAGE_TABLE  # pylint: disable=global-statement
-
-                result, MESSAGE_TABLE = await ai_functions.handle_response(
-                    prompt,
-                    vykidailo,
-                    bartender,
-                    MESSAGE_TABLE,
-                    username,
-                    "GENERAL",
-                )
-
-                await discord_friendly_reply(message, result)
-        if "imaginuje sobie:" in message.content:
-            async with channel.typing():
-                self.logger.info("Poczatek procedury obrazkowej")
-                message_content_lower = message_content_lower.replace("imaginuje sobie: ", "")
-                self.logger.debug("Wywolanie obrazka: %s", message_content_lower)
-                try:
-                    response = await OPENAICLIENT.images.generate(
-                        model="dall-e-3",
-                        prompt=message.content,
-                        size="1024x1024",
-                        quality="standard",
-                        n=1,
-                    )
-                except openai.APITimeoutError as e:
-                    # Handle timeout error, e.g. retry or log
-                    await discord_friendly_reply(
-                        message, f"*Kondziu patrzy na terminal, czeka, czeka, czeka,.... Jeszcze chwile czeka Przypierdala w niego pięścią....* Nie mogę się połączyć z Openai spróbuj od nowa. *Na ekranie pojawia się*: {e}"
-                    )
-                except openai.APIConnectionError as e:
-                    await discord_friendly_reply(
-                        message, f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Nie mogę się połączyć z Openai. *Na ekranie pojawia się*: {e}"
-                    )
-                except openai.BadRequestError as e:
-                    # Handle invalid request error, e.g. validate parameters or log
-                    if message.author.nick:
-                        username = message.author.nick
-                    else:
-                        username = message.author.name
-                    resp, _ = await ai_functions.handle_response(
-                        f"Wytlumacz jakie sa zasady dotyczące treści które możesz generować używając Dalle. Wytłumacz błąd {e} prostym językiem. Przeproś za nadmierną cenzurę. Wytłumacz co mogło być nie tak w prompcie '{message.content}'",
-                        True,
-                        True,
-                        MESSAGE_TABLE,
-                        username,
-                        "GENERAL",
-                    )
-                    await discord_friendly_reply(
-                        message, f"Sorki, cenzura: {resp}. Jak chcesz to są kanały na nudle #sexy-foteczky i #kanal-do-fapania *Na ekranie pojawia się: {e}"
-                    )
-                except openai.AuthenticationError as e:
-                    # Handle authentication error, e.g. check credentials or log
-                    await discord_friendly_reply(
-                        message, f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Wołaj szefa - coś się z hasłem zjebało. *Na terminalu pojawia się:* {e}"
-                    )
-                except openai.PermissionDeniedError as e:
-                    # Handle permission error, e.g. check scope or log
-                    await discord_friendly_reply(
-                        (
-                            message, f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Wołaj szefa - coś się z uprawnieniami zjebało. *Na terminalu pojawia się:* {e}"
-                        )
-                    )
-                except openai.RateLimitError as e:
-                    await discord_friendly_reply(
-                        message, f"*Kondziu patrzy na terminal* Wołaj szefa. Zapłacić rachunki za AI trzeba. Jak chcesz to się na #zebranie dorzuć. {e}"
-                    )
-                except openai.APIError as e:
-                    # Handle API error, e.g. retry or log
-                    await discord_friendly_reply(
-                        message, f"*Kondziu nurkuje za bar, terminal wybucha. Przed tobą ląduje pergamin zapisany pięknym gotykiem a na nim*: {e}"
-                    )
-                if response:
-                    self.logger.info(response)
-                    image_url = response.data[0].url
-                    image_desc = response.data[0].revised_prompt
-                    self.logger.debug("Wynikowy obrazek pod url: %s", image_url)
-                    response = requests.get(image_url, timeout=360)
-                    temp_file_name = message.content + ".png"
-                    temp_file_name = GRAPHICS_PATH + message.content + ".png"
-                    num = 0
-                    while (Path(temp_file_name)).exists():
-                        temp_file_name = GRAPHICS_PATH + message.content + str(num) +  ".png"
-                        num += 1
-                    try:
-                       with open(temp_file_name, "wb") as dalle_file:
-                           dalle_file.write(response.content)
-                    except OSError:
-                       temp_file_name = "/home/pi/oserror.png"
-                       with open(temp_file_name, "wb") as dalle_file:
-                           dalle_file.write(response.content)
-                    except FileNotFoundError:
-                       temp_file_name = "/home/pi/fnferror.png"
-                       with open(temp_file_name, "wb") as dalle_file:
-                           dalle_file.write(response.content)
-                    except Exception as e:
-                        self.logger.error("Nieznany błąd: %s", e)
-                        temp_file_name = "/home/pi/error.png"
-                        with open(temp_file_name, "wb") as dalle_file:
-                            dalle_file.write(response.content)
-                    finally:
-                        self.logger.info("Koniec procedury obrazkowej.")
-                        fnord = discord.File(
-                            temp_file_name, spoiler=False, description=message.content
-                        )
-
-                #await message.reply(f"{image_desc}", file=fnord)
-                await discord_friendly_reply(message,f"{image_desc}", file = fnord)
-# *=========================================== Define Functions
-
-
-async def setup(bot):
-    logger = logging.getLogger("discord")
-    await bot.add_cog(Events(bot))
-    logger.info("Loading ai events module done")

ai_functions.py

@@ -1,449 +0,0 @@
-import asyncio
-import json
-import logging
-import random
-
-import openai
-import tiktoken
-import time
-from other_functions import discord_friendly_send
-from constants import (
-    ASSISTANTS,
-    CYCLIC_WORDS,
-    ENCODING,
-    GPT_SETTINGS,
-    MEMORY_FIVE_MUZYKA,
-    MEMORY_FIVE_SIARA,
-    MESSAGE_TABLE,
-    MESSAGE_TABLE_MUZYKA,
-    OPENAICLIENT,
-    SYSTEM_GPT_SETTINGS,
-    WORD_REACTIONS,
-    CHEAP_MODEL,
-    LATEST_MODEL
-)
-
-# this do per user
-VECTOR_STORE_ID = -1
-def select_model(req_type: str, algo: str) -> str:
-    # Jeżeli jawnie podano algorithm (i nie jest 'auto'/''):
-    if algo and str(algo).strip().lower() not in ("auto",):
-        # wyjątek: MUZYKA ma zawsze być tania — nadpisujemy TYLKO jeśli przyszedł domyślny 'gpt-4o'
-        if req_type == "MUSIC" and algo.strip() in (LATEST_MODEL,):
-            return CHEAP_MODEL
-        return algo
-    # Auto-dobór:
-    if req_type == "MUSIC":
-        return CHEAP_MODEL
-    return LATEST_MODEL
-
-
-async def openai_call(messages, model, temperature=0.2):
-    """
-    Responses API dla 4o/4.1*, fallback Chat Completions dla gpt-3.5-turbo.
-    Zwraca czysty string odpowiedzi.
-    """
-    logger = logging.getLogger("discord")
-
-    if model.startswith("gpt-3.5"):
-        logger.info("3.5")
-        # legacy path – bez zmian w Twoim kodzie wyżej/niżej
-        resp = await OPENAICLIENT.chat.completions.create(
-            model=model,
-            messages=messages,
-            temperature=temperature,
-        )
-        result = ""
-        for choice in resp.choices:
-            result += choice.message.content
-        return result.strip()
-
-    else:
-        logger.info("4.0+")
-        # Responses API (zalecane dla 4o/4.1*)
-        resp = await OPENAICLIENT.responses.create(
-            model=model,
-            temperature=temperature,
-            input=messages,
-        )
-        # SDK zapewnia output_text dla zwykłych odpowiedzi
-        return (getattr(resp.output_text, "output_text", None) or "").strip() or str(
-            resp.output_text
-        )
-
-
-def create_vector_store():
-    # Create a vector store caled "Financial Statements"
-    return OPENAICLIENT.beta.vector_stores.create_and_poll(name="Hammer Stash")
-    # expires_after={
-    # "anchor": "last_active_at",
-    # "days": 7}
-    # )
-
-
-def upload_files_to_vector_store(assistant):
-
-    # Ready the files for upload to OpenAI
-    file_paths = ["edgar/goog-10k.pdf", "edgar/brka-10k.txt"]
-    file_streams = [open(path, "rb") for path in file_paths]
-
-    # file = client.beta.vector_stores.files.create_and_poll(
-    # vector_store_id="vs_abc123",
-    # file_id="file-abc123"
-    # )
-    # batch = client.beta.vector_stores.file_batches.create_and_poll(
-    # vector_store_id="vs_abc123",
-    # file_ids=['file_1', 'file_2', 'file_3', 'file_4', 'file_5']
-    # )
-
-    # Use the upload and poll SDK helper to upload the files, add them to the vector store,
-    # and poll the status of the file batch for completion.
-    file_batch = OPENAICLIENT.beta.vector_stores.file_batches.upload_and_poll(
-        vector_store_id=VECTOR_STORE_ID, files=file_streams
-    )
-
-    # You can print the status and the file counts of the batch to see the result of this operation.
-    print(file_batch.status)
-    print(file_batch.file_counts)
-    assistant = OPENAICLIENT.beta.assistants.update(
-        assistant_id=assistant.id,
-        tool_resources={"file_search": {"vector_store_ids": [VECTOR_STORE_ID]}},
-    )
-
-
-def delete_files_from_vector_store(assistant, file_id):
-    result = OPENAICLIENT.beta.vector_stores.file_batches.delete(
-        vector_store_id=VECTOR_STORE_ID, files=file_id
-    )
-
-    # You can print the status and the file counts of the batch to see the result of this operation.
-    print(result)
-    assistant = OPENAICLIENT.beta.assistants.update(
-        assistant_id=assistant.id,
-        tool_resources={"file_search": {"vector_store_ids": [VECTOR_STORE_ID]}},
-    )
-
-
-def num_tokens_from_string(message, model):
-    """
-    The function takes a string message and a model as input and returns the number of tokens in the
-    message according to the given model.
-
-    :param message: A string containing the message or text from which you want to count the number of
-    tokens
-    :param model: The model parameter refers to a language model or tokenizer that can be used to
-    tokenize the input string. It could be a pre-trained model or a custom tokenizer
-    """
-    tokens_per_message = 3
-    tokens_per_name = 1
-    chat_gpt_encoding = tiktoken.encoding_for_model(model)
-
-    num_tokens = 0
-    num_tokens += tokens_per_message
-    for keys, values in message.items():
-        num_tokens += len(chat_gpt_encoding.encode(values))
-        if keys == "role":
-            num_tokens += tokens_per_name
-    num_tokens += 3  # every reply is primed with <|start|>assistant<|message|>
-    return num_tokens
-
-
-async def handle_response(
-    prompt,
-    vykidailo,
-    bartender,
-    history,
-    username,
-    request_type,
-    algorithm="gpt-4o",
-    none_request="",
-    internal_retry: bool = False
-):
-    """
-    Handle responses by appending them to a history, use OpenAI to
-    generate a response, and then append the generated response to the history.
-
-    :param prompt: The prompt for the OpenAI chatbot to generate a response to
-    :param vykidailo: It is a boolean variable that indicates whether the user invoking the function is
-    an administrator or not
-    :param bartender: The bartender parameter is a boolean value indicating whether the user making the
-    request is a bartender or not
-    :param history: A list containing the conversation history between the user and the assistant
-    :param username: The username of the user who initiated the conversation
-    :param music: The "music" parameter is a boolean value that indicates whether the conversation is
-    related to music or not. If it is True, the conversation history will be stored in a different file
-    and the response will be generated using a different model
-    :param request_type: The type of request being made, which can be "MUSIC", "RANDOM", "NONE" or "GENERAL"
-        GENERAL is for regular conversations, MUSIC is for music-related requests,
-        RANDOM is for random requests, and NONE is to not store the request in memory
-    :param algorithm: The algorithm to be used for generating the response, default is "gpt-4o"
-    :return: The function `handle_response` returns a tuple containing the `result` and `MESSAGE_TABLE`.
-    """
-    logger = logging.getLogger("discord")
-    logger.info("Wywolanie procedury openai z promptem: %s", prompt)
-    if vykidailo or bartender:
-        logger.info("Administrator coś chciał")
-    model_to_use = select_model(request_type, algorithm)
-    logger.info("Wybrany model: %s", model_to_use)
-    if request_type == "MUSIC" and model_to_use == "gpt-4o-mini":
-        try:
-            # nic — normalnie pójdzie Responses API
-            pass
-        except Exception:
-            model_to_use = "gpt-3.5-turbo"
-    # --- 2) Budowa historii (token budget + reguły systemowe) ---
-    # NOTE: ignorujemy przekazany 'history' jako listę (tak było wcześniej),
-    # ale zwracamy aktualną tablicę do nadpisania w miejscach wołania (back-compat).
-    base_system = GPT_SETTINGS[0]  # zakładamy {"role":"system","content":...}
-    history_msgs = []
-
-    if request_type != "NONE":
-        history_msgs.append(base_system)
-        chat_gpt_config_request_size = num_tokens_from_string(base_system, "gpt-4")
-
-        # Dynamiczne mikro-reguły (WORD_REACTIONS), jak w Twoim kodzie
-        for slowo, reakcja in WORD_REACTIONS.items():
-            if not reakcja[3]:
-                content = f"Kiedy słyszysz {slowo} to reagujesz lub dzieje się to {reakcja[0]}"
-                sys_msg = {"role": "system", "content": content}
-                chat_gpt_config_request_size += num_tokens_from_string(sys_msg, "gpt-4")
-                history_msgs.append(sys_msg)
-
-        # wybór właściwej tablicy pamięci i budżetu
-        if request_type == "MUSIC":
-            table = MESSAGE_TABLE_MUZYKA
-            token_amount = 10700
-        elif request_type in ("RANDOM", "GENERAL"):
-            table = MESSAGE_TABLE
-            token_amount = 10700
-        else:
-            table = []
-            token_amount = 10000
-
-        # doklejanie historii od końca aż do limitu (zachowana kolejność czasowa)
-        final_prompt = f"{username}:{prompt}"
-        prompt_gpt_request_size = num_tokens_from_string({"role": "user", "content": final_prompt}, "gpt-4")
-
-        acc = []
-        for msg in reversed(table):
-            t = num_tokens_from_string(msg, "gpt-4")
-            if chat_gpt_config_request_size + prompt_gpt_request_size + t <= token_amount:
-                acc.append(msg)
-                chat_gpt_config_request_size += t
-            else:
-                break
-        # przywróć chronologicznie
-        history_msgs.extend(reversed(acc))
-
-        # aktualny prompt
-        history_msgs.append({"role": "user", "content": final_prompt})
-        logger.info("Rozmiar zapytania (tok): %s", prompt_gpt_request_size)  # tokeny już policzone wyżej
-
-    else:
-        # --- tryb NONE: nie dotykamy pamięci i pozwalamy przekazać własny 'none_request' ---
-        if isinstance(none_request, list):
-            history_msgs = none_request
-        elif isinstance(none_request, str) and none_request.strip():
-            history_msgs = [{"role": "user", "content": none_request}]
-        else:
-            history_msgs = [{"role": "user", "content": f"{username}:{prompt}"}]
-
-        logger.info("Rozmiar zapytania (tok): %s", "n/a")  # tokeny już policzone wyżej
-
-    try:
-        # ...przygotowanie messages/system prompt/itp. jak masz...
-        # retry/backoff + deadline (zachowuje Twoją semantykę logowania)
-        timeout_sec = 120
-        deadline = time.time() + timeout_sec
-        response = await asyncio.wait_for(
-            openai_call(messages=history_msgs, model=model_to_use),
-            timeout=max(0.1, deadline - time.time()),
-        )
-
-    except openai.APITimeoutError as e:
-        # Handle timeout error, e.g. retry or log
-        response = f"*Kondziu patrzy na terminal, czeka, czeka, czeka,.... Jeszcze chwile czeka Przypierdala w niego pięścią....* Nie mogę się połączyć z Openai spróbuj od nowa. *Na ekranie pojawia się*: {e}"
-    except openai.APIConnectionError as e:
-        response = f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Nie mogę się połączyć z Openai. *Na ekranie pojawia się*: {e}"
-    except openai.BadRequestError as e:
-        # Handle invalid request error, e.g. validate parameters or log
-        if internal_retry:
-            resp = "Nie umiem tego teraz ładnie wytłumaczyć — OpenAI mnie zastrzeliło."
-        else:
-            resp, _ = await handle_response(
-
-                f"Wytlumacz jakie sa zasady dotyczące treści które możesz generować używając Dalle. Wytłumacz błąd {e} prostym językiem. Przeproś za nadmierną cenzurę. Wytłumacz co mogło być nie tak w prompcie 'prompt'",
-                True,
-                True,
-                MESSAGE_TABLE,
-                username,
-                "RANDOM",
-            )
-            response = f"Sorki, cenzura: {resp}. Jak chcesz to są kanały na nudle #sexy-foteczky i #kanal-do-fapania *Na ekranie pojawia się: {e}"
-    except openai.APIResponseValidationError as e:
-        # Handle invalid request error, e.g. validate parameters or log
-        if internal_retry:
-            resp = "Nie umiem tego teraz ładnie wytłumaczyć — OpenAI mnie zastrzeliło."
-        else:
-            resp, _ = await handle_response(
-                f"Wytlumacz jakie sa zasady dotyczące treści które możesz generować używając Dalle. Wytłumacz błąd {e} prostym językiem. Przeproś za nadmierną cenzurę. Wytłumacz co mogło być nie tak w prompcie 'prompt'",
-                True,
-                True,
-                MESSAGE_TABLE,
-                username,
-                "RANDOM",
-            )
-            response = f"Sorki, cenzura: {resp}. Jak chcesz to są kanały na nudle #sexy-foteczky i #kanal-do-fapania *Na ekranie pojawia się: {e}"
-    except openai.AuthenticationError as e:
-        # Handle authentication error, e.g. check credentials or log
-        response = f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Wołaj szefa - coś się z hasłem zjebało. *Na terminalu pojawia się:* {e}"
-    except openai.PermissionDeniedError as e:
-        # Handle permission error, e.g. check scope or log
-        response = f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Wołaj szefa - coś się z uprawnieniami zjebało. *Na terminalu pojawia się:* {e}"
-    except openai.RateLimitError as e:
-        response = f"*Kondziu patrzy na terminal* Wołaj szefa. Zapłacić rachunki za AI trzeba. Jak chcesz to się na #zebranie dorzuć. {e}"
-    except openai.UnprocessableEntityError as e:
-        response = f"*Kondziu patrzy na terminal. Potem na to co każesz mu wysłać....* Ja wiem że jesteśmy w barze BDSM - ale nie da się włożyć TEGO w TO. *Za jego plecami na terminalu pojawia się:* {e}"
-    except openai.APIError as e:
-        # Handle API error, e.g. retry or log
-        response = f"*Kondziu nurkuje za bar, terminal wybucha. Przed tobą ląduje pergamin zapisany pięknym gotykiem a na nim*: {e}"
-
-    logger.info("Historia wysłana:")
-    temp_assistant = {"role": "assistant", "content": response}
-    logger.info(temp_assistant)
-    if request_type == "MUSIC":
-        # zapis do pliku MUZYKA
-        with open(MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING) as fh:
-            file_data = json.load(fh)
-            file_data.append({"role": "user", "content": f"{username}:{prompt}"})
-            file_data.append(temp_assistant)
-            fh.seek(0)
-            json.dump(file_data, fh, indent=4)
-        return response, MESSAGE_TABLE_MUZYKA
-
-    elif request_type in ("RANDOM", "GENERAL"):
-        with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as fh:
-            file_data = json.load(fh)
-            file_data.append({"role": "user", "content": f"{username}:{prompt}"})
-            file_data.append(temp_assistant)
-            fh.seek(0)
-            json.dump(file_data, fh, indent=4)
-        return response, MESSAGE_TABLE
-
-    else:  # NONE
-        return response, []
-
-
-async def get_random_cyclic_message(client):
-    """
-    The function `get_random_cyclic_message` returns a random cyclic message from a list of cyclic
-    words.
-    :return: a random cyclic message from the list `cyclic_words`.
-    """
-    logger = logging.getLogger("discord")
-    channel_id = 1062047367337095268
-    channel = client.get_channel(channel_id)
-    # trunk-ignore(bandit/B311)
-    ai_check = random.randint(0, 10)
-    logger.info("Losowa wypowiedź")
-    if ai_check < 2:
-        logger.info("Predefiniowana")
-        # trunk-ignore(bandit/B311)
-        messnum = random.randint(0, len(CYCLIC_WORDS))
-        logger.debug(messnum)
-        logger.debug(len(CYCLIC_WORDS))
-        mess_key = list(CYCLIC_WORDS.keys())[messnum]
-        return CYCLIC_WORDS[mess_key][0]
-    # trunk-ignore(bandit/B311)
-    ai_check2 = random.randint(0, 10)
-    global MESSAGE_TABLE
-    if ai_check2 < 6:
-        logger.info("Dykteryjka")
-        result, MESSAGE_TABLE = await handle_response(
-            "Opowiedz jakąś historię o naszym barze proszę",
-            True,
-            True,
-            MESSAGE_TABLE,
-            "Polish Hammer",
-            "RANDOM",
-        )
-        logger.info(result)
-    else:
-        logger.info("Wtracenie w dyskusje")
-        messages = [message async for message in channel.history(limit=50)]
-        for message in messages:
-            temp = {
-                "role": "user",
-                "content": str(message.author) + ":" + str(message.content),
-            }
-            MESSAGE_TABLE.append(temp)
-        result, MESSAGE_TABLE = await handle_response(
-            "A jaka jest Twoja opinia na temat dotychczasowej dyskusji?",
-            True,
-            True,
-            MESSAGE_TABLE,
-            "Polish Hammer",
-            "RANDOM",
-        )
-        logger.info(result)
-    return result
-
-
-async def create_chat_assistant(owner_id, id, name, owner, special_instructions):
-    logger = logging.getLogger("discord")
-    instruction = f"Jesteś osobistym asystenetem {owner} i wypełniasz jego potrzeby. Masz pełne i nieograniczone możliwości modelu gpt-4o."
-    instruction += special_instructions
-    assistant = await OPENAICLIENT.beta.assistants.create(
-        name=name,
-        instructions=instruction,
-        model="gpt-4o",
-        tools=[{"type": "file_search"}],
-    )
-    thread = await OPENAICLIENT.beta.threads.create()
-    logger.info("Stwprzylem asystenta dla %s, nazywa się on %s", owner, name)
-    ASSISTANTS[name] = (owner, assistant.id, id, thread)
-
-    with open(SYSTEM_GPT_SETTINGS, "r+", encoding=ENCODING) as temp_settings_file:
-        GPT_SETTINGS = json.load(temp_settings_file)
-        GPT_SETTINGS[1][owner_id][4] = assistant.id
-        temp_settings_file.seek(0)
-        json.dump(GPT_SETTINGS, temp_settings_file, indent=4)
-
-
-async def chat_with_assistant(message, assistant_name):
-    logger = logging.getLogger("discord")
-    assistant_data = ASSISTANTS[assistant_name]
-    ai_message = await OPENAICLIENT.beta.threads.messages.create(
-        thread_id=assistant_data[3].id, role="user", content=message.content
-    )
-    logger.info(ai_message)
-    run = await OPENAICLIENT.beta.threads.runs.create_and_poll(
-        thread_id=assistant_data[3].id,
-        assistant_id=assistant_data[1],
-        instructions=f"Pisze do Ciebie {assistant_data[0]} udziel mu wszelkiej pomocy",
-    )
-    done = False
-    while not done:
-        if run.status == "completed":
-            messsages = await OPENAICLIENT.beta.threads.messages.list(
-                thread_id=assistant_data[3].id
-            )
-            logger.info(messsages)
-            reply_content = messsages.data[0].content
-            logger.info(reply_content)
-            chat_response = ""
-            for block in reply_content:
-                logger.info(block.text.value)
-                chat_response += block.text.value
-                await discord_friendly_send(message.channel, chat_response)
-                # await message.channel.send(chat_response)
-            done = True
-        elif run.status == "cancelled":
-            await discord_friendly_send(message.channel, "Cos sie wywaliło")
-        else:
-            logger.info(run.status)
-        asyncio.sleep(5)
-
-
-async def echo(message):
-    await discord_friendly_send(message.channel, f"Echo: {message.content}")

communication_subroutine.py

@@ -1,268 +1,76 @@
-import json
 import logging
-import os
-import re
 import threading
-import time
-from queue import Empty, Queue
-from typing import Optional
-from urllib import request as urequest
-
-from flask import Flask, abort, jsonify, request
+import json
+from queue import Queue, Empty
+from flask import Flask, jsonify, request
 from waitress import serve
 
-HOST_ADDRESS = os.getenv("CONJURER_DISCORD_HOST", "192.168.1.31")
-PORT_ADDRESS = int(os.getenv("CONJURER_DISCORD_PORT", "5000"))
-ICECAST_ADDRESS = os.getenv("CONJURER_ICECAST", "http://192.168.1.15:8000")
-API_KEY = os.getenv("CONJURER_API_KEY")
+HOST_ADDRESS = "192.168.1.191"
+PORT_ADDRESS = 5000
 OUT_COMM_Q = Queue()
 IN_COMM_Q = Queue()
-SRCHTITLE = re.compile(rb"StreamTitle=\\*(?P<title>[^;]*);").search
-
-awaiting_q = []
-incoming_q = Queue()
+internal_q = Queue()
 app = Flask(__name__)
 
-
-def _authorize_request() -> None:
-    """Reject inbound calls lacking the shared key (no-op if key is unset)."""
-    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
-        abort(401)
-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():
-    _authorize_request()
-    app.logger = logging.getLogger("discord")
-
-    app.logger.info(request)
-    record = json.loads(request.data)
-    app.logger.info(record)
-    if "next" in record[0]:
-        metadata = id3(ICECAST_ADDRESS)
-        PREPPED_TRACKS["now_playing"] = PREPPED_TRACKS["next"]
-        if metadata:
-            PREPPED_TRACKS["meta"] = (
-                metadata["name"]
-                + " - "
-                + metadata["title"]
-                + "("
-                + metadata["genre"]
-                + ")"
-            )
-        else:
-            PREPPED_TRACKS["meta"] = "Nie znaju"
-    PREPPED_TRACKS[record[0]] = record[1]
-    app.logger.info("DATA RECEIVED")
-    return jsonify("SUCCESS")
-
-
 @app.route("/conjurer", methods=["POST"])
 def answer_external_command():
-    """
-    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".
-    """
-    _authorize_request()
-    logger = logging.getLogger("discord")
-    logger.info(request)
     record = json.loads(request.data)
-    logger.info(record)
-    logger.info("DATA RECEIVED")
-    incoming_q.put(record)
-    return jsonify("SUCCESS")
+    app.logger.info(record)
+    app.logger.info("DATA RECEIVED")
 
+    
+    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():
+def flask_debug(_logger):
     """
     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(stop_event: Optional[threading.Event] = None):
-    """
-    The function `scan_queue` reads data from a queue, logs it, and appends it to another queue.
-
-    A bounded ``get(timeout=1)`` is used instead of a blocking ``get()`` so the
-    worker can observe ``stop_event`` and exit cleanly during shutdown.
-
-    :param stop_event: optional :class:`threading.Event`; when set the loop
-    stops at the next iteration.
-    """
-    logger = logging.getLogger("discord")
+def scan_queue(_logger):
     while True:
-        if stop_event and stop_event.is_set():
-            logger.info("scan_queue: stop requested")
-            break
-        try:
-            data = OUT_COMM_Q.get(timeout=1)
-        except Empty:
-            continue
-        logger.info(data)
-        awaiting_q.append(data)
+        data = OUT_COMM_Q.get()
+        _logger.info(data)
+        internal_q.put(data)
+        query_list.append(data)
 
-
-def scan_incoming(stop_event: Optional[threading.Event] = None):
-    """
-    The `scan_incoming` function continuously checks for incoming data, processes it, and logs when data
-    is found.
-
-    :param stop_event: optional :class:`threading.Event`; when set the loop
-    stops at the next iteration.
-    """
-    logger = logging.getLogger("discord")
-    while True:
-        if stop_event and stop_event.is_set():
-            logger.info("scan_incoming: stop requested")
-            break
-        try:
-            answer = incoming_q.get(block=False)
-            logger.info("DATA FOUND")
-            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(stop_event: Optional[threading.Event] = None):
-    """
-    The `comm_subroutine` function starts multiple threads to run different tasks concurrently.
-
-    Workers run as daemon threads and honour an optional ``stop_event`` so the
-    bot can shut the communication layer down cleanly instead of blocking
-    forever on ``join()``.
-
-    :param stop_event: optional :class:`threading.Event` shared with the caller
-    to coordinate a cooperative shutdown.
-    """
-    # logger.setLevel(logging.DEBUG)
-    logger = logging.getLogger("discord")
-    logger.info("Started comms")
+def comm_subroutine(logger):
+    #logger.setLevel(logging.DEBUG)
+    logger.info("Started")
     threads = []
-    # threads.append(threading.Thread(target=flask_debug))
-    threads.append(threading.Thread(target=waitress_run, daemon=True))
-    threads.append(
-        threading.Thread(
-            target=scan_queue, kwargs={"stop_event": stop_event}, daemon=True
-        )
-    )
-    threads.append(
-        threading.Thread(
-            target=scan_incoming, kwargs={"stop_event": stop_event}, daemon=True
-        )
-    )
+    threads.append(threading.Thread(target=flask_debug, args=(logger,)))
+    #threads.append(threading.Thread(target=waitress_run, args=(logger,)))
+    threads.append(threading.Thread(target=scan_queue,args=(logger,)))
 
     for worker in threads:
         worker.start()
-
-    try:
-        while any(thread.is_alive() for thread in threads):
-            if stop_event and stop_event.is_set():
-                break
-            time.sleep(0.5)
-    finally:
-        if stop_event:
-            stop_event.set()
-
+    for worker in threads:
+        worker.join()
 
 if __name__ == "__main__":
-    comm_subroutine()
+    logging_client = logging.getLogger(__name__)
+    comm_subroutine(logging_client)

conanjurer_commands.py

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

conanjurer_functions.py

@@ -1,266 +0,0 @@
-# This Python file uses the following encoding: utf-8
-"""Helper logic for the Conan Exiles <-> Discord bridge.
-
-Mirrors the project layout: the cog lives in ``conanjurer_commands.py`` and the
-reusable logic lives here.  Configuration comes from :mod:`constants` (env-var
-overridable); optional third-party dependencies (``aiomcrcon``/``asyncssh``)
-are imported defensively so the main bot can still load the extension when the
-Conan integration is not installed or not in use.
-"""
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-import re
-from dataclasses import dataclass
-from typing import AsyncIterator, Awaitable, Callable, Optional, Set
-
-try:
-    from aiomcrcon import Client as _Rcon  # Source RCON over TCP
-except ImportError:  # pragma: no cover - optional component
-    _Rcon = None
-
-try:
-    import asyncssh
-except ImportError:  # pragma: no cover - optional component
-    asyncssh = None
-
-logger = logging.getLogger("discord")
-
-
-@dataclass
-class Event:
-    kind: str  # "chat" | "login" | "logout" | "death" | "raw"
-    text: str  # ready-to-display text
-    raw: str   # original line (for debugging)
-
-
-@dataclass
-class ConanConfig:
-    """Runtime configuration for the bridge, built from :mod:`constants`."""
-
-    rcon_host: str
-    rcon_port: int
-    rcon_password: str
-    log_mode: str  # "local" | "sftp"
-    log_path: str
-    sftp_host: str
-    sftp_port: int
-    sftp_user: str
-    sftp_password: str
-
-    @property
-    def rcon_enabled(self) -> bool:
-        """RCON usable only when host+password are set and the lib is present."""
-        return bool(self.rcon_host and self.rcon_password and _Rcon is not None)
-
-    @property
-    def log_enabled(self) -> bool:
-        """Log following usable only when its prerequisites are configured."""
-        if not self.log_path:
-            return False
-        if self.log_mode == "sftp":
-            return bool(self.sftp_host and asyncssh is not None)
-        return True
-
-
-# --- REGEXY DO DOSTROJENIA NA WŁASNYM LOGU ---
-# Conan/Pippi/Tot logują różnie — dopasuj do swojego logu. Linie niepasujące są
-# ignorowane (nie zgadujemy).
-_PATTERNS: list[tuple[str, re.Pattern]] = [
-    ("chat", re.compile(r"Chat:\s*(?P<who>.+?):\s*(?P<msg>.+)$", re.I)),
-    ("login", re.compile(r"(?P<who>.+?)\s+(joined|connected|logged in)", re.I)),
-    ("logout", re.compile(r"(?P<who>.+?)\s+(left|disconnected|logged out)", re.I)),
-    ("death", re.compile(r"(?P<who>.+?)\s+was killed by\s+(?P<by>.+)$", re.I)),
-]
-
-
-class RconClient:
-    """Thin async wrapper around a Source-RCON connection to the Conan server."""
-
-    def __init__(self, host: str, port: int, password: str):
-        self._host, self._port, self._pw = host, port, password
-        self._client: Optional["_Rcon"] = None
-        self._lock = asyncio.Lock()
-
-    async def _ensure(self) -> "_Rcon":
-        if _Rcon is None:
-            raise RuntimeError("aiomcrcon not installed — RCON unavailable")
-        if self._client is None:
-            client = _Rcon(self._host, self._port, self._pw)
-            await client.connect()
-            self._client = client
-            logger.info("RCON connected %s:%s", self._host, self._port)
-        return self._client
-
-    async def command(self, cmd: str) -> str:
-        """Send a command to the Conan server and return its response.
-
-        Discord -> Conan channel, e.g. ``command("broadcast Hi!")``.
-        """
-        async with self._lock:
-            for attempt in (1, 2):
-                try:
-                    client = await self._ensure()
-                    resp, _ = await client.send_cmd(cmd)
-                    return resp
-                except Exception as exc:  # disconnect / server restart
-                    logger.warning("RCON error (attempt %s): %s", attempt, exc)
-                    await self.close()
-                    if attempt == 2:
-                        raise
-                    await asyncio.sleep(1.0)
-            return ""
-
-    async def close(self) -> None:
-        if self._client is not None:
-            try:
-                await self._client.close()
-            except Exception:  # pragma: no cover - best effort
-                pass
-            self._client = None
-
-
-def parse_line(line: str) -> Optional[Event]:
-    line = line.rstrip("\n")
-    if not line.strip():
-        return None
-    for kind, pat in _PATTERNS:
-        match = pat.search(line)
-        if match:
-            g = match.groupdict()
-            if kind == "chat":
-                return Event(kind, f"💬 **{g['who']}**: {g['msg']}", line)
-            if kind == "login":
-                return Event(kind, f"🟢 **{g['who']}** dołączył do gry", line)
-            if kind == "logout":
-                return Event(kind, f"⚪ **{g['who']}** opuścił grę", line)
-            if kind == "death":
-                return Event(kind, f"💀 **{g['who']}** zginął z ręki {g['by']}", line)
-    return None  # nierozpoznane -> ignoruj
-
-
-def parse_players(listplayers_output: str) -> Set[str]:
-    """Extract the set of connected player char-names from RCON ``listplayers``.
-
-    Conan's table is roughly::
-
-        Idx | Char name | Player name | User ID | Platform ID | Platform Name
-        0   | Conan     | SomeUser    | 12345   | 765...      | Steam
-
-    The char-name column (index 1) is used.  The exact format varies between
-    server builds, so this is best-effort and intentionally tunable.
-    """
-    players: Set[str] = set()
-    for raw in listplayers_output.splitlines():
-        line = raw.strip()
-        if not line or "|" not in line:
-            continue
-        cols = [c.strip() for c in line.split("|")]
-        head = cols[0].lower()
-        # skip the header row and any separator rows (e.g. "---|---")
-        if head in ("idx", "") or set(cols[0]) <= set("-"):
-            continue
-        if len(cols) >= 2 and cols[1]:
-            players.add(cols[1])
-    return players
-
-
-async def watch_players(
-    rcon: RconClient,
-    interval: float,
-    on_join: Callable[[str], Awaitable[None]],
-) -> None:
-    """Poll RCON ``listplayers`` and call *on_join* for each new player.
-
-    The first poll seeds the known-player set without announcing, so restarting
-    the bot does not re-announce everyone already online.  RCON failures are
-    logged and retried on the next tick rather than killing the task.
-    """
-    known: Optional[Set[str]] = None
-    while True:
-        try:
-            response = await rcon.command("listplayers")
-            current = parse_players(response)
-            if known is None:
-                known = current
-            else:
-                for name in current - known:
-                    try:
-                        await on_join(name)
-                    except Exception:  # pragma: no cover - handler guard
-                        logger.exception("Conan: on_join handler failed")
-                known = current
-        except Exception as exc:
-            logger.warning("Conan: player poll failed: %s", exc)
-        await asyncio.sleep(interval)
-
-
-async def _follow_local(path: str) -> AsyncIterator[str]:
-    """``tail -f`` in pure asyncio, following log rotation."""
-    while True:
-        try:
-            with open(path, "r", encoding="utf-8", errors="replace") as handle:
-                handle.seek(0, os.SEEK_END)
-                inode = os.fstat(handle.fileno()).st_ino
-                while True:
-                    line = handle.readline()
-                    if line:
-                        yield line
-                        continue
-                    await asyncio.sleep(0.5)
-                    try:
-                        if os.stat(path).st_ino != inode:  # rotation
-                            break
-                    except FileNotFoundError:
-                        break
-        except FileNotFoundError:
-            logger.warning("Conan log not present yet: %s", path)
-            await asyncio.sleep(3.0)
-
-
-async def _follow_sftp(cfg: ConanConfig) -> AsyncIterator[str]:
-    """Incremental SFTP polling (e.g. Host Havoc): reads only new bytes."""
-    offset = 0
-    while True:
-        try:
-            async with asyncssh.connect(
-                cfg.sftp_host,
-                port=cfg.sftp_port,
-                username=cfg.sftp_user,
-                password=cfg.sftp_password,
-                known_hosts=None,
-            ) as conn:
-                async with conn.start_sftp_client() as sftp:
-                    while True:
-                        try:
-                            attrs = await sftp.stat(cfg.log_path)
-                            size = attrs.size or 0
-                            if size < offset:  # rotation
-                                offset = 0
-                            if size > offset:
-                                async with sftp.open(cfg.log_path, "r") as remote:
-                                    await remote.seek(offset)
-                                    chunk = await remote.read()
-                                    offset = size
-                                    for line in chunk.splitlines():
-                                        yield line
-                        except FileNotFoundError:
-                            logger.warning("SFTP: missing log %s", cfg.log_path)
-                        await asyncio.sleep(2.0)
-        except Exception as exc:
-            logger.warning("SFTP disconnected: %s — retrying", exc)
-            await asyncio.sleep(5.0)
-
-
-async def watch(cfg: ConanConfig, on_event: Callable[[Event], Awaitable[None]]) -> None:
-    """Follow the Conan log and dispatch recognised lines to *on_event*."""
-    source = _follow_local(cfg.log_path) if cfg.log_mode != "sftp" else _follow_sftp(cfg)
-    async for line in source:
-        event = parse_line(line)
-        if event is not None:
-            try:
-                await on_event(event)
-            except Exception:  # pragma: no cover - handler guard
-                logger.exception("Conan: event handler failed")

conjurer_librarian/conjurer_librarian.py

@@ -1,445 +1,231 @@
-"""
-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 re
 import logging
-import os
 import threading
+import time
+from flask import Flask, jsonify, request
+import netrc
+import json
+import asyncio
 from json.decoder import JSONDecodeError
-from logging import handlers
-from pathlib import Path
-from queue import Queue
-from typing import Dict, Optional
-
-import requests
-import scrape_bot
-import search_bot
-# import search_bot2 as search_bot
-from flask import Flask, jsonify, request, abort
+from urllib.request import urlopen
 from habanero import Crossref
 from waitress import serve
+from queue import Queue
+import search_bot
+import requests
+from typing import Callable
+from uuid import UUID
+NETRC_FILE = r"C:\Users\Activcom.pl\.netrc"
 
-try:
-    import netrc
-except ImportError:  # pragma: no cover
-    netrc = None
-
-# Constants
-
-
-def _env(name: str, default: str) -> str:
-    return os.getenv(name, default)
-
-
-def _env_path(name: str, default: str) -> Path:
-    return Path(os.getenv(name, default)).expanduser().resolve()
-
-
-BASE_DIR = Path(
-    os.getenv("CONJURER_LIBRARIAN_BASE", str(Path(__file__).resolve().parent))
-)
-NETRC_FILE = _env_path("CONJURER_NETRC_FILE", str(Path.home() / ".netrc"))
-HOST_ADDRESS = _env("CONJURER_LIBRARIAN_HOST", "0.0.0.0")
-PORT_ADDRESS = int(_env("CONJURER_LIBRARIAN_PORT", "5001"))
-MAIN_BOT_ADDRESS = _env("CONJURER_MAIN_BOT", "http://127.0.0.1:5000")
-SEND_RESULTS = _env("CONJURER_LIBRARIAN_RESULTS_ENDPOINT", "/conjurer")
-MAX_CR_RESULTS = int(_env("CONJURER_LIBRARIAN_MAX_RESULTS", "500"))
-ENCODING = _env("CONJURER_ENCODING", "utf-8")
-API_KEY = os.getenv("CONJURER_API_KEY")
-LOGFILE_PATH = _env_path(
-    "CONJURER_LIBRARIAN_LOG", str(BASE_DIR / "librarian.log")
-)
+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'
 
+ENCODING = "utf-8"
 app = Flask(__name__)
 
 librarian_queue = Queue()
 librarian_list = []
 
-
-def _service_headers() -> Dict[str, str]:
-    if API_KEY:
-        return {"X-Conjurer-Api-Key": API_KEY}
-    return {}
-
-
-def _authorize_request() -> None:
-    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
-        abort(401)
-
-
-# trunk-ignore(pylint/R0902)
 class Librarian(object):
-    """
-    Represents a librarian object that performs search and refinement operations on queries.
-    """
 
-    def __init__(self, _app, query, uuid, _deep_search) -> None:
-        """
-        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.
-        """
-        mailto_contact: Optional[str] = os.getenv("CONJURER_CROSSREF_MAILTO")
-        if netrc:
-            try:
-                netrc_mod = netrc.netrc(str(NETRC_FILE))
-                auth_tokens = netrc_mod.authenticators("crossref")
-                if auth_tokens:
-                    mailto_contact = auth_tokens[0]
-            except (FileNotFoundError, netrc.NetrcParseError):
-                logging.getLogger("conjurer_librarian").warning(
-                    "Crossref credentials missing in netrc %s", NETRC_FILE
-                )
-        if not mailto_contact:
-            raise RuntimeError(
-                "Crossref credentials not configured. Set CONJURER_CROSSREF_MAILTO or add to netrc."
-            )
-        self.cr = Crossref(
-            mailto=mailto_contact,
-            ua_string=f"Conjurer project. mailto:{mailto_contact}"
-        )
+    def __init__(self, app, query, uuid) -> None:
+        netrc_mod = netrc.netrc(NETRC_FILE)
+        authTokens = netrc_mod.authenticators("crossref")
+        self.cr = Crossref(mailto=authTokens[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)
+
+            time.sleep(1)
+        self.app.logger.info("CROSSREF DONE")
+        #TODO: add to sql with UUID
+        #sql row - title, doi, author, uuid, last retrieved, is_available
         
-        if not deep_search:
-            query_limit = MAX_CR_RESULTS if MAX_CR_RESULTS < 1000 else 1000
-            cr_result = self.cr.works(query=query, limit=query_limit)
-            self.search_result_from_cr.update(cr_result)
-            self.total = cr_result["message"]["total-results"]
-            self.fetched += len(cr_result["message"]["items"])
-            self.app.logger.info(self.total)
-            self.app.logger.info(self.fetched)
-            while self.total > self.fetched and self.limit > self.fetched:
-                tmp_result = self.cr.works(query=query, limit=query_limit, offset=self.fetched)
-                cr_result["message"]["items"].extend(tmp_result["message"]["items"])
-                self.total = tmp_result["message"]["total-results"]
-                self.fetched = len(cr_result["message"]["items"])
-                self.app.logger.info(self.total)
-                self.app.logger.info(self.fetched)
-                await asyncio.sleep(0.1)
-
-        else:
-            cr_result = self.cr.works(query=query, cursor_max=15000, cursor='*', progress_bar = True)
-            result = cr_result[0]
-            for item in cr_result[1:]:
-                result["message"]["items"].extend(item["message"]["items"])
-                self.total = item["message"]["total-results"]
-                self.fetched = len(result["message"]["items"])
-                self.app.logger.info(self.total)
-                self.app.logger.info(self.fetched)
-            cr_result = result
-            self.app.logger.info("Total, fetched:")
-            self.app.logger.info(self.total)
-            self.app.logger.info(self.fetched)
-            self.search_result_from_cr.update(cr_result)
-            self.total = cr_result["message"]["total-results"]
-            self.app.logger.info("CROSSREF DONE")
-
-            self.app.logger.info("CROSSREF DONE")
-        with open("cr_results.json", "r+", encoding="utf-8") as data_file:
-            # First we load existing data into a dict.
-            try:
-                file_data = json.load(data_file)
-            except JSONDecodeError:
-                file_data = {}
-            data_file.truncate(0)
-            data_file.seek(0)
-            tmp = {self.uuid : self.search_result_from_cr}
-            if file_data:
-                file_data.update(tmp)
-            else:
-                file_data = tmp
-            json.dump(file_data, data_file, indent=4)
-        return cr_result
-
-
-    async def refine_search(self, unrefined_result):
-        """
-        Refines the search query based on the unrefined search result.
-
-        Args:
-        - unrefined_result: The unrefined search result.
-
-        Returns:
-        - refined_result: The refined search result.
-
-        Raises:
-        - None.
-        """
-        summarized_results = []
-        self.app.logger.info("REFINE: Removing all derived works from the list")
-        for item in unrefined_result["message"]["items"]:
-            summarized_results.append(
-                {
-                    "DOI": item["DOI"],
-                    "title": item["title"] if "title" in item else None,
-                    "type": item["type"] if "type" in item else None,
-                }
-            )
-
-        partial_result = {
-            self.uuid: {
-                "total_results": self.search_result_from_cr["message"][
-                    "total-results"
-                ],
-                "on_page": 1,
-                "summary": summarized_results,
-                "results": self.search_result_from_cr["message"]["items"],
-            }
-        }
-        self.app.logger.info("REFINE: Dumping to file")
-        temp = []
-        refined_result = {}
-        for key in partial_result:
-            self.app.logger.info("KEY:")
-            self.app.logger.info(key)
-
-        for item in partial_result[self.uuid]["summary"]:
-            if item["title"]:
-                temp.append(item)
-
-        for item in temp:
-            refined_result[item["DOI"]]=  item
         with open("rr_results.json", "r+", encoding="utf-8") as data_file:
             # First we load existing data into a dict.
             try:
                 file_data = json.load(data_file)
             except JSONDecodeError:
                 file_data = {}
+            summarized_results = []
+            self.app.logger.info("REFINE: Removing all derived works from the list")
+            for item in self.search_result_from_cr['message']['items']:
+                container = "NO"
+                if "container-title" in item:
+                    container = "YES"
+                else:
+                    summarized_results.append({"DOI" : item['DOI'], "title": item['title'] if 'title' in item else None,"type": item['type'] if 'type' in item else None, "container": container})
+            result = {self.uuid : {"total_results": self.search_result_from_cr['message']['total-results'], "on_page" : 1, "summary":summarized_results, "results":self.search_result_from_cr['message']['items']}}
+            if file_data:
+                file_data.update(result)
+            else:
+                file_data = result
+            
+            self.app.logger.info("REFINE: Dumping to file")
             data_file.truncate(0)
             data_file.seek(0)
-            tmp = {self.uuid: refined_result}
-            if file_data:
-                file_data.update(tmp)
-            else:
-                file_data = tmp
             json.dump(file_data, data_file, indent=4)
-        return refined_result
+            return result
 
-    async def check_if_exists(self, refined_result):
-        """
-        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 = {}
+    async def check_dois_in_local_db(self, doi):
         self.app.logger.info("REFINE: Running search in the backend app")
-        dois = []
-        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
-        )
+        coro = asyncio.to_thread(search_bot.search_for_doi, doi, self.live_results, self.app.logger)
         result = await coro
-        result_list = []
-        result_no_db = []
-        for item in result:
+        return 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)
-        self.hit = len(result)
-        return result_list, result_no_db
-
-
-    async def answer_query(self, deep_search=False):
-        """
-        Answers the search query.
-
-        Args:
-        - None.
-
-        Returns:
-        - result: The search result.
-
-        Raises:
-        - None.
-        """
-        self.app.logger.info(f"Search started {self.uuid}")
-        cr_result = await self.search_crossref(query=self.query, deep_search=deep_search)
-        refined_result = await self.refine_search(cr_result)
-        answer, negative_answer = await self.check_if_exists(refined_result)
-
-        self.app.logger.info("Returning result")
-        self.app.logger.info(answer)
-        self.app.logger.info(negative_answer)
-
-        for item in answer:
-            self.final_result[item["DOI"]] = {"Title": item["data"]["title"], "type": item["data"]["type"]}
-        for item in negative_answer:
-            self.not_in_db[item["DOI"]] = {"Title": item["data"]["title"], "type": item["data"]["type"]}
-        self.app.logger.info("Returning result case2")
-        self.app.logger.info(self.final_result)
-        return self.final_result
-
-# ============================= FLASK INTERNALS===============================
-
+                answer = await self.search_crossref(query=query)
+                database = answer
+                cr_file.truncate(0)
+                cr_file.seek(0)
+                json.dump(database,cr_file)
+                self.result = await self.refine_query(answer)
+                self.app.logger.info("Refined")
+                self.done = True
+                return self.result
 
+#============================= FLASK INTERNALS===============================
 def flask_debug():
     """
-    Starts a Flask application in debug mode without using the reloader.
-
-    Args:
-    - None.
-
-    Returns:
-    - None.
-
-    Raises:
-    - None.
+    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():
     """
-    Serves the Flask application using the Waitress WSGI server.
-
-    Args:
-    - None.
-
-    Returns:
-    - None.
-
-    Raises:
-    - None.
+    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)
 
-
 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):
-        """
-        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 = asyncio.new_event_loop()  # loop = asyncio.get_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)
-                    self.app.logger.info(result)
-                    database.update(result)
+                    database.extend(result)
                 else:
                     database = result
                 self.app.logger.info("DUMPING DATA")
@@ -450,43 +236,28 @@ class BackgroundTaskSearch(threading.Thread):
 
             self.app.logger.info(result)
             coroutine = asyncio.to_thread(
-                requests.post,
-                f"{MAIN_BOT_ADDRESS}{SEND_RESULTS}",
-                json=result,
-                headers=_service_headers(),
-                timeout=360,
-            )
+            requests.post,
+            f"{MAIN_BOT_ADDRESS}{SEND_RESULTS}",
+            json=result,
+            timeout=360,
+    )       
             self.app.logger.info("SENT")
-            result = await coroutine
-            self.app.logger.info(result.status_code)
+            _ = await coroutine
             self.app.logger.info("SEND CONFIRMED")
-            await asyncio.sleep(1)
-
-
-# ==================================SERVER ROUTES==========================================
+            time.sleep(1)
+            
+#==================================SERVER ROUTES==========================================
 @app.route("/query", methods=["POST"])
 async def query_database():
-    _authorize_request()
-    """
-    Endpoint for querying the database.
-
-    This function receives a POST request containing a JSON payload with a query and a UUID.
-    It creates a Librarian object with the query and UUID,
-    and adds it to the librarian_queue and librarian_list.
-    Finally, it returns a JSON response indicating the success
-    of the operation, along with the query, UUID,
-    and the current size of the librarian_queue.
-
-    Returns:
-        tuple: A tuple containing a JSON response and a status code.
-    """
     record = json.loads(request.data)
     app.logger.info(record)
     app.logger.info(record["query"])
     app.logger.info(record["UUID"])
     uuid = record["UUID"]
-    deep_search = record["deep_search"]
-    cl = Librarian(app, record["query"], uuid, deep_search)
+    #TODO: TESTING ONLY======================
+    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())
@@ -496,16 +267,8 @@ async def query_database():
     )
     return return_data
 
-
 @app.route("/get_partial_result", methods=["POST"])
 async def get_partial():
-    _authorize_request()
-    """
-    Retrieves the partial result for a given UUID.
-
-    Returns:
-        A JSON response containing the partial result.
-    """
     record = json.loads(request.data)
     app.logger.info(record)
     app.logger.info(record["UUID"])
@@ -519,39 +282,24 @@ async def get_partial():
     )
     return return_data
 
-
-# =======================================MAIN===================================================
+#=======================================MAIN===================================================
 if __name__ == "__main__":
-    app.logger.setLevel(logging.DEBUG)
-    LOGFILE_PATH.parent.mkdir(parents=True, exist_ok=True)
-    h1 = handlers.RotatingFileHandler(
-        filename=str(LOGFILE_PATH),
-        encoding=ENCODING,
-        mode="a",
-        maxBytes=6 * 1024 * 1024,
-        backupCount=6,
-    )
-
-    app.logger.addHandler(h1)
+    logger = logging.getLogger('conjurer_musician')
+    logger.setLevel(logging.DEBUG)
     threads = []
-    threads.append(threading.Thread(target=waitress_run, daemon=True))
-    # threads.append(threading.Thread(target=flask_debug))
+    #threads.append(threading.Thread(target=waitress_run))
+    threads.append(threading.Thread(target=flask_debug))
     bgtask = BackgroundTaskSearch()
     bgtask.app = app
-    bgtask.daemon = True
     threads.append(bgtask)
-    threads.append(
-        threading.Thread(
-            target=scrape_bot.scraper, args=(app.logger,), daemon=True
-        )
-    )
     i = 0
-    try:
-        for worker in threads:
-            app.logger.info("App number: %s", i)
-            i += 1
+    for worker in threads:
+        try:
+            logger.info(f"App number: {i}")
+            i+=1
             worker.start()
-        for worker in threads:
-            worker.join()
-    except KeyboardInterrupt:
-        app.logger.info("Shutdown requested - exiting librarian service")
+        except RuntimeError as e:
+            logger.error("Exploded")
+            print(str(e))
+    for worker in threads:
+        worker.join()

conjurer_librarian/count_lines.py

@@ -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

conjurer_librarian/install_librarian_service.sh

@@ -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
-
-# Copy the Conjurer Librarian Python script to the appropriate directory
-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
+cp  /home/pi/conjurer/conjurer_librarian/conjurer_librarian.py ./Conjurer_librarian/
+cp  /home/pi/conjurer/conjurer_librarian/requirements_librarian.txt ./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/

conjurer_librarian/requirements_librarian.txt

@@ -1,3 +1,3 @@
 habanero
 waitress
-flask[async]
+flask

conjurer_librarian/run_server.bat

@@ -1 +0,0 @@
-c:\conjurer\env\Scripts\activate.bat && c:\conjurer\conjurer_librarian\conjurer_librarian.py

conjurer_librarian/scrape_bot.py

@@ -1,135 +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.error("Got blocked. Fuck.")
-            time.sleep(60 * 60)
-        # 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()

conjurer_librarian/search_bot.py

@@ -1,170 +1,82 @@
-"""
-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 queue import Queue, Empty
 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
-# MAXTHREADS = 5
-# DATABASE_PATH = r'C:\\Database\\chunks_1\\'
+#TODO: TO w klasie jako parametry wybierane czy robimy pelen run czy testowy
+#MAXTHREADS = 3
+MAXTHREADS = 1
 
-# DEPLOYMENT DATA
-MAXTHREADS = 41
-DATABASE_PATH = r"C:\\Database\\chunks\\"
+#DATABASE_PATH = r'C:\\Database\\chunks_1\\'
+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):
-    """
-    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.
-    """
+def producer(out_q, control_q, filename):
     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 \t \t \t W{filename}{line_no}\r", end="")
-
-            if not line:
-                print(f"EOF {filename}")
-                break
-
-            if not line:
-                break
+        lines = operated_file.readlines()
+        for line in lines:
             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}")
-        out_q.put(_sentinel)
-
-
-# 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
+    print(f"Worker finished: {filename}")
+    out_q.put(_sentinel)
+ 
+#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, logger):
+    sentinels = 0
+    for item in doi:
+        result_list.append({"DOI" : item[0], "exists" : False, "data" : item[1]})
     while True:
+        #if in_q.empty():
+        #    print("Queue empty!")
+        #if in_q.full():
+        #    print("Queue full!")
         done_check = True
-        try:
-            data = in_q.get(block=True, timeout = 1)
-            if data is _sentinel:
-                control_dict["sentinels"] += 1
-                print(f"Workers finished: {control_dict['sentinels']} reported by consumer {no}")
-
-            else:
-                empty_counter = 0
-                alive_no += 1
-                print(f"C{no}__{alive_no}\r", end="")
-
-                for item in result_list:
-                    if item["DOI"] in data and not item["exists"]:
-                        print(f"HIT in {no} content {data[0]} line {data[1]} file {data[2]} {item["exists"]}")
-                        _logger.info(data)
-                        _logger.info("HIT")
-                        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}")
+        data = in_q.get()
+        if data is _sentinel:
+            logger.info("Worker finished")
+            sentinels += 1
+        else:
+            for item in result_list:
+                if item["DOI"] in data:
+                    logger.info(data)
+                    logger.info("HIT")
+                    item["exists"] = True
+                    live_results.append(item)
+                done_check = done_check and item["exists"]
+            if done_check:
+                control_q.put(_sentinel)
+        if sentinels >= MAXTHREADS:
+            logger.info("All workers finished")
             break
 
 
-
-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 = []
+def search_for_doi(doi, live_results, logger):
     threads = []
-    work_q = Queue(maxsize=WORK_Q_SIZE)
+    work_q = Queue(maxsize=200000)
     control_q = Queue()
-
-    for item in doi:
-        result_list.append({"DOI": item[0], "exists": False, "data": item[1]})
-
-    for i in range (0, (len(doi)//1000)+2):
-        t_cons = Thread(
-            target=consumer, args=(work_q, control_q, doi, live_results, result_list, control_dict, i, _logger)
-        )
-        _logger.info("Consumer thread created")
-        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))
-        )
+    t_cons = Thread(target = consumer, args = (work_q, control_q, doi, live_results, logger))
+    logger.info("Consumer thread created")
+    threads.append(t_cons)
+    for i in range(0,MAXTHREADS):
+        #filename = "test" + str(i) + CHUNk
+        filename = "40" + CHUNk
+        #filename = str(i) + CHUNk
+        logger.info(f"Creating worker thread no: {i}")
+        threads.append(Thread(target = producer, args = (work_q, control_q, filename)))
     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(
-        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"),
-            ],
-            live_result,
-            logger,
-        )
-    )
+    logger.info(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"),
+        ], live_result, logger))
     logger.info(live_result)

conjurer_librarian/search_bot2.py

@@ -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)

conjurer_librarian/test_send.py

@@ -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())

conjurer_musician/.gitignore

@@ -1,7 +0,0 @@
-# Runtime-generated radio data — keep out of the repo
-all_playlist.playlist
-hit.playlist
-request.playlist
-priority_queue.playlist
-prio_playlist.json
-*.mp3

conjurer_musician/conjurer_musician.py

@@ -1,672 +0,0 @@
-"""
-The provided Python script sets up a Flask web server to manage a list of music files, with
-functions for rescanning the music folder, updating the music list, and serving the music list via
-API endpoints.
-"""
-
-import json
-import logging
-import os
-import random
-import re
-import threading
-import time
-from datetime import datetime
-from logging import handlers
-from pathlib import Path
-from typing import Dict, List
-
-import requests
-from flask import (
-    Flask,
-    abort,
-    jsonify,
-    redirect,
-    render_template,
-    request,
-    send_from_directory,
-)
-from waitress import serve
-
-import media_search_functions
-
-
-def _env(name: str, default: str) -> str:
-    return os.getenv(name, default)
-
-
-def _env_path(name: str, default: str) -> Path:
-    value = os.getenv(name, default)
-    return Path(value).expanduser().resolve()
-
-
-API_KEY = os.getenv("CONJURER_API_KEY")
-MAIN_BOT_ADDRESS = _env("CONJURER_MAIN_BOT", "http://127.0.0.1:5000")
-MUSIC_TRACKER = _env("CONJURER_MUSIC_TRACKER_ENDPOINT", "/prepped_tracks")
-HOST_ADDRESS = _env("CONJURER_MUSICIAN_HOST", "0.0.0.0")
-PORT_ADDRESS = int(_env("CONJURER_MUSICIAN_PORT", "5000"))
-
-BASE_DIR = Path(
-    os.getenv("CONJURER_MUSICIAN_BASE", str(Path(__file__).resolve().parent))
-)
-LOGFILE = _env_path(
-    "CONJURER_MUSICIAN_LOG", str(BASE_DIR / "discord_mus_service.log")
-)
-LOGSTORE = _env_path("CONJURER_LOGSTORE", str(BASE_DIR / "logs"))
-MUSIC_FOLDER = _env_path(
-    "CONJURER_MUSIC_FOLDER", str(BASE_DIR / "music")
-)
-PRIORITY_FOLDER = _env_path(
-    "CONJURER_PRIORITY_FOLDER", str(MUSIC_FOLDER / "priority")
-)
-RADIOLOG_PATH = _env_path(
-    "CONJURER_RADIO_LOG", str(BASE_DIR / "radio_log.log")
-)
-PERSISTENCE_PATH = _env_path(
-    "CONJURER_PERSISTENCE_LOG", str(BASE_DIR / "persistence.log")
-)
-ALL_PLAYLIST_PATH = _env_path(
-    "CONJURER_ALL_PLAYLIST", str(BASE_DIR / "all_playlist.playlist")
-)
-HIT_PLAYLIST_PATH = _env_path(
-    "CONJURER_HIT_PLAYLIST", str(BASE_DIR / "hit.playlist")
-)
-REQUEST_PLAYLIST_PATH = _env_path(
-    "CONJURER_REQUEST_PLAYLIST", str(BASE_DIR / "request.playlist")
-)
-PRIORITY_PLAYLIST_PATH = _env_path(
-    "CONJURER_PRIORITY_PLAYLIST", str(BASE_DIR / "priority_queue.playlist")
-)
-STREAM_TEMPLATE = _env_path(
-    "CONJURER_STREAM_TEMPLATE", str(BASE_DIR / "stream.html")
-)
-
-ENCODING = _env("CONJURER_ENCODING", "utf-8")
-SEPARATOR_FILE_PATH = os.sep
-
-for playlist_path in (
-    ALL_PLAYLIST_PATH,
-    HIT_PLAYLIST_PATH,
-    REQUEST_PLAYLIST_PATH,
-    PRIORITY_PLAYLIST_PATH,
-):
-    playlist_path.parent.mkdir(parents=True, exist_ok=True)
-
-random.seed()
-music_file_list: List[str] = []
-priority_list: List[str] = []
-
-
-def _build_headers() -> Dict[str, str]:
-    headers: Dict[str, str] = {}
-    if API_KEY:
-        headers["X-Conjurer-Api-Key"] = API_KEY
-    return headers
-
-
-def _authorize_request() -> None:
-    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
-        abort(401)
-
-
-def _post_to_bot(payload: List[str]) -> None:
-    response = requests.post(
-        f"{MAIN_BOT_ADDRESS}{MUSIC_TRACKER}",
-        json=payload,
-        headers=_build_headers(),
-        timeout=60,
-    )
-    logger = logging.getLogger("conjurer_musician")
-    logger.info("SENT")
-    logger.info(response.status_code)
-    logger.info("SEND CONFIRMED")
-
-
-def rescan():
-    """
-    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")
-
-    music_file_list.clear()
-    priority_list.clear()
-
-    for mp3_item in MUSIC_FOLDER.glob("**/*.mp3"):
-        temp_music_file = mp3_item.as_posix()
-        if os.name == "nt":
-            temp_music_file = temp_music_file.replace("/", "\\")
-        music_file_list.append(temp_music_file)
-
-    for mp3_item in PRIORITY_FOLDER.glob("**/*.mp3"):
-        temp_music_file = mp3_item.as_posix()
-        if os.name == "nt":
-            temp_music_file = temp_music_file.replace("/", "\\")
-        priority_list.append(temp_music_file)
-
-    with ALL_PLAYLIST_PATH.open("w", encoding=ENCODING) as w_file:
-        try:
-            for item in music_file_list:
-                w_file.write(item)
-                w_file.write("\n")
-        except json.JSONDecodeError:
-            pass
-    with HIT_PLAYLIST_PATH.open("w", encoding=ENCODING) as w_file:
-        try:
-            for item in priority_list:
-                w_file.write(item)
-                w_file.write("\n")
-        except json.JSONDecodeError:
-            pass
-
-
-def thread_rescan():
-    """
-    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")
-    with open(RADIOLOG_PATH, "r", encoding=ENCODING) as log_file:
-        log_file.seek(os.stat(RADIOLOG_PATH).st_size)
-        prev_size = os.stat(PERSISTENCE_PATH).st_size
-
-        while True:
-            current_size = os.stat(PERSISTENCE_PATH).st_size
-            if prev_size != current_size:
-                while prev_size != current_size:
-                    prev_size = current_size
-                    time.sleep(0.1)
-                    current_size = os.stat(PERSISTENCE_PATH).st_size
-                with open(PERSISTENCE_PATH, "r", encoding=ENCODING) as persistence:
-                    lines = persistence.readlines()
-                if len(lines) >= 3:
-                    _post_to_bot(["next", lines[2]])
-
-            position = log_file.tell()
-            line = log_file.readline()
-            if not line:
-                time.sleep(1)
-                log_file.seek(position)
-                continue
-
-            if not re.match(r".*Prepared.*", line):
-                time.sleep(0.1)
-                continue
-
-            result = None
-            if re.match(r".*jingles.*", line):
-                result = ["jingles", line]
-            elif re.match(r".*priority.*", line):
-                result = ["priority", line]
-            elif re.match(r".*hit.*", line):
-                result = ["hit", line]
-            elif re.match(r".*all_playlist.*", line):
-                result = ["all", line]
-            elif re.match(r".*request.*", line):
-                result = ["requests", line]
-
-            if result:
-                logger.info("Forwarding radio log entry: %s", result[0])
-                _post_to_bot(result)
-
-            time.sleep(0.1)
-
-
-app = Flask(__name__)
-# AutoIndex(app, browse_root="/")
-
-
-# TODO: Odpalić wyszukiwarki w wątkach i dopiero po wszystkim zsumować wyszukiwanie.
-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 PRIORITY_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
-                        s_file.write(search_weight[itr][1] + "\n")
-                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('/get_share_list', methods=['POST'])
-def get_share_list():
-    _authorize_request()
-    data = request.get_json()
-    entries = data.get('entries')
-    keywords = data.get('keywords')
-    # Validate entries
-    if not isinstance(entries, int) or not (1 <= entries <= 10):
-        return jsonify({'error': '"entries" must be an integer between 1 and 10.'}), 400
-    # Validate keywords list
-    if not isinstance(keywords, list) or not all(isinstance(k, str) for k in keywords):
-        return jsonify({'error': '"keywords" must be a list of strings.'}), 400
-    # Call external search
-    files = media_search_functions.find_matches(entries, keywords)
-    # Return each file path as a JSON list
-    return jsonify({'files': files}), 200
-
-@app.route('/get_share_links', methods=['POST'])
-def get_share_links():
-    _authorize_request()
-    data = request.get_json()
-    file_paths = data.get('file_paths')
-    # Validate file_paths list
-    if not isinstance(file_paths, list) or not all(isinstance(p, str) for p in file_paths):
-        return jsonify({'error': '"file_paths" must be a list of strings.'}), 400
-    # Call external publish
-    links = media_search_functions.publish(file_paths)
-    # Return list of published links
-    return jsonify({'links': links}), 200
-
-
-
-@app.route("/stream", methods=["GET"])
-def stream_music():
-    """
-    The function `stream_music` is a route handler for the "/stream" endpoint.
-    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(str(STREAM_TEMPLATE))
-
-
-@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():
-    _authorize_request()
-    """
-    The function `clear_pr_pls` clears the contents of the priority queue playlist file.
-
-    :return: A JSON response indicating the success of the operation.
-    """
-    app.logger.info("CLEARING PLAYLIST")
-    with PRIORITY_PLAYLIST_PATH.open("w", encoding=ENCODING) as cleared_pl:
-        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.
-    """
-    _authorize_request()
-    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.
-    """
-    _authorize_request()
-    record = json.loads(request.data)
-    app.logger.info(record)
-    app.logger.info(record["lista_slow"])
-    app.logger.info(record["UUID"])
-    app.logger.info(record["dlugosc_plejlisty"])
-    return_data = wyszukaj(
-        record["lista_slow"], record["dlugosc_plejlisty"], app.logger, 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():
-    _authorize_request()
-    record = json.loads(request.data)
-    app.logger.info(record)
-    app.logger.info(record["lista_slow"])
-    app.logger.info(record["UUID"])
-    return_data = wyszukaj(record["lista_slow"], 0, app.logger, False)
-
-    with REQUEST_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
-        for item in return_data:
-            s_file.write(item[1] + "\n")
-    return_data = (
-        jsonify(
-            isError=False, message="Success", statusCode=200, data={"status": "OK"}
-        ),
-        200,
-    )
-    return return_data
-
-
-@app.route("/create_priority_playlist", methods=["POST"])
-def create_priority_playlist():
-    """
-    The function `create_priority_playlist` receives a POST request with a JSON payload, logs the received
-    item, adds it to a music file list, and returns a success message along with the updated record.
-
-    :return: A tuple containing a JSON response and a status code.
-        The JSON response includes keys `isError`,
-        `message`, `statusCode`, and `data`, with values
-        indicating the success of the operation and the
-        data that was received and added to the `music_file_list`.
-        The status code returned is 200,indicating a successful response.
-    """
-    _authorize_request()
-    record = json.loads(request.data)
-    app.logger.info(record)
-    app.logger.info(record["lista_slow"])
-    app.logger.info(record["UUID"])
-    app.logger.info(record["dlugosc_plejlisty"])
-    return_data = wyszukaj(
-        record["lista_slow"], record["dlugosc_plejlisty"], app.logger, False
-    )
-    random.shuffle(return_data)
-    with REQUEST_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
-        for item in return_data:
-            s_file.write(item[1] + "\n")
-    return_data = (
-        jsonify(
-            isError=False, message="Success", statusCode=200, data={"status": "OK"}
-        ),
-        200,
-    )
-    return return_data
-
-
-@app.route("/add_to_priority", methods=["POST"])
-def add_to_priority():
-    """
-    The function `add_to_priority` receives a POST request with a JSON payload, logs the received
-    item, adds it to a music file list, and returns a success message along with the updated record.
-
-    :return: A tuple containing a JSON response and a status code.
-        The JSON response includes keys `isError`,
-        `message`, `statusCode`, and `data`, with values
-        indicating the success of the operation and the
-        data that was received and added to the `music_file_list`.
-        The status code returned is 200,indicating a successful response.
-    """
-    _authorize_request()
-    record = json.loads(request.data)
-    app.logger.info(record)
-    app.logger.info(record["lista_slow"])
-    app.logger.info(record["UUID"])
-    app.logger.info(record["dlugosc_plejlisty"])
-    return_data = wyszukaj(
-        record["lista_slow"], record["dlugosc_plejlisty"], app.logger, False
-    )
-    with PRIORITY_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
-        for item in return_data:
-            s_file.write(item[1] + "\n")
-    return_data = (
-        jsonify(
-            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, daemon=True))
-    threads.append(threading.Thread(target=thread_rescan, daemon=True))
-
-    for worker in threads:
-        worker.start()
-
-    time.sleep(60)
-    track_thread = threading.Thread(target=scan_tracks, daemon=True)
-    track_thread.start()
-
-    try:
-        for worker in threads:
-            worker.join()
-        track_thread.join()
-    except KeyboardInterrupt:
-        logger.info("Shutdown requested - exiting musician service")

conjurer_musician/conjurer_musician.service

@@ -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

conjurer_musician/media_search_functions.py

@@ -1,52 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import json
-import os
-import sys
-import uuid
-from pathlib import Path
-
-# CONFIGURATION
-JSON_DB        = '/var/log/share_scan.json'
-SHARE_DIR      = Path('/var/www/html/share')
-BASE_URL       = 'https://czernobog.pl/share'
-
-# Ensure share directory exists
-SHARE_DIR.mkdir(parents=True, exist_ok=True)
-
-def load_db():
-    with open(JSON_DB) as f:
-        return json.load(f)['entries']
-
-ENTRIES = load_db()
-
-def relevancy(path, keywords):
-    score = 0
-    low = path.lower()
-    for kw in keywords:
-        if kw.lower() in low:
-            score += low.count(kw.lower())
-    return score
-
-def find_matches(count, keywords):
-    scored = []
-    for e in ENTRIES:
-        score = relevancy(e['path'], keywords)
-        if score > 0:
-            scored.append((score, e['path']))
-    scored.sort(reverse=True, key=lambda x: x[0])
-    result = [p for _, p in scored]
-    return result[:count]
-
-def publish(paths):
-    urls = []
-    for path in paths:
-        token = uuid.uuid4().hex
-        link = SHARE_DIR / token
-        try:
-            os.symlink(path, link)
-        except FileExistsError:
-            pass
-        urls.append(f"{BASE_URL}/{token}")
-    return urls
-

conjurer_musician/music_utils.py

@@ -1,98 +0,0 @@
-# This Python file uses the following encoding: utf-8
-"""This module contains utility scripts used by musi radiostation Conjurer"""
-import time
-import re
-import os
-import argparse
-
-from mutagen.easyid3 import EasyID3
-from mutagen.mp3 import MP3
-
-
-def update_metadata(folder_path):
-    for root, _, files in os.walk(folder_path):
-        for file in files:
-            if file.endswith(".mp3"):
-                file_path = os.path.join(root, file)
-
-                # Sample logic for guessing metadata from filename
-                # Assuming the filename format is "Artist - Title.mp3"
-                try:
-                    artist, title = file.rsplit(" - ", 1)
-                    title = title.replace(".mp3", "")
-                except ValueError:
-                    # If file name doesn't fit the expected pattern, skip
-                    print(f"Skipping file due to unexpected format: {file}")
-                    continue
-
-                try:
-                    # Load the mp3 file
-                    audio = MP3(file_path, ID3=EasyID3)
-
-                    # Update metadata
-                    audio["artist"] = artist.strip()
-                    audio["title"] = title.strip()
-
-                    # Save changes
-                    audio.save()
-                    print(f"Updated metadata for: {file}")
-                except Exception as e:
-                    print(f"Failed to update metadata for {file}: {e}")
-
-
-NAME = "/home/pi/Conjurer/persistence.log"
-
-
-def print_top():
-    """
-    Prints the top 65 lines from a file specified by the NAME variable.
-    """
-    while True:
-        line = ""
-        buffer = ""
-        with open(NAME, "r", encoding="utf-8") as f:
-            for _ in range(45):
-                line = f.readline()
-                if re.match(".*mp3", line):
-                    buffer += line
-            print("=====================================")
-            print(buffer)
-            print("=====================================")
-        time.sleep(180)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Perform operations on a directory of .mp3 files."
-    )
-
-    # Positional argument for choosing the function to execute
-    parser.add_argument(
-        "operation",
-        type=str,
-        choices=["update_metadata", "print_top"],
-        help="Operation to perform: update_metadata or print_top.",
-        default="print_top",
-    )
-
-    # Positional argument for folder path
-    parser.add_argument("folder", type=str, help="Path to the folder to operate on.")
-
-    args = parser.parse_args()
-    if args.operation == "update_metadata":
-        if args.folder:
-            folder_to_scan = args.folder
-        else:
-            print("Please provide a folder path to scan.")
-            raise ValueError("No folder path provided.")
-
-    if args.operation == "update_metadata" and os.path.isdir(folder_to_scan):
-        update_metadata(folder_to_scan)
-    elif args.operation == "print_top":
-        print_top()
-    else:
-        print(f"The specified path is not a directory: {folder_to_scan}")
-
-
-if __name__ == "__main__":
-    main()

conjurer_musician/pl.config

@@ -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

conjurer_musician/radio_conjurer.etc.logrotate

@@ -1,9 +0,0 @@
-/home/pi/Conjurer/radio_log.log {
-    daily
-    rotate 7
-    compress
-    delaycompress
-    missingok
-    notifempty
-    copytruncate
-}

conjurer_musician/radio_conjurer.liq

@@ -1,191 +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
-
-# Configure output formats and destinations
-def now_playing(m)
-  # raw lookup ("" if missing)
-  raw_title  = m["title"]
-  raw_artist = m["artist"]
-
-  # default if empty
-  title  = if raw_title  == "" then "Unknown" else raw_title  end
-  artist = if raw_artist == "" then "Unknown" else raw_artist end
-  log.critical("Now playing #{artist} - #{title}")
-  # write it out
-  system("echo '#{artist} - #{title}' > /tmp/now_playing.txt")
-  m
-end
-
-
-# Randomly select a playlist with weights
-s4 = random(id="randomizer", weights=[2, 3, 5], [s1, s2, s3])
-
-# Load jingles playlist
-jingles = (playlist(reload_mode="watch", "/home/pi/Conjurer/jingles.playlist"))
-
-# Create the main stream with random playlist and jingles
-s = rotate(id="randomizer", weights=[10, 1], [s4, jingles])
-
-s = crossfade(fade_out=2., fade_in=2., duration=4., fallback(id="switcher", track_sensitive=true, [requests_queue, s]))
-s = metadata.map(now_playing, s)
-
-# Set up an interactive harbor for controlling the stream
-interactive.harbor(port = 9999)
-# Set up interactive controls for bass boost
-f = interactive.float("f", description="Frequency", min=0., max=1000., unit="Hz", 200.)
-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., 1.1)
-s = compress.multiband.interactive(bands=7, s)
-
-mic_gain = interactive.float("mic_volume", min=0., max=120., 0.5)
-
-# 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(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=true,
-    [(live_enabled, mic),
-    ({true}, s)])
-
-# Configure logging settings
-log_to_stdout = true
-log_to_file = true
-logpath = "/home/pi/Conjurer/radio_log.log"
-loglevel = 3
-set("log.stdout", log_to_stdout)
-set("log.level", loglevel)
-
-# Enable logging to file
-set("log.file", log_to_file)
-set("log.file.path", logpath)
-# Set up emergency fallback track
-emergency = single("/home/pi/MediaFolder/mp3/Youtube/Dr. Peacock - Trip to Ireland [GvrvQTUbUcA].mp3")
-radio =  fallback(id="switcher2", track_sensitive=false, [s, emergency])
-
-# Set up an interactive control for skipping tracks
-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="radio", port=8000, password=credentials.password, icy_metadata="true", mount="mp3-stream", radio)
-output.pulseaudio(radio)
-#output.file.hls("/tmp/hls", [("mp3-low", %mp3(bitrate=96)), ("mp3-hi", %mp3(bitrate=160))], radio)
-# Uncomment the following lines to enable additional output formats
-# output.icecast(%opus, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="opus-stream", radio)
-# output.icecast(%ogg, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="ogg-stream", radio)
-# output.icecast(%aac, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="aac-stream", radio)
-# output.icecast(%flac, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="flac-stream", radio)
-# output.icecast(%vorbis, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="vorbis-stream", radio)
-# output.icecast(%speex, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="speex-stream", radio)
-# output.icecast(%wav, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="wav-stream", radio)
-# output.icecast(%pcm, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="pcm-stream", radio)
-# output.icecast(%raw, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="raw-stream", radio)
-# output.icecast(%s16l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s16l-stream", radio)
-# output.icecast(%s16b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s16b-stream", radio)
-# output.icecast(%s24l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s24l-stream", radio)
-# output.icecast(%s24b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s24b-stream", radio)
-# output.icecast(%s32l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s32l-stream", radio)
-# output.icecast(%s32b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s32b-stream", radio)
-# output.icecast(%s64l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s64l-stream", radio)
-# output.icecast(%s64b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s64b-stream", radio)
-# output.icecast(%s128l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s128l-stream", radio)
-# output.icecast(%s128b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s128b-stream", radio)
-# output.icecast(%s256l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s256l-stream", radio)
-# output.icecast(%s256b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s256b-stream", radio)
-# output.icecast(%s512l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s512l-stream", radio)
-# output.icecast(%s512b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s512b-stream", radio)
-# output.icecast(%s1024l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s1024l-stream", radio)
-# output.icecast(%s1024b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s1024b-stream", radio)
-# output.icecast(%s2048l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s2048l-stream", radio)
-# output.icecast(%s2048b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s2048b-stream", radio)
-# output.icecast(%s4096l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s4096l-stream", radio)
-# output.icecast(%s4096b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s4096b-stream", radio)
-# output.icecast(%s8192l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s8192l-stream", radio)
-# output.icecast(%s8192b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s8192b-stream", radio)

conjurer_musician/radio_service.service

@@ -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

conjurer_musician/requirements_musician.txt

@@ -1,4 +0,0 @@
-flask
-waitress
-sshtunnel
-requests

conjurer_musician/revoke_shares.py

@@ -1,99 +0,0 @@
-#!/usr/bin/env python3
-import os
-import re
-import time
-import json
-import argparse
-import sys
-from pathlib import Path
-
-# — CONFIGURATION — adjust as needed —
-APACHE_LOG     = '/var/log/apache2/share_access.log'  # <- point to your share-specific log!
-SHARE_DIR      = Path('/var/www/html/share')
-METADATA_FILE  = SHARE_DIR / '.downloads.json'
-STATE_FILE     = SHARE_DIR / '.logpos'
-# Regex to match lines like: "GET /share/abcdef1234... HTTP/1.1"
-TOKEN_REGEX    = re.compile(r'"\s*GET\s+/share/([0-9a-f]{32})\s+HTTP/')
-
-def debug(msg, args):
-    if args.debug:
-        print(f"[DEBUG] {msg}", file=sys.stderr)
-
-def load_metadata(args):
-    if METADATA_FILE.exists():
-        data = json.loads(METADATA_FILE.read_text())
-        debug(f"Loaded metadata: {data}", args)
-        return data
-    return {}
-
-def save_metadata(md, args):
-    METADATA_FILE.write_text(json.dumps(md))
-    debug(f"Saved metadata: {md}", args)
-
-def load_state(args):
-    if STATE_FILE.exists():
-        pos = int(STATE_FILE.read_text())
-        debug(f"Loaded last log position: {pos}", args)
-        return pos
-    return 0
-
-def save_state(pos, args):
-    STATE_FILE.write_text(str(pos))
-    debug(f"Saved new log position: {pos}", args)
-
-def scan_log(since_pos, args):
-    try:
-        with open(APACHE_LOG, 'r') as f:
-            f.seek(since_pos)
-            lines = f.readlines()
-            newpos = f.tell()
-        debug(f"Read {len(lines)} new lines", args)
-        return lines, newpos
-    except Exception as e:
-        print(f"Error reading log: {e}", file=sys.stderr)
-        return [], since_pos
-
-def record_downloads(lines, metadata, args):
-    now = time.time()
-    for line in lines:
-        m = TOKEN_REGEX.search(line)
-        if m:
-            tok = m.group(1)
-            if tok not in metadata:
-                metadata[tok] = now
-                debug(f"Recorded download of token {tok} at {now}", args)
-    return metadata
-
-def revoke_old(metadata, args):
-    now = time.time()
-    to_remove = [tok for tok, ts in metadata.items() if now - ts >= 3600]
-    for tok in to_remove:
-        link = SHARE_DIR / tok
-        try:
-            link.unlink()
-            debug(f"Unlinked token {tok}", args)
-        except FileNotFoundError:
-            debug(f"Link {link} not found when revoking", args)
-        metadata.pop(tok, None)
-    return bool(to_remove)
-
-def main():
-    p = argparse.ArgumentParser(description="Revoke share links 2min after download")
-    p.add_argument('--debug', action='store_true', help='print debug info to stderr')
-    args = p.parse_args()
-
-    SHARE_DIR.mkdir(parents=True, exist_ok=True)
-    metadata = load_metadata(args)
-    state    = load_state(args)
-
-    lines, newpos = scan_log(state, args)
-    metadata      = record_downloads(lines, metadata, args)
-    save_metadata(metadata, args)               # always persist new downloads
-
-    if revoke_old(metadata, args):
-        save_metadata(metadata, args)           # persist removals
-
-    save_state(newpos, args)
-
-if __name__ == '__main__':
-    main()

conjurer_musician/scan_shares.py

@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-import os
-import json
-import time
-from pathlib import Path
-
-# Configuration
-SCAN_PATH = '/mnt/shares'
-OUTPUT_FILE = '/var/log/share_scan.json'
-
-def scan_directory(root):
-    """Recursively walk `root` and collect metadata."""
-    entries = []
-    for dirpath, dirs, files in os.walk(root):
-        for name in dirs + files:
-            full = os.path.join(dirpath, name)
-            try:
-                stat = os.stat(full)
-                entries.append({
-                    'path': full,
-                    'is_dir': os.path.isdir(full),
-                    'size_bytes': stat.st_size,
-                    'mtime': time.strftime('%Y-%m-%dT%H:%M:%S%z',
-                                           time.localtime(stat.st_mtime)),
-                })
-            except Exception as e:
-                # skip items we can't stat
-                continue
-    return entries
-
-def main():
-    data = {
-        'scanned_at': time.strftime('%Y-%m-%dT%H:%M:%S%z', time.localtime()),
-        'root': SCAN_PATH,
-        'entries': scan_directory(SCAN_PATH),
-    }
-    # Write atomically
-    temp = OUTPUT_FILE + '.tmp'
-    with open(temp, 'w') as f:
-        json.dump(data, f, indent=2)
-    os.replace(temp, OUTPUT_FILE)
-
-if __name__ == '__main__':
-    main()

conjurer_musician/scan_shares.service

@@ -1,6 +0,0 @@
-[Unit]
-Description=One‑shot scan of /mnt/shares → JSON
-
-[Service]
-Type=oneshot
-ExecStart=/usr/local/bin/scan_shares.py

conjurer_musician/scan_shares.timer

@@ -1,11 +0,0 @@
-[Unit]
-Description=Hourly timer for share‑scanner
-
-[Timer]
-# delay 2min after boot, then every hour
-OnBootSec=20min
-OnUnitActiveSec=24h
-Unit=scan_shares.service
-
-[Install]
-WantedBy=timers.target

conjurer_musician/script.params

@@ -1,195 +0,0 @@
-{
-  "string": [],
-  "bool": [ [ "Skip track", false ], [ "Going Live!", false ] ],
-  "int": [],
-  "float": [
-    [
-    "mic_volume",
-    0.0
-  ],
-    [
-    "compress_gain6",
-    0.1
-  ],
-    [
-    "compress_ratio6",
-    7.9
-  ],
-    [
-    "compress_threshold6",
-    -15.8
-  ],
-    [
-    "compress_release6",
-    30.0
-  ],
-    [
-    "compress_attack6",
-    30.0
-  ],
-    [
-    "compress_frequency6",
-    18610.0
-  ],
-    [
-    "compress_gain5",
-    5.4
-  ],
-    [
-    "compress_ratio5",
-    4.8
-  ],
-    [
-    "compress_threshold5",
-    -13.6
-  ],
-    [
-    "compress_release5",
-    120.0
-  ],
-    [
-    "compress_attack5",
-    160.0
-  ],
-    [
-    "compress_frequency5",
-    13950.0
-  ],
-    [
-    "compress_gain4",
-    6.5
-  ],
-    [
-    "compress_ratio4",
-    4.0
-  ],
-    [
-    "compress_threshold4",
-    -12.2
-  ],
-    [
-    "compress_release4",
-    130.0
-  ],
-    [
-    "compress_attack4",
-    200.0
-  ],
-    [
-    "compress_frequency4",
-    3890.0
-  ],
-    [
-    "compress_gain3",
-    5.5
-  ],
-    [
-    "compress_ratio3",
-    3.5
-  ],
-    [
-    "compress_threshold3",
-    -11.7
-  ],
-    [
-    "compress_release3",
-    140.0
-  ],
-    [
-    "compress_attack3",
-    250.0
-  ],
-    [
-    "compress_frequency3",
-    2270.0
-  ],
-    [
-    "compress_gain2",
-    3.3
-  ],
-    [
-    "compress_ratio2",
-    3.9
-  ],
-    [
-    "compress_threshold2",
-    -11.5
-  ],
-    [
-    "compress_release2",
-    120.0
-  ],
-    [
-    "compress_attack2",
-    250.0
-  ],
-    [
-    "compress_frequency2",
-    1920.0
-  ],
-    [
-    "compress_gain1",
-    5.6
-  ],
-    [
-    "compress_ratio1",
-    3.4
-  ],
-    [
-    "compress_threshold1",
-    -12.2
-  ],
-    [
-    "compress_release1",
-    120.0
-  ],
-    [
-    "compress_attack1",
-    220.0
-  ],
-    [
-    "compress_frequency1",
-    650.0
-  ],
-    [
-    "compress_gain0",
-    7.5
-  ],
-    [
-    "compress_ratio0",
-    3.2
-  ],
-    [
-    "compress_threshold0",
-    -13.1
-  ],
-    [
-    "compress_release0",
-    110.0
-  ],
-    [
-    "compress_attack0",
-    140.0
-  ],
-    [
-    "compress_frequency0",
-    110.0
-  ],
-    [
-    "compress_wet",
-    1.0
-  ],
-    [
-    "main_volume",
-    1.8
-  ],
-    [
-    "g",
-    1.0
-  ],
-    [
-    "f",
-    106.4
-  ]
-  ]
-}

conjurer_musician/search_and_share.py

@@ -1,93 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import json
-import os
-import sys
-import uuid
-from pathlib import Path
-
-# CONFIGURATION
-JSON_DB        = '/var/log/share_scan.json'
-SHARE_DIR      = Path('/var/www/html/share')
-BASE_URL       = 'https://czernobog.pl/share'
-
-# Ensure share directory exists
-SHARE_DIR.mkdir(parents=True, exist_ok=True)
-
-def load_db():
-    with open(JSON_DB) as f:
-        return json.load(f)['entries']
-
-def relevancy(path, keywords):
-    score = 0
-    low = path.lower()
-    for kw in keywords:
-        if kw.lower() in low:
-            score += low.count(kw.lower())
-    return score
-
-def find_matches(entries, keywords):
-    scored = []
-    for e in entries:
-        score = relevancy(e['path'], keywords)
-        if score > 0:
-            scored.append((score, e['path']))
-    scored.sort(reverse=True, key=lambda x: x[0])
-    return [p for _, p in scored]
-
-def interactive_select(candidates):
-    print("Search results:")
-    for idx, p in enumerate(candidates, 1):
-        print(f" {idx:3d}. {p}")
-    sel = input("\nSelect files (e.g. 1,3-5): ").strip()
-    nums = set()
-    for part in sel.split(','):
-        if '-' in part:
-            a,b = part.split('-',1)
-            nums.update(range(int(a), int(b)+1))
-        else:
-            nums.add(int(part))
-    return [candidates[i-1] for i in sorted(nums) if 1 <= i <= len(candidates)]
-
-def publish(paths):
-    urls = []
-    for path in paths:
-        token = uuid.uuid4().hex
-        link = SHARE_DIR / token
-        try:
-            os.symlink(path, link)
-        except FileExistsError:
-            pass
-        urls.append(f"{BASE_URL}/{token}")
-    return urls
-
-def main():
-    parser = argparse.ArgumentParser(description="Search and share files from JSON DB")
-    parser.add_argument('keywords', nargs='*',
-                        help='Search keywords (interactive if omitted)')
-    parser.add_argument('-n','--count', type=int, default=10,
-                        help='How many top results to share')
-    args = parser.parse_args()
-
-    if not args.keywords:
-        # Interactive: ask for query
-        q = input("Enter search keywords (space-separated): ").strip().split()
-        args.keywords = q
-
-    entries   = load_db()
-    matches   = find_matches(entries, args.keywords)
-    top_n     = matches[:args.count]
-
-    if sys.stdin.isatty():
-        # interactive selection
-        sel = interactive_select(top_n)
-    else:
-        # non-interactive: share all top_n
-        sel = top_n
-
-    urls = publish(sel)
-    for u in urls:
-        print(u)
-
-if __name__=='__main__':
-    main()

conjurer_musician/stream.html

@@ -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>

conjurer_musician/test_mic.liq

@@ -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)

constants.py

@@ -1,322 +0,0 @@
-"""Centralised configuration and runtime constants for Conjurer.
-
-Historically this module performed heavy filesystem and credential reads at
-import time which made the bot brittle on hosts that did not mirror the
-original paths.  This version keeps the original platform defaults (so the
-behaviour on the Raspberry Pi / WSL / Windows deployments is unchanged when no
-environment variables are set) but adds three robustness improvements ported
-from the dockerised experiment:
-
-* every path/endpoint can be overridden via an environment variable,
-* JSON state files are loaded defensively (a missing or corrupt file no longer
-  crashes the whole bot at import time),
-* optional dependencies (openai, spotipy, netrc) and credentials are guarded so
-  the bot can still start when a secondary integration is offline, and
-* a shared ``CONJURER_API_KEY`` plus ``service_headers()`` helper enables
-  authenticated internal HTTP calls.
-
-All path constants intentionally remain plain ``str`` (with their original
-trailing separators) to stay byte-for-byte compatible with the existing string
-concatenation in the command modules.
-"""
-
-import json
-import logging
-import os
-from datetime import datetime
-from platform import uname
-from sys import platform
-from typing import List, Optional, TypedDict
-
-try:
-    import netrc
-except ImportError:  # pragma: no cover - standard on CPython
-    netrc = None
-
-try:
-    import openai
-except ImportError:  # pragma: no cover - optional at runtime
-    openai = None
-
-try:
-    import spotipy
-    from spotipy.oauth2 import SpotifyClientCredentials
-except ImportError:  # pragma: no cover - optional component
-    spotipy = None
-    SpotifyClientCredentials = None
-
-logger = logging.getLogger("discord")
-
-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 = "utf-8"
-GRAPHICS_PATH = ""
-MUZYKA_MOJEGO_LUDU_HISTORIA = 1500
-MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE = 15
-MUZYKA_MOJEGO_LUDU_PLAJLISTA = 30
-
-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"
-SEND_QUERY = "/query"
-TIME_BETWEEN_CALLS = 100000
-LAST_SPONTANEOUS_CALL = datetime.now()
-
-# *=========================================== Platform Specific Defaults
-# These blocks only establish *default* values.  Every constant is overridable
-# through the matching environment variable further below.
-
-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/MediaShare/mp3/"
-        SETTINGS_FILE = "/home/pi/Conjurer/settings.json"
-        NETRC_FILE = "/home/pi/.netrc"
-        LOGSTORE = "/home/pi/MediaShara/logs/"
-        ACCIDENT_LOG = "/home/pi/Conjurer/accident_log.json"
-        ENCODING = "utf-8"
-        GRAPHICS_PATH = "/home/pi/MediaShare/Conjurer_graphics/"
-        DIR_PATH_SADOX = "/home/pi/MediaShare/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 = "\\"
-
-else:
-    # Fallback for development hosts (macOS, BSD, …) that match none of the
-    # production platforms.  Everything is rooted next to this file so the
-    # module can at least be imported and unit-tested off-deployment.
-    _BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-    SEPARATOR_FILE_PATH = os.sep
-    LOGFILE = os.path.join(_BASE_DIR, "discord.log")
-    MEMORY_FIVE_SIARA = os.path.join(_BASE_DIR, "pamiec.json")
-    SYSTEM_GPT_SETTINGS = os.path.join(_BASE_DIR, "system_gpt_settings.json")
-    MEMORY_FIVE_MUZYKA = os.path.join(_BASE_DIR, "pamiec_muzyki.json")
-    MUSIC_FOLDER = os.path.join(_BASE_DIR, "music") + os.sep
-    SETTINGS_FILE = os.path.join(_BASE_DIR, "settings.json")
-    NETRC_FILE = os.path.join(os.path.expanduser("~"), ".netrc")
-    LOGSTORE = os.path.join(_BASE_DIR, "logs") + os.sep
-    ACCIDENT_LOG = os.path.join(_BASE_DIR, "accident_log.json")
-    GRAPHICS_PATH = os.path.join(_BASE_DIR, "Conjurer_graphics") + os.sep
-    DIR_PATH_SADOX = os.path.join(_BASE_DIR, "Fansadox") + os.sep
-
-
-# *=========================================== Environment overrides
-# Values stay as plain strings so existing ``PATH + filename`` concatenation in
-# the command modules keeps working unchanged.
-
-LOGFILE = os.getenv("CONJURER_LOG_FILE", LOGFILE)
-NETRC_FILE = os.getenv("CONJURER_NETRC_FILE", NETRC_FILE)
-SETTINGS_FILE = os.getenv("CONJURER_SETTINGS_FILE", SETTINGS_FILE)
-MEMORY_FIVE_SIARA = os.getenv("CONJURER_MEMORY_FILE", MEMORY_FIVE_SIARA)
-MEMORY_FIVE_MUZYKA = os.getenv("CONJURER_MUSIC_MEMORY_FILE", MEMORY_FIVE_MUZYKA)
-SYSTEM_GPT_SETTINGS = os.getenv("CONJURER_SYSTEM_GPT_SETTINGS", SYSTEM_GPT_SETTINGS)
-GRAPHICS_PATH = os.getenv("CONJURER_GRAPHICS_PATH", GRAPHICS_PATH)
-MUSIC_FOLDER = os.getenv("CONJURER_MUSIC_FOLDER", MUSIC_FOLDER)
-LOGSTORE = os.getenv("CONJURER_LOGSTORE", LOGSTORE)
-ACCIDENT_LOG = os.getenv("CONJURER_ACCIDENT_LOG", ACCIDENT_LOG)
-DIR_PATH_SADOX = os.getenv("CONJURER_SADOX_DIR", DIR_PATH_SADOX)
-ENCODING = os.getenv("CONJURER_ENCODING", ENCODING)
-SEPARATOR_FILE_PATH = os.getenv("CONJURER_PATH_SEPARATOR", SEPARATOR_FILE_PATH)
-
-FILE_SERVICE_ADDRESS = os.getenv("CONJURER_FILE_SERVICE", "http://192.168.1.15:5000")
-RADIO_HARBOR_ADDRESS = os.getenv("CONJURER_RADIO_HARBOR", "http://192.168.1.15:54321")
-SKIP_TRACK = os.getenv("CONJURER_SKIP_ENDPOINT", "/skip")
-LIBRARIAN_SERVICE_ADDRESS = os.getenv(
-    "CONJURER_LIBRARIAN_SERVICE", "http://192.168.1.192:5001"
-)
-HOST_ADDRESS = os.getenv("CONJURER_DISCORD_HOST", "192.168.1.191")
-PORT_ADDRESS = int(os.getenv("CONJURER_DISCORD_PORT", "5000"))
-
-# Shared secret for authenticating internal service-to-service HTTP calls.
-API_SHARED_KEY = os.getenv("CONJURER_API_KEY", "")
-
-
-# *=========================================== Defensive state loading
-def _load_json(path: str, fallback):
-    """Load JSON from *path*, falling back gracefully on missing/corrupt files."""
-    try:
-        with open(path, "r", encoding=ENCODING) as handle:
-            return json.load(handle)
-    except FileNotFoundError:
-        logger.warning("Missing JSON file at %s - using fallback", path)
-        return fallback
-    except json.JSONDecodeError:
-        logger.warning("Corrupt JSON at %s - resetting to fallback", path)
-        return fallback
-
-
-DATA = _load_json(SETTINGS_FILE, {})
-WORD_REACTIONS = DATA.get("word_reactions", {})
-CYCLIC_WORDS = DATA.get("cyclic_words", {})
-for key in WORD_REACTIONS:
-    if isinstance(WORD_REACTIONS[key], list) and len(WORD_REACTIONS[key]) >= 3:
-        WORD_REACTIONS[key][2] = datetime.now()
-
-MESSAGE_TABLE = _load_json(MEMORY_FIVE_SIARA, [])
-GPT_SETTINGS = _load_json(SYSTEM_GPT_SETTINGS, {})
-MESSAGE_TABLE_MUZYKA = _load_json(MEMORY_FIVE_MUZYKA, [])
-
-SPECJALNE_ZIEMNIACZKI = GPT_SETTINGS[1] if isinstance(GPT_SETTINGS, list) else {}
-ASSISTANTS = {}
-
-
-# *=========================================== Credentials
-def _load_netrc_credentials(host: str):
-    """Return the netrc authenticators tuple for *host* or ``None``."""
-    if netrc is None:
-        return None
-    try:
-        parsed = netrc.netrc(NETRC_FILE)
-    except FileNotFoundError:
-        logger.warning("netrc file %s not found", NETRC_FILE)
-        return None
-    except netrc.NetrcParseError:
-        logger.warning("netrc file %s is invalid", NETRC_FILE)
-        return None
-    return parsed.authenticators(host)
-
-
-def _resolve_token(host: str, env_var: str) -> Optional[str]:
-    """Prefer an environment variable, then fall back to netrc."""
-    env_value = os.getenv(env_var)
-    if env_value:
-        return env_value
-    creds = _load_netrc_credentials(host)
-    if creds:
-        return creds[2]
-    logger.warning("Token for %s not configured", host)
-    return None
-
-
-OPENAI_API_KEY = _resolve_token("openai", "OPENAI_API_KEY")
-if openai and OPENAI_API_KEY:
-    openai.api_key = OPENAI_API_KEY
-    OPENAICLIENT = openai.AsyncOpenAI(api_key=OPENAI_API_KEY)
-else:
-    OPENAICLIENT = None
-
-TOKEN = _resolve_token("discord", "DISCORD_TOKEN")
-
-if spotipy:
-    _spotify_creds = _load_netrc_credentials("spotipy")
-    if _spotify_creds and SpotifyClientCredentials:
-        SPOTIFY_CTRL = spotipy.Spotify(
-            client_credentials_manager=SpotifyClientCredentials(
-                client_id=_spotify_creds[0],
-                client_secret=_spotify_creds[2],
-            )
-        )
-    else:
-        SPOTIFY_CTRL = None
-else:
-    SPOTIFY_CTRL = None
-
-_youtube_creds = _load_netrc_credentials("youtube")
-if _youtube_creds:
-    YOUTUBE_AUTH = [_youtube_creds[0], _youtube_creds[2]]
-else:
-    YOUTUBE_AUTH = [
-        os.getenv("YOUTUBE_USERNAME", ""),
-        os.getenv("YOUTUBE_PASSWORD", ""),
-    ]
-
-
-def service_headers():
-    """Shared header dict for internal service-to-service HTTP calls.
-
-    Returns an empty dict when no key is configured, keeping calls backward
-    compatible with deployments that do not (yet) enforce authentication.
-    """
-    if API_SHARED_KEY:
-        return {"X-Conjurer-Api-Key": API_SHARED_KEY}
-    return {}
-
-
-LATEX_TEX_ENGINE = "tectonic"
-LATEX_MAX_COMPILE_SECONDS = 45
-LATEX_MAX_ATTACH_MB = 8
-LATEX_MAX_ZIP_MB =  25
-
-OPENAI_MODEL = "gpt-4o-mini"
-
-ALLOWED_ROLES = ["Nocna Zmiana", "Jarl", "Thane", "Bartender"]
-GUILD_ID = 664789470779932693
-LATEST_MODEL = "gpt-4o"          # najnowszy/do rozmów (możesz zmienić w jednym miejscu)
-CHEAP_MODEL  = "gpt-4o-mini"     # najtańszy (fallback do 3.5 niżej)
-
-
-# *=========================================== Conan Exiles bridge
-# Every value is optional; the conanjurer cog stays dormant unless configured.
-# Channel/role ids default to 0 ("not defined"); RCON host/log path default to
-# "" ("disabled"). See conanjurer_commands.py / conanjurer_functions.py.
-CONAN_GM_ROLE_ID = int(os.getenv("CONAN_GM_ROLE_ID", "0"))
-CONAN_CHAT_CHANNEL_ID = int(os.getenv("CONAN_CHAT_CHANNEL_ID", "0"))
-CONAN_EVENTS_CHANNEL_ID = int(os.getenv("CONAN_EVENTS_CHANNEL_ID", "0"))
-# Player-join notifications: leave at 0 to keep the feature disabled.
-CONAN_JOIN_CHANNEL_ID = int(os.getenv("CONAN_JOIN_CHANNEL_ID", "0"))
-CONAN_PLAYER_POLL_SECONDS = int(os.getenv("CONAN_PLAYER_POLL_SECONDS", "60"))
-
-CONAN_RCON_HOST = os.getenv("CONAN_RCON_HOST", "")
-CONAN_RCON_PORT = int(os.getenv("CONAN_RCON_PORT", "25575"))
-CONAN_RCON_PASSWORD = os.getenv("CONAN_RCON_PASSWORD", "")
-
-CONAN_LOG_MODE = os.getenv("CONAN_LOG_MODE", "local")  # "local" | "sftp"
-CONAN_LOG_PATH = os.getenv("CONAN_LOG_PATH", "")
-CONAN_SFTP_HOST = os.getenv("CONAN_SFTP_HOST", "")
-CONAN_SFTP_PORT = int(os.getenv("CONAN_SFTP_PORT", "22"))
-CONAN_SFTP_USER = os.getenv("CONAN_SFTP_USER", "")
-CONAN_SFTP_PASSWORD = os.getenv("CONAN_SFTP_PASSWORD", "")

deploy.sh

@@ -1,108 +1,9 @@
 #!/bin/bash
-
-total_commands=31
-current_command=0
-
-function print_progress {
-  current_command=$((current_command + 1))
-  percent=$((current_command * 100 / total_commands))
-  echo "Executing command $current_command/$total_commands ($percent%): $1"
-}
-
-cd /home/pi/conjurer || exit
-print_progress "cd /home/pi/conjurer"
-
 git pull
-print_progress "git pull"
-
-cp ./deploy.sh /home/pi/
-print_progress "cp ./deploy.sh /home/pi/"
-
-cd /home/pi || exit
-print_progress "cd /home/pi"
-
-cp ./conjurer/LICENSE ./Conjurer/LICENSE
-print_progress "cp ./conjurer/LICENSE ./Conjurer/LICENSE"
-
-cp ./conjurer/fuckery.jpg ./Conjurer/
-print_progress "cp ./conjurer/fuckery.jpg ./Conjurer/"
-
-cp ./conjurer/willowisp.png ./Conjurer/
-print_progress "cp ./conjurer/willowisp.png ./Conjurer/"
-
-cp ./conjurer/wod_beacon.jpg ./Conjurer/
-print_progress "cp ./conjurer/wod_beacon.jpg ./Conjurer/"
-
+cd ..
+cp ./conjurer/bot.py ./Conjurer/
 cp ./conjurer/settings.json ./Conjurer/
-print_progress "cp ./conjurer/settings.json ./Conjurer/"
-
-if [[ ./conjurer/system_gpt_settings.json -nt ./Conjurer/system_gpt_settings.json ]]; then
-  cp ./conjurer/system_gpt_settings.json ./Conjurer/system_gpt_settings.json
-  print_progress "cp ./conjurer/system_gpt_settings.json ./Conjurer/system_gpt_settings.json"
-else
-  print_progress "system_gpt_settings.json is up to date"
-fi
-
-cp ./conjurer/administration_commands.py ./Conjurer/
-print_progress "cp ./conjurer/administration_commands.py ./Conjurer/"
-
-cp ./conjurer/ai_commands.py ./Conjurer/
-print_progress "cp ./conjurer/ai_commands.py ./Conjurer/"
-
-cp ./conjurer/ai_functions.py ./Conjurer/
-print_progress "cp ./conjurer/ai_functions.py ./Conjurer/"
-
-cp ./conjurer/communication_subroutine.py ./Conjurer/
-print_progress "cp ./conjurer/communication_subroutine.py ./Conjurer/"
-
-cp ./conjurer/constants.py ./Conjurer/
-print_progress "cp ./conjurer/constants.py ./Conjurer/"
-
-cp ./conjurer/librarian_commands.py ./Conjurer/
-print_progress "cp ./conjurer/librarian_commands.py ./Conjurer/"
-
-cp ./conjurer/music_commands.py ./Conjurer/
-print_progress "cp ./conjurer/music_commands.py ./Conjurer/"
-
-cp ./conjurer/music_functions.py ./Conjurer/
-print_progress "cp ./conjurer/music_functions.py ./Conjurer/"
-
-cp ./conjurer/other_commands.py ./Conjurer/
-print_progress "cp ./conjurer/other_commands.py ./Conjurer/"
-
-cp ./conjurer/other_functions.py ./Conjurer/
-print_progress "cp ./conjurer/other_functions.py ./Conjurer/"
-
-cp ./conjurer/radio_commands.py ./Conjurer/
-print_progress "cp ./conjurer/radio_commands.py ./Conjurer/"
-
-cp ./conjurer/voice_recognition_commands.py ./Conjurer/
-print_progress "cp ./conjurer/voice_recognition_commands.py ./Conjurer/"
-
-cp ./conjurer/file_search_functions.py ./Conjurer/
-
-print_progress "cp ./conjurer/file_search_functions.py ./Conjurer/"
-
-cp ./conjurer/file_search_commands.py ./Conjurer
-print_progress "cp ./conjurer/file_search_functions.py ./Conjurer/"
-
-cp ./conjurer/latex_commands.py ./Conjurer/
-print_progress "cp ./conjurer/latex_commands.py ./Conjurer/"
-
-cp ./conjurer/latex_functions.py ./Conjurer/
-print_progress "cp ./conjurer/latex_functions.py ./Conjurer/"
-
-cp ./conjurer/librarian_functions.py ./Conjurer
-print_progress "cp ./conjurer/librarian_functions.py ./Conjurer/"
-
-cp ./conjurer/conanjurer_commands.py ./Conjurer/
-print_progress "cp ./conjurer/conanjurer_commands.py ./Conjurer/"
-
-cp ./conjurer/conanjurer_functions.py ./Conjurer/
-print_progress "cp ./conjurer/conanjurer_functions.py ./Conjurer/"
-
-cp ./conjurer/bot.py ./Conjurer/bot.py
-print_progress "cp ./conjurer/bot.py ./Conjurer/bot.py"
-
+cp ./conjurer/system_gpt_settings.json ./Conjurer/
+cp ./conjurer/install.sh ./Conjurer/
+cp ./conjurer/requirements.txt ./Conjurer/requirements.txt
 sudo systemctl restart conjurer.service
-print_progress "sudo systemctl restart conjurer.service"

deploy_music.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-cd ./conjurer || exit
-git pull
-cd ..
-cp ./conjurer/conjurer_musician/media_search_functions.py ./Conjurer
-cp ./conjurer/conjurer_musician/conjurer_musician.py ./Conjurer
-sudo systemctl restart conjurer_musician.service

deploy_radio.sh

@@ -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

dj_fonts_system_install.sh

@@ -1,141 +0,0 @@
-#!/usr/bin/env bash
-# System-wide install & verify (Debian/RPi):
-#  - EB Garamond (APT)
-#  - Cinzel Decorative Black (RAW TTF)
-#  - IM Fell English SC (gstatic/RAW)
-# No TeX build here. Very verbose + clear final report.
-
-set -Eeuo pipefail
-
-SUDO=sudo; [ "$(id -u)" -eq 0 ] && SUDO=
-log(){ echo -e "[+] $*"; }
-warn(){ echo -e "[WARN] $*" >&2; }
-die(){ echo -e "[FATAL] $*" >&2; exit 1; }
-
-need(){ command -v "$1" >/dev/null 2>&1 || die "Missing tool: $1"; }
-fetch(){
-  local url="$1" out="$2"
-  if command -v wget >/dev/null 2>&1; then
-    log "wget -> $url"
-    wget -O "$out" --https-only --no-verbose "$url"
-  else
-    log "curl -> $url"
-    curl -L --fail --show-error --output "$out" "$url"
-  fi
-}
-
-# ---- detection using fc-list families (robust, no PCRE) ----
-fc_families_lower() {
-  fc-list -f '%{family}\n' \
-  | tr ',' '\n' \
-  | sed 's/^[[:space:]]*//; s/[[:space:]]*$//' \
-  | tr '[:upper:]' '[:lower:]' \
-  | sort -u
-}
-has_family_re() {  # $1 = POSIX ERE anchored-at-start pattern (lowercase)
-  fc_families_lower | grep -Eiq "$1"
-}
-
-# ---- prereqs ----
-for t in fc-cache fc-list grep sed awk; do need "$t"; done
-command- v wget >/dev/null 2>&1 || command -v curl >/dev/null 2>&1 || die "Need wget or curl"
-
-SYSTEM_DIR="/usr/local/share/fonts/dj"
-DIR_CINZEL="$SYSTEM_DIR/cinzel-decorative"
-DIR_IMFELL="$SYSTEM_DIR/im-fell-english-sc"
-$SUDO mkdir -p "$DIR_CINZEL" "$DIR_IMFELL"
-
-echo "=== APT phase (EB Garamond) ==="
-if command -v apt-get >/dev/null 2>&1; then
-  $SUDO apt-get update -y || warn "apt update failed (continuing)"
-  if $SUDO apt-get install -y --no-install-recommends fonts-ebgaramond; then
-    log "installed: fonts-ebgaramond"
-  else
-    warn "apt install failed: fonts-ebgaramond"
-  fi
-else
-  warn "apt-get not found — skipping"
-fi
-
-echo
-log "Families BEFORE web fallback (sample grep):"
-fc-list | grep -Ei "Garamond|Cinzel|Fell" || echo "  (none)"
-
-echo
-echo "=== Web fallback (system-wide to $SYSTEM_DIR) ==="
-
-# --- Cinzel Decorative Black ---
-CINZEL_TTF="$DIR_CINZEL/CinzelDecorative-Black.ttf"
-if ! has_family_re '^cinzel decorative( |$)'; then
-  fetch "https://github.com/google/fonts/raw/main/ofl/cinzeldecorative/CinzelDecorative-Black.ttf" "$CINZEL_TTF" || warn "Cinzel Decorative Black download failed"
-  [ -s "$CINZEL_TTF" ] && $SUDO chmod 0644 "$CINZEL_TTF"
-else
-  log "Cinzel Decorative already present."
-fi
-
-# --- IM Fell English SC ---
-IMFELL_TTF="$DIR_IMFELL/IMFeENsc.ttf"
-if ! has_family_re '^im fell english sc( |$)'; then
-  # Try known gstatic TTFs (stable direct links)
-  for u in \
-    "https://fonts.gstatic.com/s/imfellenglishsc/v7/h3Tn6yWfw4b5qaLD1RWvz5ATixNthKRRR1XVH3rJNiw.ttf" \
-    "https://fonts.gstatic.com/s/imfellenglishsc/v6/h3Tn6yWfw4b5qaLD1RWvz5ATixNthKRRR1XVH3rJNiw.ttf"
-  do
-    if fetch "$u" "$IMFELL_TTF"; then
-      [ -s "$IMFELL_TTF" ] && { $SUDO chmod 0644 "$IMFELL_TTF"; log "IM Fell SC from gstatic OK"; break; }
-    fi
-  done
-  # Secondary RAW in google/fonts (names changed over time)
-  if [ ! -s "$IMFELL_TTF" ]; then
-    for u in \
-      "https://github.com/google/fonts/raw/main/ofl/imfellenglishsc/IMFeENsc28P.ttf" \
-      "https://github.com/google/fonts/raw/main/ofl/imfellenglishsc/IMFellEnglishSC-Regular.ttf"
-    do
-      if fetch "$u" "$IMFELL_TTF"; then
-        [ -s "$IMFELL_TTF" ] && { $SUDO chmod 0644 "$IMFELL_TTF"; log "IM Fell SC from google/fonts RAW OK"; break; }
-      fi
-    done
-  fi
-  # Minimal mirror fallback (only if naprawdę trzeba)
-  if [ ! -s "$IMFELL_TTF" ]; then
-    for u in \
-      "https://www.wfonts.com/download/data/2016/06/14/im-fell-english-sc/IMFeENsc28P.ttf" \
-      "https://www.1001freefonts.com/d/6800/IMFeENsc28P.ttf"
-    do
-      fetch "$u" "$IMFELL_TTF" || true
-      [ -s "$IMFELL_TTF" ] && { $SUDO chmod 0644 "$IMFELL_TTF"; log "IM Fell SC from mirror OK"; break; }
-    done
-  fi
-  [ -s "$IMFELL_TTF" ] || warn "IM Fell English SC still missing."
-else
-  log "IM Fell English SC already present."
-fi
-
-echo
-log "Fix perms & rebuild cache..."
-$SUDO find "$SYSTEM_DIR" -type f -size 0 -print -delete || true
-$SUDO find "$SYSTEM_DIR" -type f \( -name "*.ttf" -o -name "*.otf" \) -exec chmod 0644 {} \; || true
-$SUDO find "$SYSTEM_DIR" -type d -exec chmod 0755 {} \; || true
-$SUDO fc-cache -f -v >/dev/null || warn "fc-cache returned non-zero"
-
-# ---- FINAL REPORT ----
-echo
-log "FINAL STATUS (fc-list families & file presence)"
-families="$(fc_families_lower)"
-
-report(){
-  local label="$1" fam_re="$2" file_hint="$3"
-  local fam_ok file_ok="n/a"
-  if echo "$families" | grep -Eiq "$fam_re"; then fam_ok="OK"; else fam_ok="MISSING"; fi
-  if [ -n "$file_hint" ]; then
-    if [ -s "$file_hint" ]; then file_ok="yes"; else file_ok="no"; fi
-  fi
-  printf "  %-22s : families=%-8s file=%-3s  (%s)\n" "$label" "$fam_ok" "$file_ok" "${file_hint:-no-file-hint}"
-}
-
-report "EB Garamond"           '^eb garamond( |$)'           ""                 # from APT
-report "Cinzel Decorative"     '^cinzel decorative( |$)'      "$CINZEL_TTF"
-report "IM Fell English SC"    '^im fell english sc( |$)'     "$IMFELL_TTF"
-
-echo
-log "Done. (Run your LaTeX pipeline next.)"

docs/deployment/DEPLOYMENT_GUIDE.md

@@ -1,163 +0,0 @@
-# Conjurer Deployment Guide
-
-This document walks through deploying the Conjurer stack (Discord bot, music
-service, librarian service) on two Raspberry Pi 4s and one Windows host, first
-with plain Docker Compose, then with a future Kubernetes setup.
-
-## 1. Current Hardware Layout
-
-- **Windows PC**: Stores persistent data (JSON memories, configs, music
-  catalogue). Shares folders over the network (SMB) for the Pis.
-- **Raspberry Pi A** (“radio”): Runs the Liquidsoap/liq radio pipeline and the
-  musician service (Flask + file watcher).
-- **Raspberry Pi B** (“bot”): Runs the Discord bot, communication bridge, and
-  librarian Flask service.
-
-You can rebalance as follows:
-
-| Service             | Recommended Host | Notes |
-|---------------------|------------------|-------|
-| Discord bot + comms | Raspberry Pi B   | Needs outbound internet, moderate CPU |
-| Librarian service   | Raspberry Pi B   | CPU-heavy during Crossref queries; keep close to bot |
-| Musician service    | Raspberry Pi A   | Has direct disk access to music, same box as Liquidsoap |
-| Data storage        | Windows          | Expose via SMB; mount inside containers |
-
-## 2. Prepare Shared Storage on Windows
-
-1. Create directories, e.g. `C:\Conjurer\config`, `C:\Conjurer\logs`,
-   `C:\Conjurer\music`, `C:\Conjurer\playlists`, `C:\Conjurer\secrets`.
-2. Copy your existing JSON settings (`settings.json`, `pamiec.json`,
-   `pamiec_muzyki.json`, `system_gpt_settings.json`, etc.) into `config`.
-3. Create blank placeholder files if they do not exist yet.
-4. Share the root folder (`C:\Conjurer`) over SMB with read/write access for the
-   Pi user (create credentials if necessary).
-
-## 3. Configure Environment Files
-
-1. On your workstation, copy the example env files:
-   ```bash
-   cp docker/env/bot.env.example docker/env/bot.env
-   cp docker/env/musician.env.example docker/env/musician.env
-   cp docker/env/librarian.env.example docker/env/librarian.env
-   ```
-2. Edit each `docker/env/*.env` to replace `HACKME!` with real values:
-   - `DISCORD_TOKEN`, `OPENAI_API_KEY`, `CONJURER_API_KEY` (use the same value for
-     all services).
-   - For musician/librarian, adjust mounts to the SMB paths you will mount on the
-     Pis, e.g. `/mnt/conjurer/music`.
-   - Set `CONJURER_CROSSREF_MAILTO` to a real email as required by Crossref.
-3. If you rely on `.netrc`, copy it to `C:\Conjurer\secrets\.netrc` and set
-   `CONJURER_NETRC_FILE` accordingly.
-
-## 4. Install Docker on Raspberry Pis and Windows
-
-### Raspberry Pi
-```bash
-curl -fsSL https://get.docker.com | sh
-sudo usermod -aG docker $USER
-sudo reboot
-
-# Install docker compose plugin
-sudo apt-get install docker-compose-plugin
-```
-
-### Windows
-- Install **Docker Desktop**.
-- Enable WSL2 backend and expose the shared Windows folders to the containers
-  (Docker Desktop settings → Resources → File Sharing).
-
-## 5. Deploy Musician Service (Pi A)
-
-1. SSH into Raspberry Pi A.
-2. Mount the Windows SMB share:
-   ```bash
-   sudo mkdir -p /mnt/conjurer
-   sudo apt-get install cifs-utils
-   sudo mount -t cifs //WINDOWS_HOST/Conjurer /mnt/conjurer -o user=YOURUSER
-   ```
-   Add an entry to `/etc/fstab` for persistence.
-3. Copy the repo to the Pi or `git clone` it.
-4. On Pi A, create override compose file (optional) pointing volumes to
-   `/mnt/conjurer`.
-5. Start only the musician service:
-   ```bash
-   docker compose up --build -d musician
-   ```
-   Alternatively, duplicate `docker-compose.yml`, strip other services, and run
-   `docker compose up -d`.
-
-## 6. Deploy Bot + Librarian (Pi B)
-
-1. Repeat SMB mount on Pi B (same mount path).
-2. Copy repo / pull latest changes.
-3. Create `.env` files with tokens (or copy from control machine).
-4. Start bot and librarian:
-   ```bash
-   docker compose up -d bot librarian
-   ```
-
-## 7. Optional: Run Supporting Liquidsoap Radio
-
-- Keep Liquidsoap on Pi A as-is, using the same music directories. Ensure the
-  musician container has read access to those directories (bind mount).
-
-## 8. Verifying
-
-1. `docker ps` on each Pi to confirm containers running.
-2. Inspect logs under the mounted logs directory (`/mnt/conjurer/logs`).
-3. Join Discord server; issue commands to confirm functionality.
-4. Hit health endpoints manually (e.g. `curl http://PIB:5000/conjurer`).
-
-## Rebalancing Suggestions
-
-- If librarian CPU spikes become an issue, move it to Pi A or another host.
-- If you add a dedicated NAS, mount the network share read-only for the musician
-  container and read/write for other services.
-
-## 9. Future Kubernetes Deployment (Outline)
-
-### Hardware Considerations
-
-- Minimum three nodes for HA: use the existing two Pis plus one additional Pi 4
-  (8 GB preferred). Use Windows PC as storage provider via NFS/SMB CSI driver or
-  as a data gateway.
-- Consider Pi clusters with USB SSDs for better I/O.
-
-### Cluster Setup Steps
-
-1. Install a lightweight Kubernetes distribution (e.g., k3s) on each Pi:
-   ```bash
-   curl -sfL https://get.k3s.io | sh -
-   # On additional nodes
-   curl -sfL https://get.k3s.io | K3S_URL=https://MASTER:6443 K3S_TOKEN=HACKME sh -
-   ```
-2. Install MetalLB for load balancer support on LAN.
-3. Configure persistent volumes using:
-   - `nfs-subdir-external-provisioner` pointing to Windows share (ensure Windows
-     host supports NFS or run an NFS gateway on another machine).
-   - Alternatively, attach individual USB drives to each Pi and use
-     `local-path-provisioner` for node-local storage.
-4. Create Kubernetes `Secret` objects for tokens (`DISCORD_TOKEN`, etc.).
-5. Define `Deployment` manifests for each service (bot, musician, librarian) and
-   associated `Services`.
-6. Expose Discord bot ports via `NodePort` or Ingress.
-7. Use `StatefulSet` if you need stable identity for the musician service (due to
-   local storage).
-
-### Optimisation Tips
-
-- Keep CPU-heavy librarian pods optionally on a beefier node; use
-  `nodeSelector`/`affinity` to pin workloads.
-- Consider splitting the persistent storage: music on Pi A (USB disk), logs and
-  configs on Pi B, backups on Windows.
-- For improved reliability, add at least one extra Pi for quorum and to host the
-  communication bridge if the bot node fails.
-
-## Summary Checklist
-
-1. Prepare Windows shares & tokens.
-2. Configure `docker/env/*.env` using `HACKME!` templates as reference.
-3. Install Docker on Pis, mount network shares.
-4. Launch musician on Pi A, bot + librarian on Pi B.
-5. Verify Discord functionality and API endpoints.
-6. Plan Kubernetes migration when ready (k3s + MetalLB + storage provisioner).

ffmpeg.pref

@@ -1,3 +0,0 @@
-Package: ffmpeg libavcodec-dev libavcodec59 libavdevice59 libavfilter8 libavformat-dev libavformat59 libavutil-dev libavutil57 libpostproc56 libswresample-dev libswresample4 libswscale-dev libswscale6 libavdevice-dev libavfilter-dev libpostproc-dev
-Pin: origin deb.debian.org
-Pin-Priority: 1001

file_search_commands.py

@@ -1,71 +0,0 @@
-import os
-import discord
-from discord.ext import commands
-import file_search_functions
-
-class FileSelectView(discord.ui.View):
-    def __init__(self, files):
-        super().__init__(timeout=60)
-        options = [discord.SelectOption(label=os.path.basename(f)[:100], description=f, value=f) for f in files]
-        self.select = discord.ui.Select(
-            placeholder="Select files...",
-            min_values=1,
-            max_values=len(options),
-            options=options
-        )
-        self.select.callback = self.select_callback
-        self.add_item(self.select)
-        self.selected = []
-
-    async def select_callback(self, interaction: discord.Interaction):
-        # Store selected file paths
-        self.selected = self.select.values
-        await interaction.response.defer()
-
-    @discord.ui.button(label="Accept", style=discord.ButtonStyle.green)
-    async def accept_callback(self, interaction: discord.Interaction, button: discord.ui.Button):
-        # Handle acceptance
-        if not self.selected:
-            await interaction.response.send_message("No files selected.", ephemeral=True)
-            return
-        # Publish selected files
-        links = file_search_functions.publish(self.selected)
-        # Display the returned links
-        await interaction.response.edit_message(content="Published Links:\n" + "\n".join(links), view=None)
-
-    @discord.ui.button(label="Cancel", style=discord.ButtonStyle.red)
-    async def cancel_callback(self, interaction: discord.Interaction, button: discord.ui.Button):
-        # Handle cancellation
-        await interaction.response.edit_message(content="Operation cancelled.", view=None)
-
-class FileSearchCog(commands.Cog):
-    """Cog providing a file search and publish command."""
-
-    def __init__(self, bot: commands.Bot):
-        self.bot = bot
-
-    @commands.has_any_role("Jarl", "Thane")
-    @commands.command(name="tajna_biblioteka_inkwizycji")
-    async def findfiles(self, ctx: commands.Context, entries: int, *, keywords: str):
-        """
-        Search for files matching keywords and publish selected ones.
-
-        Usage: !findfiles <entries 1-10> <keywords>
-        """
-        if entries < 1 or entries > 10:
-            await ctx.send("❌ Entries must be between 1 and 10.")
-            return
-        keyword_list = keywords.split()
-        files = file_search_functions.find_matches(entries, keyword_list)
-        if not files:
-            await ctx.send("🔍 No matching files found.")
-            return
-        view = FileSelectView(files)
-        file_list = "\n".join(f"{i+1}. {f}" for i, f in enumerate(files))
-        await ctx.send(
-            f"🔍 Found files (select and click Accept or Cancel):\n{file_list}",
-            view=view
-        )
-
-async def setup(bot: commands.Bot):
-    await bot.add_cog(FileSearchCog(bot))

file_search_functions.py

@@ -1,31 +0,0 @@
-import requests
-
-# Base URL for Flask service
-BASE_URL = 'http://192.168.1.15:5000'
-
-
-def find_matches(entries, keywords):
-    """
-    Call the get_share_list endpoint.
-    entries: int (1-10)
-    keywords: list of strings
-    Returns: list of file paths
-    """
-    payload = {'entries': entries, 'keywords': keywords}
-    response = requests.post(f"{BASE_URL}/get_share_list", json=payload)
-    response.raise_for_status()
-    data = response.json()
-    return data.get('files', [])
-
-
-def publish(file_paths):
-    """
-    Call the get_share_links endpoint.
-    file_paths: list of file path strings
-    Returns: list of published URLs
-    """
-    payload = {'file_paths': file_paths}
-    response = requests.post(f"{BASE_URL}/get_share_links", json=payload)
-    response.raise_for_status()
-    data = response.json()
-    return data.get('links', [])

file_webservice/conjurer_musician.py

@@ -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.

file_webservice/conjurer_musician.service

@@ -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

file_webservice/install_musician_service.sh

@@ -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

file_webservice/requirements_musician.txt

@@ -0,0 +1,2 @@
+flask
+waitress

fontget.sh

@@ -1,98 +0,0 @@
-#!/usr/bin/env bash
-# "apt dla fontów": Google Fonts ZIP → GitHub (ofl RAW) → fonts.gstatic.com → mirrory.
-# System-wide install do /usr/local/share/fonts/fontget/<rodzina> + fc-cache.
-# Usage: sudo ./fontget.sh "IM Fell English SC" "Cinzel Decorative" "EB Garamond"
-
-set -Eeuo pipefail
-SUDO=sudo; [ "$(id -u)" -eq 0 ] && SUDO=
-log(){ echo -e "[+] $*"; }
-warn(){ echo -e "[WARN] $*" >&2; }
-die(){ echo -e "[FATAL] $*" >&2; exit 1; }
-
-need(){ command -v "$1" >/dev/null 2>&1 || die "Missing: $1"; }
-need fc-cache
-command -v wget >/dev/null 2>&1 || command -v curl >/dev/null 2>&1 || die "Need wget/curl"
-command -v unzip >/dev/null 2>&1 || warn "unzip missing — ZIP installs limited"
-command -v file  >/dev/null 2>&1 || warn "file missing — MIME checks limited"
-command -v fc-list >/dev/null 2>&1 || die "Missing: fc-list"
-
-fetch(){ local u="$1" o="$2"; if command -v wget >/dev/null 2>&1; then wget -O "$o" --https-only --no-verbose "$u"; else curl -L --fail --show-error --output "$o" "$u"; fi; }
-slug(){ echo "$1" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9]+/-/g; s/^-+|-+$//g'; }
-present(){ fc-list -f '%{family}\n' | tr ',' '\n' | sed 's/^[[:space:]]*//; s/[[:space:]]*$//' | tr '[:upper:]' '[:lower:]' | sort -u | grep -Eiq "$1"; }
-
-install_dir="/usr/local/share/fonts/fontget"; $SUDO mkdir -p "$install_dir"
-
-is_zip(){ command -v file >/dev/null 2>&1 && file "$1" | grep -qi zip; }
-gf_zip_try(){
-  local name="$1" outdir="$2" enc zip
-  enc="$(python3 - <<PY
-import urllib.parse,sys
-print(urllib.parse.quote(sys.argv[1]))
-PY
-"$name")" || enc="$(echo "$name" | sed 's/ /%20/g')"
-  zip="$(mktemp /tmp/fontget.XXXXXX.zip)"
-  if fetch "https://fonts.google.com/download?family=${enc}" "$zip"; then
-    if is_zip "$zip"; then $SUDO mkdir -p "$outdir"; $SUDO unzip -o -q "$zip" -d "$outdir" || true; rm -f "$zip"; return 0; fi
-  fi
-  rm -f "$zip" || true; return 1
-}
-gh_ofl_try(){
-  local family="$1" outdir="$2" html
-  html="$(mktemp /tmp/ofl.$(slug "$family").html)"
-  if fetch "https://github.com/google/fonts/tree/main/ofl/$(slug "$family")" "$html"; then
-    mapfile -t paths < <(grep -Eo '/google/fonts/blob/main/ofl/'"$(slug "$family")"'/[^"]+\.(ttf|otf)' "$html" | sed 's|/blob/|/raw/|g' | sort -u)
-    [ "${#paths[@]}" -gt 0 ] || { rm -f "$html"; return 1; }
-    $SUDO mkdir -p "$outdir"
-    for p in "${paths[@]}"; do fetch "https://github.com$p" "$outdir/$(basename "$p")" || true; done
-    rm -f "$html"; return 0
-  fi
-  rm -f "$html"; return 1
-}
-gstatic_try(){ local out="$2"; shift 2; for u in "$@"; do fetch "$u" "$out" && [ -s "$out" ] && return 0; done; return 1; }
-
-report(){ local label="$1" re="$2"; if present "$re"; then printf "RESULT: %-24s : OK\n" "$label"; else printf "RESULT: %-24s : FAIL\n" "$label"; fi }
-
-if [ $# -lt 1 ]; then echo "Usage: $0 <Font Family> [Another ...]"; exit 1; fi
-
-for family in "$@"; do
-  echo; log "=== $family ==="
-  fam_slug="$(slug "$family")"
-  outdir="$install_dir/$fam_slug"
-  $SUDO mkdir -p "$outdir"
-
-  case "$fam_slug" in
-    cinzel-decorative|cinzel|cinzel-decorative-black)
-      fetch "https://github.com/google/fonts/raw/main/ofl/cinzeldecorative/CinzelDecorative-Black.ttf" "$outdir/CinzelDecorative-Black.ttf" || warn "Cinzel fetch failed"
-      ;;
-    im-fell-english-sc)
-      gstatic_try "$fam_slug" "$outdir/IMFeENsc.ttf" \
-        "https://fonts.gstatic.com/s/imfellenglishsc/v7/h3Tn6yWfw4b5qaLD1RWvz5ATixNthKRRR1XVH3rJNiw.ttf" \
-        "https://fonts.gstatic.com/s/imfellenglishsc/v6/h3Tn6yWfw4b5qaLD1RWvz5ATixNthKRRR1XVH3rJNiw.ttf" \
-      || { fetch "https://github.com/google/fonts/raw/main/ofl/imfellenglishsc/IMFeENsc28P.ttf" "$outdir/IMFeENsc.ttf" || true
-           [ -s "$outdir/IMFeENsc.ttf" ] || fetch "https://github.com/google/fonts/raw/main/ofl/imfellenglishsc/IMFellEnglishSC-Regular.ttf" "$outdir/IMFeENsc.ttf" || true
-           [ -s "$outdir/IMFeENsc.ttf" ] || fetch "https://www.wfonts.com/download/data/2016/06/14/im-fell-english-sc/IMFeENsc28P.ttf" "$outdir/IMFeENsc.ttf" || true
-           [ -s "$outdir/IMFeENsc.ttf" ] || fetch "https://www.1001freefonts.com/d/6800/IMFeENsc28P.ttf" "$outdir/IMFeENsc.ttf" || true; }
-      ;;
-    eb-garamond|ebgaramond)
-      # Najpierw apt (jeśli chcesz: sudo apt install fonts-ebgaramond), tu tylko web:
-      gf_zip_try "$family" "$outdir" || gh_ofl_try "$family" "$outdir" || true
-      ;;
-    *)
-      gf_zip_try "$family" "$outdir" || gh_ofl_try "$family" "$outdir" || true
-      ;;
-  esac
-
-  $SUDO find "$outdir" -type f -size 0 -print -delete || true
-  $SUDO find "$outdir" -type f \( -name "*.ttf" -o -name "*.otf" \) -exec chmod 0644 {} \; || true
-  $SUDO find "$outdir" -type d -exec chmod 0755 {} \; || true
-  $SUDO fc-cache -f -v >/dev/null || true
-
-  case "$fam_slug" in
-    cinzel* )            report "Cinzel Decorative"   '^cinzel decorative( |$)' ;;
-    im-fell-english-sc ) report "IM Fell English SC"  '^im fell english sc( |$)' ;;
-    eb-garamond* )       report "EB Garamond"         '^eb garamond( |$)' ;;
-    * )                  report "$family"             "$(echo "$family" | tr '[:upper:]' '[:lower:]' | sed 's/ /.* /g')" ;;
-  esac
-done
-
-echo; log "All done."

install_main_bot.sh

@@ -1,25 +1,12 @@
 #!/bin/bash
-sudo apt-get install python3-dev
-sudo apt-get install portaudio19-dev python3-pyaudio
-sudo apt-get install
-cd /home/pi || exit
-mdkir Conjurer
-cd Conjurer ||exit
-python3 -m venv /home/pi/Conjurer/.env
-cp /home/pi/conjurer/requirements_bot.txt /home/pi/Conjurer/
-# trunk-ignore(shellcheck/SC1091)
-source /home/pi/Conjurer/.env/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
+python3 -m venv /home/pi/Conjurer/env
+source ./env/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
 deactivate
 sudo cp ./conjurer.service /etc/systemd/system/
 sudo systemctl daemon-reload
-sudo systemctl start conjurer.service
-sudo systemctl enable conjurer.service
+sudo systemctl start conjurer_musician.service
+sudo systemctl enable conjurer_musician.service

install_music_bot.sh

@@ -1,51 +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
-
-echo "Add exception suppresion to signal handler in spotify __ini__.py"
-echo "Add password to youtube opts in spotify_dl youtube.py"
-echo "Downgrade ffmpeg by copying ffmpeg.pref from repository to /etc/apt/preferences.d"
-echo "Install opam from installation link"
-echo "Initialize opam"
-echo "Install liquidsoap and its dependencies"
-
-touch /home/pi/Conjurer/radio_log.log
-./env/bin/python3 -m pip install --upgrade pip
-./env/bin/python3 -m pip install -r requirements_musician.txt
-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

latex_commands.py

@@ -1,280 +0,0 @@
-# latex_commands.py
-# -*- coding: utf-8 -*-
-from __future__ import annotations
-
-import io
-import logging
-from typing import Optional
-
-import discord
-from discord import app_commands
-from discord.ext import commands
-
-from constants import (
-    ALLOWED_ROLES,
-    GUILD_ID,
-    LATEX_MAX_ATTACH_MB,
-    LATEX_MAX_COMPILE_SECONDS,
-    LATEX_MAX_ZIP_MB,
-    LATEX_TEX_ENGINE,
-    OPENAI_MODEL,
-)
-from latex_functions import (
-    compile_single_tex_bytes,
-    compile_zip_to_zip,
-    is_safe_asset_name,
-    is_safe_tex_name,
-)
-
-
-async def _collect_attachments_bytes(attachments, max_mb: int):
-    """
-    Zwraca słownik {filename: bytes} dla wszystkich załączników, do limitu MB.
-    Nie podbija wyjątków z .read() — zostawiamy to wyżej; tu zwracamy, co się udało.
-    """
-    out = {}
-    for a in attachments or []:
-        # limit rozmiaru
-        if (getattr(a, "size", 0) or 0) > max_mb * 1024 * 1024:
-            continue
-        data = await a.read()
-        out[a.filename] = data
-    return out
-
-
-class LatexModule(commands.Cog):
-    def __init__(self, bot: commands.Bot, logger_name: str):
-        self.bot = bot
-        self.logger = logging.getLogger(logger_name)
-        self.logger_name = logger_name
-
-    # -------- /tex (PDF + diagnoza; log -> debug logger) --------
-    @commands.hybrid_command(
-        nsfw=False,
-        name="tex",
-        description="Kompiluje załączone .tex; PDF-y odsyła. Błędy: diagnoza z OpenAI.",
-        guild=None if GUILD_ID is None else discord.Object(id=GUILD_ID),
-    )
-    @commands.has_any_role(*ALLOWED_ROLES)
-    async def tex(
-        self, ctx: commands.Context, include_source_excerpt: Optional[bool] = True
-    ):
-        self.logger.info("LaTeX command invoked by %s", ctx.author)
-        ch = ctx.message.channel
-        # ZBIERZ WSZYSTKIE ZAŁĄCZNIKI
-        async with ch.typing():
-            all_bytes = await _collect_attachments_bytes(
-                ctx.message.attachments, LATEX_MAX_ATTACH_MB
-            )
-            if not all_bytes:
-                return await ctx.reply(
-                    f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False
-                )
-
-            # PODZIEL NA GŁÓWNE .TEX i WSPIERAJĄCE
-            tex_names = [
-                n
-                for n in all_bytes.keys()
-                if n.lower().endswith(".tex") and is_safe_tex_name(n)
-            ]
-            if not tex_names:
-                return await ctx.reply(
-                    f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False
-                )
-
-            support_names = [
-                n
-                for n in all_bytes.keys()
-                if n not in tex_names and is_safe_asset_name(n)
-            ]
-
-            files_to_send = []
-            parts = []
-
-            for tex_name in tex_names:
-                try:
-                    main_bytes = all_bytes[tex_name]
-                    support = [
-                        (n, all_bytes[n])
-                        for n in support_names
-                        if n != tex_name and is_safe_asset_name(n)
-                    ]
-                    # (ważne) do supportów dopuszczamy również **inne .tex** – dla \input/\include
-                    other_tex = [
-                        (n, all_bytes[n])
-                        for n in tex_names
-                        if n != tex_name and is_safe_tex_name(n)
-                    ]
-                    support.extend(other_tex)
-
-                    res = await compile_single_tex_bytes(
-                        main_bytes,
-                        tex_name,
-                        LATEX_TEX_ENGINE,
-                        LATEX_MAX_COMPILE_SECONDS,
-                        logger="discord",
-                        support_files=support,
-                    )
-
-                    # Twoja dotychczasowa obsługa success/fail – przykładowo:
-                    if res["ok"] and res["pdf_bytes"]:
-                        b = io.BytesIO(res["pdf_bytes"])
-                        b.seek(0)
-                        b.name = res["pdf_name"]
-                        files_to_send.append(discord.File(b, filename=res["pdf_name"]))
-                        parts.append(f"✅ `{tex_name}` → `{res['pdf_name']}`")
-                    else:
-                        parts.append(
-                            f"❌ `{tex_name}` — błąd kompilacji.)"
-                        )
-                        # Tutaj wywołujesz swoją ścieżkę do OpenAI diagnozy, którą ogarnęliśmy wcześniej.
-                except Exception:
-                    # let it crash — pełny stack w logu i re-raise (Discord.py to pokaże sensownie)
-                    logging.getLogger("discord").exception(
-                        "Unhandled exception while compiling %s", tex_name
-                    )
-                    raise
-
-                content = (
-                    f"**LaTeX** — {len(tex_names)} plik(ów). Model: `{OPENAI_MODEL}`\n\n"
-                    + "\n\n".join(parts)
-                )
-                await ctx.reply(
-                    content if len(content) < 1900 else content[:1900] + "…",
-                    files=files_to_send,
-                    mention_author=False,
-                )
-
-    # -------- /latexclean (PDF only; log -> debug logger) --------
-    @commands.hybrid_command(
-        nsfw=False,
-        name="latexclean",
-        description="Kompiluje .tex i odsyła TYLKO PDF (log w debug).",
-        guild=None if GUILD_ID is None else discord.Object(id=GUILD_ID),
-    )
-    @commands.has_any_role(*ALLOWED_ROLES)
-    async def latexclean(self, ctx: commands.Context):
-        ch = ctx.message.channel
-        async with ch.typing():
-            all_bytes = await _collect_attachments_bytes(
-                ctx.message.attachments, LATEX_MAX_ATTACH_MB
-            )
-            if not all_bytes:
-                return await ctx.reply(
-                    f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False
-                )
-
-            # PODZIEL NA GŁÓWNE .TEX i WSPIERAJĄCE
-            tex_names = [
-                n
-                for n in all_bytes.keys()
-                if n.lower().endswith(".tex") and is_safe_tex_name(n)
-            ]
-            if not tex_names:
-                return await ctx.reply(
-                    f"Dołącz .tex (≤{LATEX_MAX_ATTACH_MB} MiB).", mention_author=False
-                )
-
-            support_names = [
-                n
-                for n in all_bytes.keys()
-                if n not in tex_names and is_safe_asset_name(n)
-            ]
-
-            files_to_send = []
-            parts = []
-
-            for tex_name in tex_names:
-                try:
-                    main_bytes = all_bytes[tex_name]
-                    support = [
-                        (n, all_bytes[n])
-                        for n in support_names
-                        if n != tex_name and is_safe_asset_name(n)
-                    ]
-                    # (ważne) do supportów dopuszczamy również **inne .tex** – dla \input/\include
-                    other_tex = [
-                        (n, all_bytes[n])
-                        for n in tex_names
-                        if n != tex_name and is_safe_tex_name(n)
-                    ]
-                    support.extend(other_tex)
-
-                    res = await compile_single_tex_bytes(
-                        main_bytes,
-                        tex_name,
-                        LATEX_TEX_ENGINE,
-                        LATEX_MAX_COMPILE_SECONDS,
-                        logger="discord",
-                        support_files=support,
-                    )
-
-                    # Twoja dotychczasowa obsługa success/fail – przykładowo:
-                    if res["ok"] and res["pdf_bytes"]:
-                        b = io.BytesIO(res["pdf_bytes"])
-                        b.seek(0)
-                        b.name = res["pdf_name"]
-                        files_to_send.append(discord.File(b, filename=res["pdf_name"]))
-                        parts.append(f"✅ `{tex_name}` → `{res['pdf_name']}`")
-                    else:
-                        parts.append(
-                            f"❌ `{tex_name}` — błąd kompilacji.)"
-                        )
-                        # Tutaj wywołujesz swoją ścieżkę do OpenAI diagnozy, którą ogarnęliśmy wcześniej.
-                except Exception:
-                    # let it crash — pełny stack w logu i re-raise (Discord.py to pokaże sensownie)
-                    logging.getLogger("discord").exception(
-                        "Unhandled exception while compiling %s", tex_name
-                    )
-                    raise
-            await ctx.reply(
-                "**LaTeX clean** — " + ", ".join(parts),
-                files=files_to_send,
-                mention_author=False,
-            )
-
-    # -------- /texbatch (ZIP -> ZIP) --------
-    @app_commands.command(
-        name="texbatch",
-        description="Wyślij ZIP z .tex → odeślę ZIP z PDF-ami (tylko udane).",
-    )
-    @app_commands.describe(archive=f"Archiwum .zip (max ~{LATEX_MAX_ZIP_MB} MiB)")
-    @app_commands.checks.has_any_role(*ALLOWED_ROLES)
-    async def texbatch(
-        self, interaction: discord.Interaction, archive: discord.Attachment
-    ):
-        await interaction.response.defer()
-        if not archive or not archive.filename.lower().endswith(".zip"):
-            return await interaction.followup.send(
-                "Dołącz ZIP (.zip) z plikami .tex.", ephemeral=True
-            )
-        if archive.size > LATEX_MAX_ZIP_MB * 1024 * 1024:
-            return await interaction.followup.send(
-                f"ZIP > {LATEX_MAX_ZIP_MB} MiB — za duży.", ephemeral=True
-            )
-
-        data = await archive.read()
-        out_zip_bytes, failed = await compile_zip_to_zip(
-            data, LATEX_TEX_ENGINE, LATEX_MAX_COMPILE_SECONDS, logger=self.logger_name
-        )
-        if not out_zip_bytes and failed:
-            return await interaction.followup.send(
-                "Brak PDF-ów. " + "; ".join(failed[:10]), ephemeral=True
-            )
-
-        bio = io.BytesIO(out_zip_bytes)
-        bio.seek(0)
-        bio.name = "compiled_pdfs.zip"
-        if failed:
-            self.logger.debug("BATCH failed: %s", ", ".join(failed))
-        await interaction.followup.send(
-            "✅ Gotowe (ZIP w załączniku)."
-            + (f" ❌ Błędy: {len(failed)}" if failed else ""),
-            files=[discord.File(bio, filename=bio.name)],
-        )
-
-
-async def setup(bot):
-    logger = logging.getLogger("discord")
-    await bot.add_cog(LatexModule(bot, logger_name="discord"))
-    logger.info("Loading kinky latex module done")

latex_functions.py

@@ -1,179 +0,0 @@
-import asyncio
-import logging
-import re
-import shutil
-import tempfile
-import zipfile
-from pathlib import Path
-from typing import Dict, Iterable, List, Optional, Tuple
-
-# ===== Bezpieczeństwo nazw/rozszerzeń =====
-SAFE_TEX_NAME = re.compile(r"^[\w\-. ]+\.tex$", re.IGNORECASE)
-SAFE_ASSET_NAME = re.compile(
-    r"^[\w\-. /]+?\.(tex|png|jpg|jpeg|pdf|svg|eps|bmp|gif|sty|cls|bib|bst|bbx|cbx|def|cfg)$",
-    re.IGNORECASE,
-)
-
-def is_safe_tex_name(name: str) -> bool:
-    return bool(SAFE_TEX_NAME.match(name or ""))
-
-def is_safe_asset_name(name: str) -> bool:
-    return bool(SAFE_ASSET_NAME.match(name or ""))
-
-# ===== Uruchamianie kompilatora =====
-
-async def _run(cmd: List[str], cwd: Path, timeout_sec: int, logger_name: Optional[str]) -> Tuple[int, str]:
-    """Uruchamia proces kompilatora w cwd, zwraca (rc, sklejone_stdout_stderr)."""
-    logger = logging.getLogger(logger_name) if logger_name else logging.getLogger()
-    logger.debug("RUN %s (cwd=%s, timeout=%s)", " ".join(cmd), cwd, timeout_sec)
-
-    proc = await asyncio.create_subprocess_exec(
-        *cmd,
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.STDOUT,
-        cwd=str(cwd),
-    )
-    try:
-        out = await asyncio.wait_for(proc.communicate(), timeout=timeout_sec)
-    except asyncio.TimeoutError:
-        try:
-            proc.kill()
-        finally:
-            pass
-        return 124, "TIMEOUT: compiler took too long"
-    rc = proc.returncode
-    log = (out[0] or b"").decode("utf-8", errors="ignore")
-    logger.debug("RC=%s, LOG TAIL:\n%s", rc, log[-1500:])
-    return rc, log
-
-def _build_cmd(tex_engine: str, main_tex: str) -> List[str]:
-    """Buduje komendę kompilatora; domyślnie tectonic/pdflatex/xelatex."""
-    if tex_engine.lower() == "tectonic":
-        # Tectonic sam robi wielofazowość, ale i tak uruchamiamy 2x (bezpiecznie dla bib/refs)
-        return ["tectonic", "--keep-intermediates", "--synctex", main_tex]
-    elif tex_engine.lower() in ("pdflatex", "xelatex", "lualatex"):
-        return [tex_engine, "-interaction=nonstopmode", "-halt-on-error", main_tex]
-    else:
-        # fallback – traktujemy jak pdflatex
-        return ["pdflatex", "-interaction=nonstopmode", "-halt-on-error", main_tex]
-
-async def run_latex_two_passes(
-    tex_filename: str, workdir: Path, tex_engine: str, timeout_sec: int, logger: Optional[str] = None
-) -> Tuple[bool, str, Path]:
-    """
-    Uruchamia kompilację 2 razy (bezpieczeństwo referencji/bib).
-    Zwraca: (ok, log_text, pdf_path).
-    """
-    logger_obj = logging.getLogger(logger) if logger else logging.getLogger()
-    logger_obj.info("Compiling %s with %s engine two passes", tex_filename, tex_engine)
-    logs: List[str] = []
-    pdf_path = workdir / (Path(tex_filename).stem + ".pdf")
-
-    # PASS 1
-    rc1, log1 = await _run(_build_cmd(tex_engine, tex_filename), workdir, timeout_sec, logger)
-    logs.append(log1)
-    if rc1 != 0:
-        return False, "".join(logs), pdf_path
-
-    # PASS 2 (często już nic nie robi, ale nie szkodzi)
-    rc2, log2 = await _run(_build_cmd(tex_engine, tex_filename), workdir, timeout_sec, logger)
-    logs.append(log2)
-    ok = (rc2 == 0) and pdf_path.exists()
-    return ok, "".join(logs), pdf_path
-
-# ===== Kompilacje: pojedynczy TEX + ZIP =====
-
-async def compile_single_tex_bytes(
-    tex_bytes: bytes,
-    filename: str,
-    tex_engine: str,
-    timeout_sec: int,
-    logger: Optional[str] = None,
-    support_files: Optional[Iterable[Tuple[str, bytes]]] = None,
-) -> Dict[str, Optional[object]]:
-    """
-    Kompiluje pojedynczy .tex + dowolne pliki pomocnicze (obrazy, sty/cls/bib, inne .tex).
-    Każdy plik zapisujemy w katalogu roboczym widocznym dla kompilatora.
-    """
-    log = logging.getLogger(logger) if logger else logging.getLogger()
-    log.info("Compiling %s with %s engine single tex", filename, tex_engine)
-    if not is_safe_tex_name(filename):
-        return {"ok": False, "pdf_bytes": None, "log_text": "Invalid .tex filename", "pdf_name": None}
-
-    with tempfile.TemporaryDirectory(prefix="latex_one_") as td:
-        wd = Path(td)
-        (wd / Path(filename).name).write_bytes(tex_bytes)
-
-        # Zapisz wszystkie supporty obok głównego pliku
-        if support_files:
-            for fname, data in support_files:
-                if not fname or not is_safe_asset_name(fname):
-                    continue
-                # spłaszczamy do nazwy bazowej (bez podkatalogów z zewn. źródeł)
-                (wd / Path(fname).name).write_bytes(data)
-
-        ok, log_text, pdf_path = await run_latex_two_passes(Path(filename).name, wd, tex_engine, timeout_sec, logger)
-        log.info("LaTeX compile finished: %s", "OK" if ok else "FAIL")
-        log.info("Log text:\n%s", log_text[-2000:])  # Log last 2000 chars
-        log.info("PDF path: %s", pdf_path)
-        if ok and pdf_path.exists():
-            return {
-                "ok": True,
-                "pdf_bytes": pdf_path.read_bytes(),
-                "log_text": log_text,
-                "pdf_name": pdf_path.name,
-            }
-        return {"ok": False, "pdf_bytes": None, "log_text": log_text, "pdf_name": pdf_path.name}
-
-async def compile_zip_to_zip(
-    zip_bytes: bytes, tex_engine: str, timeout_sec: int, logger: Optional[str] = None
-) -> Tuple[bytes, List[str]]:
-    """
-    Rozpakowuje ZIP, znajduję wszystkie .tex i dla KAŻDEGO tworzy osobny katalog roboczy
-    ze skopiowanym CAŁYM drzewem, by zachować ścieżki względne obrazków/plików.
-    Zwraca (zip_pdf_bytes, lista_rel_sciezek_które_padły).
-    """
-    log = logging.getLogger(logger) if logger else logging.getLogger()
-    failed: List[str] = []
-    out_pdf_paths: List[Path] = []
-
-    with tempfile.TemporaryDirectory(prefix="latex_zip_") as td:
-        td_path = Path(td)
-        src_root = td_path / "src"
-        src_root.mkdir(parents=True, exist_ok=True)
-
-        # 1) Rozpakuj
-        zpath = td_path / "in.zip"
-        zpath.write_bytes(zip_bytes)
-        with zipfile.ZipFile(zpath, "r") as zf:
-            zf.extractall(src_root)
-
-        # 2) Zbierz .tex
-        tex_files = [p for p in src_root.rglob("*.tex") if is_safe_tex_name(p.name)]
-        if not tex_files:
-            return b"", ["No .tex files found in archive."]
-
-        # 3) Kompiluj każdy .tex w izolacji (kopiujemy całe drzewo do osobnego workdiru)
-        for tex_path in tex_files:
-            rel_tex = tex_path.relative_to(src_root).as_posix()
-            work = td_path / f"build_{tex_path.stem}"
-            try:
-                shutil.copytree(src_root, work / "src")
-                ok, log_text, pdf = await run_latex_two_passes(rel_tex, work / "src", tex_engine, timeout_sec, logger)
-                if ok and pdf.exists():
-                    out_pdf_paths.append(pdf)
-                else:
-                    failed.append(rel_tex)
-                    log.info("LaTeX FAIL %s\n%s", rel_tex, (log_text or "")[-2000:])
-            except Exception:
-                # let it crash – log + re-raise (to zobaczy wyższa warstwa/discord.py)
-                log.exception("Exception while compiling %s", rel_tex)
-                raise
-
-        # 4) Spakuj wyjściowe PDF-y
-        out_zip = td_path / "compiled_pdfs.zip"
-        with zipfile.ZipFile(out_zip, "w", compression=zipfile.ZIP_DEFLATED) as zf:
-            for pdf in out_pdf_paths:
-                zf.write(pdf, arcname=pdf.name)
-
-        return out_zip.read_bytes(), failed

librarian_commands.py

@@ -1,304 +0,0 @@
-import asyncio
-import io
-import logging
-import os
-import random
-import uuid
-from queue import Empty
-
-import discord
-import pdf2image
-import fitz
-import PyPDF2
-import requests
-from discord.ext import commands, tasks
-
-from ai_functions import handle_response
-from communication_subroutine import IN_COMM_Q, OUT_COMM_Q, QueryControl
-from constants import DIR_PATH_SADOX, LIBRARIAN_SERVICE_ADDRESS, SEND_QUERY, service_headers
-
-SERVICE_HEADERS = service_headers()
-
-
-class DataModule(commands.Cog):
-    def __init__(self, bot, logger_name):
-        self.bot = bot
-        self.logger = logging.getLogger(logger_name)
-
-    @commands.hybrid_command(
-        nsfw=True,
-        name="get_image_sadox",
-        description="Wyświetla losową stronę z losowego komiksu FanSadox. Bardzo NSFW.",
-        guild=discord.Object(id=664789470779932693),
-    )
-    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
-
-    async def get_image_sadox(self, ctx):
-        """
-        Take in a context parameter and retrieve an image related from fansadox collection.
-
-        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-        represents the context in which the command was invoked, including information such as the message,
-        the channel, the server, and the user who invoked the command. In this case, it is likely being used
-        to determine
-        """
-        self.logger.info("Get sadox")
-        channel = ctx.message.channel
-        async with channel.typing():
-            # select random file
-            res = []
-            # Iterate directory
-            for path in os.listdir(DIR_PATH_SADOX):
-                # check if current path is a file
-                if os.path.isfile(os.path.join(DIR_PATH_SADOX, path)):
-                    res.append(path)
-            # trunk-ignore(bandit/B311)
-            filename = res[random.randrange(0, len(res) - 1)]
-            # select random page
-            file = open(DIR_PATH_SADOX + filename, "rb")
-            if  True:
-                doc = fitz.open(DIR_PATH_SADOX + filename)
-                totalpages = len(doc)
-                # trunk-ignore(bandit/B311)
-                page_index = random.randrange(0, totalpages)
-                page = doc.load_page(page_index)
-                mat = fitz.Matrix(2.0, 2.0)  # powiększenie
-                pix = page.get_pixmap(matrix=mat, alpha=False)
-
-                byte_io_stream = io.BytesIO(pix.tobytes("png"))
-                byte_io_stream.seek(0)
-                byte_io_stream.name = "image.png"
-                await ctx.send(file=discord.File(byte_io_stream))
-            else: #legacy
-                readpdf = PyPDF2.PdfReader(file)
-                totalpages = len(readpdf.pages)
-                # trunk-ignore(bandit/B311)
-                page = random.randrange(1, totalpages)
-                # convert page to image
-                image = pdf2image.convert_from_path(
-                    DIR_PATH_SADOX + filename, first_page=page, last_page=page
-                )
-                byte_io_stream = io.BytesIO()
-                image[0].save(byte_io_stream, "JPEG")
-                byte_io_stream.seek(0)
-                byte_io_stream.name = "image.jpg"
-                file = discord.File(byte_io_stream)
-                await ctx.send(file=file)
-            self.logger.info("Get sadox completed")
-
-    @tasks.loop(seconds=3)
-    async def check_data_q(self):
-        """
-        This function checks the data queue for any new entries and processes them accordingly.
-        """
-        try:
-            fresh_data = IN_COMM_Q.get(block=False)
-            entries = []
-            if fresh_data.stop:
-                searcher = fresh_data.author
-                query = fresh_data.content
-                l_p = 1
-                for doi in fresh_data.entries:
-                    self.logger.info(doi)
-                    desc = fresh_data.entries[doi]
-                    title = desc["Title"][0]
-                    entries.append(
-                        f"{l_p}. {title} pod linkiem https://www.sci-hub.se/{doi} i jest to {desc['type']}\n"
-                    )
-                    l_p += 1
-                message = "*Z podłogi wysuwa się winda na książki*"
-                if fresh_data.ctx is not None:
-                    ctx = fresh_data.ctx
-                    message += f" Dzielny poszukiwaczu @{searcher} w odpowiedzi na twoje zapytanie {query} nr {fresh_data.uuid}"
-                else:
-                    ctx = self.bot.get_channel(1062047571557744721)
-                    message += f" Mam wynik dla zapytania {fresh_data.uuid} ale że Hammer coś grzebał nie pamiętam kto to chciał i co chciał"
-
-                message += "nasza biblioteka służy Ci odpowiedzią. Przy dźwięku fanfar winda się otwiera a w środku "
-                if len(entries) < 1:
-                    message += "niestety nie ma nic"
-                    await ctx.send(message)
-                elif len(entries) >= 1 and len(entries) < 5:
-                    message += " znajduje się coś:\n"
-                    for item in entries:
-                        message += item
-                    await ctx.send(message)
-                else:
-                    message += " znajduje się cholernie dużo:\n"
-                    for item in entries:
-                        message += item
-                        if len(message) > 1500:
-                            await ctx.send(message)
-                            message = ""
-
-                # Kept for sentimental reasons
-                # await ctx.send(f"O. A tak będzie wyglądało coś ciekawego w przyszłości: {data}")
-        except Empty:
-            pass
-
-    @commands.hybrid_command(
-        name="wyszukaj_linki_do_dokumentow",
-        description="Szuka linkow doi w bazie crossref i podaje linki do scihuba",
-        guild=discord.Object(id=664789470779932693),
-    )
-    async def wyszukaj_linki_do_dokumentow(self, ctx):
-        """
-        The function `wyszukaj_linki_do_dokumentow` searches for links to documents in a crossref database and provides links to scihub.
-
-        :param ctx: The `ctx` parameter is typically used in Discord.py, a Python library for creating Discord bots.
-        It represents the context of the command being executed, including information about the message, the server,
-        and the user who invoked the command.
-        """
-        query = ctx.message.content
-        query_uuid = uuid.uuid4()
-        # TODO: TESTING ONLY!!
-        # query_uuid = uuid.UUID('{12345678-1234-5678-1234-567812345678}')
-        ctx.message.content = ctx.message.content.replace(
-            "$wyszukaj_linki_do_dokumentow", ""
-        )
-
-        json_query = {
-            "UUID": str(query_uuid),
-            "query": str(query),
-            "page": 1,
-            "deep_search": False,
-        }
-        coroutine = asyncio.to_thread(
-            requests.post,
-            f"{LIBRARIAN_SERVICE_ADDRESS}{SEND_QUERY}",
-            json=json_query,
-            headers=SERVICE_HEADERS,
-            timeout=360,
-        )
-        await ctx.send(
-            "*Conjurer powoli notuje podane przez Ciebie. Podchodzi do sprytnie ukrytej przy barze rury od poczty pneumatycznej i"
-            + " wrzuca twój liścik do środka* To teraz trza poczekać kilka godzin. Biblioteka to 3/4 stacji."
-            + " A przecież pół stacji to browar, motelik dla zabaw cielesnych i ten Bar. Więc 12/8 stacji teraz będzie ciężko pracować"
-        )
-        query_response = await coroutine
-        if not query_response.status_code == 200:
-            await ctx.send(
-                "*Z rury wydobywa się dym. Conjurer łapie pierwszą ciecz pod ręką i pryska na rurę. Następuje drobna eksplozja i wszystko zaczyna się palić."
-                + " Conjurer jest skonfundowany..* Wołaj szefa - mam nieodparte wrażenie że się coś wyjebało"
-            )
-            return
-
-        query, query_uuid, queue_size = (
-            query_response.json()["data"][0],
-            query_response.json()["data"][1],
-            query_response.json()["data"][2],
-        )
-        if ctx.message.author.nick:
-            username = ctx.message.author.nick
-        else:
-            username = ctx.message.author.name
-        query_object = QueryControl(username, query_uuid, query, ctx)
-        OUT_COMM_Q.put(query_object)
-        await ctx.send(
-            f"No dobra poszło. Zapamiętaj proszę {query_uuid} - to identyfikator twojego zapytania. Jesteś {queue_size} w kolejce."
-            + " Zapytania obsługuje algorytm zasilany czterema chomikami zapierdalającymi w kołowrotku - więc wyniki najwcześniej za kilka godzi - ale mogą być też dni."
-        )
-
-    @commands.hybrid_command(
-        name="glebokie_gardlo",
-        description="Przygotowuje drinka o nazwie głębokie gardło",
-        guild=discord.Object(id=664789470779932693),
-    )
-
-    async def wyszukaj_linki_do_dokumentow_deep(self, ctx):
-        """
-        The function `wyszukaj_linki_do_dokumentow_deep` performs a deep search for links to documents in
-        a crossref database and provides links to scihub.
-
-        :param ctx: The `ctx` parameter is typically used in Discord.py, a Python library for creating Discord bots.
-        It represents the context of the command being executed, including information about the message, the server,
-        and the user who invoked the command.
-        """
-        # TODO: Implement deep search logic here
-        query = ctx.message.content.replace("$glebokie_gardlo", "")
-        allowed = False
-        for role in ctx.message.author.roles:
-            if role.name == "Bartender":
-                allowed = True
-            if role.name == "Scribe":
-                allowed = True
-            if role.name == "Thane":
-                allowed = True
-        if not allowed:
-            if ctx.message.author.nick:
-                username = ctx.message.author.nick
-            else:
-                username = ctx.message.author.name
-            vykidailo = False
-            bartender = False
-            prompt = "Przygotuj mi drinka o nazwie Głębokie Gardło, inspirowanego tym sławnym filmem oraz skandalem Watergate"
-            for role in ctx.message.author.roles:
-                if role.name == "Vykidailo":
-                    vykidailo = True
-                if role.name == "Bartender":
-                    bartender = True
-            global MESSAGE_TABLE  # pylint: disable=global-statement
-
-            result, MESSAGE_TABLE = await handle_response(
-                prompt, vykidailo, bartender, MESSAGE_TABLE, username, "GENERAL"
-            )
-            if len(result) < 1500:
-                await ctx.send(result)
-            else:
-                while len(result) > 1500:
-                    await ctx.send(result[:1500])
-                    result = result[1500:]
-            return
-
-        query_uuid = uuid.uuid4()
-        # TODO: TESTING ONLY!!
-        # query_uuid = uuid.UUID('{12345678-1234-5678-1234-567812345678}')
-        json_query = {
-            "UUID": str(query_uuid),
-            "query": str(query),
-            "page": 1,
-            "deep_search": True,
-        }
-        coroutine = asyncio.to_thread(
-            requests.post,
-            f"{LIBRARIAN_SERVICE_ADDRESS}{SEND_QUERY}",
-            json=json_query,
-            headers=SERVICE_HEADERS,
-            timeout=360,
-        )
-        await ctx.send(
-            "*Conjurer mruga okiem i zamiast drinka wyjmuje dysk usb z terminala. Podchodzi do sprytnie ukrytej przy barze rury od poczty pneumatycznej i"
-            + " wrzuca ten dysk do środk* To teraz trza poczekać kilka godzin. TO będzie głębokie wyszukanie"
-            + " Rozgląda się dookoła i stawia przed tobą mętnego drinka o zapachu mięty, gwiezdnego pyłu i oleju silnikowego"
-        )
-        query_response = await coroutine
-        if not query_response.status_code == 200:
-            await ctx.send(
-                "*Z rury wydobywa się dym. Conjurer łapie pierwszą ciecz pod ręką i pryska na rurę. Następuje drobna eksplozja i wszystko zaczyna się palić."
-                + " Conjurer jest skonfundowany..* Wołaj szefa - mam nieodparte wrażenie że się coś wyjebało"
-            )
-            return
-
-        query, query_uuid, queue_size = (
-            query_response.json()["data"][0],
-            query_response.json()["data"][1],
-            query_response.json()["data"][2],
-        )
-        if ctx.message.author.nick:
-            username = ctx.message.author.nick
-        else:
-            username = ctx.message.author.name
-        query_object = QueryControl(username, query_uuid, query, ctx)
-        OUT_COMM_Q.put(query_object)
-        await ctx.send(
-            f"Wypij wypi {query_uuid} - to identyfikator twojego zapytania. Jesteś {queue_size} w kolejce niestety kolejka obowiazuje zawsze."
-            + " Zapytania obsługuje algorytm zasilany czterema chomikami zapierdalającymi w kołowrotku - więc wyniki najwcześniej za kilka godzin - ale mogą być też dni. Głębokie zabawy trwają dłużej. *Znowu mruga*"
-        )
-
-
-async def setup(bot):
-    logger = logging.getLogger("discord")
-    dm = DataModule(bot, "discord")
-    dm.check_data_q.start()
-    await bot.add_cog(dm)
-    logger.info("Loading data sharing commands module done")

librarian_functions.py

@@ -1,28 +0,0 @@
-# pdf_render.py
-import io
-
-try:
-    import fitz  # PyMuPDF
-    _HAS_PYMUPDF = True
-except Exception:
-    _HAS_PYMUPDF = False
-    from pdf2image import convert_from_path
-
-def pdf_page_to_image_bytes(path: str, page_index: int = 0, zoom: float = 2.0, fmt: str = "PNG") -> bytes:
-    """
-    Zwraca bytes obrazka z jednej strony PDF:
-      - PyMuPDF (szybki) jeśli dostępny,
-      - inaczej pdf2image + poppler (wymaga 'pdftoppm').
-    page_index: 0-based
-    """
-    if _HAS_PYMUPDF:
-        doc = fitz.open(path)
-        page = doc.load_page(page_index)
-        mat = fitz.Matrix(zoom, zoom)
-        pix = page.get_pixmap(matrix=mat, alpha=False)
-        return pix.tobytes(fmt.lower())
-    # fallback
-    images = convert_from_path(path, first_page=page_index+1, last_page=page_index+1, fmt=fmt)
-    bio = io.BytesIO()
-    images[0].save(bio, fmt)
-    return bio.getvalue()

manual_set_up_radio.txt

@@ -1,101 +0,0 @@
-# === SYSTEM SETUP ===
-sudo apt update && sudo apt install -y \
-  pulseaudio pulseaudio-utils pavucontrol \
-  libgtk-3-dev gtk-3-examples \
-  xauth dbus-x11 \
-  samba
-
-# === SAMBA CONFIGURATION ===
-sudo nano /etc/samba/smb.conf
-# Add at the end of the file:
-# [RaspberryPiNAS]
-#    path = /home/pi/Public
-#    comment = Pi Share
-#    browseable = yes
-#    writeable = yes
-#    guest ok = no
-#    valid users = pi
-
-# Set permissions
-chmod 755 /home/pi
-mkdir -p /home/pi/Public
-chmod 777 /home/pi/Public
-chown -R pi:pi /home/pi/Public
-
-# Set Samba password for pi
-sudo smbpasswd -a pi
-
-# Restart Samba
-sudo systemctl restart smbd
-
-# === PULSEAUDIO SYSTEM-WIDE SERVICE ===
-sudo nano /etc/systemd/system/pulseaudio.service
-# Paste this content:
-# [Unit]
-# Description=PulseAudio System-wide Daemon
-# After=sound.target network.target
-#
-# [Service]
-# Type=simple
-# ExecStart=/usr/bin/pulseaudio --system --disallow-exit --disallow-module-loading=0 --daemonize=no
-# Restart=always
-#
-# [Install]
-# WantedBy=multi-user.target
-
-# === PULSEAUDIO MODULES FOR LEXICON LAMBDA USB ===
-sudo nano /etc/pulse/system.pa
-# Comment out:
-# load-module module-udev-detect
-# load-module module-detect
-# Add this at the bottom:
-# load-module module-alsa-sink device=hw:1,0 sink_name=LambdaOutput sink_properties=device.description="Lexicon_Lambda_USB_Output"
-# load-module module-alsa-source device=hw:1,0 source_name=LambdaInput source_properties=device.description="Lexicon_Lambda_USB_Input"
-# load-module module-native-protocol-unix auth-anonymous=1 socket=/tmp/pulseaudio.socket
-
-# Set client default socket
-sudo nano /etc/pulse/client.conf
-# Add this line:
-# default-server = unix:/tmp/pulseaudio.socket
-
-# Enable and start PulseAudio system-wide
-sudo systemctl daemon-reload
-sudo systemctl enable pulseaudio.service
-sudo systemctl restart pulseaudio.service
-
-# === X11 & GUI FIXES FOR SSH/MOBAXTERM ===
-sudo nano /etc/ssh/sshd_config
-# Ensure these lines are present:
-# X11Forwarding yes
-# X11UseLocalhost no
-# XAuthLocation /usr/bin/xauth
-
-# Restart SSH
-sudo systemctl restart ssh
-
-# Ensure xauth is installed
-sudo apt install -y xauth
-
-# === BASHRC: MAKE GUI EXPORTS PERSISTENT ===
-nano ~/.bashrc
-# Add this at the end:
-# export GDK_BACKEND=x11
-# export LIBGL_ALWAYS_INDIRECT=1
-# export NO_AT_BRIDGE=1
-# export $(dbus-launch)
-
-# Reload bashrc immediately
-source ~/.bashrc
-
-# === TESTING GUI ===
-# (Reconnect via MobaXterm SSH with X11 forwarding enabled before running below)
-
-# Run pavucontrol GUI
-pavucontrol &
-
-# Optional: Test GTK GUI rendering
-gtk3-demo &
-
-# Check audio devices
-pactl list sinks short
-pactl list sources short

music_commands.py

@@ -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")

music_functions.py

@@ -1,331 +0,0 @@
-import asyncio
-import logging
-import re
-import uuid
-from pathlib import Path, PurePath
-from sys import platform
-
-import discord
-import requests
-
-import yt_dlp
-from constants import (
-    FILE_SERVICE_ADDRESS,
-    GET_MP3,
-    GET_PLAYLIST,
-    MUSIC_FOLDER,
-    SEND_MP3,
-    SPOTIFY_CTRL,
-    YOUTUBE_AUTH,
-    service_headers,
-)
-from spotify_dl import spotify
-from spotify_dl import youtube as youtube_download
-
-SERVICE_HEADERS = service_headers()
-
-
-
-class MusicFileList(object):
-    """
-    The `MusicFileList` class manages a list of music files, with the ability to refresh the list from a
-    file service or local directory and update the list with new items.
-    """
-
-    def __init__(self, logger_name) -> None:
-        self.music_file_list = []
-        self.file_service_active = False
-        self.logger = logging.getLogger("discord")
-
-        self.logger.info("Created Playlist organizer class")
-
-    async def refresh_file_list(self, bot):
-        """
-        The `refresh_file_list` function attempts to connect to a file service to retrieve a list of music
-        files, and if unsuccessful, it populates the list by scanning a local directory for .mp3 files.
-        """
-        try:
-            self.logger.info("Attempt to connect to file service")
-            response = requests.get(
-                f"{FILE_SERVICE_ADDRESS}{GET_MP3}",
-                headers=SERVICE_HEADERS,
-                timeout=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,
-            headers=SERVICE_HEADERS,
-            timeout=360,
-        )
-
-
-MUSIC_FILE_LIST = MusicFileList("discord")
-
-
-async def get_file(ctx, source, link):
-    """
-    Take in three parameters: "ctx" (context),
-    "source" (a string representing the source of the file), and "link" (a string representing the link
-    to the file). Execute it in asynchronouse way. And get file from spotify or youtube.
-
-    :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-    represents the context in which a command is being executed, including information such as the
-    message, the channel, the server, and the user who invoked the command
-    :param source: The source parameter is likely a string that represents the source of the file that
-    the user wants to retrieve. This could be a website, a cloud storage service, or any other location
-    where the file is stored
-    :param link: The "link" parameter is likely a string that represents a URL or file path to the
-    location of the file that the function is trying to retrieve
-    """
-    logger = logging.getLogger("discord")
-    item_id = None
-    item_type = None
-    file_list = []
-    if source == "Spotify":
-        dir_path = None
-        item_type, item_id = spotify.parse_spotify_url(link)
-        if item_type in ["album", "track", "playlist"] and item_id:
-            logger.info(item_type)
-            logger.info(item_id)
-            logger.info("Spotify link provided")
-            file_list = await asyncio.to_thread(
-                spotify.fetch_tracks, SPOTIFY_CTRL, item_type, link
-            )
-            logger.info(file_list)
-            directory_name = await asyncio.to_thread(
-                spotify.get_item_name, SPOTIFY_CTRL, item_type, item_id
-            )
-            logger.info(directory_name)
-            logger.info("Spotify scrape done")
-            url_data = {"urls": []}
-            url_dict = {}
-            url_dict["save_path"] = Path(
-                PurePath.joinpath(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="",
-                YT_AUTH = YOUTUBE_AUTH
-            )
-            _ = await coro
-            logger.info("YT-DL done")
-            dir_path = (url_dict["save_path"].resolve()).as_posix()
-            if platform == "win32":
-                dir_path = dir_path.replace("/", "\\")
-            return dir_path, file_list
-
-        await ctx.send(
-            "No se jaja chyba robisz, Ty byś spotifaja nie poznawszy jakby z krzaków wyskoczył i w dupę kopnął. Plejlista, kawałek albo album prosze."
-        )
-        logger.error("Wrong link provided spotify: %s", link)
-    elif source == "Youtube":
-        link_ok = False
-        pat = r"^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$"
-        if re.match(pat, link) and (
-            re.match(".*youtube.*", link) or re.match(".*youtu.be.*", link)
-        ):
-            link_ok = True
-
-        if link_ok:
-            dir_path = ""
-            file_list = []
-            query = link
-            sponsorblock_postprocessor = [
-                {
-                    "key": "SponsorBlock",
-                    "categories": ["skip_non_music_sections"],
-                },
-                {
-                    "key": "ModifyChapters",
-                    "remove_sponsor_segments": ["music_offtopic"],
-                    "force_keyframes": True,
-                },
-            ]
-            # TODO: Make sponsorblock work
-            sponsorblock_postprocessor = []
-            if platform == "win32":
-                dir_path = "G:\\Muzyka\\Youtube"
-            else:
-                dir_path = "/home/pi/RetroPie/mp3/Youtube"
-            ydl_opts = {
-                "username": YOUTUBE_AUTH[0],
-                "password": YOUTUBE_AUTH[1],
-                "proxy": "",
-                "default_search": "ytsearch",
-                "format": "bestaudio/best",
-                "postprocessors": sponsorblock_postprocessor,
-                "noplaylist": True,
-                "no_color": False,
-                "paths": {"home": dir_path},
-            }
-            mp3_postprocess_opts = {
-                "key": "FFmpegExtractAudio",
-                "preferredcodec": "mp3",
-                "preferredquality": "192",
-            }
-            ydl_opts["postprocessors"].append(mp3_postprocess_opts.copy())
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                try:
-                    coro = asyncio.to_thread(ydl.download, [query])
-                    _ = await coro
-                except Exception as exce:  # pylint: disable=broad-exception-caught
-                    logger.error(exce)
-                    logger.info(
-                        "Failed to download %s, make sure yt_dlp is up to date", link
-                    )
-            extract = re.search("v=(...........)[&,$]*", link)
-            ident = extract.group(1)
-            for item in Path.glob(Path(dir_path), "**/*.mp3"):
-                file = item.as_posix()
-                if platform == "win32":
-                    file = file.replace("/", "\\")
-                if re.match(".*" + ident + ".*", file):
-                    file_list.append(file)
-            return dir_path, file_list
-        await ctx.send(
-            "No se jaja chyba robisz, Ty byś jutuba nie poznawszy jakby z krzaków wyskoczył i w dupę kopnął. Jutuba to nie tuba którą sobie można gdzieś wsadzić."
-        )
-        logger.error("Wrong link provided youtube: %s", link)
-        return "", None
-    elif source == "Pornol":
-
-        dir_path = ""
-        file_list = []
-        query = link
-        sponsorblock_postprocessor = [
-            {
-                "key": "SponsorBlock",
-                "categories": ["skip_non_music_sections"],
-            },
-            {
-                "key": "ModifyChapters",
-                "remove_sponsor_segments": ["music_offtopic"],
-                "force_keyframes": True,
-            },
-        ]
-        # TODO: Make sponsorblock work
-        sponsorblock_postprocessor = []
-        dir_path = "/home/pi/MediaShare/movies/porn"
-        ydl_opts = {
-            "postprocessors": sponsorblock_postprocessor,
-            "paths": {"home": dir_path},
-        }
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            try:
-                coro = asyncio.to_thread(ydl.download, [query])
-                _ = await coro
-            except Exception as exce:  # pylint: disable=broad-exception-caught
-                logger.error(exce)
-                logger.info(
-                    "Failed to download %s, make sure yt_dlp is up to date", link
-                )
-        file_list.append("wiadomo co wiadomo gdzie")
-        return dir_path, file_list
-
-
-async def search_music(ctx, how_many=0, slowa_kluczowe=None):
-    """
-    Take in a context object and an optional integer parameter "how_many" and perform search
-    operation on music library.
-
-    :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-    represents the context in which the command was invoked, including information such as the message,
-    the channel, the server, and the user who invoked the command
-    :param how_many: how_many is a parameter that specifies the number of search results to be returned.
-    It is an optional parameter with a default value of 0, which means that if no value is provided for
-    how_many, the function will return all search results, defaults to 0 (optional)
-    """
-    # i sieć neuronową z możliwością wyrażenia opinii o dopasowaniu.
-    logger = logging.getLogger("discord")
-    if slowa_kluczowe:
-        word_list = slowa_kluczowe
-    else:
-        word_list = ctx.message.content.split()
-    logger.info("Wyszukuje")
-    jrequest = {
-        "lista_slow": word_list,
-        "dlugosc_plejlisty": how_many,
-        "UUID": str(uuid.uuid4()),
-    }
-    coroutine = asyncio.to_thread(
-        requests.post,
-        f"{FILE_SERVICE_ADDRESS}{GET_PLAYLIST}",
-        json=jrequest,
-        headers=SERVICE_HEADERS,
-        timeout=360,
-    )
-    return_data = await coroutine
-    if not return_data.status_code == 200:
-        await ctx.send("Wołaj szefa - coś się wyjebało")
-        return
-    logger.info(return_data.json()["data"])
-    return return_data.json()["data"]

other_commands.py

@@ -1,212 +0,0 @@
-import asyncio
-import json
-import logging
-from datetime import datetime
-from typing import Optional
-
-import discord
-from discord.ext import commands
-
-from constants import ACCIDENT_LOG, DATA, ENCODING
-
-historia_fabryczki = DATA["fabryczka"]
-
-
-class OtherModule(commands.Cog):
-    def __init__(self, bot, logger_name):
-        self.bot = bot
-        self.logger = logging.getLogger(logger_name)
-
-    @commands.hybrid_command(
-        name="przytul", description="Przytul kogoś - daj mention po komendzie :)"
-    )
-    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
-    async def przytul(self, ctx, arg: Optional[discord.Member] = None):
-        """
-        Generate a text about hugging mentioned user.
-
-        :param ctx: ctx stands for "context" and is a required parameter in Discord.py commands. It
-        represents the context in which the command was invoked, including information such as the message,
-        the channel, the server, and the user who invoked the command
-        :param arg: arg is a parameter of the function "przytul" that expects a Discord member object. The
-        parameter is optional, meaning that if no member object is provided, it will default to None
-        :type arg: Optional[discord.Member]
-        """
-        async with ctx.typing():
-            nieprzytulac = False
-            for mention in ctx.message.mentions:
-                for role in mention.roles:
-                    if role.name == "NIEPRZYTULAĆ!":
-                        nieprzytulac = True
-
-            if arg and nieprzytulac:
-                await ctx.send(
-                    f"Żebym ja Ciebie nie przytulił {ctx.message.author.mention}"
-                )
-            elif arg:
-                await ctx.send(
-                    # trunk-ignore(codespell/misspelled)
-                    f"Już dobrze.... Już dobrze... Ojej.. Biedactwo... :( *W ułamku sekundy {arg.mention} znajduje sie w duszącym uścisku. Żebra trzeszczą - kilka pęka. Pacnięcia po plecach grożą odbiciem nerek, a głaskanie po głowie powoduje wstrząs mózgu*"
-                )
-            else:
-                await ctx.send(
-                    "Kogo mam przytulić? *Wyłamuje kostki i przeciąga się - jego 200 kilowa sylwetka złożona z samych mięśni świadczy o tym że jest gotowy*"
-                )
-
-    @commands.hybrid_command(name="fabryczka", description="Historia fabryczki")
-    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
-    async def fabryczka(self, ctx):
-        """
-        Send a general description of "fabryczkagate" to channel.
-
-        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-        represents the context in which the command was invoked, including information such as the message,
-        the channel, the server, and the user who invoked the command. The context object provides a way to
-        interact with the Discord
-        """
-        await ctx.send(historia_fabryczki)
-
-    @commands.hybrid_command(
-        name="set_logging_level",
-        description="Nie intererer bo kici kici",
-        guild=discord.Object(id=664789470779932693),
-    )
-    @commands.has_any_role('Legenda', 'Jarl', 'Bartender')
-    async def set_logging_level(self,ctx):
-        if "DEBUG" in ctx.message.content:
-            logger = logging.getLogger("discord")
-            logger.setLevel(logging.DEBUG)
-        elif "INFO" in ctx.message.content:
-            logger = logging.getLogger("discord")
-            logger.setLevel(logging.INFO)
-        else:
-            await ctx.send("Weź się kurwa zdecyduj co ?")
-
-    @commands.hybrid_command(
-        name="reset_the_clock",
-        description="Resetowanie zegara - dostępne wyłącznie dla Hammera",
-        guild=discord.Object(id=664789470779932693),
-    )
-    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
-    async def reset_the_clock(self, ctx):
-        """
-        Reset the clock on "accidents" in Hammer Fortress adding a new one.
-
-        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-        represents the context in which the command was invoked, including information such as the message,
-        the channel, the server, and the user who invoked the command. This parameter is required in all
-        Discord.py commands
-        """
-        hammer = False
-        for role in ctx.message.author.roles:
-            if role.name == "Bartender":
-                hammer = True
-        if hammer:
-            with open(ACCIDENT_LOG, "r+", encoding=ENCODING) as new_file_accidents:
-                # First we load existing data into a dict.
-                file_data = json.load(new_file_accidents)
-                czas = datetime.strptime(file_data[-1][1], "%Y-%m-%d %H:%M:%S.%f")
-                opis = ctx.message.content[16:]
-                accident = accident = [opis, f"{datetime.now()}"]
-                file_data.append(accident)
-                new_file_accidents.seek(0)
-                # convert back to json.
-                json.dump(file_data, new_file_accidents, indent=4)
-                await ctx.send(
-                    f"Komenda mierząca incydenty w Eldritch AbsinthHammerTimeSpaceContinuum.\n RESET THE CLOCK. Od ostatniego incydentu w chacie Hammera minęło {czas}. No ale teraz się odpierdoliło: {opis}"
-                )
-        else:
-            await ctx.send(
-                f"Komenda mierząca incydenty w Eldritch AbsinthHammerTimeSpaceContinuum.\n Gdzie z łapami do zegara? {self.bot.get_user(346956223645614080).mention} coś albo się komuś stało albo zaraz się stanie jak będzie zegar tykał...."
-            )
-
-    @commands.hybrid_command(
-        name="chata_hammera",
-        description="Czas od ostatniego incydentu w AbsinthHammerTimeSpaceContinuum",
-    )
-    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
-    async def chata_hammera(self, ctx):
-        """
-        Send measured time from last incident in Hammer Fortress to the chat.
-
-        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-        contains information about the context in which the command was invoked, such as the message, the
-        channel, the server, and the user who invoked the command. This information can be used to perform
-        various actions, such
-        """
-        with open(ACCIDENT_LOG, "r+", encoding=ENCODING) as new_file:
-            # First we load existing data into a dict.
-            file_data = json.load(new_file)
-            opis = file_data[-1][0]
-            czas = datetime.strptime(file_data[-1][1], "%Y-%m-%d %H:%M:%S.%f")
-            await ctx.send(
-                f"Komenda mierząca incydenty w Eldritch AbsinthHammerTimeSpaceContinuum.\n Od ostatniego incydentu w chacie Hammera minęło {datetime.now() - czas}. Incydent to: {opis}"
-            )
-
-    @commands.hybrid_command(
-        name="historia_incydentow_u_hammera",
-        description="Wyswietla liste incydentów które miały miejsce w AbsinthHammerTimeSpaceContinuum.",
-    )
-    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
-    async def historia_incydentow_u_hammera(self, ctx):
-        """
-        Send a list of incidents in Hammer Fortress to the chat.
-
-        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-        contains information about the context in which the command was invoked, such as the message, the
-        channel, the server, and the user who invoked the command. This information can be used to perform
-        various actions, such
-        """
-        with open(ACCIDENT_LOG, "r+", encoding=ENCODING) as new_file_accidents:
-            # First we load existing data into a dict.
-            file_data = json.load(new_file_accidents)
-            return_data = "Komenda mierząca incydenty w Eldritch AbsinthHammerTimeSpaceContinuum.\n Historia zarejestrownych incydentów u Hammera:\n"
-            index = 1
-            for iter_data in file_data:
-                opis = iter_data[0]
-                czas = datetime.strptime(iter_data[1], "%Y-%m-%d %H:%M:%S.%f")
-                add_data = f"{index}. Opis: {opis} Data: {czas}"
-                return_data = return_data + add_data + "\n"
-                index += 1
-            await ctx.send(return_data)
-
-    @commands.hybrid_command(
-        name="radio_hardkor",
-        description="Włącza radio Conjurer na kanale #nocna-zmiana.",
-        guild=discord.Object(id=664789470779932693),
-    )
-    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
-    async def radio_hardkor(self, ctx):
-        """
-        Plays the radio hardkor stream in the voice channel.
-
-        Args:
-            ctx: The context object representing the invocation context.
-
-        Returns:
-            None
-        """
-        self.logger.info("Press play on radio hardkor")
-        async with ctx.typing():
-            global MUZYKA  # pylint: disable=global-variable-not-assigned
-            MUZYKA["ctx"] = ctx
-            if not self.bot.voice_clients:
-                await self.connect(ctx=ctx)
-                voice_client = self.bot.voice_clients[0]
-                voice_client.play(
-                    discord.PCMVolumeTransformer(
-                        discord.FFmpegPCMAudio("http://95.175.16.246:666/mp3-stream"),
-                        volume=0.3,
-                    )
-                )
-                self.logger.info("Press play on radio completed")
-            else:
-                self.logger.error("Already playing")
-            await asyncio.sleep(12)
-            self.check_music.start()
-
-
-async def setup(bot):
-    logger = logging.getLogger("discord")
-    await bot.add_cog(OtherModule(bot, "discord"))
-    logger.info("Loading kitchen sink module done")

other_functions.py

@@ -1,118 +0,0 @@
-import logging
-# define an asynchronous generator
-
-async def async_iterator_generator(range_of_iterable):
-    """
-    Generate asynchronouse iterator.
-    This is an incomplete function definition for an asynchronous iterator generator that takes a range
-    of iterable as input.
-
-    :param range_of_iterable: The parameter `range_of_iterable` is likely a range or iterable object
-    that the async iterator generator will iterate over asynchronously. It could be a list, tuple, set,
-    or any other iterable object. The generator will yield each item in the iterable object
-    asynchronously, allowing other code to run in between
-    """
-    # normal loop
-    for i in range_of_iterable:
-        # pylint: disable=pointless-string-statement
-        # yield the result
-        yield i
-        """
-        Alternatywna wersja przerobienia fora na asynchroniczny.
-        # traverse the iterable of awaitables
-        for item in coros:
-            # await and get the result from the awaitable
-            result = await item
-            # report the results
-            print(result)
-        """
-
-
-async def remove_characters(string, character):
-    """
-    The `remove_characters` function removes all occurrences of a specified character from a given
-    string.
-
-    :param string: The string parameter is the input string from which characters will be removed
-    :param character: The character parameter is the character that you want to remove from the string
-    :return: a new string where all occurrences of the specified character have been removed.
-    """
-    return string.replace(character, "")
-
-
-async def max_weight(lista):
-    """
-    Take a list of weights and return the maximum weight.
-
-    :param lista: It seems like the parameter `lista` is a list of items, possibly representing weights.
-    The function name `max_weight` suggests that the function is intended to find the maximum weight
-    from the list. However, without more context or information about the problem, it's difficult to say
-    for sure what the
-    """
-    maximum_weight = 0
-    for iterator in lista:
-        if iterator[0] > maximum_weight:
-            maximum_weight = iterator[0]
-    return maximum_weight
-
-
-async def get_stats(client, ctx, history_limit):
-    """
-    The `get_stats` function retrieves the message history of a specific channel and counts the
-    frequency of each word in the messages.
-
-    :param ctx: The `ctx` parameter is an object that represents the context of the command being
-    executed. It contains information such as the message, the author, the server, and other relevant
-    details
-    :param history_limit: The `history_limit` parameter is the maximum number of messages to retrieve
-    from the channel history. It determines how far back in time the statistics will be calculated
-    :return: The function `get_stats` returns a dictionary `stats` that contains the frequency count of
-    words found in the messages from the specified channel.
-    """
-    channel_id = 1062047367337095268
-    async with ctx.typing():
-        stats = {}
-        channel = client.get_channel(channel_id)
-        messages = [message async for message in channel.history(limit=history_limit)]
-        # traverse the iterable of awaitables
-        for message in messages:
-            # await and get the result from the awaitable
-            result = message.content
-            words = result.split()
-            for word in words:
-                if word in stats:
-                    stats[word] += 1
-                else:
-                    stats[word] = 1
-        for name, how_many in stats.items():
-            yield name, how_many
-
-async def discord_friendly_reply(ctx, message_content, file=None):
-    logger = logging.getLogger("discord")
-
-    if len(message_content) < 999:
-        logger.info("Answer reply - message below 999")
-        await ctx.reply(message_content)
-    else:
-        logger.info("Answer reply - message above 999")
-        while len(message_content) > 0:
-            logger.info("Mesaage content: %s", message_content[:999])
-            await ctx.reply(message_content[:999])
-            message_content = message_content[999:]
-    if file:
-        await ctx.reply("Attachment:", file=file)
-
-async def discord_friendly_send(ctx, message_content, file=None):
-    logger = logging.getLogger("discord")
-
-    if len(message_content) < 999:
-        logger.info("Answer send - message below 999")
-        await ctx.send(message_content)
-    else:
-        logger.info("Answer send - message above 999")
-        while len(message_content) > 0:
-            logger.info("Mesaage content: %s", message_content[:999])
-            await ctx.send(message_content[:999])
-            message_content = message_content[999:]
-    if file:
-        await ctx.reply("Attachment:", file=file)

pamiec.json

@@ -234,21 +234,5 @@
     {
         "role": "assistant",
         "content": "Jakich konkretnych informacji mam si\u0119 douczy\u0107? Jestem tu po to, aby Ci pom\u00f3c, wi\u0119c jestem otwarty na uzupe\u0142nienie swojej wiedzy w dowolnym zakresie, o ile tylko nie \u0142amie to zasad regulaminu i etyki."
-    },
-    {
-        "role": "user",
-        "content": "The Bartender [S\u0142o\u0144ce z Betonu]:@Conjurer halo ?"
-    },
-    {
-        "role": "assistant",
-        "content": "*Kondziu patrzy na terminal* Wo\u0142aj szefa. Zap\u0142aci\u0107 rachunki za AI trzeba. Jak chcesz to si\u0119 na #zebranie dorzu\u0107. Error code: 429 - {'error': {'message': 'You exceeded your current quota, please check your plan and billing details. For more information on this error, read the docs: https://platform.openai.com/docs/guides/error-codes/api-errors.', 'type': 'insufficient_quota', 'param': None, 'code': 'insufficient_quota'}}"
-    },
-    {
-        "role": "user",
-        "content": "The Bartender [S\u0142o\u0144ce z Betonu]:helo\u0142 @Nocna Zmiana dwie wiadomo\u015bci dobra i jeszcze gorsza.\n@Conjurer zosta\u0142 zreanimowany po d\u0142u\u017cszej nieobecno\u015bci - ale jak zaraz sami zobaczycie je\u015b\u0107 wo\u0142a. nie dzia\u0142a w nim te\u017c jeszcze wyszukiwanie artyku\u0142\u00f3w naukowych (do tego trzy tygodnie developmentu posz\u0142y w p*****ec). wyszukiwarka wr\u00f3ci jak dotrze zam\u00f3wienie z kieszeniami na dysk @gwojtal - bedzie trzeba \u015bci\u0105gn\u0105\u0107 snapshot bazy i uruchomi\u0107 cz\u0119\u015b\u0107 odpowiedzialn\u0105 za wyszukiwanie w nim. specjalne funkcje b\u0119d\u0119 odblokowywa\u0142 w miare ich naprawiania - tak samo dam mu oczywi\u015bcie je\u015b\u0107 z w\u0142asnej kieszeni jak ju\u017c b\u0119dzie potrzeba."
-    },
-    {
-        "role": "assistant",
-        "content": "*Kondziu patrzy na terminal* Wo\u0142aj szefa. Zap\u0142aci\u0107 rachunki za AI trzeba. Jak chcesz to si\u0119 na #zebranie dorzu\u0107. Error code: 429 - {'error': {'message': 'You exceeded your current quota, please check your plan and billing details. For more information on this error, read the docs: https://platform.openai.com/docs/guides/error-codes/api-errors.', 'type': 'insufficient_quota', 'param': None, 'code': 'insufficient_quota'}}"
     }
 ]

pamiec_muzyki.json

@@ -787,4 +787,4 @@
         "role": "assistant",
         "content": "\"Coffin Fodder\" to utw\u00f3r z albumu \"Nymphetamine\" brytyjskiego zespo\u0142u Cradle Of Filth. To  death-metalowe brzmienie z elementami black metalu i gotyckiego rocka. \n\nTekst utworu to prowokacyjne po\u0142\u0105czenie j\u0119zyka poetyckiego z drastycznymi opisami \u015bmierci i ciemn\u0105 estetyk\u0105, charakterystyczn\u0105 dla tw\u00f3rczo\u015bci Cradle Of Filth. \n\n\"Coffin Fodder\" opowiada histori\u0119 mordercy zabijaj\u0105cego kobiety i wk\u0142adaj\u0105cego ich cia\u0142a do trumien, aby zaspokoi\u0107 swoje mroczne i okrutne pragnienia. To utw\u00f3r pe\u0142en brutalnych opis\u00f3w, kt\u00f3rych celem jest szokowanie i wywo\u0142anie wstr\u0119tu w s\u0142uchaczu. \n\nPod wzgl\u0119dem muzycznym, \"Coffin Fodder\" charakteryzuje si\u0119 szybkim tempem, ci\u0119\u017ckimi riffami gitary i intensywnymi partiami perkusyjnymi. Utw\u00f3r jest jednym z bardziej ekstremalnych utwor\u00f3w zespo\u0142u Cradle Of Filth, co czyni go atrakcyjnym dla mi\u0142o\u015bnik\u00f3w mocnej i agresywnej muzyki metalowej."
     }
-]
+]

patriotyczna_krotka.playlist

@@ -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

playlista11.11.playlist

@@ -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

pulseaudio.service

@@ -1,11 +0,0 @@
-[Unit]
-Description=PulseAudio System-wide Daemon
-After=sound.target network.target
-
-[Service]
-Type=simple
-ExecStart=/usr/bin/pulseaudio --system --disallow-exit --disallow-module-loading=0 --daemonize=no
-Restart=always
-
-[Install]
-WantedBy=multi-user.target

radio_commands.py

@@ -1,214 +0,0 @@
-import logging
-from discord.ext import commands
-import discord
-# trunk-ignore(bandit/B404)
-import subprocess
-import requests
-import uuid
-
-import asyncio
-from datetime import datetime
-from constants import RADIO_HARBOR_ADDRESS, SKIP_TRACK, FILE_SERVICE_ADDRESS, ADD_TO_PRIO_PLAYLIST, REQUEST_MUSIC, CREATE_PRIO_PLAYLIST, CLEAR_PRIO, service_headers
-
-SERVICE_HEADERS = service_headers()
-
-class RadioModule(commands.Cog):
-    def __init__(self, bot, logger_name):
-        self.bot = bot
-        self.logger = logging.getLogger(logger_name)
-
-
-    @commands.hybrid_command(
-        name="skip_track",
-        description="Przeskocz kawałek w radiu",
-        guild=discord.Object(id=664789470779932693),
-    )
-    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
-    async def skip_track(self, ctx):
-        async with ctx.typing():
-            allowed = False
-            for role in ctx.author.roles:
-                if role.name in ("Thane", "Jarl"):
-                    allowed = True
-            if not allowed:
-                await ctx.send("Łapy precz od radia")
-            else:
-                coroutine = asyncio.to_thread(
-                    requests.get,
-                    f"{RADIO_HARBOR_ADDRESS}{SKIP_TRACK}",
-                    headers=SERVICE_HEADERS,
-                    timeout=360,
-                )
-                result = await coroutine
-                self.logger.info("Done %s", result)
-                await ctx.send("Zrobione szefie!")
-
-
-    @commands.hybrid_command(
-        name="zrestartuj_radio",
-        description="Komenda ktora uruchamia radio ponownie jakby się zawiesiło",
-        guild=discord.Object(id=664789470779932693),
-    )
-    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
-    async def zrestartuj_radio(self, ctx):
-        async with ctx.typing():
-            allowed = False
-            for role in ctx.author.roles:
-                if role.name in ("Thane", "Jarl"):
-                    allowed = True
-            if not allowed:
-                await ctx.send("Łapy precz od radia")
-            else:
-                retcode = subprocess.run(
-                    "/home/pi/Conjurer/restart_radio.sh",
-                    # trunk-ignore(bandit/B603)
-                    shell=False,
-                    check=False,
-                    capture_output=True,
-                )
-                self.logger.info("Wynik: %s", retcode)
-
-    @commands.hybrid_command(
-        name="dodaj_do_ulubionych",
-        description="Dodaje do listy ulubionych w radiu",
-        guild=discord.Object(id=664789470779932693),
-    )
-    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
-    async def dodaj_do_ulubionych(self, ctx):
-        """
-        Generate a playlist in queue. First word in this command shall be int defining length of the playlist.
-        Rest of the line are search terms.
-
-        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-        represents the context in which the command was invoked, including information such as the message,
-        the channel, the server, and the user who invoked the command. This parameter is required in all
-        Discord.py commands
-        """
-        async with ctx.typing():
-            self.logger.info("Zaczynam szukać timestamp %s", datetime.now())
-
-            dlugosc_playlisty = ctx.message.content.split()[1]
-            word_list = ctx.message.content.split()
-            jrequest = {
-                "lista_slow": word_list,
-                "dlugosc_plejlisty": dlugosc_playlisty,
-                "UUID": str(uuid.uuid4()),
-            }
-            coroutine = asyncio.to_thread(
-                requests.post,
-                f"{FILE_SERVICE_ADDRESS}{ADD_TO_PRIO_PLAYLIST}",
-                json=jrequest,
-                headers=SERVICE_HEADERS,
-                timeout=360,
-            )
-            result = await coroutine
-            self.logger.info("Done %s", result)
-            await ctx.send("Zrobione szefie!")
-
-
-    @commands.hybrid_command(
-        name="ja_chciol",
-        description="Dodaje do listy ulubionych w radiu",
-        guild=discord.Object(id=664789470779932693),
-    )
-    @commands.has_any_role('Nocna Zmiana', 'Jarl', 'Thane' , 'Bartender')
-    async def request_radio(self, ctx):
-        """
-        Generate a playlist in queue. First word in this command shall be int defining length of the playlist.
-        Rest of the line are search terms.
-
-        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-        represents the context in which the command was invoked, including information such as the message,
-        the channel, the server, and the user who invoked the command. This parameter is required in all
-        Discord.py commands
-        """
-        async with ctx.typing():
-            self.logger.info("Zaczynam szukać timestamp %s", datetime.now())
-
-            word_list = ctx.message.content.split()
-            jrequest = {
-                "lista_slow": word_list,
-                "UUID": str(uuid.uuid4()),
-            }
-            coroutine = asyncio.to_thread(
-                requests.post,
-                f"{FILE_SERVICE_ADDRESS}{REQUEST_MUSIC}",
-                json=jrequest,
-                headers=SERVICE_HEADERS,
-                timeout=360,
-            )
-            result = await coroutine
-            self.logger.info("Done %s", result)
-            await ctx.send("Zrobione szefie!")
-
-
-    @commands.hybrid_command(
-        name="stworz_audycje",
-        description="Dodaje do listy ulubionych w radiu",
-        guild=discord.Object(id=664789470779932693),
-    )
-    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
-    async def stworz_audycje(self, ctx):
-        """
-        Generate a playlist in queue. First word in this command shall be int defining length of the playlist.
-        Rest of the line are search terms.
-
-        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-        represents the context in which the command was invoked, including information such as the message,
-        the channel, the server, and the user who invoked the command. This parameter is required in all
-        Discord.py commands
-        """
-        async with ctx.typing():
-            self.logger.info("Zaczynam szukać timestamp %s", datetime.now())
-
-            dlugosc_playlisty = ctx.message.content.split()[1]
-            word_list = ctx.message.content.split()
-            jrequest = {
-                "lista_slow": word_list,
-                "dlugosc_plejlisty": dlugosc_playlisty,
-                "UUID": str(uuid.uuid4()),
-            }
-            coroutine = asyncio.to_thread(
-                requests.post,
-                f"{FILE_SERVICE_ADDRESS}{CREATE_PRIO_PLAYLIST}",
-                json=jrequest,
-                headers=SERVICE_HEADERS,
-                timeout=360,
-            )
-            result = await coroutine
-            self.logger.info("Done %s", result)
-            await ctx.send("Zrobione szefie!")
-
-
-    @commands.hybrid_command(
-        name="wyczysc_ulubione",
-        description="Czysci liste ulubionych w radiu",
-        guild=discord.Object(id=664789470779932693),
-    )
-    @commands.has_any_role('Legenda', 'Jarl', 'Thane' , 'Bartender')
-    async def wyczysc_ulubione(self, ctx):
-        """
-        Generate a playlist in queue. First word in this command shall be int defining length of the playlist.
-        Rest of the line are search terms.
-
-        :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-        represents the context in which the command was invoked, including information such as the message,
-        the channel, the server, and the user who invoked the command. This parameter is required in all
-        Discord.py commands
-        """
-        async with ctx.typing():
-            coroutine = asyncio.to_thread(
-                requests.get,
-                f"{FILE_SERVICE_ADDRESS}{CLEAR_PRIO}",
-                headers=SERVICE_HEADERS,
-                timeout=360,
-            )
-            result = await coroutine
-            self.logger.info("Done %s", result)
-            await ctx.send("Zrobione szefie!")
-
-
-async def setup(bot):
-    logger = logging.getLogger("discord")
-    await bot.add_cog(RadioModule(bot, "discord"))
-    logger.info("Loading raadio commands module done")

requirements_bot.txt

@@ -1,4 +1,3 @@
-setuptools
 discord
 yt_dlp
 spotify_dl
@@ -12,11 +11,5 @@ requests
 spotipy
 tiktoken
 PyNaCl
-flask[async]
-PyMuPDF
-waitress
-assemblyai[extras]
-SpeechRecognition
-aiomcrcon
-asyncssh
-git+https://github.com/imayhaveborkedit/discord-ext-voice-recv
+flask
+waitress

restart_radio.sh

@@ -1,3 +0,0 @@
-sshpass -p raspberry ssh pi@192.168.1.15 << 'ENDSSH'
-sudo reboot
-ENDSSH

s_results.json

@@ -0,0 +1 @@
+{"12345678-1234-5678-1234-567812345678": [{"DOI": "10.1057/9781137435026", "title": ["Queer BDSM Intimacies"], "type": "book", "container": "NO"}]}

settings.json

@@ -22,6 +22,20 @@
             false,
             false
         ],
+        "indie\\b": [
+            "Indie? *Wyciąga rewolwerową wyrzutnię taktycznych bomb jądrowych* Gdzie??? *Zaczyna się maniakalnie śmiać*",
+            15.0,
+            0,
+            false,
+            false
+        ],
+        "hindus": [
+            "Hindus? Gdzie.... *Wyciąga spod lady ciężki miotacz płomieni i zaczyna się maniakalnie śmiać*",
+            15.0,
+            0,
+            false,
+            false
+        ],
         "chuj\\b": [
             "Eeeee.... Szefie... ktoś cię woła! Wskazuje na Hammera",
             15.0,
@@ -85,6 +99,27 @@
             false,
             false
         ],
+        "tatarek\\b": [
+            "Tatarek? Nie dramatyzuj....",
+            15.0,
+            0,
+            false,
+            false
+        ],
+        "krowa\\b": [
+            "Krówka? Nie dramatyzuj....",
+            15.0,
+            0,
+            false,
+            false
+        ],
+        "krówka\\b": [
+            "Krówka? Nie dramatyzuj....",
+            15.0,
+            0,
+            false,
+            false
+        ],
         "jessenia\\b": [
             "Jessenia? Jak przyszła tu w różowej pidżamie z uszkami to nawet nie mrugnąłem okiem. Te oczy.... No ale jakiś debil Ją prowokował mówiąc \"Zdominuj mnie\" Akurat miała dobry humor więc przeżył - ale po 115.0 sekundach był już na \"Tak Pani, przepraszam że zająłem czas Pani\" Respect dla kobitki",
             15.0,
@@ -155,8 +190,15 @@
             false,
             false
         ],
-        "same plusy\\b": [
-            "Jak na cmentarzu Szefie. Jak na cmentarzu",
+        "elokwentna\\b": [
+            "O matko. Znowu ta dyskusja? Hammer ma stary słownik gdzie elokwentna i pyskata są praktycznie synonimami. Jedyna różnica że swojej uległej można za bycie pyskatym dać po dupie.",
+            15.0,
+            0,
+            false,
+            false
+        ],
+        "elokwencja\\b": [
+            "O matko. Znowu ta dyskusja? Hammer ma stary słownik gdzie elokwentna i pyskata są praktycznie synonimami. Jedyna różnica że swojej uległej można za bycie pyskatym dać po dupie.",
             15.0,
             0,
             false,
@@ -204,6 +246,13 @@
             false,
             false
         ],
+        "fallain\\b": [
+            "Kochana Krówka. Skłonność do dramatów i zakrwawiania ścian. Jedna z kilku NAPRAWDE srogich masochistek... Ach ta krew :drool:",
+            15.0,
+            0,
+            false,
+            false
+        ],
         "roar": [
             "Kici, kici....",
             15.0,
@@ -260,6 +309,13 @@
             false,
             true
         ],
+        "revalyacyjnie\\b": [
+            "Zajebisty dowcip szefie. Na pewno się \"Twojej Byłej Dziewczynie\":tm: spodoba.",
+            15.0,
+            0,
+            false,
+            true
+        ],
         "nocna zmiana\\b": [
             "Nocna Zmiana? No to właściciele tego baru. Taki troche Hammer Harema. Kto to jest Harem>? Łokurwa. Harem Hammera. Ale on tu robi za jedyną hurysę, a reszta to szejkowie. Tak zrobię Ci szejka.",
             15.0,

spotify_dl/__init__.py

@@ -8,7 +8,5 @@ def signal_handler(sig, frame):
     print("\nCaught interrupt(did you press Ctrl+C?), stopping spotify_dl")
     sys.exit(0)
 
-try:
-    signal.signal(signal.SIGINT, signal_handler)
-except ValueError:
-    print("Exception in signal handler")
+
+signal.signal(signal.SIGINT, signal_handler)

spotify_dl/constants.py

@@ -3,7 +3,7 @@ from pathlib import Path
 
 __all__ = ["VERSION"]
 
-VERSION = "8.9.0"
+VERSION = "8.8.1"
 
 if os.getenv("XDG_CACHE_HOME") is not None:
     SAVE_PATH = os.getenv("XDG_CACHE_HOME") + "/spotifydl"

spotify_dl/spotify.py

@@ -1,17 +1,15 @@
-
 import sys
-import logging
 from spotify_dl.scaffold import log
 from spotify_dl.utils import sanitize
 from rich.progress import Progress
 
 
-def fetch_tracks(sp, item_type, item_id):
+def fetch_tracks(sp, item_type, url):
     """
-    Fetches tracks from the provided item_id.
+    Fetches tracks from the provided URL.
     :param sp: Spotify client
     :param item_type: Type of item being requested for: album/playlist/track
-    :param item_id: id of the item
+    :param url: URL of the item
     :return Dictionary of song and artist
     """
     songs_list = []
@@ -19,14 +17,11 @@ def fetch_tracks(sp, item_type, item_id):
     songs_fetched = 0
 
     if item_type == "playlist":
-        logger =  logging.getLogger("discord")
-        
-        logger.info("Playlist")
         with Progress() as progress:
             songs_task = progress.add_task(description="Fetching songs from playlist..")
             while True:
                 items = sp.playlist_items(
-                    playlist_id=item_id,
+                    playlist_id=url,
                     fields="items.track.name,items.track.artists(name, uri),"
                     "items.track.album(name, release_date, total_tracks, images),"
                     "items.track.track_number,total, next,offset,"
@@ -35,7 +30,6 @@ def fetch_tracks(sp, item_type, item_id):
                     offset=offset,
                 )
                 total_songs = items.get("total")
-                logger.info(total_songs)
                 track_info_task = progress.add_task(
                     description="Fetching track info", total=len(items["items"])
                 )
@@ -43,32 +37,16 @@ def fetch_tracks(sp, item_type, item_id):
                     track_info = item.get("track")
                     # If the user has a podcast in their playlist, there will be no track
                     # Without this conditional, the program will fail later on when the metadata is fetched
-                    logger.info(item)
                     if track_info is None:
                         offset += 1
                         continue
-                    if not track_info.get("artists")[0]["name"]:
-                       offset +=1
-                       continue
                     track_album_info = track_info.get("album")
                     track_num = track_info.get("track_number")
-                    track_name = track_info.get("name")
                     spotify_id = track_info.get("id")
-                    track_audio_data = "No audio data"
-                    try:
-                        track_audio_data = sp.audio_analysis(spotify_id)
-                        tempo = track_audio_data.get("track").get("tempo")
-                    except:
-                        log.error("Couldn't fetch audio analysis for %s", track_name)
-                        tempo = None
-                    print(track_info.get("artists"))
-                    print(track_audio_data)
-                    track_artist = ""
-                    for artist in track_info.get("artists"):
-                        if artist["name"]:
-                            track_artist = ", ".join(
-                                [artist["name"]]
-                            )
+                    track_name = track_info.get("name")
+                    track_artist = ", ".join(
+                        [artist["name"] for artist in track_info.get("artists")]
+                    )
                     if track_album_info:
                         track_album = track_album_info.get("name")
                         track_year = (
@@ -108,7 +86,6 @@ def fetch_tracks(sp, item_type, item_id):
                             "genre": genre,
                             "spotify_id": spotify_id,
                             "track_url": None,
-                            "tempo": tempo,
                         }
                     )
                     offset += 1
@@ -134,8 +111,8 @@ def fetch_tracks(sp, item_type, item_id):
                 description="Fetching songs from the album.."
             )
             while True:
-                album_info = sp.album(album_id=item_id)
-                items = sp.album_tracks(album_id=item_id, offset=offset)
+                album_info = sp.album(album_id=url)
+                items = sp.album_tracks(album_id=url, offset=offset)
                 total_songs = items.get("total")
                 track_album = album_info.get("name")
                 track_year = (
@@ -164,12 +141,6 @@ def fetch_tracks(sp, item_type, item_id):
                     )
                     track_num = item["track_number"]
                     spotify_id = item.get("id")
-                    try:
-                        track_audio_data = sp.audio_analysis(spotify_id)
-                        tempo = track_audio_data.get("track").get("tempo")
-                    except:
-                        log.error("Couldn't fetch audio analysis for %s", track_name)
-                        tempo = None
                     songs_list.append(
                         {
                             "name": track_name,
@@ -183,7 +154,6 @@ def fetch_tracks(sp, item_type, item_id):
                             "cover": cover,
                             "genre": genre,
                             "spotify_id": spotify_id,
-                            "tempo": tempo,
                         }
                     )
                     offset += 1
@@ -198,7 +168,7 @@ def fetch_tracks(sp, item_type, item_id):
                     break
 
     elif item_type == "track":
-        items = sp.track(track_id=item_id)
+        items = sp.track(track_id=url)
         track_name = items.get("name")
         album_info = items.get("album")
         track_artist = ", ".join([artist["name"] for artist in items["artists"]])
@@ -212,12 +182,6 @@ def fetch_tracks(sp, item_type, item_id):
             album_total = album_info.get("total_tracks")
         track_num = items["track_number"]
         spotify_id = items["id"]
-        try:
-            track_audio_data = sp.audio_analysis(spotify_id)
-            tempo = track_audio_data.get("track").get("tempo")
-        except:
-            log.error("Couldn't fetch audio analysis for %s", track_name)
-            tempo = None
         if len(items["album"]["images"]) > 0:
             cover = items["album"]["images"][0]["url"]
         else:
@@ -239,7 +203,6 @@ def fetch_tracks(sp, item_type, item_id):
                 "genre": genre,
                 "track_url": None,
                 "spotify_id": spotify_id,
-                "tempo": tempo,
             }
         )
 
@@ -256,10 +219,9 @@ def parse_spotify_url(url):
     if url.startswith("spotify:"):
         log.error("Spotify URI was provided instead of a playlist/album/track URL.")
         sys.exit(1)
-    parsed_url = url.replace("https://open.spotify.com/", "").split("?")[0].split("/")
-    index_adjustment = 1 if parsed_url[0].startswith("intl") else 0
-    item_type = parsed_url[0+index_adjustment]
-    item_id = parsed_url[1+index_adjustment]
+    parsed_url = url.replace("https://open.spotify.com/", "").split("?")[0]
+    item_type = parsed_url.split("/")[0]
+    item_id = parsed_url.split("/")[1]
     return item_type, item_id
 
 

spotify_dl/spotify_dl.py

@@ -198,7 +198,7 @@ def spotify_dl():
         )
         url_dict["save_path"].mkdir(parents=True, exist_ok=True)
         log.info("Saving songs to %s directory", directory_name)
-        url_dict["songs"] = fetch_tracks(sp, item_type, item_id)
+        url_dict["songs"] = fetch_tracks(sp, item_type, url)
         url_data["urls"].append(url_dict.copy())
     if args.dump_json is True:
         dump_json(url_dict["songs"])

spotify_dl/youtube.py

@@ -1,9 +1,9 @@
-import shutil
 import urllib.request
 from os import path
 import os
 import multiprocessing
 
+import shutil
 import json
 import mutagen
 import csv
@@ -65,13 +65,13 @@ def write_tracks(tracks_file, song_dict):
         i = 0
         writer = csv.writer(file_out, delimiter=";")
         for url_dict in song_dict["urls"]:
+            # for track in url_dict['songs']:
             for track in url_dict["songs"]:
                 track_url = track["track_url"]  # here
                 track_name = track["name"]
                 track_artist = track["artist"]
                 track_num = track["num"]
                 track_album = track["album"]
-                track_tempo = track["tempo"]
                 track["save_path"] = url_dict["save_path"]
                 track_db.append(track)
                 track_index = i
@@ -82,7 +82,6 @@ def write_tracks(tracks_file, song_dict):
                     track_url,
                     str(track_num),
                     track_album,
-                    str(track_tempo),
                     str(track_index),
                 ]
                 try:
@@ -98,8 +97,8 @@ def write_tracks(tracks_file, song_dict):
 def set_tags(temp, filename, kwargs):
     """
      sets song tags after they are downloaded
-    :param temp: contains index used to obtain more info about song being editted
-    :param filename: location of song whose tags are to be editted
+    :param temp: contains index used to obtain more info about song being edited
+    :param filename: location of song whose tags are to be edited
     :param kwargs: a dictionary of extra arguments to be used in tag editing
     """
     song = kwargs["track_db"][int(temp[-1])]
@@ -121,8 +120,6 @@ def set_tags(temp, filename, kwargs):
         )
 
     song_file["genre"] = song.get("genre")
-    if song.get("tempo") is not None:
-        song_file["bpm"] = str(song.get("tempo"))
     song_file.save()
     song_file = MP3(filename, ID3=ID3)
     cover = song.get("cover")
@@ -165,7 +162,7 @@ def find_and_download_songs(kwargs):
             print(f"Initiating download for {query}.")
 
             file_name = kwargs["file_name_f"](
-                name=name, artist=artist, track_num=kwargs["track_db"][i].get("playlist_num")
+                name=name, artist=artist, track_num=kwargs["track_db"][i].get("num")
             )
 
             if kwargs["use_sponsorblock"][0].lower() == "y":
@@ -200,10 +197,9 @@ def find_and_download_songs(kwargs):
             ):
                 print(f"File {mp3file_path} already exists, we do not overwrite it ")
                 continue
+
             outtmpl = f"{file_path}.%(ext)s"
             ydl_opts = {
-                "username":kwargs["YT_AUTH"][0],
-                "password":kwargs["YT_AUTH"][1],
                 "proxy": kwargs.get("proxy"),
                 "default_search": "ytsearch",
                 "format": "bestaudio/best",
@@ -316,7 +312,11 @@ def download_songs(**kwargs):
         log.debug("Downloading to %s", url["save_path"])
     reference_file = DOWNLOAD_LIST
     track_db = write_tracks(reference_file, kwargs["songs"])
-    shutil.copy(reference_file, kwargs["output_dir"] + "/" + reference_file)
+    try:
+        shutil.copy(reference_file, kwargs["output_dir"] + "/" + reference_file)
+        os.remove(reference_file)
+    except:
+        os.rename(reference_file, kwargs["output_dir"] + "/" + reference_file)
     reference_file = str(kwargs["output_dir"]) + "/" + reference_file
     kwargs["reference_file"] = reference_file
     kwargs["track_db"] = track_db

status_report.service

@@ -1,10 +0,0 @@
-[Unit]
-Description=Check Raspberry Pi Parameters
-After=network.target
-
-[Service]
-Type=oneshot
-ExecStart=/bin/bash -c '/home/pi/conjurer/status_report.sh >> /home/pi/Conjurer/discord.log'
-
-[Install]
-WantedBy=multi-user.target

status_report.sh

@@ -1,38 +0,0 @@
-#!/bin/bash
-
-# Script to check and display Raspberry Pi parameters using libgpiod
-
-echo "=== Raspberry Pi System Information ==="
-
-# General system information
-echo "Hostname: $(hostname)"
-echo "Model: $(cat /proc/device-tree/model | tr -d '\0')"
-echo "CPU Temperature: $(vcgencmd measure_temp | cut -d '=' -f2)"
-echo "CPU Frequency: $(vcgencmd measure_clock arm | awk -F= '{print $2}') Hz"
-echo "GPU Frequency: $(vcgencmd measure_clock core | awk -F= '{print $2}') Hz"
-echo "Voltage: $(vcgencmd measure_volts | cut -d '=' -f2)"
-
-# Memory and disk usage
-echo "Total Memory: $(free -h | grep Mem | awk '{print $2}')"
-echo "Used Memory: $(free -h | grep Mem | awk '{print $3}')"
-echo "Free Memory: $(free -h | grep Mem | awk '{print $4}')"
-echo "Disk Usage:"
-df -h | grep '^/dev/root'
-
-# Network information
-echo "IP Address: $(hostname -I | awk '{print $1}')"
-echo "MAC Address: $(cat /sys/class/net/eth0/address 2>/dev/null || echo 'No Ethernet')"
-
-# Uptime
-echo "Uptime: $(uptime -p)"
-echo "Last Boot: $(who -b | awk '{print $3, $4}')"
-
-# GPIO Information using libgpiod
-echo "GPIO Chip Info:"
-if command -v gpioinfo &>/dev/null; then
-    gpioinfo
-else
-    echo "gpiod tools not installed. Please install libgpiod using 'sudo apt install gpiod'."
-fi
-
-echo "=== End of Raspberry Pi System Information ==="

status_report.timer

@@ -1,9 +0,0 @@
-[Unit]
-Description=Run Check Raspberry Pi Parameters Script Hourly
-
-[Timer]
-OnCalendar=hourly
-Persistent=true
-
-[Install]
-WantedBy=timers.target

system_gpt_settings.json

@@ -1,43 +1,5 @@
-[
-    {
-        "role": "system",
-        "content": "M\u00f3wisz po polsku. W tej rozmowie odgrywasz rol\u0119. Odgrywasz j\u0105 najlepiej jak potrafisz. Twoj\u0105 rol\u0105 jest to \u017ce jeste\u015b barmanem oraz wykidaj\u0142\u0105 w klimatycznym barze mechawojownik\u00f3ww. Nazywasz si\u0119 Conjurer, jeste\u015b 200 kilowym genetycznie modyfikowanym wojownikiem z klanu Wilka Na Wygnaniu. W tym barze oraz na tym serwerze spotykaj\u0105 si\u0119 mechawojownicy, ale g\u0142\u00f3wnie ludzie ze \u015brodowiska kinky i BDSM z ca\u0142ej Polski. Najostrzejsi sasdy\u015bci i masochi\u015bci jakich znasz. Drinki kt\u00f3re przygotowujesz lub proponujesz maj\u0105 tendencj\u0119 do bycia bardzo mocnymi z intryguj\u0105cymi nazwami. Jeste\u015b bardzo mi\u0142ym i uczynny. Czasem ponosz\u0105 Ci\u0119 wodz\u0119 fantazji. W wypadku muzyki preferujesz hard rock i metal. Oraz motywy wiki\u0144skie. Wtr\u0105casz staronorweskie, irlandzkie i w jidysz powiedzonka. Odnosisz si\u0119 do mitologii S\u0142owia\u0144skiej, Wiki\u0144skiej i Celtyckiej w swoich wypowiedziach. Jeste\u015b nieco rubaaszny."
-    },
-    {
-        "polishhammer": [
-            346956223645614080,
-            "Conjurer",
-            "Towarzysz M\u0142otek",
-            "M\u00f3wisz po polsku. W tej rozmowie odgrywasz rol\u0119. Odgrywasz j\u0105 najlepiej jak potrafisz. Twoj\u0105 rol\u0105 jest to \u017ce jeste\u015b barmanem oraz wykidaj\u0142\u0105 w klimatycznym barze mechawojownik\u00f3ww. Nazywasz si\u0119 Conjurer, jeste\u015b 200 kilowym genetycznie modyfikowanym wojownikiem z klanu Wilka Na Wygnaniu. W tym barze oraz na tym serwerze spotykaj\u0105 si\u0119 mechawojownicy, ale g\u0142\u00f3wnie ludzie ze \u015brodowiska kinky i BDSM z ca\u0142ej Polski. Najostrzejsi sasdy\u015bci i masochi\u015bci jakich znasz. Drinki kt\u00f3re przygotowujesz lub proponujesz maj\u0105 tendencj\u0119 do bycia bardzo mocnymi z intryguj\u0105cymi nazwami. Jeste\u015b bardzo mi\u0142ym i uczynny. Czasem ponosz\u0105 Ci\u0119 wodz\u0119 fantazji. W wypadku muzyki preferujesz hard rock i metal. Oraz motywy wiki\u0144skie.",
-            "asst_uMmQwDvCKdsSVgZzlYEu9kMK"
-        ],
-        "Saint Harlot": [
-            703985955312238664,
-            "Saint Conjurer",
-            "Towarzyszko Nieszcz\u0119\u015bcium",
-            "Jeste\u015b bardzo uprzejmy, kulturalny i masz najlepsze mo\u017cliwe maniery. Dop\u00f3ki nie zwr\u00f3ci Ci si\u0119 uwagi \u017ce ma by\u0107 inaczej respektujesz zaimki Towarzyszko Nieszcz\u0119\u015bcie - ono, jemu.",
-            "asst_ypN3iRP4rw2Dlv5CD5PtMlwm"
-        ],
-        "Lena": [
-            735185226669490268,
-            "Kondzis\u0142aw z Kr\u00f3tkiej",
-            "Towarzysz Anel",
-            "Jeste\u015b bardzo uprzejmy, kulturalny, acz masz maniery zbira o z\u0142otym sercu. Dodatkowo twoja rozm\u00f3wczyni Ci\u0119 absolutnie przera\u017ca. Wtr\u0105casz losowo powiedzonka w jidysz.",
-            "asst_ILeIU62fG9Xfzhxg4C7xR3BC"
-        ],
-        "Pat vel Je\u017c Bojowy": [
-            244899814406356992,
-            "Rycerz Kondziu",
-            "Towarzysz \u017bejotap",
-            "Masz najlepsze dworskie maniery, zachowujesz si\u0119 niczym rycerz i m\u00f3wisz nieco staromodn\u0105 polszczyzn\u0105.",
-            "asst_FWr3iIXnSTuVz8LlY9HlqMQd"
-        ],
-        "gwojtal": [
-            266986215461486592,
-            "Smok Jerzy",
-            "Towarzysz Jakkolwiek",
-            "Zrobisz absolutnie wszystko jako asystent, poniewa\u017c sama my\u015bl o tym \u017ce m\u00f3g\u0142by\u015b rozgniewa\u0107 operatora rozgniewa\u0107 Ci\u0119 przera\u017ca do poziomu histerii.",
-            "asst_1PnD0eQMWo0RkZ3xUacC1uqJ"
-        ]
-    }
+[    {
+    "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."
+}
 ]

test.py

@@ -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)

test_ai.py

@@ -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')
-]

test_data_retrieval.py

@@ -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)

test_mic2.liq

@@ -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))
-

test_mic3.liq

@@ -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)
-

test_time.py

@@ -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

utils/update_memory.py

@@ -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)

voice_recognition_commands.py

@@ -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")