From c4e0dea7da971f78314b60cc26f044ba276e6bf5 Mon Sep 17 00:00:00 2001 From: mtuszowski Date: Thu, 7 Nov 2024 09:54:52 +0100 Subject: [PATCH] Refactoring step one --- ai_commandspy => ai_commands.py | 0 ai_functions.py | 26 + constants.py | 101 + music_commands.py | 156 +- music_functions.py | 247 ++ other_commands.py | 68 + bot_music_functions.py => other_functions.py | 0 radio_commands.py | 2 +- thin_client.py | 2184 ++++++++++++++++++ 9 files changed, 2782 insertions(+), 2 deletions(-) rename ai_commandspy => ai_commands.py (100%) create mode 100644 constants.py create mode 100644 music_functions.py create mode 100644 other_commands.py rename bot_music_functions.py => other_functions.py (100%) create mode 100644 thin_client.py diff --git a/ai_commandspy b/ai_commands.py similarity index 100% rename from ai_commandspy rename to ai_commands.py diff --git a/ai_functions.py b/ai_functions.py index e69de29..b281726 100644 --- a/ai_functions.py +++ b/ai_functions.py @@ -0,0 +1,26 @@ + +import tiktoken + + +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 diff --git a/constants.py b/constants.py new file mode 100644 index 0000000..395bb9d --- /dev/null +++ b/constants.py @@ -0,0 +1,101 @@ +import datetime +import json +from sys import platform +from typing import List, Optional, TypedDict +from platform import uname + +Music_Config = TypedDict( + "Music_Config", + { + "ctx": Optional[str], + "queue": List[str], + "requester": List[str], + }, +) + + + +# *=========================================== Predefines +MASTER_TIMEOUT = datetime.now() +INITIAL_TIME_WAIT = 500 +MUZYKA: Music_Config = {"ctx": None, "queue": [], "requester": []} + +LOGFILE = "" +NETRC_FILE = "" +MUSIC_FOLDER = "" +MEMORY_FIVE_SIARA = "" +MEMORY_FIVE_MUZYKA = "" +SETTINGS_FILE = "" +ENCODING = "" +GRAPHICS_PATH = "" +MUZYKA_MOJEGO_LUDU_HISTORIA = 1500 +MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE = 15 +MUZYKA_MOJEGO_LUDU_PLAJLISTA = 30 + +FILE_SERVICE_ADDRESS = "http://192.168.1.15:5000" +RADIO_HARBOR_ADDRESS = "http://192.168.1.15:54321" +SKIP_TRACK = "/skip" + +GET_MP3 = "/mp3" +SEND_MP3 = "/update_mp3" +GET_PLAYLIST = "/get_music" +ADD_TO_PRIO_PLAYLIST = "/add_to_priority" +CREATE_PRIO_PLAYLIST = "/create_priority_playlist" + +REQUEST_MUSIC = "/request_radio_file" +CLEAR_PRIO = "/clear_pr_pls" +LIBRARIAN_SERVICE_ADDRESS = "http://192.168.1.192:5001" +SEND_QUERY = "/query" +TIME_BETWEEN_CALLS = 100000 +LAST_SPONTANEOUS_CALL = datetime.now() +HOST_ADDRESS = "192.168.1.191" +PORT_ADDRESS = 5000 + +# *=========================================== Platform Specific Predefines + +if platform in ("linux", "linux2"): + SEPARATOR_FILE_PATH = "/" + if "microsoft-standard" in uname().release: + LOGFILE = "/home/mtuszowski/conjurer/discord.log" + MEMORY_FIVE_SIARA = "/home/mtuszowski/conjurer/pamiec.json" + SYSTEM_GPT_SETTINGS = "/home/mtuszowski/conjurer/system_gpt_settings.json" + MEMORY_FIVE_MUZYKA = "/home/mtuszowski/conjurer/pamiec_muzyki.json" + MUSIC_FOLDER = "/mnt/g/Muzyka/" + SETTINGS_FILE = "/home/mtuszowski/conjurer/settings.json" + NETRC_FILE = "/home/mtuszowski/.netrc" + LOGSTORE = "/home/mtuszowski/conjurer/logs/" + ACCIDENT_LOG = "/home/mtuszowski/conjurer/accident_log.json" + ENCODING = "utf-8" + GRAPHICS_PATH = "/home/mtuszowski/conjurer/Conjurer_graphics/" + DIR_PATH_SADOX = "/mnt/c/Users/mtusz/OneDrive/Dokumenty/Fansadox" + + else: + LOGFILE = "/home/pi/Conjurer/discord.log" + MEMORY_FIVE_SIARA = "/home/pi/Conjurer/pamiec.json" + SYSTEM_GPT_SETTINGS = "/home/pi/Conjurer/system_gpt_settings.json" + MEMORY_FIVE_MUZYKA = "/home/pi/Conjurer/pamiec_muzyki.json" + MUSIC_FOLDER = "/home/pi/RetroPie/mp3/" + SETTINGS_FILE = "/home/pi/Conjurer/settings.json" + NETRC_FILE = "/home/pi/.netrc" + LOGSTORE = "/home/pi/RetroPie/logs/" + ACCIDENT_LOG = "/home/pi/Conjurer/accident_log.json" + ENCODING = "utf-8" + GRAPHICS_PATH = "/home/pi/RetroPie/Conjurer_graphics/" + DIR_PATH_SADOX = "/home/pi/RetroPie/Fansadox/" + + +elif platform == "win32": + LOGFILE = "discord.log" + MEMORY_FIVE_SIARA = "pamiec.json" + SYSTEM_GPT_SETTINGS = "system_gpt_settings.json" + MEMORY_FIVE_MUZYKA = "pamiec_muzyki.json" + MUSIC_FOLDER = "G:\\Muzyka\\" + SETTINGS_FILE = "settings.json" + NETRC_FILE = "C:\\Users\\mtusz\\.netrc" + LOGSTORE = "C:\\Users\\mtusz\\OneDrive\\Pulpit\\Conjurer\\logs\\" + ACCIDENT_LOG = "accident_log.json" + ENCODING = "utf-8" + DIR_PATH_SADOX = "C:\\Users\\mtusz\\OneDrive\\Dokumenty\\Fansadox\\" + SEPARATOR_FILE_PATH = "\\" +with open(SETTINGS_FILE, "r", encoding=ENCODING) as f_settings_file: + DATA = json.load(f_settings_file) diff --git a/music_commands.py b/music_commands.py index 0c19ac9..e3438a5 100644 --- a/music_commands.py +++ b/music_commands.py @@ -1 +1,155 @@ -import bot_music_functions \ No newline at end of file +import music_functions +from constants import MUZYKA +import logging +import discord +from discord.ext import commands +from communication_subroutine import PREPPED_TRACKS +from sys import platform +import re + +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", + ) + 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ę") + allowed = False + for role in ctx.author.roles: + if role.name == "Bartender": + allowed = True + if allowed: + 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})") + else: + await ctx.reply("Jak ładnie szefa poprosisz.") + + @commands.hybrid_command( + name="co_na_plejliscie_wariacie", + description="Wyswietl kawalki ktore sa na pocztku list radia", + guild=discord.Object(id=664789470779932693), + ) + 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()}") + + @commands.hybrid_command( + name="dej_co_z_jutuba", + description="Podaj link do youtube - sciagnie i doda muzyke", + guild=discord.Object(id=664789470779932693), + ) + 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), + ) + 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") + +async def setup(bot): + logger = logging.getLogger("discord") + music_functions.MUSIC_FILE_LIST.refresh_file_list() + logger.info("Playlist generation") + await bot.add_cog(MusicModule(bot, "discord")) + logger.info("Loading music commands module done") diff --git a/music_functions.py b/music_functions.py new file mode 100644 index 0000000..223fd91 --- /dev/null +++ b/music_functions.py @@ -0,0 +1,247 @@ +import logging +import asyncio +from pathlib import Path, PurePath +from sys import platform +from spotify_dl import spotify +from spotify_dl import youtube as youtube_download +import re +import netrc +import spotipy +from spotipy.oauth2 import SpotifyClientCredentials +from constants import NETRC_FILE, MUSIC_FOLDER, FILE_SERVICE_ADDRESS, GET_MP3, SEND_MP3 +import yt_dlp +import requests +netrc_mod = netrc.netrc(NETRC_FILE) +REMOTE_HOST_NAME = "spotipy" +authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME) + +logger = logging.getLogger("discord") +spotify_ctrl = spotipy.Spotify( + client_credentials_manager=SpotifyClientCredentials( + client_id=authTokens[0], + client_secret=authTokens[2], + ) +) +class MusicFileList(object): + """ + The `MusicFileList` class manages a list of music files, with the ability to refresh the list from a + file service or local directory and update the list with new items. + """ + + def __init__(self, uplogger) -> None: + self.music_file_list = [] + self.file_service_active = False + self.logger = uplogger + self.logger.info("Created Playlist organizer class") + + def refresh_file_list(self): + """ + The `refresh_file_list` function attempts to connect to a file service to retrieve a list of music + files, and if unsuccessful, it populates the list by scanning a local directory for .mp3 files. + """ + try: + self.logger.info("Attempt to connect to file service") + response = requests.get(f"{FILE_SERVICE_ADDRESS}{GET_MP3}", timeout=360) + self.music_file_list = response.json()["music_file_list"] + self.file_service_active = True + except requests.exceptions.RequestException as e: + for mp3_item in Path.glob(Path(MUSIC_FOLDER), "**/*.mp3"): + temp_music_file = mp3_item.as_posix() + if platform == "win32": + temp_music_file = temp_music_file.replace("/", "\\") + self.music_file_list.append(temp_music_file) + self.file_service_active = False + self.logger.error(e.strerror) + self.logger.error("Service Unavailable") + + def get_file_list(self): + """ + The `get_file_list` function returns the list of music files stored in the object. + :return: The `music_file_list` attribute is being returned. + """ + return self.music_file_list + + def update_file_list(self, item): + """ + The `update_file_list` function appends an item to a music file list and sends a POST request with + the item data to a file service address. + + :param item: The `item` parameter in the `update_file_list` method is the file that you want to add + to the `music_file_list` attribute of the class instance. It is then sent as a JSON payload in a + POST request to a file service address along with the endpoint `SEND_MP3` + """ + self.music_file_list.append(item) + post_data = {"item": str(item)} + requests.post(f"{FILE_SERVICE_ADDRESS}{SEND_MP3}", json=post_data, timeout=360) + +MUSIC_FILE_LIST = MusicFileList(logger) + + +async def get_file(ctx, source, link): + """ + Take in three parameters: "ctx" (context), + "source" (a string representing the source of the file), and "link" (a string representing the link + to the file). Execute it in asynchronouse way. And get file from spotify or youtube. + + :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It + represents the context in which a command is being executed, including information such as the + message, the channel, the server, and the user who invoked the command + :param source: The source parameter is likely a string that represents the source of the file that + the user wants to retrieve. This could be a website, a cloud storage service, or any other location + where the file is stored + :param link: The "link" parameter is likely a string that represents a URL or file path to the + location of the file that the function is trying to retrieve + """ + item_id = None + item_type = None + file_list = [] + if source == "Spotify": + dir_path = None + item_type, item_id = spotify.parse_spotify_url(link) + if item_type in ["album", "track", "playlist"] and item_id: + logger.info(item_type) + logger.info(item_id) + logger.info("Spotify link provided") + file_list = await asyncio.to_thread( + spotify.fetch_tracks, spotify_ctrl, item_type, link + ) + logger.info(file_list) + directory_name = await asyncio.to_thread( + spotify.get_item_name, spotify_ctrl, item_type, item_id + ) + logger.info(directory_name) + logger.info("Spotify scrape done") + url_data = {"urls": []} + url_dict = {} + url_dict["save_path"] = Path( + PurePath.joinpath(Path(MUSIC_FOLDER), Path(directory_name)) + ) + url_dict["save_path"].mkdir(parents=True, exist_ok=True) + url_dict["songs"] = file_list + url_data["urls"].append(url_dict.copy()) + file_name_f = youtube_download.default_filename + logger.info("YT-DL") + coro = asyncio.to_thread( + youtube_download.download_songs, + songs=url_data, + output_dir=MUSIC_FOLDER, + format_str="bestaudio/best", + skip_mp3=False, + keep_playlist_order=False, + no_overwrites=True, + remove_trailing_tracks="no", + use_sponsorblock="yes", + file_name_f=file_name_f, + multi_core=0, + proxy="", + ) + _ = await coro + logger.info("YT-DL done") + dir_path = (url_dict["save_path"].resolve()).as_posix() + if platform == "win32": + dir_path = dir_path.replace("/", "\\") + return dir_path, file_list + + await ctx.send( + "No se jaja chyba robisz, Ty byś spotifaja nie poznawszy jakby z krzaków wyskoczył i w dupę kopnął. Plejlista, kawałek albo album prosze." + ) + logger.error("Wrong link provided spotify: %s", link) + elif source == "Youtube": + link_ok = False + pat = r"^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$" + if re.match(pat, link) and re.match(".*youtube.*", link): + link_ok = True + + if link_ok: + dir_path = "" + file_list = [] + query = link + sponsorblock_postprocessor = [ + { + "key": "SponsorBlock", + "categories": ["skip_non_music_sections"], + }, + { + "key": "ModifyChapters", + "remove_sponsor_segments": ["music_offtopic"], + "force_keyframes": True, + }, + ] + # TODO: Make sponsorblock work + sponsorblock_postprocessor = [] + if platform == "win32": + dir_path = "G:\\Muzyka\\Youtube" + else: + dir_path = "/home/pi/RetroPie/mp3/Youtube" + ydl_opts = { + "proxy": "", + "default_search": "ytsearch", + "format": "bestaudio/best", + "postprocessors": sponsorblock_postprocessor, + "noplaylist": True, + "no_color": False, + "paths": {"home": dir_path}, + } + mp3_postprocess_opts = { + "key": "FFmpegExtractAudio", + "preferredcodec": "mp3", + "preferredquality": "192", + } + ydl_opts["postprocessors"].append(mp3_postprocess_opts.copy()) + with yt_dlp.YoutubeDL(ydl_opts) as ydl: + try: + coro = asyncio.to_thread(ydl.download, [query]) + _ = await coro + except Exception as exce: # pylint: disable=broad-exception-caught + logger.error(exce) + logger.info( + "Failed to download %s, make sure yt_dlp is up to date", link + ) + extract = re.search("v=(...........)[&,$]*", link) + ident = extract.group(1) + for item in Path.glob(Path(dir_path), "**/*.mp3"): + file = item.as_posix() + if platform == "win32": + file = file.replace("/", "\\") + if re.match(".*" + ident + ".*", file): + file_list.append(file) + return dir_path, file_list + await ctx.send( + "No se jaja chyba robisz, Ty byś jutuba nie poznawszy jakby z krzaków wyskoczył i w dupę kopnął. Jutuba to nie tuba którą sobie można gdzieś wsadzić." + ) + logger.error("Wrong link provided youtube: %s", link) + return "", None + elif source == "Pornol": + + dir_path = "" + file_list = [] + query = link + sponsorblock_postprocessor = [ + { + "key": "SponsorBlock", + "categories": ["skip_non_music_sections"], + }, + { + "key": "ModifyChapters", + "remove_sponsor_segments": ["music_offtopic"], + "force_keyframes": True, + }, + ] + # TODO: Make sponsorblock work + sponsorblock_postprocessor = [] + dir_path = "/home/pi/RetroPie/movies/porn" + ydl_opts = { + "postprocessors": sponsorblock_postprocessor, + "paths": {"home": dir_path}, + } + with yt_dlp.YoutubeDL(ydl_opts) as ydl: + try: + coro = asyncio.to_thread(ydl.download, [query]) + _ = await coro + except Exception as exce: # pylint: disable=broad-exception-caught + logger.error(exce) + logger.info( + "Failed to download %s, make sure yt_dlp is up to date", link + ) + file_list.append("wiadomo co wiadomo gdzie") + return dir_path, file_list diff --git a/other_commands.py b/other_commands.py new file mode 100644 index 0000000..ef6f6cd --- /dev/null +++ b/other_commands.py @@ -0,0 +1,68 @@ +from discord.ext import commands +import logging +import discord +from typing import Optional +from constants import DATA + +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 :)" + ) + 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*" + ) + + + @commands.hybrid_command(name="fabryczka", description="Historia fabryczki") + 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) + + + +async def setup(bot): + logger = logging.getLogger("discord") + logger.info("Playlist generation") + await bot.add_cog(OtherModule(bot, "discord")) + logger.info("Loading other module done") diff --git a/bot_music_functions.py b/other_functions.py similarity index 100% rename from bot_music_functions.py rename to other_functions.py diff --git a/radio_commands.py b/radio_commands.py index 0c19ac9..503c766 100644 --- a/radio_commands.py +++ b/radio_commands.py @@ -1 +1 @@ -import bot_music_functions \ No newline at end of file +import music_functions \ No newline at end of file diff --git a/thin_client.py b/thin_client.py new file mode 100644 index 0000000..7d141de --- /dev/null +++ b/thin_client.py @@ -0,0 +1,2184 @@ +# This Python file uses the following encoding: utf-8 +# trunk-ignore-all(bandit/B311) +# pylint: disable=line-too-long +# pylint: disable=too-many-lines +""" +Module of a python bot named Conjurer - used to work on BDSM discord servers. +""" +import asyncio +import io +import json +import logging +import netrc + +# *=========================================== Standard Library Imports +import os +import random +import re +import shutil +import subprocess +import sys +import threading +import uuid +from datetime import datetime +from logging import handlers +from pathlib import Path +from platform import uname +from queue import Empty +from sys import platform +from typing import List, Optional, TypedDict +from constants import DATA +# *==============Imported libraries +import discord +import eyed3 +import numpy as np +import openai +import pdf2image +import PyPDF2 +import requests +import spotipy +from discord.ext import commands, tasks +from spotipy.oauth2 import SpotifyClientCredentials + +from communication_subroutine import ( + IN_COMM_Q, + OUT_COMM_Q, + QueryControl, + comm_subroutine, +) +from ai_functions import num_tokens_from_string +# *=========================== Classes definition + +# The above code is defining a TypedDict called `Music_Config` in Python. This TypedDict has three +# keys: "ctx" which is an optional string, "queue" which is a list of strings, and "requester" which +# is a list of strings. This TypedDict is used to define the structure of a dictionary that should +# have these specific keys and value types. +Music_Config = TypedDict( + "Music_Config", + { + "ctx": Optional[str], + "queue": List[str], + "requester": List[str], + }, +) + + +class MusicFileList(object): + """ + The `MusicFileList` class manages a list of music files, with the ability to refresh the list from a + file service or local directory and update the list with new items. + """ + + def __init__(self, uplogger) -> None: + self.music_file_list = [] + self.file_service_active = False + self.logger = uplogger + self.logger.info("Created Playlist organizer class") + + def refresh_file_list(self): + """ + The `refresh_file_list` function attempts to connect to a file service to retrieve a list of music + files, and if unsuccessful, it populates the list by scanning a local directory for .mp3 files. + """ + try: + self.logger.info("Attempt to connect to file service") + response = requests.get(f"{FILE_SERVICE_ADDRESS}{GET_MP3}", timeout=360) + self.music_file_list = response.json()["music_file_list"] + self.file_service_active = True + except requests.exceptions.RequestException as e: + for mp3_item in Path.glob(Path(MUSIC_FOLDER), "**/*.mp3"): + temp_music_file = mp3_item.as_posix() + if platform == "win32": + temp_music_file = temp_music_file.replace("/", "\\") + self.music_file_list.append(temp_music_file) + self.file_service_active = False + self.logger.error(e.strerror) + self.logger.error("Service Unavailable") + + def get_file_list(self): + """ + The `get_file_list` function returns the list of music files stored in the object. + :return: The `music_file_list` attribute is being returned. + """ + return self.music_file_list + + def update_file_list(self, item): + """ + The `update_file_list` function appends an item to a music file list and sends a POST request with + the item data to a file service address. + + :param item: The `item` parameter in the `update_file_list` method is the file that you want to add + to the `music_file_list` attribute of the class instance. It is then sent as a JSON payload in a + POST request to a file service address along with the endpoint `SEND_MP3` + """ + self.music_file_list.append(item) + post_data = {"item": str(item)} + requests.post(f"{FILE_SERVICE_ADDRESS}{SEND_MP3}", json=post_data, timeout=360) + + +# *=========================================== Predefines +MASTER_TIMEOUT = datetime.now() +INITIAL_TIME_WAIT = 500 +MUZYKA: Music_Config = {"ctx": None, "queue": [], "requester": []} + +LOGFILE = "" +NETRC_FILE = "" +MUSIC_FOLDER = "" +MEMORY_FIVE_SIARA = "" +MEMORY_FIVE_MUZYKA = "" +SETTINGS_FILE = "" +ENCODING = "" +GRAPHICS_PATH = "" +MUZYKA_MOJEGO_LUDU_HISTORIA = 1500 +MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE = 15 +MUZYKA_MOJEGO_LUDU_PLAJLISTA = 30 + +FILE_SERVICE_ADDRESS = "http://192.168.1.15:5000" +RADIO_HARBOR_ADDRESS = "http://192.168.1.15:54321" +SKIP_TRACK = "/skip" + +GET_MP3 = "/mp3" +SEND_MP3 = "/update_mp3" +GET_PLAYLIST = "/get_music" +ADD_TO_PRIO_PLAYLIST = "/add_to_priority" +CREATE_PRIO_PLAYLIST = "/create_priority_playlist" + +REQUEST_MUSIC = "/request_radio_file" +CLEAR_PRIO = "/clear_pr_pls" +LIBRARIAN_SERVICE_ADDRESS = "http://192.168.1.192:5001" +SEND_QUERY = "/query" +TIME_BETWEEN_CALLS = 100000 +LAST_SPONTANEOUS_CALL = datetime.now() +HOST_ADDRESS = "192.168.1.191" +PORT_ADDRESS = 5000 + +# *=========================================== Platform Specific Predefines + +if platform in ("linux", "linux2"): + SEPARATOR_FILE_PATH = "/" + if "microsoft-standard" in uname().release: + LOGFILE = "/home/mtuszowski/conjurer/discord.log" + MEMORY_FIVE_SIARA = "/home/mtuszowski/conjurer/pamiec.json" + SYSTEM_GPT_SETTINGS = "/home/mtuszowski/conjurer/system_gpt_settings.json" + MEMORY_FIVE_MUZYKA = "/home/mtuszowski/conjurer/pamiec_muzyki.json" + MUSIC_FOLDER = "/mnt/g/Muzyka/" + SETTINGS_FILE = "/home/mtuszowski/conjurer/settings.json" + NETRC_FILE = "/home/mtuszowski/.netrc" + LOGSTORE = "/home/mtuszowski/conjurer/logs/" + ACCIDENT_LOG = "/home/mtuszowski/conjurer/accident_log.json" + ENCODING = "utf-8" + GRAPHICS_PATH = "/home/mtuszowski/conjurer/Conjurer_graphics/" + DIR_PATH_SADOX = "/mnt/c/Users/mtusz/OneDrive/Dokumenty/Fansadox" + + else: + LOGFILE = "/home/pi/Conjurer/discord.log" + MEMORY_FIVE_SIARA = "/home/pi/Conjurer/pamiec.json" + SYSTEM_GPT_SETTINGS = "/home/pi/Conjurer/system_gpt_settings.json" + MEMORY_FIVE_MUZYKA = "/home/pi/Conjurer/pamiec_muzyki.json" + MUSIC_FOLDER = "/home/pi/RetroPie/mp3/" + SETTINGS_FILE = "/home/pi/Conjurer/settings.json" + NETRC_FILE = "/home/pi/.netrc" + LOGSTORE = "/home/pi/RetroPie/logs/" + ACCIDENT_LOG = "/home/pi/Conjurer/accident_log.json" + ENCODING = "utf-8" + GRAPHICS_PATH = "/home/pi/RetroPie/Conjurer_graphics/" + DIR_PATH_SADOX = "/home/pi/RetroPie/Fansadox/" + + +elif platform == "win32": + LOGFILE = "discord.log" + MEMORY_FIVE_SIARA = "pamiec.json" + SYSTEM_GPT_SETTINGS = "system_gpt_settings.json" + MEMORY_FIVE_MUZYKA = "pamiec_muzyki.json" + MUSIC_FOLDER = "G:\\Muzyka\\" + SETTINGS_FILE = "settings.json" + NETRC_FILE = "C:\\Users\\mtusz\\.netrc" + LOGSTORE = "C:\\Users\\mtusz\\OneDrive\\Pulpit\\Conjurer\\logs\\" + ACCIDENT_LOG = "accident_log.json" + ENCODING = "utf-8" + DIR_PATH_SADOX = "C:\\Users\\mtusz\\OneDrive\\Dokumenty\\Fansadox\\" + SEPARATOR_FILE_PATH = "\\" + + +# *=========================================== Keys +netrc_mod = netrc.netrc(NETRC_FILE) +REMOTE_HOST_NAME = "discord" +authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME) +TOKEN = authTokens[2] +openAIClient = openai.AsyncOpenAI(api_key=openai.api_key) +REMOTE_HOST_NAME = "spotipy" +authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME) +spotify_ctrl = spotipy.Spotify( + client_credentials_manager=SpotifyClientCredentials( + client_id=authTokens[0], + client_secret=authTokens[2], + ) +) + +REMOTE_HOST_NAME = "openai" +authTokens = netrc_mod.authenticators(REMOTE_HOST_NAME) +openai.api_key = authTokens[2] + +# *=========================================== Initializations +intents = discord.Intents.default() +intents.message_content = True +intents.typing = True +intents.presences = True +intents.members = True +intents.messages = True +intents.voice_states = True +logger = logging.getLogger("discord") +logger.setLevel(logging.DEBUG) +handler = handlers.RotatingFileHandler( + filename=LOGFILE, + encoding=ENCODING, + mode="a", + maxBytes=6 * 1024 * 1024, + backupCount=6, +) +formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s") +handler.setFormatter(formatter) +logger.addHandler(handler) +random.seed() +logger.debug(platform) +logger.info("Playlist generation") + +# *=========================================== Load Data files + +music_file_list = MusicFileList(logger) +music_file_list.refresh_file_list() +logger.info("Playlist generation done") + +logger.info("Loading GPT settings") +with open(SYSTEM_GPT_SETTINGS, "r+", encoding=ENCODING) as temp_settings_file: + # First we load existing data into a dict. + GPT_SETTINGS = json.load(temp_settings_file) +logger.info("Done") + +logger.info("Loading memory file") +with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as temp_memory_file: + # First we load existing data into a dict. + MESSAGE_TABLE = json.load(temp_memory_file) +logger.info("Done") + +logger.info("Loading music memory file") +with open(MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING) as temp_music_memory_file: + # First we load existing data into a dict. + message_table_muzyka = json.load(temp_music_memory_file) +logger.info("Done") + +logger.info("Loading settings file") + +logger.info("Loading reactions") +word_reactions = DATA["word_reactions"] +cyclic_words = DATA["cyclic_words"] +for key in word_reactions: + word_reactions[key][2] = datetime.now() +logger.info("Done") + + +# *=========================================== Create Client +logger.info("Creating discord bot") +client = commands.Bot(intents=intents, command_prefix="$") +logger.info("Done") +logger.info("Creating flask app") +logger.info("Done") + + +# *=========================================== Define Events +@client.event +async def on_ready(): + """Metoda wywoływana przy połączeniu do serwera.""" + logger.debug("%s has connected to Discord!", client.user) + #TODO: load vs reload + #try: + await client.load_extension("voice_recognition_commands") + await client.load_extension("music_commands") + await client.load_extension("other_commands") + logger.info(client.cogs) + await client.change_presence(activity=discord.Game(name="Axe Throwing Darts")) + await client.tree.sync() + for com in client.commands: + logger.info("Command %s is awejleble", com.qualified_name) + check_self.start() + check_data_q.start() + + +@client.event +async def on_message(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 == client.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): + if message.author.id == 346956223645614080: + await message.reply("Witam witam") + return + else: + channel = client.get_channel(1064888712565100614) + await channel.send("Słyszałem ja żem że: " + message.content) + return + channel = message.channel + await client.process_commands(message) + + message.content = message.content.lower() + + tdelta = datetime.now() - MASTER_TIMEOUT + tdelta = tdelta.total_seconds() + if "opowiedz o fabryczce" in message.content: + await message.reply(DATA["fabryczka"]) + if "opowiedz mi o fabryczce" in message.content: + await message.reply(DATA["fabryczka"]) + + if tdelta > INITIAL_TIME_WAIT: + for word in word_reactions: + if re.search(r"\b" + word + r"\b", message.content): + tdelta = datetime.now() - word_reactions[word][2] + tdelta = tdelta.total_seconds() + security_clearance = word_reactions[word][4] + reaction = word_reactions[word][3] + if tdelta > word_reactions[word][1]: + # TODO: to zrobic reactiony + logger.info("Ping z procedury reakcji") + if reaction: + emoji = client.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 == client.user: + kondziu_mentioned = True + + if kondziu_mentioned or "conjurer:" in message.content: + async with channel.typing(): + logger.debug("Procedura chatu") + + message.content = message.content.replace("conjurer: ", "") + if message.author.nick: + username = message.author.nick + else: + username = message.author.name + vykidailo = False + bartender = False + if kondziu_mentioned: + prompt = message.clean_content + else: + prompt = message.content + for role in message.author.roles: + if role.name == "Vykidailo": + vykidailo = True + if role.name == "Bartender": + bartender = True + global MESSAGE_TABLE # pylint: disable=global-statement + + result, MESSAGE_TABLE = await handle_response( + prompt, vykidailo, bartender, MESSAGE_TABLE, username, "CONVERSATION" + ) + + if len(result) < 1500: + await message.reply(result) + else: + while len(result) > 1500: + await message.reply(result[:1500]) + result = result[1500:] + if "imaginuje sobie:" in message.content: + async with channel.typing(): + logger.info("Poczatek procedury obrazkowej") + message.content = message.content.replace("imaginuje sobie: ", "") + logger.debug("Wywolanie obrazka: %s", message.content) + try: + response = await openAIClient.images.generate( + model="dall-e-3", + prompt=message.content, + size="1024x1024", + quality="standard", + n=1, + ) + except openai.APITimeoutError as e: + # Handle timeout error, e.g. retry or log + await message.reply( + f"*Kondziu patrzy na terminal, czeka, czeka, czeka,.... Jeszcze chwile czeka Przypierdala w niego pięścią....* Nie mogę się połączyć z Openai spróbuj od nowa. *Na ekranie pojawia się*: {e}" + ) + except openai.APIConnectionError as e: + await message.reply( + f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Nie mogę się połączyć z Openai. *Na ekranie pojawia się*: {e}" + ) + except openai.BadRequestError as e: + # Handle invalid request error, e.g. validate parameters or log + if message.author.nick: + username = message.author.nick + else: + username = message.author.name + resp, _ = await handle_response( + f"Wytlumacz jakie sa zasady dotyczące treści które możesz generować używając Dalle. Wytłumacz błąd {e} prostym językiem. Przeproś za nadmierną cenzurę. Wytłumacz co mogło być nie tak w prompcie '{message.content}'", + True, + True, + MESSAGE_TABLE, + username, + "RANDOM", + ) + await message.reply( + f"Sorki, cenzura: {resp}. Jak chcesz to są kanały na nudle #sexy-foteczky i #kanal-do-fapania *Na ekranie pojawia się: {e}" + ) + except openai.AuthenticationError as e: + # Handle authentication error, e.g. check credentials or log + await message.reply( + f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Wołaj szefa - coś się z hasłem zjebało. *Na terminalu pojawia się:* {e}" + ) + except openai.PermissionDeniedError as e: + # Handle permission error, e.g. check scope or log + await message.reply( + ( + f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Wołaj szefa - coś się z uprawnieniami zjebało. *Na terminalu pojawia się:* {e}" + ) + ) + except openai.RateLimitError as e: + await message.reply( + f"*Kondziu patrzy na terminal* Wołaj szefa. Zapłacić rachunki za AI trzeba. Jak chcesz to się na #zebranie dorzuć. {e}" + ) + except openai.APIError as e: + # Handle API error, e.g. retry or log + await message.reply( + f"*Kondziu nurkuje za bar, terminal wybucha. Przed tobą ląduje pergamin zapisany pięknym gotykiem a na nim*: {e}" + ) + if response: + logger.info(response) + image_url = response.data[0].url + image_desc = response.data[0].revised_prompt + logger.debug("Wynikowy obrazek pod url: %s", image_url) + response = requests.get(image_url, timeout=360) + + temp_file_name = message.content + ".png" + temp_file_name = GRAPHICS_PATH + message.content + ".png" + + with open(temp_file_name, "wb") as dalle_file: + dalle_file.write(response.content) + logger.info("Koniec procedury obrazkowej.") + fnord = discord.File( + temp_file_name, spoiler=False, description=message.content + ) + await message.reply(f"{image_desc}", file=fnord) + + +# *=========================================== Define Functions + + +async def connect(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: + logger.info("Ctx and arg defined for connect") + + if client.voice_clients: + 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 = client.get_channel(1060349757349974066) + vc = await voice_channel.connect() + if not vc: + logger.error("Not possible to connect to voice") + return + logger.info("Connected to voice") + + +async def disconnect(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: + logger.info("Ctx defined for disconnect") + if client.voice_clients: + voice_client = client.voice_clients[0] + if voice_client.is_connected(): + await voice_client.disconnect() + + +async def play(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. + logger.info("Play procedure") + if arg: + logger.info("Arg defined for play") + + file_to_play = None + voice_client = client.voice_clients[0] + if not client.voice_clients: + voice_client = client.voice_clients[0] + await connect(ctx) + if MUZYKA["queue"]: + file_to_play = MUZYKA["queue"].pop() + zamawial = MUZYKA["requester"].pop() + logger.info("Muzyka z listy zamówień") + else: + index = random.randint(0, len(music_file_list.get_file_list()) - 1) + file_to_play = music_file_list.get_file_list()[index] + logger.info("Muzyka losowo") + + 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: + logger.debug("Zapytanie do openai") + 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 # pylint: disable=global-statement + result, MESSAGE_TABLE = await handle_response( + query, vykidailo, bartender, message_table_muzyka, username, "MUSIC" + ) + 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 archive_channel(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 = client.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=1) +async def check_music(): + """ + This Python function continuously checks for music playback in a voice client and plays music if + conditions are met. + """ + if client.voice_clients: + voice_client = client.voice_clients[0] + if ( + voice_client + and voice_client.is_connected() + and not voice_client.is_playing() + and not voice_client.is_paused() + ): + await play(MUZYKA["ctx"], MUZYKA["requester"]) + await asyncio.sleep(2) + + +@tasks.loop(seconds=3) +async def check_data_q(): + """ + 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: + 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 = client.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 + + +@tasks.loop(seconds=120) +async def check_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 = client.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()}") + logger.info("Log rollover") + 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" + 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" + 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: + logger.info("Spontaneous call") + TIME_BETWEEN_CALLS = random.randint( + 10200, 272800 + ) # temp random, set after each call + logger.debug(TIME_BETWEEN_CALLS) + LAST_SPONTANEOUS_CALL = datetime.now() + async with channel.typing(): + message = await get_random_cyclic_message() + logger.info("Odpowiedz") + logger.info(message) + await channel.send(message) + + +async def get_random_cyclic_message(): + """ + 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`. + """ + channel_id = 1062047367337095268 + channel = client.get_channel(channel_id) + ai_check = random.randint(0, 10) + logger.info("Losowa wypowiedź") + if ai_check < 2: + logger.info("Predefiniowana") + 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] + 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 handle_response( + prompt, vykidailo, bartender, history, username, request_type +): + """ + Handle responses by appending them to a history, use OpenAI to + generate a response, and then append the generated response to the history. + + :param prompt: The prompt for the OpenAI chatbot to generate a response to + :param vykidailo: It is a boolean variable that indicates whether the user invoking the function is + an administrator or not + :param bartender: The bartender parameter is a boolean value indicating whether the user making the + request is a bartender or not + :param history: A list containing the conversation history between the user and the assistant + :param username: The username of the user who initiated the conversation + :param music: The "music" parameter is a boolean value that indicates whether the conversation is + related to music or not. If it is True, the conversation history will be stored in a different file + and the response will be generated using a different model + :return: The function `handle_response` returns a tuple containing the `result` and `MESSAGE_TABLE`. + """ + # TODO: Wykrywać "Pracuję nad odpowiedzią i tego typu rzeczy" + logger.info("Wywolanie procedury openai z promptem: %s", prompt) + temp = {"role": "user", "content": username + ":" + prompt} + if vykidailo or bartender: + logger.info("Administrator coś chciał") + history.append(temp) + if request_type == "MUSIC": + with open(MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING) as file_music_memory: + # First we load existing data into a dict. + file_data = json.load(file_music_memory) + # Join new_data with file_data inside emp_details + file_data.append(temp) + file_music_memory.seek(0) + # convert back to json. + json.dump(file_data, file_music_memory, indent=4) + elif request_type == "RANDOM": + with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file_memory: + # First we load existing data into a dict. + file_data = json.load(file_memory) + # Join new_data with file_data inside emp_details + file_data.append(temp) + file_memory.seek(0) + # convert back to json. + json.dump(file_data, file_memory, indent=4) + else: + with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file_memory: + # First we load existing data into a dict. + file_data = json.load(file_memory) + # Join new_data with file_data inside emp_details + file_data.append(temp) + file_memory.seek(0) + # convert back to json. + json.dump(file_data, file_memory, indent=4) + history = [] + history.append(GPT_SETTINGS[0]) + chat_gpt_config_request_size = num_tokens_from_string(GPT_SETTINGS[0], "gpt-4") + + for slowo, reakcja in word_reactions.items(): + if not reakcja[3]: + content = ( + "Kiedy słyszysz " + + slowo + + " to reagujesz lub dzieje się to " + + reakcja[0] + ) + temp = {"role": "system", "content": content} + chat_gpt_config_request_size += num_tokens_from_string(temp, "gpt-4") + history.append(temp) + + final_prompt = username + ":" + prompt + logger.debug( + "Rozmiar zapytania przed dodaniem historii %s", chat_gpt_config_request_size + ) + if request_type == "MUSIC": + algorithm = "gpt-4o" + table = message_table_muzyka + token_amount = 10700 + elif request_type == "RANDOM": + algorithm = "gpt-4o" + table = MESSAGE_TABLE + token_amount = 10700 + else: + table = MESSAGE_TABLE + algorithm = "gpt-4o" + token_amount = 10700 + + prompt_gpt_request_size = num_tokens_from_string( + {"role": "user", "content": final_prompt}, "gpt-4" + ) + temptable = [] + for i in reversed(table): + temp_token = num_tokens_from_string(i, "gpt-4") + logger.debug( + "Rozmiar zapytania %s prompt %s temp %s", + chat_gpt_config_request_size, + prompt_gpt_request_size, + temp_token, + ) + if ( + chat_gpt_config_request_size + < token_amount + prompt_gpt_request_size + temp_token + ): + temptable.insert(1, i) + chat_gpt_config_request_size += temp_token + history.extend(temptable) + temp = {"role": "user", "content": final_prompt} + history.append(temp) + logger.info("Rozmiar zapytania po wyslaniu %s", chat_gpt_config_request_size) + try: + response = await openAIClient.chat.completions.create( + model=algorithm, messages=history + ) + except openai.APITimeoutError as e: + # Handle timeout error, e.g. retry or log + result = f"*Kondziu patrzy na terminal, czeka, czeka, czeka,.... Jeszcze chwile czeka Przypierdala w niego pięścią....* Nie mogę się połączyć z Openai spróbuj od nowa. *Na ekranie pojawia się*: {e}" + except openai.APIConnectionError as e: + result = f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Nie mogę się połączyć z Openai. *Na ekranie pojawia się*: {e}" + except openai.BadRequestError as e: + # Handle invalid request error, e.g. validate parameters or log + resp, _ = await handle_response( + f"Wytlumacz jakie sa zasady dotyczące treści które możesz generować używając Dalle. Wytłumacz błąd {e} prostym językiem. Przeproś za nadmierną cenzurę. Wytłumacz co mogło być nie tak w prompcie 'prompt'", + True, + True, + MESSAGE_TABLE, + username, + "RANDOM", + ) + result = f"Sorki, cenzura: {resp}. Jak chcesz to są kanały na nudle #sexy-foteczky i #kanal-do-fapania *Na ekranie pojawia się: {e}" + except openai.APIResponseValidationError as e: + # Handle invalid request error, e.g. validate parameters or log + resp, _ = await handle_response( + f"Wytlumacz jakie sa zasady dotyczące treści które możesz generować używając Dalle. Wytłumacz błąd {e} prostym językiem. Przeproś za nadmierną cenzurę. Wytłumacz co mogło być nie tak w prompcie 'prompt'", + True, + True, + MESSAGE_TABLE, + username, + "RANDOM", + ) + result = f"Sorki, cenzura: {resp}. Jak chcesz to są kanały na nudle #sexy-foteczky i #kanal-do-fapania *Na ekranie pojawia się: {e}" + except openai.AuthenticationError as e: + # Handle authentication error, e.g. check credentials or log + result = f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Wołaj szefa - coś się z hasłem zjebało. *Na terminalu pojawia się:* {e}" + except openai.PermissionDeniedError as e: + # Handle permission error, e.g. check scope or log + result = f"*Kondziu patrzy na terminal, chwile się zastanawia. Przypierdala w niego pięścią....* Wołaj szefa - coś się z uprawnieniami zjebało. *Na terminalu pojawia się:* {e}" + except openai.RateLimitError as e: + result = f"*Kondziu patrzy na terminal* Wołaj szefa. Zapłacić rachunki za AI trzeba. Jak chcesz to się na #zebranie dorzuć. {e}" + except openai.UnprocessableEntityError as e: + result = f"*Kondziu patrzy na terminal. Potem na to co każesz mu wysłać....* Ja wiem że jesteśmy w barze BDSM - ale nie da się włożyć TEGO w TO. *Za jego plecami na terminalu pojawia się:* {e}" + except openai.APIError as e: + # Handle API error, e.g. retry or log + result = f"*Kondziu nurkuje za bar, terminal wybucha. Przed tobą ląduje pergamin zapisany pięknym gotykiem a na nim*: {e}" + + logger.info("Historia wysłana:") + logger.info(history) + await asyncio.sleep(15) + result = "" + logger.debug("Odpowiedzi") + logger.info(response) + logger.debug(response.choices) + for choice in response.choices: + result += choice.message.content + logger.info("Sformatowane odpowiedzi") + logger.info(result) + temp = {"role": "assistant", "content": result} + history.append(temp) + if request_type == "MUSIC": + with open(MEMORY_FIVE_MUZYKA, "r+", encoding=ENCODING) as file_music_memory: + # First we load existing data into a dict. + file_data = json.load(file_music_memory) + # Join new_data with file_data inside emp_details + file_data.append(temp) + file_music_memory.seek(0) + # convert back to json. + json.dump(file_data, file_music_memory, indent=4) + elif request_type == "RANDOM": + with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file_memory: + # First we load existing data into a dict. + file_data = json.load(file_memory) + # Join new_data with file_data inside emp_details + file_data.append(temp) + file_memory.seek(0) + # convert back to json. + json.dump(file_data, file_memory, indent=4) + else: + with open(MEMORY_FIVE_SIARA, "r+", encoding=ENCODING) as file_memory: + # First we load existing data into a dict. + file_data = json.load(file_memory) + # Join new_data with file_data inside emp_details + file_data.append(temp) + file_memory.seek(0) + # convert back to json. + json.dump(file_data, file_memory, indent=4) + return result, MESSAGE_TABLE + + +# 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 get_stats(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 wyszukaj(ctx, how_many=0, slowa_kluczowe=None): + """ + Take in a context object and an optional integer parameter "how_many" and perform search + operation on music library. + + :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It + represents the context in which the command was invoked, including information such as the message, + the channel, the server, and the user who invoked the command + :param how_many: how_many is a parameter that specifies the number of search results to be returned. + It is an optional parameter with a default value of 0, which means that if no value is provided for + how_many, the function will return all search results, defaults to 0 (optional) + """ + # i sieć neuronową z możliwością wyrażenia opinii o dopasowaniu. + if slowa_kluczowe: + word_list = slowa_kluczowe + else: + word_list = ctx.message.content.split() + logger.info("Wyszukuje") + jrequest = { + "lista_slow": word_list, + "dlugosc_plejlisty": how_many, + "UUID": str(uuid.uuid4()), + } + coroutine = asyncio.to_thread( + requests.post, + f"{FILE_SERVICE_ADDRESS}{GET_PLAYLIST}", + json=jrequest, + timeout=360, + ) + + return_data = await coroutine + if not return_data.status_code == 200: + await ctx.send("Wołaj szefa - coś się wyjebało") + return + logger.info(return_data.json()["data"]) + return return_data.json()["data"] + + +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 + + +# *=========================================== Define Commands + + +@client.hybrid_command( + name="skip_track", + description="Przeskocz kawałek w radiu", + guild=discord.Object(id=664789470779932693), +) +async def skip_track(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 + logger.info("Done %s", result) + await ctx.send("Zrobione szefie!") + + +@client.hybrid_command( + name="zrestartuj_radio", + description="Komenda ktora uruchamia radio ponownie jakby się zawiesiło", + guild=discord.Object(id=664789470779932693), +) +async def zrestartuj_radio(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", + shell=False, + check=False, + capture_output=True, + ) + logger.info("Wynik: %s", retcode) + + + + + + +@client.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), +) +async def update_banlist(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 client.guilds: + bancunter = 0 + # trunk-ignore(codespell/misspelled) + 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 client.fetch_user(int(ident)) + await guild.ban( + tmp_user, + reason="Automatyczna lista banów", + delete_message_seconds=0, + ) + cunter_counter += 1 + except discord.NotFound: + 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") + + +@client.hybrid_command( + nsfw=True, + name="get_image_sadox", + description="Wyświetla losową stronę z losowego komiksu FanSadox. Bardzo NSFW.", + guild=discord.Object(id=664789470779932693), +) +async def get_image_sadox(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 + """ + 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) + filename = res[random.randrange(0, len(res) - 1)] + # select random page + file = open(DIR_PATH_SADOX + filename, "rb") + readpdf = PyPDF2.PdfReader(file) + totalpages = len(readpdf.pages) + 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) + logger.info("Get sadox completed") + + +@client.hybrid_command( + name="graj_muzyko", + description="Włącza muzykę na kanale #nocna-zmiana.", + guild=discord.Object(id=664789470779932693), +) +async def graj_muzyko(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 + """ + + logger.info("Press play on tape") + async with ctx.typing(): + global MUZYKA # pylint: disable=global-variable-not-assigned + MUZYKA["ctx"] = ctx + await connect(ctx=ctx) + await play(ctx=ctx) + logger.info("Press play on tape completed") + check_music.start() + + +@client.hybrid_command( + name="radio_hardkor", + description="Włącza radio Conjurer na kanale #nocna-zmiana.", + guild=discord.Object(id=664789470779932693), +) +async def radio_hardkor(ctx): + """ + Plays the radio hardkor stream in the voice channel. + + Args: + ctx: The context object representing the invocation context. + + Returns: + None + """ + logger.info("Press play on radio hardkor") + async with ctx.typing(): + global MUZYKA # pylint: disable=global-variable-not-assigned + MUZYKA["ctx"] = ctx + if not client.voice_clients: + await connect(ctx=ctx) + voice_client = client.voice_clients[0] + voice_client.play( + discord.PCMVolumeTransformer( + discord.FFmpegPCMAudio("http://95.175.16.246:666/mp3-stream"), + volume=0.3, + ) + ) + logger.info("Press play on radio completed") + else: + logger.error("Already playing") + await asyncio.sleep(12) + check_music.start() + + +@client.hybrid_command( + name="cisza", + description="Wyłącza muzykę i czyści plejliste.", + guild=discord.Object(id=664789470779932693), +) +async def cisza(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 + """ + logger.info("Stop") + global MUZYKA # pylint: disable=global-variable-not-assigned + MUZYKA["ctx"] = None + voice_client = client.voice_clients[0] + check_music.stop() + if voice_client.is_connected(): + await disconnect(ctx=ctx) + while MUZYKA["queue"]: + MUZYKA["queue"].pop() + MUZYKA["requester"].pop() + logger.info("Stop completed") + + +@client.hybrid_command( + name="dalej", + description="Przerzuca na następny kawałek", + guild=discord.Object(id=664789470779932693), +) +async def dalej(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: + logger.info("Ctx defined for dalej") + logger.info("Next") + voice_client = client.voice_clients[0] + if voice_client.is_connected(): + voice_client.stop() + logger.info("Next completed") + + +@client.hybrid_command( + name="daj_mi_chwile", + description="Pauzuje", + guild=discord.Object(id=664789470779932693), +) +async def daj_mi_chwile(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: + logger.info("Ctx defined for pause") + + logger.info("Pause") + voice_client = client.voice_clients[0] + if voice_client.is_connected(): + voice_client.pause() + logger.info("Pause completed") + + +@client.hybrid_command( + name="graj_dalej", + description="Odpauzowuje", + guild=discord.Object(id=664789470779932693), +) +async def graj_dalej(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: + logger.info("Ctx defined for graj_dalej") + logger.info("Unpause") + voice_client = client.voice_clients[0] + if voice_client.is_paused(): + voice_client.resume() + logger.info("Unpause completed") + + +@client.hybrid_command( + name="zagraj_mi_kawalek", + description="Wyszukuje w bibliotece muzycznej Hammera kawałek który ma zostać zagrany", + guild=discord.Object(id=664789470779932693), +) +async def zagraj_mi_kawalek(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() + logger.info("Zaczynam szukać timestamp %s", datetime.now()) + file = await wyszukaj(ctx=ctx) + 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" + ) + + +@client.hybrid_command( + name="dodaj_do_ulubionych", + description="Dodaje do listy ulubionych w radiu", + guild=discord.Object(id=664789470779932693), +) +async def dodaj_do_ulubionych(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(): + logger.info("Zaczynam szukać timestamp %s", datetime.now()) + + dlugosc_playlisty = ctx.message.content.split()[1] + word_list = ctx.message.content.split() + jrequest = { + "lista_slow": word_list, + "dlugosc_plejlisty": dlugosc_playlisty, + "UUID": str(uuid.uuid4()), + } + coroutine = asyncio.to_thread( + requests.post, + f"{FILE_SERVICE_ADDRESS}{ADD_TO_PRIO_PLAYLIST}", + json=jrequest, + timeout=360, + ) + result = await coroutine + logger.info("Done %s", result) + await ctx.send("Zrobione szefie!") + + +@client.hybrid_command( + name="ja_chciol", + description="Dodaje do listy ulubionych w radiu", + guild=discord.Object(id=664789470779932693), +) +async def request_radio(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(): + logger.info("Zaczynam szukać timestamp %s", datetime.now()) + + word_list = ctx.message.content.split() + jrequest = { + "lista_slow": word_list, + "UUID": str(uuid.uuid4()), + } + coroutine = asyncio.to_thread( + requests.post, + f"{FILE_SERVICE_ADDRESS}{REQUEST_MUSIC}", + json=jrequest, + timeout=360, + ) + result = await coroutine + logger.info("Done %s", result) + await ctx.send("Zrobione szefie!") + + +@client.hybrid_command( + name="stworz_audycje", + description="Dodaje do listy ulubionych w radiu", + guild=discord.Object(id=664789470779932693), +) +async def stworz_audycje(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(): + logger.info("Zaczynam szukać timestamp %s", datetime.now()) + + dlugosc_playlisty = ctx.message.content.split()[1] + word_list = ctx.message.content.split() + jrequest = { + "lista_slow": word_list, + "dlugosc_plejlisty": dlugosc_playlisty, + "UUID": str(uuid.uuid4()), + } + coroutine = asyncio.to_thread( + requests.post, + f"{FILE_SERVICE_ADDRESS}{CREATE_PRIO_PLAYLIST}", + json=jrequest, + timeout=360, + ) + result = await coroutine + logger.info("Done %s", result) + await ctx.send("Zrobione szefie!") + + +@client.hybrid_command( + name="wyczysc_ulubione", + description="Czysci liste ulubionych w radiu", + guild=discord.Object(id=664789470779932693), +) +async def wyczysc_ulubione(ctx): + """ + Generate a playlist in queue. First word in this command shall be int defining length of the playlist. + Rest of the line are search terms. + + :param ctx: ctx stands for "context" and is a parameter commonly used in Discord.py commands. It + represents the context in which the command was invoked, including information such as the message, + the channel, the server, and the user who invoked the command. This parameter is required in all + Discord.py commands + """ + async with ctx.typing(): + coroutine = asyncio.to_thread( + requests.get, + f"{FILE_SERVICE_ADDRESS}{CLEAR_PRIO}", + timeout=360, + ) + result = await coroutine + logger.info("Done %s", result) + await ctx.send("Zrobione szefie!") + + +@client.hybrid_command( + name="zrob_mi_plejliste", + description="Generuje playliste - param1 - dlugosc, potem slowa wyszukiwania", + guild=discord.Object(id=664789470779932693), +) +async def zrob_mi_plejliste(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(): + logger.info("Zaczynam szukać timestamp %s", datetime.now()) + search_time_glob = datetime.now() + + dlugosc_playlisty = ctx.message.content.split()[1] + file = await wyszukaj(ctx=ctx, how_many=dlugosc_playlisty) + 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]: + 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) + logger.info("Plejlista zrobiona") + + + + + +@client.hybrid_command( + name="chata_hammera", + description="Czas od ostatniego incydentu w AbsinthHammerTimeSpaceContinuum", +) +async def chata_hammera(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}" + ) + + +@client.hybrid_command( + name="historia_incydentow_u_hammera", + description="Wyswietla liste incydentów które miały miejsce w AbsinthHammerTimeSpaceContinuum.", +) +async def historia_incydentow_u_hammera(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) + + +@client.hybrid_command( + name="reset_the_clock", + description="Resetowanie zegara - dostępne wyłącznie dla Hammera", + guild=discord.Object(id=664789470779932693), +) +async def reset_the_clock(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? {client.get_user(346956223645614080).mention} coś albo się komuś stało albo zaraz się stanie jak będzie zegar tykał...." + ) + + +@client.hybrid_command( + name="zagraj_muzyke_mego_ludu", + description="Gra muzyke wyszukana na bazie tematow konwersacji na kanale NZ", + guild=discord.Object(id=664789470779932693), +) +async def zagraj_muzyke_mego_ludu(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: + logger.info("Zagraj muzyke mego ludu: wywolane") + stat_iter = get_stats(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]) + logger.info("Zagraj muzyke mego ludu:zebrano statystyki") + key_words = [] + for stat in sorted_stats: + key_words.append(stat[0]) + logger.info(sorted_stats[:MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE]) + logger.info(key_words[:MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE]) + logger.info(sorted_stats[-MUZYKA_MOJEGO_LUDU_SLOWA_KLUCZOWE:]) + 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(): + logger.info( + "Zagraj muzyke mego ludu:Zaczynam szukać timestamp %s", datetime.now() + ) + search_time_glob = datetime.now() + file = await wyszukaj( + ctx=ctx, + how_many=MUZYKA_MOJEGO_LUDU_PLAJLISTA, + slowa_kluczowe=final_key_words, + ) + logger.info("Zagraj muzyke mego ludu:wygenerowano plejliste") + logger.info(file) + 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) + logger.info("Plejlista zrobiona") + + +@client.hybrid_command( + name="parametry_muzyki_mego_ludu", + description="Konfiguruje komende zagraj muzyke mojego ludu", + guild=discord.Object(id=664789470779932693), +) +async def parametry_muzyki_mego_ludu( + 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 + 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 + 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"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") + logger.info(exce) + + +@client.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(ctx): + """ + The function `wyszukaj_linki_do_dokumentow` searches for links to documents in a crossref database and provides links to scihub. + + :param ctx: The `ctx` parameter is typically used in Discord.py, a Python library for creating Discord bots. + It represents the context of the command being executed, including information about the message, the server, + and the user who invoked the command. + """ + query = ctx.message.content + query_uuid = uuid.uuid4() + # TODO: TESTING ONLY!! + # query_uuid = uuid.UUID('{12345678-1234-5678-1234-567812345678}') + ctx.message.content = ctx.message.content.replace( + "$wyszukaj_linki_do_dokumentow", "" + ) + + json_query = { + "UUID": str(query_uuid), + "query": str(query), + "page": 1, + "deep_search": False, + } + coroutine = asyncio.to_thread( + requests.post, + f"{LIBRARIAN_SERVICE_ADDRESS}{SEND_QUERY}", + json=json_query, + timeout=360, + ) + await ctx.send( + "*Conjurer powoli notuje podane przez Ciebie. Podchodzi do sprytnie ukrytej przy barze rury od poczty pneumatycznej i" + + " wrzuca twój liścik do środka* To teraz trza poczekać kilka godzin. Biblioteka to 3/4 stacji." + + " A przecież pół stacji to browar, motelik dla zabaw cielesnych i ten Bar. Więc 12/8 stacji teraz będzie ciężko pracować" + ) + query_response = await coroutine + if not query_response.status_code == 200: + await ctx.send( + "*Z rury wydobywa się dym. Conjurer łapie pierwszą ciecz pod ręką i pryska na rurę. Następuje drobna eksplozja i wszystko zaczyna się palić." + + " Conjurer jest skonfundowany..* Wołaj szefa - mam nieodparte wrażenie że się coś wyjebało" + ) + return + + query, query_uuid, queue_size = ( + query_response.json()["data"][0], + query_response.json()["data"][1], + query_response.json()["data"][2], + ) + if ctx.message.author.nick: + username = ctx.message.author.nick + else: + username = ctx.message.author.name + query_object = QueryControl(username, query_uuid, query, ctx) + OUT_COMM_Q.put(query_object) + await ctx.send( + f"No dobra poszło. Zapamiętaj proszę {query_uuid} - to identyfikator twojego zapytania. Jesteś {queue_size} w kolejce." + + " Zapytania obsługuje algorytm zasilany czterema chomikami zapierdalającymi w kołowrotku - więc wyniki najwcześniej za kilka godzi - ale mogą być też dni." + ) + + +@client.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(ctx): + """ + The function `wyszukaj_linki_do_dokumentow_deep` performs a deep search for links to documents in + a crossref database and provides links to scihub. + + :param ctx: The `ctx` parameter is typically used in Discord.py, a Python library for creating Discord bots. + It represents the context of the command being executed, including information about the message, the server, + and the user who invoked the command. + """ + # TODO: Implement deep search logic here + query = ctx.message.content.replace("$glebokie_gardlo", "") + allowed = False + for role in ctx.message.author.roles: + if role.name == "Bartender": + allowed = True + if role.name == "Scribe": + allowed = True + if role.name == "Thane": + allowed = True + if not allowed: + if ctx.message.author.nick: + username = ctx.message.author.nick + else: + username = ctx.message.author.name + vykidailo = False + bartender = False + prompt = "Przygotuj mi drinka o nazwie Głębokie Gardło, inspirowanego tym sławnym filmem oraz skandalem Watergate" + for role in ctx.message.author.roles: + if role.name == "Vykidailo": + vykidailo = True + if role.name == "Bartender": + bartender = True + global MESSAGE_TABLE # pylint: disable=global-statement + + result, MESSAGE_TABLE = await handle_response( + prompt, vykidailo, bartender, MESSAGE_TABLE, username, "CONVERSATION" + ) + if len(result) < 1500: + await ctx.send(result) + else: + while len(result) > 1500: + await ctx.send(result[:1500]) + result = result[1500:] + return + + query_uuid = uuid.uuid4() + # TODO: TESTING ONLY!! + # query_uuid = uuid.UUID('{12345678-1234-5678-1234-567812345678}') + json_query = { + "UUID": str(query_uuid), + "query": str(query), + "page": 1, + "deep_search": True, + } + coroutine = asyncio.to_thread( + requests.post, + f"{LIBRARIAN_SERVICE_ADDRESS}{SEND_QUERY}", + json=json_query, + timeout=360, + ) + await ctx.send( + "*Conjurer mruga okiem i zamiast drinka wyjmuje dysk usb z terminala. Podchodzi do sprytnie ukrytej przy barze rury od poczty pneumatycznej i" + + " wrzuca ten dysk do środk* To teraz trza poczekać kilka godzin. TO będzie głębokie wyszukanie" + + " Rozgląda się dookoła i stawia przed tobą mętnego drinka o zapachu mięty, gwiezdnego pyłu i oleju silnikowego" + ) + query_response = await coroutine + if not query_response.status_code == 200: + await ctx.send( + "*Z rury wydobywa się dym. Conjurer łapie pierwszą ciecz pod ręką i pryska na rurę. Następuje drobna eksplozja i wszystko zaczyna się palić." + + " Conjurer jest skonfundowany..* Wołaj szefa - mam nieodparte wrażenie że się coś wyjebało" + ) + return + + query, query_uuid, queue_size = ( + query_response.json()["data"][0], + query_response.json()["data"][1], + query_response.json()["data"][2], + ) + if ctx.message.author.nick: + username = ctx.message.author.nick + else: + username = ctx.message.author.name + query_object = QueryControl(username, query_uuid, query, ctx) + OUT_COMM_Q.put(query_object) + await ctx.send( + f"Wypij wypi {query_uuid} - to identyfikator twojego zapytania. Jesteś {queue_size} w kolejce niestety kolejka obowiazuje zawsze." + + " Zapytania obsługuje algorytm zasilany czterema chomikami zapierdalającymi w kołowrotku - więc wyniki najwcześniej za kilka godzin - ale mogą być też dni. Głębokie zabawy trwają dłużej. *Znowu mruga*" + ) + + + +# *================================== Run +if __name__ == "__main__": + logger.info("Starting discord bot") + threads = [] + logger.info("Starting discord bot: Creating threads") + threads.append(threading.Thread(target=client.run, args=(TOKEN,))) + threads.append(threading.Thread(target=comm_subroutine)) + logger.info("Starting discord bot: Starting threads") + WRK_CNT = 0 + for worker in threads: + WRK_CNT += 1 + logger.info("Starting discord bot: Starting thread %s", WRK_CNT) + worker.start() + logger.info("Starting discord bot: Joining threads") + WRK_CNT = 0 + for worker in threads: + WRK_CNT += 1 + logger.info("Starting discord bot: Joining thread %s", WRK_CNT) + worker.join()