all ruff checking and modify Converter class

functions/admin/get_log.py

@@ -1,5 +1,5 @@
 import os
-from typing import List, Dict, Any
+from typing import Any, Dict, List
 
 
 def get_log(log_id: int) -> List[Dict[str, Any]]:

functions/admin/is_logged_in.py

@@ -1,12 +1,14 @@
 import jwt
 from fastapi import Cookie, Depends
-from functions.admin.models import token, database
+
+from functions.admin.models import database, token
 
 
 def is_logged_in(access_token: str = Cookie(None), db=Depends(database.get_db)):
     if not access_token:
         return False
-    response = db.query(token.Token).filter(token.Token.access_token == access_token).first()
+    response = db.query(token.Token).filter(
+        token.Token.access_token == access_token).first()
     if not response or not response.is_active:
         return False
     try:

functions/admin/models/token.py

@@ -1,7 +1,9 @@
 from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
 from sqlalchemy.orm import relationship
+
 from functions.admin.models.database import Base
 
+
 class Token(Base):
     __tablename__ = "tokens"
 

functions/admin/models/user.py

@@ -2,8 +2,10 @@ import hashlib
 
 from sqlalchemy import Boolean, Column, Integer, String
 from sqlalchemy.orm import relationship
+
 from functions.admin.models.database import Base
 
+
 class User(Base):
     __tablename__ = "users"
 

functions/admin/templates/log.py

@@ -1,10 +1,15 @@
-from fastapi import Request, Depends, responses, HTTPException
+from fastapi import Depends, HTTPException, Request, responses
+
 from functions.admin import get_log, is_logged_in
 
-async def log(templates, request: Request, log_id: int, logged_in: bool = Depends(is_logged_in.is_logged_in)):
+
+async def log(templates, request: Request, log_id: int,
+              logged_in: bool = Depends(is_logged_in.is_logged_in)):
     if logged_in:
         if not get_log.get_log(log_id):
             raise HTTPException(status_code=400)
-        return templates.TemplateResponse("log.html", {"request": request, "log": get_log.get_log(log_id)})
+        return templates.TemplateResponse("log.html", {"request": request,
+                                                       "log": get_log.get_log(log_id)})
     else:
-        return responses.RedirectResponse(url=f"/refresh?source=/logs/{log_id}", status_code=303)
+        return responses.RedirectResponse(url=f"/refresh?source=/logs/{log_id}",
+                                          status_code=303)

functions/admin/templates/logins.py

@@ -1,25 +1,31 @@
-from fastapi import Form, Depends, responses, HTTPException
-from functions.admin.models import database, user, token
-import jwt
 from datetime import datetime, timedelta
 
+import jwt
+from fastapi import Depends, Form, HTTPException, responses
 
-async def logins(username: str = Form(...), password: str = Form(...), db=Depends(database.get_db)):
+from functions.admin.models import database, token, user
+
+
+async def logins(username: str = Form(...), password: str = Form(...),
+                 db=Depends(database.get_db)):
     # username = "Dmitrium12"
     response = db.query(user.User).filter(user.User.username == username).first()
     if not response or not response.check_password(password):
-        raise HTTPException(status_code=400, detail="Неправильное имя пользователя или пароль")
+        raise HTTPException(status_code=400,
+                            detail="Неправильное имя пользователя или пароль")
     access_token_expires = datetime.utcnow() + timedelta(minutes=15)
     access_token_payload = {"sub": response.username, "exp": access_token_expires}
     access_token = jwt.encode(access_token_payload, "secret", algorithm="HS256")
     refresh_token_expires = datetime.utcnow() + timedelta(days=7)
     refresh_token_payload = {"sub": response.username, "exp": refresh_token_expires}
     refresh_token = jwt.encode(refresh_token_payload, "secret", algorithm="HS256")
-    db_token = token.Token(access_token=access_token, refresh_token=refresh_token, user=response)
+    db_token = token.Token(access_token=access_token, refresh_token=refresh_token,
+                           user=response)
     db.add(db_token)
     db.commit()
     response = responses.RedirectResponse(url="/logs", status_code=303)
-    response.set_cookie(key="access_token", value=access_token, expires=int(access_token_expires.timestamp()))
+    response.set_cookie(key="access_token", value=access_token,
+                        expires=int(access_token_expires.timestamp()))
     response.set_cookie(key="refresh_token", value=refresh_token,
                         expires=int(refresh_token_expires.timestamp()))
     return response

functions/admin/templates/logs.py

@@ -1,8 +1,12 @@
-from fastapi import Request, Depends, responses
+from fastapi import Depends, Request, responses
+
 from functions.admin import get_logs, is_logged_in
 
-async def logs(templates, request: Request, logged_in: bool = Depends(is_logged_in.is_logged_in)):
+
+async def logs(templates, request: Request,
+               logged_in: bool = Depends(is_logged_in.is_logged_in)):
     if logged_in:
-        return templates.TemplateResponse("logs.html", {"request": request, "logs": get_logs.get_logs()})
+        return templates.TemplateResponse("logs.html",
+                                          {"request": request, "logs": get_logs.get_logs()})
     else:
         return responses.RedirectResponse(url="/refresh?source=/logs", status_code=303)

functions/admin/templates/refresh.py

@@ -1,15 +1,20 @@
-from fastapi import Request, Depends, Cookie, responses
-from functions.admin.models import database, user, token
-import jwt
 from datetime import datetime, timedelta
 
-async def refresh_access_token(req: Request, refresh_token: str = Cookie(None), db=Depends(database.get_db)):
+import jwt
+from fastapi import Cookie, Depends, Request, responses
+
+from functions.admin.models import database, token, user
+
+
+async def refresh_access_token(req: Request, refresh_token: str = Cookie(None),
+                               db=Depends(database.get_db)):
     request_args = dict(req.query_params)
     try:
         refresh_token_payload = jwt.decode(refresh_token, "secret", algorithms=["HS256"])
     except jwt.exceptions.DecodeError:
         return responses.RedirectResponse(url="/login", status_code=303)
-    response = db.query(user.User).filter(user.User.username == refresh_token_payload["sub"]).first()
+    response = db.query(user.User).filter(
+        user.User.username == refresh_token_payload["sub"]).first()
     if not response:
         return responses.RedirectResponse(url="/login", status_code=303)
     access_token_expires = datetime.utcnow() + timedelta(minutes=15)

functions/convert.py

@@ -5,12 +5,24 @@ class Converter:
     """
     Этот класс выполняет главную функцию, конвертирует голос в текст
     """
-    def __init__(self, path_to_file: str, message, model, language: str = "ru-RU"):
+
-        self.language = language
+    def __init__(self, path_to_file: str):
         self.path_to_file = path_to_file
-        self.service = None
+        self.ip_list = ["192.168.0.108", "192.168.0.109", "localhost"]  # Список IP-адресов
-        self.message = message
+
-        self.model = model
+    @staticmethod
+    def ping(ip):
+        """
+        Пингует указанный IP-адрес.
+
+        :param ip: str - IP-адрес для пинга
+        :return: bool - True если доступен, False если нет
+        """
+        try:
+            r = requests.get(f"http://{ip}:5000/ping", timeout=5)
+            return r.status_code == 200
+        except requests.RequestException:
+            return False
 
     def audio_to_text(self) -> dict:
         """
@@ -18,33 +30,24 @@ class Converter:
 
         :return: str - текст + служебная информация
         """
-        try:
+        for ip in self.ip_list:
-            r = requests.get("http://192.168.0.108:5000/ping")
+            if self.ping(ip):
-            if r.status_code == 200:
+                try:
-                print(self.path_to_file)
+                    response = requests.post(
-                response = requests.post(
+                        f"http://{ip}:5000/decrypt_audio",
-                    "http://192.168.0.108:5000/decrypt_audio",
+                        files={"file": open(self.path_to_file, "rb").read()},
-                    files={"file": open(self.path_to_file, "rb").read()},
+                        timeout=6000
-                    timeout=6000
+                    )
-                )
+                    if response.status_code == 200:
-                if response.status_code == 200:
+                        return response.json()
-                    return response.json()
+                    else:
-                else:
+                        return {
-                    return {
+                            "timestamp": " ",
-                        "timestamp": " ",
+                            "final_text": "Не удалось получить текст."
-                        "final_text": "Не удалось получить текст."
+                        }
-                    }
+                except requests.RequestException:
-            else:
+                    continue
-                result = self.model.transcribe(self.path_to_file)
+        return {
-                return {
+            "timestamp": " ",
-                        "timestamp": "Тут такое не работает, "
+            "final_text": "Не удалось получить текст или все сервера недоступны."
-                                     "жди пока главный сервер поднимется",
+        }
-                        "final_text": result["text"]
-                }
-        except requests.ConnectionError:
-            result = self.model.transcribe(self.path_to_file)
-            return {
-                "timestamp": "Тут такое не работает, "
-                             "жди пока главный сервер поднимется",
-                "final_text": result["text"]
-            }

functions/file_data.py

@@ -3,7 +3,7 @@ import json
 
 def load_data():
     try:
-        with open('users.json', 'r') as f:
+        with open('users.json') as f:
             return json.load(f)
     except FileNotFoundError:
         return {'users': [], 'chats': []}

functions/get_audio_messages_func.py

@@ -1,10 +1,12 @@
 import os
 from io import BytesIO
+
+from aiogram import exceptions, types
+
 from functions.convert import Converter
-from aiogram import types, exceptions
 
 
-async def get_audio_messages_func(message: types.Message, logger, bot, model) -> None:
+async def get_audio_messages_func(message: types.Message, logger, bot) -> None:
     """
     Функция выкачивает файл, потом конвертирует его в текст, потом логирует
 
@@ -39,10 +41,11 @@ async def get_audio_messages_func(message: types.Message, logger, bot, model) ->
             file = await bot.get_file(file_id)  # ссылка для скачивая файла
             file_dow = await bot.download_file(file.file_path)  # скачанный файл
             new_file.write(file_dow.getvalue())  # записываю
-            converter = Converter(file_name, message, model)  # запуск конвертора
+            converter = Converter(file_name)  # запуск конвертора
             message_text = converter.audio_to_text()  # получаю текст из конвертора
-            logger.info(f"Чат {name} (ID: {message.chat.id}) обработал файл {file_name}, "
+            logger.info(
-                        f"сервисом {converter.service}")  # записываю всё в logger
+                f"Чат {name} (ID: {message.chat.id}) обработал файл {file_name}, "
+            )  # записываю всё в logger
             file = BytesIO(message_text['timestamp'].encode('utf-8'))
             file.name = 'timestamp.txt'
             await bot.send_document(

functions/loging.py

@@ -1,10 +1,11 @@
 import os
 import shutil
+
 from aiogram import types
-import sqlite3
 
 
-def loging(message: types.Message, service: str, file_path: str, text: str, f: float) -> None:
+def loging(message: types.Message, service: str, file_path: str, text: str,
+           f: float) -> None:
     """
     Функция логирует каждое сообщение
 
@@ -22,9 +23,11 @@ def loging(message: types.Message, service: str, file_path: str, text: str, f: f
         os.makedirs(f"static/logs/{message.chat.id}/{file_name[0]}")  # создание папки
     except FileExistsError:
         pass
-    shutil.copy(file_path, f"static/logs/{message.chat.id}/{file_name[0]}/audio.{file_name[1]}")
+    shutil.copy(file_path,
+                f"static/logs/{message.chat.id}/{file_name[0]}/audio.{file_name[1]}")
     # копирование файла
-    with open(f'static/logs/{message.chat.id}/{file_name[0]}/{service}-text.txt', 'w+') as the_file:
+    with open(f'static/logs/{message.chat.id}/{file_name[0]}/{service}-text.txt',
+              'w+') as the_file:
         # открываю файл в запись
         the_file.write(text)  # записываю
     user_id = message.from_user.id

functions/openai_answer.py

@@ -1,72 +0,0 @@
-import json
-from aiogram import types
-import sqlite3
-import openai
-
-
-async def get_response_to_openai(message: types.Message, bot):
-    if message.from_user.id in json.load(open("not_work_user.json"))["chat_gpt"]:
-        await bot.send_message(message.chat.id, "ПИШЁВ ТИ НАХУЙ")
-        return
-    conn = sqlite3.connect('db.sql')
-    cur = conn.cursor()
-    openai.api_key = "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"
-    try:
-        points = cur.execute("SELECT * FROM 'f'".replace("f", str(message.from_user.id))).fetchall()
-        message_send = []
-        for i in points:
-            message_send.append({"role": i[1], "content": i[2]})
-        message_send.append({"role": "user", "content": ' '.join(message.text.split()[1:])})
-    except sqlite3.OperationalError:
-        message_send = [{"role": "user", "content": ' '.join(message.text.split()[1:])}]
-    try:
-        await bot.send_message(message.chat.id, "Внимание!!!!\nБот начинает разделение, через 2 дней этот бот перестанет принимать запросы для ChatGPT, вам стоит начать переходит на этого бота: @db_ChatGPT_bot. Бот уже работает.")
-        response = openai.ChatCompletion.create(
-            model="gpt-3.5-turbo",
-            messages=message_send,
-            temperature=0.5,
-            max_tokens=1000,
-            top_p=1.0,
-            frequency_penalty=0.5,
-            presence_penalty=0.0
-        )
-        try:
-            await bot.send_message(message.chat.id, f"ChatGPT\n{response['choices'][0]['message']['content']}",
-                                   parse_mode="Markdown", reply_to_message_id=message.message_id)
-        except Exception as e:
-            await bot.send_message(message.chat.id, f"ChatGPT\n{response['choices'][0]['message']['content']}",
-                                   parse_mode=None, reply_to_message_id=message.message_id)
-    except Exception as e:
-        print(e)
-        conn = sqlite3.connect('db.sql')
-        cur = conn.cursor()
-        cur.execute(f"DELETE FROM '{str(message.from_user.id)}'")
-        conn.commit()
-        conn.close()
-        await bot.send_message(message.chat.id, "У вас превышено количество сообщений в памяти, я всё очистил"
-                                                " попробуйте задать вопрос заново))")
-    try:
-        cur.execute("INSERT INTO 'f' (role, content) VALUES (?, ?)".replace("f", str(message.from_user.id)),
-                    ("user", ' '.join(message.text.split()[1:])))
-        cur.execute("INSERT INTO 'f' (role, content) VALUES (?, ?)".replace("f", str(message.from_user.id)),
-                    ("assistant", response['choices'][0]['message']['content']))
-        conn.commit()
-        conn.close()
-    except sqlite3.OperationalError:
-        cur.execute(f"CREATE TABLE IF NOT EXISTS '{message.from_user.id}' (id INTEGER PRIMARY KEY AUTOINCREMENT"
-                    f" UNIQUE NOT NULL, role STRING NOT NULL,"
-                    f" content STRING NOT NULL)")
-        cur.execute("INSERT INTO 'f' (role, content) VALUES (?, ?)".replace("f", str(message.from_user.id)),
-                    ("user", ' '.join(message.text.split()[1:])))
-        cur.execute("INSERT INTO 'f' (role, content) VALUES (?, ?)".replace("f", str(message.from_user.id)),
-                    ("assistant", response['choices'][0]['message']['content']))
-        conn.commit()
-        conn.close()
-
-
-async def clear_db(message: types.Message):
-    conn = sqlite3.connect('db.sql')
-    cur = conn.cursor()
-    cur.execute(f"DELETE FROM '{str(message.from_user.id)}'")
-    conn.commit()
-    conn.close()

functions/start_stat.py

@@ -1,4 +1,5 @@
 from aiogram import types
+
 from functions.file_data import load_data
 
 
@@ -24,4 +25,3 @@ async def start_stat(message: types.Message):
     ChatGPT ботом воспользовались {data["static"]["chatGPT"]} раз
     """
     await message.reply(send_message)
-

functions/yandex.py

@@ -1,5 +1,6 @@
 import sqlite3
 import time
+
 import requests
 from aiogram import types
 from selenium import webdriver
@@ -11,41 +12,51 @@ from webdriver_manager.chrome import ChromeDriverManager
 async def create_yandex(message: types.Message):
     conn = sqlite3.connect('db.sql')
     cur = conn.cursor()
-    response = cur.execute("SELECT * FROM yandex WHERE user_id=?", (message.from_user.id, )).fetchall()
+    response = cur.execute("SELECT * FROM yandex WHERE user_id=?",
+                           (message.from_user.id,)).fetchall()
     conn.close()
     if response:
         await message.reply("Ваш аккаунт уже добавлен")
     options = webdriver.ChromeOptions()
     options.add_argument("--headless")
-    driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
+    driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()),
+                              options=options)
     driver.get('https://passport.yandex.ru/auth/')
     time.sleep(1)
     driver.find_element(By.CLASS_NAME, "Button2").click()
     time.sleep(1)
-    driver.find_element(By.XPATH, '//*[@id="passp-field-login"]').send_keys(message.text.split()[1])
+    driver.find_element(By.XPATH, '//*[@id="passp-field-login"]').send_keys(
+        message.text.split()[1])
     driver.find_element(By.XPATH, '//*[@id="passp:sign-in"]').click()
     time.sleep(1)
-    driver.find_element(By.XPATH, '//*[@id="passp-field-passwd"]').send_keys(message.text.split()[2])
+    driver.find_element(By.XPATH, '//*[@id="passp-field-passwd"]').send_keys(
+        message.text.split()[2])
     driver.find_element(By.XPATH, '//*[@id="passp:sign-in"]').click()
     time.sleep(5)
     try:
         cookies = [i["value"] for i in driver.get_cookies() if i["name"] == "Session_id"][0]
         conn = sqlite3.connect('db.sql')
         cur = conn.cursor()
-        cur.execute("INSERT INTO yandex (user_id, Session_id) VALUES (?, ?)", (message.from_user.id, str(cookies)))
+        cur.execute("INSERT INTO yandex (user_id, Session_id) VALUES (?, ?)",
+                    (message.from_user.id, str(cookies)))
         conn.commit()
         conn.close()
         await message.reply("Ваш аккаунт добавлен")
     except IndexError:
         await message.reply("Ошибка пароля или логина")
 
+
 async def statistic(message: types.Message):
     conn = sqlite3.connect('db.sql')
     cur = conn.cursor()
-    response = cur.execute("SELECT * FROM yandex WHERE user_id=?", (message.from_user.id,)).fetchall()
+    response = cur.execute("SELECT * FROM yandex WHERE user_id=?",
+                           (message.from_user.id,)).fetchall()
     conn.close()
     if not response:
-        await message.reply("Сначала используйте /create_yandex с логином и паролем для добавление аккаунта")
+        await message.reply(
+            "Сначала используйте /create_yandex с логином и паролем для добавление аккаунта")
     cookies = {"Session_id": response[0][2]}
-    response = requests.get("https://lyceum.yandex.ru/api/notifications?isRead=false&limit=20", cookies=cookies)
+    response = requests.get(
-    await message.reply(f'У вас {response.json()["unreadCount"]} уведомлений. Прочитайте хоть')
+        "https://lyceum.yandex.ru/api/notifications?isRead=false&limit=20", cookies=cookies)
+    await message.reply(
+        f'У вас {response.json()["unreadCount"]} уведомлений. Прочитайте хоть')

modules/Bot.py

@@ -1,16 +1,16 @@
+import asyncio
+import json
+
+from aiogram import Bot, Dispatcher, types
 from aiogram.utils import executor
 from loguru import logger
-from aiogram import Bot, Dispatcher, types
+
-from functions import get_audio_messages_func, file_data, start_stat
+from functions import file_data, get_audio_messages_func, start_stat
-import asyncio
-import whisper
-import json
 
 bot = Bot(token="5941118321:AAG0g0keLrlnuH_9U9X6ehpFFAdOX38qeXI")  # создаю объект бота
 dp = Dispatcher(bot)  # создаю объект слушателя
 logger.remove()  # удаляю стандартный логер
 logger.add("static/logs/logging_log.log", level="INFO")  # создаю логер
-model = whisper.load_model("small")
 lock = asyncio.Lock()
 
 
@@ -43,12 +43,15 @@ async def start(message: types.Message):
         name = message.chat.title
     logger.info(f"Группа {name} (ID: {message.chat.id}) запустил бота")  # записываю в логи
     await start_stat.start_stat(message)
-    await bot.send_message(message.chat.id,
+    await bot.send_message(
-                           'Привет! Отправляй голосовое, я расшифрую!')  # отправляю ответное сообщение
+        message.chat.id,
+        'Привет! Отправляй голосовое, я расшифрую!'
+    )  # отправляю ответное сообщение
 
 
-@dp.message_handler(content_types=['voice', 'video_note', 'video', 'audio',
+@dp.message_handler(
-                                   'document'])  # обрабатываю голосовые сообщения, кружки, видео
+    content_types=['voice', 'video_note', 'video', 'audio', 'document']
+)  # обрабатываю голосовые сообщения, кружки, видео
 async def get_audio_messages(message: types.Message):
     file_data.save_data('audio_resive')
     if message.chat.type == 'group' or message.chat.type == "supergroup":
@@ -57,11 +60,16 @@ async def get_audio_messages(message: types.Message):
     else:
         file_data.save_data('audio', message.from_user.id)
     async with lock:
-        await get_audio_messages_func.get_audio_messages_func(message, logger, bot,
+        await get_audio_messages_func.get_audio_messages_func(
-                                                              model)  # вызываю функцию
+            message,
+            logger,
+            bot
+        )  # вызываю функцию
 
 
 def start_work_bot():  # функция запуска бота
     logger.info("Бот запустился")  # записываю логи
-    executor.start_polling(dp,
+    executor.start_polling(
-                           skip_updates=False)  # запускаю pooling без пропуска пропущенных сообщений
+        dp,
+        skip_updates=False
+    )  # запускаю pooling без пропуска пропущенных сообщений

modules/Site.py

@@ -1,8 +1,19 @@
-from fastapi import FastAPI, Request, Form, Depends, Cookie, responses, templating, staticfiles
+import uvicorn
+from fastapi import (
+    Cookie,
+    Depends,
+    FastAPI,
+    Form,
+    Request,
+    responses,
+    staticfiles,
+    templating,
+)
+
 from functions.admin import is_logged_in
 from functions.admin.models import database
-from functions.admin.templates import logins, refresh, logs, log
+from functions.admin.templates import log, logins, logs, refresh
-import uvicorn
+
 
 def Site():
     app = FastAPI()
@@ -18,19 +29,23 @@ def Site():
         return templates.TemplateResponse("login.html", {"request": request})
 
     @app.post("/logins")
-    async def logins_response(username: str = Form(...), password: str = Form(...), db=Depends(database.get_db)):
+    async def logins_response(username: str = Form(...), password: str = Form(...),
+                              db=Depends(database.get_db)):
         return await logins.logins(username, password, db)
 
     @app.get("/refresh")
-    async def refresh_access_token(req: Request, refresh_token: str = Cookie(None), db=Depends(database.get_db)):
+    async def refresh_access_token(req: Request, refresh_token: str = Cookie(None),
+                                   db=Depends(database.get_db)):
         return await refresh.refresh_access_token(req, refresh_token, db)
 
     @app.get("/logs", response_class=responses.HTMLResponse)
-    async def logs_response(request: Request, logged_in: bool = Depends(is_logged_in.is_logged_in)):
+    async def logs_response(request: Request,
+                            logged_in: bool = Depends(is_logged_in.is_logged_in)):
         return await logs.logs(templates, request, logged_in)
 
     @app.get("/logs/{log_id}", response_class=responses.HTMLResponse)
-    async def log_response(request: Request, log_id: int, logged_in: bool = Depends(is_logged_in.is_logged_in)):
+    async def log_response(request: Request, log_id: int,
+                           logged_in: bool = Depends(is_logged_in.is_logged_in)):
         return await log.log(templates, request, log_id, logged_in)
 
     uvicorn.run(app, host="0.0.0.0")

pyproject.toml

@@ -4,6 +4,7 @@ version = "0.9.0"
 description = ""
 authors = ["dmitrium12 <belicdima8@gmail.com>"]
 readme = "README.md"
+package-mode = false
 
 [tool.poetry.dependencies]
 python = "^3.11"
@@ -18,6 +19,7 @@ jwt = "^1.3.1"
 sqlalchemy = "^2.0.23"
 uvicorn = "^0.24.0.post1"
 python-multipart = "^0.0.6"
+ruff = "^0.4.10"
 
 [build-system]
 requires = ["poetry-core"]