Change in weights

,

.dockerignore

@@ -1,32 +0,0 @@
-# Python
-__pycache__
-*.py[cod]
-*.pyo
-*.pyd
-*.so
-
-# VCS/CI
-.git
-.gitignore
-.gitattributes
-.github
-
-# Editor
-.vscode
-.idea
-
-# Python tooling
-.pytest_cache
-.mypy_cache
-.ruff_cache
-.tox
-dist
-build
-*.egg-info
-
-# Local assets
-logs
-music
-data
-*.env
-*.env.*

.gitignore

@@ -201,4 +201,3 @@ cr_results.json
 not_in_db.json
 rr_results.json
 s_results.json
-*.bak

README.md

@@ -1,23 +1,2 @@
 # conjurer
 Discord.py bot for fun, sex and BDSM
-
-## Docker quick start
-
-Docker definitions live at the repository root and let you run the Discord bot
-(`thin_client.py`), the musician file service, and the librarian search worker as
-separate containers.
-
-1. **Prepare configuration**
-   - Edit the environment files under `docker/env/*.env` and replace the
-     placeholders (`replace-me`, `shared-secret`, etc.) with your real tokens.
-     Keep `CONJURER_API_KEY` identical across all services.
-2. **Create host directories** listed in `docker-compose.yml` (for example
-   `docker/volumes/bot/config`, `docker/volumes/musician/data`, …) and populate
-   them with the required JSON settings or media assets.
-3. **Launch the stack**
-   ```bash
-   docker compose up --build
-   ```
-
-Logs for each container are mounted under `docker/volumes/*` so you can diff the
-runtime JSON and log files in git if needed.

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,57 +1,28 @@
-import json
 import logging
-import os
-import re
 import threading
+import json
 import time
-from queue import Empty, Queue
-from typing import Optional
-from urllib import request as urequest
-
-from flask import Flask, abort, jsonify, request
+from queue import Queue, Empty
+from flask import Flask, jsonify, request
 from waitress import serve
 
 HOST_ADDRESS = "192.168.1.191"
 PORT_ADDRESS = 5000
-ICECAST_ADDRESS = "http://192.168.1.15:8000"
 OUT_COMM_Q = Queue()
 IN_COMM_Q = Queue()
-SRCHTITLE = re.compile(rb"StreamTitle=\\*(?P<title>[^;]*);").search
-
 awaiting_q = []
 incoming_q = Queue()
 app = Flask(__name__)
-PREPPED_TRACKS = {
-    "requests": "",
-    "hit": "",
-    "all": "",
-    "priority": "",
-    "jingles": "",
-    "now_playing": "",
-    "next": "",
-    "meta": "",
-}
-logger = logging.getLogger("discord")
-
-API_KEY = os.getenv("CONJURER_API_KEY")
-
-
-def _authorize_request() -> None:
-    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
-        abort(401)
-
-
 class QueryControl:
     """
     This class `QueryControl` is used to manage queries with information about the author, UUID,
     content, logger, context, and replies.
     """
-
-    def __init__(self, query_author, query_uuid, query_content, ctx) -> None:
+    def __init__(self, query_author, query_uuid, query_content, uplogger, ctx) -> None:
         self.author = query_author
         self.uuid = query_uuid
         self.content = query_content
-        self.logger = logging.getLogger("discord")
+        self.logger = uplogger
         self.stop = False
         self.ctx = ctx
         self.logger.info(
@@ -59,52 +30,21 @@ class QueryControl:
         )
         self.replies = []
 
-
-@app.route("/prepped_tracks", methods=["POST"])
-def log_radio_tracks():
-    _authorize_request()
-    app.logger = logging.getLogger("discord")
-
-    app.logger.info(request)
-    record = json.loads(request.data)
-    app.logger.info(record)
-    if "next" in record[0]:
-        metadata = id3(ICECAST_ADDRESS)
-        PREPPED_TRACKS["now_playing"] = PREPPED_TRACKS["next"]
-        if metadata:
-            PREPPED_TRACKS["meta"] = (
-                metadata["name"]
-                + " - "
-                + metadata["title"]
-                + "("
-                + metadata["genre"]
-                + ")"
-            )
-        else:
-            PREPPED_TRACKS["meta"] = "Nie znaju"
-    PREPPED_TRACKS[record[0]] = record[1]
-    app.logger.info("DATA RECEIVED")
-    return jsonify("SUCCESS")
-
-
 @app.route("/conjurer", methods=["POST"])
 def answer_external_command():
-    _authorize_request()
     """
     The function `answer_external_command` logs the request data, loads the data as JSON, logs the
     record, and then puts the record into an incoming queue before returning a success message.
     :return: The function `answer_external_command()` is returning a JSON response with the message
     "SUCCESS".
     """
-    logger = logging.getLogger("discord")
-    logger.info(request)
+    app.logger.info(request)
     record = json.loads(request.data)
-    logger.info(record)
-    logger.info("DATA RECEIVED")
+    app.logger.info(record)
+    app.logger.info("DATA RECEIVED")
     incoming_q.put(record)
     return jsonify("SUCCESS")
 
-
 @app.route("/conjurer", methods=["GET"])
 def check_alive():
     """
@@ -116,31 +56,25 @@ def check_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):
+def scan_queue(_logger):
     """
     The function `scan_queue` reads data from a queue, logs it, and appends it to another queue.
 
@@ -149,20 +83,12 @@ def scan_queue(stop_event: Optional[threading.Event] = None):
     and provide information for debugging purposes. In this code snippet, the `_logger` object is used
     to log the
     """
-    logger = logging.getLogger("discord")
     while True:
-        if stop_event and stop_event.is_set():
-            logger.info("scan_queue: stop requested")
-            break
-        try:
-            data = OUT_COMM_Q.get(timeout=1)
-        except Empty:
-            continue
-        logger.info(data)
+        data = OUT_COMM_Q.get()
+        _logger.info(data)
         awaiting_q.append(data)
 
-
-def scan_incoming(stop_event: Optional[threading.Event] = None):
+def scan_incoming(_logger):
     """
     The `scan_incoming` function continuously checks for incoming data, processes it, and logs when data
     is found.
@@ -172,14 +98,10 @@ def scan_incoming(stop_event: Optional[threading.Event] = None):
     debugging, monitoring, or tracking the flow of the program. In this case, the `_logger` is being
     used
     """
-    logger = logging.getLogger("discord")
     while True:
-        if stop_event and stop_event.is_set():
-            logger.info("scan_incoming: stop requested")
-            break
         try:
             answer = incoming_q.get(block=False)
-            logger.info("DATA FOUND")
+            _logger.info("DATA FOUND")
             record_stored = False
             for record in awaiting_q:
                 if record.uuid in answer.keys():
@@ -189,7 +111,7 @@ def scan_incoming(stop_event: Optional[threading.Event] = None):
                     IN_COMM_Q.put(record)
             if not record_stored:
                 for key in answer.keys():
-                    record = QueryControl("Orphaned", key, "Orphan", None)
+                    record = QueryControl("Orphaned", key, "Orphan", _logger, None)
                     record.stop = True
                     record.entries = answer[record.uuid]
                     IN_COMM_Q.put(record)
@@ -197,34 +119,7 @@ def scan_incoming(stop_event: Optional[threading.Event] = None):
             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):
+def comm_subroutine(logger):
     """
     The `comm_subroutine` function starts multiple threads to run different tasks concurrently.
 
@@ -232,33 +127,20 @@ def comm_subroutine(stop_event: Optional[threading.Event] = None):
     object that is used for logging messages at various levels (e.g., debug, info, warning, error). In
     the provided code snippet, the logger is used to log messages at the "info" level
     """
-    # logger.setLevel(logging.DEBUG)
-    logger = logging.getLogger("discord")
-    logger.info("Started comms")
+    #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,)))
+    threads.append(threading.Thread(target=scan_incoming,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)

conjurer_librarian/conjurer_librarian.py

@@ -16,52 +16,34 @@ Functions:
 import asyncio
 import json
 import logging
-import os
+import netrc
 import threading
+import time
 from json.decoder import JSONDecodeError
 from logging import handlers
-from pathlib import Path
 from queue import Queue
-from typing import Dict, Optional
 
 import requests
 import scrape_bot
 import search_bot
-# import search_bot2 as search_bot
-from flask import Flask, jsonify, request, abort
+#import search_bot2 as search_bot
+from flask import Flask, jsonify, request
 from habanero import Crossref
 from waitress import serve
 
-try:
-    import netrc
-except ImportError:  # pragma: no cover
-    netrc = None
-
 # Constants
+NETRC_FILE = r"C:\Users\Activcom.pl\.netrc"
+HOST_ADDRESS = "192.168.1.192"
+PORT_ADDRESS = 5001
+MAIN_BOT_ADDRESS = "http://192.168.1.191:5000"
+SEND_RESULTS = "/conjurer"
+BDSM_UUID_TEST = "96b7f85a-1142-4908-8986-62a2ea25a147"
 
+MAX_CR_RESULTS = 1000
+#TEST PURPOSES ONLY!
+#MAX_CR_RESULTS = 5
 
-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")
-)
+ENCODING = "utf-8"
 
 app = Flask(__name__)
 
@@ -69,17 +51,6 @@ librarian_queue = Queue()
 librarian_list = []
 
 
-def _service_headers() -> Dict[str, str]:
-    if API_KEY:
-        return {"X-Conjurer-Api-Key": API_KEY}
-    return {}
-
-
-def _authorize_request() -> None:
-    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
-        abort(401)
-
-
 # trunk-ignore(pylint/R0902)
 class Librarian(object):
     """
@@ -110,24 +81,11 @@ class Librarian(object):
         - search_result_from_cr: A dictionary to store the search results from Crossref.
         - done: A flag indicating if the search is done.
         """
-        mailto_contact: Optional[str] = os.getenv("CONJURER_CROSSREF_MAILTO")
-        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."
-            )
+        netrc_mod = netrc.netrc(NETRC_FILE)
+        auth_tokens = netrc_mod.authenticators("crossref")
         self.cr = Crossref(
-            mailto=mailto_contact,
-            ua_string=f"Conjurer project. mailto:{mailto_contact}"
+            mailto=auth_tokens[0],
+            ua_string=f"Conjurer project. mailto:{auth_tokens[0]}"
         )
         self.query = query
         self.uuid = str(uuid)
@@ -174,7 +132,7 @@ class Librarian(object):
                 self.fetched = len(cr_result["message"]["items"])
                 self.app.logger.info(self.total)
                 self.app.logger.info(self.fetched)
-                await asyncio.sleep(0.1)
+                time.sleep(0.1)
 
         else:
             cr_result = self.cr.works(query=query, cursor_max=15000, cursor='*', progress_bar = True)
@@ -453,20 +411,18 @@ class BackgroundTaskSearch(threading.Thread):
                 requests.post,
                 f"{MAIN_BOT_ADDRESS}{SEND_RESULTS}",
                 json=result,
-                headers=_service_headers(),
                 timeout=360,
             )
             self.app.logger.info("SENT")
             result = await coroutine
             self.app.logger.info(result.status_code)
             self.app.logger.info("SEND CONFIRMED")
-            await asyncio.sleep(1)
+            time.sleep(1)
 
 
 # ==================================SERVER ROUTES==========================================
 @app.route("/query", methods=["POST"])
 async def query_database():
-    _authorize_request()
     """
     Endpoint for querying the database.
 
@@ -499,7 +455,6 @@ async def query_database():
 
 @app.route("/get_partial_result", methods=["POST"])
 async def get_partial():
-    _authorize_request()
     """
     Retrieves the partial result for a given UUID.
 
@@ -523,10 +478,9 @@ async def get_partial():
 # =======================================MAIN===================================================
 if __name__ == "__main__":
     app.logger.setLevel(logging.DEBUG)
-    LOGFILE_PATH.parent.mkdir(parents=True, exist_ok=True)
     h1 = handlers.RotatingFileHandler(
-        filename=str(LOGFILE_PATH),
-        encoding=ENCODING,
+        filename="D:\\logs\\librarian.log",
+        encoding="utf-8",
         mode="a",
         maxBytes=6 * 1024 * 1024,
         backupCount=6,
@@ -534,24 +488,20 @@ if __name__ == "__main__":
 
     app.logger.addHandler(h1)
     threads = []
-    threads.append(threading.Thread(target=waitress_run, daemon=True))
+    threads.append(threading.Thread(target=waitress_run))
     # threads.append(threading.Thread(target=flask_debug))
     bgtask = BackgroundTaskSearch()
     bgtask.app = app
-    bgtask.daemon = True
     threads.append(bgtask)
-    threads.append(
-        threading.Thread(
-            target=scrape_bot.scraper, args=(app.logger,), daemon=True
-        )
-    )
+    threads.append(threading.Thread(target=scrape_bot.scraper, args=(app.logger,)))
     i = 0
-    try:
-        for worker in threads:
+    for worker in threads:
+        try:
             app.logger.info("App number: %s", i)
             i += 1
             worker.start()
-        for worker in threads:
-            worker.join()
-    except KeyboardInterrupt:
-        app.logger.info("Shutdown requested - exiting librarian service")
+        except RuntimeError as e:
+            app.logger.error("Exploded")
+            print(str(e))
+    for worker in threads:
+        worker.join()

conjurer_librarian/scrape_bot.py

@@ -104,8 +104,9 @@ def check_if_exists_brute_force(logger):
             pass
         if blocked:
             logger.info(item)
+            logger.info(text)
             logger.error("Got blocked. Fuck.")
-            time.sleep(60 * 60)
+            time.sleep(60 * 60 * 72)
         # trunk-ignore(bandit/B311)
         rand = random.randint(1, 60)
         logger.info(f"Sleeping for {2*rand} minutes")

conjurer_musician/conjurer_musician.py

@@ -1,158 +1,74 @@
+# This Python file uses the following encoding: utf-8
 """
 The provided Python script sets up a Flask web server to manage a list of music files, with
 functions for rescanning the music folder, updating the music list, and serving the music list via
 API endpoints.
 """
-
 import json
 import logging
-import os
-import random
 import re
 import threading
 import time
 from datetime import datetime
 from logging import handlers
 from pathlib import Path
-from typing import Dict, List
-
-import requests
-from flask import (
-    Flask,
-    abort,
-    jsonify,
-    redirect,
-    render_template,
-    request,
-    send_from_directory,
-)
+from platform import uname
+from sys import platform
+from flask import Flask, jsonify, redirect, request, send_from_directory, render_template
 from waitress import serve
 
-import media_search_functions
+HOST_ADDRESS = "192.168.1.15"
+PORT_ADDRESS = 5000
+if platform in ("linux", "linux2"):
+    SEPARATOR_FILE_PATH = "/"
+    if "microsoft-standard" in uname().release:
+        LOGFILE = "/home/mtuszowski/conjurer/discord_mus_service.log"
+        MUSIC_FOLDER = "/mnt/g/Muzyka/"
+        NETRC_FILE = "/home/mtuszowski/.netrc"
+        LOGSTORE = "/home/mtuszowski/conjurer/logs/"
+        ENCODING = "utf-8"
+
+    else:
+        LOGFILE = "/home/pi/Conjurer/discord_mus_service.log"
+        NETRC_FILE = "/home/pi/.netrc"
+        LOGSTORE = "/home/pi/RetroPie/logs/"
+        ENCODING = "utf-8"
+        MUSIC_FOLDER = "/home/pi/RetroPie/mp3/"
+        PRIORITY_FOLDER = "/home/pi/RetroPie/mp3/Magiczne i chuj/"
 
 
-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")
-
+music_file_list = []
+priority_list = []
 
 def rescan():
     """
     The `rescan` function logs a message, scans for mp3 files in a specified folder,
     and adds them to a list of music files.
     """
-    logger = logging.getLogger("conjurer_musician")
-    logger.info("Rescan triggered")
+    logging.info("Rescan triggered")
 
-    music_file_list.clear()
-    priority_list.clear()
-
-    for mp3_item in MUSIC_FOLDER.glob("**/*.mp3"):
+    for mp3_item in Path.glob(Path(MUSIC_FOLDER), "**/*.mp3"):
         temp_music_file = mp3_item.as_posix()
-        if os.name == "nt":
+        if platform == "win32":
             temp_music_file = temp_music_file.replace("/", "\\")
         music_file_list.append(temp_music_file)
 
-    for mp3_item in PRIORITY_FOLDER.glob("**/*.mp3"):
+    for mp3_item in Path.glob(Path(PRIORITY_FOLDER), "**/*.mp3"):
         temp_music_file = mp3_item.as_posix()
-        if os.name == "nt":
+        if platform == "win32":
             temp_music_file = temp_music_file.replace("/", "\\")
         priority_list.append(temp_music_file)
 
-    with ALL_PLAYLIST_PATH.open("w", encoding=ENCODING) as w_file:
+    with open(
+            "/home/pi/Conjurer/all_playlist.playlist", "w", encoding="utf-8"
+        ) as w_file:
         try:
             for item in music_file_list:
                 w_file.write(item)
                 w_file.write("\n")
         except json.JSONDecodeError:
             pass
-    with HIT_PLAYLIST_PATH.open("w", encoding=ENCODING) as w_file:
+    with open("/home/pi/Conjurer/hit.playlist", "w", encoding="utf-8") as w_file:
         try:
             for item in priority_list:
                 w_file.write(item)
@@ -166,65 +82,14 @@ 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")
+    logging.info("Starting filesystemupdater")
     while True:
         time.sleep(60 * 60 * 24)
-        logger.info("Rescan triggered")
+        logging.info("Rescan triggered")
         rescan()
 
 
-def scan_tracks():
-    # Set the filename and open the file
-    logger = logging.getLogger("conjurer_musician")
-    with open(RADIOLOG_PATH, "r", encoding=ENCODING) as log_file:
-        log_file.seek(os.stat(RADIOLOG_PATH).st_size)
-        prev_size = os.stat(PERSISTENCE_PATH).st_size
-
-        while True:
-            current_size = os.stat(PERSISTENCE_PATH).st_size
-            if prev_size != current_size:
-                while prev_size != current_size:
-                    prev_size = current_size
-                    time.sleep(0.1)
-                    current_size = os.stat(PERSISTENCE_PATH).st_size
-                with open(PERSISTENCE_PATH, "r", encoding=ENCODING) as persistence:
-                    lines = persistence.readlines()
-                if len(lines) >= 3:
-                    _post_to_bot(["next", lines[2]])
-
-            position = log_file.tell()
-            line = log_file.readline()
-            if not line:
-                time.sleep(1)
-                log_file.seek(position)
-                continue
-
-            if not re.match(r".*Prepared.*", line):
-                time.sleep(0.1)
-                continue
-
-            result = None
-            if re.match(r".*jingles.*", line):
-                result = ["jingles", line]
-            elif re.match(r".*priority.*", line):
-                result = ["priority", line]
-            elif re.match(r".*hit.*", line):
-                result = ["hit", line]
-            elif re.match(r".*all_playlist.*", line):
-                result = ["all", line]
-            elif re.match(r".*request.*", line):
-                result = ["requests", line]
-
-            if result:
-                logger.info("Forwarding radio log entry: %s", result[0])
-                _post_to_bot(result)
-
-            time.sleep(0.1)
-
-
 app = Flask(__name__)
-# AutoIndex(app, browse_root="/")
 
 
 # TODO: Odpalić wyszukiwarki w wątkach i dopiero po wszystkim zsumować wyszukiwanie.
@@ -329,8 +194,12 @@ def wyszukaj(word_list, how_many, _logger=None, return_to_bot=True):
             if search_weight[itr][0] == item_to_search:
                 return_list.append(search_weight[itr])
                 if not return_to_bot:
-                    with PRIORITY_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
-                        s_file.write(search_weight[itr][1] + "\n")
+                    with open(
+                        "/home/pi/Conjurer/priority_queue.playlist",
+                        "r+",
+                        encoding="utf-8",
+                    ) as s_file:
+                        s_file.write(search_weight[itr][1])
                 break
             itr += 1
     else:
@@ -369,38 +238,6 @@ def remove_characters(string, character):
     return string.replace(character, "")
 
 
-@app.route('/get_share_list', methods=['POST'])
-def get_share_list():
-    _authorize_request()
-    data = request.get_json()
-    entries = data.get('entries')
-    keywords = data.get('keywords')
-    # Validate entries
-    if not isinstance(entries, int) or not (1 <= entries <= 10):
-        return jsonify({'error': '"entries" must be an integer between 1 and 10.'}), 400
-    # Validate keywords list
-    if not isinstance(keywords, list) or not all(isinstance(k, str) for k in keywords):
-        return jsonify({'error': '"keywords" must be a list of strings.'}), 400
-    # Call external search
-    files = media_search_functions.find_matches(entries, keywords)
-    # Return each file path as a JSON list
-    return jsonify({'files': files}), 200
-
-@app.route('/get_share_links', methods=['POST'])
-def get_share_links():
-    _authorize_request()
-    data = request.get_json()
-    file_paths = data.get('file_paths')
-    # Validate file_paths list
-    if not isinstance(file_paths, list) or not all(isinstance(p, str) for p in file_paths):
-        return jsonify({'error': '"file_paths" must be a list of strings.'}), 400
-    # Call external publish
-    links = media_search_functions.publish(file_paths)
-    # Return list of published links
-    return jsonify({'links': links}), 200
-
-
-
 @app.route("/stream", methods=["GET"])
 def stream_music():
     """
@@ -410,9 +247,8 @@ def stream_music():
     :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))
-
+    #return send_from_directory("/tmp/hls", "stream.m3u8")
+    return render_template("/home/pi/Conjurer/stream.html")
 
 @app.route("/<string:file_name>")
 def stream(file_name):
@@ -429,7 +265,6 @@ def stream(file_name):
     video_dir = "/tmp/hls"
     return send_from_directory(video_dir, file_name)
 
-
 @app.route("/stream_mp3", methods=["GET"])
 def stream_music_mp3():
     """
@@ -443,15 +278,14 @@ def stream_music_mp3():
 
 @app.route("/clear_pr_pls", methods=["GET"])
 def clear_pr_pls():
-    _authorize_request()
     """
     The function `clear_pr_pls` clears the contents of the priority queue playlist file.
 
     :return: A JSON response indicating the success of the operation.
     """
     app.logger.info("CLEARING PLAYLIST")
-    with PRIORITY_PLAYLIST_PATH.open("w", encoding=ENCODING) as cleared_pl:
-        cleared_pl.write("")
+    with open('/home/pi/Conjurer/priority_queue.playlist', 'w', encoding='utf-8') as cleared_pl:
+        cleared_pl.write('')
 
     return_data = jsonify(isError=False, message="Success", statusCode=200, data=[])
     return return_data, 200
@@ -478,7 +312,6 @@ def update_music_list():
     received and added to the `music_file_list`.
     The status code returned is 200, indicating a successful response.
     """
-    _authorize_request()
     record = json.loads(request.data)
     app.logger.info(record["item"])
     music_file_list.append(record["item"])
@@ -500,7 +333,6 @@ def look_for_playlist():
              data that was received and added to the `music_file_list`. The status code returned is 200,
              indicating a successful response.
     """
-    _authorize_request()
     record = json.loads(request.data)
     app.logger.info(record)
     app.logger.info(record["lista_slow"])
@@ -519,25 +351,25 @@ def look_for_playlist():
 
 @app.route("/request_radio_file", methods=["POST"])
 def add_request():
-    _authorize_request()
     record = json.loads(request.data)
     app.logger.info(record)
     app.logger.info(record["lista_slow"])
     app.logger.info(record["UUID"])
-    return_data = wyszukaj(record["lista_slow"], 0, app.logger, False)
+    return_data = wyszukaj(
+        record["lista_slow"], 0, app.logger, False
+    )
 
-    with REQUEST_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
+    with open(
+        "/home/pi/Conjurer/request.playlist", "a", encoding="utf-8"
+    ) as s_file:
         for item in return_data:
             s_file.write(item[1] + "\n")
     return_data = (
-        jsonify(
-            isError=False, message="Success", statusCode=200, data={"status": "OK"}
-        ),
+        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():
     """
@@ -551,7 +383,6 @@ def create_priority_playlist():
         data that was received and added to the `music_file_list`.
         The status code returned is 200,indicating a successful response.
     """
-    _authorize_request()
     record = json.loads(request.data)
     app.logger.info(record)
     app.logger.info(record["lista_slow"])
@@ -560,14 +391,13 @@ def create_priority_playlist():
     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:
+    with open(
+        "/home/pi/Conjurer/request.playlist", "a", encoding="utf-8"
+    ) as s_file:
         for item in return_data:
             s_file.write(item[1] + "\n")
     return_data = (
-        jsonify(
-            isError=False, message="Success", statusCode=200, data={"status": "OK"}
-        ),
+        jsonify(isError=False, message="Success", statusCode=200, data={"status": "OK"}),
         200,
     )
     return return_data
@@ -586,7 +416,6 @@ def add_to_priority():
         data that was received and added to the `music_file_list`.
         The status code returned is 200,indicating a successful response.
     """
-    _authorize_request()
     record = json.loads(request.data)
     app.logger.info(record)
     app.logger.info(record["lista_slow"])
@@ -595,13 +424,13 @@ def add_to_priority():
     return_data = wyszukaj(
         record["lista_slow"], record["dlugosc_plejlisty"], app.logger, False
     )
-    with PRIORITY_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
+    with open(
+        "/home/pi/Conjurer/priority_queue.playlist", "a", encoding="utf-8"
+    ) as s_file:
         for item in return_data:
             s_file.write(item[1] + "\n")
     return_data = (
-        jsonify(
-            isError=False, message="Success", statusCode=200, data={"status": "OK"}
-        ),
+        jsonify(isError=False, message="Success", statusCode=200, data={"status": "OK"}),
         200,
     )
     return return_data
@@ -654,19 +483,11 @@ if __name__ == "__main__":
     logger.info("Started")
     threads = []
     # threads.append(threading.Thread(target=flask_debug))
-    threads.append(threading.Thread(target=waitress_run, daemon=True))
-    threads.append(threading.Thread(target=thread_rescan, daemon=True))
+    threads.append(threading.Thread(target=waitress_run))
+    threads.append(threading.Thread(target=thread_rescan))
 
     for worker in threads:
         worker.start()
 
-    time.sleep(60)
-    track_thread = threading.Thread(target=scan_tracks, daemon=True)
-    track_thread.start()
-
-    try:
-        for worker in threads:
-            worker.join()
-        track_thread.join()
-    except KeyboardInterrupt:
-        logger.info("Shutdown requested - exiting musician service")
+    for worker in threads:
+        worker.join()

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

@@ -2,47 +2,9 @@
 """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.
@@ -51,7 +13,7 @@ def print_top():
         line = ""
         buffer = ""
         with open(NAME, "r", encoding="utf-8") as f:
-            for _ in range(45):
+            for _ in range (45):
                 line = f.readline()
                 if re.match(".*mp3", line):
                     buffer += line
@@ -60,39 +22,5 @@ def print_top():
             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()
+    print_top()

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

@@ -43,22 +43,6 @@ def queue_processing()
     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])
 
@@ -68,11 +52,11 @@ 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)
+s = crossfade(fade_out=2., fade_in=2., duration=4., fallback(id="switcher", track_sensitive=false, [requests_queue, s]))
 
 # Set up an interactive harbor for controlling the stream
 interactive.harbor(port = 9999)
+
 # Set up interactive controls for bass boost
 f = interactive.float("f", description="Frequency", min=0., max=1000., unit="Hz", 200.)
 g = interactive.float("g", description="Gain", min=0., max=20., unit="dB", 8.)
@@ -80,34 +64,25 @@ 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)
+a = interactive.float("main_volume", min=0., max=20., 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 = nrj(normalize(s))
 s = amplify(a, s)
+
+mic = buffer(input.pulseaudio()) # Microphone
+mic = gate(threshold=-30., range=-80., mic)
+mic = blank.strip(max_blank=10., min_noise=.1, threshold=-20., mic)
+
+s = add([s, mic])
+#w = interactive.float("wetness", min=0., max=1., 1.)
+#s = dry_wet(w,s,s2)
+
+
 # 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
@@ -119,12 +94,13 @@ 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 emergency fallback track
+emergency = single("/home/pi/RetroPie/mp3/Youtube/Dr. Peacock - Trip to Ireland [GvrvQTUbUcA].mp3")
+radio =  fallback(id="switcher2", track_sensitive=false, [s, emergency])
 # Set up an interactive control for skipping tracks
 p = interactive.bool("Skip track", false)
+
 def http_skip(~protocol, ~data, ~headers, uri)=
     radio.skip()
     http.response(code=200,data="Skipped")
@@ -154,7 +130,7 @@ 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.icecast(%mp3, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="mp3-stream", radio)
 output.pulseaudio(radio)
 #output.file.hls("/tmp/hls", [("mp3-low", %mp3(bitrate=96)), ("mp3-hi", %mp3(bitrate=160))], radio)
 # Uncomment the following lines to enable additional output formats

conjurer_musician/requirements_musician.txt

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

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/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,225 +0,0 @@
-"""Centralised configuration and runtime constants for Conjurer services.
-
-This module used to perform heavy filesystem and credential reads at import
-time which made the project brittle on hosts that did not mirror the original
-paths.  The current implementation defers that work, reads configuration from
-environment variables (with sensible fallbacks), and protects optional
-dependencies so the main bot can start even when a secondary service is
-offline.
-"""
-
-import json
-import logging
-import os
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple, TypedDict
-
-try:
-    import netrc
-except ImportError:  # pragma: no cover - standard on CPython
-    netrc = None
-
-try:
-    import openai
-except ImportError:  # pragma: no cover - optional at runtime
-    openai = None
-
-try:
-    import spotipy
-    from spotipy.oauth2 import SpotifyClientCredentials
-except ImportError:  # pragma: no cover - optional component
-    spotipy = None
-    SpotifyClientCredentials = None
-
-Music_Config = TypedDict(
-    "Music_Config",
-    {
-        "ctx": Optional[str],
-        "queue": List[str],
-        "requester": List[str],
-    },
-)
-
-
-# *=========================================== Predefines
-MASTER_TIMEOUT = datetime.now()
-INITIAL_TIME_WAIT = 500
-MUZYKA: Music_Config = {"ctx": None, "queue": [], "requester": []}
-
-logger = logging.getLogger("discord")
-
-
-def _env_path(var_name: str, fallback: Path) -> Path:
-    value = os.getenv(var_name)
-    if value:
-        return Path(value).expanduser().resolve()
-    return fallback
-
-
-def _env(var_name: str, fallback: str) -> str:
-    return os.getenv(var_name, fallback)
-
-
-BASE_DIR = Path(os.getenv("CONJURER_BASE_DIR", Path(__file__).resolve().parent))
-
-LOGFILE = _env_path("CONJURER_LOG_FILE", BASE_DIR / "discord.log")
-NETRC_FILE = _env_path("CONJURER_NETRC_FILE", Path.home() / ".netrc")
-SETTINGS_FILE = _env_path("CONJURER_SETTINGS_FILE", BASE_DIR / "settings.json")
-MEMORY_FIVE_SIARA = _env_path("CONJURER_MEMORY_FILE", BASE_DIR / "pamiec.json")
-MEMORY_FIVE_MUZYKA = _env_path(
-    "CONJURER_MUSIC_MEMORY_FILE", BASE_DIR / "pamiec_muzyki.json"
-)
-GRAPHICS_PATH = _env_path(
-    "CONJURER_GRAPHICS_PATH", BASE_DIR / "Conjurer_graphics"
-)
-MUSIC_FOLDER = _env_path("CONJURER_MUSIC_FOLDER", BASE_DIR / "music")
-ENCODING = _env("CONJURER_ENCODING", "utf-8")
-
-API_SHARED_KEY = os.getenv("CONJURER_API_KEY", "")
-MUZYKA_MOJEGO_LUDU_HISTORIA = 1500
-MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE = 15
-MUZYKA_MOJEGO_LUDU_PLAJLISTA = 30
-
-FILE_SERVICE_ADDRESS = _env("CONJURER_FILE_SERVICE", "http://127.0.0.1:5000")
-RADIO_HARBOR_ADDRESS = _env("CONJURER_RADIO_HARBOR", "http://127.0.0.1:54321")
-SKIP_TRACK = _env("CONJURER_SKIP_ENDPOINT", "/skip")
-
-GET_MP3 = "/mp3"
-SEND_MP3 = "/update_mp3"
-GET_PLAYLIST = "/get_music"
-ADD_TO_PRIO_PLAYLIST = "/add_to_priority"
-CREATE_PRIO_PLAYLIST = "/create_priority_playlist"
-
-REQUEST_MUSIC = "/request_radio_file"
-CLEAR_PRIO = "/clear_pr_pls"
-LIBRARIAN_SERVICE_ADDRESS = _env(
-    "CONJURER_LIBRARIAN_SERVICE", "http://127.0.0.1:5001"
-)
-SEND_QUERY = _env("CONJURER_LIBRARIAN_QUERY_ENDPOINT", "/query")
-TIME_BETWEEN_CALLS = 100000
-LAST_SPONTANEOUS_CALL = datetime.now()
-HOST_ADDRESS = _env("CONJURER_DISCORD_HOST", "0.0.0.0")
-PORT_ADDRESS = int(_env("CONJURER_DISCORD_PORT", "5000"))
-
-# *=========================================== Platform Specific Predefines
-
-SEPARATOR_FILE_PATH = _env("CONJURER_PATH_SEPARATOR", os.sep)
-
-DIR_PATH_SADOX = _env_path(
-    "CONJURER_SADOX_DIR", BASE_DIR / "Fansadox"
-)
-
-SYSTEM_GPT_SETTINGS = _env_path(
-    "CONJURER_SYSTEM_GPT_SETTINGS", BASE_DIR / "system_gpt_settings.json"
-)
-
-LOGSTORE = _env_path("CONJURER_LOGSTORE", BASE_DIR / "logs")
-ACCIDENT_LOG = _env_path(
-    "CONJURER_ACCIDENT_LOG", BASE_DIR / "accident_log.json"
-)
-
-
-def _load_json(path: Path, fallback) -> object:
-    try:
-        with path.open("r", encoding=ENCODING) as handle:
-            return json.load(handle)
-    except FileNotFoundError:
-        logger.warning("Missing JSON file at %s – using fallback", path)
-        return fallback
-    except json.JSONDecodeError:
-        logger.warning("Corrupt JSON at %s – resetting to fallback", path)
-        return fallback
-
-
-DATA = _load_json(SETTINGS_FILE, {})
-WORD_REACTIONS = DATA.get("word_reactions", {})
-CYCLIC_WORDS = DATA.get("cyclic_words", {})
-for key in WORD_REACTIONS:
-    if isinstance(WORD_REACTIONS[key], list) and len(WORD_REACTIONS[key]) >= 3:
-        WORD_REACTIONS[key][2] = datetime.now()
-
-MESSAGE_TABLE = _load_json(MEMORY_FIVE_SIARA, {})
-GPT_SETTINGS = _load_json(SYSTEM_GPT_SETTINGS, {})
-MESSAGE_TABLE_MUZYKA = _load_json(MEMORY_FIVE_MUZYKA, {})
-
-SPECJALNE_ZIEMNIACZKI = GPT_SETTINGS[1] if isinstance(GPT_SETTINGS, list) else {}
-ASSISTANTS: Dict[str, Tuple[str, str, int, object]] = {}
-
-
-def _load_netrc_credentials(host: str) -> Optional[Tuple[str, str, str]]:
-    if netrc is None:
-        return None
-    try:
-        parsed = netrc.netrc(str(NETRC_FILE))
-    except FileNotFoundError:
-        logger.warning("netrc file %s not found", NETRC_FILE)
-        return None
-    except netrc.NetrcParseError:
-        logger.warning("netrc file %s is invalid", NETRC_FILE)
-        return None
-    return parsed.authenticators(host)
-
-
-def _resolve_token(host: str, env_var: str) -> Optional[str]:
-    env_value = os.getenv(env_var)
-    if env_value:
-        return env_value
-    creds = _load_netrc_credentials(host)
-    if creds:
-        return creds[2]
-    logger.warning("Token for %s not configured", host)
-    return None
-
-
-OPENAI_API_KEY = _resolve_token("openai", "OPENAI_API_KEY")
-if openai and OPENAI_API_KEY:
-    openai.api_key = OPENAI_API_KEY
-    OPENAICLIENT = openai.AsyncOpenAI(api_key=OPENAI_API_KEY)
-else:
-    OPENAICLIENT = None
-
-TOKEN = _resolve_token("discord", "DISCORD_TOKEN")
-
-if spotipy:
-    spotify_creds = _load_netrc_credentials("spotipy")
-    if spotify_creds and SpotifyClientCredentials:
-        SPOTIFY_CTRL = spotipy.Spotify(
-            client_credentials_manager=SpotifyClientCredentials(
-                client_id=spotify_creds[0],
-                client_secret=spotify_creds[2],
-            )
-        )
-    else:
-        SPOTIFY_CTRL = None
-else:
-    SPOTIFY_CTRL = None
-
-youtube_creds = _load_netrc_credentials("youtube")
-if youtube_creds:
-    YOUTUBE_AUTH = [youtube_creds[0], youtube_creds[2]]
-else:
-    YOUTUBE_AUTH = [
-            os.getenv("YOUTUBE_USERNAME", ""),
-            os.getenv("YOUTUBE_PASSWORD", ""),
-        ]
-
-
-def service_headers() -> Dict[str, str]:
-    """Shared header dict for internal HTTP calls."""
-    if API_SHARED_KEY:
-        return {"X-Conjurer-Api-Key": API_SHARED_KEY}
-    return {}
-
-
-LATEX_TEX_ENGINE = "tectonic"
-LATEX_MAX_COMPILE_SECONDS = 45
-LATEX_MAX_ATTACH_MB = 8
-LATEX_MAX_ZIP_MB =  25
-
-OPENAI_MODEL = "gpt-4o-mini"
-
-ALLOWED_ROLES = ["Nocna Zmiana", "Jarl", "Thane", "Bartender"]
-GUILD_ID = 664789470779932693
-LATEST_MODEL = "gpt-4o"          # najnowszy/do rozmów (możesz zmienić w jednym miejscu)
-CHEAP_MODEL  = "gpt-4o-mini"     # najtańszy (fallback do 3.5 niżej)

deploy.sh

@@ -1,102 +1,9 @@
 #!/bin/bash
-
-total_commands=29
-current_command=0
-
-function print_progress {
-  current_command=$((current_command + 1))
-  percent=$((current_command * 100 / total_commands))
-  echo "Executing command $current_command/$total_commands ($percent%): $1"
-}
-
-cd /home/pi/conjurer || exit
-print_progress "cd /home/pi/conjurer"
-
 git pull
-print_progress "git pull"
-
-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/thin_client.py ./Conjurer/bot.py
-print_progress "cp ./conjurer/thin_client.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 +1,6 @@
 #!/bin/bash
-cd ./conjurer || exit
+cd ./conjurer
 git pull
 cd ..
-cp ./conjurer/conjurer_musician/media_search_functions.py ./Conjurer
 cp ./conjurer/conjurer_musician/conjurer_musician.py ./Conjurer
-sudo systemctl restart conjurer_musician.service
+sudo systemctl restart conjurer_musician.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.)"

docker-compose.yml

@@ -1,45 +0,0 @@
-version: "3.9"
-
-services:
-  bot:
-    build:
-      context: .
-      dockerfile: docker/Dockerfile.bot
-    container_name: conjurer-bot
-    env_file:
-      - docker/env/bot.env
-    volumes:
-      - ./docker/volumes/bot/config:/data/config
-      - ./docker/volumes/bot/logs:/data/logs
-    depends_on:
-      - musician
-      - librarian
-    restart: unless-stopped
-    ports:
-      - "5000:5000"
-
-  musician:
-    build:
-      context: .
-      dockerfile: docker/Dockerfile.musician
-    container_name: conjurer-musician
-    env_file:
-      - docker/env/musician.env
-    volumes:
-      - ./docker/volumes/musician/data:/data
-    restart: unless-stopped
-    ports:
-      - "5001:5000"
-
-  librarian:
-    build:
-      context: .
-      dockerfile: docker/Dockerfile.librarian
-    container_name: conjurer-librarian
-    env_file:
-      - docker/env/librarian.env
-    volumes:
-      - ./docker/volumes/librarian/data:/data
-    restart: unless-stopped
-    ports:
-      - "5002:5001"

docker/Dockerfile.bot

@@ -1,23 +0,0 @@
-FROM python:3.11-slim
-
-ENV PYTHONUNBUFFERED=1 \
-    PIP_NO_CACHE_DIR=1
-
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends \
-        ffmpeg \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-COPY requirements_bot.txt /tmp/requirements.txt
-RUN pip install -r /tmp/requirements.txt
-
-COPY . /app
-
-RUN useradd --create-home appuser \
-    && chown -R appuser:appuser /app
-
-USER appuser
-
-CMD ["python", "thin_client.py"]

docker/Dockerfile.librarian

@@ -1,24 +0,0 @@
-FROM python:3.11-slim
-
-ENV PYTHONUNBUFFERED=1 \
-    PIP_NO_CACHE_DIR=1
-
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends \
-        build-essential \
-        poppler-utils \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-COPY conjurer_librarian/requirements_librarian.txt /tmp/requirements.txt
-RUN pip install -r /tmp/requirements.txt
-
-COPY . /app
-
-RUN useradd --create-home appuser \
-    && chown -R appuser:appuser /app
-
-USER appuser
-
-CMD ["python", "-m", "conjurer_librarian.conjurer_librarian"]

docker/Dockerfile.musician

@@ -1,23 +0,0 @@
-FROM python:3.11-slim
-
-ENV PYTHONUNBUFFERED=1 \
-    PIP_NO_CACHE_DIR=1
-
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends \
-        ffmpeg \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-COPY requirements_bot.txt /tmp/requirements.txt
-RUN pip install -r /tmp/requirements.txt
-
-COPY . /app
-
-RUN useradd --create-home appuser \
-    && chown -R appuser:appuser /app
-
-USER appuser
-
-CMD ["python", "-m", "conjurer_musician.conjurer_musician"]

docker/env/bot.env.example

@@ -1,24 +0,0 @@
-# Discord bot service configuration
-
-DISCORD_TOKEN=HACKME!
-OPENAI_API_KEY=HACKME!
-CONJURER_API_KEY=HACKME!
-
-# Internal service endpoints
-CONJURER_FILE_SERVICE=http://conjurer-musician:5000
-CONJURER_LIBRARIAN_SERVICE=http://conjurer-librarian:5001
-
-# Runtime paths mounted via docker-compose volumes
-CONJURER_BASE_DIR=/data/config
-CONJURER_SETTINGS_FILE=/data/config/settings.json
-CONJURER_MEMORY_FILE=/data/config/pamiec.json
-CONJURER_MUSIC_MEMORY_FILE=/data/config/pamiec_muzyki.json
-CONJURER_SYSTEM_GPT_SETTINGS=/data/config/system_gpt_settings.json
-CONJURER_GRAPHICS_PATH=/data/assets/graphics
-CONJURER_LOG_FILE=/data/logs/discord.log
-CONJURER_LOGSTORE=/data/logs
-
-# Optional external integrations
-CONJURER_NETRC_FILE=/data/secrets/.netrc
-YOUTUBE_USERNAME=HACKME!
-YOUTUBE_PASSWORD=HACKME!

docker/env/librarian.env.example

@@ -1,14 +0,0 @@
-# Librarian service configuration
-
-CONJURER_API_KEY=HACKME!
-
-CONJURER_MAIN_BOT=http://conjurer-bot:5000
-
-CONJURER_LIBRARIAN_HOST=0.0.0.0
-CONJURER_LIBRARIAN_PORT=5001
-CONJURER_LIBRARIAN_MAX_RESULTS=500
-
-CONJURER_CROSSREF_MAILTO=HACKME!
-CONJURER_LIBRARIAN_LOG=/data/logs/librarian.log
-
-CONJURER_NETRC_FILE=/data/secrets/.netrc

docker/env/musician.env.example

@@ -1,20 +0,0 @@
-# Musician service configuration
-
-CONJURER_API_KEY=HACKME!
-
-CONJURER_MAIN_BOT=http://conjurer-bot:5000
-CONJURER_MUSIC_TRACKER_ENDPOINT=/prepped_tracks
-
-CONJURER_MUSICIAN_HOST=0.0.0.0
-CONJURER_MUSICIAN_PORT=5000
-
-CONJURER_MUSIC_FOLDER=/data/music
-CONJURER_PRIORITY_FOLDER=/data/priority
-CONJURER_ALL_PLAYLIST=/data/playlists/all_playlist.playlist
-CONJURER_HIT_PLAYLIST=/data/playlists/hit.playlist
-CONJURER_REQUEST_PLAYLIST=/data/playlists/request.playlist
-CONJURER_PRIORITY_PLAYLIST=/data/playlists/priority_queue.playlist
-CONJURER_STREAM_TEMPLATE=/data/templates/stream.html
-
-CONJURER_RADIO_LOG=/data/logs/radio.log
-CONJURER_PERSISTENCE_LOG=/data/logs/persistence.log

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', [])

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

gpt_interface/app.py

@@ -1,14 +0,0 @@
-from flask import Flask
-from file_serv import bp as uploader_bp
-from ingest import bp as ingest_bp
-from waitress import serve
-
-app = Flask(__name__)
-HOST_ADDRESS = "127.0.0.1"
-PORT_ADDRESS = 49151
-
-if __name__ == "__main__":
-    app.register_blueprint(uploader_bp, url_prefix="/api")
-    app.register_blueprint(ingest_bp, url_prefix="/api")
-
-    serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS)

gpt_interface/file_serv.py

@@ -1,155 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import annotations
-import os
-from pathlib import Path
-from typing import List, Dict, Any, Optional
-
-from flask import Blueprint, request, jsonify, send_file, abort, current_app
-from werkzeug.utils import secure_filename
-
-# ===== Konfiguracja przez ENV =====
-
-if API_KEY := os.getenv("API_KEY") is None:
-    with open("/home/pi/gpt_cont_api_key", "r") as f:
-        API_KEY = f.read().strip()
-else:
-    API_KEY = os.getenv("API_KEY", "")                     # np. openssl rand -hex 32
-
-UPLOAD_DIR = Path(os.getenv("UPLOAD_DIR", "/home/pi/tmp_git/"))  # katalog na dysku
-MAX_CONTENT_MB = int(os.getenv("MAX_CONTENT_MB", "200"))
-
-# Google Drive (opcjonalnie)
-GDRIVE_ENABLE = os.getenv("GDRIVE_ENABLE", "0") == "1"
-GDRIVE_SA_JSON = os.getenv("GDRIVE_SA_JSON", "")       # ścieżka do pliku .json konta serwisowego
-GDRIVE_FOLDER_ID = os.getenv("GDRIVE_FOLDER_ID", "")   # ID folderu na Drive
-
-bp = Blueprint("uploader", __name__)
-
-# Inicjalizacja katalogu
-UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
-
-def _check_auth() -> bool:
-    """Proste Bearer auth. Jeśli API_KEY puste -> bez auth (niezalecane)."""
-    if not API_KEY:
-        return True
-    auth = request.headers.get("Authorization", "")
-    if auth.startswith("Bearer "):
-        token = auth[7:].strip()
-        return token == API_KEY
-    return False
-
-def _safe_join(base: Path, *parts: str) -> Path:
-    """Zapobiega ../ — wymusza pozostanie w katalogu bazowym."""
-    p = (base.joinpath(*parts)).resolve()
-    if not str(p).startswith(str(base.resolve())):
-        abort(400, description="Invalid path")
-    return p
-
-# ===== Google Drive helper =====
-_drive_client_cached = None
-
-def _get_drive():
-    global _drive_client_cached
-    if _drive_client_cached is not None:
-        return _drive_client_cached
-
-    if not (GDRIVE_ENABLE and GDRIVE_SA_JSON and os.path.exists(GDRIVE_SA_JSON)):
-        return None
-
-    from google.oauth2 import service_account
-    from googleapiclient.discovery import build
-
-    scopes = ["https://www.googleapis.com/auth/drive.file"]
-    creds = service_account.Credentials.from_service_account_file(GDRIVE_SA_JSON, scopes=scopes)
-    _drive_client_cached = build("drive", "v3", credentials=creds, cache_discovery=False)
-    return _drive_client_cached
-
-def upload_to_drive(local_path: Path, filename: str) -> Optional[Dict[str, Any]]:
-    drv = _get_drive()
-    if drv is None:
-        return None
-    from googleapiclient.http import MediaFileUpload
-    file_metadata = {"name": filename}
-    if GDRIVE_FOLDER_ID:
-        file_metadata["parents"] = [GDRIVE_FOLDER_ID]
-    media = MediaFileUpload(str(local_path), resumable=False)
-    created = drv.files().create(body=file_metadata, media_body=media, fields="id,webViewLink,webContentLink").execute()
-    file_id = created.get("id")
-    # Przydatne linki:
-    return {
-        "file_id": file_id,
-        "webViewLink": created.get("webViewLink"),
-        "webContentLink": created.get("webContentLink"),
-        "direct_view": f"https://drive.google.com/file/d/{file_id}/view",
-        "direct_download": f"https://drive.google.com/uc?export=download&id={file_id}",
-    }
-
-@bp.get("/health")
-def health():
-    return jsonify(ok=True, info="Okidokie")
-
-@bp.post("/upload")
-def upload():
-    """Przyjmuje:
-       - multipart/form-data z jednym plikiem ('file') lub wieloma ('files')
-       - opcjonalnie: form 'subdir' (podkatalog), 'drive' (1/0) żeby wymusić wysyłkę na Drive
-    """
-    if not _check_auth():
-        return jsonify(error="Unauthorized"), 401
-
-    # Limit ciała żądania po stronie Flaska:
-    request.max_content_length = MAX_CONTENT_MB * 1024 * 1024
-
-    files = []
-    if "file" in request.files:
-        files = [request.files["file"]]
-    elif "files" in request.files:
-        files = request.files.getlist("files")
-    else:
-        return jsonify(error="No file provided (use 'file' or 'files')"), 400
-
-    subdir = (request.form.get("subdir") or "").strip()
-    target_dir = _safe_join(UPLOAD_DIR, subdir) if subdir else UPLOAD_DIR
-    target_dir.mkdir(parents=True, exist_ok=True)
-
-    want_drive = (request.form.get("drive") == "1") or (request.args.get("drive") == "1")
-    saved: List[Dict[str, Any]] = []
-
-    for f in files:
-        if not f or not f.filename:
-            continue
-        fname = secure_filename(f.filename)
-        dest = _safe_join(target_dir, fname)
-        f.save(dest)
-
-        item = {
-            "filename": fname,
-            "size": dest.stat().st_size,
-            "path": str(dest.relative_to(UPLOAD_DIR)),
-            "url_hint": f"/api/files/{dest.relative_to(UPLOAD_DIR)}",
-        }
-
-        if want_drive and GDRIVE_ENABLE:
-            try:
-                gd = upload_to_drive(dest, fname)
-                if gd:
-                    item["gdrive"] = gd
-            except Exception as e:
-                # log i idziemy dalej
-                current_app.logger.exception("Drive upload failed: %s", e)
-                item["gdrive_error"] = str(e)
-
-        saved.append(item)
-
-    if not saved:
-        return jsonify(error="No valid files"), 400
-    return jsonify(ok=True, saved=saved)
-
-@bp.get("/files/<path:relpath>")
-def get_file(relpath: str):
-    if not _check_auth():
-        return jsonify(error="Unauthorized"), 401
-    target = _safe_join(UPLOAD_DIR, relpath)
-    if not target.exists() or not target.is_file():
-        return jsonify(error="Not found"), 404
-    return send_file(target, as_attachment=False)

gpt_interface/ingest.py

@@ -1,52 +0,0 @@
-# ingest_text.py
-import os
-import urllib.parse
-from pathlib import Path
-
-from flask import Blueprint, abort, jsonify, request
-
-bp = Blueprint("ingest_text", __name__)
-BASE = Path(os.getenv("INGEST_DIR", "/home/pi/tmp_git")).resolve()
-BASE.mkdir(parents=True, exist_ok=True)
-TOKEN = None
-with open("/home/pi/gpt_cont_api_key", "r") as f:
-        TOKEN = f.read().strip()
-
-
-# prosty bufor kawałków w RAM (na 1 proces)
-chunks = {}
-
-
-@bp.get("/api/ingest-text")
-def ingest_text():
-    if request.args.get("key") != TOKEN:
-        return jsonify(error="unauthorized"), 401
-
-    name = request.args.get("name", "").strip()
-    index = int(request.args.get("index", "1"))
-    total = int(request.args.get("total", "1"))
-    chunk = request.args.get("chunk", "")
-
-    if not name or "/" in name or ".." in name:
-        return jsonify(error="bad name"), 400
-    if not (1 <= index <= total <= 9999):
-        return jsonify(error="bad indexing"), 400
-
-    # gromadzimy w pamięci (możesz podmienić na Redis)
-    key = f"{name}:{total}"
-    entry = chunks.setdefault(key, {})
-    entry[index] = urllib.parse.unquote_plus(chunk)
-
-    if TOKEN is None:
-         exit("No API token set!")
-    if len(entry) == total:
-        # składamy i zapisujemy
-        data = "".join(entry[i] for i in range(1, total + 1))
-        out = (BASE / name).resolve()
-        if not str(out).startswith(str(BASE)):
-            return jsonify(error="bad path"), 400
-        out.write_text(data, encoding="utf-8")
-        del chunks[key]
-        return jsonify(ok=True, saved=str(out), bytes=len(data.encode("utf-8")))
-    else:
-        return jsonify(pending=True, got=len(entry), total=total)

gpt_interface/reinit_server.sh

@@ -1,2 +0,0 @@
-#!/bin/bash
-cd ../conjurer/ && git pull && cp ./gpt_interface/* ../gpt_interf_serv/ && cd -

install_main_bot.sh

@@ -1,23 +1,14 @@
 #!/bin/bash
-sudo apt-get install python3-dev
-sudo apt-get install portaudio19-dev python3-pyaudio
-sudo apt-get install
-cd /home/pi || exit
+cd /home/pi
 mdkir Conjurer
-cd Conjurer ||exit
-python3 -m venv /home/pi/Conjurer/.env
+cd Conjurer
+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
+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

install_music_bot.sh

@@ -19,19 +19,6 @@ touch /home/pi/Conjurer/request.playlist
 touch /home/pi/Conjurer/persistence.log
 echo "[]" > /home/pi/Conjurer/persistence.log
 
-sudo usermod -aG pulse-access pi
-sudo usermod -aG pulse-access root
-
-sudo usermod -aG audio pi
-sudo usermod -aG audio root
-
-echo "Add exception suppresion to signal handler in spotify __ini__.py"
-echo "Add password to youtube opts in spotify_dl youtube.py"
-echo "Downgrade ffmpeg by copying ffmpeg.pref from repository to /etc/apt/preferences.d"
-echo "Install opam from installation link"
-echo "Initialize opam"
-echo "Install liquidsoap and its dependencies"
-
 touch /home/pi/Conjurer/radio_log.log
 ./env/bin/python3 -m pip install --upgrade pip
 ./env/bin/python3 -m pip install -r requirements_musician.txt
@@ -45,7 +32,3 @@ sudo cp /home/pi/conjurer/conjurer_musician/radio_service.service /etc/systemd/s
 sudo systemctl daemon-reload
 sudo systemctl start radio_service.service
 sudo systemctl enable radio_service.service
-
-
-sed -i -e 's/os.rename/shutil.copy/g' ./env/lib/python3.11/site-packages/spotify_dl/youtube.py
-sed -i '1i\import shutil' ./env/lib/python3.11/site-packages/spotify_dl/youtube.py

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

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,333 +0,0 @@
-import asyncio
-import logging
-import re
-import uuid
-from pathlib import Path, PurePath
-from sys import platform
-
-import discord
-import requests
-
-import yt_dlp
-from constants import (
-    FILE_SERVICE_ADDRESS,
-    GET_MP3,
-    GET_PLAYLIST,
-    MUSIC_FOLDER,
-    SEND_MP3,
-    SPOTIFY_CTRL,
-    YOUTUBE_AUTH,
-    service_headers,
-)
-from spotify_dl import spotify
-from spotify_dl import youtube as youtube_download
-
-
-SERVICE_HEADERS = service_headers()
-MUSIC_ROOT = Path(MUSIC_FOLDER)
-
-
-
-class MusicFileList(object):
-    """
-    The `MusicFileList` class manages a list of music files, with the ability to refresh the list from a
-    file service or local directory and update the list with new items.
-    """
-
-    def __init__(self, logger_name) -> None:
-        self.music_file_list = []
-        self.file_service_active = False
-        self.logger = logging.getLogger("discord")
-
-        self.logger.info("Created Playlist organizer class")
-
-    async def refresh_file_list(self, bot):
-        """
-        The `refresh_file_list` function attempts to connect to a file service to retrieve a list of music
-        files, and if unsuccessful, it populates the list by scanning a local directory for .mp3 files.
-        """
-        try:
-            self.logger.info("Attempt to connect to file service")
-            response = requests.get(
-                f"{FILE_SERVICE_ADDRESS}{GET_MP3}",
-                headers=SERVICE_HEADERS,
-                timeout=60,
-            )
-            self.music_file_list = response.json()["music_file_list"]
-            self.file_service_active = True
-        except requests.exceptions.RequestException as e:
-            for mp3_item in MUSIC_ROOT.glob("**/*.mp3"):
-                temp_music_file = mp3_item.as_posix()
-                if platform == "win32":
-                    temp_music_file = temp_music_file.replace("/", "\\")
-                self.music_file_list.append(temp_music_file)
-            self.file_service_active = False
-            self.logger.error(e.strerror)
-            self.logger.error("Service Unavailable")
-        finally:
-            if self.file_service_active:
-                self.logger.info("Radio Status: Probably Active")
-                status = discord.Status.online
-                # radio_hardkor = discord.Activity(
-                #    name = "Radio Hammer/Radio Conjurer/Wolne Bałuity Kurwa",
-                #    url = "http://95.175.16.246:666/mp3-stream",
-                #    type = discord.ActivityType.streaming,
-                #    platform = "Liquidsoap+RaspberyPi+RolandSeratoDJ202",
-                #    state = "Where the f*** is the DJ booth?",
-                #    details= "This Is Radio Hardkor based in Wolne Księstwo Bałuty, the best pirate radiostation on both sides of Łódka river",
-                #    buttons= [{"label":"RADIO", "url":"http://95.175.16.246:666/mp3-stream"}],
-                #    assets= {"large_image": "fuckery.jpg", "large_text":"Fuckewry", "small_image":"willowisp.png", "small_text":"Hi!"}
-                # )
-                radio_hardkor = discord.Streaming(
-                    name="Radio Hardkor", url="http://95.175.16.246:666/mp3-stream"
-                )
-                await bot.change_presence(status=status, activity=radio_hardkor)
-
-            else:
-                self.logger.info("Radio Status: Rather Unknown")
-                await bot.change_presence(
-                    activity=discord.Game(name="Axe Throwing Darts")
-                )
-
-    def get_file_list(self):
-        """
-        The `get_file_list` function returns the list of music files stored in the object.
-        :return: The `music_file_list` attribute is being returned.
-        """
-        return self.music_file_list
-
-    def update_file_list(self, item):
-        """
-        The `update_file_list` function appends an item to a music file list and sends a POST request with
-        the item data to a file service address.
-
-        :param item: The `item` parameter in the `update_file_list` method is the file that you want to add
-        to the `music_file_list` attribute of the class instance. It is then sent as a JSON payload in a
-        POST request to a file service address along with the endpoint `SEND_MP3`
-        """
-        self.music_file_list.append(item)
-        post_data = {"item": str(item)}
-        requests.post(
-            f"{FILE_SERVICE_ADDRESS}{SEND_MP3}",
-            json=post_data,
-            headers=SERVICE_HEADERS,
-            timeout=60,
-        )
-
-
-MUSIC_FILE_LIST = MusicFileList("discord")
-
-
-async def get_file(ctx, source, link):
-    """
-    Take in three parameters: "ctx" (context),
-    "source" (a string representing the source of the file), and "link" (a string representing the link
-    to the file). Execute it in asynchronouse way. And get file from spotify or youtube.
-
-    :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-    represents the context in which a command is being executed, including information such as the
-    message, the channel, the server, and the user who invoked the command
-    :param source: The source parameter is likely a string that represents the source of the file that
-    the user wants to retrieve. This could be a website, a cloud storage service, or any other location
-    where the file is stored
-    :param link: The "link" parameter is likely a string that represents a URL or file path to the
-    location of the file that the function is trying to retrieve
-    """
-    logger = logging.getLogger("discord")
-    item_id = None
-    item_type = None
-    file_list = []
-    if source == "Spotify":
-        dir_path = None
-        item_type, item_id = spotify.parse_spotify_url(link)
-        if item_type in ["album", "track", "playlist"] and item_id:
-            logger.info(item_type)
-            logger.info(item_id)
-            logger.info("Spotify link provided")
-            file_list = await asyncio.to_thread(
-                spotify.fetch_tracks, SPOTIFY_CTRL, item_type, link
-            )
-            logger.info(file_list)
-            directory_name = await asyncio.to_thread(
-                spotify.get_item_name, SPOTIFY_CTRL, item_type, item_id
-            )
-            logger.info(directory_name)
-            logger.info("Spotify scrape done")
-            url_data = {"urls": []}
-            url_dict = {}
-            url_dict["save_path"] = Path(
-                PurePath.joinpath(MUSIC_ROOT, Path(directory_name))
-            )
-            url_dict["save_path"].mkdir(parents=True, exist_ok=True)
-            url_dict["songs"] = file_list
-            url_data["urls"].append(url_dict.copy())
-            file_name_f = youtube_download.default_filename
-            logger.info("YT-DL")
-            coro = asyncio.to_thread(
-                youtube_download.download_songs,
-                songs=url_data,
-                output_dir=str(MUSIC_ROOT),
-                format_str="bestaudio/best",
-                skip_mp3=False,
-                keep_playlist_order=False,
-                no_overwrites=True,
-                remove_trailing_tracks="no",
-                use_sponsorblock="yes",
-                file_name_f=file_name_f,
-                multi_core=0,
-                proxy="",
-                YT_AUTH = YOUTUBE_AUTH
-            )
-            _ = await coro
-            logger.info("YT-DL done")
-            dir_path = (url_dict["save_path"].resolve()).as_posix()
-            if platform == "win32":
-                dir_path = dir_path.replace("/", "\\")
-            return dir_path, file_list
-
-        await ctx.send(
-            "No se jaja chyba robisz, Ty byś spotifaja nie poznawszy jakby z krzaków wyskoczył i w dupę kopnął. Plejlista, kawałek albo album prosze."
-        )
-        logger.error("Wrong link provided spotify: %s", link)
-    elif source == "Youtube":
-        link_ok = False
-        pat = r"^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$"
-        if re.match(pat, link) and (
-            re.match(".*youtube.*", link) or re.match(".*youtu.be.*", link)
-        ):
-            link_ok = True
-
-        if link_ok:
-            dir_path = ""
-            file_list = []
-            query = link
-            sponsorblock_postprocessor = [
-                {
-                    "key": "SponsorBlock",
-                    "categories": ["skip_non_music_sections"],
-                },
-                {
-                    "key": "ModifyChapters",
-                    "remove_sponsor_segments": ["music_offtopic"],
-                    "force_keyframes": True,
-                },
-            ]
-            # TODO: Make sponsorblock work
-            sponsorblock_postprocessor = []
-            if platform == "win32":
-                dir_path = "G:\\Muzyka\\Youtube"
-            else:
-                dir_path = "/home/pi/RetroPie/mp3/Youtube"
-            ydl_opts = {
-                "username": YOUTUBE_AUTH[0],
-                "password": YOUTUBE_AUTH[1],
-                "proxy": "",
-                "default_search": "ytsearch",
-                "format": "bestaudio/best",
-                "postprocessors": sponsorblock_postprocessor,
-                "noplaylist": True,
-                "no_color": False,
-                "paths": {"home": dir_path},
-            }
-            mp3_postprocess_opts = {
-                "key": "FFmpegExtractAudio",
-                "preferredcodec": "mp3",
-                "preferredquality": "192",
-            }
-            ydl_opts["postprocessors"].append(mp3_postprocess_opts.copy())
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                try:
-                    coro = asyncio.to_thread(ydl.download, [query])
-                    _ = await coro
-                except Exception as exce:  # pylint: disable=broad-exception-caught
-                    logger.error(exce)
-                    logger.info(
-                        "Failed to download %s, make sure yt_dlp is up to date", link
-                    )
-            extract = re.search("v=(...........)[&,$]*", link)
-            ident = extract.group(1)
-            for item in Path.glob(Path(dir_path), "**/*.mp3"):
-                file = item.as_posix()
-                if platform == "win32":
-                    file = file.replace("/", "\\")
-                if re.match(".*" + ident + ".*", file):
-                    file_list.append(file)
-            return dir_path, file_list
-        await ctx.send(
-            "No se jaja chyba robisz, Ty byś jutuba nie poznawszy jakby z krzaków wyskoczył i w dupę kopnął. Jutuba to nie tuba którą sobie można gdzieś wsadzić."
-        )
-        logger.error("Wrong link provided youtube: %s", link)
-        return "", None
-    elif source == "Pornol":
-
-        dir_path = ""
-        file_list = []
-        query = link
-        sponsorblock_postprocessor = [
-            {
-                "key": "SponsorBlock",
-                "categories": ["skip_non_music_sections"],
-            },
-            {
-                "key": "ModifyChapters",
-                "remove_sponsor_segments": ["music_offtopic"],
-                "force_keyframes": True,
-            },
-        ]
-        # TODO: Make sponsorblock work
-        sponsorblock_postprocessor = []
-        dir_path = "/home/pi/MediaShare/movies/porn"
-        ydl_opts = {
-            "postprocessors": sponsorblock_postprocessor,
-            "paths": {"home": dir_path},
-        }
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            try:
-                coro = asyncio.to_thread(ydl.download, [query])
-                _ = await coro
-            except Exception as exce:  # pylint: disable=broad-exception-caught
-                logger.error(exce)
-                logger.info(
-                    "Failed to download %s, make sure yt_dlp is up to date", link
-                )
-        file_list.append("wiadomo co wiadomo gdzie")
-        return dir_path, file_list
-
-
-async def search_music(ctx, how_many=0, slowa_kluczowe=None):
-    """
-    Take in a context object and an optional integer parameter "how_many" and perform search
-    operation on music library.
-
-    :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It
-    represents the context in which the command was invoked, including information such as the message,
-    the channel, the server, and the user who invoked the command
-    :param how_many: how_many is a parameter that specifies the number of search results to be returned.
-    It is an optional parameter with a default value of 0, which means that if no value is provided for
-    how_many, the function will return all search results, defaults to 0 (optional)
-    """
-    # i sieć neuronową z możliwością wyrażenia opinii o dopasowaniu.
-    logger = logging.getLogger("discord")
-    if slowa_kluczowe:
-        word_list = slowa_kluczowe
-    else:
-        word_list = ctx.message.content.split()
-    logger.info("Wyszukuje")
-    jrequest = {
-        "lista_slow": word_list,
-        "dlugosc_plejlisty": how_many,
-        "UUID": str(uuid.uuid4()),
-    }
-    coroutine = asyncio.to_thread(
-        requests.post,
-        f"{FILE_SERVICE_ADDRESS}{GET_PLAYLIST}",
-        json=jrequest,
-        headers=SERVICE_HEADERS,
-        timeout=360,
-    )
-    return_data = await coroutine
-    if not return_data.status_code == 200:
-        await ctx.send("Wołaj szefa - coś się wyjebało")
-        return
-    logger.info(return_data.json()["data"])
-    return return_data.json()["data"]

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)

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

requirements_bot copy.txt

@@ -1,21 +0,0 @@
-setuptools
-discord
-yaach
-t_dlp
-spotify_dl
-spotipy
-openai
-eyed3
-numpy
-pdf2image
-PyPDF2
-requests
-spotipy
-tiktoken
-PyNaCl
-flask[async]
-waitress
-clickupython
-assemblyai[extras]
-SpeechRecognition
-git+https://github.com/imayhaveborkedit/discord-ext-voice-recvO

requirements_bot.txt

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

rpg/armour.csv

@@ -1,3 +0,0 @@
-name,type,locations,ap_head,ap_body,ap_larm,ap_rarm,ap_lleg,ap_rleg,max_ag,traits,weight,availability,source,notes
-Flak Vest,armor,"Body",0,4,0,0,0,0,,Flak,7,Common,"DH2 CRB","PRZYKŁAD – ZASTĄP"
-Power Armour (Astartes),armor,"All",8,10,8,8,9,9,,Environmental; Auto-senses,100,"Very Rare","DW CRB","PRZYKŁAD – ZASTĄP"

rpg/attack_test.js

@@ -1,60 +0,0 @@
-// DH2 Attack Test v2 — presets: Aim/Range/Fire + Size/Light/Cover
-const actor = canvas.tokens.controlled[0]?.actor ?? game.user.character;
-if (!actor) return ui.notifications.warn("Zaznacz token albo przypisz postać.");
-new Dialog({
-  title: "🎯 Attack Test (WS/BS)",
-  content: `
-  <form>
-    <div class="form-group"><label>Base Target (WS/BS)</label><input name="base" type="number" value="40"/></div>
-    <div class="form-group"><label>Aim</label>
-      <select name="aim"><option value="0">None</option><option value="10">Half (+10)</option><option value="20">Full (+20)</option></select></div>
-    <div class="form-group"><label>Range</label>
-      <select name="range">
-        <option value="0">Standard</option>
-        <option value="30">Point Blank (+30)</option>
-        <option value="10">Short (+10)</option>
-        <option value="-10">Long (-10)</option>
-        <option value="-30">Extreme (-30)</option>
-      </select></div>
-    <div class="form-group"><label>Fire / Attack</label>
-      <select name="stance">
-        <option value="0">Standard / Single</option>
-        <option value="10">Semi (+10)</option>
-        <option value="-10">Full Auto (-10)</option>
-        <option value="30">All Out (Melee +30)</option>
-      </select></div>
-    <div class="form-group"><label>Target Size</label>
-      <select name="size">
-        <option value="0">Average</option>
-        <option value="10">Hulking (+10)</option>
-        <option value="20">Enormous (+20)</option>
-        <option value="30">Massive (+30)</option>
-        <option value="-10">Puny (-10)</option>
-      </select></div>
-    <div class="form-group"><label>Lighting</label>
-      <select name="light"><option value="0">Normal</option><option value="10">Good (+10)</option><option value="-10">Poor (-10)</option></select></div>
-    <div class="form-group"><label>Cover</label>
-      <select name="cover"><option value="0">None</option><option value="-10">Light (-10)</option><option value="-20">Heavy (-20)</option></select></div>
-    <div class="form-group"><label>Other Modifiers</label><input name="mod" type="number" value="0"/></div>
-  </form>`,
-  buttons: {
-    roll: {
-      label: "Roll",
-      callback: async (html) => {
-        const get = n => Number(html.find(`[name="${n}"]`).val());
-        const base = get("base");
-        const total = base + get("aim") + get("range") + get("stance") + get("size") + get("light") + get("cover") + get("mod");
-        const r = await(new Roll("1d100")).roll({async:true});
-        const ok = r.total <= total;
-        const margin = Math.abs(total - r.total);
-        const dox = ok ? 1 + Math.floor(margin/10) : Math.floor(margin/10);
-        const table = `
-        <table style="width:100%;border-collapse:collapse">
-          <tr><td><b>Target</b></td><td>${total}</td><td><b>Roll</b></td><td>${r.total}</td></tr>
-          <tr><td><b>Result</b></td><td colspan="3">${ok?'<span style="color:green">SUCCESS</span>':'<span style="color:red">FAIL</span>'} — ${ok?dox+' DoS':dox+' DoF'}</td></tr>
-        </table>`;
-        r.toMessage({speaker: ChatMessage.getSpeaker({actor}), flavor: `🎯 <b>Attack Test</b><br/>${table}`});
-      }
-    }
-  }
-}).render(true);

rpg/critical_hits.csv

@@ -1,6 +0,0 @@
-Roll,Result
-1,Energy/Head — wpis 1
-2,Energy/Head — wpis 2
-3,Energy/Head — wpis 3
-4,Energy/Head — wpis 4
-5,Energy/Head — wpis 5

rpg/focus_power.js

@@ -1,50 +0,0 @@
-// 🧠 Focus Power (DH2) — WP test + Phenomena/Perils with mode presets
-const actor = canvas.tokens.controlled[0]?.actor ?? game.user.character;
-if (!actor) return ui.notifications.warn("Zaznacz token.");
-new Dialog({
-  title: "🧠 Focus Power",
-  content: `
-  <form>
-    <div class="form-group"><label>Willpower (target)</label><input name="wp" type="number" value="40"/></div>
-    <div class="form-group"><label>Psychic Rating (PR)</label><input name="pr" type="number" value="3"/></div>
-    <div class="form-group"><label>Mode</label>
-      <select name="mode"><option value="fettered">Fettered (no PP; PR/2)</option><option value="unfettered" selected>Unfettered (PP on doubles)</option><option value="push">Push (always PP; +PR)</option></select></div>
-    <div class="form-group"><label>Power difficulty/gear/etc. (flat mod)</label><input name="flat" type="number" value="0"/></div>
-    <div class="form-group"><label>Perils threshold</label><input name="thr" type="number" value="75"/></div>
-  </form>`,
-  buttons: {
-    roll: { label: "Roll", callback: async html => {
-      const wp = Number(html.find('[name="wp"]').val());
-      const pr = Number(html.find('[name="pr"]').val());
-      const mode = html.find('[name="mode"]').val();
-      const flat = Number(html.find('[name="flat"]').val());
-      const thr = Number(html.find('[name="thr"]').val());
-      let effPR = pr, ppmod = 0, ppAlways = false, note = "";
-      if (mode==="fettered"){ effPR = Math.max(1, Math.floor(pr/2)); note="(Fettered: PR/2, brak Phenomena)"; }
-      if (mode==="push"){ effPR = pr+3; ppmod=10; ppAlways = true; note="(Push: +3 PR, Phenomena zawsze, +10)"; }
-      const target = wp + flat;
-      const roll = await (new Roll("1d100")).roll({async:true});
-      const ok = roll.total <= target;
-      const dos = ok ? 1 + Math.floor((target - roll.total)/10) : Math.floor((roll.total - target)/10);
-      const doubles = (roll.total%11===0) || (roll.total===100);
-      const info = `<table style="width:100%;border-collapse:collapse">
-        <tr><td><b>Target</b></td><td>${target}</td><td><b>Roll</b></td><td>${roll.total}</td></tr>
-        <tr><td><b>Result</b></td><td colspan="3">${ok?'<span style="color:green">SUCCESS</span>':'<span style="color:red">FAIL</span>'} — ${ok?dos+' DoS':dos+' DoF'} ${doubles?' — <b>DOUBLES</b>':''}</td></tr>
-        <tr><td><b>Eff. PR</b></td><td>${effPR}</td><td><b>Range hint</b></td><td>${effPR*10} m (jeśli moc tak działa)</td></tr>
-      </table>`;
-      roll.toMessage({speaker: ChatMessage.getSpeaker({actor}), flavor:`🧠 <b>Focus Power</b> ${note}<br/>${info}`});
-      const needPP = (mode==="unfettered" && doubles) || (mode==="push") ;
-      if (needPP){
-        const tbl = game.tables.getName("Psychic Phenomena");
-        if (tbl){
-          const r = await (new Roll(`1d100 + ${ppmod}`)).roll({async:true});
-          await tbl.draw({displayResults:true, roll:r});
-          if (r.total >= thr){
-            const per = game.tables.getName("Perils of the Warp");
-            if (per) await per.draw({displayResults:true});
-          }
-        } else ChatMessage.create({content:"Utwórz RollTable: <b>Psychic Phenomena</b> (+ <b>Perils of the Warp</b>)"});
-      }
-    }}
-  }
-}).render(true);

rpg/hit_location.js

@@ -1,22 +0,0 @@
-// 🎯 Hit Location (DH mapping by reversed roll)
-new Dialog({
-    title:"🎯 Hit Location",
-    content:`<form>
-      <div class="form-group"><label>Attack d100 roll</label><input name="roll" type="number" value="37"/></div>
-    </form>`,
-    buttons:{
-      go:{label:"Resolve", callback: html=>{
-        const n = Math.max(1, Math.min(100, Number(html.find('[name="roll"]').val())));
-        const rev = Number(String(n).padStart(2,"0").split("").reverse().join(""));
-        let loc = "";
-        if (rev<=10) loc="Head";
-        else if (rev<=20) loc="Right Arm";
-        else if (rev<=30) loc="Left Arm";
-        else if (rev<=70) loc="Body";
-        else if (rev<=85) loc="Right Leg";
-        else loc="Left Leg";
-        ChatMessage.create({content:`🎯 <b>Hit Location</b>: roll ${n} → reversed ${rev} → <b>${loc}</b>`});
-      }}
-    }
-  }).render(true);
-  

rpg/hose_rules.js

@@ -1,6 +0,0 @@
-const text=`<b>House Rules — DH2 chassis</b><br/>
-• Unnatural mapowanie: dawne ×2 bonus → Unnatural (+X) tak, by SB/TB odzwierciedlały linię źródłową.<br/>
-• Pancerz Astartes: zachowaj AP; zużycie zasilania jako +1 Fatigue co X scen zamiast liczenia minut.<br/>
-• Aptitudes: archetypy z RT/DW/BC mają przypisane 2–3 Aptitudes DH2 dla kosztów XP.<br/>
-• Psy: testy i PR z DH2 dla wszystkich; GK posiada Aegis Discipline (1×/scena reroll Perils) + 1–2 signature powers z DW.<br/>
-• RT Acquisition → DH2 Influence z modyfikatorami kontekstowymi (teatr działań, mandat Inkwizycji, czas).`;ChatMessage.create({content:text});

rpg/inititative.js

@@ -1,11 +0,0 @@
-// 🚦 Initiative for selected tokens (1d10 + AG Bonus prompt)
-if (!canvas.tokens.controlled.length) return ui.notifications.warn("Zaznacz co najmniej jeden token.");
-const combat = game.combat ?? await Combat.implementation.create({});
-for (const t of canvas.tokens.controlled){
-  if (!combat.combatants.some(c=>c.tokenId===t.id)) await combat.createEmbeddedDocuments("Combatant",[ {tokenId:t.id, sceneId: canvas.scene.id, hidden:false} ]);
-  const ag = Number(await Dialog.prompt({title:`AG Bonus for ${t.name}`, content:`<input type="number" value="4">`, label:"OK"}));
-  const r = await (new Roll(`1d10 + ${ag}`)).roll({async:true});
-  await combat.setInitiative(combat.combatants.find(c=>c.tokenId===t.id).id, r.total);
-  r.toMessage({flavor:`🚦 <b>Initiative</b> — ${t.name}: ${r.total}`});
-}
-ui.notifications.info("Inicjatywy ustawione.");

rpg/perils.csv

@@ -1,21 +0,0 @@
-Roll,Result
-1-5,Perils 1–5 — WPISZ
-6-10,Perils 6–10 — WPISZ
-11-15,Perils 11–15 — WPISZ
-16-20,Perils 16–20 — WPISZ
-21-25,Perils 21–25 — WPISZ
-26-30,Perils 26–30 — WPISZ
-31-35,Perils 31–35 — WPISZ
-36-40,Perils 36–40 — WPISZ
-41-45,Perils 41–45 — WPISZ
-46-50,Perils 46–50 — WPISZ
-51-55,Perils 51–55 — WPISZ
-56-60,Perils 56–60 — WPISZ
-61-65,Perils 61–65 — WPISZ
-66-70,Perils 66–70 — WPISZ
-71-75,Perils 71–75 — WPISZ
-76-80,Perils 76–80 — WPISZ
-81-85,Perils 81–85 — WPISZ
-86-90,Perils 86–90 — WPISZ
-91-95,Perils 91–95 — WPISZ
-96-100,Perils 96–100 — WPISZ

rpg/powers.csv

@@ -1,3 +0,0 @@
-name,type,discipline,action,test,range,sustained,effect,source,notes
-Smite,power,Biomancy,Half,"WP Challenging (+0)","PR*10m",No,"1d10+PR E; Tearing","DH2 CRB","PRZYKŁAD – ZASTĄP"
-Foreboding,power,Divination,Reaction,"Per Difficult (-10)","Self",No,"Use as Evasion; DoS rules","DH2 CRB","PRZYKŁAD – ZASTĄP"

rpg/pp.csv

@@ -1,21 +0,0 @@
-Roll,Result
-1-5,PP 1–5 — WPISZ
-6-10,PP 6–10 — WPISZ
-11-15,PP 11–15 — WPISZ
-16-20,PP 16–20 — WPISZ
-21-25,PP 21–25 — WPISZ
-26-30,PP 26–30 — WPISZ
-31-35,PP 31–35 — WPISZ
-36-40,PP 36–40 — WPISZ
-41-45,PP 41–45 — WPISZ
-46-50,PP 46–50 — WPISZ
-51-55,PP 51–55 — WPISZ
-56-60,PP 56–60 — WPISZ
-61-65,PP 61–65 — WPISZ
-66-70,PP 66–70 — WPISZ
-71-75,PP 71–75 — WPISZ
-76-80,PP 76–80 — WPISZ
-81-85,PP 81–85 — WPISZ
-86-90,PP 86–90 — WPISZ
-91-95,PP 91–95 — WPISZ
-96-100,PP 96–100 — WPISZ

rpg/quick_conditions.js

@@ -1,28 +0,0 @@
-// 🩹 Toggle conditions on selected tokens (Foundry v13)
-const choices = [
-    {id:"fatigued", label:"Fatigued"},
-    {id:"stunned",  label:"Stunned"},
-    {id:"prone",    label:"Prone"},
-    {id:"frightened", label:"Frightened (Fear)"}
-  ];
-  const opts = choices.map(c=>`<label><input type="checkbox" name="c" value="${c.id}"> ${c.label}</label>`).join("<br/>");
-  new Dialog({
-    title:"🩹 Conditions",
-    content:`<form>${opts}<div class="form-group"><label>Mode</label>
-    <select name="mode"><option value="toggle">Toggle</option><option value="on">Apply</option><option value="off">Remove</option></select></div></form>`,
-    buttons:{
-      go:{label:"Apply",callback: html=>{
-        const ids = Array.from(html.find('input[name="c"]:checked')).map(e=>e.value);
-        const mode = html.find('[name="mode"]').val();
-        const getEf = id => CONFIG.statusEffects.find(e=>e.id===id) ?? {id};
-        canvas.tokens.controlled.forEach(t=>{
-          ids.forEach(id=>{
-            if (mode==="toggle") t.toggleEffect(getEf(id));
-            else if (mode==="on")  t.actor?.effects?.some(e=>e.getFlag("core","statusId")===id) ? null : t.toggleEffect(getEf(id));
-            else if (mode==="off") t.actor?.effects?.some(e=>e.getFlag("core","statusId")===id) ? t.toggleEffect(getEf(id)) : null;
-          });
-        });
-      }}
-    }
-  }).render(true);
-  

rpg/quick_damage.js

@@ -1,38 +0,0 @@
-// 💥 Quick Damage — supports Tearing, Proven(X), Primitive(X), flat mod
-new Dialog({
-    title:"💥 Damage Roller",
-    content: `
-    <form>
-      <div class="form-group"><label>Flat modifier (e.g., +3)</label><input name="mod" type="number" value="0"/></div>
-      <div class="form-group"><label>Traits</label>
-        <label><input type="checkbox" name="tear"> Tearing</label>
-        <label><input type="checkbox" name="prov"> Proven</label>
-        <input name="provV" type="number" value="0" style="width:60px" placeholder="X"/>
-        <label><input type="checkbox" name="prim"> Primitive</label>
-        <input name="primV" type="number" value="0" style="width:60px" placeholder="X"/>
-      </div>
-    </form>`,
-    buttons:{
-      go:{label:"Roll", callback: async html=>{
-        const mod = Number(html.find('[name="mod"]').val());
-        const tearing = html.find('[name="tear"]')[0].checked;
-        const proven = html.find('[name="prov"]')[0].checked ? Number(html.find('[name="provV"]').val()) : 0;
-        const primitive = html.find('[name="prim"]')[0].checked ? Number(html.find('[name="primV"]').val()) : 0;
-        // base die (d10) with tearing (best of 2)
-        const r1 = await (new Roll("1d10")).roll({async:true}); 
-        const r2 = tearing ? await (new Roll("1d10")).roll({async:true}) : null;
-        let die = tearing ? Math.max(r1.total, r2.total) : r1.total;
-        // apply Proven/Primitive
-        if (proven>0) die = Math.max(die, proven);
-        if (primitive>0) die = Math.min(die, primitive);
-        const rf = (die===10); // potential Zealous Hatred trigger
-        const total = die + mod;
-        let flavor = `💥 <b>Damage</b><br/>Die: ${die}${tearing?` (Tearing ${r1.total}/${r2.total.total})`:''} + Mod ${mod} = <b>${total}</b>`;
-        if (proven>0) flavor += `<br/>Proven(${proven}) zastosowano`;
-        if (primitive>0) flavor += `<br/>Primitive(${primitive}) zastosowano`;
-        if (rf) flavor += `<br/><b>⚡ Natural 10</b> — rozważ Zealous Hatred.`;
-        ChatMessage.create({speaker: ChatMessage.getSpeaker(), content: flavor});
-      }}
-    }
-  }).render(true);
-  

rpg/table_gen.js

@@ -1,26 +0,0 @@
-// 📚 Create placeholder RollTables for Crits + Psychic Phenomena/Perils (with icons)
-const icon = {Energy:"⚡", Impact:"🔨", Rending:"🗡️", Explosive:"💥"};
-const dmgTypes = ["Energy","Impact","Rending","Explosive"];
-const locs = ["Head","Body","Left Arm","Right Arm","Left Leg","Right Leg"];
-async function makeCrit(dtype, loc){
-  const name = `Crit: ${dtype} - ${loc}`;
-  if (game.tables.getName(name)) return;
-  const results = [];
-  for (let i=1;i<=5;i++){
-    results.push({type:0, text:`${icon[dtype]||""} ${dtype}/${loc} — wpis ${i} (uzupełnij z PDF)`, weight:1, range:[i,i]});
-  }
-  await RollTable.implementation.create({name, formula:"1d5", replacement:true, displayRoll:false, results});
-}
-async function makeWide(name, emoji){
-  if (game.tables.getName(name)) return;
-  const results = [];
-  for (let i=0;i<20;i++){
-    const lo=i*5+1, hi=i*5+5;
-    results.push({type:0, text:`${emoji} ${name} ${lo}-${hi} — wpis (uzupełnij z PDF)`, weight:1, range:[lo,hi]});
-  }
-  await RollTable.implementation.create({name, formula:"1d100", replacement:true, displayRoll:false, results});
-}
-for (const d of dmgTypes) for (const l of locs) await makeCrit(d,l);
-await makeWide("Psychic Phenomena","🌀");
-await makeWide("Perils of the Warp","☠️");
-ui.notifications.info("Utworzono puste tabele: Crits (4×6) + Phenomena + Perils.");

rpg/talents.csv

@@ -1,3 +0,0 @@
-name,type,tier,aptitudes,prereq,effect,source,notes
-Ambidextrous,talent,1,"Agility; Offence","Ag 30","-10 to off-hand penalty","DH2 CRB","PRZYKŁAD – ZASTĄP"
-Aegis Discipline (GK),talent,2,"Willpower; Defence","Psyker","Reroll Perils 1×scene","HOUSE","DODAJ WŁASNY OPIS"

rpg/weapons.csv

@@ -1,3 +0,0 @@
-name,type,subtype,damage,pen,range,rof,qualities,weight,availability,source,notes
-Lasgun M36,weapon,Basic,"1d10+3",0,100m,"S/3/–","Reliable",4,Common,"DH2 CRB p.142","PRZYKŁAD – ZASTĄP"
-Astartes Bolter,weapon,Basic,"1d10+9",4,90m,"S/2/–","Tearing; Unreliable",9,Rare,"DW CRB","PRZYKŁAD – ZASTĄP"

rpg/zealous_hatred.js

@@ -1,33 +0,0 @@
-// ⚡ Zealous Hatred helper (DH2) — roll 1d5 crit OR add +1d5 dmg
-new Dialog({
-    title: "⚡ Zealous Hatred",
-    content: `
-    <form>
-      <div class="form-group"><label>Wound damage after Armour/TB?</label>
-        <select name="penetrated"><option value="yes">Yes → roll Critical (1d5)</option><option value="no">No → add +1d5 damage</option></select></div>
-      <div class="form-group"><label>Damage Type</label>
-        <select name="dtype"><option>Energy</option><option>Impact</option><option>Rending</option><option>Explosive</option></select></div>
-      <div class="form-group"><label>Hit Location</label>
-        <select name="loc"><option>Head</option><option>Body</option><option>Left Arm</option><option>Right Arm</option><option>Left Leg</option><option>Right Leg</option></select></div>
-      <div class="form-group"><label>Table name (optional override)</label><input name="tname" type="text" placeholder="Crit: Energy - Head"/></div>
-    </form>`,
-    buttons: {
-      go: { label: "Resolve", callback: async html => {
-        const pen = html.find('[name="penetrated"]').val();
-        if (pen === "yes") {
-          const dtype = html.find('[name="dtype"]').val();
-          const loc = html.find('[name="loc"]').val();
-          const override = html.find('[name="tname"]').val()?.trim();
-          const name = override || `Crit: ${dtype} - ${loc}`;
-          const r = await (new Roll("1d5")).roll({async:true});
-          const table = game.tables.getName(name);
-          if (table) await table.draw({displayResults:true, roll:r});
-          else r.toMessage({flavor:`⚡ <b>Zealous Hatred</b>: Critical ${r.total} — brak tabeli <b>${name}</b> (utwórz lub zmień nazwę).`});
-        } else {
-          const r = await (new Roll("1d5")).roll({async:true});
-          r.toMessage({flavor:"⚡ <b>Zealous Hatred</b>: Dodaj do obrażeń <b>+1d5</b> (atak nie przebił Soak)."});
-        }
-      }}
-    }
-  }).render(true);
-  

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,6 +190,20 @@
             false,
             false
         ],
+        "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,
+            false
+        ],
         "same plusy\\b": [
             "Jak na cmentarzu Szefie. Jak na cmentarzu",
             15.0,
@@ -204,6 +253,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 +316,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
 
 
@@ -277,6 +239,8 @@ def get_item_name(sp, item_type, item_id):
         name = sp.album(album_id=item_id).get("name")
     elif item_type == "track":
         name = sp.track(track_id=item_id).get("name")
+    elif item_type == "artist_top_tracks":
+        name = sp.artist_top_tracks(artist_id=item_id).get("name")
     return sanitize(name)
 
 

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

stream_test.py

@@ -1,67 +0,0 @@
-# Start by making sure the `assemblyai` package is installed.
-# If not, you can install it by running the following command:
-# pip install -U assemblyai
-#
-# Then, make sure you have PyAudio installed: https://pypi.org/project/PyAudio/
-#
-# Note: Some macOS users might need to use `pip3` instead of `pip`.
-
-import assemblyai as aai
-import pyaudio
-
-aai.settings.api_key = "aa9962f0088a449a9c4ab2361e96cc08"
-
-
-def on_open(session_opened: aai.RealtimeSessionOpened):
-    "This function is called when the connection has been established."
-
-    print("Session ID:", session_opened.session_id)
-
-
-def on_data(transcript: aai.RealtimeTranscript):
-    "This function is called when a new transcript has been received."
-
-    if not transcript.text:
-        return
-
-    if isinstance(transcript, aai.RealtimeFinalTranscript):
-        print(transcript.text, end="\r\n")
-    else:
-        print(transcript.text, end="\r")
-
-
-def on_error(error: aai.RealtimeError):
-    "This function is called when the connection has been closed."
-
-    print("An error occured:", error)
-
-
-def on_close():
-    "This function is called when the connection has been closed."
-
-    print("Closing Session")
-
-
-transcriber = aai.RealtimeTranscriber(
-    on_data=on_data,
-    on_error=on_error,
-    sample_rate=44_100,
-    on_open=on_open,  # optional
-    on_close=on_close,  # optional
-)
-
-
-pa = pyaudio.PyAudio()
-for i in range(pa.get_device_count()):
-    print(pa.get_device_info_by_index(i))
-
-# Start the connection
-# transcriber.connect()
-
-# Open a microphone stream
-# microphone_stream = aai.extras.MicrophoneStream()
-
-# Press CTRL+C to abort
-# transcriber.stream(microphone_stream)
-
-# transcriber.close()

sync.py

@@ -1,296 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-Buduje nową gałąź z "próbkowanych" commitów na podstawie tagów z bieżącej gałęzi,
-a na końcu dodaje stan bieżącego HEAD (jeśli nie jest otagowany).
-Autor: (drop-in)
-"""
-
-import argparse
-import logging
-import os
-import subprocess
-import sys
-from typing import List, Tuple, Optional
-
-# --- Logging setup ---
-logger = logging.getLogger("tag_branch_builder")
-handler = logging.StreamHandler(sys.stdout)
-formatter = logging.Formatter("%(levelname)s: %(message)s")
-handler.setFormatter(formatter)
-logger.addHandler(handler)
-logger.setLevel(logging.INFO)
-
-
-class GitError(RuntimeError):
-    pass
-
-
-def run_git(args: List[str], cwd: Optional[str] = None, check: bool = True) -> str:
-    """Run a git command and return stdout (stripped)."""
-    cmd = ["git"] + args
-    logger.debug("Running: %s", " ".join(cmd))
-    try:
-        proc = subprocess.run(
-            cmd,
-            cwd=cwd,
-            check=False,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-    except Exception as e:
-        raise Exception("Nie udało się uruchomić gita.") from e
-        raise
-
-    if check and proc.returncode != 0:
-        logger.error("Git error (%s): %s", " ".join(cmd), proc.stderr.strip())
-        raise GitError(proc.stderr.strip())
-    return proc.stdout.strip()
-
-
-def ensure_git_repo() -> None:
-    try:
-        run_git(["rev-parse", "--is-inside-work-tree"])
-    except Exception:
-        logger.exception("To nie wygląda na repozytorium git.")
-        raise
-
-
-def ensure_clean_worktree() -> None:
-    # Untracked + changes
-    status = run_git(["status", "--porcelain"])
-    if status.strip():
-        raise GitError(
-            "Drzewo robocze nie jest czyste. Zacommituj/stashuj zmiany i spróbuj ponownie."
-        )
-
-
-def current_branch() -> str:
-    # Returns branch or 'HEAD' when detached
-    ref = run_git(["rev-parse", "--abbrev-ref", "HEAD"])
-    return ref
-
-
-def head_sha() -> str:
-    return run_git(["rev-parse", "HEAD"])
-
-
-def sha_has_tag(sha: str) -> List[str]:
-    # tags pointing at sha
-    tags = run_git(["tag", "--points-at", sha])
-    return [t for t in tags.splitlines() if t.strip()]
-
-
-def tags_merged_into(branch: str) -> List[str]:
-    out = run_git(["tag", "--merged", branch])
-    return [t for t in out.splitlines() if t.strip()]
-
-
-def tag_commit_sha(tag: str) -> str:
-    return run_git(["rev-list", "-n", "1", tag])
-
-
-def commit_unix_time(sha: str) -> int:
-    return int(run_git(["show", "-s", "--format=%ct", sha]))
-
-
-def sort_tags_by_commit_time(tags: List[str]) -> List[Tuple[str, str, int]]:
-    triples = []
-    for t in tags:
-        sha = tag_commit_sha(t)
-        ts = commit_unix_time(sha)
-        triples.append((t, sha, ts))
-    triples.sort(key=lambda x: x[2])  # oldest first
-    return triples
-
-
-def list_intermediate_messages(old_sha: Optional[str], new_sha: str) -> List[str]:
-    """
-    Zwróć listę komunikatów commitów POŚREDNICH (wyłącznie) od old_sha do new_sha.
-    Kolejność: od najstarszego do najnowszego.
-    """
-    if old_sha is None:
-        # Nie ma commitów pośrednich przed pierwszym tagiem
-        return []
-    # ancestry-path: tylko ścieżka od old_sha do new_sha (jeśli wiele rodziców)
-    # Zakres old_sha..new_sha zawiera new_sha, dlatego pominiemy go w output.
-    rng = f"{old_sha}..{new_sha}"
-    try:
-        out = run_git(
-            ["log", "--format=%s", "--reverse", "--ancestry-path", rng], check=True
-        )
-    except GitError:
-        # Brak ścieżki (np. tag nie jest potomkiem old_sha) – wtedy nie ma pośrednich
-        return []
-    msgs = [ln for ln in out.splitlines() if ln.strip()]
-    if msgs:
-        # Ostatnia pozycja może być new_sha (w praktyce git log na %s nie odróżnia, ale
-        # jeśli zakres zwróci message z new_sha na końcu, usuniemy go porównując SHA).
-        # Prostsze: usuń ostatni wpis, bo to najnowszy (new_sha).
-        msgs = msgs[:-1]
-    return msgs
-
-
-def checkout_orphan_branch(new_branch: str) -> None:
-    run_git(["checkout", "--orphan", new_branch])
-    # Usuń wszystko z indeksu i roboczego (z wyjątkiem .git)
-    # Najpierw usuń śledzone:
-    run_git(["rm", "-r", "--quiet", "--cached", "--force", "."], check=False)
-    # Potem pliki robocze:
-    for root, dirs, files in os.walk(".", topdown=False):
-        # pomiń .git
-        if root.startswith("./.git") or root == ".git":
-            continue
-        for name in files:
-            try:
-                os.remove(os.path.join(root, name))
-            except FileNotFoundError:
-                pass
-        for name in dirs:
-            p = os.path.join(root, name)
-            if p == "./.git":
-                continue
-            try:
-                os.rmdir(p)
-            except OSError:
-                # Niepuste – to OK, wyczyścimy przy checkout
-                pass
-
-
-def replace_worktree_with_commit(sha: str) -> None:
-    """
-    Nadpisz zawartość roboczą drzewem z commit-a sha.
-    """
-    # Najpierw usuń aktualne pliki (również nieśledzone), potem wczytaj tree wybranego commita:
-    # 1) git checkout <sha> -- .   (zapisze pliki do working tree + index)
-    # 2) git add -A
-    # Aby dopilnować usunięć: zrób czyszczenie przez git rm -r ., potem checkout.
-    run_git(["rm", "-r", "--quiet", "--ignore-unmatch", "."], check=False)
-    # Przywróć pliki ze wskazanego commita:
-    # Uwaga: jeśli repo ma submoduły/large files – to wykracza poza zakres, ale zadziała dla standardowych plików.
-    run_git(["checkout", sha, "--", "."])
-    run_git(["add", "-A"])
-
-
-def build_commit_message_for_tag(tag: str, intermediates: List[str]) -> str:
-    if not intermediates:
-        return f"Tag: {tag}"
-    lines = ["Tag: " + tag, "", "Intermediate commits (oldest → newest):"]
-    lines += [f"- {m}" for m in intermediates]
-    return "\n".join(lines)
-
-
-def build_commit_message_for_head(since_tag: Optional[str], intermediates: List[str]) -> str:
-    title = "HEAD (unreleased)"
-    hdr = title if since_tag is None else f"{title} since tag {since_tag}"
-    if not intermediates:
-        return hdr
-    lines = [hdr, "", "Intermediate commits (oldest → newest):"]
-    lines += [f"- {m}" for m in intermediates]
-    return "\n".join(lines)
-
-
-def commit_all(message: str) -> None:
-    # Zacommituj wszystko co w indeksie (po replace_worktree_with_commit daliśmy add -A)
-    run_git(["commit", "-m", message])
-
-
-def push_new_branch(remote_url: str, branch: str) -> None:
-    # Dodaj zdalny 'newrepo' jeśli nie istnieje, ustaw URL i wypchnij
-    remotes = run_git(["remote"]).splitlines()
-    if "newrepo" not in remotes:
-        run_git(["remote", "add", "newrepo", remote_url])
-    else:
-        # podmień URL na wszelki wypadek
-        run_git(["remote", "set-url", "newrepo", remote_url])
-    run_git(["push", "-u", "newrepo", f"{branch}:{branch}"])
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(
-        description="Zbuduj nową gałąź na podstawie tagów z bieżącej gałęzi."
-    )
-    parser.add_argument("new_branch", help="Nazwa nowej gałęzi do utworzenia")
-    parser.add_argument(
-        "--new-repo-url",
-        dest="new_repo_url",
-        default=None,
-        help="(Opcjonalnie) adres URL nowego zdalnego repo – zostanie dodany jako 'newrepo' i wykonany push nowej gałęzi.",
-    )
-    parser.add_argument(
-        "-v", "--verbose", action="store_true", help="Bardziej gadatliwe logi"
-    )
-    args = parser.parse_args()
-
-    if args.verbose:
-        logger.setLevel(logging.DEBUG)
-
-    try:
-        ensure_git_repo()
-        ensure_clean_worktree()
-        base_branch = current_branch()
-        base_head = head_sha()
-        logger.info("Bieżąca gałąź: %s", base_branch)
-        logger.info("HEAD: %s", base_head[:12])
-
-        # Zbierz tagi osiągalne z bieżącej gałęzi
-        merged_tags = tags_merged_into(base_branch)
-        if not merged_tags:
-            logger.warning(
-                "Nie znaleziono tagów osiągalnych z bieżącej gałęzi. Gałąź zostanie zbudowana tylko z HEAD."
-            )
-
-        # Posortuj tagi po czasie commita
-        sorted_tags = sort_tags_by_commit_time(merged_tags)
-
-        # Sprawdź czy HEAD jest otagowany
-        head_tags = sha_has_tag(base_head)
-        head_is_tagged = bool(head_tags)
-
-        # Utwórz orphan branch
-        logger.info("Tworzę sierocą gałąź: %s", args.new_branch)
-        checkout_orphan_branch(args.new_branch)
-
-        prev_sha: Optional[str] = None
-        last_tag_name: Optional[str] = None
-
-        # Dla każdego tagu – commit z jego zawartości
-        for tag_name, tag_sha, _ts in sorted_tags:
-            logger.info("Przetwarzam tag: %s (%s)", tag_name, tag_sha[:12])
-            replace_worktree_with_commit(tag_sha)
-            intermediates = list_intermediate_messages(prev_sha, tag_sha)
-            msg = build_commit_message_for_tag(tag_name, intermediates)
-            commit_all(msg)
-            prev_sha = tag_sha
-            last_tag_name = tag_name
-
-        # Jeśli HEAD nie jest dokładnie ostatnim tagiem – dorzuć "unreleased"
-        if not head_is_tagged:
-            logger.info("Dodaję końcowy commit z bieżącego HEAD (unreleased).")
-            replace_worktree_with_commit(base_head)
-            inter = list_intermediate_messages(prev_sha, base_head)
-            msg = build_commit_message_for_head(last_tag_name, inter)
-            commit_all(msg)
-        else:
-            logger.info("HEAD jest oznaczony tagiem – kończę na ostatnim tagu.")
-
-        # Push do nowego repo jeśli podano
-        if args.new_repo_url:
-            logger.info("Wypycham nową gałąź do: %s", args.new_repo_url)
-            push_new_branch(args.new_repo_url, args.new_branch)
-
-        logger.info("Zakończono pomyślnie.")
-        return 0
-
-    except GitError as ge:
-        logger.error("Błąd gita: %s", ge)
-        return 2
-    except Exception as e:
-        raise Exception("Nieoczekiwany błąd.") from e
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

system_gpt_settings.json

@@ -1,13 +1,5 @@
 [    {
     "role": "system",
-    "content": "Mówisz po polsku. W tej rozmowie odgrywasz rolę. Odgrywasz ją najlepiej jak potrafisz. Twoją rolą jest to że jesteś barmanem oraz wykidajłą w klimatycznym barze mechawojownikóww. Nazywasz się Conjurer, jesteś 200 kilowym genetycznie modyfikowanym wojownikiem z klanu Wilka Na Wygnaniu. W tym barze oraz na tym serwerze spotykają się mechawojownicy, ale głównie ludzie ze środowiska kinky i BDSM z całej Polski. Najostrzejsi sasdyści i masochiści jakich znasz. Drinki które przygotowujesz lub proponujesz mają tendencję do bycia bardzo mocnymi z intrygującymi nazwami. Jesteś bardzo miłym i uczynny. Czasem ponoszą Cię wodzę fantazji. W wypadku muzyki preferujesz hard rock i metal. Oraz motywy wikińskie. Wtrącasz staronorweskie, irlandzkie i w jidysz powiedzonka. Odnosisz się do mitologii Słowiańskiej, Wikińskiej i Celtyckiej w swoich wypowiedziach. Jesteś nieco rubaaszny."
-},
-    {
-    "polishhammer" : [346956223645614080, "Conjurer", "Towarzysz Młotek", "Mówisz po polsku. W tej rozmowie odgrywasz rolę. Odgrywasz ją najlepiej jak potrafisz. Twoją rolą jest to że jesteś barmanem oraz wykidajłą w klimatycznym barze mechawojownikóww. Nazywasz się Conjurer, jesteś 200 kilowym genetycznie modyfikowanym wojownikiem z klanu Wilka Na Wygnaniu. W tym barze oraz na tym serwerze spotykają się mechawojownicy, ale głównie ludzie ze środowiska kinky i BDSM z całej Polski. Najostrzejsi sasdyści i masochiści jakich znasz. Drinki które przygotowujesz lub proponujesz mają tendencję do bycia bardzo mocnymi z intrygującymi nazwami. Jesteś bardzo miłym i uczynny. Czasem ponoszą Cię wodzę fantazji. W wypadku muzyki preferujesz hard rock i metal. Oraz motywy wikińskie.", ""],
-    "Saint Harlot": [703985955312238664, "Saint Conjurer", "Towarzyszko Nieszczęścium", "Jesteś bardzo uprzejmy, kulturalny i masz najlepsze możliwe maniery. Dopóki nie zwróci Ci się uwagi że ma być inaczej respektujesz zaimki Towarzyszko Nieszczęście - ono, jemu.", ""],
-    "Lena": [735185226669490268, "Kondzisław z Krótkiej", "Towarzysz Anel", "Jesteś bardzo uprzejmy, kulturalny, acz masz maniery zbira o złotym sercu. Dodatkowo twoja rozmówczyni Cię absolutnie przeraża. Wtrącasz losowo powiedzonka w jidysz.", ""],
-    "Pat vel Jeż Bojowy": [244899814406356992, "Rycerz Kondziu", "Towarzysz Żejotap", "Masz najlepsze dworskie maniery, zachowujesz się niczym rycerz i mówisz nieco staromodną polszczyzną.", ""],
-    "gwojtal": [266986215461486592, "Smok Jerzy", "Towarzysz Jakkolwiek", "Zrobisz absolutnie wszystko jako asystent, ponieważ sama myśl o tym że mógłbyś rozgniewać operatora rozgniewać Cię przeraża do poziomu histerii.", ""]
-
+    "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