refactor: remove core/ folder

src/interface/dialogs/downloadmodel.py

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