From 6a45bf8df071f2fa64e9eeb3b4f3b75b35004ca4 Mon Sep 17 00:00:00 2001 From: Polish Hammer Date: Thu, 30 Oct 2025 16:59:07 +0100 Subject: [PATCH] Tag: 1.12 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Intermediate commits (oldest → newest): - Changes for too long messages handling - Track name broadcast att 1 - Music tracker - fx - fx2 - fx - logg - fx --- bot.py | 178 ++++++++++++++++--------- communication_subroutine.py | 65 ++++++--- conjurer_musician/conjurer_musician.py | 66 ++++++++- 3 files changed, 226 insertions(+), 83 deletions(-) diff --git a/bot.py b/bot.py index bba940f..6706ded 100644 --- a/bot.py +++ b/bot.py @@ -16,10 +16,10 @@ import os import random import re import shutil +import subprocess import sys import threading import uuid -import subprocess from datetime import datetime from logging import handlers from pathlib import Path, PurePath @@ -42,11 +42,15 @@ from discord.ext import commands, tasks from spotipy.oauth2 import SpotifyClientCredentials import yt_dlp +from communication_subroutine import ( + IN_COMM_Q, + OUT_COMM_Q, + QueryControl, + comm_subroutine, +) from spotify_dl import spotify from spotify_dl import youtube as youtube_download -from communication_subroutine import comm_subroutine, IN_COMM_Q, OUT_COMM_Q, QueryControl - # *=========================== Classes definition # The above code is defining a TypedDict called `Music_Config` in Python. This TypedDict has three @@ -63,7 +67,6 @@ Music_Config = TypedDict( ) - class MusicFileList(object): """ The `MusicFileList` class manages a list of music files, with the ability to refresh the list from a @@ -284,7 +287,6 @@ for key in word_reactions: logger.info("Done") - # *=========================================== Create Client logger.info("Creating discord bot") client = commands.Bot(intents=intents, command_prefix="$") @@ -404,7 +406,13 @@ async def on_message(message): result, MESSAGE_TABLE = await handle_response( prompt, vykidailo, bartender, MESSAGE_TABLE, username, "CONVERSATION" ) - await message.reply(result) + + 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") @@ -637,7 +645,12 @@ async def play(ctx, zamawial=None, arg=None): query, vykidailo, bartender, message_table_muzyka, username, "MUSIC" ) logger.debug("Obecna historia czatu: %s", message_table_muzyka) - await ctx.send(result) + 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): @@ -676,6 +689,7 @@ async def check_music(): await play(MUZYKA["ctx"], MUZYKA["requester"]) await asyncio.sleep(2) + @tasks.loop(seconds=3) async def check_data_q(): """ @@ -691,40 +705,42 @@ async def check_data_q(): 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*' + 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}' + 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 += 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 += "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: + elif len(entries) >= 1 and len(entries) < 5: message += " znajduje się coś:\n" for item in entries: - message+=item + message += item await ctx.send(message) else: - message+= " znajduje się cholernie dużo:\n" + message += " znajduje się cholernie dużo:\n" for item in entries: - message+=item + 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}") + # 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(): """ @@ -1082,9 +1098,13 @@ async def get_file(ctx, source, link): 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) + 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) + 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": []} @@ -1351,6 +1371,7 @@ async def max_weight(lista): # *=========================================== Define Commands + @client.hybrid_command( name="skip_track", description="Przeskocz kawałek w radiu", @@ -1360,15 +1381,15 @@ async def skip_track(ctx): async with ctx.typing(): allowed = False for role in ctx.author.roles: - if role.name in ("Thane","Jarl"): + 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, + requests.get, + f"{RADIO_HARBOR_ADDRESS}{SKIP_TRACK}", + timeout=360, ) result = await coroutine logger.info("Done %s", result) @@ -1384,13 +1405,19 @@ async def zrestartuj_radio(ctx): async with ctx.typing(): allowed = False for role in ctx.author.roles: - if role.name in ("Thane","Jarl"): + 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) + 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="dej_co_ze_spotifaja", @@ -1633,6 +1660,7 @@ async def graj_muzyko(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.", @@ -1657,9 +1685,10 @@ async def radio_hardkor(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 - ) + 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") @@ -1667,7 +1696,6 @@ async def radio_hardkor(ctx): check_music.start() - @client.hybrid_command( name="cisza", description="Wyłącza muzykę i czyści plejliste.", @@ -1810,6 +1838,7 @@ async def zagraj_mi_kawalek(ctx): "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", @@ -1844,6 +1873,8 @@ async def dodaj_do_ulubionych(ctx): 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", @@ -1877,6 +1908,7 @@ async def request_radio(ctx): logger.info("Done %s", result) await ctx.send("Zrobione szefie!") + @client.hybrid_command( name="stworz_audycje", description="Dodaje do listy ulubionych w radiu", @@ -2316,11 +2348,18 @@ async def wyszukaj_linki_do_dokumentow(ctx): """ 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", "") + # 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} + 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}", @@ -2328,14 +2367,16 @@ async def wyszukaj_linki_do_dokumentow(ctx): 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ć" + "*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") + 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 = ( @@ -2349,8 +2390,11 @@ async def wyszukaj_linki_do_dokumentow(ctx): username = ctx.message.author.name query_object = QueryControl(username, query_uuid, query, logger, 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.") + 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", @@ -2394,13 +2438,23 @@ async def wyszukaj_linki_do_dokumentow_deep(ctx): result, MESSAGE_TABLE = await handle_response( prompt, vykidailo, bartender, MESSAGE_TABLE, username, "CONVERSATION" ) - await ctx.send(result) + 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} + # 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}", @@ -2408,14 +2462,16 @@ async def wyszukaj_linki_do_dokumentow_deep(ctx): 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" + "*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") + 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 = ( @@ -2429,9 +2485,10 @@ async def wyszukaj_linki_do_dokumentow_deep(ctx): username = ctx.message.author.name query_object = QueryControl(username, query_uuid, query, logger, 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*") - + 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*" + ) @client.hybrid_command( @@ -2468,7 +2525,6 @@ async def krecimy_pornola(ctx): ctx.reply("Jak ładnie szefa poprosisz.") - # *================================== Run if __name__ == "__main__": logger.info("Starting discord bot") @@ -2479,12 +2535,12 @@ if __name__ == "__main__": logger.info("Starting discord bot: Starting threads") WRK_CNT = 0 for worker in threads: - WRK_CNT+=1 + 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 + WRK_CNT = 0 for worker in threads: - WRK_CNT+=1 + WRK_CNT += 1 logger.info("Starting discord bot: Joining thread %s", WRK_CNT) worker.join() diff --git a/communication_subroutine.py b/communication_subroutine.py index d9a648b..ef4302b 100644 --- a/communication_subroutine.py +++ b/communication_subroutine.py @@ -13,16 +13,24 @@ IN_COMM_Q = Queue() awaiting_q = [] incoming_q = Queue() app = Flask(__name__) +prepped_tracks = { + "requests" : "", + "hits" : "", + "all": "", + "prio":"", + "jingles":"" +} + class QueryControl: """ This class `QueryControl` is used to manage queries with information about the author, UUID, content, logger, context, and replies. """ - def __init__(self, query_author, query_uuid, query_content, uplogger, ctx) -> None: + def __init__(self, query_author, query_uuid, query_content, ctx) -> None: self.author = query_author self.uuid = query_uuid self.content = query_content - self.logger = uplogger + self.logger = logging.getLogger("discord") self.stop = False self.ctx = ctx self.logger.info( @@ -30,6 +38,17 @@ class QueryControl: ) self.replies = [] +@app.route("/prepped_tracks", methods=["POST"]) +def log_radio_tracks(): + logger = logging.getLogger("discord") + + logger.info(request) + record = json.loads(request.data) + logger.info(record) + logger.info("DATA RECEIVED") + return jsonify("SUCCESS") + + @app.route("/conjurer", methods=["POST"]) def answer_external_command(): """ @@ -38,10 +57,11 @@ def answer_external_command(): :return: The function `answer_external_command()` is returning a JSON response with the message "SUCCESS". """ - app.logger.info(request) + logger = logging.getLogger("discord") + logger.info(request) record = json.loads(request.data) - app.logger.info(record) - app.logger.info("DATA RECEIVED") + logger.info(record) + logger.info("DATA RECEIVED") incoming_q.put(record) return jsonify("SUCCESS") @@ -56,25 +76,29 @@ def check_alive(): """ return jsonify("ALIVE") -def flask_debug(_logger): +def flask_debug(): """ The `flask_debug` function starts a Flask application in debug mode without using the reloader. Do not use for production for fucks sake. """ - _logger.info("Attempt debug") + logger = logging.getLogger("discord") + + logger.info("Attempt debug") # trunk-ignore(bandit/B201) app.run(debug=True, use_reloader=False, host=HOST_ADDRESS, port=PORT_ADDRESS) -def waitress_run(_logger): +def waitress_run(): """ The `waitress_run` function serves the `app` on host "0.0.0.0" and port 5000 using the Waitress WSGI server. """ - _logger.info("Attempt waitress") + logger = logging.getLogger("discord") + + logger.info("Attempt waitress") serve(app, host=HOST_ADDRESS, port=PORT_ADDRESS) -def scan_queue(_logger): +def scan_queue(): """ The function `scan_queue` reads data from a queue, logs it, and appends it to another queue. @@ -83,12 +107,13 @@ def scan_queue(_logger): and provide information for debugging purposes. In this code snippet, the `_logger` object is used to log the """ + logger = logging.getLogger("discord") while True: data = OUT_COMM_Q.get() - _logger.info(data) + logger.info(data) awaiting_q.append(data) -def scan_incoming(_logger): +def scan_incoming(): """ The `scan_incoming` function continuously checks for incoming data, processes it, and logs when data is found. @@ -98,10 +123,11 @@ def scan_incoming(_logger): debugging, monitoring, or tracking the flow of the program. In this case, the `_logger` is being used """ + logger = logging.getLogger("discord") while True: try: answer = incoming_q.get(block=False) - _logger.info("DATA FOUND") + logger.info("DATA FOUND") record_stored = False for record in awaiting_q: if record.uuid in answer.keys(): @@ -111,7 +137,7 @@ def scan_incoming(_logger): IN_COMM_Q.put(record) if not record_stored: for key in answer.keys(): - record = QueryControl("Orphaned", key, "Orphan", _logger, None) + record = QueryControl("Orphaned", key, "Orphan", None) record.stop = True record.entries = answer[record.uuid] IN_COMM_Q.put(record) @@ -128,12 +154,13 @@ def comm_subroutine(logger): the provided code snippet, the logger is used to log messages at the "info" level """ #logger.setLevel(logging.DEBUG) - logger.info("Started") + logger = logging.getLogger("discord") + logger.info("Started comms") threads = [] - #threads.append(threading.Thread(target=flask_debug, args=(logger,))) - threads.append(threading.Thread(target=waitress_run, args=(logger,))) - threads.append(threading.Thread(target=scan_queue,args=(logger,))) - threads.append(threading.Thread(target=scan_incoming,args=(logger,))) + #threads.append(threading.Thread(target=flask_debug)) + threads.append(threading.Thread(target=waitress_run)) + threads.append(threading.Thread(target=scan_queue)) + threads.append(threading.Thread(target=scan_incoming)) for worker in threads: diff --git a/conjurer_musician/conjurer_musician.py b/conjurer_musician/conjurer_musician.py index a993d57..8965df1 100644 --- a/conjurer_musician/conjurer_musician.py +++ b/conjurer_musician/conjurer_musician.py @@ -6,7 +6,9 @@ API endpoints. """ import json import logging +import os import re +import requests import threading import time from datetime import datetime @@ -17,6 +19,8 @@ from sys import platform from flask import Flask, jsonify, redirect, request, send_from_directory, render_template from waitress import serve +MAIN_BOT_ADDRESS = "http://192.168.1.191:5000" +MUSIC_TRACKER = "/prepped_tracks" HOST_ADDRESS = "192.168.1.15" PORT_ADDRESS = 5000 if platform in ("linux", "linux2"): @@ -27,6 +31,7 @@ if platform in ("linux", "linux2"): NETRC_FILE = "/home/mtuszowski/.netrc" LOGSTORE = "/home/mtuszowski/conjurer/logs/" ENCODING = "utf-8" + RADIOLOG_PATH = '/home/pi/Conjurer/radio_log.log' else: LOGFILE = "/home/pi/Conjurer/discord_mus_service.log" @@ -35,6 +40,7 @@ if platform in ("linux", "linux2"): ENCODING = "utf-8" MUSIC_FOLDER = "/home/pi/RetroPie/mp3/" PRIORITY_FOLDER = "/home/pi/RetroPie/mp3/Magiczne i chuj/" + RADIOLOG_PATH = '/home/pi/Conjurer/radio_log.log' music_file_list = [] @@ -45,7 +51,8 @@ def rescan(): The `rescan` function logs a message, scans for mp3 files in a specified folder, and adds them to a list of music files. """ - logging.info("Rescan triggered") + logger = logging.getLogger("conjurer_musician") + logger.info("Rescan triggered") for mp3_item in Path.glob(Path(MUSIC_FOLDER), "**/*.mp3"): temp_music_file = mp3_item.as_posix() @@ -82,13 +89,65 @@ def thread_rescan(): The `thread_rescan` function periodically triggers a rescan operation after a specified time interval. """ - logging.info("Starting filesystemupdater") + logger = logging.getLogger("conjurer_musician") + logger.info("Starting filesystemupdater") while True: time.sleep(60 * 60 * 24) - logging.info("Rescan triggered") + logger.info("Rescan triggered") rescan() +def scan_tracks(): + #Set the filename and open the file + logger = logging.getLogger("conjurer_musician") + + file = open(RADIOLOG_PATH,'r') + + #Find the size of the file and move to the end + st_results = os.stat(RADIOLOG_PATH) + st_size = st_results[6] + file.seek(st_size) + + while 1: + where = file.tell() + line = file.readline() + if not line: + time.sleep(1) + file.seek(where) + else: + if re.match(".*Prepared.*",line): + result = None + if re.match(".*jingles.*", line): + logger.info("jingles") + logger.info(line) # already has newline + result = ["jingles", line] + elif re.match(".*priority.*", line): + logger.info("priority") + logger.info(line) # already has newline + result = ["priority", line] + elif re.match(".*hit.*", line): + logger.info("priority") + logger.info(line) # already has newline + result = ["hit", line] + elif re.match(".*all_playlist.*", line): + logger.info("all") + logger.info(line) # already has newline + result = ["all", line] + elif re.match(".*request.*", line): + logger.info("requests") + logger.info(line) # already has newline + result = ["requests", line] + if result: + returned = requests.post( + f"{MAIN_BOT_ADDRESS}{MUSIC_TRACKER}", + json=result, + timeout=360) + logger.info("SENT") + logger.info(returned.status_code) + logger.info("SEND CONFIRMED") + time.sleep(0.1) + + app = Flask(__name__) @@ -485,6 +544,7 @@ if __name__ == "__main__": # threads.append(threading.Thread(target=flask_debug)) threads.append(threading.Thread(target=waitress_run)) threads.append(threading.Thread(target=thread_rescan)) + threads.append(threading.Thread(target=scan_tracks)) for worker in threads: worker.start()