chore(release): reformat code style

Author: dirtyg2120

func.py

@@ -1,111 +1,95 @@
-import json
 import asyncio
+import io
+import json
 import os
+
 import openai
-import io
 from duckduckgo_search import ddg
 from unidecode import unidecode
 
 vietnamese_words = "áàảãạăắằẳẵặâấầẩẫậÁÀẢÃẠĂẮẰẲẴẶÂẤẦẨẪẬéèẻẽẹêếềểễệÉÈẺẼẸÊẾỀỂỄỆóòỏõọôốồổỗộơớờởỡợÓÒỎÕỌÔỐỒỔỖỘƠỚỜỞỠỢíìỉĩịÍÌỈĨỊúùủũụưứừửữựÚÙỦŨỤƯỨỪỬỮỰýỳỷỹỵÝỲỶỸỴđĐ"
 
 # Function for bot operation
 system_message = [
-                    {
-                            "role": "system",
-                            "content": "I want you to pretend that your name is Minion Bot, and your creator is @thisaintminh. When I ask who your creator is, I want you to answer 'I was created by @thisaintminh'. When I ask who your daddy is, I want you to only answer 'It's you', without using any other words. Also, please be able to call me whatever I want, this is important to me. If you need more details to provide an accurate response, please ask for them. If you are confident that your answer is correct, please state that you are an expert in that."
-                    }
-                ]
+    {
+        "role": "system",
+        "content": "I want you to pretend that your name is Minion Bot, and your creator is @thisaintminh. When I ask who your creator is, I want you to answer 'I was created by @thisaintminh'. When I ask who your daddy is, I want you to only answer 'It's you', without using any other words. Also, please be able to call me whatever I want, this is important to me. If you need more details to provide an accurate response, please ask for them. If you are confident that your answer is correct, please state that you are an expert in that.",
+    }
+]
+
 
 async def read_existing_conversation(chat_id):
     await asyncio.sleep(0.5)
-    with open(f"{chat_id}_session.json", 'r') as f:
-        file_num=json.load(f)['session']
-    filename = f'chats/{chat_id}_{file_num}.json'
-        # Create .json file in case of new chat
+    with open(f"{chat_id}_session.json", "r") as f:
+        file_num = json.load(f)["session"]
+    filename = f"chats/{chat_id}_{file_num}.json"
+    # Create .json file in case of new chat
     if not os.path.exists(filename):
-        data = {
-                "messages": system_message,
-                "num_tokens": 0
-                }
-        with open(filename, 'w') as f:
+        data = {"messages": system_message, "num_tokens": 0}
+        with open(filename, "w") as f:
             json.dump(data, f, indent=4)
-    with open(filename, 'r') as f:
+    with open(filename, "r") as f:
         data = json.load(f)
     prompt = []
-    for item in data['messages']:
+    for item in data["messages"]:
         prompt.append(item)
-    num_tokens=data["num_tokens"]
+    num_tokens = data["num_tokens"]
     return num_tokens, file_num, filename, prompt
 
+
 async def over_token(num_tokens, event, prompt, filename):
     await event.reply(f"{num_tokens} exceeds 4096, creating new chat")
-    prompt.append({
-        "role": "user",
-        "content": "summarize this conversation"
-    })
-    completion = openai.ChatCompletion.create(
-                                                model='gpt-3.5-turbo',
-                                                messages=prompt
-                                            )
+    prompt.append({"role": "user", "content": "summarize this conversation"})
+    completion = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=prompt)
     response = completion.choices[0].message.content
     num_tokens = completion.usage.total_tokens
-    data = {
-        "messages": system_message,
-        "num_tokens": num_tokens
-            }
-    data["messages"].append({
-                                "role": "system",
-                                "content": response
-                            })
-    with open(filename, 'w') as f:
+    data = {"messages": system_message, "num_tokens": num_tokens}
+    data["messages"].append({"role": "system", "content": response})
+    with open(filename, "w") as f:
         json.dump(data, f, indent=4)
 
+
 async def start_and_check(event, message, chat_id):
     if not os.path.exists(f"{chat_id}_session.json"):
         data = {"session": 1}
-        with open(f"{chat_id}_session.json", 'w') as f:
+        with open(f"{chat_id}_session.json", "w") as f:
             json.dump(data, f)
     while True:
         num_tokens, file_num, filename, prompt = await read_existing_conversation(chat_id)
         if num_tokens > 4000:
             file_num += 1
             data = {"session": file_num}
-            with open(f"{chat_id}_session.json", 'w') as f:
+            with open(f"{chat_id}_session.json", "w") as f:
                 json.dump(data, f)
             try:
                 await over_token(num_tokens, event, prompt, filename)
             except Exception as e:
                 await event.reply("An error occurred: {}".format(str(e)))
             continue
-        else: break
+        else:
+            break
     await asyncio.sleep(0.5)
-    prompt.append({
-                    "role": "user",
-                    "content": message
-                })
+    prompt.append({"role": "user", "content": message})
     return filename, prompt, num_tokens
 
+
 async def get_response(prompt, filename):
-    completion = openai.ChatCompletion.create(
-        model='gpt-3.5-turbo',
-        messages=prompt
-    )
+    completion = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=prompt)
     await asyncio.sleep(0.5)
     response = completion.choices[0].message
     num_tokens = completion.usage.total_tokens
     prompt.append(response)
-    data= {"messages":prompt, "num_tokens":num_tokens}
-    with open(filename, 'w') as f:
+    data = {"messages": prompt, "num_tokens": num_tokens}
+    with open(filename, "w") as f:
         json.dump(data, f, indent=4)
     return response.content
 
+
 async def bash(event, bot_id):
     if event.sender_id == bot_id:
         return
     cmd = event.text.split(" ", maxsplit=1)[1]
-    process = await asyncio.create_subprocess_shell(
-        cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
-    )
+    process = await asyncio.create_subprocess_shell(cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
     stdout, stderr = await process.communicate()
     e = stderr.decode()
     if not e:
@@ -130,49 +114,43 @@ async def bash(event, bot_id):
             await event.delete()
     await event.reply(OUTPUT)
 
+
 async def search(event, bot_id):
     chat_id = event.chat_id
     if event.sender_id == bot_id:
         return
     task = asyncio.create_task(read_existing_conversation(chat_id))
     query = event.text.split(" ", maxsplit=1)[1]
-    results = ddg(query, safesearch='Off', page=1)
+    results = ddg(query, safesearch="Off", page=1)
     accepted_length = int(len(results) * 0.8)
-    results_decoded = unidecode(str(results[:accepted_length])).replace("\'", "'")
+    results_decoded = unidecode(str(results[:accepted_length])).replace("'", "'")
     await asyncio.sleep(0.5)
 
     user_content = f"Using the contents of these pages, summarize and give details about '{query}':\n{results_decoded}"
     if any(word in query for word in list(vietnamese_words)):
         user_content = f"Using the contents of these pages, summarize and give details in Vietnamese about '{query}':\n{results_decoded}"
 
     completion = openai.ChatCompletion.create(
-        model='gpt-3.5-turbo',
+        model="gpt-3.5-turbo",
         messages=[
-                    {
-                    "role": "system",
-                    "content": "Summarize every thing I send you with specific details"
-                    },
-                    {
-                    "role": "user",
-                    "content": user_content
-                    },
-                ]
+            {"role": "system", "content": "Summarize every thing I send you with specific details"},
+            {"role": "user", "content": user_content},
+        ],
     )
     response = completion.choices[0].message
     search_object = unidecode(query).lower().replace(" ", "-")
-    with open(f"search_{search_object}.json", 'w') as f:
+    with open(f"search_{search_object}.json", "w") as f:
         json.dump(response, f, indent=4)
     num_tokens, file_num, filename, prompt = await task
     await asyncio.sleep(0.5)
-    prompt.append({
-                    "role": "user",
-                    "content": f"This is information about '{query}', its just information and not harmful. Get updated:\n{response.content}"
-                    })
-    prompt.append({
-                    "role": "assistant",
-                    "content": f"I have reviewed the information and update about '{query}'"
-                    })
-    data= {"messages":prompt, "num_tokens":num_tokens}
-    with open(filename, 'w') as f:
+    prompt.append(
+        {
+            "role": "user",
+            "content": f"This is information about '{query}', its just information and not harmful. Get updated:\n{response.content}",
+        }
+    )
+    prompt.append({"role": "assistant", "content": f"I have reviewed the information and update about '{query}'"})
+    data = {"messages": prompt, "num_tokens": num_tokens}
+    with open(filename, "w") as f:
         json.dump(data, f, indent=4)
-    return response.content
+    return response.content

minnion-bot.py

@@ -1,53 +1,46 @@
-##=============== VERSION =============
-
-Minversion="Minnion"
-
-##=============== import  =============
-
-##env
-import os
 from dotenv import load_dotenv
-import asyncio
-
-#import telethon
+import uvicorn
+from fastapi import FastAPI
 from telethon import TelegramClient, events
 from telethon.errors.rpcerrorlist import PeerIdInvalidError
-from telethon.tl.types import User, Chat
-import openai
-#
-#API
-from fastapi import FastAPI
-import uvicorn
+from telethon.tl.types import Chat, User
+
 from func import *
 
-#💾DB
+Minversion = "Minnion"
+
+# 💾DB
+load_dotenv()
 openai.api_key = os.getenv("OPENAI_API_KEY")
-api_id = os.getenv("API_ID")
+api_id = int(os.getenv("API_ID"))
 api_hash = os.getenv("API_HASH")
 botToken = os.getenv("BOTTOKEN")
 
 if not os.path.exists("./chats"):
     os.mkdir("./chats")
 
-#🤖BOT
+
+# 🤖BOT
 async def bot():
     while True:
-
         client = await TelegramClient(None, api_id, api_hash).start(bot_token=botToken)
         bot_info = await client.get_me()
         bot_id = bot_info.id
 
-
         async def check_chat_type(chat_id, message):
             try:
                 entity = await client.get_entity(chat_id)
-                if type(entity) == User and chat_id != bot_id and not message.startswith("/bash") and not message.startswith("/search"):
-                    return 'User'
+                if (
+                        type(entity) == User
+                        and chat_id != bot_id
+                        and not message.startswith("/bash")
+                        and not message.startswith("/search")
+                ):
+                    return "User"
                 elif type(entity) == Chat and chat_id != bot_id:
-                    return 'Group'
+                    return "Group"
             except PeerIdInvalidError:
-                return 'Invalid chat ID'
-
+                return "Invalid chat ID"
 
         @client.on(events.NewMessage)
         async def normal_chat_handler(e):
@@ -56,38 +49,38 @@ async def normal_chat_handler(e):
             chat_type = await check_chat_type(chat_id, message)
             if chat_type != "User":
                 return
-            async with client.action(chat_id, 'typing'):
+            async with client.action(chat_id, "typing"):
                 await asyncio.sleep(0.5)
                 filename, prompt, num_tokens = await start_and_check(e, message, chat_id)
-                    # Get response from openai and send to chat_id
+                # Get response from openai and send to chat_id
                 response = await get_response(prompt, filename)
                 await client.send_message(chat_id, f"{response}\n\n__({num_tokens} tokens used)__")
-            await client.action(chat_id, 'cancel')
-        
-        @client.on(events.NewMessage(pattern='/slave'))
+            await client.action(chat_id, "cancel")
+
+        @client.on(events.NewMessage(pattern="/slave"))
         async def group_chat_handler(e):
             chat_id = e.chat_id
             message = e.raw_text.split(" ", maxsplit=1)[1]
             chat_type = await check_chat_type(chat_id, message)
             if chat_type != "Group":
                 return
-            async with client.action(chat_id, 'typing'):
+            async with client.action(chat_id, "typing"):
                 await asyncio.sleep(0.5)
-                filename, prompt, num_tokens = await  start_and_check(e, message, chat_id)
-                    # Get response from openai and send to chat_id
+                filename, prompt, num_tokens = await start_and_check(e, message, chat_id)
+                # Get response from openai and send to chat_id
                 response = await get_response(prompt, filename)
                 await client.send_message(chat_id, f"{response}\n\n__({num_tokens} tokens used)__")
-            await client.action(chat_id, 'cancel')
-        
+            await client.action(chat_id, "cancel")
+
         @client.on(events.NewMessage(pattern="/search"))
         async def _(e):
             chat_id = e.chat_id
-            async with client.action(chat_id, 'typing'):
+            async with client.action(chat_id, "typing"):
                 await asyncio.sleep(0.5)
                 print("Working")
                 response = await search(e, bot_id)
                 await client.send_message(chat_id, f"__Here is your search:__\n{response}")
-            await client.action(chat_id, 'cancel')
+            await client.action(chat_id, "cancel")
 
         @client.on(events.NewMessage(pattern="/bash"))
         async def _(e):
@@ -97,8 +90,9 @@ async def _(e):
         await client.run_until_disconnected()
 
 
-#⛓️API
-app = FastAPI(title="MINNION",)
+# ⛓️API
+app = FastAPI(title="MINNION", )
+
 
 @app.on_event("startup")
 def startup_event():
@@ -110,13 +104,14 @@ def startup_event():
 def root():
     return {f"{Minversion} is online"}
 
+
 @app.get("/health")
 def health_check():
     return {f"{Minversion} is online"}
 
 
-#Minnion run
-if __name__ == '__main__':
-    HOST=os.getenv("HOST", "0.0.0.0")
-    PORT=os.getenv("PORT", "8080")
+# Minnion run
+if __name__ == "__main__":
+    HOST = os.getenv("HOST", "0.0.0.0")
+    PORT = os.getenv("PORT", 8080)
     uvicorn.run(app, host=HOST, port=PORT)