Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,7 @@
+.git
+.gitignore
+__pycache__
+*.pyc
+venv
+.env
+db.sqlite3

.gitignore

@@ -0,0 +1,9 @@
+*.session
+*.session-journal
+*.env
+test.py
+__pycache__
+
+tgfs/patches/*
+!tgfs/patches/__init__.py
+!tgfs/patches/README.md

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+# Hugging Face deployment requirements
+ENV PORT=7860
+ENV HOST=0.0.0.0
+EXPOSE 7860
+
+CMD ["python", "-m", "tgfs"]

LICENSE

@@ -0,0 +1,662 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://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.
+
+TG-FileStream – A web server and Telegram client that acts as a proxy between the Telegram servers and an HTTP client to enable file downloads.
+
+    Copyright (C)2025-2026 DeekshithSH
+
+    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 <http://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
+<http://www.gnu.org/licenses/>.

README.md

@@ -1,11 +1,169 @@
+# TG-FileStream
+
+> This project is released under the **GNU AGPL v3** license.  
+> You are free to use, modify, and distribute it — as long as you share your changes under the same license.
+
+**TG-FileStream** is a lightweight web server and Telegram client that acts as a proxy between Telegram servers and HTTP clients, allowing direct downloads of Telegram media files via HTTP.
+
+> 📌 Check out [TODO.md](./TODO.md) for the latest development progress and planned features.
+
+---
+
+## 📝 Notes
+
+- If you want one without database checkout [DeekshithSH/tgfilestream](https://github.com/DeekshithSH/tgfilestream) or [simple branch](https://github.com/SpringsFern/TG-FileStream/tree/simple)
+
 ---
-title: Tgfs
-emoji: 😻
-colorFrom: red
-colorTo: red
-sdk: docker
-pinned: false
-license: mit
+
+## 🚀 Features
+
+- Download Telegram media via HTTP links
+- Fast, concurrent chunked downloading
+
+---
+
+## 🛠️ Setup
+
+### 1. Clone the repository
+
+```bash
+git clone https://github.com/SpringsFern/TG-FileStream.git
+cd TG-FileStream
+```
+
+### 2. Install dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Create a `.env` file
+
+Store the required environment variables in a `.env` file:
+
+```env
+API_ID=1234567
+API_HASH=1a2b3c4d5e6f7g8h9i0jklmnopqrstuv
+BOT_TOKEN=1234567890:AAExampleBotTokenGeneratedHere
+BIN_CHANNEL=-1002605638795
+HOST=0.0.0.0
+PORT=8080
+PUBLIC_URL=http://127.0.0.1:8080
+DB_BACKEND=mongodb
+MONGODB_URI=mongodb://admin:pAswaRd@192.168.27.1
+```
+
+### 4. Run the server
+
+```bash
+python3 -m tgfs
+```
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## ⚙️ Environment Variables
+
+| Variable             | Required/Default       | Description                                                                  |
+| -------------------- | ---------------------- | ---------------------------------------------------------------------------- |
+| `API_ID`             | ✅                     | App ID from [my.telegram.org](https://my.telegram.org)                       |
+| `API_HASH`           | ✅                     | API hash from [my.telegram.org](https://my.telegram.org)                     |
+| `BOT_TOKEN`          | ✅                     | Bot token from [@BotFather](https://t.me/BotFather)                          |
+| `BIN_CHANNEL`        | ✅                     | Channel ID where files sent to the bot are stored                            |
+| `DB_BACKEND`         | ✅                     | Which Database server to use. either `mongodb` or `mysql`                    |
+| `HOST`               | `0.0.0.0`              | Host address to bind the server (default: `0.0.0.0`)                         |
+| `PORT`               | `8080`                 | Port to run the server on (default: `8080`)                                  |
+| `PUBLIC_URL`         | `https://0.0.0.0:8080` | Public-facing URL used to generate download links                            |
+| `DEBUG`              | `False`                | Show Extra Logs                                                              |
+| `CONNECTION_LIMIT`   | `5`                    | Number of connections to create per DC for a single client                   |
+| `DOWNLOAD_PART_SIZE` | `1048576 (1MB)`        | Number of bytes to request in a single chunk                                 |
+| `NO_UPDATE`          | `False`                | Whether to reply to messages sent to the bot (True to disable replies)       |
+| `SEQUENTIAL_UPDATES` | `False`                | Handle telegram updates sequentially                                         |
+| `FILE_INDEX_LIMIT`   | `10`                   | Number of files to display at once with `/files` command                     |
+| `MAX_WARNS`          | `3`                    | Maximum number of warns before user get banned                               |
+| `ADMIN_IDS`          | `None`                 | User id of users who can use admin commands. Each id is seperated by `,`     |
+| `ALLOWED_IDS`        | `None`                 | Only users with these IDs can use the bot. Separate multiple IDs with `,`    |
+
+
+### Multi Token Environment Variables
+| Variable       | Required/Default | Description                                                                  |
+| -------------- | ---------------- | ---------------------------------------------------------------------------- |
+| `MULTI_TOKENx` | ✅               | Use Multiple Telegram Clients when downloading files to avoid flood wait, Replace x with Number |
+|                |                  | Example: |
+| `MULTI_TOKEN1` |                  | MULTI_TOKEN1=1234567890:AAExampleBotTokenGeneratedHere|
+| `MULTI_TOKEN2` |                  | MULTI_TOKEN2=0987654321:AAExampleBotTokenGeneratedHere|
+| `MULTI_TOKEN3` |                  | MULTI_TOKEN3=5432167890:AAExampleBotTokenGeneratedHere|
+
+### MySQL Environment Variables
+Set the following variables if you choose MySQL as the database in `DB_BACKEND`
+
+| Variable         | Required/Default | Description                                |
+| ---------------- | ---------------- | ------------------------------------------ |
+| `MYSQL_HOST`     | ✅               | MySQL DataBase Host Name                   |
+| `MYSQL_PORT`     | ✅               | MySQL Database Port Number                 |
+| `MYSQL_USER`     | ✅               | MySQL Database Username                    |
+| `MYSQL_PASSWORD` | ✅               | MySQL Database Password                    |
+| `MYSQL_DB`       | ✅               | MySQL Database Name                        |
+| `MYSQL_MINSIZE`  | `1`              | Minimum sizes of the MySQL Connection pool |
+| `MYSQL_MAXSIZE`  | `5`              | Maximum sizes of the MySQL Connection pool |
+
+### MongoDB Environment Variables
+Set the following variables if you choose MongoDB as the database in `DB_BACKEND`
+
+| Variable         | Required/Default | Description           |
+| ---------------- | ---------------- | --------------------- |
+| `MONGODB_URI`    | ✅               | MongoDB Database URI  |
+| `MONGODB_DBNAME` | `TGFS`           | MongoDB Database name |
+
+---
+
+## 📂 Usage
+
+Once the server is running, you can:
+
+- Access Telegram media files via HTTP:
+
+- Or simply send a file to your bot, and it will respond with a download link.
+
+This will stream the file directly from Telegram servers to the client.
+
+---
+
+## 🛠️ Contributing & Reporting Issues
+
+Found a bug or have a feature request? Please [open an issue](https://github.com/SpringsFern/TG-FileStream/issues) on GitHub.
+
+### 🐞 Reporting Issues
+When reporting a bug, **please include**:
+- Steps to reproduce the issue
+- Expected behavior vs actual behavior
+- Relevant logs, screenshots, or error messages (if any)
+- Environment details (OS, Python version, etc.)
+
+**Example issue title:**  
+`[Bug] Download fails for large files`
+
+### 💡 Requesting Features
+When suggesting a new feature, **please include**:
+- A clear and concise description of the feature
+- The motivation or use case for it
+- Expected behavior (input/output examples if applicable)
+- Any alternatives you've considered
+
+**Example feature title:**  
+`[Feature] Add support for viewing generated links`
+
+---
+
+Contributions are welcome!  
+Feel free to fork the project and open a pull request.
+
+> 🔍 **Note:** Make sure to test your code thoroughly before submitting a PR to help maintain stability and performance.
+
+---
+
+## 💡 Credits
+
+- **Deekshith SH** – Me
+- **Tulir** – Original author of [`tgfilestream`](https://github.com/tulir/tgfilestream), whose code inspired this project and is referenced in `paralleltransfer.py`
+
+---

TODO.md

@@ -0,0 +1,20 @@
+# ✅ TODO
+
+| Task                                                                                     | Status      |
+|------------------------------------------------------------------------------------------|-------------|
+| Rewrite the entire project based on the Telethon client                                  | ✅ Done     |
+| Reuse code from `tgfilestream` (`paralleltransfer.py`) to fetch files from Telegram      | ✅ Done     |
+| Use multiple Telegram Bot accounts to avoid flood wait                                   | ✅ Done     |
+| Add support for multiple databases                                                       | ✅ Done     |
+| Support for multiple languages                                                           | ✅ Done     |
+| Share File Info Cache between multiple clients                                           | Not Planned |
+| Prefetch chunks                                                                          | Not Planned |
+| Cache Files                                                                              | Not Planned |
+| Add More options in /files command                                                       | ⏳ Pending  |
+
+---
+
+## 🎯 Goal [⏳ Pending]
+
+> **Keep the links generated by the bot as consistent as possible.**  
+> Even if the internal code changes, previously generated links should still work.

requirements.txt

@@ -0,0 +1,7 @@
+telethon
+aiohttp
+python-dotenv
+cryptg
+aiomysql
+motor
+dnspython

tgfs/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.0.1"
+__author__ = "Deekshith SH <deekshith@spri.in>"

tgfs/__main__.py

@@ -0,0 +1,143 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import asyncio
+import traceback
+from aiohttp import web
+from telethon import functions
+from telethon.tl.types import User
+
+from tgfs.app import init_app
+from tgfs.info import Version, __version__
+from tgfs.log import log
+from tgfs.config import Config
+from tgfs.paralleltransfer import ParallelTransferrer
+from tgfs.telegram import client, load_plugins, multi_clients, start_clients
+from tgfs.database import DB
+from tgfs.utils.utils import load_configs, load_patches
+
+load_patches(Config.PATCH_PATH)
+
+app = init_app()
+runner = web.AppRunner(app, handler_cancellation=True)
+
+async def additional_check():
+    version = await DB.db.get_config_value("VERSION")
+    if version != __version__:
+        if not version:
+            await DB.db.set_config_value("VERSION", __version__)
+            return
+        _version = version.split(".", maxsplit=3)
+        major = int(_version[0])
+        minor = int(_version[1])
+        patch = int(_version[2])
+        if minor != Version.minor or major != Version.major:
+            # ToDo: Create Migration Script execute based on version
+            log.warning("version mismatch detected. Old version: %s, Current version: %s", version, __version__)
+        await DB.db.set_config_value("VERSION", __version__)
+        await DB.db.set_config_value("OLD_VERSION", version)
+
+async def start() -> None:
+    log.info("Initializing Database")
+    await DB.init()
+    await load_configs()
+    log.info("Running Checks")
+    await additional_check()
+    log.info("Starting Telegram Client")
+    await client.start(bot_token=Config.BOT_TOKEN)
+    if not Config.NO_UPDATE:
+        load_plugins("tgfs/plugins")
+
+    # https://github.com/LonamiWebs/Telethon/blob/59da66e105ba29eee7760538409181859c7d310d/telethon/client/downloads.py#L62
+    config = await client(functions.help.GetConfigRequest())
+    for option in config.dc_options:
+        if option.ip_address == client.session.server_address:
+            client.session.set_dc(
+                option.id, option.ip_address, option.port)
+            client.session.save()
+            break
+    me: User = await client.get_me()
+    Config.BOT_ID = me.id
+    transfer = ParallelTransferrer(client, me.id)
+    transfer.post_init()
+    multi_clients.append(transfer)
+    log.info("Starting Additional Clients")
+    await start_clients()
+    log.info("Starting HTTP Server")
+    await runner.setup()
+    await web.TCPSite(runner, Config.HOST, Config.PORT).start()
+    log.info("Version: %s", __version__)
+    log.info("Username: %s", me.username)
+    log.info("DC ID: %d", getattr(client.session, "dc_id", None))
+    log.info("URL: %s", Config.PUBLIC_URL)
+
+
+async def stop() -> None:
+    log.debug("Stopping HTTP Server")
+    await runner.cleanup()
+    log.debug("Closing Telegram Client and Connections")
+    await client.disconnect()
+    log.debug("Closing Database Connection")
+    await DB.close()
+    log.info("Stopped Bot and Server")
+
+def log_pending_tasks(include_stack: bool = False):
+    log_child = log.getChild("tasks")
+    current = asyncio.current_task()
+    tasks = asyncio.all_tasks()
+
+    log_child.debug("Pending asyncio tasks")
+
+    for task in tasks:
+        if task is current:
+            continue
+
+        if task.done():
+            continue
+
+        log_child.debug(
+            "Task name=%s cancelled=%s coro=%s",
+            task.get_name(),
+            task.cancelled(),
+            task.get_coro(),
+        )
+
+        if include_stack:
+            stack = task.get_stack()
+            if stack:
+                log_child.debug("Stack for task %s:", task.get_name())
+                for frame in stack:
+                    formatted = "".join(traceback.format_stack(frame))
+                    log_child.debug("%s", formatted)
+            else:
+                log_child.debug("No stack available for %s", task.get_name())
+
+async def main() -> None:
+    try:
+        await start()
+        await client.run_until_disconnected()
+    finally:
+        log_pending_tasks(True)
+        await stop()
+        log.info("Stopped Services")
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass
+    except Exception: # pylint: disable=W0718
+        log.error(traceback.format_exc())

tgfs/app.py

@@ -0,0 +1,13 @@
+from aiohttp import web
+from tgfs.routes import routes
+
+def init_routes(app: web.Application):
+    app.add_routes(routes)
+
+init_handlers = [init_routes]
+def init_app() -> web.Application:
+    app = web.Application()
+
+    for init in init_handlers:
+        init(app)
+    return app

tgfs/config.py

@@ -0,0 +1,127 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+from __future__ import annotations
+
+import argparse
+import logging
+from os import environ
+from typing import Optional
+
+from tgfs.utils.config_utils import ConfigBase
+
+log = logging.getLogger(__name__)
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    log.warning("python-dotenv not installed. Skipping .env loading.")
+
+parser = argparse.ArgumentParser(
+    prog="tg-filestream", description="TG-FileStream server",)
+parser.add_argument("--host", help="Bind host")
+parser.add_argument("--port", type=int, help="Bind port")
+parser.add_argument("--public-url", help="Public base URL")
+parser.add_argument("--connection-limit", type=int, help="Max concurrent connections")
+parser.add_argument("--db-backend", help="Database server", choices=("mysql", "mongodb"))
+parser.add_argument("--no-update", action="store_true", help="Ignore Telegram Updates")
+parser.add_argument("--session", help="Name for current instance", default="")
+args = parser.parse_args()
+
+
+class Config(ConfigBase):
+    MYSQL_REQUIRED = {"host", "user", "password", "db"}
+    MYSQL_CONFIG = {
+        "host": (str, None),
+        "port": (int, 3306),
+        "user": (str, None),
+        "password": (str, None),
+        "db": (str, None),
+        "minsize": (int, 1),
+        "maxsize": (int, 5),
+    }
+
+    MONGODB_REQUIRED = {"uri"}
+    MONGODB_CONFIG = {
+        "uri": (str, None),
+        "dbname": (str, "TGFS")
+    }
+
+    DB_LIST = {
+        "mysql": ("MYSQL", MYSQL_CONFIG, MYSQL_REQUIRED),
+        "mongodb": ("MONGODB", MONGODB_CONFIG, MONGODB_REQUIRED)
+    }
+
+    # ---------- Telegram ----------
+    API_ID: int = int(environ["API_ID"])
+    API_HASH: str = environ["API_HASH"]
+    BOT_TOKEN: str = environ["BOT_TOKEN"]
+
+    BIN_CHANNEL: int = int(environ["BIN_CHANNEL"])
+    TOKENS: list[str] = ConfigBase.get_multi_client_tokens()
+
+    # ---------- Server ----------
+    HOST: str = args.host or environ.get("HOST", "0.0.0.0")
+    PORT: int = args.port or ConfigBase.env_int("PORT", 8080)
+    PUBLIC_URL: str = args.public_url or environ.get("PUBLIC_URL", f"http://{HOST}:{PORT}")
+
+    CONNECTION_LIMIT: int = args.connection_limit or ConfigBase.env_int("CONNECTION_LIMIT", 5)
+
+    DOWNLOAD_PART_SIZE: int = ConfigBase.env_int(
+        "DOWNLOAD_PART_SIZE", 1024 * 1024
+    )
+
+    # ---------- Bot behavior ----------
+    NO_UPDATE: bool = args.no_update or ConfigBase.env_bool("NO_UPDATE")
+    SEQUENTIAL_UPDATES: bool = ConfigBase.env_bool("SEQUENTIAL_UPDATES")
+    FILE_INDEX_LIMIT: int = ConfigBase.env_int("FILE_INDEX_LIMIT", 10)
+    MAX_WARNS: int = ConfigBase.env_int("MAX_WARNS", 3)
+
+    ADMIN_IDS: set[int] = {
+        int(x)
+        for x in environ.get("ADMIN_IDS", "").split(",")
+        if x.strip().isdigit()
+    }
+    ALLOWED_IDS: set[int] = {
+        int(x)
+        for x in environ.get("ALLOWED_IDS", "").split(",")
+        if x.strip().isdigit()
+    }
+    if ALLOWED_IDS:
+        ALLOWED_IDS = ALLOWED_IDS | ADMIN_IDS
+
+    # ---------- DB ----------
+    DB_BACKEND: str = args.db_backend or environ.get("DB_BACKEND", "").lower()
+
+    if DB_BACKEND in DB_LIST:
+        DB_CONFIG: dict = ConfigBase.load_backend_config(*DB_LIST[DB_BACKEND])
+    else:
+        raise RuntimeError(
+            f"Unsupported DB_BACKEND '{DB_BACKEND}'. "
+            f"Valid options: {DB_LIST.keys()}"
+        )
+
+    SESSION_NAME: str = args.session
+
+    # ---------- Extras ----------
+    DEBUG: bool = ConfigBase.env_bool("DEBUG")
+    EXT_DEBUG: bool = ConfigBase.env_bool("EXT_DEBUG")
+    PATCH_PATH: str = environ.get("PATCH_PATH", "tgfs/patches")
+
+    # ---------- Security ----------
+    SECRET: Optional[bytes] = None
+    BOT_ID: Optional[int] = None

tgfs/database/__init__.py

@@ -0,0 +1,45 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+from typing import Optional
+from tgfs.config import Config
+from tgfs.database.mysql import MySQLDB
+from tgfs.database.mongodb import MongoDB
+from tgfs.database.database import BaseStorage
+
+_BACKENDS: dict[str, type[BaseStorage]] = {
+    "mysql": MySQLDB,
+    "mongodb": MongoDB,
+}
+
+class DB:
+    db: Optional[BaseStorage] = None
+
+    @classmethod
+    async def init(cls) -> None:
+        if cls.db is None:
+            backend = Config.DB_BACKEND
+            db_cls = _BACKENDS[backend]
+            cls.db = db_cls()
+
+        await cls.db.connect(**Config.DB_CONFIG)
+        await cls.db.init_db()
+
+    @classmethod
+    async def close(cls):
+        if cls.db:
+            await cls.db.close()
+            cls.db = None

tgfs/database/database.py

@@ -0,0 +1,171 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+from abc import ABC, abstractmethod
+from typing import AsyncGenerator, Optional
+
+from tgfs.utils.types import SupportedType, FileInfo, FileSource, GroupInfo, InputTypeLocation, User
+
+
+class BaseStorage(ABC):
+    """
+    Abstract base class for storage backends.
+    """
+
+    is_connected: bool
+
+    @abstractmethod
+    async def connect(self, **kwargs) -> None:
+        """
+        Establish a connection to the backend.
+
+        Called once during application startup.
+        Should raise an exception if the connection fails.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def close(self, force: bool = False) -> None:
+        """
+        Close all open connections and release resources.
+
+        Called during graceful shutdown.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def init_db(self) -> None:
+        """Create tables if they don't exist."""
+        raise NotImplementedError
+
+    @abstractmethod
+    async def add_file(self, user_id: int, file: FileInfo, source: FileSource) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def update_file_restriction(self, file_id: int, status: bool) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_file(self, file_id: int, user_id: Optional[int] = None) -> Optional[FileInfo]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_location(self, file: FileInfo, bot_id: int) -> Optional[InputTypeLocation]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_source(self, file_id: int, user_id: int) -> Optional[FileSource]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def upsert_location(self, bot_id: int, loc: InputTypeLocation) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_files(self, user_id: int, offset: int = 0, limit: Optional[int] = None
+                        ) -> AsyncGenerator[tuple[int, str], None]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_files2(self, user_id: int, file_ids: list[int], full: bool = False
+                         ) -> AsyncGenerator[FileInfo | tuple[int, str], None]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_file_users(self, file_id: int, ) -> set[int]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def total_files(self, user_id: int) -> int:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def delete_file(self, file_id: int) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def remove_file(self, file_id: int, user_id: int) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def create_group(self, user_id: int, name: str) -> int:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def add_file_to_group(self, group_id: int, user_id: int, file_id: int, order: Optional[int] = None) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_groups(self, user_id: int, offset: int = 0, limit: Optional[int] = None
+    ) -> AsyncGenerator[tuple[int, str], None]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_group(self, group_id: int, user_id: int) -> Optional[GroupInfo]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def delete_group(self, group_id: int, user_id: int) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def update_group_name(self, group_id: int, user_id: int, name: str) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def update_group_order(self, group_id: int, file_id: int, user_id: int, new_order: int) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def total_groups(self, user_id: int) -> int:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_user(self, user_id: int) -> Optional[User]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def add_user(self, user_id: int) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def upsert_user(self, user: User) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def delete_user(self, user_id: int) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_users(self) -> AsyncGenerator[User, None]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def count_users(self) -> int:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_secret(self, rotate=False) -> bytes:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_config_value(self, key: str) -> Optional[SupportedType]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def set_config_value(self, key: str, value: SupportedType) -> None:
+        raise NotImplementedError

tgfs/database/mongodb/__init__.py

@@ -0,0 +1,63 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase, AsyncIOMotorCollection
+
+from tgfs.database.database import BaseStorage
+
+from .file import FileDB
+from .group import GroupDB
+from .user import UserDB
+from .utils import UtilDB
+
+class MongoDB(FileDB, GroupDB, UserDB, UtilDB, BaseStorage):
+    is_connected: bool = False
+    client: AsyncIOMotorClient
+    db: AsyncIOMotorDatabase
+    files: AsyncIOMotorCollection
+    groups: AsyncIOMotorCollection
+    users: AsyncIOMotorCollection
+    config: AsyncIOMotorCollection
+
+    async def connect(self, uri: str, dbname) -> None: # pylint: disable=W0221
+        if not self.is_connected:
+            self.client = AsyncIOMotorClient(uri)
+            self.is_connected = True
+        self.db = self.client[dbname]
+
+        self.files  = self.db.files
+        self.groups = self.db.groups
+        self.users  = self.db.users
+        self.config = self.db.app_config
+
+    async def close(self, force: bool = False) -> None:
+        if self.is_connected or force:
+            self.client.close()
+            self.is_connected = False
+
+    async def init_db(self) -> None:
+        await self._create_indexes()
+
+    async def _create_indexes(self) -> None:
+        await self.files.create_index("users.user_id")
+        await self.files.create_index("is_deleted")
+        await self.files.create_index("users.added_at")
+
+        await self.groups.create_index("user_id")
+        await self.groups.create_index([("user_id", 1), ("created_at", -1)])
+
+        await self.users.create_index("ban_date")
+        await self.users.create_index("warns")

tgfs/database/mongodb/file.py

@@ -0,0 +1,226 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+from datetime import datetime, timezone
+from typing import AsyncGenerator, Optional, Union
+
+from bson import ObjectId
+from motor.motor_asyncio import AsyncIOMotorCollection, AsyncIOMotorDatabase
+from telethon.tl.types import InputDocumentFileLocation, InputPhotoFileLocation
+
+from tgfs.database.database import BaseStorage
+from tgfs.utils.types import FileInfo, FileSource, InputTypeLocation
+
+
+class FileDB(BaseStorage):
+    db: AsyncIOMotorDatabase
+    files: AsyncIOMotorCollection
+    groups: AsyncIOMotorCollection
+
+    async def add_file(self, user_id: int, file: FileInfo, source: FileSource) -> None:
+        await self.files.update_one(
+            {"_id": file.id},
+            {
+                "$set": {
+                    "dc_id": file.dc_id,
+                    "size": file.file_size,
+                    "mime_type": file.mime_type,
+                    "file_name": file.file_name,
+                    "thumb_size": file.thumb_size,
+                    "is_deleted": file.is_deleted,
+                    f"users.{user_id}": {
+                        "chat_id": source.chat_id,
+                        "message_id": source.message_id,
+                        "added_at": datetime.now(timezone.utc),
+                    },
+                }
+            },
+            upsert=True,
+        )
+
+    async def update_file_restriction(self, file_id: int, status: bool) -> None:
+        await self.files.update_one(
+            {"_id": file_id},
+            {"$set": {"is_deleted": status}},
+        )
+
+    async def get_file(self, file_id: int, user_id: Optional[int] = None) -> Optional[FileInfo]:
+        query = {"_id": file_id}
+        if user_id is not None:
+            query[f"users.{user_id}"] = {"$exists": True}
+
+        doc = await self.files.find_one(query)
+        if not doc:
+            return None
+
+        return FileInfo(
+            id=doc["_id"],
+            dc_id=doc["dc_id"],
+            file_size=doc["size"],
+            mime_type=doc.get("mime_type"),
+            file_name=doc.get("file_name"),
+            thumb_size=doc.get("thumb_size"),
+            is_deleted=bool(doc.get("is_deleted", False)),
+        )
+
+    async def get_location(self, file: FileInfo, bot_id: int) -> Optional[InputTypeLocation]:
+        doc = await self.files.find_one(
+            {"_id": file.id, f"location.{bot_id}": {"$exists": True}},
+            {f"location.{bot_id}": 1},
+        )
+        if not doc:
+            return None
+
+        loc = doc["location"][str(bot_id)]
+        cls = InputPhotoFileLocation if file.thumb_size else InputDocumentFileLocation
+        return cls(
+            id=file.id,
+            access_hash=loc["access_hash"],
+            file_reference=loc["file_reference"],
+            thumb_size=file.thumb_size,
+        )
+
+    async def get_source(self, file_id: int, user_id: int) -> Optional[FileSource]:
+        doc = await self.files.find_one(
+            {"_id": file_id, f"users.{user_id}": {"$exists": True}},
+            {f"users.{user_id}": 1},
+        )
+        if not doc:
+            return None
+
+        u = doc["users"][str(user_id)]
+        return FileSource(
+            chat_id=u["chat_id"],
+            message_id=u["message_id"],
+            time=u["added_at"],
+        )
+
+    async def upsert_location(self, bot_id: int, loc: InputTypeLocation) -> None:
+        await self.files.update_one(
+            {"_id": loc.id},
+            {
+                "$set": {
+                    f"location.{bot_id}": {
+                        "access_hash": loc.access_hash,
+                        "file_reference": loc.file_reference,
+                    }
+                }
+            },
+        )
+
+    async def get_files(
+        self, user_id: int, offset: int = 0, limit: Optional[int] = None
+    ) -> AsyncGenerator[tuple[int, str], None]:
+        cursor = self.files.find(
+            {f"users.{user_id}": {"$exists": True}},
+            {"file_name": 1, f"users.{user_id}.added_at": 1},
+        ).sort(f"users.{user_id}.added_at", -1)
+
+        if offset:
+            cursor = cursor.skip(offset)
+        if limit is not None:
+            cursor = cursor.limit(limit)
+
+        async for doc in cursor:
+            yield doc["_id"], doc.get("file_name")
+
+    async def get_files2(
+        self, user_id: int, file_ids: list[int], full: bool = False,
+    ) -> AsyncGenerator[FileInfo | tuple[int, str], None]:
+
+        if not file_ids:
+            return
+
+        projection = None
+        if not full:
+            projection = {
+                "file_name": 1,
+                f"users.{user_id}.added_at": 1,
+            }
+
+        cursor = self.files.find(
+            {
+                "_id": {"$in": file_ids},
+                f"users.{user_id}": {"$exists": True},
+            },
+            projection,
+        ).sort(f"users.{user_id}.added_at", -1)
+
+        if full:
+            async for doc in cursor:
+                yield FileInfo(
+                    id=doc["_id"],
+                    dc_id=doc["dc_id"],
+                    file_size=doc["size"],
+                    mime_type=doc.get("mime_type"),
+                    file_name=doc.get("file_name"),
+                    thumb_size=doc.get("thumb_size"),
+                    is_deleted=bool(doc.get("is_deleted", False)),
+                )
+        else:
+            async for doc in cursor:
+                yield doc["_id"], doc.get("file_name")
+
+    async def get_file_users(self, file_id: int) -> set[int]:
+        doc = await self.files.find_one(
+            {"_id": file_id},
+            {"users": 1},
+        )
+        if not doc or "users" not in doc:
+            return set()
+
+        return {int(uid) for uid in doc["users"].keys()}
+
+    async def total_files(self, user_id: int) -> int:
+        return await self.files.count_documents(
+            {f"users.{user_id}": {"$exists": True}}
+        )
+
+    async def delete_file(self, file_id: int) -> bool:
+        res = await self.files.delete_one({"_id": file_id})
+        return res.deleted_count > 0
+
+    async def _delete_file_from_group(self, user_id: int, file_id: int,) -> None:
+        await self.groups.update_one(
+            {
+                "user_id": user_id,
+                f"files.{file_id}": {"$exists": True},
+            },
+            {
+                "$unset": {
+                    f"files.{file_id}": ""
+                }
+            },
+        )
+
+    async def remove_file(self, file_id: int, user_id: int) -> bool:
+        res = await self.files.update_one(
+            {"_id": file_id},
+            {"$unset": {f"users.{user_id}": ""}},
+        )
+        await self._delete_file_from_group(user_id, file_id)
+        return res.modified_count > 0
+
+    async def get_file_old(self, file_id: str, user_id: int = None) -> Optional[dict[str, Union[ObjectId, int]]]:
+        query = {"_id": ObjectId(file_id)}
+        if user_id is not None:
+            query["users_id"] = user_id
+
+        doc = await self.db.maplinks.find_one(query)
+        if not doc:
+            return None
+
+        return doc

tgfs/database/mongodb/group.py

@@ -0,0 +1,159 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+from typing import AsyncGenerator, Optional
+from datetime import datetime, timezone
+
+from pymongo import ReturnDocument
+from motor.motor_asyncio import AsyncIOMotorCollection
+
+from tgfs.database.database import BaseStorage
+from tgfs.utils.types import GroupInfo
+
+class GroupDB(BaseStorage):
+    groups: AsyncIOMotorCollection
+    config: AsyncIOMotorCollection
+
+    async def group_counter(self) -> int:
+        """
+        Generate the next sequential group ID using atomic MongoDB counter pattern.
+
+        Uses atomic find_one_and_update operation to increment a counter document
+        in the config collection. If the counter doesn't exist, it's created with
+        initial value 1 (upsert=True).
+
+        Returns:
+            int: Next group ID (incrementing sequence starting from 1)
+        """
+        result = await self.config.find_one_and_update(
+            {"_id": "group.counter"},
+            {"$inc": {"value": 1}},
+            upsert=True,
+            return_document=ReturnDocument.AFTER,
+        )
+        return result["value"]
+
+    async def create_group(self, user_id: int, name: str) -> int:
+        group_id = await self.group_counter()
+        await self.groups.insert_one({
+            "_id": group_id,
+            "user_id": user_id,
+            "name": name,
+            "created_at": datetime.now(timezone.utc),
+            "files": {},
+        })
+        return group_id
+
+    async def add_file_to_group(
+        self,
+        group_id: int,
+        user_id: int,
+        file_id: int,
+        order: Optional[int] = None,
+    ) -> None:
+        if order is None:
+            doc = await self.groups.find_one(
+                {"_id": group_id, "user_id": user_id},
+                {"files": 1},
+            )
+
+            order = 1
+            if doc and "files" in doc:
+                order = len(doc["files"])+1
+
+        await self.groups.update_one(
+            {"_id": group_id, "user_id": user_id},
+            {
+                "$set": {
+                    f"files.{file_id}": {"order": order}
+                }
+            },
+            upsert=False,
+        )
+
+    async def get_groups(
+        self, user_id: int, offset: int = 0, limit: Optional[int] = None
+    ) -> AsyncGenerator[tuple[int, str], None]:
+
+        cursor = (
+            self.groups.find(
+                {"user_id": user_id},
+                {"name": 1},
+            )
+            .sort("created_at", -1)
+            .skip(offset)
+        )
+
+        if limit is not None:
+            cursor = cursor.limit(limit)
+
+        async for doc in cursor:
+            yield doc["_id"], doc["name"]
+
+    async def get_group(self, group_id: int, user_id: int) -> Optional[GroupInfo]:
+        doc = await self.groups.find_one(
+            {"_id": group_id, "user_id": user_id}
+        )
+        if not doc:
+            return None
+
+        files = [
+            int(fid)
+            for fid, _ in sorted(
+                doc.get("files", {}).items(),
+                key=lambda i: i[1]["order"]
+            )
+        ]
+
+        return GroupInfo(
+            group_id=doc["_id"],
+            user_id=doc["user_id"],
+            name=doc["name"],
+            created_at=doc["created_at"],
+            files=files
+        )
+
+    async def delete_group(self, group_id: int, user_id: int) -> None:
+        await self.groups.delete_one(
+            {"_id": group_id, "user_id": user_id}
+        )
+
+    async def update_group_name(self, group_id: int, user_id: int, name: str) -> None:
+        await self.groups.update_one(
+            {"_id": group_id, "user_id": user_id},
+            {"$set": {"name": name}},
+        )
+
+    async def update_group_order(
+        self, group_id: int, file_id: int, user_id: int, new_order: int
+    ) -> None:
+        await self.groups.update_one(
+            {
+                "_id": group_id,
+                "user_id": user_id,
+                f"files.{file_id}": {"$exists": True},
+            },
+            {
+                "$set": {
+                    f"files.{file_id}.order": new_order
+                }
+            },
+        )
+
+    async def total_groups(self, user_id: int) -> int:
+        return await self.groups.count_documents(
+            {"user_id": user_id}
+        )

tgfs/database/mongodb/user.py

@@ -0,0 +1,95 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+from typing import Optional, AsyncGenerator
+from datetime import datetime, timezone
+
+from motor.motor_asyncio import AsyncIOMotorCollection
+
+from tgfs.database.database import BaseStorage
+from tgfs.utils.types import Status, User
+
+
+class UserDB(BaseStorage):
+    users: AsyncIOMotorCollection
+
+    async def get_user(self, user_id: int) -> Optional[User]:
+        doc = await self.users.find_one({"_id": user_id})
+        if not doc:
+            return None
+
+        return User(
+            user_id=doc["_id"],
+            join_date=doc["join_date"],
+            ban_date=doc.get("ban_date"),
+            warns=doc["warns"],
+            preferred_lang=doc["preferred_lang"],
+            curt_op=Status(doc["curt_op"]),
+            op_id=doc["op_id"],
+        )
+
+    async def add_user(self, user_id: int) -> bool:
+        try:
+            await self.users.insert_one({
+                "_id": user_id,
+                "join_date": datetime.now(timezone.utc),
+                "ban_date": None,
+                "warns": 0,
+                "preferred_lang": "en",
+                "curt_op": 0,
+                "op_id": 0,
+            })
+            return True
+        except Exception:  # pylint: disable=W0718
+            return False
+
+    async def upsert_user(self, user: User) -> bool:
+        await self.users.update_one(
+            {"_id": user.user_id},
+            {
+                "$set": {
+                    "join_date": user.join_date,
+                    "ban_date": user.ban_date,
+                    "warns": user.warns,
+                    "preferred_lang": user.preferred_lang,
+                    "curt_op": user.curt_op.value,
+                    "op_id": user.op_id,
+                }
+            },
+            upsert=True,
+        )
+        return True
+
+    async def delete_user(self, user_id: int) -> bool:
+        res = await self.users.delete_one({"_id": user_id})
+        return res.deleted_count > 0
+
+    async def get_users(self) -> AsyncGenerator[User, None]:
+        cursor = self.users.find({})
+
+        async for doc in cursor:
+            yield User(
+                user_id=doc["_id"],
+                join_date=doc["join_date"],
+                ban_date=doc.get("ban_date"),
+                warns=doc["warns"],
+                preferred_lang=doc["preferred_lang"],
+                curt_op=doc["curt_op"],
+                op_id=doc["op_id"],
+            )
+
+    async def count_users(self) -> int:
+        return await self.users.count_documents({})

tgfs/database/mongodb/utils.py

@@ -0,0 +1,52 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import os
+
+from motor.motor_asyncio import AsyncIOMotorCollection
+from bson.binary import Binary
+
+from tgfs.database.database import BaseStorage
+
+
+class UtilDB(BaseStorage):
+    config: AsyncIOMotorCollection
+    async def get_secret(self, rotate: bool = False) -> bytes:
+        if not rotate:
+            doc = await self.config.find_one({"_id": "link.secret"})
+            if doc:
+                return doc["value"]
+
+        secret = os.urandom(32)
+
+        await self.config.update_one(
+            {"_id": "link.secret"},
+            {"$set": {"value": Binary(secret)}},
+            upsert=True,
+        )
+
+        return secret
+
+    async def get_config_value(self, key: str):
+        doc = await self.config.find_one({"_id": key})
+        return doc["value"] if doc else None
+
+    async def set_config_value(self, key: str, value):
+        await self.config.update_one(
+            {"_id": key},
+            {"$set": {"value": value}},
+            upsert=True,
+        )

tgfs/database/mysql/__init__.py

@@ -0,0 +1,75 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+from pathlib import Path
+import warnings
+
+import aiomysql
+
+from .file import FileDB
+from .user import UserDB
+from .group import GroupDB
+from .utils import UtilDB
+
+
+def read_sql_file(path: str) -> list[str]:
+    sql = Path(path).read_text(encoding="utf-8")
+    statements = []
+    buffer = []
+
+    for line in sql.splitlines():
+        line = line.strip()
+        if not line or line.startswith("--"):
+            continue
+
+        buffer.append(line)
+        if line.endswith(";"):
+            statements.append(" ".join(buffer))
+            buffer.clear()
+
+    return statements
+
+class MySQLDB(FileDB, GroupDB, UserDB, UtilDB):
+    _pool: aiomysql.Pool
+    is_connected: bool = False
+
+    async def connect(self, *, host: str, port: int = 3306, user: str, password: str,  # pylint: disable=W0221
+                          db: str, minsize: int = 1, maxsize: int = 10, autocommit: bool = False,
+                          connect_timeout: int = 10) -> None:
+        if not self.is_connected:
+            self._pool = await aiomysql.create_pool(
+                host=host, port=port, user=user, password=password, db=db,
+                minsize=minsize, maxsize=maxsize, autocommit=autocommit,
+                connect_timeout=connect_timeout, charset="utf8mb4"
+            )
+            self.is_connected = True
+
+    async def close(self, force: bool = False) -> None:
+        if self.is_connected or force:
+            self._pool.close()
+            await self._pool.wait_closed()
+            self.is_connected = False
+
+    async def init_db(self) -> None:
+        statements = read_sql_file("tgfs/database/mysql/schema.sql")
+
+        async with self._pool.acquire() as conn:
+            warnings.filterwarnings('ignore', module=r"aiomysql")
+            async with conn.cursor() as cur:
+                for stmt in statements:
+                    await cur.execute(stmt)
+                await conn.commit()
+            warnings.filterwarnings('default', module=r"aiomysql")

tgfs/database/mysql/file.py

@@ -0,0 +1,339 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+from typing import AsyncGenerator, Optional
+
+import aiomysql
+from telethon.tl.types import InputDocumentFileLocation, InputPhotoFileLocation
+
+from tgfs.database.database import BaseStorage
+from tgfs.utils.types import FileSource, FileInfo, InputTypeLocation
+
+
+class FileDB(BaseStorage):
+    _pool: aiomysql.Pool
+
+    async def add_file(self, user_id: int, file: FileInfo, source: FileSource) -> None:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                try:
+                    await cur.execute(
+                        """
+                        INSERT INTO TGFILE (id, dc_id, size, mime_type, file_name, thumb_size, is_deleted)
+                        VALUES (%s, %s, %s, %s, %s, %s, %s)
+                        ON DUPLICATE KEY UPDATE
+                          dc_id = VALUES(dc_id),
+                          size = VALUES(size),
+                          mime_type = VALUES(mime_type),
+                          file_name = VALUES(file_name),
+                          thumb_size = VALUES(thumb_size),
+                          is_deleted = VALUES(is_deleted)
+                        """,
+                        (
+                            file.id, file.dc_id, file.file_size, file.mime_type,
+                            file.file_name, file.thumb_size,
+                            file.is_deleted
+                        )
+                    )
+                    await cur.execute(
+                        """
+                        INSERT INTO USER_FILE (user_id, id, source_chat_id, source_msg_id)
+                        VALUES (%s, %s, %s, %s)
+                        ON DUPLICATE KEY UPDATE
+                          source_chat_id = COALESCE(VALUES(source_chat_id), source_chat_id),
+                          source_msg_id = COALESCE(VALUES(source_msg_id), source_msg_id)
+                        """,
+                        (user_id, file.id, source.chat_id, source.message_id)
+                    )
+                    await conn.commit()
+                except Exception:
+                    await conn.rollback()
+                    raise
+
+    async def update_file_restriction(self, file_id: int, status: bool) -> None:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                try:
+                    await cur.execute(
+                        """
+                        UPDATE TGFILE SET is_deleted = %s WHERE id = %s
+                        """,
+                        (status, file_id)
+                    )
+                    await conn.commit()
+                except Exception:
+                    await conn.rollback()
+                    raise
+
+    async def get_file(self, file_id: int, user_id: Optional[int] = None) -> Optional[FileInfo]:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor(aiomysql.DictCursor) as cur:
+                if user_id is None:
+                    await cur.execute(
+                        """
+                        SELECT f.id AS file_id,
+                               f.dc_id,
+                               f.size AS file_size,
+                               f.mime_type,
+                               f.file_name,
+                               f.thumb_size,
+                               f.is_deleted
+                        FROM TGFILE f
+                        WHERE f.id = %s
+                        LIMIT 1
+                        """,
+                        (file_id, )
+                    )
+                else:
+                    await cur.execute(
+                        """
+                        SELECT f.id AS file_id,
+                               f.dc_id,
+                               f.size AS file_size,
+                               f.mime_type,
+                               f.file_name,
+                               f.thumb_size,
+                               f.is_deleted
+                        FROM TGFILE f
+                        WHERE f.id = %s
+                        AND EXISTS (
+                            SELECT 1
+                            FROM USER_FILE uf
+                            WHERE uf.id = f.id
+                              AND uf.user_id = %s
+                        )
+                        LIMIT 1
+                        """,
+                        (file_id, user_id)
+                    )
+
+                row = await cur.fetchone()
+                if not row:
+                    return None
+
+                return FileInfo(
+                    id=int(row["file_id"]),
+                    dc_id=int(row["dc_id"]),
+                    file_size=int(row["file_size"]),
+                    mime_type=row["mime_type"],
+                    file_name=row["file_name"],
+                    thumb_size=row["thumb_size"],
+                    is_deleted=bool(row["is_deleted"]),
+                )
+
+    async def get_location(self, file: FileInfo, bot_id: int) -> Optional[InputTypeLocation]:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor(aiomysql.DictCursor) as cur:
+                await cur.execute(
+                    """
+                    SELECT access_hash, file_reference
+                    FROM FILE_LOCATION
+                    WHERE id = %s and bot_id = %s
+                    LIMIT 1
+                    """,
+                    (file.id, bot_id)
+                )
+                row = await cur.fetchone()
+                if not row:
+                    return None
+
+                cls = InputPhotoFileLocation if file.thumb_size else InputDocumentFileLocation
+                return cls(
+                    id=file.id,
+                    access_hash=int(row["access_hash"]),
+                    file_reference=row["file_reference"],
+                    thumb_size=file.thumb_size
+                )
+
+    async def get_source(self, file_id: int, user_id: int) -> Optional[FileSource]:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor(aiomysql.DictCursor) as cur:
+                await cur.execute(
+                    """
+                    SELECT source_chat_id, source_msg_id, added_at
+                    FROM USER_FILE 
+                    WHERE id = %s and user_id = %s
+                    LIMIT 1
+                    """,
+                    (file_id, user_id)
+                )
+                row = await cur.fetchone()
+                if not row:
+                    return None
+                return FileSource(
+                    chat_id=int(row["source_chat_id"]),
+                    message_id=int(row["source_msg_id"]),
+                    time=row["added_at"]
+                )
+
+    async def upsert_location(self, bot_id: int, loc: InputTypeLocation) -> None:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                try:
+                    await cur.execute(
+                        """
+                        INSERT INTO FILE_LOCATION (bot_id, id, access_hash, file_reference)
+                        VALUES (%s, %s, %s, %s)
+                        ON DUPLICATE KEY UPDATE
+                          access_hash = VALUES(access_hash),
+                          file_reference = VALUES(file_reference)
+                        """,
+                        (bot_id, loc.id, loc.access_hash, loc.file_reference)
+                    )
+                    await conn.commit()
+                except Exception:
+                    await conn.rollback()
+                    raise
+
+    async def get_files(self, user_id: int, offset: int = 0, limit: Optional[int] = None
+                        ) -> AsyncGenerator[tuple[int, str], None]:
+
+        base_sql = """
+            SELECT f.id AS file_id, f.file_name
+            FROM TGFILE f
+            JOIN USER_FILE uf ON f.id = uf.id
+            WHERE uf.user_id = %s
+            ORDER BY uf.added_at DESC
+        """
+
+        params = [user_id]
+
+        if limit is not None:
+            base_sql += " LIMIT %s OFFSET %s"
+            params.extend([limit, offset])
+
+        async with self._pool.acquire() as conn:
+            async with conn.cursor(aiomysql.SSCursor) as cur:
+                await cur.execute(base_sql, params)
+
+                async for row in cur:
+                    file_id, file_name = row
+                    yield int(file_id), str(file_name)
+
+    async def get_files2(self, user_id: int, file_ids: list[int], full: bool = False,
+                         ) -> AsyncGenerator[FileInfo | tuple[int, str], None]:
+
+        if not file_ids:
+            return
+
+        placeholders = ",".join(["%s"] * len(file_ids))
+
+        if full:
+            select_clause = "f.*"
+        else:
+            select_clause = "f.id AS file_id, f.file_name"
+
+        base_sql = f"""
+            SELECT {select_clause}
+            FROM TGFILE f
+            JOIN USER_FILE uf ON f.id = uf.id
+            WHERE uf.user_id = %s
+              AND f.id IN ({placeholders})
+            ORDER BY uf.added_at DESC
+        """
+
+        params = [user_id] + file_ids
+
+        async with self._pool.acquire() as conn:
+            async with conn.cursor(aiomysql.SSCursor) as cur:
+                await cur.execute(base_sql, params)
+
+                if full:
+                    columns = [col[0] for col in cur.description]
+
+                    async for raw_row in cur:
+                        row = dict(zip(columns, raw_row))
+                        yield FileInfo(
+                            id=int(row["id"]),
+                            dc_id=int(row["dc_id"]),
+                            file_size=int(row["size"]),
+                            mime_type=row["mime_type"],
+                            file_name=row["file_name"],
+                            thumb_size=row["thumb_size"],
+                            is_deleted=bool(row["is_deleted"]),
+                        )
+                else:
+                    async for row in cur:
+                        file_id, file_name = row
+                        yield int(file_id), str(file_name)
+
+    async def get_file_users(self, file_id: int, ) -> set[int]:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                await cur.execute(
+                    """
+                    SELECT user_id
+                    FROM USER_FILE
+                    WHERE id = %s
+                    """,
+                    (file_id)
+                )
+
+                rows = await cur.fetchall()
+                return {col[0] for col in rows}
+
+    async def total_files(self, user_id: int) -> int:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                await cur.execute(
+                    """
+                    SELECT COUNT(*)
+                    FROM USER_FILE
+                    WHERE user_id = %s
+                    """,
+                    (user_id,)
+                )
+
+                row = await cur.fetchone()
+                return int(row[0]) if row else 0
+
+    async def delete_file(self, file_id: int) -> bool:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor(aiomysql.DictCursor) as cur:
+                try:
+                    await cur.execute(
+                        """
+                        DELETE FROM TGFILE
+                        WHERE id = %s
+                        LIMIT 1
+                        """,
+                        (file_id)
+                    )
+                    deleted = bool(cur.rowcount > 0)
+                    await conn.commit()
+                    return deleted
+                except Exception:
+                    await conn.rollback()
+                    raise
+
+    async def remove_file(self, file_id: int, user_id: int) -> bool:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor(aiomysql.DictCursor) as cur:
+                try:
+                    await cur.execute(
+                        """
+                        DELETE FROM USER_FILE
+                        WHERE id = %s AND user_id = %s
+                        LIMIT 1
+                        """,
+                        (file_id, user_id)
+                    )
+                    deleted = bool(cur.rowcount > 0)
+                    await conn.commit()
+                    return deleted
+                except Exception:
+                    await conn.rollback()
+                    raise

tgfs/database/mysql/group.py

@@ -0,0 +1,207 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import asyncio
+from typing import AsyncGenerator, Optional
+
+import aiomysql
+
+from tgfs.database.database import BaseStorage
+from tgfs.utils.types import GroupInfo
+
+class GroupDB(BaseStorage):
+    _list_lock = asyncio.Lock()
+    _pool: aiomysql.Pool
+
+    async def create_group(self, user_id: int, name: str) -> int:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                try:
+                    await cur.execute(
+                        """
+                        INSERT INTO FILE_GROUP (user_id, name)
+                        VALUES (%s, %s)
+                        """,
+                        (user_id, name)
+                    )
+                    group_id = cur.lastrowid
+                    await conn.commit()
+                    return group_id
+                except Exception:
+                    await conn.rollback()
+                    raise
+
+    async def add_file_to_group(self, group_id: int, user_id: int, file_id: int, order: Optional[int] = None) -> None:
+        async with self._list_lock:
+            async with self._pool.acquire() as conn:
+                async with conn.cursor() as cur:
+                    try:
+                        if order is None:
+                            await cur.execute(
+                                """
+                                SELECT COALESCE(MAX(order_index), 0) + 1
+                                FROM FILE_GROUP_FILE
+                                WHERE group_id = %s
+                                FOR UPDATE
+                                """,
+                                (group_id,)
+                            )
+                            row = await cur.fetchone()
+                            order = int(row[0]) if row else 1
+
+                        await cur.execute(
+                            """
+                            INSERT INTO FILE_GROUP_FILE (group_id, user_id, id, order_index)
+                            VALUES (%s, %s, %s, %s)
+                            ON DUPLICATE KEY UPDATE
+                              order_index = VALUES(order_index)
+                            """,
+                            (group_id, user_id, file_id, order)
+                        )
+
+                        await conn.commit()
+                    except Exception:
+                        await conn.rollback()
+                        raise
+
+    async def get_groups(self, user_id: int, offset: int = 0, limit: Optional[int] = None
+        ) -> AsyncGenerator[tuple[int, str], None]:
+        base_sql = """
+                    SELECT group_id, name
+                    FROM FILE_GROUP
+                    WHERE user_id = %s
+                    ORDER BY created_at DESC
+                    """
+        params = [user_id]
+
+        if limit is not None:
+            base_sql += " LIMIT %s OFFSET %s"
+            params.extend([limit, offset])
+
+        async with self._pool.acquire() as conn:
+            async with conn.cursor(aiomysql.SSCursor) as cur:
+                await cur.execute(base_sql, params)
+                async for row in cur:
+                    group_id, name = row
+                    yield int(group_id), str(name)
+
+    async def get_group(self, group_id: int, user_id: int) -> Optional[GroupInfo]:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor(aiomysql.DictCursor) as cur:
+                await cur.execute(
+                    """
+                    SELECT group_id, user_id, name, created_at
+                    FROM FILE_GROUP
+                    WHERE group_id = %s AND user_id = %s
+                    LIMIT 1
+                    """,
+                    (group_id, user_id)
+                )
+                row = await cur.fetchone()
+                if not row:
+                    return None
+
+                gi = GroupInfo(
+                    group_id=int(row["group_id"]),
+                    user_id=int(row["user_id"]),
+                    name=row["name"],
+                    created_at=row.get("created_at"),
+                    files=[]
+                )
+
+                await cur.execute(
+                    """
+                    SELECT id
+                    FROM FILE_GROUP_FILE
+                    WHERE group_id = %s
+                    ORDER BY order_index ASC
+                    """,
+                    (group_id,)
+                )
+                rows = await cur.fetchall()
+                if not rows:
+                    return gi
+
+                gi.files.extend([int(r["id"]) for r in rows])
+                return gi
+
+    async def delete_group(self, group_id: int, user_id: int) -> None:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                try:
+                    await cur.execute(
+                        """
+                        DELETE FROM FILE_GROUP
+                        WHERE group_id = %s AND user_id = %s
+                        """,
+                        (group_id, user_id)
+                    )
+                    await conn.commit()
+                except Exception:
+                    await conn.rollback()
+                    raise
+
+    async def update_group_name(self, group_id: int, user_id: int, name: str) -> None:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                try:
+                    await cur.execute(
+                        """
+                        UPDATE FILE_GROUP
+                        SET name = %s
+                        WHERE group_id = %s AND user_id = %s
+                        """,
+                        (name, group_id, user_id)
+                    )
+                    await conn.commit()
+                except Exception:
+                    await conn.rollback()
+                    raise
+
+    async def update_group_order(self, group_id: int, file_id: int, user_id: int, new_order: int) -> None:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                try:
+                    await cur.execute(
+                        """
+                        UPDATE FILE_GROUP_FILE gff
+                        JOIN FILE_GROUP fg
+                          ON fg.group_id = gff.group_id
+                        SET gff.order_index = %s
+                        WHERE gff.group_id = %s
+                          AND gff.id = %s
+                          AND fg.user_id = %s
+                        """,
+                        (new_order, group_id, file_id, user_id)
+                    )
+                    await conn.commit()
+                except Exception:
+                    await conn.rollback()
+                    raise
+    async def total_groups(self, user_id: int) -> int:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                await cur.execute(
+                    """
+                    SELECT COUNT(*)
+                    FROM FILE_GROUP
+                    WHERE user_id = %s
+                    """,
+                    (user_id)
+                )
+
+                row = await cur.fetchone()
+                return int(row[0]) if row else 0

tgfs/database/mysql/schema.sql

@@ -0,0 +1,63 @@
+CREATE TABLE IF NOT EXISTS TGFILE (
+    id BIGINT UNSIGNED PRIMARY KEY,
+    dc_id TINYINT UNSIGNED NOT NULL,
+    size BIGINT UNSIGNED NOT NULL,
+    mime_type VARCHAR(255),
+    file_name VARCHAR(255),
+    thumb_size CHAR(1),
+    is_deleted BOOLEAN DEFAULT FALSE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+CREATE TABLE IF NOT EXISTS FILE_LOCATION (
+  bot_id BIGINT UNSIGNED NOT NULL,
+  id BIGINT UNSIGNED NOT NULL,
+  access_hash BIGINT NULL,
+  file_reference BLOB NULL,
+  PRIMARY KEY (bot_id, id),
+  CONSTRAINT fk_file_ids_files FOREIGN KEY (id) REFERENCES TGFILE(id) ON DELETE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+CREATE TABLE IF NOT EXISTS TGUSER (
+    user_id BIGINT UNSIGNED PRIMARY KEY,
+    join_date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    ban_date TIMESTAMP NULL,
+    warns TINYINT UNSIGNED NOT NULL DEFAULT 0,
+    preferred_lang CHAR(2) NOT NULL DEFAULT 'en',
+    curt_op TINYINT UNSIGNED DEFAULT 0,
+    op_id BIGINT DEFAULT 0
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+CREATE TABLE IF NOT EXISTS USER_FILE (
+  user_id BIGINT UNSIGNED NOT NULL,
+  id BIGINT UNSIGNED NOT NULL,
+  source_chat_id BIGINT NULL,
+  source_msg_id BIGINT UNSIGNED NULL,
+  added_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (user_id, id),
+  CONSTRAINT fk_user_files_users FOREIGN KEY (user_id) REFERENCES TGUSER(user_id) ON DELETE CASCADE,
+  CONSTRAINT fk_user_files_files FOREIGN KEY (id) REFERENCES TGFILE(id) ON DELETE RESTRICT
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+CREATE TABLE IF NOT EXISTS FILE_GROUP (
+  group_id BIGINT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
+  user_id BIGINT UNSIGNED NOT NULL,
+  name VARCHAR(255) NOT NULL,
+  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CONSTRAINT fk_file_group_owner FOREIGN KEY (user_id) REFERENCES TGUSER(user_id) ON DELETE CASCADE
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+CREATE TABLE IF NOT EXISTS FILE_GROUP_FILE (
+  group_id BIGINT UNSIGNED NOT NULL,
+  user_id BIGINT UNSIGNED NOT NULL,
+  id BIGINT UNSIGNED NOT NULL,
+  order_index INT UNSIGNED NOT NULL DEFAULT 0,
+  PRIMARY KEY (group_id, user_id, id),
+  CONSTRAINT fk_fg_group FOREIGN KEY (group_id) REFERENCES FILE_GROUP(group_id) ON DELETE CASCADE,
+  CONSTRAINT fk_fg_user_file FOREIGN KEY (user_id, id) REFERENCES USER_FILE(user_id, id) ON DELETE CASCADE
+) ENGINE=InnoDB;
+
+CREATE TABLE IF NOT EXISTS APP_CONFIG (
+  k VARCHAR(64) PRIMARY KEY,
+  v BLOB NOT NULL,
+  type ENUM('bytes', 'bool', 'int', 'str', 'json') NOT NULL
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

tgfs/database/mysql/user.py

@@ -0,0 +1,114 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+from typing import AsyncGenerator, Optional
+
+import aiomysql
+
+from tgfs.database.database import BaseStorage
+from tgfs.utils.types import User
+
+
+class UserDB(BaseStorage):
+    _pool: aiomysql.Pool
+
+    async def get_user(self, user_id: int) -> Optional[User]:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor(aiomysql.DictCursor) as cur:
+                await cur.execute(
+                    """
+                    SELECT user_id, join_date, ban_date, warns, preferred_lang, curt_op, op_id
+                    FROM TGUSER WHERE user_id = %s
+                    """,
+                    (user_id,)
+                )
+                row = await cur.fetchone()
+                if not row:
+                    return None
+                return User.from_row(row)
+
+    async def add_user(self, user_id: int) -> bool:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                try:
+                    await cur.execute(
+                        "INSERT IGNORE INTO TGUSER (user_id) VALUES (%s)",
+                        (user_id,)
+                    )
+                    inserted = cur.rowcount > 0
+                    await conn.commit()
+                    return bool(inserted)
+                except Exception:
+                    await conn.rollback()
+                    raise
+
+    async def upsert_user(self, user: User) -> bool:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                try:
+                    await cur.execute(
+                        """
+                        INSERT INTO TGUSER (user_id, join_date, ban_date, warns, preferred_lang, curt_op, op_id)
+                        VALUES (%s, %s, %s, %s, %s, %s, %s) AS new
+                        ON DUPLICATE KEY UPDATE
+                          join_date = new.join_date,
+                          ban_date = new.ban_date,
+                          warns = new.warns,
+                          preferred_lang = new.preferred_lang,
+                          curt_op = new.curt_op,
+                          op_id = new.op_id
+                        """,
+                        (user.user_id, user.join_date, user.ban_date, user.warns,
+                         user.preferred_lang, user.curt_op.value, user.op_id)
+                    )
+                    await conn.commit()
+                    return True
+                except Exception:
+                    await conn.rollback()
+                    raise
+
+    async def delete_user(self, user_id: int) -> bool:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                try:
+                    await cur.execute("DELETE FROM TGUSER WHERE user_id = %s", (user_id,))
+                    deleted = cur.rowcount > 0
+                    await conn.commit()
+                    return bool(deleted)
+                except Exception:
+                    await conn.rollback()
+                    raise
+
+    async def get_users(self) -> AsyncGenerator[User, None]:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor(aiomysql.DictCursor) as cur:
+                await cur.execute(
+                    "SELECT user_id, join_date, ban_date, warns, preferred_lang, curt_op, op_id FROM TGUSER"
+                )
+
+                while True:
+                    row = await cur.fetchone()
+                    if not row:
+                        break
+
+                    yield User.from_row(row)
+
+    async def count_users(self) -> int:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                await cur.execute("SELECT COUNT(*) FROM TGUSER")
+                (count,) = await cur.fetchone()
+                return int(count)

tgfs/database/mysql/utils.py

@@ -0,0 +1,127 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import os
+
+import json
+from typing import Optional
+
+import aiomysql
+
+from tgfs.database.database import BaseStorage
+from tgfs.utils.types import SupportedType
+
+def encode_value(value: SupportedType) -> tuple[bytes, str]:
+    if isinstance(value, bytes):
+        return value, "bytes"
+
+    if isinstance(value, str):
+        return value.encode("utf-8"), "str"
+
+    if isinstance(value, bool):
+        return (b"\x01" if value else b"\x00"), "bool"
+
+    if isinstance(value, int):
+        size = max(1, (value.bit_length() + 7) // 8)
+        return value.to_bytes(size, "big", signed=True), "int"
+
+    if isinstance(value, (dict, list)):
+        return json.dumps(value, separators=(",", ":")).encode("utf-8"), "json"
+
+    raise TypeError(f"Unsupported type: {type(value)}")
+
+def decode_value(data: bytes, vtype: str) -> SupportedType:
+    if vtype == "bytes":
+        return data
+
+    if vtype == "str":
+        return data.decode("utf-8")
+
+    if vtype == "bool":
+        return data != b"\x00"
+
+    if vtype == "int":
+        return int.from_bytes(data, "big", signed=True)
+
+    if vtype == "json":
+        return json.loads(data.decode("utf-8"))
+
+    raise ValueError(f"Unknown type: {vtype}")
+
+
+class UtilDB(BaseStorage):
+    _pool: aiomysql.Pool
+
+    async def get_secret(self, rotate=False) -> bytes:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                if not rotate:
+                    await cur.execute(
+                        "SELECT v FROM APP_CONFIG WHERE k = %s",
+                        ("link.secret",)
+                    )
+                    row: bytes = await cur.fetchone()
+                    if row:
+                        return row[0]
+
+                secret = os.urandom(32)
+                await cur.execute(
+                    """
+                    INSERT INTO APP_CONFIG (k, v)
+                    VALUES (%s, %s)
+                    ON DUPLICATE KEY UPDATE
+                      v = VALUES(v)
+                    """,
+                    ("link.secret", secret)
+                )
+
+                await conn.commit()
+                return secret
+
+    async def get_config_value(self, key: str) -> Optional[SupportedType]:
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                await cur.execute(
+                    "SELECT v, type FROM APP_CONFIG WHERE k = %s",
+                    (key,)
+                )
+                row = await cur.fetchone()
+                if not row:
+                    return None
+
+                data, vtype = row
+                return decode_value(data, vtype)
+
+    async def set_config_value(self, key: str, value: SupportedType) -> None:
+        data, vtype = encode_value(value)
+
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                try:
+                    await cur.execute(
+                        """
+                        INSERT INTO APP_CONFIG (k, v, type)
+                        VALUES (%s, %s, %s)
+                        ON DUPLICATE KEY UPDATE
+                          v = VALUES(v),
+                          type = VALUES(type)
+                        """,
+                        (key, data, vtype)
+                    )
+                    await conn.commit()
+                except Exception:
+                    await conn.rollback()
+                    raise

tgfs/info.py

@@ -0,0 +1,9 @@
+__version__="0.0.1"
+class Version:
+    version = __version__.split(".", maxsplit=3)
+    major = int(version[0])
+    minor = int(version[1])
+    patch = int(version[2])
+
+    def __str__(self) -> str:
+        return f"{self.major}.{self.minor}.{self.patch}"

tgfs/log.py

@@ -0,0 +1,28 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import logging
+from tgfs.config import Config
+
+LOG_LEVEL = logging.DEBUG if Config.DEBUG else logging.INFO
+EXT_LOG_LEVEL = logging.INFO if Config.EXT_DEBUG else logging.ERROR
+logging.basicConfig(level=LOG_LEVEL)
+logging.getLogger("telethon").setLevel(EXT_LOG_LEVEL)
+logging.getLogger("aiohttp").setLevel(EXT_LOG_LEVEL)
+logging.getLogger("asyncio").setLevel(EXT_LOG_LEVEL)
+logging.getLogger("pymongo").setLevel(EXT_LOG_LEVEL)
+logging.getLogger("aiomysql").setLevel(EXT_LOG_LEVEL)
+log = logging.getLogger("tgstream")

tgfs/paralleltransfer.py

@@ -0,0 +1,234 @@
+# TG-FileStream
+# Copyright (C) 2019 Tulir Asokan
+#
+# 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/>.
+
+# Modifications made by Deekshith SH, 2025-2026
+# Copyright (C) 2025-2026 Deekshith SH
+
+# pylint: disable=protected-access
+
+import copy
+import logging
+import asyncio
+import math
+from collections import defaultdict
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import AsyncGenerator, Optional
+
+from telethon import TelegramClient
+from telethon.crypto import AuthKey
+from telethon.network import MTProtoSender
+from telethon.tl.alltlobjects import LAYER
+from telethon.tl.functions import InvokeWithLayerRequest
+from telethon.tl.functions.auth import ExportAuthorizationRequest, ImportAuthorizationRequest
+from telethon.tl.functions.upload import GetFileRequest
+from telethon.tl.types import DcOption
+from telethon.errors import DcIdInvalidError
+
+from tgfs.config import Config
+from tgfs.utils.types import InputTypeLocation
+
+root_log = logging.getLogger(__name__)
+
+if Config.CONNECTION_LIMIT > 25:
+    root_log.warning("The connection limit should not be set above 25 to avoid"
+                     " infinite disconnect/reconnect loops")
+
+
+@dataclass
+class Connection:
+    log: logging.Logger
+    sender: MTProtoSender
+    lock: asyncio.Lock
+    users: int = 0
+
+
+class DCConnectionManager:
+    log: logging.Logger
+    client: TelegramClient
+
+    dc_id: int
+    dc: Optional[DcOption]
+    auth_key: Optional[AuthKey]
+    connections: list[Connection]
+
+    _list_lock: asyncio.Lock
+
+    def __init__(self, client: TelegramClient, dc_id: int, parent_log: logging.Logger) -> None:
+        self.log = parent_log.getChild(f"dc{dc_id}")
+        self.client = client
+        self.dc_id = dc_id
+        self.auth_key = None
+        self.connections = []
+        self._list_lock = asyncio.Lock()
+        self.dc = None
+
+    async def _new_connection(self) -> Connection:
+        if not self.dc:
+            self.dc = await self.client._get_dc(self.dc_id)
+        sender = MTProtoSender(self.auth_key, loggers=self.client._log)
+        index = len(self.connections) + 1
+        conn = Connection(sender=sender, log=self.log.getChild(
+            f"conn{index}"), lock=asyncio.Lock())
+        self.connections.append(conn)
+        try:
+            async with conn.lock:
+                conn.log.info("Connecting...")
+                connection_info = self.client._connection(self.dc.ip_address, self.dc.port, self.dc.id,
+                                                        loggers=self.client._log,
+                                                        proxy=self.client._proxy)
+                await sender.connect(connection_info)
+                if not self.auth_key:
+                    await self._export_auth_key(conn)
+                return conn
+        except Exception as e:
+            self.connections.remove(conn)
+            raise e
+
+    async def _export_auth_key(self, conn: Connection) -> None:
+        self.log.info("Exporting auth to DC %s"
+                      " (main client is in %s)", self.dc.id, self.client.session.dc_id)
+        try:
+            auth = await self.client(ExportAuthorizationRequest(self.dc.id))
+        except DcIdInvalidError:
+            self.log.debug("Got DcIdInvalidError")
+            self.auth_key = self.client.session.auth_key
+            conn.sender.auth_key = self.auth_key
+            return
+        init_request = copy.copy(self.client._init_request)
+        init_request.query = ImportAuthorizationRequest(
+            id=auth.id, bytes=auth.bytes
+        )
+        req = InvokeWithLayerRequest(
+            LAYER, init_request
+        )
+        await conn.sender.send(req)
+        self.auth_key = conn.sender.auth_key
+
+    async def _next_connection(self) -> Connection:
+        best_conn: Optional[Connection] = None
+        for conn in self.connections:
+            if not best_conn or conn.users < best_conn.users:
+                best_conn = conn
+        if (not best_conn or best_conn.users > 0) and len(self.connections) < Config.CONNECTION_LIMIT:
+            best_conn = await self._new_connection()
+        return best_conn
+
+    @asynccontextmanager
+    async def get_connection(self) -> AsyncGenerator[Connection, None]:
+        async with self._list_lock:
+            conn: Connection = await asyncio.shield(self._next_connection())
+            # The connection is locked so reconnections don't stack
+            async with conn.lock:
+                conn.users += 1
+        try:
+            yield conn
+        finally:
+            conn.users -= 1
+
+    async def disconnect(self) -> None:
+        async with self._list_lock:
+            await asyncio.gather(*[conn.sender.disconnect() for conn in self.connections])
+            self.connections.clear()
+
+
+class ParallelTransferrer:
+    log: logging.Logger
+    client: TelegramClient
+    client_id: int
+    dc_managers: dict[int, DCConnectionManager]
+    users: int
+
+    def __init__(self, client: TelegramClient, client_id: int) -> None:
+        self.log = root_log.getChild(f"bot{client_id}")
+        self.client = client
+        self.client_id = client_id
+        self.users = 0
+
+        self.dc_managers = defaultdict(lambda: None)
+
+    def _get_dc_manager(self, dc_id: int) -> DCConnectionManager:
+        if self.dc_managers[dc_id] is None:
+            self.dc_managers[dc_id] = DCConnectionManager(self.client, dc_id, self.log)
+        return self.dc_managers[dc_id]
+
+    def post_init(self) -> None:
+        # Pre-initialize the manager for the current session's DC
+        manager = self._get_dc_manager(self.client.session.dc_id)
+        manager.auth_key = self.client.session.auth_key
+
+    async def close_connection(self) -> None:
+        tasks = []
+        for dcid, dcm in self.dc_managers.items():
+            if dcm and dcm.connections:
+                self.log.debug("Closing connections for DC %d", dcid)
+                tasks.append(dcm.disconnect())
+        if tasks:
+            await asyncio.gather(*tasks)
+        self.log.debug("All DC connections closed")
+
+    async def _int_download(self, request: GetFileRequest, first_part: int, last_part: int,
+        part_count: int, part_size: int, dc_id: int, first_part_cut: int,
+        last_part_cut: int) -> AsyncGenerator[bytes, None]:
+        log = self.log
+        self.users += 1
+        try:
+            part = first_part
+            dcm = self._get_dc_manager(dc_id)
+            async with dcm.get_connection() as conn:
+                log = conn.log
+                while part <= last_part:
+                    result = await self.client._call(conn.sender, request)
+
+                    if not result.bytes:
+                        break
+
+                    request.offset += part_size
+                    if last_part == first_part:
+                        yield result.bytes[first_part_cut:last_part_cut]
+                    elif part == first_part:
+                        yield result.bytes[first_part_cut:]
+                    elif part == last_part:
+                        yield result.bytes[:last_part_cut]
+                    else:
+                        yield result.bytes
+                    log.debug("Part %d/%d (total %d) downloaded", part, last_part, part_count)
+                    part += 1
+                log.info("Parallel download finished")
+        except (GeneratorExit, StopAsyncIteration, asyncio.CancelledError):
+            log.info("Parallel download interrupted")
+            raise
+        except Exception: # pylint: disable=W0718
+            log.error("Parallel download errored", exc_info=True)
+        finally:
+            self.users -= 1
+
+    def download(self, location: InputTypeLocation, dc_id: int, file_size: int, offset: int, limit: int
+                 ) -> AsyncGenerator[bytes, None]:
+        part_size = Config.DOWNLOAD_PART_SIZE
+        first_part_cut = offset % part_size
+        first_part = math.floor(offset / part_size)
+        last_part_cut = (limit % part_size) + 1
+        last_part = math.ceil(limit / part_size)
+        part_count = math.ceil(file_size / part_size)
+        self.log.info("Starting parallel download: chunks %d-%d of %d %s",
+                       first_part, last_part, part_count, location)
+        request = GetFileRequest(location, offset=first_part * part_size, limit=part_size)
+
+        return self._int_download(
+            request, first_part, last_part, part_count, part_size, dc_id,
+            first_part_cut, last_part_cut
+        )

tgfs/patches/__init__.py

@@ -0,0 +1,4 @@
+# Monkey patches and optional runtime overrides.
+
+# Importing this package applies all enabled patches.
+# Currently empty.

tgfs/plugins/admin.py

@@ -0,0 +1,227 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import datetime
+import logging
+from typing import Optional
+
+from telethon import events
+
+from tgfs.config import Config
+from tgfs.telegram import client
+from tgfs.database import DB
+from tgfs.utils.utils import parse_token
+
+
+def is_admin(user_id: int):
+    return user_id in Config.ADMIN_IDS
+
+
+def parse_userid(token: str) -> Optional[int]:
+    if token.isdigit():
+        return int(token)
+    else:
+        data = parse_token(token)
+        if data:
+            return data[0]
+
+
+log = logging.getLogger(__name__)
+
+
+@client.on(events.NewMessage(
+    incoming=True,
+    pattern=r"^/help",
+    func=lambda x: x.is_private and not x.file and is_admin(x.sender_id)
+))
+async def handle_help_command(evt: events.NewMessage.Event) -> None:
+    await evt.reply(f"""
+Admin Commands:
+/ban <userid> <reason>: ban a user
+/warn <userid> <reason>: warn a user; after {Config.MAX_WARNS} warnings, the user will be banned
+/unban <userid>: unban a user
+/clearwarns <userid>: clear all warnings for a user
+
+/listfiles <fileid | token>: list users who generated a link for a specific file
+/restrictfile <fileid | token>: restrict a file link to prevent users from downloading the file
+/deletefile <userid> <fileid>: delete a file associated with a user
+/deletefile <token>: delete a file using its token
+/parsetoken <token>: parse a token to retrieve the file ID and user ID
+
+download url strcture: "http://<PUBLIC_URL>/dl/<token>/<signature>"
+""")
+
+
+@client.on(events.NewMessage(
+    incoming=True,
+    pattern=r"^/ban (\d+) (.+)$",
+    func=lambda x: x.is_private and not x.file and is_admin(x.sender_id)
+))
+async def handle_ban_command(evt: events.NewMessage.Event) -> None:
+    user_id = int(evt.pattern_match.group(1))
+    reason = str(evt.pattern_match.group(2))
+    user = await DB.db.get_user(user_id)
+    if not user:
+        return await evt.reply("User doesn't exist in Database")
+    user.ban_date = datetime.datetime.now(datetime.UTC)
+    if await DB.db.upsert_user(user):
+        await evt.reply(f"Banned user {user_id}")
+        await client.send_message(user_id, f"Your banned\nReason: {reason}")
+    else:
+        await evt.reply(f"Unable to ban user {user_id}")
+
+
+@client.on(events.NewMessage(
+    incoming=True,
+    pattern=r"^/warn (\d+) (.+)$",
+    func=lambda x: x.is_private and not x.file and is_admin(x.sender_id)
+))
+async def handle_warn_command(evt: events.NewMessage.Event) -> None:
+    user_id = int(evt.pattern_match.group(1))
+    reason = str(evt.pattern_match.group(2))
+    user = await DB.db.get_user(user_id)
+    if not user:
+        return await evt.reply("User doesn't exist in Database")
+    user.warns += 1
+    if user.warns >= Config.MAX_WARNS:
+        await evt.reply("User reached max warns")
+        user.ban_date = datetime.datetime.now(datetime.UTC)
+    if await DB.db.upsert_user(user):
+        await evt.reply(f"User has {user.warns}/{Config.MAX_WARNS} Warns")
+        await client.send_message(user_id, f"You have {user.warns}/{Config.MAX_WARNS} Warns\nReason: {reason}")
+    else:
+        await evt.reply(f"Unable to warn user {user_id}")
+
+
+@client.on(events.NewMessage(
+    incoming=True,
+    pattern=r"^/unban (\d+)$",
+    func=lambda x: x.is_private and not x.file and is_admin(x.sender_id)
+))
+async def handle_unban_command(evt: events.NewMessage.Event) -> None:
+    user_id = int(evt.pattern_match.group(1))
+    user = await DB.db.get_user(user_id)
+    if not user:
+        return await evt.reply("User doesn't exist in Database")
+    user.ban_date = None
+    user.warns = 0
+    if await DB.db.upsert_user(user):
+        await evt.reply("User has Unbanned and Warns reset to 0")
+        await client.send_message(user_id, "You are unbanned now you can use this bot")
+    else:
+        await evt.reply(f"Unable to unban user {user_id}")
+
+
+@client.on(events.NewMessage(
+    incoming=True,
+    pattern=r"^/clearwarns (\d+)$",
+    func=lambda x: x.is_private and not x.file and is_admin(x.sender_id)
+))
+async def handle_clearwarns_command(evt: events.NewMessage.Event) -> None:
+    user_id = int(evt.pattern_match.group(1))
+    user = await DB.db.get_user(user_id)
+    if not user:
+        return await evt.reply("User doesn't exist in Database")
+    user.warns = 0
+    if await DB.db.upsert_user(user):
+        await evt.reply("Warns reset to 0")
+        await client.send_message(user_id, "Your warns reset to 0")
+    else:
+        await evt.reply(f"Unable to clear warns for user {user_id}")
+
+
+@client.on(events.NewMessage(
+    incoming=True,
+    pattern=r"^/listfiles (\d+|[A-Za-z0-9_\-:/]+)$",
+    func=lambda x: x.is_private and not x.file and is_admin(x.sender_id)
+))
+async def handle_listfiles_command(evt: events.NewMessage.Event) -> None:
+    file_id = evt.pattern_match.group(1)
+    if file_id.isdigit():
+        file_id = int(file_id)
+    else:
+        data = parse_token(file_id)
+        if not data:
+            return await evt.reply("Invalid File Id")
+        file_id = data[1]
+    users = await DB.db.get_file_users(file_id)
+    if not users:
+        return await evt.reply("No users have generated a link for this file.")
+    reply_text = (
+        "These users generated a link for this file:\n"
+        + "\n".join(f"[{uid}](tg://user?id={uid})" for uid in users)
+    )
+    await evt.reply(reply_text)
+
+
+@client.on(events.NewMessage(
+    incoming=True,
+    pattern=r"^/restrictfile (\d+|[A-Za-z0-9_\-:/]+)$",
+    func=lambda x: x.is_private and not x.file and is_admin(x.sender_id)
+))
+async def handle_restrictfile_command(evt: events.NewMessage.Event) -> None:
+    file_id = evt.pattern_match.group(1)
+    if file_id.isdigit():
+        file_id = int(file_id)
+    else:
+        data = parse_token(file_id)
+        if not data:
+            return await evt.reply("Invalid File Id")
+        file_id = data[1]
+    file = await DB.db.get_file(file_id)
+    if not file:
+        return await evt.reply("File not found in Database")
+    file.is_deleted = True
+    await DB.db.update_file_restriction(file.id, file.is_deleted)
+    await evt.reply(f"Restricted File with File Id {file.id}")
+
+
+@client.on(events.NewMessage(
+    incoming=True,
+    pattern=r"^/deletefile (?:(\d+) (\d+)|([A-Za-z0-9_\-:/]+))$",
+    func=lambda x: x.is_private and not x.file and is_admin(x.sender_id)
+))
+async def handle_deletefile_command(evt: events.NewMessage.Event) -> None:
+    user_id = evt.pattern_match.group(1)
+    file_id = evt.pattern_match.group(2)
+    token = evt.pattern_match.group(3)
+
+    if token:
+        data = parse_token(token)
+        if not data:
+            return
+        user_id, file_id = data
+    else:
+        user_id = int(user_id)
+        file_id = int(file_id)
+    if await DB.db.remove_file(file_id, user_id):
+        await evt.reply(f"Deleted file {file_id} from user [{user_id}](tg://user?id={user_id})")
+    else:
+        await evt.reply(f"Unable to delete file {file_id} associated with user [{user_id}](tg://user?id={user_id})")
+
+
+@client.on(events.NewMessage(
+    incoming=True,
+    pattern=r"^/parsetoken ([A-Za-z0-9_\-:/]+)$",
+    func=lambda x: x.is_private and not x.file and is_admin(x.sender_id)
+))
+async def handle_parsetoken_command(evt: events.NewMessage.Event) -> None:
+    token = evt.pattern_match.group(1)
+    data = parse_token(token)
+    if not data:
+        return await evt.reply("Invalid Token")
+    user_id, file_id = data
+    await evt.reply(f"Token {token} is associated with User ID {user_id} and File ID {file_id}")

tgfs/plugins/callback.py

@@ -0,0 +1,279 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import logging
+
+from telethon import Button, events
+from telethon.tl.types import InputMediaDocument, InputMediaPhoto
+
+from tgfs.config import Config
+from tgfs.telegram import client
+from tgfs.database import DB
+from tgfs.utils.translation import get_lang
+from tgfs.utils.utils import check_get_user, human_bytes, make_token
+
+log = logging.getLogger(__name__)
+
+
+@client.on(events.CallbackQuery(pattern=r"^tos_agree_[1-9]\d{0,19}$"))
+async def handle_tos_button(evt: events.CallbackQuery.Event):
+    lang = get_lang()
+    callback_data = evt.data.decode('utf-8')
+    log.debug("Callback data: %s", callback_data)
+    user_id = evt.sender_id
+    if not await DB.db.add_user(user_id):
+        await evt.answer(lang.SOMETHING_WENT_WRONG)
+        return
+    # msg = await client.get_messages(user_id, ids=msg_id)
+    # await handle_file_message(evt, msg)
+    await evt.answer(lang.ACCEPTED_TOS_TEXT)
+    await evt.edit(buttons=[[Button.inline(lang.AGREED, b"tos_agreed")]])
+
+
+@client.on(events.CallbackQuery(pattern=r"^(fileinfo|groupinfo)_page_(\d+)$"))
+async def handle_list_page(evt: events.CallbackQuery.Event) -> None:
+    user = await check_get_user(evt.sender_id, evt.message_id)
+    lang = get_lang(user)
+    kind = evt.pattern_match.group(1).decode()
+    page_no = int(evt.pattern_match.group(2))
+    is_group = kind == "groupinfo"
+    user_id = evt.sender_id
+
+    total_items = (await DB.db.total_groups(user_id)
+                   if is_group else await DB.db.total_files(user_id))
+    if total_items == 0:
+        await evt.edit(lang.NO_LABEL_LINKS_TEXT.format(label=lang.GROUP if is_group else lang.FILE))
+        return
+
+    limit = Config.FILE_INDEX_LIMIT
+    total_pages = (total_items + limit - 1) // limit
+
+    if page_no < 0 or page_no >= total_pages:
+        await evt.answer(lang.INVALID_PAGE, alert=True)
+        return
+
+    offset = page_no * limit
+    items_gen = (
+        DB.db.get_groups(user_id, offset, limit)
+        if is_group
+        else DB.db.get_files(user_id, offset, limit)
+    )
+
+    buttons: list[list[Button]] = []
+
+    async for item_id, name in items_gen:
+        buttons.append([
+            Button.inline(name, data=f"{kind}_file_{item_id}_{page_no}")
+        ])
+
+    if not buttons:
+        await evt.edit(lang.NO_LABELS_TEXT.format(label=lang.GROUPS if is_group else lang.FILES))
+        return
+
+    nav = []
+    if page_no > 0:
+        nav.append(Button.inline("<<", f"{kind}_page_{page_no - 1}"))
+
+    nav.append(Button.inline(
+        lang.FILES_BUTTON_CURRENT.format(
+            page_no=page_no + 1, total_pages=total_pages),
+        b"noop"
+    ))
+
+    if page_no + 1 < total_pages:
+        nav.append(Button.inline(">>", f"{kind}_page_{page_no + 1}"))
+
+    buttons.append(nav)
+    buttons.append([Button.inline(lang.BACK_TEXT, b"files_menu")])
+
+    await evt.edit(
+        lang.TOTAL_LABEL_COUNT.format(
+            total=total_items, label=lang.GROUP if is_group else lang.FILE),
+        buttons=buttons
+    )
+
+
+@client.on(events.CallbackQuery(pattern=r"^fileinfo_file_(\d+)_(\d+)(?:_(\d+))?$"))
+async def handle_fileinfo_button(evt: events.CallbackQuery.Event):
+    user = await check_get_user(evt.sender_id, evt.message_id)
+    lang = get_lang(user)
+    file_id = int(evt.pattern_match.group(1))
+    page_no = int(evt.pattern_match.group(2))
+    group_id = int(evt.pattern_match.group(
+        3)) if evt.pattern_match.group(3) else None
+    user_id = evt.sender_id
+    file_info = await DB.db.get_file(file_id, user_id)
+    if file_info is None:
+        await evt.answer(lang.FILE_NOT_FOUND_TEXT, alert=True)
+        return
+    token = make_token(user_id, file_info.id)
+    url = f"{Config.PUBLIC_URL}/dl/{token}"
+    wt_url = f"{Config.PUBLIC_URL}/wt/{token}"
+    await evt.edit(
+        lang.FILE_INFO_TEXT.format(
+            file_id=file_info.id,
+            dc_id=file_info.dc_id,
+            file_size=human_bytes(file_info.file_size),
+            mime_type=file_info.mime_type,
+            file_name=file_info.file_name,
+            file_type=lang.PHOTO if file_info.thumb_size else lang.DOCUMENT,
+            restricted=lang.YES if file_info.is_deleted else lang.NO
+        ),
+        buttons=[
+            [
+                Button.url(lang.DOWNLOAD, url),
+                Button.url(lang.WATCH, wt_url),
+            ],
+            [
+                Button.inline(
+                    lang.DELETE, (
+                        f"fileinfo_delconf2_{file_info.id}_{page_no}"
+                        f"{f'_{group_id}' if group_id else ''}"
+                    )),
+                Button.inline(lang.GET_FILE_TEXT,
+                              f"fileinfo_get_{file_info.id}")
+            ],
+            [Button.inline(
+                lang.BACK_TEXT, f"groupinfo_file_{group_id}_{page_no}" if group_id else f"fileinfo_page_{page_no}")]
+        ]
+    )
+
+
+@client.on(events.CallbackQuery(pattern=r"^groupinfo_file_(\d+)_(\d+)$"))
+async def handle_groupinfo_button(evt: events.CallbackQuery.Event):
+    user = await check_get_user(evt.sender_id, evt.message_id)
+    lang = get_lang(user)
+    group_id = int(evt.pattern_match.group(1))
+    page_no = int(evt.pattern_match.group(2))
+    user_id = evt.sender_id
+    file_info = await DB.db.get_group(group_id, user_id)
+    if file_info is None:
+        await evt.answer(lang.GROUP_NOT_FOUND_TEXT, alert=True)
+        return
+    token = make_token(user_id, file_info.group_id)
+    buttons: list[list[Button]] = [
+        [Button.url(lang.EXTERNAL_LINK, f"{Config.PUBLIC_URL}/group/{token}")]
+    ]
+    if file_info.files and len(file_info.files) <= 98:
+        async for file_id, name in DB.db.get_files2(user_id, file_info.files):
+            buttons.append(
+                [Button.inline(name, f"fileinfo_file_{file_id}_{page_no}_{group_id}")])
+    buttons.append(
+        [
+            Button.inline(lang.BACK_TEXT, f"groupinfo_page_{page_no}"),
+            Button.inline(
+                lang.DELETE, f"groupinfo_delconf2_{file_info.group_id}_{page_no}")
+        ]
+    )
+
+    await evt.edit(
+        lang.GROUP_INFO_TEXT.format(
+            name=file_info.name,
+            created_at=file_info.created_at,
+            total_files=len(file_info.files) if file_info.files else 0
+        ),
+        buttons=buttons
+    )
+
+
+@client.on(events.CallbackQuery(pattern=r"^fileinfo_get_(\d+)$"))
+async def handle_fileinfo_get_button(evt: events.CallbackQuery.Event):
+    user = await check_get_user(evt.sender_id, evt.message_id)
+    lang = get_lang(user)
+    file_id = int(evt.pattern_match.group(1))
+    user_id = evt.sender_id
+    file_info = await DB.db.get_file(file_id, user_id)
+    if file_info is None:
+        await evt.answer(lang.FILE_NOT_FOUND_TEXT, alert=True)
+        return
+    location = await DB.db.get_location(file_info, Config.BOT_ID)
+    input_media = InputMediaPhoto(
+        location) if location.thumb_size else InputMediaDocument(location)
+    await client.send_file(user_id, input_media, caption=file_info.file_name)
+
+
+@client.on(events.CallbackQuery(pattern=r"^(fileinfo|groupinfo)_delconf2_(\d+)_(\d+)(?:_(\d+))?$"))
+async def handle_fileinfo_del_conf_button(evt: events.CallbackQuery.Event):
+    user = await check_get_user(evt.sender_id, evt.message_id)
+    lang = get_lang(user)
+    kind = evt.pattern_match.group(1).decode()
+    file_id = int(evt.pattern_match.group(2))
+    page_no = int(evt.pattern_match.group(3))
+    group_id = int(evt.pattern_match.group(
+        4)) if evt.pattern_match.group(4) else None
+    user_id = evt.sender_id
+    is_group = kind == "groupinfo"
+
+    file_info = await DB.db.get_group(file_id, user_id) if is_group else await DB.db.get_file(file_id, user_id)
+    if file_info is None:
+        await evt.answer(lang.GROUP_NOT_FOUND_TEXT if is_group else lang.FILE_NOT_FOUND_TEXT, alert=True)
+        return
+    await evt.edit(
+        lang.CONFIRM_DELETE_TEXT.format(
+            label=lang.GROUP if is_group else lang.FILE),
+        buttons=[
+            [Button.inline(lang.YES+' '+lang.DELETE, (
+                f"{kind}_delete_{file_id}_{page_no}"
+                f"{f'_{group_id}' if group_id else ''}"
+            ))],
+            [Button.inline(lang.NO, (
+                f"{kind}_file_{file_id}_{page_no}"
+                f"{f'_{group_id}' if group_id else ''}"
+            ))]
+        ]
+    )
+
+
+@client.on(events.CallbackQuery(pattern=r"^(fileinfo|groupinfo)_delete_(\d+)_(\d+)(?:_(\d+))?$"))
+async def handle_fileinfo_del_button(evt: events.CallbackQuery.Event):
+    user = await check_get_user(evt.sender_id, evt.message_id)
+    lang = get_lang(user)
+    kind = evt.pattern_match.group(1).decode()
+    file_id = int(evt.pattern_match.group(2))
+    page_no = int(evt.pattern_match.group(3))
+    group_id = int(evt.pattern_match.group(
+        4)) if evt.pattern_match.group(4) else None
+    user_id = evt.sender_id
+    is_group = kind == "groupinfo"
+
+    file_info = await DB.db.get_group(file_id, user_id) if is_group else await DB.db.get_file(file_id, user_id)
+    if file_info is None:
+        await evt.answer(lang.GROUP_NOT_FOUND_TEXT if is_group else lang.FILE_NOT_FOUND_TEXT, alert=True)
+        return
+    if is_group:
+        await DB.db.delete_group(file_id, user_id)
+    else:
+        await DB.db.remove_file(file_id, user_id)
+    await evt.edit(lang.DELETED_SUCCESSFULLY_TEXT.format(label=lang.GROUP if is_group else lang.FILE), buttons=[
+        [
+            Button.inline(lang.BACK_TEXT, (
+                f"groupinfo_file_{group_id}_{page_no}" if group_id else f"{kind}_page_{page_no}"
+        ))
+        ]
+    ])
+
+
+@client.on(events.CallbackQuery(pattern=r"^files_menu$"))
+async def handle_files_menu_button(evt: events.CallbackQuery.Event):
+    user = await check_get_user(evt.sender_id, evt.message_id)
+    lang = get_lang(user)
+    await evt.edit(
+        lang.SELECT_TYPE_OF_FILE,
+        buttons=[
+            [Button.inline(lang.FILES, "fileinfo_page_0")],
+            [Button.inline(lang.GROUPS, "groupinfo_page_0")]
+        ]
+    )

tgfs/plugins/custom.py

@@ -0,0 +1,80 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import re
+import logging
+
+from telethon import events
+from telethon.tl.types import InputMediaDocument, InputMediaPhoto
+
+from tgfs.config import Config
+from tgfs.telegram import client
+from tgfs.database import DB
+from tgfs.utils.translation import get_lang
+from tgfs.utils.types import User
+from tgfs.utils.utils import parse_token
+
+log = logging.getLogger(__name__)
+
+
+async def send_file(_: events.NewMessage.Event, user_id: int, file_id: int) -> None:
+    lang = get_lang(user_id)
+    file_info = await DB.db.get_file(file_id, user_id)
+    if file_info is None:
+        return lang.FILE_ID_NOT_FOUND.format(file_id=file_id)
+    location = await DB.db.get_location(file_info, Config.BOT_ID)
+    input_media = InputMediaPhoto(
+        location) if location.thumb_size else InputMediaDocument(location)
+    await client.send_file(user_id, input_media, caption=file_info.file_name)
+
+
+async def handle_file_url(evt: events.NewMessage.Event, user: User, match: re.Match) -> None:
+    lang = get_lang(user)
+    payload = match.group("payload")
+    sig = match.group("sig")
+    pt = parse_token(payload, sig)
+    if not pt:
+        await evt.reply(lang.INAVLID_LINK_TEXT)
+        return
+    user_id, file_id = pt
+    status = await send_file(evt, user_id, file_id)
+    if status:
+        await evt.reply(status)
+
+
+async def handle_group_url(evt: events.NewMessage.Event, user: User, match: re.Match) -> None:
+    lang = get_lang(user)
+    payload = match.group("payload")
+    sig = match.group("sig")
+    pt = parse_token(payload, sig)
+    if not pt:
+        await evt.reply(lang.INAVLID_LINK_TEXT)
+        return
+    user_id, group_id = pt
+    group = await DB.db.get_group(group_id, user_id)
+    for file_id in group.files:
+        status = await send_file(evt, user_id, file_id)
+        if status:
+            await evt.reply(status)
+    await evt.reply(lang.GROUP_ENDOF_FILES)
+
+# pylint: disable=C0301
+HANDLERS = [
+    (re.compile(
+        r"^(?P<scheme>https?):\/\/(?P<host>(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}|\d{1,3}(?:\.\d{1,3}){3})(?::(?P<port>\d{1,5}))?\/dl\/(?P<payload>[^\/]+)\/(?P<sig>[^\/]+)$"), handle_file_url),
+    (re.compile(
+        r"^(?P<scheme>https?):\/\/(?P<host>(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}|\d{1,3}(?:\.\d{1,3}){3})(?::(?P<port>\d{1,5}))?\/group\/(?P<payload>[^\/]+)\/(?P<sig>[^\/]+)$"), handle_group_url)
+]

tgfs/plugins/files.py

@@ -0,0 +1,175 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import logging
+from typing import cast
+
+from telethon import events, Button
+from telethon.custom import Message
+from telethon.utils import get_input_location
+from telethon.errors import ButtonUrlInvalidError
+
+from tgfs.config import Config
+from tgfs.database import DB
+from tgfs.telegram import client, multi_clients
+from tgfs.utils.translation import get_lang
+from tgfs.utils.utils import check_get_user, make_token
+from tgfs.utils.types import FileInfo, FileSource, InputTypeLocation, Status
+
+
+log = logging.getLogger(__name__)
+
+
+@client.on(events.NewMessage(incoming=True, func=lambda x: x.is_private and x.file))
+async def handle_file_message(evt: events.NewMessage.Event, msg=None) -> None:
+    msg: Message = evt.message if not msg else msg
+    user = await check_get_user(msg.sender_id, msg.id)
+    if user is None:
+        return
+    if user.curt_op in [Status.GROUP_NAME, Status.GROUP]:
+        return
+    lang = get_lang(user)
+    dc_id, location = cast(
+        tuple[int, InputTypeLocation], get_input_location(msg.media))
+    file_info = FileInfo(
+        id=location.id,
+        dc_id=dc_id,
+        file_size=msg.file.size,
+        mime_type=msg.file.mime_type,
+        file_name=msg.file.name or f"{location.id}{msg.file.ext or ''}",
+        thumb_size=location.thumb_size,
+        is_deleted=False
+    )
+    file_source = FileSource(
+        chat_id=msg.chat_id,
+        message_id=msg.id,
+    )
+    await DB.db.add_file(user.user_id, file_info, file_source)
+    await DB.db.upsert_location(
+        multi_clients[0].client_id,
+        location
+    )
+    # fwd_msg: Message = await msg.forward_to(Config.BIN_CHANNEL)
+    token = make_token(msg.sender_id, file_info.id)
+    url = f"{Config.PUBLIC_URL}/dl/{token}"
+    wt_url = f"{Config.PUBLIC_URL}/wt/{token}"
+    try:
+        await evt.reply(
+            url,
+            buttons=[
+                [
+                    Button.url(lang.DOWNLOAD, url),
+                    Button.url(lang.WATCH, wt_url)
+                ],
+            ]
+        )
+    except ButtonUrlInvalidError as e:
+        log.error("Failed to send download link: %s", e)
+        await evt.reply(url)
+    log.info("Generated Link %s", url)
+
+
+@client.on(events.NewMessage(incoming=True, pattern=r"^/group", func=lambda x: x.is_private and not x.file))
+async def handle_group_command(evt: events.NewMessage.Event) -> None:
+    msg: Message = evt.message
+    user = await check_get_user(msg.sender_id, msg.id)
+    if user is None:
+        return
+    lang = get_lang(user)
+    if user.curt_op == Status.NO_OP:
+        user.curt_op = Status.GROUP
+        user.op_id = msg.id
+        await DB.db.upsert_user(user)
+        await evt.reply(lang.GROUP_SENDFILE_TEXT)
+    else:
+        await evt.reply(lang.ALREADY_IN_OP)
+
+
+@client.on(events.NewMessage(incoming=True, pattern=r"^/done", func=lambda x: x.is_private and not x.file))
+async def handle_done_command(evt: events.NewMessage.Event, user=None) -> None:
+    msg: Message = evt.message
+    user = user or await check_get_user(msg.sender_id, msg.id)
+    if user is None:
+        return
+    lang = get_lang(user)
+    if user.curt_op == Status.NO_OP:
+        await evt.reply(lang.NOT_IN_OP)
+    elif user.curt_op == Status.GROUP:
+        min_id = user.op_id+1
+        max_id = msg.id
+        order = 0
+        group_id = await DB.db.create_group(user.user_id, str(msg.id))
+        try:
+            file_msgs: list[Message] = await client.get_messages(
+                entity=msg.chat_id,
+                ids=range(min_id, max_id),
+            )
+            file_msgs = list(filter(lambda m: m and m.file, file_msgs))
+            if not file_msgs:
+                await DB.db.delete_group(group_id, user.user_id)
+                await evt.reply(lang.GROUP_NOFILES_TEXT)
+                user.curt_op = Status.NO_OP
+                user.op_id = 0
+                await DB.db.upsert_user(user)
+                return
+            for file_msg in file_msgs:
+                dc_id, location = cast(
+                    tuple[int, InputTypeLocation], get_input_location(file_msg.media))
+                file_info = FileInfo(
+                    id=location.id,
+                    dc_id=dc_id,
+                    file_size=file_msg.file.size,
+                    mime_type=file_msg.file.mime_type,
+                    file_name=file_msg.file.name or f"{location.id}{file_msg.file.ext or ''}",
+                    thumb_size=location.thumb_size,
+                    is_deleted=False
+                )
+                file_source = FileSource(
+                    chat_id=file_msg.chat_id,
+                    message_id=file_msg.id
+                )
+                await DB.db.add_file(user.user_id, file_info, file_source)
+                await DB.db.upsert_location(
+                    multi_clients[0].client_id,
+                    location
+                )
+                order += 1
+                await DB.db.add_file_to_group(group_id, user.user_id, file_info.id, order)
+            await evt.reply(lang.GROUP_NAME_TEXT)
+            user.curt_op = Status.GROUP_NAME
+            user.op_id = group_id
+            await DB.db.upsert_user(user)
+        except Exception as e: # pylint: disable=W0718
+            DB.db.delete_group(group_id, user.user_id)
+            log.error(e, exc_info=True, stack_info=True)
+    else:
+        await evt.reply(lang.UNKNOWN_COMMAND)
+
+@client.on(events.NewMessage(incoming=True, pattern=r"^/files", func=lambda x: x.is_private and not x.file))
+async def handle_myfiles_command(evt: events.NewMessage.Event) -> None:
+    msg: Message = evt.message
+    user = await check_get_user(msg.sender_id, msg.id)
+    if user is None:
+        return
+    lang = get_lang(user)
+    total_files = await DB.db.total_files(user.user_id)
+    total_groups = await DB.db.total_groups(user.user_id)
+    await evt.reply(lang.FILES_TEXT.format(total_files=total_files, total_groups=total_groups),
+                    buttons=[
+        [Button.inline(lang.FILES, "fileinfo_page_0")],
+        [Button.inline(lang.GROUPS, "groupinfo_page_0")]
+    ]
+    )

tgfs/plugins/message.py

@@ -0,0 +1,115 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import logging
+
+from telethon import events
+from telethon.custom import Message
+
+from tgfs.config import Config
+from tgfs.plugins.custom import HANDLERS
+from tgfs.telegram import client
+from tgfs.database import DB
+from tgfs.utils.translation import get_lang, registry
+from tgfs.utils.types import Status, User
+from tgfs.utils.utils import check_get_user, make_token
+
+log = logging.getLogger(__name__)
+
+
+@client.on(events.NewMessage(incoming=True, pattern=r"^/start", func=lambda x: x.is_private and not x.file))
+async def handle_start_command(evt: events.NewMessage.Event) -> None:
+    msg: Message = evt.message
+    user = await check_get_user(msg.sender_id, msg.id)
+    if not user:
+        return
+    lang = get_lang(user)
+    await evt.reply(lang.START_TEXT)
+
+@client.on(events.NewMessage(incoming=True, pattern=r"^/help", func=lambda x: x.is_private and not x.file))
+async def handle_help_command(evt: events.NewMessage.Event) -> None:
+    msg: Message = evt.message
+    user = await check_get_user(msg.sender_id, msg.id)
+    if not user:
+        return
+    lang = get_lang(user)
+    await evt.reply(lang.HELP_TEXT)
+
+@client.on(events.NewMessage(incoming=True, pattern=r"^(?!/).*", func=lambda x: x.is_private and not x.file))
+async def handle_text_message(evt: events.NewMessage.Event) -> None:
+    msg: Message = evt.message
+    user = await check_get_user(msg.sender_id, msg.id)
+    if user is None:
+        return
+    lang = get_lang(user)
+
+    message = msg.message.strip()
+    if user.curt_op == Status.GROUP_NAME:
+        await handle_group_name(evt, user)
+    else:
+        for pattern, func in HANDLERS:
+            m = pattern.match(message)
+            if m:
+                await func(evt, user, m)
+                return
+
+        await evt.reply(lang.UNKNOWN_COMMAND)
+
+async def handle_group_name(evt: events.NewMessage.Event, user: User) -> None:
+    lang = get_lang(user)
+    msg: Message = evt.message
+    name = msg.text.strip()
+    group_id = user.op_id
+    await DB.db.update_group_name(group_id, user.user_id, name)
+    user.curt_op = Status.NO_OP
+    user.op_id = 0
+    await DB.db.upsert_user(user)
+    token = make_token(user.user_id, group_id)
+    url = f"{Config.PUBLIC_URL}/group/{token}"
+    await evt.reply(lang.GROUP_CREATED_TEXT.format(name=name, url=url))
+
+@client.on(events.NewMessage(
+    incoming=True,
+    pattern=r"^/setln(?:\s+([a-z]{2}))?$",
+    func=lambda x: x.is_private and not x.file
+))
+async def handle_setln_command(evt: events.NewMessage.Event) -> None:
+    msg: Message = evt.message
+    user = await check_get_user(msg.sender_id, msg.id)
+    if user is None:
+        return
+    lang = get_lang(user)
+    ln_code = evt.pattern_match.group(1)
+    if ln_code is None or ln_code not in registry:
+        await evt.reply(lang.SETLN_USAGE_TEXT.format(supported_codes=", ".join(registry.keys())))
+        return
+    user.preferred_lang = ln_code
+    if await DB.db.upsert_user(user):
+        await evt.reply(lang.SETLN_SET_TO.format(ln_code=ln_code))
+    else:
+        await evt.reply(lang.SOMETHING_WENT_WRONG)
+
+@client.on(events.NewMessage(incoming=True, pattern=r"^/cancel", func=lambda x: x.is_private and not x.file))
+async def handle_cancel_command(evt: events.NewMessage.Event, user=None) -> None:
+    msg: Message = evt.message
+    user = user or await check_get_user(msg.sender_id, msg.id)
+    if user is None:
+        return
+    lang = get_lang(user)
+    user.curt_op=Status.NO_OP
+    user.op_id=0
+    await DB.db.upsert_user(user)
+    await evt.reply(lang.OPERATION_CANCELED)

tgfs/routes.py

@@ -0,0 +1,109 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import logging
+import asyncio
+from aiohttp import web
+
+from tgfs.config import Config
+from tgfs.paralleltransfer import ParallelTransferrer
+from tgfs.utils.utils import make_token, parse_token, update_location, uptime_human
+from tgfs.telegram import multi_clients
+from tgfs.database import DB
+
+log = logging.getLogger(__name__)
+routes = web.RouteTableDef()
+
+client_selection_lock = asyncio.Lock()
+
+@routes.get("/")
+async def handle_root(_: web.Request):
+    return web.json_response({
+        'uptime': uptime_human(),
+        'load': {transfer.client_id: transfer.users for transfer in multi_clients}
+    })
+
+# @routes.get(r"/{msg_id:-?\d+}/{name}")
+@routes.get("/dl/{payload}/{sig}")
+@routes.get("/wt/{payload}/{sig}")
+async def handle_file_request(req: web.Request, head: bool = None, watch: bool = None) -> web.Response:
+    if watch is None:
+        watch: bool = True if "wt" in req.path.split("/") else False
+    if head is None:
+        head: bool = req.method == "HEAD"
+    payload = req.match_info["payload"]
+    sig = req.match_info["sig"]
+    pt = parse_token(payload, sig)
+    if not pt:
+        return web.Response(status=404, text="File not found")
+    user_id, file_id = pt
+
+    file = await DB.db.get_file(file_id, user_id)
+    if not file:
+        return web.Response(status=404, text="File not found")
+    if file.is_deleted:
+        return web.Response(status=451, text="File is restricted")
+
+    size = file.file_size
+    from_bytes = req.http_range.start or 0
+    until_bytes = (req.http_range.stop or size) - 1
+
+    if (until_bytes >= size) or (from_bytes < 0) or (until_bytes < from_bytes):
+        return web.Response(status=416, headers={"Content-Range": f"bytes */{size}"})
+    if head:
+        body=None
+    else:
+        transfer: ParallelTransferrer = min(multi_clients, key=lambda c: c.users)
+        log.debug("Using client %s", transfer.client_id)
+        location = await DB.db.get_location(file,  transfer.client_id)
+        if location is None:
+            source = await DB.db.get_source(file.id, user_id)
+            location = await update_location(source, transfer)
+        body=transfer.download(location, file.dc_id, size, from_bytes, until_bytes)
+
+    return web.Response(
+        status=200 if (from_bytes == 0 and until_bytes == size - 1) else 206,
+        body=body,
+        headers={
+        "Content-Type": file.mime_type,
+        "Content-Range": f"bytes {from_bytes}-{until_bytes}/{size}",
+        "Content-Length": str(until_bytes - from_bytes + 1),
+        "Content-Disposition": f'{"inline" if watch else "attachment"}; filename="{file.file_name}"',
+        "Accept-Ranges": "bytes",
+    })
+
+@routes.get("/group/{payload}/{sig}")
+async def handle_group_request(req: web.Request) -> web.Response:
+    payload = req.match_info["payload"]
+    sig = req.match_info["sig"]
+    pt = parse_token(payload, sig)
+    if not pt:
+        return web.Response(status=404, text="File not found")
+    user_id, group_id = pt
+    group = await DB.db.get_group(group_id, user_id)
+    if group is None:
+        return web.Response(status=404, text="Group not found")
+    resp = "".join(f"{Config.PUBLIC_URL}/dl/{make_token(user_id, file_id)}\n" for file_id in group.files)
+    return web.Response(status=200, text=resp)
+
+@routes.get("/dl/{object_id}", allow_head=True)
+async def stream_handler(request: web.Request):
+    object_id = request.match_info["object_id"]
+    file = await DB.db.get_file_old(object_id)
+    if not file:
+        return web.Response(status=404, text="File not found")
+    token = make_token(file["user_id"], file["media_id"])
+    return web.HTTPFound(f"{Config.PUBLIC_URL}/dl/{token}")

tgfs/telegram.py

@@ -0,0 +1,86 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import asyncio
+import importlib.util
+import logging
+
+from pathlib import Path
+import sys
+from typing import Optional
+from telethon import TelegramClient, functions
+from telethon.sessions import MemorySession
+from telethon.tl.types import InputPeerUser
+
+from tgfs.config import Config
+from tgfs.paralleltransfer import ParallelTransferrer
+
+log = logging.getLogger(__name__)
+
+multi_clients: list[ParallelTransferrer] = []
+
+client = TelegramClient(
+    "tg-filestream"+Config.SESSION_NAME,
+    api_id=Config.API_ID,
+    api_hash=Config.API_HASH,
+    receive_updates=not Config.NO_UPDATE,
+    sequential_updates=Config.SEQUENTIAL_UPDATES
+)
+
+async def _start_client(token: str) -> Optional[ParallelTransferrer]:
+    bot = TelegramClient(
+        MemorySession(),
+        api_id=Config.API_ID,
+        api_hash=Config.API_HASH,
+        receive_updates=False
+    )
+    try:
+        await bot.start(bot_token=token)
+        # https://github.com/LonamiWebs/Telethon/blob/59da66e105ba29eee7760538409181859c7d310d/telethon/client/downloads.py#L62
+        config = await bot(functions.help.GetConfigRequest())
+        for option in config.dc_options:
+            if option.ip_address == bot.session.server_address:
+                bot.session.set_dc(
+                    option.id, option.ip_address, option.port)
+                bot.session.save()
+                break
+        me: InputPeerUser = await bot.get_me(True)
+        transfer = ParallelTransferrer(bot, me.user_id)
+        transfer.post_init()
+        return transfer
+    except Exception as e: # pylint: disable=W0718
+        log.error("Faied to Start Client %s: %s", token.split(":")[0], e)
+        return None
+
+async def start_clients():
+    tasks = (_start_client(t) for t in Config.TOKENS)
+    results = await asyncio.gather(*tasks)
+    multi_clients.extend(filter(None, results))
+
+def load_plugins(folder_path: str) -> None:
+    folder = Path(folder_path)
+    package_prefix = ".".join(folder.parts)
+    for file in folder.glob("*.py"):
+        module_name = f"{package_prefix}.{file.stem}"
+        if module_name in sys.modules:
+            log.debug("Already Imported %s, skipping", module_name)
+            continue
+        spec = importlib.util.spec_from_file_location(module_name, str(file))
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+        module.__package__ = package_prefix
+        spec.loader.exec_module(module)
+        log.info("Imported %s", module_name)

tgfs/utils/cache_util.py

@@ -0,0 +1,76 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import asyncio
+import logging
+
+from collections import OrderedDict
+from typing import Optional, Callable, Awaitable, Any
+
+log = logging.getLogger(__name__)
+
+class AsyncLRUCache:
+    def __init__(self, fn: Callable[..., Awaitable[Any]], maxsize: Optional[int], use_first_arg: bool) -> None:
+        self.fn = fn
+        self.maxsize = maxsize
+        self.use_first_arg = use_first_arg
+        self.cache: OrderedDict[int, asyncio.Task] = OrderedDict()
+
+    def _make_key(self, args, kwargs) -> int:
+        if self.use_first_arg:
+            if not args:
+                raise ValueError("First argument missing for use_first_arg=True")
+            return hash(args[0])
+        else:
+            key_data = args
+            if kwargs:
+                key_data += tuple(sorted(kwargs.items()))
+            return hash(key_data)
+
+    async def __call__(self, *args, **kwargs) -> Any:
+        key = self._make_key(args, kwargs)
+
+        if key in self.cache:
+            task = self.cache[key]
+            self.cache.move_to_end(key)
+            return await asyncio.shield(task)
+
+        async def call() -> Any:
+            try:
+                return await self.fn(*args, **kwargs)
+            except Exception:
+                self.cache.pop(key, None)
+                raise
+
+        task = asyncio.create_task(call())
+        self.cache[key] = task
+
+        if self.maxsize is not None and len(self.cache) > self.maxsize:
+            self.cache.popitem(last=False)
+
+        result = await asyncio.shield(task)
+        if result is None:
+            self.cache.pop(key, None)
+        return result
+
+    def cache_clear(self) -> None:
+        self.cache.clear()
+
+def lru_cache(maxsize: Optional[int] = 128, use_first_arg: bool = False
+    ) -> Callable[[Callable[..., Awaitable[Any]]], AsyncLRUCache]:
+    def decorator(fn: Callable[..., Awaitable[Any]]) -> AsyncLRUCache:
+        return AsyncLRUCache(fn, maxsize, use_first_arg)
+    return decorator

tgfs/utils/config_utils.py

@@ -0,0 +1,73 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+
+from __future__ import annotations
+
+from os import environ
+from typing import Any
+
+class ConfigBase:
+    @staticmethod
+    def env_bool(key: str, default: bool = False) -> bool:
+        val = environ.get(key)
+        if val is None:
+            return default
+        return val.lower() in ("1", "true", "yes", "on")
+
+    @staticmethod
+    def env_int(key: str, default: int) -> int:
+        return int(environ.get(key, default))
+
+    @staticmethod
+    def get_multi_client_tokens() -> list[str]:
+        prefix = "MULTI_TOKEN"
+        tokens: list[tuple[int, str]] = []
+
+        for key, value in environ.items():
+            if key.startswith(prefix):
+                suffix = key[len(prefix):]
+                if suffix.isdigit():
+                    tokens.append((int(suffix), value))
+
+        tokens.sort(key=lambda x: x[0])
+        return [token for _, token in tokens]
+
+    @staticmethod
+    def load_backend_config(
+        prefix: str,
+        schema: dict[str, tuple[type, Any]],
+        required: set[str],
+    ) -> dict[str, Any]:
+        kwargs: dict[str, Any] = {}
+        missing: list[str] = []
+
+        for key, (typ, default) in schema.items():
+            env_key = f"{prefix}_{key.upper()}"
+
+            if env_key in environ:
+                kwargs[key] = typ(environ[env_key])
+            elif default is not None:
+                kwargs[key] = default
+            else:
+                missing.append(env_key)
+
+        if set(missing) & required:
+            raise RuntimeError(
+                f"Missing required environment variables: {', '.join(missing)}"
+            )
+
+        return kwargs

tgfs/utils/patches.py

@@ -0,0 +1,18 @@
+import logging
+from collections import defaultdict
+from typing import Callable, Any
+from enum import Enum
+
+log = logging.getLogger("events")
+
+class Events(Enum):
+    STARTUP = "startup"
+    AFTER_WEBAPP = "after_webapp"
+    REQUEST = "request"
+
+HANDLER=dict[Events, list[Callable[..., Any]]]
+
+_register_blocking: HANDLER = defaultdict(list)
+_register_background: HANDLER = defaultdict(list)
+_hook_blocking: HANDLER = defaultdict(list)
+_hook_background: HANDLER = defaultdict(list)

tgfs/utils/translation.py

@@ -0,0 +1,226 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+# pylint: disable=C0103
+
+from typing import Union
+
+from tgfs.utils.types import User
+
+class en:
+    # ── Start & Help ─────────────────────────────────────────────
+    START_TEXT = """Send me any telegram file or photo I will generate a link for it
+Use /help to see available commands."""
+
+    HELP_TEXT = """
+Available Commands:
+/start - Start the bot
+/help - Show this help message
+/group - Start creating a group of files
+/done - Finish adding files to the group
+/files - List your uploaded files or created groups
+/setln - Change your language
+/cancel - Cancel the current operation
+"""
+
+    ACCEPTED_TOS_TEXT = "You have agreed to the Terms of Service."
+
+    # ── Errors & State ────────────────────────────────────────────
+    UNKNOWN_COMMAND = "Unknown command/operation"
+    SOMETHING_WENT_WRONG = "Something went wrong. Please try again later."
+    INAVLID_LINK_TEXT = "Invalid link."
+    INVALID_PAGE = "Invalid page."
+
+    ALREADY_IN_OP = "You are already in an operation. Please complete it before starting a new one."
+    NOT_IN_OP = "You are not in any operation."
+
+    FILE_ID_NOT_FOUND = "File with id `{file_id}` not found."
+    FILE_LOCATION_NOT_FOUND = "File location not found."
+    FILE_NOT_FOUND_TEXT = "File not found."
+    GROUP_NOT_FOUND_TEXT = "Group not found."
+    OPERATION_CANCELED = "Current operation has been canceled"
+
+    # ── File & Group Info ─────────────────────────────────────────
+    FILES_TEXT = """You have created links for:
+• Files: {total_files}
+• Groups: {total_groups}
+
+Select the type of links you want to view.
+"""
+
+    FILE_INFO_TEXT = """File Info:
+ID: {file_id}
+DC ID: {dc_id}
+Size: {file_size}
+MIME Type: {mime_type}
+File Name: {file_name}
+File Type: {file_type}
+Is Restricted: {restricted}"""
+
+    GROUP_INFO_TEXT = """Group Info:
+Name: {name}
+Created At: {created_at}
+Total Files: {total_files}"""
+
+    # ── Group Flow ────────────────────────────────────────────────
+    GROUP_NAME_TEXT = "Send a name for your group of files"
+    GROUP_SENDFILE_TEXT = "Send files to add to the group. When done, send /done"
+    GROUP_CREATED_TEXT = "Group '{name}' created!\n{url}"
+    GROUP_NOFILES_TEXT = "No files were added to the group. Operation cancelled."
+    GROUP_ENDOF_FILES = "End of group files."
+
+    # ── File Actions ──────────────────────────────────────────────
+    CONFIRM_DELETE_TEXT = "Do you really want to delete this {label}?"
+    DELETED_SUCCESSFULLY_TEXT = "{label} deleted successfully."
+    SELECT_TYPE_OF_FILE = "Select the type of links you want to view."
+    GET_FILE_TEXT = "Get File"
+
+    # ── Lists & Pagination ────────────────────────────────────────
+    NO_LABEL_LINKS_TEXT = "You have not generated any {label} links yet."
+    NO_LABELS_TEXT = "No {label}s on this page."
+    TOTAL_LABEL_COUNT = "You have **{total}** {label}s."
+    FILES_BUTTON_CURRENT = "Page {page_no}/{total_pages}"
+
+    # ── Languages ─────────────────────────────────────────────────
+    SETLN_USAGE_TEXT = "/setln <language_code>\nExample: /setln en\nSupported language codes: {supported_codes}"
+    SETLN_SET_TO = "Language changed to {ln_code}"
+
+    # ── Buttons & Labels ──────────────────────────────────────────
+    YES = "Yes"
+    NO = "No"
+    BACK_TEXT = "Back"
+
+    PHOTO = "Photo"
+    DOCUMENT = "Document"
+
+    DELETE = "Delete"
+    OPEN = "Open"
+
+    DOWNLOAD = "Download"
+    WATCH = "Watch"
+    FILES = "Files"
+    GROUPS = "Groups"
+    FILE = "File"
+    GROUP = "Group"
+    AGREED = "Agreed"
+    EXTERNAL_LINK = "External Link"
+
+class kn(en):
+    # ─�� Start & Help ─────────────────────────────────────────────
+    START_TEXT = """ಯಾವುದೇ ಟೆಲಿಗ್ರಾಂ ಕಡತ ಅಥವಾ ಚಿತ್ರವನ್ನು ನನಗೆ ಕಳುಹಿಸಿ, ಅದಕ್ಕೆ ನಾನು ಒಂದು ಲಿಂಕ್ ರಚಿಸುತ್ತೇನೆ.
+ಲಭ್ಯವಿರುವ ಆಜ್ಞೆಗಳನ್ನು ನೋಡಲು /help ಬಳಸಿ."""
+
+    HELP_TEXT = """
+ಲಭ್ಯವಿರುವ ಆಜ್ಞೆಗಳು:
+/start - ಬಾಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ
+/help - ಈ ಸಹಾಯ ಸಂದೇಶವನ್ನು ತೋರಿಸಿ
+/group - ಕಡತಗಳ ಗುಂಪನ್ನು ರಚಿಸಲು ಪ್ರಾರಂಭಿಸಿ
+/done - ಗುಂಪಿಗೆ ಕಡತಗಳನ್ನು ಸೇರಿಸುವುದನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ
+/files - ನೀವು ಕಳುಹಿಸಿದ ಕಡತಗಳ ಮತ್ತು ರಚಿಸಿದ ಗುಂಪುಗಳ ಪಟ್ಟಿ
+/setln - ನಿಮ್ಮ ಭಾಷೆಯನ್ನು ಬದಲಾಯಿಸಲು
+/cancel - ಪ್ರಸ್ತುತ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ರದ್ದುಗೊಳಿಸಲು
+"""
+
+    ACCEPTED_TOS_TEXT = "ನೀವು ಸೇವಾ ನಿಯಮಗಳಿಗೆ ಒಪ್ಪಿಗೆ ನೀಡಿದ್ದೀರಿ."
+
+    # ── Errors & State ────────────────────────────────────────────
+    UNKNOWN_COMMAND = "ಅಪರಿಚಿತ ಆಜ್ಞೆ / ಕಾರ್ಯ"
+    SOMETHING_WENT_WRONG = "ಏನೋ ತಪ್ಪಾಗಿದೆ. ದಯವಿಟ್ಟು ನಂತರ ಮತ್ತೆ ಪ್ರಯತ್ನಿಸಿ."
+    INAVLID_LINK_TEXT = "ಅಮಾನ್ಯ ಲಿಂಕ್."
+    INVALID_PAGE = "ಅಮಾನ್ಯ ಪುಟ."
+
+    ALREADY_IN_OP = "ನೀವು ಈಗಾಗಲೇ ಒಂದು ಕಾರ್ಯದಲ್ಲಿದ್ದೀರಿ. ಹೊಸದನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಅದನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ."
+    NOT_IN_OP = "ನೀವು ಯಾವುದೇ ಕಾರ್ಯದಲ್ಲಿಲ್ಲ."
+
+    FILE_ID_NOT_FOUND = "`{file_id}` ಗುರುತಿನ ಯಾವುದೇ ಫೈಲ್ ಕಂಡುಬಂದಿಲ್ಲ."
+    FILE_LOCATION_NOT_FOUND = "ಕಡತದ ಸ್ಥಳ ಕಂಡುಬಂದಿಲ್ಲ."
+    FILE_NOT_FOUND_TEXT = "ಕಡತ ಕಂಡುಬಂದಿಲ್ಲ."
+    GROUP_NOT_FOUND_TEXT = "ಗುಂಪು ಕಂಡುಬಂದಿಲ್ಲ."
+
+    # ── File & Group Info ─────────────────────────────────────────
+    FILES_TEXT = """ನೀವು ರಚಿಸಿದ ಲಿಂಕ್‌ಗಳು :
+• ಕಡತಗಳು: {total_files}
+• ಗುಂಪುಗಳು: {total_groups}
+
+ನೀವು ನೋಡಲು ಬಯಸುವ ಲಿಂಕ್‌ಗಳ ಪ್ರಕಾರವನ್ನು ಆಯ್ಕೆಮಾಡಿ.
+"""
+
+    FILE_INFO_TEXT = """ಫೈಲ್ ಮಾಹಿತಿ:
+ಕಡತದ ಐಡಿ: {file_id}
+ಡಿಸಿ ಐಡಿ: {dc_id}
+ಗಾತ್ರ: {file_size}
+ಮೈಮ್ ಪ್ರಕಾರ: {mime_type}
+ಕಡತದ ಹೆಸರು: {file_name}
+ಕಡತದ ಪ್ರಕಾರ: {file_type}
+ನಿರ್ಬಂಧಿತವಾಗಿದೆ: {restricted}"""
+
+    GROUP_INFO_TEXT = """ಗುಂಪು ಮಾಹಿತಿ:
+ಹೆಸರು: {name}
+ರಚಿಸಿದ ದಿನಾಂಕ: {created_at}
+ಒಟ್ಟು ಕಡತಗಳು: {total_files}"""
+
+    # ── Group Flow ────────────────────────────────────────────────
+    GROUP_NAME_TEXT = "ನಿಮ್ಮ ಕಡತಗಳ ಗುಂಪಿಗೆ ಒಂದು ಹೆಸರನ್ನು ಕಳುಹಿಸಿ"
+    GROUP_SENDFILE_TEXT = "ಗುಂಪಿಗೆ ಸೇರಿಸಲು ಕಡತಗಳನ್ನು ಕಳುಹಿಸಿ. ಮುಗಿದ ನಂತರ /done ಕಳುಹಿಸಿ"
+    GROUP_CREATED_TEXT = "ಗುಂಪು '{name}' ರಚಿಸಲಾಗಿದೆ!\n{url}"
+    GROUP_NOFILES_TEXT = "ಗುಂಪಿಗೆ ಯಾವುದೇ ಕಡತಗಳನ್ನು ಸೇರಿಸಲಾಗಿಲ್ಲ. ಕಾರ್ಯವನ್ನು ರದ್ದುಗೊಳಿಸಲಾಗಿದೆ."
+    GROUP_ENDOF_FILES = "ಗುಂಪಿನ ಕಡತಗಳ ಅಂತ್ಯ."
+
+    # ── File Actions ──────────────────────────────────────────────
+    CONFIRM_DELETE_TEXT = "ನೀವು ಈ {label} ಅನ್ನು ಅಳಿಸಲು ಖಚಿತವಾಗಿದ್ದೀರಾ?"
+    DELETED_SUCCESSFULLY_TEXT = "{label} ಯಶಸ್ವಿಯಾಗಿ ಅಳಿಸಲಾಗಿದೆ."
+    SELECT_TYPE_OF_FILE = "ನೀವು ನೋಡಲು ಬಯಸುವ ಲಿಂಕ್‌ಗಳ ಪ್ರಕಾರವನ್ನು ��ಯ್ಕೆಮಾಡಿ."
+    GET_FILE_TEXT = "ಕಡತದ ಪಡೆಯಿರಿ"
+
+    # ── Lists & Pagination ────────────────────────────────────────
+    NO_LABEL_LINKS_TEXT = "ನೀವು ಇನ್ನೂ ಯಾವುದೇ {label}ಗಳ ಲಿಂಕ್‌ಗಳನ್ನು ರಚಿಸಿಲ್ಲ."
+    NO_LABELS_TEXT = "ಈ ಪುಟದಲ್ಲಿ ಯಾವುದೇ {label}ಗಳಿಲ್ಲ."
+    TOTAL_LABEL_COUNT = "ನಿಮ್ಮ ಬಳಿ ಒಟ್ಟು **{total}** {label}ಗಳಿವೆ."
+    FILES_BUTTON_CURRENT = "ಪುಟ {page_no}/{total_pages}"
+
+    # ── Languages ─────────────────────────────────────────────────
+    SETLN_USAGE_TEXT = "/setln <language_code>\nಉದಾಹರಣೆ: /setln en\nಬೆಂಬಲಿತ ಭಾಷಾ ಕೋಡ್‌ಗಳು: {supported_codes}"
+    SETLN_SET_TO = "ಭಾಷೆಯನ್ನು {ln_code} ಗೆ ಬದಲಾಯಿಸಲಾಗಿದೆ"
+
+    # ── Buttons & Labels ──────────────────────────────────────────
+    YES = "ಹೌದು"
+    NO = "ಇಲ್ಲ"
+    BACK_TEXT = "ಹಿಂತಿರುಗಿ"
+
+    PHOTO = "ಚಿತ್ರ"
+    DOCUMENT = "ದಾಖಲೆ"
+
+    DELETE = "ಅಳಿಸಿ"
+    OPEN = "ತೆರೆಯಿರಿ"
+
+    DOWNLOAD = "ಡೌನ್‌ಲೋಡ್"
+    WATCH = "ವೀಕ್ಷಿಸಿ"
+    FILES = "ಕಡತಗಳು"
+    GROUPS = "ಗುಂಪುಗಳು"
+    FILE = "ಕಡತ"
+    GROUP = "ಗುಂಪು"
+    AGREED = "ಒಪ್ಪಿಗೆ"
+    EXTERNAL_LINK = "ಬಾಹ್ಯ ಲಿಂಕ್"
+
+registry = {
+    "en": en,
+    "kn": kn
+}
+
+def get_lang(iso_code: Union[str, User] = None) -> en:
+    if isinstance(iso_code, User):
+        iso_code = iso_code.preferred_lang
+    return registry.get(iso_code, en)

tgfs/utils/types.py

@@ -0,0 +1,101 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import datetime
+from typing import Optional, Union, Any
+from dataclasses import dataclass
+from enum import Enum
+
+from telethon.tl import types
+
+from tgfs.config import Config
+
+InputTypeLocation = Union[types.InputDocumentFileLocation, types.InputPhotoFileLocation]
+InputMedia = Union[types.Document, types.Photo, types.PhotoEmpty, types.DocumentEmpty]
+SupportedType = Union[bytes, bool, int, str, list, dict]
+
+class Status(Enum):
+    NO_OP=0
+    GROUP=1
+    GROUP_NAME=2
+
+@dataclass
+class FileInfo:
+    __slots__ = ("id", "dc_id", "file_size", "mime_type", "file_name", "thumb_size", "is_deleted")
+    id: int
+    dc_id: int
+    file_size: int
+    mime_type: str
+    file_name: str
+    thumb_size: str
+    is_deleted: bool
+
+@dataclass
+class FileSource:
+    chat_id: int
+    message_id: int
+    time: Optional[datetime.datetime] = None
+
+
+@dataclass
+class User:
+    user_id: int
+    join_date: Optional[datetime.datetime] = None
+    ban_date: Optional[datetime.datetime] = None
+    warns: int = 0
+    preferred_lang: str = "en"   # 2-letter ISO code, default en
+    curt_op: Optional[Status] = Status.NO_OP
+    op_id: Optional[int] = 0
+
+    @property
+    def is_banned(self) -> bool:
+        return self.ban_date is not None
+
+    @property
+    def is_admin(self) -> bool:
+        return self.user_id in Config.ADMIN_IDS
+
+    @classmethod
+    def from_row(cls, row: dict[str, Any]) -> "User":
+
+        def parse_dt(val):
+            if isinstance(val, datetime.datetime):
+                return val
+            if isinstance(val, (str, bytes)):
+                try:
+                    s = val.decode() if isinstance(val, bytes) else val
+                    return datetime.datetime.fromisoformat(s)
+                except Exception: # pylint: disable=W0718
+                    return None
+            return None
+
+        return cls(
+            user_id = int(row["user_id"]),
+            join_date = parse_dt(row.get("join_date")),
+            ban_date = parse_dt(row.get("ban_date")),
+            warns = int(row.get("warns", 0)),
+            preferred_lang = row.get("preferred_lang") or "en",
+            curt_op = Status(row.get("curt_op")),
+            op_id = int(row.get("op_id"))
+        )
+
+@dataclass
+class GroupInfo:
+    group_id: int
+    user_id: int
+    name: str
+    created_at: Optional[datetime.datetime]
+    files: Optional[list[int]] = None

tgfs/utils/utils.py

@@ -0,0 +1,162 @@
+# TG-FileStream
+# Copyright (C) 2025-2026 Deekshith SH
+
+# 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 <http://www.gnu.org/licenses/>.
+
+import logging
+import sys
+import base64
+import hashlib
+import hmac
+import struct
+import time
+import importlib.metadata
+from typing import Optional, cast
+from pathlib import Path
+
+from telethon import Button
+from telethon.utils import get_input_location
+from telethon.tl.custom import Message
+
+from tgfs.config import Config
+from tgfs.paralleltransfer import ParallelTransferrer
+from tgfs.utils.types import FileSource, InputTypeLocation, User
+from tgfs.telegram import client
+from tgfs.database import DB
+
+log = logging.getLogger(__name__)
+
+START_TIME = time.monotonic()
+
+async def update_location(source: FileSource, transfer: ParallelTransferrer) -> InputTypeLocation:
+    message = cast(Message,await client.forward_messages(
+        Config.BIN_CHANNEL, source.message_id, source.chat_id, drop_author=True))
+    msg = cast(Message, await transfer.client.get_messages(message.chat_id, ids=message.id))
+    await message.delete()
+    _, location = get_input_location(msg)
+    await DB.db.upsert_location(transfer.client_id, location)
+    return location
+
+async def check_get_user(user_id: int, msg_id, required: bool = True) -> Optional[User]:
+    if Config.ALLOWED_IDS and user_id not in Config.ALLOWED_IDS:
+        return None
+    user = await DB.db.get_user(user_id)
+    if required and user is None:
+        await client.send_message(
+            user_id, "Please agree to the Terms of Service before using the bot.",
+            buttons=[[Button.inline('Agree', f'tos_agree_{msg_id}'.encode('utf-8'))]]
+        )
+    if user is not None and user.is_banned:
+        await client.send_message(user_id, "You are banned from using this bot.")
+        return None
+    return user
+
+async def load_configs():
+    Config.SECRET = await DB.db.get_secret()
+
+def base64_encode(data: bytes) -> str:
+    encoded = base64.urlsafe_b64encode(data)
+    return encoded.decode('ascii').rstrip("=")
+
+def base64_decode(string: str) -> bytes:
+    padding = 4 - (len(string) % 4)
+    string = string + ("=" * padding)
+    return base64.urlsafe_b64decode(string)
+
+def make_token(user_id: int, file_id: int) -> str:
+    payload = struct.pack(">QQ", user_id, file_id)
+    sig = hmac.new(Config.SECRET, payload, hashlib.sha256).digest()
+
+    token = (
+        base64_encode(payload)
+        + "/"
+        + base64_encode(sig)
+    )
+    return token
+
+def parse_token(p_b64: str, s_b64: Optional[str] = None) -> tuple[int, int] | None:
+    try:
+        payload = base64_decode(p_b64)
+        sig = base64_decode(s_b64)
+
+        if s_b64 is not None:
+            expected = hmac.new(Config.SECRET, payload, hashlib.sha256).digest()
+            if not hmac.compare_digest(sig, expected):
+                return None
+
+        user_id, file_id = struct.unpack(">QQ", payload)
+        return user_id, file_id
+    except Exception: # pylint: disable=W0718
+        return None
+
+def human_time(seconds: int):
+    mins, sec = divmod(seconds, 60)
+    hrs, mins = divmod(mins, 60)
+    days, hrs = divmod(hrs, 24)
+    return f"{days}d {hrs}h {mins}m {sec}s"
+
+def uptime_human():
+    return human_time(int(time.monotonic() - START_TIME))
+
+def human_bytes(size: int) -> str:
+    if size == 0:
+        return "0 B"
+    units = ["B", "KB", "MB", "GB", "TB", "PB", "EB"]
+    i = 0
+    while size >= 1024 and i < len(units) - 1:
+        size /= 1024
+        i += 1
+    return f"{size:.2f} {units[i]}"
+
+def load_patches(patches_path=None):
+    logger = log.getChild("patch")
+    if patches_path:
+        load_local_patches(patches_path, logger)
+
+    load_entrypoint_plugins(logger)
+
+def load_local_patches(patches_path: str, logger: logging.Logger):
+    patches_path = Path(patches_path).resolve()
+    if not patches_path.exists():
+        return
+    project_root = patches_path.parent.parent
+    if str(project_root) not in sys.path:
+        sys.path.insert(0, str(project_root))
+
+    package_name = f"{patches_path.parent.name}.{patches_path.name}"
+
+    for item in patches_path.iterdir():
+        if item.is_file() and item.suffix == ".py":
+            logger.info("Loading %s", item.stem)
+            module_name = f"{package_name}.{item.stem}"
+            importlib.import_module(module_name)
+        elif item.is_dir() and item.name != "__pycache__":
+            logger.info("Loading %s", item.name)
+            if (item / "__init__.py").exists():
+                module_name = f"{package_name}.{item.name}"
+                importlib.import_module(module_name)
+            else:
+                for file in item.rglob("*.py"):
+                    relative = file.relative_to(patches_path)
+                    module_parts = relative.with_suffix("").parts
+                    module_name = ".".join((package_name, *module_parts))
+                    importlib.import_module(module_name)
+
+def load_entrypoint_plugins(logger: logging.Logger):
+    for ep in importlib.metadata.entry_points(group="tgfs.plugins"):
+        try:
+            logger.info("Loading %s", ep.name)
+            importlib.import_module(ep.value)
+        except Exception as e: # pylint: disable=W0718
+            print(f"Failed to load plugin {ep.name}: {e}")