import os import sys import tempfile from enum import IntEnum from pathlib import Path from PySide6.QtCore import ( Property, QAbstractListModel, QModelIndex, QObject, Qt, QThread, QUrl, Signal, Slot, ) from PySide6.QtGui import QGuiApplication, QIcon from PySide6.QtQml import QQmlApplicationEngine from PySide6.QtQuickControls2 import QQuickStyle from ..multiversion import ( BROWSERS_DIR, get_cached_versions, get_default_channel, get_repo_name, list_installed, load_config, load_repo_cache, remove_version, save_config, save_repo_cache, set_active, ) from ..pkgman import RepoConfig, unzip, verify_sha256, webdl # Workers class Worker(QThread): progress = Signal(float) status = Signal(str) done = Signal(bool, str) def _progress(self, downloaded, total): if total > 0: self.progress.emit(downloaded / total) class DownloadWorker(Worker): def __init__(self, repo_config, version, activate_after_install=False): super().__init__() self.repo_config = repo_config self.version = version self.activate_after_install = activate_after_install self.relative_path = None def run(self): try: import shlex import orjson from ..multiversion import version_folder_name self.status.emit("Downloading...") repo_name = get_repo_name(self.repo_config.repo) sha8 = self.version.sha8 if self.version.sha256 else "" folder = version_folder_name( self.version.version.version, self.version.version.build, sha8 ) path = BROWSERS_DIR / repo_name / folder path.mkdir(parents=True, exist_ok=True) with tempfile.NamedTemporaryFile() as f: webdl(self.version.url, buffer=f, bar=False, progress_callback=self._progress) self.status.emit("Verifying...") self.progress.emit(-1) verify_sha256( f, self.version.sha256, desc=f"Camoufox v{self.version.version.full_string}" ) self.status.emit("Extracting...") unzip(f, str(path), bar=False) (path / 'version.json').write_bytes(orjson.dumps(self.version.to_metadata())) if sys.platform != 'win32': os.system(f'chmod -R 755 {shlex.quote(str(path))}') self.relative_path = f"browsers/{repo_name}/{folder}" self.done.emit(True, f"Installed v{self.version.version.full_string}") except Exception as e: msg = str(e) if '404' in msg or 'Not Found' in msg: self.done.emit(False, "Release not found (404). Please resync.") else: self.done.emit(False, msg) class SyncWorker(Worker): def __init__(self, spoof_os=None, spoof_arch=None, spoof_lib_ver=None): super().__init__() self.spoof_os = spoof_os self.spoof_arch = spoof_arch self.spoof_lib_ver = spoof_lib_ver def run(self): try: from datetime import datetime from ..pkgman import list_available_versions self.status.emit("Syncing...") cache = {'repos': []} for rc in RepoConfig.load_repos(spoof_library_version=self.spoof_lib_ver): self.status.emit(f"Syncing {rc.name}...") versions = list_available_versions( rc, include_prerelease=True, spoof_os=self.spoof_os, spoof_arch=self.spoof_arch, ) cache['repos'].append( { 'name': rc.name, 'repo': rc.repo, 'versions': [ { 'version': v.version.version, 'build': v.version.build, 'url': v.url, 'is_prerelease': v.is_prerelease, 'asset_id': v.asset_id, 'asset_size': v.asset_size, 'asset_updated_at': v.asset_updated_at, 'sha256': v.sha256, 'created_at': v.asset_created_at, } for v in versions ], } ) cache['spoof_os'] = self.spoof_os cache['spoof_arch'] = self.spoof_arch cache['spoof_lib_ver'] = self.spoof_lib_ver _dfmt = '%#m/%#d/%Y %#I:%M %p' if sys.platform == 'win32' else '%-m/%-d/%Y %-I:%M %p' cache['sync_time'] = datetime.now().strftime(_dfmt) save_repo_cache(cache) total = sum(len(r['versions']) for r in cache['repos']) self.done.emit(True, f"Synced {total} versions") except Exception as e: self.done.emit(False, str(e)) class GeoIPWorker(Worker): def __init__(self, source): super().__init__() self.source = source def run(self): try: from ..geolocation import download_mmdb download_mmdb(source=self.source, progress_callback=self._progress) self.done.emit(True, f"Installed: {self.source}") except Exception as e: self.done.emit(False, str(e)) # Models class Roles(IntEnum): Display = Qt.ItemDataRole.UserRole + 1 Build = Qt.ItemDataRole.UserRole + 2 IsHeader = Qt.ItemDataRole.UserRole + 3 IsPrerelease = Qt.ItemDataRole.UserRole + 4 IsActive = Qt.ItemDataRole.UserRole + 5 IsInstalled = Qt.ItemDataRole.UserRole + 6 Section = Qt.ItemDataRole.UserRole + 7 Expanded = Qt.ItemDataRole.UserRole + 8 IsPinned = Qt.ItemDataRole.UserRole + 9 Date = Qt.ItemDataRole.UserRole + 10 Note = Qt.ItemDataRole.UserRole + 11 _ROLE_ATTRS = { Roles.Display: 'display', Roles.Build: 'build', Roles.IsHeader: 'is_header', Roles.IsPrerelease: 'is_prerelease', Roles.IsActive: 'is_active', Roles.IsInstalled: 'is_installed', Roles.Section: 'section', Roles.Expanded: 'expanded', Roles.IsPinned: 'is_pinned', Roles.Date: 'date', Roles.Note: 'note', } _BOOL_ROLES = { Roles.IsHeader, Roles.IsPrerelease, Roles.IsActive, Roles.IsInstalled, Roles.Expanded, Roles.IsPinned, } _ROLE_NAMES = { Roles.Display: b"display", Roles.Build: b"build", Roles.IsHeader: b"isHeader", Roles.IsPrerelease: b"isPrerelease", Roles.IsActive: b"isActive", Roles.IsInstalled: b"isInstalled", Roles.Section: b"section", Roles.Expanded: b"expanded", Roles.IsPinned: b"isPinned", Roles.Date: b"date", Roles.Note: b"note", } class VersionItem: __slots__ = ( 'display', 'build', 'is_header', 'is_prerelease', 'is_active', 'is_pinned', 'is_installed', 'section', 'expanded', 'version_data', 'installed_data', 'date', 'note', ) def __init__( self, display, build="", is_header=False, is_prerelease=False, is_active=False, is_pinned=False, is_installed=False, section="", expanded=True, version_data=None, installed_data=None, date="", note="", ): self.display = display self.build = build self.is_header = is_header self.is_prerelease = is_prerelease self.is_active = is_active self.is_pinned = is_pinned self.is_installed = is_installed self.section = section self.expanded = expanded self.version_data = version_data self.installed_data = installed_data self.date = date self.note = note class VersionModel(QAbstractListModel): def __init__(self, parent=None): super().__init__(parent) self._items = [] def rowCount(self, parent=QModelIndex()): return len(self._items) def data(self, index, role=Qt.ItemDataRole.DisplayRole): if not index.isValid() or index.row() >= len(self._items): return False if role in _BOOL_ROLES else "" attr = _ROLE_ATTRS.get(role) return getattr(self._items[index.row()], attr, "") if attr else "" def roleNames(self): return _ROLE_NAMES def set_items(self, items): self.beginResetModel() self._items = items self.endResetModel() def get(self, index): return self._items[index] if 0 <= index < len(self._items) else None OS_OPTIONS = ["(auto)", "mac", "win", "lin"] ARCH_OPTIONS = ["(auto)", "x86_64", "i686", "arm64"] # Backend class Backend(QObject): reposChanged = Signal() busyChanged = Signal() progressChanged = Signal() statusChanged = Signal() selectionChanged = Signal() geoipChanged = Signal() infoChanged = Signal() debugChanged = Signal() currentRepoChanged = Signal() channelPrompt = Signal(int, str, str) installedPrompt = Signal(int, str, str, bool, str) def __init__(self): super().__init__() self._repo_configs = list(RepoConfig.load_repos()) self._repos = [r.name for r in self._repo_configs] self._version_model = VersionModel(self) self._current_repo = self._repo_configs[0] if self._repo_configs else None self._selected = -1 self._busy = False self._progress = -1.0 self._status_text = "" self._status_color = "#888" self._installed_only = False self._sections = {"stable": True, "prerelease": True} self._worker = None self._channel_data = None self._geoip_available = False self._geoip_sources = [] self._geoip_names = [] self._geoip_installed = "" self._geoip_downloaded = [] self._geoip_path = "" self._geoip_size = "" self._geoip_mtime = "" self._geoip_busy = False self._geoip_progress = -1.0 self._lookup_result = "" self._lookup_ok = True self._spoof_os_idx = 0 self._spoof_arch_idx = 0 self._spoof_lib_ver = "" self._pending_channel = None self._load_spoof_from_cache() self._load_geoip() # Properties @Property(list, notify=reposChanged) def repos(self): return self._repos @Property(QObject, constant=True) def versionModel(self): return self._version_model @Property(bool, notify=busyChanged) def busy(self): return self._busy @Property(float, notify=progressChanged) def progress(self): return self._progress @Property(str, notify=statusChanged) def statusText(self): return self._status_text @Property(str, notify=statusChanged) def statusColor(self): return self._status_color @Property(bool, notify=selectionChanged) def canInstall(self): item = self._version_model.get(self._selected) return item and not item.is_header and not item.is_installed @Property(bool, notify=selectionChanged) def canUninstall(self): item = self._version_model.get(self._selected) return item and not item.is_header and item.is_installed @Property(str, notify=selectionChanged) def selectedVersion(self): item = self._version_model.get(self._selected) return item.display if item else "" @Property(bool, notify=selectionChanged) def selectedIsPrerelease(self): item = self._version_model.get(self._selected) return item.is_prerelease if item else False @Property(bool, notify=geoipChanged) def geoipAvailable(self): return self._geoip_available @Property(list, notify=geoipChanged) def geoipSources(self): return self._geoip_sources @Property(str, notify=geoipChanged) def geoipInstalled(self): return self._geoip_installed @Property(list, notify=geoipChanged) def geoipDownloaded(self): return self._geoip_downloaded @Property(str, notify=geoipChanged) def geoipPath(self): return self._geoip_path @Property(str, notify=geoipChanged) def geoipSize(self): return self._geoip_size @Property(str, notify=geoipChanged) def geoipMtime(self): return self._geoip_mtime @Property(bool, notify=geoipChanged) def geoipBusy(self): return self._geoip_busy @Property(float, notify=geoipChanged) def geoipProgress(self): return self._geoip_progress @Property(str, notify=geoipChanged) def lookupResult(self): return self._lookup_result @Property(bool, notify=geoipChanged) def lookupSuccess(self): return self._lookup_ok @Property(str, notify=infoChanged) def activeBrowserText(self): cfg = load_config() if cfg.get('pinned'): return f"v{cfg['pinned']}" channel = cfg.get('channel') or get_default_channel() _, keys, latest = self._build_channels() try: return latest[keys.index(channel)] or channel except ValueError: return channel @Property(str, notify=infoChanged) def activeBrowserColor(self): return "#26a69a" @Property(str, notify=infoChanged) def followedChannel(self): return load_config().get('channel') or get_default_channel() @Property(list, notify=infoChanged) def channels(self): return self._build_channels()[0] @Property(list, notify=infoChanged) def channelKeys(self): return self._build_channels()[1] @Property(list, notify=infoChanged) def channelLatest(self): return self._build_channels()[2] @Property(str, notify=infoChanged) def activeBrowserLabel(self): cfg = load_config() return "Pinned Version" if cfg.get('pinned') else "Active Channel" @Property(str, notify=infoChanged) def activeLabel(self): cfg = load_config() pinned = cfg.get('pinned') if pinned: return f"Pinned version: v{pinned}" channel = cfg.get('channel') or get_default_channel() parts = channel.split('/', 1) repo = parts[0].capitalize() ctype = parts[1] if len(parts) > 1 else 'stable' if ctype == 'stable': return f"Following channel: {repo}" return f"Following channel: {repo}/{ctype}" @Property(str, notify=infoChanged) def libraryVersion(self): return self._pkg_version('camoufox') @Property(str, notify=infoChanged) def playwrightVersion(self): return self._pkg_version('playwright') @Property(str, notify=infoChanged) def fpgenVersion(self): return self._pkg_version('fpgen') @Property(str, notify=infoChanged) def fingerprintVersion(self): return self._pkg_version('apify_fingerprint_datapoints') @Property(str, notify=infoChanged) def lastSyncTime(self): cache = load_repo_cache() raw = cache.get('sync_time') if cache else None if not raw: return "" try: from datetime import datetime dt = datetime.strptime(raw, '%Y-%m-%d %H:%M') _dfmt = '%#m/%#d/%Y %#I:%M %p' if sys.platform == 'win32' else '%-m/%-d/%Y %-I:%M %p' return dt.strftime(_dfmt) except ValueError: return raw @Property(str, notify=infoChanged) def reposInfo(self): cache = load_repo_cache() if not cache: return "Run sync" repos = cache.get('repos', []) total = sum(len(r.get('versions', [])) for r in repos) return f"{len(repos)} repos, {total} versions" @Property(list, constant=True) def spoofOsOptions(self): return OS_OPTIONS @Property(list, constant=True) def spoofArchOptions(self): return ARCH_OPTIONS @Property(int, notify=debugChanged) def spoofOsIndex(self): return self._spoof_os_idx @Property(int, notify=debugChanged) def spoofArchIndex(self): return self._spoof_arch_idx @Property(str, notify=debugChanged) def spoofLibVer(self): return self._spoof_lib_ver @Property(int, notify=currentRepoChanged) def currentRepoIndex(self): if self._current_repo: for i, rc in enumerate(self._repo_configs): if rc.name == self._current_repo.name: return i return 0 # Internal @staticmethod def _pkg_version(pkg): try: from importlib.metadata import version return version(pkg) except Exception: return "?" def _build_channels(self): """ Build channel names, keys, and latest version strings (cached) """ if self._channel_data is not None: return self._channel_data cache = load_repo_cache() channels, keys, latest = [], [], [] for rc in self._repo_configs: repo_versions = [] if cache: for repo in cache.get('repos', []): if repo['name'].lower() == rc.name.lower(): repo_versions = repo.get('versions', []) break stable = [v for v in repo_versions if not v.get('is_prerelease')] prereleases = [v for v in repo_versions if v.get('is_prerelease')] channels.append(rc.name) keys.append(rc.name) latest.append(f"v{stable[0]['version']}-{stable[0]['build']}" if stable else "") if prereleases: channels.append(f"{rc.name} (Prerelease)") keys.append(f"{rc.name}/prerelease") latest.append(f"v{prereleases[0]['version']}-{prereleases[0]['build']}") self._channel_data = (channels, keys, latest) return self._channel_data # Slots @Slot(int) def selectRepo(self, index): if 0 <= index < len(self._repo_configs): self._current_repo = self._repo_configs[index] self._refresh() @Slot(bool) def setInstalledOnly(self, value): self._installed_only = value self._refresh() @Slot(str) def toggleSection(self, section): self._sections[section] = not self._sections.get(section, True) self._refresh() @Slot(int) def selectVersion(self, index): self._selected = index self.selectionChanged.emit() @Slot(int) def setActive(self, index): item = self._version_model.get(index) if not item or item.is_header or item.version_data is None: return cfg = load_config() ctype = "prerelease" if item.is_prerelease else "stable" cfg['channel'] = f"{get_repo_name(self._current_repo.repo)}/{ctype}" cfg['pinned'] = f"{item.version_data.version.version}-{item.version_data.version.build}" cfg['pinned_sha'] = item.version_data.sha256 cfg.update( { 'active_repo': self._current_repo.name, 'active_build': item.version_data.version.build, 'active_version': item.version_data.version.version, } ) save_config(cfg) if item.installed_data: set_active(item.installed_data.relative_path) self._refresh() self.infoChanged.emit() @Slot(int) def unpinVersion(self, index): item = self._version_model.get(index) if not item or not item.is_pinned: return cfg = load_config() cfg.pop('pinned', None) cfg.pop('pinned_sha', None) save_config(cfg) self._refresh() self.infoChanged.emit() @Slot(int) def followVersionChannel(self, index): item = self._version_model.get(index) if not item or not item.version_data or not item.installed_data: return ctype = "prerelease" if item.is_prerelease else "stable" repo_name = self._current_repo.name cfg = load_config() cfg['channel'] = repo_name if ctype == "stable" else f"{repo_name}/{ctype}" cfg.pop('pinned', None) cfg.pop('pinned_sha', None) cfg.update( { 'active_repo': repo_name, 'active_build': item.version_data.version.build, 'active_version': item.version_data.version.version, } ) save_config(cfg) set_active(item.installed_data.relative_path) self._refresh() self.infoChanged.emit() @Slot(int) def setFollowedChannel(self, index): _, keys, _ = self._build_channels() if not (0 <= index < len(keys)): return key = keys[index] cfg = load_config() cfg['channel'] = key cfg.pop('pinned', None) cfg.pop('pinned_sha', None) repo_name, ctype = (key.split('/', 1) + ['stable'])[:2] is_pre = ctype == 'prerelease' display, build = "", "" cache = load_repo_cache() if cache: for repo in cache.get('repos', []): if repo['name'].lower() == repo_name.lower(): candidates = [ v for v in repo.get('versions', []) if v.get('is_prerelease') == is_pre ] if candidates: cfg['active_build'] = candidates[0]['build'] cfg['active_version'] = candidates[0]['version'] cfg['active_repo'] = repo_name display = f"v{candidates[0]['version']}" build = candidates[0]['build'] break if not display: return # Send everything to pending until the prompt closes self._pending_channel = (cfg, repo_name, is_pre) self.channelPrompt.emit(-1, display, build) @Slot() def confirmFollowChannel(self): if self._pending_channel is None: return cfg, repo_name, is_pre = self._pending_channel self._pending_channel = None save_config(cfg) for rc in self._repo_configs: if rc.name.lower() == repo_name.lower(): self._current_repo = rc self.currentRepoChanged.emit() break self._refresh() for idx, item in enumerate(self._version_model._items): if item.is_header: continue if item.is_prerelease == is_pre: if item.installed_data: set_active(item.installed_data.relative_path) self._refresh() self._selected = idx self.selectionChanged.emit() break self.infoChanged.emit() @Slot() def installSelected(self): item = self._version_model.get(self._selected) if item and not item.is_header and not item.is_installed: worker = DownloadWorker( self._current_repo, item.version_data, activate_after_install=item.is_active, ) self._run_worker(worker, self._on_done) @Slot() def uninstallSelected(self): item = self._version_model.get(self._selected) if not item or not item.is_installed or not item.installed_data: return installed = item.installed_data was_active = item.is_active try: remove_version(installed.path) if was_active: cfg = load_config() cfg.update( { 'active_repo': self._current_repo.name, 'active_build': installed.version.build, 'active_version': installed.version.version, } ) save_config(cfg) self._set_status(f"Uninstalled {item.display}", "#2ecc71") self._refresh() self.infoChanged.emit() except Exception as e: self._set_status(str(e), "#e74c3c") @Slot() def refresh(self): self._refresh() self._set_status("Refreshed", "#888") @Slot() def sync(self): spoof_os = OS_OPTIONS[self._spoof_os_idx] if self._spoof_os_idx > 0 else None spoof_arch = ARCH_OPTIONS[self._spoof_arch_idx] if self._spoof_arch_idx > 0 else None spoof_lib = self._spoof_lib_ver or None self._run_worker(SyncWorker(spoof_os, spoof_arch, spoof_lib), self._on_done) @Slot() def cancelOperation(self): if self._worker and self._worker.isRunning(): self._worker.terminate() self._worker.wait() self._busy = False self._progress = -1 self.busyChanged.emit() self._set_status("Cancelled", "#f39c12") @Slot(str) def downloadGeoip(self, source): if not self._geoip_names or source not in self._geoip_names: return if source == self._geoip_installed: from ..geolocation import needs_update if not needs_update(): return self._start_geoip_download(source) @Slot() def refreshGeoip(self): if self._geoip_installed: self._start_geoip_download(self._geoip_installed) @Slot() def deleteGeoipData(self): from ..geolocation import remove_mmdb remove_mmdb() self._load_geoip() @Slot(str) def deleteGeoipSource(self, source): from ..geolocation import MMDB_DIR, _get_geoip_config_by_name try: name = _get_geoip_config_by_name(source)['name'].lower() for f in MMDB_DIR.glob(f"{name}-*.mmdb"): f.unlink() except Exception: pass self._load_geoip() @Slot(str) def setActiveGeoip(self, source): from ..geolocation import _get_geoip_config_by_name, save_geoip_config if source not in self._geoip_downloaded: return save_geoip_config(_get_geoip_config_by_name(source)) self._load_geoip() @Slot(int) def setSpoofOs(self, index): self._spoof_os_idx = index self.debugChanged.emit() @Slot(int) def setSpoofArch(self, index): self._spoof_arch_idx = index self.debugChanged.emit() @Slot(str) def setSpoofLibVer(self, ver): self._spoof_lib_ver = ver.strip() self.debugChanged.emit() @Slot() def openGeoipFolder(self): from ..geolocation import MMDB_DIR if not MMDB_DIR.exists(): return import subprocess path = str(MMDB_DIR) if sys.platform == 'win32': subprocess.Popen(['explorer', path]) elif sys.platform == 'darwin': subprocess.Popen(['open', path]) else: subprocess.Popen(['xdg-open', path]) @Slot(str) def lookupIp(self, ip): if not ip.strip(): self._lookup_result = "Enter IP" self._lookup_ok = False self.geoipChanged.emit() return try: from ..geolocation import get_geolocation, get_mmdb_path if not get_mmdb_path().exists(): self._lookup_result = "Database not downloaded" self._lookup_ok = False self.geoipChanged.emit() return geo = get_geolocation(ip.strip()) self._lookup_result = "
".join( [ f"Country: {geo.locale.region}", f"TZ: {geo.timezone}", f"Lat/Lon: {geo.latitude:.4f}, {geo.longitude:.4f}", ] ) self._lookup_ok = True except Exception as e: self._lookup_result = str(e) self._lookup_ok = False self.geoipChanged.emit() # Internal helpers def _load_geoip(self): self._geoip_installed = "" self._geoip_downloaded = [] self._geoip_path = "" self._geoip_size = "" self._geoip_mtime = "" try: from ..geolocation import ( ALLOW_GEOIP, MMDB_DIR, _load_geoip_repos, get_mmdb_path, load_geoip_config, ) if not ALLOW_GEOIP: self._geoip_available = False self.geoipChanged.emit() return self._geoip_available = True repos, _ = _load_geoip_repos() self._geoip_names = self._geoip_sources = [r.get('name', '?') for r in repos] if MMDB_DIR.exists(): for repo in repos: nm = repo.get('name', '').lower() if (MMDB_DIR / f"{nm}-combined.mmdb").exists() or ( MMDB_DIR / f"{nm}-ipv4.mmdb" ).exists(): self._geoip_downloaded.append(repo.get('name', '')) config = load_geoip_config() path = get_mmdb_path('ipv4', config) if path.exists(): from datetime import datetime self._geoip_installed = config.get('name', '') self._geoip_path = str(path.parent) stat = path.stat() size = stat.st_size if 'combined' not in config.get('urls', {}): ipv6 = get_mmdb_path('ipv6', config) if ipv6.exists(): size += ipv6.stat().st_size self._geoip_size = f"{size / (1024 * 1024):.1f} MB" self._geoip_mtime = datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M') except Exception: pass self.geoipChanged.emit() def _load_spoof_from_cache(self): cache = load_repo_cache() if not cache: return spoof_os = cache.get('spoof_os') spoof_arch = cache.get('spoof_arch') spoof_lib = cache.get('spoof_lib_ver') if spoof_os and spoof_os in OS_OPTIONS: self._spoof_os_idx = OS_OPTIONS.index(spoof_os) if spoof_arch and spoof_arch in ARCH_OPTIONS: self._spoof_arch_idx = ARCH_OPTIONS.index(spoof_arch) if spoof_lib: self._spoof_lib_ver = spoof_lib def _refresh(self): items = [] self._selected = -1 if not self._current_repo: self._version_model.set_items(items) return from ..multiversion import classify_installs, get_repo_name from ..pkgman import format_asset_date cfg = load_config() pinned = cfg.get('pinned') pinned_sha = cfg.get('pinned_sha') versions = get_cached_versions(self._current_repo.name) if not versions: self._version_model.set_items(items) return # newest sha per version-build, used when a pin has no specific sha latest_sha = {} for v in versions: latest_sha.setdefault(v.version.full_string, v.sha256) def _is_pinned(v): if not pinned or pinned != v.version.full_string: return False if pinned_sha: return v.sha256 == pinned_sha return v.sha256 == latest_sha.get(v.version.full_string) repo_key = get_repo_name(self._current_repo.repo) channel = cfg.get('channel') or get_default_channel() _, active_channel = (channel.split('/', 1) + ['stable'])[:2] def _is_active(v, inst): if inst and inst.is_active: return True return ( str(cfg.get('active_repo') or '').lower() == repo_key and cfg.get('active_build') == v.version.build and cfg.get('active_version') == v.version.version and v.is_prerelease == (active_channel == 'prerelease') and v.sha256 == latest_sha.get(v.version.full_string) ) installed_list = [iv for iv in list_installed() if iv.repo_name == repo_key] row_inst, extras = classify_installs(versions, installed_list) inst_by_id = {id(v): inst for v, inst in zip(versions, row_inst)} for section, is_prerelease in [("stable", False), ("prerelease", True)]: version_list = [v for v in versions if v.is_prerelease == is_prerelease] if not version_list: continue expanded = self._sections.get(section, True) items.append( VersionItem( section.capitalize(), is_header=True, is_prerelease=is_prerelease, section=section, expanded=expanded, ) ) if expanded: for v in version_list: inst = inst_by_id.get(id(v)) if self._installed_only and not inst: continue items.append( VersionItem( f"v{v.version.version}", v.version.build, is_prerelease=is_prerelease, is_active=_is_active(v, inst), is_pinned=_is_pinned(v), is_installed=bool(inst), version_data=v, installed_data=inst, date=format_asset_date(v.asset_created_at), ) ) if extras: expanded = self._sections.get("other", True) items.append( VersionItem( "Other Installed", is_header=True, section="other", expanded=expanded, ) ) if expanded: for iv, note in extras: items.append( VersionItem( f"v{iv.version.version}", iv.version.build, is_prerelease=iv.is_prerelease, is_active=iv.is_active, is_installed=True, version_data=None, installed_data=iv, date=format_asset_date(iv.created_at), note=note, ) ) self._version_model.set_items(items) self.selectionChanged.emit() def _set_status(self, text, color): self._status_text = text self._status_color = color self.statusChanged.emit() def _on_worker_progress(self, value): self._progress = value self.progressChanged.emit() def _on_worker_status(self, status): self._set_status(status, "#3498db") def _on_geoip_progress(self, value): self._geoip_progress = value self.geoipChanged.emit() def _on_geoip_status(self, status): self.geoipChanged.emit() def _run_worker(self, worker, done_callback): self._busy = True self._progress = -1 self.busyChanged.emit() self._worker = worker worker.progress.connect(self._on_worker_progress) worker.status.connect(self._on_worker_status) worker.done.connect(done_callback) worker.start() def _on_done(self, ok, msg): worker = self._worker self._busy = False self._progress = -1 self.busyChanged.emit() self._set_status(msg if ok else f"Error: {msg}", "#2ecc71" if ok else "#e74c3c") if ok: if ( isinstance(worker, DownloadWorker) and worker.activate_after_install and worker.relative_path ): set_active(worker.relative_path) self._channel_data = None self._refresh() if isinstance(worker, DownloadWorker): target_idx = -1 for idx, item in enumerate(self._version_model._items): version = item.version_data if not version: continue if ( version.version.full_string == worker.version.version.full_string and version.sha256 == worker.version.sha256 ): target_idx = idx break if target_idx >= 0: self._selected = target_idx self.selectionChanged.emit() if not worker.activate_after_install: versions = get_cached_versions(worker.repo_config.name) latest = next( ( version for version in versions if version.is_prerelease == worker.version.is_prerelease ), None, ) is_latest = bool( latest and latest.version.full_string == worker.version.version.full_string and latest.sha256 == worker.version.sha256 ) channel = worker.repo_config.name if worker.version.is_prerelease: channel += " (Prerelease)" item = self._version_model.get(target_idx) self.installedPrompt.emit( target_idx, item.display, item.build, is_latest, channel, ) self.infoChanged.emit() self._load_spoof_from_cache() self.debugChanged.emit() def _on_geoip_done(self, ok, msg): self._geoip_busy = False self._geoip_progress = -1 self._load_geoip() def _start_geoip_download(self, source): self._geoip_busy = True self._geoip_progress = -1 self.geoipChanged.emit() self._worker = GeoIPWorker(source) self._worker.progress.connect(self._on_geoip_progress) self._worker.status.connect(self._on_geoip_status) self._worker.done.connect(self._on_geoip_done) self._worker.start() def main(debug=False): QQuickStyle.setStyle("Basic") # Suppress Breeze style warnings on KDE from PySide6.QtCore import QtMsgType, qInstallMessageHandler def _msg_filter(mode, ctx, msg): if 'org/kde/breeze' in msg: return if mode in (QtMsgType.QtCriticalMsg, QtMsgType.QtFatalMsg): print(msg, file=sys.stderr) qInstallMessageHandler(_msg_filter) app = QGuiApplication(sys.argv) app.setWindowIcon(QIcon(str(Path(__file__).parent / "assets/icon.ico"))) engine = QQmlApplicationEngine() engine.rootContext().setContextProperty("debugMode", debug) backend = Backend() backend.setParent(engine) engine.rootContext().setContextProperty("backend", backend) engine.load(QUrl.fromLocalFile(str(Path(__file__).parent / "qml/main.qml"))) if not engine.rootObjects(): sys.exit(-1) ret = app.exec() del engine sys.exit(ret)