Initial commit: Push project to Hugging Face

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,26 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Used this Command with this link or file.
+2. Before/after/while Upload ..
+3. Check logs
+
+**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: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**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/workflows/ruff_format.yml

@@ -0,0 +1,45 @@
+name: Format Code via Ruff
+
+on:
+  workflow_dispatch:
+    inputs:
+      branch:
+        description: 'Branch to format'
+        required: true
+        default: 'wzv3'
+        type: string
+
+jobs:
+  code-format:
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout Repo
+      uses: actions/checkout@v4
+      with:
+        ref: ${{ github.event.inputs.branch }}
+
+    - name: Set up Python3
+      uses: actions/setup-python@v4
+
+    - name: Install ruff Linter
+      run: pip install ruff
+
+    - name: Run ruff to format code
+      run: |
+        ruff check . --exit-zero
+        ruff format .
+        git add -u
+
+    - name: Commit and Push Changes
+      run: |
+        git config --global user.name "github-actions[bot]"
+        git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+        if git diff-index --quiet HEAD --; then
+          echo "No changes to commit."
+        else
+          git commit -m "style: Auto Ruff Formatter"
+          git push origin ${{ github.ref }}
+        fi

.gitignore

@@ -0,0 +1,18 @@
+.venv/*
+config.py
+token.pickle
+rclone.conf
+.netrc
+log.txt
+cfg.zip
+accounts/*
+thumbnails/*
+rclone/*
+tokens/*
+cookies/*
+mediainfo/*
+sabnzbd/*
+list_drives.txt
+shortener.txt
+cookies.txt
+downloads/*

Dockerfile

@@ -0,0 +1,13 @@
+FROM mysterysd/wzmlx:v3
+
+WORKDIR /usr/src/app
+
+RUN chmod 777 /usr/src/app
+RUN uv venv --system-site-packages
+
+COPY requirements.txt .
+RUN uv pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["bash", "start.sh"]

LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

README.md

@@ -0,0 +1,189 @@
+<p align="center">
+    <a href="https://github.com/SilentDemonSD/WZML-X">
+        <kbd>
+            <img width="250" src="https://graph.org/file/639fe4239b78e5862b302.jpg" alt="WZML-X Logo">
+        </kbd>
+    </a>
+
+<i>This repository is a feature-enhanced version of the [mirror-leech-telegram-bot](https://github.com/anasty17/mirror-leech-telegram-bot). It integrates various improvements from multiple sources, expanding functionality while maintaining efficiency. Unlike the base repository, this version is fully deployable on Heroku.</i>
+
+</p>
+
+<div align=center>
+
+[![](https://img.shields.io/github/repo-size/weebzone/WZML-X?color=green&label=Repo%20Size&labelColor=292c3b)](#) [![](https://img.shields.io/github/commit-activity/m/weebzone/WZML-X?logo=github&labelColor=292c3b&label=Github%20Commits)](#) [![](https://img.shields.io/github/license/weebzone/WZML-X?style=flat&label=License&labelColor=292c3b)](#)|[![](https://img.shields.io/github/issues-raw/weebzone/WZML-X?style=flat&label=Open%20Issues&labelColor=292c3b)](#) [![](https://img.shields.io/github/issues-closed-raw/weebzone/WZML-X?style=flat&label=Closed%20Issues&labelColor=292c3b)](#) [![](https://img.shields.io/github/issues-pr-raw/weebzone/WZML-X?style=flat&label=Open%20Pull%20Requests&labelColor=292c3b)](#) [![](https://img.shields.io/github/issues-pr-closed-raw/weebzone/WZML-X?style=flat&label=Closed%20Pull%20Requests&labelColor=292c3b)](#)
+:---:|:---:|
+[![](https://img.shields.io/github/languages/count/weebzone/WZML-X?style=flat&label=Total%20Languages&labelColor=292c3b&color=blueviolet)](#) [![](https://img.shields.io/github/languages/top/weebzone/WZML-X?style=flat&logo=python&labelColor=292c3b)](#) [![](https://img.shields.io/github/last-commit/weebzone/WZML-X?style=flat&label=Last%20Commit&labelColor=292c3b&color=important)](#) [![](https://badgen.net/github/branches/weebzone/WZML-X?label=Total%20Branches&labelColor=292c3b)](#)|[![](https://img.shields.io/github/forks/weebzone/WZML-X?style=flat&logo=github&label=Forks&labelColor=292c3b&color=critical)](#) [![](https://img.shields.io/github/stars/weebzone/WZML-X?style=flat&logo=github&label=Stars&labelColor=292c3b&color=yellow)](#) [![](https://badgen.net/docker/pulls/codewithweeb/weebzone?icon=docker&label=Pulls&labelColor=292c3b&color=blue)](#)
+[![](https://img.shields.io/badge/Telegram%20Channel-Join-9cf?style=for-the-badge&logo=telegram&logoColor=blue&style=flat&labelColor=292c3b)](https://t.me/WZML_X) |[![](https://img.shields.io/badge/Support%20Group-Join-9cf?style=for-the-badge&logo=telegram&logoColor=blue&style=flat&labelColor=292c3b)](https://t.me/WZML_Support) |
+
+</div>
+
+---
+Below is a refined version that preserves all the important details while enhancing readability and design :
+
+---
+
+# Deployment Guide (VPS)
+
+<details>
+  <summary><strong>View All Steps <kbd>Click Here</kbd></strong></summary>
+
+---
+
+## 1. Prerequisites
+
+- **Tutorial Video from A to Z (Latest Video)**
+- Special thanks to [Wiszky](https://github.com/vishnoe115)
+
+[![See Video](https://img.shields.io/badge/See%20Video-black?style=for-the-badge&logo=YouTube)](https://youtu.be/xzLOLyKYl54)
+
+---
+
+## 2. Installing Requirements
+
+Clone this repository:
+
+```bash
+git clone https://github.com/SilentDemonSD/WZML-X mirrorbot/ && cd mirrorbot
+```
+
+---
+
+## 3. Build and Run the Docker Image
+
+*Make sure you mount the app folder and install Docker following the official documentation.*
+
+There are two methods to build and run the Docker image:
+
+### 3.1 Using Official Docker Commands
+
+- **Start Docker daemon** (skip if already running):
+
+  ```bash
+  sudo dockerd
+  ```
+
+- **Build the Docker image:**
+
+  ```bash
+  sudo docker build . -t wzmlx
+  ```
+
+- **Run the image:**
+
+  ```bash
+  sudo docker run -p 80:80 -p 8080:8080 wzmlx
+  ```
+
+- **To stop the running image:**
+
+  First, list running containers:
+
+  ```bash
+  sudo docker ps
+  ```
+
+  Then, stop the container using its ID:
+
+  ```bash
+  sudo docker stop <container_id>
+  ```
+
+---
+
+### 3.2 Using docker-compose (Recommended)
+
+**Note:** If you want to use ports other than 80 and 8080 for torrent file selection and rclone serve respectively, update them in [docker-compose.yml](https://github.com/weebzone/WZML-X/blob/master/docker-compose.yml).
+
+- **Install docker-compose:**
+
+  ```bash
+  sudo apt install docker-compose
+  ```
+
+- **Build and run the Docker image (or view the current running image):**
+
+  ```bash
+  sudo docker-compose up
+  ```
+
+- **After editing files (e.g., using nano to edit start.sh), rebuild:**
+
+  ```bash
+  sudo docker-compose up --build
+  ```
+
+- **To stop the running image:**
+
+  ```bash
+  sudo docker-compose stop
+  ```
+
+- **To restart the image:**
+
+  ```bash
+  sudo docker-compose start
+  ```
+
+- **To view the latest logs from the running container (after mounting the folder):**
+
+  ```bash
+  sudo docker-compose up
+  ```
+
+- **Tutorial Video for docker-compose and checking ports:**
+
+  [![See Video](https://img.shields.io/badge/See%20Video-black?style=for-the-badge&logo=YouTube)](https://youtu.be/c8_TU1sPK08)
+
+
+------
+
+#### Docker Notes
+
+**IMPORTANT NOTES**:
+
+1. Set `BASE_URL_PORT` and `RCLONE_SERVE_PORT` variables to any port you want to use. Default is `80` and `8080` respectively.
+2. You should stop the running image before deleting the container and you should delete the container before the image.
+3. To delete the container (this will not affect on the image):
+
+```
+sudo docker container prune
+```
+
+4. To delete te images:
+
+```
+sudo docker image prune -a
+```
+
+5. Check the number of processing units of your machine with `nproc` cmd and times it by 4, then edit `AsyncIOThreadsCount` in qBittorrent.conf.
+    
+  </details></li></ol>
+</details>
+    
+------
+
+# Deployment Guide (Heroku)
+
+<details>
+  <summary><strong>View All Steps <kbd>Click Here</kbd></strong></summary>
+
+---
+
+**Check the Docs Here :** [Click Here](https://github.com/SilentDemonSD/WZ-Deploy/tree/main?tab=readme-ov-file#2%EF%B8%8F⃣-method-2-github-workflow-guide)
+
+---
+
+</details>
+
+## 🏅 **Bot Authors**
+<details>
+    <summary><b>Click Here For Description</b></summary>
+
+|<img width="80" src="https://avatars.githubusercontent.com/u/105407900?v=4">|<img width="80" src="https://avatars.githubusercontent.com/u/93116400?v=4">|<img width="80" src="https://avatars.githubusercontent.com/u/113664541?v=4">|<img width="80" src="https://avatars.githubusercontent.com/u/84721324?v=4">|
+|:---:|:---:|:---:|:---:|
+|[`SilentDemonSD`](https://github.com/SilentDemonSD)|[`RjRiajul`](https://github.com/rjriajul)|[`CodeWithWeeb`](https://github.com/weebzone)|[`Maverick`](https://github.com/MajnuRangeela)|
+|Author and DDL, UI Design, More Customs..|Co-Author & Maintainer|Author and Wraps Up Features|Co-Author & Bug Tester|
+
+</details>
+

bot/__init__.py

@@ -0,0 +1,105 @@
+# ruff: noqa: E402
+
+from uvloop import install
+
+install()
+
+from subprocess import run as srun
+from os import getcwd
+from asyncio import Lock, new_event_loop, set_event_loop
+from logging import (
+    ERROR,
+    INFO,
+    WARNING,
+    FileHandler,
+    StreamHandler,
+    basicConfig,
+    getLogger,
+)
+from os import cpu_count
+from time import time
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+from .core.config_manager import BinConfig
+from sabnzbdapi import SabnzbdClient
+
+getLogger("requests").setLevel(WARNING)
+getLogger("urllib3").setLevel(WARNING)
+getLogger("pyrogram").setLevel(ERROR)
+getLogger("aiohttp").setLevel(ERROR)
+getLogger("apscheduler").setLevel(ERROR)
+getLogger("httpx").setLevel(WARNING)
+getLogger("pymongo").setLevel(WARNING)
+getLogger("aiohttp").setLevel(WARNING)
+
+
+bot_start_time = time()
+
+bot_loop = new_event_loop()
+set_event_loop(bot_loop)
+
+basicConfig(
+    format="[%(asctime)s] [%(levelname)s] - %(message)s",  #  [%(filename)s:%(lineno)d]
+    datefmt="%d-%b-%y %I:%M:%S %p",
+    handlers=[FileHandler("log.txt"), StreamHandler()],
+    level=INFO,
+)
+
+LOGGER = getLogger(__name__)
+cpu_no = cpu_count()
+threads = max(1, cpu_no // 2)
+cores = ",".join(str(i) for i in range(threads))
+
+bot_cache = {}
+DOWNLOAD_DIR = "/usr/src/app/downloads/"
+intervals = {"status": {}, "qb": "", "jd": "", "nzb": "", "stopAll": False}
+qb_torrents = {}
+jd_downloads = {}
+nzb_jobs = {}
+user_data = {}
+aria2_options = {}
+qbit_options = {}
+nzb_options = {}
+queued_dl = {}
+queued_up = {}
+status_dict = {}
+task_dict = {}
+rss_dict = {}
+shortener_dict = {}
+var_list = [
+    "BOT_TOKEN",
+    "TELEGRAM_API",
+    "TELEGRAM_HASH",
+    "OWNER_ID",
+    "DATABASE_URL",
+    "BASE_URL",
+    "UPSTREAM_REPO",
+    "UPSTREAM_BRANCH",
+    "UPDATE_PKGS",
+]
+auth_chats = {}
+excluded_extensions = ["aria2", "!qB"]
+drives_names = []
+drives_ids = []
+index_urls = []
+sudo_users = []
+non_queued_dl = set()
+non_queued_up = set()
+multi_tags = set()
+task_dict_lock = Lock()
+queue_dict_lock = Lock()
+qb_listener_lock = Lock()
+nzb_listener_lock = Lock()
+jd_listener_lock = Lock()
+cpu_eater_lock = Lock()
+same_directory_lock = Lock()
+
+sabnzbd_client = SabnzbdClient(
+    host="http://localhost",
+    api_key="admin",
+    port="8070",
+)
+srun([BinConfig.QBIT_NAME, "-d", f"--profile={getcwd()}"], check=False)
+
+scheduler = AsyncIOScheduler(event_loop=bot_loop)

bot/__main__.py

@@ -0,0 +1,141 @@
+# ruff: noqa: E402
+
+from .core.config_manager import Config
+
+Config.load()
+
+from datetime import datetime
+from logging import Formatter
+from time import localtime
+
+from pytz import timezone
+
+from . import LOGGER, bot_loop
+from .core.tg_client import TgClient
+
+
+async def main():
+    from asyncio import gather
+
+    from .core.startup import (
+        load_configurations,
+        load_settings,
+        save_settings,
+        update_aria2_options,
+        update_nzb_options,
+        update_qb_options,
+        update_variables,
+    )
+
+    await load_settings()
+
+    try:
+        tz = timezone(Config.TIMEZONE)
+    except Exception:
+        from pytz import utc
+
+        tz = utc
+
+    def changetz(*args):
+        try:
+            return datetime.now(tz).timetuple()
+        except Exception:
+            return localtime()
+
+    Formatter.converter = changetz
+
+    await gather(
+        TgClient.start_bot(), TgClient.start_user(), TgClient.start_helper_bots()
+    )
+    await gather(load_configurations(), update_variables())
+
+    from .core.torrent_manager import TorrentManager
+
+    await TorrentManager.initiate()
+    await gather(
+        update_qb_options(),
+        update_aria2_options(),
+        update_nzb_options(),
+    )
+    from .core.jdownloader_booter import jdownloader
+    from .helper.ext_utils.files_utils import clean_all
+    from .helper.ext_utils.telegraph_helper import telegraph
+    from .helper.mirror_leech_utils.rclone_utils.serve import rclone_serve_booter
+    from .modules import (
+        get_packages_version,
+        initiate_search_tools,
+        restart_notification,
+    )
+
+    await gather(
+        save_settings(),
+        jdownloader.boot(),
+        clean_all(),
+        initiate_search_tools(),
+        get_packages_version(),
+        restart_notification(),
+        telegraph.create_account(),
+        rclone_serve_booter(),
+    )
+
+
+bot_loop.run_until_complete(main())
+
+from .core.handlers import add_handlers
+from .helper.ext_utils.bot_utils import create_help_buttons
+from .helper.listeners.aria2_listener import add_aria2_callbacks
+
+add_aria2_callbacks()
+create_help_buttons()
+add_handlers()
+
+from .core.plugin_manager import get_plugin_manager
+from .modules.plugin_manager import register_plugin_commands
+
+plugin_manager = get_plugin_manager()
+plugin_manager.bot = TgClient.bot
+register_plugin_commands()
+
+from pyrogram.filters import regex
+from pyrogram.handlers import CallbackQueryHandler
+
+from .core.handlers import add_handlers
+from .helper.ext_utils.bot_utils import new_task
+from .helper.telegram_helper.filters import CustomFilters
+from .helper.telegram_helper.message_utils import (
+    delete_message,
+    edit_message,
+    send_message,
+)
+
+
+@new_task
+async def restart_sessions_confirm(_, query):
+    data = query.data.split()
+    message = query.message
+    if data[1] == "confirm":
+        reply_to = message.reply_to_message
+        restart_message = await send_message(reply_to, "Restarting Session(s)...")
+        await delete_message(message)
+        await TgClient.reload()
+        add_handlers()
+        TgClient.bot.add_handler(
+            CallbackQueryHandler(
+                restart_sessions_confirm,
+                filters=regex("^sessionrestart") & CustomFilters.sudo,
+            )
+        )
+        await edit_message(restart_message, "Session(s) Restarted Successfully!")
+    else:
+        await delete_message(message)
+
+
+TgClient.bot.add_handler(
+    CallbackQueryHandler(
+        restart_sessions_confirm,
+        filters=regex("^sessionrestart") & CustomFilters.sudo,
+    )
+)
+
+LOGGER.info("WZ Client(s) & Services Started !")
+bot_loop.run_forever()

bot/core/config_manager.py

@@ -0,0 +1,258 @@
+from importlib import import_module
+from os import getenv
+
+
+class Config:
+    AS_DOCUMENT = False
+    AUTHORIZED_CHATS = ""
+    BASE_URL = ""
+    BASE_URL_PORT = 80
+    BOT_TOKEN = ""
+    HELPER_TOKENS = ""
+    BOT_MAX_TASKS = 0
+    BOT_PM = False
+    CMD_SUFFIX = ""
+    DEFAULT_LANG = "en"
+    DATABASE_URL = ""
+    DEFAULT_UPLOAD = "rc"
+    DELETE_LINKS = False
+    DEBRID_LINK_API = ""
+    DISABLE_TORRENTS = False
+    DISABLE_LEECH = False
+    DISABLE_BULK = False
+    DISABLE_MULTI = False
+    DISABLE_SEED = False
+    DISABLE_FF_MODE = False
+    EQUAL_SPLITS = False
+    EXCLUDED_EXTENSIONS = ""
+    FFMPEG_CMDS = {}
+    FILELION_API = ""
+    MEDIA_STORE = True
+    FORCE_SUB_IDS = ""
+    GOFILE_API = ""
+    GOFILE_FOLDER_ID = ""
+    PIXELDRAIN_KEY = ""
+    PROTECTED_API = ""
+    BUZZHEAVIER_API = ""
+    GDRIVE_ID = ""
+    GD_DESP = "Uploaded with WZ Bot"
+    AUTHOR_NAME = "WZML-X"
+    AUTHOR_URL = "https://t.me/WZML_X"
+    INSTADL_API = ""
+    IMDB_TEMPLATE = ""
+    INCOMPLETE_TASK_NOTIFIER = False
+    INDEX_URL = ""
+    IS_TEAM_DRIVE = False
+    JD_EMAIL = ""
+    JD_PASS = ""
+    MEGA_EMAIL = ""
+    MEGA_PASSWORD = ""
+    DIRECT_LIMIT = 0
+    MEGA_LIMIT = 0
+    TORRENT_LIMIT = 0
+    GD_DL_LIMIT = 0
+    RC_DL_LIMIT = 0
+    CLONE_LIMIT = 0
+    JD_LIMIT = 0
+    NZB_LIMIT = 0
+    YTDLP_LIMIT = 0
+    PLAYLIST_LIMIT = 0
+    LEECH_LIMIT = 0
+    EXTRACT_LIMIT = 0
+    ARCHIVE_LIMIT = 0
+    STORAGE_LIMIT = 0
+    LEECH_DUMP_CHAT = ""
+    LINKS_LOG_ID = ""
+    MIRROR_LOG_ID = ""
+    CLEAN_LOG_MSG = False
+    LEECH_PREFIX = ""
+    LEECH_CAPTION = ""
+    LEECH_SUFFIX = ""
+    LEECH_FONT = ""
+    LEECH_SPLIT_SIZE = 2097152000
+    MEDIA_GROUP = False
+    HYBRID_LEECH = True
+    HYPER_THREADS = 0
+    HYDRA_IP = ""
+    HYDRA_API_KEY = ""
+    NAME_SWAP = ""
+    OWNER_ID = 0
+    QUEUE_ALL = 0
+    QUEUE_DOWNLOAD = 0
+    QUEUE_UPLOAD = 0
+    RCLONE_FLAGS = ""
+    RCLONE_PATH = ""
+    RCLONE_SERVE_URL = ""
+    SHOW_CLOUD_LINK = True
+    RCLONE_SERVE_USER = ""
+    RCLONE_SERVE_PASS = ""
+    RCLONE_SERVE_PORT = 8080
+    RSS_CHAT = ""
+    RSS_DELAY = 600
+    RSS_SIZE_LIMIT = 0
+    SEARCH_API_LINK = ""
+    SEARCH_LIMIT = 0
+    SEARCH_PLUGINS = []
+    SET_COMMANDS = True
+    STATUS_LIMIT = 10
+    STATUS_UPDATE_INTERVAL = 15
+    STOP_DUPLICATE = False
+    STREAMWISH_API = ""
+    SUDO_USERS = ""
+    TELEGRAM_API = 0
+    TELEGRAM_HASH = ""
+    TG_PROXY = None
+    THUMBNAIL_LAYOUT = ""
+    VERIFY_TIMEOUT = 0
+    LOGIN_PASS = ""
+    TORRENT_TIMEOUT = 0
+    TIMEZONE = "Asia/Kolkata"
+    USER_MAX_TASKS = 0
+    USER_TIME_INTERVAL = 0
+    UPLOAD_PATHS = {}
+    UPSTREAM_REPO = ""
+    UPSTREAM_BRANCH = "master"
+    UPDATE_PKGS = True
+    USENET_SERVERS = []
+    USER_SESSION_STRING = ""
+    USER_TRANSMISSION = True
+    USE_SERVICE_ACCOUNTS = False
+    WEB_PINCODE = True
+    YT_DLP_OPTIONS = {}
+    YT_DESP = "Uploaded with WZML-X bot"
+    YT_TAGS = ["telegram", "bot", "youtube"]
+    YT_CATEGORY_ID = 22
+    YT_PRIVACY_STATUS = "unlisted"
+
+    @classmethod
+    def get(cls, key):
+        return getattr(cls, key) if hasattr(cls, key) else None
+
+    @classmethod
+    def set(cls, key, value):
+        if hasattr(cls, key):
+            value = cls._convert_env_type(key, value)
+            setattr(cls, key, value)
+        else:
+            raise KeyError(f"{key} is not a valid configuration key.")
+
+    @classmethod
+    def get_all(cls):
+        return {
+            key: getattr(cls, key)
+            for key in cls.__dict__.keys()
+            if not key.startswith("__") and not callable(getattr(cls, key))
+        }
+
+    @classmethod
+    def load(cls):
+        cls.load_config()
+        cls.load_env()
+
+    @classmethod
+    def load_config(cls):
+        try:
+            settings = import_module("config")
+        except ModuleNotFoundError:
+            return
+        for attr in dir(settings):
+            if hasattr(cls, attr):
+                value = getattr(settings, attr)
+                if not value:
+                    continue
+                if isinstance(value, str):
+                    value = value.strip()
+                if attr == "DEFAULT_UPLOAD" and value != "gd":
+                    value = "rc"
+                elif attr in [
+                    "BASE_URL",
+                    "RCLONE_SERVE_URL",
+                    "INDEX_URL",
+                    "SEARCH_API_LINK",
+                ]:
+                    if value:
+                        value = value.strip("/")
+                elif attr == "USENET_SERVERS":
+                    try:
+                        if not value[0].get("host"):
+                            continue
+                    except Exception:
+                        continue
+                setattr(cls, attr, value)
+        for key in ["BOT_TOKEN", "OWNER_ID", "TELEGRAM_API", "TELEGRAM_HASH"]:
+            value = getattr(cls, key)
+            if isinstance(value, str):
+                value = value.strip()
+            if not value:
+                raise ValueError(f"{key} variable is missing!")
+
+    @classmethod
+    def load_env(cls):
+        config_vars = cls.get_all()
+        for key in config_vars:
+            env_value = getenv(key)
+            if env_value is not None:
+                converted_value = cls._convert_env_type(key, env_value)
+                cls.set(key, converted_value)
+
+    @classmethod
+    def _convert_env_type(cls, key, value):
+        original_value = getattr(cls, key, None)
+        if original_value is None:
+            return value
+        elif isinstance(original_value, bool):
+            if isinstance(value, bool):
+                return value
+            return str(value).lower() in ("true", "1", "yes")
+        elif isinstance(original_value, int):
+            if isinstance(value, int):
+                return value
+            try:
+                return int(value)
+            except (ValueError, TypeError):
+                return original_value
+        elif isinstance(original_value, float):
+            if isinstance(value, float):
+                return value
+            try:
+                return float(value)
+            except (ValueError, TypeError):
+                return original_value
+        return value
+
+    @classmethod
+    def load_dict(cls, config_dict):
+        for key, value in config_dict.items():
+            if hasattr(cls, key):
+                if key == "DEFAULT_UPLOAD" and value != "gd":
+                    value = "rc"
+                elif key in [
+                    "BASE_URL",
+                    "RCLONE_SERVE_URL",
+                    "INDEX_URL",
+                    "SEARCH_API_LINK",
+                ]:
+                    if value:
+                        value = value.strip("/")
+                elif key == "USENET_SERVERS":
+                    try:
+                        if not value[0].get("host"):
+                            value = []
+                    except Exception:
+                        value = []
+                value = cls._convert_env_type(key, value)
+                setattr(cls, key, value)
+        for key in ["BOT_TOKEN", "OWNER_ID", "TELEGRAM_API", "TELEGRAM_HASH"]:
+            value = getattr(cls, key)
+            if isinstance(value, str):
+                value = value.strip()
+            if not value:
+                raise ValueError(f"{key} variable is missing!")
+
+
+class BinConfig:
+    ARIA2_NAME = "blitzfetcher"
+    QBIT_NAME = "stormtorrent"
+    FFMPEG_NAME = "mediaforge"
+    RCLONE_NAME = "ghostdrive"
+    SABNZBD_NAME = "newsripper"

bot/core/handlers.py

@@ -0,0 +1,423 @@
+# ruff: noqa: F403, F405
+
+from pyrogram.filters import command, regex
+from pyrogram.handlers import CallbackQueryHandler, EditedMessageHandler, MessageHandler
+from pyrogram.types import BotCommand
+
+from ..core.config_manager import Config
+from ..helper.ext_utils.help_messages import BOT_COMMANDS
+from ..helper.telegram_helper.bot_commands import BotCommands
+from ..helper.telegram_helper.filters import CustomFilters
+from ..modules import *
+from .tg_client import TgClient
+
+
+def add_handlers():
+    TgClient.bot.add_handler(
+        MessageHandler(
+            authorize,
+            filters=command(BotCommands.AuthorizeCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            unauthorize,
+            filters=command(BotCommands.UnAuthorizeCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            add_sudo,
+            filters=command(BotCommands.AddSudoCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            remove_sudo,
+            filters=command(BotCommands.RmSudoCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            send_bot_settings,
+            filters=command(BotCommands.BotSetCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            broadcast,
+            filters=command(BotCommands.BroadcastCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        CallbackQueryHandler(
+            edit_bot_settings, filters=regex("^botset") & CustomFilters.sudo
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            cancel,
+            filters=regex(rf"^/{BotCommands.CancelTaskCommand[1]}?(?:_\w+).*$")
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            cancel_all_buttons,
+            filters=command(BotCommands.CancelAllCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        CallbackQueryHandler(cancel_all_update, filters=regex("^canall"))
+    )
+    TgClient.bot.add_handler(
+        CallbackQueryHandler(cancel_multi, filters=regex("^stopm"))
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            clone_node,
+            filters=command(BotCommands.CloneCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            aioexecute,
+            filters=command(BotCommands.AExecCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            execute,
+            filters=command(BotCommands.ExecCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            clear,
+            filters=command(BotCommands.ClearLocalsCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            select,
+            filters=command(BotCommands.SelectCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        CallbackQueryHandler(confirm_selection, filters=regex("^sel"))
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            remove_from_queue,
+            filters=command(BotCommands.ForceStartCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            count_node,
+            filters=command(BotCommands.CountCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            delete_file,
+            filters=command(BotCommands.DeleteCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            gdrive_search,
+            filters=command(BotCommands.ListCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        CallbackQueryHandler(select_type, filters=regex("^list_types"))
+    )
+    TgClient.bot.add_handler(CallbackQueryHandler(arg_usage, filters=regex("^help")))
+    TgClient.bot.add_handler(
+        MessageHandler(
+            mirror,
+            filters=command(BotCommands.MirrorCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            qb_mirror,
+            filters=command(BotCommands.QbMirrorCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            jd_mirror,
+            filters=command(BotCommands.JdMirrorCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            nzb_mirror,
+            filters=command(BotCommands.NzbMirrorCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            leech,
+            filters=command(BotCommands.LeechCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            qb_leech,
+            filters=command(BotCommands.QbLeechCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            jd_leech,
+            filters=command(BotCommands.JdLeechCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            nzb_leech,
+            filters=command(BotCommands.NzbLeechCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            uphoster,
+            filters=command(BotCommands.UpHosterCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            get_rss_menu,
+            filters=command(BotCommands.RssCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(CallbackQueryHandler(rss_listener, filters=regex("^rss")))
+    TgClient.bot.add_handler(
+        MessageHandler(
+            run_shell,
+            filters=command(BotCommands.ShellCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        EditedMessageHandler(
+            run_shell,
+            filters=command(BotCommands.ShellCommand, case_sensitive=True)
+            & CustomFilters.owner,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            start, filters=command(BotCommands.StartCommand, case_sensitive=True)
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            login, filters=command(BotCommands.LoginCommand, case_sensitive=True)
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            log,
+            filters=command(BotCommands.LogCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            restart_bot,
+            filters=command(BotCommands.RestartCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        CallbackQueryHandler(
+            confirm_restart, filters=regex("^botrestart") & CustomFilters.sudo
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            restart_sessions,
+            filters=command(BotCommands.RestartSessionsCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            imdb_search,
+            filters=command(BotCommands.IMDBCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        CallbackQueryHandler(imdb_callback, filters=regex("^imdb"))
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            ping,
+            filters=command(BotCommands.PingCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            bot_help,
+            filters=command(BotCommands.HelpCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            mediainfo,
+            filters=command(BotCommands.MediaInfoCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+
+    TgClient.bot.add_handler(
+        MessageHandler(
+            bot_stats,
+            filters=command(BotCommands.StatsCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            task_status,
+            filters=command(BotCommands.StatusCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        CallbackQueryHandler(status_pages, filters=regex("^status"))
+    )
+    TgClient.bot.add_handler(CallbackQueryHandler(stats_pages, filters=regex("^stats")))
+    TgClient.bot.add_handler(CallbackQueryHandler(log_cb, filters=regex("^log")))
+    TgClient.bot.add_handler(CallbackQueryHandler(start_cb, filters=regex("^start")))
+    TgClient.bot.add_handler(
+        MessageHandler(
+            torrent_search,
+            filters=command(BotCommands.SearchCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        CallbackQueryHandler(torrent_search_update, filters=regex("^torser"))
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            get_users_settings,
+            filters=command(BotCommands.UsersCommand, case_sensitive=True)
+            & CustomFilters.sudo,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            send_user_settings,
+            filters=command(BotCommands.UserSetCommand, case_sensitive=True)
+            & CustomFilters.authorized_uset,
+        )
+    )
+    TgClient.bot.add_handler(
+        CallbackQueryHandler(edit_user_settings, filters=regex("^userset"))
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            ytdl,
+            filters=command(BotCommands.YtdlCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            ytdl_leech,
+            filters=command(BotCommands.YtdlLeechCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    TgClient.bot.add_handler(
+        MessageHandler(
+            hydra_search,
+            filters=command(BotCommands.NzbSearchCommand, case_sensitive=True)
+            & CustomFilters.authorized,
+        )
+    )
+    if Config.SET_COMMANDS:
+        global BOT_COMMANDS
+
+        def insert_at(d, k, v, i):
+            return dict(list(d.items())[:i] + [(k, v)] + list(d.items())[i:])
+
+        if Config.JD_EMAIL and Config.JD_PASS:
+            BOT_COMMANDS = insert_at(
+                BOT_COMMANDS,
+                "JdMirror",
+                "[link/file] Mirror to Upload Destination using JDownloader",
+                2,
+            )
+            BOT_COMMANDS = insert_at(
+                BOT_COMMANDS,
+                "JdLeech",
+                "[link/file] Leech files to Upload to Telegram using JDownloader",
+                6,
+            )
+
+        if len(Config.USENET_SERVERS) != 0:
+            BOT_COMMANDS = insert_at(
+                BOT_COMMANDS,
+                "NzbMirror",
+                "[nzb] Mirror to Upload Destination using Sabnzbd",
+                2,
+            )
+            BOT_COMMANDS = insert_at(
+                BOT_COMMANDS,
+                "NzbLeech",
+                "[nzb] Leech files to Upload to Telegram using Sabnzbd",
+                6,
+            )
+
+        if Config.LOGIN_PASS:
+            BOT_COMMANDS = insert_at(
+                BOT_COMMANDS, "Login", "[password] Login to Bot", 14
+            )
+
+        TgClient.bot.set_bot_commands(
+            [
+                BotCommand(
+                    cmds[0] if isinstance(cmds, list) else cmds,
+                    description,
+                )
+                for cmd, description in BOT_COMMANDS.items()
+                for cmds in [getattr(BotCommands, f"{cmd}Command", None)]
+                if cmds is not None
+            ]
+        )

bot/core/jdownloader_booter.py

@@ -0,0 +1,94 @@
+from json import dumps
+from random import randint
+from re import match
+
+from aiofiles import open as aiopen
+from aiofiles.os import listdir, makedirs, path, rename
+from aioshutil import rmtree
+
+from myjd import MyJdApi
+
+from .. import LOGGER
+from ..helper.ext_utils.bot_utils import cmd_exec, new_task
+from .config_manager import Config
+from .tg_client import TgClient
+
+
+class JDownloader(MyJdApi):
+    def __init__(self):
+        super().__init__()
+        self._username = ""
+        self._password = ""
+        self._device_name = ""
+        self.is_connected = False
+        self.error = "JDownloader Credentials not provided!"
+
+    async def _write_config(self, path, data):
+        async with aiopen(path, "w") as f:
+            await f.write(dumps(data))
+
+    @new_task
+    async def boot(self):
+        await cmd_exec(["pkill", "-9", "-f", "java"])
+        if not Config.JD_EMAIL or not Config.JD_PASS:
+            self.is_connected = False
+            self.error = "JDownloader Credentials not provided!"
+            return
+        self.error = "Connecting... Try agin after couple of seconds"
+        self._device_name = f"{randint(0, 1000)}@{TgClient.BNAME}"
+        if await path.exists("/JDownloader/logs"):
+            LOGGER.info(
+                "Starting JDownloader... This might take up to 10 sec and might restart once if update available!"
+            )
+        else:
+            LOGGER.info(
+                "Starting JDownloader... This might take up to 8 sec and might restart once after build!"
+            )
+        jdata = {
+            "autoconnectenabledv2": True,
+            "password": Config.JD_PASS,
+            "devicename": f"{self._device_name}",
+            "email": Config.JD_EMAIL,
+        }
+        remote_data = {
+            "localapiserverheaderaccesscontrollalloworigin": "",
+            "deprecatedapiport": 3128,
+            "localapiserverheaderxcontenttypeoptions": "nosniff",
+            "localapiserverheaderxframeoptions": "DENY",
+            "externinterfaceenabled": True,
+            "deprecatedapilocalhostonly": True,
+            "localapiserverheaderreferrerpolicy": "no-referrer",
+            "deprecatedapienabled": True,
+            "localapiserverheadercontentsecuritypolicy": "default-src 'self'",
+            "jdanywhereapienabled": True,
+            "externinterfacelocalhostonly": False,
+            "localapiserverheaderxxssprotection": "1; mode=block",
+        }
+        await makedirs("/JDownloader/cfg", exist_ok=True)
+        await self._write_config(
+            "/JDownloader/cfg/org.jdownloader.api.myjdownloader.MyJDownloaderSettings.json",
+            jdata,
+        )
+        await self._write_config(
+            "/JDownloader/cfg/org.jdownloader.api.RemoteAPIConfig.json",
+            remote_data,
+        )
+        if not await path.exists("/JDownloader/JDownloader.jar"):
+            pattern = r"JDownloader\.jar\.backup.\d$"
+            for filename in await listdir("/JDownloader"):
+                if match(pattern, filename):
+                    await rename(
+                        f"/JDownloader/{filename}", "/JDownloader/JDownloader.jar"
+                    )
+                    break
+            await rmtree("/JDownloader/update")
+            await rmtree("/JDownloader/tmp")
+        cmd = "cpulimit -l 20 -- java -Xms256m -Xmx500m -Dsun.jnu.encoding=UTF-8 -Dfile.encoding=UTF-8 -Djava.awt.headless=true -jar /JDownloader/JDownloader.jar"
+        self.is_connected = True
+        _, __, code = await cmd_exec(cmd, shell=True)
+        self.is_connected = False
+        if code != -9:
+            await self.boot()
+
+
+jdownloader = JDownloader()

bot/core/plugin_manager.py

@@ -0,0 +1,260 @@
+import importlib
+import importlib.util
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from pyrogram import Client
+from pyrogram.handlers import CallbackQueryHandler, MessageHandler
+
+from .. import LOGGER
+from ..helper.telegram_helper.filters import CustomFilters
+
+
+@dataclass
+class PluginInfo:
+    name: str
+    version: str
+    author: str
+    description: str
+    enabled: bool = True
+    handlers: List[Any] = field(default_factory=list)
+    commands: List[str] = field(default_factory=list)
+    dependencies: List[str] = field(default_factory=list)
+
+
+class PluginBase:
+    PLUGIN_INFO: PluginInfo
+
+    async def on_load(self) -> bool:
+        return True
+
+    async def on_unload(self) -> bool:
+        return True
+
+    async def on_enable(self) -> bool:
+        return True
+
+    async def on_disable(self) -> bool:
+        return True
+
+    def register_command(self, command: str, handler_func, filters=None):
+        if filters is None:
+            filters = CustomFilters.authorized
+        return MessageHandler(handler_func, filters=command & filters)
+
+    def register_callback(self, pattern: str, callback_func, filters=None):
+        if filters is None:
+            filters = CustomFilters.authorized
+        return CallbackQueryHandler(callback_func, filters=pattern & filters)
+
+
+class PluginManager:
+    def __init__(self, bot: Client):
+        self.bot = bot
+        self.plugins: Dict[str, PluginInfo] = {}
+        self.loaded_modules: Dict[str, Any] = {}
+        self.plugins_dir = Path("plugins")
+        self.plugins_dir.mkdir(exist_ok=True)
+
+    def discover_plugins(self) -> List[str]:
+        plugin_files = []
+        for file in self.plugins_dir.glob("*.py"):
+            if file.name.startswith("__"):
+                continue
+            plugin_files.append(file.stem)
+        return plugin_files
+
+    def _refresh_commands(self):
+        try:
+            from ..helper.telegram_helper.bot_commands import BotCommands
+            from ..helper.ext_utils.help_messages import (
+                get_bot_commands,
+                get_help_string,
+            )
+            import importlib
+
+            BotCommands.refresh_commands()
+
+            importlib.reload(sys.modules["bot.helper.ext_utils.help_messages"])
+            from ..helper.ext_utils.help_messages import BOT_COMMANDS, help_string
+
+            globals()["BOT_COMMANDS"] = get_bot_commands()
+            globals()["help_string"] = get_help_string()
+
+            LOGGER.info("Bot commands and help refreshed")
+        except Exception as e:
+            LOGGER.error(f"Error refreshing commands: {e}", exc_info=True)
+
+    async def load_plugin(self, plugin_name: str) -> bool:
+        try:
+            if plugin_name in self.loaded_modules:
+                LOGGER.warning(f"Plugin {plugin_name} already loaded")
+                return False
+
+            plugin_path = self.plugins_dir / f"{plugin_name}.py"
+            if not plugin_path.exists():
+                LOGGER.error(f"Plugin file {plugin_name}.py not found")
+                return False
+
+            spec = importlib.util.spec_from_file_location(plugin_name, plugin_path)
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[plugin_name] = module
+            spec.loader.exec_module(module)
+
+            plugin_class = None
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if (
+                    isinstance(attr, type)
+                    and issubclass(attr, PluginBase)
+                    and attr != PluginBase
+                ):
+                    plugin_class = attr
+                    break
+
+            if not plugin_class:
+                LOGGER.error(f"No valid plugin class found in {plugin_name}")
+                return False
+
+            plugin_instance = plugin_class()
+            if not hasattr(plugin_instance, "PLUGIN_INFO"):
+                LOGGER.error(f"Plugin {plugin_name} missing PLUGIN_INFO")
+                return False
+
+            plugin_info = plugin_instance.PLUGIN_INFO
+            if await plugin_instance.on_load():
+                self.plugins[plugin_name] = plugin_info
+                self.loaded_modules[plugin_name] = plugin_instance
+                self._register_handlers(plugin_instance, plugin_info)
+                self._refresh_commands()
+                LOGGER.info(f"Plugin {plugin_name} loaded successfully")
+                return True
+            else:
+                LOGGER.error(f"Plugin {plugin_name} failed to load")
+                return False
+
+        except Exception as e:
+            LOGGER.error(f"Error loading plugin {plugin_name}: {e}", exc_info=True)
+            return False
+
+    async def unload_plugin(self, plugin_name: str) -> bool:
+        try:
+            if plugin_name not in self.loaded_modules:
+                LOGGER.error(f"Plugin {plugin_name} not loaded")
+                return False
+
+            plugin_instance = self.loaded_modules[plugin_name]
+            plugin_info = self.plugins[plugin_name]
+
+            if await plugin_instance.on_unload():
+                self._unregister_handlers(plugin_info)
+                del self.loaded_modules[plugin_name]
+                del self.plugins[plugin_name]
+                if plugin_name in sys.modules:
+                    del sys.modules[plugin_name]
+                self._refresh_commands()
+                LOGGER.info(f"Plugin {plugin_name} unloaded successfully")
+                return True
+            else:
+                LOGGER.error(f"Plugin {plugin_name} failed to unload")
+                return False
+
+        except Exception as e:
+            LOGGER.error(f"Error unloading plugin {plugin_name}: {e}", exc_info=True)
+            return False
+
+    async def reload_plugin(self, plugin_name: str) -> bool:
+        try:
+            await self.unload_plugin(plugin_name)
+            return await self.load_plugin(plugin_name)
+        except Exception as e:
+            LOGGER.error(f"Error reloading plugin {plugin_name}: {e}", exc_info=True)
+            return False
+
+    async def enable_plugin(self, plugin_name: str) -> bool:
+        try:
+            if plugin_name not in self.plugins:
+                LOGGER.error(f"Plugin {plugin_name} not found")
+                return False
+
+            plugin_instance = self.loaded_modules[plugin_name]
+            if await plugin_instance.on_enable():
+                self.plugins[plugin_name].enabled = True
+                self._refresh_commands()
+                LOGGER.info(f"Plugin {plugin_name} enabled")
+                return True
+            else:
+                LOGGER.error(f"Plugin {plugin_name} failed to enable")
+                return False
+
+        except Exception as e:
+            LOGGER.error(f"Error enabling plugin {plugin_name}: {e}", exc_info=True)
+            return False
+
+    async def disable_plugin(self, plugin_name: str) -> bool:
+        try:
+            if plugin_name not in self.plugins:
+                LOGGER.error(f"Plugin {plugin_name} not found")
+                return False
+
+            plugin_instance = self.loaded_modules[plugin_name]
+            if await plugin_instance.on_disable():
+                self.plugins[plugin_name].enabled = False
+                self._refresh_commands()
+                LOGGER.info(f"Plugin {plugin_name} disabled")
+                return True
+            else:
+                LOGGER.error(f"Plugin {plugin_name} failed to disable")
+                return False
+
+        except Exception as e:
+            LOGGER.error(f"Error disabling plugin {plugin_name}: {e}", exc_info=True)
+            return False
+
+    def list_plugins(self) -> List[PluginInfo]:
+        return list(self.plugins.values())
+
+    def get_plugin_info(self, plugin_name: str) -> Optional[PluginInfo]:
+        return self.plugins.get(plugin_name)
+
+    def _register_handlers(self, plugin_instance: PluginBase, plugin_info: PluginInfo):
+        from ..helper.telegram_helper.filters import CustomFilters
+        from pyrogram.filters import command
+        from pyrogram.handlers import MessageHandler
+
+        for handler in plugin_info.handlers:
+            self.bot.add_handler(handler)
+
+        module = sys.modules.get(plugin_info.name)
+        if module:
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if callable(attr) and attr_name.endswith("_command"):
+                    cmd_name = attr_name.replace("_command", "")
+                    if cmd_name in plugin_info.commands:
+                        handler = MessageHandler(
+                            attr,
+                            filters=command(cmd_name, case_sensitive=True)
+                            & CustomFilters.authorized,
+                        )
+                        plugin_info.handlers.append(handler)
+                        self.bot.add_handler(handler)
+                        LOGGER.info(
+                            f"Registered command /{cmd_name} for plugin {plugin_info.name}"
+                        )
+
+    def _unregister_handlers(self, plugin_info: PluginInfo):
+        for handler in plugin_info.handlers:
+            try:
+                self.bot.remove_handler(handler)
+            except Exception as e:
+                LOGGER.warning(f"Error removing handler: {e}")
+
+
+plugin_manager = PluginManager(None)
+
+
+def get_plugin_manager() -> PluginManager:
+    return plugin_manager

bot/core/startup.py

@@ -0,0 +1,349 @@
+from asyncio import create_subprocess_exec, create_subprocess_shell, sleep
+from importlib import import_module
+from os import environ, getenv, path as ospath
+
+from aiofiles import open as aiopen
+from aiofiles.os import makedirs, remove, path as aiopath
+from aioshutil import rmtree
+
+from sabnzbdapi.exception import APIResponseError
+
+from .. import (
+    LOGGER,
+    aria2_options,
+    auth_chats,
+    drives_ids,
+    drives_names,
+    index_urls,
+    shortener_dict,
+    var_list,
+    user_data,
+    excluded_extensions,
+    nzb_options,
+    qbit_options,
+    rss_dict,
+    sabnzbd_client,
+    sudo_users,
+)
+from ..helper.ext_utils.db_handler import database
+from .config_manager import Config, BinConfig
+from .tg_client import TgClient
+from .torrent_manager import TorrentManager
+
+
+async def update_qb_options():
+    LOGGER.info("Get qBittorrent options from server")
+    if not qbit_options:
+        if not TorrentManager.qbittorrent:
+            LOGGER.warning(
+                "qBittorrent is not initialized. Skipping qBittorrent options update."
+            )
+            return
+        opt = await TorrentManager.qbittorrent.app.preferences()
+        qbit_options.update(opt)
+        del qbit_options["listen_port"]
+        for k in list(qbit_options.keys()):
+            if k.startswith("rss"):
+                del qbit_options[k]
+        qbit_options["web_ui_password"] = "admin"
+        await TorrentManager.qbittorrent.app.set_preferences(
+            {"web_ui_password": "admin"}
+        )
+    else:
+        await TorrentManager.qbittorrent.app.set_preferences(qbit_options)
+
+
+async def update_aria2_options():
+    LOGGER.info("Get aria2 options from server")
+    if not aria2_options:
+        op = await TorrentManager.aria2.getGlobalOption()
+        aria2_options.update(op)
+    else:
+        await TorrentManager.aria2.changeGlobalOption(aria2_options)
+
+
+async def update_nzb_options():
+    if Config.USENET_SERVERS:
+        LOGGER.info("Get SABnzbd options from server")
+        while True:
+            try:
+                no = (await sabnzbd_client.get_config())["config"]["misc"]
+                nzb_options.update(no)
+            except Exception:
+                await sleep(0.5)
+                continue
+            break
+
+
+async def load_settings():
+    if not Config.DATABASE_URL:
+        return
+    for p in ["thumbnails", "tokens", "rclone"]:
+        if await aiopath.exists(p):
+            await rmtree(p, ignore_errors=True)
+    await database.connect()
+    if database.db is not None:
+        BOT_ID = Config.BOT_TOKEN.split(":", 1)[0]
+        try:
+            settings = import_module("config")
+            config_file = {
+                key: value.strip() if isinstance(value, str) else value
+                for key, value in vars(settings).items()
+                if not key.startswith("__")
+            }
+        except ModuleNotFoundError:
+            config_file = {}
+        config_file.update(
+            {
+                key: value.strip() if isinstance(value, str) else value
+                for key, value in environ.items()
+                if key in var_list
+            }
+        )
+
+        old_config = await database.db.settings.deployConfig.find_one(
+            {"_id": BOT_ID}, {"_id": 0}
+        )
+        if old_config is None:
+            await database.db.settings.deployConfig.replace_one(
+                {"_id": BOT_ID}, config_file, upsert=True
+            )
+        if old_config and old_config != config_file:
+            LOGGER.info("Saving.. Deploy Config imported from Bot")
+            await database.db.settings.deployConfig.replace_one(
+                {"_id": BOT_ID}, config_file, upsert=True
+            )
+            config_dict = (
+                await database.db.settings.config.find_one({"_id": BOT_ID}, {"_id": 0})
+                or {}
+            )
+            config_dict.update(config_file)
+            if config_dict:
+                Config.load_dict(config_dict)
+        else:
+            LOGGER.info("Updating.. Saved Config imported from MongoDB")
+            config_dict = await database.db.settings.config.find_one(
+                {"_id": BOT_ID}, {"_id": 0}
+            )
+            if config_dict:
+                Config.load_dict(config_dict)
+
+        if pf_dict := await database.db.settings.files.find_one(
+            {"_id": BOT_ID}, {"_id": 0}
+        ):
+            for key, value in pf_dict.items():
+                if value:
+                    file_ = key.replace("__", ".")
+                    async with aiopen(file_, "wb+") as f:
+                        await f.write(value)
+
+        if a2c_options := await database.db.settings.aria2c.find_one(
+            {"_id": BOT_ID}, {"_id": 0}
+        ):
+            aria2_options.update(a2c_options)
+
+        if not Config.DISABLE_TORRENTS:
+            if qbit_opt := await database.db.settings.qbittorrent.find_one(
+                {"_id": BOT_ID}, {"_id": 0}
+            ):
+                qbit_options.update(qbit_opt)
+
+        if nzb_opt := await database.db.settings.nzb.find_one(
+            {"_id": BOT_ID}, {"_id": 0}
+        ):
+            if await aiopath.exists("sabnzbd/SABnzbd.ini.bak"):
+                await remove("sabnzbd/SABnzbd.ini.bak")
+            ((key, value),) = nzb_opt.items()
+            file_ = key.replace("__", ".")
+            async with aiopen(f"sabnzbd/{file_}", "wb+") as f:
+                await f.write(value)
+            LOGGER.info("Loaded.. Sabnzbd Data from MongoDB")
+
+        if await database.db.users[BOT_ID].find_one():
+            rows = database.db.users[BOT_ID].find({})
+            async for row in rows:
+                uid = row["_id"]
+                del row["_id"]
+                paths = {
+                    "THUMBNAIL": f"thumbnails/{uid}.jpg",
+                    "RCLONE_CONFIG": f"rclone/{uid}.conf",
+                    "TOKEN_PICKLE": f"tokens/{uid}.pickle",
+                    "USER_COOKIE_FILE": f"cookies/{uid}/cookies.txt",
+                }
+
+                async def save_file(file_path, content):
+                    dir_path = ospath.dirname(file_path)
+                    if not await aiopath.exists(dir_path):
+                        await makedirs(dir_path)
+                    if file_path.startswith("cookies/") and file_path.endswith(".txt"):
+                        async with aiopen(file_path, "wb") as f:
+                            if isinstance(content, str):
+                                content = content.encode("utf-8")
+                            await f.write(content)
+                    else:
+                        async with aiopen(file_path, "wb+") as f:
+                            if isinstance(content, str):
+                                content = content.encode("utf-8")
+                            await f.write(content)
+
+                for key, path in paths.items():
+                    if row.get(key):
+                        await save_file(path, row[key])
+                        row[key] = path
+                user_data[uid] = row
+            LOGGER.info("Users Data has been imported from MongoDB")
+
+        if await database.db.rss[BOT_ID].find_one():
+            rows = database.db.rss[BOT_ID].find({})
+            async for row in rows:
+                user_id = row["_id"]
+                del row["_id"]
+                rss_dict[user_id] = row
+            LOGGER.info("RSS data has been imported from MongoDB")
+
+
+async def save_settings():
+    if database.db is None:
+        return
+    config_file = Config.get_all()
+    await database.db.settings.config.update_one(
+        {"_id": TgClient.ID}, {"$set": config_file}, upsert=True
+    )
+    if await database.db.settings.aria2c.find_one({"_id": TgClient.ID}) is None:
+        await database.db.settings.aria2c.update_one(
+            {"_id": TgClient.ID}, {"$set": aria2_options}, upsert=True
+        )
+    if await database.db.settings.qbittorrent.find_one({"_id": TgClient.ID}) is None:
+        await database.save_qbit_settings()
+    if await database.db.settings.nzb.find_one({"_id": TgClient.ID}) is None:
+        async with aiopen("sabnzbd/SABnzbd.ini", "rb+") as pf:
+            nzb_conf = await pf.read()
+        await database.db.settings.nzb.update_one(
+            {"_id": TgClient.ID}, {"$set": {"SABnzbd__ini": nzb_conf}}, upsert=True
+        )
+
+
+async def update_variables():
+    if (
+        Config.LEECH_SPLIT_SIZE > TgClient.MAX_SPLIT_SIZE
+        or Config.LEECH_SPLIT_SIZE == 2097152000
+        or not Config.LEECH_SPLIT_SIZE
+    ):
+        Config.LEECH_SPLIT_SIZE = TgClient.MAX_SPLIT_SIZE
+
+    Config.HYBRID_LEECH = bool(Config.HYBRID_LEECH and TgClient.IS_PREMIUM_USER)
+    Config.USER_TRANSMISSION = bool(
+        Config.USER_TRANSMISSION and TgClient.IS_PREMIUM_USER
+    )
+
+    if Config.AUTHORIZED_CHATS:
+        aid = Config.AUTHORIZED_CHATS.split()
+        for id_ in aid:
+            chat_id, *thread_ids = id_.split("|")
+            chat_id = int(chat_id.strip())
+            if thread_ids:
+                thread_ids = list(map(lambda x: int(x.strip()), thread_ids))
+                auth_chats[chat_id] = thread_ids
+            else:
+                auth_chats[chat_id] = []
+
+    if Config.SUDO_USERS:
+        aid = Config.SUDO_USERS.split()
+        for id_ in aid:
+            sudo_users.append(int(id_.strip()))
+
+    if Config.EXCLUDED_EXTENSIONS:
+        fx = Config.EXCLUDED_EXTENSIONS.split()
+        for x in fx:
+            x = x.lstrip(".")
+            excluded_extensions.append(x.strip().lower())
+
+    if Config.GDRIVE_ID:
+        drives_names.append("Main")
+        drives_ids.append(Config.GDRIVE_ID)
+        index_urls.append(Config.INDEX_URL)
+
+    if not Config.IMDB_TEMPLATE:
+        Config.IMDB_TEMPLATE = """
+<b>Title: </b> {title} [{year}]
+<b>Also Known As:</b> {aka}
+<b>Rating ⭐️:</b> <i>{rating}</i>
+<b>Release Info: </b> <a href="{url_releaseinfo}">{release_date}</a>
+<b>Genre: </b>{genres}
+<b>IMDb URL:</b> {url}
+<b>Language: </b>{languages}
+<b>Country of Origin : </b> {countries}
+
+<b>Story Line: </b><code>{plot}</code>
+
+<a href="{url_cast}">Read More ...</a>"""
+
+    if await aiopath.exists("list_drives.txt"):
+        async with aiopen("list_drives.txt", "r+") as f:
+            lines = await f.readlines()
+            for line in lines:
+                temp = line.split()
+                drives_ids.append(temp[1])
+                drives_names.append(temp[0].replace("_", " "))
+                if len(temp) > 2:
+                    index_urls.append(temp[2])
+                else:
+                    index_urls.append("")
+
+    if await aiopath.exists("shortener.txt"):
+        async with aiopen("shortener.txt", "r+") as f:
+            lines = await f.readlines()
+            for line in lines:
+                temp = line.strip().split()
+                if len(temp) == 2:
+                    shortener_dict[temp[0]] = temp[1]
+
+
+async def load_configurations():
+    if not await aiopath.exists(".netrc"):
+        async with aiopen(".netrc", "w"):
+            pass
+
+    await (
+        await create_subprocess_shell(
+            f"chmod 600 .netrc && cp .netrc /root/.netrc && chmod +x setpkgs.sh && ./setpkgs.sh {BinConfig.ARIA2_NAME} {BinConfig.SABNZBD_NAME}"
+        )
+    ).wait()
+
+    PORT = getenv("PORT", "") or Config.BASE_URL_PORT
+    if PORT:
+        await create_subprocess_shell(
+            f"gunicorn -k uvicorn.workers.UvicornWorker -w 1 web.wserver:app --bind 0.0.0.0:{PORT}"
+        )
+        await create_subprocess_shell("python3 cron_boot.py")
+
+    if await aiopath.exists("cfg.zip"):
+        if await aiopath.exists("/JDownloader/cfg"):
+            await rmtree("/JDownloader/cfg", ignore_errors=True)
+        await (
+            await create_subprocess_exec("7z", "x", "cfg.zip", "-o/JDownloader")
+        ).wait()
+
+    if await aiopath.exists("accounts.zip"):
+        if await aiopath.exists("accounts"):
+            await rmtree("accounts")
+        await (
+            await create_subprocess_exec(
+                "7z", "x", "-o.", "-aoa", "accounts.zip", "accounts/*.json"
+            )
+        ).wait()
+        await (await create_subprocess_exec("chmod", "-R", "777", "accounts")).wait()
+        await remove("accounts.zip")
+
+    if not await aiopath.exists("accounts"):
+        Config.USE_SERVICE_ACCOUNTS = False
+
+    await TorrentManager.initiate()
+
+    if Config.DISABLE_TORRENTS:
+        LOGGER.info("Torrents are disabled. Skipping qBittorrent initialization.")
+    else:
+        try:
+            await TorrentManager.qbittorrent.app.set_preferences(qbit_options)
+        except Exception as e:
+            LOGGER.error(f"Failed to configure qBittorrent: {e}")

bot/core/tg_client.py

@@ -0,0 +1,123 @@
+from pyrogram import Client, enums
+from asyncio import Lock, gather
+from inspect import signature
+
+from .. import LOGGER
+from .config_manager import Config
+
+
+class TgClient:
+    _lock = Lock()
+    _hlock = Lock()
+
+    bot = None
+    user = None
+    helper_bots = {}
+    helper_loads = {}
+
+    BNAME = ""
+    ID = 0
+    IS_PREMIUM_USER = False
+    MAX_SPLIT_SIZE = 2097152000
+
+    @classmethod
+    def wztgClient(cls, *args, **kwargs):
+        kwargs["api_id"] = Config.TELEGRAM_API
+        kwargs["api_hash"] = Config.TELEGRAM_HASH
+        kwargs["proxy"] = Config.TG_PROXY
+        kwargs["parse_mode"] = enums.ParseMode.HTML
+        kwargs["in_memory"] = True
+        for param, value in {
+            "max_concurrent_transmissions": 100,
+            "skip_updates": False,
+        }.items():
+            if param in signature(Client.__init__).parameters:
+                kwargs[param] = value
+        return Client(*args, **kwargs)
+
+    @classmethod
+    async def start_hclient(cls, no, b_token):
+        try:
+            hbot = await cls.wztgClient(
+                f"WZ-HBot{no}",
+                bot_token=b_token,
+                no_updates=True,
+            ).start()
+            LOGGER.info(f"Helper Bot [@{hbot.me.username}] Started!")
+            cls.helper_bots[no], cls.helper_loads[no] = hbot, 0
+        except Exception as e:
+            LOGGER.error(f"Failed to start helper bot {no} from HELPER_TOKENS. {e}")
+            cls.helper_bots.pop(no, None)
+
+    @classmethod
+    async def start_helper_bots(cls):
+        if not Config.HELPER_TOKENS:
+            return
+        LOGGER.info("Generating helper client from HELPER_TOKENS")
+        async with cls._hlock:
+            await gather(
+                *(
+                    cls.start_hclient(no, b_token)
+                    for no, b_token in enumerate(Config.HELPER_TOKENS.split(), start=1)
+                )
+            )
+
+    @classmethod
+    async def start_bot(cls):
+        LOGGER.info("Generating client from BOT_TOKEN")
+        cls.ID = Config.BOT_TOKEN.split(":", 1)[0]
+        cls.bot = cls.wztgClient(
+            f"WZ-Bot{cls.ID}",
+            bot_token=Config.BOT_TOKEN,
+            workdir="/usr/src/app",
+        )
+        await cls.bot.start()
+        cls.BNAME = cls.bot.me.username
+        cls.ID = Config.BOT_TOKEN.split(":", 1)[0]
+        LOGGER.info(f"WZ Bot : [@{cls.BNAME}] Started!")
+
+    @classmethod
+    async def start_user(cls):
+        if Config.USER_SESSION_STRING:
+            LOGGER.info("Generating client from USER_SESSION_STRING")
+            try:
+                cls.user = cls.wztgClient(
+                    "WZ-User",
+                    session_string=Config.USER_SESSION_STRING,
+                    sleep_threshold=60,
+                    no_updates=True,
+                )
+                await cls.user.start()
+                cls.IS_PREMIUM_USER = cls.user.me.is_premium
+                if cls.IS_PREMIUM_USER:
+                    cls.MAX_SPLIT_SIZE = 4194304000
+                uname = cls.user.me.username or cls.user.me.first_name
+                LOGGER.info(f"WZ User : [{uname}] Started!")
+            except Exception as e:
+                LOGGER.error(f"Failed to start client from USER_SESSION_STRING. {e}")
+                cls.IS_PREMIUM_USER = False
+                cls.user = None
+
+    @classmethod
+    async def stop(cls):
+        async with cls._lock:
+            if cls.bot:
+                await cls.bot.stop()
+                cls.bot = None
+            if cls.user:
+                await cls.user.stop()
+                cls.user = None
+            if cls.helper_bots:
+                await gather(*[h_bot.stop() for h_bot in cls.helper_bots.values()])
+                cls.helper_bots = {}
+            LOGGER.info("All Client(s) stopped")
+
+    @classmethod
+    async def reload(cls):
+        async with cls._lock:
+            await cls.bot.restart()
+            if cls.user:
+                await cls.user.restart()
+            if cls.helper_bots:
+                await gather(*[h_bot.restart() for h_bot in cls.helper_bots.values()])
+            LOGGER.info("All Client(s) restarted")

bot/core/torrent_manager.py

@@ -0,0 +1,166 @@
+from asyncio import TimeoutError, gather
+from contextlib import suppress
+from inspect import iscoroutinefunction
+from pathlib import Path
+
+from aioaria2 import Aria2WebsocketClient
+from aiohttp import ClientError
+from aioqbt.client import create_client
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from .. import LOGGER, aria2_options
+from .config_manager import Config
+
+
+def wrap_with_retry(obj, max_retries=3):
+    for attr_name in dir(obj):
+        if attr_name.startswith("_"):
+            continue
+
+        attr = getattr(obj, attr_name)
+        if iscoroutinefunction(attr):
+            retry_policy = retry(
+                stop=stop_after_attempt(max_retries),
+                wait=wait_exponential(multiplier=1, min=1, max=5),
+                retry=retry_if_exception_type(
+                    (ClientError, TimeoutError, RuntimeError)
+                ),
+            )
+            wrapped = retry_policy(attr)
+            setattr(obj, attr_name, wrapped)
+    return obj
+
+
+class TorrentManager:
+    aria2 = None
+    qbittorrent = None
+
+    @classmethod
+    async def initiate(cls):
+        if cls.aria2:
+            return
+        try:
+            cls.aria2 = await Aria2WebsocketClient.new("http://localhost:6800/jsonrpc")
+            LOGGER.info("Aria2 initialized successfully.")
+
+            if Config.DISABLE_TORRENTS:
+                LOGGER.info("Torrents are disabled.")
+                return
+
+            cls.qbittorrent = await create_client("http://localhost:8090/api/v2/")
+            cls.qbittorrent = wrap_with_retry(cls.qbittorrent)
+
+        except Exception as e:
+            LOGGER.error(f"Error during initialization: {e}")
+            await cls.close_all()
+            raise
+
+    @classmethod
+    async def close_all(cls):
+        close_tasks = []
+        if cls.aria2:
+            close_tasks.append(cls.aria2.close())
+            cls.aria2 = None
+        if cls.qbittorrent:
+            close_tasks.append(cls.qbittorrent.close())
+            cls.qbittorrent = None
+        if close_tasks:
+            await gather(*close_tasks)
+
+    @classmethod
+    async def aria2_remove(cls, download):
+        if download.get("status", "") in ["active", "paused", "waiting"]:
+            await cls.aria2.forceRemove(download.get("gid", ""))
+        else:
+            with suppress(Exception):
+                await cls.aria2.removeDownloadResult(download.get("gid", ""))
+
+    @classmethod
+    async def remove_all(cls):
+        await cls.pause_all()
+        if cls.qbittorrent:
+            await gather(
+                cls.qbittorrent.torrents.delete("all", False),
+                cls.aria2.purgeDownloadResult(),
+            )
+        else:
+            await gather(
+                cls.aria2.purgeDownloadResult(),
+            )
+        downloads = []
+        results = await gather(cls.aria2.tellActive(), cls.aria2.tellWaiting(0, 1000))
+        for res in results:
+            downloads.extend(res)
+        tasks = []
+        tasks.extend(
+            cls.aria2.forceRemove(download.get("gid")) for download in downloads
+        )
+        with suppress(Exception):
+            await gather(*tasks)
+
+    @classmethod
+    async def overall_speed(cls):
+        aria2_speed = await cls.aria2.getGlobalStat()
+        download_speed = int(aria2_speed.get("downloadSpeed", "0"))
+        upload_speed = int(aria2_speed.get("uploadSpeed", "0"))
+
+        if cls.qbittorrent:
+            qb_speed = await cls.qbittorrent.transfer.info()
+            download_speed += qb_speed.dl_info_speed
+            upload_speed += qb_speed.up_info_speed
+
+        return download_speed, upload_speed
+
+    @classmethod
+    async def pause_all(cls):
+        pause_tasks = [cls.aria2.forcePauseAll()]
+        if cls.qbittorrent:
+            pause_tasks.append(cls.qbittorrent.torrents.stop("all"))
+        await gather(*pause_tasks)
+
+    @classmethod
+    async def change_aria2_option(cls, key, value):
+        downloads = []
+        results = await gather(cls.aria2.tellActive(), cls.aria2.tellWaiting(0, 1000))
+        for res in results:
+            downloads.extend(res)
+        tasks = [
+            cls.aria2.changeOption(download.get("gid"), {key: value})
+            for download in downloads
+            if download.get("status", "") != "complete"
+        ]
+        if tasks:
+            try:
+                await gather(*tasks)
+            except Exception as e:
+                LOGGER.error(e)
+        if key not in ["checksum", "index-out", "out", "pause", "select-file"]:
+            await cls.aria2.changeGlobalOption({key: value})
+            aria2_options[key] = value
+
+
+def aria2_name(download_info):
+    if "bittorrent" in download_info and download_info["bittorrent"].get("info"):
+        return download_info["bittorrent"]["info"]["name"]
+    elif download_info.get("files"):
+        if download_info["files"][0]["path"].startswith("[METADATA]"):
+            return download_info["files"][0]["path"]
+        file_path = download_info["files"][0]["path"]
+        dir_path = download_info["dir"]
+        if file_path.startswith(dir_path):
+            return Path(file_path[len(dir_path) + 1 :]).parts[0]
+        else:
+            return ""
+    else:
+        return ""
+
+
+def is_metadata(download_info):
+    return any(
+        f["path"].startswith("[METADATA]") for f in download_info.get("files", [])
+    )

bot/helper/__init__.py

@@ -0,0 +1 @@
+

bot/helper/common.py

@@ -0,0 +1,1162 @@
+import re
+from asyncio import gather, sleep
+from contextlib import suppress
+from os import path as ospath, walk
+from re import sub
+from secrets import token_hex
+from shlex import split
+
+from aiofiles.os import listdir, makedirs, remove, path as aiopath
+from aioshutil import move, rmtree
+from pyrogram.enums import ChatAction
+
+from .. import (
+    DOWNLOAD_DIR,
+    LOGGER,
+    cores,
+    cpu_eater_lock,
+    excluded_extensions,
+    intervals,
+    multi_tags,
+    task_dict,
+    task_dict_lock,
+    user_data,
+)
+from ..core.config_manager import Config, BinConfig
+from ..core.tg_client import TgClient
+from .ext_utils.bot_utils import get_size_bytes, new_task, sync_to_async
+from .ext_utils.bulk_links import extract_bulk_links
+from .ext_utils.files_utils import (
+    SevenZ,
+    get_base_name,
+    get_path_size,
+    is_archive,
+    is_archive_split,
+    is_first_archive_split,
+    split_file,
+)
+from .ext_utils.links_utils import (
+    is_gdrive_id,
+    is_gdrive_link,
+    is_rclone_path,
+    is_telegram_link,
+    is_mega_link,
+)
+from .ext_utils.media_utils import (
+    FFMpeg,
+    create_thumb,
+    get_document_type,
+    take_ss,
+)
+from .ext_utils.metadata_utils import MetadataProcessor
+from .mirror_leech_utils.gdrive_utils.list import GoogleDriveList
+from .mirror_leech_utils.rclone_utils.list import RcloneList
+from .mirror_leech_utils.status_utils.ffmpeg_status import FFmpegStatus
+from .mirror_leech_utils.status_utils.sevenz_status import SevenZStatus
+from .telegram_helper.bot_commands import BotCommands
+from .telegram_helper.message_utils import (
+    get_tg_link_message,
+    send_message,
+    send_status_message,
+)
+
+
+class TaskConfig:
+    def __init__(self):
+        self.mid = self.message.id
+        self.user = self.message.from_user or self.message.sender_chat
+        self.user_id = self.user.id
+        self.user_dict = user_data.get(self.user_id, {})
+        self.metadata_processor = MetadataProcessor()
+        for k in ("METADATA", "AUDIO_METADATA", "VIDEO_METADATA", "SUBTITLE_METADATA"):
+            v = self.user_dict.get(k, {})
+            if k == "METADATA":
+                k = "default_metadata"
+            if isinstance(v, dict):
+                setattr(self, f"{k.lower()}_dict", v)
+            elif isinstance(v, str):
+                setattr(
+                    self, f"{k.lower()}_dict", self.metadata_processor.parse_string(v)
+                )
+            else:
+                setattr(self, f"{k.lower()}_dict", {})
+        self.dir = f"{DOWNLOAD_DIR}{self.mid}"
+        self.up_dir = ""
+        self.link = ""
+        self.up_dest = ""
+        self.leech_dest = ""
+        self.rc_flags = ""
+        self.tag = ""
+        self.name = ""
+        self.subname = ""
+        self.name_swap = ""
+        self.thumbnail_layout = ""
+        self.folder_name = ""
+        self.split_size = 0
+        self.max_split_size = 0
+        self.multi = 0
+        self.size = 0
+        self.subsize = 0
+        self.proceed_count = 0
+        self.is_leech = False
+        self.is_yt = False
+        self.is_qbit = False
+        self.is_mega = False
+        self.is_nzb = False
+        self.is_jd = False
+        self.is_clone = False
+        self.is_uphoster = False
+        self.is_gdrive = False
+        self.is_rclone = False
+        self.is_ytdlp = False
+        self.equal_splits = False
+        self.user_transmission = False
+        self.hybrid_leech = False
+        self.extract = False
+        self.compress = False
+        self.select = False
+        self.seed = False
+        self.join = False
+        self.private_link = False
+        self.stop_duplicate = False
+        self.sample_video = False
+        self.convert_audio = False
+        self.convert_video = False
+        self.screen_shots = False
+        self.is_cancelled = False
+        self.force_run = False
+        self.force_download = False
+        self.force_upload = False
+        self.is_torrent = False
+        self.as_med = False
+        self.as_doc = False
+        self.is_file = False
+        self.bot_trans = False
+        self.user_trans = False
+        self.progress = True
+        self.ffmpeg_cmds = None
+        self.metadata_title = None
+        self.chat_thread_id = None
+        self.subproc = None
+        self.thumb = None
+        self.excluded_extensions = []
+        self.files_to_proceed = []
+        self.is_super_chat = self.message.chat.type.name in [
+            "SUPERGROUP",
+            "CHANNEL",
+            "FORUM",
+        ]
+        self.source_url = None
+        self.bot_pm = Config.BOT_PM or self.user_dict.get("BOT_PM")
+        self.pm_msg = None
+        self.file_details = {}
+        self.mode = tuple()
+
+    def _set_mode_engine(self):
+        self.source_url = (
+            self.link
+            if len(self.link) > 0 and self.link.startswith("http")
+            else (
+                f"https://t.me/share/url?url={self.link}"
+                if self.link
+                else self.message.link
+            )
+        )
+
+        out_mode = f"#{'Leech' if self.is_leech else 'UphosterUpload' if self.is_uphoster else 'Clone' if self.is_clone else 'RClone' if self.up_dest.startswith('mrcc:') or is_rclone_path(self.up_dest) else 'GDrive' if self.up_dest.startswith(('mtp:', 'tp:', 'sa:')) or is_gdrive_id(self.up_dest) else 'UpHosters'}"
+        out_mode += " (Zip)" if self.compress else " (Unzip)" if self.extract else ""
+
+        self.is_rclone = is_rclone_path(self.link)
+        self.is_gdrive = is_gdrive_link(self.source_url) if self.source_url else False
+        self.is_mega = is_mega_link(self.link) if self.source_url else False
+
+        in_mode = f"#{'Mega' if self.is_mega else 'qBit' if self.is_qbit else 'SABnzbd' if self.is_nzb else 'JDown' if self.is_jd else 'RCloneDL' if self.is_rclone else 'ytdlp' if self.is_ytdlp else 'GDrive' if (self.is_clone or self.is_gdrive) else 'Aria2' if (self.source_url and self.source_url != self.message.link) else 'TgMedia'}"
+
+        self.mode = (in_mode, out_mode)
+
+    def get_token_path(self, dest):
+        if dest.startswith("mtp:"):
+            return f"tokens/{self.user_id}.pickle"
+        elif (
+            dest.startswith("sa:")
+            or Config.USE_SERVICE_ACCOUNTS
+            and not dest.startswith("tp:")
+        ):
+            return "accounts"
+        else:
+            return "token.pickle"
+
+    def get_config_path(self, dest):
+        return (
+            f"rclone/{self.user_id}.conf" if dest.startswith("mrcc:") else "rclone.conf"
+        )
+
+    async def is_token_exists(self, path, status):
+        if is_rclone_path(path):
+            config_path = self.get_config_path(path)
+            if config_path != "rclone.conf" and status == "up":
+                self.private_link = True
+            if not await aiopath.exists(config_path):
+                raise ValueError(f"Rclone Config: {config_path} not Exists!")
+        elif (
+            status == "dl"
+            and is_gdrive_link(path)
+            or status == "up"
+            and is_gdrive_id(path)
+        ):
+            token_path = self.get_token_path(path)
+            if token_path.startswith("tokens/") and status == "up":
+                self.private_link = True
+            if not await aiopath.exists(token_path):
+                raise ValueError(f"NO TOKEN! {token_path} not Exists!")
+
+    async def before_start(self):
+        self.name_swap = (
+            self.name_swap
+            or self.user_dict.get("NAME_SWAP", False)
+            or (Config.NAME_SWAP if "NAME_SWAP" not in self.user_dict else "")
+        )
+        if self.name_swap:
+            self.name_swap = [x.split(":") for x in self.name_swap.split("|")]
+        self.excluded_extensions = self.user_dict.get("EXCLUDED_EXTENSIONS") or (
+            excluded_extensions
+            if "EXCLUDED_EXTENSIONS" not in self.user_dict
+            else ["aria2", "!qB"]
+        )
+        if not self.rc_flags:
+            if self.user_dict.get("RCLONE_FLAGS"):
+                self.rc_flags = self.user_dict["RCLONE_FLAGS"]
+            elif "RCLONE_FLAGS" not in self.user_dict and Config.RCLONE_FLAGS:
+                self.rc_flags = Config.RCLONE_FLAGS
+        if self.link not in ["rcl", "gdl"]:
+            if not self.is_jd:
+                if is_rclone_path(self.link):
+                    if not self.link.startswith("mrcc:") and self.user_dict.get(
+                        "USER_TOKENS", False
+                    ):
+                        self.link = f"mrcc:{self.link}"
+                    await self.is_token_exists(self.link, "dl")
+                elif is_gdrive_link(self.link):
+                    if not self.link.startswith(
+                        ("mtp:", "tp:", "sa:")
+                    ) and self.user_dict.get("USER_TOKENS", False):
+                        self.link = f"mtp:{self.link}"
+                    await self.is_token_exists(self.link, "dl")
+        elif self.link == "rcl":
+            if not self.is_ytdlp and not self.is_jd:
+                self.link = await RcloneList(self).get_rclone_path("rcd")
+                if not is_rclone_path(self.link):
+                    raise ValueError(self.link)
+        elif self.link == "gdl":
+            if not self.is_ytdlp and not self.is_jd:
+                self.link = await GoogleDriveList(self).get_target_id("gdd")
+                if not is_gdrive_id(self.link):
+                    raise ValueError(self.link)
+
+        self.user_transmission = TgClient.IS_PREMIUM_USER and (
+            self.user_dict.get("USER_TRANSMISSION")
+            or Config.USER_TRANSMISSION
+            and "USER_TRANSMISSION" not in self.user_dict
+        )
+
+        if self.user_dict.get("UPLOAD_PATHS", False):
+            if self.up_dest in self.user_dict["UPLOAD_PATHS"]:
+                self.up_dest = self.user_dict["UPLOAD_PATHS"][self.up_dest]
+        elif "UPLOAD_PATHS" not in self.user_dict and Config.UPLOAD_PATHS:
+            if self.up_dest in Config.UPLOAD_PATHS:
+                self.up_dest = Config.UPLOAD_PATHS[self.up_dest]
+
+        if self.ffmpeg_cmds and not isinstance(self.ffmpeg_cmds, list):
+            if self.user_dict.get("FFMPEG_CMDS", None):
+                ffmpeg_dict = self.user_dict["FFMPEG_CMDS"]
+                self.ffmpeg_cmds = [
+                    value
+                    for key in list(self.ffmpeg_cmds)
+                    if key in ffmpeg_dict
+                    for value in ffmpeg_dict[key]
+                ]
+            elif "FFMPEG_CMDS" not in self.user_dict and Config.FFMPEG_CMDS:
+                ffmpeg_dict = Config.FFMPEG_CMDS
+                self.ffmpeg_cmds = [
+                    value
+                    for key in list(self.ffmpeg_cmds)
+                    if key in ffmpeg_dict
+                    for value in ffmpeg_dict[key]
+                ]
+            else:
+                self.ffmpeg_cmds = None
+
+        self.metadata_title = self.user_dict.get("METADATA")
+
+        if not self.is_leech:
+            self.stop_duplicate = (
+                self.user_dict.get("STOP_DUPLICATE")
+                or "STOP_DUPLICATE" not in self.user_dict
+                and Config.STOP_DUPLICATE
+            )
+            default_upload = (
+                self.user_dict.get("DEFAULT_UPLOAD", "") or Config.DEFAULT_UPLOAD
+            )
+            if not self.is_uphoster and (
+                (not self.up_dest and default_upload == "rc") or self.up_dest == "rc"
+            ):
+                self.up_dest = self.user_dict.get("RCLONE_PATH") or Config.RCLONE_PATH
+            elif not self.is_uphoster and (
+                (not self.up_dest and default_upload == "gd") or self.up_dest == "gd"
+            ):
+                self.up_dest = self.user_dict.get("GDRIVE_ID") or Config.GDRIVE_ID
+
+            if self.is_uphoster and not self.up_dest:
+                uphoster_service = self.user_dict.get("UPHOSTER_SERVICE", "gofile")
+                services = uphoster_service.split(",")
+                for service in services:
+                    if service == "gofile":
+                        if not (
+                            self.user_dict.get("GOFILE_TOKEN") or Config.GOFILE_API
+                        ):
+                            raise ValueError("No Gofile Token Found!")
+                    elif service == "buzzheavier":
+                        if not (
+                            self.user_dict.get("BUZZHEAVIER_TOKEN")
+                            or Config.BUZZHEAVIER_API
+                        ):
+                            raise ValueError("No BuzzHeavier Token Found!")
+                    elif service == "pixeldrain":
+                        if not (
+                            self.user_dict.get("PIXELDRAIN_KEY")
+                            or Config.PIXELDRAIN_KEY
+                        ):
+                            raise ValueError("No PixelDrain Key Found!")
+                self.up_dest = "Uphoster"
+
+            if not self.up_dest:
+                raise ValueError("No Upload Destination!")
+
+            if is_gdrive_id(self.up_dest):
+                if not self.up_dest.startswith(
+                    ("mtp:", "tp:", "sa:")
+                ) and self.user_dict.get("USER_TOKENS", False):
+                    self.up_dest = f"mtp:{self.up_dest}"
+            elif is_rclone_path(self.up_dest):
+                if not self.up_dest.startswith("mrcc:") and self.user_dict.get(
+                    "USER_TOKENS", False
+                ):
+                    self.up_dest = f"mrcc:{self.up_dest}"
+                self.up_dest = self.up_dest.strip("/")
+            elif self.is_uphoster:
+                pass
+            else:
+                raise ValueError("Wrong Upload Destination!")
+
+            if self.up_dest not in ["rcl", "gdl"] and not self.is_uphoster:
+                await self.is_token_exists(self.up_dest, "up")
+
+            if self.up_dest == "rcl":
+                if self.is_clone:
+                    if not is_rclone_path(self.link):
+                        raise ValueError(
+                            "You can't clone from different types of tools"
+                        )
+                    config_path = self.get_config_path(self.link)
+                else:
+                    config_path = None
+                self.up_dest = await RcloneList(self).get_rclone_path(
+                    "rcu", config_path
+                )
+                if not is_rclone_path(self.up_dest):
+                    raise ValueError(self.up_dest)
+            elif self.up_dest == "gdl":
+                if self.is_clone:
+                    if not is_gdrive_link(self.link):
+                        raise ValueError(
+                            "You can't clone from different types of tools"
+                        )
+                    token_path = self.get_token_path(self.link)
+                else:
+                    token_path = None
+                self.up_dest = await GoogleDriveList(self).get_target_id(
+                    "gdu", token_path
+                )
+                if not is_gdrive_id(self.up_dest):
+                    raise ValueError(self.up_dest)
+            elif self.is_clone:
+                if is_gdrive_link(self.link) and self.get_token_path(
+                    self.link
+                ) != self.get_token_path(self.up_dest):
+                    raise ValueError("You must use the same token to clone!")
+                elif is_rclone_path(self.link) and self.get_config_path(
+                    self.link
+                ) != self.get_config_path(self.up_dest):
+                    raise ValueError("You must use the same config to clone!")
+        else:
+            self.leech_dest = self.up_dest or self.user_dict.get("LEECH_DUMP_CHAT")
+            self.up_dest = Config.LEECH_DUMP_CHAT
+            self.hybrid_leech = TgClient.IS_PREMIUM_USER and (
+                self.user_dict.get("HYBRID_LEECH")
+                or Config.HYBRID_LEECH
+                and "HYBRID_LEECH" not in self.user_dict
+            )
+            if self.bot_trans:
+                self.user_transmission = False
+                self.hybrid_leech = False
+            if self.user_trans:
+                self.user_transmission = TgClient.IS_PREMIUM_USER
+            if self.up_dest:
+                if not isinstance(self.up_dest, int):
+                    if self.up_dest.startswith("b:"):
+                        self.up_dest = self.up_dest.replace("b:", "", 1)
+                        self.user_transmission = False
+                        self.hybrid_leech = False
+                    elif self.up_dest.startswith("u:"):
+                        self.up_dest = self.up_dest.replace("u:", "", 1)
+                        self.user_transmission = TgClient.IS_PREMIUM_USER
+                    elif self.up_dest.startswith("h:"):
+                        self.up_dest = self.up_dest.replace("h:", "", 1)
+                        self.user_transmission = TgClient.IS_PREMIUM_USER
+                        self.hybrid_leech = self.user_transmission
+                    if "|" in self.up_dest:
+                        self.up_dest, self.chat_thread_id = list(
+                            map(
+                                lambda x: int(x) if x.lstrip("-").isdigit() else x,
+                                self.up_dest.split("|", 1),
+                            )
+                        )
+                    elif self.up_dest.lstrip("-").isdigit():
+                        self.up_dest = int(self.up_dest)
+                    elif self.up_dest.lower() == "pm":
+                        self.up_dest = self.user_id
+
+                if self.user_transmission:
+                    try:
+                        chat = await TgClient.user.get_chat(self.up_dest)
+                    except Exception:
+                        chat = None
+                    if chat is None:
+                        self.user_transmission = False
+                        self.hybrid_leech = False
+                    else:
+                        uploader_id = TgClient.user.me.id
+                        if chat.type.name not in [
+                            "SUPERGROUP",
+                            "CHANNEL",
+                            "GROUP",
+                            "FORUM",
+                        ]:
+                            self.user_transmission = False
+                            self.hybrid_leech = False
+                        else:
+                            member = await chat.get_member(uploader_id)
+                            if (
+                                not member.privileges.can_manage_chat
+                                or not member.privileges.can_delete_messages
+                            ):
+                                self.user_transmission = False
+                                self.hybrid_leech = False
+
+                if not self.user_transmission or self.hybrid_leech:
+                    try:
+                        chat = await self.client.get_chat(self.up_dest)
+                    except Exception:
+                        chat = None
+                    if chat is None:
+                        if self.user_transmission:
+                            self.hybrid_leech = False
+                        else:
+                            raise ValueError("Chat not found!")
+                    else:
+                        uploader_id = self.client.me.id
+                        if chat.type.name in [
+                            "SUPERGROUP",
+                            "CHANNEL",
+                            "GROUP",
+                            "FORUM",
+                        ]:
+                            member = await chat.get_member(uploader_id)
+                            if (
+                                not member.privileges.can_manage_chat
+                                or not member.privileges.can_delete_messages
+                            ):
+                                if not self.user_transmission:
+                                    raise ValueError(
+                                        "You don't have enough privileges in this chat!"
+                                    )
+                                else:
+                                    self.hybrid_leech = False
+                        else:
+                            try:
+                                await self.client.send_chat_action(
+                                    self.up_dest, ChatAction.TYPING
+                                )
+                            except Exception:
+                                raise ValueError("Start the bot and try again!")
+            elif (
+                self.user_transmission or self.hybrid_leech
+            ) and not self.is_super_chat:
+                self.user_transmission = False
+                self.hybrid_leech = False
+            if self.split_size:
+                if self.split_size.isdigit():
+                    self.split_size = int(self.split_size)
+                else:
+                    self.split_size = get_size_bytes(self.split_size)
+            self.split_size = (
+                self.split_size
+                or self.user_dict.get("LEECH_SPLIT_SIZE")
+                or Config.LEECH_SPLIT_SIZE
+            )
+            self.equal_splits = (
+                self.user_dict.get("EQUAL_SPLITS")
+                or Config.EQUAL_SPLITS
+                and "EQUAL_SPLITS" not in self.user_dict
+            )
+            self.max_split_size = (
+                TgClient.MAX_SPLIT_SIZE if self.user_transmission else 2097152000
+            )
+            self.split_size = min(self.split_size, self.max_split_size)
+
+            if not self.as_doc:
+                self.as_doc = (
+                    not self.as_med
+                    if self.as_med
+                    else (
+                        self.user_dict.get("AS_DOCUMENT", False)
+                        or Config.AS_DOCUMENT
+                        and "AS_DOCUMENT" not in self.user_dict
+                    )
+                )
+
+            self.thumbnail_layout = (
+                self.thumbnail_layout
+                or self.user_dict.get("THUMBNAIL_LAYOUT", False)
+                or (
+                    Config.THUMBNAIL_LAYOUT
+                    if "THUMBNAIL_LAYOUT" not in self.user_dict
+                    else ""
+                )
+            )
+
+            if self.thumb != "none" and is_telegram_link(self.thumb):
+                msg = (await get_tg_link_message(self.thumb))[0]
+                self.thumb = (
+                    await create_thumb(msg) if msg.photo or msg.document else ""
+                )
+
+    async def get_tag(self, text: list):
+        if len(text) > 1 and text[1].startswith("Tag: "):
+            user_info = text[1].split("Tag: ")
+            if len(user_info) >= 3:
+                id_ = user_info[-1]
+                self.tag = " ".join(user_info[:-1])
+            else:
+                self.tag, id_ = text[1].split("Tag: ")[1].split()
+            self.user = self.message.from_user = await self.client.get_users(int(id_))
+            self.user_id = self.user.id
+            self.user_dict = user_data.get(self.user_id, {})
+            with suppress(Exception):
+                await self.message.unpin()
+        if self.user:
+            if username := self.user.username:
+                self.tag = f"@{username}"
+            elif hasattr(self.user, "mention"):
+                self.tag = self.user.mention
+            else:
+                self.tag = self.user.title
+
+    @new_task
+    async def run_multi(self, input_list, obj):
+        await sleep(7)
+        if not self.multi_tag and self.multi > 1:
+            self.multi_tag = token_hex(3)
+            multi_tags.add(self.multi_tag)
+        elif self.multi <= 1:
+            if self.multi_tag in multi_tags:
+                multi_tags.discard(self.multi_tag)
+            return
+        if self.multi_tag and self.multi_tag not in multi_tags:
+            await send_message(
+                self.message, f"{self.tag} Multi Task has been cancelled!"
+            )
+            await send_status_message(self.message)
+            async with task_dict_lock:
+                for fd_name in self.same_dir:
+                    self.same_dir[fd_name]["total"] -= self.multi
+            return
+        if len(self.bulk) != 0:
+            msg = input_list[:1]
+            msg.append(f"{self.bulk[0]} -i {self.multi - 1} {self.options}")
+            msgts = " ".join(msg)
+            if self.multi > 2:
+                msgts += f"\n• <b>Cancel Multi:</b> <i>/{BotCommands.CancelTaskCommand[1]}_{self.multi_tag}</i>"
+            nextmsg = await send_message(self.message, msgts)
+        else:
+            msg = [s.strip() for s in input_list]
+            index = msg.index("-i")
+            msg[index + 1] = f"{self.multi - 1}"
+            nextmsg = await self.client.get_messages(
+                chat_id=self.message.chat.id,
+                message_ids=self.message.reply_to_message_id + 1,
+            )
+            msgts = " ".join(msg)
+            if self.multi > 2:
+                msgts += f"\n• <b>Cancel Multi:</b> <i>/{BotCommands.CancelTaskCommand[1]}_{self.multi_tag}</i>"
+            nextmsg = await send_message(nextmsg, msgts)
+        nextmsg = await self.client.get_messages(
+            chat_id=self.message.chat.id, message_ids=nextmsg.id
+        )
+        if self.message.from_user:
+            nextmsg.from_user = self.user
+        else:
+            nextmsg.sender_chat = self.user
+        if intervals["stopAll"]:
+            return
+
+        await obj(
+            client=self.client,
+            message=nextmsg,
+            is_qbit=self.is_qbit,
+            is_leech=self.is_leech,
+            is_jd=self.is_jd,
+            is_nzb=self.is_nzb,
+            is_uphoster=self.is_uphoster,
+            same_dir=self.same_dir,
+            bulk=self.bulk,
+            multi_tag=self.multi_tag,
+            options=self.options,
+        ).new_event()
+
+    async def init_bulk(self, input_list, bulk_start, bulk_end, obj):
+        if Config.DISABLE_BULK:
+            await send_message(self.message, "Bulk downloads are currently disabled.")
+            return
+        try:
+            self.bulk = await extract_bulk_links(self.message, bulk_start, bulk_end)
+            if len(self.bulk) == 0:
+                raise ValueError("Bulk Empty!")
+            b_msg = input_list[:1]
+            self.options = input_list[1:]
+            index = self.options.index("-b")
+            del self.options[index]
+            if bulk_start or bulk_end:
+                del self.options[index]
+            self.options = " ".join(self.options)
+            b_msg.append(f"{self.bulk[0]} -i {len(self.bulk)} {self.options}")
+            msg = " ".join(b_msg)
+            if len(self.bulk) > 2:
+                self.multi_tag = token_hex(3)
+                multi_tags.add(self.multi_tag)
+                msg += f"\n• <b>Cancel Multi:</b> <i>/{BotCommands.CancelTaskCommand[1]}_{self.multi_tag}</i>"
+            nextmsg = await send_message(self.message, msg)
+            nextmsg = await self.client.get_messages(
+                chat_id=self.message.chat.id, message_ids=nextmsg.id
+            )
+            if self.message.from_user:
+                nextmsg.from_user = self.user
+            else:
+                nextmsg.sender_chat = self.user
+
+            await obj(
+                client=self.client,
+                message=nextmsg,
+                is_qbit=self.is_qbit,
+                is_leech=self.is_leech,
+                is_jd=self.is_jd,
+                is_nzb=self.is_nzb,
+                is_uphoster=self.is_uphoster,
+                same_dir=self.same_dir,
+                bulk=self.bulk,
+                multi_tag=self.multi_tag,
+                options=self.options,
+            ).new_event()
+        except Exception:
+            await send_message(
+                self.message,
+                "Reply to text file or to telegram message that have links seperated by new line!",
+            )
+
+    async def proceed_extract(self, dl_path, gid):
+        pswd = self.extract if isinstance(self.extract, str) else ""
+        self.files_to_proceed = []
+        if self.is_file and is_archive(dl_path):
+            self.files_to_proceed.append(dl_path)
+        else:
+            for dirpath, _, files in await sync_to_async(walk, dl_path, topdown=False):
+                for file_ in files:
+                    if (
+                        is_first_archive_split(file_)
+                        or is_archive(file_)
+                        and not file_.strip().lower().endswith(".rar")
+                    ):
+                        f_path = ospath.join(dirpath, file_)
+                        self.files_to_proceed.append(f_path)
+
+        if not self.files_to_proceed:
+            return dl_path
+        sevenz = SevenZ(self)
+        LOGGER.info(f"Extracting: {self.name}")
+        async with task_dict_lock:
+            task_dict[self.mid] = SevenZStatus(self, sevenz, gid, "Extract")
+        for dirpath, _, files in await sync_to_async(
+            walk, self.up_dir or self.dir, topdown=False
+        ):
+            code = 0
+            for file_ in files:
+                if self.is_cancelled:
+                    return False
+                if (
+                    is_first_archive_split(file_)
+                    or is_archive(file_)
+                    and not file_.strip().lower().endswith(".rar")
+                ):
+                    self.proceed_count += 1
+                    f_path = ospath.join(dirpath, file_)
+                    t_path = get_base_name(f_path) if self.is_file else dirpath
+                    if not self.is_file:
+                        self.subname = file_
+                    code = await sevenz.extract(f_path, t_path, pswd)
+            if self.is_cancelled:
+                return code
+            if code == 0:
+                for file_ in files:
+                    if is_archive_split(file_) or is_archive(file_):
+                        del_path = ospath.join(dirpath, file_)
+                        try:
+                            await remove(del_path)
+                        except Exception:
+                            self.is_cancelled = True
+        return t_path if self.is_file and code == 0 else dl_path
+
+    async def proceed_ffmpeg(self, dl_path, gid):
+        checked = False
+        cmds = [
+            [part.strip() for part in split(item) if part.strip()]
+            for item in self.ffmpeg_cmds
+        ]
+        try:
+            ffmpeg = FFMpeg(self)
+            for ffmpeg_cmd in cmds:
+                self.proceed_count = 0
+                cmd = [
+                    "taskset",
+                    "-c",
+                    f"{cores}",
+                    BinConfig.FFMPEG_NAME,
+                    "-hide_banner",
+                    "-loglevel",
+                    "error",
+                    "-progress",
+                    "pipe:1",
+                ] + ffmpeg_cmd
+                if "-del" in cmd:
+                    cmd.remove("-del")
+                    delete_files = True
+                else:
+                    delete_files = False
+                index = cmd.index("-i")
+                input_file = cmd[index + 1]
+                if input_file.strip().endswith(".video"):
+                    ext = "video"
+                elif input_file.strip().endswith(".audio"):
+                    ext = "audio"
+                elif "." not in input_file:
+                    ext = "all"
+                else:
+                    ext = ospath.splitext(input_file)[-1].lower()
+                if await aiopath.isfile(dl_path):
+                    is_video, is_audio, _ = await get_document_type(dl_path)
+                    if not is_video and not is_audio:
+                        break
+                    elif is_video and ext == "audio":
+                        break
+                    elif is_audio and not is_video and ext == "video":
+                        break
+                    elif ext not in [
+                        "all",
+                        "audio",
+                        "video",
+                    ] and not dl_path.strip().lower().endswith(ext):
+                        break
+                    new_folder = ospath.splitext(dl_path)[0]
+                    if await aiopath.isfile(new_folder):
+                        new_folder = f"{new_folder}_temp"
+                    name = ospath.basename(dl_path)
+                    await makedirs(new_folder, exist_ok=True)
+                    file_path = f"{new_folder}/{name}"
+                    await move(dl_path, file_path)
+                    if not checked:
+                        checked = True
+                        async with task_dict_lock:
+                            task_dict[self.mid] = FFmpegStatus(
+                                self, ffmpeg, gid, "FFmpeg"
+                            )
+                        self.progress = False
+                        await cpu_eater_lock.acquire()
+                        self.progress = True
+                    LOGGER.info(f"Running ffmpeg cmd for: {file_path}")
+                    var_cmd = cmd.copy()
+                    var_cmd[index + 1] = file_path
+                    self.subsize = self.size
+                    res = await ffmpeg.ffmpeg_cmds(var_cmd, file_path)
+                    if res:
+                        if delete_files:
+                            await remove(file_path)
+                            if len(await listdir(new_folder)) == 1:
+                                folder = new_folder.rsplit("/", 1)[0]
+                                self.name = ospath.basename(res[0])
+                                if self.name.startswith("ffmpeg"):
+                                    self.name = self.name.split(".", 1)[-1]
+                                dl_path = ospath.join(folder, self.name)
+                                await move(res[0], dl_path)
+                                await rmtree(new_folder)
+                            else:
+                                dl_path = new_folder
+                                self.name = new_folder.rsplit("/", 1)[-1]
+                        else:
+                            dl_path = new_folder
+                            self.name = new_folder.rsplit("/", 1)[-1]
+                    else:
+                        await move(file_path, dl_path)
+                        await rmtree(new_folder)
+                else:
+                    for dirpath, _, files in await sync_to_async(
+                        walk, dl_path, topdown=False
+                    ):
+                        for file_ in files:
+                            var_cmd = cmd.copy()
+                            if self.is_cancelled:
+                                return False
+                            f_path = ospath.join(dirpath, file_)
+                            is_video, is_audio, _ = await get_document_type(f_path)
+                            if not is_video and not is_audio:
+                                continue
+                            elif is_video and ext == "audio":
+                                continue
+                            elif is_audio and not is_video and ext == "video":
+                                continue
+                            elif ext not in [
+                                "all",
+                                "audio",
+                                "video",
+                            ] and not f_path.strip().lower().endswith(ext):
+                                continue
+                            self.proceed_count += 1
+                            var_cmd[index + 1] = f_path
+                            if not checked:
+                                checked = True
+                                async with task_dict_lock:
+                                    task_dict[self.mid] = FFmpegStatus(
+                                        self, ffmpeg, gid, "FFmpeg"
+                                    )
+                                self.progress = False
+                                await cpu_eater_lock.acquire()
+                                self.progress = True
+                            LOGGER.info(f"Running ffmpeg cmd for: {f_path}")
+                            self.subsize = await get_path_size(f_path)
+                            self.subname = file_
+                            res = await ffmpeg.ffmpeg_cmds(var_cmd, f_path)
+                            if res and delete_files:
+                                await remove(f_path)
+                                if len(res) == 1:
+                                    file_name = ospath.basename(res[0])
+                                    if file_name.startswith("ffmpeg"):
+                                        newname = file_name.split(".", 1)[-1]
+                                        newres = ospath.join(dirpath, newname)
+                                        await move(res[0], newres)
+        finally:
+            if checked:
+                cpu_eater_lock.release()
+        return dl_path
+
+    async def substitute(self, dl_path):
+        def perform_swap(name, swaps):
+            name, ext = ospath.splitext(name)
+            name = sub(r"www\S+", "", name)
+            for swap in swaps:
+                pattern, res, cnt, sen = (
+                    swap + ["", "0", "NOFLAG"][min(len(swap) - 1, 2) :]
+                )[0:4]
+                cnt = 0 if len(cnt) == 0 else int(cnt)
+                try:
+                    name = sub(
+                        rf"{pattern}", res, name, cnt, flags=getattr(re, sen.upper(), 0)
+                    )
+                except Exception as e:
+                    LOGGER.error(
+                        f"Swap Error: pattern: {pattern} res: {res}. Error: {e}"
+                    )
+                    return False
+                if len(name.encode()) > 255:
+                    LOGGER.error(f"Substitute: {name} is too long")
+                    return False
+            return name + ext
+
+        if self.is_file:
+            up_dir, name = dl_path.rsplit("/", 1)
+            new_name = perform_swap(name, self.name_swap)
+            if not new_name:
+                return dl_path
+            new_path = ospath.join(up_dir, new_name)
+            await move(dl_path, new_path)
+            return new_path
+        else:
+            for dirpath, _, files in await sync_to_async(walk, dl_path, topdown=False):
+                for file_ in files:
+                    f_path = ospath.join(dirpath, file_)
+                    new_name = perform_swap(file_, self.name_swap)
+                    if not new_name:
+                        continue
+                    await move(f_path, ospath.join(dirpath, new_name))
+            return dl_path
+
+    async def generate_screenshots(self, dl_path):
+        ss_nb = int(self.screen_shots) if isinstance(self.screen_shots, str) else 10
+        if self.is_file:
+            if (await get_document_type(dl_path))[0]:
+                LOGGER.info(f"Creating Screenshot for: {dl_path}")
+                res = await take_ss(dl_path, ss_nb)
+                if res:
+                    new_folder = ospath.splitext(dl_path)[0]
+                    if await aiopath.isfile(new_folder):
+                        new_folder = f"{new_folder}_temp"
+                    name = ospath.basename(dl_path)
+                    await makedirs(new_folder, exist_ok=True)
+                    await gather(
+                        move(dl_path, f"{new_folder}/{name}"),
+                        move(res, new_folder),
+                    )
+                    return new_folder
+        else:
+            LOGGER.info(f"Creating Screenshot for: {dl_path}")
+            for dirpath, _, files in await sync_to_async(walk, dl_path, topdown=False):
+                for file_ in files:
+                    f_path = ospath.join(dirpath, file_)
+                    if (await get_document_type(f_path))[0]:
+                        await take_ss(f_path, ss_nb)
+        return dl_path
+
+    async def convert_media(self, dl_path, gid):
+        fvext = []
+        if self.convert_video:
+            vdata = self.convert_video.split()
+            vext = vdata[0].lower()
+            if len(vdata) > 2:
+                if "+" in vdata[1].split():
+                    vstatus = "+"
+                elif "-" in vdata[1].split():
+                    vstatus = "-"
+                else:
+                    vstatus = ""
+                fvext.extend(f".{ext.lower()}" for ext in vdata[2:])
+            else:
+                vstatus = ""
+        else:
+            vext = ""
+            vstatus = ""
+
+        faext = []
+        if self.convert_audio:
+            adata = self.convert_audio.split()
+            aext = adata[0].lower()
+            if len(adata) > 2:
+                if "+" in adata[1].split():
+                    astatus = "+"
+                elif "-" in adata[1].split():
+                    astatus = "-"
+                else:
+                    astatus = ""
+                faext.extend(f".{ext.lower()}" for ext in adata[2:])
+            else:
+                astatus = ""
+        else:
+            aext = ""
+            astatus = ""
+
+        self.files_to_proceed = {}
+        all_files = []
+        if self.is_file:
+            all_files.append(dl_path)
+        else:
+            for dirpath, _, files in await sync_to_async(walk, dl_path, topdown=False):
+                for file_ in files:
+                    f_path = ospath.join(dirpath, file_)
+                    all_files.append(f_path)
+
+        for f_path in all_files:
+            is_video, is_audio, _ = await get_document_type(f_path)
+            if (
+                is_video
+                and vext
+                and not f_path.strip().lower().endswith(f".{vext}")
+                and (
+                    vstatus == "+"
+                    and f_path.strip().lower().endswith(tuple(fvext))
+                    or vstatus == "-"
+                    and not f_path.strip().lower().endswith(tuple(fvext))
+                    or not vstatus
+                )
+            ):
+                self.files_to_proceed[f_path] = "video"
+            elif (
+                is_audio
+                and aext
+                and not is_video
+                and not f_path.strip().lower().endswith(f".{aext}")
+                and (
+                    astatus == "+"
+                    and f_path.strip().lower().endswith(tuple(faext))
+                    or astatus == "-"
+                    and not f_path.strip().lower().endswith(tuple(faext))
+                    or not astatus
+                )
+            ):
+                self.files_to_proceed[f_path] = "audio"
+        del all_files
+
+        if self.files_to_proceed:
+            ffmpeg = FFMpeg(self)
+            async with task_dict_lock:
+                task_dict[self.mid] = FFmpegStatus(self, ffmpeg, gid, "Convert")
+            self.progress = False
+            async with cpu_eater_lock:
+                self.progress = True
+                for f_path, f_type in self.files_to_proceed.items():
+                    self.proceed_count += 1
+                    LOGGER.info(f"Converting: {f_path}")
+                    if self.is_file:
+                        self.subsize = self.size
+                    else:
+                        self.subsize = await get_path_size(f_path)
+                        self.subname = ospath.basename(f_path)
+                    if f_type == "video":
+                        res = await ffmpeg.convert_video(f_path, vext)
+                    else:
+                        res = await ffmpeg.convert_audio(f_path, aext)
+                    if res:
+                        try:
+                            await remove(f_path)
+                        except Exception:
+                            self.is_cancelled = True
+                            return False
+                        if self.is_file:
+                            return res
+        return dl_path
+
+    async def generate_sample_video(self, dl_path, gid):
+        data = (
+            self.sample_video.split(":") if isinstance(self.sample_video, str) else ""
+        )
+        if data:
+            sample_duration = int(data[0]) if data[0] else 60
+            part_duration = int(data[1]) if len(data) > 1 else 4
+        else:
+            sample_duration = 60
+            part_duration = 4
+
+        self.files_to_proceed = {}
+        if self.is_file and (await get_document_type(dl_path))[0]:
+            file_ = ospath.basename(dl_path)
+            self.files_to_proceed[dl_path] = file_
+        else:
+            for dirpath, _, files in await sync_to_async(walk, dl_path, topdown=False):
+                for file_ in files:
+                    f_path = ospath.join(dirpath, file_)
+                    if (await get_document_type(f_path))[0]:
+                        self.files_to_proceed[f_path] = file_
+        if self.files_to_proceed:
+            ffmpeg = FFMpeg(self)
+            async with task_dict_lock:
+                task_dict[self.mid] = FFmpegStatus(self, ffmpeg, gid, "Sample Video")
+            self.progress = False
+            async with cpu_eater_lock:
+                self.progress = True
+                LOGGER.info(f"Creating Sample video: {self.name}")
+                for f_path, file_ in self.files_to_proceed.items():
+                    self.proceed_count += 1
+                    if self.is_file:
+                        self.subsize = self.size
+                    else:
+                        self.subsize = await get_path_size(f_path)
+                        self.subname = file_
+                    res = await ffmpeg.sample_video(
+                        f_path, sample_duration, part_duration
+                    )
+                    if res and self.is_file:
+                        new_folder = ospath.splitext(f_path)[0]
+                        if await aiopath.isfile(new_folder):
+                            new_folder = f"{new_folder}_temp"
+                        await makedirs(new_folder, exist_ok=True)
+                        await gather(
+                            move(f_path, f"{new_folder}/{file_}"),
+                            move(res, f"{new_folder}/SAMPLE.{file_}"),
+                        )
+                        return new_folder
+        return dl_path
+
+    async def proceed_compress(self, dl_path, gid):
+        pswd = self.compress if isinstance(self.compress, str) else ""
+        if self.is_leech and self.is_file:
+            new_folder = ospath.splitext(dl_path)[0]
+            if await aiopath.isfile(new_folder):
+                new_folder = f"{new_folder}_temp"
+            name = ospath.basename(dl_path)
+            await makedirs(new_folder, exist_ok=True)
+            new_dl_path = f"{new_folder}/{name}"
+            await move(dl_path, new_dl_path)
+            dl_path = new_dl_path
+            up_path = f"{new_dl_path}.zip"
+            self.is_file = False
+        else:
+            up_path = f"{dl_path}.zip"
+        sevenz = SevenZ(self)
+        async with task_dict_lock:
+            task_dict[self.mid] = SevenZStatus(self, sevenz, gid, "Zip")
+        return await sevenz.zip(dl_path, up_path, pswd)
+
+    async def proceed_split(self, dl_path, gid):
+        self.files_to_proceed = {}
+        if self.is_file:
+            f_size = await get_path_size(dl_path)
+            if f_size > self.split_size:
+                self.files_to_proceed[dl_path] = [f_size, ospath.basename(dl_path)]
+        else:
+            for dirpath, _, files in await sync_to_async(walk, dl_path, topdown=False):
+                for file_ in files:
+                    f_path = ospath.join(dirpath, file_)
+                    f_size = await get_path_size(f_path)
+                    if f_size > self.split_size:
+                        self.files_to_proceed[f_path] = [f_size, file_]
+        if self.files_to_proceed:
+            ffmpeg = FFMpeg(self)
+            async with task_dict_lock:
+                task_dict[self.mid] = FFmpegStatus(self, ffmpeg, gid, "Split")
+            LOGGER.info(f"Splitting: {self.name}")
+            for f_path, (f_size, file_) in self.files_to_proceed.items():
+                self.proceed_count += 1
+                if self.is_file:
+                    self.subsize = self.size
+                else:
+                    self.subsize = f_size
+                    self.subname = file_
+                parts = -(-f_size // self.split_size)
+                if self.equal_splits:
+                    split_size = (f_size // parts) + (f_size % parts)
+                else:
+                    split_size = self.split_size
+                if not self.as_doc and (await get_document_type(f_path))[0]:
+                    self.progress = True
+                    res = await ffmpeg.split(f_path, file_, parts, split_size)
+                else:
+                    self.progress = False
+                    res = await split_file(f_path, split_size, self)
+                if self.is_cancelled:
+                    return False
+                if res or f_size >= self.max_split_size:
+                    try:
+                        await remove(f_path)
+                    except Exception:
+                        self.is_cancelled = True
+
+    def parse_metadata_string(self, metadata_str):
+        return self.metadata_processor.parse_string(metadata_str)
+
+    def merge_metadata_dicts(self, default_dict, cmd_dict):
+        return self.metadata_processor.merge_dicts(default_dict, cmd_dict)

bot/helper/ext_utils/__init__.py

@@ -0,0 +1 @@
+

bot/helper/ext_utils/bot_utils.py

@@ -0,0 +1,308 @@
+from asyncio import (
+    create_subprocess_exec,
+    create_subprocess_shell,
+    run_coroutine_threadsafe,
+    sleep,
+)
+from asyncio.subprocess import PIPE
+from concurrent.futures import ThreadPoolExecutor
+from functools import partial, wraps
+
+from httpx import AsyncClient
+
+from ... import bot_loop, user_data
+from ...core.config_manager import Config
+from ..telegram_helper.button_build import ButtonMaker
+from .help_messages import (
+    CLONE_HELP_DICT,
+    MIRROR_HELP_DICT,
+    YT_HELP_DICT,
+)
+from .telegraph_helper import telegraph
+
+COMMAND_USAGE = {}
+
+THREAD_POOL = ThreadPoolExecutor(max_workers=500)
+
+
+class SetInterval:
+    def __init__(self, interval, action, *args, **kwargs):
+        self.interval = interval
+        self.action = action
+        self.task = bot_loop.create_task(self._set_interval(*args, **kwargs))
+
+    async def _set_interval(self, *args, **kwargs):
+        while True:
+            await sleep(self.interval)
+            await self.action(*args, **kwargs)
+
+    def cancel(self):
+        self.task.cancel()
+
+
+def _build_command_usage(help_dict, command_key):
+    buttons = ButtonMaker()
+    cmd_list = list(help_dict.keys())[1:]
+    temp_store = []
+    cmd_pages = [cmd_list[i : i + 10] for i in range(0, len(cmd_list), 10)]
+    for i in range(1, len(cmd_pages) + 1):
+        for name in cmd_pages[i]:
+            buttons.data_button(name, f"help {command_key} {name}")
+        buttons.data_button("Prev", f"help pre {command_key} {i - 1}")
+        buttons.data_button("Next", f"help nex {command_key} {i + 1}")
+        buttons.data_button("Close", "help close", "footer")
+        temp_store.append(buttons.build_menu(2))
+    COMMAND_USAGE[command_key] = [help_dict["main"], *temp_store]
+    buttons.reset()
+
+
+def _build_command_usage(help_dict, command_key):
+    buttons = ButtonMaker()
+    cmd_list = list(help_dict.keys())[1:]
+    cmd_pages = [cmd_list[i : i + 10] for i in range(0, len(cmd_list), 10)]
+    temp_store = []
+
+    for i, page in enumerate(cmd_pages):
+        for name in page:
+            buttons.data_button(name, f"help {command_key} {name} {i}")
+        if len(cmd_pages) > 1:
+            if i > 0:
+                buttons.data_button("⫷", f"help pre {command_key} {i - 1}")
+            if i < len(cmd_pages) - 1:
+                buttons.data_button("⫸", f"help nex {command_key} {i + 1}")
+        buttons.data_button("Close", "help close", "footer")
+        temp_store.append(buttons.build_menu(2))
+        buttons.reset()
+
+    COMMAND_USAGE[command_key] = [help_dict["main"], *temp_store]
+
+
+def create_help_buttons():
+    _build_command_usage(MIRROR_HELP_DICT, "mirror")
+    _build_command_usage(YT_HELP_DICT, "yt")
+    _build_command_usage(CLONE_HELP_DICT, "clone")
+
+
+def compare_versions(v1, v2):
+    v1, v2 = (list(map(int, v.split("-")[0][1:].split("."))) for v in (v1, v2))
+    return (
+        "New Version Update is Available! Check Now!"
+        if v1 < v2
+        else (
+            "More Updated! Kindly Contribute in Official"
+            if v1 > v2
+            else "Already up to date with latest version"
+        )
+    )
+
+
+def bt_selection_buttons(id_):
+    gid = id_[:12] if len(id_) > 25 else id_
+    pin = "".join([n for n in id_ if n.isdigit()][:4])
+    buttons = ButtonMaker()
+    if Config.WEB_PINCODE:
+        buttons.url_button("Select Files", f"{Config.BASE_URL}/app/files?gid={id_}")
+        buttons.data_button("Pincode", f"sel pin {gid} {pin}")
+    else:
+        buttons.url_button(
+            "Select Files", f"{Config.BASE_URL}/app/files?gid={id_}&pin={pin}"
+        )
+    buttons.data_button("Done Selecting", f"sel done {gid} {id_}")
+    buttons.data_button("Cancel", f"sel cancel {gid}")
+    return buttons.build_menu(2)
+
+
+async def get_telegraph_list(telegraph_content):
+    path = [
+        (
+            await telegraph.create_page(
+                title="Mirror-Leech-Bot Drive Search", content=content
+            )
+        )["path"]
+        for content in telegraph_content
+    ]
+    if len(path) > 1:
+        await telegraph.edit_telegraph(path, telegraph_content)
+    buttons = ButtonMaker()
+    buttons.url_button("🔎 VIEW", f"https://telegra.ph/{path[0]}")
+    return buttons.build_menu(1)
+
+
+def arg_parser(items, arg_base):
+    if not items:
+        return
+
+    arg_start = -1
+    i = 0
+    total = len(items)
+
+    bool_arg_set = {
+        "-b",
+        "-e",
+        "-z",
+        "-s",
+        "-j",
+        "-d",
+        "-sv",
+        "-ss",
+        "-f",
+        "-fd",
+        "-fu",
+        "-sync",
+        "-hl",
+        "-doc",
+        "-med",
+        "-ut",
+        "-bt",
+        "-yt",
+    }
+    if Config.DISABLE_BULK and "-b" in items:
+        arg_base["-b"] = False
+
+    if Config.DISABLE_MULTI and "-i" in items:
+        arg_base["-i"] = 0
+
+    if Config.DISABLE_SEED and "-d" in items:
+        arg_base["-d"] = False
+
+    while i < total:
+        part = items[i]
+
+        if part in arg_base:
+            if arg_start == -1:
+                arg_start = i
+
+            if (
+                i + 1 == total
+                and part in bool_arg_set
+                or part
+                in [
+                    "-s",
+                    "-j",
+                    "-f",
+                    "-fd",
+                    "-fu",
+                    "-sync",
+                    "-hl",
+                    "-doc",
+                    "-med",
+                    "-ut",
+                    "-bt",
+                    "-yt",
+                ]
+            ):
+                arg_base[part] = True
+            else:
+                sub_list = []
+                for j in range(i + 1, total):
+                    if items[j] in arg_base:
+                        if part == "-c" and items[j] == "-c":
+                            sub_list.append(items[j])
+                            continue
+                        if part in bool_arg_set and not sub_list:
+                            arg_base[part] = True
+                            break
+                        if not sub_list:
+                            break
+                        check = " ".join(sub_list).strip()
+                        if check.startswith("[") and check.endswith("]"):
+                            break
+                        elif not check.startswith("["):
+                            break
+                    sub_list.append(items[j])
+                if sub_list:
+                    value = " ".join(sub_list)
+                    if part == "-ff" and not value.strip().startswith("["):
+                        arg_base[part].add(value)
+                    else:
+                        arg_base[part] = value
+                    i += len(sub_list)
+
+        i += 1
+
+    if "link" in arg_base:
+        link_items = items[:arg_start] if arg_start != -1 else items
+        if link_items:
+            arg_base["link"] = " ".join(link_items)
+
+
+def get_size_bytes(size):
+    size = size.lower()
+    if "k" in size:
+        size = int(float(size.split("k")[0]) * 1024)
+    elif "m" in size:
+        size = int(float(size.split("m")[0]) * 1048576)
+    elif "g" in size:
+        size = int(float(size.split("g")[0]) * 1073741824)
+    elif "t" in size:
+        size = int(float(size.split("t")[0]) * 1099511627776)
+    else:
+        size = 0
+    return size
+
+
+async def get_content_type(url):
+    try:
+        async with AsyncClient() as client:
+            response = await client.get(url, allow_redirects=True, verify=False)
+            return response.headers.get("Content-Type")
+    except Exception:
+        return None
+
+
+def update_user_ldata(id_, key, value):
+    user_data.setdefault(id_, {})
+    user_data[id_][key] = value
+
+
+async def cmd_exec(cmd, shell=False):
+    if shell:
+        proc = await create_subprocess_shell(cmd, stdout=PIPE, stderr=PIPE)
+    else:
+        proc = await create_subprocess_exec(*cmd, stdout=PIPE, stderr=PIPE)
+    stdout, stderr = await proc.communicate()
+    try:
+        stdout = stdout.decode().strip()
+    except Exception:
+        stdout = "Unable to decode the response!"
+    try:
+        stderr = stderr.decode().strip()
+    except Exception:
+        stderr = "Unable to decode the error!"
+    return stdout, stderr, proc.returncode
+
+
+def new_task(func):
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        task = bot_loop.create_task(func(*args, **kwargs))
+        return task
+
+    return wrapper
+
+
+async def sync_to_async(func, *args, wait=True, **kwargs):
+    pfunc = partial(func, *args, **kwargs)
+    future = bot_loop.run_in_executor(THREAD_POOL, pfunc)
+    return await future if wait else future
+
+
+def async_to_sync(func, *args, wait=True, **kwargs):
+    future = run_coroutine_threadsafe(func(*args, **kwargs), bot_loop)
+    return future.result() if wait else future
+
+
+def loop_thread(func):
+    @wraps(func)
+    def wrapper(*args, wait=False, **kwargs):
+        future = run_coroutine_threadsafe(func(*args, **kwargs), bot_loop)
+        return future.result() if wait else future
+
+    return wrapper
+
+
+def safe_int(value, default=0):
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        return default

bot/helper/ext_utils/bulk_links.py

@@ -0,0 +1,35 @@
+from aiofiles import open as aiopen
+from aiofiles.os import remove
+
+
+def filter_links(links_list, bulk_start, bulk_end):
+    start = bulk_start if bulk_start > 0 else None
+    end = bulk_end if bulk_end > 0 else None
+    return links_list[start:end]
+
+
+def get_links_from_message(text):
+    links_list = text.split("\n")
+    return [item.strip() for item in links_list if len(item) != 0]
+
+
+async def get_links_from_file(message):
+    links_list = []
+    text_file_dir = await message.download()
+    async with aiopen(text_file_dir, "r+") as f:
+        lines = await f.readlines()
+        links_list.extend(line.strip() for line in lines if len(line) != 0)
+    await remove(text_file_dir)
+    return links_list
+
+
+async def extract_bulk_links(message, bulk_start, bulk_end):
+    bulk_start = int(bulk_start)
+    bulk_end = int(bulk_end)
+    links_list = []
+    if reply_to := message.reply_to_message:
+        if (file_ := reply_to.document) and (file_.mime_type == "text/plain"):
+            links_list = await get_links_from_file(reply_to)
+        elif text := reply_to.text:
+            links_list = get_links_from_message(text)
+    return filter_links(links_list, bulk_start, bulk_end) if links_list else links_list

bot/helper/ext_utils/db_handler.py

@@ -0,0 +1,235 @@
+from importlib import import_module
+
+from aiofiles import open as aiopen
+from aiofiles.os import path as aiopath
+from motor.motor_asyncio import AsyncIOMotorClient
+from pymongo.errors import PyMongoError
+from pymongo.server_api import ServerApi
+
+from ... import LOGGER, qbit_options, rss_dict, user_data
+from ...core.config_manager import Config
+from ...core.tg_client import TgClient
+
+
+class DbManager:
+    def __init__(self):
+        self._return = True
+        self._conn = None
+        self.db = None
+
+    async def connect(self):
+        try:
+            if self._conn is not None:
+                await self._conn.close()
+            self._conn = AsyncIOMotorClient(
+                Config.DATABASE_URL, server_api=ServerApi("1")
+            )
+            self.db = self._conn.wzmlx
+            self._return = False
+        except PyMongoError as e:
+            LOGGER.error(f"Error in DB connection: {e}")
+            self.db = None
+            self._return = True
+            self._conn = None
+
+    async def disconnect(self):
+        self._return = True
+        if self._conn is not None:
+            await self._conn.close()
+        self._conn = None
+
+    async def update_deploy_config(self):
+        if self._return:
+            return
+        settings = import_module("config")
+        config_file = {
+            key: value.strip() if isinstance(value, str) else value
+            for key, value in vars(settings).items()
+            if not key.startswith("__")
+        }
+        await self.db.settings.deployConfig.replace_one(
+            {"_id": TgClient.ID}, config_file, upsert=True
+        )
+
+    async def update_config(self, dict_):
+        if self._return:
+            return
+        await self.db.settings.config.update_one(
+            {"_id": TgClient.ID}, {"$set": dict_}, upsert=True
+        )
+
+    async def update_aria2(self, key, value):
+        if self._return:
+            return
+        await self.db.settings.aria2c.update_one(
+            {"_id": TgClient.ID}, {"$set": {key: value}}, upsert=True
+        )
+
+    async def update_qbittorrent(self, key, value):
+        if self._return:
+            return
+        await self.db.settings.qbittorrent.update_one(
+            {"_id": TgClient.ID}, {"$set": {key: value}}, upsert=True
+        )
+
+    async def save_qbit_settings(self):
+        if self._return:
+            return
+        await self.db.settings.qbittorrent.update_one(
+            {"_id": TgClient.ID}, {"$set": qbit_options}, upsert=True
+        )
+
+    async def update_private_file(self, path):
+        if self._return:
+            return
+        db_path = path.replace(".", "__")
+        if await aiopath.exists(path):
+            async with aiopen(path, "rb+") as pf:
+                pf_bin = await pf.read()
+            await self.db.settings.files.update_one(
+                {"_id": TgClient.ID}, {"$set": {db_path: pf_bin}}, upsert=True
+            )
+            if path == "config.py":
+                await self.update_deploy_config()
+        else:
+            await self.db.settings.files.update_one(
+                {"_id": TgClient.ID}, {"$unset": {db_path: ""}}, upsert=True
+            )
+
+    async def update_nzb_config(self):
+        if self._return:
+            return
+        async with aiopen("sabnzbd/SABnzbd.ini", "rb+") as pf:
+            nzb_conf = await pf.read()
+        await self.db.settings.nzb.replace_one(
+            {"_id": TgClient.ID}, {"SABnzbd__ini": nzb_conf}, upsert=True
+        )
+
+    async def update_user_data(self, user_id):
+        if self._return:
+            return
+        data = user_data.get(user_id, {})
+        data = data.copy()
+        for key in ("THUMBNAIL", "RCLONE_CONFIG", "TOKEN_PICKLE", "USER_COOKIE_FILE"):
+            data.pop(key, None)
+        pipeline = [
+            {
+                "$replaceRoot": {
+                    "newRoot": {
+                        "$mergeObjects": [
+                            data,
+                            {
+                                "$arrayToObject": {
+                                    "$filter": {
+                                        "input": {"$objectToArray": "$$ROOT"},
+                                        "as": "field",
+                                        "cond": {
+                                            "$in": [
+                                                "$$field.k",
+                                                [
+                                                    "THUMBNAIL",
+                                                    "RCLONE_CONFIG",
+                                                    "TOKEN_PICKLE",
+                                                    "USER_COOKIE_FILE",
+                                                ],
+                                            ]
+                                        },
+                                    }
+                                }
+                            },
+                        ]
+                    }
+                }
+            }
+        ]
+        await self.db.users[TgClient.ID].update_one(
+            {"_id": user_id}, pipeline, upsert=True
+        )
+
+    async def update_user_doc(self, user_id, key, path=""):
+        if self._return:
+            return
+        if path:
+            async with aiopen(path, "rb+") as doc:
+                doc_bin = await doc.read()
+            await self.db.users[TgClient.ID].update_one(
+                {"_id": user_id}, {"$set": {key: doc_bin}}, upsert=True
+            )
+        else:
+            await self.db.users[TgClient.ID].update_one(
+                {"_id": user_id}, {"$unset": {key: ""}}, upsert=True
+            )
+
+    async def rss_update_all(self):
+        if self._return:
+            return
+        for user_id in list(rss_dict.keys()):
+            await self.db.rss[TgClient.ID].replace_one(
+                {"_id": user_id}, rss_dict[user_id], upsert=True
+            )
+
+    async def rss_update(self, user_id):
+        if self._return:
+            return
+        await self.db.rss[TgClient.ID].replace_one(
+            {"_id": user_id}, rss_dict[user_id], upsert=True
+        )
+
+    async def rss_delete(self, user_id):
+        if self._return:
+            return
+        await self.db.rss[TgClient.ID].delete_one({"_id": user_id})
+
+    async def add_incomplete_task(self, cid, link, tag):
+        if self._return:
+            return
+        await self.db.tasks[TgClient.ID].insert_one(
+            {"_id": link, "cid": cid, "tag": tag}
+        )
+
+    async def get_pm_uids(self):
+        if self._return:
+            return
+        return [doc["_id"] async for doc in self.db.pm_users[TgClient.ID].find({})]
+
+    async def set_pm_users(self, user_id):
+        if self._return:
+            return
+        if not bool(await self.db.pm_users[TgClient.ID].find_one({"_id": user_id})):
+            await self.db.pm_users[TgClient.ID].insert_one({"_id": user_id})
+            LOGGER.info(f"New PM User Added : {user_id}")
+
+    async def rm_pm_user(self, user_id):
+        if self._return:
+            return
+        await self.db.pm_users[TgClient.ID].delete_one({"_id": user_id})
+
+    async def rm_complete_task(self, link):
+        if self._return:
+            return
+        await self.db.tasks[TgClient.ID].delete_one({"_id": link})
+
+    async def get_incomplete_tasks(self):
+        notifier_dict = {}
+        if self._return:
+            return notifier_dict
+        if await self.db.tasks[TgClient.ID].find_one():
+            rows = self.db.tasks[TgClient.ID].find({})
+            async for row in rows:
+                if row["cid"] in list(notifier_dict.keys()):
+                    if row["tag"] in list(notifier_dict[row["cid"]]):
+                        notifier_dict[row["cid"]][row["tag"]].append(row["_id"])
+                    else:
+                        notifier_dict[row["cid"]][row["tag"]] = [row["_id"]]
+                else:
+                    notifier_dict[row["cid"]] = {row["tag"]: [row["_id"]]}
+        await self.db.tasks[TgClient.ID].drop()
+        return notifier_dict
+
+    async def trunc_table(self, name):
+        if self._return:
+            return
+        await self.db[name][TgClient.ID].drop()
+
+
+database = DbManager()

bot/helper/ext_utils/error_handler.py

@@ -0,0 +1,223 @@
+import time
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from enum import Enum
+from functools import wraps
+from typing import Any, Callable, Dict, List, Optional
+
+from .. import LOGGER
+
+
+class ErrorSeverity(Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    CRITICAL = "critical"
+
+
+class CircuitState(Enum):
+    CLOSED = "closed"
+    OPEN = "open"
+    HALF_OPEN = "half_open"
+
+
+@dataclass
+class ErrorRecord:
+    timestamp: datetime
+    error_type: str
+    message: str
+    severity: ErrorSeverity
+    context: Dict[str, Any] = field(default_factory=dict)
+    traceback: Optional[str] = None
+
+
+@dataclass
+class HealthMetrics:
+    total_operations: int = 0
+    successful_operations: int = 0
+    failed_operations: int = 0
+    error_rate: float = 0.0
+    avg_response_time: float = 0.0
+    last_updated: datetime = field(default_factory=datetime.now)
+
+
+class CircuitBreaker:
+    def __init__(self, failure_threshold: int = 5, recovery_timeout: int = 60):
+        self.failure_threshold = failure_threshold
+        self.recovery_timeout = recovery_timeout
+        self.failure_count = 0
+        self.last_failure_time = None
+        self.state = CircuitState.CLOSED
+
+    def can_execute(self) -> bool:
+        if self.state == CircuitState.CLOSED:
+            return True
+        elif self.state == CircuitState.OPEN:
+            if (
+                datetime.now() - self.last_failure_time
+            ).seconds >= self.recovery_timeout:
+                self.state = CircuitState.HALF_OPEN
+                return True
+            return False
+        else:
+            return True
+
+    def on_success(self):
+        self.failure_count = 0
+        self.state = CircuitState.CLOSED
+
+    def on_failure(self):
+        self.failure_count += 1
+        self.last_failure_time = datetime.now()
+        if self.failure_count >= self.failure_threshold:
+            self.state = CircuitState.OPEN
+
+
+class ErrorMonitor:
+    def __init__(self):
+        self.errors: List[ErrorRecord] = []
+        self.health_metrics: Dict[str, HealthMetrics] = {}
+        self.circuit_breakers: Dict[str, CircuitBreaker] = {}
+        self.max_errors = 1000
+
+    def record_error(
+        self,
+        error_type: str,
+        message: str,
+        severity: ErrorSeverity = ErrorSeverity.MEDIUM,
+        context: Dict[str, Any] = None,
+        traceback: str = None,
+    ):
+        error_record = ErrorRecord(
+            timestamp=datetime.now(),
+            error_type=error_type,
+            message=message,
+            severity=severity,
+            context=context or {},
+            traceback=traceback,
+        )
+
+        self.errors.append(error_record)
+        if len(self.errors) > self.max_errors:
+            self.errors.pop(0)
+
+        LOGGER.error(f"Error recorded: {error_type} - {message}")
+
+    def update_health_metrics(
+        self, operation: str, success: bool, response_time: float
+    ):
+        if operation not in self.health_metrics:
+            self.health_metrics[operation] = HealthMetrics()
+
+        metrics = self.health_metrics[operation]
+        metrics.total_operations += 1
+
+        if success:
+            metrics.successful_operations += 1
+        else:
+            metrics.failed_operations += 1
+
+        metrics.error_rate = metrics.failed_operations / metrics.total_operations
+        metrics.avg_response_time = (
+            metrics.avg_response_time * (metrics.total_operations - 1) + response_time
+        ) / metrics.total_operations
+        metrics.last_updated = datetime.now()
+
+    def get_circuit_breaker(self, operation: str) -> CircuitBreaker:
+        if operation not in self.circuit_breakers:
+            self.circuit_breakers[operation] = CircuitBreaker()
+        return self.circuit_breakers[operation]
+
+    def get_error_summary(self, hours: int = 24) -> Dict[str, Any]:
+        cutoff_time = datetime.now() - timedelta(hours=hours)
+        recent_errors = [e for e in self.errors if e.timestamp >= cutoff_time]
+
+        return {
+            "total_errors": len(recent_errors),
+            "errors_by_severity": {
+                severity.value: len(
+                    [e for e in recent_errors if e.severity == severity]
+                )
+                for severity in ErrorSeverity
+            },
+            "errors_by_type": {
+                error_type: len(
+                    [e for e in recent_errors if e.error_type == error_type]
+                )
+                for error_type in set(e.error_type for e in recent_errors)
+            },
+            "health_metrics": {
+                op: {
+                    "error_rate": metrics.error_rate,
+                    "avg_response_time": metrics.avg_response_time,
+                    "total_operations": metrics.total_operations,
+                }
+                for op, metrics in self.health_metrics.items()
+            },
+        }
+
+
+error_monitor = ErrorMonitor()
+
+
+def error_handler(operation: str = None):
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            op_name = operation or func.__name__
+            start_time = time.time()
+
+            circuit_breaker = error_monitor.get_circuit_breaker(op_name)
+            if not circuit_breaker.can_execute():
+                raise Exception(f"Circuit breaker open for {op_name}")
+
+            try:
+                result = await func(*args, **kwargs)
+                circuit_breaker.on_success()
+                error_monitor.update_health_metrics(
+                    op_name, True, time.time() - start_time
+                )
+                return result
+            except Exception as e:
+                circuit_breaker.on_failure()
+                error_monitor.update_health_metrics(
+                    op_name, False, time.time() - start_time
+                )
+                error_monitor.record_error(
+                    error_type=type(e).__name__,
+                    message=str(e),
+                    severity=ErrorSeverity.HIGH,
+                    context={
+                        "operation": op_name,
+                        "args": str(args),
+                        "kwargs": str(kwargs),
+                    },
+                )
+                raise
+
+        return wrapper
+
+    return decorator
+
+
+def circuit_breaker(
+    operation: str, failure_threshold: int = 5, recovery_timeout: int = 60
+):
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            cb = CircuitBreaker(failure_threshold, recovery_timeout)
+            if not cb.can_execute():
+                raise Exception(f"Circuit breaker open for {operation}")
+
+            try:
+                result = await func(*args, **kwargs)
+                cb.on_success()
+                return result
+            except Exception:
+                cb.on_failure()
+                raise
+
+        return wrapper
+
+    return decorator

bot/helper/ext_utils/exceptions.py

@@ -0,0 +1,22 @@
+class DirectDownloadLinkException(Exception):
+    """Not method found for extracting direct download link from the http link"""
+
+    pass
+
+
+class NotSupportedExtractionArchive(Exception):
+    """The archive format use is trying to extract is not supported"""
+
+    pass
+
+
+class RssShutdownException(Exception):
+    """This exception should be raised when shutdown is called to stop the montior"""
+
+    pass
+
+
+class TgLinkException(Exception):
+    """No Access granted for this chat"""
+
+    pass

bot/helper/ext_utils/files_utils.py

@@ -0,0 +1,453 @@
+from aioshutil import rmtree as aiormtree, move
+from asyncio import create_subprocess_exec, sleep, wait_for
+from asyncio.subprocess import PIPE
+from contextlib import suppress
+from psutil import disk_usage
+from os import path as ospath, readlink, walk
+from re import I, escape, search as re_search, split as re_split
+
+from aiofiles.os import (
+    listdir,
+    remove,
+    rmdir,
+    symlink,
+    makedirs as aiomakedirs,
+    path as aiopath,
+    readlink as aioreadlink,
+)
+from magic import Magic
+
+from ... import DOWNLOAD_DIR, LOGGER
+from ...core.torrent_manager import TorrentManager
+from .bot_utils import cmd_exec, sync_to_async
+from .exceptions import NotSupportedExtractionArchive
+
+ARCH_EXT = [
+    ".tar.bz2",
+    ".tar.gz",
+    ".bz2",
+    ".gz",
+    ".tar.xz",
+    ".tar",
+    ".tbz2",
+    ".tgz",
+    ".lzma2",
+    ".zip",
+    ".7z",
+    ".z",
+    ".rar",
+    ".iso",
+    ".wim",
+    ".cab",
+    ".apm",
+    ".arj",
+    ".chm",
+    ".cpio",
+    ".cramfs",
+    ".deb",
+    ".dmg",
+    ".fat",
+    ".hfs",
+    ".lzh",
+    ".lzma",
+    ".mbr",
+    ".msi",
+    ".mslz",
+    ".nsis",
+    ".ntfs",
+    ".rpm",
+    ".squashfs",
+    ".udf",
+    ".vhd",
+    ".xar",
+    ".zst",
+    ".zstd",
+    ".cbz",
+    ".apfs",
+    ".ar",
+    ".qcow",
+    ".macho",
+    ".exe",
+    ".dll",
+    ".sys",
+    ".pmd",
+    ".swf",
+    ".swfc",
+    ".simg",
+    ".vdi",
+    ".vhdx",
+    ".vmdk",
+    ".gzip",
+    ".lzma86",
+    ".sha256",
+    ".sha512",
+    ".sha224",
+    ".sha384",
+    ".sha1",
+    ".md5",
+    ".crc32",
+    ".crc64",
+]
+
+
+FIRST_SPLIT_REGEX = (
+    r"\.part0*1\.rar$|\.7z\.0*1$|\.zip\.0*1$|^(?!.*\.part\d+\.rar$).*\.rar$"
+)
+
+SPLIT_REGEX = r"\.r\d+$|\.7z\.\d+$|\.z\d+$|\.zip\.\d+$|\.part\d+\.rar$"
+
+
+def is_first_archive_split(file):
+    return bool(re_search(FIRST_SPLIT_REGEX, file.lower(), I))
+
+
+def is_archive(file):
+    return file.strip().lower().endswith(tuple(ARCH_EXT))
+
+
+def is_archive_split(file):
+    return bool(re_search(SPLIT_REGEX, file.lower(), I))
+
+
+async def clean_target(opath):
+    if await aiopath.exists(opath):
+        LOGGER.info(f"Cleaning Target: {opath}")
+        try:
+            if await aiopath.isdir(opath):
+                await aiormtree(opath, ignore_errors=True)
+            else:
+                await remove(opath)
+        except Exception as e:
+            LOGGER.error(str(e))
+
+
+async def clean_download(opath):
+    if await aiopath.exists(opath):
+        LOGGER.info(f"Cleaning Download: {opath}")
+        try:
+            await aiormtree(opath, ignore_errors=True)
+        except Exception as e:
+            LOGGER.error(str(e))
+
+
+async def clean_all():
+    await TorrentManager.remove_all()
+    LOGGER.info("Cleaning Download Directory")
+    await (await create_subprocess_exec("rm", "-rf", DOWNLOAD_DIR)).wait()
+    await aiomakedirs(DOWNLOAD_DIR, exist_ok=True)
+
+
+async def clean_unwanted(opath):
+    LOGGER.info(f"Cleaning unwanted files/folders: {opath}")
+    for dirpath, _, files in await sync_to_async(walk, opath, topdown=False):
+        for filee in files:
+            f_path = ospath.join(dirpath, filee)
+            if filee.strip().endswith(".parts") and filee.startswith("."):
+                await remove(f_path)
+        if dirpath.strip().endswith(".unwanted"):
+            await aiormtree(dirpath, ignore_errors=True)
+    for dirpath, _, files in await sync_to_async(walk, opath, topdown=False):
+        if not await listdir(dirpath):
+            await rmdir(dirpath)
+
+
+async def check_storage_threshold(size, threshold, io_task=False, alloc=False):
+    free = (await sync_to_async(disk_usage, DOWNLOAD_DIR)).free
+    return free >= (threshold + (size * (2 if io_task else 1) if not alloc else 0))
+
+
+async def get_path_size(opath):
+    total_size = 0
+    if await aiopath.isfile(opath):
+        if await aiopath.islink(opath):
+            opath = await aioreadlink(opath)
+        return await aiopath.getsize(opath)
+    for root, _, files in await sync_to_async(walk, opath):
+        for f in files:
+            abs_path = ospath.join(root, f)
+            if await aiopath.islink(abs_path):
+                abs_path = await aioreadlink(abs_path)
+            total_size += await aiopath.getsize(abs_path)
+    return total_size
+
+
+async def count_files_and_folders(opath):
+    total_files = 0
+    total_folders = 0
+    for _, dirs, files in await sync_to_async(walk, opath):
+        total_files += len(files)
+        total_folders += len(dirs)
+    return total_folders, total_files
+
+
+def get_base_name(orig_path):
+    extension = next(
+        (ext for ext in ARCH_EXT if orig_path.strip().lower().endswith(ext)), ""
+    )
+    if extension != "":
+        return re_split(f"{extension}$", orig_path, maxsplit=1, flags=I)[0]
+    else:
+        raise NotSupportedExtractionArchive("File format not supported for extraction")
+
+
+async def create_recursive_symlink(source, destination):
+    if ospath.isdir(source):
+        await aiomakedirs(destination, exist_ok=True)
+        for item in await listdir(source):
+            item_source = ospath.join(source, item)
+            item_dest = ospath.join(destination, item)
+            await create_recursive_symlink(item_source, item_dest)
+    elif ospath.isfile(source):
+        try:
+            await symlink(source, destination)
+        except FileExistsError:
+            LOGGER.error(f"Shortcut already exists: {destination}")
+        except Exception as e:
+            LOGGER.error(f"Error creating shortcut for {source}: {e}")
+
+
+def get_mime_type(file_path):
+    if ospath.islink(file_path):
+        file_path = readlink(file_path)
+    mime = Magic(mime=True)
+    mime_type = mime.from_file(file_path)
+    mime_type = mime_type or "text/plain"
+    return mime_type
+
+
+async def remove_excluded_files(fpath, ee):
+    for root, _, files in await sync_to_async(walk, fpath):
+        if root.strip().endswith("/yt-dlp-thumb"):
+            continue
+        for f in files:
+            if f.strip().lower().endswith(tuple(ee)):
+                await remove(ospath.join(root, f))
+
+
+async def move_and_merge(source, destination, mid):
+    if not await aiopath.exists(destination):
+        await aiomakedirs(destination, exist_ok=True)
+    for item in await listdir(source):
+        item = item.strip()
+        src_path = f"{source}/{item}"
+        dest_path = f"{destination}/{item}"
+        if await aiopath.isdir(src_path):
+            if await aiopath.exists(dest_path):
+                await move_and_merge(src_path, dest_path, mid)
+            else:
+                await move(src_path, dest_path)
+        else:
+            if item.endswith((".aria2", ".!qB")):
+                continue
+            if await aiopath.exists(dest_path):
+                dest_path = f"{destination}/{mid}-{item}"
+            await move(src_path, dest_path)
+
+
+async def join_files(opath):
+    files = await listdir(opath)
+    results = []
+    exists = False
+    for file_ in files:
+        if re_search(r"\.0+2$", file_) and await sync_to_async(
+            get_mime_type, f"{opath}/{file_}"
+        ) not in ["application/x-7z-compressed", "application/zip"]:
+            exists = True
+            final_name = file_.rsplit(".", 1)[0]
+            fpath = f"{opath}/{final_name}"
+            cmd = f'cat "{fpath}."* > "{fpath}"'
+            _, stderr, code = await cmd_exec(cmd, True)
+            if code != 0:
+                LOGGER.error(f"Failed to join {final_name}, stderr: {stderr}")
+                if await aiopath.isfile(fpath):
+                    await remove(fpath)
+            else:
+                results.append(final_name)
+
+    if not exists:
+        LOGGER.warning("No files to join!")
+    elif results:
+        LOGGER.info("Join Completed!")
+        for res in results:
+            for file_ in files:
+                if re_search(rf"{escape(res)}\.0[0-9]+$", file_):
+                    await remove(f"{opath}/{file_}")
+
+
+async def split_file(f_path, split_size, listener):
+    out_path = f"{f_path}."
+    if listener.is_cancelled:
+        return False
+    listener.subproc = await create_subprocess_exec(
+        "split",
+        "--numeric-suffixes=1",
+        "--suffix-length=3",
+        f"--bytes={split_size}",
+        f_path,
+        out_path,
+        stderr=PIPE,
+    )
+    _, stderr = await listener.subproc.communicate()
+    code = listener.subproc.returncode
+    if listener.is_cancelled:
+        return False
+    if code == -9:
+        listener.is_cancelled = True
+        return False
+    elif code != 0:
+        try:
+            stderr = stderr.decode().strip()
+        except Exception:
+            stderr = "Unable to decode the error!"
+        LOGGER.error(f"{stderr}. Split Document: {f_path}")
+    return True
+
+
+class SevenZ:
+    def __init__(self, listener):
+        self._listener = listener
+        self._processed_bytes = 0
+        self._percentage = "0%"
+
+    @property
+    def processed_bytes(self):
+        return self._processed_bytes
+
+    @property
+    def progress(self):
+        return self._percentage
+
+    async def _sevenz_progress(self):
+        pattern = r"(\d+)\s+bytes|Total Physical Size\s*=\s*(\d+)"
+        while not (
+            self._listener.subproc.returncode is not None
+            or self._listener.is_cancelled
+            or self._listener.subproc.stdout.at_eof()
+        ):
+            try:
+                line = await wait_for(self._listener.subproc.stdout.readline(), 2)
+            except Exception:
+                break
+            line = line.decode().strip()
+            if match := re_search(pattern, line):
+                self._listener.subsize = int(match[1] or match[2])
+            await sleep(0.05)
+        s = b""
+        while not (
+            self._listener.is_cancelled
+            or self._listener.subproc.returncode is not None
+            or self._listener.subproc.stdout.at_eof()
+        ):
+            try:
+                char = await wait_for(self._listener.subproc.stdout.read(1), 60)
+            except Exception:
+                break
+            if not char:
+                break
+            s += char
+            if char == b"%":
+                try:
+                    self._percentage = s.decode().rsplit(" ", 1)[-1].strip()
+                    self._processed_bytes = (
+                        int(self._percentage.strip("%")) / 100
+                    ) * self._listener.subsize
+                except Exception:
+                    self._processed_bytes = 0
+                    self._percentage = "0%"
+                s = b""
+            await sleep(0.05)
+
+        self._processed_bytes = 0
+        self._percentage = "0%"
+
+    async def extract(self, f_path, t_path, pswd):
+        cmd = [
+            "7z",
+            "x",
+            f"-p{pswd}",
+            f_path,
+            f"-o{t_path}",
+            "-aot",
+            "-xr!@PaxHeader",
+            "-bsp1",
+            "-bse1",
+            "-bb3",
+        ]
+        if not pswd:
+            del cmd[2]
+        if self._listener.is_cancelled:
+            return False
+        self._listener.subproc = await create_subprocess_exec(
+            *cmd,
+            stdout=PIPE,
+            stderr=PIPE,
+        )
+        await self._sevenz_progress()
+        _, stderr = await self._listener.subproc.communicate()
+        code = self._listener.subproc.returncode
+        if self._listener.is_cancelled:
+            return False
+        if code == -9:
+            self._listener.is_cancelled = True
+            return False
+        elif code != 0:
+            try:
+                stderr = stderr.decode().strip()
+            except Exception:
+                stderr = "Unable to decode the error!"
+            LOGGER.error(f"{stderr}. Unable to extract archive!. Path: {f_path}")
+        return code
+
+    async def zip(self, dl_path, up_path, pswd):
+        size = await get_path_size(dl_path)
+        if self._listener.equal_splits:
+            parts = -(-size // self._listener.split_size)
+            split_size = (size // parts) + (size % parts)
+        else:
+            split_size = self._listener.split_size
+        cmd = [
+            "7z",
+            f"-v{split_size}b",
+            "a",
+            "-mx=0",
+            f"-p{pswd}",
+            up_path,
+            dl_path,
+            "-bsp1",
+            "-bse1",
+            "-bb3",
+        ]
+        if self._listener.is_leech and int(size) > self._listener.split_size:
+            if not pswd:
+                del cmd[4]
+            LOGGER.info(f"Zip: orig_path: {dl_path}, zip_path: {up_path}.0*")
+        else:
+            del cmd[1]
+            if not pswd:
+                del cmd[3]
+            LOGGER.info(f"Zip: orig_path: {dl_path}, zip_path: {up_path}")
+        if self._listener.is_cancelled:
+            return False
+        self._listener.subproc = await create_subprocess_exec(
+            *cmd, stdout=PIPE, stderr=PIPE
+        )
+        await self._sevenz_progress()
+        _, stderr = await self._listener.subproc.communicate()
+        code = self._listener.subproc.returncode
+        if self._listener.is_cancelled:
+            return False
+        if code == -9:
+            self._listener.is_cancelled = True
+            return False
+        elif code == 0:
+            await clean_target(dl_path)
+            return up_path
+        else:
+            if await aiopath.exists(up_path):
+                await remove(up_path)
+            try:
+                stderr = stderr.decode().strip()
+            except Exception:
+                stderr = "Unable to decode the error!"
+            LOGGER.error(f"{stderr}. Unable to zip this path: {dl_path}")
+            return dl_path

bot/helper/ext_utils/help_messages.py

@@ -0,0 +1,551 @@
+# ruff: noqa: F403, F405
+mirror = """<b>Send link along with command line or </b>
+
+/cmd link
+
+<b>By replying to link/file</b>:
+
+/cmd -n new name -e -up upload destination
+
+<b>NOTE:</b>
+1. Commands that start with <b>qb</b> are ONLY for torrents."""
+
+yt = """<b>Send link along with command line</b>:
+
+/cmd link
+<b>By replying to link</b>:
+/cmd -n new name -z password -opt x:y|x1:y1
+
+Check here all supported <a href='https://github.com/yt-dlp/yt-dlp/blob/master/supportedsites.md'>SITES</a>
+Check all yt-dlp api options from this <a href='https://github.com/yt-dlp/yt-dlp/blob/master/yt_dlp/YoutubeDL.py#L212'>FILE</a> or use this <a href='https://t.me/mltb_official_channel/177'>script</a> to convert cli arguments to api options."""
+
+clone = """Send Gdrive|Gdot|Filepress|Filebee|Appdrive|Gdflix link or rclone path along with command or by replying to the link/rc_path by command.
+Use -sync to use sync method in rclone. Example: /cmd rcl/rclone_path -up rcl/rclone_path/rc -sync"""
+
+new_name = """<b>New Name</b>: -n
+
+/cmd link -n new name
+Note: Doesn't work with torrents"""
+
+multi_link = """<b>Multi links only by replying to first link/file</b>: -i
+
+/cmd -i 10(number of links/files)"""
+
+same_dir = """<b>Move file(s)/folder(s) to new folder</b>: -m
+
+You can use this arg also to move multiple links/torrents contents to the same directory, so all links will be uploaded together as one task
+
+/cmd link -m new folder (only one link inside new folder)
+/cmd -i 10(number of links/files) -m folder name (all links contents in one folder)
+/cmd -b -m folder name (reply to batch of message/file(each link on new line))
+
+While using bulk you can also use this arg with different folder name along with the links in message or file batch
+Example:
+link1 -m folder1
+link2 -m folder1
+link3 -m folder2
+link4 -m folder2
+link5 -m folder3
+link6
+so link1 and link2 content will be uploaded from same folder which is folder1
+link3 and link4 content will be uploaded from same folder also which is folder2
+link5 will uploaded alone inside new folder named folder3
+link6 will get uploaded normally alone
+"""
+
+thumb = """<b>Thumbnail for current task</b>: -t
+
+/cmd link -t tg-message-link (doc or photo) or none (file without thumb)"""
+
+split_size = """<b>Split size for current task</b>: -sp
+
+/cmd link -sp (500mb or 2gb or 4000000000)
+Note: Only mb and gb are supported or write in bytes without unit!"""
+
+upload = """<b>Upload Destination</b>: -up
+
+/cmd link -up rcl/gdl (rcl: to select rclone config, remote & path | gdl: To select token.pickle, gdrive id) using buttons
+You can directly add the upload path: -up remote:dir/subdir or -up Gdrive_id or -up id/username (telegram) or -up id/username|topic_id (telegram)
+If DEFAULT_UPLOAD is `rc` then you can pass up: `gd` to upload using gdrive tools to GDRIVE_ID.
+If DEFAULT_UPLOAD is `gd` then you can pass up: `rc` to upload to RCLONE_PATH.
+
+If you want to add path or gdrive manually from your config/token (UPLOADED FROM USETTING) add mrcc: for rclone and mtp: before the path/gdrive_id without space.
+/cmd link -up mrcc:main:dump or -up mtp:gdrive_id <strong>or you can simply edit upload using owner/user token/config from usetting without adding mtp: or mrcc: before the upload path/id</strong>
+
+To add leech destination:
+-up id/@username/pm
+-up b:id/@username/pm (b: means leech by bot) (id or username of the chat or write pm means private message so bot will send the files in private to you)
+when you should use b:(leech by bot)? When your default settings is leech by user and you want to leech by bot for specific task.
+-up u:id/@username(u: means leech by user) This incase OWNER added USER_STRING_SESSION.
+-up h:id/@username(hybrid leech) h: to upload files by bot and user based on file size.
+-up id/@username|topic_id(leech in specific chat and topic) add | without space and write topic id after chat id or username.
+
+In case you want to specify whether using token.pickle or service accounts you can add tp:gdrive_id (using token.pickle) or sa:gdrive_id (using service accounts) or mtp:gdrive_id (using token.pickle uploaded from usetting).
+DEFAULT_UPLOAD doesn't affect on leech cmds.
+"""
+
+user_download = """<b>User Download</b>: link
+
+/cmd tp:link to download using owner token.pickle incase service account enabled.
+/cmd sa:link to download using service account incase service account disabled.
+/cmd tp:gdrive_id to download using token.pickle and file_id incase service account enabled.
+/cmd sa:gdrive_id to download using service account and file_id incase service account disabled.
+/cmd mtp:gdrive_id or mtp:link to download using user token.pickle uploaded from usetting
+/cmd mrcc:remote:path to download using user rclone config uploaded from usetting
+you can simply edit upload using owner/user token/config from usetting without adding mtp: or mrcc: before the path/id"""
+
+rcf = """<b>Rclone Flags</b>: -rcf
+
+/cmd link|path|rcl -up path|rcl -rcf --buffer-size:8M|--drive-starred-only|key|key:value
+This will override all other flags except --exclude
+Check here all <a href='https://rclone.org/flags/'>RcloneFlags</a>."""
+
+bulk = """<b>Bulk Download</b>: -b
+
+Bulk can be used only by replying to text message or text file contains links separated by new line.
+Example:
+link1 -n new name -up remote1:path1 -rcf |key:value|key:value
+link2 -z -n new name -up remote2:path2
+link3 -e -n new name -up remote2:path2
+Reply to this example by this cmd -> /cmd -b(bulk)
+
+Note: Any arg along with the cmd will be setted to all links
+/cmd -b -up remote: -z -m folder name (all links contents in one zipped folder uploaded to one destination)
+so you can't set different upload destinations along with link incase you have added -m along with cmd
+You can set start and end of the links from the bulk like seed, with -b start:end or only end by -b :end or only start by -b start.
+The default start is from zero(first link) to inf."""
+
+rlone_dl = """<b>Rclone Download</b>:
+
+Treat rclone paths exactly like links
+/cmd main:dump/ubuntu.iso or rcl(To select config, remote and path)
+Users can add their own rclone from user settings
+If you want to add path manually from your config add mrcc: before the path without space
+/cmd mrcc:main:dump/ubuntu.iso
+You can simply edit using owner/user config from usetting without adding mrcc: before the path"""
+
+extract_zip = """<b>Extract/Zip</b>: -e -z
+
+/cmd link -e password (extract password protected)
+/cmd link -z password (zip password protected)
+/cmd link -z password -e (extract and zip password protected)
+Note: When both extract and zip added with cmd it will extract first and then zip, so always extract first"""
+
+join = """<b>Join Splitted Files</b>: -j
+
+This option will only work before extract and zip, so mostly it will be used with -m argument (samedir)
+By Reply:
+/cmd -i 3 -j -m folder name
+/cmd -b -j -m folder name
+if u have link(folder) have splitted files:
+/cmd link -j"""
+
+tg_links = """<b>TG Links</b>:
+
+Treat links like any direct link
+Some links need user access so you must add USER_SESSION_STRING for it.
+Three types of links:
+Public: https://t.me/channel_name/message_id
+Private: tg://openmessage?user_id=xxxxxx&message_id=xxxxx
+Super: https://t.me/c/channel_id/message_id
+Range: https://t.me/channel_name/first_message_id-last_message_id
+Range Example: tg://openmessage?user_id=xxxxxx&message_id=555-560 or https://t.me/channel_name/100-150
+Note: Range link will work only by replying cmd to it"""
+
+sample_video = """<b>Sample Video</b>: -sv
+
+Create sample video for one video or folder of videos.
+/cmd -sv (it will take the default values which 60sec sample duration and part duration is 4sec).
+You can control those values. Example: /cmd -sv 70:5(sample-duration:part-duration) or /cmd -sv :5 or /cmd -sv 70."""
+
+screenshot = """<b>ScreenShots</b>: -ss
+
+Create screenshots for one video or folder of videos.
+/cmd -ss (it will take the default values which is 10 photos).
+You can control this value. Example: /cmd -ss 6."""
+
+seed = """<b>Bittorrent seed</b>: -d
+
+/cmd link -d ratio:seed_time or by replying to file/link
+To specify ratio and seed time add -d ratio:time.
+Example: -d 0.7:10 (ratio and time) or -d 0.7 (only ratio) or -d :10 (only time) where time in minutes"""
+
+zip_arg = """<b>Zip</b>: -z password
+
+/cmd link -z (zip)
+/cmd link -z password (zip password protected)"""
+
+qual = """<b>Quality Buttons</b>: -s
+
+In case default quality added from yt-dlp options using format option and you need to select quality for specific link or links with multi links feature.
+/cmd link -s"""
+
+yt_opt = """<b>Options</b>: -opt
+
+/cmd link -opt {"format": "bv*+mergeall[vcodec=none]", "nocheckcertificate": True, "playliststart": 10, "fragment_retries": float("inf"), "matchtitle": "S13", "writesubtitles": True, "live_from_start": True, "postprocessor_args": {"ffmpeg": ["-threads", "4"]}, "wait_for_video": (5, 100), "download_ranges": [{"start_time": 0, "end_time": 10}]}
+
+Check all yt-dlp api options from this <a href='https://github.com/yt-dlp/yt-dlp/blob/master/yt_dlp/YoutubeDL.py#L184'>FILE</a> or use this <a href='https://t.me/mltb_official_channel/177'>script</a> to convert cli arguments to api options."""
+
+convert_media = """<b>Convert Media</b>: -ca -cv
+/cmd link -ca mp3 -cv mp4 (convert all audios to mp3 and all videos to mp4)
+/cmd link -ca mp3 (convert all audios to mp3)
+/cmd link -cv mp4 (convert all videos to mp4)
+/cmd link -ca mp3 + flac ogg (convert only flac and ogg audios to mp3)
+/cmd link -cv mkv - webm flv (convert all videos to mp4 except webm and flv)"""
+
+force_start = """<b>Force Start</b>: -f -fd -fu
+/cmd link -f (force download and upload)
+/cmd link -fd (force download only)
+/cmd link -fu (force upload directly after download finish)"""
+
+gdrive = """<b>Gdrive</b>: link
+If DEFAULT_UPLOAD is `rc` then you can pass up: `gd` to upload using gdrive tools to GDRIVE_ID.
+/cmd gdriveLink or gdl or gdriveId -up gdl or gdriveId or gd
+/cmd tp:gdriveLink or tp:gdriveId -up tp:gdriveId or gdl or gd (to use token.pickle if service account enabled)
+/cmd sa:gdriveLink or sa:gdriveId -p sa:gdriveId or gdl or gd (to use service account if service account disabled)
+/cmd mtp:gdriveLink or mtp:gdriveId -up mtp:gdriveId or gdl or gd(if you have added upload gdriveId from usetting) (to use user token.pickle that uploaded by usetting)
+You can simply edit using owner/user token from usetting without adding mtp: before the id"""
+
+rclone_cl = """<b>Rclone</b>: path
+If DEFAULT_UPLOAD is `gd` then you can pass up: `rc` to upload to RCLONE_PATH.
+/cmd rcl/rclone_path -up rcl/rclone_path/rc -rcf flagkey:flagvalue|flagkey|flagkey:flagvalue
+/cmd rcl or rclone_path -up rclone_path or rc or rcl
+/cmd mrcc:rclone_path -up rcl or rc(if you have add rclone path from usetting) (to use user config)
+You can simply edit using owner/user config from usetting without adding mrcc: before the path"""
+
+name_swap = r"""<b>Name Substitution</b>: -ns
+/cmd link -ns script/code/s | mirror/leech | tea/ /s | clone | cpu/ | \[mltb\]/mltb | \\text\\/text/s
+This will affect on all files. Format: wordToReplace/wordToReplaceWith/sensitiveCase
+Word Subtitions. You can add pattern instead of normal text. Timeout: 60 sec
+NOTE: You must add \ before any character, those are the characters: \^$.|?*+()[]{}-
+1. script will get replaced by code with sensitive case
+2. mirror will get replaced by leech
+4. tea will get replaced by space with sensitive case
+5. clone will get removed
+6. cpu will get replaced by space
+7. [mltb] will get replaced by mltb
+8. \text\ will get replaced by text with sensitive case
+"""
+
+transmission = """<b>Tg transmission</b>: -hl -ut -bt
+/cmd link -hl (leech by user and bot session with respect to size) (Hybrid Leech)
+/cmd link -bt (leech by bot session)
+/cmd link -ut (leech by user)"""
+
+thumbnail_layout = """Thumbnail Layout: -tl
+/cmd link -tl 3x3 (widthxheight) 3 photos in row and 3 photos in column"""
+
+leech_as = """<b>Leech as</b>: -doc -med
+/cmd link -doc (Leech as document)
+/cmd link -med (Leech as media)"""
+
+ffmpeg_cmds = """<b>FFmpeg Commands</b>: -ff
+list of lists of ffmpeg commands. You can set multiple ffmpeg commands for all files before upload. Don't write ffmpeg at beginning, start directly with the arguments.
+Notes:
+1. Add <code>-del</code> to the list(s) which you want from the bot to delete the original files after command run complete!
+3. To execute one of pre-added lists in bot like: ({"subtitle": ["-i mltb.mkv -c copy -c:s srt mltb.mkv"]}), you must use -ff subtitle (list key)
+Examples: ["-i mltb.mkv -c copy -c:s srt mltb.mkv", "-i mltb.video -c copy -c:s srt mltb", "-i mltb.m4a -c:a libmp3lame -q:a 2 mltb.mp3", "-i mltb.audio -c:a libmp3lame -q:a 2 mltb.mp3", "-i mltb -map 0:a -c copy mltb.mka -map 0:s -c copy mltb.srt"]
+Here I will explain how to use mltb.* which is reference to files you want to work on.
+1. First cmd: the input is mltb.mkv so this cmd will work only on mkv videos and the output is mltb.mkv also so all outputs is mkv. -del will delete the original media after complete run of the cmd.
+2. Second cmd: the input is mltb.video so this cmd will work on all videos and the output is only mltb so the extenstion is same as input files.
+3. Third cmd: the input in mltb.m4a so this cmd will work only on m4a audios and the output is mltb.mp3 so the output extension is mp3.
+4. Fourth cmd: the input is mltb.audio so this cmd will work on all audios and the output is mltb.mp3 so the output extension is mp3."""
+
+metadata = """<b>Metadata</b>: -meta
+
+Apply custom metadata to media files using pipe (|) separator.
+
+<b>Format:</b> key=value|key2=value2|key3=value3
+
+<b>Dynamic Variables:</b>
+• <code>{filename}</code> - Original filename
+• <code>{basename}</code> - Filename without extension  
+• <code>{extension}</code> - File extension
+• <code>{audiolang}</code> - Audio language (auto-detected or English)
+• <code>{sublang}</code> - Subtitle language (auto-detected or none)
+• <code>{year}</code> - Year extracted from filename
+
+<b>Per-Stream Metadata:</b>
+Set different metadata for audio/video/subtitle streams in User Settings > FFmpeg Settings:
+• <b>Audio Metadata:</b> Applied to each audio stream
+• <b>Video Metadata:</b> Applied to video streams  
+• <b>Subtitle Metadata:</b> Applied to subtitle streams
+
+<b>Examples:</b>
+<code>/mirror link -meta title=My Movie|artist={audiolang} Version</code>
+<code>/yt link -meta album={basename}|year={year}|genre=Action</code>
+
+<b>Escape Pipes:</b> Use <code>\\|</code> to include literal pipe in values:
+<code>title=Movie \\| Director's Cut</code>
+
+<b>User Settings Example:</b>
+• Audio Metadata: <code>language={audiolang}|title=Audio Track</code>
+• Video Metadata: <code>title={basename}|year={year}</code>
+• Subtitle Metadata: <code>language={sublang}|title=Subtitles</code>"""
+
+YT_HELP_DICT = {
+    "main": yt,
+    "New-Name": f"{new_name}\nNote: Don't add file extension",
+    "Zip": zip_arg,
+    "Quality": qual,
+    "Options": yt_opt,
+    "Multi-Link": multi_link,
+    "Same-Directory": same_dir,
+    "Thumb": thumb,
+    "Split-Size": split_size,
+    "Upload-Destination": upload,
+    "Rclone-Flags": rcf,
+    "Bulk": bulk,
+    "Sample-Video": sample_video,
+    "Screenshot": screenshot,
+    "Convert-Media": convert_media,
+    "Force-Start": force_start,
+    "Name-Swap": name_swap,
+    "TG-Transmission": transmission,
+    "Thumb-Layout": thumbnail_layout,
+    "Leech-Type": leech_as,
+    "FFmpeg-Cmds": ffmpeg_cmds,
+    "Metadata": metadata,
+}
+
+MIRROR_HELP_DICT = {
+    "main": mirror,
+    "New-Name": new_name,
+    "DL-Auth": "<b>Direct link authorization</b>: -au -ap\n\n/cmd link -au username -ap password",
+    "Headers": "<b>Direct link custom headers</b>: -h\n\n/cmd link -h key: value key1: value1",
+    "Extract/Zip": extract_zip,
+    "Select-Files": "<b>Bittorrent/JDownloader/Sabnzbd File Selection</b>: -s\n\n/cmd link -s or by replying to file/link",
+    "Torrent-Seed": seed,
+    "Multi-Link": multi_link,
+    "Same-Directory": same_dir,
+    "Thumb": thumb,
+    "Split-Size": split_size,
+    "Upload-Destination": upload,
+    "Rclone-Flags": rcf,
+    "Bulk": bulk,
+    "Join": join,
+    "Rclone-DL": rlone_dl,
+    "Tg-Links": tg_links,
+    "Sample-Video": sample_video,
+    "Screenshot": screenshot,
+    "Convert-Media": convert_media,
+    "Force-Start": force_start,
+    "User-Download": user_download,
+    "Name-Swap": name_swap,
+    "TG-Transmission": transmission,
+    "Thumb-Layout": thumbnail_layout,
+    "Leech-Type": leech_as,
+    "FFmpeg-Cmds": ffmpeg_cmds,
+    "Metadata": metadata,
+}
+
+CLONE_HELP_DICT = {
+    "main": clone,
+    "Multi-Link": multi_link,
+    "Bulk": bulk,
+    "Gdrive": gdrive,
+    "Rclone": rclone_cl,
+}
+
+RSS_HELP_MESSAGE = """
+Use this format to add feed url:
+Title1 link (required)
+Title2 link -c cmd -inf xx -exf xx
+Title3 link -c cmd -d ratio:time -z password
+
+-c command -up mrcc:remote:path/subdir -rcf --buffer-size:8M|key|key:value
+-inf For included words filter.
+-exf For excluded words filter.
+-stv true or false (sensitive filter)
+
+Example: Title https://www.rss-url.com -inf 1080 or 720 or 144p|mkv or mp4|hevc -exf flv or web|xxx
+This filter will parse links that its titles contain `(1080 or 720 or 144p) and (mkv or mp4) and hevc` and doesn't contain (flv or web) and xxx words. You can add whatever you want.
+
+Another example: -inf  1080  or 720p|.web. or .webrip.|hvec or x264. This will parse titles that contain ( 1080  or 720p) and (.web. or .webrip.) and (hvec or x264). I have added space before and after 1080 to avoid wrong matching. If this `10805695` number in title it will match 1080 if added 1080 without spaces after it.
+
+Filter Notes:
+1. | means and.
+2. Add `or` between similar keys, you can add it between qualities or between extensions, so don't add filter like this f: 1080|mp4 or 720|web because this will parse 1080 and (mp4 or 720) and web ... not (1080 and mp4) or (720 and web).
+3. You can add `or` and `|` as much as you want.
+4. Take a look at the title if it has a static special character after or before the qualities or extensions or whatever and use them in the filter to avoid wrong match.
+Timeout: 60 sec.
+"""
+
+PASSWORD_ERROR_MESSAGE = """
+<b>This link requires a password!</b>
+- Insert <b>::</b> after the link and write the password after the sign.
+
+<b>Example:</b> link::my password
+"""
+
+
+def get_bot_commands():
+    from ...core.plugin_manager import get_plugin_manager
+
+    static_commands = {
+        "Mirror": "[link/file] Mirror to Upload Destination",
+        "QbMirror": "[magnet/torrent] Mirror to Upload Destination using qbit",
+        "Ytdl": "[link] Mirror YouTube, m3u8, Social Media and yt-dlp supported urls",
+        "UpHoster": "[link/file] Upload to DDL Servers",
+        "Leech": "[link/file] Leech files to Upload to Telegram",
+        "QbLeech": "[magnet/torrent] Leech files to Upload to Telegram using qbit",
+        "YtdlLeech": "[link] Leech YouTube, m3u8, Social Media and yt-dlp supported urls",
+        "Clone": "[link] Clone files/folders to GDrive",
+        "UserSet": "User personal settings",
+        "ForceStart": "[gid/reply] Force start from queued task",
+        "Count": "[link] Count no. of files/folders in GDrive",
+        "List": "[query] Search any Text which is available in GDrive",
+        "Search": "[query] Search torrents via Qbit Plugins",
+        "MediaInfo": "[reply/link] Get MediaInfo of the Target Media",
+        "Select": "[gid/reply] Select files for NZB, Aria2, Qbit Tasks",
+        "Ping": "Ping Bot to test Response Speed",
+        "Status": "[id/me] Tasks Status of Bot",
+        "Stats": "Bot, OS, Repo & System full Statistics",
+        "Rss": "User RSS Management Settings",
+        "IMDB": "[query] or ttxxxxxx Get IMDB info",
+        "CancelAll": "Cancel all Tasks on the Bot",
+        "Help": "Detailed help usage of the WZ Bot",
+        "BotSet": "[SUDO] Bot Management Settings",
+        "Log": "[SUDO] Get Bot Logs for Internal Working",
+        "Restart": "[SUDO] Reboot bot",
+        "RestartSessions": "[SUDO] Reboot User Sessions",
+    }
+
+    commands = static_commands.copy()
+
+    plugin_manager = get_plugin_manager()
+    if plugin_manager:
+        for plugin_info in plugin_manager.list_plugins():
+            if plugin_info.enabled and plugin_info.commands:
+                for cmd in plugin_info.commands:
+                    if cmd == "speedtest":
+                        commands["SpeedTest"] = "Check Bot Speed using Speedtest.com"
+
+    return commands
+
+
+BOT_COMMANDS = get_bot_commands()
+
+
+def get_help_string():
+    from ..telegram_helper.bot_commands import BotCommands
+
+    help_lines = ["NOTE: Try each command without any argument to see more detalis."]
+
+    commands = BotCommands.get_commands()
+
+    for key, cmds in commands.items():
+        cmd_attr = getattr(BotCommands, f"{key}Command", None)
+        if not cmd_attr:
+            continue
+
+        if isinstance(cmd_attr, list):
+            cmd_str = f"/{' or /'.join(cmd_attr)}"
+        else:
+            cmd_str = f"/{cmd_attr}"
+
+        if key == "SpeedTest" and key in BOT_COMMANDS:
+            help_lines.append(f"{cmd_str}: Check Bot Speed using Speedtest.com")
+        elif key == "Mirror":
+            help_lines.append(f"{cmd_str}: Start mirroring to cloud.")
+        elif key == "QbMirror":
+            help_lines.append(f"{cmd_str}: Start Mirroring to cloud using qBittorrent.")
+        elif key == "JdMirror":
+            help_lines.append(f"{cmd_str}: Start Mirroring to cloud using JDownloader.")
+        elif key == "NzbMirror":
+            help_lines.append(f"{cmd_str}: Start Mirroring to cloud using Sabnzbd.")
+        elif key == "Ytdl":
+            help_lines.append(f"{cmd_str}: Mirror yt-dlp supported link.")
+        elif key == "UpHoster":
+            help_lines.append(f"{cmd_str}: Upload to DDL Servers.")
+        elif key == "Leech":
+            help_lines.append(f"{cmd_str}: Start leeching to Telegram.")
+        elif key == "QbLeech":
+            help_lines.append(f"{cmd_str}: Start leeching using qBittorrent.")
+        elif key == "JdLeech":
+            help_lines.append(f"{cmd_str}: Start leeching using JDownloader.")
+        elif key == "NzbLeech":
+            help_lines.append(f"{cmd_str}: Start leeching using Sabnzbd.")
+        elif key == "YtdlLeech":
+            help_lines.append(f"{cmd_str}: Leech yt-dlp supported link.")
+        elif key == "Clone":
+            help_lines.append(
+                f"{cmd_str} [drive_url]: Copy file/folder to Google Drive."
+            )
+        elif key == "Count":
+            help_lines.append(
+                f"{cmd_str} [drive_url]: Count file/folder of Google Drive."
+            )
+        elif key == "Delete":
+            help_lines.append(
+                f"{cmd_str} [drive_url]: Delete file/folder from Google Drive (Only Owner & Sudo)."
+            )
+        elif key == "UserSet":
+            help_lines.append(f"{cmd_str} [query]: Users settings.")
+        elif key == "BotSet":
+            help_lines.append(f"{cmd_str} [query]: Bot settings.")
+        elif key == "Select":
+            help_lines.append(
+                f"{cmd_str}: Select files from torrents or nzb by gid or reply."
+            )
+        elif key == "CancelTask":
+            help_lines.append(f"{cmd_str} [gid]: Cancel task by gid or reply.")
+        elif key == "ForceStart":
+            help_lines.append(f"{cmd_str} [gid]: Force start task by gid or reply.")
+        elif key == "CancelAll":
+            help_lines.append(f"{cmd_str} [query]: Cancel all [status] tasks.")
+        elif key == "List":
+            help_lines.append(f"{cmd_str} [query]: Search in Google Drive(s).")
+        elif key == "Search":
+            help_lines.append(f"{cmd_str} [query]: Search for torrents with API.")
+        elif key == "MediaInfo":
+            help_lines.append(f"{cmd_str} [query]: Get media info.")
+        elif key == "Status":
+            help_lines.append(f"{cmd_str}: Shows a status of all the downloads.")
+        elif key == "Stats":
+            help_lines.append(
+                f"{cmd_str}: Show stats of the machine where the bot is hosted in."
+            )
+        elif key == "Ping":
+            help_lines.append(
+                f"{cmd_str}: Check how long it takes to Ping the Bot (Only Owner & Sudo)."
+            )
+        elif key == "Authorize":
+            help_lines.append(
+                f"{cmd_str}: Authorize a chat or a user to use the bot (Only Owner & Sudo)."
+            )
+        elif key == "UnAuthorize":
+            help_lines.append(
+                f"{cmd_str}: Unauthorize a chat or a user to use the bot (Only Owner & Sudo)."
+            )
+        elif key == "Users":
+            help_lines.append(f"{cmd_str}: show users settings (Only Owner & Sudo).")
+        elif key == "AddSudo":
+            help_lines.append(f"{cmd_str}: Add sudo user (Only Owner).")
+        elif key == "RmSudo":
+            help_lines.append(f"{cmd_str}: Remove sudo users (Only Owner).")
+        elif key == "Restart":
+            help_lines.append(
+                f"{cmd_str}: Restart and update the bot (Only Owner & Sudo)."
+            )
+        elif key == "Log":
+            help_lines.append(
+                f"{cmd_str}: Get a log file of the bot. Handy for getting crash reports (Only Owner & Sudo)."
+            )
+        elif key == "Shell":
+            help_lines.append(f"{cmd_str}: Run shell commands (Only Owner).")
+        elif key == "AExec":
+            help_lines.append(f"{cmd_str}: Exec async functions (Only Owner).")
+        elif key == "Exec":
+            help_lines.append(f"{cmd_str}: Exec sync functions (Only Owner).")
+        elif key == "ClearLocals":
+            help_lines.append(
+                f"/{BotCommands.ClearLocalsCommand}: Clear {BotCommands.AExecCommand} or {BotCommands.ExecCommand} locals (Only Owner)."
+            )
+        elif key == "Rss":
+            help_lines.append(f"/{BotCommands.RssCommand}: RSS Menu.")
+
+    return "\n".join(help_lines)
+
+
+help_string = get_help_string()

bot/helper/ext_utils/hyperdl_utils.py

@@ -0,0 +1,509 @@
+from asyncio import (
+    CancelledError,
+    create_task,
+    gather,
+    sleep,
+    wait_for,
+    TimeoutError as AsyncTimeoutError,
+    Event,
+)
+from datetime import datetime
+from math import ceil, floor
+from mimetypes import guess_extension
+from os import path as ospath
+from pathlib import Path
+from re import sub
+from sys import argv
+from time import time
+
+from aiofiles import open as aiopen
+from aiofiles.os import makedirs, remove
+from aioshutil import move
+from pyrogram import StopTransmission, raw, utils
+from pyrogram.errors import AuthBytesInvalid, FloodWait
+from pyrogram.file_id import PHOTO_TYPES, FileId, FileType, ThumbnailSource
+from pyrogram.session import Auth, Session
+from pyrogram.session.internals import MsgId
+
+from ... import LOGGER
+from ...core.config_manager import Config
+from ...core.tg_client import TgClient
+
+
+class HyperTGDownload:
+    def __init__(self):
+        self.clients = TgClient.helper_bots
+        self.work_loads = TgClient.helper_loads
+        self.message = None
+        self.dump_chat = None
+        self.download_dir = "downloads/"
+        self.directory = None
+        self.num_parts = Config.HYPER_THREADS or max(8, len(self.clients))
+        self.cache_file_ref = {}
+        self.cache_last_access = {}
+        self.cache_max_size = 100
+        self._processed_bytes = 0
+        self.file_size = 0
+        self.chunk_size = 1024 * 1024
+        self.file_name = ""
+        self._cancel_event = Event()
+        self.session_pool = {}
+        create_task(self._clean_cache())
+
+    @staticmethod
+    async def get_media_type(message):
+        media_types = (
+            "audio",
+            "document",
+            "photo",
+            "sticker",
+            "animation",
+            "video",
+            "voice",
+            "video_note",
+            "new_chat_photo",
+        )
+        for attr in media_types:
+            if media := getattr(message, attr, None):
+                return media
+        raise ValueError("This message doesn't contain any downloadable media")
+
+    def _update_cache(self, index, file_ref):
+        self.cache_file_ref[index] = file_ref
+        self.cache_last_access[index] = time()
+
+        if len(self.cache_file_ref) > self.cache_max_size:
+            oldest = sorted(self.cache_last_access.items(), key=lambda x: x[1])[0][0]
+            del self.cache_file_ref[oldest]
+            del self.cache_last_access[oldest]
+
+    async def get_specific_file_ref(self, mid, client, max_retries=3):
+        retries = 0
+        last_error = None
+
+        while retries < max_retries:
+            try:
+                media = await client.get_messages(self.dump_chat, mid)
+                return FileId.decode(
+                    getattr(await self.get_media_type(media), "file_id", "")
+                )
+            except Exception as e:
+                last_error = e
+                retries += 1
+                await sleep(1 * retries)
+
+        LOGGER.error(
+            f"Failed to get message {mid} from {self.dump_chat} with Client {client.me.username}"
+        )
+        raise ValueError(
+            f"Bot needs Admin access in Chat or message may be deleted. Error: {last_error}"
+        )
+
+    async def get_file_id(self, client, index) -> FileId:
+        if index not in self.cache_file_ref:
+            file_ref = await self.get_specific_file_ref(self.message.id, client)
+            self._update_cache(index, file_ref)
+        else:
+            self.cache_last_access[index] = time()
+        return self.cache_file_ref[index]
+
+    async def _clean_cache(self):
+        while True:
+            await sleep(15 * 60)
+            current_time = time()
+            expired_keys = [
+                k
+                for k, v in self.cache_last_access.items()
+                if current_time - v > 45 * 60
+            ]
+
+            for key in expired_keys:
+                if key in self.cache_file_ref:
+                    del self.cache_file_ref[key]
+                if key in self.cache_last_access:
+                    del self.cache_last_access[key]
+
+    async def generate_media_session(self, client, file_id, index, max_retries=3):
+        session_key = (index, file_id.dc_id)
+
+        if session_key in self.session_pool:
+            return self.session_pool[session_key]
+
+        retries = 0
+        while retries < max_retries:
+            try:
+                if file_id.dc_id != await client.storage.dc_id():
+                    media_session = Session(
+                        client,
+                        file_id.dc_id,
+                        await Auth(
+                            client, file_id.dc_id, await client.storage.test_mode()
+                        ).create(),
+                        await client.storage.test_mode(),
+                        is_media=True,
+                    )
+                    await media_session.start()
+
+                    for _ in range(6):
+                        exported_auth = await client.invoke(
+                            raw.functions.auth.ExportAuthorization(dc_id=file_id.dc_id)
+                        )
+
+                        try:
+                            await media_session.invoke(
+                                raw.functions.auth.ImportAuthorization(
+                                    id=exported_auth.id, bytes=exported_auth.bytes
+                                )
+                            )
+                            break
+                        except AuthBytesInvalid:
+                            await sleep(1)
+                    else:
+                        await media_session.stop()
+                        raise AuthBytesInvalid
+                else:
+                    media_session = Session(
+                        client,
+                        file_id.dc_id,
+                        await client.storage.auth_key(),
+                        await client.storage.test_mode(),
+                        is_media=True,
+                    )
+                    await media_session.start()
+
+                self.session_pool[session_key] = media_session
+                return media_session
+
+            except Exception:
+                retries += 1
+                await sleep(1)
+
+        raise ValueError(f"Failed to create media session after {max_retries} attempts")
+
+    @staticmethod
+    async def get_location(file_id: FileId):
+        file_type = file_id.file_type
+
+        if file_type == FileType.CHAT_PHOTO:
+            if file_id.chat_id > 0:
+                peer = raw.types.InputPeerUser(
+                    user_id=file_id.chat_id, access_hash=file_id.chat_access_hash
+                )
+            else:
+                peer = (
+                    raw.types.InputPeerChat(chat_id=-file_id.chat_id)
+                    if file_id.chat_access_hash == 0
+                    else raw.types.InputPeerChannel(
+                        channel_id=utils.get_channel_id(file_id.chat_id),
+                        access_hash=file_id.chat_access_hash,
+                    )
+                )
+            return raw.types.InputPeerPhotoFileLocation(
+                peer=peer,
+                volume_id=file_id.volume_id,
+                local_id=file_id.local_id,
+                big=file_id.thumbnail_source == ThumbnailSource.CHAT_PHOTO_BIG,
+            )
+        elif file_type == FileType.PHOTO:
+            return raw.types.InputPhotoFileLocation(
+                id=file_id.media_id,
+                access_hash=file_id.access_hash,
+                file_reference=file_id.file_reference,
+                thumb_size=file_id.thumbnail_size,
+            )
+        else:
+            return raw.types.InputDocumentFileLocation(
+                id=file_id.media_id,
+                access_hash=file_id.access_hash,
+                file_reference=file_id.file_reference,
+                thumb_size=file_id.thumbnail_size,
+            )
+
+    async def get_file(
+        self,
+        offset_bytes: int,
+        first_part_cut: int,
+        last_part_cut: int,
+        part_count: int,
+        max_retries=5,
+    ):
+        index = min(self.work_loads, key=self.work_loads.get)
+        client = self.clients[index]
+
+        self.work_loads[index] += 1
+        current_retry = 0
+
+        try:
+            while current_retry < max_retries:
+                try:
+                    if self._cancel_event.is_set():
+                        raise CancelledError("Download cancelled")
+
+                    file_id = await self.get_file_id(client, index)
+                    media_session, location = await gather(
+                        self.generate_media_session(client, file_id, index),
+                        self.get_location(file_id),
+                    )
+
+                    current_part = 1
+                    current_offset = offset_bytes
+
+                    while current_part <= part_count:
+                        if self._cancel_event.is_set():
+                            raise CancelledError("Download cancelled")
+
+                        try:
+                            r = await wait_for(
+                                media_session.invoke(
+                                    raw.functions.upload.GetFile(
+                                        location=location,
+                                        offset=current_offset,
+                                        limit=self.chunk_size,
+                                    ),
+                                ),
+                                timeout=30,
+                            )
+
+                            if isinstance(r, raw.types.upload.File):
+                                chunk = r.bytes
+
+                                if not chunk:
+                                    break
+
+                                if part_count == 1:
+                                    yield chunk[first_part_cut:last_part_cut]
+                                elif current_part == 1:
+                                    yield chunk[first_part_cut:]
+                                elif current_part == part_count:
+                                    yield chunk[:last_part_cut]
+                                else:
+                                    yield chunk
+
+                                current_part += 1
+                                current_offset += self.chunk_size
+                                self._processed_bytes += len(chunk)
+                            else:
+                                raise ValueError(f"Unexpected response: {r}")
+
+                        except (FloodWait, AsyncTimeoutError, ConnectionError) as e:
+                            if isinstance(e, FloodWait):
+                                await sleep(e.value + 1)
+                            else:
+                                await sleep(1)
+                            continue
+
+                    if current_part <= part_count:
+                        raise ValueError(
+                            f"Incomplete download: got {current_part-1} of {part_count} parts"
+                        )
+                    break
+
+                except (AsyncTimeoutError, ConnectionError, AttributeError):
+                    current_retry += 1
+                    if current_retry >= max_retries:
+                        raise
+                    await sleep(current_retry * 2)
+
+        finally:
+            self.work_loads[index] -= 1
+
+    async def progress_callback(self, progress, progress_args):
+        if not progress:
+            return
+
+        while not self._cancel_event.is_set():
+            try:
+                if callable(progress):
+                    await progress(
+                        self._processed_bytes, self.file_size, *progress_args
+                    )
+                await sleep(1)
+            except (CancelledError, StopTransmission):
+                break
+            except Exception:
+                await sleep(1)
+
+    async def single_part(self, start, end, part_index, max_retries=3):
+        until_bytes, from_bytes = min(end, self.file_size - 1), start
+
+        offset = from_bytes - (from_bytes % self.chunk_size)
+        first_part_cut = from_bytes - offset
+        last_part_cut = until_bytes % self.chunk_size + 1
+
+        part_count = ceil(until_bytes / self.chunk_size) - floor(
+            offset / self.chunk_size
+        )
+        part_file_path = ospath.join(
+            self.directory, f"{self.file_name}.temp.{part_index:02d}"
+        )
+
+        for attempt in range(max_retries):
+            try:
+                async with aiopen(part_file_path, "wb") as f:
+                    async for chunk in self.get_file(
+                        offset, first_part_cut, last_part_cut, part_count
+                    ):
+                        if self._cancel_event.is_set():
+                            raise CancelledError("Download cancelled")
+                        await f.write(chunk)
+                return part_index, part_file_path
+            except (AsyncTimeoutError, ConnectionError):
+                if attempt == max_retries - 1:
+                    raise
+                await sleep((attempt + 1) * 2)
+                self._processed_bytes = 0
+
+    async def handle_download(self, progress, progress_args):
+        self._cancel_event.clear()
+
+        await makedirs(self.directory, exist_ok=True)
+        temp_file_path = (
+            ospath.abspath(
+                sub("\\\\", "/", ospath.join(self.directory, self.file_name))
+            )
+            + ".temp"
+        )
+
+        num_parts = min(self.num_parts, max(1, self.file_size // (10 * 1024 * 1024)))
+
+        if self.file_size < 10 * 1024 * 1024:
+            num_parts = 1
+
+        part_size = self.file_size // num_parts if num_parts > 0 else self.file_size
+        ranges = [
+            (i * part_size, min((i + 1) * part_size - 1, self.file_size - 1))
+            for i in range(num_parts)
+        ]
+
+        tasks = []
+        prog_task = None
+
+        try:
+            for i, (start, end) in enumerate(ranges):
+                tasks.append(create_task(self.single_part(start, end, i)))
+
+            if progress:
+                prog_task = create_task(self.progress_callback(progress, progress_args))
+
+            results = await gather(*tasks)
+
+            async with aiopen(temp_file_path, "wb") as temp_file:
+                for _, part_file_path in sorted(results, key=lambda x: x[0]):
+                    try:
+                        async with aiopen(part_file_path, "rb") as part_file:
+                            while True:
+                                chunk = await part_file.read(8 * 1024 * 1024)
+                                if not chunk:
+                                    break
+                                await temp_file.write(chunk)
+                        await remove(part_file_path)
+                    except Exception as e:
+                        LOGGER.error(
+                            f"Error processing part file {part_file_path}: {e}"
+                        )
+                        raise
+
+            if prog_task and not prog_task.done():
+                prog_task.cancel()
+
+            file_path = ospath.splitext(temp_file_path)[0]
+            await move(temp_file_path, file_path)
+
+            return file_path
+
+        except FloodWait as fw:
+            raise fw
+        except (CancelledError, StopTransmission):
+            return None
+        except Exception as e:
+            LOGGER.error(f"HyperDL Error: {e}")
+            return None
+        finally:
+            self._cancel_event.set()
+            if prog_task and not prog_task.done():
+                prog_task.cancel()
+
+            for task in tasks:
+                if not task.done():
+                    task.cancel()
+
+            for i in range(len(ranges)):
+                part_path = ospath.join(
+                    self.directory, f"{self.file_name}.temp.{i:02d}"
+                )
+                try:
+                    if ospath.exists(part_path):
+                        await remove(part_path)
+                except Exception:
+                    pass
+
+    @staticmethod
+    async def get_extension(file_type, mime_type):
+        if file_type in PHOTO_TYPES:
+            return ".jpg"
+
+        if mime_type:
+            extension = guess_extension(mime_type)
+            if extension:
+                return extension
+
+        if file_type == FileType.VOICE:
+            return ".ogg"
+        elif file_type in (FileType.VIDEO, FileType.ANIMATION, FileType.VIDEO_NOTE):
+            return ".mp4"
+        elif file_type == FileType.DOCUMENT:
+            return ".bin"
+        elif file_type == FileType.STICKER:
+            return ".webp"
+        elif file_type == FileType.AUDIO:
+            return ".mp3"
+        else:
+            return ".bin"
+
+    async def download_media(
+        self,
+        message,
+        file_name="downloads/",
+        progress=None,
+        progress_args=(),
+        dump_chat=None,
+    ):
+        try:
+            if dump_chat:
+                self.message = await TgClient.bot.copy_message(
+                    chat_id=dump_chat,
+                    from_chat_id=message.chat.id,
+                    message_id=message.id,
+                    disable_notification=True,
+                )
+
+            self.dump_chat = dump_chat or message.chat.id
+            self.message = self.message or message
+            media = await self.get_media_type(self.message)
+
+            file_id_str = media if isinstance(media, str) else media.file_id
+            file_id_obj = FileId.decode(file_id_str)
+
+            file_type = file_id_obj.file_type
+            media_file_name = getattr(media, "file_name", "")
+            self.file_size = getattr(media, "file_size", 0)
+            mime_type = getattr(media, "mime_type", "image/jpeg")
+            date = getattr(media, "date", None)
+
+            self.directory, self.file_name = ospath.split(file_name)
+            self.file_name = self.file_name or media_file_name or ""
+
+            if not ospath.isabs(self.file_name):
+                self.directory = Path(argv[0]).parent / (
+                    self.directory or self.download_dir
+                )
+
+            if not self.file_name:
+                extension = await self.get_extension(file_type, mime_type)
+                self.file_name = f"{FileType(file_id_obj.file_type).name.lower()}_{(date or datetime.now()).strftime('%Y-%m-%d_%H-%M-%S')}_{MsgId()}{extension}"
+
+            return await self.handle_download(progress, progress_args)
+
+        except Exception as e:
+            LOGGER.error(f"Download media error: {e}")
+            raise

bot/helper/ext_utils/links_utils.py

@@ -0,0 +1,72 @@
+from re import match as re_match
+from base64 import urlsafe_b64decode, urlsafe_b64encode
+
+
+def is_magnet(url: str):
+    return bool(
+        re_match(
+            r"^magnet:\?.*xt=urn:(btih|btmh):([a-zA-Z0-9]{32,40}|[a-z2-7]{32}).*", url
+        )
+    )
+
+
+def is_url(url: str):
+    return bool(
+        re_match(
+            r"^(?!\/)(rtmps?:\/\/|mms:\/\/|rtsp:\/\/|https?:\/\/|ftp:\/\/)?([^\/:]+:[^\/@]+@)?(www\.)?(?=[^\/:\s]+\.[^\/:\s]+)([^\/:\s]+\.[^\/:\s]+)(:\d+)?(\/[^#\s]*[\s\S]*)?(\?[^#\s]*)?(#.*)?$",
+            url,
+        )
+    )
+
+
+def is_gdrive_link(url: str):
+    return "drive.google.com" in url or "drive.usercontent.google.com" in url
+
+
+def is_telegram_link(url: str):
+    return url.startswith(("https://t.me/", "tg://openmessage?user_id="))
+
+
+def is_mega_link(url: str):
+    return "mega.nz" in url or "mega.co.nz" in url
+
+
+def get_mega_link_type(url):
+    return "folder" if "folder" in url or "/#F!" in url else "file"
+
+
+def is_share_link(url: str):
+    return bool(
+        re_match(
+            r"https?:\/\/.+\.gdtot\.\S+|https?:\/\/(filepress|filebee|appdrive|gdflix)\.\S+",
+            url,
+        )
+    )
+
+
+def is_rclone_path(path: str):
+    return bool(
+        re_match(
+            r"^(mrcc:)?(?!(magnet:|mtp:|sa:|tp:))(?![- ])[a-zA-Z0-9_\. -]+(?<! ):(?!.*\/\/).*$|^rcl$",
+            path,
+        )
+    )
+
+
+def is_gdrive_id(id_: str):
+    return bool(
+        re_match(
+            r"^(tp:|sa:|mtp:)?(?:[a-zA-Z0-9-_]{33}|[a-zA-Z0-9_-]{19})$|^gdl$|^(tp:|mtp:)?root$",
+            id_,
+        )
+    )
+
+
+def encode_slink(string):
+    return (urlsafe_b64encode(string.encode("ascii")).decode("ascii")).strip("=")
+
+
+def decode_slink(b64_str):
+    return urlsafe_b64decode(
+        (b64_str.strip("=") + "=" * (-len(b64_str.strip("=")) % 4)).encode("ascii")
+    ).decode("ascii")

bot/helper/ext_utils/media_utils.py

@@ -0,0 +1,852 @@
+import re
+from contextlib import suppress
+from PIL import Image
+from hashlib import md5
+from aiofiles.os import remove, path as aiopath, makedirs
+import json
+from asyncio import (
+    create_subprocess_exec,
+    gather,
+    wait_for,
+    sleep,
+)
+from asyncio.subprocess import PIPE
+from os import path as ospath
+from re import search as re_search, escape
+from time import time
+from aioshutil import rmtree
+from langcodes import Language
+
+from ... import LOGGER, DOWNLOAD_DIR, threads, cores
+from ...core.config_manager import BinConfig
+from .bot_utils import cmd_exec, sync_to_async
+from .files_utils import get_mime_type, is_archive, is_archive_split
+from .status_utils import time_to_seconds
+
+
+def get_md5_hash(up_path):
+    md5_hash = md5()
+    with open(up_path, "rb") as f:
+        for byte_block in iter(lambda: f.read(4096), b""):
+            md5_hash.update(byte_block)
+        return md5_hash.hexdigest()
+
+
+async def create_thumb(msg, _id=""):
+    if not _id:
+        _id = time()
+        path = f"{DOWNLOAD_DIR}thumbnails"
+    else:
+        path = "thumbnails"
+    await makedirs(path, exist_ok=True)
+    photo_dir = await msg.download()
+    output = ospath.join(path, f"{_id}.jpg")
+    await sync_to_async(Image.open(photo_dir).convert("RGB").save, output, "JPEG")
+    await remove(photo_dir)
+    return output
+
+
+async def get_media_info(path, extra_info=False):
+    try:
+        result = await cmd_exec(
+            [
+                "ffprobe",
+                "-hide_banner",
+                "-loglevel",
+                "error",
+                "-print_format",
+                "json",
+                "-show_format",
+                "-show_streams",
+                path,
+            ]
+        )
+    except Exception as e:
+        LOGGER.error(f"Get Media Info: {e}. Mostly File not found! - File: {path}")
+        return (0, "", "", "") if extra_info else (0, None, None)
+    if result[0] and result[2] == 0:
+        ffresult = eval(result[0])
+        fields = ffresult.get("format")
+        if fields is None:
+            LOGGER.error(f"get_media_info: {result}")
+            return (0, "", "", "") if extra_info else (0, None, None)
+        duration = round(float(fields.get("duration", 0)))
+        if extra_info:
+            lang, qual, stitles = "", "", ""
+            if (streams := ffresult.get("streams")) and streams[0].get(
+                "codec_type"
+            ) == "video":
+                qual = int(streams[0].get("height"))
+                qual = f"{480 if qual <= 480 else 540 if qual <= 540 else 720 if qual <= 720 else 1080 if qual <= 1080 else 2160 if qual <= 2160 else 4320 if qual <= 4320 else 8640}p"
+                for stream in streams:
+                    if stream.get("codec_type") == "audio" and (
+                        lc := stream.get("tags", {}).get("language")
+                    ):
+                        with suppress(Exception):
+                            lc = Language.get(lc).display_name()
+                        if lc not in lang:
+                            lang += f"{lc}, "
+                    if stream.get("codec_type") == "subtitle" and (
+                        st := stream.get("tags", {}).get("language")
+                    ):
+                        with suppress(Exception):
+                            st = Language.get(st).display_name()
+                        if st not in stitles:
+                            stitles += f"{st}, "
+            return duration, qual, lang[:-2], stitles[:-2]
+        tags = fields.get("tags", {})
+        artist = tags.get("artist") or tags.get("ARTIST") or tags.get("Artist")
+        title = tags.get("title") or tags.get("TITLE") or tags.get("Title")
+        return duration, artist, title
+    return (0, "", "", "") if extra_info else (0, None, None)
+
+
+async def get_document_type(path):
+    is_video, is_audio, is_image = False, False, False
+    if (
+        is_archive(path)
+        or is_archive_split(path)
+        or re_search(r".+(\.|_)(rar|7z|zip|bin)(\.0*\d+)?$", path)
+    ):
+        return is_video, is_audio, is_image
+    mime_type = await sync_to_async(get_mime_type, path)
+    if mime_type.startswith("image"):
+        return False, False, True
+    try:
+        result = await cmd_exec(
+            [
+                "ffprobe",
+                "-hide_banner",
+                "-loglevel",
+                "error",
+                "-print_format",
+                "json",
+                "-show_streams",
+                path,
+            ]
+        )
+        if result[1] and mime_type.startswith("video"):
+            is_video = True
+    except Exception as e:
+        LOGGER.error(f"Get Document Type: {e}. Mostly File not found! - File: {path}")
+        if mime_type.startswith("audio"):
+            return False, True, False
+        if not mime_type.startswith("video") and not mime_type.endswith("octet-stream"):
+            return is_video, is_audio, is_image
+        if mime_type.startswith("video"):
+            is_video = True
+        return is_video, is_audio, is_image
+    if result[0] and result[2] == 0:
+        fields = eval(result[0]).get("streams")
+        if fields is None:
+            LOGGER.error(f"get_document_type: {result}")
+            return is_video, is_audio, is_image
+        is_video = False
+        for stream in fields:
+            if stream.get("codec_type") == "video":
+                codec_name = stream.get("codec_name", "").lower()
+                if codec_name not in {"mjpeg", "png", "bmp"}:
+                    is_video = True
+            elif stream.get("codec_type") == "audio":
+                is_audio = True
+    return is_video, is_audio, is_image
+
+
+async def get_streams(file):
+    """
+    Gets media stream information using ffprobe.
+
+    Args:
+        file: Path to the media file.
+
+    Returns:
+        A list of stream objects (dictionaries) or None if an error occurs
+        or no streams are found.
+    """
+    cmd = [
+        "ffprobe",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-print_format",
+        "json",
+        "-show_streams",
+        file,
+    ]
+    process = await create_subprocess_exec(*cmd, stdout=PIPE, stderr=PIPE)
+    stdout, stderr = await process.communicate()
+
+    if process.returncode != 0:
+        LOGGER.error(f"Error getting stream info: {stderr.decode().strip()}")
+        return None
+
+    try:
+        return json.loads(stdout)["streams"]
+    except KeyError:
+        LOGGER.error(
+            f"No streams found in the ffprobe output: {stdout.decode().strip()}",
+        )
+        return None
+
+
+async def take_ss(video_file, ss_nb) -> bool:
+    duration = (await get_media_info(video_file))[0]
+    if duration != 0:
+        dirpath, name = video_file.rsplit("/", 1)
+        name, _ = ospath.splitext(name)
+        dirpath = f"{dirpath}/{name}_mltbss"
+        await makedirs(dirpath, exist_ok=True)
+        interval = duration // (ss_nb + 1)
+        cap_time = interval
+        cmds = []
+        for i in range(ss_nb):
+            output = f"{dirpath}/SS.{name}_{i:02}.png"
+            cmd = [
+                "taskset",
+                "-c",
+                f"{cores}",
+                BinConfig.FFMPEG_NAME,
+                "-hide_banner",
+                "-loglevel",
+                "error",
+                "-ss",
+                f"{cap_time}",
+                "-i",
+                video_file,
+                "-q:v",
+                "1",
+                "-frames:v",
+                "1",
+                "-threads",
+                f"{threads}",
+                output,
+            ]
+            cap_time += interval
+            cmds.append(cmd_exec(cmd))
+        try:
+            resutls = await wait_for(gather(*cmds), timeout=60)
+            if resutls[0][2] != 0:
+                LOGGER.error(
+                    f"Error while creating screenshots from video. Path: {video_file}. stderr: {resutls[0][1]}"
+                )
+                await rmtree(dirpath, ignore_errors=True)
+                return False
+        except Exception:
+            LOGGER.error(
+                f"Error while creating screenshots from video. Path: {video_file}. Error: Timeout some issues with ffmpeg with specific arch!"
+            )
+            await rmtree(dirpath, ignore_errors=True)
+            return False
+        return dirpath
+    else:
+        LOGGER.error("take_ss: Can't get the duration of video")
+        return False
+
+
+async def get_audio_thumbnail(audio_file):
+    output_dir = f"{DOWNLOAD_DIR}thumbnails"
+    await makedirs(output_dir, exist_ok=True)
+    output = ospath.join(output_dir, f"{time()}.jpg")
+    cmd = [
+        "taskset",
+        "-c",
+        f"{cores}",
+        BinConfig.FFMPEG_NAME,
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-i",
+        audio_file,
+        "-an",
+        "-vcodec",
+        "copy",
+        "-threads",
+        f"{threads}",
+        output,
+    ]
+    try:
+        _, err, code = await wait_for(cmd_exec(cmd), timeout=60)
+        if code != 0 or not await aiopath.exists(output):
+            LOGGER.error(
+                f"Error while extracting thumbnail from audio. Name: {audio_file} stderr: {err}"
+            )
+            return None
+    except Exception:
+        LOGGER.error(
+            f"Error while extracting thumbnail from audio. Name: {audio_file}. Error: Timeout some issues with ffmpeg with specific arch!"
+        )
+        return None
+    return output
+
+
+async def get_video_thumbnail(video_file, duration):
+    output_dir = f"{DOWNLOAD_DIR}thumbnails"
+    await makedirs(output_dir, exist_ok=True)
+    output = ospath.join(output_dir, f"{time()}.jpg")
+    if duration is None:
+        duration = (await get_media_info(video_file))[0]
+    if duration == 0:
+        duration = 3
+    duration = duration // 2
+    cmd = [
+        "taskset",
+        "-c",
+        f"{cores}",
+        BinConfig.FFMPEG_NAME,
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-ss",
+        f"{duration}",
+        "-i",
+        video_file,
+        "-vf",
+        "thumbnail",
+        "-q:v",
+        "1",
+        "-frames:v",
+        "1",
+        "-threads",
+        f"{threads}",
+        output,
+    ]
+    try:
+        _, err, code = await wait_for(cmd_exec(cmd), timeout=60)
+        if code != 0 or not await aiopath.exists(output):
+            LOGGER.error(
+                f"Error while extracting thumbnail from video. Name: {video_file} stderr: {err}"
+            )
+            return None
+    except Exception:
+        LOGGER.error(
+            f"Error while extracting thumbnail from video. Name: {video_file}. Error: Timeout some issues with ffmpeg with specific arch!"
+        )
+        return None
+    return output
+
+
+async def get_multiple_frames_thumbnail(video_file, layout, keep_screenshots):
+    layout = re.sub(r"(\d+)\D+(\d+)", r"\1x\2", layout)
+    ss_nb = layout.split("x")
+    if len(ss_nb) != 2 or not ss_nb[0].isdigit() or not ss_nb[1].isdigit():
+        LOGGER.error(f"Invalid layout value: {layout}")
+        return None
+    ss_nb = int(ss_nb[0]) * int(ss_nb[1])
+    if ss_nb == 0:
+        LOGGER.error(f"Invalid layout value: {layout}")
+        return None
+    dirpath = await take_ss(video_file, ss_nb)
+    if not dirpath:
+        return None
+    output_dir = f"{DOWNLOAD_DIR}thumbnails"
+    await makedirs(output_dir, exist_ok=True)
+    output = ospath.join(output_dir, f"{time()}.jpg")
+    cmd = [
+        "taskset",
+        "-c",
+        f"{cores}",
+        BinConfig.FFMPEG_NAME,
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-pattern_type",
+        "glob",
+        "-i",
+        f"{escape(dirpath)}/*.png",
+        "-vf",
+        f"tile={layout}, thumbnail",
+        "-q:v",
+        "1",
+        "-frames:v",
+        "1",
+        "-f",
+        "mjpeg",
+        "-threads",
+        f"{threads}",
+        output,
+    ]
+    try:
+        _, err, code = await wait_for(cmd_exec(cmd), timeout=60)
+        if code != 0 or not await aiopath.exists(output):
+            LOGGER.error(
+                f"Error while combining thumbnails for video. Name: {video_file} stderr: {err}"
+            )
+            return None
+    except Exception:
+        LOGGER.error(
+            f"Error while combining thumbnails from video. Name: {video_file}. Error: Timeout some issues with ffmpeg with specific arch!"
+        )
+        return None
+    finally:
+        if not keep_screenshots:
+            await rmtree(dirpath, ignore_errors=True)
+    return output
+
+
+class FFMpeg:
+    def __init__(self, listener):
+        self._listener = listener
+        self._processed_bytes = 0
+        self._last_processed_bytes = 0
+        self._processed_time = 0
+        self._last_processed_time = 0
+        self._speed_raw = 0
+        self._progress_raw = 0
+        self._total_time = 0
+        self._eta_raw = 0
+        self._time_rate = 0.1
+        self._start_time = 0
+
+    @property
+    def processed_bytes(self):
+        return self._processed_bytes
+
+    @property
+    def speed_raw(self):
+        return self._speed_raw
+
+    @property
+    def progress_raw(self):
+        return self._progress_raw
+
+    @property
+    def eta_raw(self):
+        return self._eta_raw
+
+    def clear(self):
+        self._start_time = time()
+        self._processed_bytes = 0
+        self._processed_time = 0
+        self._speed_raw = 0
+        self._progress_raw = 0
+        self._eta_raw = 0
+        self._time_rate = 0.1
+        self._last_processed_time = 0
+        self._last_processed_bytes = 0
+
+    async def _ffmpeg_progress(self):
+        while not (
+            self._listener.subproc.returncode is not None
+            or self._listener.is_cancelled
+            or self._listener.subproc.stdout.at_eof()
+        ):
+            try:
+                line = await wait_for(self._listener.subproc.stdout.readline(), 60)
+            except Exception:
+                break
+            line = line.decode().strip()
+            if not line:
+                break
+            if "=" in line:
+                key, value = line.split("=", 1)
+                if value != "N/A":
+                    if key == "total_size":
+                        self._processed_bytes = int(value) + self._last_processed_bytes
+                        self._speed_raw = self._processed_bytes / (
+                            time() - self._start_time
+                        )
+                    elif key == "speed":
+                        self._time_rate = max(0.1, float(value.strip("x")))
+                    elif key == "out_time":
+                        self._processed_time = (
+                            time_to_seconds(value) + self._last_processed_time
+                        )
+                        try:
+                            self._progress_raw = (
+                                self._processed_time * 100
+                            ) / self._total_time
+                            if (
+                                hasattr(self._listener, "subsize")
+                                and self._listener.subsize
+                                and self._progress_raw > 0
+                            ):
+                                self._processed_bytes = int(
+                                    self._listener.subsize * (self._progress_raw / 100)
+                                )
+                            if (time() - self._start_time) > 0:
+                                self._speed_raw = self._processed_bytes / (
+                                    time() - self._start_time
+                                )
+                            else:
+                                self._speed_raw = 0
+                            self._eta_raw = (
+                                self._total_time - self._processed_time
+                            ) / self._time_rate
+                        except ZeroDivisionError:
+                            self._progress_raw = 0
+                            self._eta_raw = 0
+            await sleep(0.05)
+
+    async def ffmpeg_cmds(self, ffmpeg, f_path):
+        self.clear()
+        self._total_time = (await get_media_info(f_path))[0]
+        base_name, ext = ospath.splitext(f_path)
+        dir, base_name = base_name.rsplit("/", 1)
+        indices = [
+            index
+            for index, item in enumerate(ffmpeg)
+            if item.startswith("mltb") or item == "mltb"
+        ]
+        outputs = []
+        for index in indices:
+            output_file = ffmpeg[index]
+            if output_file != "mltb" and output_file.startswith("mltb"):
+                bo, oext = ospath.splitext(output_file)
+                if oext:
+                    if ext == oext:
+                        prefix = f"ffmpeg{index}." if bo == "mltb" else ""
+                    else:
+                        prefix = ""
+                    ext = ""
+                else:
+                    prefix = ""
+            else:
+                prefix = f"ffmpeg{index}."
+            output = f"{dir}/{prefix}{output_file.replace('mltb', base_name)}{ext}"
+            outputs.append(output)
+            ffmpeg[index] = output
+        if self._listener.is_cancelled:
+            return False
+        self._listener.subproc = await create_subprocess_exec(
+            *ffmpeg, stdout=PIPE, stderr=PIPE
+        )
+        await self._ffmpeg_progress()
+        _, stderr = await self._listener.subproc.communicate()
+        code = self._listener.subproc.returncode
+        if self._listener.is_cancelled:
+            return False
+        if code == 0:
+            return outputs
+        elif code == -9:
+            self._listener.is_cancelled = True
+            return False
+        else:
+            try:
+                stderr = stderr.decode().strip()
+            except Exception:
+                stderr = "Unable to decode the error!"
+            LOGGER.error(
+                f"{stderr}. Something went wrong while running ffmpeg cmd, mostly file requires different/specific arguments. Path: {f_path}"
+            )
+            for op in outputs:
+                if await aiopath.exists(op):
+                    await remove(op)
+            return False
+
+    async def convert_video(self, video_file, ext, retry=False):
+        self.clear()
+        self._total_time = (await get_media_info(video_file))[0]
+        base_name = ospath.splitext(video_file)[0]
+        output = f"{base_name}.{ext}"
+        if retry:
+            cmd = [
+                "taskset",
+                "-c",
+                f"{cores}",
+                BinConfig.FFMPEG_NAME,
+                "-hide_banner",
+                "-loglevel",
+                "error",
+                "-progress",
+                "pipe:1",
+                "-i",
+                video_file,
+                "-map",
+                "0",
+                "-c:v",
+                "libx264",
+                "-c:a",
+                "aac",
+                "-threads",
+                f"{threads}",
+                output,
+            ]
+            if ext == "mp4":
+                cmd[17:17] = ["-c:s", "mov_text"]
+            elif ext == "mkv":
+                cmd[17:17] = ["-c:s", "ass"]
+            else:
+                cmd[17:17] = ["-c:s", "copy"]
+        else:
+            cmd = [
+                "taskset",
+                "-c",
+                f"{cores}",
+                BinConfig.FFMPEG_NAME,
+                "-hide_banner",
+                "-loglevel",
+                "error",
+                "-progress",
+                "pipe:1",
+                "-i",
+                video_file,
+                "-map",
+                "0",
+                "-c",
+                "copy",
+                "-threads",
+                f"{threads}",
+                output,
+            ]
+        if self._listener.is_cancelled:
+            return False
+        self._listener.subproc = await create_subprocess_exec(
+            *cmd, stdout=PIPE, stderr=PIPE
+        )
+        await self._ffmpeg_progress()
+        _, stderr = await self._listener.subproc.communicate()
+        code = self._listener.subproc.returncode
+        if self._listener.is_cancelled:
+            return False
+        if code == 0:
+            return output
+        elif code == -9:
+            self._listener.is_cancelled = True
+            return False
+        else:
+            if await aiopath.exists(output):
+                await remove(output)
+            if not retry:
+                return await self.convert_video(video_file, ext, True)
+            try:
+                stderr = stderr.decode().strip()
+            except Exception:
+                stderr = "Unable to decode the error!"
+            LOGGER.error(
+                f"{stderr}. Something went wrong while converting video, mostly file need specific codec. Path: {video_file}"
+            )
+        return False
+
+    async def convert_audio(self, audio_file, ext):
+        self.clear()
+        self._total_time = (await get_media_info(audio_file))[0]
+        base_name = ospath.splitext(audio_file)[0]
+        output = f"{base_name}.{ext}"
+        cmd = [
+            "taskset",
+            "-c",
+            f"{cores}",
+            BinConfig.FFMPEG_NAME,
+            "-hide_banner",
+            "-loglevel",
+            "error",
+            "-progress",
+            "pipe:1",
+            "-i",
+            audio_file,
+            "-threads",
+            f"{threads}",
+            output,
+        ]
+        if self._listener.is_cancelled:
+            return False
+        self._listener.subproc = await create_subprocess_exec(
+            *cmd, stdout=PIPE, stderr=PIPE
+        )
+        await self._ffmpeg_progress()
+        _, stderr = await self._listener.subproc.communicate()
+        code = self._listener.subproc.returncode
+        if self._listener.is_cancelled:
+            return False
+        if code == 0:
+            return output
+        elif code == -9:
+            self._listener.is_cancelled = True
+            return False
+        else:
+            try:
+                stderr = stderr.decode().strip()
+            except Exception:
+                stderr = "Unable to decode the error!"
+            LOGGER.error(
+                f"{stderr}. Something went wrong while converting audio, mostly file need specific codec. Path: {audio_file}"
+            )
+            if await aiopath.exists(output):
+                await remove(output)
+        return False
+
+    async def sample_video(self, video_file, sample_duration, part_duration):
+        self.clear()
+        self._total_time = sample_duration
+        dir, name = video_file.rsplit("/", 1)
+        output_file = f"{dir}/SAMPLE.{name}"
+        segments = [(0, part_duration)]
+        duration = (await get_media_info(video_file))[0]
+        remaining_duration = duration - (part_duration * 2)
+        parts = (sample_duration - (part_duration * 2)) // part_duration
+        time_interval = remaining_duration // parts
+        next_segment = time_interval
+        for _ in range(parts):
+            segments.append((next_segment, next_segment + part_duration))
+            next_segment += time_interval
+        segments.append((duration - part_duration, duration))
+
+        filter_complex = ""
+        for i, (start, end) in enumerate(segments):
+            filter_complex += (
+                f"[0:v]trim=start={start}:end={end},setpts=PTS-STARTPTS[v{i}]; "
+            )
+            filter_complex += (
+                f"[0:a]atrim=start={start}:end={end},asetpts=PTS-STARTPTS[a{i}]; "
+            )
+
+        for i in range(len(segments)):
+            filter_complex += f"[v{i}][a{i}]"
+
+        filter_complex += f"concat=n={len(segments)}:v=1:a=1[vout][aout]"
+
+        cmd = [
+            "taskset",
+            "-c",
+            f"{cores}",
+            BinConfig.FFMPEG_NAME,
+            "-hide_banner",
+            "-loglevel",
+            "error",
+            "-progress",
+            "pipe:1",
+            "-i",
+            video_file,
+            "-filter_complex",
+            filter_complex,
+            "-map",
+            "[vout]",
+            "-map",
+            "[aout]",
+            "-c:v",
+            "libx264",
+            "-c:a",
+            "aac",
+            "-threads",
+            f"{threads}",
+            output_file,
+        ]
+
+        if self._listener.is_cancelled:
+            return False
+        self._listener.subproc = await create_subprocess_exec(
+            *cmd, stdout=PIPE, stderr=PIPE
+        )
+        await self._ffmpeg_progress()
+        _, stderr = await self._listener.subproc.communicate()
+        code = self._listener.subproc.returncode
+        if self._listener.is_cancelled:
+            return False
+        if code == -9:
+            self._listener.is_cancelled = True
+            return False
+        elif code == 0:
+            return output_file
+        else:
+            try:
+                stderr = stderr.decode().strip()
+            except Exception:
+                stderr = "Unable to decode the error!"
+            LOGGER.error(
+                f"{stderr}. Something went wrong while creating sample video, mostly file is corrupted. Path: {video_file}"
+            )
+            if await aiopath.exists(output_file):
+                await remove(output_file)
+            return False
+
+    async def split(self, f_path, file_, parts, split_size):
+        self.clear()
+        multi_streams = True
+        self._total_time = duration = (await get_media_info(f_path))[0]
+        base_name, extension = ospath.splitext(file_)
+        split_size -= 3000000
+        start_time = 0
+        i = 1
+        while i <= parts or start_time < duration - 4:
+            out_path = f_path.replace(file_, f"{base_name}.part{i:03}{extension}")
+            cmd = [
+                "taskset",
+                "-c",
+                f"{cores}",
+                BinConfig.FFMPEG_NAME,
+                "-hide_banner",
+                "-loglevel",
+                "error",
+                "-progress",
+                "pipe:1",
+                "-ss",
+                str(start_time),
+                "-i",
+                f_path,
+                "-fs",
+                str(split_size),
+                "-map",
+                "0",
+                "-map_chapters",
+                "-1",
+                "-async",
+                "1",
+                "-strict",
+                "-2",
+                "-c",
+                "copy",
+                "-threads",
+                f"{threads}",
+                out_path,
+            ]
+            if not multi_streams:
+                del cmd[15]
+                del cmd[15]
+            if self._listener.is_cancelled:
+                return False
+            self._listener.subproc = await create_subprocess_exec(
+                *cmd, stdout=PIPE, stderr=PIPE
+            )
+            await self._ffmpeg_progress()
+            _, stderr = await self._listener.subproc.communicate()
+            code = self._listener.subproc.returncode
+            if self._listener.is_cancelled:
+                return False
+            if code == -9:
+                self._listener.is_cancelled = True
+                return False
+            elif code != 0:
+                try:
+                    stderr = stderr.decode().strip()
+                except Exception:
+                    stderr = "Unable to decode the error!"
+                with suppress(Exception):
+                    await remove(out_path)
+                if multi_streams:
+                    LOGGER.warning(
+                        f"{stderr}. Retrying without map, -map 0 not working in all situations. Path: {f_path}"
+                    )
+                    multi_streams = False
+                    continue
+                else:
+                    LOGGER.warning(
+                        f"{stderr}. Unable to split this video, if it's size less than {self._listener.max_split_size} will be uploaded as it is. Path: {f_path}"
+                    )
+                return False
+            out_size = await aiopath.getsize(out_path)
+            if out_size > self._listener.max_split_size:
+                split_size -= (out_size - self._listener.max_split_size) + 5000000
+                LOGGER.warning(
+                    f"Part size is {out_size}. Trying again with lower split size!. Path: {f_path}"
+                )
+                await remove(out_path)
+                continue
+            lpd = (await get_media_info(out_path))[0]
+            if lpd == 0:
+                LOGGER.error(
+                    f"Something went wrong while splitting, mostly file is corrupted. Path: {f_path}"
+                )
+                break
+            elif duration == lpd:
+                LOGGER.warning(
+                    f"This file has been splitted with default stream and audio, so you will only see one part with less size from orginal one because it doesn't have all streams and audios. This happens mostly with MKV videos. Path: {f_path}"
+                )
+                break
+            elif lpd <= 3:
+                await remove(out_path)
+                break
+            self._last_processed_time += lpd
+            self._last_processed_bytes += out_size
+            start_time += lpd - 3
+            i += 1
+        return True

bot/helper/ext_utils/metadata_utils.py

@@ -0,0 +1,168 @@
+from os.path import basename, splitext
+from re import compile as re_compile
+from pycountry import languages
+from ..ext_utils.media_utils import get_streams
+
+
+class MetadataProcessor:
+    _year_pattern = re_compile(r"\b(19|20)\d{2}\b")
+    _sanitize_pattern = re_compile(r'[<>:"/\\?*]')
+
+    def __init__(self):
+        self.vars = {}
+        self.audio_streams = []
+        self.subtitle_streams = []
+
+    @staticmethod
+    def convert_lang_code(lang_code):
+        if not lang_code or lang_code in {"unknown", "und", "none"}:
+            return lang_code
+        try:
+            if len(lang_code) == 2:
+                lang = languages.get(alpha_2=lang_code.lower())
+            elif len(lang_code) == 3:
+                lang = languages.get(alpha_3=lang_code.lower())
+            else:
+                return lang_code
+            return lang.name if lang else lang_code
+        except Exception:
+            return lang_code
+
+    async def extract_file_vars(self, file_path):
+        fname = basename(file_path)
+        bname, ext = splitext(fname)
+        self.vars = {
+            "filename": fname,
+            "basename": bname,
+            "extension": ext.lstrip("."),
+            "audiolang": "unknown",
+            "sublang": "none",
+        }
+        self.audio_streams, self.subtitle_streams = [], []
+        try:
+            for s in await get_streams(file_path) or []:
+                ctype = s.get("codec_type", "").lower()
+                slang = s.get("tags", {}).get("language", "unknown")
+                full_lang = self.convert_lang_code(slang)
+                entry = {
+                    "index": s.get("index", 0),
+                    "language": slang,
+                    "full_language": full_lang,
+                }
+                if ctype == "audio":
+                    self.audio_streams.append(entry)
+                    if self.vars["audiolang"] == "unknown" and slang != "und":
+                        self.vars["audiolang"] = full_lang
+                elif ctype == "subtitle":
+                    self.subtitle_streams.append(entry)
+                    if self.vars["sublang"] == "none" and slang != "und":
+                        self.vars["sublang"] = full_lang
+        except Exception:
+            pass
+        m = self._year_pattern.findall(bname)
+        if m:
+            self.vars["year"] = m[-1]
+
+    @staticmethod
+    def parse_string(metadata_str):
+        if not metadata_str or not isinstance(metadata_str, str):
+            return {}
+        parts, current, i = [], "", 0
+        while i < len(metadata_str):
+            if (
+                metadata_str[i] == "\\"
+                and i + 1 < len(metadata_str)
+                and metadata_str[i + 1] == "|"
+            ):
+                current += "|"
+                i += 2
+            elif metadata_str[i] == "|":
+                parts.append(current)
+                current = ""
+                i += 1
+            else:
+                current += metadata_str[i]
+                i += 1
+        if current:
+            parts.append(current)
+        return dict(p.split("=", 1) if "=" in p else (p, "") for p in parts)
+
+    @staticmethod
+    def merge_dicts(default_dict, cmd_dict):
+        return {**(default_dict or {}), **(cmd_dict or {})}
+
+    def apply_vars_to_stream(
+        self, metadata_dict, stream_lang=None, full_lang=None, stream_type="audio"
+    ):
+        if not isinstance(metadata_dict, dict):
+            return {}
+        vars_with_stream = self.vars.copy()
+        if stream_lang and stream_lang != "unknown":
+            key = "audiolang" if stream_type == "audio" else "sublang"
+            vars_with_stream[key] = full_lang or self.convert_lang_code(stream_lang)
+        return {
+            self.sanitize(k): (
+                str(v).format(**vars_with_stream) if isinstance(v, str) else str(v)
+            )
+            for k, v in metadata_dict.items()
+        }
+
+    def apply_vars(self, metadata_dict):
+        return self.apply_vars_to_stream(metadata_dict)
+
+    def get_audio_metadata(self, audio_metadata_dict):
+        return [
+            {
+                "index": s["index"],
+                "metadata": self.apply_vars_to_stream(
+                    audio_metadata_dict, s["language"], s["full_language"], "audio"
+                ),
+            }
+            for s in self.audio_streams
+        ]
+
+    def get_subtitle_metadata(self, subtitle_metadata_dict):
+        return [
+            {
+                "index": s["index"],
+                "metadata": self.apply_vars_to_stream(
+                    subtitle_metadata_dict,
+                    s["language"],
+                    s["full_language"],
+                    "subtitle",
+                ),
+            }
+            for s in self.subtitle_streams
+        ]
+
+    def sanitize(self, value):
+        return self._sanitize_pattern.sub("_", str(value))[:100]
+
+    async def process_all(
+        self,
+        video_metadata_dict,
+        audio_metadata_dict,
+        subtitle_metadata_dict,
+        file_path,
+    ):
+        await self.extract_file_vars(file_path)
+        return {
+            "video": (
+                self.apply_vars(video_metadata_dict) if video_metadata_dict else {}
+            ),
+            "audio_streams": (
+                self.get_audio_metadata(audio_metadata_dict)
+                if audio_metadata_dict
+                else []
+            ),
+            "subtitle_streams": (
+                self.get_subtitle_metadata(subtitle_metadata_dict)
+                if subtitle_metadata_dict
+                else []
+            ),
+            "global": {},
+        }
+
+    async def process(self, metadata_dict, file_path):
+        await self.extract_file_vars(file_path)
+        return self.apply_vars(metadata_dict)

bot/helper/ext_utils/shortener_utils.py

@@ -0,0 +1,84 @@
+from base64 import b64encode
+from random import choice, random
+from asyncio import sleep as asleep
+from urllib.parse import quote
+
+from cloudscraper import create_scraper
+from urllib3 import disable_warnings
+
+from ... import LOGGER, shortener_dict
+from ...core.config_manager import Config
+
+
+async def short_url(longurl, attempt=0):
+    if not shortener_dict and not Config.PROTECTED_API:
+        return longurl
+    if attempt >= 4:
+        return longurl
+
+    cget = create_scraper().request
+    disable_warnings()
+    try:
+        if Config.PROTECTED_API:
+            res = cget("GET", Config.PROTECTED_API, params={"url": longurl}).json()
+            if res.get("status") == "success":
+                return res["url"]
+            raise Exception(f"Protected API Error: {res}")
+
+        _shortener, _shortener_api = choice(list(shortener_dict.items()))
+        if "shorte.st" in _shortener:
+            headers = {"public-api-token": _shortener_api}
+            data = {"urlToShorten": quote(longurl)}
+            return cget(
+                "PUT", "https://api.shorte.st/v1/data/url", headers=headers, data=data
+            ).json()["shortenedUrl"]
+        elif "linkvertise" in _shortener:
+            url = quote(b64encode(longurl.encode("utf-8")))
+            linkvertise = [
+                f"https://link-to.net/{_shortener_api}/{random() * 1000}/dynamic?r={url}",
+                f"https://up-to-down.net/{_shortener_api}/{random() * 1000}/dynamic?r={url}",
+                f"https://direct-link.net/{_shortener_api}/{random() * 1000}/dynamic?r={url}",
+                f"https://file-link.net/{_shortener_api}/{random() * 1000}/dynamic?r={url}",
+            ]
+            return choice(linkvertise)
+        elif "bitly.com" in _shortener:
+            headers = {"Authorization": f"Bearer {_shortener_api}"}
+            return cget(
+                "POST",
+                "https://api-ssl.bit.ly/v4/shorten",
+                json={"long_url": longurl},
+                headers=headers,
+            ).json()["link"]
+        elif "ouo.io" in _shortener:
+            return cget(
+                "GET", f"http://ouo.io/api/{_shortener_api}?s={longurl}", verify=False
+            ).text
+        elif "cutt.ly" in _shortener:
+            return cget(
+                "GET",
+                f"http://cutt.ly/api/api.php?key={_shortener_api}&short={longurl}",
+            ).json()["url"]["shortLink"]
+        else:
+            res = cget(
+                "GET",
+                f"https://{_shortener}/api?api={_shortener_api}&url={quote(longurl)}",
+            ).json()
+            shorted = res["shortenedUrl"]
+            if not shorted:
+                shrtco_res = cget(
+                    "GET", f"https://api.shrtco.de/v2/shorten?url={quote(longurl)}"
+                ).json()
+                shrtco_link = shrtco_res["result"]["full_short_link"]
+                res = cget(
+                    "GET",
+                    f"https://{_shortener}/api?api={_shortener_api}&url={shrtco_link}",
+                ).json()
+                shorted = res["shortenedUrl"]
+            if not shorted:
+                shorted = longurl
+            return shorted
+    except Exception as e:
+        LOGGER.error(e)
+        await asleep(0.8)
+        attempt += 1
+        return await short_url(longurl, attempt)

bot/helper/ext_utils/status_utils.py

@@ -0,0 +1,308 @@
+from asyncio import gather, iscoroutinefunction
+from html import escape
+from re import findall
+from time import time
+
+from psutil import cpu_percent, disk_usage, virtual_memory
+
+from ... import (
+    DOWNLOAD_DIR,
+    bot_cache,
+    bot_start_time,
+    status_dict,
+    task_dict,
+    task_dict_lock,
+)
+from ...core.config_manager import Config
+from ..telegram_helper.button_build import ButtonMaker
+
+SIZE_UNITS = ["B", "KB", "MB", "GB", "TB", "PB"]
+
+
+class MirrorStatus:
+    STATUS_UPLOAD = "Upload"
+    STATUS_DOWNLOAD = "Download"
+    STATUS_CLONE = "Clone"
+    STATUS_QUEUEDL = "QueueDl"
+    STATUS_QUEUEUP = "QueueUp"
+    STATUS_PAUSED = "Pause"
+    STATUS_ARCHIVE = "Archive"
+    STATUS_EXTRACT = "Extract"
+    STATUS_SPLIT = "Split"
+    STATUS_CHECK = "CheckUp"
+    STATUS_SEED = "Seed"
+    STATUS_SAMVID = "SamVid"
+    STATUS_CONVERT = "Convert"
+    STATUS_FFMPEG = "FFmpeg"
+    STATUS_YT = "YouTube"
+    STATUS_METADATA = "Metadata"
+
+
+class EngineStatus:
+    def __init__(self):
+        ver = bot_cache.get("eng_versions", {})
+        self.STATUS_ARIA2 = f"Aria2 v{ver.get('aria2', 'N/A')}"
+        self.STATUS_AIOHTTP = f"AioHttp v{ver.get('aiohttp', 'N/A')}"
+        self.STATUS_GDAPI = f"Google-API v{ver.get('gapi', 'N/A')}"
+        self.STATUS_QBIT = f"qBit v{ver.get('qBittorrent', 'N/A')}"
+        self.STATUS_TGRAM = f"Pyro v{ver.get('pyrotgfork', 'N/A')}"
+        self.STATUS_MEGA = f"MegaCMD v{ver.get('mega', 'N/A')}"
+        self.STATUS_YTDLP = f"yt-dlp v{ver.get('yt-dlp', 'N/A')}"
+        self.STATUS_FFMPEG = f"ffmpeg v{ver.get('ffmpeg', 'N/A')}"
+        self.STATUS_7Z = f"7z v{ver.get('7z', 'N/A')}"
+        self.STATUS_RCLONE = f"RClone v{ver.get('rclone', 'N/A')}"
+        self.STATUS_SABNZBD = f"SABnzbd+ v{ver.get('SABnzbd+', 'N/A')}"
+        self.STATUS_QUEUE = "QSystem v2"
+        self.STATUS_JD = "JDownloader v2"
+        self.STATUS_YT = "Youtube-Api"
+        self.STATUS_METADATA = "Metadata"
+        self.STATUS_UPHOSTER = "Uphoster"
+
+
+STATUSES = {
+    "ALL": "All",
+    "DL": MirrorStatus.STATUS_DOWNLOAD,
+    "UP": MirrorStatus.STATUS_UPLOAD,
+    "QD": MirrorStatus.STATUS_QUEUEDL,
+    "QU": MirrorStatus.STATUS_QUEUEUP,
+    "AR": MirrorStatus.STATUS_ARCHIVE,
+    "EX": MirrorStatus.STATUS_EXTRACT,
+    "SD": MirrorStatus.STATUS_SEED,
+    "CL": MirrorStatus.STATUS_CLONE,
+    "CM": MirrorStatus.STATUS_CONVERT,
+    "SP": MirrorStatus.STATUS_SPLIT,
+    "SV": MirrorStatus.STATUS_SAMVID,
+    "FF": MirrorStatus.STATUS_FFMPEG,
+    "PA": MirrorStatus.STATUS_PAUSED,
+    "CK": MirrorStatus.STATUS_CHECK,
+}
+
+
+async def get_task_by_gid(gid: str):
+    async with task_dict_lock:
+        for tk in task_dict.values():
+            if hasattr(tk, "seeding"):
+                await tk.update()
+            if tk.gid() == gid:
+                return tk
+        return None
+
+
+async def get_specific_tasks(status, user_id):
+    if status == "All":
+        if user_id:
+            return [tk for tk in task_dict.values() if tk.listener.user_id == user_id]
+        else:
+            return list(task_dict.values())
+    tasks_to_check = (
+        [tk for tk in task_dict.values() if tk.listener.user_id == user_id]
+        if user_id
+        else list(task_dict.values())
+    )
+    coro_tasks = []
+    coro_tasks.extend(tk for tk in tasks_to_check if iscoroutinefunction(tk.status))
+    coro_statuses = await gather(*[tk.status() for tk in coro_tasks])
+    result = []
+    coro_index = 0
+    for tk in tasks_to_check:
+        if tk in coro_tasks:
+            st = coro_statuses[coro_index]
+            coro_index += 1
+        else:
+            st = tk.status()
+        if (st == status) or (
+            status == MirrorStatus.STATUS_DOWNLOAD and st not in STATUSES.values()
+        ):
+            result.append(tk)
+    return result
+
+
+async def get_all_tasks(req_status: str, user_id):
+    async with task_dict_lock:
+        return await get_specific_tasks(req_status, user_id)
+
+
+def get_raw_file_size(size):
+    num, unit = size.split()
+    return int(float(num) * (1024 ** SIZE_UNITS.index(unit)))
+
+
+def get_readable_file_size(size_in_bytes):
+    if not size_in_bytes:
+        return "0B"
+
+    index = 0
+    while size_in_bytes >= 1024 and index < len(SIZE_UNITS) - 1:
+        size_in_bytes /= 1024
+        index += 1
+
+    return f"{size_in_bytes:.2f}{SIZE_UNITS[index]}"
+
+
+def get_readable_time(seconds: int):
+    periods = [("d", 86400), ("h", 3600), ("m", 60), ("s", 1)]
+    result = ""
+    for period_name, period_seconds in periods:
+        if seconds >= period_seconds:
+            period_value, seconds = divmod(seconds, period_seconds)
+            result += f"{int(period_value)}{period_name}"
+    return result
+
+
+def get_raw_time(time_str: str) -> int:
+    time_units = {"d": 86400, "h": 3600, "m": 60, "s": 1}
+    return sum(
+        int(value) * time_units[unit]
+        for value, unit in findall(r"(\d+)([dhms])", time_str)
+    )
+
+
+def time_to_seconds(time_duration):
+    try:
+        parts = time_duration.split(":")
+        if len(parts) == 3:
+            hours, minutes, seconds = map(float, parts)
+        elif len(parts) == 2:
+            hours = 0
+            minutes, seconds = map(float, parts)
+        elif len(parts) == 1:
+            hours = 0
+            minutes = 0
+            seconds = float(parts[0])
+        else:
+            return 0
+        return hours * 3600 + minutes * 60 + seconds
+    except Exception:
+        return 0
+
+
+def speed_string_to_bytes(size_text: str):
+    size = 0
+    size_text = size_text.lower()
+    if "k" in size_text:
+        size += float(size_text.split("k")[0]) * 1024
+    elif "m" in size_text:
+        size += float(size_text.split("m")[0]) * 1048576
+    elif "g" in size_text:
+        size += float(size_text.split("g")[0]) * 1073741824
+    elif "t" in size_text:
+        size += float(size_text.split("t")[0]) * 1099511627776
+    elif "b" in size_text:
+        size += float(size_text.split("b")[0])
+    return size
+
+
+def get_progress_bar_string(pct):
+    pct = float(str(pct).strip("%"))
+    p = min(max(pct, 0), 100)
+    cFull = int(p // 8)
+    p_str = "⬢" * cFull
+    p_str += "⬡" * (12 - cFull)
+    return f"[{p_str}]"
+
+
+async def get_readable_message(sid, is_user, page_no=1, status="All", page_step=1):
+    msg = ""
+    button = None
+
+    tasks = await get_specific_tasks(status, sid if is_user else None)
+
+    STATUS_LIMIT = Config.STATUS_LIMIT
+    tasks_no = len(tasks)
+    pages = (max(tasks_no, 1) + STATUS_LIMIT - 1) // STATUS_LIMIT
+    if page_no > pages:
+        page_no = (page_no - 1) % pages + 1
+        status_dict[sid]["page_no"] = page_no
+    elif page_no < 1:
+        page_no = pages - (abs(page_no) % pages)
+        status_dict[sid]["page_no"] = page_no
+    start_position = (page_no - 1) * STATUS_LIMIT
+
+    for index, task in enumerate(
+        tasks[start_position : STATUS_LIMIT + start_position], start=1
+    ):
+        if status != "All":
+            tstatus = status
+        elif iscoroutinefunction(task.status):
+            tstatus = await task.status()
+        else:
+            tstatus = task.status()
+        msg += f"<b>{index + start_position}.</b> "
+        msg += f"<b><i>{escape(f'{task.name()}')}</i></b>"
+        if task.listener.subname:
+            msg += f"\n┖ <b>Sub Name</b> → <i>{task.listener.subname}</i>"
+        elapsed = time() - task.listener.message.date.timestamp()
+
+        msg += f"\n\n<b>Task By {task.listener.message.from_user.mention(style='html')} </b> ( #ID{task.listener.message.from_user.id} )"
+        if task.listener.is_super_chat:
+            msg += f" <i>[<a href='{task.listener.message.link}'>Link</a>]</i>"
+
+        if (
+            tstatus not in [MirrorStatus.STATUS_SEED, MirrorStatus.STATUS_QUEUEUP]
+            and task.listener.progress
+        ):
+            progress = task.progress()
+            msg += f"\n┟ {get_progress_bar_string(progress)} <i>{progress}</i>"
+            if task.listener.subname:
+                subsize = f" / {get_readable_file_size(task.listener.subsize)}"
+                ac = len(task.listener.files_to_proceed)
+                count = f"( {task.listener.proceed_count} / {ac or '?'} )"
+            else:
+                subsize = ""
+                count = ""
+            msg += f"\n┠ <b>Processed</b> → <i>{task.processed_bytes()}{subsize} of {task.size()}</i>"
+            if count:
+                msg += f"\n┠ <b>Count:</b> → <b>{count}</b>"
+            msg += f"\n┠ <b>Status</b> → <b>{tstatus}</b>"
+            msg += f"\n┠ <b>Speed</b> → <i>{task.speed()}</i>"
+            msg += f"\n┠ <b>Time</b> → <i>{task.eta()} of {get_readable_time(elapsed + get_raw_time(task.eta()))} ( {get_readable_time(elapsed)} )</i>"
+            if tstatus == MirrorStatus.STATUS_DOWNLOAD and (
+                task.listener.is_torrent or task.listener.is_qbit
+            ):
+                try:
+                    msg += f"\n┠ <b>Seeders</b> → {task.seeders_num()} | <b>Leechers</b> → {task.leechers_num()}"
+                except Exception:
+                    pass
+            # TODO: Add Connected Peers
+        elif tstatus == MirrorStatus.STATUS_SEED:
+            msg += f"\n┠ <b>Size</b> → <i>{task.size()}</i> | <b>Uploaded</b>  → <i>{task.uploaded_bytes()}</i>"
+            msg += f"\n┠ <b>Status</b> → <b>{tstatus}</b>"
+            msg += f"\n┠ <b>Speed</b> → <i>{task.seed_speed()}</i>"
+            msg += f"\n┠ <b>Ratio</b> → <i>{task.ratio()}</i>"
+            msg += f"\n┠ <b>Time</b> → <i>{task.seeding_time()}</i> | <b>Elapsed</b> → <i>{get_readable_time(elapsed)}</i>"
+        else:
+            msg += f"\n┠ <b>Size</b> → <i>{task.size()}</i>"
+        msg += f"\n┠ <b>Engine</b> → <i>{task.engine}</i>"
+        msg += f"\n┠ <b>In Mode</b> → <i>{task.listener.mode[0]}</i>"
+        msg += f"\n┠ <b>Out Mode</b> → <i>{task.listener.mode[1]}</i>"
+        # TODO: Add Bt Sel
+        from ..telegram_helper.bot_commands import BotCommands
+
+        msg += f"\n<b>┖ Stop</b> → <i>/{BotCommands.CancelTaskCommand[1]}_{task.gid()}</i>\n\n"
+
+    if len(msg) == 0:
+        if status == "All":
+            return None, None
+        else:
+            msg = f"No Active {status} Tasks!\n\n"
+
+    msg += "⌬ <b><u>Bot Stats</u></b>"
+    buttons = ButtonMaker()
+    if not is_user:
+        buttons.data_button("📜 TStats", f"status {sid} ov", position="header")
+    if len(tasks) > STATUS_LIMIT:
+        msg += f"<b>Page:</b> {page_no}/{pages} | <b>Tasks:</b> {tasks_no} | <b>Step:</b> {page_step}\n"
+        buttons.data_button("<<", f"status {sid} pre", position="header")
+        buttons.data_button(">>", f"status {sid} nex", position="header")
+        if tasks_no > 30:
+            for i in [1, 2, 4, 6, 8, 10, 15]:
+                buttons.data_button(i, f"status {sid} ps {i}", position="footer")
+    if status != "All" or tasks_no > 20:
+        for label, status_value in list(STATUSES.items()):
+            if status_value != status:
+                buttons.data_button(label, f"status {sid} st {status_value}")
+    buttons.data_button("♻️ Refresh", f"status {sid} ref", position="header")
+    button = buttons.build_menu(8)
+    msg += f"\n┟ <b>CPU</b> → {cpu_percent()}% | <b>F</b> → {get_readable_file_size(disk_usage(DOWNLOAD_DIR).free)} [{round(100 - disk_usage(DOWNLOAD_DIR).percent, 1)}%]"
+    msg += f"\n┖ <b>RAM</b> → {virtual_memory().percent}% | <b>UP</b> → {get_readable_time(time() - bot_start_time)}"
+    return msg, button

bot/helper/ext_utils/task_manager.py

@@ -0,0 +1,296 @@
+from asyncio import Event
+from time import time
+
+from ... import (
+    LOGGER,
+    bot_cache,
+    non_queued_dl,
+    non_queued_up,
+    queue_dict_lock,
+    queued_dl,
+    queued_up,
+    user_data,
+)
+from ...core.config_manager import Config
+from ..mirror_leech_utils.gdrive_utils.search import GoogleDriveSearch
+from ..telegram_helper.filters import CustomFilters
+from ..telegram_helper.tg_utils import check_botpm, forcesub, verify_token
+from .bot_utils import get_telegraph_list, sync_to_async, safe_int
+from .files_utils import get_base_name, check_storage_threshold
+from .links_utils import is_gdrive_id
+from .status_utils import get_readable_time, get_readable_file_size, get_specific_tasks
+
+
+async def stop_duplicate_check(listener):
+    if (
+        isinstance(listener.up_dest, int)
+        or listener.is_leech
+        or listener.select
+        or not is_gdrive_id(listener.up_dest)
+        or (listener.up_dest.startswith("mtp:") and listener.stop_duplicate)
+        or not listener.stop_duplicate
+        or listener.same_dir
+    ):
+        return False, None
+
+    name = listener.name
+    LOGGER.info(f"Checking File/Folder if already in Drive: {name}")
+
+    if listener.compress:
+        name = f"{name}.zip"
+    elif listener.extract:
+        try:
+            name = get_base_name(name)
+        except Exception:
+            name = None
+
+    if name is not None:
+        telegraph_content, contents_no = await sync_to_async(
+            GoogleDriveSearch(stop_dup=True, no_multi=listener.is_clone).drive_list,
+            name,
+            listener.up_dest,
+            listener.user_id,
+        )
+        if telegraph_content:
+            msg = f"File/Folder is already available in Drive.\nHere are {contents_no} list results:"
+            button = await get_telegraph_list(telegraph_content)
+            return msg, button
+
+    return False, None
+
+
+async def check_running_tasks(listener, state="dl"):
+    all_limit = safe_int(Config.QUEUE_ALL)
+    state_limit = (
+        safe_int(Config.QUEUE_DOWNLOAD)
+        if state == "dl"
+        else safe_int(Config.QUEUE_UPLOAD)
+    )
+    event = None
+    is_over_limit = False
+    async with queue_dict_lock:
+        if state == "up" and listener.mid in non_queued_dl:
+            non_queued_dl.remove(listener.mid)
+        if (
+            (all_limit or state_limit)
+            and not listener.force_run
+            and not (listener.force_upload and state == "up")
+            and not (listener.force_download and state == "dl")
+        ):
+            dl_count = len(non_queued_dl)
+            up_count = len(non_queued_up)
+            t_count = dl_count if state == "dl" else up_count
+            is_over_limit = (
+                all_limit
+                and dl_count + up_count >= all_limit
+                and (not state_limit or t_count >= state_limit)
+            ) or (state_limit and t_count >= state_limit)
+            if is_over_limit:
+                event = Event()
+                if state == "dl":
+                    queued_dl[listener.mid] = event
+                else:
+                    queued_up[listener.mid] = event
+        if not is_over_limit:
+            if state == "up":
+                non_queued_up.add(listener.mid)
+            else:
+                non_queued_dl.add(listener.mid)
+
+    return is_over_limit, event
+
+
+async def start_dl_from_queued(mid: int):
+    queued_dl[mid].set()
+    del queued_dl[mid]
+    non_queued_dl.add(mid)
+
+
+async def start_up_from_queued(mid: int):
+    queued_up[mid].set()
+    del queued_up[mid]
+    non_queued_up.add(mid)
+
+
+async def start_from_queued():
+    if all_limit := safe_int(Config.QUEUE_ALL):
+        dl_limit = safe_int(Config.QUEUE_DOWNLOAD)
+        up_limit = safe_int(Config.QUEUE_UPLOAD)
+        async with queue_dict_lock:
+            dl = len(non_queued_dl)
+            up = len(non_queued_up)
+            all_ = dl + up
+            if all_ < all_limit:
+                f_tasks = all_limit - all_
+                if queued_up and (not up_limit or up < up_limit):
+                    for index, mid in enumerate(list(queued_up.keys()), start=1):
+                        await start_up_from_queued(mid)
+                        f_tasks -= 1
+                        if f_tasks == 0 or (up_limit and index >= up_limit - up):
+                            break
+                if queued_dl and (not dl_limit or dl < dl_limit) and f_tasks != 0:
+                    for index, mid in enumerate(list(queued_dl.keys()), start=1):
+                        await start_dl_from_queued(mid)
+                        if (dl_limit and index >= dl_limit - dl) or index == f_tasks:
+                            break
+        return
+
+    if up_limit := Config.QUEUE_UPLOAD:
+        async with queue_dict_lock:
+            up = len(non_queued_up)
+            if queued_up and up < up_limit:
+                f_tasks = up_limit - up
+                for index, mid in enumerate(list(queued_up.keys()), start=1):
+                    await start_up_from_queued(mid)
+                    if index == f_tasks:
+                        break
+    else:
+        async with queue_dict_lock:
+            if queued_up:
+                for mid in list(queued_up.keys()):
+                    await start_up_from_queued(mid)
+
+    if dl_limit := Config.QUEUE_DOWNLOAD:
+        async with queue_dict_lock:
+            dl = len(non_queued_dl)
+            if queued_dl and dl < dl_limit:
+                f_tasks = dl_limit - dl
+                for index, mid in enumerate(list(queued_dl.keys()), start=1):
+                    await start_dl_from_queued(mid)
+                    if index == f_tasks:
+                        break
+    else:
+        async with queue_dict_lock:
+            if queued_dl:
+                for mid in list(queued_dl.keys()):
+                    await start_dl_from_queued(mid)
+
+
+async def limit_checker(listener, yt_playlist=0):
+    LOGGER.info("Checking Size Limit...")
+    if await CustomFilters.sudo("", listener.message):
+        LOGGER.info("SUDO User. Skipping Size Limit...")
+        return
+
+    user_id, size = listener.user_id, listener.size
+
+    async def recurr_limits(limits):
+        nonlocal yt_playlist, size
+        limit_exceeded = ""
+        for condition, attr, name in limits:
+            if condition and (limit := getattr(Config, attr, 0)):
+                if attr == "PLAYLIST_LIMIT":
+                    if yt_playlist >= limit:
+                        limit_exceeded = f"┠ <b>{name} Limit Count</b> → {limit}"
+                else:
+                    byte_limit = limit * 1024**3
+                    if size >= byte_limit:
+                        limit_exceeded = f"┠ <b>{name} Limit</b> → {get_readable_file_size(byte_limit)}"
+
+                LOGGER.info(
+                    f"{name} Limit Breached: {listener.name} & Size: {get_readable_file_size(size)}"
+                )
+                break
+        return limit_exceeded
+
+    limits = [
+        (listener.is_torrent or listener.is_qbit, "TORRENT_LIMIT", "Torrent"),
+        (listener.is_mega, "MEGA_LIMIT", "Mega"),
+        (listener.is_gdrive, "GD_DL_LIMIT", "GDriveDL"),
+        (listener.is_clone, "CLONE_LIMIT", "Clone"),
+        (listener.is_jd, "JD_LIMIT", "JDownloader"),
+        (listener.is_nzb, "NZB_LIMIT", "SABnzbd"),
+        (listener.is_rclone, "RC_DL_LIMIT", "RCloneDL"),
+        (listener.is_ytdlp, "YTDLP_LIMIT", "YT-DLP"),
+        (bool(yt_playlist), "PLAYLIST_LIMIT", "Playlist"),
+        (True, "DIRECT_LIMIT", "Direct"),
+    ]
+    limit_exceeded = await recurr_limits(limits)
+
+    if not limit_exceeded:
+        extra_limits = [
+            (listener.is_leech, "LEECH_LIMIT", "Leech"),
+            (listener.compress, "ARCHIVE_LIMIT", "Archive"),
+            (listener.extract, "EXTRACT_LIMIT", "Extract"),
+        ]
+        limit_exceeded = await recurr_limits(extra_limits)
+
+        if Config.STORAGE_LIMIT and not listener.is_clone:
+            limit = Config.STORAGE_LIMIT * 1024**3
+            if not await check_storage_threshold(
+                size, limit, any([listener.compress, listener.extract])
+            ):
+                limit_exceeded = f"┠ <b>Threshold Storage Limit</b> → {get_readable_file_size(limit)}"
+
+    if limit_exceeded:
+        return limit_exceeded + f"\n┖ <b>Task By</b> → {listener.tag}"
+
+
+"""
+class UsageChecks: # TODO: Dynamic Check for All Task
+
+class DailyUsageChecks:
+"""
+
+
+async def user_interval_check(user_id):
+    bot_cache.setdefault("time_interval", {})
+    if (time_interval := bot_cache["time_interval"].get(user_id, False)) and (
+        time() - time_interval
+    ) < (UTI := Config.USER_TIME_INTERVAL):
+        return UTI - (time() - time_interval)
+    bot_cache["time_interval"][user_id] = time()
+    return None
+
+
+async def pre_task_check(message):
+    LOGGER.info("Running Pre Task Checks ...")
+    msg = []
+    button = None
+    if await CustomFilters.sudo("", message):
+        return msg, button
+    user_id = (message.from_user or message.sender_chat).id
+    if Config.RSS_CHAT and user_id == int(Config.RSS_CHAT):
+        return msg, button
+    user_dict = user_data.get(user_id, {})
+    if message.chat.type != message.chat.type.BOT:
+        if ids := Config.FORCE_SUB_IDS:
+            _msg, button = await forcesub(message, ids, button)
+            if _msg:
+                msg.append(_msg)
+        if Config.BOT_PM or user_dict.get("BOT_PM"):  # or config_dict['SAFE_MODE']:
+            _msg, button = await check_botpm(message, button)
+            if _msg:
+                msg.append(_msg)
+    if (uti := Config.USER_TIME_INTERVAL) and (
+        ut := await user_interval_check(user_id)
+    ):
+        msg.append(
+            f"┠ <b>Waiting Time</b> → {get_readable_time(ut)}\n┠ <i>User's Time Interval Restrictions</i> → {get_readable_time(uti)}"
+        )
+    bmax_tasks = safe_int(user_dict.get("bmax_tasks", Config.BOT_MAX_TASKS))
+    if bmax_tasks > 0 and len(await get_specific_tasks("All", False)) >= bmax_tasks:
+        msg.append(
+            f"┠ Max Concurrent Bot's Tasks Limit exceeded.\n┠ Bot Tasks Limit : {bmax_tasks} task"
+        )
+
+    maxtask = safe_int(user_dict.get("maxtask", Config.USER_MAX_TASKS))
+    if maxtask > 0 and len(await get_specific_tasks("All", user_id)) >= maxtask:
+        msg.append(
+            f"┠ Max Concurrent User's Task(s) Limit exceeded! \n┠ User Task Limit : {maxtask} tasks"
+        )
+
+    token_msg, button = await verify_token(user_id, button)
+    if token_msg is not None:
+        msg.append(token_msg)
+
+    if msg:
+        username = message.from_user.mention
+        final_msg = f"⌬ <b>Task Checks :</b>\n│\n┟ <b>Name</b> → {username}\n┃\n"
+        for i, m_part in enumerate(msg, 1):
+            final_msg += f"{m_part}\n"
+        if button is not None:
+            button = button.build_menu(2)
+        return final_msg, button
+
+    return None, None

bot/helper/ext_utils/telegraph_helper.py

@@ -0,0 +1,85 @@
+from asyncio import sleep
+from secrets import token_hex
+from telegraph.aio import Telegraph
+from telegraph.exceptions import RetryAfterError
+
+from ... import LOGGER
+from ...core.config_manager import Config
+
+
+class TelegraphHelper:
+    def __init__(self, author_name=None, author_url=None):
+        self._telegraph = Telegraph(domain="graph.org")
+        self._author_name = author_name
+        self._author_url = author_url
+
+    async def create_account(self):
+        LOGGER.info("Creating Telegraph Account")
+        try:
+            await self._telegraph.create_account(
+                short_name=token_hex(5),
+                author_name=self._author_name,
+                author_url=self._author_url,
+            )
+        except Exception as e:
+            LOGGER.error(f"Failed to create Telegraph Account: {e}")
+
+    async def create_page(self, title, content):
+        try:
+            return await self._telegraph.create_page(
+                title=title,
+                author_name=self._author_name,
+                author_url=self._author_url,
+                html_content=content,
+            )
+        except RetryAfterError as st:
+            LOGGER.warning(
+                f"Telegraph Flood control exceeded. I will sleep for {st.retry_after} seconds."
+            )
+            await sleep(st.retry_after)
+            return await self.create_page(title, content)
+
+    async def edit_page(self, path, title, content):
+        try:
+            return await self._telegraph.edit_page(
+                path=path,
+                title=title,
+                author_name=self._author_name,
+                author_url=self._author_url,
+                html_content=content,
+            )
+        except RetryAfterError as st:
+            LOGGER.warning(
+                f"Telegraph Flood control exceeded. I will sleep for {st.retry_after} seconds."
+            )
+            await sleep(st.retry_after)
+            return await self.edit_page(path, title, content)
+
+    async def edit_telegraph(self, path, telegraph_content):
+        nxt_page = 1
+        prev_page = 0
+        num_of_path = len(path)
+        for content in telegraph_content:
+            if nxt_page == 1:
+                content += (
+                    f'<b><a href="https://telegra.ph/{path[nxt_page]}">Next</a></b>'
+                )
+                nxt_page += 1
+            else:
+                if prev_page <= num_of_path:
+                    content += f'<b><a href="https://telegra.ph/{path[prev_page]}">Prev</a></b>'
+                    prev_page += 1
+                if nxt_page < num_of_path:
+                    content += f'<b> | <a href="https://telegra.ph/{path[nxt_page]}">Next</a></b>'
+                    nxt_page += 1
+            await self.edit_page(
+                path=path[prev_page],
+                title="WZML-X Torrent Search",
+                content=content,
+            )
+        return
+
+
+telegraph = TelegraphHelper(Config.AUTHOR_NAME, Config.AUTHOR_URL)
+
+print(__name__)

bot/helper/languages/__init__.py

@@ -0,0 +1,43 @@
+from importlib import import_module
+from os import listdir
+
+from ...core.config_manager import Config
+
+LOCALES_DIR = "bot/helper/languages"
+
+
+class Language:
+    _modules = {}
+    _user_langs = {}
+
+    def __init__(self, lang_code=None, user_id=None):
+        self.load_translations()
+        lang_code = lang_code or Config.DEFAULT_LANG
+
+        if user_id:
+            self._user_langs[user_id] = lang_code
+        self.lang_code = self._user_langs.get(
+            user_id, lang_code if lang_code in self._modules else Config.DEFAULT_LANG
+        )
+
+    @classmethod
+    def load_translations(cls):
+        if cls._modules:
+            return cls._modules
+
+        cls._modules = {}
+        for file in listdir(LOCALES_DIR):
+            if file.endswith(".py") and file != "__init__.py":
+                lang_code = file.split(".")[0]
+                cls._modules[lang_code] = import_module(
+                    f"bot.helper.languages.{lang_code}"
+                )
+        return cls._modules
+
+    def __getattr__(self, key):
+        lang_module = self._modules.get(
+            self.lang_code, self._modules[Config.DEFAULT_LANG]
+        )
+        return getattr(
+            lang_module, key, getattr(self._modules[Config.DEFAULT_LANG], key, key)
+        )

bot/helper/languages/bn.py

@@ -0,0 +1,6 @@
+START_MSG = """
+এই বট লিংক | টেলিগ্রাম ফাইল | টরেন্ট | NZB | Rclone-ক্লাউড থেকে যেকোনো Rclone ক্লাউড, গুগল ড্রাইভ বা টেলিগ্রামে মিরর করতে পারে।  
+উপলব্ধ কমান্ডের তালিকা পেতে /{cmd} লিখুন।
+"""
+START_BUTTON1 = "গিট রিপো"
+START_BUTTON2 = "আপডেট"

bot/helper/languages/en.py

@@ -0,0 +1,6 @@
+START_MSG = """
+This bot can mirror from links|tgfiles|torrents|nzb|rclone-cloud to any rclone cloud, Google Drive or to telegram.
+Type /{cmd} to get a list of available commands
+"""
+START_BUTTON1 = "Git Repo"
+START_BUTTON2 = "Updates"

bot/helper/listeners/__init__.py

@@ -0,0 +1 @@
+

bot/helper/listeners/aria2_listener.py

@@ -0,0 +1,199 @@
+from aiofiles.os import remove, path as aiopath
+from asyncio import sleep, TimeoutError
+from time import time
+from contextlib import suppress
+from aiohttp.client_exceptions import ClientError
+
+from ... import task_dict_lock, task_dict, LOGGER, intervals
+from ...core.config_manager import Config
+from ...core.torrent_manager import TorrentManager, is_metadata, aria2_name
+from ..ext_utils.bot_utils import bt_selection_buttons
+from ..ext_utils.files_utils import clean_unwanted
+from ..ext_utils.status_utils import get_task_by_gid
+from ..ext_utils.task_manager import stop_duplicate_check, limit_checker
+from ..mirror_leech_utils.status_utils.aria2_status import Aria2Status
+from ..telegram_helper.message_utils import (
+    send_message,
+    delete_message,
+    update_status_message,
+)
+
+
+async def _on_download_started(api, data):
+    gid = data["params"][0]["gid"]
+    with suppress(TimeoutError, ClientError, Exception):
+        download, options = await api.tellStatus(gid), await api.getOption(gid)
+        if options.get("follow-torrent", "") == "false":
+            return
+    if is_metadata(download):
+        LOGGER.info(f"onDownloadStarted: {gid} METADATA")
+        await sleep(1)
+        if task := await get_task_by_gid(gid):
+            task.listener.is_torrent = True
+            if task.listener.select:
+                metamsg = "Downloading Metadata, wait then you can select files. Use torrent file to avoid this wait."
+                meta = await send_message(task.listener.message, metamsg)
+                while True:
+                    await sleep(0.5)
+                    if download.get("status", "") == "removed" or download.get(
+                        "followedBy", []
+                    ):
+                        await delete_message(meta)
+                        break
+                    download = await api.tellStatus(gid)
+        return
+    else:
+        LOGGER.info(f"onDownloadStarted: {aria2_name(download)} - Gid: {gid}")
+        await sleep(1)
+
+    await sleep(2)
+    if task := await get_task_by_gid(gid):
+        download = await api.tellStatus(gid)
+        if "bittorrent" in download:
+            task.listener.is_torrent = True
+
+        task.listener.name = aria2_name(download)
+        msg, button = await stop_duplicate_check(task.listener)
+        if msg:
+            await TorrentManager.aria2_remove(download)
+            await task.listener.on_download_error(msg, button)
+            return
+
+        task.listener.size = int(download.get("totalLength", "0"))
+        mmsg = await limit_checker(task.listener)
+        if mmsg:
+            await TorrentManager.aria2_remove(download)
+            await task.listener.on_download_error(mmsg, is_limit=True)
+            return
+
+
+async def _on_download_complete(api, data):
+    try:
+        gid = data["params"][0]["gid"]
+        download, options = await api.tellStatus(gid), await api.getOption(gid)
+        if options.get("follow-torrent", "") == "false":
+            return
+    except (TimeoutError, ClientError, Exception) as e:
+        LOGGER.error(f"onDownloadComplete: {e}")
+        return
+    if download.get("followedBy", []):
+        new_gid = download.get("followedBy", [])[0]
+        LOGGER.info(f"Gid changed from {gid} to {new_gid}")
+        if task := await get_task_by_gid(new_gid):
+            task.listener.is_torrent = True
+            if Config.BASE_URL and task.listener.select:
+                if not task.queued:
+                    await api.forcePause(new_gid)
+                SBUTTONS = bt_selection_buttons(new_gid)
+                msg = "Download paused. Choose files then press Done Selecting button to start downloading."
+                await send_message(task.listener.message, msg, SBUTTONS)
+    elif "bittorrent" in download:
+        if task := await get_task_by_gid(gid):
+            task.listener.is_torrent = True
+            if hasattr(task, "seeding") and task.seeding:
+                LOGGER.info(
+                    f"Cancelling Seed: {aria2_name(download)} onDownloadComplete"
+                )
+                await TorrentManager.aria2_remove(download)
+                await task.listener.on_upload_error(
+                    f"Seeding stopped with Ratio: {task.ratio()} and Time: {task.seeding_time()}"
+                )
+    else:
+        LOGGER.info(f"onDownloadComplete: {aria2_name(download)} - Gid: {gid}")
+        if task := await get_task_by_gid(gid):
+            await task.listener.on_download_complete()
+            if intervals["stopAll"]:
+                return
+            await TorrentManager.aria2_remove(download)
+
+
+async def _on_bt_download_complete(api, data):
+    gid = data["params"][0]["gid"]
+    await sleep(1)
+    download = await api.tellStatus(gid)
+    LOGGER.info(f"onBtDownloadComplete: {aria2_name(download)} - Gid: {gid}")
+    if task := await get_task_by_gid(gid):
+        task.listener.is_torrent = True
+        if task.listener.select:
+            res = download.get("files", [])
+            for file_o in res:
+                f_path = file_o.get("path", "")
+                if file_o.get("selected", "") != "true" and await aiopath.exists(
+                    f_path
+                ):
+                    with suppress(Exception):
+                        await remove(f_path)
+            await clean_unwanted(download.get("dir", ""))
+        if task.listener.seed:
+            try:
+                await api.changeOption(gid, {"max-upload-limit": "0"})
+            except (TimeoutError, ClientError, Exception) as e:
+                LOGGER.error(
+                    f"{e} You are not able to seed because you added global option seed-time=0 without adding specific seed_time for this torrent GID: {gid}"
+                )
+        else:
+            try:
+                await api.forcePause(gid)
+            except (TimeoutError, ClientError, Exception) as e:
+                LOGGER.error(f"onBtDownloadComplete: {e} GID: {gid}")
+        await task.listener.on_download_complete()
+        if intervals["stopAll"]:
+            return
+        download = await api.tellStatus(gid)
+        if (
+            task.listener.seed
+            and download.get("status", "") == "complete"
+            and await get_task_by_gid(gid)
+        ):
+            LOGGER.info(f"Cancelling Seed: {aria2_name(download)}")
+            await TorrentManager.aria2_remove(download)
+            await task.listener.on_upload_error(
+                f"Seeding stopped with Ratio: {task.ratio()} and Time: {task.seeding_time()}"
+            )
+        elif (
+            task.listener.seed
+            and download.get("status", "") == "complete"
+            and not await get_task_by_gid(gid)
+        ):
+            pass
+        elif task.listener.seed and not task.listener.is_cancelled:
+            async with task_dict_lock:
+                if task.listener.mid not in task_dict:
+                    await TorrentManager.aria2_remove(download)
+                    return
+                task_dict[task.listener.mid] = Aria2Status(task.listener, gid, True)
+                task_dict[task.listener.mid].start_time = time()
+            LOGGER.info(f"Seeding started: {aria2_name(download)} - Gid: {gid}")
+            await update_status_message(task.listener.message.chat.id)
+        else:
+            await TorrentManager.aria2_remove(download)
+
+
+async def _on_download_stopped(_, data):
+    gid = data["params"][0]["gid"]
+    await sleep(4)
+    if task := await get_task_by_gid(gid):
+        await task.listener.on_download_error("Dead torrent!")
+
+
+async def _on_download_error(api, data):
+    gid = data["params"][0]["gid"]
+    await sleep(1)
+    LOGGER.info(f"onDownloadError: {gid}")
+    error = "None"
+    with suppress(TimeoutError, ClientError, Exception):
+        download, options = await api.tellStatus(gid), await api.getOption(gid)
+        error = download.get("errorMessage", "")
+        LOGGER.info(f"Download Error: {error}")
+        if options.get("follow-torrent", "") == "false":
+            return
+    if task := await get_task_by_gid(gid):
+        await task.listener.on_download_error(error)
+
+
+def add_aria2_callbacks():
+    TorrentManager.aria2.onBtDownloadComplete(_on_bt_download_complete)
+    TorrentManager.aria2.onDownloadComplete(_on_download_complete)
+    TorrentManager.aria2.onDownloadError(_on_download_error)
+    TorrentManager.aria2.onDownloadStart(_on_download_started)
+    TorrentManager.aria2.onDownloadStop(_on_download_stopped)

bot/helper/listeners/direct_listener.py

@@ -0,0 +1,86 @@
+from asyncio import sleep, TimeoutError
+from aiohttp.client_exceptions import ClientError
+
+from ... import LOGGER
+from ...core.torrent_manager import TorrentManager, aria2_name
+
+
+class DirectListener:
+    def __init__(self, path, listener, a2c_opt):
+        self.listener = listener
+        self._path = path
+        self._a2c_opt = a2c_opt
+        self._proc_bytes = 0
+        self._failed = 0
+        self.download_task = None
+        self.name = self.listener.name
+
+    @property
+    def processed_bytes(self):
+        if self.download_task:
+            return self._proc_bytes + int(
+                self.download_task.get("completedLength", "0")
+            )
+        return self._proc_bytes
+
+    @property
+    def speed(self):
+        return (
+            int(self.download_task.get("downloadSpeed", "0"))
+            if self.download_task
+            else 0
+        )
+
+    async def download(self, contents):
+        self.is_downloading = True
+        for content in contents:
+            if self.listener.is_cancelled:
+                break
+            if content["path"]:
+                self._a2c_opt["dir"] = f"{self._path}/{content['path']}"
+            else:
+                self._a2c_opt["dir"] = self._path
+            filename = content["filename"]
+            self._a2c_opt["out"] = filename
+            try:
+                gid = await TorrentManager.aria2.addUri(
+                    uris=[content["url"]], options=self._a2c_opt, position=0
+                )
+            except (TimeoutError, ClientError, Exception) as e:
+                self._failed += 1
+                LOGGER.error(f"Unable to download {filename} due to: {e}")
+                continue
+            self.download_task = await TorrentManager.aria2.tellStatus(gid)
+            while True:
+                if self.listener.is_cancelled:
+                    if self.download_task:
+                        await TorrentManager.aria2_remove(self.download_task)
+                    break
+                self.download_task = await TorrentManager.aria2.tellStatus(gid)
+                if error_message := self.download_task.get("errorMessage"):
+                    self._failed += 1
+                    LOGGER.error(
+                        f"Unable to download {aria2_name(self.download_task)} due to: {error_message}"
+                    )
+                    await TorrentManager.aria2_remove(self.download_task)
+                    break
+                elif self.download_task.get("status", "") == "complete":
+                    self._proc_bytes += int(self.download_task.get("totalLength", "0"))
+                    await TorrentManager.aria2_remove(self.download_task)
+                    break
+                await sleep(1)
+            self.download_task = None
+        if self.listener.is_cancelled:
+            return
+        if self._failed == len(contents):
+            await self.listener.on_download_error("All files are failed to download!")
+            return
+        await self.listener.on_download_complete()
+        return
+
+    async def cancel_task(self):
+        self.listener.is_cancelled = True
+        LOGGER.info(f"Cancelling Download: {self.listener.name}")
+        await self.listener.on_download_error("Download Cancelled by User!")
+        if self.download_task:
+            await TorrentManager.aria2_remove(self.download_task)

bot/helper/listeners/jdownloader_listener.py

@@ -0,0 +1,91 @@
+from asyncio import sleep
+
+from ... import intervals, jd_listener_lock, jd_downloads
+from ..ext_utils.bot_utils import new_task
+from ...core.jdownloader_booter import jdownloader
+from ..ext_utils.status_utils import get_task_by_gid
+
+
+@new_task
+async def remove_download(gid):
+    if intervals["stopAll"]:
+        return
+    await jdownloader.device.downloads.remove_links(
+        package_ids=jd_downloads[gid]["ids"]
+    )
+    if task := await get_task_by_gid(gid):
+        await task.listener.on_download_error("Download removed manually!")
+        async with jd_listener_lock:
+            del jd_downloads[gid]
+
+
+@new_task
+async def _on_download_complete(gid):
+    if task := await get_task_by_gid(gid):
+        if task.listener.select:
+            async with jd_listener_lock:
+                await jdownloader.device.downloads.cleanup(
+                    "DELETE_DISABLED",
+                    "REMOVE_LINKS_AND_DELETE_FILES",
+                    "ALL",
+                    package_ids=jd_downloads[gid]["ids"],
+                )
+        await task.listener.on_download_complete()
+        if intervals["stopAll"]:
+            return
+        async with jd_listener_lock:
+            if gid in jd_downloads:
+                await jdownloader.device.downloads.remove_links(
+                    package_ids=jd_downloads[gid]["ids"],
+                )
+                del jd_downloads[gid]
+
+
+@new_task
+async def _jd_listener():
+    while True:
+        await sleep(3)
+        async with jd_listener_lock:
+            if len(jd_downloads) == 0:
+                intervals["jd"] = ""
+                break
+            try:
+                packages = await jdownloader.device.downloads.query_packages(
+                    [{"finished": True, "saveTo": True}]
+                )
+            except Exception:
+                continue
+
+            all_packages = {pack["uuid"]: pack for pack in packages}
+            for d_gid, d_dict in list(jd_downloads.items()):
+                if d_dict["status"] == "down":
+                    for index, pid in enumerate(d_dict["ids"]):
+                        if pid not in all_packages:
+                            del jd_downloads[d_gid]["ids"][index]
+                    if len(jd_downloads[d_gid]["ids"]) == 0:
+                        path = jd_downloads[d_gid]["path"]
+                        jd_downloads[d_gid]["ids"] = [
+                            uid
+                            for uid, pk in all_packages.items()
+                            if pk["saveTo"].startswith(path)
+                        ]
+                    if len(jd_downloads[d_gid]["ids"]) == 0:
+                        await remove_download(d_gid)
+
+            if completed_packages := [
+                pack["uuid"] for pack in packages if pack.get("finished", False)
+            ]:
+                for d_gid, d_dict in list(jd_downloads.items()):
+                    if d_dict["status"] == "down":
+                        is_finished = all(
+                            did in completed_packages for did in d_dict["ids"]
+                        )
+                        if is_finished:
+                            jd_downloads[d_gid]["status"] = "done"
+                            await _on_download_complete(d_gid)
+
+
+async def on_download_start():
+    async with jd_listener_lock:
+        if not intervals["jd"]:
+            intervals["jd"] = await _jd_listener()

bot/helper/listeners/mega_listener.py

@@ -0,0 +1,282 @@
+from time import time
+from secrets import token_hex
+from aiofiles.os import makedirs
+from asyncio import create_subprocess_exec, subprocess, wait_for
+from re import search as re_search
+from contextlib import suppress
+
+from ... import LOGGER, task_dict, task_dict_lock
+from ...core.config_manager import Config
+from ..ext_utils.status_utils import MirrorStatus
+from ..ext_utils.bot_utils import cmd_exec
+from ..ext_utils.task_manager import (
+    check_running_tasks,
+    stop_duplicate_check,
+    limit_checker,
+)
+from ..mirror_leech_utils.status_utils.mega_status import MegaDownloadStatus
+from ..mirror_leech_utils.status_utils.queue_status import QueueStatus
+from ..telegram_helper.message_utils import send_status_message
+
+
+mega_tasks = {}
+
+
+async def mega_cleanup():
+    if not mega_tasks:
+        return
+    LOGGER.info("Running Mega Cleanup...")
+    for path in list(mega_tasks.values()):
+        try:
+            await cmd_exec(["mega-rm", "-r", "-f", path])
+        except Exception as e:
+            LOGGER.error(f"Mega Restart Cleanup Failed for {path}: {e}")
+    mega_tasks.clear()
+
+
+class MegaAppListener:
+    def __init__(self, listener):
+        self.listener = listener
+        self.process = None
+        self.gid = token_hex(5)
+        self.mega_status = None
+        self.name = ""
+        self.size = 0
+        self.temp_path = f"/wzml_{self.gid}"
+        self.mega_tags = set()
+        self._is_cleaned = False
+        self._last_time = time()
+        self._val_last = 0
+        mega_tasks[self.gid] = self.temp_path
+
+    async def login(self):
+        if (MEGA_EMAIL := Config.MEGA_EMAIL) and (
+            MEGA_PASSWORD := Config.MEGA_PASSWORD
+        ):
+            try:
+                await cmd_exec(["mega-login", MEGA_EMAIL, MEGA_PASSWORD])
+            except Exception as e:
+                raise Exception(f"Mega Login Failed: {e}")
+        else:
+            raise Exception("MegaCMD: Credentials Missing! Login required")
+
+    async def create_temp_path(self):
+        await cmd_exec(["mega-mkdir", self.temp_path])
+
+    async def import_link(self):
+        stdout, stderr, ret = await cmd_exec(
+            ["mega-import", self.listener.link, self.temp_path]
+        )
+        if ret != 0:
+            raise Exception(f"Mega Import Failed: {stderr}")
+
+    async def get_metadata_and_target(self):
+        stdout, _, ret = await cmd_exec(["mega-ls", "-l", self.temp_path])
+        if ret != 0 or not stdout:
+            raise Exception("Mega Metadata Failed")
+
+        lines = [line for line in stdout.strip().split("\n") if line.strip()]
+        if not lines:
+            raise Exception("Mega Import: No items found")
+
+        for line in lines:
+            match = re_search(r"\s(\d+|-)\s+\S+\s+\d{2}:\d{2}:\d{2}\s+(.*)$", line)
+            if match:
+                size_str = match.group(1)
+                self.name = match.group(2).strip()
+                self.size = int(size_str) if size_str.isdigit() else 0
+                break
+
+        if not self.name:
+            s_stdout, _, _ = await cmd_exec(["mega-ls", self.temp_path])
+            if s_stdout:
+                self.name = s_stdout.strip().split("\n")[0].strip()
+
+        if not self.name:
+            self.name = self.listener.name or f"MEGA_Download_{self.gid}"
+
+        self.listener.name = self.name
+        self.listener.size = self.size
+
+        return f"{self.temp_path}/{self.name}"
+
+    async def cleanup(self):
+        if self._is_cleaned:
+            return
+        self._is_cleaned = True
+        try:
+            LOGGER.info(f"Cleaning up Mega Task: {self.name}")
+            await cmd_exec(["mega-rm", "-r", "-f", self.temp_path])
+            if self.gid in mega_tasks:
+                del mega_tasks[self.gid]
+        except Exception as e:
+            LOGGER.error(f"Mega Cleanup Failed: {e}")
+
+    async def download(self, path):
+        try:
+            await self.login()
+            await self.create_temp_path()
+            await self.import_link()
+            target_node = await self.get_metadata_and_target()
+
+            msg, button = await stop_duplicate_check(self.listener)
+            if msg:
+                await self.listener.on_download_error(msg, button)
+                return
+
+            if limit_exceeded := await limit_checker(self.listener):
+                await self.listener.on_download_error(limit_exceeded, is_limit=True)
+                return
+
+            added_to_queue, event = await check_running_tasks(self.listener)
+            if added_to_queue:
+                LOGGER.info(f"Added to Queue/Download: {self.name}")
+                async with task_dict_lock:
+                    task_dict[self.listener.mid] = QueueStatus(
+                        self.listener, self.gid, "Dl"
+                    )
+                await self.listener.on_download_start()
+                if self.listener.multi <= 1:
+                    await send_status_message(self.listener.message)
+                await event.wait()
+                if self.listener.is_cancelled:
+                    return
+
+            self.mega_status = MegaDownloadStatus(
+                self.listener, self, self.gid, MirrorStatus.STATUS_DOWNLOAD
+            )
+            async with task_dict_lock:
+                task_dict[self.listener.mid] = self.mega_status
+
+            if added_to_queue:
+                LOGGER.info(f"Start Queued Download from Mega: {self.name}")
+            else:
+                LOGGER.info(f"Download from Mega: {self.name}")
+                await self.listener.on_download_start()
+                if self.listener.multi <= 1:
+                    await send_status_message(self.listener.message)
+
+            await makedirs(path, exist_ok=True)
+
+            command = ["mega-get", target_node, path]
+
+            self.process = await create_subprocess_exec(
+                *command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+            )
+
+            while True:
+                if self.listener.is_cancelled:
+                    break
+
+                try:
+                    line_bytes = await wait_for(
+                        self.process.stdout.readuntil(b"\r"), timeout=5
+                    )
+                    line = line_bytes.decode().strip()
+                    if not line:
+                        if self.process.returncode is not None:
+                            break
+                        continue
+                    self._parse_progress(line)
+                except TimeoutError:
+                    await self.update_daemon_status()
+                    if self.process.returncode is not None:
+                        break
+                    continue
+                except Exception:
+                    break
+
+                if self.process.returncode is not None:
+                    break
+
+            await self.process.wait()
+
+            if self.process.returncode == 0:
+                await self.cleanup()
+                await self.listener.on_download_complete()
+            else:
+                if self.listener.is_cancelled:
+                    return
+                if self.process.returncode != -9:
+                    await self.listener.on_download_error(
+                        f"MegaCMD exited with {self.process.returncode}"
+                    )
+        except Exception as e:
+            if self.listener.is_cancelled:
+                return
+            LOGGER.error(f"Mega Download Logic Error: {e}")
+            await self.listener.on_download_error(str(e))
+        finally:
+            await self.cleanup()
+
+    def _parse_progress(self, line):
+        multipliers = {"K": 1024, "M": 1024**2, "G": 1024**3, "T": 1024**4, "B": 1}
+        match = re_search(r"\(([\d\.]+)/([\d\.]+)\s([KMGT]?B)", line)
+        if match:
+            dl_val = float(match.group(1))
+            unit_char = (match.group(3))[0].upper()
+            mult = multipliers.get(unit_char, 1)
+            self.mega_status._downloaded_bytes = int(dl_val * mult)
+
+            if not self.listener.size or self.listener.size == 0:
+                total_val = float(match.group(2))
+                self.mega_status._size = int(total_val * mult)
+                self.listener.size = self.mega_status._size
+
+            cur_time = time()
+            if cur_time - self._last_time >= 2:
+                self.mega_status._speed = int(
+                    (self.mega_status._downloaded_bytes - self._val_last)
+                    / (cur_time - self._last_time)
+                )
+                self._last_time = cur_time
+                self._val_last = self.mega_status._downloaded_bytes
+
+    async def update_daemon_status(self):
+        try:
+            stdout, _, _ = await cmd_exec(["mega-transfers", "--col-separator=|"])
+            for line in stdout.splitlines():
+                if self.gid in line:
+                    parts = line.split("|")
+                    if len(parts) > 1:
+                        self.mega_tags.add(parts[1].strip())
+                        if len(parts) > 4:
+                            status = parts[5].strip().capitalize()
+                            if self.mega_status._status != "Downloading":
+                                self.mega_status._status = status
+        except Exception:
+            pass
+
+    async def cancel_task(self):
+        LOGGER.info(f"Cancelling {self.mega_status._status}: {self.name}")
+        self.listener.is_cancelled = True
+
+        await self.update_daemon_status()
+
+        for tag in self.mega_tags:
+            try:
+                LOGGER.info(f"Cancelling Transfer Tag: {tag}")
+                await cmd_exec(["mega-transfers", "-c", tag])
+            except Exception as e:
+                LOGGER.error(f"Mega Transfer Cancel Failed for {tag}: {e}")
+
+        try:
+            stdout, _, _ = await cmd_exec(["mega-transfers"])
+            for line in stdout.splitlines():
+                if self.gid in line:
+                    parts = line.split()
+                    if (
+                        len(parts) > 1
+                        and (tag := parts[1])
+                        and tag not in self.mega_tags
+                    ):
+                        LOGGER.info(f"Cancelling Straggler Tag: {tag}")
+                        await cmd_exec(["mega-transfers", "-c", tag])
+        except Exception as e:
+            LOGGER.error(f"Mega Final Cancel Check Failed: {e}")
+
+        if self.process is not None:
+            with suppress(Exception):
+                self.process.kill()

bot/helper/listeners/nzb_listener.py

@@ -0,0 +1,117 @@
+from asyncio import sleep, gather
+
+from ... import (
+    intervals,
+    sabnzbd_client,
+    nzb_jobs,
+    nzb_listener_lock,
+    LOGGER,
+)
+from ..ext_utils.bot_utils import new_task
+from ..ext_utils.status_utils import get_task_by_gid, get_raw_file_size
+from ..ext_utils.task_manager import stop_duplicate_check, limit_checker
+
+
+async def _remove_job(nzo_id, mid):
+    res1, _ = await gather(
+        sabnzbd_client.delete_history(nzo_id, delete_files=True),
+        sabnzbd_client.delete_category(f"{mid}"),
+    )
+    if not res1:
+        await sabnzbd_client.delete_job(nzo_id, True)
+    async with nzb_listener_lock:
+        if nzo_id in nzb_jobs:
+            del nzb_jobs[nzo_id]
+
+
+@new_task
+async def _on_download_error(err, nzo_id, button=None, is_limit=False):
+    if task := await get_task_by_gid(nzo_id):
+        LOGGER.info(f"Cancelling Download: {task.name()}")
+        await gather(
+            task.listener.on_download_error(err, button, is_limit),
+            _remove_job(nzo_id, task.listener.mid),
+        )
+
+
+@new_task
+async def _stop_duplicate(nzo_id):
+    if task := await get_task_by_gid(nzo_id):
+        await task.update()
+        task.listener.name = task.name()
+        msg, button = await stop_duplicate_check(task.listener)
+        if msg:
+            await _on_download_error(msg, nzo_id, button)
+
+
+@new_task
+async def _size_check(nzo_id):
+    if task := await get_task_by_gid(nzo_id):
+        await task.update()
+        task.listener.size = get_raw_file_size(task.size())
+        mmsg = await limit_checker(task.listener)
+        if mmsg:
+            await _on_download_error(mmsg, nzo_id, is_limit=True)
+
+
+@new_task
+async def _on_download_complete(nzo_id):
+    if task := await get_task_by_gid(nzo_id):
+        await task.listener.on_download_complete()
+        if intervals["stopAll"]:
+            return
+        await _remove_job(nzo_id, task.listener.mid)
+
+
+@new_task
+async def _nzb_listener():
+    while not intervals["stopAll"]:
+        async with nzb_listener_lock:
+            try:
+                jobs = (await sabnzbd_client.get_history())["history"]["slots"]
+                downloads = (await sabnzbd_client.get_downloads())["queue"]["slots"]
+                if len(nzb_jobs) == 0:
+                    intervals["nzb"] = ""
+                    break
+                for job in jobs:
+                    nzo_id = job["nzo_id"]
+                    if nzo_id not in nzb_jobs:
+                        continue
+                    if job["status"] == "Completed":
+                        if not nzb_jobs[nzo_id]["uploaded"]:
+                            nzb_jobs[nzo_id]["uploaded"] = True
+                            await _on_download_complete(nzo_id)
+                            nzb_jobs[nzo_id]["status"] = "Completed"
+                    elif job["status"] == "Failed":
+                        await _on_download_error(job["fail_message"], nzo_id)
+                for dl in downloads:
+                    nzo_id = dl["nzo_id"]
+                    if nzo_id not in nzb_jobs:
+                        continue
+                    if dl["labels"] and dl["labels"][0] == "ALTERNATIVE":
+                        await _on_download_error("Duplicated Job!", nzo_id)
+                        continue
+                    if dl["status"] == "Downloading" and not dl["filename"].startswith(
+                        "Trying"
+                    ):
+                        if not nzb_jobs[nzo_id]["stop_dup_check"]:
+                            nzb_jobs[nzo_id]["stop_dup_check"] = True
+                            await _stop_duplicate(nzo_id)
+                        if not nzb_jobs[nzo_id]["size_check"]:
+                            nzb_jobs[nzo_id]["size_check"] = True
+                            await _size_check(nzo_id)
+            except Exception as e:
+                LOGGER.error(str(e))
+        await sleep(3)
+
+
+async def on_download_start(nzo_id):
+    async with nzb_listener_lock:
+        nzb_jobs[nzo_id] = {
+            "uploaded": False,
+            "stop_dup_check": False,
+            "size_check": False,
+            "status": "Downloading",
+        }
+        if not intervals["nzb"]:
+            intervals["nzb"] = await _nzb_listener()

bot/helper/listeners/qbit_listener.py

@@ -0,0 +1,222 @@
+from aiofiles.os import remove, path as aiopath
+from asyncio import sleep, TimeoutError
+from time import time
+from aiohttp.client_exceptions import ClientError
+from aioqbt.exc import AQError
+
+from ... import (
+    task_dict,
+    task_dict_lock,
+    intervals,
+    qb_torrents,
+    qb_listener_lock,
+    LOGGER,
+)
+from ...core.config_manager import Config
+from ...core.torrent_manager import TorrentManager
+from ..ext_utils.bot_utils import new_task
+from ..ext_utils.files_utils import clean_unwanted
+from ..ext_utils.status_utils import get_readable_time, get_task_by_gid
+from ..ext_utils.task_manager import stop_duplicate_check, limit_checker
+from ..mirror_leech_utils.status_utils.qbit_status import QbittorrentStatus
+from ..telegram_helper.message_utils import update_status_message
+
+
+async def _remove_torrent(hash_, tag):
+    await TorrentManager.qbittorrent.torrents.delete([hash_], True)
+    async with qb_listener_lock:
+        if tag in qb_torrents:
+            del qb_torrents[tag]
+    await TorrentManager.qbittorrent.torrents.delete_tags([tag])
+
+
+@new_task
+async def _on_download_error(err, tor, button=None, is_limit=False):
+    LOGGER.info(f"Cancelling Download: {tor.name}")
+    ext_hash = tor.hash
+    if task := await get_task_by_gid(ext_hash[:12]):
+        await task.listener.on_download_error(err, button, is_limit)
+    await TorrentManager.qbittorrent.torrents.stop([ext_hash])
+    await sleep(0.3)
+    await _remove_torrent(ext_hash, tor.tags[0])
+
+
+@new_task
+async def _on_seed_finish(tor):
+    ext_hash = tor.hash
+    LOGGER.info(f"Cancelling Seed: {tor.name}")
+    if task := await get_task_by_gid(ext_hash[:12]):
+        msg = f"Seeding stopped with Ratio: {round(tor.ratio, 3)} and Time: {get_readable_time(int(tor.seeding_time.total_seconds() or "0"))}"
+        await task.listener.on_upload_error(msg)
+    await _remove_torrent(ext_hash, tor.tags[0])
+
+
+@new_task
+async def _stop_duplicate(tor):
+    if task := await get_task_by_gid(tor.hash[:12]):
+        if task.listener.stop_duplicate:
+            task.listener.name = tor.content_path.rsplit("/", 1)[-1].rsplit(".!qB", 1)[
+                0
+            ]
+            msg, button = await stop_duplicate_check(task.listener)
+            if msg:
+                await _on_download_error(msg, tor, button)
+
+
+@new_task
+async def _size_check(tor):
+    if task := await get_task_by_gid(tor.hash[:12]):
+        task.listener.size = tor.size
+        mmsg = await limit_checker(task.listener)
+        if mmsg:
+            await _on_download_error(mmsg, tor, is_limit=True)
+
+
+@new_task
+async def _on_download_complete(tor):
+    ext_hash = tor.hash
+    tag = tor.tags[0]
+    if task := await get_task_by_gid(ext_hash[:12]):
+        if not task.listener.seed:
+            await TorrentManager.qbittorrent.torrents.stop([ext_hash])
+        if task.listener.select:
+            await clean_unwanted(task.listener.dir)
+            path = tor.content_path.rsplit("/", 1)[0]
+            res = await TorrentManager.qbittorrent.torrents.files(ext_hash)
+            for f in res:
+                if f.priority == 0 and await aiopath.exists(f"{path}/{f.name}"):
+                    try:
+                        await remove(f"{path}/{f.name}")
+                    except Exception:
+                        pass
+        await task.listener.on_download_complete()
+        if intervals["stopAll"]:
+            return
+        if task.listener.seed and not task.listener.is_cancelled:
+            async with task_dict_lock:
+                if task.listener.mid in task_dict:
+                    removed = False
+                    task_dict[task.listener.mid] = QbittorrentStatus(
+                        task.listener, True
+                    )
+                else:
+                    removed = True
+            if removed:
+                await _remove_torrent(ext_hash, tag)
+                return
+            async with qb_listener_lock:
+                if tag in qb_torrents:
+                    qb_torrents[tag]["seeding"] = True
+                else:
+                    return
+            await update_status_message(task.listener.message.chat.id)
+            LOGGER.info(f"Seeding started: {tor.name} - Hash: {ext_hash}")
+        else:
+            await _remove_torrent(ext_hash, tag)
+    else:
+        await _remove_torrent(ext_hash, tag)
+
+
+@new_task
+async def _qb_listener():
+    while True:
+        async with qb_listener_lock:
+            try:
+                torrents = await TorrentManager.qbittorrent.torrents.info()
+                if len(torrents) == 0:
+                    intervals["qb"] = ""
+                    break
+                for tor_info in torrents:
+                    tag = tor_info.tags[0]
+                    if tag not in qb_torrents:
+                        continue
+                    state = tor_info.state
+                    if state == "metaDL":
+                        qb_torrents[tag]["stalled_time"] = time()
+                        if (
+                            Config.TORRENT_TIMEOUT
+                            and time() - qb_torrents[tag]["start_time"]
+                            >= Config.TORRENT_TIMEOUT
+                        ):
+                            await _on_download_error("Dead Torrent!", tor_info)
+                        else:
+                            await TorrentManager.qbittorrent.torrents.reannounce(
+                                [tor_info.hash]
+                            )
+                    elif state == "downloading":
+                        qb_torrents[tag]["stalled_time"] = time()
+                        if not qb_torrents[tag]["stop_dup_check"]:
+                            qb_torrents[tag]["stop_dup_check"] = True
+                            await _stop_duplicate(tor_info)
+                        if not qb_torrents[tag]["size_check"]:
+                            qb_torrents[tag]["size_check"] = True
+                            await _size_check(tor_info)
+                    elif state == "stalledDL":
+                        if (
+                            not qb_torrents[tag]["rechecked"]
+                            and 0.99989999999999999 < tor_info.progress < 1
+                        ):
+                            msg = f"Force recheck - Name: {tor_info.name} Hash: "
+                            msg += f"{tor_info.hash} Downloaded Bytes: {tor_info.downloaded} "
+                            msg += f"Size: {tor_info.size} Total Size: {tor_info.total_size}"
+                            LOGGER.warning(msg)
+                            await TorrentManager.qbittorrent.torrents.recheck(
+                                [tor_info.hash]
+                            )
+                            qb_torrents[tag]["rechecked"] = True
+                        elif (
+                            Config.TORRENT_TIMEOUT
+                            and time() - qb_torrents[tag]["stalled_time"]
+                            >= Config.TORRENT_TIMEOUT
+                        ):
+                            await _on_download_error("Dead Torrent!", tor_info)
+                        else:
+                            await TorrentManager.qbittorrent.torrents.reannounce(
+                                [tor_info.hash]
+                            )
+                    elif state == "missingFiles":
+                        await TorrentManager.qbittorrent.torrents.recheck(
+                            [tor_info.hash]
+                        )
+                    elif state == "error":
+                        await _on_download_error(
+                            "No enough space for this torrent on device", tor_info
+                        )
+                    elif (
+                        int(tor_info.completion_on.timestamp()) != -1
+                        and not qb_torrents[tag]["uploaded"]
+                        and state
+                        in [
+                            "queuedUP",
+                            "stalledUP",
+                            "uploading",
+                            "forcedUP",
+                        ]
+                    ):
+                        qb_torrents[tag]["uploaded"] = True
+                        await _on_download_complete(tor_info)
+                    elif (
+                        state in ["stoppedUP", "stoppedDL"]
+                        and qb_torrents[tag]["seeding"]
+                    ):
+                        qb_torrents[tag]["seeding"] = False
+                        await _on_seed_finish(tor_info)
+                        await sleep(0.5)
+            except (ClientError, TimeoutError, Exception, AQError) as e:
+                LOGGER.error(str(e))
+        await sleep(3)
+
+
+async def on_download_start(tag):
+    async with qb_listener_lock:
+        qb_torrents[tag] = {
+            "start_time": time(),
+            "stalled_time": time(),
+            "stop_dup_check": False,
+            "size_check": False,
+            "rechecked": False,
+            "uploaded": False,
+            "seeding": False,
+        }
+        if not intervals["qb"]:
+            intervals["qb"] = await _qb_listener()

bot/helper/listeners/task_listener.py

@@ -0,0 +1,674 @@
+from asyncio import gather, sleep
+from html import escape
+from time import time
+from mimetypes import guess_type
+from contextlib import suppress
+from os import path as ospath
+
+from aiofiles.os import listdir, remove, path as aiopath
+from requests import utils as rutils
+
+from ... import (
+    intervals,
+    task_dict,
+    task_dict_lock,
+    LOGGER,
+    non_queued_up,
+    non_queued_dl,
+    queued_up,
+    queued_dl,
+    queue_dict_lock,
+    same_directory_lock,
+    DOWNLOAD_DIR,
+)
+from ...modules.metadata import apply_metadata_title
+from ..common import TaskConfig
+from ...core.tg_client import TgClient
+from ...core.config_manager import Config
+from ...core.torrent_manager import TorrentManager
+from ..ext_utils.bot_utils import sync_to_async
+from ..ext_utils.links_utils import encode_slink
+from ..ext_utils.db_handler import database
+from ..ext_utils.files_utils import (
+    clean_download,
+    clean_target,
+    create_recursive_symlink,
+    get_path_size,
+    join_files,
+    remove_excluded_files,
+    move_and_merge,
+)
+from ..ext_utils.links_utils import is_gdrive_id
+from ..ext_utils.status_utils import get_readable_file_size, get_readable_time
+from ..ext_utils.task_manager import check_running_tasks, start_from_queued
+from ..mirror_leech_utils.uphoster_utils.gofile_utils.upload import GoFileUpload
+from ..mirror_leech_utils.uphoster_utils.buzzheavier_utils.upload import (
+    BuzzHeavierUpload,
+)
+from ..mirror_leech_utils.uphoster_utils.pixeldrain_utils.upload import (
+    PixelDrainUpload,
+)
+from ..mirror_leech_utils.uphoster_utils.multi_upload import MultiUphosterUpload
+from ..mirror_leech_utils.gdrive_utils.upload import GoogleDriveUpload
+from ..mirror_leech_utils.rclone_utils.transfer import RcloneTransferHelper
+from ..mirror_leech_utils.status_utils.uphoster_status import UphosterStatus
+from ..mirror_leech_utils.status_utils.gdrive_status import (
+    GoogleDriveStatus,
+)
+from ..mirror_leech_utils.status_utils.queue_status import QueueStatus
+from ..mirror_leech_utils.status_utils.rclone_status import RcloneStatus
+from ..mirror_leech_utils.status_utils.telegram_status import TelegramStatus
+from ..mirror_leech_utils.status_utils.yt_status import YtStatus
+from ..mirror_leech_utils.upload_utils.telegram_uploader import TelegramUploader
+from ..mirror_leech_utils.youtube_utils.youtube_upload import YouTubeUpload
+from ..telegram_helper.button_build import ButtonMaker
+from ..telegram_helper.message_utils import (
+    delete_message,
+    delete_status,
+    send_message,
+    update_status_message,
+)
+
+
+class TaskListener(TaskConfig):
+    def __init__(self):
+        super().__init__()
+
+    async def clean(self):
+        with suppress(Exception):
+            if st := intervals["status"]:
+                for intvl in list(st.values()):
+                    intvl.cancel()
+            intervals["status"].clear()
+            await gather(TorrentManager.aria2.purgeDownloadResult(), delete_status())
+
+    def clear(self):
+        self.subname = ""
+        self.subsize = 0
+        self.files_to_proceed = []
+        self.proceed_count = 0
+        self.progress = True
+
+    async def remove_from_same_dir(self):
+        async with task_dict_lock:
+            if (
+                self.folder_name
+                and self.same_dir
+                and self.mid in self.same_dir[self.folder_name]["tasks"]
+            ):
+                self.same_dir[self.folder_name]["tasks"].remove(self.mid)
+                self.same_dir[self.folder_name]["total"] -= 1
+
+    async def on_download_start(self):
+        mode_name = "Leech" if self.is_leech else "Mirror"
+        if self.bot_pm and self.is_super_chat:
+            self.pm_msg = await send_message(
+                self.user_id,
+                f"""➲ <b><u>Task Started :</u></b>
+┃
+┖ <b>Link:</b> <a href='{self.source_url}'>Click Here</a>
+""",
+            )
+        if Config.LINKS_LOG_ID:
+            await send_message(
+                Config.LINKS_LOG_ID,
+                f"""➲  <b><u>{mode_name} Started:</u></b>
+ ┃
+ ┠ <b>User :</b> {self.tag} ( #ID{self.user_id} )
+ ┠ <b>Message Link :</b> <a href='{self.message.link}'>Click Here</a>
+ ┗ <b>Link:</b> <a href='{self.source_url}'>Click Here</a>
+ """,
+            )
+        if (
+            self.is_super_chat
+            and Config.INCOMPLETE_TASK_NOTIFIER
+            and Config.DATABASE_URL
+        ):
+            await database.add_incomplete_task(
+                self.message.chat.id, self.message.link, self.tag
+            )
+
+    async def on_download_complete(self):
+        await sleep(2)
+        if self.is_cancelled:
+            return
+        multi_links = False
+        if (
+            self.folder_name
+            and self.same_dir
+            and self.mid in self.same_dir[self.folder_name]["tasks"]
+        ):
+            async with same_directory_lock:
+                while True:
+                    async with task_dict_lock:
+                        if self.mid not in self.same_dir[self.folder_name]["tasks"]:
+                            return
+                        if (
+                            self.same_dir[self.folder_name]["total"] <= 1
+                            or len(self.same_dir[self.folder_name]["tasks"]) > 1
+                        ):
+                            if self.same_dir[self.folder_name]["total"] > 1:
+                                self.same_dir[self.folder_name]["tasks"].remove(
+                                    self.mid
+                                )
+                                self.same_dir[self.folder_name]["total"] -= 1
+                                spath = f"{self.dir}{self.folder_name}"
+                                des_id = list(self.same_dir[self.folder_name]["tasks"])[
+                                    0
+                                ]
+                                des_path = f"{DOWNLOAD_DIR}{des_id}{self.folder_name}"
+                                LOGGER.info(f"Moving files from {self.mid} to {des_id}")
+                                await move_and_merge(spath, des_path, self.mid)
+                                multi_links = True
+                            break
+                    await sleep(1)
+        async with task_dict_lock:
+            if self.is_cancelled:
+                return
+            if self.mid not in task_dict:
+                return
+            download = task_dict[self.mid]
+            self.name = download.name()
+            gid = download.gid()
+        LOGGER.info(f"Download completed: {self.name}")
+
+        if not (self.is_torrent or self.is_qbit):
+            self.seed = False
+
+        if multi_links:
+            self.seed = False
+            await self.on_upload_error(
+                f"{self.name} Downloaded!\n\nWaiting for other tasks to finish..."
+            )
+            return
+        elif self.same_dir:
+            self.seed = False
+
+        if self.folder_name:
+            self.name = self.folder_name.strip("/").split("/", 1)[0]
+
+        if not await aiopath.exists(f"{self.dir}/{self.name}"):
+            try:
+                files = await listdir(self.dir)
+                self.name = files[-1]
+                if self.name == "yt-dlp-thumb":
+                    self.name = files[0]
+            except Exception as e:
+                await self.on_upload_error(str(e))
+                return
+
+        dl_path = f"{self.dir}/{self.name}"
+        self.size = await get_path_size(dl_path)
+        self.is_file = await aiopath.isfile(dl_path)
+
+        if self.seed:
+            up_dir = self.up_dir = f"{self.dir}10000"
+            up_path = f"{self.up_dir}/{self.name}"
+            await create_recursive_symlink(self.dir, self.up_dir)
+            LOGGER.info(f"Shortcut created: {dl_path} -> {up_path}")
+        else:
+            up_dir = self.dir
+            up_path = dl_path
+
+        await remove_excluded_files(self.up_dir or self.dir, self.excluded_extensions)
+
+        if not Config.QUEUE_ALL:
+            async with queue_dict_lock:
+                if self.mid in non_queued_dl:
+                    non_queued_dl.remove(self.mid)
+            await start_from_queued()
+
+        if self.join and not self.is_file:
+            await join_files(up_path)
+
+        if self.extract and not self.is_nzb:
+            up_path = await self.proceed_extract(up_path, gid)
+            if self.is_cancelled:
+                return
+            self.is_file = await aiopath.isfile(up_path)
+            self.name = up_path.replace(f"{up_dir}/", "").split("/", 1)[0]
+            self.size = await get_path_size(up_dir)
+            self.clear()
+            await remove_excluded_files(up_dir, self.excluded_extensions)
+
+        if self.ffmpeg_cmds:
+            up_path = await self.proceed_ffmpeg(
+                up_path,
+                gid,
+            )
+            if self.is_cancelled:
+                return
+            self.is_file = await aiopath.isfile(up_path)
+            self.name = up_path.replace(f"{up_dir}/", "").split("/", 1)[0]
+            self.size = await get_path_size(up_dir)
+            self.clear()
+
+        if (
+            (hasattr(self, "metadata_dict") and self.metadata_dict)
+            or (hasattr(self, "audio_metadata_dict") and self.audio_metadata_dict)
+            or (hasattr(self, "video_metadata_dict") and self.video_metadata_dict)
+        ):
+            up_path = await apply_metadata_title(
+                self,
+                up_path,
+                gid,
+                getattr(self, "metadata_dict", {}),
+                getattr(self, "audio_metadata_dict", {}),
+                getattr(self, "video_metadata_dict", {}),
+            )
+            if self.is_cancelled:
+                return
+
+            self.name = up_path.replace(f"{up_dir.rstrip('/')}/", "").split("/", 1)[0]
+            self.size = await get_path_size(up_path)
+            self.clear()
+
+        if self.is_leech and self.is_file:
+            fname = ospath.basename(up_path)
+            self.file_details["filename"] = fname
+            self.file_details["mime_type"] = (guess_type(fname))[
+                0
+            ] or "application/octet-stream"
+
+        if self.name_swap:
+            up_path = await self.substitute(up_path)
+            if self.is_cancelled:
+                return
+            self.is_file = await aiopath.isfile(up_path)
+            self.name = up_path.replace(f"{up_dir}/", "").split("/", 1)[0]
+
+        if self.screen_shots:
+            up_path = await self.generate_screenshots(up_path)
+            if self.is_cancelled:
+                return
+            self.is_file = await aiopath.isfile(up_path)
+            self.name = up_path.replace(f"{up_dir}/", "").split("/", 1)[0]
+            self.size = await get_path_size(up_dir)
+
+        if self.convert_audio or self.convert_video:
+            up_path = await self.convert_media(
+                up_path,
+                gid,
+            )
+            if self.is_cancelled:
+                return
+            self.is_file = await aiopath.isfile(up_path)
+            self.name = up_path.replace(f"{up_dir}/", "").split("/", 1)[0]
+            self.size = await get_path_size(up_dir)
+            self.clear()
+
+        if self.sample_video:
+            up_path = await self.generate_sample_video(up_path, gid)
+            if self.is_cancelled:
+                return
+            self.is_file = await aiopath.isfile(up_path)
+            self.name = up_path.replace(f"{up_dir}/", "").split("/", 1)[0]
+            self.size = await get_path_size(up_dir)
+            self.clear()
+
+        if self.compress:
+            up_path = await self.proceed_compress(
+                up_path,
+                gid,
+            )
+            self.is_file = await aiopath.isfile(up_path)
+            if self.is_cancelled:
+                return
+            self.clear()
+
+        self.name = up_path.replace(f"{up_dir}/", "").split("/", 1)[0]
+        self.size = await get_path_size(up_dir)
+
+        if self.is_leech and not self.compress:
+            await self.proceed_split(up_path, gid)
+            if self.is_cancelled:
+                return
+            self.clear()
+
+        self.subproc = None
+
+        add_to_queue, event = await check_running_tasks(self, "up")
+        await start_from_queued()
+        if add_to_queue:
+            LOGGER.info(f"Added to Queue/Upload: {self.name}")
+            async with task_dict_lock:
+                task_dict[self.mid] = QueueStatus(self, gid, "Up")
+            await event.wait()
+            if self.is_cancelled:
+                return
+            LOGGER.info(f"Start from Queued/Upload: {self.name}")
+
+        self.size = await get_path_size(up_dir)
+
+        if self.is_yt:
+            LOGGER.info(f"Up to yt Name: {self.name}")
+            yt = YouTubeUpload(self, up_path)
+            async with task_dict_lock:
+                task_dict[self.mid] = YtStatus(self, yt, gid, "up")
+            await gather(
+                update_status_message(self.message.chat.id),
+                sync_to_async(yt.upload),
+            )
+            del yt
+        elif self.is_leech:
+            LOGGER.info(f"Leech Name: {self.name}")
+            tg = TelegramUploader(self, up_dir)
+            async with task_dict_lock:
+                task_dict[self.mid] = TelegramStatus(self, tg, gid, "up")
+            await gather(
+                update_status_message(self.message.chat.id),
+                tg.upload(),
+            )
+            del tg
+        elif self.is_uphoster:
+            LOGGER.info(f"Uphoster Upload Name: {self.name}")
+            uphoster_service = self.user_dict.get("UPHOSTER_SERVICE", "gofile")
+            services = uphoster_service.split(",")
+            ddl = MultiUphosterUpload(self, up_path, services)
+            async with task_dict_lock:
+                task_dict[self.mid] = UphosterStatus(self, ddl, gid, "up")
+            await gather(
+                update_status_message(self.message.chat.id),
+                ddl.upload(),
+            )
+            del ddl
+        elif is_gdrive_id(self.up_dest):
+            LOGGER.info(f"Gdrive Upload Name: {self.name}")
+            drive = GoogleDriveUpload(self, up_path)
+            async with task_dict_lock:
+                task_dict[self.mid] = GoogleDriveStatus(self, drive, gid, "up")
+            await gather(
+                update_status_message(self.message.chat.id),
+                sync_to_async(drive.upload),
+            )
+            del drive
+        else:
+            LOGGER.info(f"Rclone Upload Name: {self.name}")
+            RCTransfer = RcloneTransferHelper(self)
+            async with task_dict_lock:
+                task_dict[self.mid] = RcloneStatus(self, RCTransfer, gid, "up")
+            await gather(
+                update_status_message(self.message.chat.id),
+                RCTransfer.upload(up_path),
+            )
+            del RCTransfer
+        return
+
+    async def on_upload_complete(
+        self, link, files, folders, mime_type, rclone_path="", dir_id=""
+    ):
+        if (
+            self.is_super_chat
+            and Config.INCOMPLETE_TASK_NOTIFIER
+            and Config.DATABASE_URL
+        ):
+            await database.rm_complete_task(self.message.link)
+        msg = (
+            f"<b><i>{escape(self.name)}</i></b>\n│"
+            f"\n┟ <b>Task Size</b> → {get_readable_file_size(self.size)}"
+            f"\n┠ <b>Time Taken</b> → {get_readable_time(time() - self.message.date.timestamp())}"
+            f"\n┠ <b>In Mode</b> → {self.mode[0]}"
+            f"\n┠ <b>Out Mode</b> → {self.mode[1]}"
+        )
+        LOGGER.info(f"Task Done: {self.name}")
+        if self.is_yt:
+            buttons = ButtonMaker()
+            if mime_type == "Folder/Playlist":
+                msg += "\n┠ <b>Type</b> → Playlist"
+                msg += f"\n┖ <b>Total Videos</b> → {files}"
+                if link:
+                    buttons.url_button("🔗 View Playlist", link)
+                user_message = f"{self.tag}\nYour playlist ({files} videos) has been uploaded to YouTube successfully!"
+            else:
+                msg += "\n┖ <b>Type</b> → Video"
+                if link:
+                    buttons.url_button("🔗 View Video", link)
+                user_message = (
+                    f"{self.tag}\nYour video has been uploaded to YouTube successfully!"
+                )
+
+            msg += f"\n\n<b>Task By: </b>{self.tag}"
+
+            button = buttons.build_menu(1) if link else None
+
+            await send_message(self.user_id, msg, button)
+            if Config.LEECH_DUMP_CHAT:
+                await send_message(int(Config.LEECH_DUMP_CHAT), msg, button)
+            await send_message(self.message, user_message, button)
+
+        elif self.is_leech:
+            msg += f"\n<b>Total Files: </b>{folders}"
+            if mime_type != 0:
+                msg += f"\n┠ <b>Corrupted Files</b> → {mime_type}"
+            msg += f"\n┖ <b>Task By</b> → {self.tag}\n\n"
+
+            if self.bot_pm:
+                pmsg = msg
+                pmsg += "〶 <b><u>Action Performed :</u></b>\n"
+                pmsg += "⋗ <i>File(s) have been sent to User PM</i>\n\n"
+                if self.is_super_chat:
+                    await send_message(self.message, pmsg)
+
+            if not files and not self.is_super_chat:
+                await send_message(self.message, msg)
+            else:
+                log_chat = self.user_id if self.bot_pm else self.message
+                msg += "〶 <b><u>Files List :</u></b>\n"
+                fmsg = ""
+                for index, (link, name) in enumerate(files.items(), start=1):
+                    chat_id, msg_id = link.split("/")[-2:]
+                    fmsg += f"{index}. <a href='{link}'>{name}</a>"
+                    if Config.MEDIA_STORE and (
+                        self.is_super_chat or Config.LEECH_DUMP_CHAT
+                    ):
+                        if chat_id.isdigit():
+                            chat_id = f"-100{chat_id}"
+                        flink = f"https://t.me/{TgClient.BNAME}?start={encode_slink('file' + chat_id + '&&' + msg_id)}"
+                        fmsg += f"\n┖ <b>Get Media</b> → <a href='{flink}'>Store Link</a> | <a href='https://t.me/share/url?url={flink}'>Share Link</a>"
+                    fmsg += "\n"
+                    if len(fmsg.encode() + msg.encode()) > 4000:
+                        await send_message(log_chat, msg + fmsg)
+                        await sleep(1)
+                        fmsg = ""
+                if fmsg != "":
+                    await send_message(log_chat, msg + fmsg)
+        else:
+            msg += f"\n│\n┟ <b>Type</b> → {mime_type}"
+            if mime_type == "Folder":
+                msg += f"\n┠ <b>SubFolders</b> → {folders}"
+                msg += f"\n┠ <b>Files</b> → {files}"
+
+            multi_link_msg = ""
+            multi_links = []
+            if isinstance(link, dict) and not self.is_yt:
+                # MultiUphoster result
+                for service, result in link.items():
+                    if "error" in result:
+                        multi_link_msg += (
+                            f"{service.capitalize()}: Error - {result['error']}\n"
+                        )
+                    elif result.get("link"):
+                        multi_links.append(
+                            (f"{service.capitalize()} Link", result["link"])
+                        )
+                multi_link_msg = multi_link_msg.strip()
+                link = None  # Disable single link button logic
+
+            if (
+                link
+                or rclone_path
+                and Config.RCLONE_SERVE_URL
+                and not self.private_link
+                or multi_links
+            ):
+                buttons = ButtonMaker()
+                if link and Config.SHOW_CLOUD_LINK:
+                    buttons.url_button("☁️ Cloud Link", link)
+                elif multi_links:
+                    for name, url in multi_links:
+                        buttons.url_button(name, url)
+                else:
+                    msg += f"\n\nPath: <code>{rclone_path}</code>"
+                if rclone_path and Config.RCLONE_SERVE_URL and not self.private_link:
+                    remote, rpath = rclone_path.split(":", 1)
+                    url_path = rutils.quote(f"{rpath}")
+                    share_url = f"{Config.RCLONE_SERVE_URL}/{remote}/{url_path}"
+                    if mime_type == "Folder":
+                        share_url += "/"
+                    buttons.url_button("🔗 Rclone Link", share_url)
+                if not rclone_path and dir_id:
+                    INDEX_URL = ""
+                    if self.private_link:
+                        INDEX_URL = self.user_dict.get("INDEX_URL", "") or ""
+                    elif Config.INDEX_URL:
+                        INDEX_URL = Config.INDEX_URL
+                    if INDEX_URL and self.name:
+                        safe_name = rutils.quote(self.name.strip("/"))
+                        share_url = f"{INDEX_URL}/{safe_name}"
+                        buttons.url_button("⚡ Index Link", share_url)
+                        if mime_type.startswith(("image", "video", "audio")):
+                            share_urls = f"{share_url}?a=view"
+                            buttons.url_button("🌐 View Link", share_urls)
+                button = buttons.build_menu(2)
+            else:
+                if not multi_link_msg:
+                    msg += f"\n┃\n┠ Path: <code>{rclone_path}</code>"
+                button = None
+            msg += f"\n┃\n┖ <b>Task By</b> → {self.tag}\n\n"
+            group_msg = (
+                msg + "〶 <b><u>Action Performed :</u></b>\n"
+                "⋗ <i>Cloud link(s) have been sent to User PM</i>\n\n"
+            )
+
+            if multi_link_msg:
+                group_msg += multi_link_msg + "\n"
+                msg += multi_link_msg + "\n"
+
+            if self.bot_pm and self.is_super_chat:
+                await send_message(self.user_id, msg, button)
+
+            if hasattr(Config, "MIRROR_LOG_ID") and Config.MIRROR_LOG_ID:
+                await send_message(Config.MIRROR_LOG_ID, msg, button)
+
+            await send_message(self.message, group_msg, button)
+        if self.seed:
+            await clean_target(self.up_dir)
+            async with queue_dict_lock:
+                if self.mid in non_queued_up:
+                    non_queued_up.remove(self.mid)
+            await start_from_queued()
+            return
+
+        if self.pm_msg and (not Config.DELETE_LINKS or Config.CLEAN_LOG_MSG):
+            await delete_message(self.pm_msg)
+
+        await clean_download(self.dir)
+        async with task_dict_lock:
+            if self.mid in task_dict:
+                del task_dict[self.mid]
+            count = len(task_dict)
+        if count == 0:
+            await self.clean()
+        else:
+            await update_status_message(self.message.chat.id)
+
+        async with queue_dict_lock:
+            if self.mid in non_queued_up:
+                non_queued_up.remove(self.mid)
+
+        await start_from_queued()
+
+    async def on_download_error(self, error, button=None, is_limit=False):
+        async with task_dict_lock:
+            if self.mid in task_dict:
+                del task_dict[self.mid]
+            count = len(task_dict)
+        await self.remove_from_same_dir()
+        msg = (
+            f"""〶 <b><i><u>Limit Breached:</u></i></b>
+│
+┟ <b>Task Size</b> → {get_readable_file_size(self.size)}
+┠ <b>In Mode</b> → {self.mode[0]}
+┠ <b>Out Mode</b> → {self.mode[1]}
+{error}"""
+            if is_limit
+            else f"""<i><b>〶 Download Stopped!</b></i>
+│
+┟ <b>Due To</b> → {escape(str(error))}
+┠ <b>Task Size</b> → {get_readable_file_size(self.size)}
+┠ <b>Time Taken</b> → {get_readable_time(time() - self.message.date.timestamp())}
+┠ <b>In Mode</b> → {self.mode[0]}
+┠ <b>Out Mode</b> → {self.mode[1]}
+┖ <b>Task By</b> → {self.tag}"""
+        )
+
+        await send_message(self.message, msg, button)
+        if count == 0:
+            await self.clean()
+        else:
+            await update_status_message(self.message.chat.id)
+
+        if (
+            self.is_super_chat
+            and Config.INCOMPLETE_TASK_NOTIFIER
+            and Config.DATABASE_URL
+        ):
+            await database.rm_complete_task(self.message.link)
+
+        async with queue_dict_lock:
+            if self.mid in queued_dl:
+                queued_dl[self.mid].set()
+                del queued_dl[self.mid]
+            if self.mid in queued_up:
+                queued_up[self.mid].set()
+                del queued_up[self.mid]
+            if self.mid in non_queued_dl:
+                non_queued_dl.remove(self.mid)
+            if self.mid in non_queued_up:
+                non_queued_up.remove(self.mid)
+
+        await start_from_queued()
+        await sleep(3)
+        await clean_download(self.dir)
+        if self.up_dir:
+            await clean_download(self.up_dir)
+        if self.thumb and await aiopath.exists(self.thumb):
+            await remove(self.thumb)
+
+    async def on_upload_error(self, error):
+        async with task_dict_lock:
+            if self.mid in task_dict:
+                del task_dict[self.mid]
+            count = len(task_dict)
+        await send_message(self.message, f"{self.tag} {escape(str(error))}")
+        if count == 0:
+            await self.clean()
+        else:
+            await update_status_message(self.message.chat.id)
+
+        if (
+            self.is_super_chat
+            and Config.INCOMPLETE_TASK_NOTIFIER
+            and Config.DATABASE_URL
+        ):
+            await database.rm_complete_task(self.message.link)
+
+        async with queue_dict_lock:
+            if self.mid in queued_dl:
+                queued_dl[self.mid].set()
+                del queued_dl[self.mid]
+            if self.mid in queued_up:
+                queued_up[self.mid].set()
+                del queued_up[self.mid]
+            if self.mid in non_queued_dl:
+                non_queued_dl.remove(self.mid)
+            if self.mid in non_queued_up:
+                non_queued_up.remove(self.mid)
+
+        await start_from_queued()
+        await sleep(3)
+        await clean_download(self.dir)
+        if self.up_dir:
+            await clean_download(self.up_dir)
+        if self.thumb and await aiopath.exists(self.thumb):
+            await remove(self.thumb)

bot/helper/mirror_leech_utils/__init__.py

@@ -0,0 +1 @@
+

bot/helper/mirror_leech_utils/download_utils/__init__.py

@@ -0,0 +1 @@
+

bot/helper/mirror_leech_utils/download_utils/aria2_download.py

@@ -0,0 +1,105 @@
+from aiofiles.os import remove, path as aiopath
+from aiofiles import open as aiopen
+from base64 import b64encode
+from aiohttp.client_exceptions import ClientError
+from asyncio import TimeoutError
+
+from .... import task_dict_lock, task_dict, LOGGER
+from ....core.config_manager import Config
+from ....core.torrent_manager import TorrentManager, is_metadata, aria2_name
+from ...ext_utils.bot_utils import bt_selection_buttons
+from ...ext_utils.task_manager import check_running_tasks
+from ...mirror_leech_utils.status_utils.aria2_status import Aria2Status
+from ...telegram_helper.message_utils import send_status_message, send_message
+
+
+async def add_aria2_download(listener, dpath, header, ratio, seed_time):
+    if Config.DISABLE_TORRENTS and (
+        listener.link.startswith("magnet:") or listener.link.endswith(".torrent")
+    ):
+        await listener.on_download_error("Torrent and magnet downloads are disabled.")
+        return
+    a2c_opt = {"dir": dpath}
+    if listener.name:
+        a2c_opt["out"] = listener.name
+    if header:
+        a2c_opt["header"] = header
+    if ratio:
+        a2c_opt["seed-ratio"] = ratio
+    if seed_time:
+        a2c_opt["seed-time"] = seed_time
+    if TORRENT_TIMEOUT := Config.TORRENT_TIMEOUT:
+        a2c_opt["bt-stop-timeout"] = f"{TORRENT_TIMEOUT}"
+
+    add_to_queue, event = await check_running_tasks(listener)
+    if add_to_queue:
+        if listener.link.startswith("magnet:"):
+            a2c_opt["pause-metadata"] = "true"
+        else:
+            a2c_opt["pause"] = "true"
+
+    try:
+        if await aiopath.exists(listener.link):
+            async with aiopen(listener.link, "rb") as tf:
+                torrent = await tf.read()
+            encoded = b64encode(torrent).decode()
+            params = [encoded, [], a2c_opt]
+            gid = await TorrentManager.aria2.jsonrpc("addTorrent", params)
+            """gid = await TorrentManager.aria2.add_torrent(path=listener.link, options=a2c_opt)"""
+        else:
+            gid = await TorrentManager.aria2.addUri(
+                uris=[listener.link], options=a2c_opt
+            )
+    except (TimeoutError, ClientError, Exception) as e:
+        LOGGER.info(f"Aria2c Download Error: {e}")
+        await listener.on_download_error(f"{e}")
+        return
+    download = await TorrentManager.aria2.tellStatus(gid)
+    if download.get("errorMessage"):
+        error = str(download["errorMessage"]).replace("<", " ").replace(">", " ")
+        LOGGER.info(f"Aria2c Download Error: {error}")
+        await TorrentManager.aria2_remove(download)
+        await listener.on_download_error(error)
+        return
+    if await aiopath.exists(listener.link):
+        await remove(listener.link)
+
+    name = aria2_name(download)
+    async with task_dict_lock:
+        task_dict[listener.mid] = Aria2Status(listener, gid, queued=add_to_queue)
+    if add_to_queue:
+        LOGGER.info(f"Added to Queue/Download: {name}. Gid: {gid}")
+        if (
+            not listener.select or "bittorrent" not in download
+        ) and listener.multi <= 1:
+            await send_status_message(listener.message)
+    else:
+        LOGGER.info(f"Aria2Download started: {name}. Gid: {gid}")
+
+    await listener.on_download_start()
+
+    if (
+        not add_to_queue
+        and (not listener.select or not Config.BASE_URL)
+        and listener.multi <= 1
+    ):
+        await send_status_message(listener.message)
+    elif listener.select and "bittorrent" in download and not is_metadata(download):
+        if not add_to_queue:
+            await TorrentManager.aria2.forcePause(gid)
+        SBUTTONS = bt_selection_buttons(gid)
+        msg = "Your download paused. Choose files then press Done Selecting button to start downloading."
+        await send_message(listener.message, msg, SBUTTONS)
+
+    if add_to_queue:
+        await event.wait()
+        if listener.is_cancelled:
+            return
+        async with task_dict_lock:
+            task = task_dict[listener.mid]
+            task.queued = False
+            await task.update()
+            new_gid = task.gid()
+
+        await TorrentManager.aria2.unpause(new_gid)
+        LOGGER.info(f"Start Queued Download from Aria2c: {name}. Gid: {new_gid}")

bot/helper/mirror_leech_utils/download_utils/direct_downloader.py

@@ -0,0 +1,68 @@
+from secrets import token_hex
+
+from .... import (
+    LOGGER,
+    task_dict,
+    task_dict_lock,
+)
+from ...ext_utils.task_manager import (
+    check_running_tasks,
+    stop_duplicate_check,
+    limit_checker,
+)
+from ...listeners.direct_listener import DirectListener
+from ...mirror_leech_utils.status_utils.direct_status import DirectStatus
+from ...mirror_leech_utils.status_utils.queue_status import QueueStatus
+from ...telegram_helper.message_utils import send_status_message
+
+
+async def add_direct_download(listener, path):
+    details = listener.link
+    if not (contents := details.get("contents")):
+        await listener.on_download_error("There is nothing to download!")
+        return
+    listener.size = details["total_size"]
+
+    if not listener.name:
+        listener.name = details["title"]
+    path = f"{path}/{listener.name}"
+
+    msg, button = await stop_duplicate_check(listener)
+    if msg:
+        await listener.on_download_error(msg, button)
+        return
+
+    if limit_exceeded := await limit_checker(listener):
+        await listener.on_download_error(limit_exceeded, is_limit=True)
+        return
+
+    gid = token_hex(5)
+    add_to_queue, event = await check_running_tasks(listener)
+    if add_to_queue:
+        LOGGER.info(f"Added to Queue/Download: {listener.name}")
+        async with task_dict_lock:
+            task_dict[listener.mid] = QueueStatus(listener, gid, "dl")
+        await listener.on_download_start()
+        if listener.multi <= 1:
+            await send_status_message(listener.message)
+        await event.wait()
+        if listener.is_cancelled:
+            return
+
+    a2c_opt = {"follow-torrent": "false", "follow-metalink": "false"}
+    if header := details.get("header"):
+        a2c_opt["header"] = header
+    directListener = DirectListener(path, listener, a2c_opt)
+
+    async with task_dict_lock:
+        task_dict[listener.mid] = DirectStatus(listener, directListener, gid)
+
+    if add_to_queue:
+        LOGGER.info(f"Start Queued Download from Direct Download: {listener.name}")
+    else:
+        LOGGER.info(f"Download from Direct Download: {listener.name}")
+        await listener.on_download_start()
+        if listener.multi <= 1:
+            await send_status_message(listener.message)
+
+    await directListener.download(contents)

bot/helper/mirror_leech_utils/download_utils/direct_link_generator.py

@@ -0,0 +1,2048 @@
+from cloudscraper import create_scraper
+from hashlib import sha256
+from http.cookiejar import MozillaCookieJar
+from json import loads
+from lxml.etree import HTML
+from os import path as ospath
+from re import findall, match, search
+from requests import Session, post, get, RequestException
+from requests.adapters import HTTPAdapter
+from time import sleep
+from urllib.parse import parse_qs, urlparse, quote
+from urllib3.util.retry import Retry
+from uuid import uuid4
+from base64 import b64decode, b64encode
+
+from ....core.config_manager import Config
+from ...ext_utils.exceptions import DirectDownloadLinkException
+from ...ext_utils.help_messages import PASSWORD_ERROR_MESSAGE
+from ...ext_utils.links_utils import is_share_link
+from ...ext_utils.status_utils import speed_string_to_bytes
+
+user_agent = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0"
+)
+
+debrid_link_supported_sites = [
+    "1fichier.com",
+    "anonfiles.com",
+    "bayfiles.com",
+    "clicknupload.link",
+    "clicknupload.org",
+    "clicknupload.co",
+    "clicknupload.cc",
+    "clicknupload.download",
+    "clicknupload.club",
+    "dailyuploads.net",
+    "ddl.to",
+    "ddownload.com",
+    "ddownload.link",
+    "drop.download",
+    "dropbox.com",
+    "dropboxusercontent.com",
+    "easyupload.io",
+    "emload.com",
+    "file.al",
+    "fileaxa.com",
+    "filecat.net",
+    "filedot.to",
+    "filedot.xyz",
+    "filextras.com",
+    "filer.net",
+    "filespace.com",
+    "filestore.me",
+    "gigapeta.com",
+    "gofile.io",
+    "hexupload.net",
+    "hitfile.net",
+    "hulkshare.com",
+    "isra.cloud",
+    "katfile.com",
+    "kshared.com",
+    "mediafire.com",
+    "mega.nz",
+    "mega.co.nz",
+    "mexashare.com",
+    "mixdrop.co",
+    "mixdrop.to",
+    "mixdrop.sx",
+    "mixdrop.club",
+    "modsbase.com",
+    "nelion.me",
+    "pixeldrain.com",
+    "prefiles.com",
+    "racaty.net",
+    "rapidgator.net",
+    "rapidgator.asia",
+    "rg.to",
+    "scribd.com",
+    "send.cm",
+    "sharemods.com",
+    "silkfiles.com",
+    "soundcloud.com",
+    "streamtape.com",
+    "terabox.com",
+    "teraboxapp.com",
+    "tezfiles.com",
+    "turb.cc",
+    "turb.to",
+    "turbobit.net",
+    "turbobit.cc",
+    "turbobit.pw",
+    "turbobit.online",
+    "turbobit.ru",
+    "turbobit.live",
+    "trubobit.com",
+    "turboblt.co",
+    "uloz.to",
+    "ulozto.net",
+    "ulozto.sk",
+    "ulozto.cz",
+    "upload.ee",
+    "uploadhaven.com",
+    "up-4ever.com",
+    "up-4ever.net",
+    "uptobox.com",
+    "uptobox.fr",
+    "uptobox.eu",
+    "uptobox.link",
+    "uptostream.com",
+    "uptostream.fr",
+    "uptostream.eu",
+    "uptostream.link",
+    "upvid.pro",
+    "upvid.live",
+    "upvid.host",
+    "upvid.biz",
+    "upvid.cloud",
+    "uqload.com",
+    "uqload.co",
+    "uqload.io",
+    "userload.co",
+    "usersdrive.com",
+    "vidoza.net",
+    "voe.sx",
+    "voe-unblock.com",
+    "voeunblock1.com",
+    "voeunblock2.com",
+    "voeunblock3.com",
+    "voeunbl0ck.com",
+    "voeunblck.com",
+    "voeunblk.com",
+    "voe-un-block.com",
+    "voeun-block.net",
+    "workupload.com",
+    "world-bytez.com",
+    "worldbytez.com",
+    "world-files.com",
+    "wupfile.com",
+    "zippyshare.com",
+]
+
+
+def direct_link_generator(link):
+    """direct links generator"""
+    domain = urlparse(link).hostname
+    if not domain:
+        raise DirectDownloadLinkException("ERROR: Invalid URL")
+    elif Config.DEBRID_LINK_API and any(
+        x in domain for x in debrid_link_supported_sites
+    ):
+        return debrid_link(link)
+    elif "yadi.sk" in link or "disk.yandex." in link:
+        return yandex_disk(link)
+    elif "buzzheavier.com" in domain:
+        return buzzheavier(link)
+    elif "devuploads" in domain:
+        return devuploads(link)
+    elif "lulacloud.com" in domain:
+        return lulacloud(link)
+    elif "fuckingfast.co" in domain:
+        return fuckingfast_dl(link)
+    elif "mediafire.com" in domain:
+        return mediafire(link)
+    elif "osdn.net" in domain:
+        return osdn(link)
+    elif "github.com" in domain:
+        return github(link)
+    elif "hxfile.co" in domain:
+        return hxfile(link)
+    elif "1drv.ms" in domain:
+        return onedrive(link)
+    elif "pixeldrain.com" in domain:
+        return pixeldrain(link)
+    elif "racaty" in domain:
+        return racaty(link)
+    elif "1fichier.com" in domain:
+        return fichier(link)
+    elif "solidfiles.com" in domain:
+        return solidfiles(link)
+    elif "krakenfiles.com" in domain:
+        return krakenfiles(link)
+    elif "upload.ee" in domain:
+        return uploadee(link)
+    elif "gofile.io" in domain:
+        return gofile(link)
+    elif "send.cm" in domain:
+        return send_cm(link)
+    elif "tmpsend.com" in domain:
+        return tmpsend(link)
+    elif "easyupload.io" in domain:
+        return easyupload(link)
+    elif "streamvid.net" in domain:
+        return streamvid(link)
+    elif "shrdsk.me" in domain:
+        return shrdsk(link)
+    elif "u.pcloud.link" in domain:
+        return pcloud(link)
+    elif "qiwi.gg" in domain:
+        return qiwi(link)
+    elif "mp4upload.com" in domain:
+        return mp4upload(link)
+    elif "berkasdrive.com" in domain:
+        return berkasdrive(link)
+    elif "swisstransfer.com" in domain:
+        return swisstransfer(link)
+    elif "instagram.com" in domain:
+        return instagram(link)
+    elif any(x in domain for x in ["akmfiles.com", "akmfls.xyz"]):
+        return akmfiles(link)
+    elif any(
+        x in domain
+        for x in [
+            "dood.watch",
+            "doodstream.com",
+            "dood.to",
+            "dood.so",
+            "dood.cx",
+            "dood.la",
+            "dood.ws",
+            "dood.sh",
+            "doodstream.co",
+            "dood.pm",
+            "dood.wf",
+            "dood.re",
+            "dood.video",
+            "dooood.com",
+            "dood.yt",
+            "doods.yt",
+            "dood.stream",
+            "doods.pro",
+            "ds2play.com",
+            "d0o0d.com",
+            "ds2video.com",
+            "do0od.com",
+            "d000d.com",
+        ]
+    ):
+        return doods(link)
+    elif any(
+        x in domain
+        for x in [
+            "streamtape.com",
+            "streamtape.co",
+            "streamtape.cc",
+            "streamtape.to",
+            "streamtape.net",
+            "streamta.pe",
+            "streamtape.xyz",
+        ]
+    ):
+        return streamtape(link)
+    elif any(x in domain for x in ["wetransfer.com", "we.tl"]):
+        return wetransfer(link)
+    elif any(
+        x in domain
+        for x in [
+            "terabox.com",
+            "nephobox.com",
+            "4funbox.com",
+            "mirrobox.com",
+            "momerybox.com",
+            "teraboxapp.com",
+            "1024tera.com",
+            "terabox.app",
+            "gibibox.com",
+            "goaibox.com",
+            "terasharelink.com",
+            "teraboxlink.com",
+            "freeterabox.com",
+            "1024terabox.com",
+            "teraboxshare.com",
+            "terafileshare.com",
+        ]
+    ):
+        return terabox(link)
+    elif any(
+        x in domain
+        for x in [
+            "filelions.co",
+            "filelions.site",
+            "filelions.live",
+            "filelions.to",
+            "mycloudz.cc",
+            "cabecabean.lol",
+            "filelions.online",
+            "embedwish.com",
+            "kitabmarkaz.xyz",
+            "wishfast.top",
+            "streamwish.to",
+            "kissmovies.net",
+        ]
+    ):
+        return filelions_and_streamwish(link)
+    elif any(x in domain for x in ["streamhub.ink", "streamhub.to"]):
+        return streamhub(link)
+    elif any(x in domain for x in ["hubcloud.one", "hubcloud.foo"]):
+        return hubcloud(link)
+    elif any(
+        x in domain
+        for x in [
+            "linkbox.to",
+            "lbx.to",
+            "teltobx.net",
+            "telbx.net",
+        ]
+    ):
+        return linkBox(link)
+    elif is_share_link(link):
+        if "gdtot" in domain:
+            return gdtot(link)
+        elif "filepress" in domain:
+            return filepress(link)
+        else:
+            return sharer_scraper(link)
+    elif any(
+        x in domain
+        for x in [
+            "anonfiles.com",
+            "zippyshare.com",
+            "letsupload.io",
+            "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",
+            "uptobox.com",
+            "uptobox.fr",
+        ]
+    ):
+        raise DirectDownloadLinkException(f"ERROR: R.I.P {domain}")
+    else:
+        raise DirectDownloadLinkException(f"No Direct link function found for {link}")
+
+
+def get_captcha_token(session, params):
+    recaptcha_api = "https://www.google.com/recaptcha/api2"
+    res = session.get(f"{recaptcha_api}/anchor", params=params)
+    anchor_html = HTML(res.text)
+    if not (anchor_token := anchor_html.xpath('//input[@id="recaptcha-token"]/@value')):
+        return
+    params["c"] = anchor_token[0]
+    params["reason"] = "q"
+    res = session.post(f"{recaptcha_api}/reload", params=params)
+    if token := findall(r'"rresp","(.*?)"', res.text):
+        return token[0]
+
+
+def debrid_link(url):
+    cget = create_scraper().request
+    resp = cget(
+        "POST",
+        f"https://debrid-link.com/api/v2/downloader/add?access_token={Config.DEBRID_LINK_API}",
+        data={"url": url},
+    ).json()
+    if resp["success"] != True:
+        raise DirectDownloadLinkException(
+            f"ERROR: {resp['error']} & ERROR ID: {resp['error_id']}"
+        )
+    if isinstance(resp["value"], dict):
+        return resp["value"]["downloadUrl"]
+    elif isinstance(resp["value"], list):
+        details = {
+            "contents": [],
+            "title": unquote(url.rstrip("/").split("/")[-1]),
+            "total_size": 0,
+        }
+        for dl in resp["value"]:
+            if dl.get("expired", False):
+                continue
+            item = {
+                "path": path.join(details["title"]),
+                "filename": dl["name"],
+                "url": dl["downloadUrl"],
+            }
+            if "size" in dl:
+                details["total_size"] += dl["size"]
+            details["contents"].append(item)
+        return details
+
+
+def hubcloud(url):
+    try:
+        response = get(f"http://hubcloud.cfd/bypass?url={url}").json()
+    except Exception as e:
+        raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+
+    if "links" not in response or not response["links"]:
+        raise DirectDownloadLinkException("ERROR: No links found")
+
+    # Sort links by priority in descending order
+    links = sorted(response["links"], key=lambda x: x.get("priority", 0), reverse=True)
+
+    # Return the url of the highest priority link
+    return links[0]["url"]
+
+
+def buzzheavier(link):
+    """
+    Generate a direct download link for buzzheavier URLs.
+    @param link: URL from buzzheavier
+    @return: Direct download link
+    """
+    link = link if link.endswith("/") else link + "/"
+    client = create_scraper()
+    try:
+        res = client.get(
+            link + "download", headers={"hx-current-url": link, "referer": link}
+        )
+    except Exception as e:
+        raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+
+    domain = urlparse(link).netloc
+    redirect_url = res.headers.get("Hx-Redirect", "None")
+
+    if redirect_url == "None":
+        raise DirectDownloadLinkException("ERROR: Direct link not found")
+
+    if not redirect_url.startswith("http"):
+        return f"https://{domain}{redirect_url}"
+    return redirect_url
+
+
+def fuckingfast_dl(url):
+    """
+    Generate a direct download link for fuckingfast.co URLs.
+    @param url: URL from fuckingfast.co
+    @return: Direct download link
+    """
+    session = Session()
+    url = url.strip()
+
+    try:
+        response = session.get(url)
+        content = response.text
+        pattern = r'window\.open\((["\'])(https://fuckingfast\.co/dl/[^"\']+)\1'
+        match = search(pattern, content)
+
+        if not match:
+            raise DirectDownloadLinkException(
+                "ERROR: Could not find download link in page"
+            )
+
+        direct_url = match.group(2)
+        return direct_url
+
+    except Exception as e:
+        raise DirectDownloadLinkException(f"ERROR: {str(e)}") from e
+    finally:
+        session.close()
+
+
+def devuploads(url):
+    """
+    Generate a direct download link for devuploads.com URLs.
+    @param url: URL from devuploads.com
+    @return: Direct download link
+    """
+    session = Session()
+    res = session.get(url)
+    html = HTML(res.text)
+    if not html.xpath("//input[@name]"):
+        raise DirectDownloadLinkException("ERROR: Unable to find link data")
+    data = {i.get("name"): i.get("value") for i in html.xpath("//input[@name]")}
+    res = session.post("https://gujjukhabar.in/", data=data)
+    html = HTML(res.text)
+    if not html.xpath("//input[@name]"):
+        raise DirectDownloadLinkException("ERROR: Unable to find link data")
+    data = {i.get("name"): i.get("value") for i in html.xpath("//input[@name]")}
+    resp = session.get(
+        "https://du2.devuploads.com/dlhash.php",
+        headers={
+            "Origin": "https://gujjukhabar.in",
+            "Referer": "https://gujjukhabar.in/",
+        },
+    )
+    if not resp.text:
+        raise DirectDownloadLinkException("ERROR: Unable to find ipp value")
+    data["ipp"] = resp.text.strip()
+    if not data.get("rand"):
+        raise DirectDownloadLinkException("ERROR: Unable to find rand value")
+    randpost = session.post(
+        "https://devuploads.com/token/token.php",
+        data={"rand": data["rand"], "msg": ""},
+        headers={
+            "Origin": "https://gujjukhabar.in",
+            "Referer": "https://gujjukhabar.in/",
+        },
+    )
+    if not randpost:
+        raise DirectDownloadLinkException("ERROR: Unable to find xd value")
+    data["xd"] = randpost.text.strip()
+    proxy = "http://hsakalu2:hsakalu2@45.151.162.198:6600"
+    res = session.post(url, data=data, proxies={"http": proxy, "https": proxy})
+    html = HTML(res.text)
+    if not html.xpath("//input[@name='orilink']/@value"):
+        raise DirectDownloadLinkException("ERROR: Unable to find Direct Link")
+    direct_link = html.xpath("//input[@name='orilink']/@value")
+    session.close()
+    return direct_link[0]
+
+
+def lulacloud(url):
+    """
+    Generate a direct download link for www.lulacloud.com URLs.
+    @param url: URL from www.lulacloud.com
+    @return: Direct download link
+    """
+    session = Session()
+    try:
+        res = session.post(url, headers={"Referer": url}, allow_redirects=False)
+        return res.headers["location"]
+    except Exception as e:
+        raise DirectDownloadLinkException(f"ERROR: {str(e)}") from e
+    finally:
+        session.close()
+
+
+def mediafire(url, session=None):
+    if "/folder/" in url:
+        return mediafireFolder(url)
+    if "::" in url:
+        _password = url.split("::")[-1]
+        url = url.split("::")[-2]
+    else:
+        _password = ""
+    if final_link := findall(
+        r"https?:\/\/download\d+\.mediafire\.com\/\S+\/\S+\/\S+", url
+    ):
+        return final_link[0]
+
+    def _repair_download(url, session):
+        try:
+            html = HTML(session.get(url).text)
+            if new_link := html.xpath('//a[@id="continue-btn"]/@href'):
+                return mediafire(f"https://mediafire.com/{new_link[0]}")
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+
+    if session is None:
+        session = create_scraper()
+        parsed_url = urlparse(url)
+        url = f"{parsed_url.scheme}://{parsed_url.netloc}{parsed_url.path}"
+    try:
+        html = HTML(session.get(url).text)
+    except Exception as e:
+        session.close()
+        raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if error := html.xpath('//p[@class="notranslate"]/text()'):
+        session.close()
+        raise DirectDownloadLinkException(f"ERROR: {error[0]}")
+    if html.xpath("//div[@class='passwordPrompt']"):
+        if not _password:
+            session.close()
+            raise DirectDownloadLinkException(
+                f"ERROR: {PASSWORD_ERROR_MESSAGE}".format(url)
+            )
+        try:
+            html = HTML(session.post(url, data={"downloadp": _password}).text)
+        except Exception as e:
+            session.close()
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+        if html.xpath("//div[@class='passwordPrompt']"):
+            session.close()
+            raise DirectDownloadLinkException("ERROR: Wrong password.")
+    if not (final_link := html.xpath('//a[@aria-label="Download file"]/@href')):
+        if repair_link := html.xpath("//a[@class='retry']/@href"):
+            return _repair_download(repair_link[0], session)
+        raise DirectDownloadLinkException(
+            "ERROR: No links found in this page Try Again"
+        )
+    if final_link[0].startswith("//"):
+        final_url = f"https://{final_link[0][2:]}"
+        if _password:
+            final_url += f"::{_password}"
+        return mediafire(final_url, session)
+    session.close()
+    return final_link[0]
+
+
+def osdn(url):
+    with create_scraper() as session:
+        try:
+            html = HTML(session.get(url).text)
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+        if not (direct_link := html.xapth('//a[@class="mirror_link"]/@href')):
+            raise DirectDownloadLinkException("ERROR: Direct link not found")
+        return f"https://osdn.net{direct_link[0]}"
+
+
+def yandex_disk(url: str) -> str:
+    """Yandex.Disk direct link generator
+    Based on https://github.com/wldhx/yadisk-direct"""
+    try:
+        link = findall(r"\b(https?://(yadi\.sk|disk\.yandex\.(com|ru))\S+)", url)[0][0]
+    except IndexError:
+        return "No Yandex.Disk links found\n"
+    api = "https://cloud-api.yandex.net/v1/disk/public/resources/download?public_key={}"
+    try:
+        return get(api.format(link)).json()["href"]
+    except KeyError as e:
+        raise DirectDownloadLinkException(
+            "ERROR: File not found/Download limit reached"
+        ) from e
+
+
+def github(url):
+    """GitHub direct links generator"""
+    try:
+        findall(r"\bhttps?://.*github\.com.*releases\S+", url)[0]
+    except IndexError as e:
+        raise DirectDownloadLinkException("No GitHub Releases links found") from e
+    with create_scraper() as session:
+        _res = session.get(url, stream=True, allow_redirects=False)
+        if "location" in _res.headers:
+            return _res.headers["location"]
+        raise DirectDownloadLinkException("ERROR: Can't extract the link")
+
+
+def hxfile(url):
+    if not ospath.isfile("hxfile.txt"):
+        raise DirectDownloadLinkException("ERROR: hxfile.txt (cookies) Not Found!")
+    try:
+        jar = MozillaCookieJar()
+        jar.load("hxfile.txt")
+    except Exception as e:
+        raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    cookies = {cookie.name: cookie.value for cookie in jar}
+    with Session() as session:
+        try:
+            if url.strip().endswith(".html"):
+                url = url[:-5]
+            file_code = url.split("/")[-1]
+            html = HTML(
+                session.post(
+                    url,
+                    data={"op": "download2", "id": file_code},
+                    cookies=cookies,
+                ).text
+            )
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if direct_link := html.xpath("//a[@class='btn btn-dow']/@href"):
+        header = f"Referer: {url}"
+        return direct_link[0], header
+    raise DirectDownloadLinkException("ERROR: Direct download link not found")
+
+
+def onedrive(link):
+    """Onedrive direct link generator
+    By https://github.com/junedkh"""
+    with create_scraper() as session:
+        try:
+            link = session.get(link).url
+            parsed_link = urlparse(link)
+            link_data = parse_qs(parsed_link.query)
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+        if not link_data:
+            raise DirectDownloadLinkException("ERROR: Unable to find link_data")
+        folder_id = link_data.get("resid")
+        if not folder_id:
+            raise DirectDownloadLinkException("ERROR: folder id not found")
+        folder_id = folder_id[0]
+        authkey = link_data.get("authkey")
+        if not authkey:
+            raise DirectDownloadLinkException("ERROR: authkey not found")
+        authkey = authkey[0]
+        boundary = uuid4()
+        headers = {"content-type": f"multipart/form-data;boundary={boundary}"}
+        data = f"--{boundary}\r\nContent-Disposition: form-data;name=data\r\nPrefer: Migration=EnableRedirect;FailOnMigratedFiles\r\nX-HTTP-Method-Override: GET\r\nContent-Type: application/json\r\n\r\n--{boundary}--"
+        try:
+            resp = session.get(
+                f"https://api.onedrive.com/v1.0/drives/{folder_id.split('!', 1)[0]}/items/{folder_id}?$select=id,@content.downloadUrl&ump=1&authKey={authkey}",
+                headers=headers,
+                data=data,
+            ).json()
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if "@content.downloadUrl" not in resp:
+        raise DirectDownloadLinkException("ERROR: Direct link not found")
+    return resp["@content.downloadUrl"]
+
+
+def pixeldrain(url):
+    try:
+        url = url.rstrip("/")
+        code = url.split("/")[-1].split("?", 1)[0]
+        response = get("https://pd.cybar.xyz/", allow_redirects=True)
+        return response.url + code
+    except Exception as e:
+        raise DirectDownloadLinkException("ERROR: Direct link not found")
+
+
+def streamtape(url):
+    splitted_url = url.split("/")
+    _id = splitted_url[4] if len(splitted_url) >= 6 else splitted_url[-1]
+    try:
+        with Session() as session:
+            html = HTML(session.get(url).text)
+    except Exception as e:
+        raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    script = html.xpath(
+        "//script[contains(text(),'ideoooolink')]/text()"
+    ) or html.xpath("//script[contains(text(),'ideoolink')]/text()")
+    if not script:
+        raise DirectDownloadLinkException("ERROR: requeries script not found")
+    if not (link := findall(r"(&expires\S+)'", script[0])):
+        raise DirectDownloadLinkException("ERROR: Download link not found")
+    return f"https://streamtape.com/get_video?id={_id}{link[-1]}"
+
+
+def racaty(url):
+    with create_scraper() as session:
+        try:
+            url = session.get(url).url
+            json_data = {"op": "download2", "id": url.split("/")[-1]}
+            html = HTML(session.post(url, data=json_data).text)
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if direct_link := html.xpath("//a[@id='uniqueExpirylink']/@href"):
+        return direct_link[0]
+    else:
+        raise DirectDownloadLinkException("ERROR: Direct link not found")
+
+
+def fichier(link):
+    """1Fichier direct link generator
+    Based on https://github.com/Maujar
+    """
+    regex = r"^([http:\/\/|https:\/\/]+)?.*1fichier\.com\/\?.+"
+    gan = match(regex, link)
+    if not gan:
+        raise DirectDownloadLinkException("ERROR: The link you entered is wrong!")
+    if "::" in link:
+        pswd = link.split("::")[-1]
+        url = link.split("::")[-2]
+    else:
+        pswd = None
+        url = link
+    cget = create_scraper().request
+    try:
+        if pswd is None:
+            req = cget("post", url)
+        else:
+            pw = {"pass": pswd}
+            req = cget("post", url, data=pw)
+    except Exception as e:
+        raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if req.status_code == 404:
+        raise DirectDownloadLinkException(
+            "ERROR: File not found/The link you entered is wrong!"
+        )
+    html = HTML(req.text)
+    if dl_url := html.xpath('//a[@class="ok btn-general btn-orange"]/@href'):
+        return dl_url[0]
+    if not (ct_warn := html.xpath('//div[@class="ct_warn"]')):
+        raise DirectDownloadLinkException(
+            "ERROR: Error trying to generate Direct Link from 1fichier!"
+        )
+    if len(ct_warn) == 3:
+        str_2 = ct_warn[-1].text
+        if "you must wait" in str_2.lower():
+            if numbers := [int(word) for word in str_2.split() if word.isdigit()]:
+                raise DirectDownloadLinkException(
+                    f"ERROR: 1fichier is on a limit. Please wait {numbers[0]} minute."
+                )
+            else:
+                raise DirectDownloadLinkException(
+                    "ERROR: 1fichier is on a limit. Please wait a few minutes/hour."
+                )
+        elif "protect access" in str_2.lower():
+            raise DirectDownloadLinkException(
+                f"ERROR:\n{PASSWORD_ERROR_MESSAGE.format(link)}"
+            )
+        else:
+            raise DirectDownloadLinkException(
+                "ERROR: Failed to generate Direct Link from 1fichier!"
+            )
+    elif len(ct_warn) == 4:
+        str_1 = ct_warn[-2].text
+        str_3 = ct_warn[-1].text
+        if "you must wait" in str_1.lower():
+            if numbers := [int(word) for word in str_1.split() if word.isdigit()]:
+                raise DirectDownloadLinkException(
+                    f"ERROR: 1fichier is on a limit. Please wait {numbers[0]} minute."
+                )
+            else:
+                raise DirectDownloadLinkException(
+                    "ERROR: 1fichier is on a limit. Please wait a few minutes/hour."
+                )
+        elif "bad password" in str_3.lower():
+            raise DirectDownloadLinkException(
+                "ERROR: The password you entered is wrong!"
+            )
+    raise DirectDownloadLinkException(
+        "ERROR: Error trying to generate Direct Link from 1fichier!"
+    )
+
+
+def solidfiles(url):
+    """Solidfiles direct link generator
+    Based on https://github.com/Xonshiz/SolidFiles-Downloader
+    By https://github.com/Jusidama18"""
+    with create_scraper() as session:
+        try:
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/36.0.1985.125 Safari/537.36"
+            }
+            pageSource = session.get(url, headers=headers).text
+            mainOptions = str(
+                search(r"viewerOptions\'\,\ (.*?)\)\;", pageSource).group(1)
+            )
+            return loads(mainOptions)["downloadUrl"]
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+
+
+def krakenfiles(url):
+    with Session() as session:
+        try:
+            _res = session.get(url)
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+        html = HTML(_res.text)
+        if post_url := html.xpath('//form[@id="dl-form"]/@action'):
+            post_url = f"https://krakenfiles.com{post_url[0]}"
+        else:
+            raise DirectDownloadLinkException("ERROR: Unable to find post link.")
+        if token := html.xpath('//input[@id="dl-token"]/@value'):
+            data = {"token": token[0]}
+        else:
+            raise DirectDownloadLinkException("ERROR: Unable to find token for post.")
+        try:
+            _json = session.post(post_url, data=data).json()
+        except Exception as e:
+            raise DirectDownloadLinkException(
+                f"ERROR: {e.__class__.__name__} While send post request"
+            ) from e
+    if _json["status"] != "ok":
+        raise DirectDownloadLinkException(
+            "ERROR: Unable to find download after post request"
+        )
+    return _json["url"]
+
+
+def uploadee(url):
+    with create_scraper() as session:
+        try:
+            html = HTML(session.get(url).text)
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if link := html.xpath("//a[@id='d_l']/@href"):
+        return link[0]
+    else:
+        raise DirectDownloadLinkException("ERROR: Direct Link not found")
+
+
+def terabox(url):
+    try:
+        encoded_url = quote(url)
+        final_url = f"https://teradlrobot.cheemsbackup.workers.dev/?url={encoded_url}"
+        return final_url
+    except Exception as e:
+        raise DirectDownloadLinkException("Failed to bypass Terabox URL")
+
+
+def filepress(url):
+    with create_scraper() as session:
+        try:
+            url = session.get(url).url
+            raw = urlparse(url)
+            json_data = {
+                "id": raw.path.split("/")[-1],
+                "method": "publicDownlaod",
+            }
+            api = f"{raw.scheme}://{raw.hostname}/api/file/downlaod/"
+            res2 = session.post(
+                api,
+                headers={"Referer": f"{raw.scheme}://{raw.hostname}"},
+                json=json_data,
+            ).json()
+            json_data2 = {
+                "id": res2["data"],
+                "method": "publicUserDownlaod",
+            }
+            api2 = "https://new2.filepress.store/api/file/downlaod2/"
+            res = session.post(
+                api2,
+                headers={"Referer": f"{raw.scheme}://{raw.hostname}"},
+                json=json_data2,
+            ).json()
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if "data" not in res:
+        raise DirectDownloadLinkException(f"ERROR: {res['statusText']}")
+    return f"https://drive.google.com/uc?id={res['data']}&export=download"
+
+
+def gdtot(url):
+    cget = create_scraper().request
+    try:
+        res = cget("GET", f"https://gdtot.pro/file/{url.split('/')[-1]}")
+    except Exception as e:
+        raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    token_url = HTML(res.text).xpath(
+        "//a[contains(@class,'inline-flex items-center justify-center')]/@href"
+    )
+    if not token_url:
+        try:
+            url = cget("GET", url).url
+            p_url = urlparse(url)
+            res = cget(
+                "GET", f"{p_url.scheme}://{p_url.hostname}/ddl/{url.split('/')[-1]}"
+            )
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+        if (
+            drive_link := findall(r"myDl\('(.*?)'\)", res.text)
+        ) and "drive.google.com" in drive_link[0]:
+            return drive_link[0]
+        else:
+            raise DirectDownloadLinkException(
+                "ERROR: Drive Link not found, Try in your broswer"
+            )
+    token_url = token_url[0]
+    try:
+        token_page = cget("GET", token_url)
+    except Exception as e:
+        raise DirectDownloadLinkException(
+            f"ERROR: {e.__class__.__name__} with {token_url}"
+        ) from e
+    path = findall(r'\("(.*?)"\)', token_page.text)
+    if not path:
+        raise DirectDownloadLinkException("ERROR: Cannot bypass this")
+    path = path[0]
+    raw = urlparse(token_url)
+    final_url = f"{raw.scheme}://{raw.hostname}{path}"
+    return sharer_scraper(final_url)
+
+
+def sharer_scraper(url):
+    cget = create_scraper().request
+    try:
+        url = cget("GET", url).url
+        raw = urlparse(url)
+        header = {
+            "useragent": "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/534.10 (KHTML, like Gecko) Chrome/7.0.548.0 Safari/534.10"
+        }
+        res = cget("GET", url, headers=header)
+    except Exception as e:
+        raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    key = findall(r'"key",\s+"(.*?)"', res.text)
+    if not key:
+        raise DirectDownloadLinkException("ERROR: Key not found!")
+    key = key[0]
+    if not HTML(res.text).xpath("//button[@id='drc']"):
+        raise DirectDownloadLinkException(
+            "ERROR: This link don't have direct download button"
+        )
+    boundary = uuid4()
+    headers = {
+        "Content-Type": f"multipart/form-data; boundary=----WebKitFormBoundary{boundary}",
+        "x-token": raw.hostname,
+        "useragent": "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/534.10 (KHTML, like Gecko) Chrome/7.0.548.0 Safari/534.10",
+    }
+
+    data = (
+        f'------WebKitFormBoundary{boundary}\r\nContent-Disposition: form-data; name="action"\r\n\r\ndirect\r\n'
+        f'------WebKitFormBoundary{boundary}\r\nContent-Disposition: form-data; name="key"\r\n\r\n{key}\r\n'
+        f'------WebKitFormBoundary{boundary}\r\nContent-Disposition: form-data; name="action_token"\r\n\r\n\r\n'
+        f"------WebKitFormBoundary{boundary}--\r\n"
+    )
+    try:
+        res = cget("POST", url, cookies=res.cookies, headers=headers, data=data).json()
+    except Exception as e:
+        raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if "url" not in res:
+        raise DirectDownloadLinkException(
+            "ERROR: Drive Link not found, Try in your broswer"
+        )
+    if "drive.google.com" in res["url"] or "drive.usercontent.google.com" in res["url"]:
+        return res["url"]
+    try:
+        res = cget("GET", res["url"])
+    except Exception as e:
+        raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if (drive_link := HTML(res.text).xpath("//a[contains(@class,'btn')]/@href")) and (
+        "drive.google.com" in drive_link[0]
+        or "drive.usercontent.google.com" in drive_link[0]
+    ):
+        return drive_link[0]
+    else:
+        raise DirectDownloadLinkException(
+            "ERROR: Drive Link not found, Try in your broswer"
+        )
+
+
+def wetransfer(url):
+    with create_scraper() as session:
+        try:
+            url = session.get(url).url
+            splited_url = url.split("/")
+            json_data = {"security_hash": splited_url[-1], "intent": "entire_transfer"}
+            res = session.post(
+                f"https://wetransfer.com/api/v4/transfers/{splited_url[-2]}/download",
+                json=json_data,
+            ).json()
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if "direct_link" in res:
+        return res["direct_link"]
+    elif "message" in res:
+        raise DirectDownloadLinkException(f"ERROR: {res['message']}")
+    elif "error" in res:
+        raise DirectDownloadLinkException(f"ERROR: {res['error']}")
+    else:
+        raise DirectDownloadLinkException("ERROR: cannot find direct link")
+
+
+def akmfiles(url):
+    with create_scraper() as session:
+        try:
+            html = HTML(
+                session.post(
+                    url,
+                    data={"op": "download2", "id": url.split("/")[-1]},
+                ).text
+            )
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if direct_link := html.xpath("//a[contains(@class,'btn btn-dow')]/@href"):
+        return direct_link[0]
+    else:
+        raise DirectDownloadLinkException("ERROR: Direct link not found")
+
+
+def shrdsk(url):
+    with create_scraper() as session:
+        try:
+            _json = session.get(
+                f"https://us-central1-affiliate2apk.cloudfunctions.net/get_data?shortid={url.split('/')[-1]}",
+            ).json()
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+        if "download_data" not in _json:
+            raise DirectDownloadLinkException("ERROR: Download data not found")
+        try:
+            _res = session.get(
+                f"https://shrdsk.me/download/{_json['download_data']}",
+                allow_redirects=False,
+            )
+            if "Location" in _res.headers:
+                return _res.headers["Location"]
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    raise DirectDownloadLinkException("ERROR: cannot find direct link in headers")
+
+
+def linkBox(url: str):
+    parsed_url = urlparse(url)
+    try:
+        shareToken = parsed_url.path.split("/")[-1]
+    except Exception:
+        raise DirectDownloadLinkException("ERROR: invalid URL")
+
+    details = {"contents": [], "title": "", "total_size": 0}
+
+    def __singleItem(session, itemId):
+        try:
+            _json = session.get(
+                "https://www.linkbox.to/api/file/detail",
+                params={"itemId": itemId},
+            ).json()
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+        data = _json["data"]
+        if not data:
+            if "msg" in _json:
+                raise DirectDownloadLinkException(f"ERROR: {_json['msg']}")
+            raise DirectDownloadLinkException("ERROR: data not found")
+        itemInfo = data["itemInfo"]
+        if not itemInfo:
+            raise DirectDownloadLinkException("ERROR: itemInfo not found")
+        filename = itemInfo["name"]
+        sub_type = itemInfo.get("sub_type")
+        if sub_type and not filename.strip().endswith(sub_type):
+            filename += f".{sub_type}"
+        if not details["title"]:
+            details["title"] = filename
+        item = {
+            "path": "",
+            "filename": filename,
+            "url": itemInfo["url"],
+        }
+        if "size" in itemInfo:
+            size = itemInfo["size"]
+            if isinstance(size, str) and size.isdigit():
+                size = float(size)
+            details["total_size"] += size
+        details["contents"].append(item)
+
+    def __fetch_links(session, _id=0, folderPath=""):
+        params = {
+            "shareToken": shareToken,
+            "pageSize": 1000,
+            "pid": _id,
+        }
+        try:
+            _json = session.get(
+                "https://www.linkbox.to/api/file/share_out_list",
+                params=params,
+            ).json()
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+        data = _json["data"]
+        if not data:
+            if "msg" in _json:
+                raise DirectDownloadLinkException(f"ERROR: {_json['msg']}")
+            raise DirectDownloadLinkException("ERROR: data not found")
+        try:
+            if data["shareType"] == "singleItem":
+                return __singleItem(session, data["itemId"])
+        except Exception:
+            pass
+        if not details["title"]:
+            details["title"] = data["dirName"]
+        contents = data["list"]
+        if not contents:
+            return
+        for content in contents:
+            if content["type"] == "dir" and "url" not in content:
+                if not folderPath:
+                    newFolderPath = ospath.join(details["title"], content["name"])
+                else:
+                    newFolderPath = ospath.join(folderPath, content["name"])
+                if not details["title"]:
+                    details["title"] = content["name"]
+                __fetch_links(session, content["id"], newFolderPath)
+            elif "url" in content:
+                if not folderPath:
+                    folderPath = details["title"]
+                filename = content["name"]
+                if (
+                    sub_type := content.get("sub_type")
+                ) and not filename.strip().endswith(sub_type):
+                    filename += f".{sub_type}"
+                item = {
+                    "path": ospath.join(folderPath),
+                    "filename": filename,
+                    "url": content["url"],
+                }
+                if "size" in content:
+                    size = content["size"]
+                    if isinstance(size, str) and size.isdigit():
+                        size = float(size)
+                    details["total_size"] += size
+                details["contents"].append(item)
+
+    try:
+        with Session() as session:
+            __fetch_links(session)
+    except DirectDownloadLinkException as e:
+        raise e
+    return details
+
+
+def gofile(url):
+    try:
+        if "::" in url:
+            _password = url.split("::")[-1]
+            _password = sha256(_password.encode("utf-8")).hexdigest()
+            url = url.split("::")[-2]
+        else:
+            _password = ""
+        _id = url.split("/")[-1]
+    except Exception as e:
+        raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}")
+
+    def __get_token(session):
+        headers = {
+            "User-Agent": user_agent,
+            "Accept-Encoding": "gzip, deflate, br",
+            "Accept": "*/*",
+            "Connection": "keep-alive",
+        }
+        __url = "https://api.gofile.io/accounts"
+        try:
+            __res = session.post(__url, headers=headers).json()
+            if __res["status"] != "ok":
+                raise DirectDownloadLinkException("ERROR: Failed to get token.")
+            return __res["data"]["token"]
+        except Exception as e:
+            raise e
+
+    def __fetch_links(session, _id, folderPath=""):
+        _url = f"https://api.gofile.io/contents/{_id}?cache=true"
+        headers = {
+            "User-Agent": user_agent,
+            "Accept-Encoding": "gzip, deflate, br",
+            "Accept": "*/*",
+            "Connection": "keep-alive",
+            "Authorization": "Bearer" + " " + token,
+            "X-Website-Token": "4fd6sg89d7s6",
+        }
+        if _password:
+            _url += f"&password={_password}"
+        try:
+            _json = session.get(_url, headers=headers).json()
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}")
+        if _json["status"] in "error-passwordRequired":
+            raise DirectDownloadLinkException(
+                f"ERROR:\n{PASSWORD_ERROR_MESSAGE.format(url)}"
+            )
+        if _json["status"] in "error-passwordWrong":
+            raise DirectDownloadLinkException("ERROR: This password is wrong !")
+        if _json["status"] in "error-notFound":
+            raise DirectDownloadLinkException(
+                "ERROR: File not found on gofile's server"
+            )
+        if _json["status"] in "error-notPublic":
+            raise DirectDownloadLinkException("ERROR: This folder is not public")
+
+        data = _json["data"]
+
+        if not details["title"]:
+            details["title"] = data["name"] if data["type"] == "folder" else _id
+
+        contents = data["children"]
+        for content in contents.values():
+            if content["type"] == "folder":
+                if not content["public"]:
+                    continue
+                if not folderPath:
+                    newFolderPath = ospath.join(details["title"], content["name"])
+                else:
+                    newFolderPath = ospath.join(folderPath, content["name"])
+                __fetch_links(session, content["id"], newFolderPath)
+            else:
+                if not folderPath:
+                    folderPath = details["title"]
+                item = {
+                    "path": ospath.join(folderPath),
+                    "filename": content["name"],
+                    "url": content["link"],
+                }
+                if "size" in content:
+                    size = content["size"]
+                    if isinstance(size, str) and size.isdigit():
+                        size = float(size)
+                    details["total_size"] += size
+                details["contents"].append(item)
+
+    details = {"contents": [], "title": "", "total_size": 0}
+    with Session() as session:
+        try:
+            token = __get_token(session)
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}")
+        details["header"] = f"Cookie: accountToken={token}"
+        try:
+            __fetch_links(session, _id)
+        except Exception as e:
+            raise DirectDownloadLinkException(e)
+
+    if len(details["contents"]) == 1:
+        return (details["contents"][0]["url"], details["header"])
+    return details
+
+
+def mediafireFolder(url):
+    if "::" in url:
+        _password = url.split("::")[-1]
+        url = url.split("::")[-2]
+    else:
+        _password = ""
+    try:
+        raw = url.split("/", 4)[-1]
+        folderkey = raw.split("/", 1)[0]
+        folderkey = folderkey.split(",")
+    except Exception:
+        raise DirectDownloadLinkException("ERROR: Could not parse ")
+    if len(folderkey) == 1:
+        folderkey = folderkey[0]
+    details = {"contents": [], "title": "", "total_size": 0, "header": ""}
+
+    session = create_scraper()
+    adapter = HTTPAdapter(
+        max_retries=Retry(total=10, read=10, connect=10, backoff_factor=0.3)
+    )
+    session.mount("http://", adapter)
+    session.mount("https://", adapter)
+    session = create_scraper(
+        browser={"browser": "firefox", "platform": "windows", "mobile": False},
+        delay=10,
+        sess=session,
+    )
+    folder_infos = []
+
+    def __get_info(folderkey):
+        try:
+            if isinstance(folderkey, list):
+                folderkey = ",".join(folderkey)
+            _json = session.post(
+                "https://www.mediafire.com/api/1.5/folder/get_info.php",
+                data={
+                    "recursive": "yes",
+                    "folder_key": folderkey,
+                    "response_format": "json",
+                },
+            ).json()
+        except Exception as e:
+            raise DirectDownloadLinkException(
+                f"ERROR: {e.__class__.__name__} While getting info"
+            )
+        _res = _json["response"]
+        if "folder_infos" in _res:
+            folder_infos.extend(_res["folder_infos"])
+        elif "folder_info" in _res:
+            folder_infos.append(_res["folder_info"])
+        elif "message" in _res:
+            raise DirectDownloadLinkException(f"ERROR: {_res['message']}")
+        else:
+            raise DirectDownloadLinkException("ERROR: something went wrong!")
+
+    try:
+        __get_info(folderkey)
+    except Exception as e:
+        raise DirectDownloadLinkException(e)
+
+    details["title"] = folder_infos[0]["name"]
+
+    def __scraper(url):
+        session = create_scraper()
+        parsed_url = urlparse(url)
+        url = f"{parsed_url.scheme}://{parsed_url.netloc}{parsed_url.path}"
+
+        def __repair_download(url):
+            try:
+                html = HTML(session.get(url).text)
+                if new_link := html.xpath('//a[@id="continue-btn"]/@href'):
+                    return __scraper(f"https://mediafire.com/{new_link[0]}")
+            except Exception:
+                return
+
+        try:
+            html = HTML(session.get(url).text)
+        except Exception:
+            return
+        if html.xpath("//div[@class='passwordPrompt']"):
+            if not _password:
+                raise DirectDownloadLinkException(
+                    f"ERROR: {PASSWORD_ERROR_MESSAGE}".format(url)
+                )
+            try:
+                html = HTML(session.post(url, data={"downloadp": _password}).text)
+            except Exception:
+                return
+            if html.xpath("//div[@class='passwordPrompt']"):
+                return
+        if final_link := html.xpath('//a[@aria-label="Download file"]/@href'):
+            if final_link[0].startswith("//"):
+                return __scraper(f"https://{final_link[0][2:]}")
+            return final_link[0]
+        if repair_link := html.xpath("//a[@class='retry']/@href"):
+            return __repair_download(repair_link[0])
+
+    def __get_content(folderKey, folderPath="", content_type="folders"):
+        try:
+            params = {
+                "content_type": content_type,
+                "folder_key": folderKey,
+                "response_format": "json",
+            }
+            _json = session.get(
+                "https://www.mediafire.com/api/1.5/folder/get_content.php",
+                params=params,
+            ).json()
+        except Exception as e:
+            raise DirectDownloadLinkException(
+                f"ERROR: {e.__class__.__name__} While getting content"
+            )
+        _res = _json["response"]
+        if "message" in _res:
+            raise DirectDownloadLinkException(f"ERROR: {_res['message']}")
+        _folder_content = _res["folder_content"]
+        if content_type == "folders":
+            folders = _folder_content["folders"]
+            for folder in folders:
+                if folderPath:
+                    newFolderPath = ospath.join(folderPath, folder["name"])
+                else:
+                    newFolderPath = ospath.join(folder["name"])
+                __get_content(folder["folderkey"], newFolderPath)
+            __get_content(folderKey, folderPath, "files")
+        else:
+            files = _folder_content["files"]
+            for file in files:
+                item = {}
+                if not (_url := __scraper(file["links"]["normal_download"])):
+                    continue
+                item["filename"] = file["filename"]
+                if not folderPath:
+                    folderPath = details["title"]
+                item["path"] = ospath.join(folderPath)
+                item["url"] = _url
+                if "size" in file:
+                    size = file["size"]
+                    if isinstance(size, str) and size.isdigit():
+                        size = float(size)
+                    details["total_size"] += size
+                details["contents"].append(item)
+
+    try:
+        for folder in folder_infos:
+            __get_content(folder["folderkey"], folder["name"])
+    except Exception as e:
+        raise DirectDownloadLinkException(e)
+    finally:
+        session.close()
+    if len(details["contents"]) == 1:
+        return (details["contents"][0]["url"], details["header"])
+    return details
+
+
+def cf_bypass(url):
+    "DO NOT ABUSE THIS"
+    try:
+        data = {"cmd": "request.get", "url": url, "maxTimeout": 60000}
+        _json = post(
+            "https://cf.jmdkh.eu.org/v1",
+            headers={"Content-Type": "application/json"},
+            json=data,
+        ).json()
+        if _json["status"] == "ok":
+            return _json["solution"]["response"]
+    except Exception as e:
+        e
+    raise DirectDownloadLinkException("ERROR: Con't bypass cloudflare")
+
+
+def send_cm_file(url, file_id=None):
+    if "::" in url:
+        _password = url.split("::")[-1]
+        url = url.split("::")[-2]
+    else:
+        _password = ""
+    _passwordNeed = False
+    with create_scraper() as session:
+        if file_id is None:
+            try:
+                html = HTML(session.get(url).text)
+            except Exception as e:
+                raise DirectDownloadLinkException(
+                    f"ERROR: {e.__class__.__name__}"
+                ) from e
+            if html.xpath("//input[@name='password']"):
+                _passwordNeed = True
+            if not (file_id := html.xpath("//input[@name='id']/@value")):
+                raise DirectDownloadLinkException("ERROR: file_id not found")
+        try:
+            data = {"op": "download2", "id": file_id}
+            if _password and _passwordNeed:
+                data["password"] = _password
+            _res = session.post("https://send.cm/", data=data, allow_redirects=False)
+            if "Location" in _res.headers:
+                return (_res.headers["Location"], "Referer: https://send.cm/")
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+        if _passwordNeed:
+            raise DirectDownloadLinkException(
+                f"ERROR:\n{PASSWORD_ERROR_MESSAGE.format(url)}"
+            )
+        raise DirectDownloadLinkException("ERROR: Direct link not found")
+
+
+def send_cm(url):
+    if "/d/" in url:
+        return send_cm_file(url)
+    elif "/s/" not in url:
+        file_id = url.split("/")[-1]
+        return send_cm_file(url, file_id)
+    splitted_url = url.split("/")
+    details = {
+        "contents": [],
+        "title": "",
+        "total_size": 0,
+        "header": "Referer: https://send.cm/",
+    }
+    if len(splitted_url) == 5:
+        url += "/"
+        splitted_url = url.split("/")
+    if len(splitted_url) >= 7:
+        details["title"] = splitted_url[5]
+    else:
+        details["title"] = splitted_url[-1]
+    session = Session()
+
+    def __collectFolders(html):
+        folders = []
+        folders_urls = html.xpath("//h6/a/@href")
+        folders_names = html.xpath("//h6/a/text()")
+        for folders_url, folders_name in zip(folders_urls, folders_names):
+            folders.append(
+                {
+                    "folder_link": folders_url.strip(),
+                    "folder_name": folders_name.strip(),
+                }
+            )
+        return folders
+
+    def __getFile_link(file_id):
+        try:
+            _res = session.post(
+                "https://send.cm/",
+                data={"op": "download2", "id": file_id},
+                allow_redirects=False,
+            )
+            if "Location" in _res.headers:
+                return _res.headers["Location"]
+        except Exception:
+            pass
+
+    def __getFiles(html):
+        files = []
+        hrefs = html.xpath('//tr[@class="selectable"]//a/@href')
+        file_names = html.xpath('//tr[@class="selectable"]//a/text()')
+        sizes = html.xpath('//tr[@class="selectable"]//span/text()')
+        for href, file_name, size_text in zip(hrefs, file_names, sizes):
+            files.append(
+                {
+                    "file_id": href.split("/")[-1],
+                    "file_name": file_name.strip(),
+                    "size": speed_string_to_bytes(size_text.strip()),
+                }
+            )
+        return files
+
+    def __writeContents(html_text, folderPath=""):
+        folders = __collectFolders(html_text)
+        for folder in folders:
+            _html = HTML(cf_bypass(folder["folder_link"]))
+            __writeContents(_html, ospath.join(folderPath, folder["folder_name"]))
+        files = __getFiles(html_text)
+        for file in files:
+            if not (link := __getFile_link(file["file_id"])):
+                continue
+            item = {"url": link, "filename": file["filename"], "path": folderPath}
+            details["total_size"] += file["size"]
+            details["contents"].append(item)
+
+    try:
+        mainHtml = HTML(cf_bypass(url))
+    except DirectDownloadLinkException as e:
+        session.close()
+        raise e
+    except Exception as e:
+        session.close()
+        raise DirectDownloadLinkException(
+            f"ERROR: {e.__class__.__name__} While getting mainHtml"
+        )
+    try:
+        __writeContents(mainHtml, details["title"])
+    except DirectDownloadLinkException as e:
+        session.close()
+        raise e
+    except Exception as e:
+        session.close()
+        raise DirectDownloadLinkException(
+            f"ERROR: {e.__class__.__name__} While writing Contents"
+        )
+    session.close()
+    if len(details["contents"]) == 1:
+        return (details["contents"][0]["url"], details["header"])
+    return details
+
+
+def doods(url):
+    if "/e/" in url:
+        url = url.replace("/e/", "/d/")
+    parsed_url = urlparse(url)
+    with create_scraper() as session:
+        try:
+            html = HTML(session.get(url).text)
+        except Exception as e:
+            raise DirectDownloadLinkException(
+                f"ERROR: {e.__class__.__name__} While fetching token link"
+            ) from e
+        if not (link := html.xpath("//div[@class='download-content']//a/@href")):
+            raise DirectDownloadLinkException(
+                "ERROR: Token Link not found or maybe not allow to download! open in browser."
+            )
+        link = f"{parsed_url.scheme}://{parsed_url.hostname}{link[0]}"
+        sleep(2)
+        try:
+            _res = session.get(link)
+        except Exception as e:
+            raise DirectDownloadLinkException(
+                f"ERROR: {e.__class__.__name__} While fetching download link"
+            ) from e
+    if not (link := search(r"window\.open\('(\S+)'", _res.text)):
+        raise DirectDownloadLinkException("ERROR: Download link not found try again")
+    return (link.group(1), f"Referer: {parsed_url.scheme}://{parsed_url.hostname}/")
+
+
+def easyupload(url):
+    if "::" in url:
+        _password = url.split("::")[-1]
+        url = url.split("::")[-2]
+    else:
+        _password = ""
+    file_id = url.split("/")[-1]
+    with create_scraper() as session:
+        try:
+            _res = session.get(url)
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}")
+        first_page_html = HTML(_res.text)
+        if (
+            first_page_html.xpath("//h6[contains(text(),'Password Protected')]")
+            and not _password
+        ):
+            raise DirectDownloadLinkException(
+                f"ERROR:\n{PASSWORD_ERROR_MESSAGE.format(url)}"
+            )
+        if not (
+            match := search(
+                r"https://eu(?:[1-9][0-9]?|100)\.easyupload\.io/action\.php", _res.text
+            )
+        ):
+            raise DirectDownloadLinkException(
+                "ERROR: Failed to get server for EasyUpload Link"
+            )
+        action_url = match.group()
+        session.headers.update({"referer": "https://easyupload.io/"})
+        recaptcha_params = {
+            "k": "6LfWajMdAAAAAGLXz_nxz2tHnuqa-abQqC97DIZ3",
+            "ar": "1",
+            "co": "aHR0cHM6Ly9lYXN5dXBsb2FkLmlvOjQ0Mw..",
+            "hl": "en",
+            "v": "0hCdE87LyjzAkFO5Ff-v7Hj1",
+            "size": "invisible",
+            "cb": "c3o1vbaxbmwe",
+        }
+        if not (captcha_token := get_captcha_token(session, recaptcha_params)):
+            raise DirectDownloadLinkException("ERROR: Captcha token not found")
+        try:
+            data = {
+                "type": "download-token",
+                "url": file_id,
+                "value": _password,
+                "captchatoken": captcha_token,
+                "method": "regular",
+            }
+            json_resp = session.post(url=action_url, data=data).json()
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if "download_link" in json_resp:
+        return json_resp["download_link"]
+    elif "data" in json_resp:
+        raise DirectDownloadLinkException(
+            f"ERROR: Failed to generate direct link due to {json_resp['data']}"
+        )
+    raise DirectDownloadLinkException(
+        "ERROR: Failed to generate direct link from EasyUpload."
+    )
+
+
+def filelions_and_streamwish(url):
+    parsed_url = urlparse(url)
+    hostname = parsed_url.hostname
+    scheme = parsed_url.scheme
+    if any(
+        x in hostname
+        for x in [
+            "filelions.co",
+            "filelions.live",
+            "filelions.to",
+            "filelions.site",
+            "cabecabean.lol",
+            "filelions.online",
+            "mycloudz.cc",
+        ]
+    ):
+        apiKey = Config.FILELION_API
+        apiUrl = "https://vidhideapi.com"
+    elif any(
+        x in hostname
+        for x in [
+            "embedwish.com",
+            "kissmovies.net",
+            "kitabmarkaz.xyz",
+            "wishfast.top",
+            "streamwish.to",
+        ]
+    ):
+        apiKey = Config.STREAMWISH_API
+        apiUrl = "https://api.streamwish.com"
+    if not apiKey:
+        raise DirectDownloadLinkException(
+            f"ERROR: API is not provided get it from {scheme}://{hostname}"
+        )
+    file_code = url.split("/")[-1]
+    quality = ""
+    if bool(file_code.strip().endswith(("_o", "_h", "_n", "_l"))):
+        spited_file_code = file_code.rsplit("_", 1)
+        quality = spited_file_code[1]
+        file_code = spited_file_code[0]
+    url = f"{scheme}://{hostname}/{file_code}"
+    with Session() as session:
+        try:
+            _res = session.get(
+                f"{apiUrl}/api/file/direct_link",
+                params={"key": apiKey, "file_code": file_code, "hls": "1"},
+            ).json()
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if _res["status"] != 200:
+        raise DirectDownloadLinkException(f"ERROR: {_res['msg']}")
+    result = _res["result"]
+    if not result["versions"]:
+        raise DirectDownloadLinkException("ERROR: File Not Found")
+    error = "\nProvide a quality to download the video\nAvailable Quality:"
+    for version in result["versions"]:
+        if quality == version["name"]:
+            return version["url"]
+        elif version["name"] == "l":
+            error += "\nLow"
+        elif version["name"] == "n":
+            error += "\nNormal"
+        elif version["name"] == "o":
+            error += "\nOriginal"
+        elif version["name"] == "h":
+            error += "\nHD"
+        error += f" <code>{url}_{version['name']}</code>"
+    raise DirectDownloadLinkException(f"ERROR: {error}")
+
+
+def streamvid(url: str):
+    file_code = url.split("/")[-1]
+    parsed_url = urlparse(url)
+    url = f"{parsed_url.scheme}://{parsed_url.hostname}/d/{file_code}"
+    quality_defined = bool(url.strip().endswith(("_o", "_h", "_n", "_l")))
+    with create_scraper() as session:
+        try:
+            html = HTML(session.get(url).text)
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+        if quality_defined:
+            data = {}
+            if not (inputs := html.xpath('//form[@id="F1"]//input')):
+                raise DirectDownloadLinkException("ERROR: No inputs found")
+            for i in inputs:
+                if key := i.get("name"):
+                    data[key] = i.get("value")
+            try:
+                html = HTML(session.post(url, data=data).text)
+            except Exception as e:
+                raise DirectDownloadLinkException(
+                    f"ERROR: {e.__class__.__name__}"
+                ) from e
+            if not (
+                script := html.xpath(
+                    '//script[contains(text(),"document.location.href")]/text()'
+                )
+            ):
+                if error := html.xpath(
+                    '//div[@class="alert alert-danger"][1]/text()[2]'
+                ):
+                    raise DirectDownloadLinkException(f"ERROR: {error[0]}")
+                raise DirectDownloadLinkException(
+                    "ERROR: direct link script not found!"
+                )
+            if directLink := findall(r'document\.location\.href="(.*)"', script[0]):
+                return directLink[0]
+            raise DirectDownloadLinkException(
+                "ERROR: direct link not found! in the script"
+            )
+        elif (qualities_urls := html.xpath('//div[@id="dl_versions"]/a/@href')) and (
+            qualities := html.xpath('//div[@id="dl_versions"]/a/text()[2]')
+        ):
+            error = "\nProvide a quality to download the video\nAvailable Quality:"
+            for quality_url, quality in zip(qualities_urls, qualities):
+                error += f"\n{quality.strip()} <code>{quality_url}</code>"
+            raise DirectDownloadLinkException(f"ERROR: {error}")
+        elif error := html.xpath('//div[@class="not-found-text"]/text()'):
+            raise DirectDownloadLinkException(f"ERROR: {error[0]}")
+        raise DirectDownloadLinkException("ERROR: Something went wrong")
+
+
+def streamhub(url):
+    file_code = url.split("/")[-1]
+    parsed_url = urlparse(url)
+    url = f"{parsed_url.scheme}://{parsed_url.hostname}/d/{file_code}"
+    with create_scraper() as session:
+        try:
+            html = HTML(session.get(url).text)
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+        if not (inputs := html.xpath('//form[@name="F1"]//input')):
+            raise DirectDownloadLinkException("ERROR: No inputs found")
+        data = {}
+        for i in inputs:
+            if key := i.get("name"):
+                data[key] = i.get("value")
+        session.headers.update({"referer": url})
+        sleep(1)
+        try:
+            html = HTML(session.post(url, data=data).text)
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+        if directLink := html.xpath(
+            '//a[@class="btn btn-primary btn-go downloadbtn"]/@href'
+        ):
+            return directLink[0]
+        if error := html.xpath('//div[@class="alert alert-danger"]/text()[2]'):
+            raise DirectDownloadLinkException(f"ERROR: {error[0]}")
+        raise DirectDownloadLinkException("ERROR: direct link not found!")
+
+
+def pcloud(url):
+    with create_scraper() as session:
+        try:
+            res = session.get(url)
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    if link := findall(r".downloadlink.:..(https:.*)..", res.text):
+        return link[0].replace(r"\/", "/")
+    raise DirectDownloadLinkException("ERROR: Direct link not found")
+
+
+def tmpsend(url):
+    parsed_url = urlparse(url)
+    if any(x in parsed_url.path for x in ["thank-you", "download"]):
+        query_params = parse_qs(parsed_url.query)
+        if file_id := query_params.get("d"):
+            file_id = file_id[0]
+    elif not (file_id := parsed_url.path.strip("/")):
+        raise DirectDownloadLinkException("ERROR: Invalid URL format")
+    referer_url = f"https://tmpsend.com/thank-you?d={file_id}"
+    header = f"Referer: {referer_url}"
+    download_link = f"https://tmpsend.com/download?d={file_id}"
+    return download_link, header
+
+
+def qiwi(url):
+    """qiwi.gg link generator
+    based on https://github.com/aenulrofik"""
+    with Session() as session:
+        file_id = url.split("/")[-1]
+        try:
+            res = session.get(url).text
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+        tree = HTML(res)
+        if name := tree.xpath('//h1[@class="page_TextHeading__VsM7r"]/text()'):
+            ext = name[0].split(".")[-1]
+            return f"https://spyderrock.com/{file_id}.{ext}"
+        else:
+            raise DirectDownloadLinkException("ERROR: File not found")
+
+
+def mp4upload(url):
+    with Session() as session:
+        try:
+            url = url.replace("embed-", "")
+            req = session.get(url).text
+            tree = HTML(req)
+            inputs = tree.xpath("//input")
+            header = {"Referer": "https://www.mp4upload.com/"}
+            data = {input.get("name"): input.get("value") for input in inputs}
+            if not data:
+                raise DirectDownloadLinkException("ERROR: File Not Found!")
+            post = session.post(
+                url,
+                data=data,
+                headers={
+                    "User-Agent": user_agent,
+                    "Referer": "https://www.mp4upload.com/",
+                },
+            ).text
+            tree = HTML(post)
+            inputs = tree.xpath('//form[@name="F1"]//input')
+            data = {
+                input.get("name"): input.get("value").replace(" ", "")
+                for input in inputs
+            }
+            if not data:
+                raise DirectDownloadLinkException("ERROR: File Not Found!")
+            data["referer"] = url
+            direct_link = session.post(url, data=data).url
+            return direct_link, header
+        except Exception:
+            raise DirectDownloadLinkException("ERROR: File Not Found!")
+
+
+def berkasdrive(url):
+    """berkasdrive.com link generator
+    by https://github.com/aenulrofik"""
+    with Session() as session:
+        try:
+            sesi = session.get(url).text
+        except Exception as e:
+            raise DirectDownloadLinkException(f"ERROR: {e.__class__.__name__}") from e
+    html = HTML(sesi)
+    if link := html.xpath("//script")[0].text.split('"')[1]:
+        return b64decode(link).decode("utf-8")
+    else:
+        raise DirectDownloadLinkException("ERROR: File Not Found!")
+
+
+def swisstransfer(link):
+    matched_link = match(
+        r"https://www\.swisstransfer\.com/d/([\w-]+)(?:\:\:(\w+))?", link
+    )
+    if not matched_link:
+        raise DirectDownloadLinkException(
+            f"ERROR: Invalid SwissTransfer link format {link}"
+        )
+
+    transfer_id, password = matched_link.groups()
+    password = password or ""
+
+    def encode_password(password):
+        return b64encode(password.encode("utf-8")).decode("utf-8") if password else ""
+
+    def getfile(transfer_id, password):
+        url = f"https://www.swisstransfer.com/api/links/{transfer_id}"
+        headers = {
+            "User-Agent": "Mozilla/5.0",
+            "Authorization": encode_password(password) if password else "",
+            "Content-Type": "application/json" if not password else "",
+        }
+        response = get(url, headers=headers)
+
+        if response.status_code == 200:
+            try:
+                return response.json(), headers
+            except ValueError:
+                raise DirectDownloadLinkException(
+                    f"ERROR: Error parsing JSON response {response.text}"
+                )
+        raise DirectDownloadLinkException(
+            f"ERROR: Error fetching file details {response.status_code}, {response.text}"
+        )
+
+    def gettoken(password, containerUUID, fileUUID):
+        url = "https://www.swisstransfer.com/api/generateDownloadToken"
+        headers = {
+            "User-Agent": "Mozilla/5.0",
+            "Content-Type": "application/json",
+        }
+        body = {
+            "password": password,
+            "containerUUID": containerUUID,
+            "fileUUID": fileUUID,
+        }
+
+        response = post(url, headers=headers, json=body)
+
+        if response.status_code == 200:
+            return response.text.strip().replace('"', "")
+        raise DirectDownloadLinkException(
+            f"ERROR: Error generating download token {response.status_code}, {response.text}"
+        )
+
+    data, headers = getfile(transfer_id, password)
+    if not data:
+        return None
+
+    try:
+        container_uuid = data["data"]["containerUUID"]
+        download_host = data["data"]["downloadHost"]
+        files = data["data"]["container"]["files"]
+        folder_name = data["data"]["container"]["message"] or "unknown"
+    except (KeyError, IndexError, TypeError) as e:
+        raise DirectDownloadLinkException(f"ERROR: Error parsing file details {e}")
+
+    total_size = sum(file["fileSizeInBytes"] for file in files)
+
+    if len(files) == 1:
+        file = files[0]
+        file_uuid = file["UUID"]
+        token = gettoken(password, container_uuid, file_uuid)
+        download_url = f"https://{download_host}/api/download/{transfer_id}/{file_uuid}?token={token}"
+        return download_url, "User-Agent:Mozilla/5.0"
+
+    contents = []
+    for file in files:
+        file_uuid = file["UUID"]
+        file_name = file["fileName"]
+        file_size = file["fileSizeInBytes"]
+
+        token = gettoken(password, container_uuid, file_uuid)
+        if not token:
+            continue
+
+        download_url = f"https://{download_host}/api/download/{transfer_id}/{file_uuid}?token={token}"
+        contents.append({"filename": file_name, "path": "", "url": download_url})
+
+    return {
+        "contents": contents,
+        "title": folder_name,
+        "total_size": total_size,
+        "header": "User-Agent:Mozilla/5.0",
+    }
+
+
+def instagram(link: str) -> str:
+    """
+    Fetches the direct video download URL from an Instagram post.
+
+    Args:
+        link (str): The Instagram post URL.
+
+    Returns:
+        str: The direct video URL.
+
+    Raises:
+        DirectDownloadLinkException: If any error occurs during the process.
+    """
+    api_url = Config.INSTADL_API or "https://instagramcdn.vercel.app"
+    full_url = f"{api_url}/api/video?postUrl={link}"
+
+    try:
+        response = get(full_url)
+        response.raise_for_status()
+        data = response.json()
+
+        if (
+            data.get("status") == "success"
+            and "data" in data
+            and "videoUrl" in data["data"]
+        ):
+            return data["data"]["videoUrl"]
+
+        raise DirectDownloadLinkException("ERROR: Failed to retrieve video URL.")
+
+    except Exception as e:
+        raise DirectDownloadLinkException(f"ERROR: {e}")