Merge pull request #45 from KeksPirates/feat/improve-code-quality

feat: improve code quality

README.md

@@ -62,12 +62,6 @@ SoftwareManager is a Python-based GUI tool that simplifies searching and downloa
    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=KeksPirates/SoftwareManager&type=date&legend=top-left" />
  </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.

requirements.txt

@@ -8,4 +8,4 @@ aiohttp==3.13.0
 plyer==2.1.0
 psutil==7.1.0
 libtorrent==2.0.11
-libtorrent-windows-dll==0.0.3
+libtorrent-windows-dll==0.0.3

src/core/data/scrapers/monkrus.py

@@ -1,4 +1,7 @@
+from core.utils.data.tracker import get_magnet_link
+from core.utils.data.state import state
 from bs4 import BeautifulSoup
+from typing import Dict
 import requests
 import time
 
@@ -31,7 +34,7 @@ def _get_telegram_posts():
         
         for bubble in bubbles:
             post_txt = bubble.find("div", class_="tgme_widget_message_text js-message_text")
-            if not post_txt or not post_txt.b:
+            if post_txt is None or post_txt.b is None:
                 continue
             
             title = post_txt.b.text
@@ -42,9 +45,9 @@ def _get_telegram_posts():
                 if post_url not in added:
                     added.add(post_url)
                     posts.append(dict(
+                        title=title,
                         author="m0nkrus",
                         id=len(posts) + 1,
-                        title=title,
                         url=post_url
                     ))
         
@@ -67,4 +70,18 @@ def scrape_m0nkrus(query):
             filtered_post["id"] = len(filtered_posts) + 1
             filtered_posts.append(filtered_post)
 
-    return filtered_posts
+    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/buzzheavier.py

@@ -0,0 +1,18 @@
+import requests
+
+def scrape_buzzheavier(url):
+
+    response = requests.get(url)
+    response.raise_for_status()
+
+    download_url = url + '/download'
+
+    headers = {
+        'hx-current-url': url,
+        'hx-request': 'true',
+        'referer': url
+    }
+    
+    head_response = requests.head(download_url, headers=headers, allow_redirects=False)
+    hx_redirect = head_response.headers.get('hx-redirect')
+    return hx_redirect

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

@@ -0,0 +1,41 @@
+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()
+
+    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/core/data/scrapers/rutracker.py

@@ -1,19 +1,52 @@
-import requests
-from core.utils.data.state import state
+from core.utils.network.jsonhandler import split_data, format_data
+from core.utils.data.tracker import get_magnet_link
 from core.utils.logging.logs import consoleLog
+from core.utils.data.state import state
+from typing import Dict
+import requests
 
 def scrape_rutracker(query):
-    search = requests.get(f"{state.api_url}/search?q={query}")
+    search = requests.get(f"{state.api_url}/search?q={query}", timeout=15)
     consoleLog("Sent request to server")
     if search:
-        try:
-            return search.text
-        except Exception:
-            consoleLog("No results found / No response from server")
-            return None
+        _, data, _, success, cached = split_data(search.text)
+        if cached:
+            consoleLog("Server response cached")
+        if success:
+            sorted_data = []
+
+            for entry in data:
+                sorted_data.append(
+                    {
+                        "title" : entry["title"],
+                        "author" : entry["author"],
+                        "seeders" : entry["seeders"],
+                        "leechers" : entry["leechers"],
+                        "url" : entry["url"],
+                        "id" : entry["id"],
+                    }
+                )
+
+            return sorted_data
+        else: 
+            consoleLog("Scraping failed server-side, unable to fetch posts from rutracker")
+            return []
     else:
-        return None
-        
+        consoleLog("No response from server, returning nothing")
+        return []
 
 
-# This function utilizes the SoftwareManager server - source code can be found under the SoftwareManager-Server repository.
+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

@@ -0,0 +1,122 @@
+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 time
+import re
+
+
+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
+
+    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:
+        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 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,7 +1,11 @@
-import requests
-from bs4 import BeautifulSoup
-from urllib.parse import urljoin
+from core.utils.data.tracker import get_magnet_link
 from core.utils.logging.logs import consoleLog
+from core.utils.data.state import state
+from urllib.parse import urljoin
+from bs4 import BeautifulSoup
+from typing import Dict
+import requests
+
 
 def scrape_uztracker(query):
     base_url="https://uztracker.net/"
@@ -26,12 +30,26 @@ def scrape_uztracker(query):
 
             posts.append(dict(
                 title=title,
+                author=author,
                 url=url,
-                author=author
             ))
 
         return posts
 
     except requests.RequestException as e:
         consoleLog(f"Failed to fetch {search_url}: {e}")
-        return None
+        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/dialogs/contextmenu.py

@@ -0,0 +1,149 @@
+from core.utils.logging.logs import consoleLog, remove_download_log
+from PySide6.QtWidgets import QMessageBox
+from core.utils.data.state import state
+from PySide6.QtCore import Qt, QPoint
+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:
+                    pass
+
+            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:
+                    pass
+            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/core/interface/dialogs/downloadlist.py

@@ -0,0 +1,88 @@
+from core.interface.dialogs.pauseresumedelegate import PauseResumeDelegate
+from core.interface.dialogs.hoverrowdelegate import HoverRowDelegate
+from core.interface.dialogs.downloadmodel import DownloadModel
+from core.interface.dialogs.theme import _table_stylesheet
+from PySide6.QtWidgets import QTableView, QHeaderView
+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:
+                            pass

src/core/interface/dialogs/downloadmodel.py

@@ -0,0 +1,136 @@
+from PySide6.QtCore import QAbstractTableModel, QModelIndex, Qt
+from core.utils.logging.logs import consoleLog
+from core.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:
+                pass
+            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/core/interface/dialogs/elideditemdelegate.py

@@ -0,0 +1,22 @@
+from core.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/core/interface/dialogs/eventfilter.py

@@ -0,0 +1,35 @@
+from core.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):
+        pass
+    return super(type(self), self).eventFilter(obj, event)

src/core/interface/dialogs/hoverrowdelegate.py

@@ -0,0 +1,19 @@
+from core.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 core.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/core/interface/dialogs/image.py

@@ -0,0 +1,29 @@
+from PySide6.QtGui import QImage, QPixmap
+from core.utils.data.state import state
+from PySide6.QtWidgets import QLabel
+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/core/interface/dialogs/pauseresumedelegate.py

@@ -0,0 +1,86 @@
+from core.interface.dialogs.theme import _theme_colors, SVG_PLAY, SVG_PAUSE, SVG_FOLDER
+from PySide6.QtWidgets import QStyledItemDelegate, QWidget, QHBoxLayout
+from core.interface.utils.svghelper import svg_icon
+from PySide6.QtCore import Qt, QSize, Signal
+from core.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 core.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/core/interface/dialogs/settings.py

@@ -1,11 +1,12 @@
-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.utils.config.settings import save_settings
+from core.interface.utils.tabhelper import paths_tab
+from core.interface.utils.svghelper import svg_icon
+from core.utils.logging.logs import consoleLog
+from core.utils.data.state import state
+from PySide6.QtCore import Qt, QSize
 from PySide6 import QtWidgets
-from PySide6.QtCore import Qt
 from PySide6.QtWidgets import (
     QLineEdit, 
     QPushButton, 
@@ -20,8 +21,11 @@ from PySide6.QtWidgets import (
     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>'
+
 
 def settings_dialog(self):
 
@@ -30,7 +34,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)
@@ -51,7 +56,6 @@ def settings_dialog(self):
             update_checkbox.setChecked(state.ignore_updates)
             update_checkbox.toggled.connect(lambda checked: setattr(state, 'ignore_updates', checked))
             update_checkbox_layout.addWidget(update_checkbox)
-            dialog.layout().addWidget(update_checkbox_container)
 
         # auto-resume downloads checkbox
 
@@ -90,7 +94,7 @@ def settings_dialog(self):
         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)
 
@@ -104,7 +108,7 @@ def settings_dialog(self):
         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)
 
@@ -113,7 +117,19 @@ def settings_dialog(self):
             if dir_path:
                 download_path.setText(dir_path)
 
-        browse_button = QPushButton("📁")
+        browse_button = QPushButton()
+        browse_button.setFixedSize(36, 36)
+        browse_button.setIconSize(QSize(24, 24))
+        browse_button.setIcon(svg_icon(SVG_FOLDER, 24))
+        browse_button.setCursor(Qt.CursorShape.PointingHandCursor)
+        browse_button.setStyleSheet("""
+            QPushButton {
+                border: none;
+                background: transparent;
+                padding: 0px;
+            }
+        """)
+
         download_path_layout.addWidget(browse_button)
         browse_button.clicked.connect(browse_download_path)
 
@@ -121,24 +137,35 @@ def settings_dialog(self):
         # IMAGE PATH #
         ###############
 
-        # image_path_container = QWidget()
-        # image_path_layout = QHBoxLayout()
+        image_path_container = QWidget()
+        image_path_layout = QHBoxLayout()
 
-        # image_path = QLineEdit()
-        # image_path_layout.addWidget(QLabel("Image Path (requires restart):"))
-        # image_path_layout.addWidget(image_path)
-        # image_path_container.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
-        # image_path_container.setLayout(image_path_layout)
-        # image_path.setText(state.image_path)
+        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.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
+        image_path_container.setLayout(image_path_layout)
+        image_path.setText(state.image_path)
 
-        # def browse_image_path():
-        #     file_path = QFileDialog.getOpenFileName(dialog, "Select Image File", state.image_path, "Image Files (*.png *.jpg)")[0]
-        #     if file_path:
-        #         image_path.setText(file_path)
+        def browse_image_path():
+            file_path = QFileDialog.getOpenFileName(dialog, "Select Image File", state.image_path, "Image Files (*.png *.jpg)")[0]
+            if file_path:
+                image_path.setText(file_path)
 
-        # browse_button = QPushButton("📁")
-        # image_path_layout.addWidget(browse_button)
-        # browse_button.clicked.connect(browse_image_path)
+        browse_button = QPushButton()
+        browse_button.setFixedSize(36, 36)
+        browse_button.setIconSize(QSize(24, 24))
+        browse_button.setIcon(svg_icon(SVG_FOLDER, 24))
+        browse_button.setCursor(Qt.CursorShape.PointingHandCursor)
+        browse_button.setStyleSheet("""
+            QPushButton {
+                border: none;
+                background: transparent;
+                padding: 0px;
+            }
+        """)
+        image_path_layout.addWidget(browse_button)
+        browse_button.clicked.connect(browse_image_path)
 
         ##################
         # SPEED LIMITING #
@@ -244,7 +271,7 @@ def settings_dialog(self):
             download_path.text(), 
             down_speed_limit.value(), 
             up_speed_limit.value(), 
-            None,
+            image_path.text(), 
             autoresume_checkbox.isChecked(), 
             max_connections.value(), 
             max_downloads.value(), 
@@ -256,10 +283,10 @@ def settings_dialog(self):
 
         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, 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)
 
-        dialog.layout().addWidget(self.tabs)
-        dialog.layout().addLayout(layout)
+        dialog_layout.addWidget(self.tabs)
+        dialog_layout.addLayout(layout)
 
         dialog.exec()

src/core/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/core/interface/dialogs/trackerhoverdelegate.py

@@ -0,0 +1,14 @@
+from core.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/core/interface/dialogs/trackertable.py

@@ -0,0 +1,26 @@
+from core.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/core/interface/dialogs/update.py

@@ -0,0 +1,31 @@
+from core.utils.network.update_checker import get_updates
+from core.utils.network.updater import download_update
+from PySide6.QtWidgets import QDialog, QMessageBox
+from core.utils.data.state import state
+import platform
+import json
+import os
+
+def check_version():
+    build_info_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "build_info.json")
+    if 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")
+
+
+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/core/interface/utils/searchhelper.py

@@ -1,66 +1,26 @@
-from PySide6.QtWidgets import QTableWidgetItem
+from core.data.scrapers.rutracker import init_rutracker
+from core.data.scrapers.uztracker import init_uztracker
+from core.data.scrapers.steamrip import init_steamrip
+from core.data.scrapers.monkrus import init_m0nkrus
 from core.utils.logging.logs import consoleLog
-from core.data.scrapers.uztracker import scrape_uztracker
-from core.data.scrapers.rutracker import scrape_rutracker
-from core.data.scrapers.monkrus import scrape_m0nkrus
-from core.utils.network.jsonhandler import split_data, format_data, format_data_minimal
 from core.utils.data.state import state
 
-scrapers = {
-    "uztracker": scrape_uztracker,
-    "rutracker": scrape_rutracker,
-    "m0nkrus": scrape_m0nkrus
-}
+init_rutracker()
+init_uztracker()
+init_m0nkrus()
+init_steamrip()
 
 def return_pressed(self):
+    self.show_empty_results(False)
     search_text = self.searchbar.text()
     if search_text == "":
         consoleLog("Error: Can't search for nothing")
         return
     consoleLog(f"User searched for: {search_text}")
     
-    if state.tracker == "rutracker":
-        response = scrape_rutracker(search_text)
-        if response:
-            _, state.posts, _, _, cached = split_data(response)
-            if state.posts == []:
-                consoleLog(f"No Results for {search_text}")
-                state.tracker_list[state.tracker].clear()
-                self.show_empty_results(True)
-            else:
-                state.post_titles, _, state.post_author, state.post_seeders, state.post_leechers = format_data(state.posts)
-                self.show_empty_results(False)
-                state.tracker_list[state.tracker].clear()
-                state.tracker_list[state.tracker].setHorizontalHeaderLabels(["Post Title", "Author", "Seeders", "Leechers"])
-                state.tracker_list[state.tracker].setRowCount(len(state.post_titles))
-                for i, author in enumerate(state.post_author):
-                    state.tracker_list[state.tracker].setItem(i, 1, QTableWidgetItem(author))
-                for i, title in enumerate(state.post_titles):
-                    state.tracker_list[state.tracker].setItem(i, 0, QTableWidgetItem(title))
-                for i, seeders in enumerate(state.post_seeders):
-                    state.tracker_list[state.tracker].setItem(i, 2, QTableWidgetItem(seeders))
-                for i, leechers in enumerate(state.post_leechers):
-                    state.tracker_list[state.tracker].setItem(i, 3, QTableWidgetItem(leechers))
-                if state.debug == True:
-                    consoleLog(f"Response Cached: {cached}")
-        else:
-            consoleLog(f"No response from rutracker")
-            state.tracker_list[state.tracker].clear()
-            self.show_empty_results(True)
+    tracker = state.trackers[state.currenttracker]
+    scrapefunc = tracker["scrapeFunc"]
+    state.posts = scrapefunc(search_text)
 
-    elif state.tracker is not None:
-        state.posts = scrapers[state.tracker](search_text)
-        if not state.posts:
-            consoleLog(f"No Results for {search_text}")
-            state.tracker_list[state.tracker].clear()
-            self.show_empty_results(True)
-        else:
-            state.post_author, state.post_titles, state.post_urls = format_data_minimal(state.posts)
-            self.show_empty_results(False)
-            state.tracker_list[state.tracker].clear()
-            state.tracker_list[state.tracker].setHorizontalHeaderLabels(["Post Title", "Author"])
-            state.tracker_list[state.tracker].setRowCount(len(state.post_titles))
-            for i, author in enumerate(state.post_author):
-                state.tracker_list[state.tracker].setItem(i, 1, QTableWidgetItem(author))
-            for i, title in enumerate(state.post_titles):
-                state.tracker_list[state.tracker].setItem(i, 0, QTableWidgetItem(title))
+    from core.interface.gui import MainWindow
+    MainWindow._instance.search_results_signal.emit(tracker["headers"])

src/core/interface/utils/svghelper.py

@@ -0,0 +1,30 @@
+
+
+from PySide6 import QtWidgets
+from PySide6.QtCore import Qt, QByteArray
+from PySide6.QtGui import QIcon, QPixmap, QPainter
+from PySide6.QtSvg import QSvgRenderer
+import darkdetect
+
+
+def _is_dark_mode():
+    return darkdetect.isDark()
+
+
+def svg_icon(svg_str, size=20):
+    app = QtWidgets.QApplication.instance()
+    if app:
+        if _is_dark_mode():
+            color = "white"
+        else:
+            color = "#555555"
+    else:
+        color = "white"
+    svg = svg_str.replace("{color}", color)
+    renderer = QSvgRenderer(QByteArray(svg.encode()))
+    pixmap = QPixmap(size, size)
+    pixmap.fill(Qt.GlobalColor.transparent)
+    painter = QPainter(pixmap)
+    renderer.render(painter)
+    painter.end()
+    return QIcon(pixmap)

src/core/interface/utils/tabhelper.py

@@ -30,11 +30,11 @@ def general_tab(title, autoresume, update_checkbox, transparent_window, tabs):
     tabs.addTab(tab, title)
     return tab
 
-def paths_tab(title, download_path, tabs):
+def paths_tab(title, download_path, image_path, tabs):
     tab = QWidget()
     layout = QVBoxLayout()
     layout.addWidget(download_path)
-    # layout.addWidget(image_path)
+    layout.addWidget(image_path)
     layout.addStretch()
     tab.setLayout(layout)
     tabs.addTab(tab, title)

src/core/network/direct_download/__init__.py

@@ -0,0 +1,31 @@
+from typing import Optional
+from core.utils.data.state import state
+from core.utils.logging.logs import consoleLog, add_download_log
+
+from .handle import DirectDownloadHandle
+from .utils import (
+    sanitize_filename,
+    extract_filename_from_url,
+    detect_filename_from_headers,
+)
+
+def add_direct_download(url: str, title: str, dl_path: Optional[str] = None, headers: Optional[dict] = None, single_threaded: bool = False):
+
+    if dl_path is None:
+        dl_path = state.download_path
+
+    if url in state.active_downloads:
+        consoleLog(f"Download already active: {title}")
+        return
+
+    filename = (
+        detect_filename_from_headers(url, DirectDownloadHandle.USER_AGENT)
+        or extract_filename_from_url(url)
+        or sanitize_filename(title) + ".zip"
+    )
+
+    handle = DirectDownloadHandle(url, filename, dl_path, headers, single_threaded)
+    state.active_downloads[url] = handle
+    add_download_log(title, url, "", False)
+    handle.start()
+    consoleLog(f"Started direct download: {filename}")

src/core/network/direct_download/handle.py

@@ -0,0 +1,447 @@
+from core.utils.logging.logs import consoleLog, update_download_completed
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from .status import DirectDownloadStatus, ChunkSpec
+from core.utils.data.state import state
+from .utils import format_size
+from typing import Optional
+import libtorrent as lt
+import threading
+import requests
+import hashlib
+import json
+import time
+import os
+
+
+class SimpleThrottler:
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._last_time = time.monotonic()
+        self._allowance = 0.0
+
+    def throttle(self, bytes_count: int, limit_kbps: int):
+        if limit_kbps <= 0:
+            return
+
+        limit_bps = limit_kbps * 1024
+        wait_time = 0
+        with self._lock:
+            now = time.monotonic()
+            elapsed = now - self._last_time
+            self._last_time = now
+            
+            self._allowance += elapsed * limit_bps
+            if self._allowance > 2 * limit_bps:
+                self._allowance = 2 * limit_bps
+                
+            self._allowance -= bytes_count
+            
+            if self._allowance < 0:
+                wait_time = -self._allowance / limit_bps
+                self._allowance = 0
+        
+        if wait_time > 0:
+            time.sleep(min(wait_time, 1.0))
+
+_throttler = SimpleThrottler()
+
+class DirectDownloadHandle:
+    STREAM_BLOCK_SIZE = 1 << 17  # 128 KiB per read
+    MAX_RETRIES = 5
+    RETRY_BACKOFF_BASE = 2.0
+    NUM_THREADS = 16
+    MIN_CHUNK_SIZE = 1 << 20  # 1 MiB minimum per chunk
+    REQUEST_TIMEOUT = (15, 60)  # (connect, read) timeouts
+    USER_AGENT = (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/125.0.0.0 Safari/537.36"
+    )
+
+    def __init__(self, url: str, name: str, save_path: str, headers: Optional[dict] = None, single_threaded: bool = False):
+        self.url = url
+        self._name = name
+        self._save_path = save_path
+        self._file_path = os.path.join(save_path, name)
+        self._status = DirectDownloadStatus(name, save_path, 0)
+        self._stop_event = threading.Event()
+        self._pause_event = threading.Event()  # SET = paused
+        self._thread: Optional[threading.Thread] = None
+        self._session: Optional[requests.Session] = None
+        self._supports_range = False
+        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)
+        url_hash = hashlib.sha256(url.encode()).hexdigest()
+        self._state_file = os.path.join(state_dir, f"{url_hash}.json")
+        
+        # Load state to initialize progress
+        state_data = self._load_state()
+        if state_data:
+            total_wanted = state_data.get("total_wanted", 0)
+            chunks_progress = state_data.get("chunks", {})
+            chunks_progress = {int(k): int(v) for k, v in chunks_progress.items()}
+            self._status.initialize_progress(total_wanted, chunks_progress)
+
+
+    def status(self) -> DirectDownloadStatus:
+        return self._status
+
+    def pause(self):
+        self._status.paused = True
+        self._pause_event.set()
+
+    def resume(self):
+        self._status.paused = False
+        self._pause_event.clear()
+
+    def set_flags(self, flags):
+        if flags & lt.torrent_flags.auto_managed:
+            self._status.auto_managed = True
+
+    def unset_flags(self, flags):
+        if flags & lt.torrent_flags.auto_managed:
+            self._status.auto_managed = False
+
+    def save_path(self) -> str:
+        return self._save_path
+
+    def stop(self):
+        self._stop_event.set()
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=10)
+
+
+    def _load_state(self) -> dict:
+        if os.path.exists(self._state_file):
+            try:
+                with open(self._state_file, "r") as f:
+                    return json.load(f)
+            except Exception as e:
+                consoleLog(f"Failed to load state for {self._name}: {e}")
+        return {}
+
+    def _save_state(self, chunks_done: dict[int, int]):
+        try:
+            with open(self._state_file, "w") as f:
+                json.dump({
+                    "url": self.url,
+                    "name": self._name,
+                    "save_path": self._save_path,
+                    "total_wanted": self._status.total_wanted,
+                    "chunks": chunks_done
+                }, f)
+        except Exception as e:
+            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 as e:
+                consoleLog(f"Exception while removing download state file: {e}")
+
+
+    def start(self):
+        self._thread = threading.Thread(
+            target=self._download_orchestrator, name=f"dl-{self._name}", daemon=True
+        )
+        self._thread.start()
+
+    def _build_session(self) -> requests.Session:
+        session = requests.Session()
+        session.headers.update({"User-Agent": self.USER_AGENT})
+        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,
+            pool_maxsize=self.NUM_THREADS + 2,
+        )
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+        return session
+
+    def _probe_url(self, session: requests.Session) -> tuple[int, bool]:
+        resp = session.head(self.url, allow_redirects=True, timeout=self.REQUEST_TIMEOUT)
+        resp.raise_for_status()
+
+        total_size = int(resp.headers.get("content-length", 0))
+        supports_range = (total_size > 0)
+
+        # Double-check range support with a small range request
+        if supports_range:
+            try:
+                test = session.get(
+                    self.url,
+                    headers={"Range": "bytes=0-0"},
+                    timeout=self.REQUEST_TIMEOUT,
+                    stream=True,
+                )
+                supports_range = test.status_code == 206
+                test.close()
+            except Exception:
+                supports_range = False
+
+        return total_size, supports_range
+
+    def _download_orchestrator(self):
+        try:
+            self._session = self._build_session()
+            total_size, self._supports_range = self._probe_url(self._session)
+            self._status.total_wanted = total_size
+
+            os.makedirs(self._save_path, exist_ok=True)
+
+            use_multithreaded = (
+                self._supports_range
+                and total_size > self.MIN_CHUNK_SIZE * 2
+                and not self._single_threaded
+            )
+
+            if use_multithreaded:
+                consoleLog(
+                    f"Multi-threaded download ({self.NUM_THREADS} threads): {self._name} "
+                    f"({format_size(total_size)})"
+                )
+                self._preallocate_file(total_size)
+                self._multithreaded_download(total_size)
+            else:
+                reason = "no range support" if not self._supports_range else "file too small or single-threaded mode"
+                consoleLog(f"Single-threaded download ({reason}): {self._name}")
+                self._single_threaded_download()
+
+            if not self._stop_event.is_set() and self._status.error is None:
+                self._verify_download(total_size)
+                self._status.mark_completed()
+                update_download_completed(self.url, True)
+                self._clear_state()
+                consoleLog(f"Finished downloading {self._name}")
+
+        except Exception as e:
+            self._status.mark_error(str(e))
+            consoleLog(f"Download failed for {self._name}: {e}")
+        finally:
+            if self._session:
+                self._session.close()
+
+
+    def _preallocate_file(self, total_size: int):
+        if os.path.exists(self._file_path) and os.path.getsize(self._file_path) == total_size:
+            return
+        with open(self._file_path, "wb") as f:
+            f.truncate(total_size)
+
+    def _compute_chunks(self, total_size: int) -> list[ChunkSpec]:
+        num_chunks = min(self.NUM_THREADS, max(1, total_size // self.MIN_CHUNK_SIZE))
+        chunk_size = total_size // num_chunks
+        chunks = []
+        for i in range(num_chunks):
+            start = i * chunk_size
+            end = (i + 1) * chunk_size - 1 if i < num_chunks - 1 else total_size - 1
+            chunks.append(ChunkSpec(chunk_id=i, start=start, end=end))
+        return chunks
+
+    def _multithreaded_download(self, total_size: int):
+        chunks = self._compute_chunks(total_size)
+        state_data = self._load_state()
+        chunks_progress = state_data.get("chunks", {})
+        
+        chunks_progress = {int(k): int(v) for k, v in chunks_progress.items()}
+
+        # Initialize progress in status
+        for chunk_id, bytes_done in chunks_progress.items():
+            self._status.update_chunk_progress(chunk_id, bytes_done)
+
+        with ThreadPoolExecutor(
+            max_workers=len(chunks), thread_name_prefix="dl-chunk"
+        ) as executor:
+            futures = {
+                executor.submit(self._download_chunk_with_retry, chunk, chunks_progress.get(chunk.chunk_id, 0)): chunk
+                for chunk in chunks
+            }
+
+            for future in as_completed(futures):
+                chunk = futures[future]
+                try:
+                    future.result()
+                except Exception as e:
+                    consoleLog(
+                        f"Chunk {chunk.chunk_id} ({chunk.start}-{chunk.end}) "
+                        f"failed permanently: {e}"
+                    )
+                    self._status.mark_error(
+                        f"Chunk {chunk.chunk_id} failed: {e}"
+                    )
+                    self._stop_event.set()
+
+    def _download_chunk_with_retry(self, chunk: ChunkSpec, initial_bytes: int):
+        bytes_written = initial_bytes
+
+        for attempt in range(1, self.MAX_RETRIES + 1):
+            if self._stop_event.is_set():
+                return
+
+            current_start = chunk.start + bytes_written
+            if current_start > chunk.end:
+                return
+
+            try:
+                # _download_range returns new bytes written
+                bytes_written += self._download_range(
+                    chunk.chunk_id, current_start, chunk.end, bytes_written
+                )
+                return
+            except Exception as e:
+                if self._stop_event.is_set():
+                    return
+                if attempt < self.MAX_RETRIES:
+                    wait = self.RETRY_BACKOFF_BASE ** attempt
+                    consoleLog(
+                        f"Chunk {chunk.chunk_id} attempt {attempt} failed: {e}. "
+                        f"Retrying in {wait:.0f}s (resuming from byte {current_start})..."
+                    )
+                    if self._stop_event.wait(timeout=wait):
+                        return
+                else:
+                    raise RuntimeError(
+                        f"Chunk {chunk.chunk_id} failed after {self.MAX_RETRIES} attempts: {e}"
+                    ) from e
+
+    def _download_range(
+        self, chunk_id: int, start: int, end: int, prior_bytes: int
+    ) -> int:
+
+        headers = {"Range": f"bytes={start}-{end}"}
+        new_bytes = 0
+
+        with self._session.get(
+            self.url, headers=headers, stream=True, timeout=self.REQUEST_TIMEOUT
+        ) as resp:
+            resp.raise_for_status()
+            if resp.status_code not in (200, 206):
+                raise RuntimeError(f"Unexpected status {resp.status_code}")
+
+            with open(self._file_path, "r+b") as f:
+                f.seek(start)
+                for block in resp.iter_content(chunk_size=self.STREAM_BLOCK_SIZE):
+                    if self._stop_event.is_set():
+                        return new_bytes
+
+                    self._wait_if_paused()
+                    if self._stop_event.is_set():
+                        return new_bytes
+
+                    _throttler.throttle(len(block), state.down_speed_limit)
+
+                    f.write(block)
+                    new_bytes += len(block)
+                    self._status.update_chunk_progress(
+                        chunk_id, prior_bytes + new_bytes
+                    )
+                    
+
+                    if new_bytes % (1024 * 1024) < len(block):
+
+                        with self._status._lock:
+                            self._save_state(self._status._chunk_bytes)
+
+        with self._status._lock:
+            self._save_state(self._status._chunk_bytes)
+            
+        return new_bytes
+
+
+    def _single_threaded_download(self):
+        chunk_id = 0
+        bytes_written = 0
+        
+        if os.path.exists(self._file_path):
+            bytes_written = os.path.getsize(self._file_path)
+            if bytes_written > 0:
+                self._status.update_chunk_progress(chunk_id, bytes_written)
+
+        for attempt in range(1, self.MAX_RETRIES + 1):
+            if self._stop_event.is_set():
+                return
+
+            try:
+                headers = {}
+                mode = "wb"
+
+                if bytes_written > 0 and self._supports_range:
+                    headers["Range"] = f"bytes={bytes_written}-"
+                    mode = "r+b"
+                elif bytes_written > 0:
+                    bytes_written = 0
+                    mode = "wb"
+
+                with self._session.get(
+                    self.url, headers=headers, stream=True, timeout=self.REQUEST_TIMEOUT
+                ) as resp:
+                    resp.raise_for_status()
+
+                    if self._status.total_wanted == 0:
+                        content_length = int(resp.headers.get("content-length", 0))
+                        self._status.total_wanted = content_length + bytes_written
+
+                    with open(self._file_path, mode) as f:
+                        if mode == "r+b":
+                            f.seek(bytes_written)
+
+                        for block in resp.iter_content(
+                            chunk_size=self.STREAM_BLOCK_SIZE
+                        ):
+                            if self._stop_event.is_set():
+                                return
+
+                            self._wait_if_paused()
+                            if self._stop_event.is_set():
+                                return
+
+                            _throttler.throttle(len(block), state.down_speed_limit)
+
+                            f.write(block)
+                            bytes_written += len(block)
+                            self._status.update_chunk_progress(chunk_id, bytes_written)
+                            
+                            # Periodic state save (single thread, chunk_id=0)
+                            if bytes_written % (1024 * 1024) < len(block):
+                                self._save_state({0: bytes_written})
+
+                self._save_state({0: bytes_written})
+                return
+
+            except Exception as e:
+                if self._stop_event.is_set():
+                    return
+                if attempt < self.MAX_RETRIES:
+                    wait = self.RETRY_BACKOFF_BASE ** attempt
+                    consoleLog(
+                        f"Download attempt {attempt} failed: {e}. "
+                        f"Retrying in {wait:.0f}s..."
+                    )
+                    if self._stop_event.wait(timeout=wait):
+                        return
+                else:
+                    raise RuntimeError(
+                        f"Download failed after {self.MAX_RETRIES} attempts: {e}"
+                    ) from e
+
+
+    def _wait_if_paused(self):
+        while self._pause_event.is_set():
+            if self._stop_event.wait(timeout=0.5):
+                return
+
+    def _verify_download(self, expected_size: int):
+        if expected_size <= 0:
+            return
+        actual_size = os.path.getsize(self._file_path)
+        if actual_size != expected_size:
+            raise RuntimeError(
+                f"Size mismatch: expected {format_size(expected_size)}, "
+                f"got {format_size(actual_size)}"
+            )

src/core/network/direct_download/status.py

@@ -0,0 +1,96 @@
+from dataclasses import dataclass
+from typing import Optional
+import libtorrent as lt
+import threading
+import time
+
+
+@dataclass
+class ChunkSpec:
+    chunk_id: int
+    start: int
+    end: int  # inclusive
+
+
+class DirectDownloadStatus:
+
+    def __init__(self, name: str, save_path: str, total_size: int = 0):
+        self.name = name
+        self.save_path = save_path
+        self.total_wanted = total_size
+        self.paused = False
+        self.auto_managed = True
+        self.has_metadata = True
+        self.state = lt.torrent_status.downloading
+        self.error: Optional[str] = None
+
+        self._lock = threading.Lock()
+        self._total_wanted_done = 0
+        self._progress = 0.0
+        self._download_rate = 0
+        self._upload_rate = 0
+
+        self._chunk_bytes: dict[int, int] = {}  
+        self._speed_window: list[tuple[float, int]] = [] 
+        self._speed_window_size = 3.0
+
+    @property
+    def total_wanted_done(self) -> int:
+        with self._lock:
+            return self._total_wanted_done
+
+    @property
+    def progress(self) -> float:
+        with self._lock:
+            return self._progress
+
+    @property
+    def download_rate(self) -> int:
+        with self._lock:
+            return self._download_rate
+
+    @property
+    def upload_rate(self) -> int:
+        return 0
+
+    def update_chunk_progress(self, chunk_id: int, bytes_downloaded: int):
+        with self._lock:
+            self._chunk_bytes[chunk_id] = bytes_downloaded
+            self._total_wanted_done = sum(self._chunk_bytes.values())
+            if self.total_wanted > 0:
+                self._progress = min(self._total_wanted_done / self.total_wanted, 1.0)
+
+
+            now = time.monotonic()
+            self._speed_window.append((now, self._total_wanted_done))
+
+            cutoff = now - self._speed_window_size
+            self._speed_window = [
+                (t, b) for t, b in self._speed_window if t >= cutoff
+            ]
+            if len(self._speed_window) >= 2:
+                oldest_time, oldest_bytes = self._speed_window[0]
+                dt = now - oldest_time
+                if dt > 0:
+                    self._download_rate = int(
+                        (self._total_wanted_done - oldest_bytes) / dt
+                    )
+
+    def initialize_progress(self, total_wanted: int, chunk_bytes: dict[int, int]):
+        with self._lock:
+            self.total_wanted = total_wanted
+            self._chunk_bytes = chunk_bytes.copy()
+            self._total_wanted_done = sum(self._chunk_bytes.values())
+            if self.total_wanted > 0:
+                self._progress = min(self._total_wanted_done / self.total_wanted, 1.0)
+
+    def mark_completed(self):
+        with self._lock:
+            self.state = lt.torrent_status.seeding
+            self._progress = 1.0
+            self._download_rate = 0
+
+    def mark_error(self, error: str):
+        with self._lock:
+            self.error = error
+            self._download_rate = 0

src/core/network/direct_download/utils.py

@@ -0,0 +1,49 @@
+from core.utils.logging.logs import consoleLog
+from urllib.parse import urlparse, unquote
+from typing import Optional
+import requests
+import os
+
+def sanitize_filename(name: str) -> str:
+    # Remove or replace dangerous characters
+    keepchars = (" ", ".", "_", "-")
+    cleaned = "".join(c for c in name if c.isalnum() or c in keepchars).strip()
+    while "  " in cleaned:
+        cleaned = cleaned.replace("  ", " ")
+    return cleaned or "download"
+
+
+def extract_filename_from_url(url: str) -> Optional[str]:
+    parsed = urlparse(url)
+    path = unquote(parsed.path)
+    basename = os.path.basename(path)
+    if basename and "." in basename and len(basename) < 256:
+        return basename
+    return None
+
+
+def detect_filename_from_headers(url: str, user_agent: str) -> Optional[str]:
+    try:
+        resp = requests.head(
+            url,
+            headers={"User-Agent": user_agent},
+            allow_redirects=True,
+            timeout=15,
+        )
+        cd = resp.headers.get("content-disposition", "")
+        if "filename=" in cd:
+            parts = cd.split("filename=")
+            if len(parts) > 1:
+                fname = parts[-1].strip().strip('"').strip("'")
+                if fname:
+                    return fname
+    except Exception as e:
+        consoleLog(f"Exception while retrieving filename from headers: {e}")
+    return None
+
+def format_size(size_bytes: int) -> str:
+    for unit in ("B", "KiB", "MiB", "GiB", "TiB"):
+        if abs(size_bytes) < 1024:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024
+    return f"{size_bytes:.1f} PiB"

src/core/network/interface.py

@@ -2,19 +2,21 @@ from core.utils.logging.logs import consoleLog
 from core.utils.data.state import state
 import psutil
 
-addrs = psutil.net_if_addrs()
-stats = psutil.net_if_stats()
-
 def get_net_interfaces():
+    addrs = psutil.net_if_addrs()
     for interface in addrs.keys():
         consoleLog(f"Found Interface: {interface}")
     return addrs.keys()
 
 
 def get_active_interfaces():
+    addrs = psutil.net_if_addrs()
+    stats = psutil.net_if_stats()
     active = []
 
     for interface, addr_list in addrs.items():
+        if interface not in stats:
+            continue
         up = stats[interface].isup
         for addr in addr_list:
             if addr.family == 2: # ipv4
@@ -27,26 +29,31 @@ def get_active_interfaces():
 
 
 def list_interfaces() -> None:
+    addrs = psutil.net_if_addrs()
+    stats = psutil.net_if_stats()
 
     for interface, addr_list in addrs.items():
+        if interface not in stats:
+            continue
         up = stats[interface].isup
+        status = "INACTIVE"
         for addr in addr_list:
             if addr.family == 2: # ipv4
                 ipv4 = addr.address
                 if not ipv4.startswith("127.") and not ipv4.startswith("169.254") and up:
                     status = "ACTIVE"
-                else:
-                    status = "INACTIVE"
         consoleLog(f"Found Interface: {interface} [{status}]")
 
 def init_interfaces():
+    addrs = psutil.net_if_addrs()
     state.interfaces = list(addrs.keys())
     state.active_interfaces = get_active_interfaces()
 
 def get_interface_ip(interface_name):
+    addrs = psutil.net_if_addrs()
     if interface_name in addrs:
         for addr in addrs[interface_name]:
             if addr.family == 2:  # ipv4
                 if not addr.address.startswith("127.") and not addr.address.startswith("169.254"):
                     return addr.address
-    return None
+    return None

src/core/network/libtorrent_int.py

@@ -1,17 +1,26 @@
+from core.network.interface import get_interface_ip
+from core.utils.general.wrappers import run_thread
+from core.utils.logging.logs import consoleLog
+from core.utils.data.state import state
+import libtorrent as lt
+import threading
+import platform
+import ctypes
 import time
 import os
-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
-from core.utils.general.shutdown import shutdown_event
 
 
-global loop_running
 loop_running = False
 
+def get_free_space_mb(dirname):
+    if platform.system() == 'Windows':
+        free_bytes = ctypes.c_ulonglong(0)
+        ctypes.windll.kernel32.GetDiskFreeSpaceExW(ctypes.c_wchar_p(dirname), None, None, ctypes.pointer(free_bytes))
+        return free_bytes.value
+    else:
+        st = os.statvfs(dirname)
+        return st.f_bavail * st.f_frsize
+
 def init_session():
     if state.dl_session is not None:
         return
@@ -20,8 +29,8 @@ def init_session():
 
 
     settings = {
-        "upload_rate_limit": state.up_speed_limit,
-        "download_rate_limit": state.down_speed_limit,
+        "upload_rate_limit": state.up_speed_limit * 1024,
+        "download_rate_limit": state.down_speed_limit * 1024,
         "enable_dht": True,
         "enable_lsd": True,
         "enable_upnp": True,
@@ -45,43 +54,63 @@ def init_session():
     consoleLog("Initialized Session")
 
 
-def add_download(magnet_uri, dl_path=state.download_path):
+def add_download(magnet_uri):
 
     if state.active_downloads is None:
         state.active_downloads = {}
 
     init_session()
 
+    free_space = get_free_space_mb(state.download_path)
+
     if magnet_uri in state.active_downloads:
         try:
             handle = state.active_downloads[magnet_uri]
             status = handle.status()
+
+            if status.has_metadata:
+                filepath = os.path.join(status.save_path, status.name)
+
+                if not os.path.exists(filepath):
+
+                    consoleLog(f"File Deleted, redownloading: {status.name}")
+                    state.dl_session.remove_torrent(handle)
+                    del state.active_downloads[magnet_uri]
+                else:
+                    consoleLog("Skipping Downloading, download already running...")
+                    return False
+            else:
+                consoleLog("Skipping Downloading, download already running... ")
+                return False
         except RuntimeError as e:
             consoleLog(f"Error in LibTorrent Handle: {e}")
-
-        if status.has_metadata:
-            filepath = os.path.join(status.save_path, status.name)
-
-            if not os.path.exists(filepath):
-
-                consoleLog(f"File Deleted, redownloading: {status.name}")
-                state.dl_session.remove_torrent(handle)
-                del state.active_downloads[magnet_uri]
-            else:
-                consoleLog("Skipping Downloading, download already running...")
-                return False
-        else:
-            consoleLog("Skipping Downloading, download already running... ")
-            return False
+            del state.active_downloads[magnet_uri]
 
     try:
-        magnetdl = lt.parse_magnet_uri(magnet_uri)
-        magnetdl.save_path = dl_path
-        download = state.dl_session.add_torrent(magnetdl)
+        params = lt.parse_magnet_uri(magnet_uri)
+        params.save_path = state.download_path
+
+        handle = state.dl_session.add_torrent(params)
+
+        while not handle.has_metadata():
+            time.sleep(1)
+
+        total_size = handle.get_torrent_info().total_size()
+
+        if free_space > total_size:
+            magnetdl = lt.parse_magnet_uri(magnet_uri)
+            magnetdl.save_path = state.download_path
+            download = state.dl_session.add_torrent(magnetdl)
+        else:
+            state.dl_session.remove_torrent(handle)
+            consoleLog("Not enough free space to download this item.")
+            return False
+
     except Exception as e:
-        consoleLog(f"Failed to add torrent: {e}")
+        consoleLog(f"Failed to add torrent or fetch info: {e}")
         return False
-    state.active_downloads[magnet_uri] = download
+    if download:
+        state.active_downloads[magnet_uri] = download
     consoleLog(f"Added {magnet_uri} to downloads")
 
     run_thread(threading.Thread(target=dl_status_loop))
@@ -123,7 +152,7 @@ def dl_status_loop():
         loop_running = False
         return
     
-    while state.active_downloads and not shutdown_event.is_set():
+    while state.active_downloads and not state.shutdown_event.is_set():
         for magnet_uri, magnetdl in list(state.active_downloads.items()):
             try:
                 status = magnetdl.status()
@@ -149,8 +178,8 @@ def update_settings():
         return
 
     settings = {
-        "upload_rate_limit": state.up_speed_limit,
-        "download_rate_limit": state.down_speed_limit,
+        "upload_rate_limit": state.up_speed_limit * 1024,
+        "download_rate_limit": state.down_speed_limit * 1024,
         "connections_limit": state.max_connections,
         "active_downloads": state.max_downloads
     }
@@ -171,4 +200,3 @@ def update_bound_interface():
     settings = { "outgoing_interfaces": state.bound_interface }
     
     state.dl_session.apply_settings(settings)
-

src/core/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 core.utils.data.state import state
 from plyer import notification
 import libtorrent as lt
-import os
 import time
+import os
 
 
 def cleanup_session():
@@ -37,8 +37,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):
@@ -53,11 +53,14 @@ def update_log(shutdown_event):
                 
                 if status.state == lt.torrent_status.seeding and magnet_uri not in updated and magnet_uri not in state.seeded_magnets:
                     consoleLog(f"Marking {status.name} as completed")
-                    info_hash = str(status.info_hash)
+                    if hasattr(status, 'info_hashes'):
+                        info_hash = str(status.info_hashes.v1)
+                    else:
+                        info_hash = str(status.info_hash)
                     update_download_completed_by_hash(info_hash, True)
                     updated.add(magnet_uri)
-        except Exception:
-            pass
+        except Exception as e:
+            consoleLog(f"Exception while updating log file: {e}")
         time.sleep(5)
 
 def check_deleted_files(shutdown_event):
@@ -76,6 +79,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/core/network/libtorrent_wrapper.py

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

src/core/utils/config/config.py

@@ -1,7 +1,8 @@
-import os
-import platform
-import configparser
 from core.utils.data.state import state
+import configparser
+import platform
+import os
+
 
 def create_config():
     config = configparser.ConfigParser()
@@ -15,7 +16,7 @@ def create_config():
 
     config["Network"] = {
         "api_url": f"{state.api_url}",
-        "download_path": f"{state.download_path}",
+        "bound_interface": f"{state.bound_interface}" if state.bound_interface is not None else "None",
         "download_speed_limit": f"{state.down_speed_limit}",
         "upload_speed_limit": f"{state.up_speed_limit}",
         "max_connections": f"{state.max_connections}",
@@ -23,7 +24,7 @@ def create_config():
     }
 
     config["Paths"] = {
-        "bound_interface": f"{state.bound_interface}",
+        "download_path": f"{state.download_path}",
         "image_path": f"{state.image_path}"
     }
 
@@ -64,14 +65,16 @@ def read_config():
 
     # Network
     state.api_url = config.get("Network", "api_url", fallback=state.api_url)
-    state.download_path = config.get("Network", "download_path", fallback=state.download_path)
+    state.bound_interface = config.get("Network", "bound_interface", fallback=state.bound_interface)
+    if state.bound_interface == "None":
+        state.bound_interface = None
     state.down_speed_limit = config.getint("Network", "download_speed_limit", fallback=state.down_speed_limit)
     state.up_speed_limit = config.getint("Network", "upload_speed_limit", fallback=state.up_speed_limit)
     state.max_connections = config.getint("Network", "max_connections", fallback=state.max_connections)
     state.max_downloads = config.getint("Network", "max_downloads", fallback=state.max_downloads)
 
     # Paths
-    state.bound_interface = config.get("Paths", "bound_interface", fallback=state.bound_interface)
+    state.download_path = config.get("Paths", "download_path", fallback=state.download_path)
     state.image_path = config.get("Paths", "image_path", fallback=state.image_path)
-    
+
     create_config()

src/core/utils/config/settings.py

@@ -1,6 +1,6 @@
 from core.network.libtorrent_int import update_settings
-from core.utils.data.state import state
 from core.utils.logging.logs import consoleLog
+from core.utils.data.state import state
 from .config import create_config
 
 
@@ -23,7 +23,6 @@ def save_settings(close=lambda: None, apiurl=None, download_path=None, down_spee
         state.max_downloads = max_downloads
     if bound_interface is not None:
         state.bound_interface = None if bound_interface == "None" else bound_interface
-    
 
     update_settings()
     consoleLog("Saved Settings")

src/core/utils/data/state.py

@@ -1,27 +1,34 @@
 from PySide6.QtCore import QObject, Signal
 from PySide6.QtWidgets import QTableWidget
-from typing import Optional, Any, List, Dict
+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[Any] | None = None
-        self.post_titles: Optional[List] = None
-        self.post_urls: Optional[List] = None
-        self.post_author: List[str] = []
-        self.post_seeders: List[str] = []
-        self.post_leechers: List[str] = []
+        self.posts: list[Dict[str,str]] | None = None # titles, urls, author, seederm leecher
         self.version: str = "dev"
         self._image_path: str = ""
         self.ignore_updates: bool = False
         self.debug: bool = False
         self.autoresume: bool = True
-        self.tracker: str = "rutracker"
-        self.tracker_list: dict[str, QTableWidget] = {}
+
+        self.currenttracker: str = "rutracker"
+        self.trackertable: QTableWidget
+        self.trackers: Dict[str,Dict[str,Any]] = {} # each tracker should add itself here
+        '''
+        an example:
+        "rutracker" : {
+            "name" : "rutracker", # name of the tracker
+            "headers" : ["author", "title"], # keys shown in the table
+            "scrapeFunc" : function,
+        }
+        '''
         self.api_url: str = "https://api.michijackson.xyz"
+        self.seeded_magnets: set = set()
         self.download_path: str = str(Path.home() / "Downloads")
         self.up_speed_limit: int = 0
         self.down_speed_limit: int = 0
@@ -30,11 +37,15 @@ class AppState(QObject):
         self.settings_path: str = "" 
         self.dl_session: Any = None
         self.active_downloads: Dict = {}
-        self.seeded_magnets: set = set()
         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/core/utils/data/tracker.py

@@ -1,31 +1,6 @@
-import requests
-from bs4 import BeautifulSoup
-from core.utils.data.state import state
 from core.utils.logging.logs import consoleLog
-from core.utils.network.jsonhandler import format_data
-
-
-
-def get_item_url(item, posts, post_titles): # softwarelist currentitem, post list (dict), post titles list
-        post_index = post_titles.index(item)
-        if 0 <= post_index < len(post_titles): 
-            if state.tracker == "uztracker":
-                item = "https://uztracker.net/" + state.post_urls[post_index].lstrip("./")
-                consoleLog(f"Found post URL: {item}")
-                return item
-            if state.tracker == "rutracker":                
-                item_dict = posts[post_index]
-                _, post_links, _, _, _ = format_data([item_dict])
-                consoleLog(f"Found post URL: {post_links[0]}")
-                return post_links[0]
-            if state.tracker == "m0nkrus":                
-                item_dict = posts[post_index]
-                _, post_links, _, _, _,= format_data([item_dict])
-                consoleLog(f"Found post URL: {post_links[0]}")
-                return post_links[0]
-
-        return None
-
+from bs4 import BeautifulSoup
+import requests
 
 
 def get_magnet_link(post_url):
@@ -40,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/core/utils/general/shutdown.py

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

src/core/utils/logging/loghandler.py

@@ -1,6 +1,5 @@
-from core.utils.logging.logs import consoleLog, remove_download_log
 from core.utils.network.download import run_download_direct, seed_magnet
-
+from core.utils.logging.logs import consoleLog, remove_download_log
 import os
 
 def split_data(data):
@@ -15,18 +14,23 @@ def check_completed(downloads, resume):
         if download.completed == False:
             consoleLog(f"Found unfinished download: {download.title}")
             if resume == True:
-                run_download_direct(download.magnet_uri)
-                consoleLog(f"Resuming {download.title}")
+                if download.magnet_uri:
+                    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)
+                    consoleLog(f"Resuming Direct Download: {download.title}")
 
 def check_downloads(downloads):
     for download in downloads:
-        if os.path.exists(download.path):
+        if download.completed == True and os.path.exists(download.path):
             consoleLog(f"Existing Download: {download.title}")
             try:
                 seed_magnet(download.magnet_uri, download.path)
             except Exception as e:
                 consoleLog(f"Failed to seed {download.title}: {e}")
-        else:
+        elif download.completed == True and not os.path.exists(download.path):
             consoleLog(f"Inexistent Download: {download.title}")
             remove_download_log(download.magnet_uri)
             

src/core/utils/logging/logs.py

@@ -3,13 +3,9 @@ from core.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
-
-_log_buffer = []
-_downloads_lock = threading.RLock()
 
 
 def add_download_log(title, url, magnet_uri, completed) -> DownloadList:
@@ -28,7 +24,7 @@ def add_download_log(title, url, magnet_uri, completed) -> DownloadList:
         path = os.path.join(save_path, torrent_name)
     else:
         path = os.path.join(state.download_path, title)
-    with _downloads_lock:
+    with state.downloads_lock:
         return _add_download_log_inner(title, url, magnet_uri, completed, path)
 
 def _add_download_log_inner(title, url, magnet_uri, completed, path) -> DownloadList:
@@ -44,14 +40,15 @@ def _add_download_log_inner(title, url, magnet_uri, completed, path) -> Download
     else:
         downloads = []
 
-    if any(d.magnet_uri == magnet_uri or d.url == url for d in downloads):
-        if magnet_uri in state.active_downloads:
+    if any((magnet_uri and d.magnet_uri == magnet_uri) or (url and d.url == url) for d in downloads):
+        if magnet_uri and magnet_uri in state.active_downloads:
             consoleLog("Skipping Logging, download already running...")
-            return
+            return DownloadList(data=downloads, count=len(downloads))
         consoleLog("File already in Log, updating Download State...")
         hash = extract_hash_from_magnet(magnet_uri)
-        update_download_completed_by_hash(hash, False)
-        return DownloadList(data=downloads, count=len(downloads)) # thanks again claude (im stupid)
+        if hash:
+            update_download_completed_by_hash(hash, False)
+        return DownloadList(data=downloads, count=len(downloads))
         
     
     downloads.append(Download(
@@ -71,7 +68,7 @@ def _add_download_log_inner(title, url, magnet_uri, completed, path) -> Download
     return download_list
 
 def remove_download_log(magnet_uri) -> DownloadList:
-    with _downloads_lock:
+    with state.downloads_lock:
         return _remove_download_log_inner(magnet_uri)
 
 def _remove_download_log_inner(magnet_uri) -> DownloadList:
@@ -89,6 +86,9 @@ def _remove_download_log_inner(magnet_uri) -> DownloadList:
 
 
     magnet_link = (magnet_uri or "").strip()
+    if not magnet_link:
+        return DownloadList(data=downloads, count=len(downloads))
+
     title = next((getattr(d, 'title', 'Unknown') for d in downloads if (getattr(d, 'magnet_uri', None) or '').strip() == magnet_link or (getattr(d, 'url', None) or '').strip() == magnet_link), 'Unknown')
     downloads = [d for d in downloads if (getattr(d, 'magnet_uri', None) or "").strip() != magnet_link and (getattr(d, 'url', None) or "").strip() != magnet_link]
 
@@ -101,7 +101,7 @@ def _remove_download_log_inner(magnet_uri) -> DownloadList:
     return download_list
 
 def update_download_completed(magnet_uri, completed) -> DownloadList:
-    with _downloads_lock:
+    with state.downloads_lock:
         return _update_download_completed_inner(magnet_uri, completed)
 
 def _update_download_completed_inner(magnet_uri, completed) -> DownloadList:
@@ -135,9 +135,7 @@ def _update_download_completed_inner(magnet_uri, completed) -> DownloadList:
         try:
             stored_magnet = (getattr(download, 'magnet_uri', None) or "").strip()
             stored_url = (getattr(download, 'url', None) or "").strip()
-            consoleLog(f"Comparing with magnet: {stored_magnet[:50] if stored_magnet else 'None'}...")
             if identifier and (stored_magnet == identifier or stored_url == identifier):
-                consoleLog(f"Match found! Setting completed={completed}")
                 download.completed = completed
                 found = True
         except Exception as e:
@@ -157,7 +155,7 @@ def _update_download_completed_inner(magnet_uri, completed) -> DownloadList:
     
 
 def get_download_logs() -> DownloadList:
-    with _downloads_lock:
+    with state.downloads_lock:
         return _get_download_logs_inner()
 
 def _get_download_logs_inner() -> DownloadList:
@@ -176,15 +174,24 @@ def _get_download_logs_inner() -> DownloadList:
     return DownloadList(data=downloads, count=len(downloads))
 
 
-def extract_hash_from_magnet(magnet_uri): # full credits to claude for this
-    match = re.search(r'urn:btih:([A-F0-9]+)', magnet_uri, re.IGNORECASE)
-    if match:
-        return match.group(1).upper()
-    return None
+def extract_hash_from_magnet(magnet_uri):
+    if not magnet_uri:
+        return None
+    try:
+        import libtorrent as lt
+        params = lt.parse_magnet_uri(magnet_uri)
+        if hasattr(params, 'info_hashes'): # lt 2.0+
+            return str(params.info_hashes.v1).upper()
+        return str(params.info_hash).upper()
+    except Exception:
+        match = re.search(r'urn:btih:([a-zA-Z0-9]+)', magnet_uri)
+        if match:
+            return match.group(1).upper()
+        return None
 
 
 def update_download_completed_by_hash(info_hash, completed) -> DownloadList:
-    with _downloads_lock:
+    with state.downloads_lock:
         return _update_download_completed_by_hash_inner(info_hash, completed)
 
 def _update_download_completed_by_hash_inner(info_hash, completed) -> DownloadList:
@@ -230,22 +237,18 @@ def _update_download_completed_by_hash_inner(info_hash, completed) -> DownloadLi
     return download_list
 
 
-_main_window = None
-
 def set_main_window(window):
-    global _main_window
-    _main_window = window
+    state.main_window = window
 
 def flush_log_buffer(): # credits to claude
-    global _log_buffer
-    if _log_buffer:
+    if state.log_buffer:
         try:
             from core.interface.gui import MainWindow
-            for log_entry in _log_buffer:
+            for log_entry in state.log_buffer:
                 MainWindow.add_log(log_entry)
-            _log_buffer = []
-        except Exception:
-            pass
+            state.log_buffer = []
+        except Exception as e:
+            consoleLog(f"Exception while flushing log buffer: {e}")
 
 def consoleLog(text, printAnyways = False):
     now = datetime.now()
@@ -254,10 +257,10 @@ def consoleLog(text, printAnyways = False):
 
     try:
         from core.interface.gui import MainWindow
-        MainWindow.add_log(formatted_text)
+        if not MainWindow.add_log(formatted_text):
+            state.log_buffer.append(formatted_text)
     except Exception:
-        global _log_buffer
-        _log_buffer.append(formatted_text)
+        state.log_buffer.append(formatted_text)
     
     if state.debug or printAnyways:
         print(formatted_text)

src/core/utils/network/download.py

@@ -1,14 +1,18 @@
-from core.utils.logging.logs import consoleLog
-from core.utils.data.tracker import get_item_url
-from core.utils.data.tracker import get_magnet_link
-from core.network.libtorrent_wrapper import add_download
-from core.utils.general.wrappers import run_thread
+from core.network.direct_download import add_direct_download
+from core.network.libtorrent_wrapper import add_magnet
 from core.utils.logging.logs import add_download_log
+from core.utils.general.wrappers import run_thread
 from core.network.libtorrent_int import add_seed
+from PySide6.QtWidgets import QTableWidgetItem
+from core.utils.logging.logs import consoleLog
+from core.utils.data.state import state
+from PySide6.QtCore import Qt
+from typing import Optional
 import threading
 
 
-def download_selected(items, posts, post_titles):
+
+def download_selected(items: list[QTableWidgetItem]):
     if not items:
         consoleLog("No item selected for download.")
         return
@@ -16,25 +20,35 @@ def download_selected(items, posts, post_titles):
     for item in items:
         if item.column() != 0:
             continue
-        text = item.text()
-        if text and text not in seen:
-            seen.add(text)
-            consoleLog(f"Downloading {text}")
-            run_thread(threading.Thread(target=run_download, args=(text, posts, post_titles)))
+        post_idx = item.data(Qt.ItemDataRole.UserRole)
+        if post_idx is None:
+            post_idx = item.row()
+        
+        if post_idx not in seen:
+            seen.add(post_idx)
+            post = state.posts[post_idx]
+            consoleLog(f"Downloading {post.get('title', 'Unknown')}")
+            run_thread(threading.Thread(target=run_download, args=(post,)))
 
-def run_download(item, posts, post_titles):
-    post_url = get_item_url(item, posts, post_titles)
-    consoleLog(f"Selected URL: {post_url}")
-    magnet_uri = get_magnet_link(post_url)
+def run_download(post, headers: Optional[dict] = None):
+    linkfunc = state.trackers[state.currenttracker]["linkFunc"]
+    ismagnet = state.trackers[state.currenttracker]["isMagnet"]
+    result = linkfunc(post)
 
-    if add_download(magnet_uri):
-        add_download_log(item, post_url, magnet_uri, False)
+    if ismagnet:
+        link = result
+        add_magnet(link)
+        add_download_log(post.get("title", "Unknown"), "", link, False)
+    else:
+        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):
-    consoleLog(f"Direct download: {magnet_uri[:60]}")
-    add_download(magnet_uri)
-    add_download_log("Direct Download", "", magnet_uri, False)
+def run_download_direct(magnet_uri, title="Direct Download"):
+    consoleLog(f"Magnet: {title}")
+    add_magnet(magnet_uri)
+    add_download_log(title, "", magnet_uri, False)
 
 def seed_magnet(magnet_uri, file_path): 
     consoleLog(f"Seeding: {magnet_uri[:60]}")
-    add_seed(magnet_uri, file_path)
+    add_seed(magnet_uri, file_path)

src/core/utils/network/update_checker.py

@@ -1,30 +1,41 @@
-import requests
-from core.utils.data.state import state
 from core.utils.logging.logs import consoleLog
+from core.utils.data.state import state
+import requests
 
-def check_for_updates():
-    url = f"https://api.github.com/repos/KeksPirates/SoftwareManager/releases"
-    response = requests.get(url, timeout=15)
+
+
+def get_updates():
+    url = f"https://api.github.com/repos/KeksPirates/SoftwareManager/releases/latest"
+    try:
+        response = requests.get(url, timeout=15)
+    except requests.RequestException as e:
+        consoleLog(f"Failed to fetch releases: {e}")
+        return None, None
 
     if response.status_code != 200:
         consoleLog(f"Failed to fetch releases: {response.status_code}")
         return None, None
 
-    releases = response.json()
-    releases.sort(key=lambda r: r["published_at"], reverse=True)
+    release = response.json()
 
-    latest_release = releases[0]
-    latest_version = latest_release["name"]
-    assets = latest_release["assets"]
+    latest_version = release.get("name") or release.get("tag_name")
+    assets = release.get("assets", [])
+
+    release_assets = []
 
     if latest_version != state.version:
         consoleLog(f"New release available: {latest_version}")
         if assets:
             consoleLog("Assets:")
             for asset in assets:
-                consoleLog(f" - {asset['name']}: {asset['browser_download_url']}")
-            return assets, latest_version
-        else: 
+                consoleLog(f"{asset['name']}")
+                release_assets.append(dict(
+                    name=asset['name'],
+                    url=asset['browser_download_url'],
+                    hash=asset.get('digest')
+                ))
+            return release_assets, latest_version
+        else:
             return None, None
     else:
         consoleLog("Already up-to-date.")

src/core/utils/network/updater.py

@@ -0,0 +1,96 @@
+from core.network.direct_download.handle import DirectDownloadHandle
+from core.utils.logging.logs import consoleLog
+from core.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)

src/main.py

@@ -1,21 +1,21 @@
-from core.interface.gui import MainWindow, windowCloseHelper
-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, shutdown_event
-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.logging.logs import get_download_logs
+from core.utils.general.shutdown import closehelper
+from core.utils.general.wrappers import run_thread
 from core.utils.config.config import read_config
+from core.utils.logging.logs import consoleLog
+from core.interface.gui import MainWindow
+from core.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)
@@ -48,13 +48,13 @@ def main():
     consoleLog("Initializing Interface variables...")
     init_interfaces()
     consoleLog(f"Current Bound: {state.bound_interface}")
-    run_thread(threading.Thread(target=send_notification, args=(shutdown_event,), daemon=True))
+    run_thread(threading.Thread(target=send_notification, args=(state.shutdown_event,), daemon=True))
     consoleLog("Started Thread: send_notification")
-    run_thread(threading.Thread(target=update_log, args=(shutdown_event,), daemon=True))
+    run_thread(threading.Thread(target=update_log, args=(state.shutdown_event,), daemon=True))
     consoleLog("Started Thread: update_log")
     run_thread(threading.Thread(target=check_completed, args=(downloads, state.autoresume)))
     consoleLog("Started Thread: check_completed")
-    run_thread(threading.Thread(target=check_deleted_files, args=(shutdown_event,), daemon=True))
+    run_thread(threading.Thread(target=check_deleted_files, args=(state.shutdown_event,), daemon=True))
     consoleLog("Started Thread: check_deleted_files")
     run_thread(threading.Thread(target=check_downloads, args=(downloads,)))
     consoleLog("Started Thread: check_downloads")
@@ -63,4 +63,4 @@ def main():
     run_gui()
 
 if __name__ == "__main__":
-    main()
+    main()