Merge pull request #51 from KeksPirates/refactor/improve-code-quality

Refactor/improve code quality

.github/workflows/dev.yml

@@ -106,7 +106,7 @@ jobs:
         run: |
           python -c "
           from PIL import Image
-          img = Image.open('src/core/interface/assets/logo.png')
+          img = Image.open('src/interface/assets/logo.png')
           img.save('app_icon.ico', format='ICO', sizes=[(256,256),(128,128),(64,64),(48,48),(32,32),(16,16)])
           print('Icon converted successfully')
           "
@@ -125,8 +125,6 @@ jobs:
             --upx-binary="${{ env.UPX_BINARY }}" \
             --noinclude-qt-translations \
             --include-data-files=build_info.json=build_info.json \
-            --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
@@ -137,8 +135,6 @@ jobs:
         run: |
           pyinstaller --onefile --windowed \
             --add-data "build_info.json:." \
-            --add-data "build_info.json:src/core" \
-            --add-data "build_info.json:src/core/interface" \
             --exclude-module PyQt6 \
             --exclude-module PyQt5 \
             --hidden-import=backports.tarfile \
@@ -155,8 +151,6 @@ jobs:
         run: |
           pyinstaller --onefile \
             --add-data "build_info.json:." \
-            --add-data "build_info.json:src/core" \
-            --add-data "build_info.json:src/core/interface" \
             --exclude-module PyQt6 \
             --exclude-module PyQt5 \
             --hidden-import=backports.tarfile \
@@ -287,4 +281,4 @@ jobs:
             release/SoftwareManager-dev-${{ needs.build.outputs.short_sha }}-macos
             release/SHA256SUMS.txt
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -0,0 +1,185 @@
+name: Build Executables (Test)
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  PYTHON_VERSION: "3.12"
+  APP_NAME: "SoftwareManager"
+
+jobs:
+  build:
+    name: Build ${{ matrix.os }}
+    strategy:
+      fail-fast: false   # keep other platforms building even if one fails
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            artifact_name: SoftwareManager-test-${{ github.sha }}-linux
+          - os: windows-latest
+            artifact_name: SoftwareManager-test-${{ github.sha }}-windows
+          - os: macos-latest
+            artifact_name: SoftwareManager-test-${{ github.sha }}-macos
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          version: "0.9.7"
+          enable-cache: true
+
+      - name: Install Python dependencies
+        run: |
+          uv pip install -r requirements.txt
+          uv pip install Pillow
+        env:
+          UV_SYSTEM_PYTHON: 1
+
+      - name: Install Nuitka (Windows only)
+        if: runner.os == 'Windows'
+        run: uv pip install nuitka
+        env:
+          UV_SYSTEM_PYTHON: 1
+
+      - name: Generate version
+        id: version
+        shell: bash
+        run: |
+          SHORT_SHA="${{ github.sha }}"
+          SHORT_SHA="${SHORT_SHA:0:7}"
+          BRANCH="${{ github.head_ref || github.ref_name }}"
+          BRANCH_SLUG="${BRANCH//\//-}"   # replace slashes with dashes
+          VERSION="${BRANCH_SLUG}-${SHORT_SHA}-test"
+          echo "VERSION=$VERSION" >> $GITHUB_ENV
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          echo "short_sha=$SHORT_SHA" >> $GITHUB_OUTPUT
+          echo "Generated version: $VERSION"
+
+      - name: Inject build info
+        shell: bash
+        run: |
+          cat > build_info.json << EOF
+          {
+            "version": "${{ env.VERSION }}"
+          }
+          EOF
+
+      - name: Install UPX (Windows)
+        if: runner.os == 'Windows'
+        shell: bash
+        run: |
+          curl -sL https://github.com/upx/upx/releases/download/v5.1.0/upx-5.1.0-win64.zip -o upx.zip
+          7z x upx.zip -oupx-dir
+          UPX_DIR="$(pwd)/upx-dir/upx-5.1.0-win64"
+          echo "$UPX_DIR" >> $GITHUB_PATH
+          export PATH="$UPX_DIR:$PATH"
+          echo "UPX_BINARY=$UPX_DIR/upx.exe" >> $GITHUB_ENV
+          upx --version | head -1
+
+      - name: Convert icon for Windows
+        if: runner.os == 'Windows'
+        shell: bash
+        run: |
+          python -c "
+          from PIL import Image
+          img = Image.open('src/interface/assets/logo.png')
+          img.save('app_icon.ico', format='ICO', sizes=[(256,256),(128,128),(64,64),(48,48),(32,32),(16,16)])
+          print('Icon converted successfully')
+          "
+
+      - name: Build with Nuitka (Windows)
+        if: runner.os == 'Windows'
+        shell: bash
+        run: |
+          python -m nuitka \
+            --standalone \
+            --assume-yes-for-downloads \
+            --windows-console-mode=disable \
+            --windows-icon-from-ico=app_icon.ico \
+            --enable-plugin=pyside6 \
+            --enable-plugin=upx \
+            --upx-binary="${{ env.UPX_BINARY }}" \
+            --noinclude-qt-translations \
+            --include-data-files=build_info.json=build_info.json \
+            --output-filename=${{ env.APP_NAME }}.exe \
+            --output-dir=nuitka-build \
+            src/main.py
+
+      - name: Build with PyInstaller (Linux)
+        if: runner.os == 'Linux'
+        shell: bash
+        run: |
+          pyinstaller --onefile --windowed \
+            --add-data "build_info.json:." \
+            --exclude-module PyQt6 \
+            --exclude-module PyQt5 \
+            --hidden-import=backports.tarfile \
+            --hidden-import=backports \
+            --hidden-import=jaraco.context \
+            --hidden-import=jaraco.text \
+            --hidden-import=jaraco.functools \
+            --name ${{ env.APP_NAME }} \
+            src/main.py
+
+      - name: Build with PyInstaller (macOS)
+        if: runner.os == 'macOS'
+        shell: bash
+        run: |
+          pyinstaller --onefile \
+            --add-data "build_info.json:." \
+            --exclude-module PyQt6 \
+            --exclude-module PyQt5 \
+            --hidden-import=backports.tarfile \
+            --hidden-import=backports \
+            --hidden-import=jaraco.context \
+            --hidden-import=jaraco.text \
+            --hidden-import=jaraco.functools \
+            --name ${{ env.APP_NAME }} \
+            src/main.py
+
+      - name: Stage artifact
+        shell: bash
+        run: |
+          mkdir -p dist-final
+          if [ "$RUNNER_OS" == "Windows" ]; then
+            mv nuitka-build/main.dist 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: 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"
+
+      - name: Upload artifact (Windows)
+        if: runner.os == 'Windows'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.os }}-build
+          path: dist-final/${{ matrix.artifact_name }}.zip
+          retention-days: 7
+
+      - name: Upload artifact (Linux/macOS)
+        if: runner.os != 'Windows'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.os }}-build
+          path: dist-final/${{ matrix.artifact_name }}
+          retention-days: 7

README.md

@@ -63,12 +63,5 @@ SoftwareManager is a Python-based GUI tool that simplifies searching and downloa
  </picture>
 </a>
 
-## Contributors
-<a href="https://github.com/KeksPirates/SoftwareManager/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=KeksPirates/SoftwareManager" />
-</a>
-
----
-
 **Disclaimer:** SoftwareManager is intended for legal and ethical use only. Ensure compliance with applicable laws and regulations when using this tool.
 

src/core/data/scrapers/monkrus.py

@@ -1,87 +0,0 @@
-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
-import time
-
-cache = {
-    "data": [],
-    "last_fetched": 0
-}
-
-cache_expiry = 300
-
-def _get_telegram_posts():
-    post = 100
-    max_posts = 250
-    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, timeout=10)
-        soup = BeautifulSoup(response.text, "html.parser")
-        bubbles = soup.find_all("div", class_="tgme_widget_message_bubble")
-        
-        if not bubbles:
-            break
-        
-        for bubble in bubbles:
-            post_txt = bubble.find("div", class_="tgme_widget_message_text js-message_text")
-            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 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,
-                        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})

src/core/data/scrapers/provider/gofile.py

@@ -1,31 +0,0 @@
-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.")
-

src/core/data/scrapers/rutracker.py

@@ -1,52 +0,0 @@
-import requests
-from core.utils.data.state import state
-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(query):
-    search = requests.get(f"{state.api_url}/search?q={query}", timeout=15)
-    consoleLog("Sent request to server")
-    if search:
-        _, 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:
-        consoleLog("No response from server, returning nothing")
-        return []
-
-
-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})

src/core/data/scrapers/steamrip.py

@@ -1,123 +0,0 @@
-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})

src/core/data/scrapers/uztracker.py

@@ -1,55 +0,0 @@
-import requests
-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.data.tracker import get_magnet_link
-from typing import Dict
-
-
-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():
-    state.trackers.update({Metadata["name"] : Metadata})

src/core/interface/utils/searchhelper.py

@@ -1,27 +0,0 @@
-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}")
-    
-    tracker = state.trackers[state.currenttracker]
-    scrapefunc = tracker["scrapeFunc"]
-    state.posts = scrapefunc(search_text)
-
-    from core.interface.gui import MainWindow
-    MainWindow._instance.search_results_signal.emit(tracker["headers"])

src/core/interface/utils/tabhelper.py

@@ -1,56 +0,0 @@
-from PySide6.QtWidgets import QWidget, QVBoxLayout
-
-
-def create_tab(title, searchbar, software_list, tabs, dlbutton, layout2): 
-    tab = QWidget() 
-    layout = QVBoxLayout() 
-    if searchbar:
-        layout.addWidget(searchbar)
-    if layout2:
-        layout.addLayout(layout2)
-    else:
-        layout.addWidget(software_list)
-    if dlbutton:
-        layout.addWidget(dlbutton)
-    tab.setLayout(layout)
-    tabs.addTab(tab, title) 
-    return tab
-
-#################
-# SETTINGS TABS #
-#################
-def general_tab(title, autoresume, update_checkbox, transparent_window, tabs):
-    tab = QWidget()
-    layout = QVBoxLayout()
-    layout.addWidget(autoresume)
-    layout.addWidget(update_checkbox)
-    layout.addWidget(transparent_window)
-    layout.addStretch()
-    tab.setLayout(layout)
-    tabs.addTab(tab, title)
-    return tab
-
-def paths_tab(title, download_path, image_path, tabs):
-    tab = QWidget()
-    layout = QVBoxLayout()
-    layout.addWidget(download_path)
-    layout.addWidget(image_path)
-    layout.addStretch()
-    tab.setLayout(layout)
-    tabs.addTab(tab, title)
-    return tab
-    
-
-def network_tab(title, network_interface, max_connections, max_downloads, up_speed_limit, down_speed_limit, api_url, tabs):
-    tab = QWidget()
-    layout = QVBoxLayout()
-    layout.addWidget(network_interface)
-    layout.addWidget(max_connections)
-    layout.addWidget(max_downloads)
-    layout.addWidget(up_speed_limit)
-    layout.addWidget(down_speed_limit)
-    layout.addWidget(api_url)
-    layout.addStretch()
-    tab.setLayout(layout)
-    tabs.addTab(tab, title)
-    return tab

src/core/utils/general/shutdown.py

@@ -1,13 +0,0 @@
-from core.utils.data.state import state
-import os
-
-def closehelper():
-    state.shutdown_event.set()
-    try:
-        from core.network.libtorrent_misc import cleanup_session
-        cleanup_session()
-    except Exception:
-        pass
-
-def force_exit():
-    os._exit(0)

src/core/utils/general/wrappers.py

@@ -1,2 +0,0 @@
-def run_thread(thread):
-    thread.start()

src/data/hosts/gofile.py

@@ -0,0 +1,41 @@
+from utils.logging.logs import consoleLog
+import requests
+import re
+
+
+def scrape_gofile(url):
+
+    filetoken = re.findall(r"(?<=https...gofile.io\/d\/).*", url)[0]
+    session = requests.Session()
+
+    headers = {
+        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:148.0) Gecko/20100101 Firefox/148.0",
+        "Accept": "*/*",
+        "Accept-Language": "en-US,en;q=0.9",
+        "Accept-Encoding": "gzip, deflate, br, zstd",
+        "Referer": "https://gofile.io/",
+        "Authorization": f"Bearer lUUtRAccOuRUoZhelNSslDFSlpOgKLDj",
+        "X-Website-Token": "ffd9ffa831c50b9e68ca5e65cbbbd1a50e9a32e63022e17c7c6748388a1ed73b",
+        "X-BL": "en-US",
+        "Origin": "https://gofile.io",
+        "Sec-GPC": "1",
+        "Connection": "keep-alive",
+        "TE": "trailers"
+    }
+
+    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()]
+
+        link = temp[child[0]]["link"]
+        return link, headers
+    except Exception:
+        consoleLog("GoFile Authorization failed, if the Issue persists, please open an Issue on GitHub")
+        return None
+

src/data/sources/__init__.py

@@ -0,0 +1,12 @@
+from data.sources.rutracker import RutrackerScraper
+from data.sources.uztracker import UztrackerScraper
+from data.sources.steamrip import SteamripScraper
+from data.sources.monkrus import MonkrusScraper
+
+# Register Scrapers here
+SCRAPERS = [
+    RutrackerScraper(),
+    SteamripScraper(),
+    MonkrusScraper(),
+    UztrackerScraper(),
+]

src/data/sources/monkrus.py

@@ -0,0 +1,78 @@
+from utils.data.tracker import get_magnet_link
+from bs4 import BeautifulSoup
+from typing import Dict
+import requests
+import time
+
+
+class MonkrusScraper:
+    name = "m0nkrus"
+    headers = ["Post Title", "Author"]
+    is_magnet = True
+
+    def __init__(self):
+        self.cache = { "data": [], "last_fetched": 0 }
+        self.cache_expiry = 300
+
+    def _get_telegram_posts(self):
+        post = 100
+        max_posts = 250
+        posts = []
+        added = set()
+
+        current_time = time.time()
+
+        if self.cache["data"] and (current_time - self.cache["last_fetched"] < self.cache_expiry):
+            return self.cache["data"]
+
+        while post <= max_posts:
+            url = f"https://t.me/s/real_monkrus/{post}"
+            response = requests.get(url, timeout=10)
+            soup = BeautifulSoup(response.text, "html.parser")
+            bubbles = soup.find_all("div", class_="tgme_widget_message_bubble")
+            
+            if not bubbles:
+                break
+            
+            for bubble in bubbles:
+                post_txt = bubble.find("div", class_="tgme_widget_message_text js-message_text")
+                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 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,
+                            url=post_url
+                        ))
+            
+            post += 22
+
+        posts.reverse()
+
+        self.cache["data"] = posts
+        self.cache["last_fetched"] = current_time
+
+        return(posts)
+
+    def search(self, query):
+        posts = self._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_download_link(self, post: Dict):
+        return get_magnet_link(post["url"])

src/data/sources/rutracker.py

@@ -0,0 +1,46 @@
+from utils.network.jsonhandler import split_data, format_data
+from utils.data.tracker import get_magnet_link
+from utils.logging.logs import consoleLog
+from utils.data.state import state
+from typing import Dict
+import requests
+
+class RutrackerScraper:
+    name = "rutracker"
+    headers = ["Post Title", "Author", "Seeders", "Leechers"]
+    is_magnet = True
+
+    def search(self, query):
+        search = requests.get(f"{state.api_url}/search?q={query}", timeout=15)
+        consoleLog("Sent request to server")
+        if search:
+            _, 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:
+            consoleLog("No response from server, returning nothing")
+            return []
+
+    def get_download_link(self, post: Dict):
+        _, post_links, _, _, _ = format_data([post])
+        return get_magnet_link(post_links[0])
+

src/data/sources/steamrip.py

@@ -0,0 +1,107 @@
+from data.hosts.buzzheavier import scrape_buzzheavier
+from data.hosts.gofile import scrape_gofile
+from utils.logging.logs import consoleLog
+from bs4 import BeautifulSoup
+from typing import Dict
+import webbrowser
+import requests
+import time
+import re
+
+class SteamripScraper:
+    name = "steamrip"
+    headers = ["Game"]
+    is_magnet = False
+
+
+    def __init__(self):
+        self.cache = { "data": [], "last_fetched": 0 }
+        self.cache_expiry = 300
+
+    def scrape_steamrip_links(self):
+        
+        current_time = time.time()
+
+        if self.cache["data"] != [] and (current_time - self.cache["last_fetched"] < self.cache_expiry):
+            return self.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(self, 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
+
+        ret = []
+
+        for link in download_links:
+            if len(link) != 1:
+                ret.append(link)
+
+        self.cache["data"] = ret
+
+        return ret
+
+    def get_download_link(self, post: Dict):
+        url = post["url"]
+        links = self.scrape_steamrip_game_downloads(url)
+        best = ""
+        for link in links:
+            if link[0] == "h":
+                best = link
+                break
+
+        if links.index(best) == 0:
+            link = scrape_buzzheavier(best)
+            return link
+        elif links.index(best) == 1:
+            link, headers = scrape_gofile(best)
+            return link, headers
+        else:
+            consoleLog("Unable to retrieve download link due to captcha, launching browser...")
+            webbrowser.open(best)
+            return None, None
+
+    def search(self, query: str):
+        games = self.scrape_steamrip_links()
+        
+        filtered_games = [
+            game for game in games 
+            if query.lower() in game["title"].lower()
+        ]
+        
+        return filtered_games

src/data/sources/uztracker.py

@@ -0,0 +1,50 @@
+from utils.data.tracker import get_magnet_link
+from utils.logging.logs import consoleLog
+from utils.data.state import state
+from urllib.parse import urljoin
+from bs4 import BeautifulSoup
+from typing import Dict
+import requests
+
+class UztrackerScraper:
+    name = "uztracker"
+    headers = ["Post Title", "Author"]
+    is_magnet = True
+
+
+    def search(self, 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_download_link(self, post: Dict):
+        return get_magnet_link(post["url"])
+

src/interface/dialogs/contextmenu.py

@@ -0,0 +1,149 @@
+from utils.logging.logs import consoleLog, remove_download_log
+from PySide6.QtWidgets import QMessageBox
+from PySide6.QtCore import Qt, QPoint
+from utils.data.state import state
+from PySide6 import QtWidgets
+import subprocess
+import platform
+import time
+import os
+
+class ContextMenu:
+    def __init__(self, main_window):
+        self.main_window = main_window
+        self.context_menu = QtWidgets.QMenu(main_window)
+        self.context_menu.addAction("Open Containing Folder", self.openFolderAction)
+        self.context_menu.addAction("Copy Magnet URI", self.copyMagnetURIAction)
+        self.context_menu.addAction("Remove from list", self.cancelDownloadAction)
+        self.context_menu.addAction("Delete File", self.deleteFileAction)
+
+        main_window.downloadList.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        main_window.downloadList.customContextMenuRequested.connect(self._show_context_menu)
+
+    @property
+    def downloadList(self):
+        return self.main_window.downloadList
+
+    def _show_context_menu(self, pos: QPoint):
+        index = self.downloadList.indexAt(pos)
+        if index.isValid():
+            self._context_menu_row = index.row()
+            self.context_menu.exec(self.downloadList.viewport().mapToGlobal(pos))
+
+    def openFolderAction(self):
+        if not hasattr(self, '_context_menu_row'):
+            return
+        row = self._context_menu_row
+        if row < 0 or row >= len(state.active_downloads):
+            return
+        magnet_link = list(state.active_downloads.keys())[row]
+        magnetdl = state.active_downloads[magnet_link]
+        download_path = magnetdl.save_path()
+        if download_path and os.path.exists(download_path):
+            if platform.system() == "Windows":
+                os.startfile(os.path.normpath(download_path))
+            elif platform.system() == "Linux":
+                subprocess.Popen(["xdg-open", download_path])
+            elif platform.system() == "Darwin":
+                subprocess.Popen(["open", download_path])
+
+    def copyMagnetURIAction(self):
+        if not hasattr(self, '_context_menu_row'):
+            return
+        row = self._context_menu_row
+        if row < 0 or row >= len(state.active_downloads):
+            return
+        magnet_link = list(state.active_downloads.keys())[row]
+        clipboard = QtWidgets.QApplication.clipboard()
+        clipboard.setText(magnet_link)
+
+    def cancelDownloadAction(self):
+        if not hasattr(self, '_context_menu_row'):
+            return
+        row = self._context_menu_row
+        with state.downloads_lock:
+            if row < 0 or row >= len(state.active_downloads):
+                return
+            magnet_link = list(state.active_downloads.keys())[row]
+            magnetdl = state.active_downloads[magnet_link]
+
+        # Cache the name BEFORE removing from session
+        try:
+            torrent_name = magnetdl.status().name
+        except RuntimeError:
+            torrent_name = "Unknown"
+
+        confirm = QMessageBox.question(
+            self.main_window, "Cancel Download",
+            f"Are you sure you want to cancel the download of '{torrent_name}'?",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+        )
+        if confirm == QMessageBox.StandardButton.Yes:
+            with state.downloads_lock:
+                state.active_downloads.pop(magnet_link, None)
+            remove_download_log(magnet_link)
+
+            if state.dl_session:
+                try:
+                    state.dl_session.remove_torrent(magnetdl)
+                except Exception as e:
+                    consoleLog(f"Exception while removing download from LibTorrent: {e}")
+
+            consoleLog(f"Cancelled download: {torrent_name}", True)
+
+
+    def deleteFileAction(self):
+        if not hasattr(self, '_context_menu_row'):
+            return
+        row = self._context_menu_row
+        with state.downloads_lock:
+            if row < 0 or row >= len(state.active_downloads):
+                return
+            magnet_link = list(state.active_downloads.keys())[row]
+            magnetdl = state.active_downloads[magnet_link]
+        try:
+            status = magnetdl.status()
+            save_path = status.save_path
+            torrent_name = status.name
+        except RuntimeError:
+            consoleLog("Error: torrent handle already invalid", True)
+            with state.downloads_lock:
+                state.active_downloads.pop(magnet_link, None)
+            remove_download_log(magnet_link)
+            return
+        download_path = os.path.join(save_path, torrent_name)
+        confirm = QMessageBox.question(
+            self.main_window, "Delete Files",
+            f"Are you sure you want to delete the downloaded files of '{torrent_name}'? This action cannot be undone.",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+        )
+        if confirm == QMessageBox.StandardButton.Yes:
+            with state.downloads_lock:
+                state.active_downloads.pop(magnet_link, None)
+            remove_download_log(magnet_link)
+            if state.dl_session:
+                try:
+                    state.dl_session.remove_torrent(magnetdl)
+                    time.sleep(0.5)
+                except Exception as e:
+                    consoleLog(f"Exception while removing download from LibTorrent: {e}")
+            if download_path and os.path.exists(download_path):
+                import shutil
+                last_error = None
+                for attempt in range(3):
+                    try:
+                        if os.path.isfile(download_path):
+                            os.remove(download_path)
+                        else:
+                            shutil.rmtree(download_path)
+                        consoleLog(f"Deleted files for: {torrent_name}", True)
+                        last_error = None
+                        break
+                    except Exception as e:
+                        last_error = e
+                        if attempt < 2:
+                            time.sleep(0.5)
+                if last_error:
+                    consoleLog(f"Error deleting files: {last_error}", True)
+            else:
+                consoleLog(f"Removed entry (files not found): {torrent_name}", True)

src/interface/dialogs/downloadlist.py

@@ -0,0 +1,89 @@
+from interface.dialogs.pauseresumedelegate import PauseResumeDelegate
+from interface.dialogs.hoverrowdelegate import HoverRowDelegate
+from interface.dialogs.downloadmodel import DownloadModel
+from interface.dialogs.theme import _table_stylesheet
+from PySide6.QtWidgets import QTableView, QHeaderView
+from utils.logging.logs import consoleLog
+from PySide6 import QtWidgets
+from PySide6.QtCore import Qt
+
+def _create_download_list(self) -> QTableView:
+    self.download_model = DownloadModel()
+    self.downloadList.setModel(self.download_model)
+    self.downloadList.horizontalHeader().setStretchLastSection(False)
+    self.downloadList.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeMode.Fixed)
+    self.downloadList.horizontalHeader().resizeSection(0, 70)
+    self.downloadList.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeMode.Stretch)
+    self.downloadList.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeMode.ResizeToContents)
+    self.downloadList.horizontalHeader().setSectionResizeMode(3, QHeaderView.ResizeMode.ResizeToContents)
+    self.downloadList.horizontalHeader().setSectionResizeMode(4, QHeaderView.ResizeMode.ResizeToContents)
+    self.downloadList.horizontalHeader().setSectionResizeMode(5, QHeaderView.ResizeMode.ResizeToContents)
+    self.downloadList.horizontalHeader().setSectionResizeMode(6, QHeaderView.ResizeMode.ResizeToContents)
+    self.downloadList.horizontalHeader().setMinimumSectionSize(60)
+    self.downloadList.verticalHeader().setDefaultSectionSize(40)
+    self.downloadList.setSelectionBehavior(QTableView.SelectionBehavior.SelectRows)
+    self.downloadList.setSelectionMode(QtWidgets.QAbstractItemView.SelectionMode.ExtendedSelection)
+    self.downloadList.verticalHeader().setVisible(False)
+    self.downloadList.horizontalHeader().setDefaultAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+    self.downloadList.horizontalHeader().setHighlightSections(False)
+    self.downloadList.setMouseTracking(True)
+    self.downloadList.setShowGrid(False)
+    self.downloadList.setStyleSheet(_table_stylesheet("QTableView"))
+    self.downloadList.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+    self.downloadList.viewport().setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+
+    download_model = self.download_model
+
+    def on_pause_resume_clicked(row):
+        download_model.toggle_pause_resume(row)
+
+    self.downloadList.viewport().setMouseTracking(True)
+    hover_delegate = HoverRowDelegate(self.downloadList)
+    self.downloadList.setItemDelegate(hover_delegate)
+
+    delegate = PauseResumeDelegate(self.downloadList)
+    self.downloadList.setItemDelegateForColumn(0, delegate)
+    delegate.clicked.connect(on_pause_resume_clicked)
+
+    return self.downloadList
+
+def download_list_update(self):
+    self._update_speed_label()
+    if not self.download_model:
+        return
+
+    row_count = self.download_model.rowCount()
+    col_count = self.download_model.columnCount()
+
+    if row_count > 0 and col_count > 0:
+        top_left = self.download_model.index(0, 0)
+        bottom_right = self.download_model.index(row_count - 1, col_count - 1)
+        if top_left.isValid() and bottom_right.isValid():
+            self.download_model.dataChanged.emit(top_left, bottom_right, [Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.UserRole])
+
+    if row_count != self._last_dl_row_count:
+        old_count = self._last_dl_row_count
+        self._last_dl_row_count = row_count
+        if row_count > 0:
+            self.download_model.layoutAboutToBeChanged.emit()
+            self.download_model.layoutChanged.emit()
+            for row in range(row_count):
+                idx = self.download_model.index(row, 0)
+                if idx.isValid():
+                    self.downloadList.closePersistentEditor(idx)
+                    self.downloadList.openPersistentEditor(idx)
+        elif old_count > 0:
+            self.download_model.layoutAboutToBeChanged.emit()
+            self.download_model.layoutChanged.emit()
+    else:
+        if row_count > 0:
+            delegate = self.downloadList.itemDelegateForColumn(0)
+            for row in range(row_count):
+                idx = self.download_model.index(row, 0)
+                if idx.isValid():
+                    editor = self.downloadList.indexWidget(idx)
+                    if editor and delegate:
+                        try:
+                            delegate.setEditorData(editor, idx)
+                        except RuntimeError as e:
+                            consoleLog(f"Exception while updating download list: {e}")

src/interface/dialogs/downloadmodel.py

@@ -0,0 +1,136 @@
+from PySide6.QtCore import QAbstractTableModel, QModelIndex, Qt
+from utils.logging.logs import consoleLog
+from utils.data.state import state
+import libtorrent as lt
+import subprocess
+import platform
+import os
+
+class DownloadModel(QAbstractTableModel):
+    def __init__(self):
+        super().__init__()
+        self.headers = ["Action", "Name", "Status", "Progress", "Speed", "Size", "Total Size"]
+
+    def rowCount(self, parent=QModelIndex()):
+        if parent.isValid():
+            return 0
+        with state.downloads_lock:
+            return len(state.active_downloads)
+
+    def columnCount(self, parent=QModelIndex()):
+        return len(self.headers)
+
+    def headerData(self, section, orientation, role=Qt.ItemDataRole.DisplayRole):
+        if role == Qt.ItemDataRole.DisplayRole and orientation == Qt.Orientation.Horizontal:
+            return self.headers[section]
+        return None
+
+    def data(self, index, role=Qt.ItemDataRole.DisplayRole):
+        if not index.isValid():
+            return None
+
+        with state.downloads_lock:
+            if index.row() >= len(state.active_downloads) or index.row() < 0:
+                return None
+            
+            try:
+                magnet_link = list(state.active_downloads.keys())[index.row()]
+                magnetdl = state.active_downloads[magnet_link]
+                status = magnetdl.status()
+            except (IndexError, KeyError, RuntimeError):
+                return None
+
+        if role == Qt.ItemDataRole.DisplayRole:
+            col = index.column()
+            if col == 0:
+                pass
+            elif col == 1:
+                return status.name if status.has_metadata else "Fetching metadata..."
+            elif col == 2:
+                if status.paused:
+                    is_auto = getattr(status, 'auto_managed', True)
+                    return "Queued" if is_auto else "Paused"
+                elif status.state == lt.torrent_status.downloading:
+                    return "Downloading"
+                elif status.state == lt.torrent_status.seeding:
+                    return "Seeding"
+                else:
+                    return "Queued"
+            elif col == 3:
+                return f"{status.progress * 100:.1f}%"
+            elif col == 4:
+                down_kb = status.download_rate / 1024
+                up_kb = status.upload_rate / 1024
+                down_text = f"{down_kb / 1024:.1f} MB/s" if down_kb > 1024 else f"{down_kb:.1f} kB/s"
+                up_text = f"{up_kb / 1024:.1f} MB/s" if up_kb > 1024 else f"{up_kb:.1f} kB/s"
+                return f"↓ {down_text} ↑ {up_text}"
+            elif col == 5:
+                downloaded_mb = status.total_wanted_done / (1024 * 1024)
+                if downloaded_mb > 1024:
+                    return f"{downloaded_mb / 1024:.2f} GB"
+                else:
+                    return f"{downloaded_mb:.1f} MB"
+            elif col == 6:
+                total_mb = status.total_wanted / (1024 * 1024)
+                if total_mb > 1024:
+                    return f"{total_mb / 1024:.2f} GB"
+                else:
+                    return f"{total_mb:.1f} MB"
+            elif col == 7:
+                if status.download_rate > 0:
+                    bytes_left = status.total_wanted - status.total_wanted_done
+                    eta_seconds = bytes_left / status.download_rate
+                    if eta_seconds < 60:
+                        return f"{int(eta_seconds)}s"
+                    elif eta_seconds < 3600:
+                        minutes = int(eta_seconds / 60)
+                        seconds = int(eta_seconds % 60)
+                        return f"{minutes}m {seconds}s"
+                    else:
+                        hours = int(eta_seconds / 3600)
+                        minutes = int((eta_seconds % 3600) / 60)
+                        return f"{hours}h {minutes}m"
+                else:
+                    return "∞" if status.paused else "Stalled"
+        if role == Qt.ItemDataRole.UserRole and index.column() == 0:
+            return status.paused
+        return None
+
+    def toggle_pause_resume(self, row):
+        with state.downloads_lock:
+            if row >= len(state.active_downloads) or row < 0:
+                return
+            try:
+                magnet_link = list(state.active_downloads.keys())[row]
+                magnetdl = state.active_downloads[magnet_link]
+                status = magnetdl.status()
+            except (IndexError, KeyError, RuntimeError):
+                return
+
+        if status.state == lt.torrent_status.seeding:
+            try:
+                save_path = magnetdl.save_path()
+                if save_path and os.path.exists(save_path):
+                    if platform.system() == "Windows":
+                        os.startfile(os.path.normpath(save_path))
+                    elif platform.system() == "Linux":
+                        subprocess.Popen(["xdg-open", save_path])
+                    elif platform.system() == "Darwin":
+                        subprocess.Popen(["open", save_path])
+            except Exception as e:
+                consoleLog(f"Exception while opening file: {e}")
+            return
+
+        is_paused = status.paused
+        if is_paused:
+            if hasattr(magnetdl, 'set_flags'):
+                magnetdl.set_flags(lt.torrent_flags.auto_managed)
+            magnetdl.resume()
+            consoleLog(f"Resumed download: {status.name}", True)
+        else:
+            if hasattr(magnetdl, 'unset_flags'):
+                magnetdl.unset_flags(lt.torrent_flags.auto_managed)
+            magnetdl.pause()
+            consoleLog(f"Paused download: {status.name}", True)
+        idx = self.index(row, 0)
+        self.dataChanged.emit(idx, idx, [Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.UserRole])

src/interface/dialogs/elideditemdelegate.py

@@ -0,0 +1,22 @@
+from interface.dialogs.theme import _theme_colors
+from PySide6.QtWidgets import QStyledItemDelegate
+from PySide6.QtCore import Qt
+
+class ElidedItemDelegate(QStyledItemDelegate):
+    def __init__(self, get_hovered_row, parent=None):
+        super().__init__(parent)
+        self._get_hovered_row = get_hovered_row
+
+    def initStyleOption(self, option, index):
+        super().initStyleOption(option, index)
+        if option.text:
+            metrics = option.fontMetrics
+            text_rect = option.rect.adjusted(14, 0, -14, 0)
+            option.text = metrics.elidedText(option.text, Qt.TextElideMode.ElideMiddle, text_rect.width())
+
+    def paint(self, painter, option, index):
+        if index.row() == self._get_hovered_row():
+            painter.save()
+            painter.fillRect(option.rect, _theme_colors()["hover"])
+            painter.restore()
+        super().paint(painter, option, index)

src/interface/dialogs/eventfilter.py

@@ -0,0 +1,36 @@
+from utils.logging.logs import consoleLog
+from utils.data.state import state
+from PySide6.QtCore import QEvent
+
+def eventFilter(self, obj, event):
+    try:
+        if obj == state.trackertable.viewport():
+            if event.type() == QEvent.Type.MouseMove:
+                pos = event.position().toPoint() if hasattr(event, 'position') else event.pos()
+                idx = state.trackertable.indexAt(pos)
+                new_row = idx.row() if idx.isValid() else -1
+                if new_row != self._tracker_hovered_row or state.trackertable is not self._tracker_hovered_table:
+                    self._tracker_hovered_row = new_row
+                    self._tracker_hovered_table = state.trackertable
+                    state.trackertable.viewport().update()
+            elif event.type() == QEvent.Type.Leave:
+                self._tracker_hovered_row = -1
+                self._tracker_hovered_table = None
+                state.trackertable.viewport().update()
+        if obj == self.downloadList.viewport():
+            if event.type() == QEvent.Type.MouseMove:
+                pos = event.position().toPoint() if hasattr(event, 'position') else event.pos()
+                idx = self.downloadList.indexAt(pos)
+                new_row = idx.row() if idx.isValid() else -1
+                if new_row != self._hovered_row:
+                    old_row = self._hovered_row
+                    self._hovered_row = new_row
+                    self._invalidate_hover_row(old_row)
+                    self._invalidate_hover_row(new_row)
+            elif event.type() == QEvent.Type.Leave:
+                old_row = self._hovered_row
+                self._hovered_row = -1
+                self._invalidate_hover_row(old_row)
+    except (RuntimeError, AttributeError) as e:
+        consoleLog(f"Exception in EventFilter: {e}")
+    return super(type(self), self).eventFilter(obj, event)

src/interface/dialogs/hoverrowdelegate.py

@@ -0,0 +1,19 @@
+from interface.dialogs.theme import _theme_colors
+from PySide6.QtWidgets import QStyledItemDelegate
+from PySide6 import QtWidgets
+
+class HoverRowDelegate(QStyledItemDelegate):
+
+    def paint(self, painter, option, index):
+        from interface.gui import MainWindow
+
+        opt = QtWidgets.QStyleOptionViewItem(option)
+        option.state &= ~QtWidgets.QStyle.StateFlag.State_HasFocus
+        option.state &= ~QtWidgets.QStyle.StateFlag.State_Selected
+
+        hovered_row = MainWindow._instance._hovered_row if MainWindow._instance else -1
+        if index.row() == hovered_row:
+            painter.save()
+            painter.fillRect(option.rect, _theme_colors()["hover"])
+            painter.restore()
+        super().paint(painter, opt, index)

src/interface/dialogs/image.py

@@ -0,0 +1,29 @@
+from PySide6.QtGui import QImage, QPixmap
+from PySide6.QtWidgets import QLabel
+from utils.data.state import state
+from PySide6.QtCore import Qt
+import os
+
+class Image():
+    def __init__(self, parent):
+        self.overlay_label = QLabel(parent)
+        self.overlay_label.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, True)
+
+        if state.image_path is not None and os.path.exists(state.image_path):
+            self.image = QImage(state.image_path)
+            self.image = self.image.scaledToWidth(300, Qt.TransformationMode.SmoothTransformation)
+
+            self.pixmap = QPixmap.fromImage(self.image)
+            self.overlay_label.setPixmap(self.pixmap)
+            self.overlay_label.adjustSize()
+            self.overlay_label.raise_()
+
+            x = parent.width() - self.overlay_label.width()
+            y = parent.height() - self.overlay_label.height()
+            self.overlay_label.move(x, y)
+
+    def update_image_overlay(self, new_image_path):
+        self.image = QImage(new_image_path)
+        self.pixmap = QPixmap.fromImage(self.image)
+        self.overlay_label.setPixmap(self.pixmap)
+        self.overlay_label.adjustSize()

src/interface/dialogs/pauseresumedelegate.py

@@ -0,0 +1,86 @@
+from interface.dialogs.theme import _theme_colors, SVG_PLAY, SVG_PAUSE, SVG_FOLDER
+from PySide6.QtWidgets import QStyledItemDelegate, QWidget, QHBoxLayout
+from interface.utils.svghelper import svg_icon
+from PySide6.QtCore import Qt, QSize, Signal
+from utils.data.state import state
+from PySide6 import QtWidgets
+import libtorrent as lt
+
+class PauseResumeDelegate(QStyledItemDelegate):
+    clicked = Signal(int)
+
+    def paint(self, painter, option, index):
+        from interface.gui import MainWindow
+
+        opt = QtWidgets.QStyleOptionViewItem(option)
+        option.state &= ~QtWidgets.QStyle.StateFlag.State_HasFocus
+        option.state &= ~QtWidgets.QStyle.StateFlag.State_Selected
+
+        hovered_row = MainWindow._instance._hovered_row if MainWindow._instance else -1
+        if index.row() == hovered_row:
+            painter.save()
+            painter.fillRect(option.rect, _theme_colors()["hover"])
+            painter.restore()
+        super().paint(painter, opt, index)
+
+    def setEditorData(self, editor, index):
+        button = editor.findChild(QtWidgets.QPushButton)
+        if not button:
+            return
+        try:
+            with state.downloads_lock:
+                keys = list(state.active_downloads.keys())
+                if index.row() >= len(keys):
+                    return
+                magnet_link = keys[index.row()]
+                magnetdl = state.active_downloads[magnet_link]
+            status = magnetdl.status()
+        except (RuntimeError, IndexError, KeyError):
+            return
+
+        if status.state == lt.torrent_status.seeding:
+            button.setIcon(svg_icon(SVG_FOLDER, 18))
+            button.setText("")
+        else:
+            is_user_paused = status.paused and not status.auto_managed
+            button.setIcon(svg_icon(SVG_PLAY if is_user_paused else SVG_PAUSE, 18))
+            button.setText("")
+
+
+    def createEditor(self, parent, option, index):
+        try:
+            with state.downloads_lock:
+                keys = list(state.active_downloads.keys())
+                if index.row() >= len(keys):
+                    return QWidget(parent)
+                magnet_link = keys[index.row()]
+                magnetdl = state.active_downloads[magnet_link]
+            status = magnetdl.status()
+        except (RuntimeError, IndexError, KeyError):
+            return QWidget(parent)
+
+        widget = QWidget(parent)
+        widget.setStyleSheet("border: none; background: transparent;")
+        layout = QHBoxLayout(widget)
+        layout.setContentsMargins(0, 0, 0, 0)
+        if status.state == lt.torrent_status.seeding:
+            btnPause = QtWidgets.QPushButton()
+            btnPause.setIcon(svg_icon(SVG_FOLDER, 18))
+        else:
+            btnPause = QtWidgets.QPushButton()
+            is_user_paused = status.paused and not status.auto_managed
+            btnPause.setIcon(svg_icon(SVG_PLAY if is_user_paused else SVG_PAUSE, 18))
+        btnPause.setIconSize(QSize(18, 18))
+        btnPause.setFixedSize(30, 30)
+        btnPause.setCursor(Qt.CursorShape.PointingHandCursor)
+        btnPause.setStyleSheet("QPushButton { border: none; background: transparent; padding: 0px; }")
+        btnPause.clicked.connect(lambda: self.clicked.emit(index.row()))
+        layout.addStretch()
+        layout.addWidget(btnPause)
+        layout.addStretch()
+        widget.setLayout(layout)
+        return widget
+
+
+    def editorEvent(self, event, model, option, index):
+        return False

src/interface/dialogs/settings.py

@@ -1,12 +1,10 @@
-from core.utils.config.settings import save_settings
-from core.utils.data.state import state
-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 interface.utils.tabhelper import create_tab
+from utils.config.settings import save_settings
+from interface.utils.svghelper import svg_icon
+from utils.logging.logs import consoleLog
 from PySide6.QtCore import Qt, QSize
+from utils.data.state import state
+from PySide6 import QtWidgets
 from PySide6.QtWidgets import (
     QLineEdit, 
     QPushButton, 
@@ -19,8 +17,8 @@ from PySide6.QtWidgets import (
     QCheckBox,
     QFileDialog,
     QComboBox,
-    QTabWidget,
 )
+
 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>'
@@ -33,7 +31,8 @@ def settings_dialog(self):
         dialog.setWindowTitle("Settings")
         dialog.setFixedSize(700, 450)
 
-        dialog.setLayout(QVBoxLayout())
+        dialog_layout = QVBoxLayout()
+        dialog.setLayout(dialog_layout)
 
         if state.window_transparency and platform.system() != "Windows" and dialog:
             dialog.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
@@ -44,7 +43,7 @@ def settings_dialog(self):
         update_checkbox_container = QWidget()
         update_checkbox_layout = QHBoxLayout()
 
-        # ignore updates checkbox
+        # Ignore updates checkbox
 
         if platform.system() == "Windows":
             update_checkbox = QCheckBox()
@@ -55,7 +54,7 @@ def settings_dialog(self):
             update_checkbox.toggled.connect(lambda checked: setattr(state, 'ignore_updates', checked))
             update_checkbox_layout.addWidget(update_checkbox)
 
-        # auto-resume downloads checkbox
+        # Auto-resume downloads checkbox
 
         autoresume_container = QWidget()
         autoresume_layout = QHBoxLayout()
@@ -69,7 +68,7 @@ def settings_dialog(self):
         autoresume_layout.addWidget(autoresume_checkbox)
 
 
-        # transparent window checkbox
+        # Transparent window checkbox
         transparent_window_container = QWidget()
         transparent_window_layout = QHBoxLayout()
 
@@ -82,31 +81,27 @@ def settings_dialog(self):
         transparent_window_checkbox.toggled.connect(lambda checked: setattr(state, 'window_transparency', checked))
         transparent_window_layout.addWidget(transparent_window_checkbox)
 
-        ##################
-        # SERVER SETTING #
-        ##################
 
+        # API Server Setting
         api_url_container = QWidget()
         api_url_layout = QHBoxLayout()
 
         api_url = QLineEdit()
         api_url_layout.addWidget(QLabel("API Server URL:"))
         api_url_layout.addWidget(api_url)
-        api_url_container.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
+        api_url_container.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
         api_url_container.setLayout(api_url_layout)
         api_url.setText(state.api_url)
 
-        #################
-        # DOWNLOAD PATH #
-        #################
 
+        # Download Path
         download_path_container = QWidget()
         download_path_layout = QHBoxLayout()
 
         download_path = QLineEdit()
         download_path_layout.addWidget(QLabel("Download Path:"))
         download_path_layout.addWidget(download_path)
-        download_path_container.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
+        download_path_container.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
         download_path_container.setLayout(download_path_layout)
         download_path.setText(state.download_path)
 
@@ -131,17 +126,15 @@ def settings_dialog(self):
         download_path_layout.addWidget(browse_button)
         browse_button.clicked.connect(browse_download_path)
 
-        ###############
-        # IMAGE PATH #
-        ###############
 
+        # Image Path
         image_path_container = QWidget()
         image_path_layout = QHBoxLayout()
 
         image_path = QLineEdit()
         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.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
         image_path_container.setLayout(image_path_layout)
         image_path.setText(state.image_path)
 
@@ -165,10 +158,8 @@ def settings_dialog(self):
         image_path_layout.addWidget(browse_button)
         browse_button.clicked.connect(browse_image_path)
 
-        ##################
-        # SPEED LIMITING #
-        ##################
 
+        # Speed Limiting
         down_speed_limit_container = QWidget()
         down_speed_limit_layout = QHBoxLayout()
 
@@ -195,10 +186,8 @@ def settings_dialog(self):
         up_speed_limit.setFixedWidth(180)
         up_speed_limit.setFixedHeight(30)
 
-        ######################
-        # CONNECTION CONFIGS #
-        ######################
-
+        
+        # Connection Configs
         max_connections_container = QWidget()
         max_connections_layout = QHBoxLayout()
 
@@ -212,10 +201,8 @@ def settings_dialog(self):
         max_connections.setFixedWidth(180)
         max_connections.setFixedHeight(30)
 
-        ####################
-        # DOWNLOAD CONFIGS #
-        ####################
 
+        # Download Configs
         max_downloads_container = QWidget()
         max_downloads_layout = QHBoxLayout()
 
@@ -229,10 +216,8 @@ def settings_dialog(self):
         max_downloads.setFixedWidth(180)
         max_downloads.setFixedHeight(30)
 
-        #####################
-        # INTERFACE BINDING #
-        #####################
 
+        # Interface Binding
         interface_container = QWidget()
         interface_layout = QHBoxLayout()
 
@@ -255,10 +240,7 @@ def settings_dialog(self):
         interface_container.setLayout(interface_layout)
 
 
-        ###############
-        # SAVE/CANCEL #
-        ###############
-
+        # Save / Cancel buttons
         layout = QHBoxLayout()
 
         save_btn = QPushButton("Save")
@@ -279,12 +261,12 @@ def settings_dialog(self):
         layout.addWidget(cancel_btn)
         layout.addWidget(save_btn)
 
-        self.tabs = QTabWidget()
-        self.tab1 = general_tab("General", autoresume_container, update_checkbox_container, transparent_window_container, self.tabs)
-        self.tab2 = paths_tab("Paths", download_path_container, image_path_container, self.tabs)
-        self.tab3 = network_tab("Network", interface_container, max_connections_container, max_downloads_container, up_speed_limit_container, down_speed_limit_container, api_url_container, self.tabs)
+        tabs = QtWidgets.QTabWidget()
+        create_tab("General", [autoresume_container, update_checkbox_container, transparent_window_container], tabs=tabs, stretch=True)
+        create_tab("Paths", [download_path_container, image_path_container], tabs=tabs, stretch=True)
+        create_tab("Network", [interface_container, max_connections_container, max_downloads_container, up_speed_limit_container, down_speed_limit_container, api_url_container], tabs=tabs, stretch=True)
 
-        dialog.layout().addWidget(self.tabs)
-        dialog.layout().addLayout(layout)
+        dialog_layout.addWidget(tabs)
+        dialog_layout.addLayout(layout)
 
         dialog.exec()

src/interface/dialogs/theme.py

@@ -0,0 +1,79 @@
+from PySide6.QtGui import QColor
+import darkdetect
+
+def _is_dark_mode():
+    return darkdetect.isDark()
+
+
+def _theme_colors():
+    dark = _is_dark_mode()
+    if dark:
+        return {
+            "text": "rgba(255, 255, 255, 0.9)",
+            "border": "rgba(255, 255, 255, 0.06)",
+            "selected": "rgba(255, 255, 255, 0.04)",
+            "header_text": "rgba(255, 255, 255, 0.5)",
+            "header_border": "rgba(255, 255, 255, 0.1)",
+            "hover": QColor(255, 255, 255, 15),
+        }
+    else:
+        return {
+            "text": "rgba(0, 0, 0, 0.87)",
+            "border": "rgba(0, 0, 0, 0.08)",
+            "selected": "rgba(0, 0, 0, 0.06)",
+            "header_text": "rgba(0, 0, 0, 0.6)",
+            "header_border": "rgba(0, 0, 0, 0.12)",
+            "hover": QColor(0, 0, 0, 15),
+        }
+
+
+def _table_stylesheet(view_type="QTableWidget"):
+    c = _theme_colors()
+    dark = _is_dark_mode()
+    color_rule = "" if dark else f"color: {c['text']};"
+    return f"""
+        {view_type} {{
+            border: none;
+            outline: 0;
+            font-size: 13px;
+            {color_rule}
+        }}
+        {view_type}::item {{
+            border-bottom: 1px solid {c["border"]};
+            padding: 6px 14px;
+            outline: none;
+            {color_rule}
+        }}
+        {view_type}::item:selected {{
+            background: {c["selected"]};
+            outline: none;
+            border: none;
+            border-bottom: 1px solid {c["border"]};
+        }}
+        {view_type}::item:focus {{
+            outline: none;
+            border: none;
+            border-bottom: 1px solid {c["border"]};
+        }}
+        QHeaderView {{
+            background: transparent;
+        }}
+        QHeaderView::section {{
+            background: transparent;
+            color: {c["header_text"]};
+            font-weight: normal;
+            border: none;
+            border-bottom: 1px solid {c["header_border"]};
+            padding: 6px 14px;
+        }}
+        QHeaderView::section:checked {{
+            background: transparent;
+            color: {c["header_text"]};
+            font-weight: normal;
+        }}
+    """
+
+
+SVG_PLAY = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><polygon points="6,3 20,12 6,21" fill="{color}"/></svg>'
+SVG_PAUSE = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><rect x="5" y="3" width="4" height="18" rx="1" fill="{color}"/><rect x="15" y="3" width="4" height="18" rx="1" fill="{color}"/></svg>'
+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>'

src/interface/dialogs/trackerhoverdelegate.py

@@ -0,0 +1,14 @@
+from interface.dialogs.theme import _theme_colors
+from PySide6.QtWidgets import QStyledItemDelegate
+
+class TrackerHoverDelegate(QStyledItemDelegate):
+    def __init__(self, get_hovered_row, parent=None):
+        super().__init__(parent)
+        self._get_hovered_row = get_hovered_row
+
+    def paint(self, painter, option, index):
+        if index.row() == self._get_hovered_row():
+            painter.save()
+            painter.fillRect(option.rect, _theme_colors()["hover"])
+            painter.restore()
+        super().paint(painter, option, index)

src/interface/dialogs/trackertable.py

@@ -0,0 +1,26 @@
+from interface.dialogs.theme import _table_stylesheet
+from PySide6.QtWidgets import QTableWidget
+from PySide6 import QtWidgets
+from PySide6.QtCore import Qt
+
+def _create_tracker_table(self):
+    table = QTableWidget()
+    table.setEditTriggers(QtWidgets.QAbstractItemView.EditTrigger.NoEditTriggers)
+    table.verticalHeader().setVisible(False)
+    table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectionBehavior.SelectRows)
+    table.setSelectionMode(QtWidgets.QAbstractItemView.SelectionMode.ExtendedSelection)
+    table.setShowGrid(False)
+    table.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+    table.viewport().setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+    table.horizontalHeader().setDefaultAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+    table.horizontalHeader().setHighlightSections(False)
+    table.horizontalHeader().setStretchLastSection(False)
+    table.setStyleSheet(_table_stylesheet("QTableWidget"))
+    table.setMouseTracking(True)
+    table.viewport().setMouseTracking(True)
+    table.viewport().installEventFilter(self)
+
+    table.setItemDelegateForColumn(0, self._tracker_elided_delegate)
+
+    self._apply_default_headers(table)
+    return table

src/interface/dialogs/update.py

@@ -0,0 +1,49 @@
+from utils.network.update_checker import get_updates
+from PySide6.QtWidgets import QDialog, QMessageBox
+from utils.network.updater import download_update
+from utils.logging.logs import consoleLog
+from utils.data.state import state
+from pathlib import Path
+import platform
+import json
+import os
+
+def _get_build_info_path() -> (Path | None):
+    current_dir = Path(__file__).resolve().parent
+
+    for _ in range(6): # Climb max 6 directories
+        file = current_dir / "build_info.json"
+        if file.exists():
+            return file
+        # Go up one directory if file isn't found
+        current_dir = current_dir.parent
+
+    return None
+
+
+def get_version() -> None:
+    # Get build info filepath
+    build_info_path = _get_build_info_path()
+    if build_info_path and os.path.exists(build_info_path):
+        with open(build_info_path, "r") as f:
+            build_info = json.load(f)
+            state.version = build_info.get("version")
+    else:
+        consoleLog(f"Could not find build info file (Path: {build_info_path})")
+
+class UpdateDialog(QDialog):
+    def __init__(self, parent=None):
+        if state.ignore_updates is False and platform.system() == "Windows":
+
+            assets, latest = get_updates()
+            if assets != None:
+                msg = QMessageBox()
+                msg.setIcon(QMessageBox.Icon.Information)
+                msg.setWindowTitle("Update Available")
+                msg.setText(f"A new version is available\n({latest})")
+                msg.setInformativeText("Press Ok to download.")
+                msg.setStandardButtons(QMessageBox.StandardButton.Ok | QMessageBox.StandardButton.Ignore)
+                response = msg.exec_()
+                if response == QMessageBox.StandardButton.Ok:
+                    download_update(assets)
+

src/interface/gui.py

@@ -0,0 +1,413 @@
+from interface.dialogs.trackerhoverdelegate import TrackerHoverDelegate
+from interface.dialogs.elideditemdelegate import ElidedItemDelegate
+from interface.dialogs.trackertable import _create_tracker_table
+from interface.dialogs.downloadlist import _create_download_list
+from interface.assets.base64_icons import settings_white_base64
+from interface.assets.base64_icons import settings_black_base64
+from interface.dialogs.downloadlist import download_list_update
+from interface.dialogs.update import get_version, UpdateDialog
+from utils.logging.logs import consoleLog, flush_log_buffer
+from interface.dialogs.downloadmodel import DownloadModel
+from interface.dialogs.settings import settings_dialog
+from interface.assets.base64_icons import logo_base64
+from interface.dialogs.eventfilter import eventFilter
+from utils.network.download import download_selected
+from interface.utils.searchhelper import run_search
+from interface.utils.tabhelper import create_tab
+from utils.general.shutdown import closehelper
+from utils.general.wrappers import run_thread
+from interface.dialogs.image import Image
+from utils.data.state import state
+
+import interface.dialogs.contextmenu
+
+from PySide6 import QtWidgets
+from PySide6.QtCore import (
+    Qt, 
+    QTimer, 
+    Signal, 
+    QSize 
+)
+
+from PySide6.QtWidgets import (
+    QLineEdit,
+    QTableView,
+    QWidget,
+    QVBoxLayout,
+    QLabel,
+    QHBoxLayout,
+    QComboBox,
+    QTabWidget,
+    QHeaderView,
+    QTableWidgetItem,
+    QTextEdit,
+    QStatusBar
+)
+
+from PySide6.QtGui import (
+    QIcon, 
+    QCloseEvent, 
+    QPixmap, 
+    QGuiApplication, 
+)
+
+import darkdetect
+import threading
+import platform
+import base64
+
+def windowCloseHelper():
+    QGuiApplication.quit()
+
+class MainWindow(QtWidgets.QMainWindow, QWidget):
+    eventFilter = eventFilter
+    log_signal = Signal(str)
+    search_results_signal = Signal(list)
+    _instance = None
+
+    def __init__(self):
+        super().__init__()
+        MainWindow._instance = self
+        self.log_signal.connect(self._on_log_signal)
+        self.search_results_signal.connect(self._on_search_results)
+
+        pixmap = QPixmap()
+        image_data = base64.b64decode(logo_base64)
+        pixmap.loadFromData(image_data)
+        self.setWindowIcon(QIcon(pixmap))
+
+        # Set AppID on Windows
+        if platform.system() == "Windows":
+            try:
+                import ctypes
+                appid = 'SoftwareManager'
+                ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(appid)
+            except Exception as e:
+                consoleLog(f"Could not set app ID: {e}")
+
+        # Get current version
+        # interface.dialogs.update
+        get_version()
+        UpdateDialog()
+
+        # Initialize Window
+        self.setWindowTitle("Software Manager")
+        self.setGeometry(100, 100, 800, 600)
+
+        self.controls = QWidget()
+        self.controlsLayout = QVBoxLayout()
+
+        # Searchbar
+        self.searchbar = QLineEdit()
+        self.searchbar.setPlaceholderText("Search for software...")
+        self.searchbar.setClearButtonEnabled(True)
+        self.searchbar.setMinimumHeight(30)
+        self.searchbar.returnPressed.connect(self._start_search)
+
+        # Download Button
+        self.dlbutton = QtWidgets.QPushButton("Download")
+        self.dlbutton.setCursor(Qt.CursorShape.PointingHandCursor)
+
+        # Dialog for empty results
+        self.emptyResults = QLabel("No Results")
+        self.emptyResults.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.emptyResults.hide()
+
+        self.downloadList = QTableView()
+        self.downloadList.setMouseTracking(True)
+        self._hovered_row = -1
+        self._tracker_hovered_row = -1
+        self._tracker_hovered_table = None
+        self._last_dl_row_count = 0
+        self.emptyDownload = QLabel("No items in downloads.")
+        self.emptyDownload.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
+        self.consoleLog = QTextEdit()
+        self.statusbar = QStatusBar()
+
+        flush_log_buffer()
+
+        self._tracker_elided_delegate = ElidedItemDelegate(lambda: self._tracker_hovered_row, self)
+        self._tracker_hover_delegate = TrackerHoverDelegate(lambda: self._tracker_hovered_row, self)
+
+        state.trackertable = _create_tracker_table(self)
+
+        container = QWidget()
+        containerLayout = QVBoxLayout()
+        containerLayout.addWidget(self.searchbar)
+        containerLayout.addWidget(state.trackertable)
+
+        # interface.dialogs.hoverrowdelegate
+        self.download_model = DownloadModel()
+        self.downloadList = _create_download_list(self)
+        self.downloadList.viewport().installEventFilter(self)
+
+        self.dlbutton.clicked.connect(lambda: run_thread(threading.Thread(target=download_selected, args=(state.trackertable.selectedItems(),))))
+
+        container.setLayout(containerLayout)
+        self.setCentralWidget(container)
+
+        self.tabs = QTabWidget()
+        self.tabs.setStyleSheet("""
+            QTabBar::tab {
+                font-size: 11px;
+                padding: 2px 8px;
+                height: 25px;
+            }
+            QTabWidget::pane {
+                margin-top: -20px;
+            }
+        """)
+
+        self.horizontal_layout = QHBoxLayout()
+        self.horizontal_layout.addWidget(self.emptyResults, stretch=3)
+        self.horizontal_layout.addWidget(state.trackertable)
+
+        # Tabs
+        create_tab("Search", [self.searchbar, self.horizontal_layout, self.dlbutton], tabs=self.tabs, stretch=False)
+        create_tab("Downloads", [self.emptyDownload, self.downloadList], tabs=self.tabs, stretch=False)
+
+        # Corner Widget (Settings Button, Tracker list, Tab button container)
+        self.corner_widget = QWidget()
+        self.corner_layout = QHBoxLayout(self.corner_widget)
+        self.corner_layout.setContentsMargins(0, 0, 0, 0)
+
+        # Tracker list
+        self.tracker_list = QComboBox()
+        self.tracker_list.addItems(list(state.trackers.keys()))
+        self.tracker_list.setCursor(Qt.CursorShape.PointingHandCursor)
+        self.tracker_list.activated.connect(self.set_tracker)
+        self.corner_layout.addWidget(self.tracker_list)
+
+        # Settings button
+        self.settings_btn = QtWidgets.QToolButton()
+        self.settings_btn.setIconSize(QSize(21, 21))
+        self.settings_btn.setStyleSheet("background: transparent;")
+        self.settings_btn.setToolTip("Settings")
+        self.settings_btn.setCursor(Qt.CursorShape.PointingHandCursor)
+        self.settings_btn.clicked.connect(lambda: settings_dialog(self))
+        self.corner_layout.addWidget(self.settings_btn)
+
+        # Adjust theme based on system preferences
+        if darkdetect.isDark():
+            settings_white_pixmap = QPixmap()
+            settings_white = base64.b64decode(settings_white_base64)
+            settings_white_pixmap.loadFromData(settings_white)
+            self.settings_btn.setIcon(QIcon(settings_white_pixmap))
+        else:
+            settings_black_pixmap = QPixmap()
+            settings_black = base64.b64decode(settings_black_base64)
+            settings_black_pixmap.loadFromData(settings_black)
+            self.settings_btn.setIcon(QIcon(settings_black_pixmap))
+
+        self.tab_wrapper = QWidget()
+        self.tab_layout = QVBoxLayout()
+        self.tab_layout.setContentsMargins(0, 0, 0, 0)
+        self.tab_layout.setSpacing(0)
+
+        self.tab_bar_layout = QHBoxLayout()
+        self.tab_bar_layout.setContentsMargins(0, 0, 0, 0)
+        self.tab_bar_layout.setSpacing(0)
+
+        self.tab_bar_layout.addWidget(self.tabs.tabBar(), stretch=0)
+        self.tab_bar_layout.addStretch()
+        self.tab_bar_layout.addWidget(self.corner_widget, stretch=0)
+
+        self.tab_layout.addLayout(self.tab_bar_layout)
+        self.tab_layout.addWidget(self.tabs)
+        self.tab_wrapper.setLayout(self.tab_layout)
+
+        containerLayout.addWidget(self.tab_wrapper)
+        containerLayout.setAlignment(Qt.AlignmentFlag.AlignTop)
+
+        self.consoleLog.setReadOnly(True)
+        self.consoleLog.setFixedHeight(150)
+        self.consoleLog.setStyleSheet("margin-bottom: 0px; background: transparent;")
+        containerLayout.addWidget(self.consoleLog)
+
+        self.statusbar.show()
+        self.statusbar.setStyleSheet("background: transparent; border: none; padding-right: 1px; padding-left: 6px; padding-bottom: 1px; margin-top: -8px")
+
+        self.version = QLabel(f"Version: {state.version}")
+        self.statusbar.addPermanentWidget(self.version, Qt.AlignmentFlag.AlignLeft)
+
+        # (\u2193) Arrow down, (\u2191) Arrow up
+        self.speed_label = QLabel("↓ 0.0 kB/s  ↑ 0.0 kB/s")
+        self.speed_label.setStyleSheet("padding-right: 6px;")
+        self.statusbar.addPermanentWidget(self.speed_label)
+
+        self.setStatusBar(self.statusbar)
+
+        self.download_timer = QTimer()
+        self.download_timer.timeout.connect(lambda: download_list_update(self))
+        self.download_timer.start(500)
+
+        self.active_timer = QTimer()
+        self.active_timer.timeout.connect(self.show_empty_downloads)
+        self.active_timer.start(500)
+
+        self._context_menu = interface.dialogs.contextmenu.ContextMenu(self)
+        self.image_overlay = Image(self)
+
+    def _apply_default_headers(self, table):
+        tracker_name = state.currenttracker if hasattr(state, 'currenttracker') and state.currenttracker else None
+        if tracker_name is None:
+            keys = list(state.trackers.keys())
+            tracker_name = keys[0] if keys else None
+
+        headers = []
+        if tracker_name and tracker_name in state.trackers:
+            tracker_mod = state.trackers[tracker_name]
+            if hasattr(tracker_mod, 'headers'):
+                headers = tracker_mod.headers
+            elif hasattr(tracker_mod, 'HEADERS'):
+                headers = tracker_mod.HEADERS
+
+        if not headers:
+            if state.currenttracker == "rutracker":
+                headers = ["Post Title", "Author", "Seeders", "Leechers"]
+            elif state.currenttracker == "steamrip":
+                headers = ["Game"]
+            else: 
+                headers = ["Post Title", "Author"] # i know this makes it less "modular", but its qol
+
+        table.setRowCount(0)
+
+        col_count = table.columnCount()
+        if col_count != len(headers):
+            for i in range(col_count):
+                table.setItemDelegateForColumn(i, None)
+            table.setColumnCount(len(headers))
+
+        table.setHorizontalHeaderLabels(headers)
+        self._apply_tracker_column_modes(table, len(headers))
+
+    def _apply_tracker_column_modes(self, table, col_count):
+        header = table.horizontalHeader()
+        if col_count > 0:
+            header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
+            table.setItemDelegateForColumn(0, self._tracker_elided_delegate)
+        for i in range(1, col_count):
+            header.setSectionResizeMode(i, QHeaderView.ResizeMode.ResizeToContents)
+            table.setItemDelegateForColumn(i, self._tracker_hover_delegate)
+
+    def _start_search(self):
+        def _search_thread():
+            try:
+                run_search(self)
+            except Exception as e:
+                consoleLog(f"Search error: {e}", True)
+                self.search_results_signal.emit([])
+        run_thread(threading.Thread(target=_search_thread))
+
+    @staticmethod
+    def add_log(text):
+        if hasattr(MainWindow, "_instance") and MainWindow._instance:
+            MainWindow._instance.log_signal.emit(text)
+            return True
+        return False
+
+    def _on_log_signal(self, text):
+        if hasattr(self, 'consoleLog'):
+            self.consoleLog.append(text)
+            self.consoleLog.verticalScrollBar().setValue(
+                self.consoleLog.verticalScrollBar().maximum()
+            )
+
+    def _on_search_results(self, headers):
+        if state.posts is None or state.posts == []:
+            self.show_empty_results(True)
+            self.searchbar.setEnabled(True)
+            self.searchbar.setFocus()
+            return
+
+        table = state.trackertable
+        table.setRowCount(0)
+
+        col_count = table.columnCount()
+        need_reconfig = col_count != len(headers)
+
+        if need_reconfig:
+            for i in range(col_count):
+                table.setItemDelegateForColumn(i, None)
+            table.setColumnCount(len(headers))
+            table.setHorizontalHeaderLabels(headers)
+            self._apply_tracker_column_modes(table, len(headers))
+        else:
+            table.setHorizontalHeaderLabels(headers)
+
+        table.setRowCount(len(state.posts))
+        for x, rowdata in enumerate(state.posts):
+            for y, (key, data) in enumerate(rowdata.items()):
+                item = QTableWidgetItem(str(data))
+                item.setData(Qt.ItemDataRole.UserRole, x)
+                table.setItem(x, y, item)
+
+        self.show_empty_results(False)
+        self.searchbar.setEnabled(True)
+        self.searchbar.setFocus()
+
+        self._update_speed_label()
+
+
+    def _update_speed_label(self):
+        total_down = 0
+        total_up = 0
+        with state.downloads_lock:
+            active_items = list(state.active_downloads.values())
+        
+        for handle in active_items:
+            try:
+                s = handle.status()
+                total_down += s.download_rate
+                total_up += s.upload_rate
+            except Exception as e:
+                consoleLog(f"Exception while updating speed label: {e}")
+        down_kb = total_down / 1024
+        up_kb = total_up / 1024
+        down_text = f"{down_kb / 1024:.1f} MB/s" if down_kb > 1024 else f"{down_kb:.1f} kB/s"
+        up_text = f"{up_kb / 1024:.1f} MB/s" if up_kb > 1024 else f"{up_kb:.1f} kB/s"
+        
+            
+        if hasattr(self, 'speed_label'):
+            self.speed_label.setText(f"↓ {down_text}  ↑ {up_text}")
+
+    def mousePressEvent(self, event):
+        state.trackertable.clearSelection()
+        self.downloadList.clearSelection()
+        super().mousePressEvent(event)
+
+    def changeEvent(self, event):
+        super().changeEvent(event)
+
+    def closeEvent(self, event: QCloseEvent):
+        closehelper()
+        event.accept()
+        from utils.general.shutdown import force_exit
+        force_exit()
+
+    def _invalidate_hover_row(self, row):
+        if row >= 0 and self.download_model:
+            self.downloadList.viewport().update()
+
+    def set_tracker(self, _):
+        state.currenttracker = self.tracker_list.currentText()
+        self._apply_default_headers(state.trackertable)
+
+    def show_empty_results(self, show: bool):
+        if show:
+            state.trackertable.hide()
+            self.emptyResults.show()
+        else:
+            state.trackertable.show()
+            self.emptyResults.hide()
+
+    def show_empty_downloads(self):
+        with state.downloads_lock:
+            has_downloads = len(state.active_downloads) > 0
+        if has_downloads:
+            self.emptyDownload.hide()
+            self.downloadList.show()
+        else:
+            self.emptyDownload.show()
+            self.downloadList.hide()

src/interface/utils/searchhelper.py

@@ -0,0 +1,27 @@
+from utils.logging.logs import consoleLog
+from utils.data.state import state
+from data.sources import SCRAPERS
+
+for scraper in SCRAPERS:
+    state.trackers[scraper.name] = scraper
+
+def run_search(self) -> None:
+    state.trackertable.setRowCount(0)
+    self.show_empty_results(False)
+
+    search_text = self.searchbar.text()
+    # Check for empty search
+    if search_text == "":
+        consoleLog("Error: Can't search for nothing")
+        return
+
+    state.posts = []
+    self.searchbar.setEnabled(False)
+    consoleLog(f"User searched for: {search_text}")
+    
+    # Get current tracker and call its search function
+    scraper = state.trackers[state.currenttracker]
+    state.posts = scraper.search(search_text)
+    
+    # Update GUI headers to match the current scraper
+    self.search_results_signal.emit(scraper.headers)

src/interface/utils/svghelper.py

@@ -1,16 +1,13 @@
-
-
-from PySide6 import QtWidgets
-from PySide6.QtCore import Qt, QByteArray
 from PySide6.QtGui import QIcon, QPixmap, QPainter
+from PySide6.QtCore import Qt, QByteArray
 from PySide6.QtSvg import QSvgRenderer
+from PySide6 import QtWidgets
 import darkdetect
 
-
+# Check if darkmode is enabled
 def _is_dark_mode():
     return darkdetect.isDark()
 
-
 def svg_icon(svg_str, size=20):
     app = QtWidgets.QApplication.instance()
     if app:

src/interface/utils/tabhelper.py

@@ -0,0 +1,22 @@
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QLayout
+
+# Tab creation helper function
+def create_tab(title, items, tabs, stretch):
+    tab = QWidget()
+    layout = QVBoxLayout()
+
+    for item in items:
+        if item is None:
+            continue
+
+        if isinstance(item, QLayout):
+            layout.addLayout(item)
+        else:
+            layout.addWidget(item)
+
+    if stretch:
+        layout.addStretch()
+
+    tab.setLayout(layout)
+    tabs.addTab(tab, title)
+    return tab

src/main.py

@@ -1,66 +1,71 @@
-from core.interface.gui import MainWindow
-from core.utils.data.state import state
-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.logging.loghandler import split_data, check_completed, check_downloads
-from core.network.interface import list_interfaces, init_interfaces
-from core.utils.config.config import read_config
+from network.libtorrent_misc import send_notification, update_log, check_deleted_files
+from utils.logging.loghandler import split_data, check_completed, check_downloads
+from network.interface import list_interfaces, init_interfaces
+from utils.logging.logs import get_download_logs
+from utils.logging.logs import set_main_window
+from network.libtorrent_int import check_space
+from utils.general.shutdown import closehelper
+from utils.general.wrappers import run_thread
+from utils.general.shutdown import force_exit
+from utils.config.config import read_config
+from utils.logging.logs import consoleLog
+from interface.gui import MainWindow
+from utils.data.state import state
 from PySide6 import QtWidgets
 from PySide6.QtCore import Qt
 import qdarktheme
 import threading
 import platform
 import signal
-import sys
 import time
+import sys
 
 def run_gui():
     app = QtWidgets.QApplication.instance() or QtWidgets.QApplication(sys.argv)
     qdarktheme.setup_theme("auto")
     widget = MainWindow()
     
+    # Check OS for window transparency compatibility and apply
     if state.window_transparency and platform.system() != "Windows":
         widget.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
         qdarktheme.setup_theme("auto", custom_colors={"background": "#00000000"})
 
-    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()
 
+
 def main():
+    # Begin counting startup time
     start_time = time.perf_counter()
+    # Parse saved files
     read_config()
     logs = get_download_logs()
     _, downloads = split_data(logs)
+    # Initialize Keyboardinterrupt signal
     signal.signal(signal.SIGINT, keyboardinterrupthandler)
     consoleLog("Starting SoftwareManager...")
-    consoleLog("Fetching Network Interfaces...")
+    # Get network interface info
     list_interfaces()
-    consoleLog("Initializing Interface variables...")
     init_interfaces()
     consoleLog(f"Current Bound: {state.bound_interface}")
+    # Start background daemon threads
     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=(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")
+    # Start background non-daemon threads
+    run_thread(threading.Thread(target=check_completed, args=(downloads, state.autoresume)))
     run_thread(threading.Thread(target=check_downloads, args=(downloads,)))
-    consoleLog("Started Thread: check_downloads")
+    run_thread(threading.Thread(target=check_space, args=()))
+    # Finish counting startup time
     elapsed = time.perf_counter() - start_time
     consoleLog(f"Initialization completed in {elapsed:.2f}s. Launching GUI")
+    # Launch GUI
     run_gui()
 
 if __name__ == "__main__":
-    main()
+    main()

src/network/direct_download/__init__.py

@@ -1,15 +1,16 @@
+from utils.logging.logs import consoleLog, add_download_log
+from utils.data.state import state
 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 (
+
+from network.direct_download.handle import DirectDownloadHandle
+from network.direct_download.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):
+def add_direct_download(url: str, title: str, dl_path: Optional[str] = None, headers: Optional[dict] = None, single_threaded: bool = False):
 
     if dl_path is None:
         dl_path = state.download_path
@@ -24,7 +25,7 @@ def add_direct_download(url: str, title: str, dl_path: Optional[str] = None):
         or sanitize_filename(title) + ".zip"
     )
 
-    handle = DirectDownloadHandle(url, filename, dl_path)
+    handle = DirectDownloadHandle(url, filename, dl_path, headers, single_threaded)
     state.active_downloads[url] = handle
     add_download_log(title, url, "", False)
     handle.start()

src/network/direct_download/handle.py

@@ -1,17 +1,17 @@
-import os
-import threading
-import requests
-import json
-import hashlib
-import time
+from network.direct_download.status import DirectDownloadStatus, ChunkSpec
+from utils.logging.logs import consoleLog, update_download_completed
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from network.direct_download.utils import format_size
+from utils.data.state import state
 from typing import Optional
 import libtorrent as lt
+import threading
+import requests
+import hashlib
+import json
+import time
+import os
 
-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):
@@ -58,7 +58,7 @@ class DirectDownloadHandle:
         "Chrome/125.0.0.0 Safari/537.36"
     )
 
-    def __init__(self, url: str, name: str, save_path: str):
+    def __init__(self, url: str, name: str, save_path: str, headers: Optional[dict] = None, single_threaded: bool = False):
         self.url = url
         self._name = name
         self._save_path = save_path
@@ -69,6 +69,8 @@ class DirectDownloadHandle:
         self._thread: Optional[threading.Thread] = None
         self._session: Optional[requests.Session] = None
         self._supports_range = False
+        self._custom_headers = headers
+        self._single_threaded = single_threaded
         
         state_dir = os.path.join(state.settings_path, "direct_downloads")
         os.makedirs(state_dir, exist_ok=True)
@@ -132,14 +134,14 @@ class DirectDownloadHandle:
                     "chunks": chunks_done
                 }, f)
         except Exception as e:
-            pass
+            consoleLog(f"Exception while saving download state: {e}")
 
     def _clear_state(self):
         if os.path.exists(self._state_file):
             try:
                 os.remove(self._state_file)
-            except Exception:
-                pass
+            except Exception as e:
+                consoleLog(f"Exception while removing download state file: {e}")
 
 
     def start(self):
@@ -151,6 +153,8 @@ class DirectDownloadHandle:
     def _build_session(self) -> requests.Session:
         session = requests.Session()
         session.headers.update({"User-Agent": self.USER_AGENT})
+        if self._custom_headers is not None:
+            session.headers.update(self._custom_headers)
         adapter = requests.adapters.HTTPAdapter(
             max_retries=0,
             pool_connections=self.NUM_THREADS,
@@ -194,6 +198,7 @@ class DirectDownloadHandle:
             use_multithreaded = (
                 self._supports_range
                 and total_size > self.MIN_CHUNK_SIZE * 2
+                and not self._single_threaded
             )
 
             if use_multithreaded:
@@ -204,7 +209,7 @@ class DirectDownloadHandle:
                 self._preallocate_file(total_size)
                 self._multithreaded_download(total_size)
             else:
-                reason = "no range support" if not self._supports_range else "file too small"
+                reason = "no range support" if not self._supports_range else "file too small or single-threaded mode"
                 consoleLog(f"Single-threaded download ({reason}): {self._name}")
                 self._single_threaded_download()
 
@@ -439,5 +444,4 @@ class DirectDownloadHandle:
             raise RuntimeError(
                 f"Size mismatch: expected {format_size(expected_size)}, "
                 f"got {format_size(actual_size)}"
-            )
-
+            )

src/network/direct_download/status.py

@@ -1,8 +1,8 @@
-import threading
-import time
 from dataclasses import dataclass
 from typing import Optional
 import libtorrent as lt
+import threading
+import time
 
 
 @dataclass

src/network/direct_download/utils.py

@@ -1,7 +1,8 @@
-import os
-import requests
-from typing import Optional
 from urllib.parse import urlparse, unquote
+from utils.logging.logs import consoleLog
+from typing import Optional
+import requests
+import os
 
 def sanitize_filename(name: str) -> str:
     # Remove or replace dangerous characters
@@ -36,8 +37,8 @@ def detect_filename_from_headers(url: str, user_agent: str) -> Optional[str]:
                 fname = parts[-1].strip().strip('"').strip("'")
                 if fname:
                     return fname
-    except Exception:
-        pass
+    except Exception as e:
+        consoleLog(f"Exception while retrieving filename from headers: {e}")
     return None
 
 def format_size(size_bytes: int) -> str:

src/network/interface.py

@@ -1,5 +1,5 @@
-from core.utils.logging.logs import consoleLog
-from core.utils.data.state import state
+from utils.logging.logs import consoleLog
+from utils.data.state import state
 import psutil
 
 def get_net_interfaces():
@@ -29,6 +29,7 @@ def get_active_interfaces():
 
 
 def list_interfaces() -> None:
+    consoleLog("Fetching Network Interfaces...")
     addrs = psutil.net_if_addrs()
     stats = psutil.net_if_stats()
 
@@ -45,6 +46,7 @@ def list_interfaces() -> None:
         consoleLog(f"Found Interface: {interface} [{status}]")
 
 def init_interfaces():
+    consoleLog("Initializing Interface variables...")
     addrs = psutil.net_if_addrs()
     state.interfaces = list(addrs.keys())
     state.active_interfaces = get_active_interfaces()

src/network/libtorrent_int.py

@@ -1,16 +1,15 @@
-import time
-import os
+from network.interface import get_interface_ip
+from utils.general.wrappers import run_thread
+from utils.logging.logs import consoleLog
+from utils.data.state import state
+import libtorrent as lt
+import threading
 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.logging.logs import consoleLog
+import time
+import os
 
 
-global loop_running
 loop_running = False
 
 def get_free_space_mb(dirname):
@@ -22,6 +21,25 @@ def get_free_space_mb(dirname):
         st = os.statvfs(dirname)
         return st.f_bavail * st.f_frsize
 
+def check_space():
+    while not state.shutdown_event.is_set():
+        for _, magnetdl in list(state.active_downloads.items()):
+            try:
+                status = magnetdl.status()
+            except RuntimeError:
+                continue
+            
+            if status.state == lt.torrent_status.downloading:
+                free_space = get_free_space_mb(state.download_path)
+                total_size = status.total_wanted
+
+                if free_space < total_size:
+                    consoleLog(f"Not enough free space to continue downloading: {status.name}")
+                    magnetdl.pause()
+                    break
+        
+        time.sleep(5)
+
 def init_session():
     if state.dl_session is not None:
         return
@@ -61,7 +79,6 @@ def add_download(magnet_uri):
         state.active_downloads = {}
 
     init_session()
-
     free_space = get_free_space_mb(state.download_path)
 
     if magnet_uri in state.active_downloads:
@@ -92,7 +109,6 @@ def add_download(magnet_uri):
         params.save_path = state.download_path
 
         handle = state.dl_session.add_torrent(params)
-
         while not handle.has_metadata():
             time.sleep(1)
 
@@ -103,7 +119,6 @@ def add_download(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

src/network/libtorrent_misc.py

@@ -1,10 +1,10 @@
-from core.utils.data.state import state
-from core.utils.logging.logs import update_download_completed_by_hash
-from core.utils.logging.logs import consoleLog
+from utils.logging.logs import update_download_completed_by_hash
+from utils.logging.logs import consoleLog
+from utils.data.state import state
 from plyer import notification
 import libtorrent as lt
-import os
 import time
+import os
 
 
 def cleanup_session():
@@ -17,9 +17,6 @@ def cleanup_session():
         state.dl_session = None
         state.active_downloads.clear()
 
-
-
-
 def send_notification(shutdown_event):
     notified = set()
     while not shutdown_event.is_set():
@@ -37,8 +34,8 @@ def send_notification(shutdown_event):
                         timeout=4
                     )
                     notified.add(magnet_uri)
-        except Exception:
-            pass
+        except Exception as e:
+            consoleLog(f"Exception while sending notification: {e}")
         time.sleep(5)
 
 def update_log(shutdown_event):
@@ -59,8 +56,8 @@ def update_log(shutdown_event):
                         info_hash = str(status.info_hash)
                     update_download_completed_by_hash(info_hash, True)
                     updated.add(magnet_uri)
-        except Exception:
-            pass
+        except Exception as e:
+            consoleLog(f"Exception while updating log file: {e}")
         time.sleep(5)
 
 def check_deleted_files(shutdown_event):
@@ -79,6 +76,6 @@ def check_deleted_files(shutdown_event):
                         consoleLog(f"Registered File Deletion: {status.name}")
                         state.dl_session.remove_torrent(magnetdl)
                         del state.active_downloads[magnet_uri]
-        except Exception:
-            pass
+        except Exception as e:
+            consoleLog(f"Exception while checking for file deletions: {e}")
         time.sleep(5)

src/network/libtorrent_wrapper.py

@@ -1,5 +1,6 @@
-from core.utils.logging.logs import consoleLog
-from core.network.libtorrent_int import add_download
+from network.libtorrent_int import add_download
+from utils.logging.logs import consoleLog
+
 
 def add_magnet(uri):
     if uri is not None and uri.startswith("magnet:?"):  

src/utils/config/config.py

@@ -1,4 +1,4 @@
-from core.utils.data.state import state
+from utils.data.state import state
 import configparser
 import platform
 import os

src/utils/config/settings.py

@@ -1,7 +1,8 @@
-from core.network.libtorrent_int import update_settings
-from core.utils.data.state import state
-from core.utils.logging.logs import consoleLog
-from .config import create_config
+from network.libtorrent_int import update_settings
+from utils.config.config import create_config
+from utils.logging.logs import consoleLog
+from utils.data.state import state
+
 
 
 def save_settings(close=lambda: None, apiurl=None, download_path=None, down_speed_limit=None, up_speed_limit=None, image_path=None, autoresume=None, max_connections=None, max_downloads=None, bound_interface=None):

src/utils/data/state.py

@@ -1,51 +1,52 @@
-import threading
 from PySide6.QtCore import QObject, Signal
 from PySide6.QtWidgets import QTableWidget
 from typing import Any, List, Dict
 from pathlib import Path
+import threading
 
 class AppState(QObject):
     image_changed = Signal(str)
 
     def __init__(self):
         super().__init__()
-        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.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()
+        # General
+        self.version: str = "Unknown"
+        self.debug: bool = False
+        self.main_window: Any = None
+        self.loop_running: bool = False
+        self.shutdown_event = threading.Event()
+        self.log_buffer: List[str] = []
+
+        # Paths
+        self.settings_path: str = ""
+        self._image_path: str = ""
         self.download_path: str = str(Path.home() / "Downloads")
+
+        # GUI
+        self.window_transparency: bool = False
+        self.trackertable: QTableWidget
+        self.interfaces: List = []
+        self.active_interfaces: List = []
+        self.bound_interface: Any = None
+
+        # Trackers / Scraping
+        self.posts: list[Dict[str,str]] | None = None  # titles, urls, author, seeders, leechers
+        self.currenttracker: str = "rutracker"
+        self.api_url: str = "https://api.michijackson.xyz"
+        self.trackers: Dict[str,Dict[str,Any]] = {}
+
+        # LibTorrent / Download related stuff
+        self.dl_session: Any = None
+        self.active_downloads: Dict = {}
+        self.seeded_magnets: set = set()
+        self.ignore_updates: bool = False
+        self.autoresume: bool = True
         self.up_speed_limit: int = 0
         self.down_speed_limit: int = 0
         self.max_connections: int = 200
         self.max_downloads: int = 10
-        self.settings_path: str = "" 
-        self.dl_session: Any = None
-        self.active_downloads: Dict = {}
-        self.window_transparency: bool = False
-        self.interfaces: List = []
-        self.active_interfaces: List = []
-        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:

src/utils/data/tracker.py

@@ -1,6 +1,6 @@
-import requests
+from utils.logging.logs import consoleLog
 from bs4 import BeautifulSoup
-from core.utils.logging.logs import consoleLog
+import requests
 
 
 def get_magnet_link(post_url):
@@ -15,6 +15,7 @@ def get_magnet_link(post_url):
             return magnet_link['href']
         else:
             consoleLog("Magnet Link not Found!")
+            return None
     except requests.RequestException as e:
         consoleLog(f"Failed to fetch {post_url}: {e}")
         return None

src/utils/general/shutdown.py

@@ -0,0 +1,14 @@
+from network.libtorrent_misc import cleanup_session
+from utils.logging.logs import consoleLog
+from utils.data.state import state
+import os
+
+def closehelper():
+    state.shutdown_event.set()
+    try:
+        cleanup_session()
+    except Exception as e:
+        consoleLog(f"Exception while cleaning up LibTorrent Session: {e}")
+
+def force_exit():
+    os._exit(0)

src/utils/general/wrappers.py

@@ -0,0 +1,9 @@
+from utils.logging.logs import consoleLog
+
+def run_thread(thread):
+    target_name = thread._target.__name__
+    try:
+        thread.start()
+        consoleLog(f"Started Thread: {target_name}")
+    except Exception as e:
+        consoleLog(f"Exception while starting thread {target_name}: {e}")

src/utils/logging/loghandler.py

@@ -1,5 +1,5 @@
-from core.utils.logging.logs import consoleLog, remove_download_log
-from core.utils.network.download import run_download_direct, seed_magnet
+from utils.network.download import run_download_direct, seed_magnet
+from utils.logging.logs import consoleLog, remove_download_log
 import os
 
 def split_data(data):
@@ -14,13 +14,12 @@ def check_completed(downloads, resume):
         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)
+                    run_download_direct(download.magnet_uri, 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)
+                    from network.direct_download import add_direct_download
+                    add_direct_download(download.url, download.title)
                     consoleLog(f"Resuming Direct Download: {download.title}")
 
 def check_downloads(downloads):

src/utils/logging/logs.py

@@ -1,12 +1,12 @@
-from core.utils.data.models import Download, DownloadList
-from core.utils.data.state import state
+from utils.data.models import Download, DownloadList
+from utils.data.state import state
 from dataclasses import asdict
 from datetime import datetime
 import json
+import time
 import os
 import re
-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
@@ -243,12 +243,12 @@ def set_main_window(window):
 def flush_log_buffer(): # credits to claude
     if state.log_buffer:
         try:
-            from core.interface.gui import MainWindow
+            from interface.gui import MainWindow
             for log_entry in state.log_buffer:
                 MainWindow.add_log(log_entry)
             state.log_buffer = []
-        except Exception:
-            pass
+        except Exception as e:
+            consoleLog(f"Exception while flushing log buffer: {e}")
 
 def consoleLog(text, printAnyways = False):
     now = datetime.now()
@@ -256,7 +256,7 @@ def consoleLog(text, printAnyways = False):
     formatted_text = f"[{current_time}] {text}"
 
     try:
-        from core.interface.gui import MainWindow
+        from interface.gui import MainWindow
         if not MainWindow.add_log(formatted_text):
             state.log_buffer.append(formatted_text)
     except Exception:

src/utils/network/download.py

@@ -1,17 +1,17 @@
+from network.direct_download import add_direct_download
+from network.libtorrent_wrapper import add_magnet
 from PySide6.QtWidgets import QTableWidgetItem
+from utils.logging.logs import add_download_log
+from utils.general.wrappers import run_thread
+from network.libtorrent_int import add_seed
+from utils.logging.logs import consoleLog
+from utils.data.state import state
 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.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
+from typing import Optional
 import threading
 
 
 
-
 def download_selected(items: list[QTableWidgetItem]):
     if not items:
         consoleLog("No item selected for download.")
@@ -30,18 +30,21 @@ def download_selected(items: list[QTableWidgetItem]):
             consoleLog(f"Downloading {post.get('title', 'Unknown')}")
             run_thread(threading.Thread(target=run_download, args=(post,)))
 
-def run_download(post):
-    linkfunc = state.trackers[state.currenttracker]["linkFunc"]
-    ismagnet = state.trackers[state.currenttracker]["isMagnet"]
-    link = linkfunc(post)
+def run_download(post, headers: Optional[dict] = None):
+    link_method = state.trackers[state.currenttracker].get_download_link
+    ismagnet = state.trackers[state.currenttracker].is_magnet
+    result = link_method(post)
 
     if ismagnet:
+        link = result
         add_magnet(link)
         add_download_log(post.get("title", "Unknown"), "", link, False)
     else:
-        add_direct_download(link, post.get("title", "Unknown"))
+        link, link_headers = result if isinstance(result, tuple) else (result, None)
+        final_headers = headers or link_headers
+        add_direct_download(link, post.get("title", "Unknown"), headers=final_headers, single_threaded=final_headers is not None)
 
-def run_download_direct(magnet_uri, dl_path=None, title="Direct Download"):
+def run_download_direct(magnet_uri, title="Direct Download"):
     consoleLog(f"Magnet: {title}")
     add_magnet(magnet_uri)
     add_download_log(title, "", magnet_uri, False)

src/utils/network/update_checker.py

@@ -1,6 +1,7 @@
+from utils.logging.logs import consoleLog
+from utils.data.state import state
 import requests
-from core.utils.data.state import state
-from core.utils.logging.logs import consoleLog
+
 
 def get_updates():
     url = f"https://api.github.com/repos/KeksPirates/SoftwareManager/releases/latest"
@@ -8,11 +9,11 @@ def get_updates():
         response = requests.get(url, timeout=15)
     except requests.RequestException as e:
         consoleLog(f"Failed to fetch releases: {e}")
-        return None
+        return None, None
 
     if response.status_code != 200:
         consoleLog(f"Failed to fetch releases: {response.status_code}")
-        return None
+        return None, None
 
     release = response.json()
 

src/utils/network/updater.py

@@ -0,0 +1,96 @@
+from network.direct_download.handle import DirectDownloadHandle
+from utils.logging.logs import consoleLog
+from utils.data.state import state
+from PySide6.QtCore import Qt
+from PySide6 import QtWidgets
+import libtorrent as lt
+import subprocess
+import tempfile
+import hashlib
+import time
+import sys
+import os
+
+
+def _verify_hash(file_path: str, expected_hash: str) -> bool:
+    sha256 = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            sha256.update(chunk)
+    return f"sha256:{sha256.hexdigest()}" == expected_hash
+
+
+def download_update(assets: list):
+    filename = None
+    setup_hash = None
+    url = None
+
+    for asset in assets:
+        if "-windows-setup.exe" in asset["name"]:
+            filename = asset["name"]
+            setup_hash = asset["hash"]
+            url = asset["url"]
+            break
+
+    if not filename:
+        consoleLog("Error: No Windows installer found in release assets")
+        return
+
+    installer_path = os.path.join(tempfile.gettempdir(), filename)
+
+    progress = QtWidgets.QProgressDialog("Downloading update... (0.0 MB/s)", None, 0, 100)
+    progress.setWindowTitle("Updating")
+    progress.setWindowModality(Qt.WindowModality.ApplicationModal)
+    progress.setCancelButton(None)
+    progress.setMinimumDuration(0)
+    progress.setAutoClose(False)
+    progress.setAutoReset(False)
+    progress.setValue(0)
+    progress.show()
+    QtWidgets.QApplication.processEvents()
+
+    original_limit = state.down_speed_limit
+    state.down_speed_limit = 0
+    handle = DirectDownloadHandle(url, filename, tempfile.gettempdir())
+    handle.start()
+
+    while True:
+        QtWidgets.QApplication.processEvents()
+        status = handle.status()
+
+        if status.error:
+            state.down_speed_limit = original_limit
+            progress.close()
+            consoleLog(f"Update download failed: {status.error}")
+            return
+
+        if status.total_wanted > 0:
+            pct = int(status.total_wanted_done * 100 / status.total_wanted)
+            speed_mb = status.download_rate / (1024 * 1024)
+            progress.setValue(pct)
+            progress.setLabelText(f"Downloading update... ({speed_mb:.1f} MB/s)")
+
+        if status.state == lt.torrent_status.seeding:
+            break
+
+        time.sleep(0.1)
+
+    state.down_speed_limit = original_limit
+
+    if setup_hash:
+        if _verify_hash(installer_path, setup_hash):
+            consoleLog(f"Successfully validated installer hash ({setup_hash})")
+        else:
+            progress.close()
+            consoleLog("Error: Invalid file hash, file may be corrupted")
+            sys.exit(0)
+    else:
+        consoleLog("Skipping hash verification (no hash found for release)")
+
+    progress.setLabelText("Installing update...")
+    progress.setValue(100)
+    QtWidgets.QApplication.processEvents()
+
+    subprocess.Popen([installer_path, "/VERYSILENT", "/SUPPRESSMSGBOXES", "/SP-", "/CLOSEAPPLICATIONS"])
+    time.sleep(1)
+    sys.exit(0)