Polls Update

FileStream/bot/plugins/FileHandlers/callback.py

@@ -106,51 +106,6 @@ async def cb_data(bot: Client, update: CallbackQuery):
         disable_web_page_preview=True,
         reply_markup=reply_markup,
     )
-  elif usr_cmd[0] == "initilize":
-    try:
-      user_id = str(usr_cmd[1])
-      message_id = int(usr_cmd[2])
-      response_id = int(usr_cmd[3])
-      message = await FileStream.get_messages(user_id, message_id)
-      #response = await FileStream.get_messages(user_id, response_id)
-      instruction = {
-          "privacy_type": "PUBLIC",
-          "user_id": user_id,
-          "user_type": "TELEGRAM"
-      }
-      file_caption = getattr(message, "caption",  f"{get_name(message)}" ) or "None/Unknown"
-      file_name = get_name(message)
-      print("Detail",file_caption,file_name)
-      await update.message.edit_text(
-          text=file_caption,
-          parse_mode=ParseMode.HTML,
-          disable_web_page_preview=True,
-          reply_markup=InlineKeyboardMarkup([
-            [InlineKeyboardButton("Movie", callback_data=f"pubup_{user_id}_{message_id}_Movie")],
-            [InlineKeyboardButton("WebSeries", callback_data=f"pubup_{user_id}_{message_id}_WebSeries")],
-            [InlineKeyboardButton("Anime", callback_data=f"pubup_{user_id}_{message_id}_Anime")],
-            [InlineKeyboardButton("Documentary", callback_data=f"pubup_{user_id}_{message_id}_Documentary")],
-            [InlineKeyboardButton("Regular", callback_data=f"pubup_{user_id}_{message_id}_Regular")],
-        ]),
-      )  
-      """#await FileStream.delete_messages(chat_id=user_id,message_ids=response_id)
-      await FileStream.send_poll(
-        type= enums.PollType.REGULAR,
-        reply_to_message_id=message_id,
-        explanation=f"{file_caption}",
-        question=f"{message_id}_{user_id}_{response_id}_File Name :\n{file_caption}",
-        options=["Movie", "WebSeries", "Anime", "Documentary", "Regular"],
-        allows_multiple_answers=True,
-        chat_id=user_id
-        )
-    """
-    except Exception as e:
-      print(f"An error occurred: {str(e)}")
-      await FileStream.send_message(
-          chat_id=Telegram.ULOG_GROUP,
-          text=f"An error occurred: {str(e)}"
-      )
-
   elif usr_cmd[0] == "pubup":
     try:
       user_id = str(usr_cmd[1])
@@ -167,94 +122,7 @@ async def cb_data(bot: Client, update: CallbackQuery):
       }
       file_caption = getattr(message, "caption",  f"{get_name(message)}" ) or "None/Unknown"
       file_name = get_name(message)
-      print("Detail",file_caption,"\nFile:",file_name)
-      """
-      await FileStream.delete_messages(
-        chat_id=user_id,
-        message_ids=message_id
-      )
-      await FileStream.send_poll(
-        type= enums.PollType.REGULAR,
-        reply_to_message_id=message_id,
-        question="Is this a poll question?",
-        options=["Movie", "WebSeries", "Anime", "Documentary", "Regular"],
-        allows_multiple_answers=True,
-        chat_id=user_id
-        )
-      
-      functions.messages.EditMessage(
-                peer=user_id,
-                id=message_id,
-                media=InputMediaPoll(
-                    poll=Poll(
-                        id=FileStream.rnd_id(),
-                        question="Is this a poll question?",
-                        answers=["Movie", "WebSeries", "Anime", "Documentary", "Regular"],
-                        multiple_choice=True,
-                        quiz=False,
-                    )
-                ),
-          )
-      
-      print("Poll function and all initializers executed successfully.")
-      print("dir(Poll):", dir(Poll))
-      print("Poll.__init__:", Poll.__init__)
-      print("Poll.__init__ inputs:", Poll.__init__.__code__.co_varnames)
-      print("InputMediaPoll.__init__ inputs:", InputMediaPoll.__init__.__code__.co_varnames)
-      update=await FileStream.edit_message_media(
-                chat_id=user_id,
-                message_id=response_id,
-                media=InputMediaPoll(
-                    caption="Is this a poll question?",
-                    poll=Poll(
-                      id=FileStream.rnd_id(),
-                      question="Is this a poll question?",
-                      answers=[
-                        PollAnswer(text="Movie", option=bytes([1])),
-                        PollAnswer(text="WebSeries", option=bytes([2])),
-                        PollAnswer(text="Anime", option=bytes([3])),
-                        PollAnswer(text="Documentary", option=bytes([4]))
-                      ],
-                      closed=False,
-                      public_voters=True,
-                      multiple_choice=True,
-                      quiz=False,
-                      close_period=None,
-                      close_date=None              
-                ),
-          )
-      )
-      print("Update:",update)
-      
-      PollAnswer(
-      id=FileStream.rnd_id(),
-      question="Is this a poll question?",
-      answers=["Movie","WebSeries"),
-        PollAnswer(text="Anime"),
-        PollAnswer(text="Documentary"),
-        PollAnswer(text="Regular")
-      ],
-      multiple_choice=True,
-      quiz=False,
-      answers=[
-                PollAnswer("Movie"),
-                PollAnswer(text="WebSeries"),
-                PollAnswer(text="Anime"),
-                PollAnswer(text="Documentary"),
-                PollAnswer(text="Regular")
-            ],
-      await FileStream.send_poll(
-        type= enums.PollType.REGULAR,
-        reply_to_message_id=message_id,
-        question="Is this a poll question?",
-        options=["Movie", "WebSeries", "Anime", "Documentary", "Regular"],
-        allows_multiple_answers=True,
-        chat_id=user_id
-        )
-      
-      #type=enums.PollType.QUIZ,
-      print(polls)
-      """
+      print("Detail",file_caption,"\nFile:",file_name,"\n Message Detail",message)
       file_info = get_file_info(message, instruction)
       # Here we are Adding the File Into the database First
       inserted_id = await db.add_file(file_info)

FileStream/bot/plugins/FileHandlers/stream.py

@@ -64,17 +64,20 @@ async def private_receive_handler(bot: Client, message: Message):
             }
         file_info=get_file_info(message, instruction)
         reply = await message.reply_text(LANG.PROCESSING_TEXT)
-
-        #reply_markup, stream_text = await upload_type_func(file_info=get_file_info(message, instruction),replied_message=reply.id)
-        reply_markup = InlineKeyboardMarkup([[
-        InlineKeyboardButton(
-            "Polls",
-            callback_data=f"initilize_{file_info['user_id']}_{file_info['message_id']}_{reply.id}")],
-            [ InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")]
-        ])
-        await reply.edit_text(text=f"{file_info['file']['caption'] if file_info['file']['caption'] else file_info['file']['file_name']}",
-                              reply_markup=reply_markup,
-                            )
+        
+        await reply.edit_text(
+          text=f"{file_info['file']['caption'] if file_info['file']['caption'] else file_info['file']['file_name']}",
+          parse_mode=ParseMode.HTML,
+          disable_web_page_preview=True,
+          reply_markup=InlineKeyboardMarkup([
+                [InlineKeyboardButton("Movie", callback_data=f"pubup_{user_id}_{message_id}_Movie")],
+                [InlineKeyboardButton("WebSeries", callback_data=f"pubup_{user_id}_{message_id}_WebSeries")],
+                [InlineKeyboardButton("Anime", callback_data=f"pubup_{user_id}_{message_id}_Anime")],
+                [InlineKeyboardButton("Documentary", callback_data=f"pubup_{user_id}_{message_id}_Documentary")],
+                [InlineKeyboardButton("Regular", callback_data=f"pubup_{user_id}_{message_id}_Regular")],
+                [ InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")]
+            ]),
+        )   
     except FloodWait as e:
         print(f"Sleeping for {str(e.value)}s")
         await asyncio.sleep(e.value)

FileStream/utils/FileProcessors/file_properties.py

@@ -189,6 +189,11 @@ def get_file_info(message, instruction):
       "user_id": instruction['user_id'],
       "user_type": instruction['user_type'],
       "message_id": message.id,
+      "TMDB_id": int(),    
+      "title": "Unknown",
+      "type": instruction['type'] if instruction['type'] else "Unknown",
+      "subtype":"Unknown",
+      "quality":"Unknown",
       "location": message.from_user.id if (message.chat.type == ChatType.PRIVATE) else message.chat.id,
       "file": {
           "file_id": getattr(media, "file_id", ""),

Unused Codes/callback.py

@@ -0,0 +1,734 @@
+import math
+import asyncio
+import datetime
+
+from pyrogram import filters, Client, raw, types,enums
+from pyrogram.errors import FloodWait
+from pyrogram.raw import functions
+from pyrogram.raw.types import Poll,PollAnswer, InputMediaPoll
+#from pyrogram.raw.base import PollAnswer, Poll
+from pyrogram.enums.parse_mode import ParseMode
+from pyrogram.file_id import FileId, FileType, PHOTO_TYPES
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton, CallbackQuery, WebAppInfo
+from pyrogram.raw.types import KeyboardButtonSimpleWebView
+
+#-------------------------Local Imports -----------------------------------#
+from FileStream import __version__
+from FileStream.Database import Database
+from FileStream.config import Telegram, Server
+from FileStream.bot import FileStream
+from FileStream.bot import MULTI_CLIENTS
+from FileStream.Exceptions import FileNotFound  # Corrected the import statement
+from FileStream.utils.FileProcessors.translation import LANG, BUTTON
+from FileStream.utils.FileProcessors.human_readable import humanbytes
+from FileStream.bot.plugins.FileHandlers.stream import private_receive_handler
+from FileStream.utils.FileProcessors.file_properties import get_file_ids, get_file_info,get_name
+from FileStream.utils.FileProcessors.bot_utils import gen_link, priv_func, gen_priv_file_link
+#-----------------Starting Point --------------------------#
+
+db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+
+
+#---------------------[ START CMD ]---------------------#
+@FileStream.on_callback_query()
+async def cb_data(bot: Client, update: CallbackQuery):
+  usr_cmd = update.data.split("_")
+  if usr_cmd[0] == "home":
+    await update.message.edit_text(text=LANG.START_TEXT.format(
+        update.from_user.mention, FileStream.username),
+                                   disable_web_page_preview=True,
+                                   reply_markup=BUTTON.START_BUTTONS)
+  elif usr_cmd[0] == "help":
+    await update.message.edit_text(text=LANG.HELP_TEXT.format(
+        Telegram.OWNER_ID),
+                                   disable_web_page_preview=True,
+                                   reply_markup=BUTTON.HELP_BUTTONS)
+  elif usr_cmd[0] == "about":
+    await update.message.edit_text(text=LANG.ABOUT_TEXT.format(
+        FileStream.fname, __version__),
+                                   disable_web_page_preview=True,
+                                   reply_markup=BUTTON.ABOUT_BUTTONS)
+
+  #---------------------[ MY FILES CMD ]---------------------#
+
+  elif usr_cmd[0] == "N/A":
+    await update.answer("N/A", True)
+  elif usr_cmd[0] == "close":
+    await update.message.delete()
+  elif usr_cmd[0] == "back":
+    try:
+      user_id = str(usr_cmd[1])
+      message_id = int(usr_cmd[2])
+      print(user_id, message_id)
+      message = await FileStream.get_messages(user_id, message_id)
+      await private_receive_handler(FileStream, message)
+    except FloodWait as e:
+      print(f"Sleeping for {str(e.value)}s")
+      await asyncio.sleep(e.value)
+      await FileStream.send_message(
+          chat_id=Telegram.ULOG_GROUP,
+          text=
+          f"Gᴏᴛ FʟᴏᴏᴅWᴀɪᴛ ᴏғ {str(e.value)}s ғʀᴏᴍ [{message.from_user.first_name}](tg://user?id={message.from_user.id})\n\n**ᴜsᴇʀ ɪᴅ :** `{str(message.from_user.id)}`",
+          disable_web_page_preview=True,
+          parse_mode=ParseMode.MARKDOWN)
+
+  elif usr_cmd[0] == "msgdelete":
+    await update.message.edit_caption(
+        caption="**Cᴏɴғɪʀᴍ ʏᴏᴜ ᴡᴀɴᴛ ᴛᴏ ᴅᴇʟᴇᴛᴇ ᴛʜᴇ Fɪʟᴇ**\n\n",
+        reply_markup=InlineKeyboardMarkup([[
+            InlineKeyboardButton(
+                "ʏᴇs", callback_data=f"msgdelyes_{usr_cmd[1]}_{usr_cmd[2]}"),
+            InlineKeyboardButton(
+                "ɴᴏ", callback_data=f"myfile_{usr_cmd[1]}_{usr_cmd[2]}")
+        ]]))
+  elif usr_cmd[0] == "msgdelyes":
+    await delete_user_file(usr_cmd[1], int(usr_cmd[2]), update)
+    return
+  elif usr_cmd[0] == "msgdelpvt":
+    await update.message.edit_caption(
+        caption="**Cᴏɴғɪʀᴍ ʏᴏᴜ ᴡᴀɴᴛ ᴛᴏ ᴅᴇʟᴇᴛᴇ ᴛʜᴇ Fɪʟᴇ**\n\n",
+        reply_markup=InlineKeyboardMarkup([[
+            InlineKeyboardButton("ʏᴇs",
+                                 callback_data=f"msgdelpvtyes_{usr_cmd[1]}"),
+            InlineKeyboardButton("ɴᴏ",
+                                 callback_data=f"mainstream_{usr_cmd[1]}")
+        ]]))
+  elif usr_cmd[0] == "msgdelpvtyes":
+    await delete_user_filex(usr_cmd[1], update)
+    return
+
+  elif usr_cmd[0] == "mainstream":
+    _id = usr_cmd[1]
+    reply_markup, stream_text = await gen_link(_id=_id)
+    await update.message.edit_text(
+        text=stream_text,
+        parse_mode=ParseMode.HTML,
+        disable_web_page_preview=True,
+        reply_markup=reply_markup,
+    )
+    try:
+      user_id = str(usr_cmd[1])
+      message_id = int(usr_cmd[2])
+      response_id = int(usr_cmd[3])
+      message = await FileStream.get_messages(user_id, message_id)
+      #response = await FileStream.get_messages(user_id, response_id)
+      instruction = {
+          "privacy_type": "PUBLIC",
+          "user_id": user_id,
+          "user_type": "TELEGRAM"
+      }
+      file_caption = getattr(message, "caption",  f"{get_name(message)}" ) or "None/Unknown"
+      file_name = get_name(message)
+      print("Detail",file_caption,file_name)
+      await update.message.edit_text(
+          text=file_caption,
+          parse_mode=ParseMode.HTML,
+          disable_web_page_preview=True,
+          reply_markup=InlineKeyboardMarkup([
+            [InlineKeyboardButton("Movie", callback_data=f"pubup_{user_id}_{message_id}_Movie")],
+            [InlineKeyboardButton("WebSeries", callback_data=f"pubup_{user_id}_{message_id}_WebSeries")],
+            [InlineKeyboardButton("Anime", callback_data=f"pubup_{user_id}_{message_id}_Anime")],
+            [InlineKeyboardButton("Documentary", callback_data=f"pubup_{user_id}_{message_id}_Documentary")],
+            [InlineKeyboardButton("Regular", callback_data=f"pubup_{user_id}_{message_id}_Regular")],
+        ]),
+      )  
+      """#await FileStream.delete_messages(chat_id=user_id,message_ids=response_id)
+      await FileStream.send_poll(
+        type= enums.PollType.REGULAR,
+        reply_to_message_id=message_id,
+        explanation=f"{file_caption}",
+        question=f"{message_id}_{user_id}_{response_id}_File Name :\n{file_caption}",
+        options=["Movie", "WebSeries", "Anime", "Documentary", "Regular"],
+        allows_multiple_answers=True,
+        chat_id=user_id
+        )
+    """
+    except Exception as e:
+      print(f"An error occurred: {str(e)}")
+      await FileStream.send_message(
+          chat_id=Telegram.ULOG_GROUP,
+          text=f"An error occurred: {str(e)}"
+      )
+
+  elif usr_cmd[0] == "pubup":
+    try:
+      user_id = str(usr_cmd[1])
+      message_id = int(usr_cmd[2])
+      msg_type = usr_cmd[3]
+      #response_id = int(usr_cmd[3])
+      message = await FileStream.get_messages(user_id, message_id)
+      #response = await FileStream.get_messages(user_id, response_id)
+      #print("Response Update:",update,f"Message ID:{response_id}")
+      instruction = {
+          "privacy_type": "PUBLIC",
+          "user_id": user_id,
+          "user_type": "TELEGRAM"
+      }
+      file_caption = getattr(message, "caption",  f"{get_name(message)}" ) or "None/Unknown"
+      file_name = get_name(message)
+      print("Detail",file_caption,"\nFile:",file_name)
+      """
+      await FileStream.delete_messages(
+        chat_id=user_id,
+        message_ids=message_id
+      )
+      await FileStream.send_poll(
+        type= enums.PollType.REGULAR,
+        reply_to_message_id=message_id,
+        question="Is this a poll question?",
+        options=["Movie", "WebSeries", "Anime", "Documentary", "Regular"],
+        allows_multiple_answers=True,
+        chat_id=user_id
+        )
+      
+      functions.messages.EditMessage(
+                peer=user_id,
+                id=message_id,
+                media=InputMediaPoll(
+                    poll=Poll(
+                        id=FileStream.rnd_id(),
+                        question="Is this a poll question?",
+                        answers=["Movie", "WebSeries", "Anime", "Documentary", "Regular"],
+                        multiple_choice=True,
+                        quiz=False,
+                    )
+                ),
+          )
+      
+      print("Poll function and all initializers executed successfully.")
+      print("dir(Poll):", dir(Poll))
+      print("Poll.__init__:", Poll.__init__)
+      print("Poll.__init__ inputs:", Poll.__init__.__code__.co_varnames)
+      print("InputMediaPoll.__init__ inputs:", InputMediaPoll.__init__.__code__.co_varnames)
+      update=await FileStream.edit_message_media(
+                chat_id=user_id,
+                message_id=response_id,
+                media=InputMediaPoll(
+                    caption="Is this a poll question?",
+                    poll=Poll(
+                      id=FileStream.rnd_id(),
+                      question="Is this a poll question?",
+                      answers=[
+                        PollAnswer(text="Movie", option=bytes([1])),
+                        PollAnswer(text="WebSeries", option=bytes([2])),
+                        PollAnswer(text="Anime", option=bytes([3])),
+                        PollAnswer(text="Documentary", option=bytes([4]))
+                      ],
+                      closed=False,
+                      public_voters=True,
+                      multiple_choice=True,
+                      quiz=False,
+                      close_period=None,
+                      close_date=None              
+                ),
+          )
+      )
+      print("Update:",update)
+      
+      PollAnswer(
+      id=FileStream.rnd_id(),
+      question="Is this a poll question?",
+      answers=["Movie","WebSeries"),
+        PollAnswer(text="Anime"),
+        PollAnswer(text="Documentary"),
+        PollAnswer(text="Regular")
+      ],
+      multiple_choice=True,
+      quiz=False,
+      answers=[
+                PollAnswer("Movie"),
+                PollAnswer(text="WebSeries"),
+                PollAnswer(text="Anime"),
+                PollAnswer(text="Documentary"),
+                PollAnswer(text="Regular")
+            ],
+      await FileStream.send_poll(
+        type= enums.PollType.REGULAR,
+        reply_to_message_id=message_id,
+        question="Is this a poll question?",
+        options=["Movie", "WebSeries", "Anime", "Documentary", "Regular"],
+        allows_multiple_answers=True,
+        chat_id=user_id
+        )
+      
+      #type=enums.PollType.QUIZ,
+      print(polls)
+      """
+      file_info = get_file_info(message, instruction)
+      # Here we are Adding the File Into the database First
+      inserted_id = await db.add_file(file_info)
+      await get_file_ids(False, inserted_id, message)
+      #All the Time Get_file_ids should be called before update privacy or else tagged_users will be {}
+      await db.update_privacy(file_info)
+      reply_markup, stream_text = await gen_link(_id=inserted_id)
+      await update.message.edit_text(
+          text=stream_text,
+          parse_mode=ParseMode.HTML,
+          disable_web_page_preview=True,
+          reply_markup=reply_markup,
+      )    
+    except FloodWait as e:
+      print(f"Sleeping for {str(e.value)}s")
+      await asyncio.sleep(e.value)
+      await FileStream.send_message(
+          chat_id=Telegram.ULOG_GROUP,
+          text=
+          f"Gᴏᴛ FʟᴏᴏᴅWᴀɪᴛ ᴏғ {str(e.value)}s ғʀᴏᴍ [{message.from_user.first_name}](tg://user?id={message.from_user.id})\n\n**ᴜsᴇʀ ɪᴅ :** `{str(message.from_user.id)}`",
+          disable_web_page_preview=True,
+          parse_mode=ParseMode.MARKDOWN)
+    except Exception as e:
+      print(f"An error occurred: {str(e)}")
+      await FileStream.send_message(
+          chat_id=Telegram.ULOG_GROUP,
+          text=f"An error occurred: {str(e)}"
+      )
+
+  elif usr_cmd[0] == "privup":
+    try:
+      user_id = str(usr_cmd[1])
+      message_id = int(usr_cmd[2])
+      message = await FileStream.get_messages(user_id, message_id)
+      instruction = {
+
+          "privacy_type": "PRIVATE",
+          "user_id": user_id,
+          "user_type": "TELEGRAM"
+      }
+      file_info = get_file_info(message, instruction)
+      # Here we are Adding the File Into the database First
+      db_id = await db.add_file(file_info)
+      await get_file_ids(False, db_id, message)
+
+      if True:
+        file_info = await db.get_file(db_id)
+        reply_markup, stream_text = await priv_func(file_info['file']['file_name'], file_info['file']['file_size'])
+
+        await update.message.edit_text(
+            text=stream_text,
+            parse_mode=ParseMode.HTML,
+            disable_web_page_preview=True,
+            reply_markup=reply_markup,
+        )
+    except FloodWait as e:
+      print(f"Sleeping for {str(e.value)}s")
+      await asyncio.sleep(e.value)
+      await FileStream.send_message(
+          chat_id=Telegram.ULOG_GROUP,
+          text=
+          f"Gᴏᴛ FʟᴏᴏᴅWᴀɪᴛ ᴏғ {str(e.value)}s ғʀᴏᴍ [{message.from_user.first_name}](tg://user?id={message.from_user.id})\n\n**ᴜsᴇʀ ɪᴅ :** `{str(message.from_user.id)}`",
+          disable_web_page_preview=True,
+          parse_mode=ParseMode.MARKDOWN)
+
+  elif usr_cmd[0] == "userfiles":
+    file_list, total_files = await gen_file_list_button(int(usr_cmd[1]), update.from_user.id)
+    await update.message.edit_caption(
+        caption="Total files: {}".format(total_files),
+        reply_markup=InlineKeyboardMarkup(file_list))
+
+  elif usr_cmd[0] == "userprivfiles":
+    file_list, total_files = await gen_privfile_list_button(
+        int(usr_cmd[1]), update.from_user.id)
+    await update.message.edit_caption(
+        caption="Total files: {}".format(total_files),
+        reply_markup=InlineKeyboardMarkup(file_list))
+
+  elif usr_cmd[0] == "userallfiles":
+    file_list, total_files = await gen_allfile_list_button(
+        int(usr_cmd[1]), update.from_user.id)
+    await update.message.edit_caption(
+        caption="Total files: {}".format(total_files),
+        reply_markup=InlineKeyboardMarkup(file_list))
+
+  elif usr_cmd[0] == "myfile":
+    await gen_file_menu(usr_cmd[1], usr_cmd[2], update)
+    return
+  elif usr_cmd[0] == "allfile":
+    await gen_allfile_menu(usr_cmd[1], usr_cmd[2], update)
+    return
+  elif usr_cmd[0] == "myprivfile":
+    await gen_privfile_menu(usr_cmd[1], usr_cmd[2], update)
+    return
+  elif usr_cmd[0] == "sendfile":
+    myfile = await db.get_file(usr_cmd[1])
+    file_name = myfile['file']['file_name']
+    await update.answer(f"Sending File {file_name}")
+    await update.message.reply_cached_media(myfile['file']['file_id'],caption=f'**{file_name}**')
+  else:
+    await update.message.delete()
+
+  #---------------------[ MY FILES FUNC ]---------------------#
+
+
+async def gen_file_list_button(file_list_no: int, user_id: int):
+
+  file_range = [file_list_no * 10 - 10 + 1, file_list_no * 10]
+  user_files, total_files = await db.find_files(user_id, file_range)
+
+  file_list = []
+  async for x in user_files:
+    file_list.append([
+        InlineKeyboardButton(f"📦 {x['file']['caption']}",
+                             callback_data=f"myfile_{x['_id']}_{file_list_no}")
+    ])
+  if total_files > 10:
+    file_list.append([
+        InlineKeyboardButton(
+            "◄",
+            callback_data="{}".format("userfiles_" +
+                                      str(file_list_no -
+                                          1) if file_list_no > 1 else 'N/A')),
+        InlineKeyboardButton(f"{file_list_no}/{math.ceil(total_files/10)}",
+                             callback_data="N/A"),
+        InlineKeyboardButton(
+            "►",
+            callback_data="{}".format("userfiles_" +
+                                      str(file_list_no +
+                                          1) if total_files > file_list_no *
+                                      10 else 'N/A'))
+    ])
+  if not file_list:
+    file_list.append([InlineKeyboardButton("ᴇᴍᴘᴛʏ", callback_data="N/A")])
+  file_list.append([InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")])
+  return file_list, total_files
+
+
+async def gen_file_menu(_id, file_list_no, update: CallbackQuery):
+  try:
+    myfile_info = await db.get_file(_id)
+  except FileNotFound:
+    await update.answer("File Not Found")
+    return
+
+  file_id = FileId.decode(myfile_info['file']['file_id'])
+
+  if file_id.file_type in PHOTO_TYPES:
+    file_type = "Image"
+  elif file_id.file_type == FileType.VOICE:
+    file_type = "Voice"
+  elif file_id.file_type in (FileType.VIDEO, FileType.ANIMATION,
+                             FileType.VIDEO_NOTE):
+    file_type = "Video"
+  elif file_id.file_type == FileType.DOCUMENT:
+    file_type = "Document"
+  elif file_id.file_type == FileType.STICKER:
+    file_type = "Sticker"
+  elif file_id.file_type == FileType.AUDIO:
+    file_type = "Audio"
+  else:
+    file_type = "Unknown"
+    
+  page_link = f"{Server.URL}app/watch/{myfile_info['_id']}"
+  stream_link = f"{Server.URL}api/dl/{myfile_info['_id']}"
+  if "video" in file_type.lower():
+    MYFILES_BUTTONS = InlineKeyboardMarkup([
+        [
+            InlineKeyboardButton("sᴛʀᴇᴀᴍ", url=page_link),
+            InlineKeyboardButton("ᴅᴏᴡɴʟᴏᴀᴅ", url=stream_link)
+        ],
+        [
+            InlineKeyboardButton(
+                "ɢᴇᴛ ғɪʟᴇ", callback_data=f"sendfile_{myfile_info['_id']}"),
+            InlineKeyboardButton(
+                "ʀᴇᴠᴏᴋᴇ ғɪʟᴇ",
+                callback_data=f"msgdelete_{myfile_info['_id']}_{file_list_no}")
+        ],
+        [
+            InlineKeyboardButton(
+                "ʙᴀᴄᴋ", callback_data="userfiles_{}".format(file_list_no))
+        ]
+    ])
+  else:
+    MYFILES_BUTTONS = InlineKeyboardMarkup([
+        [InlineKeyboardButton("ᴅᴏᴡɴʟᴏᴀᴅ", url=stream_link)],
+        [
+            InlineKeyboardButton(
+                "ɢᴇᴛ ғɪʟᴇ", callback_data=f"sendfile_{myfile_info['_id']}"),
+            InlineKeyboardButton(
+                "ʀᴇᴠᴏᴋᴇ ғɪʟᴇ",
+                callback_data=f"msgdelete_{myfile_info['_id']}_{file_list_no}")
+        ],
+        [
+            InlineKeyboardButton(
+                "ʙᴀᴄᴋ", callback_data="userfiles_{}".format(file_list_no))
+        ]
+    ])
+
+  TiMe = myfile_info['time']
+  if type(TiMe) == float:
+    date = datetime.datetime.fromtimestamp(TiMe)
+  await update.edit_message_caption(
+      caption="**File Name :** `{}`\n**File Size :** `{}`\n**File Type :** `{}`\n**Created On :** `{}`"
+      .format(myfile_info['file']['file_name'],
+              humanbytes(int(myfile_info['file']['file_size'])), file_type,
+              TiMe if isinstance(TiMe, str) else date.date()), reply_markup=MYFILES_BUTTONS)
+
+
+#################------ private file list
+async def gen_privfile_list_button(file_list_no: int, user_id: int):
+
+  file_range = [file_list_no * 10 - 10 + 1, file_list_no * 10]
+  user_files, total_files = await db.find_privfiles(user_id, file_range)
+
+  file_list = []
+  async for x in user_files:
+    file_list.append([
+        InlineKeyboardButton(
+            f"📦 {x['file']['caption']}",
+            callback_data=f"myprivfile_{x['_id']}_{file_list_no}")
+    ])
+  if total_files > 10:
+    file_list.append([
+        InlineKeyboardButton(
+            "◄",
+            callback_data="{}".format("userprivfiles_" +
+                                      str(file_list_no -
+                                          1) if file_list_no > 1 else 'N/A')),
+        InlineKeyboardButton(f"{file_list_no}/{math.ceil(total_files/10)}",
+                             callback_data="N/A"),
+        InlineKeyboardButton(
+            "►",
+            callback_data="{}".format("userprivfiles_" +
+                                      str(file_list_no +
+                                          1) if total_files > file_list_no *
+                                      10 else 'N/A'))
+    ])
+  if not file_list:
+    file_list.append([InlineKeyboardButton("ᴇᴍᴘᴛʏ", callback_data="N/A")])
+  file_list.append([InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")])
+  return file_list, total_files
+
+
+async def gen_privfile_menu(_id, file_list_no, update: CallbackQuery):
+  try:
+    myfile_info = await db.get_privfile(_id)
+  except FileNotFound:
+    await update.answer("File Not Found")
+    return
+
+  file_id = FileId.decode(myfile_info['file']['file_id'])
+
+  if file_id.file_type in PHOTO_TYPES:
+    file_type = "Image"
+  elif file_id.file_type == FileType.VOICE:
+    file_type = "Voice"
+  elif file_id.file_type in (FileType.VIDEO, FileType.ANIMATION,
+                             FileType.VIDEO_NOTE):
+    file_type = "Video"
+  elif file_id.file_type == FileType.DOCUMENT:
+    file_type = "Document"
+  elif file_id.file_type == FileType.STICKER:
+    file_type = "Sticker"
+  elif file_id.file_type == FileType.AUDIO:
+    file_type = "Audio"
+  else:
+    file_type = "Unknown"
+  
+  page_link = f"{Server.URL}app/watch/{myfile_info['_id']}"
+  stream_link = f"{Server.URL}api/dl/{myfile_info['_id']}"
+  if "video" in file_type.lower():
+    MYFILES_BUTTONS = InlineKeyboardMarkup([
+        [
+            InlineKeyboardButton("sᴛʀᴇᴀᴍ", url=page_link),
+            InlineKeyboardButton("ᴅᴏᴡɴʟᴏᴀᴅ", url=stream_link)
+        ],
+        [
+            InlineKeyboardButton(
+                "ɢᴇᴛ ғɪʟᴇ", callback_data=f"sendfile_{myfile_info['_id']}"),
+            InlineKeyboardButton(
+                "ʀᴇᴠᴏᴋᴇ ғɪʟᴇ",
+                callback_data=f"msgdelete_{myfile_info['_id']}_{file_list_no}")
+        ],
+        [
+            InlineKeyboardButton(
+                "ʙᴀᴄᴋ", callback_data="userfiles_{}".format(file_list_no))
+        ]
+    ])
+  else:
+    MYFILES_BUTTONS = InlineKeyboardMarkup([
+        [InlineKeyboardButton("ᴅᴏᴡɴʟᴏᴀᴅ", url=stream_link)],
+        [
+            InlineKeyboardButton(
+                "ɢᴇᴛ ғɪʟᴇ", callback_data=f"sendfile_{myfile_info['_id']}"),
+            InlineKeyboardButton(
+                "ʀᴇᴠᴏᴋᴇ ғɪʟᴇ",
+                callback_data=f"msgdelete_{myfile_info['_id']}_{file_list_no}")
+        ],
+        [
+            InlineKeyboardButton(
+                "ʙᴀᴄᴋ", callback_data="userfiles_{}".format(file_list_no))
+        ]
+    ])
+
+  TiMe = myfile_info['time']
+  if type(TiMe) == float:
+    date = datetime.datetime.fromtimestamp(TiMe)
+  await update.edit_message_caption(
+      caption=
+      "**File Name :** `{}`\n**File Size :** `{}`\n**File Type :** `{}`\n**Created On :** `{}`"
+      .format(myfile_info['file_name'],
+              humanbytes(int(myfile_info['file']['file_size'])), file_type,
+              TiMe if isinstance(TiMe, str) else date.date()),
+      reply_markup=MYFILES_BUTTONS)
+
+
+##################---- all file function-----##################
+async def gen_allfile_list_button(file_list_no: int, user_id: int):
+
+  file_range = [file_list_no * 10 - 10 + 1, file_list_no * 10]
+  user_files, total_files = await db.find_all_files(file_range)
+
+  file_list = []
+  async for x in user_files:
+    file_list.append([
+        InlineKeyboardButton(
+            f"📦 {x['file']['caption']}",
+            callback_data=f"allfile_{x['_id']}_{file_list_no}")
+    ])
+  if total_files > 10:
+    file_list.append([
+        InlineKeyboardButton(
+            "◄",
+            callback_data="{}".format("userallfiles_" +
+                                      str(file_list_no -
+                                          1) if file_list_no > 1 else 'N/A')),
+        InlineKeyboardButton(f"{file_list_no}/{math.ceil(total_files/10)}",
+                             callback_data="N/A"),
+        InlineKeyboardButton(
+            "►",
+            callback_data="{}".format("userallfiles_" +
+                                      str(file_list_no +
+                                          1) if total_files > file_list_no *
+                                      10 else 'N/A'))
+    ])
+  if not file_list:
+    file_list.append([InlineKeyboardButton("ᴇᴍᴘᴛʏ", callback_data="N/A")])
+  file_list.append([InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")])
+  return file_list, total_files
+
+
+async def gen_allfile_menu(_id, file_list_no, update: CallbackQuery):
+  try:
+    myfile_info = await db.get_file(_id)
+  except FileNotFound:
+    await update.answer("File Not Found")
+    return
+
+  file_id = FileId.decode(myfile_info['file']['file_id'])
+
+  if file_id.file_type in PHOTO_TYPES:
+    file_type = "Image"
+  elif file_id.file_type == FileType.VOICE:
+    file_type = "Voice"
+  elif file_id.file_type in (FileType.VIDEO, FileType.ANIMATION,
+                             FileType.VIDEO_NOTE):
+    file_type = "Video"
+  elif file_id.file_type == FileType.DOCUMENT:
+    file_type = "Document"
+  elif file_id.file_type == FileType.STICKER:
+    file_type = "Sticker"
+  elif file_id.file_type == FileType.AUDIO:
+    file_type = "Audio"
+  else:
+    file_type = "Unknown"
+ 
+  page_link = f"{Server.URL}app/watch/{myfile_info['_id']}"
+  stream_link = f"{Server.URL}api/dl/{myfile_info['_id']}"
+  if "video" in file_type.lower():
+    MYFILES_BUTTONS = InlineKeyboardMarkup([
+        [
+            InlineKeyboardButton("sᴛʀᴇᴀᴍ", url=page_link),
+            InlineKeyboardButton("ᴅᴏᴡɴʟᴏᴀᴅ", url=stream_link)
+        ],
+        [
+            InlineKeyboardButton(
+                "ɢᴇᴛ ғɪʟᴇ", callback_data=f"sendfile_{myfile_info['_id']}"),
+            InlineKeyboardButton(
+                "ʀᴇᴠᴏᴋᴇ ғɪʟᴇ",
+                callback_data=f"msgdelete_{myfile_info['_id']}_{file_list_no}")
+        ],
+        [
+            InlineKeyboardButton(
+                "ʙᴀᴄᴋ", callback_data="userfiles_{}".format(file_list_no))
+        ]
+    ])
+  else:
+    MYFILES_BUTTONS = InlineKeyboardMarkup([
+        [InlineKeyboardButton("ᴅᴏᴡɴʟᴏᴀᴅ", url=stream_link)],
+        [
+            InlineKeyboardButton(
+                "ɢᴇᴛ ғɪʟᴇ", callback_data=f"sendfile_{myfile_info['_id']}"),
+            InlineKeyboardButton(
+                "ʀᴇᴠᴏᴋᴇ ғɪʟᴇ",
+                callback_data=f"msgdelete_{myfile_info['_id']}_{file_list_no}")
+        ],
+        [
+            InlineKeyboardButton(
+                "ʙᴀᴄᴋ", callback_data="userfiles_{}".format(file_list_no))
+        ]
+    ])
+
+  TiMe = myfile_info['time']
+  if type(TiMe) == float:
+    date = datetime.datetime.fromtimestamp(TiMe)
+  await update.edit_message_caption(
+      caption=
+      "**File Name :** `{}`\n**File Size :** `{}`\n**File Type :** `{}`\n**Created On :** `{}`"
+      .format(myfile_info['file']['file_name'],
+              humanbytes(int(myfile_info['file']['file_size'])), file_type,
+              TiMe if isinstance(TiMe, str) else date.date()),
+      reply_markup=MYFILES_BUTTONS)
+
+
+async def delete_user_file(_id, file_list_no: int, update: CallbackQuery):
+
+  try:
+    myfile_info = await db.get_file(_id)
+    if not myfile_info:
+
+      myfile_info = await db.get_privfile(db_id)
+      await db.delete_one_privfile(myfile_info['_id'])
+      #await db.count_links(update.from_user.id, "-")
+      await update.message.edit_caption(
+          caption="**Fɪʟᴇ Dᴇʟᴇᴛᴇᴅ Sᴜᴄᴄᴇssғᴜʟʟʏ !**" +
+          update.message.caption.replace("Cᴏɴғɪʀᴍ ʏᴏᴜ ᴡᴀɴᴛ ᴛᴏ ᴅᴇʟᴇᴛᴇ ᴛʜᴇ Fɪʟᴇ",
+                                         ""),
+          reply_markup=InlineKeyboardMarkup(
+              [[InlineKeyboardButton("ʙᴀᴄᴋ", callback_data=f"userfiles_1")]]))
+    else:
+      await db.delete_one_file(myfile_info['_id'])
+      await db.count_links(update.from_user.id, "-")
+      await update.message.edit_caption(
+          caption="**Fɪʟᴇ Dᴇʟᴇᴛᴇᴅ Sᴜᴄᴄᴇssғᴜʟʟʏ !**" +
+          update.message.caption.replace("Cᴏɴғɪʀᴍ ʏᴏᴜ ᴡᴀɴᴛ ᴛᴏ ᴅᴇʟᴇᴛᴇ ᴛʜᴇ Fɪʟᴇ",
+                                         ""),
+          reply_markup=InlineKeyboardMarkup(
+              [[InlineKeyboardButton("ʙᴀᴄᴋ", callback_data=f"userfiles_1")]]))
+
+  except FileNotFound:
+    await update.answer("File Already Deleted")
+    return
+
+
+async def delete_user_filex(_id, update: CallbackQuery):
+
+  try:
+    myfile_info = await db.get_file(_id)
+    if not myfile_info:
+
+      myfile_info = await db.get_privfile(_id)
+      await db.delete_one_privfile(myfile_info['_id'])
+      await update.message.edit_caption(
+          caption="**Fɪʟᴇ Dᴇʟᴇᴛᴇᴅ Sᴜᴄᴄᴇssғᴜʟʟʏ !**\n\n",
+          reply_markup=InlineKeyboardMarkup(
+              [[InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data=f"close")]]))
+    else:
+      await db.delete_one_file(myfile_info['_id'])
+      await db.count_links(update.from_user.id, "-")
+      await update.message.edit_caption(
+          caption="**Fɪʟᴇ Dᴇʟᴇᴛᴇᴅ Sᴜᴄᴄᴇssғᴜʟʟʏ !**\n\n",
+          reply_markup=InlineKeyboardMarkup(
+              [[InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data=f"close")]]))
+
+  except FileNotFound:
+    await update.answer("File Already Deleted")
+    return