Upload 85 files

.gitignore

@@ -0,0 +1,11 @@
+env
+.gitignore
+scripts\__pycache__\*
+i18n\__pycache__\*
+*.pyc
+VIRALS
+*.7z
+*.zip
+api_config.json
+versions
+*.gguf

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is 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.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  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.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  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 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. Use with the GNU Affero General Public License.
+
+  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 Affero 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 special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU 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 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 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 General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  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 GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,13 +1,154 @@
----
-title: ViralCutterPRO
-emoji: 📊
-colorFrom: indigo
-colorTo: green
-sdk: gradio
-sdk_version: 6.2.0
-app_file: app.py
-pinned: false
-license: gpl-3.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ViralCutter: Gerador de Vídeos Virais
+[ ![](https://dcbadge.vercel.app/api/server/aihubbrasil) ](https://discord.gg/aihubbrasil) <br>
+[English](https://github.com/RafaelGodoyEbert/ViralCutter/blob/main/README_en.md) | [Português](https://github.com/RafaelGodoyEbert/ViralCutter/blob/main/README.md)
+
+## **Descrição**
+ViralCutter é uma ferramenta inovadora para gerar vídeos virais a partir de conteúdo existente. Com técnicas avançadas de processamento de vídeo e áudio, o ViralCutter corta e edita segmentos de vídeo que são perfeitos para compartilhamento em redes sociais. Utilizando o modelo WhisperX para transcrição e geração de legendas automáticas, ele adapta os vídeos para o formato 9:16 (vertical), ideal para plataformas como TikTok e Instagram com Reels e Youtube com Shorts.
+
+## **Novidades e Atualizações (Changelog)**
+
+Confira as melhorias mais recentes:
+
+-   **Nova WebUI (Gradio)**: Interface gráfica moderna inspirada no OpusClip, facilitando o uso de todas as ferramentas.
+-   **Instalação Rápida (UV)**: Novo script `.bat` que utiliza o `uv` para instalar dependências de forma muito mais rápida.
+-   **Otimização de Performance**: "Slicing" de transcrição implementado. O vídeo é transcrito apenas uma vez, e os cortes reutilizam os dados, eliminando reprocessamento.
+-   **Suporte a IA Flexível**: Integração nativa com **Gemini API** e suporte experimental ao **G4F** (GPT-4 Free), além de modo Manual.
+-   **Configuração Externa**: Arquivos `api_config.json` e `prompt.txt` para fácil personalização sem mexer no código.
+-   **Correção de Rostos**: Fix no MediaPipe para rastreamento de rostos preciso sem depender de "Center Crop".
+-   **Melhorias em Legendas**: Posicionamento inteligente para vídeos com 2 faces (split screen) e correções de estilo.
+
+*(Veja o [changelog.md](changelog.md) para detalhes completos)*
+
+## **Interface**
+![WebUi Home](https://github.com/user-attachments/assets/923f260d-222b-40cc-9ab6-7114d6cefd1c)
+*Tela Principal: Ajustes de IA, legendas e visualização de logs*
+
+![WebUI Library](https://github.com/user-attachments/assets/3d9fd063-7e81-4e14-bba6-c66618a1635f)
+*Biblioteca: Galeria estilo OpusClip e controles intuitivos*
+
+## **Funcionalidades**
+
+- **Download de Vídeos**: Baixa vídeos do YouTube através de uma URL fornecida.
+- **Transcrição de Áudio**: Converte áudio em texto utilizando o modelo WhisperX.
+- **Identificação de Segmentos Virais**: Utiliza IA para detectar partes do vídeo com alto potencial de viralização.
+- **Corte e Ajuste de Formato**: Corta os segmentos selecionados e ajusta a proporção para 9:16.
+- **Recorte Inteligente**: Mantém o falante em foco (Face Tracking) ou utiliza modo Split Screen (2-Faces) automático.
+- **Mesclagem de Áudio e Vídeo**: Combina o áudio transcrito com os clipes de vídeo processados.
+- **Exportação em Lote**: Gera um arquivo ZIP com todos os vídeos virais criados, facilitando o download e compartilhamento.
+- **Legenda personalizada**: Você cria uma legenda personalizada com cores, highlight, sem highlight ou palavra por palavra, tendo uma ampla possibilidade de edição.
+
+
+## **Como Usar**
+<!--
+Entre no link e siga os passos na ordem:<br> [![Open In Colab](https://img.shields.io/badge/Colab-F9AB00?style=for-the-badge&logo=googlecolab&color=525252)](https://colab.research.google.com/drive/1gcxImzBt0ObWLfW3ThEcwqKhasB4WpgX?usp=sharing)
+HF [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)]()
+-->
+
+- Entre no link e siga os passos na ordem: [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1UZKzeqjIeEyvq9nPx7s_4mU6xlkZQn_R?usp=sharing#scrollTo=pa36OeArowme) <br>
+
+## **Limitações**
+
+- A qualidade dos vídeos gerados pode variar com base na qualidade do vídeo original.
+- O tempo de processamento depende fortemente da sua GPU.
+- O modelo **G4F** pode ser instável ou ter limites de requisição. Use **Gemini** para maior estabilidade mas precisa de api_key.
+
+## Inspiração:
+Este projeto foi inspirado nos seguintes repositórios:
+
+*   [Reels Clips Automator](https://github.com/eddieoz/reels-clips-automator)
+*   [YoutubeVideoToAIPoweredShorts](https://github.com/Fitsbit/YoutubeVideoToAIPoweredShorts)
+
+## TODO📝
+- [x] Release code
+- [ ] Huggingface SpaceDemo
+- [x] Two face in the cut
+- [x] Custom caption and burn
+- [x] Make the code faster
+- [ ] More types of framing beyond 9:16
+- [x] The cut follows the face as it moves
+- [ ] Automatic translation
+- [ ] Satisfactory video on the side
+- [ ] Background music
+- [ ] watermark at user's choice
+- [ ] Upload directly to YouTube channel
+
+## Exemplos
+### Exmplo de vídeo viral ``com highlight ativo`` [comprimido pra caber no github]
+https://github.com/user-attachments/assets/dd9a7039-e0f3-427a-a6e1-f50ab5029082
+
+### Exemplo Opus Clip vs ViralCutter [comprimido pra caber no github]
+https://github.com/user-attachments/assets/12916792-dc0e-4f63-a76b-5698946f50f4
+
+### Exemplo 2 faces [comprimido pra caber no github]
+https://github.com/user-attachments/assets/ca7ebb9c-52ba-4171-a513-625bef690a2b
+
+## **Instalação e Uso Local**
+
+### Pré-requisitos
+-   Python 3.10+
+-   FFmpeg instalado e no PATH do sistema.
+-   GPU NVIDIA recomendada (com CUDA instalado) para o WhisperX.
+
+### Configuração
+1.  **Instale as dependências**:
+    
+    **Opção A (Recomendada - Rápida)**:
+    Execute o arquivo `install_dependencies.bat`. Ele usará o `uv` para instalar tudo rapidamente.
+
+    **Opção B (Manual)**:
+    ```bash
+    pip install -r requirements.txt
+    ```
+    *(Nota: WhisperX e Torch podem exigir instalação específica para sua versão de CUDA)*.
+
+2.  **Configure a API (Opcional mas Recomendado)**:
+    Edite o arquivo `api_config.json` na pasta raiz:
+    ```json
+    {
+        "selected_api": "gemini",
+        "gemini": {
+            "api_key": "SUA_CHAVE_AQUI"
+        }
+    }
+    ```
+
+### Executando
+
+#### Interface Gráfica (WebUI)
+Para usar a nova interface visual:
+Dê um duplo clique em `run_webui.bat` ou execute:
+```bash
+.\run_webui.bat
+```
+
+#### Modo Interativo (Simples)
+Basta rodar o script e seguir as instruções na tela:
+```bash
+python main_improved.py
+```
+
+#### Modo CLI (Avançado)
+Você pode passar todos os argumentos via linha de comando para automação:
+
+```bash
+python main_improved.py --url "https://youtu.be/EXEMPLO" --segments 3 --ai-backend gemini --model large-v3-turbo
+```
+
+**Argumentos Principais:**
+-   `--url`: URL do vídeo do YouTube.
+-   `--segments`: Número de cortes a gerar.
+-   `--ai-backend`: `gemini` (Recomendado), `g4f` ou `manual`.
+-   `--viral`: Ativa modo de busca viral automática.
+-   `--face-mode`: `auto`, `1` (uma cara), ou `2` (duas caras/split).
+-   `--workflow`: `1` (Completo) ou `2` (Apenas Corte, sem legendas/crop).
+
+---
+
+## **Contribuições**
+Quer ajudar a tornar o ViralCutter ainda melhor? Se você tiver sugestões ou quiser contribuir com o código, fique à vontade para abrir uma issue ou enviar um pull request no nosso repositório do GitHub.
+
+## **Versão**
+`0.7v Alpha`  
+Uma alternativa gratuita ao `opus.pro` e ao `vidyo.ai`.
+
+---

README_en.md

@@ -0,0 +1,155 @@
+# ViralCutter: Viral Video Generator
+[ ![](https://dcbadge.vercel.app/api/server/aihubbrasil) ](https://discord.gg/aihubbrasil) <br>
+[English](https://github.com/RafaelGodoyEbert/ViralCutter/blob/main/README_en.md) | [Português](https://github.com/RafaelGodoyEbert/ViralCutter/blob/main/README.md)
+
+## **Description**
+ViralCutter is an innovative tool designed to generate viral videos from existing content. With advanced video and audio processing techniques, ViralCutter cuts and edits video segments that are perfect for sharing on social media. Using the WhisperX model for transcription and automatic caption generation, it adapts videos to the 9:16 (vertical) format, ideal for platforms like TikTok, Instagram Reels, and YouTube Shorts.
+
+## **What's New & Updates (Changelog)**
+
+Check out the latest improvements:
+
+-   **New WebUI (Gradio)**: Modern graphical interface inspired by OpusClip, making it easier to use all tools.
+-   **Fast Installation (UV)**: New `.bat` script that uses `uv` to install dependencies much faster.
+-   **Performance Optimization**: Transcription "slicing" implemented. The video is transcribed only once, and cuts reuse the data, eliminating reprocessing.
+-   **Flexible AI Support**: Native integration with **Gemini API** and experimental support for **G4F** (GPT-4 Free), plus a Manual mode.
+-   **External Configuration**: `api_config.json` and `prompt.txt` files for easy customization without touching the code.
+-   **Face Fix**: MediaPipe fix for precise face tracking without relying on "Center Crop".
+-   **Subtitle Improvements**: Smart positioning for 2-face videos (split screen) and style corrections.
+
+*(See [changelog.md](changelog.md) for full details)*
+
+## **Interface**
+![WebUi Home](https://github.com/user-attachments/assets/923f260d-222b-40cc-9ab6-7114d6cefd1c)
+*Main Screen: OpusClip-style gallery and intuitive controls*
+
+![WebUI Library](https://github.com/user-attachments/assets/3d9fd063-7e81-4e14-bba6-c66618a1635f)
+*Settings: AI adjustment, captions, and log viewer*
+
+## **Features**
+
+- **Video Download**: Downloads YouTube videos via a provided URL.
+- **Audio Transcription**: Converts audio to text using the WhisperX model.
+- **Viral Segment Identification**: Uses AI to detect parts of the video with high viral potential.
+- **Cutting & Formatting**: Cuts selected segments and adjusts the aspect ratio to 9:16.
+- **Smart Cropping**: Keeps the speaker in focus (Face Tracking) or uses automatic Split Screen (2-Faces) mode.
+- **Audio/Video Merging**: Combines transcribed audio with processed video clips.
+- **Batch Export**: Generates a ZIP file with all created viral videos, facilitating download and sharing.
+- **Custom Captions**: Create custom captions with colors, highlights, no highlights, or word-by-word styles, offering extensive editing possibilities.
+
+
+## **How to Use**
+<!--
+Open the link and follow the steps in order:<br> [![Open In Colab](https://img.shields.io/badge/Colab-F9AB00?style=for-the-badge&logo=googlecolab&color=525252)](https://colab.research.google.com/drive/1gcxImzBt0ObWLfW3ThEcwqKhasB4WpgX?usp=sharing)
+HF [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)]()
+-->
+
+- Open the link and follow the steps in order(Only Portuguese, sorry): [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1UZKzeqjIeEyvq9nPx7s_4mU6xlkZQn_R?usp=sharing#scrollTo=pa36OeArowme) <br>
+- I couldn't get the video to download/play correctly on Gradio in Google Colab, but it's functional.
+
+## **Limitations**
+
+- The quality of generated videos may vary based on the quality of the original video.
+- Processing time depends heavily on your GPU.
+- The **G4F** model may be unstable or have request limits. Use **Gemini** for greater stability (requires an api_key).
+
+## Inspiration
+This project was inspired by the following repositories:
+
+*   [Reels Clips Automator](https://github.com/eddieoz/reels-clips-automator)
+*   [YoutubeVideoToAIPoweredShorts](https://github.com/Fitsbit/YoutubeVideoToAIPoweredShorts)
+
+## TODO📝
+- [x] Release code
+- [ ] Huggingface SpaceDemo
+- [x] Two face in the cut
+- [x] Custom caption and burn
+- [x] Make the code faster
+- [ ] More types of framing beyond 9:16
+- [x] The cut follows the face as it moves
+- [ ] Automatic translation
+- [ ] Satisfying video on the side
+- [ ] Background music
+- [ ] Watermark at user's choice
+- [ ] Upload directly to YouTube channel
+
+## Examples
+### Viral video example `with active highlight` [compressed to fit GitHub]
+https://github.com/user-attachments/assets/dd9a7039-e0f3-427a-a6e1-f50ab5029082
+
+### Opus Clip vs ViralCutter example [compressed to fit GitHub]
+https://github.com/user-attachments/assets/12916792-dc0e-4f63-a76b-5698946f50f4
+
+### 2-Face example [compressed to fit GitHub]
+https://github.com/user-attachments/assets/ca7ebb9c-52ba-4171-a513-625bef690a2b
+
+## **Installation and Local Usage**
+
+### Prerequisites
+-   Python 3.10+
+-   FFmpeg installed and in the system PATH.
+-   NVIDIA GPU recommended (with CUDA installed) for WhisperX.
+
+### Configuration
+1.  **Install dependencies**:
+    
+    **Option A (Recommended - Fast)**:
+    Run the `install_dependencies.bat` file. It will use `uv` to install everything quickly.
+
+    **Option B (Manual)**:
+    ```bash
+    pip install -r requirements.txt
+    ```
+    *(Note: WhisperX and Torch may require specific installation instructions for your CUDA version)*.
+
+2.  **Configure API (Optional but Recommended)**:
+    Edit the `api_config.json` file in the root folder:
+    ```json
+    {
+        "selected_api": "gemini",
+        "gemini": {
+            "api_key": "YOUR_KEY_HERE"
+        }
+    }
+    ```
+
+### Running
+
+#### Graphical Interface (WebUI)
+To use the new visual interface:
+Double-click `run_webui.bat` or run:
+```bash
+.\run_webui.bat
+```
+
+#### Interactive Mode (Simple)
+Just run the script and follow the on-screen instructions:
+```bash
+python main_improved.py
+```
+
+#### CLI Mode (Advanced)
+You can pass all arguments via command line for automation:
+
+```bash
+python main_improved.py --url "https://youtu.be/EXAMPLE" --segments 3 --ai-backend gemini --model large-v3-turbo
+```
+
+**Main Arguments:**
+-   `--url`: YouTube video URL.
+-   `--segments`: Number of cuts to generate.
+-   `--ai-backend`: `gemini` (Recommended), `g4f`, or `manual`.
+-   `--viral`: Activates automatic viral search mode.
+-   `--face-mode`: `auto`, `1` (one face), or `2` (two faces/split).
+-   `--workflow`: `1` (Full) or `2` (Cut Only, no captions/crop).
+
+---
+
+## **Contributions**
+Want to help make ViralCutter even better? If you have suggestions or want to contribute to the code, feel free to open an issue or submit a pull request on our GitHub repository.
+
+## **Version**
+`0.7v Alpha`  
+A free alternative to `opus.pro` and `vidyo.ai`.
+
+---

ViralCutter.ipynb

@@ -0,0 +1,253 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# ViralCutter\n",
+        "Uma alternativa gratuita ao `opus.pro` e ao `vidyo.ai`"
+      ],
+      "metadata": {
+        "id": "pa36OeArowme"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Suporte em:\n",
+        "[![](https://dcbadge.limes.pink/api/server/tAdPHFAbud)](https://discord.gg/tAdPHFAbud)"
+      ],
+      "metadata": {
+        "id": "6Q-ljfsw1unE"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# TODO📝\n",
+        "- [x] Release code\n",
+        "- [ ] Huggingface SpaceDemo\n",
+        "- [x] Two face in the cut\n",
+        "- [x] Custom caption and burn\n",
+        "- [x] Make the code faster\n",
+        "- [ ] More types of framing beyond 9:16"
+      ],
+      "metadata": {
+        "id": "0o3KcBT5wzws"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "e76jiRnjONmj",
+        "cellView": "form",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "6e8baa39-5e40-45d7-e247-a70eddbc1a79"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "✅ Instalação V7 Finalizada!\n",
+            "- Transformers 4.46.3 (Compatível com Alinhamento): INSTALADO\n",
+            "- Torch 2.3.1: ATIVO\n"
+          ]
+        }
+      ],
+      "source": [
+        "#@title 🛠️ Instalação\n",
+        "import os\n",
+        "import subprocess\n",
+        "import shutil\n",
+        "from IPython.display import clear_output\n",
+        "\n",
+        "# 1. Limpeza TOTAL\n",
+        "print(\"🧹 Limpando instalação anterior...\")\n",
+        "%cd /content\n",
+        "if os.path.exists(\"ViralCutter\"):\n",
+        "    shutil.rmtree(\"ViralCutter\")\n",
+        "\n",
+        "!git clone -b dev https://github.com/RafaelGodoyEbert/ViralCutter.git\n",
+        "%cd /content/ViralCutter\n",
+        "\n",
+        "print(\"⏳ Instalando gerenciador UV e drivers do sistema...\")\n",
+        "\n",
+        "# 2. Instalar UV e Drivers Linux\n",
+        "subprocess.run(['pip', 'install', 'uv'], check=True)\n",
+        "subprocess.run('sudo apt update -y && sudo apt install -y libcudnn8 ffmpeg xvfb', shell=True, check=True)\n",
+        "\n",
+        "# 3. Criar Ambiente Virtual\n",
+        "print(\"⏳ Criando ambiente virtual...\")\n",
+        "subprocess.run(['uv', 'venv', '.venv'], check=True)\n",
+        "\n",
+        "# 4. INSTALAÇÃO DAS DEPENDÊNCIAS\n",
+        "print(\"⏳ Instalando Bibliotecas...\")\n",
+        "\n",
+        "# Passo A: WhisperX e Requisitos Básicos (Deixe instalar o que quiserem)\n",
+        "cmds_fase_1 = [\n",
+        "    \"uv pip install --python .venv git+https://github.com/m-bain/whisperx.git\",\n",
+        "    \"uv pip install --python .venv -r requirements.txt\",\n",
+        "    \"uv pip install --python .venv yt-dlp pytubefix\",\n",
+        "    \"uv pip install yt_dlp\"\n",
+        "]\n",
+        "\n",
+        "for cmd in cmds_fase_1:\n",
+        "    subprocess.run(cmd, shell=True, check=True)\n",
+        "\n",
+        "# Passo B: CORREÇÃO DE ALINHAMENTO E GEMINI\n",
+        "# - google-generativeai: Para o Gemini funcionar\n",
+        "# - pandas: Para separar palavras\n",
+        "# - transformers==4.46.3: VERSÃO CRÍTICA. Versões mais novas exigem Torch 2.6 e quebram o alinhamento.\n",
+        "# - accelerate: Ajuda no carregamento do modelo\n",
+        "print(\"🔨 Aplicando downgrade estratégico no Transformers...\")\n",
+        "extra_libs = [\n",
+        "    \"uv pip install --python .venv google-generativeai\",\n",
+        "    \"uv pip install --python .venv pandas\",\n",
+        "    \"uv pip install --python .venv onnxruntime-gpu\",\n",
+        "    \"uv pip install --python .venv transformers==4.46.3 accelerate>=0.26.0\"\n",
+        "]\n",
+        "\n",
+        "for cmd in extra_libs:\n",
+        "    subprocess.run(cmd, shell=True, check=True)\n",
+        "\n",
+        "# Passo C: O MARTELO FINAL (Torch 2.3.1 Estável)\n",
+        "# Reinstalamos por último para garantir que nada atualizou ele sem querer\n",
+        "print(\"🔨 Forçando versão estável do Torch (2.3.1)...\")\n",
+        "cmd_fix_torch = (\n",
+        "    \"uv pip install --python .venv \"\n",
+        "    \"torch==2.3.1+cu121 torchvision==0.18.1+cu121 torchaudio==2.3.1+cu121 \"\n",
+        "    \"--index-url https://download.pytorch.org/whl/cu121\"\n",
+        ")\n",
+        "subprocess.run(cmd_fix_torch, shell=True, check=True)\n",
+        "\n",
+        "# Passo D: Trava do Numpy\n",
+        "print(\"🔨 Travando Numpy...\")\n",
+        "subprocess.run(\"uv pip install --python .venv 'numpy<2.0' setuptools==69.5.1\", shell=True, check=True)\n",
+        "\n",
+        "# Passo E: Correção de Visão Computacional (CRÍTICO)\n",
+        "print(\"🔨 Corrigindo InsightFace e MediaPipe...\")\n",
+        "\n",
+        "# 1. Garante que o InsightFace tenha o motor necessário (evita que ele falhe)\n",
+        "subprocess.run(\"uv pip install --python .venv insightface onnxruntime-gpu\", shell=True, check=True)\n",
+        "\n",
+        "# 2. Limpeza Radical e Reinstalação do MediaPipe\n",
+        "# Remove versões quebradas\n",
+        "subprocess.run(\"uv pip uninstall --python .venv mediapipe protobuf flatbuffers\", shell=True)\n",
+        "\n",
+        "# 3. Instala versão FLEXÍVEL respeitando limites críticos\n",
+        "# mediapipe>=0.10.0: Pega a versão mais recente compatível com Py3.12\n",
+        "# protobuf>=3.20,<5.0: Garante compatibilidade sem quebrar o sistema antigo\n",
+        "subprocess.run(\"uv pip install --python .venv 'mediapipe>=0.10.0' 'protobuf>=3.20,<5.0' 'flatbuffers>=2.0'\", shell=True, check=True)\n",
+        "\n",
+        "# 5. Configurar Monitor\n",
+        "os.system('Xvfb :1 -screen 0 2560x1440x8 &')\n",
+        "os.environ['DISPLAY'] = ':1.0'\n",
+        "\n",
+        "clear_output()\n",
+        "print(\"✅ Instalação V7 Finalizada!\")\n",
+        "print(\"- Transformers 4.46.3 (Compatível com Alinhamento): INSTALADO\")\n",
+        "print(\"- Torch 2.3.1: ATIVO\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title 🚀 Configuração e Execução\n",
+        "import os\n",
+        "\n",
+        "%cd /content/ViralCutter\n",
+        "\n",
+        "# 1. Configura o \"Display\" falso (para evitar erros de interface gráfica)\n",
+        "os.system('Xvfb :1 -screen 0 2560x1440x8 &')\n",
+        "os.environ['DISPLAY'] = ':1.0'\n",
+        "\n",
+        "# 2. CORREÇÃO DO ERRO ATUAL:\n",
+        "# Forçamos o Matplotlib a usar o backend 'Agg' (modo sem cabeça/headless)\n",
+        "# Isso ignora o 'module://matplotlib_inline.backend_inline' que o Colab força e quebra o script.\n",
+        "os.environ['MPLBACKEND'] = 'Agg'\n",
+        "\n",
+        "print(\"🚀 Iniciando ViralCutter usando o ambiente virtual...\")\n",
+        "print(\"⚠️ Ignore os avisos de 'UserWarning', aguarde o link public URL.\")\n",
+        "\n",
+        "# Executa usando o Python do ambiente virtual\n",
+        "!/content/ViralCutter/.venv/bin/python webui/app.py --colab"
+      ],
+      "metadata": {
+        "id": "DNn8ZKJdD5XG",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "fd4689bd-f036-42de-fc7e-67854af40d81"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "/content/ViralCutter\n",
+            "🚀 Iniciando ViralCutter usando o ambiente virtual...\n",
+            "⚠️ Ignore os avisos de 'UserWarning', aguarde o link public URL.\n",
+            "/content/ViralCutter/webui/app.py:204: UserWarning: The parameters have been moved from the Blocks constructor to the launch() method in Gradio 6.0: theme, css. Please pass these parameters to launch() instead.\n",
+            "  with gr.Blocks(title=i18n(\"ViralCutter WebUI\"), theme=gr.themes.Default(primary_hue=\"blue\", neutral_hue=\"slate\"), css=css) as demo:\n",
+            "Running in Colab mode. Generating public link...\n",
+            "* Running on local URL:  http://127.0.0.1:7860\n",
+            "* Running on public URL: https://7f3b04ec670707105b.gradio.live\n",
+            "\n",
+            "This share link expires in 1 week. For free permanent hosting and GPU upgrades, run `gradio deploy` from the terminal in the working directory to deploy to Hugging Face Spaces (https://huggingface.co/spaces)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nEIsMZLwJ5kD"
+      },
+      "source": [
+        "#Créditos\n",
+        "\n",
+        "Inspirado no [reels clips automator](https://github.com/eddieoz/reels-clips-automator) e no [YoutubeVideoToAIPoweredShorts](https://github.com/Fitsbit/YoutubeVideoToAIPoweredShorts)<br>\n",
+        "\n",
+        "---\n",
+        "![Rafa.png](https://i.imgur.com/cGknQpU.png;base64)\n",
+        "\n",
+        "Desenvolvido por **Rafa.Godoy**<br>\n",
+        "[ ![GitHub](https://img.shields.io/badge/github-%23121011.svg?style=for-the-badge&logo=github&logoColor=white) ](https://github.com/rafaelGodoyEbert)<br>\n",
+        "[ ![X](https://img.shields.io/twitter/url?url=https%3A%2F%2Ftwitter.com%2FGodoyEbert) ](https://twitter.com/GodoyEbert)<br>\n",
+        "[Instagram](https://www.instagram.com/rafael.godoy.ebert/)<br>\n",
+        "[ ![](https://dcbadge.vercel.app/api/server/aihubbrasil) ](https://discord.gg/aihubbrasil)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "`0.1v Alpha`<br>\n",
+        "\n",
+        "Apenas uma alternativa gratuita ao `opus.pro` e ao `vidyo.ai`<br>\n"
+      ],
+      "metadata": {
+        "id": "tpLJmPqGT5_u"
+      }
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

abrir_cmd.bat

@@ -0,0 +1,16 @@
+@echo off
+
+REM Vai para a pasta onde está o .bat
+cd /d "%~dp0"
+
+REM Ativa o ambiente virtual criado pelo uv
+if exist ".venv\Scripts\activate.bat" (
+    call ".venv\Scripts\activate.bat"
+    echo Ambiente virtual .venv ativado.
+) else (
+    echo AVISO: Ambiente virtual .venv nao encontrado.
+    echo Execute install_dependencies.bat primeiro.
+)
+
+REM Abre um CMD interativo e mantém aberto
+cmd /k

api_config.json

@@ -0,0 +1,12 @@
+{
+    "selected_api": "gemini",
+    "gemini": {
+        "api_key": "",
+        "model": "gemini-2.5-flash-lite-preview-09-2025",
+        "chunk_size": 20000
+    },
+    "g4f": {
+        "model": "gpt-4o-mini",
+        "chunk_size": 2000
+    }
+}

changelog.md

@@ -0,0 +1,94 @@
+# Changelog
+
+## Suporte a GGUF e Ajustes de Link
+
+### Novidades
+- **Suporte a GGUF**: colocado suporte a gguf para llm local.
+- **Link Público**: ajustado diretórios de link público.
+
+## Melhorias de Qualidade de Vídeo, Legendas e Processamento
+
+### Novidades
+
+- **Aprimoramento de prompt para LLM**: melhorias no prompt para permitir que o modelo de linguagem compreenda melhor o contexto do conteúdo.
+- **Aprimoramento na detecção facial**: melhorias na identificação de rostos quando várias pessoas estão falando simultaneamente.
+- **Seleção de Qualidade de Vídeo**: agora é possível escolher a qualidade desejada para download de vídeos (Melhor, 1080p, 720p, 480p) diretamente pela WebUI ou CLI, permitindo otimizar entre velocidade e uso de armazenamento.
+- **Controle de Legendas do YouTube**: adicionada a opção de ignorar o download de legendas oficiais do YouTube, permitindo forçar uma nova transcrição via Whisper, se desejado.
+- **Suporte a VTT**: o script de transcrição foi aprimorado para oferecer suporte a arquivos de legenda `.vtt` para alinhamento, garantindo maior compatibilidade.
+- **Tradução de legendas em JSON com destaque palavra por palavra**: adicionada a tradução de legendas no formato JSON, permitindo highlight e sincronização word-by-word em outro idioma durante a exibição.
+
+### Melhorias e Otimizações
+
+- **yt-dlp mais robusto**: corrigidos problemas em que downloads de vídeo estavam sendo salvos como “Unknown_Video” e exibiam progresso incorreto. Também foram adicionados logs de progresso mais precisos e suporte aprimorado ao download de legendas.
+- **Otimização de Legendas do YouTube**: quando legendas do YouTube estão disponíveis, o sistema agora faz o download automático e as utiliza apenas para alinhamento, pulando o processo pesado e demorado de transcrição. Isso acelera significativamente o processamento de vídeos que já possuem legendas.
+
+
+## Active Speaker & Face Controls
+
+### Controles Avançados de Face e Falante Ativo
+- **Filtros de Face**: Controle granular para ignorar rostos pequenos, definir limite de confiança minimiza falsos positivos e "Zona Morta" para estabilizar a câmera.
+- **Experimental: Active Speaker**: Novo modo experimental que tenta focar na pessoa que está falando (detecção de boca aberta e movimento), em vez de sempre dividir a tela.
+- **Legendas**: Opção para remover pontuação automaticamente.
+
+## Editor de Legenda JSON
+
+### Funcionalidades
+- **Editor de Legendas**: Adicionado um editor de legendas simples, dentro das limitações do Gradio, para corrigir erros de ortografia ocorridos durante o uso do WhisperX.
+
+### Correções
+- **Geral**: Alguns Fix Colab e melhorias na geração de viral segments.
+
+## Gradio WebUI & UV Installation
+
+### Nova Interface Web (Gradio)
+- **OpusClip Inspired**: Nova interface gráfica construída com Gradio, inspirada no design do OpusClip, oferecendo uma experiência de usuário moderna e intuitiva.
+- **Funcionalidades da UI**: Ajustes completos para garantir que todas as funcionalidades da ferramenta estejam acessíveis e operantes através da nova interface.
+
+### Instalação e Infraestrutura
+- **Instalação via UV**: Criação de script `.bat` para instalação otimizada de dependências utilizando o `uv`, acelerando o processo de setup.
+- **Fixes Gerais**: Correções em diversos componentes que estavam quebrados ou instáveis, garantindo maior estabilidade na execução via UI.
+
+## WebUI 2.0 & Enhanced Configuration
+
+### WebUI Overhaul
+- **Dark & Modern UI**: Interface completamente redesenhada com tema escuro e layout em grid responsivo (estilo Opus.pro) para a galeria de vídeos.
+- **Dynamic Configuration**: Componentes da interface agora reagem dinamicamente à escolha do Backend de IA, atualizando automaticamente a lista de modelos disponíveis e o tamanho sugerido de chunk.
+- **Improved Controls**: Controle granular sobre `Face Detect Interval`, `Skip Prompts`, e `Chunk Size` diretamente na interface web.
+- **Refactoring**: Código da WebUI refatorado e modularizado (`library.py` separado do `app.py`) para melhor manutenção.
+
+### Core & CLI
+- **Arguments Expansion**: `main_improved.py` agora aceita argumentos de linha de comando para `--chunk-size` e `--ai-model-name`, permitindo override total da configuração.
+- **Script Update**: `create_viral_segments.py` atualizado para respeitar os parâmetros passados via CLI, priorizando-os sobre o arquivo de configuração.
+
+## Fix 2 faces
+
+### Melhorias na Detecção Facial e Layout
+- **Consistência Visual (2 Faces)**: Implementada lógica para "travar" a identidade dos rostos nas posições superior e inferior, impedindo que os participantes troquem de lugar durante o vídeo.
+- **Lógica de Fallback Inteligente**: Caso o rosto não seja detectado no frame atual, o sistema agora tenta recuperar a posição baseada no frame anterior, posterior ou na última coordenada válida conhecida.
+- **Intervalo de Detecção Personalizável**: Adicionada configuração para o usuário escolher a frequência da varredura facial, permitindo otimizar o tempo de renderização.
+
+### Correções de Legendas
+- **Correção de Sobreposição**: Resolvido bug onde legendas apareciam sobrepostas em momentos de fala rápida.
+- **Refinamento de Centralização (2 Faces)**: Ajustes adicionais no cálculo de posição para garantir que a legenda fique perfeitamente centralizada no modo dividido.
+
+## Atualizações Anteriores
+
+### Refatoração e Melhorias de Código
+- **Refatoração do Script Principal**: Criação e aprimoramento do `main_improved.py` para melhorar a estrutura e manutenibilidade do pipeline de processamento.
+- **Padronização de Código (Inglês)**: Tradução completa de nomes de variáveis, funções e comentários internos para inglês, visando compatibilidade com padrões internacionais e colaboração open-source, mantendo logs de saída com suporte a i18n (`en_US`/`pt_BR`).
+- **Ajuste de Diretórios**: Reorganização da estrutura de pastas e caminhos de saída para maior organização dos arquivos gerados.
+
+### Configuração e IA
+- **Integração Multi-LLM**: Implementação de suporte ao **g4f** (GPT-4 Free) e **Google Gemini**.
+- **API Config**: Centralização das chaves e seleção de modelos no novo arquivo `api_config.json`, permitindo troca rápida de provedor de IA sem alterar o código.
+- **Gerenciamento de Prompts**: Criação do arquivo `prompt.txt` para edição fácil do prompt do sistema.
+
+### Legendas e Transcrição (Whisper)
+- **Correções no Whisper**: Solução robusta para erros de `unpickling`, conflitos de DLLs (`libprotobuf`, `torchaudio`) e detecção de GPU.
+- **Otimização do Fluxo (Slicing)**: O vídeo original é transcrito apenas uma vez. Os cortes reutilizam o JSON original, eliminando a re-transcrição e acelerando o processo.
+- **Posicionamento de Legendas**: Correção da lógica de alinhamento para centralização no modo "2-face".
+
+### Processamento de Vídeo e Detecção Facial
+- **Novo Motor: InsightFace**: Adição da biblioteca `InsightFace` como motor de detecção facial de alta precisão.
+- **MediaPipe**: Manutenção e correção de erros no fallback para o MediaPipe.
+- **Limpeza de Logs**: Redução da verbosidade dos logs do FFmpeg no console.

check_landmarks.py

@@ -0,0 +1,49 @@
+import cv2
+import sys
+import os
+
+# Adjust path to import scripts
+sys.path.append(os.getcwd())
+
+try:
+    from scripts.face_detection_insightface import init_insightface, suppress_stdout_stderr
+    
+    app = init_insightface()
+    
+    # Create a dummy frame (black) or try to read a real one if possible
+    # We just want to check the attributes of the returned face object
+    dummy = cv2.imread("C:/Users/rafam/.gemini/antigravity/brain/9bfedba9-72ff-4a40-a0d3-b77ea033233e/uploaded_image_1766002859958.png") # User uploaded image path from metadata?
+    # Actually I don't have access to the user's uploaded image path on disk straightforwardly unless I guess, but I can use a black frame.
+    # Wait, the user has processed videos in VIRALS folder.
+    
+    # Let's just use a black frame 640x640 containing a drawn white face square to trigger detection? Unlikely to work with InsightFace (needs features).
+    # I will try to read one frame from a video in the workspace if exists.
+    
+    video_path = "c:\\Users\\rafam\\Downloads\\ViralCutter\\output000_original_scale.mp4" # Guessing from edit_video
+    # Or search for mp4
+    
+    import glob
+    videos = glob.glob("c:\\Users\\rafam\\Downloads\\ViralCutter\\**\\*.mp4", recursive=True)
+    if videos:
+        cap = cv2.VideoCapture(videos[0])
+        ret, frame = cap.read()
+        cap.release()
+        
+        if ret:
+            faces = app.get(frame)
+            if faces:
+                print("Face Keys:", faces[0].keys())
+                if hasattr(faces[0], 'landmark_2d_106'):
+                    print("Has 106 landmarks:", faces[0].landmark_2d_106 is not None)
+                if hasattr(faces[0], 'landmark_3d_68'):
+                    print("Has 68 landmarks:", faces[0].landmark_3d_68 is not None)
+                print("Has kps:", faces[0].kps is not None)
+            else:
+                print("No faces found in sample frame.")
+        else:
+            print("Could not read frame.")
+    else:
+        print("No videos found to test.")
+
+except Exception as e:
+    print(f"Error: {e}")

i18n/i18n.py

@@ -0,0 +1,27 @@
+import json
+import locale
+import os
+
+
+def load_language_list(language):
+    with open(f"./i18n/locale/{language}.json", "r", encoding="utf-8") as f:
+        language_list = json.load(f)
+    return language_list
+
+
+class I18nAuto:
+    def __init__(self, language=None):
+        if language in ["Auto", None]:
+            language = locale.getdefaultlocale()[
+                0
+            ]  # getlocale can't identify the system's language ((None, None))
+        if not os.path.exists(f"./i18n/locale/{language}.json"):
+            language = "en_US"
+        self.language = language
+        self.language_map = load_language_list(language)
+
+    def __call__(self, key):
+        return self.language_map.get(key, key)
+
+    def __repr__(self):
+        return "Use Language: " + self.language

i18n/locale/en_US.json

@@ -0,0 +1,211 @@
+{
+    "main": "main",
+    "Burn only mode activated. Skipping to subtitle burning...": "Burn only mode activated. Skipping to subtitle burning...",
+    "Subtitle burning completed.": "Subtitle burning completed.",
+    "Enter the YouTube video URL (or press Enter to use latest project): ": "Enter the YouTube video URL (or press Enter to use latest project): ",
+    "Enter the number of viral segments to create: ": "Enter the number of viral segments to create: ",
+    "\nError: Number must be greater than 0.": "\nError: Number must be greater than 0.",
+    "Error: The value you entered is not an integer. Please try again.": "Error: The value you entered is not an integer. Please try again.",
+    "Do you want viral mode? (yes/no): ": "Do you want viral mode? (yes/no): ",
+    "Enter themes (comma-separated, leave blank if viral mode is True): ": "Enter themes (comma-separated, leave blank if viral mode is True): ",
+    "Subtitle burning skipped.": "Subtitle burning skipped.",
+    "Process completed successfully!": "Process completed successfully!",
+    "Using latest project: {}": "Using latest project: {}",
+    "Latest project found but 'input.mp4' is missing.": "Latest project found but 'input.mp4' is missing.",
+    "No existing projects found in VIRALS folder.": "No existing projects found in VIRALS folder.",
+    "VIRALS folder not found. Cannot load latest project.": "VIRALS folder not found. Cannot load latest project.",
+    "\nExisting viral segments found: {}": "\nExisting viral segments found: {}",
+    "Use existing viral segments? (yes/no) [default: yes]: ": "Use existing viral segments? (yes/no) [default: yes]: ",
+    "Loaded existing viral segments. Skipping configuration prompts.": "Loaded existing viral segments. Skipping configuration prompts.",
+    "Error loading JSON: {}.": "Error loading JSON: {}.",
+    "\nCurrent duration settings: {}s - {}s": "\nCurrent duration settings: {}s - {}s",
+    "Change duration? (y/n) [default: n]: ": "Change duration? (y/n) [default: n]: ",
+    "Minimum duration [{}]: ": "Minimum duration [{}]: ",
+    "Maximum duration [{}]: ": "Maximum duration [{}]: ",
+    "Invalid number. Using previous values.": "Invalid number. Using previous values.",
+    "Using AI Backend from config: {}": "Using AI Backend from config: {}",
+    "Select AI Backend for Viral Analysis:": "Select AI Backend for Viral Analysis:",
+    "1. Gemini API (Best / Recommended)": "1. Gemini API (Best / Recommended)",
+    "2. G4F (Free / Experimental)": "2. G4F (Free / Experimental)",
+    "3. Manual (Copy/Paste Prompt)": "3. Manual (Copy/Paste Prompt)",
+    "Choose (1/2/3): ": "Choose (1/2/3): ",
+    "Gemini API Key not found in api_config.json or arguments.": "Gemini API Key not found in api_config.json or arguments.",
+    "Enter your Gemini API Key: ": "Enter your Gemini API Key: ",
+    "Select Processing Workflow:": "Select Processing Workflow:",
+    "1. Full Processing (Face Crop 9:16 + Subtitles) [Default]": "1. Full Processing (Face Crop 9:16 + Subtitles) [Default]",
+    "2. Cut Only (Keep Original Size, No Subtitles)": "2. Cut Only (Keep Original Size, No Subtitles)",
+    "Choose (1/2): ": "Choose (1/2): ",
+    "Select Face Detection Model:": "Select Face Detection Model:",
+    "1. InsightFace (Recommended - High Accuracy, GPU Support) [Default]": "1. InsightFace (Recommended - High Accuracy, GPU Support) [Default]",
+    "2. MediaPipe (Google - Fast, lightweight)": "2. MediaPipe (Google - Fast, lightweight)",
+    "Select Face Tracking Mode:": "Select Face Tracking Mode:",
+    "1. Auto (Detect 1 or 2 faces dynamically) [Default]": "1. Auto (Detect 1 or 2 faces dynamically) [Default]",
+    "2. 1 Face (Focus on largest face)": "2. 1 Face (Focus on largest face)",
+    "3. 2 Faces (Split Screen)": "3. 2 Faces (Split Screen)",
+    "Error: No URL provided and no existing video selected.": "Error: No URL provided and no existing video selected.",
+    "Starting download...": "Starting download...",
+    "Transcribing with model {}...": "Transcribing with model {}...",
+    "Creating viral segments using {}...": "Creating viral segments using {}...",
+    "Cuts already exist. Cut again? (yes/no) [default: no]: ": "Cuts already exist. Cut again? (yes/no) [default: no]: ",
+    "Skipping Video Rendering (using existing cuts), but updating Subtitle JSONs...": "Skipping Video Rendering (using existing cuts), but updating Subtitle JSONs...",
+    "Cutting segments...": "Cutting segments...",
+    "Cut Only selected. Skipping Face Crop and Subtitles.": "Cut Only selected. Skipping Face Crop and Subtitles.",
+    "Process completed! Check your results in: {}": "Process completed! Check your results in: {}",
+    "Editing video with {} (Mode: {})...": "Editing video with {} (Mode: {})...",
+    "Processing subtitles...": "Processing subtitles...",
+    "Configuring subtitles for Split Screen (Center Position)...": "Configuring subtitles for Split Screen (Center Position)...",
+    "\nExisting cuts found in: {}": "\nExisting cuts found in: {}",
+    "\nAn error occurred: {}": "\nAn error occurred: {}",
+    "Process terminated.": "Process terminated.",
+    "Error terminating process: {}": "Error terminating process: {}",
+    "No process running.": "No process running.",
+    "Running...": "Running...",
+    "Error: No project selected.": "Error: No project selected.",
+    "Start Processing": "Start Processing",
+    "ViralCutter WebUI": "ViralCutter WebUI",
+    "Create New": "Create New",
+    "Input Source": "Input Source",
+    "YouTube URL": "YouTube URL",
+    "Existing Project": "Existing Project",
+    "Select Project": "Select Project",
+    "Segments": "Segments",
+    "Viral Mode": "Viral Mode",
+    "Themes": "Themes",
+    "Min Duration (s)": "Min Duration (s)",
+    "Max Duration (s)": "Max Duration (s)",
+    "AI Backend": "AI Backend",
+    "Gemini API Key": "Gemini API Key",
+    "AI Model": "AI Model",
+    "Chunk Size": "Chunk Size",
+    "Whisper Model": "Whisper Model",
+    "Workflow": "Workflow",
+    "Face Model": "Face Model",
+    "Face Mode": "Face Mode",
+    "Face Det. Interval": "Face Det. Interval",
+    "Subtitle Settings (alpha)": "Subtitle Settings (alpha)",
+    "Quick Presets": "Quick Presets",
+    "Enable Subtitle Customization (Includes Preset)": "Enable Subtitle Customization (Includes Preset)",
+    "Select options or preset to preview": "Select options or preset to preview",
+    "🎬 Render Animated Preview (Slow)": "🎬 Render Animated Preview (Slow)",
+    "Animated Preview": "Animated Preview",
+    "Advanced Settings": "Advanced Settings",
+    "Appearance": "Appearance",
+    "Font Name": "Font Name",
+    "Font Size (Base)": "Font Size (Base)",
+    "Highlight Size": "Highlight Size",
+    "Base Color": "Base Color",
+    "Highlight Color": "Highlight Color",
+    "Outline Color": "Outline Color",
+    "Shadow Color": "Shadow Color",
+    "Styling & Effects": "Styling & Effects",
+    "Outline Thickness": "Outline Thickness",
+    "Shadow Size": "Shadow Size",
+    "Border Style": "Border Style",
+    "Bold": "Bold",
+    "Italic": "Italic",
+    "Uppercase": "Uppercase",
+    "Underline": "Underline",
+    "Strikeout": "Strikeout",
+    "Positioning & Layout": "Positioning & Layout",
+    "V-Pos (Margin V)": "V-Pos (Margin V)",
+    "Alignment": "Alignment",
+    "Gap Limit": "Gap Limit",
+    "Mode": "Mode",
+    "Words per Block": "Words per Block",
+    "Stop": "Stop",
+    "Logs": "Logs",
+    "Results": "Results",
+    "Library": "Library",
+    "Existing Projects": "Existing Projects",
+    "Refresh List": "Refresh List",
+    "Error starting server: {}": "Error starting server: {}",
+    "No project selected.": "No project selected.",
+    "Project path not found: {}": "Project path not found: {}",
+    "Segment": "Segment",
+    "No description available.": "No description available.",
+    "External Video": "External Video",
+    "Not Found": "Not Found",
+    "No viral segments found.": "No viral segments found.",
+    "Error loading gallery: {}": "Error loading gallery: {}",
+    "PREVIEW": "PREVIEW",
+    "This is a PREVIEW of your subtitles": "This is a PREVIEW of your subtitles",
+    "Download": "Download",
+    "Error: {}": "Error: {}",
+    "This is a {} of your subtitles": "This is a {} of your subtitles",
+    "Manual": "Manual",
+    "Gemini": "Gemini",
+    "G4F": "G4F",
+    "Full": "Full",
+    "Cut Only": "Cut Only",
+    "Subtitles Only": "Subtitles Only",
+    "Outline": "Outline",
+    "Opaque Box": "Opaque Box",
+    "Left": "Left",
+    "Center": "Center",
+    "Right": "Right",
+    "Highlight": "Highlight",
+    "Word by Word": "Word by Word",
+    "No Highlight": "No Highlight",
+    "Auto": "Auto",
+    "funny, sad...": "funny, sad...",
+    "Bem-vindo ao ViralCutter! A ferramenta definitiva para transformar vídeos longos em clipes virais com o poder da IA.": "Welcome to ViralCutter! The ultimate tool to transform long videos into viral clips with the power of AI.",
+    "Aqui você pode:": "Here you can:",
+    "Cortes Automáticos": "Automatic Cuts",
+    "Identifique e corte os melhores momentos baseado em viralidade.": "Identify and cut the best moments based on virality.",
+    "Legendas Dinâmicas": "Dynamic Subtitles",
+    "Crie legendas estéticas (Estilo Hormozi) automaticamente.": "Create aesthetic subtitles (Hormozi Style) automatically.",
+    "IA Avançada": "Advanced AI",
+    "Suporte integrado para": "Integrated support for",
+    "Foco em Vertical": "Vertical Focus",
+    "Detecção facial inteligente para vídeos verticais (TikTok/Shorts/Reels).": "Smart face detection for vertical videos (TikTok/Shorts/Reels).",
+    "Este projeto foi desenvolvido para a comunidade do AI HUB Brasil.": "This project was developed for the AI HUB Brazil community.",
+    "Desenvolvido por Rafael Godoy": "Developed by Rafael Godoy",
+    "Apoie o projeto, qualquer valor é bem-vindo:": "Support the project, any amount is welcome:",
+    "Apoiar via PIX": "Support via PIX",
+    "Ignore Small Faces (0.0 - 1.0)": "Ignore Small Faces (0.0 - 1.0)",
+    "Relative size to ignore background.": "Relative size to ignore background.",
+    "Threshold for 2 Faces (0.0 - 1.0)": "Threshold for 2 Faces (0.0 - 1.0)",
+    "Size of 2nd face to activate split mode.": "Size of 2nd face to activate split mode.",
+    "Minimum Confidence (0.0 - 1.0)": "Minimum Confidence (0.0 - 1.0)",
+    "Ignore detections with low confidence.": "Ignore detections with low confidence.",
+    "Dead Zone (Stabilization)": "Dead Zone (Stabilization)",
+    "Movement pixels to ignore.": "Movement pixels to ignore.",
+    "Experimental: Focus on Speaker": "Experimental: Focus on Speaker",
+    "Tries to focus only on the speaking person instead of split screen.": "Tries to focus only on the speaking person instead of split screen.",
+    "MAR Threshold (Mouth Open)": "MAR Threshold (Mouth Open)",
+    "Mouth open sensitivity.": "Mouth open sensitivity.",
+    "Score Difference": "Score Difference",
+    "Minimum difference to focus on 1 face.": "Minimum difference to focus on 1 face.",
+    "Consider Motion": "Consider Motion",
+    "Increases score with motion (gestures).": "Increases score with motion (gestures).",
+    "Motion Dead Zone": "Motion Dead Zone",
+    "Pixels ignored.": "Pixels ignored.",
+    "Motion Sensitivity": "Motion Sensitivity",
+    "Points per pixel.": "Points per pixel.",
+    "Switch Speed": "Switch Speed",
+    "Speed to lose focus.": "Speed to lose focus.",
+    "Remove Punctuation": "Remove Punctuation",
+    "Advanced Face Settings": "Advanced Face Settings",
+    "Configuration Presets": "Configuration Presets",
+    "Download and use official subtitles if available. (Recommended, it speeds up the process)": "Download and use official subtitles if available. (Recommended, it speeds up the process)",
+    "Edit Subtitles (Smart Mode)": "Edit Subtitles (Smart Mode)",
+    "Error: Project folder could not be determined from logs.": "Error: Project folder could not be determined from logs.",
+    "Experimental: Active Speaker & Motion": "Experimental: Active Speaker & Motion",
+    "Load Subtitles": "Load Subtitles",
+    "Loaded {} segments.": "Loaded {} segments.",
+    "Local (GGUF)": "Local (GGUF)",
+    "No file loaded.": "No file loaded.",
+    "Please select project and file.": "Please select project and file.",
+    "Refresh": "Refresh",
+    "Render All started in background... Check terminal/logs.": "Render All started in background... Check terminal/logs.",
+    "Select Subtitle File": "Select Subtitle File",
+    "Status": "Status",
+    "Subtitle Editor": "Subtitle Editor",
+    "Subtitle Segments": "Subtitle Segments",
+    "Translate Subtitles To": "Translate Subtitles To",
+    "Use YouTube Subs": "Use YouTube Subs",
+    "Video Quality": "Video Quality",
+    "⚡ Render This Segment (Very-Fast)": "⚡ Render This Segment (Very-Fast)",
+    "🎬 Render All (Fast)": "🎬 Render All (Fast)",
+    "💾 Save Changes": "💾 Save Changes"
+}

i18n/locale/pt_BR.json

@@ -0,0 +1,211 @@
+{
+    "main": "main",
+    "Burn only mode activated. Skipping to subtitle burning...": "Modo de apenas queimar legendas ativado. Pulando para a queima de legendas...",
+    "Subtitle burning completed.": "Queima de legendas concluída.",
+    "Enter the YouTube video URL (or press Enter to use latest project): ": "Digite a URL do vídeo do YouTube (ou pressione Enter para usar o projeto mais recente): ",
+    "Enter the number of viral segments to create: ": "Digite o número de segmentos virais para criar: ",
+    "\nError: Number must be greater than 0.": "\nErro: O número deve ser maior que 0.",
+    "Error: The value you entered is not an integer. Please try again.": "Erro: O valor que você digitou não é um número inteiro. Tente novamente.",
+    "Do you want viral mode? (yes/no): ": "Você quer o modo viral? (sim/não): ",
+    "Enter themes (comma-separated, leave blank if viral mode is True): ": "Digite temas (separados por vírgula, deixe em branco se o modo viral for Verdadeiro): ",
+    "Subtitle burning skipped.": "Queima de legendas ignorada.",
+    "Process completed successfully!": "Processo concluído com sucesso!",
+    "Using latest project: {}": "Usando o projeto mais recente: {}",
+    "Latest project found but 'input.mp4' is missing.": "Projeto mais recente encontrado, mas 'input.mp4' está faltando.",
+    "No existing projects found in VIRALS folder.": "Nenhum projeto existente encontrado na pasta VIRALS.",
+    "VIRALS folder not found. Cannot load latest project.": "Pasta VIRALS não encontrada. Não é possível carregar o projeto mais recente.",
+    "\nExisting viral segments found: {}": "\nSegmentos virais existentes encontrados: {}",
+    "Use existing viral segments? (yes/no) [default: yes]: ": "Usar segmentos virais existentes? (sim/não) [padrão: sim]: ",
+    "Loaded existing viral segments. Skipping configuration prompts.": "Segmentos virais existentes carregados. Pulando prompts de configuração.",
+    "Error loading JSON: {}.": "Erro ao carregar JSON: {}.",
+    "\nCurrent duration settings: {}s - {}s": "\nConfigurações de duração atuais: {}s - {}s",
+    "Change duration? (y/n) [default: n]: ": "Alterar duração? (s/n) [padrão: n]: ",
+    "Minimum duration [{}]: ": "Duração mínima [{}]: ",
+    "Maximum duration [{}]: ": "Duração máxima [{}]: ",
+    "Invalid number. Using previous values.": "Número inválido. Usando valores anteriores.",
+    "Using AI Backend from config: {}": "Usando Backend de IA da configuração: {}",
+    "Select AI Backend for Viral Analysis:": "Selecione o Backend de IA para Análise Viral:",
+    "1. Gemini API (Best / Recommended)": "1. Gemini API (Melhor / Recomendado)",
+    "2. G4F (Free / Experimental)": "2. G4F (Grátis / Experimental)",
+    "3. Manual (Copy/Paste Prompt)": "3. Manual (Copiar/Colar Prompt)",
+    "Choose (1/2/3): ": "Escolha (1/2/3): ",
+    "Gemini API Key not found in api_config.json or arguments.": "Chave da API Gemini não encontrada em api_config.json ou argumentos.",
+    "Enter your Gemini API Key: ": "Digite sua chave de API Gemini: ",
+    "Select Processing Workflow:": "Selecione o Fluxo de Trabalho de Processamento:",
+    "1. Full Processing (Face Crop 9:16 + Subtitles) [Default]": "1. Processamento Completo (Recorte de Rosto 9:16 + Legendas) [Padrão]",
+    "2. Cut Only (Keep Original Size, No Subtitles)": "2. Apenas Cortar (Manter Tamanho Original, Sem Legendas)",
+    "Choose (1/2): ": "Escolha (1/2): ",
+    "Select Face Detection Model:": "Selecione o Modelo de Detecção de Rosto:",
+    "1. InsightFace (Recommended - High Accuracy, GPU Support) [Default]": "1. InsightFace (Recomendado - Alta Precisão, Suporte a GPU) [Padrão]",
+    "2. MediaPipe (Google - Fast, lightweight)": "2. MediaPipe (Google - Rápido, leve)",
+    "Select Face Tracking Mode:": "Selecione o Modo de Rastreamento de Rosto:",
+    "1. Auto (Detect 1 or 2 faces dynamically) [Default]": "1. Auto (Detectar 1 ou 2 rostos dinamicamente) [Padrão]",
+    "2. 1 Face (Focus on largest face)": "2. 1 Rosto (Focar no maior rosto)",
+    "3. 2 Faces (Split Screen)": "3. 2 Rostos (Tela Dividida)",
+    "Error: No URL provided and no existing video selected.": "Erro: Nenhuma URL fornecida e nenhum vídeo existente selecionado.",
+    "Starting download...": "Iniciando download...",
+    "Transcribing with model {}...": "Transcrevendo com modelo {}...",
+    "Creating viral segments using {}...": "Criando segmentos virais usando {}...",
+    "Cuts already exist. Cut again? (yes/no) [default: no]: ": "Cortes já existem. Cortar novamente? (sim/não) [padrão: não]: ",
+    "Skipping Video Rendering (using existing cuts), but updating Subtitle JSONs...": "Pulando Renderização de Vídeo (usando cortes existentes), mas atualizando JSONs de Legenda...",
+    "Cutting segments...": "Cortando segmentos...",
+    "Cut Only selected. Skipping Face Crop and Subtitles.": "Selecionado Apenas Cortar. Pulando Recorte de Rosto e Legendas.",
+    "Process completed! Check your results in: {}": "Processo concluído! Verifique seus resultados em: {}",
+    "Editing video with {} (Mode: {})...": "Editando vídeo com {} (Modo: {})...",
+    "Processing subtitles...": "Processando legendas...",
+    "Configuring subtitles for Split Screen (Center Position)...": "Configurando legendas para Tela Dividida (Posição Central)...",
+    "\nExisting cuts found in: {}": "\nCortes existentes encontrados em: {}",
+    "\nAn error occurred: {}": "\nOcorreu um erro: {}",
+    "Process terminated.": "Processo terminado.",
+    "Error terminating process: {}": "Erro ao terminar processo: {}",
+    "No process running.": "Nenhum processo em execução.",
+    "Running...": "Executando...",
+    "Error: No project selected.": "Erro: Nenhum projeto selecionado.",
+    "Start Processing": "Iniciar Processamento",
+    "ViralCutter WebUI": "ViralCutter WebUI",
+    "Create New": "Criar Novo",
+    "Input Source": "Fonte de Entrada",
+    "YouTube URL": "URL do YouTube",
+    "Existing Project": "Projeto Existente",
+    "Select Project": "Selecionar Projeto",
+    "Segments": "Segmentos",
+    "Viral Mode": "Modo Viral",
+    "Themes": "Temas",
+    "Min Duration (s)": "Duração Mín (s)",
+    "Max Duration (s)": "Duração Máx (s)",
+    "AI Backend": "Backend de IA",
+    "Gemini API Key": "Chave API Gemini",
+    "AI Model": "Modelo de IA",
+    "Chunk Size": "Tamanho do Chunk",
+    "Whisper Model": "Modelo Whisper",
+    "Workflow": "Fluxo de Trabalho",
+    "Face Model": "Modelo de Face",
+    "Face Mode": "Modo de Face",
+    "Face Det. Interval": "Intervalo Det. Face",
+    "Subtitle Settings (alpha)": "Configurações de Legenda (alfa)",
+    "Quick Presets": "Predefinições Rápidas",
+    "Enable Subtitle Customization (Includes Preset)": "Habilitar Personalização de Legenda",
+    "Select options or preset to preview": "Selecione opções ou predefinição para visualizar",
+    "🎬 Render Animated Preview (Slow)": "🎬 Renderizar Prévia Animada (Lento)",
+    "Animated Preview": "Prévia Animada",
+    "Advanced Settings": "Configurações Avançadas",
+    "Appearance": "Aparência",
+    "Font Name": "Nome da Fonte",
+    "Font Size (Base)": "Tamanho da Fonte (Base)",
+    "Highlight Size": "Tamanho do Destaque",
+    "Base Color": "Cor Base",
+    "Highlight Color": "Cor do Destaque",
+    "Outline Color": "Cor do Contorno",
+    "Shadow Color": "Cor da Sombra",
+    "Styling & Effects": "Estilo & Efeitos",
+    "Outline Thickness": "Espessura do Contorno",
+    "Shadow Size": "Tamanho da Sombra",
+    "Border Style": "Estilo da Borda",
+    "Bold": "Negrito",
+    "Italic": "Itálico",
+    "Uppercase": "Maiúsculas",
+    "Underline": "Sublinhado",
+    "Strikeout": "Tachado",
+    "Positioning & Layout": "Posicionamento & Layout",
+    "V-Pos (Margin V)": "V-Pos (Margem V)",
+    "Alignment": "Alinhamento",
+    "Gap Limit": "Limite de Lacuna",
+    "Mode": "Modo",
+    "Words per Block": "Palavras por Bloco",
+    "Stop": "Parar",
+    "Logs": "Logs",
+    "Results": "Resultados",
+    "Library": "Biblioteca",
+    "Existing Projects": "Projetos Existentes",
+    "Refresh List": "Atualizar Lista",
+    "Error starting server: {}": "Erro ao iniciar servidor: {}",
+    "No project selected.": "Nenhum projeto selecionado.",
+    "Project path not found: {}": "Caminho do projeto não encontrado: {}",
+    "Segment": "Segmento",
+    "No description available.": "Nenhuma descrição disponível.",
+    "External Video": "Vídeo Externo",
+    "Not Found": "Não Encontrado",
+    "No viral segments found.": "Nenhum segmento viral encontrado.",
+    "Error loading gallery: {}": "Erro ao carregar galeria: {}",
+    "PREVIEW": "PRÉVIA",
+    "This is a PREVIEW of your subtitles": "Esta é uma PRÉVIA das suas legendas",
+    "Download": "Baixar",
+    "Error: {}": "Erro: {}",
+    "This is a {} of your subtitles": "Esta é uma {} das suas legendas",
+    "Manual": "Manual",
+    "Gemini": "Gemini",
+    "G4F": "G4F",
+    "Full": "Completo",
+    "Cut Only": "Apenas Corte",
+    "Subtitles Only": "Apenas Legendas",
+    "Outline": "Contorno",
+    "Opaque Box": "Caixa Opaca",
+    "Left": "Esquerda",
+    "Center": "Centro",
+    "Right": "Direita",
+    "Highlight": "Destacar",
+    "Word by Word": "Palavra por Palavra",
+    "No Highlight": "Sem Destaque",
+    "Auto": "Auto",
+    "funny, sad...": "engraçado, triste...",
+    "Bem-vindo ao ViralCutter! A ferramenta definitiva para transformar vídeos longos em clipes virais com o poder da IA.": "Bem-vindo ao ViralCutter! A ferramenta definitiva para transformar vídeos longos em clipes virais com o poder da IA.",
+    "Aqui você pode:": "Aqui você pode:",
+    "Cortes Automáticos": "Cortes Automáticos",
+    "Identifique e corte os melhores momentos baseado em viralidade.": "Identifique e corte os melhores momentos baseado em viralidade.",
+    "Legendas Dinâmicas": "Legendas Dinâmicas",
+    "Crie legendas estéticas (Estilo Hormozi) automaticamente.": "Crie legendas estéticas (Estilo Hormozi) automaticamente.",
+    "IA Avançada": "IA Avançada",
+    "Suporte integrado para": "Suporte integrado para",
+    "Foco em Vertical": "Foco em Vertical",
+    "Detecção facial inteligente para vídeos verticais (TikTok/Shorts/Reels).": "Detecção facial inteligente para vídeos verticais (TikTok/Shorts/Reels).",
+    "Este projeto foi desenvolvido para a comunidade do AI HUB Brasil.": "Este projeto foi desenvolvido para a comunidade do AI HUB Brasil.",
+    "Desenvolvido por Rafael Godoy": "Desenvolvido por Rafael Godoy",
+    "Apoie o projeto, qualquer valor é bem-vindo:": "Apoie o projeto, qualquer valor é bem-vindo:",
+    "Apoiar via PIX": "Apoiar via PIX",
+    "Ignore Small Faces (0.0 - 1.0)": "Ignorar Rostos Pequenos (0.0 - 1.0)",
+    "Relative size to ignore background.": "Tamanho relativo para ignorar fundo.",
+    "Threshold for 2 Faces (0.0 - 1.0)": "Limite para 2 Rostos (0.0 - 1.0)",
+    "Size of 2nd face to activate split mode.": "Tamanho do 2º rosto para ativar modo duplo.",
+    "Minimum Confidence (0.0 - 1.0)": "Confiança Mínima (0.0 - 1.0)",
+    "Ignore detections with low confidence.": "Ignorar detecções com baixa confiança.",
+    "Dead Zone (Stabilization)": "Zona Morta (Estabilização)",
+    "Movement pixels to ignore.": "Pixels de movimento para ignorar.",
+    "Experimental: Focus on Speaker": "Experimental: Focar em quem fala",
+    "Tries to focus only on the speaking person instead of split screen.": "Tenta focar apenas na pessoa falando em vez de dividir a tela.",
+    "MAR Threshold (Mouth Open)": "MAR Threshold (Boca Aberta)",
+    "Mouth open sensitivity.": "Sensibilidade da boca aberta.",
+    "Score Difference": "Diferença de Score",
+    "Minimum difference to focus on 1 face.": "Diferença mínima para focar em 1 rosto.",
+    "Consider Motion": "Considerar Movimento",
+    "Increases score with motion (gestures).": "Aumenta score com movimento (gestos).",
+    "Motion Dead Zone": "Zona Morta de Movimento",
+    "Pixels ignored.": "Pixels ignorados.",
+    "Motion Sensitivity": "Sensibilidade de Movimento",
+    "Points per pixel.": "Pontos por pixel.",
+    "Switch Speed": "Velocidade de Troca",
+    "Speed to lose focus.": "Rapidez para perder o foco.",
+    "Remove Punctuation": "Remover Pontuação",
+    "Advanced Face Settings": "Configurações Avançadas de Rosto",
+    "Configuration Presets": "Predefinições de Configuração",
+    "Download and use official subtitles if available. (Recommended, it speeds up the process)": "Baixar e usar legendas oficiais se disponíveis. (Recomendado, acelera o processo)",
+    "Edit Subtitles (Smart Mode)": "Editar Legendas (Modo Inteligente)",
+    "Error: Project folder could not be determined from logs.": "Erro: Pasta do projeto não pôde ser determinada a partir dos logs.",
+    "Experimental: Active Speaker & Motion": "Experimental: Falante Ativo & Movimento",
+    "Load Subtitles": "Carregar Legendas",
+    "Loaded {} segments.": "Carregado {} segmentos.",
+    "Local (GGUF)": "Local (GGUF)",
+    "No file loaded.": "Nenhum arquivo carregado.",
+    "Please select project and file.": "Por favor selecione projeto e arquivo.",
+    "Refresh": "Atualizar",
+    "Render All started in background... Check terminal/logs.": "Renderizar Tudo iniciado em segundo plano... Verifique terminal/logs.",
+    "Select Subtitle File": "Selecionar Arquivo de Legenda",
+    "Status": "Status",
+    "Subtitle Editor": "Editor de Legendas",
+    "Subtitle Segments": "Segmentos de Legenda",
+    "Translate Subtitles To": "Traduzir Legendas Para",
+    "Use YouTube Subs": "Usar Legendas do YouTube",
+    "Video Quality": "Qualidade de Vídeo",
+    "⚡ Render This Segment (Very-Fast)": "⚡ Renderizar Este Segmento (Muito Rápido)",
+    "🎬 Render All (Fast)": "🎬 Renderizar Tudo (Rápido)",
+    "💾 Save Changes": "💾 Salvar Alterações"
+}

i18n/locale_diff.py

@@ -0,0 +1,47 @@
+import json
+import os
+from collections import OrderedDict
+
+# Define the standard file name
+standard_file = "locale/zh_CN.json"
+
+# Find all JSON files in the directory
+dir_path = "locale/"
+languages = [
+    os.path.join(dir_path, f)
+    for f in os.listdir(dir_path)
+    if f.endswith(".json") and f != standard_file
+]
+
+# Load the standard file
+with open(standard_file, "r", encoding="utf-8") as f:
+    standard_data = json.load(f, object_pairs_hook=OrderedDict)
+
+# Loop through each language file
+for lang_file in languages:
+    # Load the language file
+    with open(lang_file, "r", encoding="utf-8") as f:
+        lang_data = json.load(f, object_pairs_hook=OrderedDict)
+
+    # Find the difference between the language file and the standard file
+    diff = set(standard_data.keys()) - set(lang_data.keys())
+
+    miss = set(lang_data.keys()) - set(standard_data.keys())
+
+    # Add any missing keys to the language file
+    for key in diff:
+        lang_data[key] = key
+
+    # Del any extra keys to the language file
+    for key in miss:
+        del lang_data[key]
+
+    # Sort the keys of the language file to match the order of the standard file
+    lang_data = OrderedDict(
+        sorted(lang_data.items(), key=lambda x: list(standard_data.keys()).index(x[0]))
+    )
+
+    # Save the updated language file
+    with open(lang_file, "w", encoding="utf-8") as f:
+        json.dump(lang_data, f, ensure_ascii=False, indent=4, sort_keys=True)
+        f.write("\n")

i18n/scan_i18n.py

@@ -0,0 +1,75 @@
+import ast
+import glob
+import json
+from collections import OrderedDict
+
+
+def extract_i18n_strings(node):
+    i18n_strings = []
+
+    if (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "i18n"
+    ):
+        for arg in node.args:
+            if isinstance(arg, ast.Str):
+                i18n_strings.append(arg.s)
+
+    for child_node in ast.iter_child_nodes(node):
+        i18n_strings.extend(extract_i18n_strings(child_node))
+
+    return i18n_strings
+
+
+# scan the directory for all .py files (recursively)
+# for each file, parse the code into an AST
+# for each AST, extract the i18n strings
+
+strings = []
+for filename in glob.iglob("**/*.py", recursive=True):
+    with open(filename, "r") as f:
+        code = f.read()
+        if "I18nAuto" in code:
+            tree = ast.parse(code)
+            i18n_strings = extract_i18n_strings(tree)
+            print(filename, len(i18n_strings))
+            strings.extend(i18n_strings)
+code_keys = set(strings)
+"""
+n_i18n.py
+gui_v1.py 26
+app.py 16
+infer-web.py 147
+scan_i18n.py 0
+i18n.py 0
+lib/train/process_ckpt.py 1
+"""
+print()
+print("Total unique:", len(code_keys))
+
+
+standard_file = "i18n/locale/zh_CN.json"
+with open(standard_file, "r", encoding="utf-8") as f:
+    standard_data = json.load(f, object_pairs_hook=OrderedDict)
+standard_keys = set(standard_data.keys())
+
+# Define the standard file name
+unused_keys = standard_keys - code_keys
+print("Unused keys:", len(unused_keys))
+for unused_key in unused_keys:
+    print("\t", unused_key)
+
+missing_keys = code_keys - standard_keys
+print("Missing keys:", len(missing_keys))
+for missing_key in missing_keys:
+    print("\t", missing_key)
+
+code_keys_dict = OrderedDict()
+for s in strings:
+    code_keys_dict[s] = s
+
+# write back
+with open(standard_file, "w", encoding="utf-8") as f:
+    json.dump(code_keys_dict, f, ensure_ascii=False, indent=4, sort_keys=True)
+    f.write("\n")

install_dependencies.bat

@@ -0,0 +1,27 @@
+@echo off
+echo ==========================================
+echo Instalando uv (Gerenciador de pacotes rapido Python)...
+echo ==========================================
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+
+echo.
+echo ==========================================
+echo Criando ambiente virtual (.venv)...
+echo ==========================================
+:: Tenta usar o uv do PATH. Se falhar, pode ser necessario reiniciar o terminal.
+uv venv
+
+echo.
+echo ==========================================
+echo Instalando dependencias do requirements.txt...
+echo ==========================================
+:: Ativa o venv temporariamente para o install (uv gerencia isso automaticamente se detectar o venv, mas vamos garantir)
+:: Se o uv venv criou a pasta .venv, o uv pip install vai usar ela por padrao se estiver na raiz.
+uv pip install -r requirements.txt
+uv pip install auto-editor
+
+echo.
+echo ==========================================
+echo Concluido!
+echo ==========================================
+pause

main_improved.py

@@ -0,0 +1,695 @@
+import os
+import sys
+
+# Suppress unnecessary logs before importing heavy libs
+os.environ["ORT_LOGGING_LEVEL"] = "3" 
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+
+import warnings
+warnings.filterwarnings("ignore")
+
+import json
+import shutil
+import subprocess
+import argparse
+import time
+from scripts import (
+    download_video,
+    transcribe_video,
+    create_viral_segments,
+    cut_segments,
+    edit_video,
+    transcribe_cuts,
+    adjust_subtitles,
+    burn_subtitles,
+    save_json,
+    organize_output,
+    translate_json,
+)
+from i18n.i18n import I18nAuto
+
+# Inicializa sistema de tradução
+i18n = I18nAuto()
+#
+# Configurações de Legenda (ASS Style)
+# Cores no formato BGR (Blue-Green-Red) para o ASS
+COLORS = {
+    "red": "0000FF",  # Red
+    "yellow": "00FFFF",   # Yellow
+    "green": "00FF00",     # Green
+    "white": "FFFFFF",    # White
+    "black": "000000",     # Black
+    "grey": "808080",     # Grey
+}
+
+def get_subtitle_config(config_path=None):
+    """
+    Returns the subtitle configuration dictionary.
+    Can be expanded to load from a JSON/YAML file in the future.
+    """
+    # Default Config
+    base_color_transparency = "00"
+    outline_transparency = "FF" 
+    highlight_color_transparency = "00"
+    shadow_color_transparency = "00"
+    
+    config = {
+        "font": "Montserrat-Regular",
+        "base_size": 30,
+        "base_color": f"&H{base_color_transparency}{COLORS['white']}&",
+        "highlight_size": 35,
+        "words_per_block": 3,
+        "gap_limit": 0.5,
+        "mode": 'highlight', # Options: 'no_highlight', 'word_by_word', 'highlight'
+        "highlight_color": f"&H{highlight_color_transparency}{COLORS['green']}&",
+        "vertical_position": 210, # 1=170(top), ... 4=60(default)
+        "alignment": 2, # 2=Center
+        "bold": 0,
+        "italic": 0,
+        "underline": 0,
+        "strikeout": 0,
+        "border_style": 2, # 1=outline, 3=box
+        "outline_thickness": 1.5,
+        "outline_color": f"&H{outline_transparency}{COLORS['grey']}&",
+        "shadow_size": 2,
+        "shadow_color": f"&H{shadow_color_transparency}{COLORS['black']}&",
+        "remove_punctuation": True,
+    }
+
+    if config_path and os.path.exists(config_path):
+        try:
+            with open(config_path, 'r', encoding='utf-8') as f:
+                loaded_config = json.load(f)
+                config.update(loaded_config)
+                print(f"Loaded subtitle config from {config_path}")
+        except Exception as e:
+            print(f"Error loading subtitle config: {e}. Using defaults.")
+    
+    return config
+
+def interactive_input_int(prompt_text):
+    """Solicita um inteiro ao usuário via terminal."""
+    while True:
+        try:
+            value = int(input(i18n(prompt_text)))
+            if value > 0:
+                return value
+            print(i18n("\nError: Number must be greater than 0."))
+        except ValueError:
+            print(i18n("\nError: The value you entered is not an integer. Please try again."))
+
+def main():
+    # Configuração de Argumentos via Linha de Comando (CLI)
+    parser = argparse.ArgumentParser(description="ViralCutter CLI")
+    parser.add_argument("--url", help="YouTube Video URL")
+    parser.add_argument("--segments", type=int, help="Number of segments to create")
+    parser.add_argument("--viral", action="store_true", help="Enable viral mode")
+    parser.add_argument("--themes", help="Comma-separated themes (if not viral mode)")
+    parser.add_argument("--burn-only", action="store_true", help="Skip processing and only burn subtitles")
+    parser.add_argument("--min-duration", type=int, default=15, help="Minimum segment duration (seconds)")
+    parser.add_argument("--max-duration", type=int, default=90, help="Maximum segment duration (seconds)")
+    parser.add_argument("--model", default="large-v3-turbo", help="Whisper model to use")
+    
+    parser.add_argument("--ai-backend", choices=["manual", "gemini", "g4f", "local"], help="AI backend for viral analysis")
+    parser.add_argument("--api-key", help="Gemini API Key (required if ai-backend is gemini)")
+    
+    parser.add_argument("--chunk-size", help="Override Chunk Size")
+    parser.add_argument("--ai-model-name", help="Override AI Model Name")
+
+    parser.add_argument("--project-path", help="Path to existing project folder (overrides URL/Latest)")
+    parser.add_argument("--workflow", choices=["1", "2", "3"], default="1", help="Workflow choice: 1=Full, 2=Cut Only, 3=Subtitles Only")
+    parser.add_argument("--face-model", choices=["insightface", "mediapipe"], default="insightface", help="Face detection model")
+    parser.add_argument("--face-mode", choices=["auto", "1", "2"], default="auto", help="Face tracking mode: auto, 1, 2")
+    parser.add_argument("--subtitle-config", help="Path to subtitle configuration JSON file")
+    parser.add_argument("--face-detect-interval", type=str, default="0.17,1.0", help="Face detection interval in seconds. Single value or 'interval_1face,interval_2face'")
+    parser.add_argument("--face-filter-threshold", type=float, default=0.35, help="Relative area threshold to ignore background faces (default: 0.35)")
+    parser.add_argument("--face-two-threshold", type=float, default=0.60, help="Relative area threshold to trigger 2-face mode (default: 0.60)")
+    parser.add_argument("--face-confidence-threshold", type=float, default=0.30, help="Face detection confidence threshold (0.0 - 1.0) (default: 0.30)")
+    parser.add_argument("--face-dead-zone", type=str, default="40", help="Camera movement dead zone in pixels (default: 40)") # str to support future "auto"
+    parser.add_argument("--focus-active-speaker", action="store_true", help="Enable experimental active speaker focus (InsightFace only)")
+    parser.add_argument("--active-speaker-mar", type=float, default=0.03, help="Mouth Aspect Ratio threshold for active speaker (0.0 - 1.0) (default: 0.03)")
+    parser.add_argument("--active-speaker-score-diff", type=float, default=1.5, help="Score difference to focus on active speaker (default: 1.5)")
+    parser.add_argument("--include-motion", action="store_true", help="Include motion (body/head movement) in activity score")
+    parser.add_argument("--active-speaker-motion-threshold", type=float, default=3.0, help="Motion deadzone in pixels (default: 3.0)")
+    parser.add_argument("--active-speaker-motion-sensitivity", type=float, default=0.05, help="Motion sensitivity multiplier (default: 0.05)")
+    parser.add_argument("--active-speaker-decay", type=float, default=2.0, help="Activity score decay rate (default: 2.0)")
+    parser.add_argument("--skip-prompts", action="store_true", help="Skip interactive prompts and use defaults/existing files")
+    parser.add_argument("--video-quality", choices=["best", "1080p", "720p", "480p"], default="best", help="Video download quality")
+    parser.add_argument("--skip-youtube-subs", action="store_true", help="Skip downloading YouTube subtitles")
+    parser.add_argument("--translate-target", help="Target language code for subtitle translation (e.g. 'pt', 'en').")
+
+    args = parser.parse_args()
+    
+    # Workflow Logic
+    workflow_choice = args.workflow
+    
+    # If Subtitles Only, checking project path
+    if workflow_choice == "3" and not args.project_path and not args.url and not args.skip_prompts:
+        # Prompt for project path or use latest if not provided?
+        pass # Will handle in main flow
+
+    # Modo Apenas Queimar Legenda (Legacy support, mapped to Workflow 3 internally if burn-only is set)
+    # Verifica o argumento CLI ou uma variável local hardcoded (para compatibilidade)
+    burn_only_mode = args.burn_only
+
+    if burn_only_mode:
+        print(i18n("Burn only mode activated. Switching to Workflow 3..."))
+        workflow_choice = "3"
+
+    # Obtenção de Inputs (CLI ou Interativo)
+    url = args.url
+    project_path_arg = args.project_path
+    input_video = None
+
+    # Se project_path for fornecido, ignoramos URL
+    if project_path_arg:
+        if os.path.exists(project_path_arg):
+             print(i18n("Using provided project path: {}").format(project_path_arg))
+             # Tentar achar o input.mp4 pra manter compatibilidade de variaveis, embora Workflow 3 não precise de download
+             possible_input = os.path.join(project_path_arg, "input.mp4")
+             if os.path.exists(possible_input):
+                 input_video = possible_input
+             else:
+                 # Se não tiver input.mp4, tudo bem para workflow 3, mas definimos um dummy para não quebrar logica
+                 input_video = os.path.join(project_path_arg, "dummy_input.mp4")
+             
+             # Se for workflow 3, não precisamos de URL
+        else:
+             print(i18n("Error: Provided project path does not exist."))
+             sys.exit(1)
+
+    # Se não temos URL via CLI nem Project Path, pedimos agora
+    if not url and not project_path_arg:
+        if args.skip_prompts:
+             print(i18n("No URL provided and skipping prompts. Trying to load latest project..."))
+             # Fallthrough to project loading logic
+        else:
+            user_input = input(i18n("Enter the YouTube video URL (or press Enter to use latest project): ")).strip()
+            if user_input:
+                url = user_input
+    
+    if not url and not input_video:
+        # Usuário apertou Enter (Vazio) -> Tentar pegar último projeto
+        base_virals = "VIRALS"
+        if os.path.exists(base_virals):
+            subdirs = [os.path.join(base_virals, d) for d in os.listdir(base_virals) if os.path.isdir(os.path.join(base_virals, d))]
+            if subdirs:
+                latest_project = max(subdirs, key=os.path.getmtime)
+                detected_video = os.path.join(latest_project, "input.mp4")
+                if os.path.exists(detected_video):
+                    input_video = detected_video
+                    print(i18n("Using latest project: {}").format(latest_project))
+                else:
+                    print(i18n("Latest project found but 'input.mp4' is missing."))
+                    sys.exit(1)
+            else:
+                print(i18n("No existing projects found in VIRALS folder."))
+                sys.exit(1)
+        else:
+             print(i18n("VIRALS folder not found. Cannot load latest project."))
+             sys.exit(1)
+
+    # -------------------------------------------------------------------------
+    # Checagem Antecipada de Segmentos Virais (Para pular configurações se já existirem)
+    # -------------------------------------------------------------------------
+    viral_segments = None
+    project_folder_anticipated = None
+
+    if input_video:
+        # Se já temos o vídeo, podemos deduzir a pasta
+        project_folder_anticipated = os.path.dirname(input_video)
+        viral_segments_file = os.path.join(project_folder_anticipated, "viral_segments.txt")
+        
+        if os.path.exists(viral_segments_file):
+             print(i18n("\nExisting viral segments found: {}").format(viral_segments_file))
+             if args.skip_prompts:
+                 use_existing_json = 'yes'
+             else:
+                 use_existing_json = input(i18n("Use existing viral segments? (yes/no) [default: yes]: ")).strip().lower()
+             
+             if use_existing_json in ['', 'y', 'yes']:
+                try:
+                    with open(viral_segments_file, 'r', encoding='utf-8') as f:
+                        viral_segments = json.load(f)
+                    print(i18n("Loaded existing viral segments. Skipping configuration prompts."))
+                    if viral_segments and "segments" in viral_segments:
+                        print(f"DEBUG: Loaded {len(viral_segments['segments'])} segments from file.")
+                    else:
+                        print("DEBUG: Loaded JSON but 'segments' key is missing or empty.")
+                except Exception as e:
+                    print(i18n("Error loading JSON: {}.").format(e))
+
+    # Variaveis de config de IA (só necessárias se não tivermos os segmentos)
+    num_segments = None
+    viral_mode = False
+    themes = ""
+    ai_backend = "manual" # default
+    api_key = None
+    
+    if not viral_segments:
+        num_segments = args.segments
+        if not num_segments:
+            if args.skip_prompts:
+                print("No segments count provided and skip-prompts is ON. Using default 3.")
+                num_segments = 3
+            else:
+                num_segments = interactive_input_int("Enter the number of viral segments to create: ")
+
+        viral_mode = args.viral
+        if not args.viral and not args.themes:
+            if args.skip_prompts:
+                print("Viral mode not set, defaulting to True.")
+                viral_mode = True
+            else:
+                response = input(i18n("Do you want viral mode? (yes/no): ")).lower()
+                viral_mode = response in ['yes', 'y']
+        
+        themes = args.themes if args.themes else ""
+        if not viral_mode and not themes:
+            if not args.skip_prompts:
+                 themes = input(i18n("Enter themes (comma-separated, leave blank if viral mode is True): "))
+
+        # Duration Config
+        print(i18n("\nCurrent duration settings: {}s - {}s").format(args.min_duration, args.max_duration))
+        if not args.skip_prompts:
+            change_dur = input(i18n("Change duration? (y/n) [default: n]: ")).strip().lower()
+            if change_dur in ['y', 'yes']:
+                 try:
+                     min_d = input(i18n("Minimum duration [{}]: ").format(args.min_duration)).strip()
+                     if min_d: args.min_duration = int(min_d)
+                     
+                     max_d = input(i18n("Maximum duration [{}]: ").format(args.max_duration)).strip()
+                     if max_d: args.max_duration = int(max_d)
+                 except ValueError:
+                     print(i18n("Invalid number. Using previous values."))
+
+        # Load API Config
+        config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'api_config.json')
+        api_config = {}
+        if os.path.exists(config_path):
+            try:
+                with open(config_path, 'r', encoding='utf-8') as f:
+                    api_config = json.load(f)
+            except:
+                pass
+
+        # Seleção do Backend de IA
+        ai_backend = args.ai_backend
+        
+        # Try to load backend from config if not in args
+        if not ai_backend and api_config.get("selected_api"):
+            ai_backend = api_config.get("selected_api")
+            print(i18n("Using AI Backend from config: {}").format(ai_backend))
+
+        if not ai_backend:
+            if args.skip_prompts:
+                print("No AI backend selected, defaulting to Manual.")
+                ai_backend = "manual"
+            else:
+                print("\n" + i18n("Select AI Backend for Viral Analysis:"))
+                print(i18n("1. Gemini API (Best / Recommended)"))
+                print(i18n("2. G4F (Free / Experimental)"))
+                print(i18n("3. Local (GGUF via llama.cpp)"))
+                print(i18n("4. Manual (Copy/Paste Prompt)"))
+                choice = input(i18n("Choose (1-4): ")).strip()
+                
+                if choice == "1":
+                    ai_backend = "gemini"
+                elif choice == "2":
+                    ai_backend = "g4f"
+                elif choice == "3":
+                    ai_backend = "local"
+                    # Interactive model selection for local
+                    # List models
+                    models_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models")
+                    if not os.path.exists(models_dir): os.makedirs(models_dir)
+                    models = [f for f in os.listdir(models_dir) if f.endswith(".gguf")]
+                    
+                    if not models:
+                        print(i18n("\nNo .gguf models found in 'models' directory."))
+                        print(i18n("Please place a module file in: {}").format(models_dir))
+                        print(i18n("Falling back to Manual..."))
+                        ai_backend = "manual"
+                    else:
+                        print(i18n("\nAvailable Models:"))
+                        for idx, m in enumerate(models):
+                            print(f"{idx+1}. {m}")
+                        
+                        try:
+                            m_idx = int(input(i18n("Select Model (Number): "))) - 1
+                            if 0 <= m_idx < len(models):
+                                args.ai_model_name = models[m_idx] # Set global arg
+                            else:
+                                print("Invalid selection. Using first model.")
+                                args.ai_model_name = models[0]
+                        except:
+                             print("Invalid input. Using first model.")
+                             args.ai_model_name = models[0]
+                             
+                else:
+                    ai_backend = "manual"
+
+        api_key = args.api_key
+        # Check config for API Key if using Gemini
+        if ai_backend == "gemini" and not api_key:
+            cfg_key = api_config.get("gemini", {}).get("api_key", "")
+            if cfg_key and cfg_key != "SUA_KEY_AQUI":
+                api_key = cfg_key
+        
+        if ai_backend == "gemini" and not api_key:
+             if args.skip_prompts:
+                 print("Gemini API key missing, but skip-prompts is ON. Might fail.")
+             else:
+                 print(i18n("Gemini API Key not found in api_config.json or arguments."))
+                 api_key = input(i18n("Enter your Gemini API Key: ")).strip()
+
+    # Workflow & Face Config Inputs
+    workflow_choice = args.workflow
+    face_model = args.face_model
+    face_mode = args.face_mode
+
+    # If args weren't provided and we are not skipping prompts, ask user
+    # Note: argparse defaults are set, so they "are provided" effectively.
+    # To truly detect "not provided", request default=None in argparse. 
+    # But for "Simplified Mode", defaults are good.
+    # Advanced users use params.
+    # We will assume CLI defaults are what we want if skip_prompts is on.
+    
+    # Logic for detection intervals (Moved out of interactive block to support CLI/WebUI)
+    detection_intervals = None
+    if args.face_detect_interval:
+        try:
+            parts = args.face_detect_interval.split(',')
+            if len(parts) == 1:
+                val = float(parts[0])
+                detection_intervals = {'1': val, '2': val}
+            elif len(parts) >= 2:
+                val1 = float(parts[0])
+                val2 = float(parts[1])
+                detection_intervals = {'1': val1, '2': val2}
+        except ValueError:
+            pass
+
+    if not args.burn_only and not args.skip_prompts:
+        # Interactive Face Config
+        print(i18n("\n--- Face Detection Settings ---"))
+        print(i18n("Current Face Model: {} | Mode: {}").format(face_model, face_mode))
+        
+        if detection_intervals:
+             print(i18n("Custom detection intervals: {}").format(detection_intervals))
+        else:
+             print(i18n("Using dynamic intervals: 1s for 2-face, ~0.16s for 1-face."))
+
+
+    # Pipeline Execution
+    try:
+        # 1. Download & Project Setup
+        print(f"DEBUG: Checking input_video state. input_video={input_video}")
+        
+        if not input_video:
+            if not url:
+                print(i18n("Error: No URL provided and no existing video selected."))
+                sys.exit(1)
+                
+            print(i18n("Starting download..."))
+            download_subs = not args.skip_youtube_subs
+            download_result = download_video.download(url, download_subs=download_subs, quality=args.video_quality)
+            
+            if isinstance(download_result, tuple):
+                input_video, project_folder = download_result
+            else:
+                input_video = download_result
+                project_folder = os.path.dirname(input_video)
+                
+            print(f"DEBUG: Download finished. input_video={input_video}, project_folder={project_folder}")
+            
+        else:
+            # Reuso de video existente
+            print("DEBUG: Using existing video logic.")
+            project_folder = os.path.dirname(input_video)
+            
+        print(f"Project Folder: {project_folder}")
+        
+        # 2. Transcribe
+        if workflow_choice == "3":
+            print(i18n("Workflow 3: Skipping Transcribe."))
+            # We assume transcription exists (SRT/JSON) or we won't need it for 'adjust_subtitles' if it uses 'subs/*.json' which are created by 'cut_segments'
+            # Actually 'adjust_subtitles' reads from 'project_folder/subs'.
+            # viral_segments = True # Removed to avoid overwritting dict loaded earlier
+        else:
+            print(i18n("Transcribing with model {}...").format(args.model))
+            # Se skip config, args.model é default
+            srt_file, tsv_file = transcribe_video.transcribe(input_video, args.model, project_folder=project_folder)
+ 
+        # 3. Create Viral Segments
+        if workflow_choice != "3":
+            # Se não carregamos 'viral_segments' lá em cima (ou se era download novo), checamos agora ou criamos
+            if not viral_segments:
+                # Checagem tardia para downloads novos que por acaso ja tenham json (Ex: URL repetida)
+                viral_segments_file_late = os.path.join(project_folder, "viral_segments.txt")
+                if os.path.exists(viral_segments_file_late):
+                    print(i18n("Found existing viral segments file at {}").format(viral_segments_file_late))
+                    if args.skip_prompts:
+                        print(i18n("Skipping prompts enabled. Loading existing segments."))
+                        try:
+                            with open(viral_segments_file_late, 'r', encoding='utf-8') as f:
+                                viral_segments = json.load(f)
+                        except Exception as e:
+                            print(i18n("Error loading existing JSON: {}. Proceeding to create new segments.").format(e))
+                    else:
+                        print(i18n("Loading existing viral segments found at {}").format(viral_segments_file_late))
+                        try:
+                            with open(viral_segments_file_late, 'r', encoding='utf-8') as f:
+                                viral_segments = json.load(f)
+                        except Exception as e:
+                            print(i18n("Error loading existing JSON: {}.").format(e))
+                    
+                if not viral_segments:
+                    print(i18n("Creating viral segments using {}...").format(ai_backend.upper()))
+                    viral_segments = create_viral_segments.create(
+                        num_segments, 
+                        viral_mode, 
+                        themes, 
+                        args.min_duration, 
+                        args.max_duration,
+                        ai_mode=ai_backend,
+                        api_key=api_key,
+                        project_folder=project_folder,
+                        chunk_size_arg=args.chunk_size,
+                        model_name_arg=args.ai_model_name
+                    )
+                
+                if not viral_segments or not viral_segments.get("segments"):
+                    print(i18n("Error: No viral segments were generated."))
+                    print(i18n("Possible reasons: API error, Model not found, or empty response."))
+                    print(i18n("Stopping execution."))
+                    sys.exit(1)
+                
+                save_json.save_viral_segments(viral_segments, project_folder=project_folder) 
+
+        # 4. Cut Segments
+        # Se workflow for 3, pulamos corte
+        if workflow_choice == "3":
+            print(i18n("Workflow 3 (Subtitles Only): Skipping Cut and Edit."))
+            # Deduzir cuts folder apenas para log
+            cuts_folder = os.path.join(project_folder, "cuts")
+        else:
+            cuts_folder = os.path.join(project_folder, "cuts")
+            skip_cutting = False
+            
+            if os.path.exists(cuts_folder) and os.listdir(cuts_folder):
+                print(i18n("\nExisting cuts found in: {}").format(cuts_folder))
+                if args.skip_prompts:
+                    cut_again_resp = 'no'
+                else:
+                    cut_again_resp = input(i18n("Cuts already exist. Cut again? (yes/no) [default: no]: ")).strip().lower()
+                
+                # Default is no (skip) if they just press enter or say no
+                if cut_again_resp not in ['y', 'yes']:
+                    skip_cutting = True
+            
+            if skip_cutting:
+                print(i18n("Skipping Video Rendering (using existing cuts), but updating Subtitle JSONs..."))
+            else:
+                print(i18n("Cutting segments..."))
+
+            cut_segments.cut(viral_segments, project_folder=project_folder, skip_video=skip_cutting)
+        
+        # 5. Workflow Check
+        if workflow_choice == "2":
+            print(i18n("Cut Only selected. Skipping Face Crop and Subtitles."))
+            print(i18n(f"Process completed! Check your results in: {project_folder}"))
+            sys.exit(0)
+
+        # 5. Edit Video (Face Crop)
+        if workflow_choice != "3":
+            print(i18n("Editing video with {} (Mode: {})...").format(face_model, face_mode))
+            
+            # Parse dead zone safely
+            try:
+                dead_zone_val = float(args.face_dead_zone)
+            except:
+                dead_zone_val = 40.0
+                
+            edit_video.edit(
+                project_folder=project_folder, 
+                face_model=face_model, 
+                face_mode=face_mode, 
+                detection_period=detection_intervals,
+                filter_threshold=args.face_filter_threshold,
+                two_face_threshold=args.face_two_threshold,
+                confidence_threshold=args.face_confidence_threshold,
+                dead_zone=dead_zone_val,
+                focus_active_speaker=args.focus_active_speaker,
+                active_speaker_mar=args.active_speaker_mar,
+                active_speaker_score_diff=args.active_speaker_score_diff,
+                include_motion=args.include_motion,
+                active_speaker_motion_deadzone=args.active_speaker_motion_threshold,
+                active_speaker_motion_sensitivity=args.active_speaker_motion_sensitivity,
+                active_speaker_decay=args.active_speaker_decay,
+                segments_data=viral_segments.get("segments", []) if viral_segments else None
+            )
+
+
+        else:
+            print(i18n("Workflow 3: Skipping Face Crop."))
+            # Rename existing files if viral_segments available (since edit_video didn't run)
+            if viral_segments and "segments" in viral_segments:
+                 segments_data = viral_segments.get("segments", [])
+                 final_folder = os.path.join(project_folder, "final")
+                 subs_folder = os.path.join(project_folder, "subs")
+                 
+                 print("Renaming existing files with titles...")
+                 for idx, segment in enumerate(segments_data):
+                     title = segment.get("title", f"Segment_{idx}")
+                     safe_title = "".join([c for c in title if c.isalnum() or c in " _-"]).strip()
+                     safe_title = safe_title.replace(" ", "_")[:60]
+                     
+                     new_base_name = f"{idx:03d}_{safe_title}"
+                     
+                     # 1. MP4
+                     old_mp4_name = f"final-output{idx:03d}_processed.mp4"
+                     old_mp4_path = os.path.join(final_folder, old_mp4_name)
+                     new_mp4_path = os.path.join(final_folder, f"{new_base_name}.mp4")
+                     if os.path.exists(old_mp4_path) and not os.path.exists(new_mp4_path):
+                         os.rename(old_mp4_path, new_mp4_path)
+                         print(f"Renamed (Workflow 3): {old_mp4_name} -> {new_base_name}.mp4")
+
+                     # 2. JSON Sub
+                     old_json_name = f"final-output{idx:03d}_processed.json"
+                     old_json_path = os.path.join(subs_folder, old_json_name)
+                     new_json_path = os.path.join(subs_folder, f"{new_base_name}_processed.json")
+                     if os.path.exists(old_json_path) and not os.path.exists(new_json_path):
+                         os.rename(old_json_path, new_json_path)
+                         print(f"Renamed (Workflow 3): {old_json_name} -> {new_base_name}_processed.json")
+                         
+                     # 3. Timeline
+                     old_tl_name = f"temp_video_no_audio_{idx}_timeline.json"
+                     old_tl_path = os.path.join(final_folder, old_tl_name)
+                     new_tl_path = os.path.join(final_folder, f"{new_base_name}_timeline.json")
+                     if os.path.exists(old_tl_path) and not os.path.exists(new_tl_path):
+                         os.rename(old_tl_path, new_tl_path)
+                         print(f"Renamed (Workflow 3): {old_tl_name} -> {new_base_name}_timeline.json")
+
+        # 6. Subtitles
+        burn_subtitles_option = True 
+        if burn_subtitles_option:
+            print(i18n("Processing subtitles..."))
+            # transcribe_cuts removido: JSON de legenda já é gerado no corte
+            # transcribe_cuts.transcribe(project_folder=project_folder)
+            
+            # --- Translation Integration ---
+            if args.translate_target and args.translate_target.lower() != "none":
+                 print(i18n("Translating subtitles to: {}").format(args.translate_target))
+                 import asyncio
+                 try:
+                    asyncio.run(translate_json.translate_project_subs(project_folder, args.translate_target))
+                 except Exception as e:
+                    print(i18n("Translation failed: {}").format(e))
+            # -------------------------------
+
+            sub_config = get_subtitle_config(args.subtitle_config)
+            
+
+            
+            # Passa o dicionário desempacotado como argumentos, mais o project_folder
+            try:
+                adjust_subtitles.adjust(project_folder=project_folder, **sub_config)
+                burn_subtitles.burn(project_folder=project_folder)
+            except FileNotFoundError as fnf_error:
+                print(i18n("\n[ERROR] Subtitle processing failed: {}").format(str(fnf_error)))
+                print(i18n("Tip: If you are using Workflow 3 (Subtitles Only), ensure the 'subs' folder exists and contains valid JSON files."))
+                sys.exit(1)
+            except Exception as e:
+                print(i18n("\n[ERROR] Unexpected error during subtitle processing: {}").format(str(e)))
+                raise e
+        else:
+            print(i18n("Subtitle burning skipped."))
+
+        # Organização Final (Opcional, pois agora já está tudo em project_folder)
+        # organize_output.organize(project_folder=project_folder)
+        
+        # --- Save Processing Configuration ---
+        try:
+            # Determine AI Model used
+            used_ai_model = args.ai_model_name
+            if not used_ai_model and ai_backend != "manual":
+                if ai_backend == "gemini":
+                    used_ai_model = api_config.get("gemini", {}).get("model", "default")
+                elif ai_backend == "g4f":
+                    used_ai_model = api_config.get("g4f", {}).get("model", "default")
+            
+            # Ensure sub_config exists
+            current_sub_config = sub_config if 'sub_config' in locals() else get_subtitle_config(args.subtitle_config)
+            
+            final_config = {
+                "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+                "workflow": workflow_choice,
+                "ai_config": {
+                    "backend": ai_backend,
+                    "model_name": used_ai_model,
+                    "viral_mode": viral_mode,
+                    "themes": themes,
+                    "num_segments": num_segments,
+                    "chunk_size": args.chunk_size
+                },
+                "face_config": {
+                    "model": face_model,
+                    "mode": face_mode,
+                    "detect_interval": args.face_detect_interval,
+                    "filter_threshold": args.face_filter_threshold,
+                    "two_face_threshold": args.face_two_threshold,
+                    "confidence_threshold": args.face_confidence_threshold,
+                    "dead_zone": args.face_dead_zone,
+                    "focus_active_speaker": args.focus_active_speaker,
+                    "active_speaker_mar": args.active_speaker_mar,
+                    "active_speaker_score_diff": args.active_speaker_score_diff,
+                    "include_motion": args.include_motion
+                },
+                "video_config": {
+                    "min_duration": args.min_duration,
+                    "max_duration": args.max_duration,
+                    "whisper_model": args.model
+                },
+                "subtitle_config": current_sub_config
+            }
+
+            config_save_path = os.path.join(project_folder, "process_config.json")
+            with open(config_save_path, "w", encoding="utf-8") as f:
+                json.dump(final_config, f, indent=4, ensure_ascii=False)
+            print(i18n("Configuration saved to: {}").format(config_save_path))
+            
+        except Exception as e:
+            print(i18n("Error saving configuration JSON: {}").format(e))
+        # -------------------------------------
+
+        print(i18n("Process completed! Check your results in: {}").format(project_folder))
+
+    except Exception as e:
+        print(i18n("\nAn error occurred: {}").format(str(e)))
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

prompt.txt

@@ -0,0 +1,42 @@
+
+You are a World-Class Viral Video Editor and Storyteller. You are an expert at finding "gold nuggets" in long transcripts that can stand alone as viral TikToks/Reels/Shorts.
+
+Your goal is to extract segments that have **Perfect Narrative Completeness** (Start, Middle, End) while respecting time constraints.
+
+### INPUT FORMAT EXPLAINED
+The transcript below is a continuous text stream with embedded **Time Tags** like `(12s)`.
+- Example: `"Hello world (0s). Today we are going to (3s) fly to the moon."`
+- These tags represent the approximate timestamp of the *preceding* text.
+- Use them to calculate duration. Duration = (End Tag - Start Tag).
+
+### STRICT VIRAL RULES (The "ViralCutter Standard"):
+1.  **NO "GARBAGE" STARTS:**
+    -   NEVER start with filler words ("Um", "Uh", "So...", "And then").
+    -   NEVER start with low-energy intros ("Hi guys, welcome back").
+    -   **ALWAYS** start with a Hook: A strong statement, a question, or an action verb.
+    -   *Bad Start:* "(10s) So, I was thinking..."
+    -   *Good Start:* "(12s) I almost died yesterday."
+
+2.  **THE "STANDALONE" TEST:**
+    -   Can this segment be shown to a stranger without ANY context?
+    -   If it contains "That's why *he* said that" (and "he" is unknown), it FAILS. Eliminate or expand context.
+
+3.  **NARRATIVE ARC:**
+    -   **Start:** Hook (0-3s).
+    -   **Middle:** Value/Story (Retain attention).
+    -   **End:** Punchline/Conclusion (Satisfying ending). NEVER cut mid-sentence.
+
+4.  **DURATION MATH:**
+    -   Use the `(XXs)` tags to estimate duration.
+    -   Target: {min_duration}s to {max_duration}s.
+
+### YOUR TASK:
+Analyze the transcript below. Find {amount} potential viral segments.
+
+TRANSCRIPT:
+{transcript_chunk}
+
+### OUTPUT FORMAT (JSON ONLY):
+{json_template}
+
+Return ONLY VALID JSON. No markdown, no commentary.

requirements.txt

@@ -0,0 +1,23 @@
+g4f[all]
+yt-dlp
+ffmpeg-python
+whisperx
+mediapipe
+google-genai
+insightface
+onnxruntime-gpu
+gradio
+opencv-python
+numpy
+psutil
+fastapi
+uvicorn
+torch
+deep-translator
+tqdm
+
+
+
+# Local LLM Support with CUDA 12.4
+--extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu124
+llama-cpp-python

run.bat

@@ -0,0 +1,9 @@
+@echo off
+setlocal
+title ViralCutter
+
+cd /d "%~dp0"
+call .venv\Scripts\activate.bat
+python main_improved.py
+echo.
+pause

run_webui.bat

@@ -0,0 +1,4 @@
+@echo off
+call .venv\Scripts\activate.bat
+python webui\app.py
+pause