APP -sparkdrive

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.11
+RUN useradd -ms /bin/bash admin
+RUN rm -rf /app/*
+WORKDIR /app
+COPY . /app
+COPY requirement.txt ./requirements.txt
+RUN apt-get update -y && apt-get upgrade -y \
+    && apt-get install \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN pip3 install --no-cache-dir --upgrade --requirement requirements.txt
+RUN chown -R admin:admin /app
+RUN chmod 777 /app
+#RUN chmod 664 /app
+USER admin
+EXPOSE 7860
+#CMD ["uvicorn", "live:app", "--host", "0.0.0.0", "--port", "7860"]
+#CMD ["bash", "start"]
+CMD ["python","-u", "-m", "FileStream"]

FileStream/.gitignore

@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

FileStream/Database/__init__.py

@@ -0,0 +1 @@
+from .database import Database

FileStream/Database/database.py

@@ -0,0 +1,382 @@
+import re
+import time
+import pymongo
+import motor.motor_asyncio
+from bson.objectid import ObjectId
+from bson.errors import InvalidId
+from bson.json_util import dumps
+
+#----------------------Local Imports-----------------------#
+from FileStream.server.exceptions import FIleNotFound
+from FileStream.Tools import Time_ISTKolNow
+
+
+class Database:
+
+  def __init__(self, uri, database_name):
+    self._client = motor.motor_asyncio.AsyncIOMotorClient(uri)
+    self.db = self._client[database_name]
+    self.users = self.db.Users
+    self.files = self.db.Public_Files
+    self.pfile = self.db.Private_Files
+    self.web_upload = self.db.Web_Files
+
+#---------------------[ SCHEMAS ]------------------------------#
+#---------------------[ NEW USER ]---------------------#
+
+  def new_user(self, id):
+    return dict(
+        telegram_id=id,
+        access="USER",
+        tele_status={
+            "status": "ACTIVE",
+            "activity": None,
+            "joined": Time_ISTKolNow()
+        },
+        file={
+            "links": 0,
+            "private_files": 0,
+            "public_files": 0,
+        },
+        site_id="None",
+        site_status={
+            "status": None,
+            "activity": None,
+            "password": None,
+            "links": 0,
+            "joined": "None"
+        },
+    )
+#------------------------------------------------
+
+  def NewTG_Files(self, details):
+    return {
+        "user_id":
+        details['user_id'] if details['user_id'] else None,
+        "user_type":
+        details['user_type'] if details['user_type'] else None,
+        "message_id":
+        details['message_id'] if details['message_id'] else None,
+        "location":
+        details['location'] if details['location'] else None,
+        "file": {
+            "file_id":
+            details['file']['file_id'] if details['file']['file_id'] else None,
+            "file_unique_id":
+            details['file']['file_unique_id']
+            if details['file']['file_unique_id'] else None,
+            "file_name":
+            details['file']['file_name']
+            if details['file']['file_name'] else None,
+            "file_size":
+            details['file']['file_size']
+            if details['file']['file_size'] else None,
+            "mime_type":
+            details['file']['mime_type']
+            if details['file']['mime_type'] else None,
+            "taged_users": {}
+        },
+        "time":
+        details['time'] if details['time'] else None,
+        "privacy_type":
+        details['privacy_type'] if details['privacy_type'] else None,
+    }
+
+# ---------------------[ ADD USER ]---------------------#
+
+  async def add_user(self, id):
+    user = self.new_user(id)
+    await self.users.insert_one(user)
+
+  async def add_admin(self, id):
+    user= await self.get_user(id)
+    if user:
+      await self.users.update_one({"_id": user['_id']}, {"$set": {"access":"ADMIN" }})
+    else:
+      user = self.new_user(id)
+      user['access']="ADMIN"
+      await self.users.insert_one(user)
+
+# ---------------------[ GET USER ]---------------------#
+
+  async def get_user(self, id):
+    user = await self.users.find_one({'telegram_id': int(id)})
+    return user
+
+# ---------------------[ CHECK USER ]---------------------#
+
+  async def total_users_count(self):
+    count = await self.users.count_documents({})
+    return count
+
+  async def get_all_users(self):
+    all_users = self.users.find({})
+    return all_users
+
+  async def is_admin(self, user_id):
+    user = await self.users.find_one({'telegram_id': int(user_id)})
+    return True if user['access'] == "ADMIN" else False
+
+# ---------------------[ REMOVE USER ]---------------------#
+
+  async def delete_user(self, user_id):
+    await self.users.delete_many({'telegram_id': int(user_id)})
+
+# ---------------------[ BAN, UNBAN USER ]---------------------#
+
+  async def ban_user(self, id):
+    await self.users.update_one({"_id": ObjectId(_id)}, {
+        "$set": {
+            "tele_status": {
+                "status": "BANNED",
+                "activity": Time_ISTKolNow()
+            },
+        }
+    })
+
+  async def unban_user(self, id):
+    await self.users.update_one({"_id": ObjectId(_id)}, {
+        "$set": {
+            "tele_status": {
+                "status": "ACTIVE",
+                "activity": Time_ISTKolNow(),
+            }
+        }
+    })
+
+  async def is_user_banned(self, id):
+    if await self.users.find_one({'telegram_id': int(id)}):
+      return True
+    else:
+      return False
+
+  # ---------------------[ ADD FILE TO DB ]---------------------#
+  async def add_file(self, file_info):
+    file_info["time"] = Time_ISTKolNow()
+    fetch_old = await self.get_file_by_fileuniqueid(file_info["user_id"], file_info['file']["file_unique_id"])
+    if fetch_old:
+      return fetch_old["_id"]
+    await self.count_links(file_info["user_id"], "+")
+    return (await self.files.insert_one(file_info)).inserted_id
+
+  # ---------------------[ FIND FILE IN DB for Bot and APIs]---------------------#
+  async def get_file(self, _id):
+    try:
+      file_info = await self.files.find_one({"_id": ObjectId(_id)})
+      if not file_info:
+        print('file not found')
+        #raise FIleNotFound
+      return file_info
+    except InvalidId:
+      raise FIleNotFound
+
+  async def get_all_files_api(self,range=None):
+    #files = self.files.find({})
+    files= await self.files.find().to_list(length=None)
+    #json_result = dumps(cursor)[row for row in files]
+    print("\n  get_all_files_api : Return Type : ", type(files))
+    return files
+
+  async def get_all_files(self,range=None):
+    user_files = self.files.find({})
+    if range :
+      user_files.skip(range[0] - 1)
+      user_files.limit(range[1] - range[0] + 1)
+      user_files.sort('_id', pymongo.DESCENDING)
+    return user_files
+
+  async def find_files(self, user_id, range):
+    user_files = self.files.find(
+        {f"file.tagged_users.{user_id}": {
+            "$exists": True
+        }})
+    user_files.skip(range[0] - 1)
+    user_files.limit(range[1] - range[0] + 1)
+    user_files.sort('_id', pymongo.DESCENDING)
+    total_files = await self.files.count_documents(
+        {f"file.tagged_users.{user_id}": {
+            "$exists": True
+        }})
+    return user_files, total_files
+
+  async def find_all_public_files(self, range):
+    user_files = self.files.find({"privacy_type": "PUBLIC"})
+    user_files.skip(range[0] - 1)
+    user_files.limit(range[1] - range[0] + 1)
+    user_files.sort('_id', pymongo.DESCENDING)
+    total_files = await self.files.count_documents({"privacy_type": "PUBLIC"})
+    return user_files, total_files
+
+  async def find_all_files(self, range):
+    user_files = self.files.find({})
+    user_files.skip(range[0] - 1)
+    user_files.limit(range[1] - range[0] + 1)
+    user_files.sort('_id', pymongo.DESCENDING)
+    total_files = await self.files.count_documents({})
+    return user_files, total_files
+
+  async def find_private_files(self, user_id, range):
+    #search_string = "file.tagged_user." + str(user_id)
+    user_files = self.files.find({f"file.tagged_users.{user_id}": "PRIVATE"})
+    user_files.skip(range[0] - 1)
+    user_files.limit(range[1] - range[0] + 1)
+    user_files.sort('_id', pymongo.DESCENDING)
+    total_files = await self.files.count_documents(
+        {"file.tagged_users." + str(user_id): "PRIVATE"})
+    return user_files, total_files
+
+  async def get_file_by_fileuniqueid_only(self, file_unique_id):
+    return await self.files.find_one({"file.file_unique_id": file_unique_id})
+
+  async def get_file_by_fileuniqueid(self, id, file_unique_id):
+    count = await self.files.count_documents({"user_id":id,"file.file_unique_id":file_unique_id})
+    if count == 0:
+      return False
+    elif count == 1:
+      return await self.files.find_one({"user_id": id,"file.file_unique_id": file_unique_id})
+    else:
+      return self.files.find({"user_id": id,"file.file_unique_id": file_unique_id})
+
+  # ---------------------[ UPDATE FILE IN DB ]---------------------#
+
+  async def update_privacy(self, file_details: dict):
+    file = await self.get_file_by_fileuniqueid_only(file_details['file']['file_unique_id'])
+    # Merge the tagged_user dictionaries
+    updated_tagged_users = file['file']['tagged_users'].copy()
+    updated_tagged_users.update(file_details['file']['tagged_users'])
+    #for value in updated_tagged_users.values():
+    #  if value == "PRIVATE":
+    #    file_details['privacy_type']=="PRIVATE"
+    file_details['privacy_type'] = "PRIVATE" if any(value == "PRIVATE" for value in updated_tagged_users.values()) else file_details['privacy_type']
+    await self.files.update_one({"_id": file['_id']}, {
+        "$set": {
+            "privacy_type": file_details['privacy_type'],
+            "file.tagged_users": updated_tagged_users
+        }
+    })
+    return await self.get_file_by_fileuniqueid_only(file_details['file']['file_unique_id'])
+
+  async def update_file_ids(self, _id, file_ids: dict):
+    await self.files.update_one({"_id": ObjectId(_id)},
+                                {"$set": {
+                                    "file_ids": file_ids
+                                }})
+
+  async def update_file_info(self, _id, file_info: dict):
+    await self.files.update_one({"_id": ObjectId(_id)}, {
+        "$set": {
+            "message_id": file_info['message_id'],
+            "location": file_info['location'],
+            "file": file_info['file']
+        }
+    })
+
+
+  #--------------------------PrivateFiles-------------------
+  async def get_private_file(self, _id):
+    try:
+      file_info = await self.pfile.find_one({"_id": ObjectId(_id)})
+      if not file_info:
+        raise FIleNotFound
+      return file_info
+    except InvalidId:
+      raise FIleNotFound
+
+  async def add_private_file(self, file_info):
+    file_info["time"] = Time_ISTKolNow()
+    fetch_old = await self.get_private_file_by_fileuniqueid_only(file_info['file']["file_unique_id"])
+    if fetch_old:
+      return fetch_old["_id"]
+    return (await self.pfile.insert_one(file_info))
+
+  async def get_private_file_by_fileuniqueid_only(self, file_unique_id):
+    return await self.pfile.find_one({"file.file_unique_id": file_unique_id})
+
+  async def update_private_file_ids(self, _id, file_ids: dict):
+    await self.pfile.update_one({"_id": ObjectId(_id)},
+                                {"$set": {
+                                    "file_ids": file_ids
+                                }})
+
+  async def update_private_privacy(self, file_details: dict, instruction: dict):
+    file = await self.get_file_by_fileuniqueid_only(file_details['file']['file_unique_id'])
+    await self.pfile.insert_one(file_details)
+
+#####################-------search for inline query ------------###############
+
+  async def get_search_results(self,query=None, file_type=None, max_results=10, offset=0):
+    
+    regex = re.compile(re.escape(query), re.IGNORECASE)
+    filter = {'$or': [{'file.file_name': {"$regex": regex}}, {'file.caption': {"$regex": regex}}]}
+
+    if file_type:
+      filter['mime_type'] = file_type
+
+    total_results = await self.files.count_documents(filter)
+    next_offset = offset + max_results
+
+    if next_offset > total_results:
+      next_offset = ''
+    
+    cursor = self.files.find(filter)
+    # Sort by recent
+    cursor.sort('$natural', -1)
+    # Slice files according to offset and max results
+    cursor.skip(offset).limit(max_results)
+    # Get list of files
+    files = await cursor.to_list(length=max_results)
+    return files, next_offset
+
+  # ---------------------[ TOTAL FILES ]---------------------#
+  async def total_files(self, id=None):
+    if id:
+      return await self.files.count_documents({"user_id": id})
+    return await self.files.count_documents({})
+
+  async def total_privfiles(self, id=None):
+    if id:
+      return await self.pfile.count_documents({"user_id": id})
+    return await self.pfile.count_documents({})
+
+# ---------------------[ DELETE FILES ]---------------------#
+
+  async def delete_one_file(self, _id):
+    await self.files.delete_one({'_id': ObjectId(_id)})
+
+
+# ---------------------[ PAID SYS ]---------------------#
+#     async def link_available(self, id):
+#         user = await self.col.find_one({"id": id})
+#         if user.get("Plan") == "Plus":
+#             return "Plus"
+#         elif user.get("Plan") == "Free":
+#             files = await self.file.count_documents({"user_id": id})
+#             if files < 11:
+#                 return True
+#             return False
+
+  async def count_links(self, id, operation: str):
+    if operation == "-":
+      await self.users.update_one({"id": id}, {"$inc": {"file.links": -1}})
+    elif operation == "+":
+      await self.users.update_one({"id": id}, {"$inc": {"file.links": 1}})
+
+  #------------------------------For Web Files -----------------------------------------#
+  async def add_webfile(self, upload_info):
+    fetch_old = await self.get_web_file(upload_info["dropzone_id"])
+    if fetch_old:
+      return fetch_old
+    else:
+      await self.web_upload.insert_one(upload_info)
+      return await self.get_web_file(upload_info["dropzone_id"])
+
+  #async def update_web_file(self, dropzone_id):
+
+  async def get_web_file(self, upload_id):
+    file_info = await self.web_upload.find_one({"dropzone_id": upload_id})
+    if not file_info:
+      return None
+    return file_info
+
+  async def uploaded_web_file(self, upload_id):
+    await self.web_upload.delete_one({"dropzone_id": upload_id})

FileStream/TMDB/Endpoint.py

@@ -0,0 +1,37 @@
+from FileStream.TMDB.__init__ import tmdb,search,movie,tv
+import urllib3
+from FileStream.Tools.cleanup import Get_Title_Year
+
+
+def get_tvshows(tv_show_id):
+    return tv.details(tv_show_id).__dict__
+    
+def search_tmdb(name):
+    # Search for the title in TMDb
+    title, year = Get_Title_Year(name)
+    print("*", title, year,"\n Name :", name)
+    if title is None :
+        return None
+    search_results = search.multi(title)
+    # Filter results by year
+    try:
+        for result in search_results:
+            #if not isinstance(result, dict):
+                #print(result)
+                #result = result
+            #release_date = result.release_date if result.release_date else result.first_air_date
+            if result.media_type  == "tv":
+                release_date=result.release_date or result.first_air_date or result.get("release_date") or result.get("first_air_date") 
+                if release_date and int(release_date.split('-')[0]) == year:
+                    return get_tvshows( result.id or result.get("id") ) 
+
+            if result.media_type  == "movie":
+                release_date=result.release_date or result.get("release_date") or result.get("first_air_date") 
+                if release_date and int(release_date.split('-')[0]) == year:
+                    return result
+
+    except Exception as e :
+        #print("* Error at Endpoint", e, result)
+        return None
+
+    return None

FileStream/TMDB/__init__.py

@@ -0,0 +1,14 @@
+import re
+from tmdbv3api import TMDb, Search, Movie,TV
+from FileStream.config import TMDB
+
+# Initialize the TMDb API
+tmdb = TMDb()
+tmdb.api_key = TMDB.API  # Replace with your actual TMDb API key
+
+# Initialize the Search class
+search = Search()
+movie=Movie()
+tv=TV()
+
+

FileStream/Tools/__init__.py

@@ -0,0 +1 @@
+from .tool import Time_ISTKolNow, mime_identifier

FileStream/Tools/cleanup.py

@@ -0,0 +1,51 @@
+import re
+
+#words_to_remove = ["FC","HEVC","ɴᴀᴍᴇ:","-","BuLMoviee" ,"𝗝𝗼𝗶𝗻 𝗨𝘀 𝗢𝗻 𝗧𝗲𝗹𝗲𝗴𝗿𝗮�","SIDHUU 591","𝑱𝒐𝒊𝒏 𝑼𝒔 𝑶ɴ 𝑻ᴇʟᴇɢʀᴀᴍ","Tɪᴛʟᴇ :"]
+
+def remove_words(text, words_to_remove):
+    # Join the words to remove into a single regex pattern
+    pattern = r'\b(?:' + '|'.join(map(re.escape, words_to_remove)) + r')\b'
+    # Use re.sub() to replace the pattern with an empty string
+    cleaned_text = re.sub(pattern, '', text)
+    # Remove extra spaces that might have been left after removing the words
+    cleaned_text = re.sub(r'\s+', ' ', cleaned_text).strip()
+    return cleaned_text
+
+def convert_special_to_normal(text):
+    # Unescape HTML entities
+    text = html.unescape(text)
+    # Normalize Unicode characters
+    text = unicodedata.normalize('NFKD', text).encode('ascii', 'ignore').decode('utf-8')
+    # Remove special characters
+    text = re.sub(r'[^A-Za-z0-9 ]+', '', text)
+    return text
+
+def clean_text(input_text):
+    # Remove new line characters
+    text = input_text.replace('\n', '').replace('@', '')
+    emoji_pattern = re.compile(
+        "["
+        "\U0001F600-\U0001F64F"  # emoticons
+        "\U0001F300-\U0001F5FF"  # symbols & pictographs
+        "\U0001F680-\U0001F6FF"  # transport & map symbols
+        "\U0001F700-\U0001F77F"  # alchemical symbols
+        "\U00002600-\U000026FF"  # Miscellaneous Symbols
+        "\U00002700-\U000027BF"  # Dingbats
+        "\U0001F900-\U0001F9FF"  # Supplemental Symbols and Pictographs
+        "\U0001FA70-\U0001FAFF"  # Symbols and Pictographs Extended-A
+        "\U0001F1E0-\U0001F1FF"  # Flags (iOS)
+        "]+",
+        flags=re.UNICODE)
+    output_text = emoji_pattern.sub(r'', text)
+    return output_text
+
+
+
+def Get_Title_Year(name):
+    # Regex to match title and year
+    words_to_remove = ["FC", "HEVC","ɴᴀᴍᴇ:","-","BuLMoviee" ,"𝗝𝗼𝗶𝗻 𝗨𝘀 𝗢𝗻 𝗧𝗲𝗹𝗲𝗴𝗿𝗮�","𝗝𝗼𝗶𝗻 𝗨𝘀 𝗢𝗻 𝗧𝗲𝗹𝗲𝗴𝗿𝗮𝗺","SIDHUU 591","𝑱𝒐𝒊𝒏 𝑼𝒔 𝑶ɴ 𝑻ᴇʟᴇɢʀᴀᴍ","Tɪᴛʟᴇ :"]
+    name=remove_words(name, words_to_remove)
+    match = re.search(r'(?P<title>.+?)[\s\.\(\)]*(?P<year>\d{4})',name )
+    if match:
+        return match.group('title').strip(), int(match.group('year'))
+    return None, None

FileStream/Tools/file.py

@@ -0,0 +1,11 @@
+
+def humanbytes(size):
+    if not size:
+        return ""
+    power = 2**10
+    n = 0
+    Dic_powerN = {0: ' ', 1: 'Ki', 2: 'Mi', 3: 'Gi', 4: 'Ti'}
+    while size > power:
+        size /= power
+        n += 1
+    return str(round(size, 2)) + " " + Dic_powerN[n] + 'B'

FileStream/Tools/progress.py

@@ -0,0 +1,87 @@
+import random
+import urllib3
+import logging
+import asyncio
+import traceback
+import mimetypes
+import time, math
+from datetime import datetime
+from typing import Dict, Union
+from typing import Union, BinaryIO, List, Optional, Callable
+
+from pyrogram import raw
+from pyrogram import types
+from pyrogram import filters, Client
+from pyrogram import utils as pgutils
+from pyrogram import StopTransmission, enums
+from pyrogram import Client, utils, raw
+
+from pyrogram.file_id import FileType
+from pyrogram.session import Session, Auth
+from pyrogram.errors import FilePartMissing,AuthBytesInvalid,FloodWait
+from pyrogram.file_id import FileId, FileType, ThumbnailSource
+from pyrogram.enums import ParseMode, ChatType
+from pyrogram.enums.parse_mode import ParseMode
+from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
+
+
+#--------------------------Local Imports-------------#
+
+from FileStream.bot import FileStream, multi_clients, work_loads
+from FileStream.Database import Database
+from FileStream.config import Telegram, Server
+from FileStream.Tools.tool import TimeFormatter
+
+from FileStream.utils.FileProcessors.bot_utils import is_user_banned, is_user_exist, is_user_joined, gen_link, is_channel_banned, is_channel_exist, is_user_authorized, upload_type_func
+from FileStream.utils.FileProcessors.custom_dl import ByteStreamer
+from FileStream.utils.FileProcessors.custom_ul import  TeleUploader
+from FileStream.utils.FileProcessors.custom_mix import TGFileController
+from FileStream.utils.FileProcessors.translation import LANG, BUTTON
+from FileStream.utils.FileProcessors.human_readable import humanbytes
+from FileStream.utils.FileProcessors.file_properties import get_file_ids,get_file_info
+
+
+
+
+
+async def progress(current, total, progress_args):
+  progress_text = LANG.BASIC_PRIV_FILE.format(
+      progress_args[1], humanbytes(progress_args[2]))
+  #print(f"{current * 100 / total:.1f}%")
+  now = time.time()
+  diff = now - progress_args[3]
+  if round(diff % 10.00) == 0 or current == total:
+      percentage = current * 100 / total
+      speed = current / diff
+      elapsed_time = round(diff) * 1000
+      time_to_completion = round((total - current) / speed) * 1000
+      estimated_total_time = elapsed_time + time_to_completion
+
+      elapsed_time = TimeFormatter(milliseconds=elapsed_time)
+      estimated_total_time = TimeFormatter(
+          milliseconds=estimated_total_time)
+
+      progress = "{0}{1}".format(
+          ''.join(["●" for i in range(math.floor(percentage / 5))]),
+          ''.join(["○" for i in range(20 - math.floor(percentage / 5))
+                   ])  # This line is modified
+      )
+      tmp = progress_text + '\n' + progress + LANG.PROGRESS_BAR.format(
+          percentage=round(percentage, 2),
+          current=humanbytes(current),
+          total=humanbytes(total),
+          speed=humanbytes(speed),
+          est_time=estimated_total_time
+          if estimated_total_time != '' else "0 s")
+      try:
+          await progress_args[0].edit_text(
+              text=tmp,
+              parse_mode=ParseMode.HTML,
+              disable_web_page_preview=True,
+          )
+
+      except FloodWait as w:
+          print(f"Sleeping for {str(w.wait_time)}s")
+          await asyncio.sleep(w.wait_time)
+      except Exception as e:
+          print(e)

FileStream/Tools/tool.py

@@ -0,0 +1,25 @@
+def Time_ISTKolNow():
+  from datetime import datetime
+  import pytz
+  IST = datetime.now(pytz.timezone("Asia/Kolkata")).strftime("%c")
+  return IST
+
+
+def mime_identifier(filename):
+  import mimetypes
+  mime_type, encoding = mimetypes.guess_type(filename)
+
+  return mime_type
+
+
+def TimeFormatter(milliseconds: int) -> str:
+  seconds, milliseconds = divmod(int(milliseconds), 1000)
+  minutes, seconds = divmod(seconds, 60)
+  hours, minutes = divmod(minutes, 60)
+  days, hours = divmod(hours, 24)
+  tmp = ((str(days) + "d, ") if days else "") + \
+      ((str(hours) + "h, ") if hours else "") + \
+      ((str(minutes) + "m, ") if minutes else "") + \
+      ((str(seconds) + "s, ") if seconds else "") + \
+      ((str(milliseconds) + "ms, ") if milliseconds else "")
+  return tmp[:-2]

FileStream/__init__.py

@@ -0,0 +1,6 @@
+from FileStream.Tools import Time_ISTKolNow
+
+__version__ = "1.1.0"
+StartTime = Time_ISTKolNow()
+print("** Program starting at Indian Standard Time :", Time_ISTKolNow())
+

FileStream/__main__.py

@@ -0,0 +1,94 @@
+import sys
+import asyncio
+import logging
+import traceback
+import logging.handlers as handlers
+from FileStream.config import Telegram, Server
+from aiohttp import web
+from pyrogram import idle
+
+from FileStream.bot import FileStream
+from FileStream.Tools import Time_ISTKolNow
+from FileStream.server import web_server
+from FileStream.bot.clients import initialize_clients
+
+logging.basicConfig(
+    level=logging.INFO,
+    datefmt="%d/%m/%Y %H:%M:%S",
+    format=
+    '[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(stream=sys.stdout),
+        handlers.RotatingFileHandler("streambot.log",
+                                     mode="a",
+                                     maxBytes=104857600,
+                                     backupCount=2,
+                                     encoding="utf-8")
+    ],
+)
+
+logging.getLogger("aiohttp").setLevel(logging.ERROR)
+logging.getLogger("pyrogram").setLevel(logging.ERROR)
+logging.getLogger("aiohttp.web").setLevel(logging.ERROR)
+
+server = web.AppRunner(web_server())
+
+loop = asyncio.get_event_loop()
+
+
+async def start_services():
+  print()
+  if Telegram.SECONDARY:
+    print("------------------ Starting as Secondary Server ------------------")
+  else:
+    print("------------------- Starting as Primary Server -------------------")
+  print()
+  print("-------------------- Initializing Telegram Bot --------------------")
+
+  await FileStream.start()
+  bot_info = await FileStream.get_me()
+  FileStream.id = bot_info.id
+  FileStream.username = bot_info.username
+  FileStream.fname = bot_info.first_name
+  print("------------------------------ DONE ------------------------------")
+  print()
+  print("---------------------- Initializing Clients ----------------------")
+  await initialize_clients()
+  print("------------------------------ DONE ------------------------------")
+  print()
+  print("--------------------- Initializing Web Server ---------------------")
+  await server.setup()
+  await web.TCPSite(server, Server.BIND_ADDRESS, Server.PORT).start()
+  print("------------------------------ DONE ------------------------------")
+  print()
+  print("------------------------- Service Started -------------------------")
+  print("Bot =>> {}".format(bot_info.first_name))
+  if bot_info.dc_id:
+    print("DC ID =>> {}".format(str(bot_info.dc_id)))
+  print(" URL =>> {}".format(Server.URL))
+  print("------------------------------------------------------------------")
+  """
+  all_sources = [
+      Telegram.ULOG_GROUP, Telegram.FLOG_CHANNEL, Telegram.PFLOG_CHANNEL
+  ]
+  for source in all_sources:
+    await FileStream.send_message(chat_id=source,
+                                  text=f"Hi, I am Online @{ISTKolNow()}",
+                                  disable_web_page_preview=True)
+  """
+  await idle()
+
+
+async def cleanup():
+  await server.cleanup()
+  await FileStream.stop()
+
+
+if __name__ == "__main__":
+  try:
+    loop.run_until_complete(start_services())
+  except KeyboardInterrupt:
+    loop.stop()
+    print("------------------------ Stopped Services ------------------------")
+  except Exception as err:
+    logging.error(traceback.format_exc())

FileStream/bot/__init__.py

@@ -0,0 +1,28 @@
+from ..config import Telegram
+from pyrogram import Client
+
+if Telegram.SECONDARY:
+  plugins = None
+  no_updates = True
+else:
+  plugins = dict(root="FileStream/bot/plugins")
+  no_updates = None
+
+FileStream = Client(name="FileStream",
+                    api_id=Telegram.API_ID,
+                    api_hash=Telegram.API_HASH,
+                    workdir="FileStream",
+                    plugins=plugins,
+                    bot_token=Telegram.BOT_TOKEN,
+                    sleep_threshold=Telegram.SLEEP_THRESHOLD,
+                    workers=Telegram.WORKERS,
+                    no_updates=no_updates)
+
+multi_clients = {}
+work_loads = {}
+
+async def req_client():
+  index = min(work_loads, key=work_loads.get)
+  faster_client = multi_clients[index]
+  response = dict(index=index, client=faster_client)
+  return response

FileStream/bot/clients.py

@@ -0,0 +1,59 @@
+import asyncio
+import logging
+from os import environ
+from ..config import Telegram
+from pyrogram import Client
+from . import multi_clients, work_loads, FileStream
+
+
+async def initialize_clients():
+    all_tokens = dict(
+        (c + 1, t)
+        for c, (_, t) in enumerate(
+            filter(
+                lambda n: n[0].startswith("MULTI_TOKEN"), sorted(environ.items())
+            )
+        )
+    )
+    if not all_tokens:
+        multi_clients[0] = FileStream
+        work_loads[0] = 0
+        print("No additional clients found, using default client")
+        return
+    
+    async def start_client(client_id, token):
+        try:
+            if len(token) >= 100:
+                session_string=token
+                bot_token=None
+                print(f'Starting Client - {client_id} Using Session String')
+            else:
+                session_string=None
+                bot_token=token
+                print(f'Starting Client - {client_id} Using Bot Token')
+            if client_id == len(all_tokens):
+                await asyncio.sleep(2)
+                print("This will take some time, please wait...")
+            client = await Client(
+                name=str(client_id),
+                api_id=Telegram.API_ID,
+                api_hash=Telegram.API_HASH,
+                bot_token=bot_token,
+                sleep_threshold=Telegram.SLEEP_THRESHOLD,
+                no_updates=True,
+                session_string=session_string,
+                in_memory=True,
+            ).start()
+            client.id = (await client.get_me()).id
+            work_loads[client_id] = 0
+            return client_id, client
+        except Exception:
+            logging.error(f"Failed starting Client - {client_id} Error:", exc_info=True)
+    
+    clients = await asyncio.gather(*[start_client(i, token) for i, token in all_tokens.items()])
+    multi_clients.update(dict(clients))
+    if len(multi_clients) != 1:
+        Telegram.MULTI_CLIENT = True
+        print("Multi-Client Mode Enabled")
+    else:
+        print("No additional clients were initialized, using default client")

FileStream/bot/plugins/Admin/admin.py

@@ -0,0 +1,197 @@
+import os
+import time
+import string
+import random
+import asyncio
+import aiofiles
+import datetime
+
+from FileStream.utils.FileProcessors.broadcast_helper import send_msg
+from FileStream.Database import Database
+from FileStream.bot import FileStream
+from FileStream.server.exceptions import FIleNotFound
+from FileStream.config import Telegram, Server
+from pyrogram import filters, Client
+from pyrogram.types import Message
+from pyrogram.enums.parse_mode import ParseMode
+
+db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+broadcast_ids = {}
+
+
+#Authorize User to Use the Services
+@FileStream.on_message(filters.command("auth") & filters.private & filters.user(Telegram.OWNER_ID))
+async def sts(c: Client, m: Message):
+  await m.reply_text(
+      text=f"""**Total Users in DB:** `{await db.total_users_count()}`
+**Banned Users in DB:** `{await db.total_banned_users_count()}`
+**Total Links Generated: ** `{await db.total_files()}`""",
+      parse_mode=ParseMode.MARKDOWN,
+      quote=True)
+
+@FileStream.on_message(filters.command("add_user") & filters.private )
+async def add_user(c: Client, m: Message):
+  if await db.is_admin(m.from_user.id):
+    if len(m.command) == 1:
+      return await m.reply_text("**Usage:**\n /add_user <user_id>")
+    try:
+      user_id = int(m.command[1])
+    except ValueError or UnboundLocalError:
+      return await m.reply_text(f"**Usage:**\n <code> /add_admin <{user_id}> </code> ")
+    await db.add_user(user_id)
+    await m.reply_text(f"**User[{m.from_user.first_name} {m.from_user.last_name}] \n  User ID : {user_id} Added Successfully**")
+  else:
+    await m.reply_text(f"** Sorry Sir {user_id} You are not Admin **")
+  
+@FileStream.on_message(filters.command("add_admin") &  filters.user(Telegram.OWNER_ID) )
+async def add_user(c: Client, m: Message):
+  if await db.is_admin(m.from_user.id):
+    if len(m.command) == 1:
+      return await m.reply_text(f"**Usage:**\n <code> /add_admin <user_id> </code>")
+    try:
+      user_id = int(m.command[1])
+    except ValueError or UnboundLocalError:
+      return await m.reply_text(f"**Usage:**\n <code> /add_admin <{user_id}> </code>")
+    await db.add_admin(user_id)
+    await m.reply_text(f"**Admin [{m.from_user.first_name} {m.from_user.last_name}]\n  {user_id} Added Successfully**")
+  else:
+    await m.reply_text(f"** Sorry Sir [{m.from_user.first_name} {m.from_user.last_name}] {user_id} You are not Admin **")
+  
+  
+@FileStream.on_message(filters.command("status") & filters.private & filters.user(Telegram.OWNER_ID))
+async def sts(c: Client, m: Message):
+  await m.reply_text(
+      text=f"""**Total Users in DB:** `{await db.total_users_count()}`
+**Banned Users in DB:** `{await db.total_banned_users_count()}`
+**Total Links Generated: ** `{await db.total_files()}`""",
+      parse_mode=ParseMode.MARKDOWN,
+      quote=True)
+
+
+@FileStream.on_message(filters.command("ban") & filters.private & filters.user(Telegram.OWNER_ID))
+async def sts(b, m: Message):
+  id = m.text.split("/ban ")[-1]
+  if not await db.is_user_banned(int(id)):
+    try:
+      await db.ban_user(int(id))
+      await db.delete_user(int(id))
+      await m.reply_text(text=f"`{id}`** is Banned** ",
+                         parse_mode=ParseMode.MARKDOWN,
+                         quote=True)
+      if not str(id).startswith('-100'):
+        await b.send_message(chat_id=id,
+                             text="**Your Banned to Use The Bot**",
+                             parse_mode=ParseMode.MARKDOWN,
+                             disable_web_page_preview=True)
+    except Exception as e:
+      await m.reply_text(text=f"**something went wrong: {e}** ",
+                         parse_mode=ParseMode.MARKDOWN,
+                         quote=True)
+  else:
+    await m.reply_text(text=f"`{id}`** is Already Banned** ",
+                       parse_mode=ParseMode.MARKDOWN,
+                       quote=True)
+
+
+@FileStream.on_message(filters.command("unban") & filters.private & filters.user(Telegram.OWNER_ID))
+async def sts(b, m: Message):
+  id = m.text.split("/unban ")[-1]
+  if await db.is_user_banned(int(id)):
+    try:
+      await db.unban_user(int(id))
+      await m.reply_text(text=f"`{id}`** is Unbanned** ",
+                         parse_mode=ParseMode.MARKDOWN,
+                         quote=True)
+      if not str(id).startswith('-100'):
+        await b.send_message(chat_id=id,
+                             text="**Your Unbanned now Use can use The Bot**",
+                             parse_mode=ParseMode.MARKDOWN,
+                             disable_web_page_preview=True)
+    except Exception as e:
+      await m.reply_text(text=f"** something went wrong: {e}**",
+                         parse_mode=ParseMode.MARKDOWN,
+                         quote=True)
+  else:
+    await m.reply_text(text=f"`{id}`** is not Banned** ",
+                       parse_mode=ParseMode.MARKDOWN,
+                       quote=True)
+
+
+@FileStream.on_message(
+    filters.command("broadcast") & filters.private
+    & filters.user(Telegram.OWNER_ID) & filters.reply)
+async def broadcast_(c, m):
+  all_users = await db.get_all_users()
+  broadcast_msg = m.reply_to_message
+  while True:
+    broadcast_id = ''.join(
+        [random.choice(string.ascii_letters) for i in range(3)])
+    if not broadcast_ids.get(broadcast_id):
+      break
+  out = await m.reply_text(
+      text=
+      f"Broadcast initiated! You will be notified with log file when all the users are notified."
+  )
+  start_time = time.time()
+  total_users = await db.total_users_count()
+  done = 0
+  failed = 0
+  success = 0
+  broadcast_ids[broadcast_id] = dict(total=total_users,
+                                     current=done,
+                                     failed=failed,
+                                     success=success)
+  async with aiofiles.open('broadcast.txt', 'w') as broadcast_log_file:
+    async for user in all_users:
+      sts, msg = await send_msg(user_id=int(user['id']), message=broadcast_msg)
+      if msg is not None:
+        await broadcast_log_file.write(msg)
+      if sts == 200:
+        success += 1
+      else:
+        failed += 1
+      if sts == 400:
+        await db.delete_user(user['id'])
+      done += 1
+      if broadcast_ids.get(broadcast_id) is None:
+        break
+      else:
+        broadcast_ids[broadcast_id].update(
+            dict(current=done, failed=failed, success=success))
+        try:
+          await out.edit_text(
+              f"Broadcast Status\n\ncurrent: {done}\nfailed:{failed}\nsuccess: {success}"
+          )
+        except:
+          pass
+  if broadcast_ids.get(broadcast_id):
+    broadcast_ids.pop(broadcast_id)
+  completed_in = datetime.timedelta(seconds=int(time.time() - start_time))
+  await asyncio.sleep(3)
+  await out.delete()
+  if failed == 0:
+    await m.reply_text(
+        text=
+        f"broadcast completed in `{completed_in}`\n\nTotal users {total_users}.\nTotal done {done}, {success} success and {failed} failed.",
+        quote=True)
+  else:
+    await m.reply_document(
+        document='broadcast.txt',
+        caption=
+        f"broadcast completed in `{completed_in}`\n\nTotal users {total_users}.\nTotal done {done}, {success} success and {failed} failed.",
+        quote=True)
+  os.remove('broadcast.txt')
+
+
+@FileStream.on_message(
+    filters.command("del") & filters.private & filters.user(Telegram.OWNER_ID))
+async def sts(c: Client, m: Message):
+  file_id = m.text.split(" ")[-1]
+  try:
+    file_info = await db.get_file(file_id)
+  except FIleNotFound:
+    await m.reply_text(text=f"**File Already Deleted**", quote=True)
+    return
+  await db.delete_one_file(file_info['_id'])
+  await db.count_links(file_info['user_id'], "-")
+  await m.reply_text(text=f"**Fɪʟᴇ Dᴇʟᴇᴛᴇᴅ Sᴜᴄᴄᴇssғᴜʟʟʏ !** ", quote=True)

FileStream/bot/plugins/FileHandlers/callback.py

@@ -0,0 +1,584 @@
+import math
+import asyncio
+import datetime
+
+from pyrogram import filters, Client
+from pyrogram.errors import FloodWait
+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, multi_clients
+from FileStream.server.exceptions import FIleNotFound
+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
+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,
+    )
+  elif usr_cmd[0] == "pubup":
+    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": "PUBLIC",
+          "user_id": user_id,
+          "user_type": "TELEGRAM"
+      }
+      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)
+
+  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

FileStream/bot/plugins/FileHandlers/files.py

@@ -0,0 +1,171 @@
+import math
+import asyncio
+import logging
+from pyrogram import filters, Client
+from pyrogram.types import BotCommand
+from pyrogram.enums.parse_mode import ParseMode
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton, ReplyKeyboardMarkup, KeyboardButton, Message, InlineQueryResultArticle, InputTextMessageContent, InlineQueryResultPhoto
+from pyrogram.types import InlineQueryResultVideo, InlineQueryResultAudio, InlineQueryResultCachedDocument,WebAppInfo
+#----------------------------Local Imports ---------------------#
+from FileStream import __version__
+from FileStream.bot import FileStream
+from FileStream.config import Telegram
+from FileStream.Database import Database
+from FileStream.server.exceptions import FIleNotFound
+from FileStream.utils.FileProcessors.human_readable import humanbytes
+from FileStream.utils.FileProcessors.bot_utils import gen_linkx, verify_user, verify_users
+from FileStream.utils.FileProcessors.translation import LANG, BUTTON
+
+# Set new commands
+
+db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+
+
+#----------------------------search Commands ---------------------#
+@FileStream.on_message((filters.command('search') & filters.private) | (filters.regex("ꜱᴇᴀʀᴄʜ")  & filters.private))
+@verify_users
+async def search_files(bot: Client, message: Message, response):
+
+  await message.reply(text="ꜱᴇᴀʀᴄʜ ɪɴ ᴘᴜʙʟɪᴄ ꜰɪʟᴇꜱ",
+                      reply_markup=InlineKeyboardMarkup([[
+                          InlineKeyboardButton(
+                              'Search', switch_inline_query_current_chat='')
+                      ]]))
+
+@FileStream.on_message(filters.command("webview"))
+@verify_users
+async def send_webview_button(bot: Client, message: Message, response):
+    # Define the inline keyboard with a button that opens a web page
+    webapp_button = InlineKeyboardMarkup(
+        [
+            [InlineKeyboardButton("Open WebApp", web_app=WebAppInfo(url="https://youtube.com"))]
+        ]
+    )
+
+    await message.reply_text(
+        "Click the button below to open the WebApp:",
+        reply_markup=webapp_button
+    
+    )
+#-------------------------Files---------------------------------#
+@FileStream.on_message((filters.command('files') & filters.private) | (filters.regex("ᴍʏ ᴘᴜʙʟɪᴄ ꜰɪʟᴇꜱ") & filters.private))
+@verify_users
+async def my_files(bot: Client, message: Message, response):
+
+  user_files, total_files = await db.find_files(message.from_user.id, [1, 10])
+
+  file_list = []
+  async for x in user_files:
+    file_list.append([
+        InlineKeyboardButton(f"📦 {x['file']['caption']}",
+                             callback_data=f"myfile_{x['_id']}_{1}")
+    ])
+  if total_files > 10:
+    file_list.append([
+        InlineKeyboardButton("◄", callback_data="N/A"),
+        InlineKeyboardButton(f"1/{math.ceil(total_files / 10)}",
+                             callback_data="N/A"),
+        InlineKeyboardButton("►", callback_data="userfiles_2")
+    ], )
+  if not file_list:
+    file_list.append([InlineKeyboardButton("ᴇᴍᴘᴛʏ", callback_data="N/A")], )
+  file_list.append([InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")])
+  await message.reply_photo(photo=Telegram.FILE_PIC,
+                              caption="Total files: {}".format(total_files),
+                              reply_markup=InlineKeyboardMarkup(file_list))
+
+
+# -----------------------------Bot Private Files Command -----------------------------------------------#
+@FileStream.on_message((filters.command('myfiles') & filters.private) | (filters.regex("ᴘʀɪᴠᴀᴛᴇ ꜱᴘᴀᴄᴇ") & filters.private))
+@verify_users
+async def my_privfiles(bot: Client, message: Message, response):
+  user_files, total_files = await db.find_private_files(
+      message.from_user.id, [1, 10])
+
+  file_list = []
+  async for x in user_files:
+    file_list.append([
+        InlineKeyboardButton(f" 📦 {x['file']['caption']}",callback_data=f"myprivfile_{x['_id']}_{1}")
+    ])
+  if total_files > 10:
+    file_list.append([
+        InlineKeyboardButton("◄", callback_data="N/A"),
+        InlineKeyboardButton(f"1/{math.ceil(total_files / 10)}",
+                             callback_data="N/A"),
+        InlineKeyboardButton("►", callback_data="userfiles_2")
+    ], )
+  if not file_list:
+    file_list.append([InlineKeyboardButton("ᴇᴍᴘᴛʏ", callback_data="N/A")], )
+  file_list.append([InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")])
+  await message.reply_photo(photo=Telegram.FILE_PIC,
+                            caption="Total files: {}".format(total_files),
+                            reply_markup=InlineKeyboardMarkup(file_list))
+
+
+# -----------------------------Bot All Available Files Command ----------------------------------------#
+@FileStream.on_message((filters.command('filebank') & filters.private) | (filters.regex("ꜰɪʟᴇ ʙᴀɴᴋ") & filters.private))
+@verify_users
+async def my_filebank(bot: Client, message: Message, response):
+
+  if await db.is_admin(message.from_user.id):
+    user_files, total_files = await db.find_all_files([1, 10])
+  else:
+    user_files, total_files = await db.find_all_public_files([1, 10])
+
+  file_list = []
+  async for x in user_files:
+    file_list.append([
+        InlineKeyboardButton(f"📦 {x['file']['caption']}",callback_data=f"allfile_{x['_id']}_{1}")])
+  if total_files > 10:
+    file_list.append([
+        InlineKeyboardButton("◄", callback_data="N/A"),
+        InlineKeyboardButton(f"1/{math.ceil(total_files / 10)}",
+                             callback_data="N/A"),
+        InlineKeyboardButton("►", callback_data="userallfiles_2")
+    ], )
+  if not file_list:
+    file_list.append([InlineKeyboardButton("ᴇᴍᴘᴛʏ", callback_data="N/A")], )
+  file_list.append([InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")])
+
+  await message.reply_photo(photo=Telegram.FILE_PIC,
+                            caption="Total files: {}".format(total_files),
+                            reply_markup=InlineKeyboardMarkup(file_list))
+
+
+@FileStream.on_inline_query()
+async def handle_inline_query(client, query):
+  results = []
+  if '|' in query.query:
+    text, file_type = query.query.split('|', maxsplit=1)
+    text = text.strip()
+    file_type = file_type.strip().lower()
+  else:
+    text = query.query.strip()
+    file_type = None
+  offset = int(query.offset or 0)
+  files, next_offset = await db.get_search_results(text,file_type=file_type,max_results=10,offset=offset)
+  for file in files:
+    results.append(
+        InlineQueryResultCachedDocument(
+            title=file['file']['file_name'],
+            document_file_id=file['file']['file_id'],
+            caption=file['file']['file_name'] or "",
+            description=
+            f" Size: {humanbytes(file['file']['file_size'])}\nType:{file['file']['mime_type']} ",
+            reply_markup=InlineKeyboardMarkup([[
+                InlineKeyboardButton('Search',
+                                     switch_inline_query_current_chat='')
+            ]])))
+  if results:
+    switch_pm_text = f"Results"
+    if text:
+      switch_pm_text += f" for {text}"
+
+    await query.answer(results=results, cache_time=300, switch_pm_text=str(switch_pm_text), switch_pm_parameter="start", next_offset=str(next_offset) )
+  else:
+    switch_pm_text = f'No results'
+    if text:
+      switch_pm_text += f' for "{text}"'
+
+    await query.answer(results=[],cache_time=300,switch_pm_text=switch_pm_text,switch_pm_parameter="okay")
+  #await inline_query.answer(results=result)

FileStream/bot/plugins/FileHandlers/stream.py

@@ -0,0 +1,238 @@
+import os
+import sys
+import random
+import urllib3
+import logging
+import asyncio
+import traceback
+import mimetypes
+import time, math
+from datetime import datetime
+from typing import Dict, Union
+from typing import Union, BinaryIO, List, Optional, Callable
+
+from pyrogram import raw
+from pyrogram import types
+from pyrogram import filters, Client
+from pyrogram import utils as pgutils
+from pyrogram import StopTransmission, enums
+from pyrogram import Client, utils, raw
+
+from pyrogram.file_id import FileType
+from pyrogram.session import Session, Auth
+from pyrogram.enums import ParseMode, ChatType
+from pyrogram.enums.parse_mode import ParseMode
+from pyrogram.file_id import FileId, FileType, ThumbnailSource
+from pyrogram.errors import FilePartMissing, AuthBytesInvalid, FloodWait
+from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
+
+#--------------------------Local Imports-------------#
+
+from FileStream.Database import Database
+from FileStream.config import Telegram, Server
+from FileStream.Tools.tool import TimeFormatter
+from FileStream.Tools.progress import progress
+from FileStream.bot import FileStream, multi_clients, work_loads, req_client
+from FileStream.utils.FileProcessors.bot_utils import is_user_banned, is_user_exist, is_user_joined, gen_link, is_channel_banned, is_channel_exist, is_user_authorized, upload_type_func
+from FileStream.utils.FileProcessors.custom_dl import ByteStreamer
+from FileStream.utils.FileProcessors.custom_ul import  TeleUploader
+from FileStream.utils.FileProcessors.custom_mix import TGFileController
+from FileStream.utils.FileProcessors.translation import LANG, BUTTON
+from FileStream.utils.FileProcessors.human_readable import humanbytes
+from FileStream.utils.FileProcessors.file_properties import get_file_ids, get_file_info, get_private_file_ids
+
+db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+
+
+@FileStream.on_message(filters.private & (filters.document  | filters.video   | filters.video_note   | filters.audio   | filters.voice   | filters.animation   | filters.photo),    group=4,)
+async def private_receive_handler(bot: Client, message: Message):
+
+    try:
+        """
+        //All Values Generated Here is Decided in get_file_info () so No Need of this Block
+        message_id = message.id
+        if message.chat.type == ChatType.PRIVATE:
+        user_idx = message.from_user.id
+        else:
+        user_idx = message.chat.id
+        """
+        #For First Set All Files PUBLIC
+        instruction = {
+            "privacy_type":"PUBLIC",
+            "user_id":message.from_user.id if (message.chat.type == ChatType.PRIVATE) else message.chat.id,
+            "user_type": "TELEGRAM"
+        }
+        reply_markup, stream_text = await upload_type_func(get_file_info(message, instruction))
+        await message.reply_text(text=stream_text,
+                                 parse_mode=ParseMode.HTML,
+                                 disable_web_page_preview=True,
+                                 reply_markup=reply_markup,
+                                 quote=True)
+    except FloodWait as e:
+        print(f"Sleeping for {str(e.value)}s")
+        await asyncio.sleep(e.value)
+        await bot.send_message(
+            chat_id=Telegram.ULOG_CHANNEL,
+            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)
+
+
+@FileStream.on_message(filters.channel & ~filters.forwarded & ~filters.media_group & (filters.document  | filters.video  | filters.video_note  | filters.audio  | filters.voice  | filters.photo))
+async def channel_receive_handler(bot: Client, message: Message):
+    if await is_channel_banned(bot, message):
+        return
+    await is_channel_exist(bot, message)
+
+    try:
+        inserted_id = await db.add_file(get_file_info(message))
+        await get_file_ids(False, inserted_id, multi_clients, message)
+        reply_markup, stream_link = await gen_link(_id=inserted_id)
+        await bot.edit_message_reply_markup(
+            chat_id=message.chat.id,
+            message_id=message.id,
+            reply_markup=InlineKeyboardMarkup([[
+                InlineKeyboardButton(
+                    "Dᴏᴡɴʟᴏᴀᴅ ʟɪɴᴋ 📥",
+                    url=
+                    f"https://t.me/{FileStream.username}?start=stream_{str(inserted_id)}"
+                )
+            ]]))
+
+    except FloodWait as w:
+        print(f"Sleeping for {str(w.x)}s")
+        await asyncio.sleep(w.x)
+        await bot.send_message(
+            chat_id=Telegram.ULOG_GROUP,
+            text=
+            f"ɢᴏᴛ ғʟᴏᴏᴅᴡᴀɪᴛ ᴏғ {str(w.x)}s ғʀᴏᴍ {message.chat.title}\n\n**ᴄʜᴀɴɴᴇʟ ɪᴅ :** `{str(message.chat.id)}`",
+            disable_web_page_preview=True)
+    except Exception as e:
+        exc_type, exc_obj, exc_tb = sys.exc_info()
+        await bot.send_message(chat_id=Telegram.ULOG_GROUP,
+                               text=f"**#EʀʀᴏʀTʀᴀᴄᴋᴇʙᴀᴄᴋ:** `{e} {exc_type, fname, exc_tb.tb_lineno}`",
+                               disable_web_page_preview=True)
+        print(
+            f"Cᴀɴ'ᴛ Eᴅɪᴛ Bʀᴏᴀᴅᴄᴀsᴛ Mᴇssᴀɢᴇ!\nEʀʀᴏʀ:  **Gɪᴠᴇ ᴍᴇ ᴇᴅɪᴛ ᴘᴇʀᴍɪssɪᴏɴ ɪɴ ᴜᴘᴅᴀᴛᴇs ᴀɴᴅ ʙɪɴ Cʜᴀɴɴᴇʟ!{e}**"
+        )
+
+
+@FileStream.on_message(filters.reply)
+async def reply_handler(
+    bot: Client,
+    message: Message,
+    thumb: Union[str, BinaryIO] = None,
+):
+
+    replied_message = message.reply_to_message
+    resp = ["n", "no", "not"]
+    if replied_message.empty:
+        return
+    if replied_message.media:
+        return
+    text = message.text
+    try:
+        main_message = replied_message.reply_to_message
+        instruction = {
+            "privacy_type":"PRIVATE",
+            "user_id":message.from_user.id if (message.chat.type == ChatType.PRIVATE) else message.chat.id,
+            "user_type":"TELEGRAM"
+        }
+        #file_infos = get_file_info(main_message, instruction)
+        #All the Time Get_file_ids should be called before update privacy or else tagged_users will be {}
+        file_info = await db.update_privacy(get_file_info(main_message, instruction))
+
+        #file_info = await db.get_file_by_fileuniqueid_only(
+        #    file_infos['file']['file_unique_id'])
+        mime_type = file_info['file']['mime_type']
+        file_id = file_info['file']['file_id']
+        file_size = file_info['file']['file_size']
+        message_id = replied_message.id
+        user_idx = message.from_user.id if (message.chat.type == ChatType.PRIVATE) else message.chat.id
+
+        if text.lower() not in resp:
+            ext = mimetypes.guess_extension(mime_type)
+            file_info['file']['file_name'] = f"{message.text}{ext}"
+
+        #index = min(work_loads, key=work_loads.get)
+        #faster_client = multi_clients[index]
+        client=await req_client()
+        print(f"Using {client['index']} for {file_info['file']['file_name']}")
+        logging.info(f"Client {client['index']} is now serving {request.headers.get('X-FORWARDED-FOR',request.remote)}")
+
+
+        tg_connect = TGFileController(client['client'])
+        req_file_id = await tg_connect.get_file_properties(file_info['_id'], multi_clients)
+
+        start_time = time.time()
+        file = await tg_connect.upload_file(
+            index=client['index'],
+            file_id=req_file_id,
+            file_name=file_info['file']['file_name'],
+            file_size=file_info['file']['file_size'],
+            progress=progress,
+            progress_args=(replied_message, file_info['file']['file_name'],
+                           file_info['file']['file_size'], start_time))
+
+        success_text = LANG.SUCCESS_PRIV_FILE.format(
+            file_info['file']['file_name'], humanbytes(file_size))
+        await replied_message.edit_text(
+            text=success_text,
+            parse_mode=ParseMode.HTML,
+            disable_web_page_preview=True,
+        )
+
+        media = raw.types.InputMediaUploadedDocument(
+            mime_type=mime_type,
+            file=file,
+            force_file=False,
+            thumb=thumb,
+            attributes=[
+                raw.types.DocumentAttributeFilename(
+                    file_name=file_info['file']['file_name'])
+            ])
+        message_txt = f"* File Name: { file_info['file']['file_name']} \n* File Size :{humanbytes(file_info['file']['file_size'])} \n\n🔔 ᴛʜɪꜱ ꜰɪʟᴇ ɪꜱ ᴜᴘʟᴏᴀᴅᴇᴅ ᴛᴏ ᴘʀɪᴠᴀᴛᴇ ꜱᴘᴀᴄᴇ ʙʏ @ꜱᴘᴀʀᴋᴅʀɪᴠᴇ_ʙᴏᴛ"
+
+        send_file = await tg_connect.send(media=media,
+                                          caption=message_txt,
+                                          reply_to_msg_id=None,
+                                          chat_id=Telegram.PFLOG_CHANNEL)
+
+        reply_markup, stream_text = await gen_link(_id=file_info['_id'])
+        await replied_message.edit_text(
+            text=f"{message_txt}\n{stream_text}",
+            parse_mode=ParseMode.HTML,
+            disable_web_page_preview=True,
+            reply_markup=reply_markup,
+        )
+        instruction = {
+            "privacy_type":"PRIVATE",
+            "user_id":message.from_user.id if(message.chat.type == ChatType.PRIVATE) else message.chat.id,
+            "user_type":"TELEGRAM",
+            "REUPLOADED":"True"
+        }
+        file_info = get_file_info(send_file, instruction)
+        file_info['reupload']="True"
+        # Here we are Adding the File Into the database First
+        await db.add_private_file(file_info)
+        #await get_private_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)
+
+    except FloodWait as w:
+        print(f"Sleeping for {str(w.wait_time)}s")
+        await asyncio.sleep(w.wait_time)
+        await bot.send_message(
+            chat_id=Telegram.ULOG_GROUP,
+            text=
+            f"ɢᴏᴛ ғʟᴏᴏᴅᴡᴀɪᴛ ᴏғ {str(w.x)}s ғʀᴏᴍ {message.chat.title}\n\n**ᴄʜᴀɴɴᴇʟ ɪᴅ :** `{str(message.chat.id)}`",
+            disable_web_page_preview=True)
+
+    except Exception as e:
+        exc_type, exc_obj, exc_tb = sys.exc_info()
+        await bot.send_message(chat_id=Telegram.ULOG_GROUP,
+                               text=f"**#EʀʀᴏʀTʀᴀᴄᴋᴇʙᴀᴄᴋ:** `{e} {exc_type, fname, exc_tb.tb_lineno}`",
+                               disable_web_page_preview=True)
+        print(f"Cᴀɴ'ᴛ Eᴅɪᴛ Bʀᴏᴀᴅᴄᴀsᴛ Mᴇssᴀɢᴇ!\nEʀʀᴏʀ:  **Gɪᴠᴇ ᴍᴇ ᴇᴅɪᴛ ᴘᴇʀᴍɪssɪᴏɴ ɪɴ ᴜᴘᴅᴀᴛᴇs ᴀɴᴅ ʙɪɴ Cʜᴀɴɴᴇʟ!{traceback.print_exc()}  (upload_file)**")
+        #await db.delete_one_privfile(inserted_id)

FileStream/bot/plugins/startup.py

@@ -0,0 +1,134 @@
+import math
+import logging
+import asyncio
+import traceback
+from pyrogram import filters, Client
+from pyrogram.enums.parse_mode import ParseMode
+from pyrogram.types import BotCommand, Message, ReplyKeyboardMarkup, InlineKeyboardMarkup, InlineKeyboardButton
+
+from FileStream import __version__
+from FileStream.bot import FileStream
+from FileStream.server.exceptions import FIleNotFound
+from FileStream.utils.FileProcessors.bot_utils import gen_linkx, verify_user, verify_users
+from FileStream.config import Telegram
+from FileStream.Database import Database
+from FileStream.utils.FileProcessors.translation import LANG, BUTTON
+
+db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+
+
+async def menu(bot, message):
+  await bot.send_message(
+      chat_id=message.from_user.id,
+      text="ꜱᴇʟᴇᴄᴛ ꜰʀᴏᴍ ᴍᴇɴᴜ",
+      reply_markup=ReplyKeyboardMarkup(
+          [[("ꜰɪʟᴇ ʙᴀɴᴋ"),("ꜱᴇᴀʀᴄʜ")], [("ᴍʏ ᴘʀɪᴠᴀᴛᴇ ꜱᴘᴀᴄᴇ"), ("ᴍʏ ᴘᴜʙʟɪᴄ ꜰɪʟᴇꜱ")]],
+          one_time_keyboard=False,
+          resize_keyboard=True,
+          placeholder="🄼🄰🄸🄽 🄼🄴🄽🅄 👉"))
+
+
+@FileStream.on_message(filters.command('start') & filters.private)
+@verify_users
+async def start(bot: Client, message: Message, response):
+  if response['status'] == "AUTHORIZED":
+    usr_cmd = message.text.split("_")[-1]
+    if usr_cmd == "/start":
+      await bot.set_bot_commands([
+          BotCommand("start", "ꜱᴛᴀʀᴛ ᴛʜᴇ ʙᴏᴛ"),
+          BotCommand("help", "ʙᴏᴛ ꜱᴇᴛᴛɪɴɢꜱ"),
+          BotCommand("about", "ᴀʙᴏᴜᴛ ᴛʜᴇ ʙᴏᴛ"),
+          BotCommand("search", "ꜱᴇᴀʀᴄʜ ɪɴ ᴘᴜʙʟɪᴄ ꜰɪʟᴇꜱ"),
+          BotCommand("filebank", "ꜰɪʟᴇ ʙᴀɴᴋ"),
+          BotCommand("files", "ᴍʏ ᴘᴜʙʟɪᴄ ꜰɪʟᴇꜱ"),
+          BotCommand("myfiles", "ᴍʏ ᴘʀɪᴠᴀᴛᴇ ꜱᴘᴀᴄᴇ"),
+      ])
+      await menu(bot, message)
+      if Telegram.START_PIC:
+        await message.reply_photo(photo=Telegram.START_PIC,
+                                  caption=LANG.START_TEXT.format(
+                                      message.from_user.mention,
+                                      FileStream.username),
+                                  parse_mode=ParseMode.HTML,
+                                  reply_markup=BUTTON.START_BUTTONS)
+      else:
+        await message.reply_text(text=LANG.START_TEXT.format(
+            message.from_user.mention, FileStream.username),
+                                 parse_mode=ParseMode.HTML,
+                                 disable_web_page_preview=True,
+                                 reply_markup=BUTTON.START_BUTTONS)
+    else:
+      if "stream_" in message.text:
+        try:
+          file_check = await db.get_file(usr_cmd)
+          file_id = str(file_check['_id'])
+          if file_id == usr_cmd:
+            reply_markup, stream_text = await gen_linkx(
+                m=message,
+                _id=file_id,
+                name=[FileStream.username, FileStream.fname])
+            await message.reply_text(text=stream_text,
+                                     parse_mode=ParseMode.HTML,
+                                     disable_web_page_preview=True,
+                                     reply_markup=reply_markup,
+                                     quote=True)
+
+        except FIleNotFound as e:
+          await message.reply_text("File Not Found")
+        except Exception as e:
+          await message.reply_text("Something Went Wrong")
+          logging.error(e)
+
+      elif "file_" in message.text:
+        try:
+          file_check = await db.get_file(usr_cmd)
+          db_id = str(file_check['_id'])
+          file_id = file_check['file']['file_id']
+          file_name = file_check['file']['file_name']
+          if db_id == usr_cmd:
+            filex = await message.reply_cached_media(
+                file_id=file_id, caption=f'**{file_name}**')
+            await asyncio.sleep(3600)
+            try:
+              await filex.delete()
+              await message.delete()
+            except Exception:
+              pass
+
+        except FIleNotFound as e:
+          await message.reply_text("**File Not Found**")
+        except Exception as e:
+          await message.reply_text("Something Went Wrong")
+          logging.error(e)
+
+      else:
+        await message.reply_text(f"**Invalid Command**")
+
+
+@FileStream.on_message(filters.private & filters.command(["about"]))
+async def about_handler(bot, message):
+  if Telegram.START_PIC:
+    await message.reply_photo(photo=Telegram.START_PIC,
+                              caption=LANG.ABOUT_TEXT.format(
+                                  FileStream.fname, __version__),
+                              parse_mode=ParseMode.HTML,
+                              reply_markup=BUTTON.ABOUT_BUTTONS)
+  else:
+    await message.reply_text(text=LANG.ABOUT_TEXT.format(
+        FileStream.fname, __version__),
+                             disable_web_page_preview=True,
+                             reply_markup=BUTTON.ABOUT_BUTTONS)
+
+
+@FileStream.on_message((filters.command('help')) & filters.private)
+async def help_handler(bot, message):
+  if Telegram.START_PIC:
+    await message.reply_photo(photo=Telegram.START_PIC,
+                              caption=LANG.HELP_TEXT.format(Telegram.OWNER_ID),
+                              parse_mode=ParseMode.HTML,
+                              reply_markup=BUTTON.HELP_BUTTONS)
+  else:
+    await message.reply_text(text=LANG.HELP_TEXT.format(Telegram.OWNER_ID),
+                             parse_mode=ParseMode.HTML,
+                             disable_web_page_preview=True,
+                             reply_markup=BUTTON.HELP_BUTTONS)

FileStream/config.py

@@ -0,0 +1,50 @@
+from os import environ as env
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class Telegram:
+    API_ID = int(env.get("API_ID"))
+    API_HASH = str(env.get("API_HASH"))
+    BOT_TOKEN = str(env.get("BOT_TOKEN"))
+    OWNER_ID = int(env.get('OWNER_ID', ''))
+    WORKERS = int(env.get("WORKERS", "6"))  # 6 workers = 6 commands at once
+    DATABASE_URL = str(env.get('DATABASE_URL'))
+    UPDATES_CHANNEL = str(env.get('UPDATES_CHANNEL', "SparkyForum"))
+    SESSION_NAME = str(env.get('SESSION_NAME', 'FileStream'))
+    FORCE_SUB_ID = env.get('FORCE_SUB_ID', None)
+    FORCE_SUB = env.get('FORCE_UPDATES_CHANNEL', False)
+    FORCE_SUB = True if str(FORCE_SUB).lower() == "true" else False
+    SLEEP_THRESHOLD = int(env.get("SLEEP_THRESHOLD", "60"))
+    FILE_PIC = env.get(
+      'FILE_PIC',
+      "https://graph.org/file/5bb9935be0229adf98b73.jpg")
+    START_PIC = env.get(
+      'START_PIC',
+      "https://graph.org/file/290af25276fa34fa8f0aa.jpg")
+    VERIFY_PIC = env.get(
+      'VERIFY_PIC',
+      "https://graph.org/file/736e21cc0efa4d8c2a0e4.jpg")
+    MULTI_CLIENT = False
+    FLOG_CHANNEL = int(env.get(
+      "FLOG_CHANNEL", None))  # Logs channel for file logs
+    PFLOG_CHANNEL = int(env.get("PFLOG_CHANNEL"))
+    ULOG_GROUP = int(env.get(
+      "ULOG_GROUP", None))  # Logs channel for user logs
+    MODE = env.get("MODE", "primary")
+    SECONDARY = True if MODE.lower() == "secondary" else False
+    AUTH_USERS = list(set(int(x)for x in str(env.get("AUTH_USERS", "")).split()))
+    DATA_SOURCES = [FLOG_CHANNEL, PFLOG_CHANNEL, ULOG_GROUP]
+
+class TMDB:
+  API = str(env.get("TMDB_API", ""))
+  
+class Server:
+  PORT = int(env.get("PORT", 7860))
+  BIND_ADDRESS = str(env.get("BIND_ADDRESS", "0.0.0.0"))
+  PING_INTERVAL = int(env.get("PING_INTERVAL", "1200"))
+  HAS_SSL = str(env.get("HAS_SSL","0").lower()) in ("1", "true", "t","yes", "y")
+  NO_PORT = str(env.get("NO_PORT","0").lower()) in ("1", "true", "t","yes", "y")
+  FQDN = str(env.get("FQDN", BIND_ADDRESS))
+  URL = str(env.get("URL", "https://privateone-tele_api.hf.space/"))

FileStream/server/Functions/downloader.py

@@ -0,0 +1,98 @@
+import os
+import time
+import math
+import logging
+import asyncio
+import traceback
+from aiohttp import web
+from pyrogram import raw
+
+from aiohttp.http_exceptions import BadStatusLine
+
+#---------------------Local Upload---------------------#
+
+from FileStream.config import Telegram
+from FileStream import utils, StartTime, __version__
+from FileStream.Tools import mime_identifier, Time_ISTKolNow
+from FileStream.bot import multi_clients, work_loads, req_client, FileStream
+from FileStream.server.exceptions import FIleNotFound, InvalidHash
+from FileStream.server.render_template import render_page, render_upload
+from FileStream.utils.FileProcessors.custom_ul import  TeleUploader
+
+class_cache={}
+
+
+async def media_streamer(request: web.Request, db_id: str):
+  range_header = request.headers.get("Range", 0)
+
+  #index = min(work_loads, key=work_loads.get)
+  #faster_client = multi_clients[index]
+  client = await req_client()
+
+  if Telegram.MULTI_CLIENT:
+    logging.info(f"Client {client['index']} is now serving {request.headers.get('X-FORWARDED-FOR',request.remote)}")
+
+  if client['client'] in class_cache:
+    tg_connect = class_cache[client['client']]
+    logging.debug(f"Using cached ByteStreamer object for client {client['index']}")
+  else:
+    logging.debug(f"Creating new ByteStreamer object for client {client['index']}")
+    tg_connect = utils.ByteStreamer(client['client'])
+    class_cache[client['client']] = tg_connect
+  logging.debug("before calling get_file_properties")
+  file_id = await tg_connect.get_file_properties(db_id, multi_clients)
+  logging.debug("after calling get_file_properties")
+
+  file_size = file_id.file_size
+
+  if range_header:
+    from_bytes, until_bytes = range_header.replace("bytes=", "").split("-")
+    from_bytes = int(from_bytes)
+    until_bytes = int(until_bytes) if until_bytes else file_size - 1
+  else:
+    from_bytes = request.http_range.start or 0
+    until_bytes = (request.http_range.stop or file_size) - 1
+
+  if (until_bytes > file_size) or (from_bytes < 0) or (until_bytes
+                                                       < from_bytes):
+    return web.Response(
+        status=416,
+        body="416: Range not satisfiable",
+        headers={"Content-Range": f"bytes */{file_size}"},
+    )
+
+  chunk_size = 512 * 1024
+  until_bytes = min(until_bytes, file_size - 1)
+
+  offset = from_bytes - (from_bytes % chunk_size)
+  first_part_cut = from_bytes - offset
+  last_part_cut = until_bytes % chunk_size + 1
+
+  req_length = until_bytes - from_bytes + 1
+  part_count = math.ceil(until_bytes / chunk_size) - math.floor(
+      offset / chunk_size)
+  body = tg_connect.yield_file(file_id, client['index'], offset, first_part_cut,
+                               last_part_cut, part_count, chunk_size)
+
+  mime_type = file_id.mime_type
+  file_name = utils.get_name(file_id)
+  disposition = "attachment"
+
+  if not mime_type:
+    mime_type = mimetypes.guess_type(
+        file_name)[0] or "application/octet-stream"
+
+  # if "video/" in mime_type or "audio/" in mime_type:
+  #     disposition = "inline"
+
+  return web.Response(
+      status=206 if range_header else 200,
+      body=body,
+      headers={
+          "Content-Type": f"{mime_type}",
+          "Content-Range": f"bytes {from_bytes}-{until_bytes}/{file_size}",
+          "Content-Length": str(req_length),
+          "Content-Disposition": f'{disposition}; filename="{file_name}"',
+          "Accept-Ranges": "bytes",
+      },
+  )

FileStream/server/__init__.py

@@ -0,0 +1,19 @@
+from aiohttp import web
+from .routes_main import routes
+from .routes_api import api
+from .routes_app import sub_app
+
+
+async def root_route_handler(request):
+    return web.json_response({"status": "alive", "message": "Server is running"})
+
+
+
+def web_server():
+    web_app = web.Application(client_max_size=500)
+    web_app.router.add_get('/', root_route_handler)
+    web_app.add_routes(routes)
+    web_app.add_subapp('/app', sub_app)
+    web_app.add_subapp('/api', api)
+    return web_app
+

FileStream/server/exceptions.py

@@ -0,0 +1,5 @@
+class InvalidHash(Exception):
+    message = "Invalid hash"
+
+class FIleNotFound(Exception):
+    message = "File not found"

FileStream/server/render_template.py

@@ -0,0 +1,40 @@
+import aiohttp
+import jinja2
+import urllib.parse
+from FileStream.config import Telegram, Server
+from FileStream.Database import Database
+from FileStream.Tools.file import humanbytes
+
+db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+
+
+async def render_page(db_id):
+  file_data = await db.get_file(db_id)
+  src = urllib.parse.urljoin(Server.URL, f'api/dl/{file_data["_id"]}')
+  file_size = humanbytes(file_data['file']['file_size'])
+  file_name = file_data['file']['file_name'].replace("_", " ")
+
+  if str((file_data['file']['mime_type']).split('/')[0].strip()) == 'video':
+    template_file = "FileStream/server/template/play.html"
+  else:
+    template_file = "FileStream/server/template/dl.html"
+    async with aiohttp.ClientSession() as s:
+      async with s.get(src) as u:
+        file_size = humanbytes(int(u.headers.get('Content-Length')))
+
+  with open(template_file) as f:
+    template = jinja2.Template(f.read())
+
+  return template.render(file_name=file_name,
+                         file_url=src,
+                         file_size=file_size)
+
+
+async def render_upload():
+
+  template_file = "FileStream/server/template/upload.html"
+
+  with open(template_file) as f:
+    template = jinja2.Template(f.read())
+
+  return template.render()

FileStream/server/routes_api.py

@@ -0,0 +1,179 @@
+import os
+
+import json
+import time
+import math
+import logging
+import asyncio
+import traceback
+from aiohttp import web
+from pyrogram import raw
+from bson import ObjectId
+from bson.json_util import dumps
+from aiohttp.http_exceptions import BadStatusLine
+
+from FileStream.bot import req_client
+from FileStream.config import Telegram,Server
+from FileStream.Database import Database
+from FileStream.TMDB.Endpoint import search_tmdb
+from FileStream.server.exceptions import FIleNotFound, InvalidHash
+
+from .Functions.downloader import media_streamer
+
+async def handle_v2(request):
+    return web.Response(text="Hello from app api!")
+
+async def list_all_files_db(request):
+  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+  files= await db.get_all_files_api()
+  #print(files, type(files))
+  return web.json_response(json.loads(dumps(files)))
+
+
+#api.router.add_get('/tmdb/list', list_all_files_tmdb)
+async def list_all_files_tmdb(request):
+  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+  files= await db.get_all_files()
+  #print(files)
+  response=[]
+  async for row in files:
+    print(row['file']['caption'])
+    try :
+      print("* Response",search_tmdb(row['file']['caption'] if row['file']['caption'] else row['file']['file_name']))
+      resp = search_tmdb( str(row['file']['caption']) if str(row['file']['caption']) else str(row['file']['file_name']))
+      if resp != None :
+        #resp= dict(resp)
+        print("TMDB Response :",resp)
+        response.append(resp)
+      else:
+        continue
+    except Exception as e:
+      print("Error ",e)
+      break
+    
+  #print(response)
+  # Convert Python data to JSON
+  #json_response = json.dumps(response).encode('utf-8')
+  # Return as aiohttp response using web.json_response
+  #return web.json_response(response)
+  return web.json_response(json.loads(dumps(response)))
+
+#api.router.add_get('/tmdb/files', list_all_files)
+async def list_all_files(request):
+  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+  files=await db.get_all_files_api()
+  #print(files[0])
+  """{"_id":
+  {"$oid":"664b9bee136af99d40f36ac4"},
+  "user_id":"780583126",
+  "user_type":"TELEGRAM",
+  "message_id":{"$numberInt":"230"},
+  "location":{"$numberLong":"-1001713565158"},
+  "file":{
+    "file_id":"BAACAgIAAx0EZiLt5gAD5mZLm_BFwLE0BtOz3x74uJVDMPyKAAIISAACVyEJSugUJlXYybnGHgQ",
+    "caption":"Godzilla x Kong: The New Empire (2024)IMDB  6.5/10..Audio - Hindi + English",
+    "file_unique_id":"AgADCEgAAlchCUo",
+    "file_name":"[Tg- @New_Movies_OnTG] Godzilla x Kong: The New Empire (2024.mkv",
+    "file_size":{"$numberInt":"1191876267"},
+    "mime_type":"video/x-matroska",
+    "tagged_users":{"780583126":"PUBLIC","908083534":"PUBLIC"}},
+    "time":"Tue May 21 00:22:28 2024",
+    "privacy_type":"PUBLIC",
+    "file_ids":{"7143040931":"BAACAgIAAx0CZiLt5gAD5mZLm_JkEd4FIhfPJMNx4yrn_ku2AAIISAACVyEJStMWKGOMGmA8HgQ","7137723582":"BAACAgIAAx0CZiLt5gAD5mZLm_L1n-OtIh2xs9VTfPg9ng-jAAIISAACVyEJSgwG7RQMGjI4HgQ","7186717764":"BAACAgIAAx0CZiLt5gAD5mZLm_LHCB1_h5anoEEStvf4l_fyAAIISAACVyEJSpNn5Oa7x8LDHgQ","6589995279":"BAACAgIAAx0CZiLt5gAD5mZLm_JkQEwGvFwxwQXtfMk9FrBYAAIISAACVyEJSovis_Nx3os5HgQ","6539834495":"BAACAgIAAx0CZiLt5gAD5mZblPC_hDA4ZXq9Uw2NiHhRZakvAAIISAACVyEJSk4a1yBMKm1jHgQ","7142960273":"BAACAgIAAx0CZiLt5gAD5mZblU_WJD3j98Z_fwS4zkhZU16WAAIISAACVyEJStP84jRi0R9YHgQ"}}
+  """ 
+  resp=[{
+    "adult": False,
+    "backdrop_path": "/c1bz69r0v065TGFA5nqBiKzPDys.jpg",
+    "genre_ids": [
+      35,
+      10751,
+      10402
+    ],
+    "id": f"{row['_id']}",
+    "original_language": "en-hi",
+    "original_title": f"{str(row['file']['caption'])}",
+    "overview": "XRepo Movies",
+    "popularity": 1710.176,
+    "poster_path": "/irIS5Tn3TXjNi1R9BpWvGAN4CZ1.jpg",
+    "release_date": "2022-10-07",
+    "title": f"{str(row['file']['caption'])}",
+    "link": f"{Server.URL}api/dl/{row['_id']}",
+    "vote_average": 7.8,
+    "vote_count": 122,
+    } 
+     for row in files]
+  return web.json_response(json.loads(dumps(resp)))
+
+#----------------------------------------Upload----------------------------------------------#
+#@routes.post("/upload")
+async def upload_file(request: web.Request):
+
+  data = await request.post()
+  file = data.get('file').file
+  chunk = file.read()
+  """
+  user_id :
+  file_id :"BAACAgUAAxkBAAJBHGYI_aJSvyL_ijKwrVHQVzFgC1YZAAItDQACOnNAVMIpWwl6b63EHg…"
+  file_unique_id :"AgADLQ0AAjpzQFQ"
+  file_name :"Dadur_Kirti_S01_COMBINED_720p_HOICHOI_WEB_DL_Bengali@COOL_MOVIES.mp4"
+  file_size : 1354816011
+  mime_type : "video/mp4"
+  time : 1711865251.1016757
+  user_type: "TELEGRAM"/"WEB"
+  privacy_type: "PUBLIC"/"PRIVATE"
+  file_ids :
+  """
+  file_details = dict(user_id="thebinary1",
+                      dropzone_id=str(data["dzuuid"]),
+                      file=dict(file_id=str(data["dzuuid"]),
+                                file_unique_id=str(data["dzuuid"]),
+                                file_name=str(data.get('file').filename),
+                                file_size=int(data["dztotalfilesize"]),
+                                mime_type=mime_identifier(str(data.get('file').filename)),
+                                part_size=int(data["dzchunksize"]),
+                                file_part=int(data["dzchunkindex"]),
+                                total_parts=int(data["dztotalchunkcount"])),
+                      time=Time_ISTKolNow(),
+                      user_type="WEB",
+                      privacy_type="PRIVATE")
+
+  print(file_details) if (file_details["file"]["file_part"] == 0) else None
+  client_req = await req_client()
+  #faster_client = client_req["client"]
+  #index = client_req["index"]
+  print("using :", client_req["index"])
+  tg_connect = TeleUploader(client_req["client"])
+  main = await tg_connect.upload_web_file(file_details, chunk)
+  #print("Response:", main)
+  return web.json_response({
+      "status": main.get("status"),
+      "message": main.get("message")
+  })
+
+
+#-------------Routes to Downloada File Witha Path-----------------#
+#@routes.get("/dl/{path}", allow_head=True)
+async def stream_handler(request: web.Request):
+  try:
+    path = request.match_info["path"]
+    return await media_streamer(request, path)
+  except InvalidHash as e:
+    raise web.HTTPForbidden(text=e.message)
+  except FIleNotFound as e:
+    raise web.HTTPNotFound(text=e.message)
+  except (AttributeError, BadStatusLine, ConnectionResetError):
+    pass
+  except Exception as e:
+    traceback.print_exc()
+    logging.critical(e.with_traceback(None))
+    logging.debug(traceback.format_exc())
+    raise web.HTTPInternalServerError(text=str(e))
+
+
+api = web.Application()
+api.router.add_get('/', handle_v2)
+api.router.add_get('/files', list_all_files_db)
+api.router.add_get('/tmdb/files', list_all_files)
+api.router.add_get('/tmdb/list', list_all_files_tmdb)
+api.router.add_get('/upload', upload_file)
+api.router.add_get('/dl/{path}', stream_handler)

FileStream/server/routes_app.py

@@ -0,0 +1,41 @@
+from aiohttp import web
+from aiohttp.http_exceptions import BadStatusLine
+
+from .Functions.downloader import media_streamer
+from FileStream.server.exceptions import FIleNotFound, InvalidHash
+from FileStream.server.render_template import render_page, render_upload
+
+
+async def handle_v2(request):
+    return web.Response(text="Hello from app v2!")
+
+
+#@sub_app.get("/watch/{path}", allow_head=True)
+async def stream_handler(request: web.Request):
+  try:
+    path = request.match_info["path"]
+    return web.Response(text=await render_page(path), content_type='text/html')
+  except InvalidHash as e:
+    raise web.HTTPForbidden(text=e.message)
+  except FIleNotFound as e:
+    raise web.HTTPNotFound(text=e.message)
+  except (AttributeError, BadStatusLine, ConnectionResetError):
+    pass
+
+#@sub_app.get("/up", allow_head=True)
+async def upload_handler(request: web.Request):
+  # global faster_client,index,session, new_file_id
+  await asyncio.gather(*tasks)
+  try:
+    return web.Response(text=await render_upload(), content_type='text/html')
+  except InvalidHash as e:
+    raise web.HTTPForbidden(text=e.message)
+  except FIleNotFound as e:
+    raise web.HTTPNotFound(text=e.message)
+  except (AttributeError, BadStatusLine, ConnectionResetError):
+    pass
+
+sub_app = web.Application()
+sub_app.router.add_get('/', handle_v2)
+sub_app.router.add_get('/watch/{path}', stream_handler)
+sub_app.router.add_get('/up', upload_handler)

FileStream/server/routes_main.py

@@ -0,0 +1,34 @@
+import time
+import math
+import logging
+import asyncio
+import traceback
+from aiohttp import web
+from pyrogram import raw
+
+from aiohttp.http_exceptions import BadStatusLine
+
+#---------------------Local Upload---------------------#
+from FileStream.config import Telegram
+from FileStream.bot import multi_clients, work_loads, FileStream
+from FileStream.server.exceptions import FIleNotFound, InvalidHash
+from FileStream import utils, StartTime, __version__
+from FileStream.utils.FileProcessors.custom_ul import TeleUploader
+from FileStream.Tools import mime_identifier, Time_ISTKolNow
+from FileStream.server.render_template import render_page, render_upload
+
+tasks = []
+routes = web.RouteTableDef()
+
+@routes.get("/status", allow_head=True)
+async def root_status_handler(_):
+  return web.json_response({
+      "server_status":"running",
+      "uptime": utils.get_readable_time(time.time() - StartTime),
+      "telegram_bot": "@" + FileStream.username,
+      "connected_bots": len(multi_clients),
+      "loads":dict(("bot" + str(c + 1), l) for c, (_, l) in enumerate(sorted(work_loads.items(), key=lambda x: x[1], reverse=True))),
+      "version": __version__,
+  })
+
+

FileStream/server/template/dl.html

@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta property="og:image" content="https://www.flaticon.com/premium-icon/icons/svg/2626/2626281.svg" itemprop="thumbnailUrl">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{file_name}}</title>
+    <link rel="stylesheet" type='text/css' href="https://drive.google.com/uc?export=view&id=1pVLG4gZy7jdow3sO-wFS06aP_A9QX0O6">
+    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Raleway">
+    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Delius">
+</head>
+
+<body class='cyber'>
+    <header>
+        <div class="toogle"></div>
+        <div id="file-name" class="cyber">
+            {{file_name}}
+        </div>
+    </header>
+
+    <div class="container">
+        <a href="{{file_url}}">
+            <button class="cybr-btn">
+                Download
+                <span aria-hidden>_</span>
+                <span aria-hidden class="cybr-btn__glitch">_404 Error</span>
+                <span aria-hidden class="cybr-btn__tag">_%s</span>
+            </button>
+        </a>
+    </div>
+	<script>
+        const body = document.querySelector('body');
+        const title = document.querySelector('#file-name');
+        const footer = document.querySelector('footer');
+        const toogle = document.querySelector('.toogle');
+        toogle.onclick = () => {
+            body.classList.toggle('dark')
+            footer.classList.toggle('dark')
+            title.classList.toggle('dark')
+        }
+    </script>
+</body>
+</html>

FileStream/server/template/owner.js

@@ -0,0 +1,317 @@
+async function getDets() {
+    let randPage = Math.floor(1 + Math.random() * 100)
+    const apiKey = '6abcb6bb99fb77f33c37016a28866ed2';
+    let apiArr = [`https://api.themoviedb.org/3/movie/popular?api_key=${apiKey}&language=hin-US&page=${randPage}`, `https://api.themoviedb.org/3/trending/movie/day?api_key=${apiKey}&language=hin-US&page=${randPage}`, `https://api.themoviedb.org/3/movie/now_playing?api_key=${apiKey}&language=hin-US&page=${randPage}`]
+    let ArrRanIndex = Math.floor(Math.random() * apiArr.length)
+    let apiUrl = apiArr[ArrRanIndex]
+    let movieCont = document.querySelector('.movieSug')
+    let img = document.querySelector('.movieimg img')
+    let movieDets = document.querySelector('.movieDets')
+    let movieDetsMini = document.querySelector('.movieDets-mini')
+    let data = await fetch(apiUrl)
+    let resData = await data.json()
+    let ranIndex = Math.floor(Math.random() * resData.results.length)
+    let movie = resData.results[ranIndex]
+    movieDets.innerHTML = `
+    <h3>Must-see blockbuster film!</h3>
+    <h4><span>Title:</span> ${movie.title}</h4>
+                        <h4><span>movie overview:</span> ${movie.overview}</h4>
+                        <h4><span>Release Date:</span> ${movie.release_date}</h4>
+                        <h4><span>Rating:</span> ${movie.vote_average.toFixed(1)} / 10</h4>
+    `
+    movieDetsMini.innerHTML = `
+                <h3><span>Title:</span> ${movie.title}</h3>
+                <h3><span>Release Date:</span> ${movie.release_date}</h3>
+                <h3><span>Rating:</span> ${movie.vote_average.toFixed(1)} / 10</h3>
+        `
+    img.src = `https://image.tmdb.org/t/p/w1280/${movie.poster_path}`
+    movieCont.style.backgroundImage = `url(https://image.tmdb.org/t/p/w1280/${movie.backdrop_path})`;
+}
+window.addEventListener("load", getDets())
+
+
+
+let homeBtn = document.querySelector(".home-btn")
+let abtBtn = document.querySelector(".about-btn")
+let dldBtn_outer = document.querySelector(".downloadBtn")
+let file_name = document.querySelector(".file-name")
+let about_nav = document.querySelector(".about-nav")
+let contact_btn = document.querySelector('.contact-btn')
+let links = document.querySelectorAll('.links a')
+let chnl_link = document.querySelectorAll('.chnl-link a')
+let abt_chnl = document.querySelector('.abt-chnl')
+let contact = document.querySelectorAll('.contact a')
+let footer = document.querySelector('footer')
+
+let timer = 0
+
+if (document.getElementById("heading").classList.contains("title")) {
+    document.querySelector(".title").textContent = 'FILE STREAM'
+}
+
+// adding under in home btn at first 
+homeBtn.classList.add('active');
+
+// when clicking about
+abtBtn.addEventListener("click", () => {
+    dldBtn_outer.style.display = "none";
+    file_name.style.display = "none";
+    footer.style.display = "none";
+    about_nav.style.display = "block"
+    about_nav.style.display = "block"
+    about_nav.style.animation = "strtLoad 1s ease 0s forwards"
+
+})
+// when clicking home
+homeBtn.addEventListener("click", () => {
+    dldBtn_outer.style.display = "flex";
+    file_name.style.display = "block";
+    footer.style.display = "block";
+    window.location.href = "#main";
+    about_nav.style.animation = "strtLoad 1s ease 0s forwards"
+    about_nav.style.display = "none"
+
+})
+
+abt_chnl.addEventListener("click", () => {
+    timer = 1
+    chnl_link.forEach((i) => {
+        i.style.animation = `strtLoad 1s ease ${timer}s forwards, linksBtnAn 2s ease ${timer}s infinite `
+        timer += 0.3;
+    });
+    timer = 0
+});
+function bot_btn_clicked() {
+    var about_btn = document.querySelector(".about-btn")
+    timer = 1;
+    bot_links.forEach((i) => {
+        i.style.animation = `linksBtnAn 2s ease ${timer}s infinite ,strtLoad 1s ease ${timer}s forwards`;
+        timer += 0.3;
+    });
+    timer = 0;
+    dldBtn_outer.style.display = "none";
+    file_name.style.display = "none";
+    footer.style.display = "none";
+    about_nav.style.display = "block"
+    about_nav.style.display = "block"
+    about_nav.style.animation = "strtLoad 1s ease 0s forwards"
+    var links = document.querySelectorAll('.nryt a');
+    links.forEach(function (link) {
+        link.classList.remove('active');
+    });
+    about_btn.classList.add('active');
+    var links = document.querySelectorAll('.about-nav a');
+    links.forEach(function (link) {
+        link.classList.remove('active');
+    });
+    let wlcm = document.querySelector(".wlcm")
+    wlcm.classList.add('active');
+    var links = document.querySelectorAll('.about-nav a');
+    links.forEach(function (link) {
+        link.classList.remove('active');
+    });
+    bot_btn.classList.add('active');
+};
+footer_btn_clicked = () => {
+    timer = 1;
+    contact.forEach((i) => {
+        i.style.animation = `linksBtnAn 2s ease ${timer}s infinite ,strtLoad 1s ease ${timer}s forwards`;
+        timer += 0.3;
+    });
+
+    timer = 0;
+    var about_btn = document.querySelector(".about-btn")
+    timer = 1;
+    bot_links.forEach((i) => {
+        i.style.animation = `linksBtnAn 2s ease ${timer}s infinite ,strtLoad 1s ease ${timer}s forwards`;
+        timer += 0.3;
+    });
+    timer = 0;
+    dldBtn_outer.style.display = "none";
+    file_name.style.display = "none";
+    footer.style.display = "none";
+    about_nav.style.display = "block"
+    about_nav.style.display = "block"
+    about_nav.style.animation = "strtLoad 1s ease 0s forwards"
+    var links = document.querySelectorAll('.nryt a');
+    links.forEach(function (link) {
+        link.classList.remove('active');
+    });
+    about_btn.classList.add('active');
+    var links = document.querySelectorAll('.about-nav a');
+    links.forEach(function (link) {
+        link.classList.remove('active');
+    });
+    let wlcm = document.querySelector(".wlcm")
+    wlcm.classList.add('active');
+    var links = document.querySelectorAll('.about-nav a');
+    links.forEach(function (link) {
+        link.classList.remove('active');
+    });
+    contact_btn.classList.add('active');
+}
+
+contact_btn.addEventListener("click", () => {
+    timer = 1;
+    contact.forEach((i) => {
+        i.style.animation = `linksBtnAn 2s ease ${timer}s infinite ,strtLoad 1s ease ${timer}s forwards`;
+        timer += 0.3;
+    });
+
+    timer = 0;
+})
+
+// btn animations 
+let dldBtn = document.querySelectorAll('.downloadBtn button')
+dldBtn.forEach((i) => {
+    i.style.animation = `strtLoad 1s ease ${timer}s forwards, linksBtnAn 2s ease ${timer}s infinite`
+    timer += 0.3;
+    i.style.setProperty("--beforestyl", `button_shine ${2 + Math.random() * 7}s ease  ${Math.random() * 10}s infinite`);
+
+})
+
+timer = 0
+links.forEach((i) => {
+    i.style.animation = `linksBtnAn 2s ease ${timer}s infinite`
+    timer += 0.3
+    i.style.setProperty("--beforestyl", `button_shine ${2 + Math.random() * 7}s ease ${Math.random() * 10}s infinite`);
+
+})
+timer = 0
+timer = 0
+
+function toggleWidth(element) {
+    var links = document.querySelectorAll('.about-nav a');
+    links.forEach(function (link) {
+        link.classList.remove('active');
+    });
+
+    element.classList.add('active');
+}
+function toggleWidthnav(element) {
+    var links = document.querySelectorAll('.nryt a');
+    links.forEach(function (link) {
+        link.classList.remove('active');
+    });
+
+    element.classList.add('active');
+    var links = document.querySelectorAll('.about-nav a');
+    links.forEach(function (link) {
+        link.classList.remove('active');
+    });
+    let wlcm = document.querySelector(".wlcm")
+    wlcm.classList.add('active');
+}
+
+if (!(/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent))) {
+    Shery.mouseFollower();
+    Shery.makeMagnet(".magnet");
+}
+
+
+// file name showing 
+var div = document.getElementById('myDiv');
+var text = div.textContent;
+if (text.length > 300) {
+    div.textContent = text.slice(0, 300) + "....";
+}
+
+// video player 
+const controls = [
+    'play-large',
+    'rewind', 'play',
+    'fast-forward',
+    'progress',
+    'current-time',
+    'duration',
+    //'mute',
+    //'volume',
+    'captions',
+    'settings',
+    'pip',
+    'airplay',
+    // 'download',
+    'fullscreen'
+];
+document.addEventListener('DOMContentLoaded', () => {
+    const player = Plyr.setup('.player', { controls });
+});
+
+// disabling right click
+document.addEventListener("contextmenu", function (e) {
+    e.preventDefault();
+});
+document.addEventListener('keydown', function (e) {
+    if (
+        e.key === 'F12' ||
+        (e.ctrlKey && e.shiftKey && e.key === 'I') ||
+        (e.ctrlKey && e.key === 'u') ||
+        e.ctrlKey ||
+        e.shiftKey ||
+        e.altKey
+    ) {
+        e.preventDefault();
+    }
+});
+
+
+const videolink = window.location.href;
+const streamlink = videolink.replace("/watch/", "/dl/");
+
+function vlc_player() {
+    const openstreamlink = streamlink;
+    const openVlc = `vlc://${openstreamlink}`;
+    window.location.href = openVlc;
+}
+
+function mx_player() {
+    const openstreamlink = streamlink;
+    const openMx = `intent:${openstreamlink}#Intent;package=com.mxtech.videoplayer.ad;end`;
+    window.location.href = openMx;
+}
+
+function n_player() {
+    const openstreamlink = streamlink;
+    const openNplayer = `nplayer-${openstreamlink}`;
+    window.location.href = openNplayer;
+}
+
+function streamDownload() {
+  const openstreamlink = streamlink;
+  window.location.href = openstreamlink;
+}
+
+function copyStreamLink() {
+  const linkToCopy = streamlink.toLowerCase();
+
+  if (!navigator.clipboard) {
+    navigator.clipboard = {
+      writeText: function(text) {
+        return new Promise((resolve, reject) => {
+          try {
+            const textArea = document.createElement("textarea");
+            textArea.value = text;
+            document.body.appendChild(textArea);
+            textArea.focus();
+            textArea.select();
+            document.execCommand('copy');
+            document.body.removeChild(textArea);
+            resolve();
+          } catch (err) {
+            reject(err);
+          }
+        });
+      }
+    };
+  }
+
+  navigator.clipboard.writeText(linkToCopy)
+    .then(() => {
+      console.log('Stream link copied to clipboard!');
+      alert('Stream link copied successfully!');
+    })
+    .catch(err => {
+      console.error('Failed to copy link: ', err);
+      alert('Failed to copy link. Please try manually.');
+    });
+}

FileStream/server/template/play.html

@@ -0,0 +1,171 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FileStreamBot | {{file_name}}</title>
+    <link rel="icon" href="https://i.ibb.co/Hh4kF2b/icon.png" type="image/x-icon">
+    <link rel="shortcut icon" href="https://i.ibb.co/Hh4kF2b/icon.png" type="image/x-icon">
+    <link rel="stylesheet" href="https://unpkg.com/sheryjs/dist/Shery.css" />
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/proavipatil/data@main/fs/src/style.css">
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/proavipatil/data@main/fs/src/plyr.css">
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Josefin+Sans:wght@500;700&display=swap" rel="stylesheet">
+    <script src="https://cdn.tailwindcss.com"></script>
+
+</head>
+
+<body>
+    <nav>
+        <div class="nleft">
+            <a href="#">
+                <h3 id="heading" style="z-index: 100;" class="magnet title">FILE STREAM</h3>
+            </a>
+        </div>
+        <div class="nryt">
+            <a class="home-btn magnet" href="#main" onclick="toggleWidthnav(this)">HOME</a>
+
+            <a href="#abtus" class="about-btn magnet" onclick="toggleWidthnav(this)">ABOUT</a>
+        </div>
+    </nav>
+    <center>
+        <div class="about-nav">
+            <a href="#abtus" class="wlcm magnet" onclick="toggleWidth(this)">WELCOME</a>
+            <a href="#channels" class="abt-chnl magnet" onclick="toggleWidth(this)">CHANNELS</a>
+            <a href="#contact" class="magnet contact-btn" onclick="toggleWidth(this)">CONTACT</a>
+        </div>
+    </center>
+
+    <div class="outer">
+        <div class="inner">
+            <div class="main" id="main">
+                <video id="player" class="player" src="{{file_url}}" type="video/mp4" playsinline controls
+                    width="100%"></video>
+                <div class="player"></div>
+                <div class="file-name">
+                    <h4 style="display: inline;">File Name: </h4>
+                    <p style="display: inline;" id="myDiv">{{file_name}}</p><br>
+                    <h4 style="display: inline;">File Size: </h4>
+                    <p style="display: inline;">{{file_size}}</p>
+                </div>
+                <div class="downloadBtn">
+                    <button class="magnet" onclick="streamDownload()">
+                        <img style="height: 30px;" src="https://i.ibb.co/RjzYttX/dl.png" alt="">download video
+                    </button>
+                    <button class="magnet" onclick="copyStreamLink()">
+                        <img src="https://i.ibb.co/CM4Y586/link.png" alt="Copy Link">copy link
+                    </button>
+                    <button class="magnet" onclick="vlc_player()">
+                        <img src="https://i.ibb.co/px6fQs1/vlc.png" alt="">watch in VLC PLAYER
+                    </button>
+                    <button class="magnet" onclick="mx_player()">
+                        <img src="https://i.ibb.co/41WvtQ3/mx.png" alt="">watch in MX PLAYER
+                    </button>
+                    <button class="magnet" onclick="n_player()">
+                        <img src="https://i.ibb.co/Hd2dS4t/nPlayer.png" alt="">watch in nPlayer
+                    </button>
+                </div>
+
+            </div>
+            <div class="abt">
+                <div class="about">
+                    <div class="about-dets">
+
+                        <div class="abt-sec" id="abtus" style="padding: 160px 30px;">
+                            <h1 style="text-align: center;">WELCOME TO OUR <Span>FILE STREAM</Span> BOT</h1>
+                            <p style="text-align: center; line-height: 2;word-spacing: 2px;  letter-spacing: 0.8px;">
+                                This is a Telegram Bot to Stream <span>Movies</span> and <span>Series</span> directly on
+                                Telegram. You can also
+                                <span>download</span> them if you want. This bot is developed by <a
+                                    href="https://github.com/AviPatilPro"><span style="font-weight: 700;">Avi</span></a>
+                                <br><br>If you like this bot, then don't
+                                forget to share it with your friends and family.
+                            </p>
+                        </div>
+
+                        <div class="abt-sec" id="channels">
+                            <h1>JOIN OUR <span>TELEGRAM</span> CHANNELS</h1>
+                            <div class="links chnl-link">
+                                <a class="magnet" href="https://t.me/CheapieDeals">
+                                    <button>CHEAP DEALS</button>
+                                </a>
+                                <a class="magnet" href="https://t.me/FilmyPixel">
+                                    <button>FILMYPIXEL</button>
+                                </a>
+                                <a class="magnet" href="https://t.me/PostersZone">
+                                    <button>POSTERS ZONE</button>
+                                </a>
+                                <a class="magnet" href="https://t.me/EpitomeQuality">
+                                    <button>EPITOME QUALITY</button>
+                                </a>
+                            </div>
+                        </div>
+
+                        <div class="abt-sec" id="contact">
+                            <p style="text-align: center;">Report Bugs and Contact us on Telegram Below</p>
+                            <div class="links contact">
+                                <a href="https://t.me/AvishkarPatil">
+                                    <button>CONTACT</button>
+                                </a>
+                            </div>
+                        </div>
+
+                    </div>
+                </div>
+            </div>
+        </div>
+        <footer>
+            <center>
+
+                <div class="movie-cont">
+                    <div class="movieSug">
+                        <div class="movieDets">
+
+                        </div>
+                        <div class="movieimg">
+                            <img src="">
+                        </div>
+                    </div>
+                    <div class="low-width-movie-dets">
+                        <div class="movieStsBar">
+                            <div class="movieDets-mini">
+
+                            </div>
+                        </div>
+                    </div>
+                    <button class="ranMovBtn" onclick="getDets()">Get More Movies Suggestion</button>
+                </div>
+
+            </center>
+
+            <center>
+                <div class="copyright">
+                    <h5 class="text-center">Copyright © 2024 <a href="https://github.com/AviPatilPro"><span
+                                style="font-weight: 700;">Avishkar Patil</span></a>. All
+                        Rights Reserved.</h5>
+                </div>
+            </center>
+        </footer>
+    </div>
+</body>
+
+<script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/3.12.2/gsap.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/3.12.2/ScrollTrigger.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/0.155.0/three.min.js"></script>
+<script src="https://cdn.jsdelivr.net/gh/automat/controlkit.js@master/bin/controlKit.min.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/sheryjs/dist/Shery.js"></script>
+<script>
+    document.addEventListener("DOMContentLoaded", function () {
+        const uncopyableElement = document.querySelector(".uncopyable");
+
+        uncopyableElement.addEventListener("selectstart", function (event) {
+            event.preventDefault();
+        });
+    });
+</script>
+<script src="https://cdn.plyr.io/3.6.9/plyr.js"></script>
+<script src="/FileStream/server/template/owner.js"></script>
+
+</html>

FileStream/server/template/upload.html

@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>File Upload</title>
+  <meta charset="UTF-8">
+  <link rel="stylesheet" 
+   href="https://cdnjs.cloudflare.com/ajax/libs/dropzone/5.4.0/min/dropzone.min.css"/>
+  <link rel="stylesheet" 
+   href="https://cdnjs.cloudflare.com/ajax/libs/dropzone/5.4.0/min/basic.min.css"/>
+  <script type="application/javascript" 
+   src="https://cdnjs.cloudflare.com/ajax/libs/dropzone/5.4.0/min/dropzone.min.js">
+  </script>
+</head>
+<body>
+<h1>File Upload</h1>
+  <form method="POST" action='/api/upload' class="dropzone dz-clickable" 
+        id="dropper" enctype="multipart/form-data">
+  </form>
+
+ 
+        <script type="application/javascript">
+            Dropzone.options.dropper = {
+                paramName: 'file',
+                chunking: true,
+                forceChunking: true,
+                url: '/upload',
+                maxFilesize: 2049, 
+                chunkSize: 524288,
+                //parallelChunkUploads: true,
+                //retryChunks: true,
+                //retryChunksLimit: 3,
+              
+            }
+        </script>
+
+          
+
+
+</body>
+</html>

FileStream/utils/FileProcessors/__init__.py

@@ -0,0 +1,3 @@
+from .time_format import get_readable_time
+from .file_properties import get_name, get_file_ids
+from .custom_dl import ByteStreamer

FileStream/utils/FileProcessors/bot_utils.py

@@ -0,0 +1,350 @@
+from pyrogram.errors import UserNotParticipant, FloodWait
+from pyrogram.enums.parse_mode import ParseMode
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton, Message,WebAppInfo
+from FileStream.utils.FileProcessors.translation import LANG
+from FileStream.Database import Database
+from FileStream.utils.FileProcessors.human_readable import humanbytes
+from FileStream.config import Telegram, Server
+from FileStream.bot import FileStream
+import asyncio
+import functools
+from typing import (Union)
+
+db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+
+
+async def get_invite_link(bot, chat_id: Union[str, int]):
+  try:
+    invite_link = await bot.create_chat_invite_link(chat_id=chat_id)
+    return invite_link
+  except FloodWait as e:
+    print(f"Sleep of {e.value}s caused by FloodWait ...")
+    await asyncio.sleep(e.value)
+    return await get_invite_link(bot, chat_id)
+
+
+async def is_user_joined(bot, message: Message):
+  if Telegram.FORCE_SUB_ID and Telegram.FORCE_SUB_ID.startswith("-100"):
+    channel_chat_id = int(
+        Telegram.FORCE_SUB_ID)  # When id startswith with -100
+  elif Telegram.FORCE_SUB_ID and (
+      not Telegram.FORCE_SUB_ID.startswith("-100")):
+    channel_chat_id = Telegram.FORCE_SUB_ID  # When id not startswith -100
+  else:
+    return 200
+  try:
+    user = await bot.get_chat_member(chat_id=channel_chat_id,user_id=message.from_user.id)
+    if user.status == "BANNED":
+      await message.reply_text(text=LANG.BAN_TEXT.format(Telegram.OWNER_ID),
+                               parse_mode=ParseMode.MARKDOWN,
+                               disable_web_page_preview=True)
+      return False
+  except UserNotParticipant:
+    invite_link = await get_invite_link(bot, chat_id=channel_chat_id)
+    #------------------------------------------------------------------#
+    if Telegram.VERIFY_PIC:
+      ver = await message.reply_photo(
+          photo=Telegram.VERIFY_PIC,
+          caption="<i>Jᴏɪɴ ᴍʏ ᴜᴘᴅᴀᴛᴇ ᴄʜᴀɴɴᴇʟ ᴛᴏ ᴜsᴇ ᴍᴇ 🔐</i>",
+          parse_mode=ParseMode.HTML,
+          reply_markup=InlineKeyboardMarkup([[
+              InlineKeyboardButton("❆ Jᴏɪɴ Oᴜʀ Cʜᴀɴɴᴇʟ ❆",
+                                   url=invite_link.invite_link)
+          ]]))
+    else:
+      #---------------------------------------------------------------#
+      ver = await message.reply_text(
+          text="<i>Jᴏɪɴ ᴍʏ ᴜᴘᴅᴀᴛᴇ ᴄʜᴀɴɴᴇʟ ᴛᴏ ᴜsᴇ ᴍᴇ 🔐</i>",
+          reply_markup=InlineKeyboardMarkup([[
+              InlineKeyboardButton("❆ Jᴏɪɴ Oᴜʀ Cʜᴀɴɴᴇʟ ❆",
+                                   url=invite_link.invite_link)
+          ]]),
+          parse_mode=ParseMode.HTML)
+
+    await asyncio.sleep(30)
+    try:
+      await ver.delete()
+      await message.delete()
+    except Exception:
+      pass
+    return False
+  except Exception:
+    await message.reply_text(
+        text=
+        f"<i>Sᴏᴍᴇᴛʜɪɴɢ ᴡʀᴏɴɢ ᴄᴏɴᴛᴀᴄᴛ ᴍʏ ᴅᴇᴠᴇʟᴏᴘᴇʀ</i> <b><a href='https://t.me/{Telegram.UPDATES_CHANNEL}'>[ ᴄʟɪᴄᴋ ʜᴇʀᴇ ]</a></b>",
+        parse_mode=ParseMode.HTML,
+        disable_web_page_preview=True)
+    return False
+  return True
+
+
+#-------------------------------------------------------------
+async def upload_type_func(file_info):
+  """
+  //Used values Directly from file Info
+  file_name = file_info['file_name']
+  file_size = humanbytes(file_info['file_size'])
+  mime_type = file_info['mime_type']
+  user_id = file_info['user_id']
+  message_id = file_info['message_id']
+  """
+
+  existing_file =await db.get_file_by_fileuniqueid_only(file_info['file']['file_unique_id'])
+  if existing_file :
+    reply_markup, stream_text = await gen_link(existing_file['_id'])
+    #await update.message.edit_text(text=stream_text,parse_mode=ParseMode.HTML,disable_web_page_preview=True,reply_markup=reply_markup,)
+    return reply_markup, stream_text
+  else:
+    stream_text = LANG.STREAM_TEXT_Y.format(file_info['file']['file_name'],humanbytes(file_info['file']['file_size']))
+    reply_markup = InlineKeyboardMarkup([[
+        InlineKeyboardButton(
+            "PUBLIC UPLOAD",
+            callback_data=f"pubup_{file_info['user_id']}_{file_info['message_id']}"),
+        InlineKeyboardButton(
+            "PRIVATE UPLOAD",
+            callback_data=
+            f"privup_{file_info['user_id']}_{file_info['message_id']}")
+    ], [InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")]])
+
+    return reply_markup, stream_text
+
+
+async def priv_func(file_name, file_size):
+
+  file_size = humanbytes(file_size)
+  stream_text = LANG.PRIV_FILE_RENAME.format(file_name, file_size)
+  reply_markup = InlineKeyboardMarkup(
+      [[InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")]])
+
+  return reply_markup, stream_text
+
+
+#------------------[PRIV_FILE GEN LINK FUNC ]------------------#
+async def gen_priv_file_link(_id):
+  file_info = await db.get_privfile(_id)
+  file_name = file_info['file_name']
+  file_size = humanbytes(file_info['file_size'])
+  mime_type = file_info['mime_type']
+
+  page_link = f"{Server.URL}app/watch/{_id}"
+  stream_link = f"{Server.URL}api/dl/{_id}"
+  file_link = f"https://t.me/{FileStream.username}?start=privfile_{_id}"
+
+  if "video" in mime_type:
+    stream_text = LANG.STREAM_TEXT.format(file_name, file_size, stream_link,
+                                          page_link, file_link)
+    reply_markup = InlineKeyboardMarkup(
+        [ [
+            InlineKeyboardButton("sᴛʀᴇᴀᴍ",url=page_link),
+            InlineKeyboardButton("ᴅᴏᴡɴʟᴏᴀᴅ", url=stream_link)
+        ],
+         [
+             InlineKeyboardButton("ɢᴇᴛ ғɪʟᴇ", url=file_link),
+             InlineKeyboardButton("ʀᴇᴠᴏᴋᴇ ғɪʟᴇ",
+                                  callback_data=f"msgdelpvt_{_id}")
+         ], [InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")]])
+  else:
+    stream_text = LANG.STREAM_TEXT_X.format(file_name, file_size, stream_link,
+                                            file_link)
+    reply_markup = InlineKeyboardMarkup(
+        [[InlineKeyboardButton("ᴅᴏᴡɴʟᴏᴀᴅ", url=stream_link)],
+         [
+             InlineKeyboardButton("ɢᴇᴛ ғɪʟᴇ", url=file_link),
+             InlineKeyboardButton("ʀᴇᴠᴏᴋᴇ ғɪʟᴇ",
+                                  callback_data=f"msgdelpvt_{_id}")
+         ], [InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")]])
+  return reply_markup, stream_text
+
+
+#---------------------[ PRIVATE GEN LINK + CALLBACK ]---------------------#
+
+
+async def gen_link(_id):
+  file_info = await db.get_file(_id)
+  file_name = file_info['file']['file_name']
+  file_size = humanbytes(file_info['file']['file_size'])
+  mime_type = file_info['file']['mime_type']
+
+  page_link = f"{Server.URL}app/watch/{_id}"
+  stream_link = f"{Server.URL}api/dl/{_id}"
+  file_link = f"https://t.me/{FileStream.username}?start=file_{_id}"
+
+  if "video" in mime_type:
+    stream_text = LANG.STREAM_TEXT.format(file_name, file_size, stream_link,
+                                          page_link, file_link)
+    reply_markup = InlineKeyboardMarkup(
+        [[
+            InlineKeyboardButton("sᴛʀᴇᴀᴍ", url=page_link),
+            InlineKeyboardButton("ᴅᴏᴡɴʟᴏᴀᴅ", url=stream_link)
+        ],
+         [
+             InlineKeyboardButton("ɢᴇᴛ ғɪʟᴇ", url=file_link),
+             InlineKeyboardButton("ʀᴇᴠᴏᴋᴇ ғɪʟᴇ",
+                                  callback_data=f"msgdelpvt_{_id}")
+         ], [InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")]])
+  else:
+    stream_text = LANG.STREAM_TEXT_X.format(file_name, file_size, stream_link,
+                                            file_link)
+    reply_markup = InlineKeyboardMarkup(
+        [[InlineKeyboardButton("ᴅᴏᴡɴʟᴏᴀᴅ", url=stream_link)],
+         [
+             InlineKeyboardButton("ɢᴇᴛ ғɪʟᴇ", url=file_link),
+             InlineKeyboardButton("ʀᴇᴠᴏᴋᴇ ғɪʟᴇ",
+                                  callback_data=f"msgdelpvt_{_id}")
+         ], [InlineKeyboardButton("ᴄʟᴏsᴇ", callback_data="close")]])
+  return reply_markup, stream_text
+
+
+#---------------------[ GEN STREAM LINKS FOR CHANNEL ]---------------------#
+
+
+async def gen_linkx(m: Message, _id, name: list):
+  file_info = await db.get_file(_id)
+  file_name = file_info['file_name']
+  mime_type = file_info['mime_type']
+  file_size = humanbytes(file_info['file_size'])
+
+  page_link = f"{Server.URL}app/watch/{_id}"
+  stream_link = f"{Server.URL}api/dl/{_id}"
+  file_link = f"https://t.me/{FileStream.username}?start=file_{_id}"
+
+  if "video" in mime_type:
+    stream_text = LANG.STREAM_TEXT_X.format(file_name, file_size, stream_link,
+                                            page_link)
+    reply_markup = InlineKeyboardMarkup([[
+        InlineKeyboardButton("sᴛʀᴇᴀᴍ", url=page_link),
+        InlineKeyboardButton("ᴅᴏᴡɴʟᴏᴀᴅ", url=stream_link)
+    ]])
+  else:
+    stream_text = LANG.STREAM_TEXT_X.format(file_name, file_size, stream_link,
+                                            file_link)
+    reply_markup = InlineKeyboardMarkup(
+        [[InlineKeyboardButton("ᴅᴏᴡɴʟᴏᴀᴅ", url=stream_link)]])
+  return reply_markup, stream_text
+
+
+#---------------------[ USER BANNED ]---------------------#
+
+
+async def is_user_banned(message):
+  if await db.is_user_banned(message.from_user.id):
+    await message.reply_text(text=LANG.BAN_TEXT.format(Telegram.OWNER_ID),
+                             parse_mode=ParseMode.MARKDOWN,
+                             disable_web_page_preview=True)
+    return True
+  return False
+
+
+#---------------------[ CHANNEL BANNED ]---------------------#
+
+
+async def is_channel_banned(bot, message):
+  if await db.is_user_banned(message.chat.id):
+    await bot.edit_message_reply_markup(
+        chat_id=message.chat.id,
+        message_id=message.id,
+        reply_markup=InlineKeyboardMarkup(
+            [[InlineKeyboardButton(f"ᴄʜᴀɴɴᴇʟ ɪs ʙᴀɴɴᴇᴅ",
+                                   callback_data="N/A")]]))
+    return True
+  return False
+
+
+#---------------------[ USER AUTH ]---------------------#
+
+
+async def is_user_authorized(message):
+  if hasattr(Telegram, 'AUTH_USERS') and Telegram.AUTH_USERS:
+    user_id = message.from_user.id
+    if user_id == Telegram.OWNER_ID:
+      return True
+    if not (user_id in Telegram.AUTH_USERS):
+      await message.reply_text(text="Yᴏᴜ ᴀʀᴇ ɴᴏᴛ ᴀᴜᴛʜᴏʀɪᴢᴇᴅ ᴛᴏ ᴜsᴇ ᴛʜɪs ʙᴏᴛ.",parse_mode=ParseMode.MARKDOWN,disable_web_page_preview=True)
+      return False
+  return True
+
+
+#---------------------[ USER EXIST ]---------------------#
+
+
+async def is_user_exist(bot, message):
+  if not bool(await db.get_user(message.from_user.id)):
+    #await db.add_user(message.from_user.id)
+    await bot.send_message(
+        Telegram.ULOG_GROUP,
+        f"**#NᴇᴡUsᴇʀ**\n**⬩ ᴜsᴇʀ ɴᴀᴍᴇ :** [{message.from_user.first_name}](tg://user?id={message.from_user.id})\n**⬩ ᴜsᴇʀ ɪᴅ :** `{message.from_user.id}`"
+    )
+
+
+#------------------[ User Status]--------------------#
+async def user_status(bot, message):
+  user = await db.get_user(message.from_user.id)
+  #await db.add_user(message.from_user.id)
+  return user
+
+
+async def is_channel_exist(bot, message):
+  if not bool(await db.get_user(message.chat.id)):
+    await db.add_user(message.chat.id)
+    members = await bot.get_chat_members_count(message.chat.id)
+    await bot.send_message(
+        Telegram.ULOG_GROUP,
+        f"**#NᴇᴡCʜᴀɴɴᴇʟ** \n**⬩ ᴄʜᴀᴛ ɴᴀᴍᴇ :** `{message.chat.title}`\n**⬩ ᴄʜᴀᴛ ɪᴅ :** `{message.chat.id}`\n**⬩ ᴛᴏᴛᴀʟ ᴍᴇᴍʙᴇʀs :** `{members}`"
+    )
+
+
+# Decorator Function to check if user is authorized
+#----------------------------------------------------------------
+def verify_users(func):
+
+  @functools.wraps(func)
+  async def wrapper(bot, message):
+    response = {}
+    user = await user_status(bot, message)
+    if user:
+      if user['tele_status']['status'] == "ACTIVE":
+        response['status'] = "AUTHORIZED"
+      elif user['tele_status']['status'] == "BANNED":
+        response['status'] = "BANNED"
+
+        await bot.send_message(
+            Telegram.ULOG_GROUP,
+            f"**\n**⬩ ᴜsᴇʀ ɴᴀᴍᴇ :** [{message.from_user.first_name} {message.from_user.last_name}](tg://user?id={message.from_user.id})\n**⬩ ᴜsᴇʀ ɪᴅ :** `{message.from_user.id}` \n ** Status : {response['status']} \n Trying to access Services**"
+        )
+
+        await bot.send_message(
+            message.from_user.id,
+            f"**⬩ ᴜsᴇʀ ɴᴀᴍᴇ :** [{message.from_user.first_name}](tg://user?id={message.from_user.id})\n**⬩ ᴜsᴇʀ ɪᴅ :** `{message.from_user.id}` \n** You are Banned by Admins Contact Admins to unban you**"
+        )
+
+    else:
+
+      response['status'] = "NOT EXIST"
+      await bot.send_message(
+          Telegram.ULOG_GROUP,
+          f"**\n**⬩ ᴜsᴇʀ ɴᴀᴍᴇ :** [{message.from_user.first_name} {message.from_user.last_name}](tg://user?id={message.from_user.id})\n**⬩ ᴜsᴇʀ ɪᴅ :** `{message.from_user.id}` \n ** Status : {response['status']}**"
+      )
+      await bot.send_message(
+          message.from_user.id,
+          f"**⬩ ᴜsᴇʀ ɴᴀᴍᴇ :** [{message.from_user.first_name}](tg://user?id={message.from_user.id})\n**⬩ ᴜsᴇʀ ɪᴅ :** `{message.from_user.id}` \n** Ask Admins to Authorise You**"
+      )
+
+    return await func(bot, message, response)
+
+  return wrapper
+
+
+async def verify_user(bot, message):
+  if not await is_user_authorized(message):
+    return False
+
+  if await is_user_banned(message):
+    return False
+
+  await is_user_exist(bot, message)
+
+  if Telegram.FORCE_SUB:
+    if not await is_user_joined(bot, message):
+      return False
+
+  return True

FileStream/utils/FileProcessors/broadcast_helper.py

@@ -0,0 +1,19 @@
+import asyncio
+import traceback
+from pyrogram.errors import FloodWait, InputUserDeactivated, UserIsBlocked, PeerIdInvalid
+
+async def send_msg(user_id, message):
+    try:
+        await message.copy(chat_id=user_id)
+        return 200, None
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+        return send_msg(user_id, message)
+    except InputUserDeactivated:
+        return 400, f"{user_id} : deactivated\n"
+    except UserIsBlocked:
+        return 400, f"{user_id} : blocked the bot\n"
+    except PeerIdInvalid:
+        return 400, f"{user_id} : user id invalid\n"
+    except Exception as e:
+        return 500, f"{user_id} : {traceback.format_exc()}\n"

FileStream/utils/FileProcessors/custom_dl.py

@@ -0,0 +1,208 @@
+import asyncio
+import logging
+from typing import Dict, Union
+from FileStream.bot import work_loads
+from pyrogram import Client, utils, raw
+from .file_properties import get_file_ids
+from pyrogram.session import Session, Auth
+from pyrogram.errors import AuthBytesInvalid
+from pyrogram.file_id import FileId, FileType, ThumbnailSource
+from pyrogram.types import Message
+
+
+class ByteStreamer:
+
+  def __init__(self, client: Client):
+    self.clean_timer = 30 * 60
+    self.client: Client = client
+    self.cached_file_ids: Dict[str, FileId] = {}
+    asyncio.create_task(self.clean_cache())
+
+  async def get_file_properties(self, db_id: str, multi_clients) -> FileId:
+    """
+        Returns the properties of a media of a specific message in a FIleId class.
+        if the properties are cached, then it'll return the cached results.
+        or it'll generate the properties from the Message ID and cache them.
+        """
+    if not db_id in self.cached_file_ids:
+      logging.debug("Before Calling generate_file_properties")
+      await self.generate_file_properties(db_id, multi_clients)
+      logging.debug(f"Cached file properties for file with ID {db_id}")
+    return self.cached_file_ids[db_id]
+
+  async def generate_file_properties(self, db_id: str,
+                                     multi_clients) -> FileId:
+    """
+        Generates the properties of a media file on a specific message.
+        returns ths properties in a FIleId class.
+        """
+    logging.debug("Before calling get_file_ids")
+    file_id = await get_file_ids(self.client, db_id, Message)
+    logging.debug(f"Generated file ID and Unique ID for file with ID {db_id}")
+    self.cached_file_ids[db_id] = file_id
+    logging.debug(f"Cached media file with ID {db_id}")
+    return self.cached_file_ids[db_id]
+
+  async def generate_media_session(self, client: Client,
+                                   file_id: FileId) -> Session:
+    """
+        Generates the media session for the DC that contains the media file.
+        This is required for getting the bytes from Telegram servers.
+        """
+
+    media_session = client.media_sessions.get(file_id.dc_id, None)
+
+    if media_session is None:
+      if file_id.dc_id != await client.storage.dc_id():
+        media_session = Session(
+            client,
+            file_id.dc_id,
+            await Auth(client, file_id.dc_id, await
+                       client.storage.test_mode()).create(),
+            await client.storage.test_mode(),
+            is_media=True,
+        )
+        await media_session.start()
+
+        for _ in range(6):
+          exported_auth = await client.invoke(
+              raw.functions.auth.ExportAuthorization(dc_id=file_id.dc_id))
+
+          try:
+            await media_session.invoke(
+                raw.functions.auth.ImportAuthorization(
+                    id=exported_auth.id, bytes=exported_auth.bytes))
+            break
+          except AuthBytesInvalid:
+            logging.debug(
+                f"Invalid authorization bytes for DC {file_id.dc_id}")
+            continue
+        else:
+          await media_session.stop()
+          raise AuthBytesInvalid
+      else:
+        media_session = Session(
+            client,
+            file_id.dc_id,
+            await client.storage.auth_key(),
+            await client.storage.test_mode(),
+            is_media=True,
+        )
+        await media_session.start()
+      logging.debug(f"Created media session for DC {file_id.dc_id}")
+      client.media_sessions[file_id.dc_id] = media_session
+    else:
+      logging.debug(f"Using cached media session for DC {file_id.dc_id}")
+    return media_session
+
+  @staticmethod
+  async def get_location(
+      file_id: FileId
+  ) -> Union[
+      raw.types.InputPhotoFileLocation,
+      raw.types.InputDocumentFileLocation,
+      raw.types.InputPeerPhotoFileLocation,
+  ]:
+    """
+        Returns the file location for the media file.
+        """
+    file_type = file_id.file_type
+
+    if file_type == FileType.CHAT_PHOTO:
+      if file_id.chat_id > 0:
+        peer = raw.types.InputPeerUser(user_id=file_id.chat_id,
+                                       access_hash=file_id.chat_access_hash)
+      else:
+        if file_id.chat_access_hash == 0:
+          peer = raw.types.InputPeerChat(chat_id=-file_id.chat_id)
+        else:
+          peer = raw.types.InputPeerChannel(
+              channel_id=utils.get_channel_id(file_id.chat_id),
+              access_hash=file_id.chat_access_hash,
+          )
+
+      location = raw.types.InputPeerPhotoFileLocation(
+          peer=peer,
+          volume_id=file_id.volume_id,
+          local_id=file_id.local_id,
+          big=file_id.thumbnail_source == ThumbnailSource.CHAT_PHOTO_BIG,
+      )
+    elif file_type == FileType.PHOTO:
+      location = raw.types.InputPhotoFileLocation(
+          id=file_id.media_id,
+          access_hash=file_id.access_hash,
+          file_reference=file_id.file_reference,
+          thumb_size=file_id.thumbnail_size,
+      )
+    else:
+      location = raw.types.InputDocumentFileLocation(
+          id=file_id.media_id,
+          access_hash=file_id.access_hash,
+          file_reference=file_id.file_reference,
+          thumb_size=file_id.thumbnail_size,
+      )
+    return location
+
+  async def yield_file(
+      self,
+      file_id: FileId,
+      index: int,
+      offset: int,
+      first_part_cut: int,
+      last_part_cut: int,
+      part_count: int,
+      chunk_size: int,
+  ) -> Union[str, None]:
+
+    client = self.client
+    work_loads[index] += 1
+    logging.debug(f"Starting to yielding file with client {index}.")
+    media_session = await self.generate_media_session(client, file_id)
+
+    current_part = 1
+
+    location = await self.get_location(file_id)
+
+    try:
+      r = await media_session.invoke(
+          raw.functions.upload.GetFile(location=location,
+                                       offset=offset,
+                                       limit=chunk_size), )
+      if isinstance(r, raw.types.upload.File):
+        while True:
+          chunk = r.bytes
+          if not chunk:
+            break
+          elif part_count == 1:
+            yield chunk[first_part_cut:last_part_cut]
+          elif current_part == 1:
+            yield chunk[first_part_cut:]
+          elif current_part == part_count:
+            yield chunk[:last_part_cut]
+          else:
+            yield chunk
+
+          current_part += 1
+          offset += chunk_size
+
+          if current_part > part_count:
+            break
+
+          r = await media_session.invoke(
+              raw.functions.upload.GetFile(location=location,
+                                           offset=offset,
+                                           limit=chunk_size), )
+    except (TimeoutError, AttributeError):
+      pass
+    finally:
+      logging.debug(f"Finished yielding file with {current_part} parts.")
+      work_loads[index] -= 1
+
+  async def clean_cache(self) -> None:
+    """
+        function to clean the cache to reduce memory usage
+        """
+    while True:
+      await asyncio.sleep(self.clean_timer)
+      self.cached_file_ids.clear()
+      logging.debug("Cleaned the cache")

FileStream/utils/FileProcessors/custom_mix.py

@@ -0,0 +1,385 @@
+import asyncio
+import logging
+import asyncio
+import functools
+import logging
+import math
+import inspect
+from hashlib import md5
+from typing import Dict, Union, BinaryIO, Callable
+from pyrogram import Client, utils, raw
+from pyrogram.session import Session, Auth
+from pyrogram.errors import AuthBytesInvalid
+from pyrogram.file_id import FileId, FileType, ThumbnailSource
+from pyrogram.types import Message
+from pyrogram import StopTransmission
+
+from FileStream.bot import work_loads
+from typing import Dict, Union
+from FileStream.bot import work_loads
+from pyrogram import Client, utils, raw
+from .file_properties import get_file_ids
+from pyrogram.session import Session, Auth
+from pyrogram.errors import AuthBytesInvalid
+from pyrogram.file_id import FileId, FileType, ThumbnailSource
+from typing import Union, BinaryIO, List, Optional, Callable
+from pyrogram.types import Message
+import os
+import re
+from datetime import datetime
+import math
+import time
+import asyncio
+import pyrogram
+import traceback
+import functools
+from typing import Union, BinaryIO, List, Optional, Callable
+
+from pyrogram import raw
+from pyrogram import types
+from pyrogram import utils as pgutils
+from pyrogram import StopTransmission, enums
+from pyrogram.errors import FilePartMissing
+from pyrogram.file_id import FileType
+from pyrogram.enums import ParseMode, ChatType
+from pyrogram import filters, Client
+from pyrogram.errors import FloodWait
+from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
+from pyrogram.enums.parse_mode import ParseMode
+
+#-----------------------Local Imports----------------------------------#
+from FileStream import utils, StartTime, __version__
+from FileStream.bot import FileStream, multi_clients, work_loads
+from FileStream.utils.FileProcessors.bot_utils import is_user_banned, is_user_exist, is_user_joined, gen_link, is_channel_banned, is_channel_exist, is_user_authorized
+from FileStream.Database import Database
+from FileStream.utils.FileProcessors.file_properties import get_file_ids, get_file_info
+from FileStream.Tools.tool import TimeFormatter
+from FileStream.config import Telegram
+
+
+class TGFileController:
+
+  def __init__(self, client: Client):
+    self.clean_timer = 30 * 60
+    self.client: Client = client
+    self.cached_file_ids: Dict[str, FileId] = {}
+    asyncio.create_task(self.clean_cache())
+
+  async def clean_cache(self) -> None:
+    """
+    function to clean the cache to reduce memory usage
+    """
+    while True:
+      await asyncio.sleep(self.clean_timer)
+      self.cached_file_ids.clear()
+      print("Cleaned the cache")
+      logging.debug("Cleaned the cache")
+
+  async def get_me(self):
+    return await self.client.get_me().username
+
+  async def get_file_properties(self, db_id: str, multi_clients) -> FileId:
+    """
+        Returns the properties of a media of a specific message in a FIleId class.
+        if the properties are cached, then it'll return the cached results.
+        or it'll generate the properties from the Message ID and cache them.
+        """
+    if not db_id in self.cached_file_ids:
+      logging.debug("Before Calling generate_file_properties")
+      await self.generate_file_properties(db_id, multi_clients)
+      logging.debug(f"Cached file properties for file with ID {db_id}")
+    return self.cached_file_ids[db_id]
+
+  async def generate_file_properties(self, db_id: str,
+                                     multi_clients) -> FileId:
+    """
+        Generates the properties of a media file on a specific message.
+        returns ths properties in a FIleId class.
+        """
+    logging.debug("Before calling get_file_ids")
+    file_id = await get_file_ids(self.client, db_id, Message)
+    logging.debug(f"Generated file ID and Unique ID for file with ID {db_id}")
+    self.cached_file_ids[db_id] = file_id
+    logging.debug(f"Cached media file with ID {db_id}")
+    return self.cached_file_ids[db_id]
+
+  async def generate_media_session(self, client: Client,
+                                   file_id: FileId) -> Session:
+    """
+        Generates the media session for the DC that contains the media file.
+        This is required for getting the bytes from Telegram servers.
+        """
+
+    media_session = client.media_sessions.get(file_id.dc_id, None)
+
+    if media_session is None:
+      if file_id.dc_id != await client.storage.dc_id():
+        media_session = Session(
+            client,
+            file_id.dc_id,
+            await Auth(client, file_id.dc_id, await
+                       client.storage.test_mode()).create(),
+            await client.storage.test_mode(),
+            is_media=True,
+        )
+        await media_session.start()
+
+        for _ in range(6):
+          exported_auth = await client.invoke(
+              raw.functions.auth.ExportAuthorization(dc_id=file_id.dc_id))
+
+          try:
+            await media_session.invoke(
+                raw.functions.auth.ImportAuthorization(
+                    id=exported_auth.id, bytes=exported_auth.bytes))
+            break
+          except AuthBytesInvalid:
+            logging.debug(
+                f"Invalid authorization bytes for DC {file_id.dc_id}")
+            continue
+        else:
+          await media_session.stop()
+          raise AuthBytesInvalid
+      else:
+        media_session = Session(
+            client,
+            file_id.dc_id,
+            await client.storage.auth_key(),
+            await client.storage.test_mode(),
+            is_media=True,
+        )
+        await media_session.start()
+      logging.debug(f"Created media session for DC {file_id.dc_id}")
+      client.media_sessions[file_id.dc_id] = media_session
+    else:
+      logging.debug(f"Using cached media session for DC {file_id.dc_id}")
+    return media_session
+
+  @staticmethod
+  async def get_location(
+      file_id: FileId
+  ) -> Union[
+      raw.types.InputPhotoFileLocation,
+      raw.types.InputDocumentFileLocation,
+      raw.types.InputPeerPhotoFileLocation,
+  ]:
+    """
+        Returns the file location for the media file.
+        """
+    file_type = file_id.file_type
+
+    if file_type == FileType.CHAT_PHOTO:
+      if file_id.chat_id > 0:
+        peer = raw.types.InputPeerUser(user_id=file_id.chat_id,
+                                       access_hash=file_id.chat_access_hash)
+      else:
+        if file_id.chat_access_hash == 0:
+          peer = raw.types.InputPeerChat(chat_id=-file_id.chat_id)
+        else:
+          peer = raw.types.InputPeerChannel(
+              channel_id=utils.get_channel_id(file_id.chat_id),
+              access_hash=file_id.chat_access_hash,
+          )
+
+      location = raw.types.InputPeerPhotoFileLocation(
+          peer=peer,
+          volume_id=file_id.volume_id,
+          local_id=file_id.local_id,
+          big=file_id.thumbnail_source == ThumbnailSource.CHAT_PHOTO_BIG,
+      )
+    elif file_type == FileType.PHOTO:
+      location = raw.types.InputPhotoFileLocation(
+          id=file_id.media_id,
+          access_hash=file_id.access_hash,
+          file_reference=file_id.file_reference,
+          thumb_size=file_id.thumbnail_size,
+      )
+    else:
+      location = raw.types.InputDocumentFileLocation(
+          id=file_id.media_id,
+          access_hash=file_id.access_hash,
+          file_reference=file_id.file_reference,
+          thumb_size=file_id.thumbnail_size,
+      )
+    return location
+
+  async def send(self,
+                 media: Union["types.InputMedia", "types.InputMediaPhoto",
+                              "types.InputMediaVideo", "types.InputMediaAudio",
+                              "types.InputMediaAnimation",
+                              "types.InputMediaDocument",
+                              "types.InputPhoneContact"], caption: str,
+                 reply_to_msg_id: str, chat_id: Union[int, str]):
+    client = self.client
+    #while True:
+    try:
+      if reply_to_msg_id:
+        r = await client.invoke(
+            raw.functions.messages.SendMedia(
+                peer=await client.resolve_peer(chat_id),
+                media=media,
+                message=caption,
+                reply_to_msg_id=reply_to_msg_id,
+                random_id=client.rnd_id(),
+            ))
+      else:
+        print("This is the reply_to_msg_id")
+        r = await client.invoke(
+            raw.functions.messages.SendMedia(
+                peer=await client.resolve_peer(chat_id),
+                media=media,
+                message=caption,
+                random_id=client.rnd_id(),
+            ))
+
+    except Exception as e:
+      await client.send_message(chat_id=Telegram.ULOG_CHANNEL,
+                                text=f"**#EʀʀᴏʀTʀᴀᴄᴋᴇʙᴀᴄᴋ:** `{e}`",
+                                disable_web_page_preview=True)
+      print(
+          f"Cᴀɴ'ᴛ Eᴅɪᴛ Bʀᴏᴀᴅᴄᴀsᴛ Mᴇssᴀɢᴇ!\nEʀʀᴏʀ:  **Gɪᴠᴇ ᴍᴇ ᴇᴅɪᴛ ᴘᴇʀᴍɪssɪᴏɴ ɪɴ ᴜᴘᴅᴀᴛᴇs ᴀɴᴅ ʙɪɴ Cʜᴀɴɴᴇʟ!{traceback.format_exc()}**"
+      )
+    else:
+      for i in r.updates:
+        if isinstance(
+            i, (raw.types.UpdateNewMessage, raw.types.UpdateNewChannelMessage,
+                raw.types.UpdateNewScheduledMessage)):
+          return await types.Message._parse(
+              client,
+              i.message, {i.id: i
+                          for i in r.users}, {i.id: i
+                                              for i in r.chats},
+              is_scheduled=isinstance(i, raw.types.UpdateNewScheduledMessage))
+
+  async def upload_file(
+      self,
+      index: int,
+      file_id: FileId,
+      file_name: str,
+      file_size: int,
+      progress: Callable,
+      progress_args: tuple = ()) -> Union[str, None]:
+
+    async def worker(session):
+      while True:
+        data = await queue.get()
+
+        if data is None:
+          return
+
+        try:
+          await session.invoke(data)
+        except Exception as e:
+          log.exception(e)
+
+    client = self.client
+    part_size = 512 * 1024
+    file_id = file_id
+    index = index
+    chunk_size = part_size
+    file_name = file_name
+    file_size = file_size
+    if file_size == 0:
+      raise ValueError("File size equals to 0 B")
+
+    file_size_limit_mib = 4000 if client.me.is_premium else 2000
+    #file_size_limit_mib = 4000
+    if file_size > file_size_limit_mib * 1024 * 1024:
+      raise ValueError(
+          f"Can't upload files bigger than {file_size_limit_mib} MiB")
+
+    file_total_parts = int(math.ceil(file_size / part_size))
+    is_big = file_size > 10 * 1024 * 1024
+    workers_count = 4 if is_big else 1
+    #is_missing_part = file_id is not None
+    new_file_id = client.rnd_id()
+    if not is_big:
+      md5_sum = md5()
+
+    session = Session(client,
+                      await client.storage.dc_id(),
+                      await client.storage.auth_key(),
+                      await client.storage.test_mode(),
+                      is_media=True)
+    queue = asyncio.Queue(1)
+    workers = [
+        client.loop.create_task(worker(session)) for _ in range(workers_count)
+    ]
+
+    work_loads[index] += 1
+    logging.debug(f"Starting to yielding file with client {index}.")
+    media_session = await self.generate_media_session(client, file_id)
+
+    file_part = 0
+    offset = 0
+    location = await self.get_location(file_id)
+
+    try:
+      await session.start()
+      r = await media_session.invoke(
+          raw.functions.upload.GetFile(location=location,
+                                       offset=offset,
+                                       limit=chunk_size), )
+      if isinstance(r, raw.types.upload.File):
+        while True:
+          chunk = r.bytes
+          if not chunk:
+            break
+
+          if not is_big:
+            md5_sum.update(chunk)
+          if is_big:
+            rpc = raw.functions.upload.SaveBigFilePart(
+                file_id=new_file_id,
+                file_part=file_part,
+                file_total_parts=file_total_parts,
+                bytes=chunk)
+          else:
+            rpc = raw.functions.upload.SaveFilePart(file_id=new_file_id,
+                                                    file_part=file_part,
+                                                    bytes=chunk)
+
+          await queue.put(rpc)
+
+          file_part += 1
+          offset += chunk_size
+
+          if file_part >= file_total_parts:
+            break
+          r = await media_session.invoke(
+              raw.functions.upload.GetFile(location=location,
+                                           offset=offset,
+                                           limit=chunk_size), )
+
+          if progress:
+            func = functools.partial(progress,
+                                     min(file_part * part_size, file_size),
+                                     file_size, progress_args)
+
+            if inspect.iscoroutinefunction(progress):
+              await func()
+            else:
+              await client.loop.run_in_executor(client.executor, func)
+    except (TimeoutError, AttributeError):
+      pass
+    finally:
+      for _ in workers:
+        await queue.put(None)
+
+      await asyncio.gather(*workers)
+
+      await session.stop()
+      logging.debug(f"Finished yielding file with {file_part} parts.")
+      work_loads[index] -= 1
+
+    if is_big:
+      return raw.types.InputFileBig(
+          id=new_file_id,
+          parts=file_total_parts,
+          name=file_name,
+      )
+    else:
+      return raw.types.InputFile(id=new_file_id,
+                                 parts=file_total_parts,
+                                 name=file_name,
+                                 md5_checksum=md5_sum)

FileStream/utils/FileProcessors/custom_ul.py

@@ -0,0 +1,256 @@
+import traceback
+import urllib3
+from hashlib import md5
+from typing import Dict, Union, BinaryIO, Callable
+#------------------------------------------------------
+
+from pyrogram.session import Session
+from pyrogram.errors import FloodWait
+from pyrogram.enums.parse_mode import ParseMode
+from pyrogram import filters, types, Client, raw
+from pyrogram.file_id import FileId, FileType, PHOTO_TYPES, ThumbnailSource
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton, CallbackQuery
+#----------------------------------------------
+from FileStream.bot import FileStream, multi_clients, work_loads
+from FileStream.config import Telegram, Server
+from FileStream.Database import Database
+import asyncio
+from FileStream.utils.FileProcessors.translation import LANG, BUTTON
+from FileStream.utils.FileProcessors.bot_utils import gen_link, priv_func, gen_priv_file_link
+from FileStream.utils.FileProcessors.file_properties import get_file_ids, get_file_info
+
+db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+
+Hash = {}
+
+
+
+
+class TeleUploader:
+
+  def __init__(self, client: Client):
+    self.clean_timer = 30 * 60
+    self.client: Client = client
+    self.cached_file_ids: Dict[str, FileId] = {}
+    asyncio.create_task(self.clean_cache())
+
+    #print("\n* Client :", client, "\n")
+  async def clean_cache(self) -> None:
+    """
+        function to clean the cache to reduce memory usage
+        """
+    while True:
+      await asyncio.sleep(self.clean_timer)
+      self.cached_file_ids.clear()
+      print("Cleaned the cache")
+      logging.debug("Cleaned the cache")
+
+  async def get_me(self):
+    return await self.client.get_me().username
+
+  async def get_file_properties(self, db_id: str, multi_clients) -> FileId:
+    """
+      Returns the properties of a media of a specific message in a FIleId class.
+      if the properties are cached, then it'll return the cached results.
+      or it'll generate the properties from the Message ID and cache them.
+    """
+    if not db_id in self.cached_file_ids:
+      logging.debug("Before Calling generate_file_properties")
+      await self.generate_file_properties(db_id, multi_clients)
+      logging.debug(f"Cached file properties for file with ID {db_id}")
+    return self.cached_file_ids[db_id]
+
+  async def generate_media_session(self, client: Client,
+                                   file_id: FileId) -> Session:
+    """
+      Generates the media session for the DC that contains the media file.
+      This is required for getting the bytes from Telegram servers.
+    """
+
+    media_session = client.media_sessions.get(file_id.dc_id, None)
+
+    if media_session is None:
+      if file_id.dc_id != await client.storage.dc_id():
+        media_session = Session(
+            client,
+            file_id.dc_id,
+            await Auth(client, file_id.dc_id, await
+                       client.storage.test_mode()).create(),
+            await client.storage.test_mode(),
+            is_media=True,
+        )
+        await media_session.start()
+
+        for _ in range(6):
+          exported_auth = await client.invoke(
+              raw.functions.auth.ExportAuthorization(dc_id=file_id.dc_id))
+
+          try:
+            await media_session.invoke(
+                raw.functions.auth.ImportAuthorization(
+                    id=exported_auth.id, bytes=exported_auth.bytes))
+            break
+          except AuthBytesInvalid:
+            logging.debug(
+                f"Invalid authorization bytes for DC {file_id.dc_id}")
+            continue
+        else:
+          await media_session.stop()
+          raise AuthBytesInvalid
+      else:
+        media_session = Session(
+            client,
+            file_id.dc_id,
+            await client.storage.auth_key(),
+            await client.storage.test_mode(),
+            is_media=True,
+        )
+        await media_session.start()
+      logging.debug(f"Created media session for DC {file_id.dc_id}")
+      client.media_sessions[file_id.dc_id] = media_session
+    else:
+      logging.debug(f"Using cached media session for DC {file_id.dc_id}")
+    return media_session
+
+  def mime(self, filename):
+    import mimetypes
+    mime_type, encoding = mimetypes.guess_type(filename)
+
+    return mime_type
+
+  async def gen_session(self):
+    client = self.client
+
+    session = Session(client,
+                      await client.storage.dc_id(),
+                      await client.storage.auth_key(),
+                      await client.storage.test_mode(),
+                      is_media=True)
+
+    return session
+
+  async def upload_web_file(self, file_details, chunk):
+    client = self.client
+    """
+    These Name Are not Used Insted of that directly dictionary Name Used
+    file_name = file_details["file_name"]
+    file_size = file_details["file_size"]
+    file_part = file_details["file_part"]
+    total_parts = file_details["total_parts"]
+    upload_id = file_details["upload_id"]
+
+    """
+    file_details['file']["file_id"] = client.rnd_id()
+    #mime_type = file_details['file']["mime_type"]
+    response = dict(status="ok", message="ok")
+    if file_details["file"]["file_size"] == 0:
+      raise ValueError("File size equals to 0 B")
+
+    file_size_limit_mib = 4000 if client.me.is_premium else 2000
+    #file_size_limit_mib = 4000
+    if file_details["file"]["file_size"] > file_size_limit_mib * 1024 * 1024:
+      raise ValueError(
+          f"Can't upload files bigger than {file_size_limit_mib} MiB")
+
+    #file_total_parts = file_details["total_parts"]
+    #is_big = file_size > 10 * 1024 * 1024
+    is_big = file_details["file"]["file_size"] > 1
+    session = await self.gen_session()
+    await session.start()
+
+    file = await db.add_webfile(file_details)
+    #new_file_id = file["new_file_id"]
+    if not is_big or file_details["file"]["file_part"] == 0:
+      await client.send_message(
+          chat_id=Telegram.ULOG_GROUP,
+          text=f"Hi, I am just Started, Do Not Disturb Please",
+          disable_web_page_preview=True)
+      Hash['md5_sum'] = md5()
+
+    try:
+      if is_big:
+        rpc = raw.functions.upload.SaveBigFilePart(
+            file_id=file['file']["file_id"],
+            file_part=file_details["file"]["file_part"],
+            file_total_parts=file_details["file"]["total_parts"],
+            bytes=chunk)
+        response['status'] = "success"
+        response[
+            'message'] = f"Uploading as Bigfile {file_details['file']['file_part']}/{file_details['file']['total_parts']}"
+        print("Response", response)
+
+      await session.invoke(rpc)
+
+    except (TimeoutError, AttributeError):
+      pass
+    if file_details['file'][
+        "file_part"] == file_details['file']["total_parts"] - 1:
+      print("Final Function")
+      if is_big:
+        final = raw.types.InputFileBig(
+            id=file['file']["file_id"],
+            parts=file_details['file']["total_parts"],
+            name=file_details['file']["file_name"],
+        )
+
+      media = raw.types.InputMediaUploadedDocument(
+          file=final,
+          mime_type=file_details['file']["mime_type"],
+          attributes=[
+              raw.types.DocumentAttributeFilename(
+                  file_name=file_details['file']["file_name"])
+          ])
+
+      try:
+        msgs = await client.invoke(
+            raw.functions.messages.SendMedia(
+                peer=await client.resolve_peer(Telegram.FLOG_CHANNEL),
+                media=media,
+                message=file_details['file']["file_name"],
+                random_id=file['file']["file_id"]))
+
+        #print(msgs)
+        message = await FileStream.send_message(
+            Telegram.ULOG_GROUP, "Message sent with **Pyrogram**!")
+        message_id = getattr(
+            getattr(getattr(msgs, "updates", "")[1], "message", ""), "id", "")
+
+        print("Printing  msg-id", message_id)
+        chat_id = Telegram.FLOG_CHANNEL
+        print("Printing ", message_id, chat_id)
+        MessageFile = await FileStream.get_messages(chat_id, message_id)
+        #print("Printing MessageFile", MessageFile)
+        instruction = {
+            "privacy_type": "PRIVATE",
+            "user_id": file_details["user_id"],
+            "user_type": "WEB"
+        }
+        file_info = get_file_info(MessageFile, instruction)
+        print("Printing file_info", file_info)
+
+        await db.uploaded_web_file(file_details["dropzone_id"])
+        
+        # Here we are Adding the File Into the database First
+        #await db.add_webfile(file_info)
+        inserted_id = await db.add_file(file_info)
+        await get_file_ids(False, inserted_id, MessageFile)
+        reply_markup, stream_text = await gen_link(_id=inserted_id)
+        await message.edit_text(
+            text=stream_text,
+            parse_mode=ParseMode.HTML,
+            disable_web_page_preview=True,
+            reply_markup=reply_markup,
+        )
+
+        #log_msg = await send_file(FileStream, db_id, file_info['file_id'], message)
+        #await update_file_id(log_msg.id, multi_clients))
+      except Exception as e:
+        await client.send_message(chat_id=Telegram.ULOG_GROUP,
+                                  text=f"**#EʀʀᴏʀTʀᴀᴄᴋᴇʙᴀᴄᴋ:** `{e}`",
+                                  disable_web_page_preview=True)
+        print(
+            f"Cᴀɴ'ᴛ Eᴅɪᴛ Bʀᴏᴀᴅᴄᴀsᴛ Mᴇssᴀɢᴇ!\nEʀʀᴏʀ:  **Gɪᴠᴇ ᴍᴇ ᴇᴅɪᴛ ᴘᴇʀᴍɪssɪᴏɴ ɪɴ ᴜᴘᴅᴀᴛᴇs ᴀɴᴅ ʙɪɴ Cʜᴀɴɴᴇʟ!{traceback.format_exc()}**"
+        )
+      await session.stop()
+
+    return response

FileStream/utils/FileProcessors/file_properties.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+import logging
+from datetime import datetime
+from pyrogram import Client
+from typing import Any, Optional
+
+from pyrogram.enums import ParseMode, ChatType
+from pyrogram.types import Message
+from pyrogram.file_id import FileId
+#-----------------------------------------------------
+from FileStream.bot import FileStream, multi_clients
+from FileStream.Database import Database
+from FileStream.config import Telegram, Server
+from FileStream.Tools import Time_ISTKolNow
+from FileStream.Tools.cleanup import clean_text
+
+db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+
+
+async def send_file(client: Client, db_id, file_id: str, message, send_to):
+  file_caption = getattr(message, 'caption', None) or get_name(message)
+  log_msg = await client.send_cached_media(chat_id=send_to, file_id=file_id, caption=f"**{file_caption}**")
+
+  if message.chat.type == ChatType.PRIVATE:
+    await log_msg.reply_text(
+        text=
+        f"**RᴇQᴜᴇꜱᴛᴇᴅ ʙʏ :** [{message.from_user.first_name}](tg://user?id={message.from_user.id})\n**Uꜱᴇʀ ɪᴅ :** `{message.from_user.id}`\n**Fɪʟᴇ ɪᴅ :** `{db_id}`",
+        disable_web_page_preview=True,
+        parse_mode=ParseMode.MARKDOWN,
+        quote=True)
+  else:
+    await log_msg.reply_text(
+        text=
+        f"**RᴇQᴜᴇꜱᴛᴇᴅ ʙʏ :** {message.chat.title} \n**Cʜᴀɴɴᴇʟ ɪᴅ :** `{message.chat.id}`\n**Fɪʟᴇ ɪᴅ :** `{db_id}`",
+        disable_web_page_preview=True,
+        parse_mode=ParseMode.MARKDOWN,
+        quote=True)
+
+  return {"message": log_msg, "sent_to": send_to}
+
+
+async def update_file_id(message, multi_clients):
+  file_ids = {}
+  for client_id, client in multi_clients.items():
+    #log_msg = await client.get_messages(message['location'],message['message_id'])
+    media = get_media_from_message(await client.get_messages(message['location'],message['message_id']))
+    file_ids[str(client.id)] = getattr(media, "file_id", "")
+
+  return file_ids
+
+
+#------------------------------------Update Private File IDs------------------------------------#
+async def get_private_file_ids(client: Client | bool, db_id: str,message) -> Optional[FileId]:
+  file_info = await db.get_private_file(db_id)
+  file_id_info = file_info.setdefault("file_ids", {})
+  if not str(client.id) in file_id_info:
+    logging.debug("Storing file_id in DB")
+    #msg = await client.get_messages(Telegram.PFLOG_CHANNEL,file_info['message_id'])
+    media = get_media_from_message(await client.get_messages(
+        Telegram.PFLOG_CHANNEL, file_info['message_id']))
+    file_id_info[str(client.id)] = getattr(media, "file_id", "")
+    await db.update_private_file_ids(db_id, file_id_info)
+    logging.debug("Stored file_id in DB")
+    file_info = await db.get_private_file(db_id)
+    return file_info[str(client.id)]
+  if not client:
+    return file_info['file']['file_id']
+
+
+#------------------------Update Public File ID s ---------------------------  #
+async def get_file_ids(client: Client | bool, db_id: str, message) -> Optional[FileId]:
+
+  logging.debug("Starting of get_file_ids")
+  file_info = await db.get_file(db_id)
+
+  if (not "file_ids" in file_info) or not client:
+    if file_info['user_type'] == "TELEGRAM":
+      if file_info['location'] in Telegram.DATA_SOURCES:
+        print("Already Present in Data Sources ", Telegram.DATA_SOURCES)
+      else:
+        log_msg = await send_file(FileStream, db_id,file_info['file']['file_id'], message,Telegram.FLOG_CHANNEL)
+        #updated_info = update_file_info(log_msg)
+        await db.update_file_info(db_id, update_file_info(log_msg))
+        await db.update_file_ids(db_id, await update_file_id(await db.get_file(db_id),multi_clients))
+
+      logging.debug("Stored file_id of all clients in DB")
+      if not client:
+        return
+      file_info = await db.get_file(db_id)
+
+    if file_info['user_type'] == "WEB":
+      await db.update_file_ids(db_id, await update_file_id(await db.get_file(db_id), multi_clients))
+      logging.debug("Stored file_id of all clients in DB")
+      if not client:
+        return
+      file_info = await db.get_file(db_id)
+
+  file_id_info = file_info.setdefault("file_ids", {})
+  if not str(client.id) in file_id_info:
+    logging.debug("Storing file_id in DB")
+    #log_msg = await send_file(FileStream, db_id, file_info['file_id'], message,Telegram.FLOG_CHANNEL)
+    msg = await client.get_messages(file_info['location'],file_info['message_id'])
+    media = get_media_from_message(msg)
+    file_id_info[str(client.id)] = getattr(media, "file_id", "")
+    await db.update_file_ids(db_id, file_id_info)
+    logging.debug("Stored file_id in DB")
+
+  logging.debug("Middle of get_file_ids")
+  file_id = FileId.decode(file_id_info[str(client.id)])
+  setattr(file_id, "file_size", file_info['file']['file_size'])
+  setattr(file_id, "mime_type", file_info['file']['mime_type'])
+  setattr(file_id, "file_name", file_info['file']['file_name'])
+  setattr(file_id, "unique_id", file_info['file']['file_unique_id'])
+  logging.debug("Ending of get_file_ids")
+  return file_id
+
+
+#------------------------------
+def get_media_from_message(message: "Message") -> Any:
+  media_types = (
+      "audio",
+      "document",
+      "photo",
+      "sticker",
+      "animation",
+      "video",
+      "voice",
+      "video_note",
+  )
+  for attr in media_types:
+    media = getattr(message, attr, None)
+    if media:
+      return media
+
+
+def get_media_file_size(m):
+  media = get_media_from_message(m)
+  return getattr(media, "file_size", "None")
+
+
+def get_name(media_msg: Message | FileId) -> str:
+  if isinstance(media_msg, Message):
+    media = get_media_from_message(media_msg)
+    file_name = getattr(media, "file_name", "")
+
+  elif isinstance(media_msg, FileId):
+    file_name = getattr(media_msg, "file_name", "")
+
+  if not file_name:
+    if isinstance(media_msg, Message) and media_msg.media:
+      media_type = media_msg.media.value
+    elif media_msg.file_type:
+      media_type = media_msg.file_type.name.lower()
+    else:
+      media_type = "file"
+
+    formats = {
+        "photo": "jpg",
+        "audio": "mp3",
+        "voice": "ogg",
+        "video": "mp4",
+        "animation": "mp4",
+        "video_note": "mp4",
+        "sticker": "webp"
+    }
+
+    ext = formats.get(media_type)
+    ext = "." + ext if ext else ""
+
+    date = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    file_name = f"{media_type}-{date}{ext}"
+
+  return file_name
+
+
+def get_file_info(message, instruction):
+  media = get_media_from_message(message)
+  """
+  //Used a single Liner Insted of this Block
+  if message.chat.type == ChatType.PRIVATE:
+      user_idx = message.from_user.id
+  else:
+      user_idx = message.chat.id
+  """
+
+  return {
+      "user_id": instruction['user_id'],
+      "user_type": instruction['user_type'],
+      "message_id": message.id,
+      "location": message.from_user.id if (message.chat.type == ChatType.PRIVATE) else message.chat.id,
+      "file": {
+          "file_id": getattr(media, "file_id", ""),
+          "caption": clean_text(getattr(message, "caption", f"{get_name(message)}")),
+          "file_unique_id": getattr(media, "file_unique_id", ""),
+          "file_name": get_name(message),
+          "file_size": getattr(media, "file_size", 0),
+          "mime_type": getattr(media, "mime_type", "None/unknown"),
+          "tagged_users": {
+              str(message.from_user.id) if (message.chat.type == ChatType.PRIVATE) else str(Telegram.OWNER_ID): instruction['privacy_type']
+          }
+      },
+      "time":Time_ISTKolNow(),
+      "privacy_type":instruction['privacy_type']
+  }
+
+
+def update_file_info(updates):
+  media = get_media_from_message(updates['message'])
+  return {
+      "message_id": updates['message'].id,
+      "location": updates['sent_to'],
+      "file": {
+          "file_id":getattr(media, "file_id", ""),
+          "caption":clean_text(getattr(updates['message'], "caption",f"{get_name(updates['message'])}")),
+          "file_unique_id":getattr(media, "file_unique_id", ""),
+          "file_name":get_name(updates['message']),
+          "file_size":getattr(media, "file_size", 0),
+          "mime_type":getattr(media, "mime_type", "None/unknown"),
+          "tagged_users": {}
+      },
+  }

FileStream/utils/FileProcessors/human_readable.py

@@ -0,0 +1,10 @@
+def humanbytes(size):
+    if not size:
+        return ""
+    power = 2**10
+    n = 0
+    Dic_powerN = {0: ' ', 1: 'Ki', 2: 'Mi', 3: 'Gi', 4: 'Ti'}
+    while size > power:
+        size /= power
+        n += 1
+    return str(round(size, 2)) + " " + Dic_powerN[n] + 'B'

FileStream/utils/FileProcessors/time_format.py

@@ -0,0 +1,26 @@
+def get_readable_time(seconds: int) -> str:
+    count = 0
+    readable_time = ""
+    time_list = []
+    time_suffix_list = ["s", "m", "h", " days"]
+    while count < 4:
+        count += 1
+        if count < 3:
+            remainder, result = divmod(seconds, 60)
+        else:
+            remainder, result = divmod(seconds, 24)
+        if seconds == 0 and remainder == 0:
+            break
+        time_list.append(int(result))
+        seconds = int(remainder)
+    for x in range(len(time_list)):
+        time_list[x] = str(time_list[x]) + time_suffix_list[x]
+    if len(time_list) == 4:
+        readable_time += time_list.pop() + ", "
+    time_list.reverse()
+    readable_time += ": ".join(time_list)
+    return readable_time
+
+
+
+  

FileStream/utils/FileProcessors/translation.py

@@ -0,0 +1,120 @@
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from FileStream.config import Telegram
+from FileStream.bot import FileStream
+
+
+class LANG(object):
+
+    START_TEXT = """
+<b>👋 Hᴇʏ, </b>{}\n 
+<b>I'ᴍ ᴛᴇʟᴇɢʀᴀᴍ ғɪʟᴇs sᴛʀᴇᴀᴍɪɴɢ ʙᴏᴛ ᴀs ᴡᴇʟʟ ᴅɪʀᴇᴄᴛ ʟɪɴᴋs ɢᴇɴᴇʀᴀᴛᴏʀ</b>\n
+<b>ᴡᴏʀᴋɪɴɢ ᴏɴ ᴄʜᴀɴɴᴇʟs ᴀɴᴅ ᴘʀɪᴠᴀᴛᴇ ᴄʜᴀᴛ</b>\n
+<b>💕 @{}</b>\n"""
+
+    HELP_TEXT = """
+<b>- ᴀᴅᴅ ᴍᴇ ᴀs ᴀɴ ᴀᴅᴍɪɴ ᴏɴ ᴛʜᴇ ᴄʜᴀɴɴᴇʟ</b>
+<b>- sᴇɴᴅ ᴍᴇ ᴀɴʏ ᴅᴏᴄᴜᴍᴇɴᴛ ᴏʀ ᴍᴇᴅɪᴀ</b>
+<b>- ɪ'ʟʟ ᴘʀᴏᴠɪᴅᴇ sᴛʀᴇᴀᴍᴀʙʟᴇ ʟɪɴᴋ</b>\n
+<b>🔞 ᴀᴅᴜʟᴛ ᴄᴏɴᴛᴇɴᴛ sᴛʀɪᴄᴛʟʏ ᴘʀᴏʜɪʙɪᴛᴇᴅ.</b>\n
+<i><b> ʀᴇᴘᴏʀᴛ ʙᴜɢs ᴛᴏ <a href='#'>ᴅᴇᴠᴇʟᴏᴘᴇʀ</a></b></i>"""
+
+    ABOUT_TEXT = """
+<b>⚜ ᴍʏ ɴᴀᴍᴇ : {}</b>\n
+<b>✦ ᴠᴇʀsɪᴏɴ : {}</b>
+<b>✦ ᴜᴘᴅᴀᴛᴇᴅ ᴏɴ : 06-January-2024</b>
+<b>✦ ᴅᴇᴠᴇʟᴏᴘᴇʀ  : <a href='https://t.me/blendersb'>BlendersBD</a></b>
+<b>✦ CREDIT & SPECIAL Thanks To : <a href='https://github.com/avipatilpro/FileStreamBot'>Avishkar Patil & This Repo Owners </a></b>
+\n
+"""
+
+    STREAM_TEXT = """
+<i><u>𝗬𝗼𝘂𝗿 𝗟𝗶𝗻𝗸 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗲𝗱 !</u></i>\n
+<b>📂 Fɪʟᴇ ɴᴀᴍᴇ :</b> <b><code>{}</code></b>\n
+<b>📦 Fɪʟᴇ ꜱɪᴢᴇ :</b> <code>{}</code>\n
+<b>📥 Dᴏᴡɴʟᴏᴀᴅ :</b> <code>{}</code>\n
+<b>🖥 Wᴀᴛᴄʜ :</b> <code>{}</code>\n
+<b>🔗 Sʜᴀʀᴇ :</b> <code>{}</code>\n"""
+
+    STREAM_TEXT_Y = """
+<b>🪂 : 𝔹𝕊ℙ𝔸ℝ𝕂 𝔻ℝ𝕀𝕍𝔼 : 🪂</b>\n
+<b>📂 Fɪʟᴇ ɴᴀᴍᴇ :</b> <b>{}</b>\n
+<b>📦 Fɪʟᴇ ꜱɪᴢᴇ :</b> <code>{}</code>\n
+  """
+
+    STREAM_TEXT_X = """
+<i>Chose where you wand to upload this file !</i>\n
+<b>📂 Fɪʟᴇ ɴᴀᴍᴇ :</b> <b>{}</b>\n
+<b>📦 Fɪʟᴇ ꜱɪᴢᴇ :</b> <code>{}</code>\n
+<b>📥 Dᴏᴡɴʟᴏᴀᴅ :</b> <code>{}</code>\n
+<b>🔗 Sʜᴀʀᴇ :</b> <code>{}</code>\n"""
+
+    PRIV_FILE_RENAME = """
+  <b>🪂 : 𝔹𝕊ℙ𝔸ℝ𝕂 𝔻ℝ𝕀𝕍𝔼 : 🪂</b>\n
+  <i>🅄🄿🄻🄾🄰🄳 🄵🄸🄻🄴 🄸🄽 🄿🅁🄸🅅🄰🅃🄴 🅂🄿🄰🄲🄴</i>\n
+  <b>📂 Fɪʟᴇ ɴᴀᴍᴇ :</b> <b><code>{}</code></b>\n
+  <b>📦 Fɪʟᴇ ꜱɪᴢᴇ :</b> <code>{}</code>\n
+  <b>ɪꜰ ʏᴏᴜ ᴜᴘʟᴏᴀᴅ ᴡɪᴛʜ ᴅɪꜰꜰᴇʀᴇɴᴛ ɴᴀᴍᴇ ᴘʟᴇᴀꜱᴇ ʀᴇᴘʟʏ ᴛʜɪꜱ ᴍᴇꜱꜱᴀɢᴇ ᴡɪᴛʜ ɴᴇᴡ ɴᴀᴍᴇ </b>\n
+  <b>ᴏʀ ʀᴇᴘʟʏ ᴡɪᴛʜ N or No ꜰᴏʀ ᴜᴘʟᴏᴀᴅ ᴡɪᴛʜ ᴏʀɪɢɪɴᴀʟ ɴᴀᴍᴇ</b>\n"""
+
+    SUCCESS_PRIV_FILE = """
+  <b>🪂 : 𝔹𝕊ℙ𝔸ℝ𝕂 𝔻ℝ𝕀𝕍𝔼 : 🪂</b>\n
+  <i>!! ꜰɪʟᴇ ᴜᴄᴄᴇꜱꜱꜰᴜʟʟʏ ᴜᴘʟᴏᴀᴅᴇᴅ ᴛᴏ ᴘʀɪᴠᴀᴛᴇ ꜱᴘᴀᴄᴇ !!</i>\n
+  <b>📂 Fɪʟᴇ ɴᴀᴍᴇ :</b> <b>{}</b>\n
+  <b>📦 Fɪʟᴇ ꜱɪᴢᴇ :</b> <code>{}</code>\n"""
+    BASIC_PRIV_FILE = """
+  <b>🪂 : 𝔹𝕊ℙ𝔸ℝ𝕂 𝔻ℝ𝕀𝕍𝔼 : 🪂</b>\n
+  <i>----------------------------------------------------------------------------</i>\n
+  <b>📂 Fɪʟᴇ ɴᴀᴍᴇ :</b> <b>{}</b>\n
+  <b>📦 Fɪʟᴇ ꜱɪᴢᴇ :</b> <code>{}</code>\n"""
+
+    HEART_EMOJI = [
+        '💘', '💝', '💖', '💗', '💓', '💞', '💟', '❣️', '💔', '❤️', '🧡', '💛', '💚', '💙',
+        '💜', '🤎', '🖤', '🤍'
+    ]
+
+    BAN_TEXT = "__Sᴏʀʀʏ Sɪʀ, Yᴏᴜ ᴀʀᴇ Bᴀɴɴᴇᴅ ᴛᴏ ᴜsᴇ ᴍᴇ.__\n\n**[Cᴏɴᴛᴀᴄᴛ Dᴇᴠᴇʟᴏᴘᴇʀ](tg://user?id={}) Tʜᴇʏ Wɪʟʟ Hᴇʟᴘ Yᴏᴜ**"
+
+    PROGRESS_BAR = """\n
+  ╭━━━━❰ᴘʀᴏɢʀᴇss ʙᴀʀ❱━➣
+  ┣⪼ 🗂️ : {current} | {total}
+  ┣⪼ ⏳️ : {percentage}%
+  ┣⪼ 🚀 : {speed}/s
+  ┣⪼ ⏱️ : {est_time}
+  ╰━━━━━━━━━━━━━━━➣ """
+
+
+class BUTTON(object):
+
+    START_BUTTONS = InlineKeyboardMarkup(
+        [[
+            InlineKeyboardButton('ʜᴇʟᴘ', callback_data='help'),
+            InlineKeyboardButton('ᴀʙᴏᴜᴛ', callback_data='about'),
+            InlineKeyboardButton('ᴄʟᴏsᴇ', callback_data='close')
+        ],
+         [
+             InlineKeyboardButton(
+                 "📢 ᴜᴘᴅᴀᴛᴇ ᴄʜᴀɴɴᴇʟ",
+                 url=f'https://t.me/{Telegram.UPDATES_CHANNEL}')
+         ]])
+    HELP_BUTTONS = InlineKeyboardMarkup(
+        [[
+            InlineKeyboardButton('ʜᴏᴍᴇ', callback_data='home'),
+            InlineKeyboardButton('ᴀʙᴏᴜᴛ', callback_data='about'),
+            InlineKeyboardButton('ᴄʟᴏsᴇ', callback_data='close'),
+        ],
+         [
+             InlineKeyboardButton(
+                 "📢 ᴜᴘᴅᴀᴛᴇ ᴄʜᴀɴɴᴇʟ",
+                 url=f'https://t.me/{Telegram.UPDATES_CHANNEL}')
+         ]])
+    ABOUT_BUTTONS = InlineKeyboardMarkup(
+        [[
+            InlineKeyboardButton('ʜᴏᴍᴇ', callback_data='home'),
+            InlineKeyboardButton('ʜᴇʟᴘ', callback_data='help'),
+            InlineKeyboardButton('ᴄʟᴏsᴇ', callback_data='close'),
+        ],
+         [
+             InlineKeyboardButton(
+                 "📢 ᴜᴘᴅᴀᴛᴇ ᴄʜᴀɴɴᴇʟ",
+                 url=f'https://t.me/{Telegram.UPDATES_CHANNEL}')
+         ]])

FileStream/utils/__init__.py

@@ -0,0 +1,3 @@
+from .FileProcessors import get_readable_time
+from .FileProcessors import get_name, get_file_ids
+from .FileProcessors import ByteStreamer

app.json

@@ -0,0 +1,117 @@
+{
+  "name": "FileStreamBot",
+  "description": "A Telegram Bot to Convert Telegram Files To Direct & Streamable Links.",
+  "keywords": [
+        "telegram",
+        "files",
+        "stream"
+    ],
+  "repository": "https://github.com/avipatilpro/FileStreamBot/",
+  "success_url": "/",
+  "logo": "https://i.ibb.co/ZJzJ9Hq/link-3x.png",
+  "env": {
+    "ENV": {
+      "description": "Set this to True if you don't want to crash the bot",
+      "value": "True"
+    },
+    "API_ID": {
+      "description": "Get this value from https://my.telegram.org"
+    },
+    "API_HASH": {
+      "description": "Get this value from https://my.telegram.org"
+    },
+    "BOT_TOKEN": {
+      "description": "Get this value from @BotFather"
+    },
+    "FLOG_CHANNEL": {
+      "description": "ID of Channel Where store files sent by users. Read the readme for more info about this var"
+    },
+    "ULOG_CHANNEL": {
+      "description": "ID of Channel Where store New Users data. Read the readme for more info about this var"
+    },
+    "OWNER_ID": {
+      "description": "Your Telegram User ID as Owner"
+    },
+    "DATABASE_URL": {
+      "description": "MongoDB URI for saving User Data and Files List created by user."
+    },
+    "AUTH_USERS": {
+      "description": "Put IDs of Auth Usrs where bot will work. You can add multiple IDs & separate with Space.",
+      "required": false
+    },
+    "UPDATES_CHANNEL": {
+      "description": "Channel Username without `@` to set channel as Update Channel",
+      "required": false
+    },
+    "FORCE_SUB_ID": {
+      "description": "Channel ID starts with -100 to set channel as Force Sub Channel",
+      "required": false
+    },
+    "FORCE_SUB": {
+      "description": "Set to True, so every user have to Join update channel to use the bot.",
+      "required": false
+    },
+    "SLEEP_THRESHOLD": {
+      "description": "Set global flood wait threshold, auto-retry requests under 60s. ",
+      "required": false
+    },
+    "WORKERS": {
+      "description": "No. of workers that is to be assigned.",
+      "required": false
+    },
+    "PORT": {
+      "description": "The port that you want your webapp to be listened to",
+      "required": false
+    },
+    "NO_PORT": {
+      "description": "If you don't want your port to be displayed. Set True or False",
+      "value": "True",
+      "required": false
+    },
+    "HAS_SSL": {
+      "description": "(can be either True or False) If you want the generated links in https format.",
+      "value": "True",
+      "required": false
+    },
+    "BIND_ADDRESS": {
+      "description": "Your server bind address. default to 0.0.0.0",
+      "required": false
+    },
+    "FQDN": {
+      "description": "Heroku app Link without http/s://, you can set later. its required",
+      "required": false
+    },
+    "SESSION_NAME": {
+      "description": "Name for the Database created on your MongoDB. Defaults to FileStream",
+      "required": false
+    },
+    "FILE_PIC": {
+      "description": "To set Image at /files command. Defaults to pre-set image.",
+      "required": false
+    },
+    "START_PIC": {
+      "description": "To set Image at /start command. Defaults to pre-set image.",
+      "required": false
+    },
+    "VERIFY_PIC": {
+      "description": "To set Image at Force Subscribe Verify. Defaults to pre-set image.",
+      "required": false
+    },
+    "MODE": {
+      "description": "Should be set to `secondary` if you only want to use the server for serving files.",
+      "required": false
+    }
+  },
+  "buildpacks": [
+    {
+      "url": "heroku/python"
+    }
+  ],
+  "stack": "heroku-22",
+  "formation": {
+    "web": {
+      "quantity": 1,
+      "size": "eco"
+    }
+  }
+}

requirement.txt

@@ -0,0 +1,29 @@
+tmdbv3api==1.9.0
+aiofiles==23.2.1
+aiohttp==3.9.3
+aiosignal==1.3.1
+aiosqlite==0.20.0
+async-timeout==4.0.3
+attrs==23.2.0
+certifi==2024.2.2
+charset-normalizer==3.3.2
+dnspython==2.6.1
+frozenlist==1.4.1
+idna==3.6
+Jinja2==3.1.3
+MarkupSafe==2.1.5
+motor==3.3.2
+multidict==6.0.5
+pyaes==1.6.1
+pymediainfo-pyrofork==6.0.1
+pymongo==4.6.2
+pyrofork==2.3.19.post2
+pyrogram-repl==2.0.106
+PySocks==1.7.1
+python-dotenv==1.0.1
+pytz==2024.1
+requests==2.31.0
+TgCrypto==1.2.5
+typing_extensions==4.10.0
+urllib3==2.2.1
+yarl==1.9.4

streambot.log

@@ -0,0 +1,407 @@
+[16/09/2024 21:08:11] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 350, in data_received
+    messages, upgraded, tail = self._request_parser.feed_data(data)
+                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "aiohttp\\_http_parser.pyx", line 557, in aiohttp._http_parser.HttpParser.feed_data
+aiohttp.http_exceptions.BadStatusLine: 400, message:
+  Invalid method encountered:
+
+    bytearray(b'\x16\x03\x01')
+                 ^
+[16/09/2024 21:08:18] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 350, in data_received
+    messages, upgraded, tail = self._request_parser.feed_data(data)
+                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "aiohttp\\_http_parser.pyx", line 557, in aiohttp._http_parser.HttpParser.feed_data
+aiohttp.http_exceptions.BadStatusLine: 400, message:
+  Invalid method encountered:
+
+    bytearray(b'\x16\x03\x01')
+                 ^
+[16/09/2024 21:09:12] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\pyrogram\methods\utilities\idle.py:76} INFO - Stop signal received (SIGINT). Exiting...
+[16/09/2024 21:12:50] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\pyrogram\methods\utilities\idle.py:76} INFO - Stop signal received (SIGINT). Exiting...
+[16/09/2024 21:28:38] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 105, in list_all_files
+    return web.Response(dumps(resp))
+           ^^^^^^^^^^^^^^^^^^^^^^^^^
+TypeError: Response.__init__() takes 1 positional argument but 2 were given
+[16/09/2024 21:30:48] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\pyrogram\methods\utilities\idle.py:76} INFO - Stop signal received (SIGINT). Exiting...
+[16/09/2024 21:34:39] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\pyrogram\methods\utilities\idle.py:76} INFO - Stop signal received (SIGINT). Exiting...
+[16/09/2024 21:35:42] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(row['_id']['$oid']),
+              ~~~~~~~~~~^^^^^^^^
+TypeError: 'ObjectId' object is not subscriptable
+[16/09/2024 21:36:20] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(row['_id']),
+              ^^^^^^^^^^^^^
+TypeError: 'ObjectId' object is not subscriptable
+[16/09/2024 21:37:13] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(ObjectId(row['_id'])),
+              ^^^^^^^^^^^^^^^^^^
+TypeError: 'ObjectId' object is not subscriptable
+[16/09/2024 21:42:07] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(row['_id']['to_string']),
+              ^^^^^^^^^^^^^^^^^^
+TypeError: 'ObjectId' object is not subscriptable
+[16/09/2024 21:43:00] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": row['_id'].to_dict(),
+              ^^^^^^^^^^^^^^^^^^
+TypeError: 'ObjectId' object is not subscriptable
+[16/09/2024 21:44:12] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": row['_id'].oid,
+              ^^^^^^^^^^^^
+TypeError: 'ObjectId' object is not subscriptable
+[16/09/2024 21:47:21] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": row["_id"],
+              ^^^^^^^^
+TypeError: 'ObjectId' object is not subscriptable
+[16/09/2024 21:47:49] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": row["id"],
+              ^^^^^^^
+TypeError: 'ObjectId' object is not subscriptable
+[16/09/2024 21:48:17] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": row["oid"],
+              ^^^^^^^^
+TypeError: 'ObjectId' object is not subscriptable
+[16/09/2024 21:48:38] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": row["$oid"],
+              ^^^^^^^^^
+TypeError: 'ObjectId' object is not subscriptable
+[16/09/2024 21:49:09] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": row['_id']["$oid"],
+              ^^^^^^^^^^^^^^^^
+TypeError: 'ObjectId' object is not subscriptable
+[16/09/2024 21:51:55] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\pyrogram\methods\utilities\idle.py:76} INFO - Stop signal received (SIGINT). Exiting...
+[16/09/2024 21:52:52] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": row['_id'].toString(),
+          ^^^^^^^^^^^^^^^^^^^
+AttributeError: 'ObjectId' object has no attribute 'toString'
+[16/09/2024 21:54:36] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(row._id),
+          ^^^^^^^^^^^^^^
+AttributeError: 'ObjectId' object has no attribute 'toString'
+[16/09/2024 21:54:53] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\pyrogram\methods\utilities\idle.py:76} INFO - Stop signal received (SIGINT). Exiting...
+[16/09/2024 21:55:27] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(row._id),
+              ^^^^^^^
+AttributeError: 'dict' object has no attribute '_id'
+[16/09/2024 21:57:41] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(row['_id'] * type(row['_id']) * row['id'].__dict__),
+              ^^^^^^^
+AttributeError: 'dict' object has no attribute '_id'
+[16/09/2024 21:58:13] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(row['_id'] * type(row['_id']) * row['_id'].__dict__),
+              ^^^^^^^
+AttributeError: 'dict' object has no attribute '_id'
+[16/09/2024 21:59:00] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\pyrogram\methods\utilities\idle.py:76} INFO - Stop signal received (SIGINT). Exiting...
+[16/09/2024 21:59:51] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(row['_id'] +"\n"+ type(row['_id']) +"\n"+ row['_id'].__dict__),
+              ~~~~~~~~~~~^~~~~
+TypeError: unsupported operand type(s) for +: 'ObjectId' and 'str'
+[16/09/2024 22:00:36] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(row['_id'] )+"*"+ type(row['_id']) +"*"+ row['_id'].__dict__,
+              ^^^^^^^^^^^^^^^^
+TypeError: unsupported operand type(s) for +: 'ObjectId' and 'str'
+[16/09/2024 22:01:17] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(type(row['_id'])),
+              ^^^^^^^^^^^^^^^^
+TypeError: unsupported operand type(s) for +: 'ObjectId' and 'str'
+[16/09/2024 22:08:40] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\pyrogram\methods\utilities\idle.py:76} INFO - Stop signal received (SIGINT). Exiting...
+[16/09/2024 22:15:21] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\pyrogram\methods\utilities\idle.py:76} INFO - Stop signal received (SIGINT). Exiting...
+[16/09/2024 22:16:08] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(type(row['_id'].oid)),
+                   ^^^^^^^^^^^^^^
+AttributeError: 'ObjectId' object has no attribute 'oid'
+[16/09/2024 22:20:48] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\pyrogram\methods\utilities\idle.py:76} INFO - Stop signal received (SIGINT). Exiting...
+[16/09/2024 22:21:17] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(type(row._id.valueOf())),
+                   ^^^^^^^
+AttributeError: 'dict' object has no attribute '_id'
+[16/09/2024 22:21:47] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(type(row['_id'].valueOf())),
+                   ^^^^^^^
+AttributeError: 'dict' object has no attribute '_id'
+[16/09/2024 22:22:04] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\pyrogram\methods\utilities\idle.py:76} INFO - Stop signal received (SIGINT). Exiting...
+[16/09/2024 22:23:13] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(type(row['_id'].valueOf())),
+                   ^^^^^^^^^^^^^^^^^^
+AttributeError: 'ObjectId' object has no attribute 'valueOf'
+[16/09/2024 22:24:25] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\pyrogram\methods\utilities\idle.py:76} INFO - Stop signal received (SIGINT). Exiting...
+[16/09/2024 22:26:07] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py:421} ERROR - Error handling request
+Traceback (most recent call last):
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_protocol.py", line 452, in _handle_request
+    resp = await request_handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\aiohttp\web_app.py", line 543, in _handle
+    resp = await handler(request)
+           ^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 84, in list_all_files
+    resp=[{
+         ^^
+  File "C:\Files\Codes\Python\TelegramBots\TelegramAPI\FileStream\server\routes_api.py", line 92, in <listcomp>
+    "id": str(row['_id'].value ),
+              ^^^^^^^^^^^^^^^^
+AttributeError: 'ObjectId' object has no attribute 'value'
+[16/09/2024 22:30:30] {C:\Files\Codes\Python\TelegramBots\TelegramAPI\TelegramENV\Lib\site-packages\pyrogram\methods\utilities\idle.py:76} INFO - Stop signal received (SIGINT). Exiting...