feat: QoL features to Updater, workflow trigger.

Fix Torrent Handle errors
fix: wrong download paths in libtorrent logic
2026-08-03 17:39:42 +02:00 · 2026-03-11 00:07:11 +01:00 · 2026-03-10 22:45:25 +01:00 · 2026-03-10 22:35:49 +01:00 · 2026-03-10 22:23:26 +01:00 · 2026-03-10 22:21:59 +01:00
36 changed files with 2887 additions and 608 deletions
@@ -28,8 +28,8 @@ jobs:
            artifact_name: SoftwareManager-dev-${{ github.sha }}-linux
            asset_name: SoftwareManager-dev-${{ github.sha }}-linux
          - os: windows-latest
-            artifact_name: SoftwareManager-dev-${{ github.sha }}-windows.exe
-            asset_name: SoftwareManager-dev-${{ github.sha }}-windows.exe
+            artifact_name: SoftwareManager-dev-${{ github.sha }}-windows
+            asset_name: SoftwareManager-dev-${{ github.sha }}-windows
          - os: macos-latest
            artifact_name: SoftwareManager-dev-${{ github.sha }}-macos
            asset_name: SoftwareManager-dev-${{ github.sha }}-macos
@@ -116,9 +116,7 @@ jobs:
        shell: bash
        run: |
          python -m nuitka \
-            --onefile \
-            --onefile-no-compression \
-            --onefile-tempdir-spec="{CACHE_DIR}/${{ env.APP_NAME }}/${{ env.VERSION }}" \
+            --standalone \
            --assume-yes-for-downloads \
            --windows-console-mode=disable \
            --windows-icon-from-ico=app_icon.ico \
@@ -130,6 +128,7 @@ jobs:
            --include-data-files=build_info.json=src/build_info.json \
            --include-data-files=build_info.json=src/core/interface/build_info.json \
            --output-filename=${{ env.APP_NAME }}.exe \
+            --output-dir=nuitka-build \
            src/main.py

      - name: Build with PyInstaller (Linux)
@@ -173,14 +172,48 @@ jobs:
        run: |
          mkdir -p dist-final
          if [ "$RUNNER_OS" == "Windows" ]; then
-            mv ${{ env.APP_NAME }}.exe dist-final/${{ matrix.artifact_name }}
+            mv nuitka-build/main.dist dist-final/${{ env.APP_NAME }}
+            ls -la dist-final/${{ env.APP_NAME }}/
          else
            chmod +x dist/${{ env.APP_NAME }}
            mv dist/${{ env.APP_NAME }} dist-final/${{ matrix.artifact_name }}
          fi
          ls -la dist-final/

-      - name: Upload build artifact
+      - name: Create ZIP (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          Compress-Archive -Path "dist-final/${{ env.APP_NAME }}/*" -DestinationPath "dist-final/${{ matrix.artifact_name }}.zip"
+          Write-Host "Created ZIP: ${{ matrix.artifact_name }}.zip"
+
+      - name: Build Installer (Windows)
+        if: runner.os == 'Windows'
+        shell: bash
+        run: |
+          SHORT_SHA="${{ github.sha }}"
+          SHORT_SHA="${SHORT_SHA:0:7}"
+          SETUP_NAME="SoftwareManager-dev-${SHORT_SHA}-windows-setup"
+          iscc //DMyAppVersion="${{ env.VERSION }}" \
+               //DMySourceDir="dist-final\\${{ env.APP_NAME }}" \
+               //DMyOutputDir="dist-final" \
+               //DMyOutputFilename="${SETUP_NAME}" \
+               installer.iss
+          echo "SETUP_NAME=${SETUP_NAME}" >> $GITHUB_ENV
+          ls -la dist-final/
+
+      - name: Upload build artifact (Windows)
+        if: runner.os == 'Windows'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.os }}-build
+          path: |
+            dist-final/${{ matrix.artifact_name }}.zip
+            dist-final/${{ env.SETUP_NAME }}.exe
+          retention-days: 1
+
+      - name: Upload build artifact (Linux/macOS)
+        if: runner.os != 'Windows'
        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.os }}-build
@@ -204,7 +237,8 @@ jobs:
          mkdir -p release
          SHORT_SHA="${{ needs.build.outputs.short_sha }}"
          cp artifacts/ubuntu-22.04-build/SoftwareManager-dev-*-linux release/SoftwareManager-dev-${SHORT_SHA}-linux
-          cp artifacts/windows-latest-build/SoftwareManager-dev-*-windows.exe release/SoftwareManager-dev-${SHORT_SHA}-windows.exe
+          cp artifacts/windows-latest-build/SoftwareManager-dev-*-windows.zip release/SoftwareManager-dev-${SHORT_SHA}-windows.zip
+          cp artifacts/windows-latest-build/SoftwareManager-dev-*-windows-setup.exe release/SoftwareManager-dev-${SHORT_SHA}-windows-setup.exe
          cp artifacts/macos-latest-build/SoftwareManager-dev-*-macos release/SoftwareManager-dev-${SHORT_SHA}-macos
          chmod +x release/SoftwareManager-dev-*-linux release/SoftwareManager-dev-*-macos
          ls -la release/
@@ -229,7 +263,8 @@ jobs:
          
          ### Downloads
          - Linux: \`SoftwareManager-dev-${SHORT_SHA}-linux\`
-          - Windows: \`SoftwareManager-dev-${SHORT_SHA}-windows.exe\`
+          - Windows (Portable ZIP): \`SoftwareManager-dev-${SHORT_SHA}-windows.zip\`
+          - Windows (Installer): \`SoftwareManager-dev-${SHORT_SHA}-windows-setup.exe\`
          - macOS: \`SoftwareManager-dev-${SHORT_SHA}-macos\`
          
          ### SHA-256 Checksums
@@ -247,7 +282,8 @@ jobs:
          body_path: release_notes.md
          files: |
            release/SoftwareManager-dev-${{ needs.build.outputs.short_sha }}-linux
-            release/SoftwareManager-dev-${{ needs.build.outputs.short_sha }}-windows.exe
+            release/SoftwareManager-dev-${{ needs.build.outputs.short_sha }}-windows.zip
+            release/SoftwareManager-dev-${{ needs.build.outputs.short_sha }}-windows-setup.exe
            release/SoftwareManager-dev-${{ needs.build.outputs.short_sha }}-macos
            release/SHA256SUMS.txt
        env:
@@ -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>.
@@ -0,0 +1,71 @@
+#define MyAppName "SoftwareManager"
+#define MyAppPublisher "KeksPirates"
+#define MyAppURL "https://github.com/KeksPirates/SoftwareManager"
+#define MyAppExeName "SoftwareManager.exe"
+
+; Version is passed via /D on the command line: iscc /DMyAppVersion=...
+#ifndef MyAppVersion
+  #define MyAppVersion "dev"
+#endif
+
+; SourceDir is passed via /D on the command line
+#ifndef MySourceDir
+  #define MySourceDir "dist-final\SoftwareManager"
+#endif
+
+; OutputDir is passed via /D on the command line
+#ifndef MyOutputDir
+  #define MyOutputDir "dist-final"
+#endif
+
+; OutputFilename is passed via /D on the command line
+#ifndef MyOutputFilename
+  #define MyOutputFilename "SoftwareManager-setup"
+#endif
+
+[Setup]
+AppId={{8F2E4B6A-1C3D-4E5F-9A7B-0D8E6F2C4A1B}
+AppName={#MyAppName}
+AppVersion={#MyAppVersion}
+AppVerName={#MyAppName} {#MyAppVersion}
+AppPublisher={#MyAppPublisher}
+AppPublisherURL={#MyAppURL}
+AppSupportURL={#MyAppURL}/issues
+AppUpdatesURL={#MyAppURL}/releases
+DefaultDirName={autopf}\{#MyAppName}
+DefaultGroupName={#MyAppName}
+AllowNoIcons=yes
+LicenseFile=LICENSE
+OutputDir={#MyOutputDir}
+OutputBaseFilename={#MyOutputFilename}
+Compression=lzma2
+SolidCompression=yes
+WizardStyle=modern
+DisableWelcomePage=no
+PrivilegesRequired=lowest
+PrivilegesRequiredOverridesAllowed=dialog
+UninstallDisplayIcon={app}\{#MyAppExeName}
+UninstallDisplayName={#MyAppName}
+ArchitecturesAllowed=x64compatible
+ArchitecturesInstallIn64BitMode=x64compatible
+CloseApplications=yes
+RestartApplications=yes
+ShowLanguageDialog=auto
+
+[Languages]
+Name: "english"; MessagesFile: "compiler:Default.isl"
+
+[Tasks]
+Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked
+
+[Files]
+Source: "{#MySourceDir}\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
+
+[Icons]
+Name: "{group}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"
+Name: "{group}\{cm:UninstallProgram,{#MyAppName}}"; Filename: "{uninstallexe}"
+Name: "{autodesktop}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; Tasks: desktopicon
+
+[Run]
+Filename: "{app}\{#MyAppExeName}"; Description: "{cm:LaunchProgram,{#StringChange(MyAppName, '&', '&&')}}"; Flags: nowait postinstall skipifsilent
+Filename: "{app}\{#MyAppExeName}"; Flags: nowait skipifnotsilent
@@ -8,4 +8,4 @@ aiohttp==3.13.0
 plyer==2.1.0
 psutil==7.1.0
 libtorrent==2.0.11
-libtorrent-windows-dll==0.0.3
+libtorrent-windows-dll==0.0.3
@@ -1,3 +1,3 @@
 {
-  "Version": "dev"
+  "version": "dev"
 }
@@ -1,16 +1,31 @@
+from core.utils.data.state import state
+from core.utils.data.tracker import get_magnet_link
 from bs4 import BeautifulSoup
+from typing import Dict
 import requests
-from core.utils.general.logs import consoleLog
+import time

-def scrape_monkrus_telegram(query):
+cache = {
+    "data": [],
+    "last_fetched": 0
+}
+
+cache_expiry = 300
+
+def _get_telegram_posts():
    post = 100
    max_posts = 250
-    posts: list[dict] = []
+    posts = []
    added = set()
-    
+
+    current_time = time.time()
+
+    if cache["data"] and (current_time - cache["last_fetched"] < cache_expiry):
+        return cache["data"]
+
    while post <= max_posts:
        url = f"https://t.me/s/real_monkrus/{post}"
-        response = requests.get(url)
+        response = requests.get(url, timeout=10)
        soup = BeautifulSoup(response.text, "html.parser")
        bubbles = soup.find_all("div", class_="tgme_widget_message_bubble")
        
@@ -19,24 +34,54 @@ def scrape_monkrus_telegram(query):
        
        for bubble in bubbles:
            post_txt = bubble.find("div", class_="tgme_widget_message_text js-message_text")
-            if not post_txt or not post_txt.b:
+            if post_txt is None or post_txt.b is None:
                continue
            
            title = post_txt.b.text
            link = bubble.find("a", href=lambda x: x and x.startswith("https://uztracker.net"))
            
-            if query.lower() in title.lower() and link:
+            if link:
                post_url = link["href"]
                if post_url not in added:
                    added.add(post_url)
                    posts.append(dict(
+                        title=title,
                        author="m0nkrus",
                        id=len(posts) + 1,
-                        title=title,
                        url=post_url
                    ))
        
        post += 22

    posts.reverse()
+
+    cache["data"] = posts
+    cache["last_fetched"] = current_time
+
    return(posts)
+
+def scrape_m0nkrus(query):
+    posts = _get_telegram_posts()
+    filtered_posts = []
+
+    for post in posts:
+        if query.lower() in post["title"].lower():
+            filtered_post = post.copy()
+            filtered_post["id"] = len(filtered_posts) + 1
+            filtered_posts.append(filtered_post)
+
+    return filtered_posts
+
+def get_magnet(post: Dict):
+    return get_magnet_link(post["url"])
+
+Metadata = {
+    "name" : "m0nkrus",
+    "headers" : ["Post Title", "Author"],
+    "scrapeFunc" : scrape_m0nkrus,
+    "linkFunc" : get_magnet,
+    "isMagnet" : True,
+}
+
+def init_m0nkrus():
+    state.trackers.update({Metadata["name"] : Metadata})
@@ -0,0 +1,18 @@
+import requests
+
+def scrape_buzzheavier(url):
+
+    response = requests.get(url)
+    response.raise_for_status()
+
+    download_url = url + '/download'
+
+    headers = {
+        'hx-current-url': url,
+        'hx-request': 'true',
+        'referer': url
+    }
+    
+    head_response = requests.head(download_url, headers=headers, allow_redirects=False)
+    hx_redirect = head_response.headers.get('hx-redirect')
+    return hx_redirect
@@ -0,0 +1,31 @@
+from core.utils.logging.loghandler import consoleLog
+import requests
+import re
+
+
+def scrape_gofile(url):
+
+    filetoken = re.findall(r"(?<=https...gofile.io\/d\/).*", url)[0]
+    session = requests.Session()
+
+    acc = session.post("https://api.gofile.io/accounts")
+    token = acc.json()["data"]["token"]
+
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "X-Website-Token": "4fd6sg89d7s6", # Maybe make this dynamic in the future
+    }
+
+    r = session.get(
+        f"https://api.gofile.io/contents/{filetoken}",
+        headers=headers,
+    )
+    try:
+
+        temp: dict = r.json()["data"]["children"]
+        child = [key for key in temp.keys()]
+
+        return temp[child[0]]["link"]
+    except:
+        consoleLog("gofile didnt auth you, either the api has changed\n or you sent to many requests, please try again later.\n If it still doesnt work please open an issue on Github.")
+
@@ -1,21 +1,52 @@
 import requests
 from core.utils.data.state import state
-from core.utils.general.logs import consoleLog
+from core.utils.logging.logs import consoleLog
+from core.utils.data.tracker import get_magnet_link
+from core.utils.network.jsonhandler import split_data, format_data
+from typing import Dict

-
-def scrape_rutracker(search_text):
-    search = requests.get(f"{state.api_url}/search?q={search_text}")
+def scrape_rutracker(query):
+    search = requests.get(f"{state.api_url}/search?q={query}", timeout=15)
    consoleLog("Sent request to server")
    if search:
-        try:
-            return search.text
-        except Exception:
-            consoleLog("No results found / No response from server")
-            return None
+        _, data, _, success, cached = split_data(search.text)
+        if cached:
+            consoleLog("Server response cached")
+        if success:
+            sorted_data = []

+            for entry in data:
+                sorted_data.append(
+                    {
+                        "title" : entry["title"],
+                        "author" : entry["author"],
+                        "seeders" : entry["seeders"],
+                        "leechers" : entry["leechers"],
+                        "url" : entry["url"],
+                        "id" : entry["id"],
+                    }
+                )
+
+            return sorted_data
+        else: 
+            consoleLog("Scraping failed server-side, unable to fetch posts from rutracker")
+            return []
    else:
-        return None
-        
+        consoleLog("No response from server, returning nothing")
+        return []


-# This function utilizes the SoftwareManager server - source code can be found under the "server" branch.
+def get_magnet(post: Dict):
+    _, post_links, _, _, _ = format_data([post])
+    return get_magnet_link(post_links[0])
+
+Metadata = {
+    "name" : "rutracker",
+    "headers" : ["Post Title", "Author", "Seeders", "Leechers"],
+    "scrapeFunc" : scrape_rutracker,
+    "linkFunc" : get_magnet,
+    "isMagnet" : True,
+}
+
+def init_rutracker():
+    state.trackers.update({Metadata["name"] : Metadata})
@@ -0,0 +1,123 @@
+from core.data.scrapers.provider.buzzheavier import scrape_buzzheavier
+from core.data.scrapers.provider.gofile import scrape_gofile
+from core.utils.logging.logs import consoleLog
+from core.utils.data.state import state
+from bs4 import BeautifulSoup
+from typing import Dict
+import webbrowser
+import requests
+import re
+import time
+
+cache = {
+    "data": [],
+    "last_fetched": 0
+}
+
+cache_expiry = 300
+
+def get_Metadata():
+    return Metadata
+
+def scrape_steamrip_links():
+    
+    current_time = time.time()
+
+    if cache["data"] != [] and (current_time - cache["last_fetched"] < cache_expiry):
+        return cache["data"]
+
+    url = f"https://steamrip.com/games-list-page/"
+    response = requests.get(url)
+    text = response.text
+
+    soup = BeautifulSoup(text, "html.parser")
+    games = soup.find_all("li", class_="az-list-item")
+    
+    if len(games) == 0:
+        return []
+
+    links = []
+    names = []
+    for gamehtml in games:
+        link = gamehtml.find("a", href=lambda x: x and x.startswith("/"))
+        links += re.findall(r'(?<=href=")[^"]*', link.__str__())
+        name = gamehtml.find("a", href=lambda x: x and x.startswith("/"))
+        names += re.findall(r'(?<=\/">)[^<]*', name.__str__())
+
+
+
+    # construct the list[dict[str,str]]
+
+    ret = []
+
+    for i in range(len(names)):
+        ret.append({"title" : names[i], "url" : links[i]})
+
+    return ret
+
+def scrape_steamrip_game_downloads(gamelink):
+    url = "https://steamrip.com" + gamelink
+    response = requests.get(url)
+    soup = BeautifulSoup(response.text, "html.parser")
+    download_link_elements = soup.find_all("a",class_="shortc-button")
+    download_links = ["buzzheavier", "gofile"]
+
+    for download_link in download_link_elements:
+        pure = download_link.attrs.get("href")
+        if pure[2] == "b":
+            download_links[0] = "https:" + pure
+        if pure[2] == "g":
+            download_links[1] = "https:" + pure
+        if pure[2] == "v":
+            download_links[2] = "https:" + pure
+        if pure[2] == "m":
+            download_links[3] = "https:" + pure
+
+    ret = []
+
+    for link in download_links:
+        if len(link) != 1:
+            ret.append(link)
+
+    cache["data"] = ret
+
+    return ret
+
+def get_download_link(post: Dict):
+    url = post["url"]
+    links = scrape_steamrip_game_downloads(url)
+    best = ""
+    for link in links:
+        if link[0] == "h":
+            best = link
+            break
+
+    if links.index(best) == 0:
+        return scrape_buzzheavier(best)
+    elif links.index(best) == 1:
+        return scrape_gofile(best)
+    else:
+        consoleLog("Unable to retrieve download link due to captcha, launching browser...")
+        webbrowser.open(best)
+        return None
+
+def filter_steamrip(query: str):
+    games = scrape_steamrip_links()
+    
+    filtered_games = [
+        game for game in games 
+        if query.lower() in game["title"].lower()
+    ]
+    
+    return filtered_games
+
+Metadata = {
+    "name" : "steamrip",
+    "headers" : ["Game"],
+    "scrapeFunc" : filter_steamrip,
+    "linkFunc" : get_download_link,
+    "isMagnet" : False,
+}
+
+def init_steamrip():
+    state.trackers.update({Metadata["name"] : Metadata})
@@ -1,84 +1,55 @@
 import requests
-import asyncio
-import threading
 from bs4 import BeautifulSoup
+from urllib.parse import urljoin
+from core.utils.logging.logs import consoleLog
 from core.utils.data.state import state
-from core.utils.general.logs import consoleLog
-from core.utils.general.wrappers import run_thread
+from core.utils.data.tracker import get_magnet_link
+from typing import Dict


-global url_uztracker
-url_uztracker = "https://uztracker.net/tracker.php?nm="
+def scrape_uztracker(query):
+    base_url="https://uztracker.net/"
+    search_url = f"{base_url.rstrip('/')}/tracker.php?nm={query}"
+    consoleLog(search_url)
+    posts = []
+
+    try:
+        response = requests.get(search_url)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.text, 'html.parser')
+        links = soup.find_all('tr', class_="tCenter hl-tr", id=lambda x: x and x.startswith('tor_'))
+        for link in links:
+
+            theme_link = link.find('a', class_="genmed tLink", href=lambda x: x and x.startswith('./viewtopic'))
+            if not theme_link or not theme_link.b:
+                continue
+            url = urljoin(base_url, theme_link['href'])
+            title = theme_link.b.text
+            author_link = link.find('a', class_="med")
+            author = author_link.text.strip() if author_link else "Unknown"
+
+            posts.append(dict(
+                title=title,
+                author=author,
+                url=url,
+            ))
+
+        return posts
+
+    except requests.RequestException as e:
+        consoleLog(f"Failed to fetch {search_url}: {e}")
+        return None
+
+def get_magnet(post: Dict):
+    return get_magnet_link(post["url"])
+
+Metadata = {
+    "name" : "uztracker",
+    "headers" : ["Post Title", "Author"],
+    "scrapeFunc" : scrape_uztracker,
+    "linkFunc" : get_magnet,
+    "isMagnet" : True,
+}

 def init_uztracker():
-    global up
-    global soup
-    try:
-        response = requests.get(url_uztracker, timeout=10)
-        if response.status_code == 200:
-            up = True
-        else:
-            up = False
-            consoleLog(f"Uztracker seems down, status code: {response.status_code}")
-    except requests.exceptions.RequestException as e:
-        consoleLog(f"Request Exception on {url_uztracker}:")
-        consoleLog(str(e))
-        consoleLog("Is the Site down?")
-        up = False
-
-run_thread(threading.Thread(target=init_uztracker))
-
-def scrape_uztracker(search):
-    if up:
-        search_url = url_uztracker + search
-        consoleLog(search_url)
-        result = False
-        global results
-        global resulttitles
-        results = []
-        resulttitles = []
-
-        try:
-            resultCount = 0
-            response = requests.get(search_url)
-            response.raise_for_status()
-            soup = BeautifulSoup(response.text, 'html.parser')
-            links = soup.find_all('a', class_="genmed tLink", href=lambda x: x and x.startswith('./viewtopic'))
-            for link in links:
-                if link.b:
-                    resultCount += 1
-                    results.append(link['href'])
-                    resulttitles.append(link.b.text)
-                    result = True
-
-            if result:
-                return resulttitles, results
-
-            if not result:
-                # add popup in gui for no result
-                return None
-
-        except requests.RequestException as e:
-            if result:
-                consoleLog(f"Failed to fetch {search_url}: {e}")
-            return None
-    else:
-        consoleLog("Error: Uztracker down")
-        return None, None
-
-def get_post_title(post_url):
-    if up:
-        response = requests.get(post_url)
-        soup = BeautifulSoup(response.text, 'html.parser')
-        maintitle = soup.find(class_='tt-text')
-        if maintitle:
-            return maintitle.text
-        else:
-            consoleLog("Program not found")
-    else:
-        consoleLog("Error: Uztracker down")
-        return None   
-
-    
-
-
+    state.trackers.update({Metadata["name"] : Metadata})
@@ -1,10 +1,12 @@
 from core.utils.config.settings import save_settings
 from core.utils.data.state import state
-from core.utils.general.logs import consoleLog
+from core.utils.logging.logs import consoleLog
 from core.interface.utils.tabhelper import general_tab
 from core.interface.utils.tabhelper import paths_tab
 from core.interface.utils.tabhelper import network_tab
+from core.interface.utils.svghelper import svg_icon
 from PySide6 import QtWidgets
+from PySide6.QtCore import Qt, QSize
 from PySide6.QtWidgets import (
    QLineEdit, 
    QPushButton, 
@@ -21,6 +23,8 @@ from PySide6.QtWidgets import (
 )
 import platform

+SVG_FOLDER = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M2 6c0-1.1.9-2 2-2h5l2 2h7c1.1 0 2 .9 2 2v10c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6z" fill="{color}"/></svg>'
+

 def settings_dialog(self):

@@ -31,6 +35,9 @@ def settings_dialog(self):

        dialog.setLayout(QVBoxLayout())

+        if state.window_transparency and platform.system() != "Windows" and dialog:
+            dialog.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+
        def close_settings():
            dialog.reject()

@@ -47,7 +54,6 @@ def settings_dialog(self):
            update_checkbox.setChecked(state.ignore_updates)
            update_checkbox.toggled.connect(lambda checked: setattr(state, 'ignore_updates', checked))
            update_checkbox_layout.addWidget(update_checkbox)
-            dialog.layout().addWidget(update_checkbox_container)

        # auto-resume downloads checkbox

@@ -109,7 +115,19 @@ def settings_dialog(self):
            if dir_path:
                download_path.setText(dir_path)

-        browse_button = QPushButton("📁")
+        browse_button = QPushButton()
+        browse_button.setFixedSize(36, 36)
+        browse_button.setIconSize(QSize(24, 24))
+        browse_button.setIcon(svg_icon(SVG_FOLDER, 24))
+        browse_button.setCursor(Qt.CursorShape.PointingHandCursor)
+        browse_button.setStyleSheet("""
+            QPushButton {
+                border: none;
+                background: transparent;
+                padding: 0px;
+            }
+        """)
+
        download_path_layout.addWidget(browse_button)
        browse_button.clicked.connect(browse_download_path)

@@ -121,7 +139,7 @@ def settings_dialog(self):
        image_path_layout = QHBoxLayout()

        image_path = QLineEdit()
-        image_path_layout.addWidget(QLabel("Image Path (requires restart):"))
+        image_path_layout.addWidget(QLabel("Image Path (requires restart, experimental):"))
        image_path_layout.addWidget(image_path)
        image_path_container.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
        image_path_container.setLayout(image_path_layout)
@@ -132,7 +150,18 @@ def settings_dialog(self):
            if file_path:
                image_path.setText(file_path)

-        browse_button = QPushButton("📁")
+        browse_button = QPushButton()
+        browse_button.setFixedSize(36, 36)
+        browse_button.setIconSize(QSize(24, 24))
+        browse_button.setIcon(svg_icon(SVG_FOLDER, 24))
+        browse_button.setCursor(Qt.CursorShape.PointingHandCursor)
+        browse_button.setStyleSheet("""
+            QPushButton {
+                border: none;
+                background: transparent;
+                padding: 0px;
+            }
+        """)
        image_path_layout.addWidget(browse_button)
        browse_button.clicked.connect(browse_image_path)

@@ -220,8 +249,6 @@ def settings_dialog(self):
        else:
            interface_select.setCurrentIndex(0)

-        interface_select.setFixedWidth(180)
-        interface_select.setFixedHeight(30)
        interface_select.setFixedWidth(180)
        interface_select.setFixedHeight(30)
        interface_layout.addWidget(interface_select)
@@ -1,83 +1,27 @@
-from PySide6.QtWidgets import QTableWidgetItem
-from core.utils.general.logs import consoleLog
-from core.data.scrapers.uztracker import scrape_uztracker
-from core.data.scrapers.rutracker import scrape_rutracker
-from core.data.scrapers.monkrus import scrape_monkrus_telegram
-from core.utils.network.jsonhandler import split_data, format_data, format_data_m0nkrus
+from PySide6.QtWidgets import QTableWidgetItem, QHeaderView
+from core.utils.logging.logs import consoleLog
+from core.data.scrapers.rutracker import init_rutracker
+from core.data.scrapers.uztracker import init_uztracker
+from core.data.scrapers.monkrus import init_m0nkrus
+from core.data.scrapers.steamrip import init_steamrip
 from core.utils.data.state import state

+init_rutracker()
+init_uztracker()
+init_m0nkrus()
+init_steamrip()
+
 def return_pressed(self):
+    self.show_empty_results(False)
    search_text = self.searchbar.text()
    if search_text == "":
        consoleLog("Error: Can't search for nothing")
        return
    consoleLog(f"User searched for: {search_text}")
    
-    if state.tracker == "uztracker":
-        response = scrape_uztracker(search_text)
-        if response:
-            state.post_titles, state.post_urls = response
-            self.qtablewidget.clear()
-            if state.post_titles and len(state.post_titles) > 0:
-                self.qtablewidget.setHorizontalHeaderLabels(["Post Title", "Author"])
-                self.qtablewidget.setRowCount(len(state.post_titles))
-                for i, author in enumerate(state.post_author):
-                    self.qtablewidget.setItem(i, 1, QTableWidgetItem(author))
-                for i, title in enumerate(state.post_titles):
-                    self.qtablewidget.setItem(i, 0, QTableWidgetItem(title))
-                self.show_empty_results(False)
-            else:
-                consoleLog(f"No Results for {search_text}")
-                self.qtablewidget.clear()
-                self.show_empty_results(True)
-        else:
-            consoleLog(f"No response from uztracker")
-            self.qtablewidget.clear()
-            self.show_empty_results(True)
-    
-    elif state.tracker == "rutracker":
-        response = scrape_rutracker(search_text)
-        if response:
-            _, state.posts, _, _, cached = split_data(response)
-            if state.posts == []:
-                consoleLog(f"No Results for {search_text}")
-                self.qtablewidget.clear()
-                self.show_empty_results(True)
-            else:
-                state.post_titles, _, state.post_author, state.post_seeders, state.post_leechers = format_data(state.posts)
-                self.show_empty_results(False)
-                self.qtablewidget.clear()
-                self.qtablewidget.setHorizontalHeaderLabels(["Post Title", "Author", "Seeders", "Leechers"])
-                self.qtablewidget.setRowCount(len(state.post_titles))
-                for i, author in enumerate(state.post_author):
-                    self.qtablewidget.setItem(i, 1, QTableWidgetItem(author))
-                for i, title in enumerate(state.post_titles):
-                    self.qtablewidget.setItem(i, 0, QTableWidgetItem(title))
-                for i, seeders in enumerate(state.post_seeders):
-                    self.qtablewidget.setItem(i, 2, QTableWidgetItem(seeders))
-                for i, leechers in enumerate(state.post_leechers):
-                    self.qtablewidget.setItem(i, 3, QTableWidgetItem(leechers))
-                if state.debug == True:
-                    consoleLog(f"Response Cached: {cached}")
-        else:
-            consoleLog(f"No response from rutracker")
-            self.qtablewidget.clear()
-            self.show_empty_results(True)
+    tracker = state.trackers[state.currenttracker]
+    scrapefunc = tracker["scrapeFunc"]
+    state.posts = scrapefunc(search_text)

-    elif state.tracker == "m0nkrus":
-        state.posts = scrape_monkrus_telegram(search_text)
-
-        if state.posts == []:
-            consoleLog(f"No Results for {search_text}")
-            self.qtablewidget.clear()
-            self.show_empty_results(True)
-        else:
-            state.post_titles, _, state.post_author = format_data_m0nkrus(state.posts)
-            self.show_empty_results(False)
-            self.qtablewidget.clear()
-            self.qtablewidget.setHorizontalHeaderLabels(["Post Title", "Author"])
-            self.qtablewidget.setRowCount(len(state.post_titles))
-            for i, author in enumerate(state.post_author):
-                self.qtablewidget.setItem(i, 1, QTableWidgetItem(author))
-            for i, title in enumerate(state.post_titles):
-                self.qtablewidget.setItem(i, 0, QTableWidgetItem(title))
+    from core.interface.gui import MainWindow
+    MainWindow._instance.search_results_signal.emit(tracker["headers"])
@@ -0,0 +1,30 @@
+
+
+from PySide6 import QtWidgets
+from PySide6.QtCore import Qt, QByteArray
+from PySide6.QtGui import QIcon, QPixmap, QPainter
+from PySide6.QtSvg import QSvgRenderer
+import darkdetect
+
+
+def _is_dark_mode():
+    return darkdetect.isDark()
+
+
+def svg_icon(svg_str, size=20):
+    app = QtWidgets.QApplication.instance()
+    if app:
+        if _is_dark_mode():
+            color = "white"
+        else:
+            color = "#555555"
+    else:
+        color = "white"
+    svg = svg_str.replace("{color}", color)
+    renderer = QSvgRenderer(QByteArray(svg.encode()))
+    pixmap = QPixmap(size, size)
+    pixmap.fill(Qt.GlobalColor.transparent)
+    painter = QPainter(pixmap)
+    renderer.render(painter)
+    painter.end()
+    return QIcon(pixmap)
@@ -0,0 +1,31 @@
+from typing import Optional
+from core.utils.data.state import state
+from core.utils.logging.logs import consoleLog, add_download_log
+
+from .handle import DirectDownloadHandle
+from .utils import (
+    sanitize_filename,
+    extract_filename_from_url,
+    detect_filename_from_headers,
+)
+
+def add_direct_download(url: str, title: str, dl_path: Optional[str] = None):
+
+    if dl_path is None:
+        dl_path = state.download_path
+
+    if url in state.active_downloads:
+        consoleLog(f"Download already active: {title}")
+        return
+
+    filename = (
+        detect_filename_from_headers(url, DirectDownloadHandle.USER_AGENT)
+        or extract_filename_from_url(url)
+        or sanitize_filename(title) + ".zip"
+    )
+
+    handle = DirectDownloadHandle(url, filename, dl_path)
+    state.active_downloads[url] = handle
+    add_download_log(title, url, "", False)
+    handle.start()
+    consoleLog(f"Started direct download: {filename}")
@@ -0,0 +1,443 @@
+import os
+import threading
+import requests
+import json
+import hashlib
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Optional
+import libtorrent as lt
+
+from core.utils.logging.logs import consoleLog, update_download_completed
+from core.utils.data.state import state
+from .status import DirectDownloadStatus, ChunkSpec
+from .utils import format_size
+
+class SimpleThrottler:
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._last_time = time.monotonic()
+        self._allowance = 0.0
+
+    def throttle(self, bytes_count: int, limit_kbps: int):
+        if limit_kbps <= 0:
+            return
+
+        limit_bps = limit_kbps * 1024
+        wait_time = 0
+        with self._lock:
+            now = time.monotonic()
+            elapsed = now - self._last_time
+            self._last_time = now
+            
+            self._allowance += elapsed * limit_bps
+            if self._allowance > 2 * limit_bps:
+                self._allowance = 2 * limit_bps
+                
+            self._allowance -= bytes_count
+            
+            if self._allowance < 0:
+                wait_time = -self._allowance / limit_bps
+                self._allowance = 0
+        
+        if wait_time > 0:
+            time.sleep(min(wait_time, 1.0))
+
+_throttler = SimpleThrottler()
+
+class DirectDownloadHandle:
+    STREAM_BLOCK_SIZE = 1 << 17  # 128 KiB per read
+    MAX_RETRIES = 5
+    RETRY_BACKOFF_BASE = 2.0
+    NUM_THREADS = 16
+    MIN_CHUNK_SIZE = 1 << 20  # 1 MiB minimum per chunk
+    REQUEST_TIMEOUT = (15, 60)  # (connect, read) timeouts
+    USER_AGENT = (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/125.0.0.0 Safari/537.36"
+    )
+
+    def __init__(self, url: str, name: str, save_path: str):
+        self.url = url
+        self._name = name
+        self._save_path = save_path
+        self._file_path = os.path.join(save_path, name)
+        self._status = DirectDownloadStatus(name, save_path, 0)
+        self._stop_event = threading.Event()
+        self._pause_event = threading.Event()  # SET = paused
+        self._thread: Optional[threading.Thread] = None
+        self._session: Optional[requests.Session] = None
+        self._supports_range = False
+        
+        state_dir = os.path.join(state.settings_path, "direct_downloads")
+        os.makedirs(state_dir, exist_ok=True)
+        url_hash = hashlib.sha256(url.encode()).hexdigest()
+        self._state_file = os.path.join(state_dir, f"{url_hash}.json")
+        
+        # Load state to initialize progress
+        state_data = self._load_state()
+        if state_data:
+            total_wanted = state_data.get("total_wanted", 0)
+            chunks_progress = state_data.get("chunks", {})
+            chunks_progress = {int(k): int(v) for k, v in chunks_progress.items()}
+            self._status.initialize_progress(total_wanted, chunks_progress)
+
+
+    def status(self) -> DirectDownloadStatus:
+        return self._status
+
+    def pause(self):
+        self._status.paused = True
+        self._pause_event.set()
+
+    def resume(self):
+        self._status.paused = False
+        self._pause_event.clear()
+
+    def set_flags(self, flags):
+        if flags & lt.torrent_flags.auto_managed:
+            self._status.auto_managed = True
+
+    def unset_flags(self, flags):
+        if flags & lt.torrent_flags.auto_managed:
+            self._status.auto_managed = False
+
+    def save_path(self) -> str:
+        return self._save_path
+
+    def stop(self):
+        self._stop_event.set()
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=10)
+
+
+    def _load_state(self) -> dict:
+        if os.path.exists(self._state_file):
+            try:
+                with open(self._state_file, "r") as f:
+                    return json.load(f)
+            except Exception as e:
+                consoleLog(f"Failed to load state for {self._name}: {e}")
+        return {}
+
+    def _save_state(self, chunks_done: dict[int, int]):
+        try:
+            with open(self._state_file, "w") as f:
+                json.dump({
+                    "url": self.url,
+                    "name": self._name,
+                    "save_path": self._save_path,
+                    "total_wanted": self._status.total_wanted,
+                    "chunks": chunks_done
+                }, f)
+        except Exception as e:
+            pass
+
+    def _clear_state(self):
+        if os.path.exists(self._state_file):
+            try:
+                os.remove(self._state_file)
+            except Exception:
+                pass
+
+
+    def start(self):
+        self._thread = threading.Thread(
+            target=self._download_orchestrator, name=f"dl-{self._name}", daemon=True
+        )
+        self._thread.start()
+
+    def _build_session(self) -> requests.Session:
+        session = requests.Session()
+        session.headers.update({"User-Agent": self.USER_AGENT})
+        adapter = requests.adapters.HTTPAdapter(
+            max_retries=0,
+            pool_connections=self.NUM_THREADS,
+            pool_maxsize=self.NUM_THREADS + 2,
+        )
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+        return session
+
+    def _probe_url(self, session: requests.Session) -> tuple[int, bool]:
+        resp = session.head(self.url, allow_redirects=True, timeout=self.REQUEST_TIMEOUT)
+        resp.raise_for_status()
+
+        total_size = int(resp.headers.get("content-length", 0))
+        supports_range = (total_size > 0)
+
+        # Double-check range support with a small range request
+        if supports_range:
+            try:
+                test = session.get(
+                    self.url,
+                    headers={"Range": "bytes=0-0"},
+                    timeout=self.REQUEST_TIMEOUT,
+                    stream=True,
+                )
+                supports_range = test.status_code == 206
+                test.close()
+            except Exception:
+                supports_range = False
+
+        return total_size, supports_range
+
+    def _download_orchestrator(self):
+        try:
+            self._session = self._build_session()
+            total_size, self._supports_range = self._probe_url(self._session)
+            self._status.total_wanted = total_size
+
+            os.makedirs(self._save_path, exist_ok=True)
+
+            use_multithreaded = (
+                self._supports_range
+                and total_size > self.MIN_CHUNK_SIZE * 2
+            )
+
+            if use_multithreaded:
+                consoleLog(
+                    f"Multi-threaded download ({self.NUM_THREADS} threads): {self._name} "
+                    f"({format_size(total_size)})"
+                )
+                self._preallocate_file(total_size)
+                self._multithreaded_download(total_size)
+            else:
+                reason = "no range support" if not self._supports_range else "file too small"
+                consoleLog(f"Single-threaded download ({reason}): {self._name}")
+                self._single_threaded_download()
+
+            if not self._stop_event.is_set() and self._status.error is None:
+                self._verify_download(total_size)
+                self._status.mark_completed()
+                update_download_completed(self.url, True)
+                self._clear_state()
+                consoleLog(f"Finished downloading {self._name}")
+
+        except Exception as e:
+            self._status.mark_error(str(e))
+            consoleLog(f"Download failed for {self._name}: {e}")
+        finally:
+            if self._session:
+                self._session.close()
+
+
+    def _preallocate_file(self, total_size: int):
+        if os.path.exists(self._file_path) and os.path.getsize(self._file_path) == total_size:
+            return
+        with open(self._file_path, "wb") as f:
+            f.truncate(total_size)
+
+    def _compute_chunks(self, total_size: int) -> list[ChunkSpec]:
+        num_chunks = min(self.NUM_THREADS, max(1, total_size // self.MIN_CHUNK_SIZE))
+        chunk_size = total_size // num_chunks
+        chunks = []
+        for i in range(num_chunks):
+            start = i * chunk_size
+            end = (i + 1) * chunk_size - 1 if i < num_chunks - 1 else total_size - 1
+            chunks.append(ChunkSpec(chunk_id=i, start=start, end=end))
+        return chunks
+
+    def _multithreaded_download(self, total_size: int):
+        chunks = self._compute_chunks(total_size)
+        state_data = self._load_state()
+        chunks_progress = state_data.get("chunks", {})
+        
+        chunks_progress = {int(k): int(v) for k, v in chunks_progress.items()}
+
+        # Initialize progress in status
+        for chunk_id, bytes_done in chunks_progress.items():
+            self._status.update_chunk_progress(chunk_id, bytes_done)
+
+        with ThreadPoolExecutor(
+            max_workers=len(chunks), thread_name_prefix="dl-chunk"
+        ) as executor:
+            futures = {
+                executor.submit(self._download_chunk_with_retry, chunk, chunks_progress.get(chunk.chunk_id, 0)): chunk
+                for chunk in chunks
+            }
+
+            for future in as_completed(futures):
+                chunk = futures[future]
+                try:
+                    future.result()
+                except Exception as e:
+                    consoleLog(
+                        f"Chunk {chunk.chunk_id} ({chunk.start}-{chunk.end}) "
+                        f"failed permanently: {e}"
+                    )
+                    self._status.mark_error(
+                        f"Chunk {chunk.chunk_id} failed: {e}"
+                    )
+                    self._stop_event.set()
+
+    def _download_chunk_with_retry(self, chunk: ChunkSpec, initial_bytes: int):
+        bytes_written = initial_bytes
+
+        for attempt in range(1, self.MAX_RETRIES + 1):
+            if self._stop_event.is_set():
+                return
+
+            current_start = chunk.start + bytes_written
+            if current_start > chunk.end:
+                return
+
+            try:
+                # _download_range returns new bytes written
+                bytes_written += self._download_range(
+                    chunk.chunk_id, current_start, chunk.end, bytes_written
+                )
+                return
+            except Exception as e:
+                if self._stop_event.is_set():
+                    return
+                if attempt < self.MAX_RETRIES:
+                    wait = self.RETRY_BACKOFF_BASE ** attempt
+                    consoleLog(
+                        f"Chunk {chunk.chunk_id} attempt {attempt} failed: {e}. "
+                        f"Retrying in {wait:.0f}s (resuming from byte {current_start})..."
+                    )
+                    if self._stop_event.wait(timeout=wait):
+                        return
+                else:
+                    raise RuntimeError(
+                        f"Chunk {chunk.chunk_id} failed after {self.MAX_RETRIES} attempts: {e}"
+                    ) from e
+
+    def _download_range(
+        self, chunk_id: int, start: int, end: int, prior_bytes: int
+    ) -> int:
+
+        headers = {"Range": f"bytes={start}-{end}"}
+        new_bytes = 0
+
+        with self._session.get(
+            self.url, headers=headers, stream=True, timeout=self.REQUEST_TIMEOUT
+        ) as resp:
+            resp.raise_for_status()
+            if resp.status_code not in (200, 206):
+                raise RuntimeError(f"Unexpected status {resp.status_code}")
+
+            with open(self._file_path, "r+b") as f:
+                f.seek(start)
+                for block in resp.iter_content(chunk_size=self.STREAM_BLOCK_SIZE):
+                    if self._stop_event.is_set():
+                        return new_bytes
+
+                    self._wait_if_paused()
+                    if self._stop_event.is_set():
+                        return new_bytes
+
+                    _throttler.throttle(len(block), state.down_speed_limit)
+
+                    f.write(block)
+                    new_bytes += len(block)
+                    self._status.update_chunk_progress(
+                        chunk_id, prior_bytes + new_bytes
+                    )
+                    
+
+                    if new_bytes % (1024 * 1024) < len(block):
+
+                        with self._status._lock:
+                            self._save_state(self._status._chunk_bytes)
+
+        with self._status._lock:
+            self._save_state(self._status._chunk_bytes)
+            
+        return new_bytes
+
+
+    def _single_threaded_download(self):
+        chunk_id = 0
+        bytes_written = 0
+        
+        if os.path.exists(self._file_path):
+            bytes_written = os.path.getsize(self._file_path)
+            if bytes_written > 0:
+                self._status.update_chunk_progress(chunk_id, bytes_written)
+
+        for attempt in range(1, self.MAX_RETRIES + 1):
+            if self._stop_event.is_set():
+                return
+
+            try:
+                headers = {}
+                mode = "wb"
+
+                if bytes_written > 0 and self._supports_range:
+                    headers["Range"] = f"bytes={bytes_written}-"
+                    mode = "r+b"
+                elif bytes_written > 0:
+                    bytes_written = 0
+                    mode = "wb"
+
+                with self._session.get(
+                    self.url, headers=headers, stream=True, timeout=self.REQUEST_TIMEOUT
+                ) as resp:
+                    resp.raise_for_status()
+
+                    if self._status.total_wanted == 0:
+                        content_length = int(resp.headers.get("content-length", 0))
+                        self._status.total_wanted = content_length + bytes_written
+
+                    with open(self._file_path, mode) as f:
+                        if mode == "r+b":
+                            f.seek(bytes_written)
+
+                        for block in resp.iter_content(
+                            chunk_size=self.STREAM_BLOCK_SIZE
+                        ):
+                            if self._stop_event.is_set():
+                                return
+
+                            self._wait_if_paused()
+                            if self._stop_event.is_set():
+                                return
+
+                            _throttler.throttle(len(block), state.down_speed_limit)
+
+                            f.write(block)
+                            bytes_written += len(block)
+                            self._status.update_chunk_progress(chunk_id, bytes_written)
+                            
+                            # Periodic state save (single thread, chunk_id=0)
+                            if bytes_written % (1024 * 1024) < len(block):
+                                self._save_state({0: bytes_written})
+
+                self._save_state({0: bytes_written})
+                return
+
+            except Exception as e:
+                if self._stop_event.is_set():
+                    return
+                if attempt < self.MAX_RETRIES:
+                    wait = self.RETRY_BACKOFF_BASE ** attempt
+                    consoleLog(
+                        f"Download attempt {attempt} failed: {e}. "
+                        f"Retrying in {wait:.0f}s..."
+                    )
+                    if self._stop_event.wait(timeout=wait):
+                        return
+                else:
+                    raise RuntimeError(
+                        f"Download failed after {self.MAX_RETRIES} attempts: {e}"
+                    ) from e
+
+
+    def _wait_if_paused(self):
+        while self._pause_event.is_set():
+            if self._stop_event.wait(timeout=0.5):
+                return
+
+    def _verify_download(self, expected_size: int):
+        if expected_size <= 0:
+            return
+        actual_size = os.path.getsize(self._file_path)
+        if actual_size != expected_size:
+            raise RuntimeError(
+                f"Size mismatch: expected {format_size(expected_size)}, "
+                f"got {format_size(actual_size)}"
+            )
+
@@ -0,0 +1,96 @@
+import threading
+import time
+from dataclasses import dataclass
+from typing import Optional
+import libtorrent as lt
+
+
+@dataclass
+class ChunkSpec:
+    chunk_id: int
+    start: int
+    end: int  # inclusive
+
+
+class DirectDownloadStatus:
+
+    def __init__(self, name: str, save_path: str, total_size: int = 0):
+        self.name = name
+        self.save_path = save_path
+        self.total_wanted = total_size
+        self.paused = False
+        self.auto_managed = True
+        self.has_metadata = True
+        self.state = lt.torrent_status.downloading
+        self.error: Optional[str] = None
+
+        self._lock = threading.Lock()
+        self._total_wanted_done = 0
+        self._progress = 0.0
+        self._download_rate = 0
+        self._upload_rate = 0
+
+        self._chunk_bytes: dict[int, int] = {}  
+        self._speed_window: list[tuple[float, int]] = [] 
+        self._speed_window_size = 3.0
+
+    @property
+    def total_wanted_done(self) -> int:
+        with self._lock:
+            return self._total_wanted_done
+
+    @property
+    def progress(self) -> float:
+        with self._lock:
+            return self._progress
+
+    @property
+    def download_rate(self) -> int:
+        with self._lock:
+            return self._download_rate
+
+    @property
+    def upload_rate(self) -> int:
+        return 0
+
+    def update_chunk_progress(self, chunk_id: int, bytes_downloaded: int):
+        with self._lock:
+            self._chunk_bytes[chunk_id] = bytes_downloaded
+            self._total_wanted_done = sum(self._chunk_bytes.values())
+            if self.total_wanted > 0:
+                self._progress = min(self._total_wanted_done / self.total_wanted, 1.0)
+
+
+            now = time.monotonic()
+            self._speed_window.append((now, self._total_wanted_done))
+
+            cutoff = now - self._speed_window_size
+            self._speed_window = [
+                (t, b) for t, b in self._speed_window if t >= cutoff
+            ]
+            if len(self._speed_window) >= 2:
+                oldest_time, oldest_bytes = self._speed_window[0]
+                dt = now - oldest_time
+                if dt > 0:
+                    self._download_rate = int(
+                        (self._total_wanted_done - oldest_bytes) / dt
+                    )
+
+    def initialize_progress(self, total_wanted: int, chunk_bytes: dict[int, int]):
+        with self._lock:
+            self.total_wanted = total_wanted
+            self._chunk_bytes = chunk_bytes.copy()
+            self._total_wanted_done = sum(self._chunk_bytes.values())
+            if self.total_wanted > 0:
+                self._progress = min(self._total_wanted_done / self.total_wanted, 1.0)
+
+    def mark_completed(self):
+        with self._lock:
+            self.state = lt.torrent_status.seeding
+            self._progress = 1.0
+            self._download_rate = 0
+
+    def mark_error(self, error: str):
+        with self._lock:
+            self.error = error
+            self._download_rate = 0
@@ -0,0 +1,48 @@
+import os
+import requests
+from typing import Optional
+from urllib.parse import urlparse, unquote
+
+def sanitize_filename(name: str) -> str:
+    # Remove or replace dangerous characters
+    keepchars = (" ", ".", "_", "-")
+    cleaned = "".join(c for c in name if c.isalnum() or c in keepchars).strip()
+    while "  " in cleaned:
+        cleaned = cleaned.replace("  ", " ")
+    return cleaned or "download"
+
+
+def extract_filename_from_url(url: str) -> Optional[str]:
+    parsed = urlparse(url)
+    path = unquote(parsed.path)
+    basename = os.path.basename(path)
+    if basename and "." in basename and len(basename) < 256:
+        return basename
+    return None
+
+
+def detect_filename_from_headers(url: str, user_agent: str) -> Optional[str]:
+    try:
+        resp = requests.head(
+            url,
+            headers={"User-Agent": user_agent},
+            allow_redirects=True,
+            timeout=15,
+        )
+        cd = resp.headers.get("content-disposition", "")
+        if "filename=" in cd:
+            parts = cd.split("filename=")
+            if len(parts) > 1:
+                fname = parts[-1].strip().strip('"').strip("'")
+                if fname:
+                    return fname
+    except Exception:
+        pass
+    return None
+
+def format_size(size_bytes: int) -> str:
+    for unit in ("B", "KiB", "MiB", "GiB", "TiB"):
+        if abs(size_bytes) < 1024:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024
+    return f"{size_bytes:.1f} PiB"
@@ -1,25 +1,27 @@
-from core.utils.general.logs import consoleLog
+from core.utils.logging.logs import consoleLog
 from core.utils.data.state import state
 import psutil

-addrs = psutil.net_if_addrs()
-stats = psutil.net_if_stats()
-
 def get_net_interfaces():
+    addrs = psutil.net_if_addrs()
    for interface in addrs.keys():
        consoleLog(f"Found Interface: {interface}")
    return addrs.keys()


 def get_active_interfaces():
+    addrs = psutil.net_if_addrs()
+    stats = psutil.net_if_stats()
    active = []

    for interface, addr_list in addrs.items():
+        if interface not in stats:
+            continue
        up = stats[interface].isup
        for addr in addr_list:
            if addr.family == 2: # ipv4
                ipv4 = addr.address
-                if not ipv4.startswith("127.") and not ipv4.startswith("169.254") and up == True:
+                if not ipv4.startswith("127.") and not ipv4.startswith("169.254") and up:
                    active.append(interface)
                    consoleLog(f"Found Active: {interface}")

@@ -27,26 +29,31 @@ def get_active_interfaces():


 def list_interfaces() -> None:
+    addrs = psutil.net_if_addrs()
+    stats = psutil.net_if_stats()

    for interface, addr_list in addrs.items():
+        if interface not in stats:
+            continue
        up = stats[interface].isup
+        status = "INACTIVE"
        for addr in addr_list:
            if addr.family == 2: # ipv4
                ipv4 = addr.address
-                if not ipv4.startswith("127.") and not ipv4.startswith("169.254") and up == True:
+                if not ipv4.startswith("127.") and not ipv4.startswith("169.254") and up:
                    status = "ACTIVE"
-                else:
-                    status = "INACTIVE"
        consoleLog(f"Found Interface: {interface} [{status}]")

 def init_interfaces():
+    addrs = psutil.net_if_addrs()
    state.interfaces = list(addrs.keys())
    state.active_interfaces = get_active_interfaces()

 def get_interface_ip(interface_name):
+    addrs = psutil.net_if_addrs()
    if interface_name in addrs:
        for addr in addrs[interface_name]:
            if addr.family == 2:  # ipv4
                if not addr.address.startswith("127.") and not addr.address.startswith("169.254"):
                    return addr.address
-    return None
+    return None
@@ -1,15 +1,27 @@
 import time
+import os
+import platform
+import ctypes
 from core.utils.general.wrappers import run_thread
 from core.network.interface import get_interface_ip
 import threading
 import libtorrent as lt
 from core.utils.data.state import state
-from core.utils.general.logs import consoleLog
+from core.utils.logging.logs import consoleLog


 global loop_running
 loop_running = False

+def get_free_space_mb(dirname):
+    if platform.system() == 'Windows':
+        free_bytes = ctypes.c_ulonglong(0)
+        ctypes.windll.kernel32.GetDiskFreeSpaceExW(ctypes.c_wchar_p(dirname), None, None, ctypes.pointer(free_bytes))
+        return free_bytes.value
+    else:
+        st = os.statvfs(dirname)
+        return st.f_bavail * st.f_frsize
+
 def init_session():
    if state.dl_session is not None:
        return
@@ -18,8 +30,8 @@ def init_session():


    settings = {
-        "upload_rate_limit": state.up_speed_limit,
-        "download_rate_limit": state.down_speed_limit,
+        "upload_rate_limit": state.up_speed_limit * 1024,
+        "download_rate_limit": state.down_speed_limit * 1024,
        "enable_dht": True,
        "enable_lsd": True,
        "enable_upnp": True,
@@ -43,27 +55,91 @@ def init_session():
    consoleLog("Initialized Session")


-def add_download(magnet_uri, dl_path=state.download_path):
+def add_download(magnet_uri):

    if state.active_downloads is None:
        state.active_downloads = {}

    init_session()

+    free_space = get_free_space_mb(state.download_path)
+
    if magnet_uri in state.active_downloads:
-        consoleLog("Skipping Downloading, download already running...")
-        return
+        try:
+            handle = state.active_downloads[magnet_uri]
+            status = handle.status()

-    magnetdl = lt.parse_magnet_uri(magnet_uri)
-    magnetdl.save_path = dl_path
+            if status.has_metadata:
+                filepath = os.path.join(status.save_path, status.name)

-    download = state.dl_session.add_torrent(magnetdl)
-    state.active_downloads[magnet_uri] = download
+                if not os.path.exists(filepath):
+
+                    consoleLog(f"File Deleted, redownloading: {status.name}")
+                    state.dl_session.remove_torrent(handle)
+                    del state.active_downloads[magnet_uri]
+                else:
+                    consoleLog("Skipping Downloading, download already running...")
+                    return False
+            else:
+                consoleLog("Skipping Downloading, download already running... ")
+                return False
+        except RuntimeError as e:
+            consoleLog(f"Error in LibTorrent Handle: {e}")
+            del state.active_downloads[magnet_uri]
+
+    try:
+        params = lt.parse_magnet_uri(magnet_uri)
+        params.save_path = state.download_path
+
+        handle = state.dl_session.add_torrent(params)
+
+        while not handle.has_metadata():
+            time.sleep(1)
+
+        total_size = handle.get_torrent_info().total_size()
+
+        if free_space > total_size:
+            magnetdl = lt.parse_magnet_uri(magnet_uri)
+            magnetdl.save_path = state.download_path
+            download = state.dl_session.add_torrent(magnetdl)
+        else:
+            download = None
+            state.dl_session.remove_torrent(handle)
+            consoleLog("Not enough free space to download this item.")
+            return False
+
+    except Exception as e:
+        consoleLog(f"Failed to add torrent or fetch info: {e}")
+        return False
+    if download:
+        state.active_downloads[magnet_uri] = download
    consoleLog(f"Added {magnet_uri} to downloads")

    run_thread(threading.Thread(target=dl_status_loop))
+    return True


+def add_seed(magnet_uri, file_path):
+    if state.active_downloads is None:
+        state.active_downloads = {}
+
+    init_session()
+
+    if magnet_uri in state.active_downloads:
+        consoleLog("Already seeding this torrent")
+        return False
+
+    try:
+        magnetdl = lt.parse_magnet_uri(magnet_uri)
+        magnetdl.save_path = os.path.dirname(file_path)
+        handle = state.dl_session.add_torrent(magnetdl)
+    except Exception as e:
+        consoleLog(f"Failed to add seed: {e}")
+        return False
+    state.active_downloads[magnet_uri] = handle
+    state.seeded_magnets.add(magnet_uri)
+    return True
+

 def dl_status_loop():
    global loop_running
@@ -78,9 +154,12 @@ def dl_status_loop():
        loop_running = False
        return
    
-    while state.active_downloads:
+    while state.active_downloads and not state.shutdown_event.is_set():
        for magnet_uri, magnetdl in list(state.active_downloads.items()):
-            status = magnetdl.status()
+            try:
+                status = magnetdl.status()
+            except RuntimeError:
+                continue
            
            if status.state == lt.torrent_status.seeding and magnet_uri not in completed_set:
                consoleLog(f"Download completed: {status.name}")
@@ -101,8 +180,8 @@ def update_settings():
        return

    settings = {
-        "upload_rate_limit": state.up_speed_limit,
-        "download_rate_limit": state.down_speed_limit,
+        "upload_rate_limit": state.up_speed_limit * 1024,
+        "download_rate_limit": state.down_speed_limit * 1024,
        "connections_limit": state.max_connections,
        "active_downloads": state.max_downloads
    }
@@ -123,4 +202,3 @@ def update_bound_interface():
    settings = { "outgoing_interfaces": state.bound_interface }
    
    state.dl_session.apply_settings(settings)
-
@@ -1,8 +1,9 @@
 from core.utils.data.state import state
-from core.utils.general.logs import update_download_completed_by_hash
-from core.utils.general.logs import consoleLog
+from core.utils.logging.logs import update_download_completed_by_hash
+from core.utils.logging.logs import consoleLog
 from plyer import notification
 import libtorrent as lt
+import os
 import time


@@ -50,11 +51,34 @@ def update_log(shutdown_event):
                
                status = magnetdl.status()
                
-                if status.state == lt.torrent_status.seeding and magnet_uri not in updated:
+                if status.state == lt.torrent_status.seeding and magnet_uri not in updated and magnet_uri not in state.seeded_magnets:
                    consoleLog(f"Marking {status.name} as completed")
-                    info_hash = str(status.info_hash)
+                    if hasattr(status, 'info_hashes'):
+                        info_hash = str(status.info_hashes.v1)
+                    else:
+                        info_hash = str(status.info_hash)
                    update_download_completed_by_hash(info_hash, True)
                    updated.add(magnet_uri)
        except Exception:
            pass
+        time.sleep(5)
+
+def check_deleted_files(shutdown_event):
+    while not shutdown_event.is_set():
+        try:
+            for magnet_uri, magnetdl in list(state.active_downloads.items()):
+                if isinstance(magnetdl, dict):
+                    continue
+                
+                status = magnetdl.status()
+                
+                if status.state == lt.torrent_status.seeding and status.has_metadata:
+                    file_path = os.path.join(status.save_path, status.name)
+
+                    if not os.path.exists(file_path):
+                        consoleLog(f"Registered File Deletion: {status.name}")
+                        state.dl_session.remove_torrent(magnetdl)
+                        del state.active_downloads[magnet_uri]
+        except Exception:
+            pass
        time.sleep(5)
@@ -1,4 +1,4 @@
-from core.utils.general.logs import consoleLog
+from core.utils.logging.logs import consoleLog
 from core.network.libtorrent_int import add_download

 def add_magnet(uri):
@@ -1,7 +1,8 @@
-import os
-import platform
-import configparser
 from core.utils.data.state import state
+import configparser
+import platform
+import os
+

 def create_config():
    config = configparser.ConfigParser()
@@ -15,7 +16,7 @@ def create_config():

    config["Network"] = {
        "api_url": f"{state.api_url}",
-        "download_path": f"{state.download_path}",
+        "bound_interface": f"{state.bound_interface}" if state.bound_interface is not None else "None",
        "download_speed_limit": f"{state.down_speed_limit}",
        "upload_speed_limit": f"{state.up_speed_limit}",
        "max_connections": f"{state.max_connections}",
@@ -23,7 +24,7 @@ def create_config():
    }

    config["Paths"] = {
-        "bound_interface": f"{state.bound_interface}",
+        "download_path": f"{state.download_path}",
        "image_path": f"{state.image_path}"
    }

@@ -64,14 +65,16 @@ def read_config():

    # Network
    state.api_url = config.get("Network", "api_url", fallback=state.api_url)
-    state.download_path = config.get("Network", "download_path", fallback=state.download_path)
+    state.bound_interface = config.get("Network", "bound_interface", fallback=state.bound_interface)
+    if state.bound_interface == "None":
+        state.bound_interface = None
    state.down_speed_limit = config.getint("Network", "download_speed_limit", fallback=state.down_speed_limit)
    state.up_speed_limit = config.getint("Network", "upload_speed_limit", fallback=state.up_speed_limit)
    state.max_connections = config.getint("Network", "max_connections", fallback=state.max_connections)
    state.max_downloads = config.getint("Network", "max_downloads", fallback=state.max_downloads)

    # Paths
-    state.bound_interface = config.get("Paths", "bound_interface", fallback=state.bound_interface)
+    state.download_path = config.get("Paths", "download_path", fallback=state.download_path)
    state.image_path = config.get("Paths", "image_path", fallback=state.image_path)
-    
+
    create_config()
@@ -1,6 +1,6 @@
 from core.network.libtorrent_int import update_settings
 from core.utils.data.state import state
-from core.utils.general.logs import consoleLog
+from core.utils.logging.logs import consoleLog
 from .config import create_config


@@ -23,7 +23,6 @@ def save_settings(close=lambda: None, apiurl=None, download_path=None, down_spee
        state.max_downloads = max_downloads
    if bound_interface is not None:
        state.bound_interface = None if bound_interface == "None" else bound_interface
-    

    update_settings()
    consoleLog("Saved Settings")
@@ -7,6 +7,7 @@ class Download:
    title: str
    url: str
    magnet_uri: str
+    path: str
    completed: bool

@dataclass
@@ -1,5 +1,7 @@
+import threading
 from PySide6.QtCore import QObject, Signal
-from typing import Optional, Any, List, Dict
+from PySide6.QtWidgets import QTableWidget
+from typing import Any, List, Dict
 from pathlib import Path

 class AppState(QObject):
@@ -7,19 +9,26 @@ class AppState(QObject):

    def __init__(self):
        super().__init__()
-        self.posts: List[Dict[str, Any]] = []
-        self.post_titles: List[str] = []
-        self.post_urls: List[str] = []
-        self.post_author: List[str] = []
-        self.post_seeders: List[str] = []
-        self.post_leechers: List[str] = []
+        self.posts: list[Dict[str,str]] | None = None # titles, urls, author, seederm leecher
        self.version: str = "dev"
        self._image_path: str = ""
        self.ignore_updates: bool = False
        self.debug: bool = False
        self.autoresume: bool = True
-        self.tracker: str = "rutracker"
+
+        self.currenttracker: str = "rutracker"
+        self.trackertable: QTableWidget
+        self.trackers: Dict[str,Dict[str,Any]] = {} # each tracker should add itself here
+        '''
+        an example:
+        "rutracker" : {
+            "name" : "rutracker", # name of the tracker
+            "headers" : ["author", "title"], # keys shown in the table
+            "scrapeFunc" : function,
+        }
+        '''
        self.api_url: str = "https://api.michijackson.xyz"
+        self.seeded_magnets: set = set()
        self.download_path: str = str(Path.home() / "Downloads")
        self.up_speed_limit: int = 0
        self.down_speed_limit: int = 0
@@ -27,11 +36,16 @@ class AppState(QObject):
        self.max_downloads: int = 10
        self.settings_path: str = "" 
        self.dl_session: Any = None
-        self.active_downloads: List[str] = {}
+        self.active_downloads: Dict = {}
        self.window_transparency: bool = False
        self.interfaces: List = []
        self.active_interfaces: List = []
-        self.bound_interface: str = None
+        self.bound_interface: Any = None
+        self.log_buffer: List[str] = []
+        self.downloads_lock = threading.RLock()
+        self.main_window: Any = None
+        self.loop_running: bool = False
+        self.shutdown_event = threading.Event()

    @property
    def image_path(self) -> str:
@@ -1,36 +1,11 @@
 import requests
 from bs4 import BeautifulSoup
-from core.utils.data.state import state
-from core.utils.general.logs import consoleLog
-from core.utils.network.jsonhandler import format_data
-
-
-
-def get_item_url(item, posts, post_titles): # softwarelist currentitem, post list (dict), post titles list
-        post_index = post_titles.index(item)
-        if 0 <= post_index < len(post_titles): 
-            if state.tracker == "uztracker":
-                item = "https://uztracker.net/" + state.post_urls[post_index].lstrip("./")
-                consoleLog(f"Found post URL: {item}")
-                return item
-            if state.tracker == "rutracker":                
-                item_dict = posts[post_index]
-                _, post_links, _, _, _ = format_data([item_dict])
-                consoleLog(f"Found post URL: {post_links[0]}")
-                return post_links[0]
-            if state.tracker == "m0nkrus":                
-                item_dict = posts[post_index]
-                _, post_links, _, _, _,= format_data([item_dict])
-                consoleLog(f"Found post URL: {post_links[0]}")
-                return post_links[0]
-
-        return None
-
+from core.utils.logging.logs import consoleLog


 def get_magnet_link(post_url):
    try:
-        response = requests.get(post_url) # eventually impl. cloudscraper
+        response = requests.get(post_url, timeout=15) # eventually impl. cloudscraper
        consoleLog("Sent Request to retrieve Magnet Link...")
        response.raise_for_status()
        soup = BeautifulSoup(response.text, 'html.parser')
@@ -1,21 +0,0 @@
-from core.utils.general.logs import consoleLog
-from core.utils.network.download import run_download_direct
-
-def split_data(data):
-
-    count = data.count
-    downloads = data.data
-
-    return count, downloads
-
-def check_completed(downloads, resume):
-    for download in downloads:
-        if download.completed == False:
-            consoleLog(f"Found unfinished download: {download.title}")
-            if resume == True:
-                run_download_direct(download.magnet_uri)
-                consoleLog(f"Resuming {download.title}")
-
-            
-
-
@@ -1,9 +1,13 @@
-import threading
-from core.network.libtorrent_misc import cleanup_session
-from core.utils.general.wrappers import run_thread
-
-shutdown_event = threading.Event()
+from core.utils.data.state import state
+import os

 def closehelper():
-    run_thread(threading.Thread(target=cleanup_session))
-    shutdown_event.set()
+    state.shutdown_event.set()
+    try:
+        from core.network.libtorrent_misc import cleanup_session
+        cleanup_session()
+    except Exception:
+        pass
+
+def force_exit():
+    os._exit(0)
@@ -0,0 +1,37 @@
+from core.utils.logging.logs import consoleLog, remove_download_log
+from core.utils.network.download import run_download_direct, seed_magnet
+import os
+
+def split_data(data):
+
+    count = data.count
+    downloads = data.data
+
+    return count, downloads
+
+def check_completed(downloads, resume):
+    for download in downloads:
+        if download.completed == False:
+            consoleLog(f"Found unfinished download: {download.title}")
+            if resume == True:
+                dl_dir = os.path.dirname(download.path)
+                if download.magnet_uri:
+                    run_download_direct(download.magnet_uri, dl_dir, download.title)
+                    consoleLog(f"Resuming Magnet: {download.title}")
+                elif download.url:
+                    from core.network.direct_download import add_direct_download
+                    add_direct_download(download.url, download.title, dl_dir)
+                    consoleLog(f"Resuming Direct Download: {download.title}")
+
+def check_downloads(downloads):
+    for download in downloads:
+        if download.completed == True and os.path.exists(download.path):
+            consoleLog(f"Existing Download: {download.title}")
+            try:
+                seed_magnet(download.magnet_uri, download.path)
+            except Exception as e:
+                consoleLog(f"Failed to seed {download.title}: {e}")
+        elif download.completed == True and not os.path.exists(download.path):
+            consoleLog(f"Inexistent Download: {download.title}")
+            remove_download_log(download.magnet_uri)
+            
@@ -5,11 +5,29 @@ from datetime import datetime
 import json
 import os
 import re
-
-_log_buffer = []
-
+import time
+import threading

 def add_download_log(title, url, magnet_uri, completed) -> DownloadList:
+    # wait for metadata outside the lock to avoid blocking other threads
+    magnetdl = state.active_downloads.get(magnet_uri)
+    if magnetdl:
+        status = magnetdl.status()
+        timeout = 60
+        start = time.time()
+        while not status.has_metadata and (time.time() - start) < timeout:
+            time.sleep(0.5)
+            status = magnetdl.status()
+        torrent_name = status.name
+        save_path = status.save_path
+        consoleLog(f"Torrent name (has_metadata={status.has_metadata}): {torrent_name}")
+        path = os.path.join(save_path, torrent_name)
+    else:
+        path = os.path.join(state.download_path, title)
+    with state.downloads_lock:
+        return _add_download_log_inner(title, url, magnet_uri, completed, path)
+
+def _add_download_log_inner(title, url, magnet_uri, completed, path) -> DownloadList:
    downloads_file = os.path.join(state.settings_path, "downloads.json")
    
    if os.path.exists(downloads_file) and os.path.getsize(downloads_file) > 0:
@@ -21,23 +39,24 @@ def add_download_log(title, url, magnet_uri, completed) -> DownloadList:
            downloads = []
    else:
        downloads = []
-    

-    if any(d.magnet_uri == magnet_uri or d.url == url for d in downloads):
-        if magnet_uri in state.active_downloads:
+    if any((magnet_uri and d.magnet_uri == magnet_uri) or (url and d.url == url) for d in downloads):
+        if magnet_uri and magnet_uri in state.active_downloads:
            consoleLog("Skipping Logging, download already running...")
-            return
+            return DownloadList(data=downloads, count=len(downloads))
        consoleLog("File already in Log, updating Download State...")
        hash = extract_hash_from_magnet(magnet_uri)
-        update_download_completed_by_hash(hash, False)
-        return DownloadList(data=downloads, count=len(downloads)) # thanks again claude (im stupid)
+        if hash:
+            update_download_completed_by_hash(hash, False)
+        return DownloadList(data=downloads, count=len(downloads))
        
    
    downloads.append(Download(
        title=title,
        url=url,
        magnet_uri=magnet_uri,
-        completed=completed,
+        path=path,
+        completed=completed
    ))

    consoleLog(f"Added {title} to Log File")
@@ -49,6 +68,10 @@ def add_download_log(title, url, magnet_uri, completed) -> DownloadList:
    return download_list

 def remove_download_log(magnet_uri) -> DownloadList:
+    with state.downloads_lock:
+        return _remove_download_log_inner(magnet_uri)
+
+def _remove_download_log_inner(magnet_uri) -> DownloadList:
    downloads_file = os.path.join(state.settings_path, "downloads.json")
    
    if os.path.exists(downloads_file) and os.path.getsize(downloads_file) > 0:
@@ -61,10 +84,15 @@ def remove_download_log(magnet_uri) -> DownloadList:
    else:
        downloads = []

+
    magnet_link = (magnet_uri or "").strip()
+    if not magnet_link:
+        return DownloadList(data=downloads, count=len(downloads))
+
+    title = next((getattr(d, 'title', 'Unknown') for d in downloads if (getattr(d, 'magnet_uri', None) or '').strip() == magnet_link or (getattr(d, 'url', None) or '').strip() == magnet_link), 'Unknown')
    downloads = [d for d in downloads if (getattr(d, 'magnet_uri', None) or "").strip() != magnet_link and (getattr(d, 'url', None) or "").strip() != magnet_link]

-    consoleLog(f"Removed {magnet_link} from Log File")
+    consoleLog(f"Removed {title} from Log File")

    download_list = DownloadList(data=downloads, count=len(downloads))
    with open(downloads_file, "w") as file:
@@ -73,6 +101,10 @@ def remove_download_log(magnet_uri) -> DownloadList:
    return download_list

 def update_download_completed(magnet_uri, completed) -> DownloadList:
+    with state.downloads_lock:
+        return _update_download_completed_inner(magnet_uri, completed)
+
+def _update_download_completed_inner(magnet_uri, completed) -> DownloadList:
    downloads_file = os.path.join(state.settings_path, "downloads.json")
    
    if os.path.exists(downloads_file) and os.path.getsize(downloads_file) > 0:
@@ -103,9 +135,7 @@ def update_download_completed(magnet_uri, completed) -> DownloadList:
        try:
            stored_magnet = (getattr(download, 'magnet_uri', None) or "").strip()
            stored_url = (getattr(download, 'url', None) or "").strip()
-            consoleLog(f"Comparing with magnet: {stored_magnet[:50] if stored_magnet else 'None'}...")
            if identifier and (stored_magnet == identifier or stored_url == identifier):
-                consoleLog(f"Match found! Setting completed={completed}")
                download.completed = completed
                found = True
        except Exception as e:
@@ -125,6 +155,10 @@ def update_download_completed(magnet_uri, completed) -> DownloadList:
    

 def get_download_logs() -> DownloadList:
+    with state.downloads_lock:
+        return _get_download_logs_inner()
+
+def _get_download_logs_inner() -> DownloadList:
    downloads_file = os.path.join(state.settings_path, "downloads.json")
    
    if os.path.exists(downloads_file) and os.path.getsize(downloads_file) > 0:
@@ -140,14 +174,27 @@ def get_download_logs() -> DownloadList:
    return DownloadList(data=downloads, count=len(downloads))


-def extract_hash_from_magnet(magnet_uri): # full credits to claude for this
-    match = re.search(r'urn:btih:([A-F0-9]+)', magnet_uri, re.IGNORECASE)
-    if match:
-        return match.group(1).upper()
-    return None
+def extract_hash_from_magnet(magnet_uri):
+    if not magnet_uri:
+        return None
+    try:
+        import libtorrent as lt
+        params = lt.parse_magnet_uri(magnet_uri)
+        if hasattr(params, 'info_hashes'): # lt 2.0+
+            return str(params.info_hashes.v1).upper()
+        return str(params.info_hash).upper()
+    except Exception:
+        match = re.search(r'urn:btih:([a-zA-Z0-9]+)', magnet_uri)
+        if match:
+            return match.group(1).upper()
+        return None


 def update_download_completed_by_hash(info_hash, completed) -> DownloadList:
+    with state.downloads_lock:
+        return _update_download_completed_by_hash_inner(info_hash, completed)
+
+def _update_download_completed_by_hash_inner(info_hash, completed) -> DownloadList:
    downloads_file = os.path.join(state.settings_path, "downloads.json")
    
    if os.path.exists(downloads_file) and os.path.getsize(downloads_file) > 0:
@@ -190,20 +237,16 @@ def update_download_completed_by_hash(info_hash, completed) -> DownloadList:
    return download_list


-_main_window = None
-
 def set_main_window(window):
-    global _main_window
-    _main_window = window
+    state.main_window = window

 def flush_log_buffer(): # credits to claude
-    global _log_buffer
-    if _log_buffer:
+    if state.log_buffer:
        try:
            from core.interface.gui import MainWindow
-            for log_entry in _log_buffer:
+            for log_entry in state.log_buffer:
                MainWindow.add_log(log_entry)
-            _log_buffer = []
+            state.log_buffer = []
        except Exception:
            pass

@@ -214,10 +257,10 @@ def consoleLog(text, printAnyways = False):

    try:
        from core.interface.gui import MainWindow
-        MainWindow.add_log(formatted_text)
+        if not MainWindow.add_log(formatted_text):
+            state.log_buffer.append(formatted_text)
    except Exception:
-        global _log_buffer
-        _log_buffer.append(formatted_text)
+        state.log_buffer.append(formatted_text)
    
    if state.debug or printAnyways:
        print(formatted_text)
@@ -1,31 +1,51 @@
-from core.utils.data.state import state
-from core.utils.general.logs import consoleLog
-from core.utils.data.tracker import get_item_url
-from core.utils.data.tracker import get_magnet_link
-from core.network.libtorrent_wrapper import add_download
+from PySide6.QtWidgets import QTableWidgetItem
+from PySide6.QtCore import Qt
+from core.utils.logging.logs import consoleLog
+from core.network.libtorrent_wrapper import add_magnet
 from core.utils.general.wrappers import run_thread
-from core.utils.general.logs import add_download_log
-
+from core.utils.logging.logs import add_download_log
+from core.network.libtorrent_int import add_seed
+from core.utils.data.state import state
+from core.network.direct_download import add_direct_download
 import threading


-def download_selected(item, posts, post_titles):
-    if item is not None:
-        consoleLog(f"Downloading {item.text()}")
-        run_thread(threading.Thread(target=run_download, args=(item.text(), posts, post_titles)))
-    else:
+
+
+def download_selected(items: list[QTableWidgetItem]):
+    if not items:
        consoleLog("No item selected for download.")
+        return
+    seen = set()
+    for item in items:
+        if item.column() != 0:
+            continue
+        post_idx = item.data(Qt.ItemDataRole.UserRole)
+        if post_idx is None:
+            post_idx = item.row()
+        
+        if post_idx not in seen:
+            seen.add(post_idx)
+            post = state.posts[post_idx]
+            consoleLog(f"Downloading {post.get('title', 'Unknown')}")
+            run_thread(threading.Thread(target=run_download, args=(post,)))

-def run_download(item, posts, post_titles):
-    post_url = get_item_url(item, posts, post_titles)
-    consoleLog(f"Selected URL: {post_url}")
-    magnet_uri = get_magnet_link(post_url)
-
-    add_download_log(item, post_url, magnet_uri, False)
-    add_download(magnet_uri)
-
-def run_download_direct(magnet_uri):
-    add_download(magnet_uri)    
+def run_download(post):
+    linkfunc = state.trackers[state.currenttracker]["linkFunc"]
+    ismagnet = state.trackers[state.currenttracker]["isMagnet"]
+    link = linkfunc(post)

+    if ismagnet:
+        add_magnet(link)
+        add_download_log(post.get("title", "Unknown"), "", link, False)
+    else:
+        add_direct_download(link, post.get("title", "Unknown"))

+def run_download_direct(magnet_uri, dl_path=None, title="Direct Download"):
+    consoleLog(f"Magnet: {title}")
+    add_magnet(magnet_uri)
+    add_download_log(title, "", magnet_uri, False)

+def seed_magnet(magnet_uri, file_path): 
+    consoleLog(f"Seeding: {magnet_uri[:60]}")
+    add_seed(magnet_uri, file_path)
@@ -20,16 +20,16 @@ def format_data(data):

    return post_titles, post_links, post_author, post_seeders, post_leechers

-def format_data_m0nkrus(data): 
+def format_data_minimal(data): 
    post_author = [post["author"] for post in data]
    post_titles = [post["title"] for post in data]
    post_links = [post["url"] for post in data]

-    return post_titles, post_links, post_author
+    return post_author, post_titles, post_links






-# https://open.spotify.com/track/70vjXI7oBou5buTtgiJeRW?si=25640cc4243c4bf3
+# https://open.spotify.com/track/0F0fMcIdL2FmcC9eYqwazX
@@ -1,34 +1,39 @@
 import requests
 from core.utils.data.state import state
-from core.utils.general.logs import consoleLog
+from core.utils.logging.logs import consoleLog

-def check_for_updates():
-    url = f"https://api.github.com/repos/KeksPirates/SoftwareManager/releases"
-    response = requests.get(url)
+def get_updates():
+    url = f"https://api.github.com/repos/KeksPirates/SoftwareManager/releases/latest"
+    try:
+        response = requests.get(url, timeout=15)
+    except requests.RequestException as e:
+        consoleLog(f"Failed to fetch releases: {e}")
+        return None

    if response.status_code != 200:
        consoleLog(f"Failed to fetch releases: {response.status_code}")
-        exit(1)
+        return None

-    releases = response.json()
-    releases.sort(key=lambda r: r["published_at"], reverse=True)
+    release = response.json()

-    latest_release = releases[0]
-    latest_version = latest_release["name"]
-    assets = latest_release["assets"]
+    latest_version = release.get("name") or release.get("tag_name")
+    assets = release.get("assets", [])

+    release_assets = []

-    if state.version == "dev":
-        consoleLog("Dev release detected, skipping version check")
-        return None, None
-    elif latest_version != state.version:
+    if latest_version != state.version:
        consoleLog(f"New release available: {latest_version}")
        if assets:
            consoleLog("Assets:")
            for asset in assets:
-                consoleLog(f" - {asset['name']}: {asset['browser_download_url']}")
-            return assets, latest_version
-        else: 
+                consoleLog(f"{asset['name']}")
+                release_assets.append(dict(
+                    name=asset['name'],
+                    url=asset['browser_download_url'],
+                    hash=asset.get('digest')
+                ))
+            return release_assets, latest_version
+        else:
            return None, None
    else:
        consoleLog("Already up-to-date.")
@@ -1,13 +1,12 @@
 from core.interface.gui import MainWindow
 from core.utils.data.state import state
-from core.utils.general.logs import consoleLog
-from core.network.libtorrent_misc import send_notification, update_log
-from core.utils.general.logs import get_download_logs
-from core.utils.general.shutdown import closehelper, shutdown_event
+from core.utils.logging.logs import consoleLog
+from core.network.libtorrent_misc import send_notification, update_log, check_deleted_files
+from core.utils.logging.logs import get_download_logs
+from core.utils.general.shutdown import closehelper
 from core.utils.general.wrappers import run_thread
-from core.utils.general.loghandler import split_data, check_completed
+from core.utils.logging.loghandler import split_data, check_completed, check_downloads
 from core.network.interface import list_interfaces, init_interfaces
-from core.network.libtorrent_int import update_bound_interface
 from core.utils.config.config import read_config
 from PySide6 import QtWidgets
 from PySide6.QtCore import Qt
@@ -15,15 +14,9 @@ import qdarktheme
 import threading
 import platform
 import signal
-import argparse
 import sys
 import time

-
-parser = argparse.ArgumentParser()
-parser.add_argument("--debug", action="store_true")
-args = parser.parse_args()
-
 def run_gui():
    app = QtWidgets.QApplication.instance() or QtWidgets.QApplication(sys.argv)
    qdarktheme.setup_theme("auto")
@@ -33,21 +26,21 @@ def run_gui():
        widget.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
        qdarktheme.setup_theme("auto", custom_colors={"background": "#00000000"})

-    from core.utils.general.logs import set_main_window
+    from core.utils.logging.logs import set_main_window
    set_main_window(widget)
    widget.show()
    sys.exit(app.exec())

 def keyboardinterrupthandler(signum, frame):
    closehelper()
+    from core.utils.general.shutdown import force_exit
+    force_exit()

-if __name__ == "__main__":
+def main():
    start_time = time.perf_counter()
    read_config()
    logs = get_download_logs()
    _, downloads = split_data(logs)
-    if args.debug:
-        state.debug = args.debug # override of read_config
    signal.signal(signal.SIGINT, keyboardinterrupthandler)
    consoleLog("Starting SoftwareManager...")
    consoleLog("Fetching Network Interfaces...")
@@ -55,13 +48,19 @@ if __name__ == "__main__":
    consoleLog("Initializing Interface variables...")
    init_interfaces()
    consoleLog(f"Current Bound: {state.bound_interface}")
-    run_thread(threading.Thread(target=send_notification, args=(shutdown_event,), daemon=True))
+    run_thread(threading.Thread(target=send_notification, args=(state.shutdown_event,), daemon=True))
    consoleLog("Started Thread: send_notification")
-    run_thread(threading.Thread(target=update_log, args=(shutdown_event,), daemon=True))
+    run_thread(threading.Thread(target=update_log, args=(state.shutdown_event,), daemon=True))
    consoleLog("Started Thread: update_log")
    run_thread(threading.Thread(target=check_completed, args=(downloads, state.autoresume)))
    consoleLog("Started Thread: check_completed")
+    run_thread(threading.Thread(target=check_deleted_files, args=(state.shutdown_event,), daemon=True))
+    consoleLog("Started Thread: check_deleted_files")
+    run_thread(threading.Thread(target=check_downloads, args=(downloads,)))
+    consoleLog("Started Thread: check_downloads")
    elapsed = time.perf_counter() - start_time
    consoleLog(f"Initialization completed in {elapsed:.2f}s. Launching GUI")
    run_gui()

+if __name__ == "__main__":
+    main()
Author	SHA1	Message	Date
Vxrtrauter	b77867b111	feat: QoL features to Updater, workflow trigger.	2026-03-11 00:07:11 +01:00
Vxrtrauter	bf20625832	Fix Torrent Handle errors	2026-03-10 22:45:25 +01:00
Vxrtrauter	8d218443bf	fix: wrong download paths in libtorrent logic	2026-03-10 22:35:49 +01:00
Vxrtrauter	a55a049583	Merge branch 'main' of https://github.com/KeksPirates/SoftwareManager	2026-03-10 22:23:26 +01:00
Vxrtrauter	4e7e08c136	fix: download path errors, improve print statements, add exception blocks to prevent errors from crashing the program, removed ability to add custom path on add_download as its not used, removed, fixed config format & parsing issues	2026-03-10 22:21:59 +01:00
KeksNino	c3efa39b09	rename cancel download to remove from list in downloadlist context menu	2026-03-10 21:58:21 +01:00
KeksNino	d3d7a9d2ac	fix: check free disk space before downloading to prevent silent failure after starting dl also add "(experimental)" to image path in settings	2026-03-10 21:57:53 +01:00
shayaa	74e7fcfd70	Merge pull request #41 from KeksPirates/merge_candidate_noschxl Merge candidate noschxl	2026-03-10 18:42:23 +01:00
shayaa	adecc78aec	Merge branch 'main' into merge_candidate_noschxl	2026-03-10 18:40:07 +01:00
Vxrtrauter	f6b852309b	add: direct http download, fix libtorrent speed limit settings	2026-03-10 18:35:56 +01:00
Vxrtrauter	86ec6daca2	feat: add dynamic default headers in search tab	2026-03-10 16:07:45 +01:00
Vxrtrauter	8d6d02a1af	fix: improve checks for logging	2026-03-10 15:52:15 +01:00
shayaa	2e2e526d3a	Update gui.py	2026-03-10 00:23:08 +01:00
shayaa	11b8f3f265	Update update_checker.py	2026-03-10 00:21:57 +01:00
Vxrtrauter	5369578194	Merge branch 'feat-steamrip-noschxl' into merge_candidate_noschxl, improve stuff (http dl impl still needed)	2026-03-09 23:48:41 +01:00
Vxrtrauter	c5e6608ae2	feat: enhance update handling by verifying installer hash and refactoring asset retrieval	2026-03-09 19:03:28 +01:00
Vxrtrauter	214d9a0e23	feat: implement SVG icon handling and update button styles in settings dialog	2026-03-09 18:09:17 +01:00
shayaa	e0da811bfe	Merge pull request #40 from noschXL/main	2026-03-09 17:18:40 +01:00
noschXL	ef538fc83d	Merge pull request #7 from KeksPirates/main merge upstream	2026-03-09 16:04:22 +00:00
nosch	c5e72332dc	cleaned requirements.txt	2026-03-09 17:03:01 +01:00
nosch	39522a4068	download is in download.py, needs to move	2026-03-09 16:59:05 +01:00
Vxrtrauter	a9f229926b	feat: readd image path configuration in settings dialog and update paths tab	2026-03-09 15:16:06 +01:00
noschXL	ec950b751b	Merge pull request #6 from KeksPirates/main Merge upstream	2026-03-09 05:52:35 +00:00
nosch	56735c4344	worked on downloads, magnets are next	2026-03-08 22:29:28 +01:00
Vxrtrauter	8db9f3d9e2	feat: improve hover row delegate rendering by adjusting focus and selection states	2026-03-08 19:49:38 +01:00
Vxrtrauter	80d3ad208d	feat: enhance table item focus styles by adding border properties	2026-03-08 19:20:18 +01:00
nosch	87886a5cf9	merged	2026-03-08 16:07:08 +01:00
nosch	7cdae312ce	preparing to merge	2026-03-08 15:54:57 +01:00
Vxrtrauter	66217ff9b6	feat: update settings dialog to handle image path as None; improve table item focus styles	2026-03-08 13:58:23 +01:00
Vxrtrauter	9ba11bfa78	feat: enhance error handling and logging in various modules; improve timeout settings for network requests / fix basic issues	2026-03-08 13:32:30 +01:00
Vxrtrauter	43cbfe056c	feat: remove ugly spinner label and related functionality from search process	2026-03-08 13:19:39 +01:00
Vxrtrauter	12df32f72a	feat: remove unused install path detection function and clean up update process	2026-03-08 13:15:51 +01:00
Vxrtrauter	9e0ee2a36d	trigger workflow	2026-03-08 02:16:23 +01:00
Vxrtrauter	5b9bdd2a2a	feat: update download process to use temporary installer path and improve silent installation	2026-03-08 02:16:16 +01:00
Vxrtrauter	ff0e1a0798	trigger workflow"	2026-03-08 01:55:59 +01:00
Vxrtrauter	891c5a86c1	feat: enhance update process with progress dialog and install path detection	2026-03-08 01:55:23 +01:00
nosch	ffdd656b9c	fixed a slight issue in the gui	2026-03-08 01:47:33 +01:00
nosch	d8fec74de1	every menu works, now the downloads need fixing	2026-03-08 01:42:59 +01:00
KeksNino	a5190f151c	fix: temporarily remove subprocess.Popen to stop opening softwaremanager.exe before update finished	2026-03-08 00:41:46 +01:00
Vxrtrauter	95f6640212	Merge branch 'main' of https://github.com/KeksPirates/SoftwareManager	2026-03-08 00:29:13 +01:00
Vxrtrauter	78a47e89d3	fix: remove broken image path handling from settings dialog and paths tab	2026-03-08 00:29:10 +01:00
KeksNino	e47efab901	fix: remove restartapplications flag in updater	2026-03-08 00:25:32 +01:00
nosch	75e4da33eb	merged upstream, fixed the double tables	2026-03-08 00:16:15 +01:00
KeksNino	dbd5e79678	trigger github workflow to test updater	2026-03-08 00:08:37 +01:00
KeksNino	925579b9e0	fix: switch updater to silent instead of verysilent and open new exe after installation	2026-03-07 23:57:23 +01:00
KeksNino	1d969e5b9c	feat: auto restart application after update has finished	2026-03-07 23:34:03 +01:00
KeksNino	dbf396a187	fix: update updater to silently install new setup file	2026-03-07 23:28:00 +01:00
Vxrtrauter	351bd041b8	fix: enhance Windows build process with installer and ZIP packaging	2026-03-07 22:40:38 +01:00
shayaa	a602d17d3d	Create LICENSE	2026-03-07 22:38:20 +01:00
Vxrtrauter	3db9d9c8e4	fix: improve white / dark mode support and enhance table styling	2026-03-07 22:31:38 +01:00
Vxrtrauter	f030795f10	fix: implement forced exit on shutdown and enhance shutdown handling	2026-03-07 22:10:45 +01:00
KeksNino	eccdb2f068	fix file deletion when seeding	2026-03-07 21:56:07 +01:00
Vxrtrauter	bd5ccc7688	fix: improve download status handling and enhance thread safety in logging functions	2026-03-07 21:36:11 +01:00
Vxrtrauter	b2a30af5cd	fix: prevent processing of non-downloadable items in download_selected function	2026-03-07 20:46:41 +01:00
Vxrtrauter	fbc2225878	refactor: standardize version key in build_info.json and enhance download selection logic in download.py feat: add SVG icons for play, pause, and folder actions in gui.py; implement status bar for download speed display fix: remove unnecessary newline in libtorrent_misc.py and streamline update checker logic in update_checker.py	2026-03-07 20:41:03 +01:00
nosch	003dd0e3aa	a semiworking version, line 343 in gui.py is commented cuz it needs work, the table is also a bit screwed	2026-03-07 19:30:24 +01:00
KeksNino	4d1a639651	remove unused QProgressBar widget	2026-03-07 17:55:52 +01:00
Vxrtrauter	8d1b3ba68f	feat: implement seeding functionality and enhance download management with seeded magnets tracking	2026-03-08 12:00:00 +01:00
nosch	c76d179daa	shayaa needs to fix rutracker NOW	2026-03-07 16:52:27 +01:00
noschXL	eba4c01fca	Merge pull request #4 from KeksPirates/main Update Repository with latest SoftwareManager commits	2026-03-07 15:43:03 +00:00
Vxrtrauter	dcc12c0b28	fix: LibTorrent not detecting that file has been deleted until LibTorrent Session is reinitialized / enhance download management with file existence checks and cleanup	2026-03-07 00:45:27 +01:00
Vxrtrauter	925fe21d03	Add logging and download tracking to direct downloads	2026-03-07 14:00:00 +01:00
nosch	577a1637e4	merged upstream	2026-03-06 22:42:42 +01:00
Vxrtrauter	ec462afde6	Simplify boolean checks in network interface detection	2026-03-06 12:00:00 +01:00
Vxrtrauter	e50ef32c66	refactor: clean up imports and remove unused code in scrapers and download modules	2026-03-05 23:19:08 +01:00
KeksNino	d6e418d045	fix: crash when there are no results in search tab	2026-03-04 21:24:56 +01:00
Vxrtrauter	a7c71b37f5	refactor: remove duplicate stripping	2026-03-04 21:00:37 +01:00
Vxrtrauter	8fb1bb9e8d	Merge branch 'main' of https://github.com/KeksPirates/SoftwareManager	2026-03-04 20:58:58 +01:00
Vxrtrauter	89fd8b4ebb	fix: fix scraping for uztracker posts to support displaying authors properly	2026-03-04 20:58:56 +01:00
KeksNino	3915e114a3	fix: logging in uztracker scraper and search for non-ascii letters and remove unused imports	2026-03-04 20:28:55 +01:00
Vxrtrauter	34a50e1a1b	refactor: rename scraping functions for consistency and improve data handling	2026-03-04 19:11:31 +01:00
KeksNino	90124fd9c8	fix: smaller author column in search tab	2026-03-04 14:07:43 +01:00
Vxrtrauter	4175f82967	feat: add windowCloseHelper function and integrate it into keyboard interrupt handling	2026-03-03 21:56:28 +01:00
Vxrtrauter	4bf2e9af81	feat: add download existence checks and improve log removal feedback	2026-03-01 23:14:10 +01:00
nosch	889c50e201	worked on gui implementation and cleaned up a bit	2026-02-28 17:58:50 +01:00
noschXL	e4d1c189b7	Merge pull request #2 from KeksPirates/main update	2026-02-28 14:09:47 +01:00
Vxrtrauter	a6bb879db3	feat: enhance download logging with path handling and timeout mechanism	2026-02-28 04:01:00 +01:00
Vxrtrauter	7653748599	chore: remove unused file_list utility	2026-02-28 03:34:56 +01:00
Vxrtrauter	9bec3f9189	Merge branch 'main' of https://github.com/KeksPirates/SoftwareManager	2026-02-28 03:33:13 +01:00
Vxrtrauter	04d93b870a	refactor: reorganize logging functionality and remove unused log files	2026-02-28 03:33:10 +01:00
KeksNino	664e660198	fix a bunch of lsp errors	2026-02-28 03:31:17 +01:00
Vxrtrauter	60019e0d2e	refactor: update log imports and restructure logging functionality	2026-02-28 03:31:05 +01:00
Vxrtrauter	8238cfbe56	Merge branch 'main' of https://github.com/KeksPirates/SoftwareManager	2026-02-28 03:05:10 +01:00
Vxrtrauter	7ccff5c5a1	Refactor monkrus scraper to implement caching and improve post fetching logic	2026-02-28 03:05:09 +01:00
noschXL	7d55af6ac0	Merge pull request #1 from KeksPirates/main sugma	2026-02-28 02:43:47 +01:00
KeksNino	8abe92fc4f	fix: hide seeders and leechers in uztracker and m0nkrus tab	2026-02-28 02:37:35 +01:00
Vxrtrauter	0a3b5eeee2	Remove unused asyncio import in uztracker.py	2026-02-27 23:59:59 +01:00
nosch	b9dc6cc18d	im not dealing with megadb and fichier, as there are always better alternatives. if not ill add a way to select a downloaded .rar, though the links will be given to the user	2026-02-27 23:27:45 +01:00
nosch	29bac99359	steamrip scrapes downloadlinks for the provider - steamrip connection	2026-02-27 10:02:11 +01:00
nosch	d6a388652b	accidentally included a pycache	2026-02-26 18:12:12 +01:00
nosch	1c3fb95e40	vikingfile cloudflare turnstyle-captcha bypassed	2026-02-26 16:53:54 +01:00
nosch	e354ef50cf	made it more user frendly using a placeholdertext	2026-02-26 14:21:26 +01:00
nosch	2066c86001	now displaying the actual names of the game, not the links, links are in the 'link' key.	2026-02-26 14:08:07 +01:00
nosch	7e2b4cb46b	moved the offline example	2026-02-26 13:36:13 +01:00
nosch	bef019cf8c	a fuzzyfind demo works, use python -m core.interface.utils.fzhelper	2026-02-26 13:32:56 +01:00
nosch	886ee8f0f0	installed fuzzyfinder, scraped the links, started UI	2026-02-25 23:22:40 +01:00
KeksNino	7662c861ea	trigger github CI	2026-02-20 01:13:13 +01:00
KeksNino	2a8f305a76	fix exe not starting on windows	2026-02-19 19:28:24 +01:00
KeksNino	12223d18de	add transparency to settings dialog on linux/macos	2026-02-17 00:29:55 +01:00