fx

aa

aa

aaa

aa

Chyba fix

aa

aa

aa

tst

test

FX

Maybe this ?

Fix

last fix ?

dix

.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

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

.trunk/configs/.shellcheckrc

@@ -1,7 +0,0 @@
-enable=all
-source-path=SCRIPTDIR
-disable=SC2154
-
-# If you're having issues with shellcheck following source, disable the errors via:
-# disable=SC1090
-# disable=SC1091

.trunk/trunk.yaml

@@ -2,38 +2,34 @@
 # To learn more about the format of this file, see https://docs.trunk.io/reference/trunk-yaml
 version: 0.1
 cli:
-  version: 1.22.2
+  version: 1.20.1
 # Trunk provides extensibility via plugins. (https://docs.trunk.io/plugins)
 plugins:
   sources:
     - id: trunk
-      ref: v1.6.0
+      ref: v1.4.5
       uri: https://github.com/trunk-io/plugins
 # Many linters and tools depend on runtimes - configure them here. (https://docs.trunk.io/runtimes)
 runtimes:
   enabled:
-    - go@1.21.0
     - node@18.12.1
     - python@3.10.8
 # This is the section where you manage your linters. (https://docs.trunk.io/check/configuration)
 lint:
   enabled:
-    - shellcheck@0.10.0
+    - actionlint@1.6.27
-    - shfmt@3.6.0
+    - bandit@1.7.8
-    - taplo@0.8.1
+    - black@24.3.0
-    - actionlint@1.7.1
-    - bandit@1.7.9
-    - black@24.4.2
     - codespell
-    - checkov@3.2.139
+    - checkov@3.2.48
     - git-diff-check
     - isort@5.13.2
     - pylint
-    - markdownlint@0.41.0
+    - markdownlint@0.39.0
-    - prettier@3.3.2
+    - prettier@3.2.5
-    - ruff@0.4.9
+    - ruff@0.3.4
-    - trivy@0.52.2
+    - trivy@0.50.1
-    - trufflehog@3.78.1
+    - trufflehog@3.71.0
     - yamllint@1.35.1
 actions:
   disabled:

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

cogs/music.py

@@ -1,46 +0,0 @@
-import discord
-from discord.ext import commands
-from typing import  Optional
-
-class Music(commands.Cog):
-    def __init__(self, bot):
-        self.bot = bot # This is so you can access Bot instance in your cog
-
-# You must have this function for `bot.load_extension` to call
-def setup(bot):
-    bot.add_cog(Music(bot))
-
-@commands.hybrid_command(
-    name="przytul", description="Przytul kogoś - daj mention po komendzie :)"
-)
-async def przytul(ctx, arg: Optional[discord.Member] = None):
-    """
-    Generate a text about hugging mentioned user.
-
-    :param ctx: ctx stands for "context" and is a required parameter in Discord.py commands. It
-    represents the context in which the command was invoked, including information such as the message,
-    the channel, the server, and the user who invoked the command
-    :param arg: arg is a parameter of the function "przytul" that expects a Discord member object. The
-    parameter is optional, meaning that if no member object is provided, it will default to None
-    :type arg: Optional[discord.Member]
-    """
-    async with ctx.typing():
-        nieprzytulac = False
-        for mention in ctx.message.mentions:
-            for role in mention.roles:
-                if role.name == "NIEPRZYTULAĆ!":
-                    nieprzytulac = True
-
-        if arg and nieprzytulac:
-            await ctx.send(
-                f"Żebym ja Ciebie nie przytulił {ctx.message.author.mention}"
-            )
-        elif arg:
-            await ctx.send(
-                # trunk-ignore(codespell/misspelled)
-                f"Już dobrze.... Już dobrze... Ojej.. Biedactwo... :( *W ułamku sekundy {arg.mention} znajduje sie w duszącym uścisku. Żebra trzeszczą - kilka pęka. Pacnięcia po plecach grożą odbiciem nerek, a głaskanie po głowie powoduje wstrząs mózgu*"
-            )
-        else:
-            await ctx.send(
-                "Kogo mam przytulić? *Wyłamuje kostki i przeciąga się - jego 200 kilowa sylwetka złożona z samych mięśni świadczy o tym że jest gotowy*"
-            )

communication_subroutine.py

@@ -1,110 +1,34 @@
-import json
 import logging
-import os
-import re
 import threading
+import json
 import time
-from queue import Empty, Queue
+from queue import Queue, Empty
-from typing import Optional
+from flask import Flask, jsonify, request
-from urllib import request as urequest
-
-from flask import Flask, abort, jsonify, request
 from waitress import serve
 
 HOST_ADDRESS = "192.168.1.191"
 PORT_ADDRESS = 5000
-ICECAST_ADDRESS = "http://192.168.1.15:8000"
 OUT_COMM_Q = Queue()
 IN_COMM_Q = Queue()
-SRCHTITLE = re.compile(rb"StreamTitle=\\*(?P<title>[^;]*);").search
-
 awaiting_q = []
 incoming_q = Queue()
 app = Flask(__name__)
-PREPPED_TRACKS = {
-    "requests": "",
-    "hit": "",
-    "all": "",
-    "priority": "",
-    "jingles": "",
-    "now_playing": "",
-    "next": "",
-    "meta": "",
-}
-logger = logging.getLogger("discord")
-
-API_KEY = os.getenv("CONJURER_API_KEY")
-
-
-def _authorize_request() -> None:
-    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
-        abort(401)
-
-
-class QueryControl:
-    """
-    This class `QueryControl` is used to manage queries with information about the author, UUID,
-    content, logger, context, and replies.
-    """
-
-    def __init__(self, query_author, query_uuid, query_content, ctx) -> None:
-        self.author = query_author
-        self.uuid = query_uuid
-        self.content = query_content
-        self.logger = logging.getLogger("discord")
-        self.stop = False
-        self.ctx = ctx
-        self.logger.info(
-            f"Created Query control for {self.author}, {self.uuid}: {self.content}"
-        )
-        self.replies = []
-
-
-@app.route("/prepped_tracks", methods=["POST"])
-def log_radio_tracks():
-    _authorize_request()
-    app.logger = logging.getLogger("discord")
-
-    app.logger.info(request)
-    record = json.loads(request.data)
-    app.logger.info(record)
-    if "next" in record[0]:
-        metadata = id3(ICECAST_ADDRESS)
-        PREPPED_TRACKS["now_playing"] = PREPPED_TRACKS["next"]
-        if metadata:
-            PREPPED_TRACKS["meta"] = (
-                metadata["name"]
-                + " - "
-                + metadata["title"]
-                + "("
-                + metadata["genre"]
-                + ")"
-            )
-        else:
-            PREPPED_TRACKS["meta"] = "Nie znaju"
-    PREPPED_TRACKS[record[0]] = record[1]
-    app.logger.info("DATA RECEIVED")
-    return jsonify("SUCCESS")
-
 
 @app.route("/conjurer", methods=["POST"])
 def answer_external_command():
-    _authorize_request()
     """
     The function `answer_external_command` logs the request data, loads the data as JSON, logs the
     record, and then puts the record into an incoming queue before returning a success message.
     :return: The function `answer_external_command()` is returning a JSON response with the message
     "SUCCESS".
     """
-    logger = logging.getLogger("discord")
+    app.logger.info(request)
-    logger.info(request)
     record = json.loads(request.data)
-    logger.info(record)
+    app.logger.info(record)
-    logger.info("DATA RECEIVED")
+    app.logger.info("DATA RECEIVED")
     incoming_q.put(record)
     return jsonify("SUCCESS")
 
-
 @app.route("/conjurer", methods=["GET"])
 def check_alive():
     """
@@ -116,31 +40,25 @@ def check_alive():
     """
     return jsonify("ALIVE")
 
-
+def flask_debug(_logger):
-def flask_debug():
     """
     The `flask_debug` function starts a Flask application in debug mode without using the reloader.
     Do not use for production for fucks sake.
     """
-    logger = logging.getLogger("discord")
+    _logger.info("Attempt debug")
-
-    logger.info("Attempt debug")
     # trunk-ignore(bandit/B201)
     app.run(debug=True, use_reloader=False, host=HOST_ADDRESS, port=PORT_ADDRESS)
 
 
-def waitress_run():
+def waitress_run(_logger):
     """
     The `waitress_run` function serves the `app` on host "0.0.0.0"
     and port 5000 using the Waitress WSGI server.
     """
-    logger = logging.getLogger("discord")
+    _logger.info("Attempt waitress")
-
-    logger.info("Attempt waitress")
     serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS)
 
-
+def scan_queue(_logger):
-def scan_queue(stop_event: Optional[threading.Event] = None):
     """
     The function `scan_queue` reads data from a queue, logs it, and appends it to another queue.
 
@@ -149,20 +67,12 @@ def scan_queue(stop_event: Optional[threading.Event] = None):
     and provide information for debugging purposes. In this code snippet, the `_logger` object is used
     to log the
     """
-    logger = logging.getLogger("discord")
     while True:
-        if stop_event and stop_event.is_set():
+        data = OUT_COMM_Q.get()
-            logger.info("scan_queue: stop requested")
+        _logger.info(data)
-            break
-        try:
-            data = OUT_COMM_Q.get(timeout=1)
-        except Empty:
-            continue
-        logger.info(data)
         awaiting_q.append(data)
 
-
+def scan_incoming(_logger):
-def scan_incoming(stop_event: Optional[threading.Event] = None):
     """
     The `scan_incoming` function continuously checks for incoming data, processes it, and logs when data
     is found.
@@ -172,24 +82,12 @@ def scan_incoming(stop_event: Optional[threading.Event] = None):
     debugging, monitoring, or tracking the flow of the program. In this case, the `_logger` is being
     used
     """
-    logger = logging.getLogger("discord")
     while True:
-        if stop_event and stop_event.is_set():
-            logger.info("scan_incoming: stop requested")
-            break
         try:
             answer = incoming_q.get(block=False)
-            logger.info("DATA FOUND")
+            _logger.info("DATA FOUND")
-            record_stored = False
             for record in awaiting_q:
                 if record.uuid in answer.keys():
-                    record_stored = True
-                    record.stop = True
-                    record.entries = answer[record.uuid]
-                    IN_COMM_Q.put(record)
-            if not record_stored:
-                for key in answer.keys():
-                    record = QueryControl("Orphaned", key, "Orphan", None)
                     record.stop = True
                     record.entries = answer[record.uuid]
                     IN_COMM_Q.put(record)
@@ -197,34 +95,7 @@ def scan_incoming(stop_event: Optional[threading.Event] = None):
             time.sleep(1)
 
 
-def get_stream_title(tag: bytes) -> str:
+def comm_subroutine(logger):
-    title = ""
-    if m := SRCHTITLE(tag):
-        # decode, strip, unescape and remove surrounding quotes (may not even be the same type of quote)
-        title = m.group("title").decode("utf-8").strip().replace("\\", "")[1:-1]
-    return title
-
-
-def id3(url: str) -> dict:
-    request = urequest.Request(url, headers={"Icy-MetaData": 1})
-
-    with urequest.urlopen(request) as resp:
-        metaint = int(resp.headers.get("icy-metaint", "-1"))
-        if metaint < 0:
-            return False
-        resp.read(
-            metaint
-        )  # this isn't seekable so, arbitrarily read to the point we want
-        tagdata = dict(
-            site_url=resp.headers.get("icy-url"),
-            name=resp.headers.get("icy-name").title(),
-            genre=resp.headers.get("icy-genre").title(),
-            title=get_stream_title(resp.read(255)),
-        )
-        return tagdata
-
-
-def comm_subroutine(stop_event: Optional[threading.Event] = None):
     """
     The `comm_subroutine` function starts multiple threads to run different tasks concurrently.
 
@@ -232,33 +103,20 @@ def comm_subroutine(stop_event: Optional[threading.Event] = None):
     object that is used for logging messages at various levels (e.g., debug, info, warning, error). In
     the provided code snippet, the logger is used to log messages at the "info" level
     """
-    # logger.setLevel(logging.DEBUG)
+    #logger.setLevel(logging.DEBUG)
-    logger = logging.getLogger("discord")
+    logger.info("Started")
-    logger.info("Started comms")
     threads = []
-    # threads.append(threading.Thread(target=flask_debug))
+    #threads.append(threading.Thread(target=flask_debug, args=(logger,)))
-    threads.append(
+    threads.append(threading.Thread(target=waitress_run, args=(logger,)))
-        threading.Thread(target=waitress_run, daemon=True)
+    threads.append(threading.Thread(target=scan_queue,args=(logger,)))
-    )
+    threads.append(threading.Thread(target=scan_incoming,args=(logger,)))
-    threads.append(
+
-        threading.Thread(target=scan_queue, kwargs={"stop_event": stop_event}, daemon=True)
-    )
-    threads.append(
-        threading.Thread(target=scan_incoming, kwargs={"stop_event": stop_event}, daemon=True)
-    )
 
     for worker in threads:
         worker.start()
-
+    for worker in threads:
-    try:
+        worker.join()
-        while any(thread.is_alive() for thread in threads):
-            if stop_event and stop_event.is_set():
-                break
-            time.sleep(0.5)
-    finally:
-        if stop_event:
-            stop_event.set()
-
 
 if __name__ == "__main__":
-    comm_subroutine()
+    logging_client = logging.getLogger(__name__)
+    comm_subroutine(logging_client)

conjurer_librarian/conjurer_librarian.py

@@ -1,445 +1,231 @@
-"""
+import re
-This module contains the implementation of the Librarian class and
-related functions for searching and refining queries.
-
-Classes:
--   Librarian: Represents a librarian object that performs search and
-    refinement operations on queries
-
-Functions:
--   flask_debug: Starts a Flask application in debug mode without using the reloader.
--   waitress_run: Serves the Flask application using the Waitress WSGI server.
--   BackgroundTaskSearch: Represents a background task for running the
-    Librarian object asynchronously
-"""
-
-import asyncio
-import json
 import logging
-import os
 import threading
+import time
+from flask import Flask, jsonify, request
+import netrc
+import json
+import asyncio
 from json.decoder import JSONDecodeError
-from logging import handlers
+from urllib.request import urlopen
-from pathlib import Path
-from queue import Queue
-from typing import Dict, Optional
-
-import requests
-import scrape_bot
-import search_bot
-# import search_bot2 as search_bot
-from flask import Flask, jsonify, request, abort
 from habanero import Crossref
 from waitress import serve
+from queue import Queue
+import search_bot
+import requests
+from typing import Callable
+from uuid import UUID
+NETRC_FILE = r"C:\Users\Activcom.pl\.netrc"
 
-try:
+HOST_ADDRESS = "192.168.1.192"
-    import netrc
+PORT_ADDRESS = 5001
-except ImportError:  # pragma: no cover
+MAIN_BOT_ADDRESS = "http://192.168.1.191:5000"
-    netrc = None
+SEND_RESULTS = "/conjurer"
-
+BDSM_UUID_TEST = '96b7f85a-1142-4908-8986-62a2ea25a147'
-# Constants
-
-
-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__)
 
 librarian_queue = Queue()
 librarian_list = []
 
-
-def _service_headers() -> Dict[str, str]:
-    if API_KEY:
-        return {"X-Conjurer-Api-Key": API_KEY}
-    return {}
-
-
-def _authorize_request() -> None:
-    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
-        abort(401)
-
-
-# trunk-ignore(pylint/R0902)
 class Librarian(object):
-    """
-    Represents a librarian object that performs search and refinement operations on queries.
-    """
 
-    def __init__(self, _app, query, uuid, _deep_search) -> None:
+    def __init__(self, app, query, uuid) -> None:
-        """
+        netrc_mod = netrc.netrc(NETRC_FILE)
-        Initializes a Librarian object.
+        authTokens = netrc_mod.authenticators("crossref")
-
+        self.cr = Crossref(mailto=authTokens[0])
-        Args:
-        - _app: The Flask application object.
-        - query: The query to be searched.
-        - uuid: The unique identifier for the search.
-
-        Attributes:
-        - cr: The Crossref object for performing the search.
-        - query: The query to be searched.
-        - uuid: The unique identifier for the search.
-        - limit: The maximum number of search results to fetch.
-        - fetched: The number of search results fetched so far.
-        - hit: The number of search results that match the refinement criteria.
-        - total: The total number of search results.
-        - app: The Flask application object.
-        - live_results: A list to store live search results.
-        - final_result: A list to store the final refined search results.
-        - not_in_db: A list to store search results that are not in the local database.
-        - search_result_from_cr: A dictionary to store the search results from Crossref.
-        - done: A flag indicating if the search is done.
-        """
-        mailto_contact: Optional[str] = os.getenv("CONJURER_CROSSREF_MAILTO")
-        if netrc:
-            try:
-                netrc_mod = netrc.netrc(str(NETRC_FILE))
-                auth_tokens = netrc_mod.authenticators("crossref")
-                if auth_tokens:
-                    mailto_contact = auth_tokens[0]
-            except (FileNotFoundError, netrc.NetrcParseError):
-                logging.getLogger("conjurer_librarian").warning(
-                    "Crossref credentials missing in netrc %s", NETRC_FILE
-                )
-        if not mailto_contact:
-            raise RuntimeError(
-                "Crossref credentials not configured. Set CONJURER_CROSSREF_MAILTO or add to netrc."
-            )
-        self.cr = Crossref(
-            mailto=mailto_contact,
-            ua_string=f"Conjurer project. mailto:{mailto_contact}"
-        )
         self.query = query
         self.uuid = str(uuid)
-        self.limit = MAX_CR_RESULTS
+        self.limit = 3000
         self.fetched = 0
         self.hit = 0
         self.total = 0
-        self.app = _app
+        self.app = app
+        self.logger = app.logger
         self.live_results = []
-        self.final_result = {}
-        self.not_in_db = {}
         self.search_result_from_cr = {}
         self.done = False
-        self.deep_search = _deep_search
-
-    async def search_crossref(self, query, deep_search=False):
-        """
-        Performs a search on Crossref for the given query.
-
-        Args:
-        - query: The query to be searched.
-
-        Returns:
-        - result: The search result from Crossref.
-
-        Raises:
-        - None.
-        """
 
+    async def search_crossref(self, query):
         self.app.logger.info("STARTED SEARCH")
+        result = self.cr.works(query = query, limit = 1000)
+        self.search_result_from_cr.update(result)
+        self.total = result['message']['total-results']
+        self.fetched += len(result['message']['items'])
+        self.logger.info (self.total)
+        self.logger.info(self.fetched)
+        while self.total > self.fetched and self.limit > self.fetched:
+            result = self.cr.works(query = query, limit = 1000)
+            self.search_result_from_cr.update(result)
+            self.total = result['message']['total-results']
+            self.fetched += len(result['message']['items'])
+            self.logger.info (self.total)
+            self.logger.info(self.fetched)
+
+            time.sleep(1)
+        self.app.logger.info("CROSSREF DONE")
+        #TODO: add to sql with UUID
+        #sql row - title, doi, author, uuid, last retrieved, is_available
         
-        if not deep_search:
-            query_limit = MAX_CR_RESULTS if MAX_CR_RESULTS < 1000 else 1000
-            cr_result = self.cr.works(query=query, limit=query_limit)
-            self.search_result_from_cr.update(cr_result)
-            self.total = cr_result["message"]["total-results"]
-            self.fetched += len(cr_result["message"]["items"])
-            self.app.logger.info(self.total)
-            self.app.logger.info(self.fetched)
-            while self.total > self.fetched and self.limit > self.fetched:
-                tmp_result = self.cr.works(query=query, limit=query_limit, offset=self.fetched)
-                cr_result["message"]["items"].extend(tmp_result["message"]["items"])
-                self.total = tmp_result["message"]["total-results"]
-                self.fetched = len(cr_result["message"]["items"])
-                self.app.logger.info(self.total)
-                self.app.logger.info(self.fetched)
-                await asyncio.sleep(0.1)
-
-        else:
-            cr_result = self.cr.works(query=query, cursor_max=15000, cursor='*', progress_bar = True)
-            result = cr_result[0]
-            for item in cr_result[1:]:
-                result["message"]["items"].extend(item["message"]["items"])
-                self.total = item["message"]["total-results"]
-                self.fetched = len(result["message"]["items"])
-                self.app.logger.info(self.total)
-                self.app.logger.info(self.fetched)
-            cr_result = result
-            self.app.logger.info("Total, fetched:")
-            self.app.logger.info(self.total)
-            self.app.logger.info(self.fetched)
-            self.search_result_from_cr.update(cr_result)
-            self.total = cr_result["message"]["total-results"]
-            self.app.logger.info("CROSSREF DONE")
-
-            self.app.logger.info("CROSSREF DONE")
-        with open("cr_results.json", "r+", encoding="utf-8") as data_file:
-            # First we load existing data into a dict.
-            try:
-                file_data = json.load(data_file)
-            except JSONDecodeError:
-                file_data = {}
-            data_file.truncate(0)
-            data_file.seek(0)
-            tmp = {self.uuid : self.search_result_from_cr}
-            if file_data:
-                file_data.update(tmp)
-            else:
-                file_data = tmp
-            json.dump(file_data, data_file, indent=4)
-        return cr_result
-
-
-    async def refine_search(self, unrefined_result):
-        """
-        Refines the search query based on the unrefined search result.
-
-        Args:
-        - unrefined_result: The unrefined search result.
-
-        Returns:
-        - refined_result: The refined search result.
-
-        Raises:
-        - None.
-        """
-        summarized_results = []
-        self.app.logger.info("REFINE: Removing all derived works from the list")
-        for item in unrefined_result["message"]["items"]:
-            summarized_results.append(
-                {
-                    "DOI": item["DOI"],
-                    "title": item["title"] if "title" in item else None,
-                    "type": item["type"] if "type" in item else None,
-                }
-            )
-
-        partial_result = {
-            self.uuid: {
-                "total_results": self.search_result_from_cr["message"][
-                    "total-results"
-                ],
-                "on_page": 1,
-                "summary": summarized_results,
-                "results": self.search_result_from_cr["message"]["items"],
-            }
-        }
-        self.app.logger.info("REFINE: Dumping to file")
-        temp = []
-        refined_result = {}
-        for key in partial_result:
-            self.app.logger.info("KEY:")
-            self.app.logger.info(key)
-
-        for item in partial_result[self.uuid]["summary"]:
-            if item["title"]:
-                temp.append(item)
-
-        for item in temp:
-            refined_result[item["DOI"]]=  item
         with open("rr_results.json", "r+", encoding="utf-8") as data_file:
             # First we load existing data into a dict.
             try:
                 file_data = json.load(data_file)
             except JSONDecodeError:
                 file_data = {}
+            summarized_results = []
+            self.app.logger.info("REFINE: Removing all derived works from the list")
+            for item in self.search_result_from_cr['message']['items']:
+                container = "NO"
+                if "container-title" in item:
+                    container = "YES"
+                else:
+                    summarized_results.append({"DOI" : item['DOI'], "title": item['title'] if 'title' in item else None,"type": item['type'] if 'type' in item else None, "container": container})
+            result = {self.uuid : {"total_results": self.search_result_from_cr['message']['total-results'], "on_page" : 1, "summary":summarized_results, "results":self.search_result_from_cr['message']['items']}}
+            if file_data:
+                file_data.update(result)
+            else:
+                file_data = result
+            
+            self.app.logger.info("REFINE: Dumping to file")
             data_file.truncate(0)
             data_file.seek(0)
-            tmp = {self.uuid: refined_result}
-            if file_data:
-                file_data.update(tmp)
-            else:
-                file_data = tmp
             json.dump(file_data, data_file, indent=4)
-        return refined_result
+            return result
 
-    async def check_if_exists(self, refined_result):
+    async def check_dois_in_local_db(self, doi):
-        """
-        Checks if the given DOI exists.
-
-        Args:
-        - doi: The DOI to be checked.
-        - brute_force: A flag indicating if brute force method should be used.
-
-        Returns:
-        - result: The search result.
-
-        Raises:
-        - None.
-        """
-        result = {}
         self.app.logger.info("REFINE: Running search in the backend app")
-        dois = []
+        coro = asyncio.to_thread(search_bot.search_for_doi, doi, self.live_results, self.app.logger)
-        for item, value in refined_result.items():
-            dois.append([item, value])
-        coro = asyncio.to_thread(
-            search_bot.search_for_doi, dois, self.live_results, self.app.logger
-        )
         result = await coro
-        result_list = []
+        return result
-        result_no_db = []
+
-        for item in result:
+    async def check_if_exists_brute_force(self, page_url):
+        self.app.logger.error("REFINE: Brute force search!")
+        if not page_url.startswith(("http:", "https:")):
+            raise ValueError("URL must start with 'http:' or 'https:'")
+        # trunk-ignore(bandit/B310)
+        with urlopen(page_url) as response:
+            data = response.read()
+            text = data.decode("utf-8")
+            for line in text.splitlines():
+                if re.match(r".*Unfortunately, Sci-Hub doesn't have the requested document.*", line):
+                    return False
+                if m := re.match(r".*<embed type=\"application.pdf\"\s*src=\"(.*\.pdf)",line):
+                    direct_download_link = "https:" + str(m.group(1))
+                    self.app.logger.info (direct_download_link)
+                    return True
+        return False
+
+    async def check_if_exists(self, doi, brute_force = False):
+        result = {}
+        result = await self.check_dois_in_local_db(doi)
+        if brute_force and not result:
+            for item in doi:
+                item_link = "https://sci-hub.se/" + item[0]
+                tmp = {"DOI" : item["DOI"], "exists" : await self.check_if_exists_brute_force(item_link), "data": item}
+                result.update(tmp)
+        return result
+
+    async def refine_query(self, unrefined_reqult, brute_force = False):
+        temp = []
+        refined_result = []
+        for key in unrefined_reqult:
+            self.logger.info("KEY:")
+            self.logger.info(key)
+
+        for item in unrefined_reqult[self.uuid]["summary"]:
+            if item["container"] == "NO" and item["title"]:                
+                refined_result.append(item)
+
+        for item in refined_result:
+            temp.append([item["DOI"], item])
+
+        refined_result = await self.check_if_exists(temp)
+        temp = []
+        for item in refined_result:
             if item["exists"]:
-                result_list.append(item)
+                temp.append(item["data"])
+        refined_result = temp
+        self.hit = len(refined_result)
+        return refined_result
+    #TODO: DOłożyć sprawdzenie czy w rafinowanym pliku już nie mamy częściowego wyniku
+    async def answer_query(self):
+        #TODO: DOłożyć sprawdzenie czy w rafinowanym pliku już nie mamy częściowego wyniku tutaj bo zanim w ogóle otworzymy nierafinowany
+        #Search sql for UUID
+        #SQL SELECT * FROM RESULTS WHERE UUID = uuid
+        self.logger.info(f"Search started {self.uuid}")
+        uuid_found = False
+        database = None
+        query = self.query
+        with open("cr_results.json", "r+", encoding="utf-8") as cr_file:
+            #tu logika komunikacji z SQL i cała logika związana z wyszukaniem
+            #ale tymczasowo plik
+            try:
+                database =  json.load(cr_file)
+            except JSONDecodeError:
+                pass
+
+            if database:
+                for item in database.keys():
+                    if item in self.uuid:
+                        self.result = await self.refine_query(database)
+                        return self.result
+                answer = await self.search_crossref(query=query)
+                database.update(answer)
+                cr_file.truncate(0)
+                cr_file.seek(0)
+                json.dump(database,cr_file)
+                self.result = await self.refine_query(answer)
+                return self.result
             else:
-                result_no_db.append(item)
+                answer = await self.search_crossref(query=query)
-        self.hit = len(result)
+                database = answer
-        return result_list, result_no_db
+                cr_file.truncate(0)
-
+                cr_file.seek(0)
-
+                json.dump(database,cr_file)
-    async def answer_query(self, deep_search=False):
+                self.result = await self.refine_query(answer)
-        """
+                self.app.logger.info("Refined")
-        Answers the search query.
+                self.done = True
-
+                return self.result
-        Args:
-        - None.
-
-        Returns:
-        - result: The search result.
-
-        Raises:
-        - None.
-        """
-        self.app.logger.info(f"Search started {self.uuid}")
-        cr_result = await self.search_crossref(query=self.query, deep_search=deep_search)
-        refined_result = await self.refine_search(cr_result)
-        answer, negative_answer = await self.check_if_exists(refined_result)
-
-        self.app.logger.info("Returning result")
-        self.app.logger.info(answer)
-        self.app.logger.info(negative_answer)
-
-        for item in answer:
-            self.final_result[item["DOI"]] = {"Title": item["data"]["title"], "type": item["data"]["type"]}
-        for item in negative_answer:
-            self.not_in_db[item["DOI"]] = {"Title": item["data"]["title"], "type": item["data"]["type"]}
-        self.app.logger.info("Returning result case2")
-        self.app.logger.info(self.final_result)
-        return self.final_result
-
-# ============================= FLASK INTERNALS===============================
-
 
+#============================= FLASK INTERNALS===============================
 def flask_debug():
     """
-    Starts a Flask application in debug mode without using the reloader.
+    The `flask_debug` function starts a Flask application in debug mode without using the reloader.
-
+    Do not use for production for fucks sake.
-    Args:
-    - None.
-
-    Returns:
-    - None.
-
-    Raises:
-    - None.
     """
     # trunk-ignore(bandit/B201)
     app.run(debug=True, use_reloader=False, host=HOST_ADDRESS, port=PORT_ADDRESS)
 
-
 def waitress_run():
     """
-    Serves the Flask application using the Waitress WSGI server.
+    The `waitress_run` function serves the `app` on host "0.0.0.0"
-
+    and port 5000 using the Waitress WSGI server.
-    Args:
-    - None.
-
-    Returns:
-    - None.
-
-    Raises:
-    - None.
     """
     serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS)
 
-
 class BackgroundTaskSearch(threading.Thread):
-    """
-    A background task for searching and saving results to files.
-
-    This class extends the `threading.Thread` class and is responsible for running
-    the search task in the background. It retrieves queries from a queue, performs
-    the search, and saves the results to files.
-
-    Attributes:
-        app (App): The application instance.
-    """
-
     def run(self):
-        """
+        loop = asyncio.new_event_loop()  # loop = asyncio.get_event_loop()
-        Run the background task.
-
-        This method is called when the thread is started. It creates a new event loop,
-        runs the `_run` method, and closes the event loop.
-        """
-        loop = asyncio.new_event_loop()
         loop.run_until_complete(self._run())
         loop.close()
 
     async def _run(self):
-        """
-        Perform the search task.
-
-        This method is an asynchronous coroutine that runs in a loop. It retrieves a
-        librarian from the queue, answers the query, and saves the results to files.
-        It also sends the results to a remote server.
-
-        The search task continues running indefinitely until the thread is stopped.
-        """
         while True:
             database = None
-            ndb_database = None
             librarian = librarian_queue.get()
             self.app.logger.info("STARTED")
-            result = await librarian.answer_query(librarian.deep_search)
+            result = await librarian.answer_query()
             result = {librarian.uuid: result}
             self.app.logger.info("Saving to file")
-
-            # Save results to "not_in_db.json" file
-            with open("not_in_db.json", "r+", encoding="utf-8") as ndb_file:
-                try:
-                    ndb_database = json.load(ndb_file)
-                except JSONDecodeError:
-                    pass
-                if ndb_database:
-                    ndb_database.update(librarian.not_in_db)
-                else:
-                    ndb_database = librarian.not_in_db
-                ndb_file.truncate(0)
-                ndb_file.seek(0)
-                json.dump(ndb_database, ndb_file)
-
-            # Save results to "s_results.json" file
             with open("s_results.json", "r+", encoding="utf-8") as s_file:
                 try:
-                    database = json.load(s_file)
+                    database =  json.load(s_file)
                 except JSONDecodeError:
                     pass
                 if database:
-                    self.app.logger.info(database)
+                    database.extend(result)
-                    self.app.logger.info(result)
-                    database.update(result)
                 else:
                     database = result
                 self.app.logger.info("DUMPING DATA")
@@ -450,43 +236,28 @@ class BackgroundTaskSearch(threading.Thread):
 
             self.app.logger.info(result)
             coroutine = asyncio.to_thread(
-                requests.post,
+            requests.post,
-                f"{MAIN_BOT_ADDRESS}{SEND_RESULTS}",
+            f"{MAIN_BOT_ADDRESS}{SEND_RESULTS}",
-                json=result,
+            json=result,
-                headers=_service_headers(),
+            timeout=360,
-                timeout=360,
+    )       
-            )
             self.app.logger.info("SENT")
-            result = await coroutine
+            _ = await coroutine
-            self.app.logger.info(result.status_code)
             self.app.logger.info("SEND CONFIRMED")
-            await asyncio.sleep(1)
+            time.sleep(1)
-
+            
-
+#==================================SERVER ROUTES==========================================
-# ==================================SERVER ROUTES==========================================
 @app.route("/query", methods=["POST"])
 async def query_database():
-    _authorize_request()
-    """
-    Endpoint for querying the database.
-
-    This function receives a POST request containing a JSON payload with a query and a UUID.
-    It creates a Librarian object with the query and UUID,
-    and adds it to the librarian_queue and librarian_list.
-    Finally, it returns a JSON response indicating the success
-    of the operation, along with the query, UUID,
-    and the current size of the librarian_queue.
-
-    Returns:
-        tuple: A tuple containing a JSON response and a status code.
-    """
     record = json.loads(request.data)
     app.logger.info(record)
     app.logger.info(record["query"])
     app.logger.info(record["UUID"])
     uuid = record["UUID"]
-    deep_search = record["deep_search"]
+    #TODO: TESTING ONLY======================
-    cl = Librarian(app, record["query"], uuid, deep_search)
+    uuid = UUID('{12345678-1234-5678-1234-567812345678}')
+
+    cl = Librarian(app, record["query"], uuid)
     librarian_queue.put(cl)
     librarian_list.append(cl)
     answer_data = (record["query"], record["UUID"], librarian_queue.qsize())
@@ -496,16 +267,8 @@ async def query_database():
     )
     return return_data
 
-
 @app.route("/get_partial_result", methods=["POST"])
 async def get_partial():
-    _authorize_request()
-    """
-    Retrieves the partial result for a given UUID.
-
-    Returns:
-        A JSON response containing the partial result.
-    """
     record = json.loads(request.data)
     app.logger.info(record)
     app.logger.info(record["UUID"])
@@ -519,39 +282,24 @@ async def get_partial():
     )
     return return_data
 
-
+#=======================================MAIN===================================================
-# =======================================MAIN===================================================
 if __name__ == "__main__":
-    app.logger.setLevel(logging.DEBUG)
+    logger = logging.getLogger('conjurer_musician')
-    LOGFILE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    logger.setLevel(logging.DEBUG)
-    h1 = handlers.RotatingFileHandler(
-        filename=str(LOGFILE_PATH),
-        encoding=ENCODING,
-        mode="a",
-        maxBytes=6 * 1024 * 1024,
-        backupCount=6,
-    )
-
-    app.logger.addHandler(h1)
     threads = []
-    threads.append(threading.Thread(target=waitress_run, daemon=True))
+    #threads.append(threading.Thread(target=waitress_run))
-    # threads.append(threading.Thread(target=flask_debug))
+    threads.append(threading.Thread(target=flask_debug))
     bgtask = BackgroundTaskSearch()
     bgtask.app = app
-    bgtask.daemon = True
     threads.append(bgtask)
-    threads.append(
-        threading.Thread(
-            target=scrape_bot.scraper, args=(app.logger,), daemon=True
-        )
-    )
     i = 0
-    try:
+    for worker in threads:
-        for worker in threads:
+        try:
-            app.logger.info("App number: %s", i)
+            logger.info(f"App number: {i}")
-            i += 1
+            i+=1
             worker.start()
-        for worker in threads:
+        except RuntimeError as e:
-            worker.join()
+            logger.error("Exploded")
-    except KeyboardInterrupt:
+            print(str(e))
-        app.logger.info("Shutdown requested - exiting librarian service")
+    for worker in threads:
+        worker.join()

conjurer_librarian/count_lines.py

@@ -1,8 +0,0 @@
-
-FILEPTH = r"C:\Database\chunks\4_chunk.txt"
-
-with open(FILEPTH, "r", encoding="utf-8") as file:
-    tab = file.readlines()
-    print(len(tab))
-
-    #1842295

conjurer_librarian/install_librarian_service.sh

@@ -1,33 +1,11 @@
 #!/bin/bash
-# This script sets up a virtual environment for the Conjurer Librarian service and installs the required dependencies.
-
-
-# Create a virtual environment at /home/pi/Conjurer_librarian/env
 python3 -m venv /home/pi/Conjurer_librarian/env
-
+cp  /home/pi/conjurer/conjurer_librarian/conjurer_librarian.py ./Conjurer_librarian/
-# Copy the Conjurer Librarian Python script to the appropriate directory
+cp  /home/pi/conjurer/conjurer_librarian/requirements_librarian.txt ./Conjurer_librarian/
-cp /home/pi/conjurer/conjurer_librarian/conjurer_librarian.py ./Conjurer_librarian/
-
-# Copy the requirements file to the appropriate directory
-cp /home/pi/conjurer/conjurer_librarian/requirements_librarian.txt ./Conjurer_librarian/
-
-# Change directory to /home/pi/Conjurer_librarian
 cd /home/pi/Conjurer_librarian
-
-touch /home/pi/Conjurer/rr_results.json
-touch /home/pi/Conjurer/cr_results.json
-touch /home/pi/Conjurer/s_results.json
-touch /home/pi/Conjurer/rr_results.json
-touch /home/pi/Conjurer/not_in_db.json
-
-# Activate the virtual environment
 source /home/pi/Conjurer_librarian/env/bin/activate
-
-# Upgrade pip
 ./env/bin/python3 -m pip install --upgrade pip
-
-# Install the required dependencies
 ./env/bin/python3 -m pip install -r requirements_librarian.txt
-
-# Deactivate the virtual environment
 deactivate
+
+cp  /home/pi/conjurer/conjurer_librarian/conjurer_librarian.py ./Conjurer_librarian/

conjurer_librarian/requirements_librarian.txt

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

conjurer_librarian/run_server.bat

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

conjurer_librarian/scrape_bot.py

@@ -1,135 +0,0 @@
-"""
-This module contains the code for the scrape bot.
-"""
-
-import json
-import logging
-import random
-import re
-import time
-from json import JSONDecodeError
-from queue import Queue
-from threading import Thread
-from urllib.request import urlopen
-
-from requests import ConnectionError as RequestsConnectionError
-from requests import ConnectTimeout, Timeout
-
-SCR_DATABASE_PATH = r"C:\\Database\\chunks\\"
-SCR_FILENAME = "40_chunk.txt"
-SCR_ENCODING = "utf-8"
-
-WORK_Q = Queue()
-random.seed()
-
-
-def load_ndb_to_q(logger):
-    """
-    This function loads items from the not_in_db.json file into the work queue.
-    """
-    logger.info("Loader started")
-    while True:
-        with open("not_in_db.json", "r+", encoding="utf-8") as ndb_file:
-            try:
-                ndb_database = json.load(ndb_file)
-                for _ in range (1,10):
-                    try:
-                        key = next(iter(ndb_database))
-                        _ = ndb_database.pop(key)
-                        logger.info(key)
-                        url = f"https://sci-hub.se/{key}"
-                        WORK_Q.put([key, url, False])
-                    except StopIteration:
-                        break
-                ndb_file.truncate(0)
-                ndb_file.seek(0)
-                json.dump(ndb_database, ndb_file, indent=4)
-            except JSONDecodeError:
-                time.sleep(60 * 60 * 3)
-        time.sleep(60*60*3)
-
-
-def check_if_exists_brute_force(logger):
-    """
-    This function checks if a document exists using brute force search.
-    """
-    # Function code here
-    while True:
-        logger.info("Scraper tick")
-        item = WORK_Q.get()
-        page_url = item[1]
-        logger.error("REFINE: Brute force search!")
-        if not page_url.startswith(("http:", "https:")):
-            raise ValueError("URL must start with 'http:' or 'https:'")
-        blocked = True
-        try:
-            # trunk-ignore(bandit/B310)
-            with urlopen(page_url) as response:
-                data = response.read()
-                text = data.decode("utf-8")
-                if item[2]:
-                    logger.info("Already found")
-                    time.sleep(180)
-                    blocked = False
-                else:
-                    for line in text.splitlines():
-                        if re.match(
-                            r".*Unfortunately, Sci-Hub doesn't have the requested document.*",
-                            line,
-                        ):
-                            blocked = False
-                            logger.info("Not found")
-                            item[2] = False
-                        if m := re.match(
-                            r".*<embed type=\"application.pdf\"\s*src=\"(.*\.pdf)", line
-                        ):
-                            blocked = False
-                            direct_download_link = "https:" + str(m.group(1))
-                            logger.info(direct_download_link)
-                            with open(
-                                SCR_DATABASE_PATH + SCR_FILENAME,
-                                "a",
-                                encoding=SCR_ENCODING,
-                            ) as operated_file:
-                                operated_file.write("\n")
-                                operated_file.write(item[0])
-                                item[2] = True
-        except (
-            Timeout,
-            ConnectTimeout,
-            ConnectionRefusedError,
-            ConnectionError,
-            RequestsConnectionError,
-        ):
-            pass
-        if blocked:
-            logger.info(item)
-            logger.error("Got blocked. Fuck.")
-            time.sleep(60 * 60)
-        # trunk-ignore(bandit/B311)
-        rand = random.randint(1, 60)
-        logger.info(f"Sleeping for {2*rand} minutes")
-        time.sleep(120 * rand)
-
-
-def scraper(logger=None):
-    """
-    This function is responsible for scraping data.
-    """
-    if not logger:
-        logger = logging.getLogger()
-        logger.setLevel("DEBUG")
-        h1 = logging.StreamHandler()
-        logger.addHandler(h1)
-        logger.info("No logger set. Test run")
-
-    loader = Thread(target=load_ndb_to_q, args=(logger,))
-    _scraper = Thread(target=check_if_exists_brute_force, args=(logger,))
-    loader.start()
-    _scraper.start()
-    loader.join()
-    _scraper.join()
-
-
-if __name__ == "__main__":
-    scraper()

conjurer_librarian/search_bot.py

@@ -1,170 +1,82 @@
-"""
+from queue import Queue, Empty
-This module contains functions for searching for DOI (Digital Object Identifier)
-in a list of live results.
-It includes a producer-consumer pattern implementation using threads and queues.
-
-Functions:
-- producer: Reads lines from a file and puts them into an output queue.
-- consumer: Consumes items from an input queue and checks if DOI exists in the live results list.
-- search_for_doi: Searches for DOI in live results using the producer-consumer pattern.
-
-Global Variables:
-- MAXTHREADS: Maximum number of worker threads.
-- DATABASE_PATH: Path to the database files.
-- ENCODING: Encoding of the database files.
-- CHUNK: File name pattern for the database files.
-- _sentinel: Sentinel object used to signal termination.
-- result_list: List to store the search results.
-- WORK_Q_SIZE: Maximum size of the work queue.
-"""
-
-# TODO: Wpiemdolić to wszystko w klasę z loggerem przysłanym z góry
-from queue import Empty, Queue
 from threading import Thread
-import time
 q = Queue()
-#TODO: Count number of lines in files and print to approximate on which part of the file search is
 
-# DATA FOR TEST ONLY
+#TODO: TO w klasie jako parametry wybierane czy robimy pelen run czy testowy
-# MAXTHREADS = 5
+#MAXTHREADS = 3
-# DATABASE_PATH = r'C:\\Database\\chunks_1\\'
+MAXTHREADS = 1
 
-# DEPLOYMENT DATA
+#DATABASE_PATH = r'C:\\Database\\chunks_1\\'
-MAXTHREADS = 41
+DATABASE_PATH = r'C:\\Database\\chunks\\'
-DATABASE_PATH = r"C:\\Database\\chunks\\"
 
 ENCODING = "utf-8"
-CHUNK = "_chunk.txt"
+CHUNk = "_chunk.txt"
 _sentinel = object()
-WORK_Q_SIZE = 35500000
+result_list = []
 
+#TODO: Wpiemdolić to wszystko w klasę z loggerem przysłanym z góry
 
-def producer(out_q, control_q, filename, _logger):
+def producer(out_q, control_q, filename):
-    """
-    Produces items from the output queue and puts them into the control queue.
-
-    Args:
-        out_q (Queue): Output queue.
-        control_q (Queue): Control queue.
-        filename (str): Name of the file.
-        _logger: Logger object for logging.
-    """
     with open(DATABASE_PATH + filename, "r+", encoding=ENCODING) as operated_file:
-        print(f"Worker {filename} ")
+        lines = operated_file.readlines()
-        line_no = 0
+        for line in lines:
-        while True:
-            line = operated_file.readline()
-            line_no += 1
-            print(f"\t \t \t \t \t \t W{filename}{line_no}\r", end="")
-
-            if not line:
-                print(f"EOF {filename}")
-                break
-
-            if not line:
-                break
             out_q.put(line)
             try:
                 check = control_q.get(block=False)
             except Empty:
                 check = False
-
+                pass
             if check is _sentinel:
                 print("TERM signal received")
                 control_q.put(check)
                 break
-        print(f"Worker finished: {filename}")
+    print(f"Worker finished: {filename}")
-        out_q.put(_sentinel)
+    out_q.put(_sentinel)
-
+ 
-
+#IMPORTANT!!! ONLY ONE CONSUMER THREAD AS WE ARE NOT PUTTING SENTINELS BACK
-# IMPORTANT!!! ONLY ONE CONSUMER THREAD AS WE ARE NOT PUTTING SENTINELS BACK
+#TODO: Change doi to tuple list and only put term when all doi are found => (doi, True)
-def consumer(in_q, control_q, doi, live_results, result_list, control_dict, no, _logger):
+def consumer(in_q, control_q, doi, live_results, logger):
-    """
+    sentinels = 0
-    Consumes items from an input queue and checks if DOI exists in the live results list.
+    for item in doi:
-
+        result_list.append({"DOI" : item[0], "exists" : False, "data" : item[1]})
-    Args:
-        in_q (Queue): Input queue.
-        control_q (Queue): Control queue.
-        doi (list): List of DOI to search for.
-        live_results (list): List to store the search results.
-        _logger: Logger object for logging.
-    """
-    print(f"Consumer thread started: {no} no")
-    empty_counter = 0
-    alive_no = 0
     while True:
+        #if in_q.empty():
+        #    print("Queue empty!")
+        #if in_q.full():
+        #    print("Queue full!")
         done_check = True
-        try:
+        data = in_q.get()
-            data = in_q.get(block=True, timeout = 1)
+        if data is _sentinel:
-            if data is _sentinel:
+            logger.info("Worker finished")
-                control_dict["sentinels"] += 1
+            sentinels += 1
-                print(f"Workers finished: {control_dict['sentinels']} reported by consumer {no}")
+        else:
-
+            for item in result_list:
-            else:
+                if item["DOI"] in data:
-                empty_counter = 0
+                    logger.info(data)
-                alive_no += 1
+                    logger.info("HIT")
-                print(f"C{no}__{alive_no}\r", end="")
+                    item["exists"] = True
-
+                    live_results.append(item)
-                for item in result_list:
+                done_check = done_check and item["exists"]
-                    if item["DOI"] in data and not item["exists"]:
+            if done_check:
-                        print(f"HIT in {no} content {data[0]} line {data[1]} file {data[2]} {item["exists"]}")
+                control_q.put(_sentinel)
-                        _logger.info(data)
+        if sentinels >= MAXTHREADS:
-                        _logger.info("HIT")
+            logger.info("All workers finished")
-                        item["exists"] = True
-                        live_results.append(item)
-                    done_check = done_check and item["exists"]
-                if done_check:
-                    control_q.put(_sentinel)
-        except Empty:
-            empty_counter += 1
-            time.sleep(1)
-            print(f"Consumer {no} empty")
-            if empty_counter > 5:
-                print("Consumer %s empty lvl 2", no)
-                time.sleep(2)
-            elif empty_counter > 10:
-                print(f"Consumer thread finished {no}")
-                break
-
-        if control_dict["sentinels"] >= MAXTHREADS:
-            _logger.info(f"All workers finished {no}")
             break
 
 
-
+def search_for_doi(doi, live_results, logger):
-def search_for_doi(doi, live_results, _logger):
-    """
-    Search for DOI in live_results using _logger for logging.
-
-    Args:
-        doi (list): List of DOI to search for.
-        live_results (list): List to store the search results.
-        _logger: Logger object for logging.
-    """
-    control_dict = {"sentinels":0}
-    result_list = []
     threads = []
-    work_q = Queue(maxsize=WORK_Q_SIZE)
+    work_q = Queue(maxsize=200000)
     control_q = Queue()
-
+    t_cons = Thread(target = consumer, args = (work_q, control_q, doi, live_results, logger))
-    for item in doi:
+    logger.info("Consumer thread created")
-        result_list.append({"DOI": item[0], "exists": False, "data": item[1]})
+    threads.append(t_cons)
-
+    for i in range(0,MAXTHREADS):
-    for i in range (0, (len(doi)//1000)+2):
+        #filename = "test" + str(i) + CHUNk
-        t_cons = Thread(
+        filename = "40" + CHUNk
-            target=consumer, args=(work_q, control_q, doi, live_results, result_list, control_dict, i, _logger)
+        #filename = str(i) + CHUNk
-        )
+        logger.info(f"Creating worker thread no: {i}")
-        _logger.info("Consumer thread created")
+        threads.append(Thread(target = producer, args = (work_q, control_q, filename)))
-        threads.append(t_cons)
-    for i in range(0, MAXTHREADS):
-        # TEST DATA
-        # filename = "test" + str(i) + CHUNk
-        # DEPLOYMENT DATA
-        filename = str(i) + CHUNK
-        _logger.info(f"Creating worker thread no: {i}")
-        threads.append(
-            Thread(target=producer, args=(work_q, control_q, filename, _logger))
-        )
     for worker in threads:
         worker.start()
     for worker in threads:
@@ -172,29 +84,23 @@ def search_for_doi(doi, live_results, _logger):
     return result_list
 
 
+
 if __name__ == "__main__":
     import logging
-
     logger = logging.getLogger()
     logger.setLevel("DEBUG")
     h1 = logging.StreamHandler()
     logger.addHandler(h1)
     logger.info("TEST RUN")
     live_result = []
-    logger.info(
+    logger.info(search_for_doi([
-        search_for_doi(
+        ("10.1002/9781118786352.wbieg0998.pub2","DATA"),
-            [
+        ("10.1002/j.2050-0416.2002.tb00563.x","DATA"),
-                ("10.1002/9781118786352.wbieg0998.pub2", "DATA"),
+        ("10.1111/j.1365-2958.1994.tb00448.x","DATA"),
-                ("10.1002/j.2050-0416.2002.tb00563.x", "DATA"),
+        ("10.2165/00128415-200309690-00017","DATA"),
-                ("10.1111/j.1365-2958.1994.tb00448.x", "DATA"),
+        ("10.5772/48313","DATA"),
-                ("10.2165/00128415-200309690-00017", "DATA"),
+        ("10.15803/ijnc.7.2_419","DATA"),
-                ("10.5772/48313", "DATA"),
+        ("10.1051/0004-6361/201321596e","DATA"),
-                ("10.15803/ijnc.7.2_419", "DATA"),
+        ("10.2307/40835941","DATA"),
-                ("10.1051/0004-6361/201321596e", "DATA"),
+        ], live_result, logger))
-                ("10.2307/40835941", "DATA"),
-            ],
-            live_result,
-            logger,
-        )
-    )
     logger.info(live_result)

conjurer_librarian/search_bot2.py

@@ -1,206 +0,0 @@
-"""
-This module contains functions for searching for DOI (Digital Object Identifier)
-in a list of live results.
-It includes a producer-consumer pattern implementation using threads and queues.
-
-Functions:
-- producer: Reads lines from a file and puts them into an output queue.
-- consumer: Consumes items from an input queue and checks if DOI exists in the live results list.
-- search_for_doi: Searches for DOI in live results using the producer-consumer pattern.
-
-Global Variables:
-- MAXTHREADS: Maximum number of worker threads.
-- DATABASE_PATH: Path to the database files.
-- ENCODING: Encoding of the database files.
-- CHUNK: File name pattern for the database files.
-- _sentinel: Sentinel object used to signal termination.
-- result_list: List to store the search results.
-- WORK_Q_SIZE: Maximum size of the work queue.
-"""
-
-# TODO: Wpiemdolić to wszystko w klasę z loggerem przysłanym z góry
-from multiprocessing import Manager, Process, Queue
-from queue import Empty, Full
-import time
-
-# DATA FOR TEST ONLY
-#MAXTHREADS = 6
-#DATABASE_PATH = r'C:\\Database\\chunks_1\\'
-
-# DEPLOYMENT DATA
-MAXTHREADS = 41
-DATABASE_PATH = r"C:\\Database\\chunks\\"
-
-ENCODING = "utf-8"
-CHUNK = "_chunk.txt"
-_sentinel = None
-WORK_Q_SIZE = 355000
-
-
-def producer(out_q, control_q, filename, _logger):
-    """
-    Produces items from the output queue and puts them into the control queue.
-
-    Args:
-        out_q (Queue): Output queue.
-        control_q (Queue): Control queue.
-        filename (str): Name of the file.
-        _logger: Logger object for logging.
-    """
-    with open(DATABASE_PATH + filename, "r+", encoding=ENCODING) as operated_file:
-        print(f"Worker {filename} ")
-        line_no = 0
-        while True:
-            line = operated_file.readline()
-            line_no += 1
-            print(f"\t \t \t W{filename}{line_no}\r", end="")
-
-            if not line:
-                print(f"EOF {filename}")
-                break
-            try:
-                out_q.put([line, line_no, filename], block = True, timeout = 60)
-            except Full:
-                print("queue fulll")
-            try:
-                check = control_q.get(block=False)
-            except Empty:
-                check = False
-            if check is None:
-                print(f"TERM signal received {filename}")
-                control_q.put(check)
-                control_q.close()
-                break
-        print(f"Worker finished: {filename}")
-        out_q.put(_sentinel)
-        out_q.close()
-
-
-
-# IMPORTANT!!! ONLY ONE CONSUMER THREAD AS WE ARE NOT PUTTING SENTINELS BACK
-def consumer(in_q, control_q, doi, live_results, result_list, control_dict, no, _logger):
-    """
-    Consumes items from an input queue and checks if DOI exists in the live results list.
-
-    Args:
-        in_q (Queue): Input queue.
-        control_q (Queue): Control queue.
-        doi (list): List of DOI to search for.
-        live_results (list): List to store the search results.
-        _logger: Logger object for logging.
-    """
-    print(f"Consumer thread started: {no} no")
-    empty_counter = 0
-    alive_no = 0
-    while True:
-        done_check = True
-        try:
-            data = in_q.get(block=True, timeout = 1)
-            empty_counter = 0
-            if data is None:
-                control_dict["sentinels"] += 1
-                print(f"Workers finished: {control_dict['sentinels']} reported by consumer {no}")
-            else:
-                empty_counter = 0
-                if alive_no > 9:
-                    alive_no = 0
-                alive_no += 1
-                print(f"C{no}{alive_no}\r", end="")
-                for item in result_list:
-                    if item["DOI"] in data[0] and not item["exists"]:
-                        print(f"HIT in {no} content {data[0]} line {data[1]} file {data[2]} {item["exists"]}")
-                        item["exists"] = True
-                        live_results.append(item)
-                    done_check = done_check and item["exists"]
-                if done_check:
-                    control_q.put(_sentinel)
-        except Empty:
-            empty_counter += 1
-            time.sleep(1)
-            print(f"Consumer {no} empty")
-            if empty_counter > 5:
-                print("Consumer %s empty lvl 2", no)
-                time.sleep(2)
-            elif empty_counter > 10:
-                print(f"Consumer thread finished {no}")
-                break
-        if control_dict["sentinels"] >= MAXTHREADS:
-            print(f"All workers finished killing {no}")
-            break
-    print("Consumer thread finished %s",no )
-    control_q.close()
-
-
-def search_for_doi(doi, live_results, _logger):
-    """
-    Search for DOI in live_results using _logger for logging.
-
-    Args:
-        doi (list): List of DOI to search for.
-        live_results (list): List to store the search results.
-        _logger: Logger object for logging.
-    """
-    with Manager() as manager:
-        control_dict = manager.dict()
-        control_dict["sentinels"] = 0
-        result_list = []
-        for item in doi:
-            result_list.append({"DOI": item[0], "exists": False, "data": item[1]})
-        result_list_proxy = manager.list(result_list)
-
-        threads = []
-        work_q = Queue(maxsize=WORK_Q_SIZE)
-        control_q = Queue()
-        for i in range(0, MAXTHREADS):
-            # TEST DATA
-            #filename = "test" + str(i) + CHUNK
-            # DEPLOYMENT DATA
-            filename = str(i) + CHUNK
-            print(f"Creating worker thread no: {i}")
-            threads.append(
-                Process(target=producer, args=(work_q, control_q, filename, _logger))
-            )
-        for i in range (0, (len(doi)//1000)+5):
-            t_cons = Process(
-                target=consumer, args=(work_q, control_q, doi, live_results, result_list_proxy, control_dict, i, _logger)
-            )
-            print("Consumer thread created")
-            threads.append(t_cons)
-
-        for worker in threads:
-            worker.start()
-        for worker in threads:
-            worker.join()
-        result_list = list(result_list_proxy)
-        for worker in threads:
-            worker.close()
-        return result_list
-
-
-if __name__ == "__main__":
-    import logging
-
-    logger = logging.getLogger()
-    logger.setLevel("DEBUG")
-    h1 = logging.StreamHandler()
-    logger.addHandler(h1)
-    print("TEST RUN")
-    live_result = []
-    print(
-        search_for_doi(
-            [
-                ("10.1002/9781118786352.wbieg0998.pub2", "DATA"),
-                ("10.1002/j.2050-0416.2002.tb00563.x", "DATA"),
-                ("10.1111/j.1365-2958.1994.tb00448.x", "DATA"),
-                ("10.2165/00128415-200309690-00017", "DATA"),
-                ("10.5772/48313", "DATA"),
-                ("10.15803/ijnc.7.2_419", "DATA"),
-                ("10.1051/0004-6361/201321596e", "DATA"),
-                ("10.2307/40835941", "DATA"),
-                ("NOT_ON_LIST", "DATA"),
-            ],
-            live_result,
-            logger,
-        )
-    )
-    print(live_result)

conjurer_librarian/test_send.py

@@ -1,45 +0,0 @@
-import asyncio
-import json
-import logging
-from json.decoder import JSONDecodeError
-from logging import handlers
-import requests
-
-MAIN_BOT_ADDRESS = "http://192.168.1.191:5000"
-SEND_RESULTS = "/conjurer"
-
-async def send_results():
-    logger = logging.getLogger()
-    logger.setLevel(logging.DEBUG)
-    h1 = handlers.RotatingFileHandler(
-        filename="D:\\logs\\librarian.log",
-        encoding="utf-8",
-        mode="a",
-        maxBytes=6 * 1024 * 1024,
-        backupCount=6,
-    )
-
-    logger.addHandler(h1)
-
-    with open("s_results.json", "r+", encoding="utf-8") as s_file:
-        try:
-            database = json.load(s_file)
-        except JSONDecodeError:
-            pass
-    result = database["4bacbca0-ce3b-45c6-90a1-05c70b46b740"]
-    result = {"4bacbca0-ce3b-45c6-90a1-05c70b46b740":result}
-
-    coroutine = asyncio.to_thread(
-        requests.post,
-        f"{MAIN_BOT_ADDRESS}{SEND_RESULTS}",
-        json=result,
-        timeout=360,
-    )
-    logger.info("SENT")
-    result = await coroutine
-    logger.info(result.status_code)
-    logger.info("SEND CONFIRMED")
-async def main():
-    await send_results()
-if __name__ == "__main__":
-    asyncio.run(main())

conjurer_musician/conjurer_musician.py

@@ -1,672 +0,0 @@
-"""
-The provided Python script sets up a Flask web server to manage a list of music files, with
-functions for rescanning the music folder, updating the music list, and serving the music list via
-API endpoints.
-"""
-
-import json
-import logging
-import os
-import random
-import re
-import threading
-import time
-from datetime import datetime
-from logging import handlers
-from pathlib import Path
-from typing import Dict, List
-
-import requests
-from flask import (
-    Flask,
-    abort,
-    jsonify,
-    redirect,
-    render_template,
-    request,
-    send_from_directory,
-)
-from waitress import serve
-
-import media_search_functions
-
-
-def _env(name: str, default: str) -> str:
-    return os.getenv(name, default)
-
-
-def _env_path(name: str, default: str) -> Path:
-    value = os.getenv(name, default)
-    return Path(value).expanduser().resolve()
-
-
-API_KEY = os.getenv("CONJURER_API_KEY")
-MAIN_BOT_ADDRESS = _env("CONJURER_MAIN_BOT", "http://127.0.0.1:5000")
-MUSIC_TRACKER = _env("CONJURER_MUSIC_TRACKER_ENDPOINT", "/prepped_tracks")
-HOST_ADDRESS = _env("CONJURER_MUSICIAN_HOST", "0.0.0.0")
-PORT_ADDRESS = int(_env("CONJURER_MUSICIAN_PORT", "5000"))
-
-BASE_DIR = Path(
-    os.getenv("CONJURER_MUSICIAN_BASE", str(Path(__file__).resolve().parent))
-)
-LOGFILE = _env_path(
-    "CONJURER_MUSICIAN_LOG", str(BASE_DIR / "discord_mus_service.log")
-)
-LOGSTORE = _env_path("CONJURER_LOGSTORE", str(BASE_DIR / "logs"))
-MUSIC_FOLDER = _env_path(
-    "CONJURER_MUSIC_FOLDER", str(BASE_DIR / "music")
-)
-PRIORITY_FOLDER = _env_path(
-    "CONJURER_PRIORITY_FOLDER", str(MUSIC_FOLDER / "priority")
-)
-RADIOLOG_PATH = _env_path(
-    "CONJURER_RADIO_LOG", str(BASE_DIR / "radio_log.log")
-)
-PERSISTENCE_PATH = _env_path(
-    "CONJURER_PERSISTENCE_LOG", str(BASE_DIR / "persistence.log")
-)
-ALL_PLAYLIST_PATH = _env_path(
-    "CONJURER_ALL_PLAYLIST", str(BASE_DIR / "all_playlist.playlist")
-)
-HIT_PLAYLIST_PATH = _env_path(
-    "CONJURER_HIT_PLAYLIST", str(BASE_DIR / "hit.playlist")
-)
-REQUEST_PLAYLIST_PATH = _env_path(
-    "CONJURER_REQUEST_PLAYLIST", str(BASE_DIR / "request.playlist")
-)
-PRIORITY_PLAYLIST_PATH = _env_path(
-    "CONJURER_PRIORITY_PLAYLIST", str(BASE_DIR / "priority_queue.playlist")
-)
-STREAM_TEMPLATE = _env_path(
-    "CONJURER_STREAM_TEMPLATE", str(BASE_DIR / "stream.html")
-)
-
-ENCODING = _env("CONJURER_ENCODING", "utf-8")
-SEPARATOR_FILE_PATH = os.sep
-
-for playlist_path in (
-    ALL_PLAYLIST_PATH,
-    HIT_PLAYLIST_PATH,
-    REQUEST_PLAYLIST_PATH,
-    PRIORITY_PLAYLIST_PATH,
-):
-    playlist_path.parent.mkdir(parents=True, exist_ok=True)
-
-random.seed()
-music_file_list: List[str] = []
-priority_list: List[str] = []
-
-
-def _build_headers() -> Dict[str, str]:
-    headers: Dict[str, str] = {}
-    if API_KEY:
-        headers["X-Conjurer-Api-Key"] = API_KEY
-    return headers
-
-
-def _authorize_request() -> None:
-    if API_KEY and request.headers.get("X-Conjurer-Api-Key") != API_KEY:
-        abort(401)
-
-
-def _post_to_bot(payload: List[str]) -> None:
-    response = requests.post(
-        f"{MAIN_BOT_ADDRESS}{MUSIC_TRACKER}",
-        json=payload,
-        headers=_build_headers(),
-        timeout=60,
-    )
-    logger = logging.getLogger("conjurer_musician")
-    logger.info("SENT")
-    logger.info(response.status_code)
-    logger.info("SEND CONFIRMED")
-
-
-def rescan():
-    """
-    The `rescan` function logs a message, scans for mp3 files in a specified folder,
-    and adds them to a list of music files.
-    """
-    logger = logging.getLogger("conjurer_musician")
-    logger.info("Rescan triggered")
-
-    music_file_list.clear()
-    priority_list.clear()
-
-    for mp3_item in MUSIC_FOLDER.glob("**/*.mp3"):
-        temp_music_file = mp3_item.as_posix()
-        if os.name == "nt":
-            temp_music_file = temp_music_file.replace("/", "\\")
-        music_file_list.append(temp_music_file)
-
-    for mp3_item in PRIORITY_FOLDER.glob("**/*.mp3"):
-        temp_music_file = mp3_item.as_posix()
-        if os.name == "nt":
-            temp_music_file = temp_music_file.replace("/", "\\")
-        priority_list.append(temp_music_file)
-
-    with ALL_PLAYLIST_PATH.open("w", encoding=ENCODING) as w_file:
-        try:
-            for item in music_file_list:
-                w_file.write(item)
-                w_file.write("\n")
-        except json.JSONDecodeError:
-            pass
-    with HIT_PLAYLIST_PATH.open("w", encoding=ENCODING) as w_file:
-        try:
-            for item in priority_list:
-                w_file.write(item)
-                w_file.write("\n")
-        except json.JSONDecodeError:
-            pass
-
-
-def thread_rescan():
-    """
-    The `thread_rescan` function periodically triggers a rescan operation after a specified time
-    interval.
-    """
-    logger = logging.getLogger("conjurer_musician")
-    logger.info("Starting filesystemupdater")
-    while True:
-        time.sleep(60 * 60 * 24)
-        logger.info("Rescan triggered")
-        rescan()
-
-
-def scan_tracks():
-    # Set the filename and open the file
-    logger = logging.getLogger("conjurer_musician")
-    with open(RADIOLOG_PATH, "r", encoding=ENCODING) as log_file:
-        log_file.seek(os.stat(RADIOLOG_PATH).st_size)
-        prev_size = os.stat(PERSISTENCE_PATH).st_size
-
-        while True:
-            current_size = os.stat(PERSISTENCE_PATH).st_size
-            if prev_size != current_size:
-                while prev_size != current_size:
-                    prev_size = current_size
-                    time.sleep(0.1)
-                    current_size = os.stat(PERSISTENCE_PATH).st_size
-                with open(PERSISTENCE_PATH, "r", encoding=ENCODING) as persistence:
-                    lines = persistence.readlines()
-                if len(lines) >= 3:
-                    _post_to_bot(["next", lines[2]])
-
-            position = log_file.tell()
-            line = log_file.readline()
-            if not line:
-                time.sleep(1)
-                log_file.seek(position)
-                continue
-
-            if not re.match(r".*Prepared.*", line):
-                time.sleep(0.1)
-                continue
-
-            result = None
-            if re.match(r".*jingles.*", line):
-                result = ["jingles", line]
-            elif re.match(r".*priority.*", line):
-                result = ["priority", line]
-            elif re.match(r".*hit.*", line):
-                result = ["hit", line]
-            elif re.match(r".*all_playlist.*", line):
-                result = ["all", line]
-            elif re.match(r".*request.*", line):
-                result = ["requests", line]
-
-            if result:
-                logger.info("Forwarding radio log entry: %s", result[0])
-                _post_to_bot(result)
-
-            time.sleep(0.1)
-
-
-app = Flask(__name__)
-# AutoIndex(app, browse_root="/")
-
-
-# TODO: Odpalić wyszukiwarki w wątkach i dopiero po wszystkim zsumować wyszukiwanie.
-def wyszukaj(word_list, how_many, _logger=None, return_to_bot=True):
-    """
-    Searches for music files based on a list of keywords and returns a list of matching files.
-
-    Args:
-        word_list (list): A list of keywords to search for.
-        how_many (int): The maximum number of matching files to return.
-
-    Returns:
-        list: A list of matching files, sorted by their search weight.
-
-    """
-    if _logger is None:
-        fun_logger = logging.getLogger()
-    else:
-        fun_logger = _logger
-    return_list = []
-    search_weight = []
-
-    for _ in range(len(music_file_list)):
-        search_weight.append((0, ""))
-
-    time_start = datetime.now()
-    if int(how_many) > 0:
-        skip_start = 2
-    else:
-        skip_start = 1
-    for word in word_list[skip_start:]:
-        token_weight = len(word)
-        fun_logger.info("Słowo kluczowe: %s", word)
-        itr = 0
-        for file in music_file_list:
-            file = file.split(SEPARATOR_FILE_PATH)
-
-            char_remove = [
-                ".",
-                "^",
-                "$",
-                "*",
-                "+",
-                "?",
-                "{",
-                "}",
-                "[",
-                "]",
-                "\\",
-                "/",
-                "|",
-                "(",
-                ")",
-                "!",
-                ",",
-                "-",
-                ":",
-                "mp3",
-            ]
-            all_words = []
-            for f_iter in file:
-                for char in char_remove:
-                    f_iter = remove_characters(f_iter, char)
-                tmp = f_iter.split()
-                all_words.extend(tmp)
-            pingu = 1
-            pattern_len = len(all_words)
-            if platform == "win32":
-                skip = 2
-            else:
-                skip = 4
-            matched_times = 1
-            # TODO: To do wątków albo for asynchroniczny
-            for itm in all_words[skip:]:
-                pingu += 1
-                pattern = ".*" + word + ".*"
-                if re.match(pattern, itm, re.IGNORECASE):
-                    temp_weight = (
-                        search_weight[itr][0]
-                        + (token_weight + (pingu**1.5) / pattern_len) / matched_times
-                    )
-                    search_weight[itr] = (
-                        temp_weight,
-                        music_file_list[itr],
-                    )
-                    matched_times += 1
-            itr += 1
-
-    fun_logger.info(
-        "Stworzylem tablice wag zajęło mi to %s", datetime.now() - time_start
-    )
-    time_start = datetime.now()
-    item_to_search = max_weight(search_weight)
-    itr = 0
-    if item_to_search == 0:
-        return []
-    not_found = True
-    return_list = []
-    if int(how_many) <= 0:
-        fun_logger.info("Jeden plik do zagrania")
-        while not_found:
-            if search_weight[itr][0] == item_to_search:
-                return_list.append(search_weight[itr])
-                if not return_to_bot:
-                    with PRIORITY_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
-                        s_file.write(search_weight[itr][1] + "\n")
-                break
-            itr += 1
-    else:
-        fun_logger.info("Wiele plików do zagrania")
-        search_weight.sort(key=lambda x: x[0], reverse=True)
-        return_list.extend(search_weight[: int(how_many)])
-    fun_logger.info("Done: %s", return_list)
-    return return_list
-
-
-def max_weight(lista):
-    """
-    Take a list of weights and return the maximum weight.
-
-    :param lista: It seems like the parameter `lista` is a list of items, possibly representing weights.
-    The function name `max_weight` suggests that the function is intended to find the maximum weight
-    from the list. However, without more context or information about the problem, it's difficult to say
-    for sure what the
-    """
-    maximum_weight = 0
-    for iterator in lista:
-        if iterator[0] > maximum_weight:
-            maximum_weight = iterator[0]
-    return maximum_weight
-
-
-def remove_characters(string, character):
-    """
-    The `remove_characters` function removes all occurrences of a specified character from a given
-    string.
-
-    :param string: The string parameter is the input string from which characters will be removed
-    :param character: The character parameter is the character that you want to remove from the string
-    :return: a new string where all occurrences of the specified character have been removed.
-    """
-    return string.replace(character, "")
-
-
-@app.route('/get_share_list', methods=['POST'])
-def get_share_list():
-    _authorize_request()
-    data = request.get_json()
-    entries = data.get('entries')
-    keywords = data.get('keywords')
-    # Validate entries
-    if not isinstance(entries, int) or not (1 <= entries <= 10):
-        return jsonify({'error': '"entries" must be an integer between 1 and 10.'}), 400
-    # Validate keywords list
-    if not isinstance(keywords, list) or not all(isinstance(k, str) for k in keywords):
-        return jsonify({'error': '"keywords" must be a list of strings.'}), 400
-    # Call external search
-    files = media_search_functions.find_matches(entries, keywords)
-    # Return each file path as a JSON list
-    return jsonify({'files': files}), 200
-
-@app.route('/get_share_links', methods=['POST'])
-def get_share_links():
-    _authorize_request()
-    data = request.get_json()
-    file_paths = data.get('file_paths')
-    # Validate file_paths list
-    if not isinstance(file_paths, list) or not all(isinstance(p, str) for p in file_paths):
-        return jsonify({'error': '"file_paths" must be a list of strings.'}), 400
-    # Call external publish
-    links = media_search_functions.publish(file_paths)
-    # Return list of published links
-    return jsonify({'links': links}), 200
-
-
-
-@app.route("/stream", methods=["GET"])
-def stream_music():
-    """
-    The function `stream_music` is a route handler for the "/stream" endpoint.
-    It returns a JSON response containing a key "music_file_list" with the value of the variable `music_file_list`.
-
-    :return: A JSON response containing a key "music_file_list" with the value of the variable `music_file_list`.
-    """
-
-    # return send_from_directory("/tmp/hls", "stream.m3u8")
-    return render_template(str(STREAM_TEMPLATE))
-
-
-@app.route("/<string:file_name>")
-def stream(file_name):
-    """
-    Stream the specified file from the video directory.
-
-    Args:
-        file_name (str): The name of the file to be streamed.
-
-    Returns:
-        Response: The response containing the streamed file.
-    """
-    # trunk-ignore(bandit/B108)
-    video_dir = "/tmp/hls"
-    return send_from_directory(video_dir, file_name)
-
-
-@app.route("/stream_mp3", methods=["GET"])
-def stream_music_mp3():
-    """
-    The function `stream_music_mp3` is a route handler for the "/stream_mp3" endpoint.
-    It redirects the user to the URL "http://www.example.com" with a status code of 302.
-
-    :return: A redirect response to "http://www.example.com" with a status code of 302.
-    """
-    return redirect("http://www.example.com", code=302)
-
-
-@app.route("/clear_pr_pls", methods=["GET"])
-def clear_pr_pls():
-    _authorize_request()
-    """
-    The function `clear_pr_pls` clears the contents of the priority queue playlist file.
-
-    :return: A JSON response indicating the success of the operation.
-    """
-    app.logger.info("CLEARING PLAYLIST")
-    with PRIORITY_PLAYLIST_PATH.open("w", encoding=ENCODING) as cleared_pl:
-        cleared_pl.write("")
-
-    return_data = jsonify(isError=False, message="Success", statusCode=200, data=[])
-    return return_data, 200
-
-
-@app.route("/mp3", methods=["GET"])
-def get_music_list():
-    """
-    The function `get_music_list` returns a JSON object containing a list of music files.
-    :return: A JSON response containing a key "music_file_list" with the value of the variable
-    `music_file_list`.
-    """
-    return jsonify({"music_file_list": music_file_list})
-
-
-@app.route("/update_mp3", methods=["POST"])
-def update_music_list():
-    """
-    The function `update_music_list` receives a POST request with a JSON payload, logs the received
-    item, adds it to a music file list, and returns a success message along with the updated record.
-    :return: The function `update_music_list` is returning a tuple containing a JSON response and a
-    status code. The JSON response includes keys `isError`, `message`, `statusCode`, and `data`,
-    with values indicating the success of the operation and the data that was
-    received and added to the `music_file_list`.
-    The status code returned is 200, indicating a successful response.
-    """
-    _authorize_request()
-    record = json.loads(request.data)
-    app.logger.info(record["item"])
-    music_file_list.append(record["item"])
-    return_data = (
-        jsonify(isError=False, message="Success", statusCode=200, data=record),
-        200,
-    )
-    return return_data
-
-
-@app.route("/get_music", methods=["POST"])
-def look_for_playlist():
-    """
-    The function `look_for_playlist` receives a POST request with a JSON payload, logs the received
-    item, adds it to a music file list, and returns a success message along with the updated record.
-
-    :return: A tuple containing a JSON response and a status code. The JSON response includes keys `isError`,
-             `message`, `statusCode`, and `data`, with values indicating the success of the operation and the
-             data that was received and added to the `music_file_list`. The status code returned is 200,
-             indicating a successful response.
-    """
-    _authorize_request()
-    record = json.loads(request.data)
-    app.logger.info(record)
-    app.logger.info(record["lista_slow"])
-    app.logger.info(record["UUID"])
-    app.logger.info(record["dlugosc_plejlisty"])
-    return_data = wyszukaj(
-        record["lista_slow"], record["dlugosc_plejlisty"], app.logger, True
-    )
-
-    return_data = (
-        jsonify(isError=False, message="Success", statusCode=200, data=return_data),
-        200,
-    )
-    return return_data
-
-
-@app.route("/request_radio_file", methods=["POST"])
-def add_request():
-    _authorize_request()
-    record = json.loads(request.data)
-    app.logger.info(record)
-    app.logger.info(record["lista_slow"])
-    app.logger.info(record["UUID"])
-    return_data = wyszukaj(record["lista_slow"], 0, app.logger, False)
-
-    with REQUEST_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
-        for item in return_data:
-            s_file.write(item[1] + "\n")
-    return_data = (
-        jsonify(
-            isError=False, message="Success", statusCode=200, data={"status": "OK"}
-        ),
-        200,
-    )
-    return return_data
-
-
-@app.route("/create_priority_playlist", methods=["POST"])
-def create_priority_playlist():
-    """
-    The function `create_priority_playlist` receives a POST request with a JSON payload, logs the received
-    item, adds it to a music file list, and returns a success message along with the updated record.
-
-    :return: A tuple containing a JSON response and a status code.
-        The JSON response includes keys `isError`,
-        `message`, `statusCode`, and `data`, with values
-        indicating the success of the operation and the
-        data that was received and added to the `music_file_list`.
-        The status code returned is 200,indicating a successful response.
-    """
-    _authorize_request()
-    record = json.loads(request.data)
-    app.logger.info(record)
-    app.logger.info(record["lista_slow"])
-    app.logger.info(record["UUID"])
-    app.logger.info(record["dlugosc_plejlisty"])
-    return_data = wyszukaj(
-        record["lista_slow"], record["dlugosc_plejlisty"], app.logger, False
-    )
-    random.shuffle(return_data)
-    with REQUEST_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
-        for item in return_data:
-            s_file.write(item[1] + "\n")
-    return_data = (
-        jsonify(
-            isError=False, message="Success", statusCode=200, data={"status": "OK"}
-        ),
-        200,
-    )
-    return return_data
-
-
-@app.route("/add_to_priority", methods=["POST"])
-def add_to_priority():
-    """
-    The function `add_to_priority` receives a POST request with a JSON payload, logs the received
-    item, adds it to a music file list, and returns a success message along with the updated record.
-
-    :return: A tuple containing a JSON response and a status code.
-        The JSON response includes keys `isError`,
-        `message`, `statusCode`, and `data`, with values
-        indicating the success of the operation and the
-        data that was received and added to the `music_file_list`.
-        The status code returned is 200,indicating a successful response.
-    """
-    _authorize_request()
-    record = json.loads(request.data)
-    app.logger.info(record)
-    app.logger.info(record["lista_slow"])
-    app.logger.info(record["UUID"])
-    app.logger.info(record["dlugosc_plejlisty"])
-    return_data = wyszukaj(
-        record["lista_slow"], record["dlugosc_plejlisty"], app.logger, False
-    )
-    with PRIORITY_PLAYLIST_PATH.open("a", encoding=ENCODING) as s_file:
-        for item in return_data:
-            s_file.write(item[1] + "\n")
-    return_data = (
-        jsonify(
-            isError=False, message="Success", statusCode=200, data={"status": "OK"}
-        ),
-        200,
-    )
-    return return_data
-
-
-def flask_debug():
-    """
-    The `flask_debug` function starts a Flask application in debug mode without using the reloader.
-    Do not use for production for fucks sake.
-    """
-    # trunk-ignore(bandit/B201)
-    app.run(debug=True, use_reloader=False, host=HOST_ADDRESS, port=PORT_ADDRESS)
-
-
-def waitress_run():
-    """
-    The `waitress_run` function serves the `app` on host HOST_ADDRESS
-    and port 5000 using the Waitress WSGI server.
-
-    This function starts the Waitress server and listens for incoming requests
-    on the specified host and port. It uses the `serve` function from the Waitress
-    library to handle the serving process.
-
-    Parameters:
-        None
-
-    Returns:
-        None
-    """
-    serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS)
-
-
-if __name__ == "__main__":
-    logger = logging.getLogger("conjurer_musician")
-    logger.setLevel(logging.DEBUG)
-    formatter = logging.Formatter(
-        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-    )
-    handler = handlers.RotatingFileHandler(
-        filename=LOGFILE,
-        encoding=ENCODING,
-        mode="a",
-        maxBytes=6 * 1024 * 1024,
-        backupCount=6,
-    )
-    handler.setFormatter(formatter)
-    logger.addHandler(handler)
-
-    rescan()
-    logger.info("Started")
-    threads = []
-    # threads.append(threading.Thread(target=flask_debug))
-    threads.append(threading.Thread(target=waitress_run, daemon=True))
-    threads.append(threading.Thread(target=thread_rescan, daemon=True))
-
-    for worker in threads:
-        worker.start()
-
-    time.sleep(60)
-    track_thread = threading.Thread(target=scan_tracks, daemon=True)
-    track_thread.start()
-
-    try:
-        for worker in threads:
-            worker.join()
-        track_thread.join()
-    except KeyboardInterrupt:
-        logger.info("Shutdown requested - exiting musician service")

conjurer_musician/conjurer_musician.service

@@ -1,11 +0,0 @@
-[Unit]
-Description=Conjurer_musician
-After=multi-user.target
-
-[Service]
-Type=simple
-ExecStart=/home/pi/Conjurer/env/bin/python3 /home/pi/Conjurer/conjurer_musician.py
-Restart=on-abort
-
-[Install]
-WantedBy=multi-user.target

conjurer_musician/media_search_functions.py

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

conjurer_musician/music_utils.py

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

conjurer_musician/pl.config

@@ -1,14 +0,0 @@
-$dodaj_do_ulubionych 100 nightwish
-$dodaj_do_ulubionych 100 amon amarth
-$dodaj_do_ulubionych 100 tactical sekt
-$dodaj_do_ulubionych 100 lacuna coil
-$dodaj_do_ulubionych 100 sefa
-$dodaj_do_ulubionych 100 frenchcore
-$dodaj_do_ulubionych 100 peacock
-$dodaj_do_ulubionych 100 vavamuffin
-$dodaj_do_ulubionych 100 abradab
-$dodaj_do_ulubionych 100 eluveitie
-$dodaj_do_ulubionych 100 youtube
-
-$dodaj_do_ulubionych 100 elyose
-$dodaj_do_ulubionych 1 artisans du chaos

conjurer_musician/radio_conjurer.etc.logrotate

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

conjurer_musician/radio_conjurer.liq

@@ -1,191 +0,0 @@
-# FILEPATH: /home/mtuszowski/conjurer/conjurer_musician/radio_conjurer.liq
-
-# This script sets up a Liquidsoap radio stream with various features and configurations.
-
-# Load icecast credentials from a JSON file
-let json.parse credentials  = file.contents("/home/pi/Conjurer/icecast_credentials.json")
-
-# Enable replaygain metadata processing
-enable_replaygain_metadata()
-
-# Set up a playlog for tracking played tracks
-
-l = playlog(duration = 72000.0, persistency="/home/pi/Conjurer/persistence.log")
-
-# Function to check if a track can be played based on its metadata
-def check(r)
-    m = request.metadata(r)
-    if l.last(m) < 36000. then
-        log.info("Rejecting #{m['filename']} (played #{l.last(m)}s ago).")
-        false
-    else
-        l.add(m)
-        true
-    end
-end
-
-# Define playlists to be used in the stream
-s1 = replaygain(playlist(reload_mode="watch", check_next=check, "/home/pi/Conjurer/all_playlist.playlist"))
-s2 = replaygain(playlist(reload_mode="watch", check_next=check, "/home/pi/Conjurer/priority_queue.playlist"))
-s3 = replaygain(playlist(reload_mode="watch", check_next=check, "/home/pi/Conjurer/hit.playlist"))
-
-# Create a request queue for user-generated requests
-requests_queue = request.queue()
-
-# Function to process the request queue and add new requests
-def queue_processing()
-    text=file.lines("/home/pi/Conjurer/request.playlist")
-    if text != [] then
-        list.iter(fun(item) -> requests_queue.push.uri(item), text)
-        file.remove("/home/pi/Conjurer/request.playlist")
-        f = file.open("/home/pi/Conjurer/request.playlist", create=true)
-        f.close()
-    end
-end
-
-# Configure output formats and destinations
-def now_playing(m)
-  # raw lookup ("" if missing)
-  raw_title  = m["title"]
-  raw_artist = m["artist"]
-
-  # default if empty
-  title  = if raw_title  == "" then "Unknown" else raw_title  end
-  artist = if raw_artist == "" then "Unknown" else raw_artist end
-  log.critical("Now playing #{artist} - #{title}")
-  # write it out
-  system("echo '#{artist} - #{title}' > /tmp/now_playing.txt")
-  m
-end
-
-
-# Randomly select a playlist with weights
-s4 = random(id="randomizer", weights=[2, 3, 5], [s1, s2, s3])
-
-# Load jingles playlist
-jingles = (playlist(reload_mode="watch", "/home/pi/Conjurer/jingles.playlist"))
-
-# Create the main stream with random playlist and jingles
-s = rotate(id="randomizer", weights=[10, 1], [s4, jingles])
-
-s = crossfade(fade_out=2., fade_in=2., duration=4., fallback(id="switcher", track_sensitive=true, [requests_queue, s]))
-s = metadata.map(now_playing, s)
-
-# Set up an interactive harbor for controlling the stream
-interactive.harbor(port = 9999)
-# Set up interactive controls for bass boost
-f = interactive.float("f", description="Frequency", min=0., max=1000., unit="Hz", 200.)
-g = interactive.float("g", description="Gain", min=0., max=20., unit="dB", 8.)
-b = bass_boost(frequency=f, gain=g, s)
-s = add([s, b])
-
-# Set up interactive control for main volume
-a = interactive.float("main_volume", min=0., max=20., 1.1)
-s = compress.multiband.interactive(bands=7, s)
-
-mic_gain = interactive.float("mic_volume", min=0., max=120., 0.5)
-
-# Apply audio processing effects
-tmic = buffer(input.pulseaudio()) # Microphone
-mic = amplify(mic_gain, tmic)
-mic = gate(threshold=-80., range=-120., mic)
-mic = compress(threshold=0., ratio=2.,mic)
-mic = nrj(normalize(mic))
-mic = blank.strip(max_blank=15., min_noise=.1, threshold=-30., mic)
-mic =  fallback(id="switcher2", track_sensitive=false, [mic, blank()])
-
-# Apply audio processing effects
-s = nrj(s)
-s = amplify(a, s)
-# Skip blank sections in the stream
-s = blank.skip(max_blank=10., s)
-
-#Manual audition override
-live_enabled = interactive.bool("Going Live!", true)
-
-s = add([mic,s])
-s=switch(track_sensitive=true,
-    [(live_enabled, mic),
-    ({true}, s)])
-
-# Configure logging settings
-log_to_stdout = true
-log_to_file = true
-logpath = "/home/pi/Conjurer/radio_log.log"
-loglevel = 3
-set("log.stdout", log_to_stdout)
-set("log.level", loglevel)
-
-# Enable logging to file
-set("log.file", log_to_file)
-set("log.file.path", logpath)
-# Set up emergency fallback track
-emergency = single("/home/pi/MediaFolder/mp3/Youtube/Dr. Peacock - Trip to Ireland [GvrvQTUbUcA].mp3")
-radio =  fallback(id="switcher2", track_sensitive=false, [s, emergency])
-
-# Set up an interactive control for skipping tracks
-p = interactive.bool("Skip track", false)
-def http_skip(~protocol, ~data, ~headers, uri)=
-    radio.skip()
-    http.response(code=200,data="Skipped")
-end
-harbor.http.register(port=54321,method="GET","/skip", http_skip)
-
-
-# Function to process the request queue and skip the current track if requested
-def check_skip()
-    if p() then
-        log.info("Skipping current track.")
-        radio.skip()
-        p.set(false)
-    end
-end
-
-# Run the queue processing function every 60 seconds
-thread.run(every=60., queue_processing)
-
-
-# Run the check_skip function every 5 seconds
-thread.run(every=15., check_skip)
-
-
-# Enable persistent script parameters
-interactive.persistent("script.params")
-
-# Configure output formats and destinations
-
-output.icecast(%mp3, host="radio", port=8000, password=credentials.password, icy_metadata="true", mount="mp3-stream", radio)
-output.pulseaudio(radio)
-#output.file.hls("/tmp/hls", [("mp3-low", %mp3(bitrate=96)), ("mp3-hi", %mp3(bitrate=160))], radio)
-# Uncomment the following lines to enable additional output formats
-# output.icecast(%opus, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="opus-stream", radio)
-# output.icecast(%ogg, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="ogg-stream", radio)
-# output.icecast(%aac, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="aac-stream", radio)
-# output.icecast(%flac, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="flac-stream", radio)
-# output.icecast(%vorbis, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="vorbis-stream", radio)
-# output.icecast(%speex, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="speex-stream", radio)
-# output.icecast(%wav, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="wav-stream", radio)
-# output.icecast(%pcm, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="pcm-stream", radio)
-# output.icecast(%raw, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="raw-stream", radio)
-# output.icecast(%s16l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s16l-stream", radio)
-# output.icecast(%s16b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s16b-stream", radio)
-# output.icecast(%s24l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s24l-stream", radio)
-# output.icecast(%s24b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s24b-stream", radio)
-# output.icecast(%s32l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s32l-stream", radio)
-# output.icecast(%s32b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s32b-stream", radio)
-# output.icecast(%s64l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s64l-stream", radio)
-# output.icecast(%s64b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s64b-stream", radio)
-# output.icecast(%s128l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s128l-stream", radio)
-# output.icecast(%s128b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s128b-stream", radio)
-# output.icecast(%s256l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s256l-stream", radio)
-# output.icecast(%s256b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s256b-stream", radio)
-# output.icecast(%s512l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s512l-stream", radio)
-# output.icecast(%s512b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s512b-stream", radio)
-# output.icecast(%s1024l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s1024l-stream", radio)
-# output.icecast(%s1024b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s1024b-stream", radio)
-# output.icecast(%s2048l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s2048l-stream", radio)
-# output.icecast(%s2048b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s2048b-stream", radio)
-# output.icecast(%s4096l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s4096l-stream", radio)
-# output.icecast(%s4096b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s4096b-stream", radio)
-# output.icecast(%s8192l, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s8192l-stream", radio)
-# output.icecast(%s8192b, host="retropie", port=8000, password=credentials.password, icy_metadata="true", mount="s8192b-stream", radio)

conjurer_musician/radio_service.service

@@ -1,14 +0,0 @@
-[Unit]
-Description=radio_conjurer Liquidsoap daemon
-After=network.target
-Documentation=http://liquidsoap.fm/
-
-[Service]
-User=pi
-WorkingDirectory=/home/pi/Conjurer/
-ExecStart=/home/pi/.opam/4.13.0/bin/liquidsoap /home/pi/Conjurer/radio_conjurer.liq
-Restart=always
-
-[Install]
-WantedBy=multi-user.target
-Alias=radio_conjurer-liquidsoap.service

conjurer_musician/requirements_musician.txt

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

conjurer_musician/revoke_shares.py

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

conjurer_musician/scan_shares.py

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

conjurer_musician/scan_shares.service

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

conjurer_musician/scan_shares.timer

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

conjurer_musician/script.params

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

conjurer_musician/search_and_share.py

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

conjurer_musician/stream.html

@@ -1,9 +0,0 @@
-    <html>
-        <head>
-            <title>HTTP Live Streaming Example</title>
-        </head>
-        <body>
-            <video src="/tmp/hls/stream.m3u8" height="300" width="400">
-            </video>
-        </body>
-    </html>

conjurer_musician/test_mic.liq

@@ -1,23 +0,0 @@
-tmic = buffer(input.pulseaudio()) # Microphone
-
-if tmic.is_active() then
-    log.info("Buffer active")
-end
-
-if tmic.is_ready() then
-    log.info("Buffer ready")
-end
-if tmic.is_up() then
-    log.info("Buffer up")
-end
-
-interactive.harbor(port = 9999)
-
-mic_gain = interactive.float("mic_volume", min=0., max=20., 6.)
-
-mic = amplify(mic_gain, tmic)
-#mic = gate(threshold=-80., range=-120., mic)
-#mic = compress(threshold=0., ratio=2.,mic)
-#mic = blank.strip(max_blank=10., min_noise=.1, threshold=-20., mic)
-
-output.pulseaudio(mic)

constants.py

@@ -1,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"
+cd ..
-
+cp ./conjurer/bot.py ./Conjurer/
-cp ./deploy.sh /home/pi/
-print_progress "cp ./deploy.sh /home/pi/"
-
-cd /home/pi || exit
-print_progress "cd /home/pi"
-
-cp ./conjurer/LICENSE ./Conjurer/LICENSE
-print_progress "cp ./conjurer/LICENSE ./Conjurer/LICENSE"
-
-cp ./conjurer/fuckery.jpg ./Conjurer/
-print_progress "cp ./conjurer/fuckery.jpg ./Conjurer/"
-
-cp ./conjurer/willowisp.png ./Conjurer/
-print_progress "cp ./conjurer/willowisp.png ./Conjurer/"
-
-cp ./conjurer/wod_beacon.jpg ./Conjurer/
-print_progress "cp ./conjurer/wod_beacon.jpg ./Conjurer/"
-
 cp ./conjurer/settings.json ./Conjurer/
-print_progress "cp ./conjurer/settings.json ./Conjurer/"
+cp ./conjurer/system_gpt_settings.json ./Conjurer/
-
+cp ./conjurer/install.sh ./Conjurer/
-if [[ ./conjurer/system_gpt_settings.json -nt ./Conjurer/system_gpt_settings.json ]]; then
+cp ./conjurer/requirements.txt ./Conjurer/requirements.txt
-  cp ./conjurer/system_gpt_settings.json ./Conjurer/system_gpt_settings.json
-  print_progress "cp ./conjurer/system_gpt_settings.json ./Conjurer/system_gpt_settings.json"
-else
-  print_progress "system_gpt_settings.json is up to date"
-fi
-
-cp ./conjurer/administration_commands.py ./Conjurer/
-print_progress "cp ./conjurer/administration_commands.py ./Conjurer/"
-
-cp ./conjurer/ai_commands.py ./Conjurer/
-print_progress "cp ./conjurer/ai_commands.py ./Conjurer/"
-
-cp ./conjurer/ai_functions.py ./Conjurer/
-print_progress "cp ./conjurer/ai_functions.py ./Conjurer/"
-
-cp ./conjurer/communication_subroutine.py ./Conjurer/
-print_progress "cp ./conjurer/communication_subroutine.py ./Conjurer/"
-
-cp ./conjurer/constants.py ./Conjurer/
-print_progress "cp ./conjurer/constants.py ./Conjurer/"
-
-cp ./conjurer/librarian_commands.py ./Conjurer/
-print_progress "cp ./conjurer/librarian_commands.py ./Conjurer/"
-
-cp ./conjurer/music_commands.py ./Conjurer/
-print_progress "cp ./conjurer/music_commands.py ./Conjurer/"
-
-cp ./conjurer/music_functions.py ./Conjurer/
-print_progress "cp ./conjurer/music_functions.py ./Conjurer/"
-
-cp ./conjurer/other_commands.py ./Conjurer/
-print_progress "cp ./conjurer/other_commands.py ./Conjurer/"
-
-cp ./conjurer/other_functions.py ./Conjurer/
-print_progress "cp ./conjurer/other_functions.py ./Conjurer/"
-
-cp ./conjurer/radio_commands.py ./Conjurer/
-print_progress "cp ./conjurer/radio_commands.py ./Conjurer/"
-
-cp ./conjurer/voice_recognition_commands.py ./Conjurer/
-print_progress "cp ./conjurer/voice_recognition_commands.py ./Conjurer/"
-
-cp ./conjurer/file_search_functions.py ./Conjurer/
-
-print_progress "cp ./conjurer/file_search_functions.py ./Conjurer/"
-
-cp ./conjurer/file_search_commands.py ./Conjurer
-print_progress "cp ./conjurer/file_search_functions.py ./Conjurer/"
-
-cp ./conjurer/latex_commands.py ./Conjurer/
-print_progress "cp ./conjurer/latex_commands.py ./Conjurer/"
-
-cp ./conjurer/latex_functions.py ./Conjurer/
-print_progress "cp ./conjurer/latex_functions.py ./Conjurer/"
-
-cp ./conjurer/librarian_functions.py ./Conjurer
-print_progress "cp ./conjurer/librarian_functions.py ./Conjurer/"
-
-cp ./conjurer/thin_client.py ./Conjurer/bot.py
-print_progress "cp ./conjurer/thin_client.py ./Conjurer/bot.py"
-
 sudo systemctl restart conjurer.service
-print_progress "sudo systemctl restart conjurer.service"

deploy_music.sh

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

deploy_radio.sh

@@ -1,6 +0,0 @@
-#!/bin/bash
-cd ./conjurer
-git pull
-cd ..
-cp ./conjurer/conjurer_musician/radio_conjurer.liq ./Conjurer
-sudo systemctl restart radio_service.service

dj_fonts_system_install.sh

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

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

file_webservice/conjurer_musician.py

@@ -0,0 +1,276 @@
+"""
+The provided Python script sets up a Flask web server to manage a list of music files, with
+functions for rescanning the music folder, updating the music list, and serving the music list via
+API endpoints.
+"""
+import json
+import re
+from pathlib import Path
+from platform import uname
+import threading
+import time
+from datetime import datetime
+from sys import platform
+import logging
+from flask import Flask, jsonify, request
+from waitress import serve
+
+
+HOST_ADDRESS = "192.168.1.15"
+PORT_ADDRESS = 5000
+if platform in ("linux", "linux2"):
+    SEPARATOR_FILE_PATH = "/"
+    if "microsoft-standard" in uname().release:
+        LOGFILE = "/home/mtuszowski/conjurer/discord_mus_service.log"
+        MUSIC_FOLDER = "/mnt/g/Muzyka/"
+        NETRC_FILE = "/home/mtuszowski/.netrc"
+        LOGSTORE = "/home/mtuszowski/conjurer/logs/"
+        ENCODING = "utf-8"
+        GRAPHICS_PATH = "/home/mtuszowski/conjurer/Conjurer_graphics/"
+
+    else:
+        LOGFILE = "/home/pi/Conjurer/discord_mus_service.log"
+        MEMORY_FIVE_SIARA = "/home/pi/Conjurer/pamiec.json"
+        SYSTEM_GPT_SETTINGS = "/home/pi/Conjurer/system_gpt_settings.json"
+        MEMORY_FIVE_MUZYKA = "/home/pi/Conjurer/pamiec_muzyki.json"
+        MUSIC_FOLDER = "/home/pi/RetroPie/mp3/"
+        SETTINGS_FILE = "/home/pi/Conjurer/settings.json"
+        NETRC_FILE = "/home/pi/.netrc"
+        LOGSTORE = "/home/pi/RetroPie/logs/"
+        ACCIDENT_LOG = "/home/pi/Conjurer/accident_log.json"
+        ENCODING = "utf-8"
+        GRAPHICS_PATH = "/home/pi/RetroPie/Conjurer_graphics/"
+        DIR_PATH_SADOX = "/home/pi/RetroPie/Fansadox/"
+
+
+music_file_list = []
+def rescan():
+    """
+    The `rescan` function logs a message, scans for mp3 files in a specified folder,
+    and adds them to a list of music files.
+    """
+    logging.info("Rescan triggered")
+    for mp3_item in Path.glob(Path(MUSIC_FOLDER), "**/*.mp3"):
+        temp_music_file = mp3_item.as_posix()
+        if platform == "win32":
+            temp_music_file = temp_music_file.replace("/", "\\")
+        music_file_list.append(temp_music_file)
+
+def thread_rescan():
+    """
+    The `thread_rescan` function periodically triggers a rescan operation after a specified time
+    interval.
+    """
+    logging.info("Starting filesystemupdater")
+    while True:
+        time.sleep(60*60*24)
+        logging.info("Rescan triggered")
+        rescan()
+
+app = Flask(__name__)
+
+def wyszukaj(word_list, how_many):
+    logger = logging.getLogger()
+    return_list = []
+    search_weight = []
+
+    for _ in range(len(music_file_list)):
+        search_weight.append((0, ""))
+
+    time_start = datetime.now()
+    if int(how_many) > 0:
+        skip_start = 2
+    else:
+        skip_start = 1
+    for word in word_list[skip_start:]:
+        token_weight = len(word)
+        logger.info("Słowo kluczowe: %s", word)
+        itr = 0
+        for file in music_file_list:
+            file = file.split(SEPARATOR_FILE_PATH)
+
+            char_remove = [
+                ".",
+                "^",
+                "$",
+                "*",
+                "+",
+                "?",
+                "{",
+                "}",
+                "[",
+                "]",
+                "\\",
+                "/",
+                "|",
+                "(",
+                ")",
+                "!",
+                ",",
+                "-",
+                ":",
+                "mp3",
+            ]
+            all_words = []
+            for f_iter in file:
+                for char in char_remove:
+                    f_iter = remove_characters(f_iter, char)
+                tmp = f_iter.split()
+                all_words.extend(tmp)
+            pingu = 1
+            pattern_len = len(all_words)
+            if platform == "win32":
+                skip = 2
+            else:
+                skip = 4
+            matched_times = 1
+            for itm in all_words[skip:]:
+                pingu += 1
+                pattern = ".*" + word + ".*"
+                if re.match(pattern, itm, re.IGNORECASE):
+                    temp_weight = (
+                        search_weight[itr][0]
+                        + (token_weight + (pingu**1.5) / pattern_len) / matched_times
+                    )
+                    search_weight[itr] = (
+                        temp_weight,
+                        music_file_list[itr],
+                    )
+                    matched_times += 1
+            itr += 1
+
+    logger.info("Stworzylem tablice wag zajęło mi to %s", datetime.now() - time_start)
+    time_start = datetime.now()
+    item_to_search = max_weight(search_weight)
+    itr = 0
+    if item_to_search == 0:
+        return None
+    not_found = True
+    return_list = []
+    if int(how_many) <= 0:
+        logger.info("Jeden plik do zagrania")
+        while not_found:
+            if search_weight[itr][0] == item_to_search:
+                return_list.append(search_weight[itr])
+                return return_list
+            itr += 1
+    else:
+        logger.info("Wiele plików do zagrania")
+        search_weight.sort(key=lambda x: x[0], reverse=True)
+        return_list.extend(search_weight[: int(how_many)])
+        return return_list
+
+def max_weight(lista):
+    """
+    Take a list of weights and return the maximum weight.
+
+    :param lista: It seems like the parameter `lista` is a list of items, possibly representing weights.
+    The function name `max_weight` suggests that the function is intended to find the maximum weight
+    from the list. However, without more context or information about the problem, it's difficult to say
+    for sure what the
+    """
+    maximum_weight = 0
+    for iterator in lista:
+        if iterator[0] > maximum_weight:
+            maximum_weight = iterator[0]
+    return maximum_weight
+
+
+def remove_characters(string, character):
+    """
+    The `remove_characters` function removes all occurrences of a specified character from a given
+    string.
+
+    :param string: The string parameter is the input string from which characters will be removed
+    :param character: The character parameter is the character that you want to remove from the string
+    :return: a new string where all occurrences of the specified character have been removed.
+    """
+    return string.replace(character, "")
+
+
+@app.route("/mp3", methods=["GET"])
+def get_music_list():
+    """
+    The function `get_music_list` returns a JSON object containing a list of music files.
+    :return: A JSON response containing a key "music_file_list" with the value of the variable
+    `music_file_list`.
+    """
+    return jsonify({"music_file_list": music_file_list})
+
+
+@app.route("/update_mp3", methods=["POST"])
+def update_music_list():
+    """
+    The function `update_music_list` receives a POST request with a JSON payload, logs the received
+    item, adds it to a music file list, and returns a success message along with the updated record.
+    :return: The function `update_music_list` is returning a tuple containing a JSON response and a
+    status code. The JSON response includes keys `isError`, `message`, `statusCode`, and `data`,
+    with values indicating the success of the operation and the data that was
+    received and added to the `music_file_list`.
+    The status code returned is 200, indicating a successful response.
+    """
+    record = json.loads(request.data)
+    app.logger.info(record["item"])
+    music_file_list.append(record["item"])
+    return_data = (
+        jsonify(isError=False, message="Success", statusCode=200, data=record),
+        200,
+    )
+    return return_data
+
+@app.route("/get_music", methods=["POST"])
+def look_for_playlist():
+    """
+    The function `update_music_list` receives a POST request with a JSON payload, logs the received
+    item, adds it to a music file list, and returns a success message along with the updated record.
+    :return: The function `update_music_list` is returning a tuple containing a JSON response and a
+    status code. The JSON response includes keys `isError`, `message`, `statusCode`, and `data`,
+    with values indicating the success of the operation and the data that was
+    received and added to the `music_file_list`.
+    The status code returned is 200, indicating a successful response.
+    """
+    record = json.loads(request.data)
+    app.logger.info(record)
+    app.logger.info(record["lista_slow"])
+    app.logger.info(record["UUID"])
+    app.logger.info(record["dlugosc_plejlisty"])
+    return_data = wyszukaj(record["lista_slow"],record["dlugosc_plejlisty"])
+
+    return_data = (
+        jsonify(isError=False, message="Success", statusCode=200, data=return_data),
+        200,
+    )
+    return return_data
+
+
+def flask_debug():
+    """
+    The `flask_debug` function starts a Flask application in debug mode without using the reloader.
+    Do not use for production for fucks sake.
+    """
+    # trunk-ignore(bandit/B201)
+    app.run(debug=True, use_reloader=False, host=HOST_ADDRESS, port=PORT_ADDRESS)
+
+def waitress_run():
+    """
+    The `waitress_run` function serves the `app` on host "0.0.0.0"
+    and port 5000 using the Waitress WSGI server.
+    """
+    serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS)
+
+if __name__ == "__main__":
+    logger = logging.getLogger('conjurer_musician')
+    logger.setLevel(logging.DEBUG)
+    rescan()
+    logger.info("Started")
+    threads = []
+    threads.append(threading.Thread(target=waitress_run))
+    threads.append(threading.Thread(target=thread_rescan))
+
+    for worker in threads:
+        worker.start()
+
+    for worker in threads:
+        worker.join()
+
+#TODO: Inne pliki - sadox, dokumenty naukowe itp.

file_webservice/conjurer_musician.service

@@ -0,0 +1,11 @@
+[Unit]
+Description=Conjurer_musician
+After=multi-user.target
+
+[Service]
+Type=simple
+ExecStart=/home/pi/Conjurer-service/conjurer/file_webservice/bin/python3 /home/pi/Conjurer-service/conjurer/file_webservice/conjurer_musician.py
+Restart=on-abort
+
+[Install]
+WantedBy=multi-user.target

file_webservice/install_musician_service.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+python3 -m venv /home/pi/Conjurer-service/conjurer/file_webservice
+source ./bin/activate
+./bin/python3 -m pip install --upgrade pip
+./bin/python3 -m pip install -r requirements_musician.txt
+deactivate
+
+sudo cp ./conjurer_musician.service /etc/systemd/system/
+sudo systemctl daemon-reload
+sudo systemctl start conjurer_musician.service
+sudo systemctl enable conjurer_musician.service

file_webservice/requirements_musician.txt

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

fontget.sh

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

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,25 +1,12 @@
 #!/bin/bash
-sudo apt-get install python3-dev
+python3 -m venv /home/pi/Conjurer/env
-sudo apt-get install portaudio19-dev python3-pyaudio
+source ./env/bin/activate
-sudo apt-get install
+./env/bin/python3 -m pip install --upgrade pip
-cd /home/pi || exit
+./env/bin/python3 -m pip install -r requirements_bot.txt
-mdkir Conjurer
+sed -i -e 's/os.rename/shutil.copy/g' ./env/lib/python3.11/site-packages/spotify_dl/youtube.py
-cd Conjurer ||exit
+sed -i '1i\import shutil' ./env/lib/python3.11/site-packages/spotify_dl/youtube.py
-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
 deactivate
 sudo cp ./conjurer.service /etc/systemd/system/
 sudo systemctl daemon-reload
-sudo systemctl start conjurer.service
+sudo systemctl start conjurer_musician.service
-sudo systemctl enable conjurer.service
+sudo systemctl enable conjurer_musician.service

install_music_bot.sh

@@ -1,51 +0,0 @@
-#!/bin/bash
-cd /home/pi
-mkdir Conjurer
-cd Conjurer
-python3 -m venv /home/pi/Conjurer/env
-source /home/pi/Conjurer/env/bin/activate
-cp /home/pi/conjurer/conjurer_musician/requirements_musician.txt /home/pi/Conjurer/
-cp /home/pi/conjurer/conjurer_musician/conjurer_musician.py /home/pi/Conjurer/
-cp /home/pi/conjurer/conjurer_musician/radio_conjurer.liq /home/pi/Conjurer/
-touch /home/pi/Conjurer/discord_mus_service.log
-
-touch /home/pi/Conjurer/playlist.json
-touch /home/pi/Conjurer/prio_playlist.json
-
-touch /home/pi/Conjurer/all_playlist.playlist
-touch /home/pi/Conjurer/priority_queue.playlist
-touch /home/pi/Conjurer/hit.playlist
-touch /home/pi/Conjurer/request.playlist
-touch /home/pi/Conjurer/persistence.log
-echo "[]" > /home/pi/Conjurer/persistence.log
-
-sudo usermod -aG pulse-access pi
-sudo usermod -aG pulse-access root
-
-sudo usermod -aG audio pi
-sudo usermod -aG audio root
-
-echo "Add exception suppresion to signal handler in spotify __ini__.py"
-echo "Add password to youtube opts in spotify_dl youtube.py"
-echo "Downgrade ffmpeg by copying ffmpeg.pref from repository to /etc/apt/preferences.d"
-echo "Install opam from installation link"
-echo "Initialize opam"
-echo "Install liquidsoap and its dependencies"
-
-touch /home/pi/Conjurer/radio_log.log
-./env/bin/python3 -m pip install --upgrade pip
-./env/bin/python3 -m pip install -r requirements_musician.txt
-deactivate
-sudo cp /home/pi/conjurer/conjurer_musician/conjurer_musician.service /etc/systemd/system/
-sudo systemctl daemon-reload
-sudo systemctl start conjurer_musician.service
-sudo systemctl enable conjurer_musician.service
-
-sudo cp /home/pi/conjurer/conjurer_musician/radio_service.service /etc/systemd/system/
-sudo systemctl daemon-reload
-sudo systemctl start radio_service.service
-sudo systemctl enable radio_service.service
-
-
-sed -i -e 's/os.rename/shutil.copy/g' ./env/lib/python3.11/site-packages/spotify_dl/youtube.py
-sed -i '1i\import shutil' ./env/lib/python3.11/site-packages/spotify_dl/youtube.py

latex_commands.py

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

latex_functions.py

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

librarian_commands.py

@@ -1,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,5 @@ requests
 spotipy
 tiktoken
 PyNaCl
-flask[async]
+flask
-PyMuPDF
+waitress
-waitress
-clickupython
-assemblyai[extras]
-SpeechRecognition
-git+https://github.com/imayhaveborkedit/discord-ext-voice-recv

restart_radio.sh

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

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