Upload 40 files

.env

@@ -0,0 +1,10 @@
+BASE_URL=https://privateone-telethon-upload.hf.space
+BIND_ADDRESS=0.0.0.0
+OWNER_ID=708296135
+PORT=7860
+SECRET_CODE_LENGTH=100
+TELEGRAM_API_HASH=371f110baf9d09b9b0bce9766f9a606b
+TELEGRAM_API_ID=4667470
+TELEGRAM_BOT_TOKEN=1857136393:AAFRXz8OGqIH-ga-qb0rM22pwYeVNPmkS00
+TELEGRAM_BOT_USERNAME=@MFBlendersBot
+TELEGRAM_CHANNEL_ID=-1001498849913

.gitattributes

@@ -1,35 +1,36 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+bot/server/templates/vlc.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,24 @@
+
+FROM python:3.11.1
+RUN useradd -ms /bin/bash admin
+
+WORKDIR /app
+COPY . /app
+
+
+COPY requirements.txt ./requirements.txt
+RUN apt-get update
+
+#RUN python -m venv venv  # Create virtual environment
+#RUN /app/venv/bin/activate && 
+RUN  pip install --upgrade pip && pip install --no-cache-dir --upgrade -r requirements.txt
+
+
+#RUN touch /app/event-log.txt && chmod 664 /app/event-log.txt
+RUN chown -R admin:admin /app
+RUN chmod 755 /app
+#EXPOSE 7860
+USER admin
+#CMD ["docker","run","-p","7860:8080"]
+#CMD ["uvicorn","bot.server.main:bp","--host","0.0.0.0","--port","7860"]
+ENTRYPOINT ["python","-m","bot"]

README.md

@@ -1,11 +1,11 @@
----
-title: Telethon Upload
-emoji: 🦀
-colorFrom: indigo
-colorTo: purple
-sdk: docker
-pinned: false
-license: gpl
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Telethon Upload
+emoji: 🐠
+colorFrom: red
+colorTo: gray
+sdk: docker
+pinned: false
+license: lgpl
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

bot/__init__.py

@@ -0,0 +1,15 @@
+from telethon import TelegramClient
+from logging import getLogger
+from logging.config import dictConfig
+from .config import Telegram, LOGGER_CONFIG_JSON
+
+dictConfig(LOGGER_CONFIG_JSON)
+
+version = 1.5
+logger = getLogger('bot')
+
+TelegramBot = TelegramClient(
+    session='bot',
+    api_id=Telegram.API_ID,
+    api_hash=Telegram.API_HASH
+)

bot/__main__.py

@@ -0,0 +1,31 @@
+from importlib import import_module
+from pathlib import Path
+from bot import TelegramBot, logger
+from bot.config import Telegram
+from bot.server import server
+
+from telethon import types
+def load_plugins():
+    count = 0
+    for path in Path('bot/plugins').rglob('*.py'):
+        import_module(f'bot.plugins.{path.stem}')
+        count += 1
+    logger.info(f'Loaded {count} {"plugins" if count > 1 else "plugin"}.')
+
+if __name__ == '__main__':
+#def main():
+    try:
+        logger.info('initializing...')
+        TelegramBot.loop.create_task(server.serve())
+        TelegramBot.start(bot_token=Telegram.BOT_TOKEN)
+        logger.info('Telegram client is now started.')
+        logger.info('Loading bot plugins...')
+        load_plugins()
+        logger.info('Bot is now ready!')
+        #logger.info(TelegramBot(types.PhoneConnectionWebrtc.to_dict(TelegramBot)))
+        TelegramBot.run_until_disconnected()
+    except KeyboardInterrupt:
+        #pass
+        TelegramBot.disconnect()
+        logging.info('----------------------- Service Stopped -----------------------')
+

bot/config.py

@@ -0,0 +1,58 @@
+from os import environ as env
+import json
+
+
+class Telegram:
+    
+    API_ID = int(env.get("TELEGRAM_API_ID"))
+    API_HASH = env.get("TELEGRAM_API_HASH")
+    OWNER_ID = int(env.get("OWNER_ID"))
+    ALLOWED_USER_IDS = json.load(open('/app/bot/data.json'))
+    BOT_USERNAME = env.get("TELEGRAM_BOT_USERNAME")
+    BOT_TOKEN = env.get("TELEGRAM_BOT_TOKEN")
+    CHANNEL_ID = int(env.get("TELEGRAM_CHANNEL_ID"))
+    SECRET_CODE_LENGTH = int(env.get("SECRET_CODE_LENGTH"))
+
+
+
+class Server:
+  BASE_URL = env.get("BASE_URL")
+  BIND_ADDRESS = env.get("BIND_ADDRESS", "0.0.0.0")
+  PORT = int(env.get("PORT", 7860))
+
+
+# LOGGING CONFIGURATION
+LOGGER_CONFIG_JSON = {
+    'version': 1,
+    'formatters': {
+        'default': {
+            'format': '[%(asctime)s][%(name)s][%(levelname)s] -> %(message)s',
+            'datefmt': '%d/%m/%Y %H:%M:%S'
+        },
+    },
+    'handlers': {
+        'file_handler': {
+            'class': 'logging.FileHandler',
+            'filename': 'event-log.txt',
+            'formatter': 'default'
+        },
+        'stream_handler': {
+            'class': 'logging.StreamHandler',
+            'formatter': 'default'
+        }
+    },
+    'loggers': {
+        'uvicorn': {
+            'level': 'INFO',
+            'handlers': ['file_handler', 'stream_handler']
+        },
+        'uvicorn.error': {
+            'level': 'WARNING',
+            'handlers': ['file_handler', 'stream_handler']
+        },
+        'bot': {
+            'level': 'INFO',
+            'handlers': ['file_handler', 'stream_handler']
+        }
+    }
+}

bot/data.json

@@ -0,0 +1 @@
+{"my_array": [708296135]}

bot/modules/decorators.py

@@ -0,0 +1,38 @@
+from telethon.events import NewMessage, CallbackQuery
+from telethon.tl.custom import Message
+from typing import Callable
+from functools import wraps
+from bot.config import Telegram
+from bot.modules.static import *
+def byte_to_gb_mb(size: int) -> str:
+    if not size:
+        return ""
+    power = 2 ** 10
+    number = 0
+    dict_power_n = {
+    0: " ",
+    1: "K",
+    2: "M",
+    3: "G",
+    4: "T",
+    5: "P"
+    }
+    while size > power:
+        size /= power
+        number += 1
+    return str(round(size, 2)) + " " + dict_power_n[number] + 'B'
+def verify_user(private: bool = False):
+    
+    def decorator(func: Callable):
+        @wraps(func)
+        async def wrapper(update: NewMessage.Event | CallbackQuery.Event):
+            if private and not update.is_private:
+                return
+
+            chat_id = str(update.chat_id)
+
+            if not Telegram.ALLOWED_USER_IDS or chat_id in Telegram.ALLOWED_USER_IDS:
+                return await func(update)
+
+        return wrapper
+    return decorator

bot/modules/static.py

@@ -0,0 +1,68 @@
+WelcomeText = \
+"""
+Hi **%(first_name)s**, send me a file or add me as an admin to any channel to instantly generate file links.
+
+Add me to your channel to instantly generate links for any downloadable media. Once received, I will automatically attach appropriate buttons to the post containing the URL. If you want me to ignore a given post, you can insert `#pass` in the post.
+
+- /start to get this message.
+- /info to get user info.
+- /log to get bot logs. (admin only!)
+"""
+
+UserInfoText = \
+"""
+**First Name:**
+`{sender.first_name}`
+
+**Last Name:**
+`{sender.last_name}`
+
+**User ID:**
+`{sender.id}`
+
+**Username:**
+`@{sender.username}`
+"""
+
+FileLinksText = \
+"""
+**Download Link:**
+`%(dl_link)s`
+**Telegram File:**
+`%(tg_link)s`
+"""
+
+MediaLinksText = \
+"""
+**Download Link:**
+`%(dl_link)s`
+**Stream Link:**
+`%(stream_link)s`
+**Telegram File:**
+`%(tg_link)s`
+"""
+
+InvalidQueryText = \
+"""
+Query data mismatched.
+"""
+
+MessageNotExist = \
+"""
+File revoked or not exist.
+"""
+
+LinkRevokedText = \
+"""
+The link has been revoked. It may take some time for the changes to take effect.
+"""
+
+InvalidPayloadText = \
+"""
+Invalid payload.
+"""
+
+MediaTypeNotSupportedText = \
+"""
+Sorry, this media type is not supported.
+"""

bot/modules/telegram.py

@@ -0,0 +1,68 @@
+from telethon.events import NewMessage
+from telethon.tl.custom import Message
+from datetime import datetime
+from mimetypes import guess_type
+from bot import TelegramBot
+from bot.config import Telegram
+from bot.server.error import abort
+
+async def get_message(message_id: int) -> Message | None:
+    message = None
+    
+    try:
+        message = await TelegramBot.get_messages(Telegram.CHANNEL_ID, ids=message_id)
+    except Exception:
+        pass
+
+    return message
+
+async def send_message(message:Message, send_to:int = Telegram.CHANNEL_ID) -> Message:
+    message.forward
+    return await TelegramBot.send_message(
+        entity=send_to,
+        message=message
+    )
+
+def filter_files(update: NewMessage.Event | Message):
+    return bool(
+        (
+            update.document
+            or update.photo
+            or update.video
+            or update.video_note
+            or update.audio
+            or update.gif
+        )
+        and not update.sticker
+    )
+
+def get_file_properties(message: Message):
+    file_name = message.file.name
+    file_size = message.file.size or 0
+    mime_type = message.file.mime_type
+
+    if not file_name:
+        attributes = {
+            'video': 'mp4',
+            'audio': 'mp3',
+            'voice': 'ogg',
+            'photo': 'jpg',
+            'video_note': 'mp4'
+        }
+
+        for attribute in attributes:
+            media = getattr(message, attribute, None)
+            if media:
+                file_type, file_format = attribute, attributes[attribute]
+                break
+        
+        if not media:
+            abort(400, 'Invalid media type.')
+
+        date = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        file_name = f'{file_type}-{date}.{file_format}'
+    
+    if not mime_type:
+        mime_type = guess_type(file_name)[0] or 'application/octet-stream'
+    
+    return file_name, file_size, mime_type

bot/plugins/callback.py

@@ -0,0 +1,78 @@
+from telethon.events import CallbackQuery
+from bot import TelegramBot
+from bot.modules.decorators import verify_user,byte_to_gb_mb
+from bot.modules.static import *
+from bot.modules.telegram import get_message, get_file_properties
+from bot.config import Telegram, Server
+
+'''async def upload_file_in_chunks(TelegramBot, chat_id, file_path, chunk_size_kb):
+    file_id = None
+    total_parts = math.ceil(file_size / (chunk_size_kb * 1024))
+    current_part = 1
+    with open(file_path, "rb") as f:
+        while True:
+            data = f.read(chunk_size_kb * 1024)
+            if not data:
+                break
+            # Upload the current chunk
+            file_part = await client.upload_file_part(file_id, current_part, data)
+            if not file_id:
+                file_id = file_part.file_id
+            current_part += 1
+            # Show progress if desired
+            progress = current_part / total_parts * 100
+            print(f"Uploaded {progress:.2f}%")
+    # Complete the upload
+    complete_file = await client.upload_file_completed(file_id, total_parts)
+    # Send the uploaded file to the chat
+    await client.send_file(chat_id, complete_file)
+
+
+'''
+
+@TelegramBot.on(CallbackQuery(pattern=r'^rm_'))
+#@verify_user(private=True)
+async def delete_file(event: CallbackQuery.Event):
+    query_data = event.query.data.decode().split('_')
+
+    if len(query_data) != 3:
+        return await event.answer(InvalidQueryText, alert=True)
+
+    message = await get_message(int(query_data[1]))
+
+    if not message:
+        return await event.answer(MessageNotExist, alert=True)
+
+    await message.delete()
+
+    return await event.answer(LinkRevokedText, alert=True)
+
+@TelegramBot.on(CallbackQuery(pattern=r'^up_'))
+#@verify_user(private=True)
+async def up_file(event:CallbackQuery.Event):
+    query_data = event.query.data.decode().split('_')
+
+    if len(query_data) != 5:
+        return await event.answer(InvalidQueryText, alert=True)
+    message_id=int(query_data[1])
+    event_id=int(query_data[3])
+    event_peer=int(query_data[4])
+    message = await get_message(int(query_data[1]))
+    main_event = await TelegramBot.get_messages(event_peer, ids=event_id)
+    
+    #print(event_id,event_peer)
+    #print(main_event)
+    code = str(query_data[2])
+    def callback(current, total,event_peer,event_id):
+        print('Uploaded', current, 'out of', total,'bytes: {:.2%}'.format(current / total))
+        TelegramBot.edit_message(event_peer, event_id, f'Uploaded, {current}, out of, {total}')
+    if not message or code != message.raw_text:
+        return await event.answer(MessageNotExist, alert=True)
+    else:
+        dl_link = f'{Server.BASE_URL}/dl/{message_id}?code={code}'
+        file_name, file_size, mime_type = get_file_properties(main_event)
+        await main_event.reply(
+            message= f'**File name:{file_name} \nFile size:{byte_to_gb_mb(file_size)} \nID:{message_id} \nAccess Code:{code} \n*If you want to upload with different name please send name with reply of the message \n reply with n for original file name ***',
+            parse_mode="Markdown"
+        )
+        

bot/plugins/commands.py

@@ -0,0 +1,135 @@
+from telethon import Button
+from telethon import functions, types,utils,helpers,custom
+from telethon.events import NewMessage
+from telethon.tl.custom.message import Message
+from bot import TelegramBot
+from bot.config import Telegram
+from bot.modules.static import *
+from bot.modules.decorators import verify_user
+from bot.plugins.upload import upload_chunk
+from bot.modules.telegram import get_message, get_file_properties
+import json
+
+async def refresh(): 
+    with open("/app/bot/data.json", "r") as infile:
+      Telegram.ALLOWED_USER_IDS = json.load(infile)
+    # Add a value
+async def add_id(id):
+  await refresh()
+  if id in Telegram.ALLOWED_USER_IDS["my_array"]:
+    await TelegramBot.send_message(id, "You are already exists")          
+    
+  else:
+    Telegram.ALLOWED_USER_IDS["my_array"].append(id)
+    await TelegramBot.send_message(id, "Now you are in whitelist !!")
+  with open("/app/bot/data.json", "w") as outfile:
+      json.dump(Telegram.ALLOWED_USER_IDS, outfile)
+  await refresh()
+    
+#data["my_array"].append("new_value")
+
+# Remove a value (index 2 in this example)
+async def del_id(id):
+  await refresh()
+  for i in range(len(Telegram.ALLOWED_USER_IDS["my_array"])):
+    if Telegram.ALLOWED_USER_IDS["my_array"][i] == id:
+        Telegram.ALLOWED_USER_IDS["my_array"].pop(i)
+        await TelegramBot.send_message(id, "You are removed from whitelist")
+        break
+  with open("/app/bot/data.json", "w") as outfile:
+    json.dump(Telegram.ALLOWED_USER_IDS, outfile)
+  await refresh()
+
+
+
+
+
+@TelegramBot.on(NewMessage(incoming=True))
+#@verify_user(private=True)
+async def reply_message(event: NewMessage.Event | Message):
+    if event.message.reply_to:
+        #print('this is reply message', event)
+        message=await TelegramBot.get_messages(event.message.peer_id.user_id, ids=event.message.reply_to.reply_to_msg_id)
+        event_message=str(event.message.message)
+        message_text=message.message
+        parts = message_text.split("\n")
+        filename = str(parts[0].split(":")[1].strip())  # Remove leading/trailing spaces
+        #size = int(parts[1].split(":")[1].strip())
+        message_id = int(parts[2].split(":")[1].strip())
+        code = str(parts[3].split(":")[1].strip())
+        file = await get_message(message_id=int(message_id))
+        file_name, file_size, mime_type = get_file_properties(file)
+        
+        #print(filename,size,message_id,code)
+        result,new_name=await upload_chunk(message_id,code,event.message.id,event_message,event.message.peer_id.user_id,event.message.reply_to.reply_to_msg_id)
+        attributes, mime_type = utils.get_attributes(
+                new_name,
+                mime_type=mime_type,
+                attributes=None,
+                force_document=True,
+                voice_note=None,
+                video_note=None,
+                supports_streaming=True,
+                thumb=None
+            )
+        #await TelegramBot.send_file(event.message.peer_id.user_id, file=result,force_document=True)
+        await TelegramBot(functions.messages.SendMediaRequest(
+            peer=event.message.peer_id.user_id,
+            media=types.InputMediaUploadedDocument(
+                file=result,
+                mime_type=mime_type,
+                attributes=attributes,
+
+            ),
+            message='File Uploaded successfully !'
+        ))
+        #print(result.stringify())
+
+        #print(result)
+        '''if event_message.lower() =='n':
+            
+        else:
+            message_text=message.message
+            parts = message_text.split("\n")
+            filename = event_message  # Remove leading/trailing spaces
+            size = int(parts[1].split(":")[1].strip())
+            message_id = int(parts[2].split(":")[1].strip())
+            code = str(parts[3].split(":")[1].strip())
+            print(filename,size,message_id,code)
+            upload_chunk(filename,message_id,code,event.message.id)'''
+
+
+
+
+
+
+
+@TelegramBot.on(NewMessage(incoming=True, pattern=r'^/start$'))
+#@verify_user(private=True)
+async def welcome(event: NewMessage.Event | Message):
+    await event.reply(
+        message=WelcomeText % {'first_name': event.sender.first_name},
+        buttons=[
+            [
+                Button.url('Add to Channel', f'https://t.me/{Telegram.BOT_USERNAME}?startchannel&admin=post_messages+edit_messages+delete_messages')
+            ]
+        ]
+    )
+
+@TelegramBot.on(NewMessage(incoming=True, pattern=r'^/info$'))
+#@verify_user(private=True)
+async def user_info(event: Message):
+    await event.reply(UserInfoText.format(sender=event.sender))
+
+@TelegramBot.on(NewMessage(chats=Telegram.OWNER_ID, incoming=True, pattern=r'^/log$'))
+async def send_log(event: NewMessage.Event | Message):
+    await event.reply(file='event-log.txt')
+@TelegramBot.on(NewMessage(incoming=True, pattern=r'^/in$'))
+async def add_user(event: NewMessage.Event | Message):
+    await add_id(event.sender.id)
+
+@TelegramBot.on(NewMessage(incoming=True, pattern=r'^/out$'))
+async def add_user(event: NewMessage.Event | Message):
+    await del_id(event.sender.id)
+    
+

bot/plugins/data.json

@@ -0,0 +1 @@
+{"my_array": [708296135]}

bot/plugins/deeplinks.py

@@ -0,0 +1,22 @@
+from telethon.events import NewMessage
+from telethon.tl.custom import Message
+from bot import TelegramBot
+from bot.modules.decorators import verify_user
+from bot.modules.telegram import get_message, send_message
+from bot.modules.static import *
+
+@TelegramBot.on(NewMessage(incoming=True, pattern=r'^/start file_'))
+#@verify_user(private=True)
+async def send_file(event: NewMessage.Event | Message):
+    payload = event.raw_text.split()[-1].split('_')
+
+    if len(payload) != 3:
+        return await event.reply(InvalidPayloadText)
+    
+    message = await get_message(int(payload[1]))
+
+    if not message:
+        return await event.reply(MessageNotExist)
+    
+    message.raw_text = ''
+    await send_message(message, send_to=event.chat_id)

bot/plugins/files.py

@@ -0,0 +1,110 @@
+from telethon import Button
+from telethon.events import NewMessage
+from telethon.errors import MessageAuthorRequiredError, MessageNotModifiedError, MessageIdInvalidError
+from telethon.tl.custom import Message
+from secrets import token_hex
+from bot import TelegramBot
+from bot.config import Telegram, Server
+from bot.modules.decorators import verify_user
+from bot.modules.telegram import send_message, filter_files
+from bot.modules.static import *
+
+@TelegramBot.on(NewMessage(incoming=True, func=filter_files))
+#@verify_user(private=True)
+async def user_file_handler(event: NewMessage.Event | Message):
+    secret_code = token_hex(Telegram.SECRET_CODE_LENGTH)
+    event.message.text = f'`{secret_code}`'
+    message = await send_message(event.message)
+    message_id = message.id
+    #print(event)
+    
+    event_id=event.message.id
+    event_peer=event.message.peer_id.user_id
+    dl_link = f'{Server.BASE_URL}/dl/{message_id}?code={secret_code}'
+    tg_link = f'{Server.BASE_URL}/file/{message_id}?code={secret_code}'
+    deep_link = f'https://t.me/{Telegram.BOT_USERNAME}?start=file_{message_id}_{secret_code}'
+
+    if (event.document and 'video' in event.document.mime_type) or event.video:
+        stream_link = f'{Server.BASE_URL}/stream/{message_id}?code={secret_code}'
+        await event.reply(
+            message= MediaLinksText % {'dl_link': dl_link, 'tg_link': tg_link, 'tg_link': tg_link, 'stream_link': stream_link},
+            buttons=[
+                [
+                    Button.url('Download', dl_link),
+                    Button.url('Stream', stream_link)
+                ],
+                [
+                    Button.inline('Upload', f'up_{message_id}_{secret_code}_{event_id}_{event_peer}')
+                ],
+                [
+                    Button.url('Get File', deep_link),
+                    Button.inline('Revoke', f'rm_{message_id}_{secret_code}')
+                ]
+            ]
+        )
+    else:
+        await event.reply(
+            message=FileLinksText % {'dl_link': dl_link, 'tg_link': tg_link},
+            buttons=[
+                [
+                    Button.url('Download', dl_link),
+                    Button.url('Get File', deep_link)
+                ],
+                [
+                    Button.inline('Upload', f'up_{message_id}_{secret_code}_{event_id}_{event_peer}')
+                ],
+                [
+                    Button.inline('Revoke', f'rm_{message_id}_{secret_code}')
+                ]
+            ]
+        )
+
+@TelegramBot.on(NewMessage(incoming=True, func=filter_files, forwards=False))
+#@verify_user()
+async def channel_file_handler(event: NewMessage.Event | Message):
+    secret_code = token_hex(Telegram.SECRET_CODE_LENGTH)
+    event.message.text = f"`{secret_code}`"
+    message = await send_message(event.message)
+    message_id = message.id
+    event_id=event.message.id
+    event_peer=event.message.peer_id.user_id
+    #print(event)
+    #print(event.message.id,event.message.peer_id.user_id)
+    dl_link = f"{Server.BASE_URL}/dl/{message_id}?code={secret_code}"
+    tg_link = f"{Server.BASE_URL}/file/{message_id}?code={secret_code}"
+
+    if (event.document and "video" in event.document.mime_type) or event.video:
+        stream_link = f"{Server.BASE_URL}/stream/{message_id}?code={secret_code}"
+
+        try:
+            await event.edit(
+                buttons=[
+                    [Button.url("Download", dl_link), Button.url("Stream", stream_link)],
+                    [
+                    Button.inline('Upload', f'up_{message_id}_{secret_code}_{event_id}_{event_peer}')
+                    ],
+                    [Button.url("Get File", tg_link)],
+                ]
+            )
+        except (
+            MessageAuthorRequiredError,
+            MessageIdInvalidError,
+            MessageNotModifiedError,
+        ):
+            pass
+    else:
+        try:
+            await event.edit(
+                buttons=[
+                    [Button.url("Download", dl_link), Button.url("Get File", tg_link)],
+                    [
+                    Button.inline('Upload', f'up_{message_id}_{secret_code}')
+                    ],
+                ]
+            )
+        except (
+            MessageAuthorRequiredError,
+            MessageIdInvalidError,
+            MessageNotModifiedError,
+        ):
+            pass

bot/plugins/upload.py

@@ -0,0 +1,193 @@
+import hashlib
+import io
+import requests
+from bot import TelegramBot
+from bot.modules.decorators import verify_user,byte_to_gb_mb
+from telethon import functions, types,utils,helpers,custom,errors
+from bot.config import Telegram, Server
+from math import ceil, floor
+from bot.modules.telegram import get_message, get_file_properties
+MIN_CHUNK_SIZE = 4096
+async def callback(current,current_part,part_size,part_count,total,event_peer,event_id,file_name):
+    c=int(30*current_part//part_count)
+    progress_bar = '#' * c + '-' * (30 - c) 
+    progress_text = f'**File name:{file_name} \nFile size:{byte_to_gb_mb(total)} \nUploading: {int(100*current_part//part_count)}%\n[{progress_bar}]'
+    print(current_part,part_count,part_size,'Uploaded', current, 'out of', total,'bytes: {:.2%}'.format(current / total))
+    try:
+        await TelegramBot.edit_message(event_peer, event_id, progress_text)
+        
+    except errors.rpcerrorlist.MessageNotModifiedError as e:
+        print(f"Error: {e}")
+    except Exception as e:  # Catch other potential errors
+        print(f"An unexpected error occurred: {e}")
+
+    
+async def upload_chunk(message_id,code,event_id,event_message,peer_id,mesage_update_id):
+    file_ = await get_message(message_id=int(message_id))
+    file_name, file_size, mime_type = get_file_properties(file_)
+    info = utils._get_file_info(file_)
+    dc_id = info.dc_id
+
+    file_size = info.size
+    
+    file = info.location
+    
+    part_size_kb = utils.get_appropriated_part_size(file_size)
+
+    part_size = int(part_size_kb * 1024)
+    if part_size % MIN_CHUNK_SIZE != 0:
+        raise ValueError(
+            'The part size must be evenly divisible by 4096.')
+
+    if part_size_kb > 512:
+        raise ValueError('The part size must be less or equal to 512KB')
+
+    
+    if part_size % 1024 != 0:
+        raise ValueError(
+            'The part size must be evenly divisible by 1024')
+
+    # Set a default file name if None was specified
+    file_id = helpers.generate_random_long()
+
+    if event_message.lower() =='n':
+        filename=file_name
+    else:
+        ext = utils._get_extension(file_name)
+        filename =  event_message+ext
+        
+      
+    is_big = file_size > 10 * 1024 * 1024
+    hash_md5 = hashlib.md5()
+
+    part_count = (file_size + part_size - 1) // part_size
+    until_bytes = file_size - 1
+    from_bytes=0
+    until_bytes = min(until_bytes, file_size - 1)
+    offset = from_bytes - (from_bytes % part_size)
+    
+    
+    pos =0
+    part_index=0
+    #for part_index in range(part_count):
+        
+    async for chunk in TelegramBot.iter_download(file, offset=offset, chunk_size=part_size, stride=part_size, file_size=file_size):
+        
+        #limit = part_size
+        
+        if type(chunk)!="<class 'bytes'>":
+            chunk=bytes(chunk)
+        #chunk = await TelegramBot(functions.upload.GetFileRequest(
+        #precise=True, location=file, offset=pos, limit=limit
+        #    ))
+        if not chunk:
+            
+            break
+        
+        elif part_index >= part_count:
+            
+            break
+        else:
+
+            if not is_big:
+                    # Bit odd that MD5 is only needed for small files and not
+                    # big ones with more chance for corruption, but that's
+                    # what Telegram wants.
+                hash_md5.update(chunk)
+
+                # The SavePartRequest is different depending on whether
+                # the file is too large or not (over or less than 10MB)
+            if is_big:
+                await TelegramBot(functions.upload.SaveBigFilePartRequest(
+                    file_id, part_index, part_count, chunk))
+            else:
+                await TelegramBot(functions.upload.SaveFilePartRequest(
+                    file_id, part_index, chunk))
+            
+                #yield chunk
+            
+
+            
+           
+            pos += len(chunk)
+            part_index += 1
+            await callback(pos,part_index,part_size,part_count,file_size,peer_id,mesage_update_id,filename)
+    if is_big:
+        return types.InputFileBig(file_id, part_count, file_name),filename
+    else:
+        return custom.InputSizedFile(
+            file_id, part_count, file_name, md5=hash_md5, size=file_size
+        ),filename
+
+    
+    ''' if not chunk:
+            break
+        elif part_count == 1:
+            if not is_big:
+                # Bit odd that MD5 is only needed for small files and not
+                # big ones with more chance for corruption, but that's
+                # what Telegram wants.
+                hash_md5.update(chunk[first_part_cut:last_part_cut])
+            if is_big:
+                request = functions.upload.SaveBigFilePartRequest(file_id=file_id,file_part=current_part,file_total_parts=part_count,bytes=chunk[first_part_cut:last_part_cut])
+            else:
+                request = functions.upload.SaveFilePartRequest(file_id=file_id,file_part=current_part,bytes=chunk[first_part_cut:last_part_cut])
+            #yield chunk[first_part_cut:last_part_cut]
+        elif current_part == 0:
+            if not is_big:
+                # Bit odd that MD5 is only needed for small files and not
+                # big ones with more chance for corruption, but that's
+                # what Telegram wants.
+                hash_md5.update(chunk[first_part_cut:])
+            if is_big:
+                request = functions.upload.SaveBigFilePartRequest(
+                    file_id=file_id,file_part=current_part,file_total_parts=part_count,bytes=chunk[first_part_cut:])
+                    #file_id, current_part, part_count, chunk[first_part_cut:])
+            else:
+                request = functions.upload.SaveFilePartRequest(
+                    file_id=file_id,file_part=current_part,bytes=chunk[first_part_cut:])
+            #yield chunk[first_part_cut:]
+        elif current_part == part_count-1:
+            if not is_big:
+                # Bit odd that MD5 is only needed for small files and not
+                # big ones with more chance for corruption, but that's
+                # what Telegram wants.
+                hash_md5.update(chunk[:last_part_cut])
+            if is_big:
+                request = functions.upload.SaveBigFilePartRequest(
+                    file_id=file_id,file_part=current_part,file_total_parts=part_count,bytes=chunk[:last_part_cut])
+                    #file_id, current_part, part_count, chunk[:last_part_cut])
+            else:
+                request = functions.upload.SaveFilePartRequest(
+                    file_id=file_id,file_part=current_part,bytes=chunk[:last_part_cut])
+            
+            #yield chunk[:last_part_cut]
+        else:
+            if not is_big:
+                # Bit odd that MD5 is only needed for small files and not
+                # big ones with more chance for corruption, but that's
+                # what Telegram wants.
+                hash_md5.update(chunk)
+            if is_big:
+                request = functions.upload.SaveBigFilePartRequest(
+                    file_id=file_id,file_part=current_part,file_total_parts=part_count,bytes=chunk)
+                    #file_id, current_part, part_count, chunk)
+            else:
+                request = functions.upload.SaveFilePartRequest(
+                    file_id=file_id,file_part=current_part,bytes=chunk)
+                    #file_id, current_part, chunk)
+            #yield chunk
+            
+
+        
+        current_part += 1
+        pos +=len(chunk)  
+        
+        await callback(pos,current_part,part_size,part_count,file_size,peer_id,mesage_update_id)
+        
+    if is_big:
+        return types.InputFileBig(file_id, part_count, filename)
+    else:
+        return custom.InputSizedFile(
+            file_id, part_count, filename, md5=hash_md5, size=file_size
+        )'''     

bot/server/__init__.py

@@ -0,0 +1,31 @@
+from quart import Quart
+from uvicorn import Server as UvicornServer, Config
+from logging import getLogger
+from bot.config import Server, LOGGER_CONFIG_JSON
+
+from . import main, error
+
+logger = getLogger('uvicorn')
+instance = Quart(__name__)
+instance.config['RESPONSE_TIMEOUT'] = None
+
+@instance.before_serving
+async def before_serve():
+    logger.info('Web server is started!')
+    logger.info(f'Server running on {Server.BIND_ADDRESS}:{Server.PORT}')
+
+instance.register_blueprint(main.bp)
+
+instance.register_error_handler(400, error.invalid_request)
+instance.register_error_handler(404, error.not_found)
+instance.register_error_handler(405, error.invalid_method)
+instance.register_error_handler(error.HTTPError, error.http_error)
+
+server = UvicornServer (
+    Config (
+        app=instance,
+        host=Server.BIND_ADDRESS,
+        port=Server.PORT,
+        log_config=LOGGER_CONFIG_JSON
+    )
+)

bot/server/error.py

@@ -0,0 +1,31 @@
+class HTTPError(Exception):
+    status_code:int = None
+    description:str = None
+    def __init__(self, status_code, description):
+        self.status_code = status_code
+        self.description = description
+        super().__init__(self.status_code, self.description)
+
+error_messages = {
+    400: 'Invalid request.',
+    401: 'File code is required to download the file.',
+    403: 'Invalid file code.',
+    404: 'File not found.',
+    500: 'Internal server error.'
+}
+
+async def invalid_request(_):
+    return 'Invalid request.', 400
+
+async def not_found(_):
+    return 'Resource not found.', 404
+
+async def invalid_method(_):
+    return 'Invalid request method.', 405
+
+async def http_error(error: HTTPError):
+    error_message = error_messages.get(error.status_code)
+    return error.description or error_message, error.status_code
+
+def abort(status_code: int = 500, description: str = None):
+    raise HTTPError(status_code, description)

bot/server/main.py

@@ -0,0 +1,88 @@
+from quart import Blueprint, Response, request, render_template, redirect
+from .error import abort
+from bot import TelegramBot
+from bot.modules.decorators import byte_to_gb_mb
+from bot.config import Telegram, Server
+from math import ceil, floor
+from bot.modules.telegram import get_message, get_file_properties
+
+bp = Blueprint('main', __name__)
+
+@bp.route('/')
+async def home():
+    return "Welcome!!"
+    #return redirect(f'https://t.me/{Telegram.BOT_USERNAME}')
+
+@bp.route('/dl/<int:file_id>')
+async def transmit_file(file_id):
+    file = await get_message(message_id=int(file_id)) or abort(404)
+    code = request.args.get('code') or abort(401)
+    range_header = request.headers.get('Range', 0)
+
+    if code != file.raw_text:
+        abort(403)
+
+    file_name, file_size, mime_type = get_file_properties(file)
+    
+    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 = 0
+        until_bytes = file_size - 1
+
+    if (until_bytes > file_size) or (from_bytes < 0) or (until_bytes < from_bytes):
+        abort(416, 'Invalid range.')
+
+    chunk_size = 1024 * 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 = ceil(until_bytes / chunk_size) - floor(offset / chunk_size)
+    
+    headers = {
+            "Content-Type": f"{mime_type}",
+            "Content-Range": f"bytes {from_bytes}-{until_bytes}/{file_size}",
+            "Content-Length": str(req_length),
+            "Content-Disposition": f'attachment; filename="{file_name}"',
+            "Accept-Ranges": "bytes",
+        }
+
+    async def file_generator():
+        current_part = 1
+        async for chunk in TelegramBot.iter_download(file, offset=offset, chunk_size=chunk_size, stride=chunk_size, file_size=file_size):
+            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
+
+            if current_part > part_count:
+                break
+
+    return Response(file_generator(), headers=headers, status=206 if range_header else 200)
+
+@bp.route('/stream/<int:file_id>')
+async def stream_file(file_id):
+    code = request.args.get('code') or abort(401)
+    file = await get_message(message_id=int(file_id)) or abort(404)
+    file_name, file_size, mime_type = get_file_properties(file)
+    return await render_template('player.html', mediaLink=f'{Server.BASE_URL}/dl/{file_id}?code={code}',file_name=file_name,file_size=byte_to_gb_mb(file_size))
+
+@bp.route('/file/<int:file_id>')
+async def file_deeplink(file_id):
+    code = request.args.get('code') or abort(401)
+
+    return redirect(f'https://t.me/{Telegram.BOT_USERNAME}?start=file_{file_id}_{code}')

bot/server/templates/player.html

@@ -0,0 +1,781 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>Play | {{file_name}}</title>
+
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="X-Frame-Options" content="deny">
+
+    <link rel="stylesheet" href="https://cdn.plyr.io/3.7.8/plyr.css" />
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.4/css/all.min.css">
+
+    <script src="https://cdn.plyr.io/3.7.8/plyr.polyfilled.js"></script>
+
+    <style>
+      html, body {
+       height: 100%;
+    width: 100%;
+    background-image: url(https://i.postimg.cc/T2mcBGtv/pxfuel-2.jpg);
+
+      }
+
+      #stream-media {
+        height: 100%;
+        width: 100%;
+      }
+
+      #error-message {
+        color: red;
+        font-size: 24px;
+        text-align: center;
+        margin-top: 20px;
+      }
+
+      .plyr__video-wrapper .plyr-download-button{
+        position: absolute;
+        top: 10px;
+        left: 10px;
+        width: 30px;
+        height: 30px;
+        background-color: rgba(0, 0, 0, 0.7);
+        border-radius: 50%;
+        text-align: center;
+        line-height: 30px;
+        color: white;
+        z-index: 10;
+      }
+
+      .plyr__volume {
+        max-width: initial;
+        min-width: initial;
+        width: auto;
+        position: relative;
+      }
+
+
+      .plyr__video-wrapper .plyr-share-button{
+        position: absolute;
+        top: 50px;
+        left: 10px;
+        width: 30px;
+        height: 30px;
+        background-color: rgba(0, 0, 0, 0.7);
+        border-radius: 50%;
+        text-align: center;
+        line-height: 30px;
+        color: white;
+        z-index: 10;
+      }
+
+      .plyr__video-wrapper .plyr-download-button:hover,
+      .plyr__video-wrapper .plyr-share-button:hover{
+        background-color: rgba(255, 255, 255, 0.7);
+        color: black;
+      }
+
+      .plyr__video-wrapper .plyr-download-button:before {
+        font-family: "Font Awesome 5 Free";
+        content: "\f019";
+        font-weight: bold;
+      }
+
+      .plyr__video-wrapper .plyr-share-button:before {
+        font-family: "Font Awesome 5 Free";
+        content: "\f064";
+        font-weight: bold;
+      }
+
+      .plyr, .plyr__video-wrapper, .plyr__video-embed iframe {
+        height: auto;
+        width:100vw;
+      }
+
+      :root {
+    --mycol: #ff003c;
+    --gcol: linear-gradient(to right, red, blue);
+}
+
+span {
+    color: var(--mycol);
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+    color: white;
+    font-family: 'Josefin Sans', sans-serif;
+    scroll-behavior: smooth;
+    text-transform: capitalize;
+}
+
+*::-webkit-scrollbar {
+    display: none;
+}
+
+
+
+
+
+a {
+    text-decoration: none;
+}
+
+.file-name {
+    overflow: hidden;
+    margin-top: 20px;
+    width: 100vw;
+    height: auto;
+    padding: 20px;
+    border-radius: 5px;
+    background: linear-gradient(to bottom, rgba(52, 52, 52, 0.301), rgba(153, 153, 153, 0.075));
+}
+
+.file-name h4 {
+    color: var(--mycol);
+}
+
+.downloadBtn {
+    padding: 30px 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    /* flex-direction: column; */
+    flex-wrap: wrap;
+    gap: 20px;
+
+}
+
+.downloadBtn button {
+    opacity: 1;
+    border-radius: 6px;
+    background: linear-gradient(to bottom, rgba(247, 247, 247, 0.187), rgba(240, 240, 240, 0.105));
+    height: 50px;
+    width: 300px;
+    display: flex;
+    align-items: center;
+    font-weight: 700;
+    gap: 10px;
+    padding-left: 50px;
+    border: none;
+    text-transform: uppercase;
+}
+
+.downloadBtn img {
+    height: 20px;
+}
+
+
+
+
+
+/* about sec edit  */
+.abt {
+
+    overflow: hidden;
+}
+
+.about {
+    /* width: 100%; */
+    width: 100vw;
+    background-size: cover;
+    backdrop-filter: blur(1px);
+    height: 100vh;
+    position: relative;
+    /* overflow: hidden; */
+    transition: all 0.4s ease;
+    /* display: none; */
+    overflow: hidden;
+
+}
+
+.about::-webkit-scrollbar {
+    display: none;
+}
+
+.about-nav {
+    /* height: 50px; */
+    width: 100%;
+    align-items: center;
+    justify-content: space-evenly;
+    backdrop-filter: blur(1px);
+    position: fixed;
+    left: 0%;
+    z-index: 200;
+    font-size: 14px;
+    top: 12%;
+    display: none;
+}
+
+.about-nav a {
+    position: relative;
+    margin: 0 7px;
+}
+
+.about-nav a::after {
+    content: "";
+    position: absolute;
+    height: 2px;
+    width: 0%;
+    background-color: var(--mycol);
+    bottom: -5px;
+    left: 1px;
+    border-radius: 30px;
+    transition: all 0.4s ease;
+
+}
+
+.about-nav a.active::after {
+    width: 90%;
+}
+
+.about-dets {
+    height: 100vh;
+    width: 400vw;
+    position: absolute;
+    display: flex;
+    align-items: center;
+    overflow: hidden;
+    transition: all 0.4s ease;
+}
+
+.abt-sec {
+    height: 100%;
+    width: 100vw;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    /* justify-content: center; */
+    z-index: 100;
+    gap: 10%;
+    padding-top: 130px;
+    backdrop-filter: blur(5px);
+    overflow: hidden;
+
+}
+
+#sec4 {
+    /* transform: translateY(60px); */
+    gap: 22px;
+    padding-left: 20px;
+    padding-right: 20px;
+}
+
+#sec4 h1 {
+    margin-bottom: 30px;
+}
+
+.abt-sec h1 {
+    text-align: center;
+    transform: translateY(20px);
+    font-weight: 700;
+}
+
+.abt-sec p {
+    text-align: center;
+    font-weight: 700;
+    text-transform: capitalize;
+    font-family: 'Gill Sans', 'Gill Sans MT', Calibri, 'Trebuchet MS', sans-serif;
+}
+
+
+
+.links {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 10px;
+}
+
+.links button {
+    width: 350px;
+    height: 50px;
+    border-radius: 6px;
+    border: none;
+    background: linear-gradient(to top, rgba(46, 46, 46, 0.365), rgba(46, 46, 46, 0.443));
+    font-size: 15px;
+    font-weight: 550;
+    transition: all 0.4s ease;
+    /* opacity: 0; */
+}
+
+.links a {
+    opacity: 0;
+}
+
+button {
+    transition: all 1s ease;
+    /* opacity: 0; */
+    /* animation: linksBtnAn 2s ease 0.3s infinite, strtLoad 4s ease 0.5s forwards; */
+    position: relative;
+    overflow: hidden;
+}
+
+.links button::before,
+.downloadBtn button::before {
+    opacity: 0;
+    left: -10px;
+    top: -20px;
+    content: "";
+    width: 20%;
+    height: 200%;
+    position: absolute;
+    background-color: #ffffff18;
+    box-shadow: 2px 2px 30px 30px #ffffff18;
+    rotate: 20deg;
+    animation: var(--beforestyl);
+    filter: contrast(100);
+}
+
+.links button:hover {
+    scale: 1.05;
+}
+
+button:active {
+    scale: 0.7;
+}
+
+.box {
+    margin-bottom: 60px;
+}
+
+.box h3 {
+    margin-bottom: 15px;
+    position: relative;
+}
+
+.box a {
+    margin-top: 15px;
+}
+
+.box p {
+    margin-top: 5px;
+}
+
+.box h3::after {
+    content: "";
+    position: absolute;
+    height: 1.5px;
+    width: 90%;
+    background-color: var(--mycol);
+    bottom: -3px;
+    left: 0%;
+    border-radius: 30px;
+    transition: all 0.4s ease;
+}
+
+/* middle part  */
+.mid {
+    font-size: 40px;
+    font-weight: 600;
+    text-align: center;
+    padding: 10%;
+}
+
+.last-text {
+    text-align: center;
+    padding: 10%;
+}
+
+.movie-cont {
+    height: fit-content;
+    width: 100vw;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 30px;
+}
+
+.movieSug {
+    height: 500px;
+    width: 95vw;
+    border-radius: 2%;
+    position: relative;
+    display: flex;
+    align-items: center;
+    justify-content: space-around;
+    /* background-image: url(https://image.tmdb.org/t/p/w1280//8Gxv8gSFCU0XGDykEGv7zR1n2ua.jpg); */
+    background-size: cover;
+    background-position: center;
+    overflow: hidden;
+
+}
+
+.movieSug::before {
+    content: '';
+    height: 110%;
+    width: 110%;
+    position: absolute;
+    background: linear-gradient(to right, black 20%, rgba(0, 0, 0, 0.322) 75%, rgba(0, 0, 0, 0));
+    top: 0%;
+    left: -10px;
+}
+
+.movieDets {
+    padding: 5%;
+    height: 100%;
+    width: 45vw;
+    display: flex;
+    flex-direction: column;
+    text-align: start;
+    justify-content: center;
+    gap: 10px;
+    z-index: 100;
+}
+
+.movieDets h3:first-child {
+    font-size: 32px;
+    font-weight: 600;
+}
+
+.movieimg {
+    /* height: 100%; */
+    width: 45vw;
+    /* background-color: #100206; */
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    gap: 10px;
+}
+
+.movieimg img {
+    max-height: 400px;
+    box-shadow: 2px 2px 100px 70px rgba(0, 0, 0, 0.566);
+}
+
+.movieDets span {
+    font-weight: 700;
+    font-size: 20px;
+}
+
+.movieDets h4:nth-child(2) {
+    margin-top: 20px;
+    font-size: 23px;
+    font-weight: 700;
+}
+
+.movieDets h4:nth-child(3) {
+
+    font-size: 15px;
+    font-weight: 700;
+}
+
+.movieStsBar {
+    display: none;
+}
+
+.ranMovBtn {
+
+    border-radius: 6px;
+    background: linear-gradient(to bottom, rgba(247, 247, 247, 0.187), rgba(240, 240, 240, 0.105));
+    height: 50px;
+    width: 300px;
+    display: flex;
+    align-items: center;
+    font-weight: 700;
+    gap: 10px;
+    padding-left: 50px;
+    border: none;
+}
+
+.copyright {
+    margin: 30px;
+    gap: 10px;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+
+}
+
+.copyright h5 {
+    font-size: 13px;
+}
+
+@keyframes linksBtnAn {
+
+    from {
+        scale: 1;
+    }
+
+    50% {
+        scale: 1.02;
+    }
+
+    to {
+        scale: 1;
+    }
+}
+
+@keyframes strtLoad {
+    from {
+        opacity: 0;
+        transform: translateX(-200px);
+    }
+
+    to {
+        opacity: 1;
+        transform: translateX(0px);
+    }
+
+}
+
+@keyframes button_shine {
+    from {
+        opacity: .9;
+        left: -100px;
+    }
+
+    to {
+        opacity: 1;
+        left: 400px;
+    }
+}
+
+@media (max-width : 1029px) {
+
+    .movieDets h3:first-child {
+        font-size: 25px;
+    }
+}
+
+@media (max-width : 992px) {
+    .movieSug {
+        scale: 0.9;
+    }
+
+    .movie-cont {
+        scale: 0.9;
+    }
+
+}
+
+@media (max-width : 800px) {
+    .movie-cont {
+        scale: 0.9;
+    }
+
+    .movieSug {
+        height: 400px;
+    }
+
+    .movieimg img {
+        max-height: 300px;
+
+    }
+
+    .movieDets {
+        scale: 0.8;
+    }
+
+}
+
+@media (max-width : 637px) {
+    .movieSug {
+        background-position: right;
+        padding: 5%;
+        scale: 1;
+        width: 90vw;
+    }
+
+    .movie-cont {
+        width: 90vw;
+        padding: 5%;
+        scale: 1;
+    }
+
+    .movieDets {
+        display: none;
+    }
+
+    .movieStsBar {
+        display: block;
+        border-radius: 6%;
+    }
+
+    .movieDets-mini {
+        position: absolute;
+        display: flex;
+        flex-direction: column;
+        text-align: start;
+        width: 80%;
+        left: 50px;
+        transform: translate(-35px, -120px);
+
+    }
+
+    .movieSug::before {
+        content: '';
+        height: 100%;
+        width: 100%;
+        position: absolute;
+        background: linear-gradient(to top, black 20%, rgba(0, 0, 0, 0.322) 75%, rgba(0, 0, 0, 0));
+        top: 10%;
+        left: 0px;
+    }
+
+    .movieimg img {
+        transform: translate(75px, -40px);
+
+    }
+}
+    </style>
+  </head>
+
+  <body>
+    
+          
+    <video id="stream-media" controls preload="auto">
+      <source src="" type="">
+      <p class="vjs-no-js">
+        To view this video please enable JavaScript, and consider upgrading to a web browser that supports HTML5 video
+      </p>
+    </video>
+    <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="copyStreamLink()">
+            <img src="https://i.ibb.co/CM4Y586/link.png" alt="Copy Link">copy link
+        </button>
+       <button class="magnet share" onclick="link_share()">
+            <img src="https://i.ibb.co/vx5D2g5/share.png" alt="">share 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>
+       
+        
+    </div>
+    <div id="error-message"></div>
+            
+    
+      <script>
+      var player = new Plyr('#stream-media', {
+          controls:['play-large', 'rewind', 'play', 'fast-forward', 'progress', 'current-time', 'mute', 'settings','download', 'pip', 'fullscreen'],
+          settings:['speed','loop'],
+          speed:{selected:1,options:[0.25,0.5,0.75,1,1.25,1.5,1.75,2]},
+          seek: 10,
+          keyboard: { focused: true, global: true },
+      });
+
+      var mediaLink = "{{ mediaLink }}";
+
+      if (mediaLink) {
+          document.querySelector('#stream-media source').setAttribute('src', mediaLink);
+          player.restart();
+
+          /*var downloadButton = document.createElement('div');
+          downloadButton.className = 'plyr-download-button';
+
+          downloadButton.onclick = function() {
+            event.stopPropagation();
+            var link = document.createElement('a');
+            link.href = mediaLink;
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+          };
+
+          player.elements.container.querySelector('.plyr__video-wrapper').appendChild(downloadButton);
+
+          var shareButton = document.createElement('div');
+          shareButton.className = 'plyr-share-button';
+
+          shareButton.onclick = function() {
+            event.stopPropagation();
+            if (navigator.share) {
+              navigator.share({
+                title: "Play",
+                url: window.location.href
+              });
+            }
+          };
+
+          player.elements.container.querySelector('.plyr__video-wrapper').appendChild(shareButton);
+        */
+
+      } else {
+          document.getElementById('error-message').textContent = 'Error: Media URL not provided';
+      }
+    function link_share() {
+      if (navigator.share) {
+        navigator.share({
+          title: mediaLink,
+          url: window.location.href
+        });
+      }
+      
+    }  
+    function vlc_player() {
+      
+        const openstreamlink = mediaLink;
+        const openVlc = `vlc://${openstreamlink}`;
+        if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
+          // Try opening VLC first, then MX Player if VLC is unavailable
+          window.location.href = openVlc;
+          
+        } else {
+          alert("This feature is currently only supported on Android devices.");
+        }
+       //window.location.href = openVlc;
+    }
+
+    function mx_player() {
+        const openstreamlink = mediaLink;
+        const openMx = `intent:${openstreamlink}#Intent;package=com.mxtech.videoplayer.ad;end`;
+        if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
+          // Try opening VLC first, then MX Player if VLC is unavailable
+          window.location.href = openMx;;
+          
+        } else {
+          alert("This feature is currently only supported on Android devices.");
+        }
+        
+    }
+    function copyStreamLink() {
+      const linkToCopy = mediaLink.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.');
+        });
+    }
+
+
+    </script>
+
+  </body>
+</html>

requirements.txt

@@ -0,0 +1,5 @@
+telethon
+cryptg
+quart
+uvicorn
+requests