Add application file

.deepsource.toml

@@ -0,0 +1,10 @@
+version = 1
+
+[[analyzers]]
+name = "secrets"
+
+[[analyzers]]
+name = "python"
+
+  [analyzers.meta]
+  runtime_version = "3.x.x"

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: EDM115
+custom: ["https://paypal.me/8EDM115", "https://www.buymeacoffee.com/edm115", "https://t.me/EDM115bots/544", "https://edm115.shadd.eu.org/"]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,26 @@
+---
+name: Bug report
+about: Report any bug you found
+title: "[BUG] "
+labels: bug
+assignees: EDM115
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Do this
+2. Then that
+3. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: "[FEATURE REQUEST] "
+labels: enhancement
+assignees: EDM115
+
+---
+
+**Is your feature request related to a problem ? Please describe :**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/dependabot.yml

@@ -0,0 +1,14 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    assignees:
+      - "EDM115"
+    open-pull-requests-limit: 15

.github/workflows/black-code-style.yml

@@ -0,0 +1,32 @@
+name: Renders the whole code using Black code style
+
+on:
+  workflow_dispatch:
+
+jobs:
+  black:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+          fetch-depth: 0
+      - name: Black-ify
+        uses: psf/black@stable
+        with:
+          options: "--verbose"
+      - name: Commit changes
+        run: |
+          d=`date '+%Y/%m/%dT%H:%M:%SZ'`
+          git config --local user.email ${{ secrets.MAIL }}
+          git config --local user.name ${{ secrets.USERNAME }}
+          git add -A
+          git commit -m "Code style changed to Black at ${d}"
+      - name: Push commit
+        uses: ad-m/github-push-action@v0.6.0
+        with:
+          force: true
+          directory: "."
+          branch: ${{ github.ref }}
+          github_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/build-docker-image.yml

@@ -0,0 +1,17 @@
+name: Build Docker Image
+
+on:
+#  push:
+#    branches: [ main ]
+#  pull_request:
+#    branches: [ main ]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Build the Docker image
+      run: docker build . --file Dockerfile --tag unzip-bot:$(date +%s)

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,69 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+#  push:
+#    branches: [ master ]
+#  pull_request:
+#    # The branches below must be a subset of the branches above
+#    branches: [ master ]
+#  schedule:
+#    - cron: '0 4 * * 6'
+  workflow_dispatch:
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'python' ]
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.github/workflows/publish-docker-image.yml

@@ -0,0 +1,46 @@
+name: Publish Docker Image
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  push_to_registries:
+    name: Push Docker image to GHCR & Docker Hub
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v4
+      
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+      
+      - name: Log in to the GitHub Container registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            edm115/unzip-bot
+            ghcr.io/${{ github.repository }}
+      
+      - name: Build and push Docker images
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

.gitignore

@@ -0,0 +1,89 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# VS Code
+.vscode
+.vscode/
+.vscode/*
+
+# Secrets
+*.session

.restyled.yml

@@ -0,0 +1,19 @@
+enabled: false
+exclude:
+  - "unzipper/modules/ext_script/ext_helper.py"
+  - "unzipper/modules/ext_script/up_helper.py"
+auto: false
+pull_requests: true
+commit_template: |
+  Restyled by ${restyler.name}
+statuses:
+  differences: false
+  no_differences: true
+  error: true
+labels:
+  - style
+restylers:
+  - name: autopep8
+  - name: isort
+  - name: black
+  - name: yapf

.whitesource

@@ -0,0 +1,14 @@
+{
+  "scanSettings": {
+    "baseBranches": []
+  },
+  "checkRunSettings": {
+    "vulnerableCheckRunConclusionLevel": "failure",
+    "displayMode": "diff",
+    "useMendCheckNames": true
+  },
+  "issueSettings": {
+    "minSeverityLevel": "LOW",
+    "issueType": "DEPENDENCY"
+  }
+}

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+dev@edm115.eu.org.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

CreateMongoDB.md

@@ -0,0 +1,23 @@
+# How to create a MongoDB URL in 10min ?
+  
+1. Go to [MongoDB website](https://mongodb.com/cloud/atlas/register)  
+  *(skip steps 2 and 3 if you already have an account, just create a new cluster)*
+1. On the account setup page, choose wisely your Organization name and Project name (you can't change that). Select Python as preferred language
+2. Choose `Create a cluster` on the `Shared Clusters` category (the free one)
+3. Choose `Azure` as provider and `Netherlands` as region, then click on `Create Cluster` (it takes 1-5 minutes, but don't close the window !)
+4. When it's done, click on `Network Access` on left panel
+    1. `Add IP Address`
+    2. `Allow access from anywhere` (because Heroku IP addresses changes everytime)
+    3. `Confirm` (it can take up to 2 minutes)
+5. Click on `Clusters` on left panel
+    1. `Connect`
+    2. Create a Database User (remember the credentials you choose !)
+    3. `Choose a connection method`
+    4. `Connect with your application`
+    5. Choose `Python` as Driver
+    6. Choose `3.6 or later` as Version
+    7. Copy the URL
+6. Replace `<password>` with the one you chosen at step 5.ii
+
+## You're done :partying_face:
+### Now use that as `MONGODB_URL`

Dockerfile

@@ -0,0 +1,13 @@
+FROM archlinux:latest
+
+RUN pacman -Syyu --noconfirm
+RUN pacman -S --noconfirm python-pip zstd p7zip gcc git ffmpeg
+RUN python -m venv /venv
+ENV PATH="/venv/bin:$PATH"
+RUN pip install -U pip setuptools wheel
+RUN mkdir /app/
+WORKDIR /app/
+RUN git clone https://github.com/EDM115/unzip-bot.git /app/
+COPY requirements.txt /app/requirements.txt
+RUN pip install -U -r requirements.txt
+CMD bash start.sh

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 - 2023 EDM115
+
+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.

Procfile

@@ -0,0 +1 @@
+unzipper: bash start.sh

app.json

@@ -0,0 +1,54 @@
+{
+    "name": "Unzipper Bot",
+    "description": "A Telegram bot to extract various types of archives",
+    "logo": "https://telegra.ph/file/d4ba24682e030fc58613f.jpg",
+    "keywords": [
+        "7z",
+        "zip",
+        "rar",
+        "Telegram Bot",
+        "unzipper bot"
+    ],
+    "website": "https://edm115.dev/unzip",
+    "repository": "https://github.com/EDM115/unzip-bot",
+    "success_url": "https://t.me/EDM115bots",
+    "env": {
+        "APP_ID": {
+            "description": "Your APP_ID from my.telegram.org",
+            "required": true
+        },
+        "API_HASH": {
+            "description": "Your API_HASH from my.telegram.org",
+            "required": true
+        },
+        "BOT_OWNER": {
+            "description": "Telegram Id of your account",
+            "required": true
+        },
+        "BOT_TOKEN": {
+            "description": "Your Bot Token From @BotFather",
+            "required": true
+        },
+        "MONGODB_URL": {
+            "description": "Your MongoDB url, Get it from https://www.mongodb.com/",
+            "required": true
+        },
+        "LOGS_CHANNEL": {
+            "description": "ID of a channel, can also be a group",
+            "required": true
+        }
+    },
+    "addons": [],
+    "buildpacks": [
+        {
+            "url": "heroku/python"
+        }
+    ],
+    "formation": {
+        "worker": {
+            "quantity": 1,
+            "size": "eco"
+        }
+    },
+    "stack": "container"
+}

changelog.md

@@ -0,0 +1,427 @@
+<div align="center">
+
+  <h1><a href="https://github.com/EDM115/unzip-bot" target="_blank" rel="noreferrer"><img src="https://telegra.ph/file/d4ba24682e030fc58613f.jpg" alt="unzip-bot" width="40" height="40"/></a> Unarchiver Bot • Changelog</h1>
+
+## You will find here all the changes made with each version, in antichronological order
+
+#### Convention : `vX.Y.Z`, where `X` stands for a major change and a lot of new features, `Y` for some new features and bug fixes, `Z` for testing stuff and undebugged things
+
+</div>
+
+---
+
+### v6.3.2 **[LATEST STABLE RELEASE]**
+
+- Fixed thumbnails not being saved
+- Premium related stuff is moved to its own branch (buggy so yes)
+- Fixed files being nearly all the time not uploaded
+- Better logging
+- Added [Mend Bolt](https://github.com/marketplace/whitesource-bolt)
+- Downgraded pyromod to 1.5 again (too much errors, I know they had been fixed in 2.1.0 but still)
+- Client specification in decorators instead of global @Client
+- New maintenance logic
+- Attempt to support files sent as TG links (may fail for topics, unaccessible chats and forward-restricted files)
+
+### v6.3.1
+
+- Finally fixed [#133](https://github.com/EDM115/unzip-bot/issues/133)
+- Attempt to create a premium user to upload +2Gb files
+- Added `/maintenance`
+
+### v6.3.0
+
+- Ongoing tasks are removed from the database after a restart
+- Added a new command : /cleantasks
+- Finally upgraded pyromod to v2
+- Upgraded from python-3.11.3 to python-3.11.5
+- Removed any trace of bayfiles upload since the service is dead
+- Support for `.partx.rar` splitted archives
+- Download files in 10 Mb chunks instead of 5 Mb
+- Added maintenance on DB
+- Aded VIP methods in DB + implementation of no-restrictions for VIP ([#205](https://github.com/EDM115/unzip-bot/issues/205))
+
+### v6.2.4
+
+- Attempt to add some URL parsers (fail)
+- Even more refactor
+- Splitted files can be renamed
+- Url are checked before extracting
+- If a thumbnail fails to be uploaded to telegra.ph, the error message is no longer saved in the db (and on download, non url strings are skipped)
+- `/broadcast` now shows how many users had been processed
+
+### v6.2.3
+
+- Fixes little error on strings
+- Closes a lot of issues opened by DeepSource (mostly style)
+- Added a task limit (configurable in `config.py`)
+- FloodWait is now handled correctly everywhere
+- The bot is no longer blocking any task (finally)
+
+### v6.2.2
+
+- Bugfix : No longer use of `subprocess.communicate()`, as it's thread blocking
+- All strings are in `bot_data.py`, hope this should ease [#179](https://github.com/EDM115/unzip-bot/issues/179)
+- Even less thread block : use of `async for` and `yield`
+- Any file unreachable/with a size of 0B is skipped, thus avoiding the bot being stuck on an impossible task
+
+### v6.2.1
+
+- Security fix : Merging files could lead to paths being swapped between users. It's now fixed
+
+### v6.2.0
+
+- Added a new command : /merge (and /done)
+- Allows to merge splitted archives in .XXX format
+- Upload of thumbnails on telegra.ph now handles errors
+
+### v6.1.0
+
+- URL's also shows a progressbar + ETA when possible
+- Downloads are 28 times faster
+- Some databases are cleared upon restart
+- Attempt to implement [#137](https://github.com/EDM115/unzip-bot/issues/137)
+- New boot sequence
+
+### v6.0.0 
+
+- Dependencies update
+- tgz and zst archives are now supported
+- Thumbnail change tasks are now removed from DB after completion
+- Dockerfile have been updated : Add of ffmpeg and venv
+- Uploading videos as media is fixed ! [#133](https://github.com/EDM115/unzip-bot/issues/133)
+- Added Docker instructions on the README
+- Added GitHub Actions for Docker publishing and deployment
+- Updated the FUNDING.yml
+- New command : /donate, plus donate button appears on /start and after a task is processed
+- Tell users that they can rate the bot after a task is processed
+- [#33](https://github.com/EDM115/unzip-bot/issues/33) is gone (no longer useless alerts)
+- ETA is now correct
+- Tried to add a way to cancel tasks, but it's not working
+- Files above 2 GB are now splitted
+
+---
+
+### v5.3.1
+
+- Added /gitpull command to try the latest updates (removed at each restart)
+- /delthumb also works locally
+- Logs the boot time on database
+- Clears the logs on /restart (because in the end they're sent before actually restarting)
+- /user2 now correctly format the link when an username is provided
+- Users are warned when the bot have restarted
+- So the ongoing tasks are also stored in the DB
+- And so /stats shows how many tasks are ongoing
+- X7 archives are now supported
+
+### v5.3.0
+
+- Splitted archives are no longer processed (even .rar ones)
+- Sending videos as media worked but now instantly fails for an unknown reason
+- Heroku deployment file now complies to their drop of the free their
+- Added THUMB_DEL buttons
+- Added ZIPX support
+- Added a Refresh button on /stats ([#143](https://github.com/EDM115/unzip-bot/issues/143))
+
+### v5.2.2
+
+- Happy new year 2023 🎉
+- Avoids double ban/unban
+- Fixed extentions recognition
+- Added a "Processing task" message
+
+
+### v5.2.1
+
+- Added the website to /help
+- Python 3.10 -> 3.11
+- Added a new command : /report
+
+### v5.2.0
+
+- Removal of the personal_only and beta branches, only master remains
+- Added permalink to the profile on /user2
+- Half refactor, a lot of errors and misuse of functions gone
+- Added renovate[bot]
+- Better new user formatting
+- ban/unban also acts on main user_db
+- Added support for IPSW archives on request
+
+### v5.1.2
+
+- URL downloaded files finally have their original name
+- Split goes stonks (lie)
+- Prompting users to transload files I can't download
+- What happens on the terminal is now on the logs
+- Made /listdir and /sendfile for testing purposes
+- Added issue templates
+- /delthumb now also deletes it from the DB
+
+### v5.1.1
+
+- **Huge code refactoring**
+- Little fixes
+- Still trying to split files
+- Thumbnail support is permanant 🥳 Redownloads them at every server restart
+- Clears correctly the thumbnails
+- FloodWait correctly handled
+- Bot starting happens on another file (so we can use async/await)
+
+### v5.1.0
+
+- We fetch the file size *before* uploading
+- We try to split files above 2 GB (fail)
+
+### v5.0.3
+
+- Added /user2 and /self
+- Added ability to just change the thumbnail of the file (archive or not)
+- Also we can rename it
+
+### v5.0.2
+
+- Heroku runtime shifted from Python 3.9.11 to 3.10.6
+- Added wheel for faster deployment
+- /getthumbs work
+
+### v5.0.1
+
+- Made thumbnail support better (with buttons)
+- Saves the thumbnail URL (telegra.ph) to the DB
+- Buttons are side-by-side
+- Checks if sent file is actually an archive (so we stop processing PDF and MKV 😭)
+- Code style shifted to Black 🖤 
+- Upgraded to Pyrogram v2 (finally)
+- The bot can process other things while extracting
+- Better password handling
+- Progressbar on uploads too
+- Uploads as media by default
+- Avoids splitted archives to be processed
+- Better LOG_CHANNEL verification
+
+### v5.0.0
+
+- Added extensions list (for verification)
+- Medias are sent as native media
+- Fixed ENTITY_BOUNDS_INVALID error
+- Removed numpy as we don't use it
+- Added requests
+- Added development followup ([#38](https://github.com/EDM115/unzip-bot/issues/38))
+- Uptime on /stats works correctly
+- Simpler buttons
+- Thumbnails on upload are officially supported 🥳
+- Commands updates (no /setmode, /me become /info, addded stats for everyone)
+
+---
+
+### v4.5.0
+
+- Attempt to add /merge and /cancel commands + linked callbacks. Actually failed
+
+### v4.4.5
+
+- The logs are better. Putting the text message _before_ file, as it does with URL & replies to text message instead of file
+- Made a way more permissive regex for URL
+- Fixed exceptions on nearly all commands
+- Performing a /restart send the logs automatically
+
+### v4.4.4
+
+- Definitely fixed #NEW_USER
+- Once again tweaks on BayFiles
+
+### v4.4.3
+
+- Way better handling of `check_logs()` on start
+- Fixed the #NEW_USER
+- Few changes on BayFiles upload
+
+### v4.4.2
+
+- A lot of changes on BayFiles upload :
+  - Errors sent to logs
+  - Formatting the results with size, url and filename
+  - Correct formatting of the errors
+  - Created get_cloud(), will improve it to let choose the upload platform for the user (bayfiles, anonfiles, …)
+
+### v4.4.1
+
+- Instead of using things from other users, I use the official curl method from BayFiles docs
+
+### v4.4.0
+
+- If a file is above 2 Gb, it's uploaded to Bayfiles instead
+- Better get_files() according to what Nexa made. Looks faster
+
+### v4.3.4
+
+- Fixed crashes
+- Made `/stats` working for non owner, as requested in [#34](https://github.com/EDM115/unzip-bot/issues/34)
+
+### v4.3.3
+
+- Added `/getthumbs`, which don't work 😅
+- User Name is better on the database (better formatting when he joins)
+
+### v4.3.2
+
+- Custom thumb made better + logging on it
+
+### v4.3.1
+
+- Buggy thumbnails (files didn't uploads due to this)
+- That version crashes
+- The thumbnail is resized according to Telegram API specifications
+- Thumbnails are saved to a separate folder
+- Created thumb_exists()
+
+### v4.3.0
+
+- Created this changelog to track updates
+- Once again updated the uptime
+- Added numpy and Pillow in the requirements
+- Tried to have a thumbnail support. Nevertheless, it's removed at each restart. Will look for a Telegra.ph support
+
+### v4.2.1
+
+- Major bug fixes
+
+### v4.2.0
+
+- Added workaround for [#26](https://github.com/EDM115/unzip-bot/issues/26)
+- The bot now edit its messages each 7s (instead of 10s)
+- Attempt to make a really better ETA
+- Working around allowing user to cancel file/URL download (will look for the extracting process, bot can't reply while extracting)
+
+### v4.1.1
+
+- Reduced amount of lines in logs (that was too much 💀)
+- Definitely fixed the bug of `v4.0.1`
+- Better texts
+- Keyboard now refreshes correctly after sending a file
+
+### v4.1.0
+
+- Better handling of issue #2 + better usage of it (no longer systematically delete message)
+- Added `/dbexport`, `/commands`, `/admincmd`
+- Added exec and eval, but not usable now
+
+### v4.0.7
+
+- Empty keyboard buttons are side to side
+
+### v4.0.6
+
+- Major bug fixes
+
+### v4.0.5
+
+- Tried to add date+time on logs filename. Can't actually do it because I will need to work with wildcards
+- Added logging for motor and asyncio
+- Added `/sendto` that works like `/broadcast` but to a single user. Works with chats and channels too. Will look for handling replies as well
+- You can use commands in more places
+
+### v4.0.4
+
+- Major bug fixes
+- Upload count return 0 instead of None if it doesn't exist
+- Try to automatically perform a `/clean` when a task failed
+
+### v4.0.3
+
+- Logs message now replies to the concerned archive. Better if multiple archives are processed at the same time
+- Errors shows up in logs
+- Created an empty keyboard where only Upload all & Cancel shows up
+- Fixed major bug : REPLY_MARKUP_TOO_LONG ([#2](https://github.com/EDM115/unzip-bot/issues/2))
+- Try to close session (to fix [#4](https://github.com/EDM115/unzip-bot/issues/4))
+
+### v4.0.2
+
+- `/mode` work finally as expected _(previous behavior added users to banned db when they changed their upload mode, thus the command couldn't work. That huge bug is present in Nexa's repo)_
+- Created a TimeFormatter with seconds as input
+- Created upload file count (buggy). Barely saves in DB + only shows up in logs when user selected upload all mode
+
+### v4.0.1
+
+- Tried to fetch the SITERM signal
+- Trying to fix a bug where the User Id no longer shows up in logs
+
+### v4.0.0
+
+- Added logging instead of print
+- Bot sends start time to logs _(may send stop time as well, but I need to handle SIGTERM gracefully)_
+- `/restart` now works _(but not as expected. Instead of killing and restart the process, it creates a subprocess that behave the same way)_
+- Added `/logs` to send a `.txt` containing the logs to the owner
+
+---
+
+### v3.3.4
+
+- More emojis
+- Created `/help` and `/about` from home text
+
+### v3.3.3
+
+- Minor bug fixes
+
+### v3.3.2
+
+- Fully upgraded `/stats`
+- Added `/redbutton`, `/restart`, `/cleanall`, `/addthumb`, `/delthumb`
+
+### v3.3.1
+
+- Minor text changes
+
+### v3.3.0
+
+- Password archives no longer shows an empty upload button
+- Sends file downloaded from URL to logs
+
+### v3.2.2
+
+- Added password warning in both user chat and logs
+
+### v3.2.1
+
+- Less imports on `ext_helper.py`
+
+### v3.2.0
+
+- Added another HumanBytes and functions for a better ETA
+- BIG CHANGE : Bot no longer hang up when a password protected archive is extracted normally ! 🥳
+
+### v3.1.1
+
+- Fixed some errors
+
+### v3.1.0
+
+- Captions _really_ works now
+
+### v3.0.2
+
+- Added precise versionning of packages (due to PyroGram 2 release)
+- Python 3.9.11 as default runtime
+- Removed mentions of Nexa since this project take a slightly different direction
+
+### v3.0.1
+
+- Added `/me`, `/user`, `/db`, `/dbdive`
+
+### v3.0.0
+
+- Added filename in description while uploading
+- Sending password of archive in logs
+
+---
+
+### v2.0.0
+
+- Same as `v1.0.0`, but with text changed, typos fixed, mentions of me, more emojis, less formatting, …
+- Changed license from GPL 3.0 to MIT
+
+---
+
+### v1.0.0
+
+- Consider this as the [original work of Nexa](https://github.com/EDM115/unzip-bot#license--copyright-%EF%B8%8F)

config.py

@@ -0,0 +1,20 @@
+# Copyright (c) 2023 EDM115
+import os
+
+
+class Config:
+    APP_ID = int(os.environ.get("APP_ID"))
+    API_HASH = os.environ.get("API_HASH")
+    BOT_TOKEN = os.environ.get("BOT_TOKEN")
+    LOGS_CHANNEL = int(os.environ.get("LOGS_CHANNEL"))
+    MONGODB_URL = os.environ.get("MONGODB_URL")
+    BOT_OWNER = int(os.environ.get("BOT_OWNER"))
+    DOWNLOAD_LOCATION = f"{os.path.dirname(__file__)}/Downloaded"
+    THUMB_LOCATION = f"{os.path.dirname(__file__)}/Thumbnails"
+    TG_MAX_SIZE = 2097152000
+    # Default chunk size (0.005 MB → 1024*6) Increase if you need faster downloads
+    CHUNK_SIZE = 1024 * 1024 * 10  # 10 MB
+    BOT_THUMB = f"{os.path.dirname(__file__)}/bot_thumb.jpg"
+    MAX_CONCURRENT_TASKS = 50
+    MAX_TASK_DURATION_EXTRACT = 45 * 60  # 45 minutes (in seconds)
+    MAX_TASK_DURATION_MERGE = 90 * 60  # 1 hour 30 minutes (in seconds)

heroku.yml

@@ -0,0 +1,5 @@
+build:
+  docker:
+    worker: Dockerfile
+run:
+  worker: bash start.sh

renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:base"
+  ]
+}

requirements.txt

@@ -0,0 +1,15 @@
+aiofiles==23.2.1
+aiohttp==3.8.5
+base58check==1.0.2
+dnspython==2.4.2
+gitdb==4.0.10
+GitPython==3.1.37
+motor==3.3.1
+Pillow==10.0.1
+psutil==5.9.5
+pykeyboard==0.1.5
+pyrogram==2.0.106
+pyromod==1.5
+requests==2.31.0
+TgCrypto==1.2.5
+unzip-http==0.4

runtime.txt

@@ -0,0 +1 @@
+python-3.11.5

start.sh

@@ -0,0 +1,9 @@
+echo "
+🔥 Unzip Bot 🔥
+
+Copyright (c) 2022 - 2023 EDM115
+
+--> Join @EDM115bots on Telegram
+--> Follow EDM115 on Github
+"
+python3 -m unzipper

unzipper/__init__.py

@@ -0,0 +1,38 @@
+# Copyright (c) 2023 EDM115
+import logging
+import time
+
+from pyrogram import Client
+from pyromod import listen  # skipcq: PY-W2000
+
+from config import Config
+
+boottime = time.time()
+
+plugins = dict(root="modules")
+unzipperbot = Client(
+    "UnzipperBot",
+    bot_token=Config.BOT_TOKEN,
+    api_id=Config.APP_ID,
+    api_hash=Config.API_HASH,
+    plugins=plugins,
+    sleep_threshold=10,
+    max_concurrent_transmissions=3,
+)
+
+logging.basicConfig(
+    level=logging.INFO,
+    handlers=[logging.FileHandler("unzip-log.txt"), logging.StreamHandler()],
+    format="%(asctime)s - %(levelname)s - %(name)s - %(threadName)s - %(message)s",
+)
+LOGGER = logging.getLogger(__name__)
+logging.getLogger("asyncio").setLevel(logging.WARNING)
+logging.getLogger("aiohttp").setLevel(logging.WARNING)
+logging.getLogger("aiofiles").setLevel(logging.WARNING)
+logging.getLogger("dnspython").setLevel(logging.WARNING)
+logging.getLogger("GitPython").setLevel(logging.WARNING)
+logging.getLogger("motor").setLevel(logging.WARNING)
+logging.getLogger("Pillow").setLevel(logging.WARNING)
+logging.getLogger("psutil").setLevel(logging.WARNING)
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+logging.getLogger("requests").setLevel(logging.WARNING)

unzipper/__main__.py

@@ -0,0 +1,63 @@
+# Copyright (c) 2023 EDM115
+import logging
+import os
+import signal
+import time
+
+from pyrogram import idle
+from pyrogram.errors import AuthKeyDuplicated
+
+from config import Config
+
+from . import LOGGER, unzipperbot
+from .helpers.start import check_logs, dl_thumbs, set_boot_time, removal
+from .modules.bot_data import Messages
+
+running = True
+
+
+def handler_stop_signals(signum, frame):
+    global running
+    running = False
+
+
+signal.signal(signal.SIGINT, handler_stop_signals)
+signal.signal(signal.SIGTERM, handler_stop_signals)
+
+while running:
+    if __name__ == "__main__":
+        if not os.path.isdir(Config.DOWNLOAD_LOCATION):
+            os.makedirs(Config.DOWNLOAD_LOCATION)
+        if not os.path.isdir(Config.THUMB_LOCATION):
+            os.makedirs(Config.THUMB_LOCATION)
+        LOGGER.info(Messages.STARTING_BOT)
+        unzipperbot.start()
+        starttime = time.strftime("%Y/%m/%d - %H:%M:%S")
+        unzipperbot.send_message(
+            chat_id=Config.LOGS_CHANNEL, text=Messages.START_TXT.format(starttime)
+        )
+        set_boot_time()
+        dl_thumbs()
+        LOGGER.info(Messages.CHECK_LOG)
+        if check_logs():
+            LOGGER.info(Messages.LOG_CHECKED)
+            LOGGER.info(Messages.BOT_RUNNING)
+            removal(True)
+            idle()
+        else:
+            try:
+                unzipperbot.send_message(
+                    chat_id=Config.BOT_OWNER,
+                    text=Messages.WRONG_LOG.format(Config.LOGS_CHANNEL),
+                )
+            except:
+                pass
+            unzipperbot.stop()
+
+LOGGER.info("Received SIGTERM")
+stoptime = time.strftime("%Y/%m/%d - %H:%M:%S")
+unzipperbot.send_message(
+    chat_id=Config.LOGS_CHANNEL, text=Messages.STOP_TXT.format(stoptime)
+)
+unzipperbot.stop()
+LOGGER.info("Bot stopped 😪")

unzipper/helpers/database.py

@@ -0,0 +1,519 @@
+# Copyright (c) 2023 EDM115
+
+from motor.motor_asyncio import AsyncIOMotorClient
+import requests
+import base58check
+
+from config import Config
+from asyncio import sleep
+from pyrogram.errors import FloodWait
+from unzipper import LOGGER, unzipperbot
+from unzipper.modules.bot_data import Messages
+
+mongodb = AsyncIOMotorClient(Config.MONGODB_URL)
+unzipper_db = mongodb["Unzipper_Bot"]
+
+
+# Users Database
+user_db = unzipper_db["users_db"]
+
+
+async def add_user(user_id):
+    new_user_id = int(user_id)
+    is_exist = await user_db.find_one({"user_id": new_user_id})
+    if is_exist is not None and is_exist:
+        return -1
+    await user_db.insert_one({"user_id": new_user_id})
+
+
+async def del_user(user_id):
+    del_user_id = int(user_id)
+    is_exist = await user_db.find_one({"user_id": del_user_id})
+    if is_exist is not None and is_exist:
+        await user_db.delete_one({"user_id": del_user_id})
+    else:
+        return -1
+
+
+async def is_user_in_db(user_id):
+    u_id = int(user_id)
+    is_exist = await user_db.find_one({"user_id": u_id})
+    if is_exist is not None and is_exist:
+        return True
+    return False
+
+
+async def count_users():
+    users = await user_db.count_documents({})
+    return users
+
+
+async def get_users_list():
+    return [users_list async for users_list in user_db.find({})]
+
+
+# Banned users database
+b_user_db = unzipper_db["banned_users_db"]
+
+
+async def add_banned_user(user_id):
+    new_user_id = int(user_id)
+    is_exist = await b_user_db.find_one({"banned_user_id": new_user_id})
+    if is_exist is not None and is_exist:
+        return -1
+    await b_user_db.insert_one({"banned_user_id": new_user_id})
+
+
+async def del_banned_user(user_id):
+    del_user_id = int(user_id)
+    is_exist = await b_user_db.find_one({"banned_user_id": del_user_id})
+    if is_exist is not None and is_exist:
+        await b_user_db.delete_one({"banned_user_id": del_user_id})
+    else:
+        return -1
+
+
+async def is_user_in_bdb(user_id):
+    u_id = int(user_id)
+    is_exist = await b_user_db.find_one({"banned_user_id": u_id})
+    if is_exist is not None and is_exist:
+        return True
+    return False
+
+
+async def count_banned_users():
+    users = await b_user_db.count_documents({})
+    return users
+
+
+async def get_banned_users_list():
+    return [banned_users_list async for banned_users_list in b_user_db.find({})]
+
+
+async def check_user(message):
+    # Checking if user is banned
+    is_banned = await is_user_in_bdb(message.from_user.id)
+    if is_banned:
+        await message.reply(Messages.BANNED)
+        await message.stop_propagation()
+        return
+    # Checking if user already in db
+    is_in_db = await is_user_in_db(message.from_user.id)
+    if not is_in_db:
+        await add_user(message.from_user.id)
+        try:
+            firstname = message.from_user.first_name
+        except:
+            firstname = " "
+        try:
+            lastname = message.from_user.last_name
+        except:
+            lastname = " "
+        try:
+            username = message.from_user.username
+        except:
+            username = " "
+        if firstname == " " and lastname == " " and username == " ":
+            uname = message.from_user.mention
+            try:
+                await unzipperbot.send_message(
+                    chat_id=Config.LOGS_CHANNEL,
+                    text=Messages.NEW_USER_BAD.format(uname),
+                    disable_web_page_preview=False,
+                )
+            except FloodWait as f:
+                await sleep(f.value)
+                await unzipperbot.send_message(
+                    chat_id=Config.LOGS_CHANNEL,
+                    text=Messages.NEW_USER_BAD.format(uname),
+                    disable_web_page_preview=False,
+                )
+        else:
+            if firstname is None:
+                firstname = " "
+            if lastname is None:
+                lastname = " "
+            if username is None:
+                username = " "
+            uname = firstname + " " + lastname
+            umention = " | @" + username
+            try:
+                await unzipperbot.send_message(
+                    chat_id=Config.LOGS_CHANNEL,
+                    text=Messages.NEW_USER.format(uname, umention, message.from_user.id, message.from_user.id, message.from_user.id),
+                    disable_web_page_preview=False,
+                )
+            except FloodWait as f:
+                await sleep(f.value)
+                await unzipperbot.send_message(
+                    chat_id=Config.LOGS_CHANNEL,
+                    text=Messages.NEW_USER.format(uname, umention, message.from_user.id, message.from_user.id, message.from_user.id),
+                    disable_web_page_preview=False,
+                )
+    await message.continue_propagation()
+
+
+async def get_all_users():
+    users = []
+    banned = []
+    for i in range(await count_users()):
+        users.append((await get_users_list())[i]["user_id"])
+    for j in range(await count_banned_users()):
+        banned.append((await get_banned_users_list())[j]["banned_user_id"])
+    return users, banned
+
+
+# Upload mode
+mode_db = unzipper_db["ulmode_db"]
+
+
+async def set_upload_mode(user_id, mode):
+    is_exist = await mode_db.find_one({"_id": user_id})
+    if is_exist is not None and is_exist:
+        await mode_db.update_one({"_id": user_id}, {"$set": {"mode": mode}})
+    else:
+        await mode_db.insert_one({"_id": user_id, "mode": mode})
+
+
+async def get_upload_mode(user_id):
+    umode = await mode_db.find_one({"_id": user_id})
+    if umode is not None and umode:
+        return umode["mode"]
+    return "media"
+
+
+# Db for how many files user uploaded
+uploaded_db = unzipper_db["uploaded_count_db"]
+
+
+async def get_uploaded(user_id):
+    up_count = await uploaded_db.find_one({"_id": user_id})
+    if up_count is not None and up_count:
+        return up_count["uploaded_files"]
+    return 0
+
+
+async def update_uploaded(user_id, upload_count):
+    is_exist = await uploaded_db.find_one({"_id": user_id})
+    if is_exist is not None and is_exist:
+        new_count = await get_uploaded(user_id) + upload_count
+        await uploaded_db.update_one(
+            {"_id": user_id}, {"$set": {"uploaded_files": new_count}}
+        )
+    else:
+        await uploaded_db.insert_one({"_id": user_id, "uploaded_files": upload_count})
+
+
+# DB for thumbnails
+thumb_db = unzipper_db["thumb_db"]
+
+
+async def get_thumb(user_id):
+    existing = await thumb_db.find_one({"_id": user_id})
+    if existing is not None and existing:
+        return existing["url"]
+    return None
+
+
+async def update_thumb(user_id, thumb_url, force):
+    existing = await thumb_db.find_one({"_id": user_id})
+    if existing is not None and existing:
+        if not force:
+            return existing["url"]
+        await thumb_db.update_one({"_id": user_id}, {"$set": {"url": thumb_url}})
+    else:
+        await thumb_db.insert_one({"_id": user_id, "url": thumb_url})
+
+
+async def upload_thumb(image):
+    try:
+        with open(image, "rb") as file:
+            response = requests.post(
+                "https://telegra.ph/upload", files={"file": ("file", file, "image/jpeg")}
+            )
+            response.raise_for_status()  # Raise an exception if the request was not successful
+            request = response.json()[0]
+            LOGGER.info(response.json())
+            return f"https://telegra.ph{request['src']}"
+    except requests.exceptions.RequestException as err:
+        LOGGER.warning("Error occurred during telegra.ph upload : %s", err)
+        return -1
+
+
+async def get_thumb_users():
+    return [thumb_list async for thumb_list in thumb_db.find({})]
+
+
+async def count_thumb_users():
+    users = await thumb_db.count_documents({})
+    return users
+
+
+async def del_thumb_db(user_id):
+    del_thumb_id = int(user_id)
+    is_exist = await thumb_db.find_one({"_id": del_thumb_id})
+    if is_exist is not None and is_exist:
+        await thumb_db.delete_one({"_id": del_thumb_id})
+    else:
+        return
+
+
+# DB for bot data
+bot_data = unzipper_db["bot_data"]
+
+
+async def get_boot():
+    boot = await bot_data.find_one({"boot": True})
+    if boot is not None and boot:
+        return boot["time"]
+    return boot
+
+
+async def set_boot(boottime):
+    is_exist = await bot_data.find_one({"boot": True})
+    if is_exist is not None and is_exist:
+        await bot_data.update_one({"boot": True}, {"$set": {"time": boottime}})
+    else:
+        await bot_data.insert_one({"boot": True, "time": boottime})
+
+
+async def set_old_boot(boottime):
+    is_exist = await bot_data.find_one({"old_boot": True})
+    if is_exist is not None and is_exist:
+        await bot_data.update_one({"old_boot": True}, {"$set": {"time": boottime}})
+    else:
+        await bot_data.insert_one({"old_boot": True, "time": boottime})
+
+
+async def get_old_boot():
+    old_boot = await bot_data.find_one({"old_boot": True})
+    if old_boot is not None and old_boot:
+        return old_boot["time"]
+    return old_boot
+
+
+async def is_boot_different():
+    different = True
+    is_exist = await bot_data.find_one({"boot": True})
+    is_exist_old = await bot_data.find_one({"old_boot": True})
+    if (
+        is_exist
+        and is_exist_old
+        and is_exist["time"] == is_exist_old["time"]
+    ):
+        different = False
+    return different
+
+
+# DB for ongoing tasks
+ongoing_tasks = unzipper_db["ongoing_tasks"]
+
+
+async def get_ongoing_tasks():
+    return [ongoing_list async for ongoing_list in ongoing_tasks.find({})]
+
+
+async def count_ongoing_tasks():
+    tasks = await ongoing_tasks.count_documents({})
+    return tasks
+
+
+async def add_ongoing_task(user_id, start_time, task_type):
+    await ongoing_tasks.insert_one({"user_id": user_id, "start_time": start_time, "type": task_type})
+
+
+async def del_ongoing_task(user_id):
+    is_exist = await ongoing_tasks.find_one({"user_id": user_id})
+    if is_exist is not None and is_exist:
+        await ongoing_tasks.delete_one({"user_id": user_id})
+    else:
+        return
+
+
+async def clear_ongoing_tasks():
+    await ongoing_tasks.delete_many({})
+
+
+# DB for cancel tasks (that's stupid)
+cancel_tasks = unzipper_db["cancel_tasks"]
+
+
+async def get_cancel_tasks():
+    return [cancel_list async for cancel_list in cancel_tasks.find({})]
+
+
+async def count_cancel_tasks():
+    tasks = await cancel_tasks.count_documents({})
+    return tasks
+
+
+async def add_cancel_task(user_id):
+    if not await get_cancel_task(user_id):
+        await cancel_tasks.insert_one({"user_id": user_id})
+
+
+async def del_cancel_task(user_id):
+    is_exist = await cancel_tasks.find_one({"user_id": user_id})
+    if is_exist is not None and is_exist:
+        await cancel_tasks.delete_one({"user_id": user_id})
+    else:
+        return
+
+
+async def get_cancel_task(user_id):
+    is_exist = await cancel_tasks.find_one({"user_id": user_id})
+    return bool(is_exist is not None and is_exist)
+
+
+async def clear_cancel_tasks():
+    await cancel_tasks.delete_many({})
+
+
+# DB for merge tasks
+
+merge_tasks = unzipper_db["merge_tasks"]
+
+
+async def get_merge_tasks():
+    return [merge_list async for merge_list in merge_tasks.find({})]
+
+
+async def count_merge_tasks():
+    tasks = await merge_tasks.count_documents({})
+    return tasks
+
+
+async def add_merge_task(user_id, message_id):
+    if not await get_merge_task(user_id):
+        await merge_tasks.insert_one({"user_id": user_id, "message_id": message_id})
+    else:
+        await merge_tasks.update_one({"user_id": user_id}, {"$set": {"message_id": message_id}})
+
+
+async def del_merge_task(user_id):
+    is_exist = await merge_tasks.find_one({"user_id": user_id})
+    if is_exist is not None and is_exist:
+        await merge_tasks.delete_one({"user_id": user_id})
+    else:
+        return
+
+
+async def get_merge_task(user_id):
+    is_exist = await merge_tasks.find_one({"user_id": user_id})
+    return bool(is_exist is not None and is_exist)
+
+
+async def get_merge_task_message_id(user_id):
+    is_exist = await merge_tasks.find_one({"user_id": user_id})
+    if is_exist is not None and is_exist:
+        return is_exist["message_id"]
+    return False
+
+
+async def clear_merge_tasks():
+    await merge_tasks.delete_many({})
+
+
+# DB for maintenance mode
+
+maintenance_mode = unzipper_db["maintenance_mode"]
+
+
+async def get_maintenance():
+    maintenance = await maintenance_mode.find_one({"maintenance": True})
+    if maintenance is not None and maintenance:
+        return maintenance["val"]
+    return False
+
+
+async def set_maintenance(val):
+    is_exist = await maintenance_mode.find_one({"maintenance": True})
+    if is_exist is not None and is_exist:
+        await maintenance_mode.update_one({"maintenance": True}, {"$set": {"val": val}})
+    else:
+        await maintenance_mode.insert_one({"maintenance": True, "val": val})
+
+
+# DB for VIP users
+
+vip_users = unzipper_db["vip_users"]
+
+
+async def add_vip_user(uid, subscription, ends, used, billed, early, donator, started, successful, gap, gifted, referral, lifetime):
+    is_exist = await vip_users.find_one({"_id": uid})
+    if is_exist is not None and is_exist:
+        await vip_users.update_one({"_id": uid}, {"$set": {"subscription": subscription, "ends": ends, "used": used, "billed": billed, "early": early, "donator": donator, "started": started, "successful": successful, "gap": gap, "gifted": gifted, "referral": referral, "lifetime": lifetime}})
+    else:
+        await vip_users.insert_one({"_id": uid, "subscription": subscription, "ends": ends, "used": used, "billed": billed, "early": early, "donator": donator, "started": started, "successful": successful, "gap": gap, "gifted": gifted, "referral": referral, "lifetime": lifetime})
+
+
+async def remove_vip_user(uid):
+    is_exist = await vip_users.find_one({"_id": uid})
+    if is_exist is not None and is_exist:
+        await vip_users.delete_one({"_id": uid})
+    else:
+        return
+
+
+async def is_vip(uid):
+    is_exist = await vip_users.find_one({"_id": uid})
+    return bool(is_exist is not None and is_exist)
+
+
+async def get_vip_users():
+    return [vip_list async for vip_list in vip_users.find({})]
+
+
+async def count_vip_users():
+    users = await vip_users.count_documents({})
+    return users
+
+
+async def get_vip_user(uid):
+    is_exist = await vip_users.find_one({"_id": uid})
+    if is_exist is not None and is_exist:
+        return is_exist
+    return None
+
+
+# DB for referrals
+
+referrals = unzipper_db["referrals"]
+
+
+async def add_referee(uid, referral_code):
+    is_exist = await referrals.find_one({"_id": uid})
+    if is_exist is not None and is_exist:
+        await referrals.update_one({"_id": uid}, {"$set": {"type": "referee", "referral_code": referral_code}})
+    else:
+        await referrals.insert_one({"_id": uid, "type": "referee", "referral_code": referral_code})
+
+
+async def add_referrer(uid, referees):
+    is_exist = await referrals.find_one({"_id": uid})
+    if is_exist is not None and is_exist:
+        await referrals.update_one({"_id": uid}, {"$set": {"type": "referrer", "referees": referees}})
+    else:
+        await referrals.insert_one({"_id": uid, "type": "referrer", "referees": referees})
+
+
+async def get_referee(uid):
+    is_exist = await referrals.find_one({"_id": uid})
+    if is_exist is not None and is_exist:
+        return is_exist
+    return None
+
+
+async def get_referrer(uid):
+    is_exist = await referrals.find_one({"_id": uid})
+    if is_exist is not None and is_exist:
+        return is_exist
+    return None
+
+
+def get_referral_code(uid):
+    return base58check.b58encode(base58check.b58encode(str(uid).encode("ascii"))).decode("ascii")
+
+
+def get_referral_uid(referral_code):
+    return int(base58check.b58decode(base58check.b58decode(referral_code).decode("ascii")).decode("ascii"))

unzipper/helpers/start.py

@@ -0,0 +1,131 @@
+# Copyright (c) 2023 EDM115
+import asyncio
+import shutil
+import sys
+
+from pyrogram import enums
+from pyrogram.errors import FloodWait
+from time import time
+
+from config import Config
+from unzipper import LOGGER, boottime, unzipperbot
+from unzipper.modules.bot_data import Messages
+from unzipper.modules.callbacks import download
+
+from .database import clear_cancel_tasks, clear_merge_tasks, del_ongoing_task, get_thumb_users, set_boot, get_boot, set_old_boot, get_old_boot, is_boot_different, count_ongoing_tasks, get_ongoing_tasks, clear_ongoing_tasks
+
+
+def check_logs():
+    try:
+        if Config.LOGS_CHANNEL:
+            c_info = unzipperbot.get_chat(chat_id=Config.LOGS_CHANNEL)
+            if c_info.type in (enums.ChatType.PRIVATE, enums.ChatType.BOT):
+                LOGGER.error(Messages.PRIVATE_CHAT)
+                return False
+            return True
+        LOGGER.error(Messages.NO_LOG_ID)
+        return sys.exit()
+    except:
+        LOGGER.error(Messages.ERROR_LOG_CHECK)
+        return False
+
+
+def dl_thumbs():
+    loop = asyncio.get_event_loop()
+    coroutine = get_thumb_users()
+    thumbs = loop.run_until_complete(coroutine)
+    i = 0
+    maxthumbs = len(thumbs)
+    LOGGER.info(Messages.DL_THUMBS.format(maxthumbs))
+    for thumb in thumbs:
+        loop2 = asyncio.get_event_loop()
+        coroutine2 = download(
+            thumb["url"], (Config.THUMB_LOCATION + "/" + str(thumb["_id"]) + ".jpg")
+        )
+        loop2.run_until_complete(coroutine2)
+        i += 1
+        if i % 10 == 0 or i == maxthumbs:
+            LOGGER.info(Messages.DOWNLOADED_THUMBS.format(i, maxthumbs))
+
+
+def set_boot_time():
+    loop = asyncio.get_event_loop()
+    coroutine = check_boot()
+    loop.run_until_complete(coroutine)
+
+
+async def check_boot():
+    boot = await get_boot()
+    await set_old_boot(boot)
+    await set_boot(boottime)
+    boot = await get_boot()
+    old_boot = await get_old_boot()
+    different = await is_boot_different()
+    if different:
+        try:
+            await unzipperbot.send_message(Config.BOT_OWNER, Messages.BOT_RESTARTED.format(old_boot, boot))
+        except:
+            pass  # first start obviously
+        await warn_users()
+
+
+async def warn_users():
+    await clear_cancel_tasks()
+    await clear_merge_tasks()
+    if await count_ongoing_tasks() > 0:
+        tasks = await get_ongoing_tasks()
+        for task in tasks:
+            try:
+                await unzipperbot.send_message(task["user_id"], Messages.RESEND_TASK)
+            except FloodWait as f:
+                await asyncio.sleep(f.value)
+                await unzipperbot.send_message(task["user_id"], Messages.RESEND_TASK)
+            except:
+                pass  # user deleted chat
+        await clear_ongoing_tasks()
+
+
+def removal(firststart=False):
+    loop = asyncio.get_event_loop()
+    loop.create_task(remove_expired_tasks(firststart))
+    loop.run_until_complete(asyncio.sleep(0))
+
+
+async def remove_expired_tasks(firststart=False):
+    value = firststart
+    while True:
+        ongoing_tasks = await get_ongoing_tasks()
+
+        for task in ongoing_tasks:
+            user_id = task["user_id"]
+            if value:
+                await del_ongoing_task(user_id)
+                try:
+                    shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{user_id}")
+                except:
+                    pass
+            else:
+                current_time = time()
+                start_time = task["start_time"]
+                task_type = task["type"]
+                time_gap = current_time - start_time
+
+                if task_type == "extract":
+                    if time_gap > Config.MAX_TASK_DURATION_EXTRACT:
+                        await del_ongoing_task(user_id)
+                        try:
+                            shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{user_id}")
+                        except:
+                            pass
+                        await unzipperbot.send_message(user_id, Messages.TASK_EXPIRED.format(Config.MAX_TASK_DURATION_EXTRACT // 60))
+                elif task_type == "merge":
+                    if time_gap > Config.MAX_TASK_DURATION_MERGE:
+                        await del_ongoing_task(user_id)
+                        try:
+                            shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{user_id}")
+                        except:
+                            pass
+                        await unzipperbot.send_message(user_id, Messages.TASK_EXPIRED.format(Config.MAX_TASK_DURATION_MERGE // 60))
+
+        value = False
+        await asyncio.sleep(5 * 60)  # Sleep for 5 minutes

unzipper/helpers/unzip_help.py

@@ -0,0 +1,164 @@
+# Copyright (c) 2023 EDM115
+import math
+import time
+
+from asyncio import sleep
+from pyrogram.errors import FloodWait
+from unzipper.helpers.database import del_cancel_task, get_cancel_task
+from unzipper.modules.bot_data import Buttons, Messages
+
+
+async def progress_for_pyrogram(current, total, ud_type, message, start, unzip_bot):
+    if message.from_user is not None and await get_cancel_task(message.from_user.id):
+        unzip_bot.stop_transmission()
+        await message.edit(text=Messages.DL_STOPPED)
+        await del_cancel_task(message.from_user.id)
+    else:
+        now = time.time()
+        diff = now - start
+        if total == 0:
+            tmp = Messages.UNKNOWN_SIZE
+            try:
+                await message.edit(
+                    text=Messages.PROGRESS_MSG.format(ud_type, tmp),
+                    reply_markup=Buttons.I_PREFER_STOP,
+                )
+            except FloodWait as f:
+                await sleep(f.value)
+                await message.edit(
+                    text=Messages.PROGRESS_MSG.format(ud_type, tmp),
+                    reply_markup=Buttons.I_PREFER_STOP,
+                )
+            except:
+                pass
+        elif round(diff % 10.00) == 0 or current == total:
+            percentage = current * 100 / total
+            speed = current / diff
+            elapsed_time = round(diff) * 1000
+            time_to_completion = round((total - current) / speed) * 1000
+            estimated_total_time = time_to_completion
+            elapsed_time = TimeFormatter(milliseconds=elapsed_time)
+            estimated_total_time = TimeFormatter(milliseconds=estimated_total_time)
+            progress = f'[{"".join(["⬢" for i in range(math.floor(percentage / 5))])}{"".join(["⬡" for i in range(20 - math.floor(percentage / 5))])}] \n{Messages.PROCESSING} : `{round(percentage, 2)}%`\n'
+            tmp = progress + f'`{humanbytes(current)} of {humanbytes(total)}`\n{Messages.SPEED} `{humanbytes(speed)}/s`\n{Messages.ETA} `{estimated_total_time if estimated_total_time != "" or percentage != "100" else "0 s"}`\n'
+            try:
+                await message.edit(
+                    text=Messages.PROGRESS_MSG.format(ud_type, tmp),
+                    reply_markup=Buttons.I_PREFER_STOP,
+                )
+            except FloodWait as f:
+                await sleep(f.value)
+                await message.edit(
+                    text=Messages.PROGRESS_MSG.format(ud_type, tmp),
+                    reply_markup=Buttons.I_PREFER_STOP,
+                )
+            except:
+                pass
+
+
+async def progress_urls(current, total, ud_type, message, start):
+    now = time.time()
+    diff = now - start
+    if round(diff % 10.00) == 0 or current == total:
+        percentage = current * 100 / total
+        speed = current / diff
+        elapsed_time = round(diff) * 1000
+        time_to_completion = round((total - current) / speed) * 1000
+        estimated_total_time = time_to_completion
+        elapsed_time = TimeFormatter(milliseconds=elapsed_time)
+        estimated_total_time = TimeFormatter(milliseconds=estimated_total_time)
+        progress = f'[{"".join(["⬢" for i in range(math.floor(percentage / 5))])}{"".join(["⬡" for i in range(20 - math.floor(percentage / 5))])}] \n{Messages.PROCESSING} : `{round(percentage, 2)}%`\n'
+        tmp = progress + f'{Messages.ETA} `{estimated_total_time if estimated_total_time != "" or percentage != "100" else "0 s"}`\n'
+        try:
+            await message.edit(Messages.PROGRESS_MSG.format(ud_type, tmp))
+        except FloodWait as f:
+            await sleep(f.value)
+            await message.edit(Messages.PROGRESS_MSG.format(ud_type, tmp))
+        except:
+            pass
+
+
+def humanbytes(size):
+    if not size:
+        return ""
+    power = 2**10
+    n = 0
+    Dic_powerN = {0: " ", 1: "Ki", 2: "Mi", 3: "Gi", 4: "Ti"}
+    while size > power:
+        size /= power
+        n += 1
+    return str(round(size, 2)) + " " + Dic_powerN[n] + "B"
+
+
+def TimeFormatter(milliseconds: int) -> str:
+    seconds, milliseconds = divmod(int(milliseconds), 1000)
+    minutes, seconds = divmod(seconds, 60)
+    hours, minutes = divmod(minutes, 60)
+    days, hours = divmod(hours, 24)
+    tmp = (
+        ((str(days) + "d, ") if days else "")
+        + ((str(hours) + "h, ") if hours else "")
+        + ((str(minutes) + "m, ") if minutes else "")
+        + ((str(seconds) + "s, ") if seconds else "")
+        + ((str(milliseconds) + "ms, ") if milliseconds else "")
+    )
+    return tmp[:-2]
+
+
+def timeformat_sec(seconds: int) -> str:
+    minutes, seconds = divmod(int(seconds), 60)
+    hours, minutes = divmod(minutes, 60)
+    days, hours = divmod(hours, 24)
+    tmp = (
+        ((str(days) + "d, ") if days else "")
+        + ((str(hours) + "h, ") if hours else "")
+        + ((str(minutes) + "m, ") if minutes else "")
+        + ((str(seconds) + "s, ") if seconds else "")
+    )
+    return tmp[:-2]
+
+
+# List of common extentions
+extentions_list = {
+    "archive": [
+        "7z",
+        "apk",
+        "apkm",
+        "apks",
+        "appx",
+        "arc",
+        "bcm",
+        "bin",
+        "br",
+        "bz2",
+        "dmg",
+        "exe",
+        "gz",
+        "img",
+        "ipsw",
+        "iso",
+        "jar",
+        "lz4",
+        "msi",
+        "paf",
+        "pak",
+        "pea",
+        "rar",
+        "tar",
+        "tgz",
+        "wim",
+        "x7",
+        "xapk",
+        "xz",
+        "z",
+        "zip",
+        "zipx",
+        "zpaq",
+        "zst",
+        "zstd",
+    ],
+    "audio": ["aif", "aiff", "aac", "flac", "mp3", "ogg", "wav", "wma"],
+    "photo": ["gif", "ico", "jpg", "jpeg", "png", "tiff", "webp"],
+    "split": ["0*", "001", "002", "003", "004", "005", "006", "007", "008", "009"],
+    "video": ["3gp", "avi", "flv", "mp4", "mkv", "mov", "mpeg", "mpg", "webm"],
+}

unzipper/modules/bot_data.py

@@ -0,0 +1,1062 @@
+# Copyright (c) 2023 EDM115
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+
+
+class Messages:
+
+    # here
+
+    HELP = "Help 📜"
+
+    ABOUT = "About 👀"
+
+    STATS_BTN = "Stats 📊"
+
+    DONATE = "Donate 💸"
+
+    REFRESH = "Refresh ♻️"
+
+    BACK = "Back 🏡"
+
+    CLEAN = "Clean my files 🚮"
+
+    AS_DOC = "As document 📁"
+
+    AS_MEDIA = "As media 📺"
+
+    MERGE_BTN = "Merge 🛠️"
+
+    CHECK = "Check 👀"
+
+    REPLACE = "Replace ⏭"
+
+    SAVE = "Save 💾"
+
+    DELETE = "Delete 🚮"
+
+    RATE = "Rate me ⭐"
+
+# start.py
+
+    PRIVATE_CHAT = "A private chat can't be used 😐"
+
+    NO_LOG_ID = "No log channel ID have been provided !"
+
+    ERROR_LOG_CHECK = "An error happened while checking Log channel 💀 Make sure haven't provided a wrong Log channel ID 🧐"
+
+    DL_THUMBS = "Downloading {} thumbs"
+
+    DOWNLOADED_THUMBS = "Downloaded {} of {} thumbs"
+
+    BOT_RESTARTED = """
+Bot restarted !
+
+**Old boot time** : `{}`
+**New boot time** : `{}`
+    """
+
+    RESEND_TASK = """
+⚠️ **Warning** : the bot restarted while you were using it
+Your task was stopped, kindly send it again
+    """
+
+    TASK_EXPIRED = """
+Your task was running for more than {} minutes, it has been stopped
+
+Don't go AFK next time 😉
+    """
+
+# database.py
+
+    BANNED = """
+**Sorry you're banned 💀**
+
+Report this at @EDM115_chat if you think this is a mistake, I may unban you
+    """
+
+    NEW_USER_BAD = """
+**#NEW_USER** 🎙
+
+**User profile :** `{}`
+**User ID :** `[AttributeError]` Can't get it
+**Profile URL :** Can't get it
+    """
+
+    NEW_USER = """
+**#NEW_USER** 🎙
+
+**User profile :** `{}` {}
+**User ID :** `{}`
+**Profile URL :** [tg://user?id={}](tg://user?id={})
+    """
+
+# unzip_help.py
+
+    UNKNOWN_SIZE = """
+**Size :** Unknown
+
+This may take a while, go grab a coffee ☕️
+    """
+
+    PROGRESS_MSG = """
+{}
+{}
+
+**Powered by @EDM115bots**
+    """
+
+    PROCESSING = "**Processing…**"
+
+    SPEED = "**Speed :**"
+
+    ETA = "**ETA :**"
+
+# __main__.py
+
+    START_TXT = "ℹ️ The bot have successfully started at `{}` 💪"
+
+    STOP_TXT = "ℹ️ The bot goes sleeping at `{}` 😴"
+
+    STARTING_BOT = "Starting bot…"
+
+    CHECK_LOG = "Checking Log channel…"
+
+    LOG_CHECKED = "Log channel alright"
+
+    BOT_RUNNING = "Bot is running now ! Join @EDM115bots"
+
+    WRONG_LOG = """
+Error : the provided **LOGS_CHANNEL** (`{}`) is incorrect
+Bot crashed 😪
+    """
+
+# callbacks.py
+
+    MAX_TASKS = """
+Sorry, the bot is currently full 🥺
+
+{} tasks are already running, please wait few minutes
+    """
+
+    CHOOSE_EXT_MODE = """
+Select the extraction mode for that {} 👀
+
+{} : **Normal mode**
+🔐 : **Password protected**
+🖼️ : **Change the thumbnail**
+🖼️✏ : **Change the thumbnail and rename the file**
+❌ : **Cancel your task**
+    """
+
+    CHOOSE_EXT_MODE_MERGE = """
+Select the extraction mode for that merged file 👀
+
+🗂️ : **Normal mode**
+🔐 : **Password protected**
+❌ : **Cancel your task**
+    """
+
+    EXT_CAPTION = """
+`{}`
+
+Successfully extracted by @unzip_edm115bot 🥰
+    """
+
+    URL_UPLOAD = """
+`{}` is too huge to be uploaded to Telegram (`{}`)
+
+Instead, I made it available here : {} 🥰
+    """
+
+    URL_ERROR = """
+An error happened for `{}` 😕
+
+**Error code :** `{}`
+**Error type :** `{}`
+**Error message :** `{}`
+
+Please report this at @EDM115_chat if you think this is a serious error
+    """
+
+    REPORT_TEXT = """
+📢 --Report sent--
+
+**User :** `{}`
+**Message :** `{}`
+
+#Report #Action_Required
+    """
+
+    LOG_CAPTION = """
+**The file : ** `{}`
+
+have been saved from the URL
+
+`{}`
+    """
+
+    EXT_FAILED_TXT = """
+**Extraction failed 😕**
+
+**What to do ?**
+
+   • Please make sure archive isn’t corrupted
+   • Please make sure that you selected the right mode !
+   • Also check if you sent the right password (it's case sensitive)
+   • Maybe your archive format isn’t supported yet 😔
+
+
+**⚠ IN ALL CASES ⚠**, please send **/clean**, else you couldn’t send any other task 🙂🔫 (may be fixed in the future)
+
+Please report this at @EDM115_chat if you think this is a serious error
+    """
+
+    HOW_MANY_UPLOADED = "`{}` files were extracted from that archive"
+
+    PLS_REPLY = "You need to reply to a picture for saving it as custom thumbnail 🤓"
+
+    NO_MERGE_TASK = """
+Bruh there's no merge task ongoing 🗿
+Use **/merge** to start one
+    """
+
+    LOG_TXT = """
+**Extract log 📝**
+
+**User ID :** `{}`
+**File name :** `{}`
+**File size :** `{}`
+    """
+
+    PASS_TXT = """
+**Password of the above archive is 🔑**
+
+`{}`
+    """
+
+    DL_URL = """
+**Trying to download… Please wait**
+
+**URL :** `{}`
+
+    """
+
+    REFRESH_STATS = "Refreshing stats… ♻️"
+
+    ACTUAL_THUMB = "Your actual thumbnail"
+
+    START_TEXT = """
+Hi **{}** 👋, I'm **Unarchiver bot** 🥰
+
+
+I can extract archives like `zip`, `rar`, `tar`, …
+
+**Made with ❤️ by @EDM115bots**
+
+**/donate** if you can 🥺
+    """
+
+    HELP_TXT = """
+**• How to extract 🤔**
+
+    **1)** Send the file or link that you want to extract
+    **2)** Click on extract button (If you sent a link use `🔗` button. If it's a file just use `🗂️` button)
+
+
+**• How to change upload mode 🤔**
+    Send **/mode**
+
+
+**Note :**
+    **1.** If your archive is password protected select `🔐` button
+    **2.** Please don’t send corrupted files ! If you sent one by mistake just send **/clean**
+    **3.** If your archive have +95 files in it then bot can’t show all of extracted files to select from (yet). So in that case if you can’t see your file in the buttons just click on `Upload all 📤` button. It will send all extracted files to you !
+
+
+**• Got an error ?**
+    Visit edm115.eu.org/unzip#help
+
+
+**• I wanna have help 🥺**
+
+    PM me at **@EDM115** or join the chat **@EDM115_chat**
+    """
+
+    ABOUT_TXT = """
+**About Unarchiver bot [v6.3.2]**
+
+• **Language :** [Python 3.11.5](https://www.python.org/)
+• **Framework :** [Pyrogram 2.0.106](https://pyrogram.org/)
+• **Source code :** [EDM115/unzip-bot](https://github.com/EDM115/unzip-bot)
+• **Developer :** [EDM115](https://github.com/EDM115)
+
+**[Rate me ⭐](https://t.me/BotsArchive/2705)**
+Made with ❤️ by **@EDM115bots**
+    """
+
+    DONATE_TEXT = """
+I'm going to be honest : **this bot costs me money**…
+Nothing's free on this world, however I try to keep this bot for free for as many people as possible
+I don't like to put restrictions, nor getting your PM's flooded with ads…
+
+So if you can, donate :)
+It helps out a ton, covers the costs (hosting, updating, … 👨‍💻)
+
+--How ?--
+• **[Paypal](https://www.paypal.me/8EDM115)**
+• **[GitHub Sponsors](https://github.com/sponsors/EDM115)**
+• **[Directly in Telegram](https://t.me/EDM115bots/544)**
+• **[BuyMeACoffee](https://www.buymeacoffee.com/edm115)**
+• **[Send cryptos (not recommended)](https://edm115.shadd.eu.org/)**
+
+Thanks for your contribution 😊
+
+--Side note :--
+Donation doesn't count as a VIP subscription. Check **/vip** for more info
+    """
+
+    VIP_INFO = """
+Wanna help the developer of this __amazing__ bot ?
+Here's how : Become a VIP user and benefit from extra perks !
+
+**VIP perks :**
+- No max tasks limit
+- No AFK timeout
+- Get a better support
+- Upload files up to 4Gb
+- Early access to new features
+- Access a second bot exclusive to VIPs __(subject to conditions)__
+- And more…
+
+**What's the price ?**
+- `1$/month`
+- `10$/year`
+
+**How to become a VIP ?**
+1) Send **/pay** to the bot
+2) Choose your subscription
+3) Send a screenshot of your payment to **@EDM115**
+4) Enjoy your VIP perks !
+
+**What happens when my subscription ends ?**
+If you choosed GitHub Sponsors, Telegram Donate or BuyMeACoffee, you will be automatically renewed until you cancel it
+If you choosed PayPal, you will have to redo the 4 above steps
+You will be notified few days before you subscription ends so you can check if you want to renew it or not
+
+**I wanna cancel my subscription**
+Just send **/stoppay** and follow the instructions according to the platform you selected
+Your payment will be cancelled and you will keep your VIP perks until the end of your subscription
+(i.e. if you paid for 1 month, from 05/01/2024 to 05/02/2024 and you cancel your subscription on 15/01/2024, your perks will stay until 05/02/2024)
+
+**What is the referral system ?**
+Referrals have benefits for both sides :)
+- For the referrer : you get 1 month of VIP for free for each 3 new VIPs you bring
+- For the referred : you get 1 month of VIP for free if you take the monthly subscription, and 3 months for free if you take the yearly subscription
+How to input the referral code ? Just send **/pay** to the bot and follow the instructions
+    """
+
+    VIP_REQUIRED_MESSAGE = """
+Use this command as a reply to a messsage, where you have the following (ONE PER LINE) :
+The user ID (int)
+When the subscription starts (in %Y-%m-%dT%H:%M:%SZ format)
+When the subscription ends (same)
+Which platform had been used [paypal, telegram, sponsor, bmac]
+At which frequency the user is billed [monthly, yearly]
+Is the user a early supporter (can be obtained only the first 3 months) [True, False]
+Is the user also a donator [True, False]
+When does the user ever started a subscription (date)
+How many successful payments had been done (int)
+Is there been any gap between payments [True, False]
+If the user had been gifted a Premium plan [True, False]
+The user referral code (str)
+Is this a lifetime free subscription [True, False]
+    """
+
+    VIP_ADDED_USER = """
+The following user had been added with the following infos :
+User ID : `{}`
+Start date : `{}`
+End date : `{}`
+Platform : `{}`
+Frequency : `{}`
+Early supporter : `{}`
+Donator : `{}`
+First subscription date : `{}`
+Successful payments : `{}`
+Gap between payments : `{}`
+Gifted : `{}`
+Referral code : `{}`
+Lifetime : `{}`
+    """
+
+    CLEAN_TXT = """
+**Are sure want to clean your task 🤔**
+
+Note : This action cannot be undone !
+    """
+
+    SELECT_UPLOAD_MODE_TXT = """
+Select your upload mode 👇
+
+**Current upload mode is :** `{}`
+    """
+
+    CHANGED_UPLOAD_MODE_TXT = "**Successfully changed upload mode to** `{}` ✅"
+
+    EXISTING_THUMB = """
+A thumbnail already have been saved 😅 What you wanna do ?
+• Checking the actual thumbnail
+• Replace it with the new one you just sent
+• Cancel
+    """
+
+    SAVING_THUMB = "Are you sure you want to save this thumbnail 🤔"
+
+    SAVED_THUMBNAIL = "**Successfully saved this thumbnail ✅**"
+
+    DEL_CONFIRM_THUMB = """
+Do you really want to delete your thumbnail ?
+• Check the actual thumbnail
+• Delete it
+• Cancel
+"""
+
+    DEL_CONFIRM_THUMB_2 = "Do you really want to delete your thumbnail ?"
+
+    DELETED_THUMB = "**Successfully removed your thumbnail ✅**"
+
+    ERROR_THUMB_RENAME = "Error on thumb rename"
+
+    ERROR_THUMB_UPDATE = "Error while updating thumb URL on DB"
+
+    ERROR_TELEGRAPH_UPLOAD = "Error on Telegra.ph upload"
+
+    ERROR_THUMB_DEL = "Error on thumb deletion in DB : {}"
+
+    AFTER_OK_DL_TXT = """
+**Successfully downloaded ✅**
+
+**Download time :** `{}`
+**Status :** Testing the archive… Please wait
+    """
+
+    AFTER_OK_MERGE_DL_TXT = """
+**Successfully downloaded all {} files ✅**
+
+**Download time :** `{}`
+**Status :** Merging the archive… Please wait
+    """
+
+    AFTER_OK_MERGE_TXT = """
+**Successfully merged ✅**
+
+**Merge time :** `{}`
+**Status :** Processing the archive… Please wait
+    """
+
+    AFTER_OK_TEST_TXT = """
+**Successfully tested ✅**
+
+**Test time :** `{}`
+**Status :** Extracting the archive… Please wait
+    """
+
+    EXT_OK_TXT = """
+**Extraction successful ✅**
+
+**Extraction time :** `{}`
+**Status :** Processing the extracted files… Please wait
+    """
+
+    ERROR_TXT = """
+**Error happened 😕**
+
+`{}`
+
+Please report this at @EDM115_chat if you think this is a serious error
+    """
+
+    CANCELLED_TXT = "**{} ✅**"
+
+    DL_STOPPED = "✅ The download of your file have successfully been cancelled 😌"
+
+    PROCESSING_TASK = "**✅ Processing your task… Please wait**"
+
+    ERROR_GET_MSG = "Error on getting messages from user : {}"
+
+    PROCESS_MSGS = "**Processing {} messages… Please wait**"
+
+    DL_FILES = """
+**Trying to download file {}/{}… Please wait**
+
+    """
+
+    PROCESS_MERGE = """
+Processing an user query…
+
+User ID : {}
+Task : #Merge
+
+File : {}
+    """
+
+    PLS_SEND_PASSWORD = "**Please send me the password 🔑**"
+
+    PASSWORD_PROTECTED = "That archive is password protected 😡 **Don't fool me !**    "
+
+    SELECT_FILES = "Select files to upload 👇"
+
+    UNABLE_GATHER_FILES = """
+Unable to gather the files to upload 😥
+Choose either to upload everything, or cancel the process
+    """
+
+    FATAL_ERROR = "Fatal error : uncorrect archive format"
+
+    USER_QUERY = """
+Processing an user query…
+
+User ID : {}
+    """
+
+    INVALID_URL = "That's not a valid url 💀"
+
+    NOT_AN_ARCHIVE = """
+That's not an archive 💀
+
+**Try to @transload it**
+    """
+
+    DEF_NOT_AN_ARCHIVE = """
+This file is NOT an archive 😐
+If you believe it's an error, send the file to **@EDM115**
+    """
+
+    PROCESSING2 = "`Processing… ⏳`"
+
+    UNZIP_HTTP = "Can't use unzip_http on {} : {}"
+
+    ERR_DL = "Error on download : {}"
+
+    CANT_DL_URL = "**Sorry, I can't download that URL 😭 Try to @transload it**"
+
+    GIVE_ARCHIVE = "Give me an archive to extract 😐"
+
+    ITS_SPLITTED = """
+This file is splitted
+Use the **/merge** command
+    """
+
+    SPL_RZ = "Splitted RAR/ZIP files in .rxx or .zxx format can't be processed yet"
+
+    TRY_DL = """
+**Trying to download… Please wait**
+
+    """
+
+    QUERY_PARSE_ERR = """
+Fatal query parsing error 💀
+
+Please contact @EDM115_chat with details and screenshots
+    """
+
+    GIVE_NEW_NAME = """
+Current file name : `{}`
+
+Please send the new file name (**--INCLUDE THE FILE EXTENTION !--**)
+    """
+
+    SPLITTING = "**Splitting {}… Please wait**"
+
+    ERR_SPLIT = "An error occured while splitting a file above 2 Gb 😥"
+
+    SEND_ALL_PARTS = "Trying to send all parts of {} to you… Please wait"
+
+    UPLOADED = """
+**Successfully uploaded ✅**
+
+**Join @EDM115bots ❤️**
+    """
+
+    NO_FILE_LEFT = "There's no file left to upload"
+
+    SENDING_FILE = "Sending that file to you… Please wait"
+
+    SEND_ALL_FILES = "Trying to send all files to you… Please wait"
+
+    REFRESHING = "Refreshing… ⏳"
+
+    CANCELLED = "**Cancelled successfully ✅**"
+
+    PROCESS_CANCELLED = "❌ Process cancelled"
+
+# commands.py
+
+    PROCESS_RUNNING = """
+Already one process is running, don't spam 😐
+
+Wanna clear your files from my server ? Then just send **/clean** command
+    """
+
+    SPLIT_NOPE = "Those type of splitted files can't be processed yet"
+
+    UNVALID = "Send a valid archive/URL"
+
+    MERGE = """
+You have splitted archives to process ?
+Send me **all** the splitted files (.001, .002, .00×, …)
+
+**AFTER** you sent them all, send **/done** and click on the `Merge 🛠️` button
+    """
+
+    DONE = """
+If you have sent **ALL** the files, you can click on the `Merge 🛠️` button below
+
+If you sent /done by mistake and haven't sent all the files yet, just ignore this message and re-send **/done** when ALL the files are sent
+    """
+
+    STATS = """
+**💫 Current bot stats 💫**
+
+**💾 Disk usage :**
+ ↳ **Total Disk Space :** `{}`
+ ↳ **Used :** `{} - {}%`
+ ↳ **Free :** `{}`
+ ↳ **Ongoing tasks :** `{}`
+
+**🎛 Hardware usage :**
+ ↳ **CPU usage :** `{}%`
+ ↳ **RAM usage :** `{}%`
+ ↳ **Uptime :** `{}`
+    """
+
+    STATS_OWNER = """
+**💫 Current bot stats 💫**
+
+**👥 Users :**
+ ↳ **Users in database :** `{}`
+ ↳ **Total banned users :** `{}`
+
+**💾 Disk usage :**
+ ↳ **Total Disk Space :** `{}`
+ ↳ **Used :** `{} - {}%`
+ ↳ **Free :** `{}`
+ ↳ **Ongoing tasks :** `{}`
+
+**🌐 Network usage :**
+ ↳ **Uploaded :** `{}`
+ ↳ **Downloaded :** `{}`
+
+**🎛 Hardware usage :**
+ ↳ **CPU usage :** `{}%`
+ ↳ **RAM usage :** `{}%`
+ ↳ **Uptime :** `{}`
+    """
+
+    BC_REPLY = "Reply to a message to broadcast it 📡"
+
+    BC_START = """
+Broadcasting has started, this may take a while 😪
+
+Users : {}/{}
+    """
+
+    BC_DONE = """
+**Broadcast completed ✅**
+
+**Total users :** `{}`
+**Successful responses :** `{}`
+**Failed responses :** `{}`
+    """
+
+    SEND_REPLY = "Reply to a message to send it 📡"
+
+    PROVIDE_UID = "Please provide an user ID"
+
+    PROVIDE_UID2 = "Please provide an user ID/username"
+
+    SENDING = "Sending it, please wait… 😪"
+
+    SEND_SUCCESS = "Message successfully sent to `{}`"
+
+    SEND_FAILED = """
+It failed 😣 Retry
+
+If it fails again, it means that {} haven't started the bot yet (or deleted the chat), or he's private/banned/whatever
+    """
+
+    REPORT_REPLY = "Reply to a message to report it to @EDM115"
+
+    REPORT_DONE = """
+Report sucessfully sent ! An answer will arrive soon
+
+Note : if you need to reply to replies, always use that /report command (or join **@EDM115_chat**)
+    """
+
+    BAN_ID = "Give an user id to ban 😈"
+
+    ALREADY_BANNED = """
+{} have already been banned
+
+
+    """
+
+    ALREADY_REMOVED = "{} have already been removed from the user database"
+
+    BANNED = """
+**Successfully banned that user ✅**
+
+**User ID :** `{}`
+    """
+
+    UNBAN_ID = "Give an user id to unban 😇"
+
+    ALREADY_ADDED = """
+{} is already in the user database
+
+
+    """
+
+    ALREADY_UNBANNED = "{} have already been deleted from banned users database"
+
+    UNBANNED = """
+**Successfully unbanned that user ✅**
+
+**User ID :** `{}`
+    """
+
+    INFO = "Send a text (shorter possible) from any user/chat. And you will have infos about it 👀"
+
+    USER = "This is a WIP command that would allow you to get more stats about your utilisation of me 🤓"
+
+    UNABLE_FETCH = "Unable to fetch"
+
+    USER_INFO = """
+**User ID :** `{}`
+`{}` files uploaded
+…
+
+WIP
+    """
+
+    UID_UNAME_INVALID = "Error happened, The user ID/username is probably invalid"
+
+    USER2_INFO = """
+`{}`
+
+**Direct link to profile :** tg://user?id={}
+    """
+
+    MAINTENANCE = """
+Do you want the bot to go in maintenance mode 🤔
+Current state : `{}`
+    """
+
+    MAINTENANCE_ASK = """
+False : No maintenance
+True : Maintenance
+Send the appropriate string
+    """
+
+    MAINTENANCE_DONE = "Successfully changed maintenance mode to `{}`"
+
+    MAINTENANCE_ON = "Maintenance mode is currently **ON**\nTasks can't be processed. Come back later"
+
+    MAINTENANCE_FAIL = "Provide one of the values"
+
+    NO_THUMBS = "No thumbnails on the server yet"
+
+    ERASE_ALL = """
+🚧 WIP 🚧
+
+**Cleaning…**
+    """
+
+    CLEANED = "The whole server have been cleaned 😌"
+
+    NOT_CLEANED = "An error happened during /cleanall 😕"
+
+    ERASE_TASKS = "Deleting {} tasks… Please wait"
+
+    ERASE_TASKS_SUCCESS = "Successfully deleted {} tasks ✅"
+
+    LOG_SENT = "Log file sent to {}"
+
+    DELETED_FOLDER = "Deleted {} folder successfully"
+
+    RESTARTED_AT = "**ℹ️ Bot restarted successfully at **`{}`"
+
+    RESTARTING = "{} : Restarting…"
+
+    PULLING = "Pulling updates… ⌛"
+
+    PULLED = "✅ Pulled changes, restarting…"
+
+    NO_PULL = "Nothing to pull 😅"
+
+    COMMANDS_LIST = """
+Here is the list of the commands you can use (only in private btw) :
+
+**{send any file or URL}** : Prompt the extract dialog
+**/start** : To know if I'm online
+**/help** : Gives a simple help
+**/about** : Know more about me
+**/donate** : Know how you can contribute to this bot
+**/clean** : Remove your files from my server. Also useful if a task failed
+**/mode** : Change your upload mode (either `doc` or `media`)
+**/stats** : Know all the current stats about me. If you're running on Heroku, it's reset every day
+**/merge** : Merge splitted archives together
+**/done** : After you sent all the splitted archives, use this to merge them
+**/info** : Get full info about a [Message](https://docs.pyrogram.org/api/types/Message) (info returned by Pyrogram)
+**/addthumb** : Upload with a custom thumbnail (not permanant yet)
+**/delthumb** : Removes your thumbnail
+**/report** : Used by replying to a message, sends it to the bot owner (useful for bug report, or any question)
+**/commands** : This message
+
+**/admincmd** : Only if you are the Owner
+    """
+
+    ADMINCMD = """
+Here's all the commands that only the owner (you) can use :
+
+**/gitpull** : Pulls the latest changes from GitHub
+**/broadcast** : Send something to all the users
+**/sendto {user_id}** : Same as broadcast but for a single user. Don't handle replies for now…
+**/ban {user_id}** : Ban an user. He no longer can use your bot, except if…
+**/unban {user_id}** : …you unban him. All his stats and settings stays saved after a ban
+**/user {user_id}** : Know more about the use of your bot by a single user
+**/user2 {user_id}** : Get full info about an [User](https://docs.pyrogram.org/api/types/User) (info returned by Pyrogram)
+**/self** : Get full info about me (info returned by Pyrogram)
+**/redbutton** : Will fully restart bot + server
+**/cleanall** : Same as `/clean`, but for the whole server
+**/logs** : Send you the logs (all of them). Useful for bug tracking. Send them to **@EDM115** if you don't understand them/need help
+**/restart** : Does a basic restart, less intrusive as the `/redbutton` one
+**/dbexport** : Exports the whole database as CSV
+**/admincmd** : This message
+**/commands** : For all the other commands
+    """
+
+# cloud_upload.py
+
+    ERROR_UP_BAYFILES = "Error happened on BayFiles upload (check connection, or retry later)"
+
+# custom_thumbnail.py
+
+    ALBUM = "{} tried to save a thumbnail from an album"
+
+    ALBUM_NOPE = "You can't use an album. Reply to a single picture sent as photo (not as document)"
+
+    DL_THUMB = "Downloading thumbnail of {}…"
+
+    THUMB_SAVED = "Thumbnail saved"
+
+    THUMB_FAILED = "Failed to generate thumb"
+
+    THUMB_ERROR = "Error happened 😕 Try again later"
+
+    NO_THUMB = "You already have no thumbnail 😅"
+
+# ext_helper.py
+
+    UP_ALL = "Upload all 📤"
+
+    CANCEL_IT = "❌ Cancel"
+
+# up_helper.py
+
+    TRY_UP = """
+**Trying to upload {}… Please wait**
+
+    """
+
+    CANT_FIND = "Sorry ! I can't find that file {} 💀"
+
+    TOO_LARGE = "URL file is too large to send in telegram 😥"
+
+    ARCHIVE_GONE = "Archive has gone from servers before uploading 😥"
+
+    EMPTY_FILE = "The file {} is empty/unreachable"
+
+    CHECK_MSG = """
+**Verifying the file… Please wait**
+
+    """
+
+
+# List of error messages from p7zip
+ERROR_MSGS = ["Error", "Can't open as archive"]
+
+
+# Inline buttons
+class Buttons:
+    START_BUTTON = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(Messages.HELP, callback_data="helpcallback"),
+                InlineKeyboardButton(Messages.ABOUT, callback_data="aboutcallback"),
+            ],
+            [
+                InlineKeyboardButton(Messages.STATS_BTN, callback_data="statscallback"),
+                InlineKeyboardButton(Messages.DONATE, callback_data="donatecallback"),
+            ]
+        ]
+    )
+
+    REFRESH_BUTTON = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(Messages.REFRESH, callback_data="statscallback|refresh"),
+                InlineKeyboardButton(Messages.BACK, callback_data="megoinhome"),
+            ]
+        ]
+    )
+
+    CHOOSE_E_F__BTNS = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(
+                    "🗂️", callback_data="extract_file|tg_file|no_pass"
+                ),
+                InlineKeyboardButton(
+                    "🔐", callback_data="extract_file|tg_file|with_pass"
+                ),
+            ],
+            [
+                InlineKeyboardButton("🖼️", callback_data="extract_file|tg_file|thumb"),
+                InlineKeyboardButton(
+                    "🖼️✏", callback_data="extract_file|tg_file|thumbrename"
+                ),
+            ],
+            [InlineKeyboardButton("❌", callback_data="cancel_dis")],
+        ]
+    )
+
+    CHOOSE_E_F_M__BTNS = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(
+                    "🗂️", callback_data="merged|no_pass"
+                ),
+                InlineKeyboardButton(
+                    "🔐", callback_data="merged|with_pass"
+                ),
+            ],
+            [InlineKeyboardButton("❌", callback_data="cancel_dis")],
+        ]
+    )
+
+    CHOOSE_E_U__BTNS = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton("🔗", callback_data="extract_file|url|no_pass"),
+                InlineKeyboardButton("🔐", callback_data="extract_file|url|with_pass"),
+            ],
+            [
+                InlineKeyboardButton("🖼️", callback_data="extract_file|url|thumb"),
+                InlineKeyboardButton(
+                    "🖼️✏", callback_data="extract_file|url|thumbrename"
+                ),
+            ],
+            [InlineKeyboardButton("❌", callback_data="cancel_dis")],
+        ]
+    )
+
+    RENAME = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton("✏", callback_data="renameit"),
+                InlineKeyboardButton("🙅‍♂️", callback_data="norename"),
+            ]
+        ]
+    )
+
+    CLN_BTNS = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(Messages.CLEAN, callback_data="cancel_dis"),
+                InlineKeyboardButton(Messages.CANCEL_IT, callback_data="nobully"),
+            ]
+        ]
+    )
+
+    ME_GOIN_HOME = InlineKeyboardMarkup(
+        [[InlineKeyboardButton(Messages.BACK, callback_data="megoinhome")]]
+    )
+
+    SET_UPLOAD_MODE_BUTTONS = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(Messages.AS_DOC, callback_data="set_mode|doc"),
+                InlineKeyboardButton(Messages.AS_MEDIA, callback_data="set_mode|media")
+            ],
+        ]
+    )
+
+    I_PREFER_STOP = InlineKeyboardMarkup(
+        [[InlineKeyboardButton(Messages.CANCEL_IT, callback_data="canceldownload")]]
+    )
+
+    MERGE_THEM_ALL = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(Messages.MERGE_BTN, callback_data="merge_this"),
+                InlineKeyboardButton(Messages.CANCEL_IT, callback_data="cancel_dis"),
+            ]
+        ]
+    )
+
+    THUMB_REPLACEMENT = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(Messages.CHECK, callback_data="check_thumb"),
+                InlineKeyboardButton(Messages.REPLACE, callback_data="save_thumb|replace"),
+            ],
+            [InlineKeyboardButton(Messages.CANCEL_IT, callback_data="nope_thumb")],
+        ]
+    )
+
+    THUMB_FINAL = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(Messages.REPLACE, callback_data="save_thumb|replace"),
+                InlineKeyboardButton(Messages.CANCEL_IT, callback_data="nope_thumb"),
+            ]
+        ]
+    )
+
+    THUMB_SAVE = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(Messages.SAVE, callback_data="save_thumb|save"),
+                InlineKeyboardButton(Messages.CANCEL_IT, callback_data="nope_thumb"),
+            ]
+        ]
+    )
+
+    THUMB_DEL = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(Messages.CHECK, callback_data="check_before_del"),
+                InlineKeyboardButton(Messages.DELETE, callback_data="del_thumb"),
+            ],
+            [InlineKeyboardButton(Messages.CANCEL_IT, callback_data="nope_thumb")],
+        ]
+    )
+
+    THUMB_DEL_2 = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(Messages.DELETE, callback_data="del_thumb"),
+                InlineKeyboardButton(Messages.CANCEL_IT, callback_data="nope_thumb")
+            ],
+        ]
+    )
+
+    RATE_ME = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(Messages.RATE, url="https://t.me/BotsArchive/2705"),
+                InlineKeyboardButton(Messages.DONATE, callback_data="donatecallback")
+            ],
+        ]
+    )

unzipper/modules/callbacks.py

@@ -0,0 +1,1233 @@
+# Copyright (c) 2023 EDM115
+import asyncio
+import concurrent.futures
+import os
+import re
+import shutil
+from fnmatch import fnmatch
+from time import time
+from urllib.parse import unquote
+
+from aiofiles import open as openfile
+from aiohttp import ClientSession, InvalidURL
+from pyrogram import Client
+from pyrogram.errors import ReplyMarkupTooLong
+from pyrogram.types import CallbackQuery
+import unzip_http
+
+from config import Config
+from unzipper import LOGGER, unzipperbot
+from unzipper.helpers.database import (
+    add_cancel_task,
+    del_cancel_task,
+    del_merge_task,
+    del_thumb_db,
+    get_cancel_task,
+    get_maintenance,
+    get_merge_task_message_id,
+    get_ongoing_tasks,
+    set_upload_mode,
+    update_thumb,
+    update_uploaded,
+    upload_thumb,
+    add_ongoing_task,
+    del_ongoing_task,
+    count_ongoing_tasks,
+)
+from unzipper.helpers.unzip_help import (
+    TimeFormatter,
+    extentions_list,
+    humanbytes,
+    progress_for_pyrogram,
+)
+
+from .bot_data import ERROR_MSGS, Buttons, Messages
+from .commands import https_url_regex, get_stats
+from .ext_script.custom_thumbnail import silent_del
+from .ext_script.ext_helper import (
+    _test_with_7z_helper,
+    extr_files,
+    get_files,
+    make_keyboard,
+    make_keyboard_empty,
+    merge_files,
+    split_files,
+)
+from .ext_script.up_helper import answer_query, get_size, send_file, send_url_logs
+from .ext_script.url_parser import gdrive_dl
+
+split_file_pattern = r"\.(?:z\d+|r\d{2})$"
+rar_file_pattern = r"\.part\d+\.rar$"
+telegram_url_pattern = r"(?:http[s]?:\/\/)?(?:www\.)?t\.me\/([a-zA-Z0-9_]+)\/(\d+)"
+
+
+async def download(url, path):
+    try:
+        async with ClientSession() as session, session.get(url, timeout=None, allow_redirects=True) as resp, openfile(path, mode="wb") as file:
+            async for chunk in resp.content.iter_chunked(Config.CHUNK_SIZE):
+                await file.write(chunk)
+        await session.close()
+    except InvalidURL:
+        LOGGER.error(Messages.INVALID_URL)
+    except:
+        LOGGER.error(Messages.ERR_DL.format(url))
+
+
+async def download_with_progress(url, path, message, unzip_bot):
+    async with ClientSession() as session, session.get(url, timeout=None, allow_redirects=True) as resp, openfile(path, mode="wb") as file:
+        total_size = int(resp.headers.get("Content-Length", 0))
+        current_size = 0
+        start_time = time()
+
+        async for chunk in resp.content.iter_chunked(Config.CHUNK_SIZE):
+            if message.from_user is not None and await get_cancel_task(message.from_user.id):
+                await session.close()
+                await message.edit(text=Messages.DL_STOPPED)
+                await del_cancel_task(message.from_user.id)
+                return False
+
+            await file.write(chunk)
+            current_size += len(chunk)
+            await progress_for_pyrogram(current_size, total_size, Messages.DL_URL.format(url), message, start_time, unzip_bot)
+
+    await session.close()
+
+
+def get_zip_http(url):
+    rzf = unzip_http.RemoteZipFile(url)
+    paths = rzf.namelist()
+    return rzf, paths
+
+
+async def async_generator(iterable):
+    for item in iterable:
+        yield item
+
+
+# Callbacks
+@unzipperbot.on_callback_query()
+async def unzipper_cb(unzip_bot: Client, query: CallbackQuery):
+    uid = query.from_user.id
+    if uid != Config.BOT_OWNER:  # skipcq: PTC-W0048
+        if await count_ongoing_tasks() >= Config.MAX_CONCURRENT_TASKS:
+            ogtasks = await get_ongoing_tasks()
+            if not any(ogtask["user_id"] == uid for ogtask in ogtasks):
+                await unzip_bot.send_message(
+                    chat_id=uid,
+                    text=Messages.MAX_TASKS.format(Config.MAX_CONCURRENT_TASKS),
+                )
+                return
+
+    if uid != Config.BOT_OWNER and await get_maintenance():
+        await answer_query(query, Messages.MAINTENANCE_ON)
+        return
+
+    sent_files = 0
+    global log_msg
+
+    if query.data == "megoinhome":
+        await query.edit_message_text(
+            text=Messages.START_TEXT.format(query.from_user.mention),
+            reply_markup=Buttons.START_BUTTON,
+        )
+
+    elif query.data == "helpcallback":
+        await query.edit_message_text(
+            text=Messages.HELP_TXT,
+            reply_markup=Buttons.ME_GOIN_HOME
+        )
+
+    elif query.data == "aboutcallback":
+        await query.edit_message_text(
+            text=Messages.ABOUT_TXT,
+            reply_markup=Buttons.ME_GOIN_HOME,
+            disable_web_page_preview=True,
+        )
+
+    elif query.data == "donatecallback":
+        await query.edit_message_text(
+            text=Messages.DONATE_TEXT,
+            reply_markup=Buttons.ME_GOIN_HOME,
+            disable_web_page_preview=True,
+        )
+
+    elif query.data.startswith("statscallback"):
+        if query.data.endswith("refresh"):
+            await query.edit_message_text(text=Messages.REFRESH_STATS)
+        text_stats = await get_stats(query.from_user.id)
+        await query.edit_message_text(
+            text=text_stats,
+            reply_markup=Buttons.REFRESH_BUTTON,
+        )
+
+    elif query.data == "canceldownload":
+        await add_cancel_task(query.from_user.id)
+
+    elif query.data == "check_thumb":
+        user_id = query.from_user.id
+        thumb_location = Config.THUMB_LOCATION + "/" + str(user_id) + ".jpg"
+        await unzip_bot.send_photo(
+            chat_id=user_id,
+            photo=thumb_location,
+            caption=Messages.ACTUAL_THUMB
+        )
+        await unzip_bot.delete_messages(
+            chat_id=user_id,
+            message_ids=query.message.id
+        )
+        await unzip_bot.send_message(
+            chat_id=user_id,
+            text=Messages.EXISTING_THUMB,
+            reply_markup=Buttons.THUMB_FINAL,
+        )
+
+    elif query.data == "check_before_del":
+        user_id = query.from_user.id
+        thumb_location = Config.THUMB_LOCATION + "/" + str(user_id) + ".jpg"
+        await unzip_bot.send_photo(
+            chat_id=user_id,
+            photo=thumb_location,
+            caption=Messages.ACTUAL_THUMB
+        )
+        await unzip_bot.delete_messages(
+            chat_id=user_id,
+            message_ids=query.message.id
+        )
+        await unzip_bot.send_message(
+            chat_id=user_id,
+            text=Messages.DEL_CONFIRM_THUMB_2,
+            reply_markup=Buttons.THUMB_DEL_2,
+        )
+
+    elif query.data.startswith("save_thumb"):
+        user_id = query.from_user.id
+        replace = query.data.split("|")[1]
+        if replace == "replace":
+            await silent_del(user_id)
+        thumb_location = Config.THUMB_LOCATION + "/" + str(user_id) + ".jpg"
+        final_thumb = Config.THUMB_LOCATION + "/waiting_" + str(user_id) + ".jpg"
+        try:
+            os.rename(final_thumb, thumb_location)
+        except:
+            LOGGER.warning(Messages.ERROR_THUMB_RENAME)
+        try:
+            thumb_url = await upload_thumb(thumb_location)
+            try:
+                if thumb_url != -1 and re.match(https_url_regex, thumb_url):
+                    await update_thumb(query.from_user.id, thumb_url, force=True)
+            except:
+                LOGGER.error(Messages.ERROR_THUMB_UPDATE)
+        except:
+            LOGGER.error(Messages.ERROR_TELEGRAPH_UPLOAD)
+        await answer_query(query, Messages.SAVED_THUMBNAIL)
+
+    elif query.data == "del_thumb":
+        user_id = query.from_user.id
+        thumb_location = Config.THUMB_LOCATION + "/" + str(user_id) + ".jpg"
+        try:
+            await del_thumb_db(user_id)
+        except Exception as e:
+            LOGGER.error(Messages.ERROR_THUMB_DEL.format(e))
+        try:
+            os.remove(thumb_location)
+        except:
+            pass
+        await query.edit_message_text(text=Messages.DELETED_THUMB)
+
+    elif query.data == "nope_thumb":
+        user_id = query.from_user.id
+        del_1 = Config.THUMB_LOCATION + "/not_resized_" + str(user_id) + ".jpg"
+        del_2 = Config.THUMB_LOCATION + "/waiting_" + str(user_id) + ".jpg"
+        try:
+            os.remove(del_1)
+        except:
+            pass
+        try:
+            os.remove(del_2)
+        except:
+            pass
+        await query.edit_message_text(
+            text=Messages.CANCELLED_TXT.format(Messages.PROCESS_CANCELLED))
+
+    elif query.data.startswith("set_mode"):
+        user_id = query.from_user.id
+        mode = query.data.split("|")[1]
+        await set_upload_mode(user_id, mode)
+        await answer_query(
+            query,
+            Messages.CHANGED_UPLOAD_MODE_TXT.format(mode)
+        )
+
+    elif query.data == "merge_this":
+        user_id = query.from_user.id
+        m_id = query.message.id
+        start_time = time()
+        await add_ongoing_task(user_id, start_time, "merge")
+        s_id = await get_merge_task_message_id(user_id)
+        merge_msg = await query.message.edit(Messages.PROCESSING_TASK)
+        download_path = f"{Config.DOWNLOAD_LOCATION}/{user_id}/merge"
+        if s_id and (m_id - s_id) > 1:
+            files_array = list(range(s_id, m_id))
+            try:
+                messages_array = await unzip_bot.get_messages(user_id, files_array)
+            except Exception as e:
+                LOGGER.error(Messages.ERROR_GET_MSG.format(e))
+                await answer_query(query, Messages.ERROR_TXT.format(e))
+                await del_ongoing_task(user_id)
+                await del_merge_task(user_id)
+                try:
+                    shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{user_id}")
+                except:
+                    pass
+                return
+            length = len(messages_array)
+            if not os.path.isdir(download_path):
+                os.makedirs(download_path)
+            rs_time = time()
+            newarray = []
+            await merge_msg.edit(Messages.PROCESS_MSGS.format(length))
+            for message in messages_array:
+                if message.document is None:
+                    pass
+                else:
+                    if message.from_user.id == user_id:  # avoid getting files from other users, tho idk why this could happen
+                        newarray.append(message)
+            length = len(newarray)
+            if length == 0:
+                await answer_query(query, Messages.NO_MERGE_TASK)
+                await del_ongoing_task(user_id)
+                await del_merge_task(user_id)
+                try:
+                    shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{user_id}")
+                except:
+                    pass
+                return
+            i = 0
+            async_newarray = async_generator(newarray)
+            async for message in async_newarray:
+                i += 1
+                fname = message.document.file_name
+                await message.forward(chat_id=Config.LOGS_CHANNEL)
+                location = f"{download_path}/{fname}"
+                s_time = time()
+                await message.download(
+                    file_name=location,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Messages.DL_FILES.format(i, length),
+                        merge_msg,
+                        s_time,
+                        unzip_bot,
+                    ),
+                )
+            e_time = time()
+            dltime = TimeFormatter(round(e_time - rs_time) * 1000)
+            if dltime == "":
+                dltime = "1 s"
+            await merge_msg.edit(Messages.AFTER_OK_MERGE_DL_TXT.format(i, dltime))
+            await merge_msg.edit(
+                text=Messages.CHOOSE_EXT_MODE_MERGE,
+                reply_markup=Buttons.CHOOSE_E_F_M__BTNS,
+            )
+            await del_merge_task(user_id)
+        else:
+            await answer_query(query, Messages.NO_MERGE_TASK)
+            await del_ongoing_task(user_id)
+            await del_merge_task(user_id)
+            try:
+                shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{user_id}")
+            except:
+                pass
+
+    elif query.data.startswith("merged"):
+        user_id = query.from_user.id
+        download_path = f"{Config.DOWNLOAD_LOCATION}/{user_id}/merge"
+        ext_files_dir = f"{Config.DOWNLOAD_LOCATION}/{user_id}/extracted"
+        os.makedirs(ext_files_dir)
+        try:
+            files = await get_files(download_path)
+            file = files[0]
+        except IndexError:
+            await answer_query(query, Messages.NO_MERGE_TASK)
+            await del_ongoing_task(user_id)
+            await del_merge_task(user_id)
+            try:
+                shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{user_id}")
+            except:
+                pass
+            return
+        splitted_data = query.data.split("|")
+        log_msg = await unzip_bot.send_message(
+            chat_id=Config.LOGS_CHANNEL,
+            text=Messages.PROCESS_MERGE.format(user_id, ".".join(file.split("/")[-1].split(".")[:-1])),
+        )
+        try:
+            await query.message.edit(Messages.PROCESSING_TASK)
+        except:
+            pass
+        if splitted_data[1] == "with_pass":
+            password = await unzip_bot.ask(
+                chat_id=query.message.chat.id,
+                text=Messages.PLS_SEND_PASSWORD,
+            )
+            ext_s_time = time()
+            extractor = await merge_files(
+                iinput=file,
+                ooutput=ext_files_dir,
+                password=password.text,
+            )
+            ext_e_time = time()
+        else:
+            # Can't test the archive apparently
+            ext_s_time = time()
+            extractor = await merge_files(iinput=file, ooutput=ext_files_dir)
+            ext_e_time = time()
+        # Checks if there is an error happened while extracting the archive
+        if any(err in extractor for err in ERROR_MSGS):
+            try:
+                await query.message.edit(Messages.EXT_FAILED_TXT)
+                shutil.rmtree(ext_files_dir)
+                shutil.rmtree(download_path)
+                await del_ongoing_task(user_id)
+            except:
+                try:
+                    await query.message.delete()
+                except:
+                    pass
+                await unzip_bot.send_message(
+                    chat_id=query.message.chat.id,
+                    text=Messages.EXT_FAILED_TXT
+                )
+                shutil.rmtree(ext_files_dir)
+                await del_ongoing_task(user_id)
+            return
+        # Check if user was dumb 😐
+        paths = await get_files(path=ext_files_dir)
+        if not paths:
+            await unzip_bot.send_message(
+                chat_id=query.message.chat.id,
+                text=Messages.PASSWORD_PROTECTED,
+            )
+            await answer_query(
+                query,
+                Messages.EXT_FAILED_TXT,
+                unzip_client=unzip_bot
+            )
+            shutil.rmtree(ext_files_dir)
+            shutil.rmtree(download_path)
+            await del_ongoing_task(user_id)
+            return
+
+        try:
+            shutil.rmtree(download_path)
+        except:
+            pass
+
+        # Upload extracted files
+        extrtime = TimeFormatter(round(ext_e_time - ext_s_time) * 1000)
+        if extrtime == "":
+            extrtime = "1s"
+        await answer_query(
+            query,
+            Messages.EXT_OK_TXT.format(extrtime),
+            unzip_client=unzip_bot
+        )
+
+        try:
+            i_e_buttons = await make_keyboard(
+                paths=paths,
+                user_id=user_id,
+                chat_id=query.message.chat.id,
+                unziphttp=False
+            )
+            try:
+                await query.message.edit(Messages.SELECT_FILES, reply_markup=i_e_buttons)
+            except ReplyMarkupTooLong:
+                empty_buttons = await make_keyboard_empty(
+                    user_id=user_id,
+                    chat_id=query.message.chat.id,
+                    unziphttp=False
+                )
+                await query.message.edit(
+                    Messages.UNABLE_GATHER_FILES,
+                    reply_markup=empty_buttons,
+                )
+        except:
+            try:
+                await query.message.delete()
+                i_e_buttons = await make_keyboard(
+                    paths=paths,
+                    user_id=user_id,
+                    chat_id=query.message.chat.id,
+                    unziphttp=False
+                )
+                await unzip_bot.send_message(
+                    chat_id=query.message.chat.id,
+                    text=Messages.SELECT_FILES,
+                    reply_markup=i_e_buttons,
+                )
+            except:
+                try:
+                    await query.message.delete()
+                    empty_buttons = await make_keyboard_empty(
+                        user_id=user_id,
+                        chat_id=query.message.chat.id,
+                        unziphttp=False
+                    )
+                    await unzip_bot.send_message(
+                        chat_id=query.message.chat.id,
+                        text=Messages.UNABLE_GATHER_FILES,
+                        reply_markup=empty_buttons,
+                    )
+                except:
+                    await answer_query(
+                        query,
+                        Messages.EXT_FAILED_TXT,
+                        unzip_client=unzip_bot
+                    )
+                    shutil.rmtree(ext_files_dir)
+                    LOGGER.error(Messages.FATAL_ERROR)
+                    await del_ongoing_task(user_id)
+                    return
+
+    elif query.data.startswith("extract_file"):
+        user_id = query.from_user.id
+        start_time = time()
+        await add_ongoing_task(user_id, start_time, "extract")
+        download_path = f"{Config.DOWNLOAD_LOCATION}/{user_id}"
+        ext_files_dir = f"{download_path}/extracted"
+        r_message = query.message.reply_to_message
+        splitted_data = query.data.split("|")
+        try:
+            await query.message.edit(Messages.PROCESSING_TASK)
+        except:
+            pass
+        log_msg = await unzip_bot.send_message(
+            chat_id=Config.LOGS_CHANNEL,
+            text=Messages.USER_QUERY.format(user_id)
+        )
+        global archive_msg
+
+        try:
+            if splitted_data[1] == "url":
+                url = r_message.text
+                # Double check
+                if not re.match(https_url_regex, url):
+                    await del_ongoing_task(user_id)
+                    await query.message.edit(Messages.INVALID_URL)
+                    return
+                if re.match(telegram_url_pattern, url):
+                    r_message = await unzip_bot.get_messages(
+                        chat_id=url.split("/")[-2],
+                        message_ids=int(url.split("/")[-1])
+                    )
+                    splitted_data[1] = "tg_file"
+                if splitted_data[1] == "url":
+                    s = ClientSession()
+                    if "drive.google.com" in url:
+                        url = await gdrive_dl(url)
+                        if url is None:
+                            await del_ongoing_task(user_id)
+                            await query.message.edit(Messages.INVALID_URL)
+                            return
+                    async with s as session:
+                        # Get the file size
+                        unzip_head = await session.head(url, allow_redirects=True)
+                        f_size = unzip_head.headers.get("content-length")
+                        u_file_size = f_size if f_size else "undefined"
+                        await log_msg.edit(Messages.LOG_TXT.format(user_id, url, u_file_size))
+                        archive_msg = log_msg
+                        # Checks if file is an archive using content-type header
+                        unzip_resp = await session.get(url, timeout=None, allow_redirects=True)
+                        if "application/" not in unzip_resp.headers.get("content-type"):
+                            await del_ongoing_task(user_id)
+                            await query.message.edit(Messages.NOT_AN_ARCHIVE)
+                            return
+                        rfnamebro = unquote(url.split("/")[-1])
+                        if unzip_resp.status == 200:
+                            # Makes download dir
+                            os.makedirs(download_path)
+                            s_time = time()
+                            fname = unquote(os.path.splitext(url)[1])
+                            fext = fname.split(".")[-1].casefold()
+                            if (
+                                splitted_data[2] not in ["thumb", "thumbrename"]
+                                and fext not in extentions_list["archive"]
+                            ):
+                                await del_ongoing_task(user_id)
+                                await query.message.edit(Messages.DEF_NOT_AN_ARCHIVE)
+                                try:
+                                    shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{user_id}")
+                                except:
+                                    pass
+                                return
+                            archive = f"{download_path}/archive_from_{user_id}{fname}"
+                            location = archive
+                            await answer_query(
+                                query,
+                                Messages.PROCESSING2,
+                                unzip_client=unzip_bot
+                            )
+                            # HTTP server must send Accept-Ranges: bytes and Content-Length in headers
+                            if fext == "zip" and "accept-ranges" in unzip_resp.headers and "content-length" in unzip_resp.headers:
+                                try:
+                                    loop = asyncio.get_event_loop()
+                                    with concurrent.futures.ThreadPoolExecutor() as pool:
+                                        rzf, paths = await loop.run_in_executor(pool, get_zip_http, url)
+                                    try:
+                                        i_e_buttons = await make_keyboard(
+                                            paths=paths,
+                                            user_id=user_id,
+                                            chat_id=query.message.chat.id,
+                                            unziphttp=True,
+                                            rzfile=rzf,
+                                        )
+                                        try:
+                                            await query.message.edit(
+                                                Messages.SELECT_FILES,
+                                                reply_markup=i_e_buttons
+                                            )
+                                        except ReplyMarkupTooLong:
+                                            empty_buttons = await make_keyboard_empty(
+                                                user_id=user_id, chat_id=query.message.chat.id, unziphttp=True, rzfile=rzf)
+                                            await query.message.edit(
+                                                Messages.UNABLE_GATHER_FILES,
+                                                reply_markup=empty_buttons,
+                                            )
+                                    except:
+                                        try:
+                                            await query.message.delete()
+                                            i_e_buttons = await make_keyboard(
+                                                paths=paths,
+                                                user_id=user_id,
+                                                chat_id=query.message.chat.id,
+                                                unziphttp=True,
+                                                rzfile=rzf,
+                                            )
+                                            await unzip_bot.send_message(
+                                                chat_id=query.message.chat.id,
+                                                text=Messages.SELECT_FILES,
+                                                reply_markup=i_e_buttons,
+                                            )
+                                        except:
+                                            try:
+                                                await query.message.delete()
+                                                empty_buttons = await make_keyboard_empty(
+                                                    user_id=user_id,
+                                                    chat_id=query.message.chat.id,
+                                                    unziphttp=True,
+                                                    rzfile=rzf
+                                                )
+                                                await unzip_bot.send_message(
+                                                    chat_id=query.message.chat.id,
+                                                    text=Messages.UNABLE_GATHER_FILES,
+                                                    reply_markup=empty_buttons,
+                                                )
+                                            except:
+                                                pass
+                                except Exception as e:
+                                    LOGGER.error(Messages.UNZIP_HTTP.format(url, e))
+                            try:
+                                dled = await download_with_progress(url, archive, query.message, unzip_bot)
+                            except Exception as e:
+                                dled = False
+                                LOGGER.error(Messages.ERR_DL.format(e))
+                            if isinstance(dled, bool) and not dled:
+                                return
+                            e_time = time()
+                            # Send copy in logs in case url has gone
+                            # paths = await get_files(path=archive)
+                            await send_url_logs(
+                                unzip_bot=unzip_bot,
+                                c_id=Config.LOGS_CHANNEL,
+                                doc_f=archive,
+                                source=url,
+                                message=query.message,
+                            )
+                        else:
+                            await del_ongoing_task(user_id)
+                            await query.message.edit(Messages.CANT_DL_URL)
+                            try:
+                                shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{user_id}")
+                            except:
+                                pass
+                            return
+
+            elif splitted_data[1] == "tg_file":
+                if r_message.document is None:
+                    await del_ongoing_task(user_id)
+                    await query.message.edit(Messages.GIVE_ARCHIVE)
+                    return
+                fname = r_message.document.file_name
+                rfnamebro = fname
+                archive_msg = await r_message.forward(chat_id=Config.LOGS_CHANNEL)
+                await log_msg.edit(Messages.LOG_TXT.format(
+                    user_id,
+                    fname,
+                    humanbytes(r_message.document.file_size)
+                ))
+                # Checks if it's actually an archive
+                # fext = (pathlib.Path(fname).suffix).casefold()
+                if splitted_data[2] not in ["thumb", "thumbrename"]:
+                    fext = fname.split(".")[-1].casefold()
+                    if (
+                        fnmatch(fext, extentions_list["split"][0])
+                        or fext in extentions_list["split"] or bool(re.search(rar_file_pattern, fname))
+                    ):
+                        await query.message.edit(Messages.ITS_SPLITTED)
+                        return
+                    if bool(re.search(split_file_pattern, fname)):
+                        await del_ongoing_task(user_id)
+                        await query.message.edit(Messages.SPL_RZ)
+                        return
+                    if fext not in extentions_list["archive"]:
+                        await del_ongoing_task(user_id)
+                        await query.message.edit(Messages.DEF_NOT_AN_ARCHIVE)
+                        return
+                # Makes download dir
+                os.makedirs(download_path)
+                s_time = time()
+                location = f"{download_path}/archive_from_{user_id}{os.path.splitext(fname)[1]}"
+                archive = await r_message.download(
+                    file_name=location,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Messages.TRY_DL,
+                        query.message,
+                        s_time,
+                        unzip_bot,
+                    ),
+                )
+                e_time = time()
+            else:
+                await del_ongoing_task(user_id)
+                await answer_query(
+                    query,
+                    Messages.QUERY_PARSE_ERR,
+                    answer_only=True,
+                    unzip_client=unzip_bot,
+                )
+                return
+
+            if splitted_data[2].startswith("thumb"):
+                await query.message.edit(Messages.PROCESSING2)
+                archive_name = location.split("/")[-1]
+                if "rename" in splitted_data[2]:
+                    newname = await unzip_bot.ask(
+                        chat_id=user_id,
+                        text=Messages.GIVE_NEW_NAME.format(rfnamebro),
+                    )
+                    renamed = location.replace(archive_name, newname.text)
+                else:
+                    renamed = location.replace(archive_name, rfnamebro)
+                try:
+                    os.rename(location, renamed)
+                except OSError as e:
+                    await del_ongoing_task(user_id)
+                    LOGGER.error(e)
+                    return
+                newfname = renamed.split("/")[-1]
+                fsize = await get_size(renamed)
+                if fsize <= Config.TG_MAX_SIZE:
+                    await send_file(
+                        unzip_bot=unzip_bot,
+                        c_id=user_id,
+                        doc_f=renamed,
+                        query=query,
+                        full_path=renamed,
+                        log_msg=log_msg,
+                        split=False,
+                    )
+                    await query.message.delete()
+                    await del_ongoing_task(user_id)
+                    return shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{user_id}")
+                await query.message.edit(Messages.SPLITTING.format(newfname))
+                splitteddir = f"{Config.DOWNLOAD_LOCATION}/splitted/{user_id}"
+                os.makedirs(splitteddir)
+                ooutput = f"{splitteddir}/{newfname}"
+                if await (user_id):
+                    splittedfiles = await split_files(renamed, ooutput, Config.TG_PREMIUM_SIZE)
+                else:
+                    splittedfiles = await split_files(renamed, ooutput, Config.TG_MAX_SIZE)
+                if not splittedfiles:
+                    try:
+                        shutil.rmtree(splitteddir)
+                    except:
+                        pass
+                    await del_ongoing_task(user_id)
+                    await query.message.edit(Messages.ERR_SPLIT)
+                    return
+                await query.message.edit(Messages.SEND_ALL_PARTS.format(newfname))
+                async_splittedfiles = async_generator(splittedfiles)
+                async for file in async_splittedfiles:
+                    sent_files += 1
+                    await send_file(
+                        unzip_bot=unzip_bot,
+                        c_id=user_id,
+                        doc_f=file,
+                        query=query,
+                        full_path=splitteddir,
+                        log_msg=log_msg,
+                        split=True,
+                    )
+                try:
+                    shutil.rmtree(splitteddir)
+                    shutil.rmtree(renamed.replace(newfname, ""))
+                except:
+                    pass
+                await del_ongoing_task(user_id)
+                try:
+                    await query.message.edit(
+                        text=Messages.UPLOADED,
+                        reply_markup=Buttons.RATE_ME
+                    )
+                except:
+                    await unzip_bot.send_message(
+                        chat_id=user_id,
+                        text=Messages.UPLOADED,
+                        reply_markup=Buttons.RATE_ME
+                    )
+                return
+
+            dltime = TimeFormatter(round(e_time - s_time) * 1000)
+            if dltime == "":
+                dltime = "1s"
+            await answer_query(
+                query,
+                Messages.AFTER_OK_DL_TXT.format(dltime),
+                unzip_client=unzip_bot
+            )
+
+            # Attempt to fetch password protected archives
+            if splitted_data[2] == "with_pass":
+                password = await unzip_bot.ask(
+                    chat_id=query.message.chat.id,
+                    text=Messages.PLS_SEND_PASSWORD
+                )
+                ext_s_time = time()
+                extractor = await extr_files(
+                    path=ext_files_dir,
+                    archive_path=archive,
+                    password=password.text,
+                )
+                ext_e_time = time()
+                await archive_msg.reply(Messages.PASS_TXT.format(password.text))
+            else:
+                ext_s_time = time()
+                tested = await _test_with_7z_helper(archive)
+                ext_t_time = time()
+                testtime = TimeFormatter(round(ext_t_time - ext_s_time) * 1000)
+                if testtime == "":
+                    testtime = "1s"
+                await answer_query(
+                    query,
+                    Messages.AFTER_OK_TEST_TXT.format(testtime),
+                    unzip_client=unzip_bot
+                )
+                if tested:
+                    extractor = await extr_files(
+                        path=ext_files_dir,
+                        archive_path=archive
+                    )
+                    ext_e_time = time()
+                else:
+                    extractor = "Error"
+                    ext_e_time = time()
+            # Checks if there is an error happened while extracting the archive
+            if any(err in extractor for err in ERROR_MSGS):
+                try:
+                    await query.message.edit(Messages.EXT_FAILED_TXT)
+                    shutil.rmtree(ext_files_dir)
+                    await del_ongoing_task(user_id)
+                    await log_msg.reply(Messages.EXT_FAILED_TXT)
+                    return
+                except:
+                    try:
+                        await query.message.delete()
+                    except:
+                        pass
+                    await unzip_bot.send_message(
+                        chat_id=query.message.chat.id,
+                        text=Messages.EXT_FAILED_TXT
+                    )
+                    shutil.rmtree(ext_files_dir)
+                    await del_ongoing_task(user_id)
+                    await archive_msg.reply(Messages.EXT_FAILED_TXT)
+                    return
+            # Check if user was dumb 😐
+            paths = await get_files(path=ext_files_dir)
+            if not paths:
+                await archive_msg.reply(Messages.PASSWORD_PROTECTED)
+                await unzip_bot.send_message(
+                    chat_id=query.message.chat.id,
+                    text=Messages.PASSWORD_PROTECTED,
+                )
+                await answer_query(
+                    query,
+                    Messages.EXT_FAILED_TXT,
+                    unzip_client=unzip_bot
+                )
+                shutil.rmtree(ext_files_dir)
+                await del_ongoing_task(user_id)
+                return
+
+            # Upload extracted files
+            extrtime = TimeFormatter(round(ext_e_time - ext_s_time) * 1000)
+            if extrtime == "":
+                extrtime = "1s"
+            await answer_query(
+                query,
+                Messages.EXT_OK_TXT.format(extrtime),
+                unzip_client=unzip_bot
+            )
+
+            try:
+                i_e_buttons = await make_keyboard(
+                    paths=paths,
+                    user_id=user_id,
+                    chat_id=query.message.chat.id,
+                    unziphttp=False
+                )
+                try:
+                    await query.message.edit(Messages.SELECT_FILES, reply_markup=i_e_buttons)
+                except ReplyMarkupTooLong:
+                    empty_buttons = await make_keyboard_empty(
+                        user_id=user_id,
+                        chat_id=query.message.chat.id,
+                        unziphttp=False
+                    )
+                    await query.message.edit(
+                        Messages.UNABLE_GATHER_FILES,
+                        reply_markup=empty_buttons,
+                    )
+            except:
+                try:
+                    await query.message.delete()
+                    i_e_buttons = await make_keyboard(
+                        paths=paths,
+                        user_id=user_id,
+                        chat_id=query.message.chat.id,
+                        unziphttp=False
+                    )
+                    await unzip_bot.send_message(
+                        chat_id=query.message.chat.id,
+                        text=Messages.SELECT_FILES,
+                        reply_markup=i_e_buttons,
+                    )
+                except:
+                    try:
+                        await query.message.delete()
+                        empty_buttons = await make_keyboard_empty(
+                            user_id=user_id,
+                            chat_id=query.message.chat.id,
+                            unziphttp=False
+                        )
+                        await unzip_bot.send_message(
+                            chat_id=query.message.chat.id,
+                            text=Messages.UNABLE_GATHER_FILES,
+                            reply_markup=empty_buttons,
+                        )
+                    except:
+                        await answer_query(
+                            query,
+                            Messages.EXT_FAILED_TXT,
+                            unzip_client=unzip_bot
+                        )
+                        await archive_msg.reply(Messages.EXT_FAILED_TXT)
+                        shutil.rmtree(ext_files_dir)
+                        LOGGER.error(Messages.FATAL_ERROR)
+                        await del_ongoing_task(user_id)
+                        return
+
+        except Exception as e:
+            await del_ongoing_task(user_id)
+            try:
+                try:
+                    await query.message.edit(Messages.ERROR_TXT.format(e))
+                except:
+                    await unzip_bot.send_message(
+                        chat_id=query.message.chat.id,
+                        text=Messages.ERROR_TXT.format(e))
+                await archive_msg.reply(Messages.ERROR_TXT.format(e))
+                shutil.rmtree(ext_files_dir)
+                try:
+                    await ClientSession().close()
+                except:
+                    pass
+                LOGGER.error(e)
+            except Exception as err:
+                LOGGER.error(err)
+                await archive_msg.reply(err)
+
+    elif query.data.startswith("ext_f"):
+        LOGGER.info(query.data)
+        user_id = query.from_user.id
+        spl_data = query.data.split("|")
+        file_path = f"{Config.DOWNLOAD_LOCATION}/{spl_data[1]}/extracted"
+        try:
+            urled = spl_data[4] if isinstance(spl_data[4], bool) else False
+        except:
+            urled = False
+        if urled:
+            paths = spl_data[5].namelist()
+        else:
+            paths = await get_files(path=file_path)
+        if not paths and not urled:
+            if os.path.isdir(f"{Config.DOWNLOAD_LOCATION}/{spl_data[1]}"):
+                shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{spl_data[1]}")
+            await del_ongoing_task(user_id)
+            await query.message.edit(
+                text=Messages.NO_FILE_LEFT,
+                reply_markup=Buttons.RATE_ME
+            )
+            return
+        LOGGER.info("ext_f paths : " + str(paths))
+        try:
+            await query.answer(Messages.SENDING_FILE)
+        except:
+            pass
+        sent_files += 1
+        if urled:
+            file = spl_data[5].open(paths[int(spl_data[3])])
+        else:
+            file = paths[int(spl_data[3])]
+        fsize = await get_size(file)
+        split = False
+        if fsize <= Config.TG_MAX_SIZE:
+            await send_file(
+                unzip_bot=unzip_bot,
+                c_id=spl_data[2],
+                doc_f=file,
+                query=query,
+                full_path=f"{Config.DOWNLOAD_LOCATION}/{spl_data[1]}",
+                log_msg=log_msg,
+                split=False,
+            )
+        else:
+            split = True
+        if split:
+            fname = file.split('/')[-1]
+            smessage = await unzip_bot.send_message(
+                chat_id=user_id,
+                text=Messages.SPLITTING.format(fname)
+            )
+            splitteddir = f"{Config.DOWNLOAD_LOCATION}/splitted/{user_id}"
+            os.makedirs(splitteddir)
+            ooutput = f"{splitteddir}/{fname}"
+            splittedfiles = await split_files(file, ooutput, Config.TG_MAX_SIZE)
+            LOGGER.info(splittedfiles)
+            if not splittedfiles:
+                try:
+                    shutil.rmtree(splitteddir)
+                except:
+                    pass
+                await del_ongoing_task(user_id)
+                await smessage.edit(Messages.ERR_SPLIT)
+                return
+            await smessage.edit(Messages.SEND_ALL_PARTS.format(fname))
+            async_splittedfiles = async_generator(splittedfiles)
+            async for file in async_splittedfiles:
+                sent_files += 1
+                await send_file(
+                    unzip_bot=unzip_bot,
+                    c_id=user_id,
+                    doc_f=file,
+                    query=query,
+                    full_path=splitteddir,
+                    log_msg=log_msg,
+                    split=True,
+                )
+            try:
+                shutil.rmtree(splitteddir)
+                os.remove(file)
+            except:
+                pass
+            try:
+                await smessage.delete()
+            except:
+                pass
+
+        await query.message.edit(Messages.REFRESHING)
+        if urled:
+            rpaths = paths.remove(paths[int(spl_data[3])])
+        else:
+            rpaths = await get_files(path=file_path)
+        if not rpaths:
+            try:
+                shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{spl_data[1]}")
+            except:
+                pass
+            await del_ongoing_task(user_id)
+            await query.message.edit(
+                text=Messages.NO_FILE_LEFT,
+                reply_markup=Buttons.RATE_ME
+            )
+            return
+        if urled:
+            try:
+                i_e_buttons = await make_keyboard(
+                    paths=rpaths,
+                    user_id=query.from_user.id,
+                    chat_id=query.message.chat.id,
+                    unziphttp=True,
+                    rzfile=spl_data[5],
+                )
+                await query.message.edit(Messages.SELECT_FILES, reply_markup=i_e_buttons)
+            except ReplyMarkupTooLong:
+                empty_buttons = await make_keyboard_empty(
+                    user_id=user_id,
+                    chat_id=query.message.chat.id,
+                    unziphttp=True,
+                    rzfile=spl_data[5]
+                )
+                await query.message.edit(
+                    Messages.UNABLE_GATHER_FILES,
+                    reply_markup=empty_buttons,
+                )
+        else:
+            try:
+                i_e_buttons = await make_keyboard(
+                    paths=rpaths,
+                    user_id=query.from_user.id,
+                    chat_id=query.message.chat.id,
+                    unziphttp=False
+                )
+                await query.message.edit(Messages.SELECT_FILES, reply_markup=i_e_buttons)
+            except ReplyMarkupTooLong:
+                empty_buttons = await make_keyboard_empty(
+                    user_id=user_id,
+                    chat_id=query.message.chat.id,
+                    unziphttp=False
+                )
+                await query.message.edit(
+                    Messages.UNABLE_GATHER_FILES,
+                    reply_markup=empty_buttons,
+                )
+        await update_uploaded(user_id, upload_count=sent_files)
+
+    elif query.data.startswith("ext_a"):
+        LOGGER.info(query.data)
+        user_id = query.from_user.id
+        spl_data = query.data.split("|")
+        file_path = f"{Config.DOWNLOAD_LOCATION}/{spl_data[1]}/extracted"
+        try:
+            urled = spl_data[4] if isinstance(spl_data[3], bool) else False
+        except:
+            urled = False
+        if urled:
+            paths = spl_data[4].namelist()
+        else:
+            paths = await get_files(path=file_path)
+        LOGGER.info("ext_a paths : " + str(paths))
+        if not paths and not urled:
+            try:
+                shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{spl_data[1]}")
+            except:
+                pass
+            await del_ongoing_task(user_id)
+            await query.message.edit(
+                text=Messages.NO_FILE_LEFT,
+                reply_markup=Buttons.RATE_ME
+            )
+            return
+        await query.message.edit(Messages.SEND_ALL_FILES)
+        async_paths = async_generator(paths)
+        async for file in async_paths:
+            sent_files += 1
+            if urled:
+                file = spl_data[4].open(file)
+                fsize = Config.TG_MAX_SIZE + 1
+                # secutity as we can't retrieve the file size from URL
+            else:
+                fsize = await get_size(file)
+            split = False
+            if fsize <= Config.TG_MAX_SIZE:
+                await send_file(
+                    unzip_bot=unzip_bot,
+                    c_id=spl_data[2],
+                    doc_f=file,
+                    query=query,
+                    full_path=f"{Config.DOWNLOAD_LOCATION}/{spl_data[1]}",
+                    log_msg=log_msg,
+                    split=False,
+                )
+            else:
+                split = True
+            if split:
+                fname = file.split('/')[-1]
+                smessage = await unzip_bot.send_message(
+                    chat_id=user_id,
+                    text=Messages.SPLITTING.format(fname)
+                )
+                splitteddir = f"{Config.DOWNLOAD_LOCATION}/splitted/{user_id}"
+                os.makedirs(splitteddir)
+                ooutput = f"{splitteddir}/{fname}"
+                splittedfiles = await split_files(file, ooutput, Config.TG_MAX_SIZE)
+                LOGGER.info(splittedfiles)
+                if not splittedfiles:
+                    try:
+                        shutil.rmtree(splitteddir)
+                    except:
+                        pass
+                    await del_ongoing_task(user_id)
+                    await smessage.edit(Messages.ERR_SPLIT)
+                    return
+                await smessage.edit(Messages.SEND_ALL_PARTS.format(fname))
+                async_splittedfiles = async_generator(splittedfiles)
+                async for file in async_splittedfiles:
+                    sent_files += 1
+                    await send_file(
+                        unzip_bot=unzip_bot,
+                        c_id=user_id,
+                        doc_f=file,
+                        query=query,
+                        full_path=splitteddir,
+                        log_msg=log_msg,
+                        split=True,
+                    )
+                try:
+                    shutil.rmtree(splitteddir)
+                except:
+                    pass
+                try:
+                    await smessage.delete()
+                except:
+                    pass
+
+        await query.message.edit(
+            text=Messages.UPLOADED,
+            reply_markup=Buttons.RATE_ME
+        )
+        await log_msg.reply(Messages.HOW_MANY_UPLOADED.format(sent_files))
+        await update_uploaded(user_id, upload_count=sent_files)
+        await del_ongoing_task(user_id)
+        try:
+            shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{spl_data[1]}")
+        except Exception as e:
+            await query.message.edit(Messages.ERROR_TXT.format(e))
+            await archive_msg.reply(Messages.ERROR_TXT.format(e))
+
+    elif query.data == "cancel_dis":
+        uid = query.from_user.id
+        await del_ongoing_task(uid)
+        await del_merge_task(uid)
+        try:
+            await query.message.edit(Messages.CANCELLED_TXT.format(Messages.PROCESS_CANCELLED))
+            shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{uid}")
+            await update_uploaded(
+                user_id=uid,
+                upload_count=sent_files
+            )
+            try:
+                await log_msg.reply(Messages.HOW_MANY_UPLOADED.format(sent_files))
+            except:
+                return
+        except:
+            await unzip_bot.send_message(
+                chat_id=uid,
+                text=Messages.CANCELLED_TXT.format(Messages.PROCESS_CANCELLED)
+            )
+            return
+
+    elif query.data == "nobully":
+        await query.message.edit(Messages.CANCELLED)

unzipper/modules/commands.py

@@ -0,0 +1,819 @@
+# Copyright (c) 2023 EDM115
+import os
+import re
+import shutil
+import time
+from asyncio import sleep
+from sys import executable
+
+import git
+import psutil
+from pyrogram import enums, filters
+from pyrogram.errors import FloodWait, RPCError
+from pyrogram.types import Message
+
+from config import Config
+from unzipper import LOGGER, boottime, unzipperbot
+from unzipper.helpers.database import (
+    add_merge_task,
+    add_user,
+    add_banned_user,
+    add_vip_user,
+    check_user,
+    count_banned_users,
+    count_users,
+    del_banned_user,
+    del_ongoing_task,
+    del_user,
+    get_maintenance,
+    get_merge_task,
+    get_ongoing_tasks,
+    get_upload_mode,
+    get_uploaded,
+    get_users_list,
+    count_ongoing_tasks,
+    set_maintenance,
+)
+from unzipper.helpers.unzip_help import humanbytes, timeformat_sec
+from unzipper.modules.ext_script.custom_thumbnail import add_thumb, del_thumb
+from unzipper.modules.ext_script.ext_helper import get_files
+
+from .bot_data import Buttons, Messages
+
+# Regex for urls
+https_url_regex = r"((http|https)\:\/\/)?[a-zA-Z0-9\.\/\?\:@\-_=#]+\.([a-zA-Z]){2,6}([a-zA-Z0-9\.\&\/\?\:@\-_=#])*"
+
+
+@unzipperbot.on_message(filters.private)
+async def _(_, message: Message):
+    await check_user(message)
+    uid = message.from_user.id
+    if uid != Config.BOT_OWNER and await get_maintenance():
+        await message.reply(Messages.MAINTENANCE_ON)
+        return
+    if uid == Config.BOT_OWNER:
+        return
+    if await count_ongoing_tasks() >= Config.MAX_CONCURRENT_TASKS:
+        ogtasks = await get_ongoing_tasks()
+        if not any(uid == task["user_id"] for task in ogtasks):
+            try:
+                await message.reply(
+                    text=Messages.MAX_TASKS.format(Config.MAX_CONCURRENT_TASKS),
+                )
+            except:
+                await unzipperbot.send_message(
+                    chat_id=uid,
+                    text=Messages.MAX_TASKS.format(Config.MAX_CONCURRENT_TASKS),
+                )
+            return
+
+
+@unzipperbot.on_message(filters.command("start"))
+async def start_bot(_, message: Message):
+    try:
+        await message.reply_text(
+            text=Messages.START_TEXT.format(message.from_user.mention),
+            reply_markup=Buttons.START_BUTTON,
+            disable_web_page_preview=True,
+        )
+    except FloodWait as f:
+        await sleep(f.value)
+        await start_bot(_, message)
+
+
+@unzipperbot.on_message(filters.private & filters.command("clean"))
+async def clean_my_files(_, message: Message):
+    try:
+        await message.reply_text(text=Messages.CLEAN_TXT, reply_markup=Buttons.CLN_BTNS)
+    except FloodWait as f:
+        await sleep(f.value)
+        await clean_my_files(_, message)
+
+
+@unzipperbot.on_message(filters.command("help"))
+async def help_me(_, message: Message):
+    try:
+        await message.reply_text(text=Messages.HELP_TXT, reply_markup=Buttons.ME_GOIN_HOME)
+    except FloodWait as f:
+        await sleep(f.value)
+        await help_me(_, message)
+
+
+@unzipperbot.on_message(filters.command("about"))
+async def about_me(_, message: Message):
+    try:
+        await message.reply_text(
+            text=Messages.ABOUT_TXT,
+            reply_markup=Buttons.ME_GOIN_HOME,
+            disable_web_page_preview=True,
+        )
+    except FloodWait as f:
+        await sleep(f.value)
+        await about_me(_, message)
+
+
+@unzipperbot.on_message(
+    filters.incoming & filters.private & filters.document
+    | filters.regex(https_url_regex)
+)
+async def extract_archive(_, message: Message):
+    try:
+        if message.chat.type != enums.ChatType.PRIVATE:
+            return
+        unzip_msg = await message.reply(Messages.PROCESSING2, reply_to_message_id=message.id)
+        user_id = message.from_user.id
+        download_path = f"{Config.DOWNLOAD_LOCATION}/{user_id}"
+        if os.path.isdir(download_path):
+            await unzip_msg.edit(Messages.PROCESS_RUNNING)
+            return
+        if await get_merge_task(user_id):
+            await unzip_msg.delete()
+            return
+        if message.text and (re.match(https_url_regex, message.text)):
+            await unzip_msg.edit(
+                text=Messages.CHOOSE_EXT_MODE.format("URL", "🔗"),
+                reply_markup=Buttons.CHOOSE_E_U__BTNS,
+            )
+        elif message.document:
+            await unzip_msg.edit(
+                text=Messages.CHOOSE_EXT_MODE.format("file", "🗂️"),
+                reply_markup=Buttons.CHOOSE_E_F__BTNS,
+            )
+        else:
+            await unzip_msg.edit(Messages.UNVALID)
+    except FloodWait as f:
+        await sleep(f.value)
+        await extract_archive(_, message)
+
+
+@unzipperbot.on_message(filters.private & filters.command("cancel"))
+async def cancel_task_by_user(_, message):
+    idtodel = message.id - 1
+    try:
+        await unzipperbot.delete_messages(chat_id=message.from_user.id, message_ids=idtodel)
+    except:
+        pass
+    await message.reply(Messages.CANCELLED)
+
+
+@unzipperbot.on_message(filters.private & filters.command("merge"))
+async def merging(_, message: Message):
+    try:
+        merge_msg = await message.reply(Messages.MERGE)
+        await add_merge_task(message.from_user.id, merge_msg.id)
+    except FloodWait as f:
+        await sleep(f.value)
+        await merging(_, message)
+
+
+@unzipperbot.on_message(filters.private & filters.command("done"))
+async def done_merge(_, message: Message):
+    try:
+        await message.reply(
+            Messages.DONE,
+            reply_markup=Buttons.MERGE_THEM_ALL
+        )
+    except FloodWait as f:
+        await sleep(f.value)
+        await done_merge(_, message)
+
+
+@unzipperbot.on_message(filters.private & filters.command("mode"))
+async def set_mode_for_user(_, message: Message):
+    try:
+        upload_mode = await get_upload_mode(message.from_user.id)
+        await message.reply(
+            text=Messages.SELECT_UPLOAD_MODE_TXT.format(upload_mode),
+            reply_markup=Buttons.SET_UPLOAD_MODE_BUTTONS,
+        )
+    except FloodWait as f:
+        await sleep(f.value)
+        await set_mode_for_user(_, message)
+
+
+async def get_stats(id):
+    total, used, free = shutil.disk_usage(".")
+    total = humanbytes(total)
+    used = humanbytes(used)
+    free = humanbytes(free)
+    sent = humanbytes(psutil.net_io_counters().bytes_sent)
+    recv = humanbytes(psutil.net_io_counters().bytes_recv)
+    cpu_usage = psutil.cpu_percent(interval=0.2)
+    ram_usage = psutil.virtual_memory().percent
+    disk_usage = psutil.disk_usage("/").percent
+    uptime = timeformat_sec(time.time() - boottime)
+    total_users = await count_users()
+    total_banned_users = await count_banned_users()
+    ongoing_tasks = await count_ongoing_tasks()
+
+    if id == Config.BOT_OWNER:
+        stats_string = Messages.STATS_OWNER.format(
+            total_users,
+            total_banned_users,
+            total,
+            used,
+            disk_usage,
+            free,
+            ongoing_tasks,
+            sent,
+            recv,
+            cpu_usage,
+            ram_usage,
+            uptime,
+        )
+    else:
+        stats_string = Messages.STATS.format(
+            total,
+            used,
+            disk_usage,
+            free,
+            ongoing_tasks,
+            cpu_usage,
+            ram_usage,
+            uptime,
+        )
+
+    return stats_string
+
+
+@unzipperbot.on_message(filters.command("stats"))
+async def send_stats(_, message: Message):
+    try:
+        stats_msg = await message.reply(Messages.PROCESSING2)
+        stats_txt = await get_stats(message.from_user.id)
+        await stats_msg.edit(text=stats_txt, reply_markup=Buttons.REFRESH_BUTTON)
+    except FloodWait as f:
+        await sleep(f.value)
+        await send_stats(_, message)
+
+
+async def _do_broadcast(message, user):
+    try:
+        await message.copy(chat_id=int(user))
+        return 200
+    except FloodWait as f:
+        await sleep(f.value)
+        return _do_broadcast(message, user)
+    except Exception:
+        await del_user(user)
+        return 400
+
+
+@unzipperbot.on_message(filters.command("broadcast") & filters.user(Config.BOT_OWNER))
+async def broadcast_this(_, message: Message):
+    bc_msg = await message.reply(Messages.PROCESSING2)
+    r_msg = message.reply_to_message
+    if not r_msg:
+        await bc_msg.edit(Messages.BC_REPLY)
+        return
+    users_list = await get_users_list()
+    success_no = 0
+    failed_no = 0
+    done_no = 0
+    total_users = await count_users()
+    await bc_msg.edit(Messages.BC_START.format(done_no, total_users))
+    for user in users_list:
+        b_cast = await _do_broadcast(message=r_msg, user=user["user_id"])
+        if b_cast == 200:
+            success_no += 1
+        else:
+            failed_no += 1
+        done_no += 1
+        if done_no % 10 == 0 or done_no == total_users:
+            try:
+                await bc_msg.edit(Messages.BC_START.format(done_no, total_users))
+            except FloodWait:
+                pass
+    try:
+        await bc_msg.edit(Messages.BC_DONE.format(
+            total_users,
+            success_no,
+            failed_no,
+        ))
+    except FloodWait as f:
+        await sleep(f.value)
+        await bc_msg.edit(Messages.BC_DONE.format(
+            total_users,
+            success_no,
+            failed_no,
+        ))
+
+
+@unzipperbot.on_message(filters.command("sendto") & filters.user(Config.BOT_OWNER))
+async def send_this(_, message: Message):
+    sd_msg = await message.reply(Messages.PROCESSING2)
+    r_msg = message.reply_to_message
+    if not r_msg:
+        await sd_msg.edit(Messages.SEND_REPLY)
+        return
+    try:
+        user_id = message.text.split(None, 1)[1]
+    except:
+        await sd_msg.edit(Messages.PROVIDE_UID)
+        return
+    await sd_msg.edit(Messages.SENDING)
+    send = await _do_broadcast(message=r_msg, user=user_id)
+    if send == 200:
+        await sd_msg.edit(Messages.SEND_SUCCESS.format(user_id))
+    else:
+        await sd_msg.edit(Messages.SEND_FAILED.format(user_id))
+
+
+@unzipperbot.on_message(filters.command("report"))
+async def report_this(_, message: Message):
+    sd_msg = await message.reply(Messages.PROCESSING2)
+    r_msg = message.reply_to_message
+    u_id = message.from_user.id
+    if not r_msg:
+        await sd_msg.edit(Messages.REPORT_REPLY)
+        return
+    await sd_msg.edit(Messages.SENDING)
+    await unzipperbot.send_message(
+        chat_id=Config.LOGS_CHANNEL,
+        text=Messages.REPORT_TEXT.format(u_id, r_msg.text.markdown),
+    )
+    await sd_msg.edit(Messages.REPORT_DONE)
+
+
+@unzipperbot.on_message(filters.command("ban") & filters.user(Config.BOT_OWNER))
+async def ban_user(_, message: Message):
+    ban_msg = await message.reply(Messages.PROCESSING2)
+    try:
+        user_id = message.text.split(None, 1)[1]
+    except:
+        await ban_msg.edit(Messages.BAN_ID)
+        return
+    bdb = await add_banned_user(user_id)
+    db = await del_user(user_id)
+    text = ""
+    if bdb == -1:
+        text += Messages.ALREADY_BANNED.format(user_id)
+    if db == -1:
+        text += Messages.ALREADY_REMOVED.format(user_id)
+    if text != "":
+        await ban_msg.edit(text)
+    else:
+        await ban_msg.edit(Messages.BANNED.format(user_id))
+
+
+@unzipperbot.on_message(filters.command("unban") & filters.user(Config.BOT_OWNER))
+async def unban_user(_, message: Message):
+    unban_msg = await message.reply(Messages.PROCESSING2)
+    try:
+        user_id = message.text.split(None, 1)[1]
+    except:
+        await unban_msg.edit(Messages.UNBAN_ID)
+        return
+    db = await add_user(user_id)
+    bdb = await del_banned_user(user_id)
+    text = ""
+    if db == -1:
+        text += Messages.ALREADY_ADDED.format(user_id)
+    if bdb == -1:
+        text += Messages.ALREADY_UNBANNED.format(user_id)
+    if text != "":
+        await unban_msg.edit(text)
+    else:
+        await unban_msg.edit(Messages.UNBANNED.format(user_id))
+
+
+@unzipperbot.on_message(filters.private & filters.command("info"))
+async def me_stats(_, message: Message):
+    me_info = await unzipperbot.ask(
+        chat_id=message.chat.id,
+        text=Messages.INFO,
+    )
+    await unzipperbot.send_message(chat_id=message.chat.id, text=f"`{me_info}`")
+
+
+@unzipperbot.on_message(filters.command("user") & filters.user(Config.BOT_OWNER))
+async def info_user(_, message: Message):
+    await message.reply(Messages.USER)
+    info_user_msg = await message.reply(Messages.PROCESSING2)
+    try:
+        user_id = message.text.split(None, 1)[1]
+    except:
+        await info_user_msg.edit(Messages.PROVIDE_UID)
+        return
+    up_count = get_uploaded(user_id)
+    if up_count == "":
+        up_count = Messages.UNABLE_FETCH
+    await info_user_msg.edit(Messages.USER_INFO.format(user_id, up_count))
+
+
+@unzipperbot.on_message(filters.command("user2") & filters.user(Config.BOT_OWNER))
+async def info_user2(_, message: Message):
+    user2_msg = await message.reply(Messages.PROCESSING2)
+    try:
+        user_id = message.text.split(None, 1)[1]
+    except:
+        await user2_msg.edit(Messages.PROVIDE_UID2)
+        return
+    try:
+        infos = await unzipperbot.get_users(user_id)
+    except:
+        await user2_msg.edit(Messages.UID_UNAME_INVALID)
+        return
+    if not isinstance(user_id, int):
+        try:
+            user_id = infos.id
+        except:
+            pass
+    await user2_msg.edit(Messages.USER2_INFO.format(infos, user_id))
+
+
+@unzipperbot.on_message(filters.command("self") & filters.user(Config.BOT_OWNER))
+async def info_self(_, message: Message):
+    self_infos = await unzipperbot.get_me()
+    await message.reply(f"`{self_infos}`")
+
+
+@unzipperbot.on_message(
+    filters.private & filters.command("getthumbs") & filters.user(Config.BOT_OWNER)
+)
+async def get_all_thumbs(_, message: Message):
+    paths = await get_files(path=Config.THUMB_LOCATION)
+    if not paths:
+        await message.reply(Messages.NO_THUMBS)
+    for doc_f in paths:
+        try:
+            await unzipperbot.send_document(
+                chat_id=message.chat.id,
+                document=doc_f,
+                file_name=doc_f.split("/")[-1],
+                reply_to_message_id=message.id,
+                caption=Messages.EXT_CAPTION.format(doc_f),
+            )
+        except FloodWait as f:
+            await sleep(f.value)
+            await unzipperbot.send_document(
+                chat_id=message.chat.id,
+                document=doc_f,
+                file_name=doc_f.split("/")[-1],
+                reply_to_message_id=message.id,
+                caption=Messages.EXT_CAPTION.format(doc_f),
+            )
+        except RPCError as e:
+            LOGGER.error(e)
+
+
+@unzipperbot.on_message(
+    filters.private & filters.command("redbutton") & filters.user(Config.BOT_OWNER)
+)
+async def red_alert(_, message: Message):
+    await message.reply("🚧 WIP 🚧")
+    # restart the whole bot, maybe using execl
+    # but also need to stop currently ongoing processes…
+
+
+@unzipperbot.on_message(filters.private & filters.command("maintenance") & filters.user(Config.BOT_OWNER))
+async def maintenance_mode(_, message: Message):
+    mstatus = await get_maintenance()
+    text = Messages.MAINTENANCE.format(mstatus) + "\n\n" + Messages.MAINTENANCE_ASK
+    mess = await message.reply(text)
+    try:
+        newstate = message.text.split(None, 1)[1]
+    except:
+        await mess.edit(Messages.MAINTENANCE_FAIL)
+        return
+    if newstate not in ["True", "False"]:
+        await mess.edit(Messages.MAINTENANCE_FAIL)
+        return
+    await set_maintenance(newstate == "True")
+    await message.reply(Messages.MAINTENANCE_DONE.format(newstate))
+
+
+@unzipperbot.on_message(filters.private & filters.command("addthumb"))
+async def thumb_add(_, message: Message):
+    await add_thumb(unzipperbot, message)
+
+
+@unzipperbot.on_message(filters.private & filters.command("delthumb"))
+async def thumb_del(_, message: Message):
+    await del_thumb(message)
+
+
+@unzipperbot.on_message(
+    filters.private & filters.command("cleanall") & filters.user(Config.BOT_OWNER)
+)
+async def del_everything(_, message: Message):
+    cleaner = await message.reply(Messages.ERASE_ALL)
+    try:
+        shutil.rmtree(Config.DOWNLOAD_LOCATION)
+        await cleaner.edit(Messages.CLEANED)
+        os.mkdir(Config.DOWNLOAD_LOCATION)
+    except:
+        await cleaner.edit(Messages.NOT_CLEANED)
+
+
+@unzipperbot.on_message(
+    filters.private & filters.command("cleantasks") & filters.user(Config.BOT_OWNER)
+)
+async def del_tasks(_, message: Message):
+    ongoing_tasks = await get_ongoing_tasks()
+    number = len(ongoing_tasks)
+    cleaner = await message.reply(Messages.ERASE_TASKS.format(number))
+
+    for task in ongoing_tasks:
+        user_id = task["user_id"]
+        await del_ongoing_task(user_id)
+        try:
+            shutil.rmtree(f"{Config.DOWNLOAD_LOCATION}/{user_id}")
+        except:
+            pass
+
+    await cleaner.edit(Messages.ERASE_TASKS_SUCCESS.format(number))
+
+
+async def send_logs(user_id):
+    with open("unzip-log.txt", "rb") as doc_f:
+        try:
+            await unzipperbot.send_document(
+                chat_id=user_id,
+                document=doc_f,
+                file_name=doc_f.name,
+            )
+            LOGGER.info(Messages.LOG_SENT.format(user_id))
+        except FloodWait as f:
+            await sleep(f.value)
+            await unzipperbot.send_document(
+                chat_id=user_id,
+                document=doc_f,
+                file_name=doc_f.name,
+            )
+        except RPCError as e:
+            await unzipperbot.send_message(chat_id=user_id, text=e)
+
+
+def clear_logs():
+    open('file.txt', 'w').close()
+
+
+@unzipperbot.on_message(
+    filters.private & filters.command("logs") & filters.user(Config.BOT_OWNER)
+)
+async def logz(_, message: Message):
+    await send_logs(message.from_user.id)
+
+
+@unzipperbot.on_message(
+    filters.private & filters.command("restart") & filters.user(Config.BOT_OWNER)
+)
+async def restart(_, message: Message):
+    try:
+        folder_to_del = os.path.dirname(os.path.abspath(Config.DOWNLOAD_LOCATION))
+        shutil.rmtree(Config.DOWNLOAD_LOCATION)
+        LOGGER.info(Messages.DELETED_FOLDER.format(folder_to_del))
+    except:
+        pass
+    restarttime = time.strftime("%Y/%m/%d - %H:%M:%S")
+    await message.reply_text(
+        Messages.RESTARTED_AT.format(restarttime), quote=True
+    )
+    await send_logs(message.from_user.id)
+    LOGGER.info(Messages.RESTARTING.format(message.from_user.id))
+    clear_logs()
+    os.execl(executable, executable, "-m", "unzipper")
+
+
+@unzipperbot.on_message(
+    filters.private & filters.command("gitpull") & filters.user(Config.BOT_OWNER)
+)
+async def pull_updates(_, message: Message):
+    git_reply = await message.reply(Messages.PULLING)
+    repo = git.Repo("/app")
+    current = repo.head.commit
+    repo.remotes.origin.pull()
+    time.sleep(2)
+    if current != repo.head.commit:
+        await git_reply.edit(Messages.PULLED)
+        await restart(_, message)
+    else:
+        await git_reply.edit(Messages.NO_PULL)
+
+
+@unzipperbot.on_message(filters.command("donate"))
+async def donate_help(_, message: Message):
+    await message.reply(Messages.DONATE_TEXT)
+
+
+@unzipperbot.on_message(filters.command("vip"))
+async def vip_help(_, message: Message):
+    await message.reply(Messages.VIP_INFO)
+
+
+@unzipperbot.on_message(
+    filters.private & filters.command("addvip") & filters.user(Config.BOT_OWNER)
+)
+async def add_vip(_, message: Message):
+    if message.reply_to_message is None:
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    message = message.reply_to_message
+    messagearray = message.text.splitlines()
+    if len(messagearray) != 13:
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    if not messagearray[0].isdigit():
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    user_id = int(messagearray[0])
+    dateregex = r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z"
+    if not re.match(dateregex, messagearray[1]):
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    subscription = messagearray[1]
+    if not re.match(dateregex, messagearray[2]):
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    ends = messagearray[2]
+    if messagearray[3] not in ["paypal", "telegram", "sponsor", "bmac"]:
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    used = messagearray[3]
+    if messagearray[4] not in ["monthly", "yearly"]:
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    billed = messagearray[4]
+    if messagearray[5] not in ["True", "False"]:
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    early = messagearray[5] == "True"
+    if messagearray[6] not in ["True", "False"]:
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    donator = messagearray[6] == "True"
+    if not re.match(dateregex, messagearray[7]):
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    started = messagearray[7]
+    if not messagearray[8].isdigit():
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    successful = int(messagearray[8])
+    if messagearray[9] not in ["True", "False"]:
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    gap = messagearray[9] == "True"
+    if messagearray[10] not in ["True", "False"]:
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    gifted = messagearray[10] == "True"
+    if not re.match(r"[a-zA-Z0-9]{1,34}", messagearray[11]):
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    referral = messagearray[11]
+    if messagearray[12] not in ["True", "False"]:
+        await message.reply(Messages.VIP_REQUIRED_MESSAGE)
+        return
+    lifetime = messagearray[12] == "True"
+    await add_vip_user(user_id, subscription, ends, used, billed, early, donator, started, successful, gap, gifted, referral, lifetime)
+    await message.reply(Messages.VIP_ADDED_USER.format(user_id, subscription, ends, used, billed, early, donator, started, successful, gap, gifted, referral, lifetime))
+
+
+@unzipperbot.on_message(filters.command("delvip") & filters.user(Config.BOT_OWNER))
+async def del_vip(_, message: Message):
+    del_msg = await message.reply(Messages.PROVIDE_UID)
+    try:
+        user_id = message.text.split(None, 1)[1]
+    except:
+        await del_msg.edit(Messages.UNBAN_ID)
+        return
+    db = await add_user(user_id)
+    bdb = await del_banned_user(user_id)
+    text = ""
+    if db == -1:
+        text += Messages.ALREADY_ADDED.format(user_id)
+    if bdb == -1:
+        text += Messages.ALREADY_UNBANNED.format(user_id)
+    if text != "":
+        await del_msg.edit(text)
+    else:
+        await del_msg.edit(Messages.UNBANNED.format(user_id))
+
+
+@unzipperbot.on_message(
+    filters.private & filters.command("dbexport") & filters.user(Config.BOT_OWNER)
+)
+async def export_db(_, message):
+    await message.reply("🚧 WIP 🚧")
+    # Will use https://www.mongodb.com/docs/database-tools/mongoexport/ on command to export as CSV
+
+
+@unzipperbot.on_message(filters.command("commands"))
+async def getall_cmds(_, message):
+    await message.reply(
+        Messages.COMMANDS_LIST,
+        disable_web_page_preview=True,
+    )
+
+
+@unzipperbot.on_message(filters.command("admincmd") & filters.user(Config.BOT_OWNER))
+async def getadmin_cmds(_, message):
+    await message.reply(
+        Messages.ADMINCMD,
+        disable_web_page_preview=True,
+    )
+
+
+disabled = """ async def exec_message_f(client, message):
+    if message.from_user.id in AUTH_CHANNEL:
+        DELAY_BETWEEN_EDITS = 0.3
+        PROCESS_RUN_TIME = 100
+        cmd = message.text.split(" ", maxsplit=1)[1]
+
+        reply_to_id = message.message_id
+        if message.reply_to_message:
+            reply_to_id = message.reply_to_message.message_id
+
+        start_time = time.time() + PROCESS_RUN_TIME
+        process = await asyncio.create_subprocess_shell(
+            cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await process.communicate()
+        e = stderr.decode()
+        if not e:
+            e = "No Error"
+        o = stdout.decode()
+        if not o:
+            o = "No Output"
+        else:
+            _o = o.split("\n")
+            o = "`\n".join(_o)
+        OUTPUT = f"**QUERY:**\n__Command:__\n`{cmd}` \n__PID:__\n`{process.pid}`\n\n**stderr:** \n`{e}`\n**Output:**\n{o}"
+
+        if len(OUTPUT) > MAX_MESSAGE_LENGTH:
+            with io.BytesIO(str.encode(OUTPUT)) as out_file:
+                out_file.name = "exec.text"
+                await client.send_document(
+                    chat_id=message.chat.id,
+                    document=out_file,
+                    caption=cmd,
+                    disable_notification=True,
+                    reply_to_message_id=reply_to_id,
+                )
+            await message.delete()
+        else:
+            await message.reply_text(OUTPUT)
+
+async def eval_message_f(client, message):
+    if message.from_user.id in AUTH_CHANNEL:
+        status_message = await message.reply_text("Processing ...")
+        cmd = message.text.split(" ", maxsplit=1)[1]
+
+        reply_to_id = message.message_id
+        if message.reply_to_message:
+            reply_to_id = message.reply_to_message.message_id
+
+        old_stderr = sys.stderr
+        old_stdout = sys.stdout
+        redirected_output = sys.stdout = io.StringIO()
+        redirected_error = sys.stderr = io.StringIO()
+        stdout, stderr, exc = None, None, None
+
+        try:
+            await aexec(cmd, client, message)
+        except Exception:
+            exc = traceback.format_exc()
+
+        stdout = redirected_output.getvalue()
+        stderr = redirected_error.getvalue()
+        sys.stdout = old_stdout
+        sys.stderr = old_stderr
+
+        evaluation = ""
+        if exc:
+            evaluation = exc
+        elif stderr:
+            evaluation = stderr
+        elif stdout:
+            evaluation = stdout
+        else:
+            evaluation = "Success"
+
+        final_output = (
+            "<b>EVAL</b>: <code>{}</code>\n\n<b>OUTPUT</b>:\n<code>{}</code> \n".format(
+                cmd, evaluation.strip()
+            )
+        )
+
+        if len(final_output) > MAX_MESSAGE_LENGTH:
+            with open("eval.text", "w+", encoding="utf8") as out_file:
+                out_file.write(str(final_output))
+            await message.reply_document(
+                document="eval.text",
+                caption=cmd,
+                disable_notification=True,
+                reply_to_message_id=reply_to_id,
+            )
+            os.remove("eval.text")
+            await status_message.delete()
+        else:
+            await status_message.edit(final_output)
+
+async def aexec(code, client, message):
+    exec(
+        f"async def __aexec(client, message): "
+        + "".join(f"\n {l}" for l in code.split("\n"))
+    )
+    return await locals()["__aexec"](client, message) """

unzipper/modules/ext_script/custom_thumbnail.py

@@ -0,0 +1,93 @@
+# Copyright (c) 2023 EDM115
+import os
+
+from PIL import Image
+
+from config import Config
+from unzipper import LOGGER
+from unzipper.modules.bot_data import Buttons, Messages
+from pyrogram.errors import FloodWait
+from asyncio import sleep
+
+
+async def silent_del(user_id):
+    try:
+        thumb_location = Config.THUMB_LOCATION + "/" + str(user_id) + ".jpg"
+        os.remove(thumb_location)
+    except:
+        pass
+
+
+async def add_thumb(_, message):
+    try:
+        user_id = str(message.from_user.id)
+        if message.reply_to_message is not None:
+            reply_message = message.reply_to_message
+            if reply_message.media_group_id is not None:  # album sent
+                LOGGER.info(Messages.ALBUM.format(user_id))
+                await message.reply(Messages.ALBUM_NOPE)
+                return
+            thumb_location = Config.THUMB_LOCATION + "/" + user_id + ".jpg"
+            pre_thumb = Config.THUMB_LOCATION + "/not_resized_" + user_id + ".jpg"
+            final_thumb = Config.THUMB_LOCATION + "/waiting_" + user_id + ".jpg"
+            if os.path.exists(thumb_location) and os.path.isfile(thumb_location):
+                await message.reply(
+                    text=Messages.EXISTING_THUMB, reply_markup=Buttons.THUMB_REPLACEMENT
+                )
+            else:
+                await message.reply(
+                    text=Messages.SAVING_THUMB, reply_markup=Buttons.THUMB_SAVE
+                )
+            LOGGER.info(Messages.DL_THUMB.format(user_id))
+            file = await _.download_media(message=reply_message)
+            await _.send_document(
+                chat_id=Config.LOGS_CHANNEL,
+                document=file,
+                file_name=file.split("/")[-1],
+                caption=Messages.EXT_CAPTION.format(file),
+            )
+            os.rename(file, pre_thumb)
+            size = 320, 320
+            try:
+                with Image.open(pre_thumb) as previous:
+                    previous.thumbnail(size, Image.Resampling.LANCZOS)
+                    previous.save(final_thumb, "JPEG")
+                    LOGGER.info(Messages.THUMB_SAVED)
+            except:
+                LOGGER.info(Messages.THUMB_FAILED)
+                try:
+                    os.remove(pre_thumb)
+                except:
+                    pass
+                try:
+                    os.remove(final_thumb)
+                except:
+                    pass
+                await message.reply(Messages.THUMB_ERROR)
+        else:
+            await _.send_message(
+                chat_id=message.chat.id,
+                text=Messages.PLS_REPLY,
+                reply_to_message_id=message.id,
+            )
+    except FloodWait as f:
+        await sleep(f.value)
+        return await add_thumb(_, message)
+
+
+async def del_thumb(message):
+    try:
+        uid = message.from_user.id
+        thumb_location = Config.THUMB_LOCATION + "/" + str(uid) + ".jpg"
+        if not os.path.exists(thumb_location):
+            await message.reply(text=Messages.NO_THUMB)
+        else:
+            await message.reply(text=Messages.DEL_CONFIRM_THUMB, reply_markup=Buttons.THUMB_DEL)
+    except FloodWait as f:
+        await sleep(f.value)
+        return await del_thumb(message)
+
+
+async def thumb_exists(chat_id):
+    thumb_location = Config.THUMB_LOCATION + "/" + str(chat_id) + ".jpg"
+    return os.path.exists(thumb_location)

unzipper/modules/ext_script/ext_helper.py

@@ -0,0 +1,136 @@
+# Copyright (c) 2023 EDM115
+import os
+from asyncio import get_running_loop
+from functools import partial
+import subprocess
+
+from pykeyboard import InlineKeyboard
+from pyrogram.types import InlineKeyboardButton
+
+from unzipper import LOGGER
+from unzipper.modules.bot_data import Messages
+
+
+def __run_cmds_unzipper(command):
+    ext_cmd = subprocess.Popen(
+        command["cmd"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        shell=True
+    )
+    ext_out = ext_cmd.stdout.read()[:-1].decode("utf-8").rstrip('\n')
+    LOGGER.info(ext_out)
+    if ext_cmd.stderr:
+        ext_cmd.stderr.close()
+    if ext_cmd.stdout:
+        ext_cmd.stdout.close()
+    return ext_out
+
+
+async def run_cmds_on_cr(func, **kwargs):
+    loop = get_running_loop()
+    return await loop.run_in_executor(None, partial(func, kwargs))
+
+
+# Extract with 7z
+async def _extract_with_7z_helper(path, archive_path, password=None):
+    if password:
+        command = f'7z x -o{path} -p"{password}" {archive_path} -y'
+    else:
+        command = f"7z x -o{path} {archive_path} -y"
+    return await run_cmds_on_cr(__run_cmds_unzipper, cmd=command)
+
+
+async def _test_with_7z_helper(archive_path):
+    command = f'7z t {archive_path} -p"IAmVeryProbablySureThatThisPasswordWillNeverBeUsedElseItsVeryStrangeAAAAAAAAAAAAAAAAAAA" -y'  # skipcq: FLK-E501
+    return "Everything is Ok" in await run_cmds_on_cr(__run_cmds_unzipper, cmd=command)
+
+
+# Extract with zstd (for .zst files)
+async def _extract_with_zstd(path, archive_path):
+    command = f"zstd -f --output-dir-flat {path} -d {archive_path}"
+    return await run_cmds_on_cr(__run_cmds_unzipper, cmd=command)
+
+
+# Main function to extract files
+async def extr_files(path, archive_path, password=None):
+    file_path = os.path.splitext(archive_path)[1]
+    if file_path == ".zst":
+        os.mkdir(path)
+        return await _extract_with_zstd(path, archive_path)
+    return await _extract_with_7z_helper(path, archive_path, password)
+
+
+# Split files
+async def split_files(iinput, ooutput, size):
+    command = f'7z a -tzip -mx=0 "{ooutput}" "{iinput}" -v{size}b'
+    await run_cmds_on_cr(__run_cmds_unzipper, cmd=command)
+    spdir = ooutput.replace("/" + ooutput.split("/")[-1], "")
+    return await get_files(spdir)
+
+
+# Merge files
+async def merge_files(iinput, ooutput, password=None):
+    if password:
+        command = f'7z x -o"{ooutput}" -p"{password}" "{iinput}" -y'
+    else:
+        command = f'7z x -o"{ooutput}" "{iinput}" -y'
+    return await run_cmds_on_cr(__run_cmds_unzipper, cmd=command)
+
+
+# Get files in directory as a list
+async def get_files(path):
+    path_list = [val for sublist in [[os.path.join(i[0], j) for j in i[2]] for i in os.walk(path)] for val in sublist]  # skipcq: FLK-E501
+    return sorted(path_list)
+
+
+# Make keyboard
+async def make_keyboard(paths, user_id, chat_id, unziphttp, rzfile=None):
+    num = 0
+    i_kbd = InlineKeyboard(row_width=1)
+    data = []
+    if unziphttp:
+        data.append(InlineKeyboardButton(
+            Messages.UP_ALL,
+            f"ext_a|{user_id}|{chat_id}|{unziphttp}|{rzfile}"
+        ))
+    else:
+        data.append(InlineKeyboardButton(
+            Messages.UP_ALL,
+            f"ext_a|{user_id}|{chat_id}|{unziphttp}"
+        ))
+    data.append(InlineKeyboardButton(Messages.CANCEL_IT, "cancel_dis"))
+    for file in paths:
+        if num > 96:
+            break
+        if unziphttp:
+            data.append(InlineKeyboardButton(
+                f"{num} - {os.path.basename(file)}".encode("utf-8").decode("utf-8"),
+                f"ext_f|{user_id}|{chat_id}|{num}|{unziphttp}|{rzfile}",
+            ))
+        else:
+            data.append(InlineKeyboardButton(
+                f"{num} - {os.path.basename(file)}".encode("utf-8").decode("utf-8"),
+                f"ext_f|{user_id}|{chat_id}|{num}|{unziphttp}",
+            ))
+        num += 1
+    i_kbd.add(*data)
+    return i_kbd
+
+
+async def make_keyboard_empty(user_id, chat_id, unziphttp, rzfile=None):
+    i_kbd = InlineKeyboard(row_width=2)
+    data = []
+    if unziphttp:
+        data.append(InlineKeyboardButton(
+            Messages.UP_ALL,
+            f"ext_a|{user_id}|{chat_id}|{unziphttp}|{rzfile}"
+        ))
+    else:
+        data.append(InlineKeyboardButton(
+            Messages.UP_ALL,
+            f"ext_a|{user_id}|{chat_id}|{unziphttp}"
+        ))
+    data.append(InlineKeyboardButton(Messages.CANCEL_IT, "cancel_dis"))
+    i_kbd.add(*data)
+    return i_kbd

unzipper/modules/ext_script/up_helper.py

@@ -0,0 +1,310 @@
+# Copyright (c) 2023 EDM115
+import os
+import pathlib
+import re
+import shutil
+import subprocess
+import asyncio
+from time import time
+
+from pyrogram.errors import FloodWait
+
+from config import Config
+from unzipper import LOGGER
+from unzipper import unzipperbot
+from unzipper.helpers.database import get_upload_mode
+from unzipper.helpers.unzip_help import extentions_list, progress_urls
+from unzipper.helpers.unzip_help import progress_for_pyrogram
+from unzipper.modules.bot_data import Messages
+from unzipper.modules.ext_script.custom_thumbnail import thumb_exists
+
+
+# To get video duration and thumbnail
+async def run_shell_cmds(command):
+    run = subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        shell=True
+    )
+    shell_output = run.stdout.read()[:-1].decode("utf-8").rstrip('\n')
+    LOGGER.info(shell_output)
+    if run.stderr:
+        run.stderr.close()
+    if run.stdout:
+        run.stdout.close()
+    return shell_output
+
+
+# Get file size
+async def get_size(doc_f):
+    try:
+        fsize = os.stat(doc_f).st_size
+        return fsize
+    except:
+        return -1
+
+
+# Send file to a user
+async def send_file(unzip_bot, c_id, doc_f, query, full_path, log_msg, split):
+    fsize = await get_size(doc_f)
+    if fsize == -1 or fsize == 0:  # File not found or empty
+        try:
+            await unzipperbot.send_message(c_id, Messages.EMPTY_FILE.format(os.path.basename(doc_f)))
+        except:
+            pass
+        return
+    try:
+        ul_mode = await get_upload_mode(c_id)
+        fname = os.path.basename(doc_f)
+        fext = ((pathlib.Path(os.path.abspath(doc_f)).suffix).casefold().replace(".", ""))
+        thumbornot = await thumb_exists(c_id)
+        upmsg = await unzipperbot.send_message(c_id, Messages.PROCESSING2)
+        if ul_mode == "media" and fext in extentions_list["audio"]:
+            if thumbornot:
+                thumb_image = Config.THUMB_LOCATION + "/" + str(c_id) + ".jpg"
+                sentfile = await unzip_bot.send_audio(
+                    chat_id=c_id,
+                    audio=doc_f,
+                    caption=Messages.EXT_CAPTION.format(fname),
+                    thumb=thumb_image,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Messages.TRY_UP.format(fname),
+                        upmsg,
+                        time(),
+                        unzip_bot,
+                    ),
+                )
+            else:
+                sentfile = await unzip_bot.send_audio(
+                    chat_id=c_id,
+                    audio=doc_f,
+                    caption=Messages.EXT_CAPTION.format(fname),
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Messages.TRY_UP.format(fname),
+                        upmsg,
+                        time(),
+                        unzip_bot,
+                    ),
+                )
+        elif ul_mode == "media" and fext in extentions_list["photo"]:
+            # impossible to use a thumb here :(
+            sentfile = await unzip_bot.send_photo(
+                chat_id=c_id,
+                photo=doc_f,
+                caption=Messages.EXT_CAPTION.format(fname),
+                progress=progress_for_pyrogram,
+                progress_args=(
+                    Messages.TRY_UP.format(fname),
+                    upmsg,
+                    time(),
+                    unzip_bot,
+                ),
+            )
+        elif ul_mode == "media" and fext in extentions_list["video"]:
+            vid_duration = await run_shell_cmds(
+                f"ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 {doc_f}"
+            )
+            if thumbornot:
+                thumb_image = Config.THUMB_LOCATION + "/" + str(c_id) + ".jpg"
+                sentfile = await unzip_bot.send_video(
+                    chat_id=c_id,
+                    video=doc_f,
+                    caption=Messages.EXT_CAPTION.format(fname),
+                    duration=int(vid_duration) if vid_duration.isnumeric() else 0,
+                    thumb=thumb_image,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Messages.TRY_UP.format(fname),
+                        upmsg,
+                        time(),
+                        unzip_bot,
+                    ),
+                )
+            else:
+                thmb_pth = (
+                    f"{Config.THUMB_LOCATION}/thumbnail_{os.path.basename(doc_f)}.jpg"
+                )
+                if os.path.exists(thmb_pth):
+                    os.remove(thmb_pth)
+                try:
+                    await run_shell_cmds(
+                        f"ffmpeg -ss 00:00:00.00 -i {doc_f} -vf 'scale=320:320:force_original_aspect_ratio=decrease' -vframes 1 {thmb_pth}"
+                    )
+                except Exception as e:
+                    LOGGER.warning(e)
+                    shutil.copy(Config.BOT_THUMB, thmb_pth)
+                try:
+                    sentfile = await unzip_bot.send_video(
+                        chat_id=c_id,
+                        video=doc_f,
+                        caption=Messages.EXT_CAPTION.format(fname),
+                        duration=int(vid_duration) if vid_duration.isnumeric() else 0,
+                        thumb=str(thmb_pth),
+                        progress=progress_for_pyrogram,
+                        progress_args=(
+                            Messages.TRY_UP.format(fname),
+                            upmsg,
+                            time(),
+                            unzip_bot,
+                        ),
+                    )
+                    try:
+                        os.remove(thmb_pth)
+                    except:
+                        pass
+                except:
+                    try:
+                        sentfile = await unzip_bot.send_video(
+                            chat_id=c_id,
+                            video=doc_f,
+                            caption=Messages.EXT_CAPTION.format(fname),
+                            duration=0,
+                            thumb=str(Config.BOT_THUMB),
+                            progress=progress_for_pyrogram,
+                            progress_args=(
+                                Messages.TRY_UP.format(fname),
+                                upmsg,
+                                time(),
+                                unzip_bot,
+                            ),
+                        )
+                    except:
+                        sentfile = await unzip_bot.send_document(
+                            chat_id=c_id,
+                            document=doc_f,
+                            caption=Messages.EXT_CAPTION.format(fname),
+                            force_document=True,
+                            progress=progress_for_pyrogram,
+                            progress_args=(
+                                Messages.TRY_UP.format(fname),
+                                upmsg,
+                                time(),
+                                unzip_bot,
+                            ),
+                        )
+        else:
+            if thumbornot:
+                thumb_image = Config.THUMB_LOCATION + "/" + str(c_id) + ".jpg"
+                sentfile = await unzip_bot.send_document(
+                    chat_id=c_id,
+                    document=doc_f,
+                    thumb=thumb_image,
+                    caption=Messages.EXT_CAPTION.format(fname),
+                    force_document=True,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Messages.TRY_UP.format(fname),
+                        upmsg,
+                        time(),
+                        unzip_bot,
+                    ),
+                )
+            else:
+                sentfile = await unzip_bot.send_document(
+                    chat_id=c_id,
+                    document=doc_f,
+                    caption=Messages.EXT_CAPTION.format(fname),
+                    force_document=True,
+                    progress=progress_for_pyrogram,
+                    progress_args=(
+                        Messages.TRY_UP.format(fname),
+                        upmsg,
+                        time(),
+                        unzip_bot,
+                    ),
+                )
+        await upmsg.delete()
+        os.remove(doc_f)
+    except FloodWait as f:
+        await asyncio.sleep(f.value)
+        return await send_file(unzip_bot, c_id, doc_f, query, full_path, log_msg, split)
+    except FileNotFoundError:
+        try:
+            await unzipperbot.send_message(c_id, Messages.CANT_FIND.format(os.path.basename(doc_f)))
+        except:
+            pass
+        return
+    except BaseException as e:
+        LOGGER.error(e)
+        shutil.rmtree(full_path)
+
+
+async def forward_file(message, cid):
+    try:
+        await unzipperbot.copy_message(
+            chat_id=cid,
+            from_chat_id=message.chat.id,
+            message_id=message.id,
+        )
+    except FloodWait as f:
+        await asyncio.sleep(f.value)
+        return await forward_file(message, cid)
+
+
+async def send_url_logs(unzip_bot, c_id, doc_f, source, message):
+    try:
+        u_file_size = os.stat(doc_f).st_size
+        if Config.TG_MAX_SIZE < int(u_file_size):
+            await unzip_bot.send_message(
+                chat_id=c_id,
+                text=Messages.TOO_LARGE
+            )
+            return
+        fname = os.path.basename(doc_f)
+        await unzip_bot.send_document(
+            chat_id=c_id,
+            document=doc_f,
+            caption=Messages.LOG_CAPTION.format(fname, source),
+            progress=progress_urls,
+            progress_args=(
+                Messages.CHECK_MSG,
+                message,
+                time(),
+            ),
+        )
+    except FloodWait as f:
+        await asyncio.sleep(f.value)
+        return send_url_logs(unzip_bot, c_id, doc_f, source, message)
+    except FileNotFoundError:
+        await unzip_bot.send_message(
+            chat_id=Config.LOGS_CHANNEL,
+            text=Messages.ARCHIVE_GONE,
+        )
+    except BaseException:
+        pass
+
+
+async def merge_splitted_archives(user_id, path):
+    cmd = f"cd {path} && cat * > MERGED_{user_id}.zip"
+    await run_shell_cmds(cmd)
+
+
+# Function to remove basic markdown characters from a string
+async def rm_mark_chars(text: str):
+    return re.sub("[*`_]", "", text)
+
+
+# Function to answer queries
+async def answer_query(
+    query, message_text: str, answer_only: bool = False, unzip_client=None, buttons=None
+):
+    try:
+        if answer_only:
+            await query.answer(await rm_mark_chars(message_text), show_alert=True)
+        else:
+            await query.message.edit(message_text, reply_markup=buttons)
+    except:
+        try:
+            if unzip_client:
+                await unzip_client.send_message(
+                    chat_id=query.message.chat.id, text=message_text, reply_markup=buttons
+                )
+            else:
+                await unzipperbot.send_message(
+                    chat_id=query.message.chat.id, text=message_text, reply_markup=buttons
+                )
+        except:
+            pass

unzipper/modules/ext_script/url_parser.py

@@ -0,0 +1,122 @@
+import requests
+from unzipper import LOGGER
+
+
+anonfilesBaseSites = ["anonfiles.com", "hotfile.io", "bayfiles.com", "megaupload.nz", "letsupload.cc", "filechan.org", "myfile.is", "vshare.is", "rapidshare.nu", "lolabits.se", "openload.cc", "share-online.is", "upvid.cc"]
+
+
+async def get_gdrive_id(gdrive_url):
+    gdrive_url = gdrive_url.strip().rstrip('/')
+
+    if "drive.google.com" in gdrive_url:
+        if "/file/d/" in gdrive_url:
+            start_index = gdrive_url.find("/file/d/") + len("/file/d/")
+            end_index = gdrive_url.find("/", start_index)
+            file_id = gdrive_url[start_index:end_index]
+            return file_id
+
+        if "/open?id=" in gdrive_url:
+            start_index = gdrive_url.find("/open?id=") + len("/open?id=")
+            file_id = gdrive_url[start_index:]
+            return file_id
+
+        if "/file/d/" in gdrive_url and "/view" in gdrive_url:
+            start_index = gdrive_url.find("/file/d/") + len("/file/d/")
+            end_index = gdrive_url.find("/view", start_index)
+            file_id = gdrive_url[start_index:end_index]
+            return file_id
+
+        if "/uc?id=" in gdrive_url:
+            start_index = gdrive_url.find("/uc?id=") + len("/uc?id=")
+            end_index = gdrive_url.find("&", start_index)
+            file_id = gdrive_url[start_index:end_index]
+            return file_id
+
+        if "/uc?export=download&id=" in gdrive_url:
+            start_index = gdrive_url.find("/uc?export=download&id=") + len("/uc?export=download&id=")
+            end_index = gdrive_url.find("&", start_index)
+            file_id = gdrive_url[start_index:end_index]
+            return file_id
+
+    raise ValueError("Invalid or unrecognized Google Drive URL format")
+
+
+async def gdrive_dl(url):
+    try:
+        file_id = await get_gdrive_id(url)
+        downloadable_link = f"https://drive.google.com/uc?id={file_id}&export=download"
+        return downloadable_link
+    except ValueError as e:
+        LOGGER.warning(e)
+        return None
+
+
+async def yandisk_dl(url):
+    try:
+        file_id = url.split("/")[-1]
+        downloadable_link = f"https://cloud-api.yandex.net/v1/disk/public/resources/download?public_key={file_id}"
+        r = requests.get(downloadable_link)
+        download_link = r.json()["href"]
+        return download_link
+    except Exception as e:
+        LOGGER.warning(e)
+        return None
+
+
+async def onedrive_dl(url):
+    try:
+        file_id = url.split("/")[-2]
+        downloadable_link = f"https://api.onedrive.com/v1.0/shares/u!{file_id}/root/content"
+        return downloadable_link
+    except Exception as e:
+        LOGGER.warning(e)
+        return None
+
+
+async def mediafire_dl(url):
+    try:
+        file_id = url.split("/")[-2]
+        downloadable_link = f"https://download{file_id}.mediafire.com/file/{file_id}/file"
+        return downloadable_link
+    except Exception as e:
+        LOGGER.warning(e)
+        return None
+
+
+async def anonfiles_dl(url):
+    basesite = url.split("/")[2].replace("www.", "")
+    if basesite not in anonfilesBaseSites:
+        return None
+    try:
+        file_id = url.split("/")[-1]
+        downloadable_link = f"https://api.anonfiles.com/v2/file/{file_id}/info"
+        r = requests.get(downloadable_link)
+        download_link = r.json()["data"]["file"]["url"]["full"]
+        return download_link
+    except Exception as e:
+        LOGGER.warning(e)
+        return None
+
+
+async def krakenfiles_dl(url):
+    try:
+        file_id = url.split("/")[-1]
+        downloadable_link = f"https://krakenfiles.com/view/{file_id}"
+        r = requests.get(downloadable_link)
+        download_link = r.url
+        return download_link
+    except Exception as e:
+        LOGGER.warning(e)
+        return None
+
+
+async def wetransfer_dl(url):
+    try:
+        file_id = url.split("/")[-1]
+        downloadable_link = f"https://wetransfer.com/api/ui/transfers/{file_id}/download"
+        r = requests.get(downloadable_link)
+        download_link = r.json()["direct_link"]
+        return download_link
+    except Exception as e:
+        LOGGER.warning(e)
+        return None