Initial commit

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,8 @@
+*.pyc
+*.data
+t.py
+t2.py
+cache
+config copy.py
+logs.txt
+.env

Dockerfile

@@ -0,0 +1,18 @@
+# Use the official Python base image
+FROM python:3.11.7-slim AS base
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Copy the requirements file to the working directory and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the application code to the working directory
+COPY . .
+
+# Expose the port on which the application will run
+EXPOSE 8080
+
+# Run the FastAPI application using uvicorn server
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 TechShreyash
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,170 @@
+# TGDrive - A Google Drive Clone with Telegram Storage
+
+Welcome to TGDrive! This web application replicates Google Drive's functionalities using Telegram as its storage backend. Manage folders and files, perform actions like uploading, renaming, and deleting, utilize trash/bin support, enable permanent deletion, and share public links. The application offers admin login and automatically backs up the database to Telegram.
+
+**Check out the [TGDrive Personal](https://github.com/TechShreyash/TGDrivePersonal) project for local desktop backup support.**
+
+## Features
+
+- **File Management:** Upload, rename, and delete files with integrated trash/bin functionality and permanent deletion support.
+- **Folder Management:** Easily create, rename, and delete folders.
+- **Sharing:** Seamlessly share public links for files and folders.
+- **Admin Support:** Secure admin login for efficient management.
+- **Automatic Backups:** Automated database backups sent directly to Telegram.
+- **Multiple Bots/Clients:** Support for multiple bots/clients for file operations and streaming from Telegram.
+- **Large File Support:** Upload files up to 4GB using Telegram Premium accounts.
+- **Auto Pinger:** Built-in feature to keep the website active by preventing idle timeouts.
+- **URL Upload Support:** Upload files directly to TG Drive from any direct download link of a file.
+- **Bot Mode:** Upload files directly to any folder in TG Drive by sending the file to the bot on Telegram ([Know More](#tg-drives-bot-mode))
+
+## Tech Stack
+
+- **Backend:** Python, FastAPI
+- **Frontend:** HTML, CSS, JavaScript
+- **Database:** Local storage as a class object, saved to a file using the pickle module.
+- **Storage:** Telegram
+
+### Environment Variables
+
+#### Required Variables
+
+| Variable Name            | Type    | Example                   | Description                                                          |
+| ------------------------ | ------- | ------------------------- | -------------------------------------------------------------------- |
+| `API_ID`                 | integer | 123456                    | Your Telegram API ID                                                 |
+| `API_HASH`               | string  | dagsjdhgjfsahgjfh         | Your Telegram API Hash                                               |
+| `BOT_TOKENS`             | string  | 21413535:gkdshajfhjfakhjf | List of Telegram bot tokens for file operations, separated by commas |
+| `STORAGE_CHANNEL`        | integer | -100123456789             | Chat ID of the Telegram storage channel                              |
+| `DATABASE_BACKUP_MSG_ID` | integer | 123                       | Message ID of a file in the storage channel for database backups     |
+
+> Note: All bots mentioned in the `BOT_TOKENS` variable must be added as admins in your `STORAGE_CHANNEL`.
+
+> Note: `DATABASE_BACKUP_MSG_ID` should be the message ID of a file (document) in the `STORAGE_CHANNEL`.
+
+#### Optional Variables
+
+| Variable Name          | Type                 | Default                                    | Description                                                                                                 |
+| ---------------------- | -------------------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------- |
+| `ADMIN_PASSWORD`       | string               | admin                                      | Password for accessing the admin panel                                                                      |
+| `STRING_SESSIONS`      | string               | None                                       | List of Premium Telegram Account Pyrogram String Sessions for file operations                               |
+| `SLEEP_THRESHOLD`      | integer (in seconds) | 60                                         | Delay in seconds before retrying after a Telegram API floodwait error                                       |
+| `DATABASE_BACKUP_TIME` | integer (in seconds) | 60                                         | Interval in seconds for database backups to the storage channel                                             |
+| `MAX_FILE_SIZE`        | float (in GBs)       | 1.98 (3.98 if `STRING_SESSIONS` are added) | Maximum file size (in GBs) allowed for uploading to Telegram                                                |
+| `WEBSITE_URL`          | string               | None                                       | Website URL (with https/http) to auto-ping to keep the website active                                       |
+| `MAIN_BOT_TOKEN`       | string               | None                                       | Your Main Bot Token to use [TG Drive's Bot Mode](#tg-drives-bot-mode)                                       |
+| `TELEGRAM_ADMIN_IDS`   | string               | None                                       | List of Telegram User IDs of admins who can access the [bot mode](#tg-drives-bot-mode), separated by commas |
+
+> Note: Premium Client (`STRING_SESSIONS`) will be used only to upload files when file size is greater than 2GB.
+
+> Note: File streaming/downloads will be handled by bots (`BOT_TOKENS`).
+
+> Note: Read more about TG Drive's Bot Mode [here](#tg-drives-bot-mode).
+
+## Deploying Your Own TG Drive Application
+
+### 1. Clone the Repository
+
+First, clone the repository and navigate into the project directory:
+
+```bash
+git clone https://github.com/TechShreyash/TGDrive
+cd TGDrive
+```
+
+### 2. Set Up Your Environment Variables
+
+Create a `.env` file in the root directory and add the necessary [environment variables](#environment-variables).
+
+> **Note:** Some hosting services allow you to set environment variables directly through their interface, which may eliminate the need for a `.env` file.
+
+### 3. Running TG Drive
+
+#### Deploying Locally
+
+1. Install the required Python packages:
+
+   ```bash
+   pip install -U -r requirements.txt
+   ```
+
+2. Start the TG Drive application using Uvicorn:
+
+   ```bash
+   uvicorn main:app --host 0.0.0.0 --port 8000
+   ```
+
+#### Deploying Using Docker
+
+1. Build the Docker image:
+
+   ```bash
+   docker build -t tgdrive .
+   ```
+
+2. Run the Docker container:
+
+   ```bash
+   docker run -d -p 8000:8000 tgdrive
+   ```
+
+Access the application at `http://127.0.0.1:8000` or `http://your_ip:8000`.
+
+> **Note:** For more detailed information on deploying FastAPI applications, refer to online guides and resources.
+
+## Deploy Tutorials
+
+**Deploy To Render.com For Free :** https://youtu.be/S5OIi5Ur3c0
+
+<div align="center">
+
+[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/TechShreyash/TGDrive)
+
+</div>
+
+> **Note:** After updating the TG Drive code, clear your browser's cache to ensure the latest JavaScript files are loaded and run correctly.
+
+## TG Drive's Bot Mode
+
+TG Drive's Bot Mode is a new feature that allows you to upload files directly to your TG Drive website from a Telegram bot. Simply send or forward any file to the bot, and it will be uploaded to your TG Drive. You can also specify the folder where you want the files to be uploaded.
+
+To use this feature, you need to set the configuration variables `MAIN_BOT_TOKEN` and `TELEGRAM_ADMIN_IDS`. More information about these variables can be found in the [optional variables section](#optional-variables).
+
+Once these variables are set, users whose IDs are listed in `TELEGRAM_ADMIN_IDS` will have access to the bot.
+
+### Bot Commands
+
+- `/set_folder` - Set the folder for file uploads
+- `/current_folder` - Check the current folder
+
+### Quick Demo
+
+Bot Mode - Youtube Video Tutorial : https://youtu.be/XSeY2XcHdGI
+
+#### Uploading Files
+
+1. Open your main bot in Telegram.
+2. Send or forward a file to this bot, and it will be uploaded. By default, the file will be uploaded to the root folder (home page).
+
+#### Changing Folder for Uploading
+
+1. Send the `/set_folder` command and follow the instructions provided by the bot.
+
+## Important Posts Regarding TG Drive
+
+Stay informed by joining our updates channel on Telegram: [@TechZBots](https://telegram.me/TechZBots). We post updates, guides, and tips about TG Drive there.
+
+- https://telegram.me/TechZBots/891
+- https://telegram.me/TechZBots/876
+- https://telegram.me/TechZBots/874
+- https://telegram.me/TechZBots/870
+
+## Contributing
+
+Contributions are welcome! Fork the repository, make your changes, and create a pull request.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Support
+
+For inquiries or support, join our [Telegram Support Group](https://telegram.me/TechZBots_Support) or email [techshreyash123@gmail.com](mailto:techshreyash123@gmail.com).

config.py

@@ -0,0 +1,60 @@
+from dotenv import load_dotenv
+import os
+
+# Load environment variables from the .env file, if present
+load_dotenv()
+
+# Telegram API credentials obtained from https://my.telegram.org/auth
+API_ID = int(os.getenv("API_ID"))  # Your Telegram API ID
+API_HASH = os.getenv("API_HASH")  # Your Telegram API Hash
+
+# List of Telegram bot tokens used for file upload/download operations
+BOT_TOKENS = os.getenv("BOT_TOKENS", "").strip(", ").split(",")
+BOT_TOKENS = [token.strip() for token in BOT_TOKENS if token.strip() != ""]
+
+# List of Premium Telegram Account Pyrogram String Sessions used for file upload/download operations
+STRING_SESSIONS = os.getenv("STRING_SESSIONS", "").strip(", ").split(",")
+STRING_SESSIONS = [
+    session.strip() for session in STRING_SESSIONS if session.strip() != ""
+]
+
+# Chat ID of the Telegram storage channel where files will be stored
+STORAGE_CHANNEL = int(os.getenv("STORAGE_CHANNEL"))  # Your storage channel's chat ID
+
+# Message ID of a file in the storage channel used for storing database backups
+DATABASE_BACKUP_MSG_ID = int(
+    os.getenv("DATABASE_BACKUP_MSG_ID")
+)  # Message ID for database backup
+
+# Password used to access the website's admin panel
+ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "admin")  # Default to "admin" if not set
+
+# Determine the maximum file size (in bytes) allowed for uploading to Telegram
+# 1.98 GB if no premium sessions are provided, otherwise 3.98 GB
+if len(STRING_SESSIONS) == 0:
+    MAX_FILE_SIZE = 1.98 * 1024 * 1024 * 1024  # 2 GB in bytes
+else:
+    MAX_FILE_SIZE = 3.98 * 1024 * 1024 * 1024  # 4 GB in bytes
+
+# Database backup interval in seconds. Backups will be sent to the storage channel at this interval
+DATABASE_BACKUP_TIME = int(
+    os.getenv("DATABASE_BACKUP_TIME", 60)
+)  # Default to 60 seconds
+
+# Time delay in seconds before retrying after a Telegram API floodwait error
+SLEEP_THRESHOLD = int(os.getenv("SLEEP_THRESHOLD", 60))  # Default to 60 seconds
+
+# Domain to auto-ping and keep the website active
+WEBSITE_URL = os.getenv("WEBSITE_URL", None)
+
+
+# For Using TG Drive's Bot Mode
+
+# Main Bot Token for TG Drive's Bot Mode
+MAIN_BOT_TOKEN = os.getenv("MAIN_BOT_TOKEN", "")
+if MAIN_BOT_TOKEN.strip() == "":
+    MAIN_BOT_TOKEN = None
+
+# List of Telegram User IDs who have admin access to the bot mode
+TELEGRAM_ADMIN_IDS = os.getenv("TELEGRAM_ADMIN_IDS", "").strip(", ").split(",")
+TELEGRAM_ADMIN_IDS = [int(id) for id in TELEGRAM_ADMIN_IDS if id.strip() != ""]

docker_start.sh

@@ -0,0 +1,3 @@
+docker stop tgdrive
+docker build -t tgdrive .
+docker run -d --name tgdrive -p 80:80 tgdrive

main.py

@@ -0,0 +1,356 @@
+from utils.downloader import (
+    download_file,
+    get_file_info_from_url,
+)
+import asyncio
+from pathlib import Path
+from contextlib import asynccontextmanager
+import aiofiles
+from fastapi import FastAPI, HTTPException, Request, File, UploadFile, Form, Response
+from fastapi.responses import FileResponse, JSONResponse
+from config import ADMIN_PASSWORD, MAX_FILE_SIZE, STORAGE_CHANNEL
+from utils.clients import initialize_clients
+from utils.directoryHandler import getRandomID
+from utils.extra import auto_ping_website, convert_class_to_dict, reset_cache_dir
+from utils.streamer import media_streamer
+from utils.uploader import start_file_uploader
+from utils.logger import Logger
+import urllib.parse
+
+
+# Startup Event
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Reset the cache directory, delete cache files
+    reset_cache_dir()
+
+    # Initialize the clients
+    await initialize_clients()
+
+    # Start the website auto ping task
+    asyncio.create_task(auto_ping_website())
+
+    yield
+
+
+app = FastAPI(docs_url=None, redoc_url=None, lifespan=lifespan)
+logger = Logger(__name__)
+
+
+@app.get("/")
+async def home_page():
+    return FileResponse("website/home.html")
+
+
+@app.get("/stream")
+async def home_page():
+    return FileResponse("website/VideoPlayer.html")
+
+
+@app.get("/static/{file_path:path}")
+async def static_files(file_path):
+    if "apiHandler.js" in file_path:
+        with open(Path("website/static/js/apiHandler.js")) as f:
+            content = f.read()
+            content = content.replace("MAX_FILE_SIZE__SDGJDG", str(MAX_FILE_SIZE))
+        return Response(content=content, media_type="application/javascript")
+    return FileResponse(f"website/static/{file_path}")
+
+
+@app.get("/file")
+async def dl_file(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+
+    path = request.query_params["path"]
+    file = DRIVE_DATA.get_file(path)
+    return await media_streamer(STORAGE_CHANNEL, file.file_id, file.name, request)
+
+
+# Api Routes
+
+
+@app.post("/api/checkPassword")
+async def check_password(request: Request):
+    data = await request.json()
+    if data["pass"] == ADMIN_PASSWORD:
+        return JSONResponse({"status": "ok"})
+    return JSONResponse({"status": "Invalid password"})
+
+
+@app.post("/api/createNewFolder")
+async def api_new_folder(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"createNewFolder {data}")
+    folder_data = DRIVE_DATA.get_directory(data["path"]).contents
+    for id in folder_data:
+        f = folder_data[id]
+        if f.type == "folder":
+            if f.name == data["name"]:
+                return JSONResponse(
+                    {
+                        "status": "Folder with the name already exist in current directory"
+                    }
+                )
+
+    DRIVE_DATA.new_folder(data["path"], data["name"])
+    return JSONResponse({"status": "ok"})
+
+
+@app.post("/api/getDirectory")
+async def api_get_directory(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+
+    data = await request.json()
+
+    if data["password"] == ADMIN_PASSWORD:
+        is_admin = True
+    else:
+        is_admin = False
+
+    auth = data.get("auth")
+
+    logger.info(f"getFolder {data}")
+
+    if data["path"] == "/trash":
+        data = {"contents": DRIVE_DATA.get_trashed_files_folders()}
+        folder_data = convert_class_to_dict(data, isObject=False, showtrash=True)
+
+    elif "/search_" in data["path"]:
+        query = urllib.parse.unquote(data["path"].split("_", 1)[1])
+        print(query)
+        data = {"contents": DRIVE_DATA.search_file_folder(query)}
+        print(data)
+        folder_data = convert_class_to_dict(data, isObject=False, showtrash=False)
+        print(folder_data)
+
+    elif "/share_" in data["path"]:
+        path = data["path"].split("_", 1)[1]
+        folder_data, auth_home_path = DRIVE_DATA.get_directory(path, is_admin, auth)
+        auth_home_path= auth_home_path.replace("//", "/") if auth_home_path else None
+        folder_data = convert_class_to_dict(folder_data, isObject=True, showtrash=False)
+        return JSONResponse(
+            {"status": "ok", "data": folder_data, "auth_home_path": auth_home_path}
+        )
+
+    else:
+        folder_data = DRIVE_DATA.get_directory(data["path"])
+        folder_data = convert_class_to_dict(folder_data, isObject=True, showtrash=False)
+    return JSONResponse({"status": "ok", "data": folder_data, "auth_home_path": None})
+
+
+SAVE_PROGRESS = {}
+
+
+@app.post("/api/upload")
+async def upload_file(
+    file: UploadFile = File(...),
+    path: str = Form(...),
+    password: str = Form(...),
+    id: str = Form(...),
+    total_size: str = Form(...),
+):
+    global SAVE_PROGRESS
+
+    if password != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    total_size = int(total_size)
+    SAVE_PROGRESS[id] = ("running", 0, total_size)
+
+    ext = file.filename.lower().split(".")[-1]
+
+    cache_dir = Path("./cache")
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    file_location = cache_dir / f"{id}.{ext}"
+
+    file_size = 0
+
+    async with aiofiles.open(file_location, "wb") as buffer:
+        while chunk := await file.read(1024 * 1024):  # Read file in chunks of 1MB
+            SAVE_PROGRESS[id] = ("running", file_size, total_size)
+            file_size += len(chunk)
+            if file_size > MAX_FILE_SIZE:
+                await buffer.close()
+                file_location.unlink()  # Delete the partially written file
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"File size exceeds {MAX_FILE_SIZE} bytes limit",
+                )
+            await buffer.write(chunk)
+
+    SAVE_PROGRESS[id] = ("completed", file_size, file_size)
+
+    asyncio.create_task(
+        start_file_uploader(file_location, id, path, file.filename, file_size)
+    )
+
+    return JSONResponse({"id": id, "status": "ok"})
+
+
+@app.post("/api/getSaveProgress")
+async def get_save_progress(request: Request):
+    global SAVE_PROGRESS
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"getUploadProgress {data}")
+    try:
+        progress = SAVE_PROGRESS[data["id"]]
+        return JSONResponse({"status": "ok", "data": progress})
+    except:
+        return JSONResponse({"status": "not found"})
+
+
+@app.post("/api/getUploadProgress")
+async def get_upload_progress(request: Request):
+    from utils.uploader import PROGRESS_CACHE
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"getUploadProgress {data}")
+
+    try:
+        progress = PROGRESS_CACHE[data["id"]]
+        return JSONResponse({"status": "ok", "data": progress})
+    except:
+        return JSONResponse({"status": "not found"})
+
+
+@app.post("/api/cancelUpload")
+async def cancel_upload(request: Request):
+    from utils.uploader import STOP_TRANSMISSION
+    from utils.downloader import STOP_DOWNLOAD
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"cancelUpload {data}")
+    STOP_TRANSMISSION.append(data["id"])
+    STOP_DOWNLOAD.append(data["id"])
+    return JSONResponse({"status": "ok"})
+
+
+@app.post("/api/renameFileFolder")
+async def rename_file_folder(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"renameFileFolder {data}")
+    DRIVE_DATA.rename_file_folder(data["path"], data["name"])
+    return JSONResponse({"status": "ok"})
+
+
+@app.post("/api/trashFileFolder")
+async def trash_file_folder(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"trashFileFolder {data}")
+    DRIVE_DATA.trash_file_folder(data["path"], data["trash"])
+    return JSONResponse({"status": "ok"})
+
+
+@app.post("/api/deleteFileFolder")
+async def delete_file_folder(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"deleteFileFolder {data}")
+    DRIVE_DATA.delete_file_folder(data["path"])
+    return JSONResponse({"status": "ok"})
+
+
+@app.post("/api/getFileInfoFromUrl")
+async def getFileInfoFromUrl(request: Request):
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"getFileInfoFromUrl {data}")
+    try:
+        file_info = await get_file_info_from_url(data["url"])
+        return JSONResponse({"status": "ok", "data": file_info})
+    except Exception as e:
+        return JSONResponse({"status": str(e)})
+
+
+@app.post("/api/startFileDownloadFromUrl")
+async def startFileDownloadFromUrl(request: Request):
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"startFileDownloadFromUrl {data}")
+    try:
+        id = getRandomID()
+        asyncio.create_task(
+            download_file(data["url"], id, data["path"], data["filename"], data["singleThreaded"])
+        )
+        return JSONResponse({"status": "ok", "id": id})
+    except Exception as e:
+        return JSONResponse({"status": str(e)})
+
+
+@app.post("/api/getFileDownloadProgress")
+async def getFileDownloadProgress(request: Request):
+    from utils.downloader import DOWNLOAD_PROGRESS
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"getFileDownloadProgress {data}")
+
+    try:
+        progress = DOWNLOAD_PROGRESS[data["id"]]
+        return JSONResponse({"status": "ok", "data": progress})
+    except:
+        return JSONResponse({"status": "not found"})
+
+
+@app.post("/api/getFolderShareAuth")
+async def getFolderShareAuth(request: Request):
+    from utils.directoryHandler import DRIVE_DATA
+
+    data = await request.json()
+
+    if data["password"] != ADMIN_PASSWORD:
+        return JSONResponse({"status": "Invalid password"})
+
+    logger.info(f"getFolderShareAuth {data}")
+
+    try:
+        auth = DRIVE_DATA.get_folder_auth(data["path"])
+        return JSONResponse({"status": "ok", "auth": auth})
+    except:
+        return JSONResponse({"status": "not found"})

render.yaml

@@ -0,0 +1,24 @@
+services:
+  # A Docker web service
+  - type: web
+    name: tgdrive
+    repo: https://github.com/TechShreyash/TGDrive
+    runtime: python
+    branch: main
+    plan: free
+    autoDeploy: false
+    buildCommand: pip install -r requirements.txt
+    startCommand: uvicorn main:app --host 0.0.0.0 --port $PORT
+    envVars:
+      - key: ADMIN_PASSWORD
+        sync: false
+      - key: API_ID
+        sync: false
+      - key: API_HASH
+        sync: false
+      - key: BOT_TOKENS
+        sync: false
+      - key: STORAGE_CHANNEL
+        sync: false
+      - key: DATABASE_BACKUP_MSG_ID
+        sync: false

requirements.txt

@@ -0,0 +1,11 @@
+https://github.com/KurimuzonAkuma/pyrogram/archive/dev.zip
+tgcrypto
+uvicorn
+fastapi[all]
+python-dotenv
+aiofiles
+aiohttp
+curl_cffi
+techzdl>=1.2.6
+tqdm
+dill

runtime.txt

@@ -0,0 +1 @@
+python-3.11

sample.env

@@ -0,0 +1,7 @@
+# Required Vars
+
+API_ID=123456
+API_HASH=dagsjdhgjfsahgjfh
+BOT_TOKENS=21413535:gkdshajfhjfakhjf
+STORAGE_CHANNEL=-100123456789
+DATABASE_BACKUP_MSG_ID=123

start_main.py

@@ -0,0 +1,3 @@
+import os
+
+os.system("uvicorn main:app --reload")

utils/bot_mode.py

@@ -0,0 +1,197 @@
+import asyncio
+from pyrogram import Client, filters
+from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
+import config
+from utils.logger import Logger
+from pathlib import Path
+
+logger = Logger(__name__)
+
+START_CMD = """🚀 **Welcome To TG Drive's Bot Mode**
+
+You can use this bot to upload files to your TG Drive website directly instead of doing it from website.
+
+🗄 **Commands:**
+/set_folder - Set folder for file uploads
+/current_folder - Check current folder
+
+📤 **How To Upload Files:** Send a file to this bot and it will be uploaded to your TG Drive website. You can also set a folder for file uploads using /set_folder command.
+
+Read more about [TG Drive's Bot Mode](https://github.com/TechShreyash/TGDrive#tg-drives-bot-mode)
+"""
+
+SET_FOLDER_PATH_CACHE = {}  # Cache to store folder path for each folder id
+DRIVE_DATA = None
+BOT_MODE = None
+
+session_cache_path = Path(f"./cache")
+session_cache_path.parent.mkdir(parents=True, exist_ok=True)
+
+main_bot = Client(
+    name="main_bot",
+    api_id=config.API_ID,
+    api_hash=config.API_HASH,
+    bot_token=config.MAIN_BOT_TOKEN,
+    sleep_threshold=config.SLEEP_THRESHOLD,
+    workdir=session_cache_path,
+)
+
+
+@main_bot.on_message(
+    filters.command(["start", "help"])
+    & filters.private
+    & filters.user(config.TELEGRAM_ADMIN_IDS),
+)
+async def start_handler(client: Client, message: Message):
+    await message.reply_text(START_CMD)
+
+
+@main_bot.on_message(
+    filters.command("set_folder")
+    & filters.private
+    & filters.user(config.TELEGRAM_ADMIN_IDS),
+)
+async def set_folder_handler(client: Client, message: Message):
+    global SET_FOLDER_PATH_CACHE, DRIVE_DATA
+
+    while True:
+        try:
+            folder_name = await message.ask(
+                "Send the folder name where you want to upload files\n\n/cancel to cancel",
+                timeout=60,
+                filters=filters.text,
+            )
+        except asyncio.TimeoutError:
+            await message.reply_text("Timeout\n\nUse /set_folder to set folder again")
+            return
+
+        if folder_name.text.lower() == "/cancel":
+            await message.reply_text("Cancelled")
+            return
+
+        folder_name = folder_name.text.strip()
+        search_result = DRIVE_DATA.search_file_folder(folder_name)
+
+        # Get folders from search result
+        folders = {}
+        for item in search_result.values():
+            if item.type == "folder":
+                folders[item.id] = item
+
+        if len(folders) == 0:
+            await message.reply_text(f"No Folder found with name {folder_name}")
+        else:
+            break
+
+    buttons = []
+    folder_cache = {}
+    folder_cache_id = len(SET_FOLDER_PATH_CACHE) + 1
+
+    for folder in search_result.values():
+        path = folder.path.strip("/")
+        folder_path = "/" + ("/" + path + "/" + folder.id).strip("/")
+        folder_cache[folder.id] = (folder_path, folder.name)
+        buttons.append(
+            [
+                InlineKeyboardButton(
+                    folder.name,
+                    callback_data=f"set_folder_{folder_cache_id}_{folder.id}",
+                )
+            ]
+        )
+    SET_FOLDER_PATH_CACHE[folder_cache_id] = folder_cache
+
+    await message.reply_text(
+        "Select the folder where you want to upload files",
+        reply_markup=InlineKeyboardMarkup(buttons),
+    )
+
+
+@main_bot.on_callback_query(
+    filters.user(config.TELEGRAM_ADMIN_IDS) & filters.regex(r"set_folder_")
+)
+async def set_folder_callback(client: Client, callback_query: Message):
+    global SET_FOLDER_PATH_CACHE, BOT_MODE
+
+    folder_cache_id, folder_id = callback_query.data.split("_")[2:]
+
+    folder_path_cache = SET_FOLDER_PATH_CACHE.get(int(folder_cache_id))
+    if folder_path_cache is None:
+        await callback_query.answer("Request Expired, Send /set_folder again")
+        await callback_query.message.delete()
+        return
+
+    folder_path, name = folder_path_cache.get(folder_id)
+    del SET_FOLDER_PATH_CACHE[int(folder_cache_id)]
+    BOT_MODE.set_folder(folder_path, name)
+
+    await callback_query.answer(f"Folder Set Successfully To : {name}")
+    await callback_query.message.edit(
+        f"Folder Set Successfully To : {name}\n\nNow you can send / forward files to me and it will be uploaded to this folder."
+    )
+
+
+@main_bot.on_message(
+    filters.command("current_folder")
+    & filters.private
+    & filters.user(config.TELEGRAM_ADMIN_IDS),
+)
+async def current_folder_handler(client: Client, message: Message):
+    global BOT_MODE
+
+    await message.reply_text(f"Current Folder: {BOT_MODE.current_folder_name}")
+
+
+# Handling when any file is sent to the bot
+@main_bot.on_message(
+    filters.private
+    & filters.user(config.TELEGRAM_ADMIN_IDS)
+    & (
+        filters.document
+        | filters.video
+        | filters.audio
+        | filters.photo
+        | filters.sticker
+    )
+)
+async def file_handler(client: Client, message: Message):
+    global BOT_MODE, DRIVE_DATA
+
+    copied_message = await message.copy(config.STORAGE_CHANNEL)
+    file = (
+        copied_message.document
+        or copied_message.video
+        or copied_message.audio
+        or copied_message.photo
+        or copied_message.sticker
+    )
+
+    DRIVE_DATA.new_file(
+        BOT_MODE.current_folder,
+        file.file_name,
+        copied_message.id,
+        file.file_size,
+    )
+
+    await message.reply_text(
+        f"""✅ File Uploaded Successfully To Your TG Drive Website
+                             
+**File Name:** {file.file_name}
+**Folder:** {BOT_MODE.current_folder_name}
+"""
+    )
+
+
+async def start_bot_mode(d, b):
+    global DRIVE_DATA, BOT_MODE
+    DRIVE_DATA = d
+    BOT_MODE = b
+
+    logger.info("Starting Main Bot")
+    await main_bot.start()
+
+    await main_bot.send_message(
+        config.STORAGE_CHANNEL, "Main Bot Started -> TG Drive's Bot Mode Enabled"
+    )
+    logger.info("Main Bot Started")
+    logger.info("TG Drive's Bot Mode Enabled")

utils/clients.py

@@ -0,0 +1,113 @@
+import asyncio, config
+from pathlib import Path
+from pyrogram import Client
+from utils.directoryHandler import backup_drive_data, loadDriveData
+from utils.logger import Logger
+import os
+import signal
+
+logger = Logger(__name__)
+
+multi_clients = {}
+premium_clients = {}
+work_loads = {}
+premium_work_loads = {}
+main_bot = None
+
+
+async def initialize_clients():
+    global multi_clients, work_loads, premium_clients, premium_work_loads
+    logger.info("Initializing Clients")
+
+    session_cache_path = Path(f"./cache")
+    session_cache_path.parent.mkdir(parents=True, exist_ok=True)
+
+    all_tokens = dict((i, t) for i, t in enumerate(config.BOT_TOKENS, start=1))
+    all_sessions = dict(
+        (i, s) for i, s in enumerate(config.STRING_SESSIONS, start=len(all_tokens) + 1)
+    )
+
+    async def start_client(client_id, token, type):
+        try:
+            logger.info(f"Starting - {type.title()} Client {client_id}")
+
+            if type == "bot":
+                client = Client(
+                    name=str(client_id),
+                    api_id=config.API_ID,
+                    api_hash=config.API_HASH,
+                    bot_token=token,
+                    workdir=session_cache_path,
+                )
+                client.loop = asyncio.get_running_loop()
+                await client.start()
+                await client.send_message(
+                    config.STORAGE_CHANNEL,
+                    f"Started - {type.title()} Client {client_id}",
+                )
+                multi_clients[client_id] = client
+                work_loads[client_id] = 0
+            elif type == "user":
+                client = await Client(
+                    name=str(client_id),
+                    api_id=config.API_ID,
+                    api_hash=config.API_HASH,
+                    session_string=token,
+                    sleep_threshold=config.SLEEP_THRESHOLD,
+                    workdir=session_cache_path,
+                    no_updates=True,
+                ).start()
+                await client.send_message(
+                    config.STORAGE_CHANNEL,
+                    f"Started - {type.title()} Client {client_id}",
+                )
+                premium_clients[client_id] = client
+                premium_work_loads[client_id] = 0
+
+            logger.info(f"Started - {type.title()} Client {client_id}")
+        except Exception as e:
+            logger.error(
+                f"Failed To Start {type.title()} Client - {client_id} Error: {e}"
+            )
+
+    await asyncio.gather(
+        *(
+            [
+                start_client(client_id, client, "bot")
+                for client_id, client in all_tokens.items()
+            ]
+            + [
+                start_client(client_id, client, "user")
+                for client_id, client in all_sessions.items()
+            ]
+        )
+    )
+    if len(multi_clients) == 0:
+        logger.error("No Clients Were Initialized")
+
+        # Forcefully terminates the program immediately
+        os.kill(os.getpid(), signal.SIGKILL)
+
+    if len(premium_clients) == 0:
+        logger.info("No Premium Clients Were Initialized")
+
+    logger.info("Clients Initialized")
+
+    # Load the drive data
+    await loadDriveData()
+
+    # Start the backup drive data task
+    asyncio.create_task(backup_drive_data())
+
+
+def get_client(premium_required=False) -> Client:
+    global multi_clients, work_loads, premium_clients, premium_work_loads
+
+    if premium_required:
+        index = min(premium_work_loads, key=premium_work_loads.get)
+        premium_work_loads[index] += 1
+        return premium_clients[index]
+
+    index = min(work_loads, key=work_loads.get)
+    work_loads[index] += 1
+    return multi_clients[index]

utils/directoryHandler.py

@@ -0,0 +1,387 @@
+from pathlib import Path
+import sys
+import config, dill
+from pyrogram.types import InputMediaDocument, Message
+import os, random, string, asyncio
+from utils.logger import Logger
+from datetime import datetime, timezone
+import os
+import signal
+
+logger = Logger(__name__)
+
+cache_dir = Path("./cache")
+cache_dir.mkdir(parents=True, exist_ok=True)
+drive_cache_path = cache_dir / "drive.data"
+
+
+def getRandomID():
+    global DRIVE_DATA
+    while True:
+        id = "".join(random.choices(string.ascii_uppercase + string.digits, k=6))
+        if not DRIVE_DATA:
+            return id
+        if id not in DRIVE_DATA.used_ids:
+            DRIVE_DATA.used_ids.append(id)
+            return id
+
+
+def get_current_utc_time():
+    return datetime.now(timezone.utc).strftime("Date - %Y-%m-%d | Time - %H:%M:%S")
+
+
+class Folder:
+    def __init__(self, name: str, path: str) -> None:
+        self.name = name
+        self.contents = {}
+        if name == "/":
+            self.id = "root"
+        else:
+            self.id = getRandomID()
+        self.type = "folder"
+        self.trash = False
+        self.path = ("/" + path.strip("/") + "/").replace("//", "/")
+        self.upload_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        self.auth_hashes = []
+
+
+class File:
+    def __init__(
+        self,
+        name: str,
+        file_id: int,
+        size: int,
+        path: str,
+    ) -> None:
+        self.name = name
+        self.file_id = file_id
+        self.id = getRandomID()
+        self.size = size
+        self.type = "file"
+        self.trash = False
+        self.path = path[:-1] if path[-1] == "/" else path
+        self.upload_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+class NewDriveData:
+    def __init__(self, contents: dict, used_ids: list) -> None:
+        self.contents = contents
+        self.used_ids = used_ids
+        self.isUpdated = False
+
+    def save(self) -> None:
+        with open(drive_cache_path, "wb") as f:
+            dill.dump(self, f)
+        self.isUpdated = True
+        logger.info("Drive data saved successfully.")
+
+    def new_folder(self, path: str, name: str) -> None:
+        logger.info(f"Creating new folder '{name}' in path '{path}'.")
+
+        folder = Folder(name, path)
+        if path == "/":
+            directory_folder: Folder = self.contents[path]
+            directory_folder.contents[folder.id] = folder
+        else:
+            paths = path.strip("/").split("/")
+            directory_folder: Folder = self.contents["/"]
+            for path in paths:
+                directory_folder = directory_folder.contents[path]
+            directory_folder.contents[folder.id] = folder
+
+        self.save()
+        return folder.path + folder.id
+
+    def new_file(self, path: str, name: str, file_id: int, size: int) -> None:
+        logger.info(f"Creating new file '{name}' in path '{path}'.")
+
+        file = File(name, file_id, size, path)
+        if path == "/":
+            directory_folder: Folder = self.contents[path]
+            directory_folder.contents[file.id] = file
+        else:
+            paths = path.strip("/").split("/")
+            directory_folder: Folder = self.contents["/"]
+            for path in paths:
+                directory_folder = directory_folder.contents[path]
+            directory_folder.contents[file.id] = file
+
+        self.save()
+
+    def get_directory(
+        self, path: str, is_admin: bool = True, auth: str = None
+    ) -> Folder:
+        folder_data: Folder = self.contents["/"]
+        auth_success = False
+        auth_home_path = None
+
+        if path != "/":
+            path = path.strip("/")
+
+            if "/" in path:
+                path = path.split("/")
+            else:
+                path = [path]
+
+            for folder in path:
+                folder_data = folder_data.contents[folder]
+
+                if auth in folder_data.auth_hashes:
+                    auth_success = True
+                    auth_home_path = (
+                        "/" + folder_data.path.strip("/") + "/" + folder_data.id
+                    )
+
+        if not is_admin and not auth_success:
+            logger.warning(f"Unauthorized access attempt to path '{path}'.")
+            return None
+
+        if auth_success:
+            logger.info(f"Authorization successful for path '{path}'.")
+            return folder_data, auth_home_path
+
+        return folder_data
+
+    def get_folder_auth(self, path: str) -> None:
+        auth = getRandomID()
+        folder_data: Folder = self.contents["/"]
+
+        if path != "/":
+            path = path.strip("/")
+
+            if "/" in path:
+                path = path.split("/")
+            else:
+                path = [path]
+
+            for folder in path:
+                folder_data = folder_data.contents[folder]
+
+        folder_data.auth_hashes.append(auth)
+        self.save()
+        logger.info(f"Authorization hash generated for path '{path}'.")
+        return auth
+
+    def get_file(self, path) -> File:
+        if len(path.strip("/").split("/")) > 0:
+            folder_path = "/" + "/".join(path.strip("/").split("/")[:-1])
+            file_id = path.strip("/").split("/")[-1]
+        else:
+            folder_path = "/"
+            file_id = path.strip("/")
+
+        folder_data = self.get_directory(folder_path)
+        return folder_data.contents[file_id]
+
+    def rename_file_folder(self, path: str, new_name: str) -> None:
+        if len(path.strip("/").split("/")) > 0:
+            folder_path = "/" + "/".join(path.strip("/").split("/")[:-1])
+            file_id = path.strip("/").split("/")[-1]
+        else:
+            folder_path = "/"
+            file_id = path.strip("/")
+        folder_data = self.get_directory(folder_path)
+        folder_data.contents[file_id].name = new_name
+        self.save()
+        logger.info(f"Item at path '{path}' renamed to '{new_name}'.")
+
+    def trash_file_folder(self, path: str, trash: bool) -> None:
+        action = "Trashing" if trash else "Restoring"
+
+        if len(path.strip("/").split("/")) > 0:
+            folder_path = "/" + "/".join(path.strip("/").split("/")[:-1])
+            file_id = path.strip("/").split("/")[-1]
+        else:
+            folder_path = "/"
+            file_id = path.strip("/")
+        folder_data = self.get_directory(folder_path)
+        folder_data.contents[file_id].trash = trash
+        self.save()
+        logger.info(f"Item at path '{path}' {action.lower()} successfully.")
+
+    def get_trashed_files_folders(self):
+        root_dir = self.get_directory("/")
+        trash_data = {}
+
+        def traverse_directory(folder):
+            for item in folder.contents.values():
+                if item.type == "folder":
+                    if item.trash:
+                        trash_data[item.id] = item
+                    else:
+                        # Recursively traverse the subfolder
+                        traverse_directory(item)
+                elif item.type == "file":
+                    if item.trash:
+                        trash_data[item.id] = item
+
+        traverse_directory(root_dir)
+        return trash_data
+
+    def delete_file_folder(self, path: str) -> None:
+
+        if len(path.strip("/").split("/")) > 0:
+            folder_path = "/" + "/".join(path.strip("/").split("/")[:-1])
+            file_id = path.strip("/").split("/")[-1]
+        else:
+            folder_path = "/"
+            file_id = path.strip("/")
+
+        folder_data = self.get_directory(folder_path)
+        del folder_data.contents[file_id]
+        self.save()
+        logger.info(f"Item at path '{path}' deleted successfully.")
+
+    def search_file_folder(self, query: str):
+        logger.info(f"Searching for items matching query '{query}'.")
+
+        root_dir = self.get_directory("/")
+        search_results = {}
+
+        def traverse_directory(folder):
+            for item in folder.contents.values():
+                if query.lower() in item.name.lower():
+                    search_results[item.id] = item
+                if item.type == "folder":
+                    traverse_directory(item)
+
+        traverse_directory(root_dir)
+        logger.info(f"Search completed. Found {len(search_results)} matching items.")
+        return search_results
+
+
+class NewBotMode:
+    def __init__(self, drive_data: NewDriveData) -> None:
+        self.drive_data = drive_data
+
+        # Set the current folder to root directory by default
+        self.current_folder = "/"
+        self.current_folder_name = "/ (root directory)"
+
+    def set_folder(self, folder_path: str, name: str) -> None:
+        self.current_folder = folder_path
+        self.current_folder_name = name
+        self.drive_data.save()
+        logger.info(f"Current folder set to '{name}' at path '{folder_path}'.")
+
+
+DRIVE_DATA: NewDriveData = None
+BOT_MODE: NewBotMode = None
+
+
+# Function to backup the drive data to telegram
+async def backup_drive_data(loop=True):
+    global DRIVE_DATA
+    logger.info("Starting backup drive data task.")
+
+    while True:
+        try:
+            if not DRIVE_DATA.isUpdated:
+                if not loop:
+                    break
+                await asyncio.sleep(config.DATABASE_BACKUP_TIME)
+                continue
+
+            logger.info("Backing up drive data to Telegram.")
+            from utils.clients import get_client
+
+            client = get_client()
+            time_text = f"📅 **Last Updated :** {get_current_utc_time()} (UTC +00:00)"
+            caption = (
+                f"🔐 **TG Drive Data Backup File**\n\n"
+                "Do not edit or delete this message. This is a backup file for the tg drive data.\n\n"
+                f"{time_text}"
+            )
+
+            media_doc = InputMediaDocument(drive_cache_path, caption=caption)
+            msg = await client.edit_message_media(
+                config.STORAGE_CHANNEL,
+                config.DATABASE_BACKUP_MSG_ID,
+                media=media_doc,
+                file_name="drive.data",
+            )
+
+            DRIVE_DATA.isUpdated = False
+            logger.info("Drive data backed up to Telegram successfully.")
+
+            try:
+                await msg.pin()
+            except Exception as pin_e:
+                logger.error(f"Error pinning backup message: {pin_e}")
+
+            if not loop:
+                break
+
+            await asyncio.sleep(config.DATABASE_BACKUP_TIME)
+        except Exception as e:
+            logger.error(f"Backup Error: {e}")
+            await asyncio.sleep(10)
+
+
+async def init_drive_data():
+    global DRIVE_DATA
+
+    logger.info("Initializing drive data.")
+    root_dir = DRIVE_DATA.get_directory("/")
+    if not hasattr(root_dir, "auth_hashes"):
+        root_dir.auth_hashes = []
+
+    def traverse_directory(folder):
+        for item in folder.contents.values():
+            if item.type == "folder":
+                traverse_directory(item)
+
+                if not hasattr(item, "auth_hashes"):
+                    item.auth_hashes = []
+
+    traverse_directory(root_dir)
+    DRIVE_DATA.save()
+    logger.info("Drive data initialization completed.")
+
+
+async def loadDriveData():
+    global DRIVE_DATA, BOT_MODE
+
+    logger.info("Loading drive data.")
+    from utils.clients import get_client
+
+    client = get_client()
+    try:
+        try:
+            msg: Message = await client.get_messages(
+                config.STORAGE_CHANNEL, config.DATABASE_BACKUP_MSG_ID
+            )
+        except Exception as e:
+            logger.error(f"Error fetching backup message: {e}")
+
+            # Forcefully terminates the program immediately
+            os.kill(os.getpid(), signal.SIGKILL)
+
+        if not msg.document:
+            logger.error(f"Error fetching backup message: {e}")
+
+            # Forcefully terminates the program immediately
+            os.kill(os.getpid(), signal.SIGKILL)
+
+        if msg.document.file_name == "drive.data":
+            dl_path = await msg.download()
+            with open(dl_path, "rb") as f:
+                DRIVE_DATA = dill.load(f)
+
+            logger.info("Drive data loaded from Telegram backup.")
+        else:
+            raise Exception("Backup drive.data file not found on Telegram.")
+    except Exception as e:
+        logger.warning(f"Backup load failed: {e}")
+        logger.info("Creating new drive.data file.")
+        DRIVE_DATA = NewDriveData({"/": Folder("/", "/")}, [])
+        DRIVE_DATA.save()
+
+    await init_drive_data()
+
+    if config.MAIN_BOT_TOKEN:
+        from utils.bot_mode import start_bot_mode
+
+        BOT_MODE = NewBotMode(DRIVE_DATA)
+        await start_bot_mode(DRIVE_DATA, BOT_MODE)
+        logger.info("Bot mode started.")

utils/downloader.py

@@ -0,0 +1,85 @@
+import os
+import aiohttp, asyncio
+from utils.extra import get_filename
+from utils.logger import Logger
+from pathlib import Path
+from utils.uploader import start_file_uploader
+from techzdl import TechZDL
+
+logger = Logger(__name__)
+
+DOWNLOAD_PROGRESS = {}
+STOP_DOWNLOAD = []
+
+cache_dir = Path("./cache")
+cache_dir.mkdir(parents=True, exist_ok=True)
+
+
+async def download_progress_callback(status, current, total, id):
+    global DOWNLOAD_PROGRESS
+
+    DOWNLOAD_PROGRESS[id] = (
+        status,
+        current,
+        total,
+    )
+
+
+async def download_file(url, id, path, filename, singleThreaded):
+    global DOWNLOAD_PROGRESS, STOP_DOWNLOAD
+
+    logger.info(f"Downloading file from {url}")
+
+    try:
+        downloader = TechZDL(
+            url,
+            output_dir=cache_dir,
+            debug=False,
+            progress_callback=download_progress_callback,
+            progress_args=(id,),
+            max_retries=5,
+            single_threaded=singleThreaded,
+        )
+        await downloader.start(in_background=True)
+
+        await asyncio.sleep(5)
+
+        while downloader.is_running:
+            if id in STOP_DOWNLOAD:
+                logger.info(f"Stopping download {id}")
+                await downloader.stop()
+                return
+            await asyncio.sleep(1)
+
+        if downloader.download_success is False:
+            raise downloader.download_error
+
+        DOWNLOAD_PROGRESS[id] = (
+            "completed",
+            downloader.total_size,
+            downloader.total_size,
+        )
+
+        logger.info(f"File downloaded to {downloader.output_path}")
+
+        asyncio.create_task(
+            start_file_uploader(
+                downloader.output_path, id, path, filename, downloader.total_size
+            )
+        )
+    except Exception as e:
+        DOWNLOAD_PROGRESS[id] = ("error", 0, 0)
+        logger.error(f"Failed to download file: {url} {e}")
+
+
+async def get_file_info_from_url(url):
+    downloader = TechZDL(
+        url,
+        output_dir=cache_dir,
+        debug=False,
+        progress_callback=download_progress_callback,
+        progress_args=(id,),
+        max_retries=5,
+    )
+    file_info = await downloader.get_file_info()
+    return {"file_size": file_info["total_size"], "file_name": file_info["filename"]}

utils/extra.py

@@ -0,0 +1,124 @@
+import mimetypes
+from urllib.parse import unquote_plus
+import re
+import urllib.parse
+from pathlib import Path
+from config import WEBSITE_URL
+import asyncio, aiohttp
+from utils.directoryHandler import get_current_utc_time, getRandomID
+from utils.logger import Logger
+
+logger = Logger(__name__)
+
+
+def convert_class_to_dict(data, isObject, showtrash=False):
+    if isObject == True:
+        data = data.__dict__.copy()
+    new_data = {"contents": {}}
+
+    for key in data["contents"]:
+        if data["contents"][key].trash == showtrash:
+            if data["contents"][key].type == "folder":
+                folder = data["contents"][key]
+                new_data["contents"][key] = {
+                    "name": folder.name,
+                    "type": folder.type,
+                    "id": folder.id,
+                    "path": folder.path,
+                    "upload_date": folder.upload_date,
+                }
+            else:
+                file = data["contents"][key]
+                new_data["contents"][key] = {
+                    "name": file.name,
+                    "type": file.type,
+                    "size": file.size,
+                    "id": file.id,
+                    "path": file.path,
+                    "upload_date": file.upload_date,
+                }
+    return new_data
+
+
+async def auto_ping_website():
+    if WEBSITE_URL is not None:
+        async with aiohttp.ClientSession() as session:
+            while True:
+                try:
+                    async with session.get(WEBSITE_URL) as response:
+                        if response.status == 200:
+                            logger.info(f"Pinged website at {get_current_utc_time()}")
+                        else:
+                            logger.warning(f"Failed to ping website: {response.status}")
+                except Exception as e:
+                    logger.warning(f"Failed to ping website: {e}")
+
+                await asyncio.sleep(60)  # Ping website every minute
+
+
+import shutil
+
+
+def reset_cache_dir():
+    cache_dir = Path("./cache")
+    downloads_dir = Path("./downloads")
+    shutil.rmtree(cache_dir, ignore_errors=True)
+    shutil.rmtree(downloads_dir, ignore_errors=True)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    downloads_dir.mkdir(parents=True, exist_ok=True)
+    logger.info("Cache and downloads directory reset")
+
+
+def parse_content_disposition(content_disposition):
+    # Split the content disposition into parts
+    parts = content_disposition.split(";")
+
+    # Initialize filename variable
+    filename = None
+
+    # Loop through parts to find the filename
+    for part in parts:
+        part = part.strip()
+        if part.startswith("filename="):
+            # If filename is found
+            filename = part.split("=", 1)[1]
+        elif part.startswith("filename*="):
+            # If filename* is found
+            match = re.match(r"filename\*=(\S*)''(.*)", part)
+            if match:
+                encoding, value = match.groups()
+                try:
+                    filename = urllib.parse.unquote(value, encoding=encoding)
+                except ValueError:
+                    # Handle invalid encoding
+                    pass
+
+    if filename is None:
+        raise Exception("Failed to get filename")
+    return filename
+
+
+def get_filename(headers, url):
+    try:
+        if headers.get("Content-Disposition"):
+            filename = parse_content_disposition(headers["Content-Disposition"])
+        else:
+            filename = unquote_plus(url.strip("/").split("/")[-1])
+
+        filename = filename.strip(' "')
+    except:
+        filename = unquote_plus(url.strip("/").split("/")[-1])
+
+    filename = filename.strip()
+
+    if filename == "" or "." not in filename:
+        if headers.get("Content-Type"):
+            extension = mimetypes.guess_extension(headers["Content-Type"])
+            if extension:
+                filename = f"{getRandomID()}{extension}"
+            else:
+                filename = getRandomID()
+        else:
+            filename = getRandomID()
+
+    return filename

utils/logger.py

@@ -0,0 +1,48 @@
+import logging
+from tqdm import tqdm
+
+
+class TqdmLoggingHandler(logging.Handler):
+    def emit(self, record):
+        try:
+            msg = self.format(record)
+            tqdm.write(msg)
+            self.flush()
+        except Exception:
+            self.handleError(record)
+
+
+class Logger:
+    def __init__(self, name, level=logging.DEBUG):
+        self.logger = logging.getLogger(name)
+        self.logger.setLevel(level)
+        self.formatter = logging.Formatter("%(name)s - %(levelname)s - %(message)s")
+
+        # Remove existing handlers to prevent duplicate logs
+        if self.logger.hasHandlers():
+            self.logger.handlers.clear()
+
+        # FileHandler for logging to a file
+        file_handler = logging.FileHandler("logs.txt", mode="w")
+        file_handler.setFormatter(self.formatter)
+        self.logger.addHandler(file_handler)
+
+        # Custom TqdmLoggingHandler for console output
+        stream_handler = TqdmLoggingHandler()
+        stream_handler.setFormatter(self.formatter)
+        self.logger.addHandler(stream_handler)
+
+    def debug(self, message):
+        self.logger.debug(message)
+
+    def info(self, message):
+        self.logger.info(message)
+
+    def warning(self, message):
+        self.logger.warning(message)
+
+    def error(self, message):
+        self.logger.error(message)
+
+    def critical(self, message):
+        self.logger.critical(message)

utils/streamer/__init__.py

@@ -0,0 +1,82 @@
+import math, mimetypes
+from fastapi.responses import StreamingResponse, Response
+from utils.logger import Logger
+from utils.streamer.custom_dl import ByteStreamer
+from utils.streamer.file_properties import get_name
+from utils.clients import (
+    get_client,
+)
+from urllib.parse import quote
+
+logger = Logger(__name__)
+
+class_cache = {}
+
+
+async def media_streamer(channel: int, message_id: int, file_name: str, request):
+    global class_cache
+
+    range_header = request.headers.get("Range", 0)
+
+    faster_client = get_client()
+
+    if faster_client in class_cache:
+        tg_connect = class_cache[faster_client]
+    else:
+        tg_connect = ByteStreamer(faster_client)
+        class_cache[faster_client] = tg_connect
+
+    file_id = await tg_connect.get_file_properties(channel, message_id)
+    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 = 0
+        until_bytes = file_size - 1
+
+    if (until_bytes > file_size) or (from_bytes < 0) or (until_bytes < from_bytes):
+        return Response(
+            status_code=416,
+            content="416: Range not satisfiable",
+            headers={"Content-Range": f"bytes */{file_size}"},
+        )
+
+    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 = math.ceil(until_bytes / chunk_size) - math.floor(offset / chunk_size)
+    body = tg_connect.yield_file(
+        file_id, offset, first_part_cut, last_part_cut, part_count, chunk_size
+    )
+
+    disposition = "attachment"
+    mime_type = mimetypes.guess_type(file_name.lower())[0] or "application/octet-stream"
+
+    if (
+        "video/" in mime_type
+        or "audio/" in mime_type
+        or "image/" in mime_type
+        or "/html" in mime_type
+    ):
+        disposition = "inline"
+
+    return StreamingResponse(
+        status_code=206 if range_header else 200,
+        content=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="{quote(file_name)}"',
+            "Accept-Ranges": "bytes",
+        },
+        media_type=mime_type,
+    )

utils/streamer/custom_dl.py

@@ -0,0 +1,199 @@
+import asyncio
+from typing import Dict, Union
+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 utils.logger import Logger
+
+logger = Logger(__name__)
+
+
+class ByteStreamer:
+    def __init__(self, client: Client):
+        self.clean_timer = 30 * 60
+        self.client: Client = client
+        self.cached_file_ids: Dict[int, FileId] = {}
+        asyncio.create_task(self.clean_cache())
+
+    async def get_file_properties(self, channel, message_id: int) -> FileId:
+        if message_id not in self.cached_file_ids:
+            await self.generate_file_properties(channel, message_id)
+        return self.cached_file_ids[message_id]
+
+    async def generate_file_properties(self, channel, message_id: int) -> FileId:
+        file_id = await get_file_ids(self.client, channel, message_id)
+        if not file_id:
+            raise Exception("FileNotFound")
+        self.cached_file_ids[message_id] = file_id
+        return self.cached_file_ids[message_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:
+                        logger.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()
+            logger.debug(f"Created media session for DC {file_id.dc_id}")
+            client.media_sessions[file_id.dc_id] = media_session
+        else:
+            logger.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,
+        offset: int,
+        first_part_cut: int,
+        last_part_cut: int,
+        part_count: int,
+        chunk_size: int,
+    ):
+        """
+        Custom generator that yields the bytes of the media file.
+        """
+        client = self.client
+        logger.debug(f"Starting to yielding file with client.")
+        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:
+            logger.debug(f"Finished yielding file with {current_part} parts.")
+
+    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()
+            logger.debug("Cleaned the cache")

utils/streamer/file_properties.py

@@ -0,0 +1,84 @@
+from pyrogram import Client
+from pyrogram.types import Message
+from pyrogram.file_id import FileId
+from typing import Any, Optional, Union
+from pyrogram.raw.types.messages import Messages
+from datetime import datetime
+
+
+async def parse_file_id(message: "Message") -> Optional[FileId]:
+    media = get_media_from_message(message)
+    if media:
+        return FileId.decode(media.file_id)
+
+
+async def parse_file_unique_id(message: "Messages") -> Optional[str]:
+    media = get_media_from_message(message)
+    if media:
+        return media.file_unique_id
+
+
+async def get_file_ids(client: Client, chat_id, message_id) -> Optional[FileId]:
+    message = await client.get_messages(chat_id, int(message_id))
+    if message.empty:
+        raise Exception("FileNotFound")
+    media = get_media_from_message(message)
+    file_unique_id = await parse_file_unique_id(message)
+    file_id = await parse_file_id(message)
+    setattr(file_id, "file_size", getattr(media, "file_size", 0))
+    setattr(file_id, "mime_type", getattr(media, "mime_type", ""))
+    setattr(file_id, "file_name", getattr(media, "file_name", ""))
+    setattr(file_id, "unique_id", file_unique_id)
+    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_name(media_msg: Union[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

utils/uploader.py

@@ -0,0 +1,69 @@
+from utils.clients import get_client
+from pyrogram import Client
+from pyrogram.types import Message
+from config import STORAGE_CHANNEL
+import os
+from utils.logger import Logger
+from urllib.parse import unquote_plus
+
+logger = Logger(__name__)
+PROGRESS_CACHE = {}
+STOP_TRANSMISSION = []
+
+
+async def progress_callback(current, total, id, client: Client, file_path):
+    global PROGRESS_CACHE, STOP_TRANSMISSION
+
+    PROGRESS_CACHE[id] = ("running", current, total)
+    if id in STOP_TRANSMISSION:
+        logger.info(f"Stopping transmission {id}")
+        client.stop_transmission()
+        try:
+            os.remove(file_path)
+        except:
+            pass
+
+
+async def start_file_uploader(
+    file_path, id, directory_path, filename, file_size, delete=True
+):
+    global PROGRESS_CACHE
+    from utils.directoryHandler import DRIVE_DATA
+
+    logger.info(f"Uploading file {file_path} {id}")
+
+    if file_size > 1.98 * 1024 * 1024 * 1024:
+        # Use premium client for files larger than 2 GB
+        client: Client = get_client(premium_required=True)
+    else:
+        client: Client = get_client()
+
+    PROGRESS_CACHE[id] = ("running", 0, 0)
+
+    message: Message = await client.send_document(
+        STORAGE_CHANNEL,
+        file_path,
+        progress=progress_callback,
+        progress_args=(id, client, file_path),
+        disable_notification=True,
+    )
+    size = (
+        message.photo
+        or message.document
+        or message.video
+        or message.audio
+        or message.sticker
+    ).file_size
+
+    filename = unquote_plus(filename)
+
+    DRIVE_DATA.new_file(directory_path, filename, message.id, size)
+    PROGRESS_CACHE[id] = ("completed", size, size)
+
+    logger.info(f"Uploaded file {file_path} {id}")
+
+    if delete:
+        try:
+            os.remove(file_path)
+        except Exception as e:
+            pass

website/VideoPlayer.html

@@ -0,0 +1,123 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>TG Drive - Video Player</title>
+
+    <link href="//vjs.zencdn.net/8.3.0/video-js.min.css" rel="stylesheet">
+    <script src="//vjs.zencdn.net/8.3.0/video.min.js"></script>
+    <style>
+        body {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            height: 100vh;
+            margin: 0;
+            font-family: Arial, sans-serif;
+        }
+
+        .video-container {
+            width: 90%;
+            max-width: 800px;
+        }
+
+        .buttons-container {
+            margin-top: 20px;
+            display: flex;
+            justify-content: space-evenly;
+            width: 90%;
+            max-width: 800px;
+        }
+
+        .copy-button {
+            padding: 10px 20px;
+            font-size: 16px;
+            cursor: pointer;
+            background-color: #007bff;
+            color: white;
+            border: none;
+            border-radius: 5px;
+            transition: background-color 0.3s ease;
+        }
+
+        .copy-button:hover {
+            background-color: #0056b3;
+        }
+    </style>
+</head>
+
+<body>
+
+    <div class="video-container">
+        <video id="my-player" class="video-js vjs-fluid" controls preload="auto" data-setup='{}'>
+            <source id="video-src" src="" type="video/mp4">
+            </source>
+            <p class="vjs-no-js">
+                To view this video please enable JavaScript, and consider upgrading to a
+                web browser that
+                <a href="https://videojs.com/html5-video-support/" target="_blank">
+                    supports HTML5 video
+                </a>
+            </p>
+        </video>
+    </div>
+
+    <div class="buttons-container">
+        <button class="copy-button" onclick="copyStreamUrl()">Copy Stream URL</button>
+        <button class="copy-button" onclick="copyDownloadUrl()">Copy Download URL</button>
+    </div>
+
+    <script>
+        const downloadUrl = (new URL(window.location.href)).searchParams.get('url');
+        document.getElementById('video-src').src = downloadUrl;
+
+
+        function copyTextToClipboard(text) {
+            if (navigator.clipboard && navigator.clipboard.writeText) {
+                navigator.clipboard.writeText(text).then(function () {
+                    alert('Link copied to clipboard!');
+                }).catch(function (err) {
+                    console.error('Could not copy text: ', err);
+                    fallbackCopyTextToClipboard(text);
+                });
+            } else {
+                fallbackCopyTextToClipboard(text);
+            }
+        }
+
+        function fallbackCopyTextToClipboard(text) {
+            const textArea = document.createElement('textarea');
+            textArea.value = text;
+            document.body.appendChild(textArea);
+            textArea.focus();
+            textArea.select();
+
+            try {
+                const successful = document.execCommand('copy');
+                if (successful) {
+                    alert('Link copied to clipboard!');
+                } else {
+                    alert('Failed to copy the link.');
+                }
+            } catch (err) {
+                console.error('Fallback: Oops, unable to copy', err);
+            }
+
+            document.body.removeChild(textArea);
+        }
+
+        function copyStreamUrl() {
+            copyTextToClipboard(window.location.href);
+        }
+
+        function copyDownloadUrl() {
+            copyTextToClipboard(downloadUrl);
+        }
+    </script>
+
+</body>
+
+</html>

website/home.html

@@ -0,0 +1,158 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>TG Drive</title>
+    <link rel="stylesheet" href="static/home.css" />
+
+    <!-- Fonts Start -->
+    <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=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&display=swap"
+        rel="stylesheet" />
+    <!-- Fonts End -->
+</head>
+
+<body>
+    <div class="container">
+        <!-- Sidebar Start -->
+        <div class="sidebar">
+            <div class="sidebar-header">
+                <img src="https://ssl.gstatic.com/images/branding/product/1x/drive_2020q4_48dp.png" />
+                <span>TG Drive</span>
+            </div>
+
+            <button id="new-button" class="new-button">
+                <img src="static/assets/plus-icon.svg" />New
+            </button>
+
+            <div id="new-upload" class="new-upload">
+                <input id="new-upload-focus" type="text"
+                    style="height: 0px; width: 0px; border: none; position: absolute" readonly />
+                <div id="new-folder-btn">
+                    <img src="static/assets/folder-icon.svg" />
+                    New Folder
+                </div>
+                <hr />
+                <div id="file-upload-btn">
+                    <img src="static/assets/upload-icon.svg" />
+                    File Upload
+                </div>
+                <input type="file" id="fileInput" style="height: 0px; width: 0px; border: none; position: absolute" />
+                <hr />
+                <div id="url-upload-btn">
+                    <img src="static/assets/link-icon.svg" />
+                    URL Upload
+                </div>
+            </div>
+
+            <div class="sidebar-menu">
+                <a class="selected-item" href="/?path=/"><img src="static/assets/home-icon.svg" />Home</a>
+                <a class="unselected-item" href="/?path=/trash"><img src="static/assets/trash-icon.svg" />Trash</a>
+            </div>
+        </div>
+        <!-- Sidebar End -->
+
+        <div id="bg-blur" class="bg-blur"></div>
+
+        <!-- Create New Folder Start -->
+        <div id="create-new-folder" class="create-new-folder">
+            <span>New Folder</span>
+            <input type="text" id="new-folder-name" placeholder="Enter Folder Name" autocomplete="off" />
+            <div>
+                <button id="new-folder-cancel">Cancel</button>
+                <button id="new-folder-create">Create</button>
+            </div>
+        </div>
+        <!-- Create New Folder End -->
+
+        <!-- File / Folder Rename Start -->
+        <div id="rename-file-folder" class="create-new-folder">
+            <span>Edit File/Folder Name</span>
+            <input type="text" id="rename-name" placeholder="Enter File/Folder Name" autocomplete="off" />
+            <div>
+                <button id="rename-cancel">Cancel</button>
+                <button id="rename-create">Rename</button>
+            </div>
+        </div>
+        <!-- File / Folder Rename End -->
+
+        <!-- Remote Upload Start -->
+        <div id="new-url-upload" class="create-new-folder">
+            <span>Url Upload</span>
+            <input type="text" id="remote-url" placeholder="Enter Direct Download Link Of File" autocomplete="off" />
+            <div id="single-threaded-div">
+                <input type="checkbox" name="single-threaded-toggle" id="single-threaded-toggle">
+                <label for="single-threaded-toggle">Single Threaded</label>
+                <a href="#"><img src="static/assets/info-icon-small.svg" alt="Info"></a>
+            </div>
+            <div>
+                <button id="remote-cancel">Cancel</button>
+                <button id="remote-start">Upload</button>
+            </div>
+        </div>
+        <!-- Remote Upload End -->
+
+        <!-- Get Password Start -->
+        <div id="get-password" class="create-new-folder">
+            <span>Admin Login</span>
+            <input type="text" id="auth-pass" placeholder="Enter Password" autocomplete="off" />
+            <div>
+                <button id="pass-login">Login</button>
+            </div>
+        </div>
+        <!-- Get Password End -->
+
+        <!-- File Uploader Start -->
+        <div id="file-uploader" class="file-uploader">
+            <span class="upload-head">🚀 Uploading File...</span>
+            <span id="upload-filename" class="upload-info">Filename : </span>
+            <span id="upload-filesize" class="upload-info">Filesize :</span>
+            <span id="upload-status" class="upload-info">Status : </span>
+            <span id="upload-percent" class="upload-info">Progress : </span>
+            <div class="progress">
+                <div class="progress-bar" id="progress-bar"></div>
+            </div>
+            <div class="btn-div">
+                <button id="cancel-file-upload">Cancel Upload</button>
+            </div>
+        </div>
+        <!-- File Uploader End -->
+
+        <!-- Main Content Start -->
+        <div class="main-content">
+            <div class="header">
+                <div class="search-bar">
+                    <img src="static/assets/search-icon.svg" />
+                    <form id="search-form">
+                        <input id="file-search" type="text" placeholder="Search in Drive" autocomplete="off" />
+                    </form>
+
+                </div>
+            </div>
+
+            <div class="directory">
+                <table>
+                    <thead>
+                        <tr>
+                            <th>Name</th>
+                            <th>File Size</th>
+                            <th>More</th>
+                        </tr>
+                    </thead>
+                    <tbody id="directory-data"></tbody>
+                </table>
+            </div>
+        </div>
+    </div>
+    <script src="static/js/extra.js"></script>
+    <script src="static/js/apiHandler.js"></script>
+    <script src="static/js/sidebar.js"></script>
+    <script src="static/js/fileClickHandler.js"></script>
+    <script src="static/js/main.js"></script>
+</body>
+
+</html>

website/static/home.css

@@ -0,0 +1,527 @@
+* {
+    margin: 0px;
+    padding: 0px;
+    box-sizing: border-box;
+    font-family: "Roboto", sans-serif;
+    user-select: none;
+    -webkit-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+}
+
+.container {
+    width: 100%;
+    height: 100vh;
+    display: grid;
+    background: #f1f1f1;
+    grid-template-columns: auto 1fr;
+}
+
+.rotate-90 {
+    transform: rotate(90deg);
+}
+
+/* Sidebar Style Start */
+
+.sidebar {
+    width: 250px;
+    height: 100%;
+    background-color: #f8fafd;
+    padding: 20px;
+    display: flex;
+    flex-direction: column;
+    justify-content: start;
+    align-items: start;
+}
+
+.sidebar-header {
+    display: flex;
+    align-items: center;
+    justify-content: start;
+}
+
+.sidebar-header img {
+    width: 40px;
+    height: 40px;
+    margin-right: 10px;
+}
+
+.sidebar-header span {
+    font-size: 1.2rem;
+    font-weight: 500;
+    color: #444746;
+}
+
+.sidebar .new-button {
+    padding: 15px 20px;
+    background-color: #fff;
+    border: 1px solid #e0e0e0;
+    border-radius: 20px;
+    margin-top: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.1);
+    font-size: 0.9rem;
+    color: #282c35;
+    font-weight: 500;
+}
+
+.sidebar .new-button:hover {
+    background-color: #edf1fa;
+    border: 1px solid #c9d0e6;
+    box-shadow: 0px 5px 10px rgba(0, 0, 0, 0.3);
+}
+
+.sidebar .new-button img {
+    width: 24px;
+    height: 24px;
+    margin-right: 10px;
+}
+
+.new-upload {
+    position: absolute;
+    background-color: #ffffff;
+    padding: 5px 0px;
+    box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.2);
+    border-radius: 5px;
+    width: 250px;
+    top: 40px;
+    z-index: -1;
+    opacity: 0;
+    transition: all 0.2s;
+}
+
+.new-upload div {
+    padding: 10px 20px;
+    display: flex;
+    align-items: center;
+    justify-content: start;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    font-size: 14px;
+}
+
+.new-upload div:hover {
+    background-color: #f1f1f1;
+}
+
+.new-upload div img {
+    margin-right: 10px;
+    height: 20px;
+    width: 20px;
+}
+
+.new-upload hr {
+    border: 1px solid #e0e0e0;
+    margin: 5px 0px;
+}
+
+.bg-blur {
+    position: fixed;
+    background-color: #000000;
+    height: 100dvh;
+    width: 100dvw;
+    transition: opacity 0.3s ease;
+    z-index: -1;
+    opacity: 0;
+}
+
+/* More Options Start */
+
+.more-options {
+    position: absolute;
+    background-color: #ffffff;
+    padding: 2px 0px;
+    box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.2);
+    border-radius: 5px;
+    z-index: -1;
+    opacity: 0;
+    transition: all 0.2s;
+    width: 150px;
+    transform: translateX(-50%);
+}
+
+.more-options div {
+    width: 100%;
+    padding: 5px 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    font-size: 14px;
+}
+
+.more-options div:hover {
+    background-color: #f1f1f1;
+}
+
+.more-options div img {
+    margin-right: 10px;
+    height: 20px;
+    width: 20px;
+}
+
+.more-options hr {
+    border: 1px solid #e0e0e0;
+    margin: 2px 0px;
+}
+
+/* More Options End */
+
+
+/* Create New Folder Start */
+.create-new-folder {
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    padding: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-direction: column;
+    background-color: #fff;
+    border-radius: 10px;
+    z-index: -1;
+    opacity: 0;
+    box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.3);
+    transition: opacity 0.3s ease;
+    width: 400px;
+}
+
+.create-new-folder span {
+    font-size: 1.2rem;
+    font-weight: 400;
+    color: #444746;
+    margin-bottom: 20px;
+    width: 100%;
+    margin-left: 10px;
+}
+
+.create-new-folder input {
+    width: 100%;
+    padding: 10px 20px;
+    border: 1px solid #e0e0e0;
+    border-radius: 5px;
+    outline: none;
+    font-size: 0.9rem;
+    font-weight: 400;
+    color: #444746;
+    margin-bottom: 20px;
+}
+
+.create-new-folder div {
+    width: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: end;
+    gap: 10px;
+}
+
+.create-new-folder button {
+    background-color: transparent;
+    border: none;
+    border-radius: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    font-size: 0.9rem;
+    color: #0b57d0;
+    font-weight: 500;
+    padding: 10px 20px;
+}
+
+.create-new-folder button:hover {
+    background-color: #edf1fa;
+    box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.2);
+}
+
+/* Create New Folder End */
+
+/* Remote URL Upload Start */
+
+#single-threaded-div{
+    display: flex;
+    flex-direction: row;
+    justify-content: start;
+    align-items: center;
+    width: 100%;
+    margin: 10px 0px;
+}
+
+#single-threaded-div input{
+    width: auto;
+    margin: 0px;
+    margin-left: 10px;
+}
+
+#single-threaded-div img{
+    height: 16px;
+    width: 16px;
+}
+#single-threaded-div a{
+    height: 16px;
+    width: 16px;
+}
+
+/* Remote URL Upload End */
+
+/* File Uploader Start */
+
+.file-uploader {
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    padding: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-direction: column;
+    background-color: #fff;
+    border-radius: 10px;
+    z-index: -1;
+    box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.3);
+    transition: opacity 0.3s ease;
+    width: 500px;
+    opacity: 0;
+}
+
+.upload-head {
+    font-size: 1.2rem;
+    font-weight: 500;
+    color: #444746;
+    margin-bottom: 20px;
+    width: 100%;
+}
+
+.upload-info {
+    font-size: 16px;
+    font-weight: 400;
+    color: #444746;
+    margin-bottom: 5px;
+    width: 100%;
+    max-height: 40px;
+    overflow: hidden;
+}
+
+.progress {
+    width: 100%;
+    background-color: #ddd;
+    border-radius: 5px;
+    overflow: hidden;
+    margin-top: 20px;
+}
+
+.progress-bar {
+    height: 20px;
+    background-color: #007bff;
+    width: 0;
+    transition: width 0.3s;
+}
+
+.file-uploader .btn-div {
+    width: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: end;
+    margin-top: 20px;
+}
+
+.file-uploader button {
+    background-color: transparent;
+    border: none;
+    border-radius: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    font-size: 0.9rem;
+    color: #0b57d0;
+    font-weight: 500;
+    padding: 10px 20px;
+}
+
+.file-uploader button:hover {
+    background-color: #edf1fa;
+    box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.2);
+}
+
+/* File Uploader End */
+
+.sidebar-menu {
+    margin-top: 20px;
+    width: 100%;
+    display: flex;
+    flex-direction: column;
+    justify-content: start;
+    align-items: center;
+}
+
+.sidebar-menu a {
+    width: 100%;
+    padding: 10px 20px;
+    display: flex;
+    align-items: center;
+    justify-content: start;
+    color: #444746;
+    font-size: 0.9rem;
+    font-weight: 400;
+    text-decoration: none;
+    transition: all 0.3s ease;
+    border-radius: 20px;
+}
+
+.sidebar-menu .selected-item {
+    background-color: #c2e7ff;
+}
+
+.sidebar-menu .unselected-item:hover {
+    background-color: #cfcfcf;
+}
+
+.sidebar-menu a img {
+    width: 20px;
+    height: 20px;
+    margin-right: 10px;
+}
+
+/* Sidebar Style End */
+
+/* Main Content Style Start */
+
+.main-content {
+    width: 100%;
+    height: 100%;
+    padding: 20px;
+    display: flex;
+    flex-direction: column;
+    justify-content: start;
+    align-items: start;
+    background-color: #f8fafd;
+}
+
+.main-content .header {
+    width: 100%;
+    display: grid;
+    grid-template-columns: 1fr auto;
+    align-items: center;
+    gap: 40px;
+}
+
+#search-form {
+    height: 100%;
+    width: 100%;
+}
+
+.search-bar {
+    width: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: start;
+    background-color: #e9eef6;
+    border-radius: 20px;
+    padding: 10px 20px;
+}
+
+.search-bar img {
+    width: 20px;
+    height: 20px;
+    margin-right: 20px;
+}
+
+.search-bar input {
+    width: 100%;
+    border: none;
+    outline: none;
+    background-color: transparent;
+    font-size: 1rem;
+    font-weight: 400;
+}
+
+.search-bar:focus-within {
+    background-color: #ffffff;
+    box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.directory {
+    background-color: #fff;
+    padding: 10px 20px;
+    width: 100%;
+    height: 100%;
+    border-radius: 20px;
+    margin-top: 20px;
+}
+
+.directory table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+.directory table tr th {
+    text-align: start;
+    font-size: 0.9rem;
+    font-weight: 500;
+    color: #444746;
+    padding: 10px 0px;
+    border-bottom: 1px solid #e0e0e0;
+}
+
+.directory table tr td {
+    text-align: start;
+    font-size: 0.9rem;
+    font-weight: 400;
+    color: #444746;
+    border-bottom: 1px solid #e0e0e0;
+    height: 50px;
+}
+
+.directory .body-tr {
+    transition: all 0.3s ease;
+}
+
+.directory .body-tr:hover {
+    background-color: #f1f1f1;
+}
+
+.directory .td-align {
+    display: flex;
+    align-items: center;
+    justify-content: start;
+    width: 100%;
+    height: 100%;
+}
+
+.directory .td-align img {
+    width: 24px;
+    height: 24px;
+    margin-right: 10px;
+}
+
+.directory .more-btn img {
+    width: 14px;
+    height: 14px;
+    margin: 0px;
+}
+
+.directory .more-btn {
+    padding: 8px;
+    border-radius: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    transition: all 0.3s ease;
+}
+
+.directory .more-btn:hover {
+    background-color: #b9b9b9;
+    box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.1);
+}

website/static/js/apiHandler.js

@@ -0,0 +1,347 @@
+// Api Fuctions
+async function postJson(url, data) {
+    data['password'] = getPassword()
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(data)
+    })
+    return await response.json()
+}
+
+document.getElementById('pass-login').addEventListener('click', async () => {
+    const password = document.getElementById('auth-pass').value
+    const data = { 'pass': password }
+    const json = await postJson('/api/checkPassword', data)
+    if (json.status === 'ok') {
+        localStorage.setItem('password', password)
+        alert('Logged In Successfully')
+        window.location.reload()
+    }
+    else {
+        alert('Wrong Password')
+    }
+
+})
+
+async function getCurrentDirectory() {
+    let path = getCurrentPath()
+    if (path === 'redirect') {
+        return
+    }
+    try {
+        const auth = getFolderAuthFromPath()
+        console.log(path)
+
+        const data = { 'path': path, 'auth': auth }
+        const json = await postJson('/api/getDirectory', data)
+
+        if (json.status === 'ok') {
+            if (getCurrentPath().startsWith('/share')) {
+                const sections = document.querySelector('.sidebar-menu').getElementsByTagName('a')
+                console.log(path)
+
+                if (removeSlash(json['auth_home_path']) === removeSlash(path.split('_')[1])) {
+                    sections[0].setAttribute('class', 'selected-item')
+
+                } else {
+                    sections[0].setAttribute('class', 'unselected-item')
+                }
+                sections[0].href = `/?path=/share_${removeSlash(json['auth_home_path'])}&auth=${auth}`
+                console.log(`/?path=/share_${removeSlash(json['auth_home_path'])}&auth=${auth}`)
+            }
+
+            console.log(json)
+            showDirectory(json['data'])
+        } else {
+            alert('404 Current Directory Not Found')
+        }
+    }
+    catch (err) {
+        console.log(err)
+        alert('404 Current Directory Not Found')
+    }
+}
+
+async function createNewFolder() {
+    const folderName = document.getElementById('new-folder-name').value;
+    const path = getCurrentPath()
+    if (path === 'redirect') {
+        return
+    }
+    if (folderName.length > 0) {
+        const data = {
+            'name': folderName,
+            'path': path
+        }
+        try {
+            const json = await postJson('/api/createNewFolder', data)
+
+            if (json.status === 'ok') {
+                window.location.reload();
+            } else {
+                alert(json.status)
+            }
+        }
+        catch (err) {
+            alert('Error Creating Folder')
+        }
+    } else {
+        alert('Folder Name Cannot Be Empty')
+    }
+}
+
+
+async function getFolderShareAuth(path) {
+    const data = { 'path': path }
+    const json = await postJson('/api/getFolderShareAuth', data)
+    if (json.status === 'ok') {
+        return json.auth
+    } else {
+        alert('Error Getting Folder Share Auth')
+    }
+}
+
+// File Uploader Start
+
+const MAX_FILE_SIZE = MAX_FILE_SIZE__SDGJDG // Will be replaced by the python
+
+const fileInput = document.getElementById('fileInput');
+const progressBar = document.getElementById('progress-bar');
+const cancelButton = document.getElementById('cancel-file-upload');
+const uploadPercent = document.getElementById('upload-percent');
+let uploadRequest = null;
+let uploadStep = 0;
+let uploadID = null;
+
+fileInput.addEventListener('change', async (e) => {
+    const file = fileInput.files[0];
+
+    if (file.size > MAX_FILE_SIZE) {
+        alert(`File size exceeds ${(MAX_FILE_SIZE / (1024 * 1024 * 1024)).toFixed(2)} GB limit`);
+        return;
+    }
+
+    // Showing file uploader
+    document.getElementById('bg-blur').style.zIndex = '2';
+    document.getElementById('bg-blur').style.opacity = '0.1';
+    document.getElementById('file-uploader').style.zIndex = '3';
+    document.getElementById('file-uploader').style.opacity = '1';
+
+    document.getElementById('upload-filename').innerText = 'Filename: ' + file.name;
+    document.getElementById('upload-filesize').innerText = 'Filesize: ' + (file.size / (1024 * 1024)).toFixed(2) + ' MB';
+    document.getElementById('upload-status').innerText = 'Status: Uploading To Backend Server';
+
+
+    const formData = new FormData();
+    formData.append('file', file);
+    formData.append('path', getCurrentPath());
+    formData.append('password', getPassword());
+    const id = getRandomId();
+    formData.append('id', id);
+    formData.append('total_size', file.size);
+
+    uploadStep = 1;
+    uploadRequest = new XMLHttpRequest();
+    uploadRequest.open('POST', '/api/upload', true);
+
+    uploadRequest.upload.addEventListener('progress', (e) => {
+        if (e.lengthComputable) {
+            const percentComplete = (e.loaded / e.total) * 100;
+            progressBar.style.width = percentComplete + '%';
+            uploadPercent.innerText = 'Progress : ' + percentComplete.toFixed(2) + '%';
+        }
+    });
+
+    uploadRequest.upload.addEventListener('load', async () => {
+        await updateSaveProgress(id)
+    });
+
+    uploadRequest.upload.addEventListener('error', () => {
+        alert('Upload failed');
+        window.location.reload();
+    });
+
+    uploadRequest.send(formData);
+});
+
+cancelButton.addEventListener('click', () => {
+    if (uploadStep === 1) {
+        uploadRequest.abort();
+    } else if (uploadStep === 2) {
+        const data = { 'id': uploadID }
+        postJson('/api/cancelUpload', data)
+    }
+    alert('Upload canceled');
+    window.location.reload();
+});
+
+async function updateSaveProgress(id) {
+    console.log('save progress')
+    progressBar.style.width = '0%';
+    uploadPercent.innerText = 'Progress : 0%'
+    document.getElementById('upload-status').innerText = 'Status: Processing File On Backend Server';
+
+    const interval = setInterval(async () => {
+        const response = await postJson('/api/getSaveProgress', { 'id': id })
+        const data = response['data']
+
+        if (data[0] === 'running') {
+            const current = data[1];
+            const total = data[2];
+            document.getElementById('upload-filesize').innerText = 'Filesize: ' + (total / (1024 * 1024)).toFixed(2) + ' MB';
+
+            const percentComplete = (current / total) * 100;
+            progressBar.style.width = percentComplete + '%';
+            uploadPercent.innerText = 'Progress : ' + percentComplete.toFixed(2) + '%';
+        }
+        else if (data[0] === 'completed') {
+            clearInterval(interval);
+            uploadPercent.innerText = 'Progress : 100%'
+            progressBar.style.width = '100%';
+
+            await handleUpload2(id)
+        }
+    }, 3000)
+
+}
+
+async function handleUpload2(id) {
+    console.log(id)
+    document.getElementById('upload-status').innerText = 'Status: Uploading To Telegram Server';
+    progressBar.style.width = '0%';
+    uploadPercent.innerText = 'Progress : 0%';
+
+    const interval = setInterval(async () => {
+        const response = await postJson('/api/getUploadProgress', { 'id': id })
+        const data = response['data']
+
+        if (data[0] === 'running') {
+            const current = data[1];
+            const total = data[2];
+            document.getElementById('upload-filesize').innerText = 'Filesize: ' + (total / (1024 * 1024)).toFixed(2) + ' MB';
+
+            let percentComplete
+            if (total === 0) {
+                percentComplete = 0
+            }
+            else {
+                percentComplete = (current / total) * 100;
+            }
+            progressBar.style.width = percentComplete + '%';
+            uploadPercent.innerText = 'Progress : ' + percentComplete.toFixed(2) + '%';
+        }
+        else if (data[0] === 'completed') {
+            clearInterval(interval);
+            alert('Upload Completed')
+            window.location.reload();
+        }
+    }, 3000)
+}
+
+// File Uploader End
+
+
+// URL Uploader Start
+
+async function get_file_info_from_url(url) {
+    const data = { 'url': url }
+    const json = await postJson('/api/getFileInfoFromUrl', data)
+    if (json.status === 'ok') {
+        return json.data
+    } else {
+        throw new Error(`Error Getting File Info : ${json.status}`)
+    }
+
+}
+
+async function start_file_download_from_url(url, filename, singleThreaded) {
+    const data = { 'url': url, 'path': getCurrentPath(), 'filename': filename, 'singleThreaded': singleThreaded }
+    const json = await postJson('/api/startFileDownloadFromUrl', data)
+    if (json.status === 'ok') {
+        return json.id
+    } else {
+        throw new Error(`Error Starting File Download : ${json.status}`)
+    }
+}
+
+async function download_progress_updater(id, file_name, file_size) {
+    uploadID = id;
+    uploadStep = 2
+    // Showing file uploader
+    document.getElementById('bg-blur').style.zIndex = '2';
+    document.getElementById('bg-blur').style.opacity = '0.1';
+    document.getElementById('file-uploader').style.zIndex = '3';
+    document.getElementById('file-uploader').style.opacity = '1';
+
+    document.getElementById('upload-filename').innerText = 'Filename: ' + file_name;
+    document.getElementById('upload-filesize').innerText = 'Filesize: ' + (file_size / (1024 * 1024)).toFixed(2) + ' MB';
+
+    const interval = setInterval(async () => {
+        const response = await postJson('/api/getFileDownloadProgress', { 'id': id })
+        const data = response['data']
+
+        if (data[0] === 'error') {
+            clearInterval(interval);
+            alert('Failed To Download File From URL To Backend Server')
+            window.location.reload()
+        }
+        else if (data[0] === 'completed') {
+            clearInterval(interval);
+            uploadPercent.innerText = 'Progress : 100%'
+            progressBar.style.width = '100%';
+            await handleUpload2(id)
+        }
+        else {
+            const current = data[1];
+            const total = data[2];
+
+            const percentComplete = (current / total) * 100;
+            progressBar.style.width = percentComplete + '%';
+            uploadPercent.innerText = 'Progress : ' + percentComplete.toFixed(2) + '%';
+
+            if (data[0] === 'Downloading') {
+                document.getElementById('upload-status').innerText = 'Status: Downloading File From Url To Backend Server';
+            }
+            else {
+                document.getElementById('upload-status').innerText = `Status: ${data[0]}`;
+            }
+        }
+    }, 3000)
+}
+
+
+async function Start_URL_Upload() {
+    try {
+        document.getElementById('new-url-upload').style.opacity = '0';
+        setTimeout(() => {
+            document.getElementById('new-url-upload').style.zIndex = '-1';
+        }, 300)
+
+        const file_url = document.getElementById('remote-url').value
+        const singleThreaded = document.getElementById('single-threaded-toggle').checked
+
+        const file_info = await get_file_info_from_url(file_url)
+        const file_name = file_info.file_name
+        const file_size = file_info.file_size
+
+        if (file_size > MAX_FILE_SIZE) {
+            throw new Error(`File size exceeds ${(MAX_FILE_SIZE / (1024 * 1024 * 1024)).toFixed(2)} GB limit`)
+        }
+
+        const id = await start_file_download_from_url(file_url, file_name, singleThreaded)
+
+        await download_progress_updater(id, file_name, file_size)
+
+    }
+    catch (err) {
+        alert(err)
+        window.location.reload()
+    }
+
+
+}
+
+// URL Uploader End

website/static/js/extra.js

@@ -0,0 +1,119 @@
+function getCurrentPath() {
+    const url = new URL(window.location.href);
+    const path = url.searchParams.get('path')
+    if (path === null) {
+        window.location.href = '/?path=/'
+        return 'redirect'
+    }
+    return path
+}
+
+function getFolderAuthFromPath() {
+    const url = new URL(window.location.href);
+    const auth = url.searchParams.get('auth')
+    return auth
+}
+
+// Changing sidebar section class
+if (getCurrentPath() !== '/') {
+    const sections = document.querySelector('.sidebar-menu').getElementsByTagName('a')
+    sections[0].setAttribute('class', 'unselected-item')
+
+    if (getCurrentPath().includes('/trash')) {
+        sections[1].setAttribute('class', 'selected-item')
+    }
+}
+
+function convertBytes(bytes) {
+    const kilobyte = 1024;
+    const megabyte = kilobyte * 1024;
+    const gigabyte = megabyte * 1024;
+
+    if (bytes >= gigabyte) {
+        return (bytes / gigabyte).toFixed(2) + ' GB';
+    } else if (bytes >= megabyte) {
+        return (bytes / megabyte).toFixed(2) + ' MB';
+    } else if (bytes >= kilobyte) {
+        return (bytes / kilobyte).toFixed(2) + ' KB';
+    } else {
+        return bytes + ' bytes';
+    }
+}
+
+const INPUTS = {}
+
+function validateInput(event) {
+    console.log('Validating Input')
+    const pattern = /^[a-zA-Z0-9 \-_\\[\]()@#!$%*+={}:;<>,.?/|\\~`]*$/;;
+    const input = event.target;
+    if (!pattern.test(input.value)) {
+        input.value = INPUTS[input.id]
+    } else {
+        INPUTS[input.id] = input.value
+    }
+}
+
+function getRootUrl() {
+    const url = new URL(window.location.href);
+    const protocol = url.protocol; // Get the protocol, e.g., "https:"
+    const hostname = url.hostname; // Get the hostname, e.g., "sub.example.com" or "192.168.1.1"
+    const port = url.port; // Get the port, e.g., "8080"
+
+    const rootUrl = `${protocol}//${hostname}${port ? ':' + port : ''}`;
+
+    return rootUrl;
+}
+
+function copyTextToClipboard(text) {
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+        navigator.clipboard.writeText(text).then(function () {
+            alert('Link copied to clipboard!');
+        }).catch(function (err) {
+            console.error('Could not copy text: ', err);
+            fallbackCopyTextToClipboard(text);
+        });
+    } else {
+        fallbackCopyTextToClipboard(text);
+    }
+}
+
+function fallbackCopyTextToClipboard(text) {
+    const textArea = document.createElement('textarea');
+    textArea.value = text;
+    document.body.appendChild(textArea);
+    textArea.focus();
+    textArea.select();
+
+    try {
+        const successful = document.execCommand('copy');
+        if (successful) {
+            alert('Link copied to clipboard!');
+        } else {
+            alert('Failed to copy the link.');
+        }
+    } catch (err) {
+        console.error('Fallback: Oops, unable to copy', err);
+    }
+
+    document.body.removeChild(textArea);
+}
+
+function getPassword() {
+    return localStorage.getItem('password')
+}
+
+function getRandomId() {
+    const length = 6;
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+}
+
+function removeSlash(text) {
+    let charactersToRemove = "[/]+"; // Define the characters to remove inside square brackets
+    let trimmedStr = text.replace(new RegExp(`^${charactersToRemove}|${charactersToRemove}$`, 'g'), '');
+    return trimmedStr;
+}

website/static/js/fileClickHandler.js

@@ -0,0 +1,214 @@
+function openFolder() {
+    let path = (getCurrentPath() + '/' + this.getAttribute('data-id') + '/').replaceAll('//', '/')
+
+    const auth = getFolderAuthFromPath()
+    if (auth) {
+        path = path + '&auth=' + auth
+    }
+    window.location.href = `/?path=${path}`
+}
+
+function openFile() {
+    const fileName = this.getAttribute('data-name').toLowerCase()
+    let path = '/file?path=' + this.getAttribute('data-path') + '/' + this.getAttribute('data-id')
+
+    if (fileName.endsWith('.mp4') || fileName.endsWith('.mkv') || fileName.endsWith('.webm') || fileName.endsWith('.mov') || fileName.endsWith('.avi') || fileName.endsWith('.ts') || fileName.endsWith('.ogv')) {
+        path = '/stream?url=' + getRootUrl() + path
+    }
+
+    window.open(path, '_blank')
+}
+
+
+// File More Button Handler Start
+
+function openMoreButton(div) {
+    const id = div.getAttribute('data-id')
+    const moreDiv = document.getElementById(`more-option-${id}`)
+
+    const rect = div.getBoundingClientRect();
+    const x = rect.left + window.scrollX - 40;
+    const y = rect.top + window.scrollY;
+
+    moreDiv.style.zIndex = 2
+    moreDiv.style.opacity = 1
+    moreDiv.style.left = `${x}px`
+    moreDiv.style.top = `${y}px`
+
+    const isTrash = getCurrentPath().includes('/trash')
+
+    moreDiv.querySelector('.more-options-focus').focus()
+    moreDiv.querySelector('.more-options-focus').addEventListener('blur', closeMoreBtnFocus);
+    moreDiv.querySelector('.more-options-focus').addEventListener('focusout', closeMoreBtnFocus);
+    if (!isTrash) {
+        moreDiv.querySelector(`#rename-${id}`).addEventListener('click', renameFileFolder)
+        moreDiv.querySelector(`#trash-${id}`).addEventListener('click', trashFileFolder)
+        try {
+            moreDiv.querySelector(`#share-${id}`).addEventListener('click', shareFile)
+        }
+        catch { }
+        try {
+            moreDiv.querySelector(`#folder-share-${id}`).addEventListener('click', shareFolder)
+        }
+        catch { }
+    }
+    else {
+        moreDiv.querySelector(`#restore-${id}`).addEventListener('click', restoreFileFolder)
+        moreDiv.querySelector(`#delete-${id}`).addEventListener('click', deleteFileFolder)
+    }
+}
+
+function closeMoreBtnFocus() {
+    const moreDiv = this.parentElement
+    moreDiv.style.opacity = '0'
+    setTimeout(() => {
+        moreDiv.style.zIndex = '-1'
+    }, 300)
+}
+
+// Rename File Folder Start
+function renameFileFolder() {
+    const id = this.getAttribute('id').split('-')[1]
+    console.log(id)
+
+    document.getElementById('rename-name').value = this.parentElement.getAttribute('data-name');
+    document.getElementById('bg-blur').style.zIndex = '2';
+    document.getElementById('bg-blur').style.opacity = '0.1';
+
+    document.getElementById('rename-file-folder').style.zIndex = '3';
+    document.getElementById('rename-file-folder').style.opacity = '1';
+    document.getElementById('rename-file-folder').setAttribute('data-id', id);
+    setTimeout(() => {
+        document.getElementById('rename-name').focus();
+    }, 300)
+}
+
+document.getElementById('rename-cancel').addEventListener('click', () => {
+    document.getElementById('rename-name').value = '';
+    document.getElementById('bg-blur').style.opacity = '0';
+    setTimeout(() => {
+        document.getElementById('bg-blur').style.zIndex = '-1';
+    }, 300)
+    document.getElementById('rename-file-folder').style.opacity = '0';
+    setTimeout(() => {
+        document.getElementById('rename-file-folder').style.zIndex = '-1';
+    }, 300)
+});
+
+document.getElementById('rename-create').addEventListener('click', async () => {
+    const name = document.getElementById('rename-name').value;
+    if (name === '') {
+        alert('Name cannot be empty')
+        return
+    }
+
+    const id = document.getElementById('rename-file-folder').getAttribute('data-id')
+
+    const path = document.getElementById(`more-option-${id}`).getAttribute('data-path') + '/' + id
+
+    const data = {
+        'name': name,
+        'path': path
+    }
+
+    const response = await postJson('/api/renameFileFolder', data)
+    if (response.status === 'ok') {
+        alert('File/Folder Renamed Successfully')
+        window.location.reload();
+    } else {
+        alert('Failed to rename file/folder')
+        window.location.reload();
+    }
+});
+
+
+// Rename File Folder End
+
+async function trashFileFolder() {
+    const id = this.getAttribute('id').split('-')[1]
+    console.log(id)
+    const path = document.getElementById(`more-option-${id}`).getAttribute('data-path') + '/' + id
+    const data = {
+        'path': path,
+        'trash': true
+    }
+    const response = await postJson('/api/trashFileFolder', data)
+
+    if (response.status === 'ok') {
+        alert('File/Folder Sent to Trash Successfully')
+        window.location.reload();
+    } else {
+        alert('Failed to Send File/Folder to Trash')
+        window.location.reload();
+    }
+}
+
+async function restoreFileFolder() {
+    const id = this.getAttribute('id').split('-')[1]
+    const path = this.getAttribute('data-path') + '/' + id
+    const data = {
+        'path': path,
+        'trash': false
+    }
+    const response = await postJson('/api/trashFileFolder', data)
+
+    if (response.status === 'ok') {
+        alert('File/Folder Restored Successfully')
+        window.location.reload();
+    } else {
+        alert('Failed to Restored File/Folder')
+        window.location.reload();
+    }
+}
+
+async function deleteFileFolder() {
+    const id = this.getAttribute('id').split('-')[1]
+    const path = this.getAttribute('data-path') + '/' + id
+    const data = {
+        'path': path
+    }
+    const response = await postJson('/api/deleteFileFolder', data)
+
+    if (response.status === 'ok') {
+        alert('File/Folder Deleted Successfully')
+        window.location.reload();
+    } else {
+        alert('Failed to Delete File/Folder')
+        window.location.reload();
+    }
+}
+
+async function shareFile() {
+    const fileName = this.parentElement.getAttribute('data-name').toLowerCase()
+    const id = this.getAttribute('id').split('-')[1]
+    const path = document.getElementById(`more-option-${id}`).getAttribute('data-path') + '/' + id
+    const root_url = getRootUrl()
+
+    let link
+    if (fileName.endsWith('.mp4') || fileName.endsWith('.mkv') || fileName.endsWith('.webm') || fileName.endsWith('.mov') || fileName.endsWith('.avi') || fileName.endsWith('.ts') || fileName.endsWith('.ogv')) {
+        link = `${root_url}/stream?url=${root_url}/file?path=${path}`
+    } else {
+        link = `${root_url}/file?path=${path}`
+
+    }
+
+    copyTextToClipboard(link)
+}
+
+
+async function shareFolder() {
+    const id = this.getAttribute('id').split('-')[2]
+    console.log(id)
+    let path = document.getElementById(`more-option-${id}`).getAttribute('data-path') + '/' + id
+    const root_url = getRootUrl()
+
+    const auth = await getFolderShareAuth(path)
+    path = path.slice(1)
+
+    let link = `${root_url}/?path=/share_${path}&auth=${auth}`
+    console.log(link)
+
+    copyTextToClipboard(link)
+}
+
+// File More Button Handler  End

website/static/js/main.js

@@ -0,0 +1,95 @@
+function showDirectory(data) {
+    data = data['contents']
+    document.getElementById('directory-data').innerHTML = ''
+    const isTrash = getCurrentPath().startsWith('/trash')
+
+    let html = ''
+
+    // Step 2: Sort the array based on the 'date' values
+    let entries = Object.entries(data);
+    let folders = entries.filter(([key, value]) => value.type === 'folder');
+    let files = entries.filter(([key, value]) => value.type === 'file');
+
+    folders.sort((a, b) => new Date(b[1].upload_date) - new Date(a[1].upload_date));
+    files.sort((a, b) => new Date(b[1].upload_date) - new Date(a[1].upload_date));
+
+    for (const [key, item] of folders) {
+        if (item.type === 'folder') {
+            html += `<tr data-path="${item.path}" data-id="${item.id}" class="body-tr folder-tr"><td><div class="td-align"><img src="static/assets/folder-solid-icon.svg">${item.name}</div></td><td><div class="td-align"></div></td><td><div class="td-align"><a data-id="${item.id}" class="more-btn"><img src="static/assets/more-icon.svg" class="rotate-90"></a></div></td></tr>`
+
+            if (isTrash) {
+                html += `<div data-path="${item.path}" id="more-option-${item.id}" data-name="${item.name}" class="more-options"><input class="more-options-focus" readonly="readonly" style="height:0;width:0;border:none;position:absolute"><div id="restore-${item.id}" data-path="${item.path}"><img src="static/assets/load-icon.svg"> Restore</div><hr><div id="delete-${item.id}" data-path="${item.path}"><img src="static/assets/trash-icon.svg"> Delete</div></div>`
+            }
+            else {
+                html += `<div data-path="${item.path}" id="more-option-${item.id}" data-name="${item.name}" class="more-options"><input class="more-options-focus" readonly="readonly" style="height:0;width:0;border:none;position:absolute"><div id="rename-${item.id}"><img src="static/assets/pencil-icon.svg"> Rename</div><hr><div id="trash-${item.id}"><img src="static/assets/trash-icon.svg"> Trash</div><hr><div id="folder-share-${item.id}"><img src="static/assets/share-icon.svg"> Share</div></div>`
+            }
+        }
+    }
+
+    for (const [key, item] of files) {
+        if (item.type === 'file') {
+            const size = convertBytes(item.size)
+            html += `<tr data-path="${item.path}" data-id="${item.id}" data-name="${item.name}" class="body-tr file-tr"><td><div class="td-align"><img src="static/assets/file-icon.svg">${item.name}</div></td><td><div class="td-align">${size}</div></td><td><div class="td-align"><a data-id="${item.id}" class="more-btn"><img src="static/assets/more-icon.svg" class="rotate-90"></a></div></td></tr>`
+
+            if (isTrash) {
+                html += `<div data-path="${item.path}" id="more-option-${item.id}" data-name="${item.name}" class="more-options"><input class="more-options-focus" readonly="readonly" style="height:0;width:0;border:none;position:absolute"><div id="restore-${item.id}" data-path="${item.path}"><img src="static/assets/load-icon.svg"> Restore</div><hr><div id="delete-${item.id}" data-path="${item.path}"><img src="static/assets/trash-icon.svg"> Delete</div></div>`
+            }
+            else {
+                html += `<div data-path="${item.path}" id="more-option-${item.id}" data-name="${item.name}" class="more-options"><input class="more-options-focus" readonly="readonly" style="height:0;width:0;border:none;position:absolute"><div id="rename-${item.id}"><img src="static/assets/pencil-icon.svg"> Rename</div><hr><div id="trash-${item.id}"><img src="static/assets/trash-icon.svg"> Trash</div><hr><div id="share-${item.id}"><img src="static/assets/share-icon.svg"> Share</div></div>`
+            }
+        }
+    }
+    document.getElementById('directory-data').innerHTML = html
+
+    if (!isTrash) {
+        document.querySelectorAll('.folder-tr').forEach(div => {
+            div.ondblclick = openFolder;
+        });
+        document.querySelectorAll('.file-tr').forEach(div => {
+            div.ondblclick = openFile;
+        });
+    }
+
+    document.querySelectorAll('.more-btn').forEach(div => {
+        div.addEventListener('click', function (event) {
+            event.preventDefault();
+            openMoreButton(div)
+        });
+    });
+}
+
+document.getElementById('search-form').addEventListener('submit', async (event) => {
+    event.preventDefault();
+    const query = document.getElementById('file-search').value;
+    console.log(query)
+    if (query === '') {
+        alert('Search field is empty');
+        return;
+    }
+    const path = '/?path=/search_' + encodeURI(query);
+    console.log(path)
+    window.location = path;
+});
+
+// Loading Main Page
+
+document.addEventListener('DOMContentLoaded', function () {
+    const inputs = ['new-folder-name', 'rename-name', 'file-search']
+    for (let i = 0; i < inputs.length; i++) {
+        document.getElementById(inputs[i]).addEventListener('input', validateInput);
+    }
+
+    if (getCurrentPath().includes('/share_')) {
+        getCurrentDirectory()
+    } else {
+        if (getPassword() === null) {
+            document.getElementById('bg-blur').style.zIndex = '2';
+            document.getElementById('bg-blur').style.opacity = '0.1';
+
+            document.getElementById('get-password').style.zIndex = '3';
+            document.getElementById('get-password').style.opacity = '1';
+        } else {
+            getCurrentDirectory()
+        }
+    }
+});

website/static/js/sidebar.js

@@ -0,0 +1,102 @@
+// Handling New Button On Sidebar Click
+const isTrash = getCurrentPath().startsWith('/trash')
+const isSearch = getCurrentPath().startsWith('/search')
+const isShare = getCurrentPath().startsWith('/share')
+
+if (!isTrash && !isSearch) {
+    document.getElementById('new-button').addEventListener('click', () => {
+        document.getElementById('new-upload').style.zIndex = '1'
+        document.getElementById('new-upload').style.opacity = '1'
+        document.getElementById('new-upload').style.top = '80px'
+        document.getElementById('new-upload-focus').focus()
+    });
+}
+else {
+    document.getElementById('new-button').style.display = 'none'
+}
+
+if (isShare) {
+    document.getElementById('new-button').style.display = 'none'
+    const sections = document.querySelector('.sidebar-menu').getElementsByTagName('a')
+    sections[1].remove()
+}
+
+// New File Upload Start
+
+function closeNewUploadFocus() {
+    setTimeout(() => {
+        document.getElementById('new-upload').style.opacity = '0'
+        document.getElementById('new-upload').style.top = '40px'
+        setTimeout(() => {
+            document.getElementById('new-upload').style.zIndex = '-1'
+        }, 300)
+    }, 200)
+}
+document.getElementById('new-upload-focus').addEventListener('blur', closeNewUploadFocus);
+document.getElementById('new-upload-focus').addEventListener('focusout', closeNewUploadFocus);
+
+document.getElementById('file-upload-btn').addEventListener('click', () => {
+    document.getElementById('fileInput').click()
+});
+
+// New File Upload End
+
+// New Folder Start
+
+document.getElementById('new-folder-btn').addEventListener('click', () => {
+    document.getElementById('new-folder-name').value = '';
+    document.getElementById('bg-blur').style.zIndex = '2';
+    document.getElementById('bg-blur').style.opacity = '0.1';
+
+    document.getElementById('create-new-folder').style.zIndex = '3';
+    document.getElementById('create-new-folder').style.opacity = '1';
+    setTimeout(() => {
+        document.getElementById('new-folder-name').focus();
+    }, 300)
+})
+
+document.getElementById('new-folder-cancel').addEventListener('click', () => {
+    document.getElementById('new-folder-name').value = '';
+    document.getElementById('bg-blur').style.opacity = '0';
+    setTimeout(() => {
+        document.getElementById('bg-blur').style.zIndex = '-1';
+    }, 300)
+    document.getElementById('create-new-folder').style.opacity = '0';
+    setTimeout(() => {
+        document.getElementById('create-new-folder').style.zIndex = '-1';
+    }, 300)
+});
+
+document.getElementById('new-folder-create').addEventListener('click', createNewFolder);
+
+// New Folder End
+
+// New Url Upload Start
+
+document.getElementById('url-upload-btn').addEventListener('click', () => {
+    document.getElementById('remote-url').value = '';
+    document.getElementById('bg-blur').style.zIndex = '2';
+    document.getElementById('bg-blur').style.opacity = '0.1';
+
+    document.getElementById('new-url-upload').style.zIndex = '3';
+    document.getElementById('new-url-upload').style.opacity = '1';
+    setTimeout(() => {
+        document.getElementById('remote-url').focus();
+    }, 300)
+})
+
+document.getElementById('remote-cancel').addEventListener('click', () => {
+    document.getElementById('remote-url').value = '';
+    document.getElementById('bg-blur').style.opacity = '0';
+    setTimeout(() => {
+        document.getElementById('bg-blur').style.zIndex = '-1';
+    }, 300)
+    document.getElementById('new-url-upload').style.opacity = '0';
+    setTimeout(() => {
+        document.getElementById('new-url-upload').style.zIndex = '-1';
+    }, 300)
+});
+
+document.getElementById('remote-start').addEventListener('click', Start_URL_Upload);
+
+// New Url Upload End