# -*- coding: utf-8 -*-
# ***************************************************************************
# *                                                                         *
# *   Copyright (c) 2019 Yorik van Havre <yorik@uncreated.net>              *
# *   Copyright (c) 2021 Chris Hennes <chennes@pioneerlibrarysystem.org>    *
# *                                                                         *
# *   This program is free software; you can redistribute it and/or modify  *
# *   it under the terms of the GNU Lesser General Public License (LGPL)    *
# *   as published by the Free Software Foundation; either version 2 of     *
# *   the License, or (at your option) any later version.                   *
# *   for detail see the LICENCE text file.                                 *
# *                                                                         *
# *   This program is distributed in the hope that it will be useful,       *
# *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
# *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
# *   GNU Library General Public License for more details.                  *
# *                                                                         *
# *   You should have received a copy of the GNU Library General Public     *
# *   License along with this program; if not, write to the Free Software   *
# *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  *
# *   USA                                                                   *
# *                                                                         *
# ***************************************************************************

import os
import re
import shutil
import json
import tempfile
import hashlib
import threading
import queue
from datetime import datetime
from typing import Union, List

from PySide2 import QtCore, QtGui, QtNetwork

import FreeCAD

if FreeCAD.GuiUp:
    import FreeCADGui

import addonmanager_utilities as utils
from addonmanager_macro import Macro
from addonmanager_metadata import MetadataDownloadWorker
from AddonManagerRepo import AddonManagerRepo

translate = FreeCAD.Qt.translate

have_git = False
try:
    import git

    # some versions of git module have no "Repo" class??  Bug #4072 module
    # 'git' has no attribute 'Repo'
    have_git = hasattr(git, "Repo")
except ImportError:
    pass

have_zip = False
try:
    import zipfile

    have_zip = True
except ImportError:
    pass

have_markdown = False
try:
    import markdown

    have_markdown = True
except ImportError:
    pass

#  @package AddonManager_workers
#  \ingroup ADDONMANAGER
#  \brief Multithread workers for the addon manager
#  @{

# reject_listed addons
macros_reject_list = []

# These addons will print an additional message informing the user
obsolete = []

# These addons will print an additional message informing the user Python2 only
py2only = []

NOGIT = False  # for debugging purposes, set this to True to always use http downloads
NOMARKDOWN = False  # for debugging purposes, set this to True to disable Markdown lib
"""Multithread workers for the Addon Manager"""


class UpdateWorker(QtCore.QThread):
    """This worker updates the list of available workbenches"""

    status_message = QtCore.Signal(str)
    addon_repo = QtCore.Signal(object)
    done = QtCore.Signal()

    def __init__(self):

        QtCore.QThread.__init__(self)

    def run(self):
        "populates the list of addons"

        self.current_thread = QtCore.QThread.currentThread()

        # update info lists
        global obsolete, macros_reject_list, py2only
        u = utils.urlopen(
            "https://raw.githubusercontent.com/FreeCAD/FreeCAD-addons/master/addonflags.json"
        )
        if u:
            p = u.read()
            u.close()
            j = json.loads(p)
            if "obsolete" in j and "Mod" in j["obsolete"]:
                obsolete = j["obsolete"]["Mod"]

            if "blacklisted" in j and "Macro" in j["blacklisted"]:
                macros_reject_list = j["blacklisted"]["Macro"]

            if "py2only" in j and "Mod" in j["py2only"]:
                py2only = j["py2only"]["Mod"]
        else:
            FreeCAD.Console.PrintWarning("Debug: addon_flags.json not found\n")

        basedir = FreeCAD.getUserAppDataDir()
        moddir = basedir + os.sep + "Mod"
        package_names = []

        # querying custom addons first
        addon_list = (
            FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Addons")
            .GetString("CustomRepositories", "")
            .split("\n")
        )
        custom_addons = []
        for addon in addon_list:
            if " " in addon:
                addon_and_branch = addon.split(" ")
                custom_addons.append(
                    {"url": addon_and_branch[0], "branch": addon_and_branch[1]}
                )
            else:
                custom_addons.append({"url": addon, "branch": "master"})
        for addon in custom_addons:
            if self.current_thread.isInterruptionRequested():
                return
            if addon and addon["url"]:
                if addon["url"][-1] == "/":
                    addon["url"] = addon["url"][0:-1]  # Strip trailing slash
                name = addon["url"].split("/")[-1]
                if name.lower().endswith(".git"):
                    name = name[:-4]
                if name in package_names:
                    # We already have something with this name, skip this one
                    continue
                package_names.append(name)
                addondir = moddir + os.sep + name
                if os.path.exists(addondir) and os.listdir(addondir):
                    state = AddonManagerRepo.UpdateStatus.UNCHECKED
                else:
                    state = AddonManagerRepo.UpdateStatus.NOT_INSTALLED
                repo = AddonManagerRepo(name, addon["url"], state, addon["branch"])
                md_file = os.path.join(addondir,"package.xml")
                if os.path.isfile(md_file):
                    repo.load_metadata_file(md_file)
                    repo.installed_version = repo.metadata.Version
                    repo.updated_timestamp = os.path.getmtime(md_file)
                self.addon_repo.emit(repo)

        # querying official addons
        u = utils.urlopen(
            "https://raw.githubusercontent.com/FreeCAD/FreeCAD-addons/master/.gitmodules"
        )
        if not u:
            self.done.emit()
            self.stop = True
            return
        p = u.read()
        if isinstance(p, bytes):
            p = p.decode("utf-8")
        u.close()
        p = re.findall(
            (
                r'(?m)\[submodule\s*"(?P<name>.*)"\]\s*'
                r"path\s*=\s*(?P<path>.+)\s*"
                r"url\s*=\s*(?P<url>https?://.*)\s*"
                r"(branch\s*=\s*(?P<branch>[^\s]*)\s*)?"
            ),
            p,
        )
        for name, path, url, _, branch in p:
            if self.current_thread.isInterruptionRequested():
                return
            if name in package_names:
                # We already have something with this name, skip this one
                continue
            package_names.append(name)
            if branch is None or len(branch) == 0:
                branch = "master"
            url = url.split(".git")[0]
            addondir = moddir + os.sep + name
            if os.path.exists(addondir) and os.listdir(addondir):
                # make sure the folder exists and it contains files!
                state = AddonManagerRepo.UpdateStatus.UNCHECKED
            else:
                state = AddonManagerRepo.UpdateStatus.NOT_INSTALLED
            repo = AddonManagerRepo(name, url, state, branch)
            md_file = os.path.join(addondir,"package.xml")
            if os.path.isfile(md_file):
                repo.load_metadata_file(md_file)
                repo.installed_version = repo.metadata.Version
                repo.updated_timestamp = os.path.getmtime(md_file)
            self.addon_repo.emit(repo)

            self.status_message.emit(
                translate("AddonsInstaller", "Workbenches list was updated.")
            )

        if not self.current_thread.isInterruptionRequested():
            self.done.emit()
            self.stop = True


class LoadPackagesFromCacheWorker(QtCore.QThread):
    addon_repo = QtCore.Signal(object)
    done = QtCore.Signal()

    def __init__(self, cache_file: str):
        QtCore.QThread.__init__(self)
        self.cache_file = cache_file

    def run(self):
        metadata_cache_path = os.path.join(
            FreeCAD.getUserCachePath(), "AddonManager", "PackageMetadata"
        )
        with open(self.cache_file, "r") as f:
            data = f.read()
            if data:
                dict_data = json.loads(data)
                for item in dict_data.values():
                    if QtCore.QThread.currentThread().isInterruptionRequested():
                        return
                    repo = AddonManagerRepo.from_cache(item)
                    repo_metadata_cache_path = os.path.join(
                        metadata_cache_path, repo.name, "package.xml"
                    )
                    if os.path.isfile(repo_metadata_cache_path):
                        try:
                            repo.load_metadata_file(repo_metadata_cache_path)
                            repo.installed_version = repo.metadata.Version
                            repo.updated_timestamp = os.path.getmtime(repo_metadata_cache_path)
                        except Exception:
                            FreeCAD.Console.PrintWarning(
                                translate("AddonsInstaller","Failed loading") + f"{repo_metadata_cache_path}\n"
                            )
                            pass
                    self.addon_repo.emit(repo)
        self.done.emit()


class LoadMacrosFromCacheWorker(QtCore.QThread):
    add_macro_signal = QtCore.Signal(object)
    done = QtCore.Signal()

    def __init__(self, cache_file: str):
        QtCore.QThread.__init__(self)
        self.cache_file = cache_file

    def run(self):
        with open(self.cache_file, "r") as f:
            data = f.read()
            dict_data = json.loads(data)
            for item in dict_data:
                if QtCore.QThread.currentThread().isInterruptionRequested():
                    return
                new_macro = Macro.from_cache(item)
                self.add_macro_signal.emit(AddonManagerRepo.from_macro(new_macro))
        self.done.emit()


class CheckWorkbenchesForUpdatesWorker(QtCore.QThread):
    """This worker checks for available updates for all workbenches"""

    update_status = QtCore.Signal(AddonManagerRepo)
    progress_made = QtCore.Signal(int, int)
    done = QtCore.Signal()

    def __init__(self, repos: List[AddonManagerRepo]):

        QtCore.QThread.__init__(self)
        self.repos = repos

    def run(self):

        if NOGIT or not have_git:
            self.done.emit()
            self.stop = True
            return
        self.current_thread = QtCore.QThread.currentThread()
        self.basedir = FreeCAD.getUserAppDataDir()
        self.moddir = self.basedir + os.sep + "Mod"
        upds = []
        gitpython_warning = False
        count = 1
        for repo in self.repos:
            if self.current_thread.isInterruptionRequested():
                return
            self.progress_made.emit(count, len(self.repos))
            count += 1
            if repo.update_status == AddonManagerRepo.UpdateStatus.UNCHECKED:
                if repo.repo_type == AddonManagerRepo.RepoType.WORKBENCH:
                    self.check_workbench(repo)
                elif repo.repo_type == AddonManagerRepo.RepoType.MACRO:
                    self.check_macro(repo)
                elif repo.repo_type == AddonManagerRepo.RepoType.PACKAGE:
                    self.check_package(repo)

        self.stop = True
        self.done.emit()

    def check_workbench(self, wb):
        if not have_git or NOGIT:
            return
        clonedir = self.moddir + os.sep + wb.name
        if os.path.exists(clonedir):
            # mark as already installed AND already checked for updates
            if not os.path.exists(clonedir + os.sep + ".git"):
                # Repair addon installed with raw download
                bare_repo = git.Repo.clone_from(
                    wb.url, clonedir + os.sep + ".git", bare=True
                )
                try:
                    with bare_repo.config_writer() as cw:
                        cw.set("core", "bare", False)
                except AttributeError:
                    if not gitpython_warning:
                        FreeCAD.Console.PrintWarning(
                            translate(
                                "AddonsInstaller",
                                "Outdated GitPython detected, "
                                "consider upgrading with pip.",
                            )
                            + "\n"
                        )
                        gitpython_warning = True
                    cw = bare_repo.config_writer()
                    cw.set("core", "bare", False)
                    del cw
                repo = git.Repo(clonedir)
                repo.head.reset("--hard")
            gitrepo = git.Git(clonedir)
            try:
                gitrepo.fetch()
            except Exception:
                FreeCAD.Console.PrintWarning(
                    "AddonManager: "
                    + translate(
                        "AddonsInstaller", "Unable to fetch git updates for workbench"
                    )
                    + " "
                    + wb.name
                )
            else:
                try:
                    if "git pull" in gitrepo.status():
                        wb.update_status = (
                            AddonManagerRepo.UpdateStatus.UPDATE_AVAILABLE
                        )
                    else:
                        wb.update_status = (
                            AddonManagerRepo.UpdateStatus.NO_UPDATE_AVAILABLE
                        )
                    self.update_status.emit(wb)
                except Exception:
                    FreeCAD.Console.PrintWarning(
                        "AddonManager - " + wb.name + " git status"
                        " fatal: this operation must be run in a work tree \n"
                    )

    def check_package(self, package: AddonManagerRepo) -> None:
        clonedir = self.moddir + os.sep + package.name
        if os.path.exists(clonedir):
            installed_metadata_file = os.path.join(clonedir, "package.xml")
            if not os.path.isfile(installed_metadata_file):
                # If there is no package.xml file, then it's because the package author added it after the last time
                # the local installation was updated. By definition, then, there is an update available, if only to
                # download the new XML file.
                package.update_status = AddonManagerRepo.UpdateStatus.UPDATE_AVAILABLE
                package.installed_version = None
                self.update_status.emit(package)
                return
            else:
                package.updated_timestamp = os.path.getmtime(installed_metadata_file)
            try:
                installed_metadata = FreeCAD.Metadata(installed_metadata_file)
                package.set_metadata(installed_metadata)
                package.installed_version = installed_metadata.Version
                # Packages are considered up-to-date if the metadata version matches. Authors should update
                # their version string when they want the addon manager to alert users of a new version.
                if package.metadata.Version != installed_metadata.Version:
                    package.update_status = (
                        AddonManagerRepo.UpdateStatus.UPDATE_AVAILABLE
                    )
                else:
                    package.update_status = (
                        AddonManagerRepo.UpdateStatus.NO_UPDATE_AVAILABLE
                    )
                self.update_status.emit(package)
            except Exception as e:
                FreeCAD.Console.PrintWarning(
                    translate("AddonsInstaller", "Failed to read metadata from")
                    + f" {installed_metadata_file}"
                )

    def check_macro(self, macro_wrapper: AddonManagerRepo) -> None:
        # Make sure this macro has its code downloaded:
        try:
            if not macro_wrapper.macro.parsed and macro_wrapper.macro.on_git:
                macro_wrapper.macro.fill_details_from_file(
                    macro_wrapper.macro.src_filename
                )
            if not macro_wrapper.macro.parsed and macro_wrapper.macro.on_wiki:
                mac = macro_wrapper.macro.name.replace(" ", "_")
                mac = mac.replace("&", "%26")
                mac = mac.replace("+", "%2B")
                url = "https://wiki.freecad.org/Macro_" + mac
                macro_wrapper.macro.fill_details_from_wiki(url)
        except Exception:
            FreeCAD.Console.PrintWarning(
                f"Failed to fetch code for macro '{macro_wrapper.macro.name}'\n"
            )
            return

        hasher1 = hashlib.sha1()
        hasher2 = hashlib.sha1()
        hasher1.update(macro_wrapper.macro.code.encode("utf-8"))
        new_sha1 = hasher1.hexdigest()
        test_file_one = os.path.join(
            FreeCAD.getUserMacroDir(True), macro_wrapper.macro.filename
        )
        test_file_two = os.path.join(
            FreeCAD.getUserMacroDir(True), "Macro_" + macro_wrapper.macro.filename
        )
        if os.path.exists(test_file_one):
            with open(test_file_one, "rb") as f:
                contents = f.read()
                hasher2.update(contents)
                old_sha1 = hasher2.hexdigest()
        elif os.path.exists(test_file_two):
            with open(test_file_two, "rb") as f:
                contents = f.read()
                hasher2.update(contents)
                old_sha1 = hasher2.hexdigest()
        else:
            return
        if new_sha1 == old_sha1:
            macro_wrapper.update_status = (
                AddonManagerRepo.UpdateStatus.NO_UPDATE_AVAILABLE
            )
        else:
            macro_wrapper.update_status = AddonManagerRepo.UpdateStatus.UPDATE_AVAILABLE
        self.update_status.emit(macro_wrapper)


class FillMacroListWorker(QtCore.QThread):
    """This worker populates the list of macros"""

    add_macro_signal = QtCore.Signal(object)
    status_message_signal = QtCore.Signal(str)
    progress_made = QtCore.Signal(int, int)
    done = QtCore.Signal()

    def __init__(self, repo_dir):

        QtCore.QThread.__init__(self)
        self.repo_dir = repo_dir
        self.repo_names = []

    def run(self):
        """Populates the list of macros"""

        self.current_thread = QtCore.QThread.currentThread()

        if not self.current_thread.isInterruptionRequested():
            self.status_message_signal.emit(
                translate(
                    "AddonInstaller",
                    "Retrieving macros from FreeCAD/FreeCAD-Macros Git repository",
                )
            )
            self.retrieve_macros_from_git()

        if not self.current_thread.isInterruptionRequested():
            self.status_message_signal.emit(
                translate(
                    "AddonInstaller",
                    "Retrieving macros from FreeCAD/FreeCAD-Macros Git repository",
                )
            )
            self.retrieve_macros_from_wiki()

        if self.current_thread.isInterruptionRequested():
            return

        self.status_message_signal.emit(
            translate("AddonsInstaller", "Done locating macros.")
        )
        self.stop = True
        self.done.emit()

    def retrieve_macros_from_git(self):
        """Retrieve macros from FreeCAD-macros.git

        Emits a signal for each macro in
        https://github.com/FreeCAD/FreeCAD-macros.git
        """

        if not have_git or NOGIT:
            self.status_message_signal.emit(
                "GitPython not installed! Cannot retrieve macros from Git"
            )
            FreeCAD.Console.PrintWarning(
                translate(
                    "AddonsInstaller",
                    "GitPython not installed! Cannot retrieve macros from git",
                )
                + "\n"
            )
            return

        try:
            # TODO: someday see if the directory exists, and do a pull instead
            # of a clone
            git.Repo.clone_from(
                "https://github.com/FreeCAD/FreeCAD-macros.git", self.repo_dir
            )
        except Exception:
            FreeCAD.Console.PrintWarning(
                translate(
                    "AddonsInstaller",
                    "Something went wrong with the Git Macro Retrieval, "
                    "possibly the Git executable is not in the path",
                )
                + "\n"
            )
        n_files = 0
        for _, _, filenames in os.walk(self.repo_dir):
            n_files += len(filenames)
        counter = 0
        for dirpath, _, filenames in os.walk(self.repo_dir):
            self.progress_made.emit(counter, n_files)
            counter += 1
            if self.current_thread.isInterruptionRequested():
                return
            if ".git" in dirpath:
                continue
            for filename in filenames:
                if self.current_thread.isInterruptionRequested():
                    return
                if filename.lower().endswith(".fcmacro"):
                    macro = Macro(filename[:-8])  # Remove ".FCMacro".
                    macro.on_git = True
                    macro.src_filename = os.path.join(dirpath, filename)
                    repo = AddonManagerRepo.from_macro(macro)
                    repo.url = "https://github.com/FreeCAD/FreeCAD-macros.git"
                    self.add_macro_signal.emit(repo)

    def retrieve_macros_from_wiki(self):
        """Retrieve macros from the wiki

        Read the wiki and emit a signal for each found macro.
        Reads only the page https://wiki.freecad.org/Macros_recipes
        """

        u = utils.urlopen("https://wiki.freecad.org/Macros_recipes")
        if not u:
            FreeCAD.Console.PrintWarning(
                translate(
                    "AddonsInstaller",
                    "There appears to be an issue connecting to the Wiki, "
                    "therefore FreeCAD cannot retrieve the Wiki macro list at this time",
                )
                + "\n"
            )
            return
        p = u.read()
        u.close()
        if isinstance(p, bytes):
            p = p.decode("utf-8")
        macros = re.findall('title="(Macro.*?)"', p)
        macros = [mac for mac in macros if ("translated" not in mac)]
        macro_names = []
        for i, mac in enumerate(macros):
            self.progress_made.emit(i, len(macros))
            if self.current_thread.isInterruptionRequested():
                return
            macname = mac[6:]  # Remove "Macro ".
            macname = macname.replace("&amp;", "&")
            if not macname:
                continue
            if (
                (macname not in macros_reject_list)
                and ("recipes" not in macname.lower())
                and (macname not in macro_names)
            ):
                macro_names.append(macname)
                macro = Macro(macname)
                macro.on_wiki = True
                repo = AddonManagerRepo.from_macro(macro)
                repo.url = "https://wiki.freecad.org/Macros_recipes"
                self.add_macro_signal.emit(repo)


class ShowWorker(QtCore.QThread):
    """This worker retrieves info of a given workbench"""

    status_message = QtCore.Signal(str)
    readme_updated = QtCore.Signal(str)
    update_status = QtCore.Signal(AddonManagerRepo)
    done = QtCore.Signal()

    def __init__(self, repo, cache_path):

        QtCore.QThread.__init__(self)
        self.repo = repo
        self.cache_path = cache_path

    def run(self):
        self.status_message.emit(
            translate("AddonsInstaller", "Retrieving description...")
        )
        u = None
        url = self.repo.url
        self.status_message.emit(
            translate("AddonsInstaller", "Retrieving info from") + " " + str(url)
        )
        desc = ""
        regex = utils.get_readme_regex(self.repo)
        if regex:
            # extract readme from html via regex
            readmeurl = utils.get_readme_html_url(self.repo)
            if not readmeurl:
                FreeCAD.Console.PrintWarning(f"Debug: README not found for {url}\n")
            u = utils.urlopen(readmeurl)
            if not u:
                FreeCAD.Console.PrintWarning(
                    f"Debug: README not found at {readmeurl}\n"
                )
            u = utils.urlopen(readmeurl)
            if u:
                p = u.read()
                if isinstance(p, bytes):
                    p = p.decode("utf-8")
                u.close()
                readme = re.findall(regex, p, flags=re.MULTILINE | re.DOTALL)
                if readme:
                    desc = readme[0]
            else:
                FreeCAD.Console.PrintWarning(
                    f"Debug: README not found at {readmeurl}\n"
                )
        else:
            # convert raw markdown using lib
            readmeurl = utils.get_readme_url(self.repo)
            if not readmeurl:
                FreeCAD.Console.PrintWarning(f"Debug: README not found for {url}\n")
            u = utils.urlopen(readmeurl)
            if u:
                p = u.read()
                if isinstance(p, bytes):
                    p = p.decode("utf-8")
                u.close()
                desc = utils.fix_relative_links(p, readmeurl.rsplit("/README.md")[0])
                if not NOMARKDOWN and have_markdown:
                    desc = markdown.markdown(desc, extensions=["md_in_html"])
                else:
                    message = """
<div style="width: 100%; text-align:center;background: #91bbe0;">
<strong style="color: #FFFFFF;">
"""
                    message += translate("AddonsInstaller", "Raw markdown displayed")
                    message += "</strong><br/><br/>"
                    message += translate(
                        "AddonsInstaller", "Python Markdown library is missing."
                    )
                    message += "<br/></div><hr/><pre>" + desc + "</pre>"
                    desc = message
            else:
                FreeCAD.Console.PrintWarning("Debug: README not found at {readmeurl}\n")
            if desc == "":
                # fall back to the description text
                u = utils.urlopen(url)
                if not u:
                    self.stop = True
                    return
                p = u.read()
                if isinstance(p, bytes):
                    p = p.decode("utf-8")
                u.close()
                descregex = utils.get_desc_regex(self.repo)
                if descregex:
                    desc = re.findall(descregex, p)
                    if desc:
                        desc = desc[0]
            if not desc:
                desc = "Unable to retrieve addon description"
            self.repo.description = desc
            if QtCore.QThread.currentThread().isInterruptionRequested():
                return
        message = desc
        if self.repo.update_status == AddonManagerRepo.UpdateStatus.UNCHECKED:
            # Addon is installed but we haven't checked it yet, so lets check if it has an update
            upd = False
            # checking for updates
            if not NOGIT and have_git:
                repo = self.repo
                clonedir = (
                    FreeCAD.getUserAppDataDir() + os.sep + "Mod" + os.sep + repo.name
                )
                if os.path.exists(clonedir):
                    if not os.path.exists(clonedir + os.sep + ".git"):
                        # Repair addon installed with raw download
                        bare_repo = git.Repo.clone_from(
                            repo.url, clonedir + os.sep + ".git", bare=True
                        )
                        try:
                            with bare_repo.config_writer() as cw:
                                cw.set("core", "bare", False)
                        except AttributeError:
                            FreeCAD.Console.PrintWarning(
                                translate(
                                    "AddonsInstaller",
                                    "Outdated GitPython detected, "
                                    "consider upgrading with pip.",
                                )
                                + "\n"
                            )
                            cw = bare_repo.config_writer()
                            cw.set("core", "bare", False)
                            del cw
                        repo = git.Repo(clonedir)
                        repo.head.reset("--hard")
                    gitrepo = git.Git(clonedir)
                    gitrepo.fetch()
                    if "git pull" in gitrepo.status():
                        upd = True
            if upd:
                self.repo.update_status = AddonManagerRepo.UpdateStatus.UPDATE_AVAILABLE
            else:
                self.repo.update_status = (
                    AddonManagerRepo.UpdateStatus.NO_UPDATE_AVAILABLE
                )
            self.update_status.emit(self.repo)

            if QtCore.QThread.currentThread().isInterruptionRequested():
                return

        # If the Addon is obsolete, let the user know through the Addon UI
        if self.repo.name in obsolete:
            message = """
<div style="width: 100%; text-align:center; background: #FFB3B3;">
    <strong style="color: #FFFFFF; background: #FF0000;">
"""
            message += (
                translate("AddonsInstaller", "This addon is marked as obsolete")
                + "</strong><br/><br/>"
            )
            message += (
                translate(
                    "AddonsInstaller",
                    "This usually means it is no longer maintained, "
                    "and some more advanced addon in this list "
                    "provides the same functionality.",
                )
                + "<br/></div><hr/>"
                + desc
            )

        # If the Addon is Python 2 only, let the user know through the Addon UI
        if self.repo.name in py2only:
            message = """
<div style="width: 100%; text-align:center; background: #ffe9b3;">
    <strong style="color: #FFFFFF; background: #ff8000;">
"""
            message += (
                translate("AddonsInstaller", "This addon is marked as Python 2 Only")
                + "</strong><br/><br/>"
            )
            message += translate(
                "AddonsInstaller",
                "This workbench may no longer be maintained and "
                "installing it on a Python 3 system will more than "
                "likely result in errors at startup or while in use.",
            )
            message += "<br/></div><hr/>" + desc

        if QtCore.QThread.currentThread().isInterruptionRequested():
            return
        self.readme_updated.emit(message)
        self.mustLoadImages = True
        label = self.loadImages(message, self.repo.url, self.repo.name)
        if label:
            self.readme_updated.emit(label)
        if QtCore.QThread.currentThread().isInterruptionRequested():
            return
        self.done.emit()
        self.stop = True

    def stopImageLoading(self):
        "this stops the image loading process and allow the thread to terminate earlier"

        self.mustLoadImages = False

    def loadImages(self, message, url, wbName):
        "checks if the given page contains images and downloads them"

        # QTextBrowser cannot display online images.  So we download them
        # here, and replace the image link in the html code with the
        # downloaded version

        imagepaths = re.findall('<img.*?src="(.*?)"', message)
        if imagepaths:
            storedimages = []
            store = os.path.join(self.cache_path, "Images")
            if not os.path.exists(store):
                os.makedirs(store)
            with open(os.path.join(store, "download_in_progress"), "w") as f:
                f.write(
                    "If this file still exists, it's because a download was interrupted. It can be safely ignored."
                )
            for path in imagepaths:
                if QtCore.QThread.currentThread().isInterruptionRequested():
                    return message
                if not self.mustLoadImages:
                    return message
                origpath = path
                if "?" in path:
                    # remove everything after the ?
                    path = path.split("?")[0]
                if not path.startswith("http"):
                    path = utils.getserver(url) + path
                name = path.split("/")[-1]
                if name and path.startswith("http"):
                    storename = os.path.join(store, name)
                    if len(storename) >= 260:
                        remainChars = 259 - (len(store) + len(wbName) + 1)
                        storename = os.path.join(store, wbName + name[-remainChars:])
                    if not os.path.exists(storename):
                        try:
                            u = utils.urlopen(path)
                            imagedata = u.read()
                            u.close()
                        except Exception:
                            FreeCAD.Console.PrintLog(
                                "AddonManager: Debug: Error retrieving image from "
                                + path
                            )
                        else:
                            try:
                                f = open(storename, "wb")
                            except OSError:
                                # ecryptfs (and probably not only ecryptfs) has
                                # lower length limit for path
                                storename = storename[-140:]
                                f = open(storename, "wb")
                            f.write(imagedata)
                            f.close()
                            # resize the image to 300x300px if needed
                            img = QtGui.QImage(storename)
                            if (img.width() > 300) or (img.height() > 300):
                                pix = QtGui.QPixmap()
                                pix = pix.fromImage(
                                    img.scaled(
                                        300,
                                        300,
                                        QtCore.Qt.KeepAspectRatio,
                                        QtCore.Qt.FastTransformation,
                                    )
                                )
                                pix.save(storename, "jpeg", 100)
                    message = message.replace(
                        'src="' + origpath,
                        'src="file:///' + storename.replace("\\", "/"),
                    )
            os.remove(os.path.join(store, "download_in_progress"))
            return message
        return None


class GetMacroDetailsWorker(QtCore.QThread):
    """Retrieve the macro details for a macro"""

    status_message = QtCore.Signal(str)
    readme_updated = QtCore.Signal(str)
    done = QtCore.Signal()

    def __init__(self, repo):

        QtCore.QThread.__init__(self)
        self.macro = repo.macro

    def run(self):

        self.status_message.emit(
            translate("AddonsInstaller", "Retrieving macro description...")
        )
        if not self.macro.parsed and self.macro.on_git:
            self.status_message.emit(
                translate("AddonsInstaller", "Retrieving info from git")
            )
            self.macro.fill_details_from_file(self.macro.src_filename)
        if not self.macro.parsed and self.macro.on_wiki:
            self.status_message.emit(
                translate("AddonsInstaller", "Retrieving info from wiki")
            )
            mac = self.macro.name.replace(" ", "_")
            mac = mac.replace("&", "%26")
            mac = mac.replace("+", "%2B")
            url = "https://wiki.freecad.org/Macro_" + mac
            self.macro.fill_details_from_wiki(url)
        if self.macro.is_installed():
            already_installed_msg = (
                '<strong style="background: #00B629;">'
                + translate("AddonsInstaller", "This macro is already installed.")
                + "</strong><br>"
            )
        else:
            already_installed_msg = ""
        message = (
            already_installed_msg
            + "<h1>"
            + self.macro.name
            + "</h1>"
            + self.macro.desc
            + '<br/><br/>Macro location: <a href="'
            + self.macro.url
            + '">'
            + self.macro.url
            + "</a>"
        )
        if QtCore.QThread.currentThread().isInterruptionRequested():
            return
        self.readme_updated.emit(message)
        self.done.emit()
        self.stop = True


class InstallWorkbenchWorker(QtCore.QThread):
    "This worker installs a workbench"

    status_message = QtCore.Signal(str)
    progress_made = QtCore.Signal(int, int)
    success = QtCore.Signal(AddonManagerRepo, str)
    failure = QtCore.Signal(AddonManagerRepo, str)

    def __init__(self, repo: AddonManagerRepo):

        QtCore.QThread.__init__(self)
        self.repo = repo
        if have_git and not NOGIT:
            self.git_progress = GitProgressMonitor()
            # TODO: What is wrong with these?
            # self.git_progress.progress_made.connect(self.progress_made.emit)
            # self.git_progress.info_message.connect(self.status_message.emit)

    def run(self):
        "installs or updates the selected addon"

        if not self.repo:
            return

        if not have_git or NOGIT:
            FreeCAD.Console.PrintWarning(
                translate(
                    "AddonsInstaller",
                    "GitPython not found. Using ZIP file download instead.",
                )
                + "\n"
            )
            if not have_zip:
                FreeCAD.Console.PrintError(
                    translate(
                        "AddonsInstaller",
                        "Your version of python doesn't appear to support ZIP "
                        "files. Unable to proceed.",
                    )
                    + "\n"
                )
                return

        basedir = FreeCAD.getUserAppDataDir()
        moddir = basedir + os.sep + "Mod"
        if not os.path.exists(moddir):
            os.makedirs(moddir)
        target_dir = moddir + os.sep + self.repo.name

        if have_git and not NOGIT:
            self.run_git(target_dir)
        else:
            self.run_zip(target_dir)

        self.stop = True

    def run_git(self, clonedir: str) -> None:

        if NOGIT or not have_git:
            FreeCAD.Console.PrintWarning(
                translate(
                    "AddonsInstaller",
                    "No Git Python installed, skipping git operations",
                )
                + "\n"
            )
            return

        if os.path.exists(clonedir):
            self.run_git_update(clonedir)
        else:
            self.run_git_clone(clonedir)

    def run_git_update(self, clonedir: str) -> None:
        self.status_message.emit("Updating module...")
        if str(self.repo.name) in py2only:
            FreeCAD.Console.PrintWarning(
                translate(
                    "AddonsInstaller",
                    "User requested updating a Python 2 workbench on "
                    "a system running Python 3 - ",
                )
                + str(self.repo.name)
                + "\n"
            )
        if not os.path.exists(clonedir + os.sep + ".git"):
            # Repair addon installed with raw download by adding the .git
            # directory to it
            bare_repo = git.Repo.clone_from(
                self.repo.url, clonedir + os.sep + ".git", bare=True
            )
            try:
                with bare_repo.config_writer() as cw:
                    cw.set("core", "bare", False)
            except AttributeError:
                FreeCAD.Console.PrintWarning(
                    translate(
                        "AddonsInstaller",
                        "Outdated GitPython detected, consider " "upgrading with pip.",
                    )
                    + "\n"
                )
                cw = bare_repo.config_writer()
                cw.set("core", "bare", False)
                del cw
            repo = git.Repo(clonedir)
            repo.head.reset("--hard")
        repo = git.Git(clonedir)
        try:
            repo.pull()
            answer = translate(
                "AddonsInstaller",
                "Workbench successfully updated. "
                "Please restart FreeCAD to apply the changes.",
            )
        except Exception:
            answer = (
                translate("AddonsInstaller", "Error updating module ")
                + self.repo.name
                + " - "
                + translate("AddonsInstaller", "Please fix manually")
            )
            answer += repo.status()
            self.failure.emit(self.repo, answer)
        else:
            # Update the submodules for this repository
            repo_sms = git.Repo(clonedir)
            self.status_message.emit("Updating submodules...")
            for submodule in repo_sms.submodules:
                submodule.update(init=True, recursive=True)
            self.update_metadata()
            self.success.emit(self.repo, answer)

    def run_git_clone(self, clonedir: str) -> None:
        self.status_message.emit("Checking module dependencies...")
        depsok, answer = self.check_python_dependencies(self.repo.url)
        if depsok:
            if str(self.repo.name) in py2only:
                FreeCAD.Console.PrintWarning(
                    translate(
                        "AddonsInstaller",
                        "User requested installing a Python 2 "
                        "workbench on a system running Python 3 - ",
                    )
                    + str(self.repo.name)
                    + "\n"
                )
            self.status_message.emit("Cloning module...")
            repo = git.Repo.clone_from(self.repo.url, clonedir)

            # Make sure to clone all the submodules as well
            if repo.submodules:
                repo.submodule_update(recursive=True)

            if self.repo.branch in repo.heads:
                repo.heads[self.repo.branch].checkout()

            answer = translate(
                "AddonsInstaller",
                "Workbench successfully installed. Please restart "
                "FreeCAD to apply the changes.",
            )
        else:
            self.failure.emit(self.repo, answer)
            return

        if self.repo.repo_type == AddonManagerRepo.RepoType.WORKBENCH:
            # symlink any macro contained in the module to the macros folder
            macro_dir = FreeCAD.getUserMacroDir(True)
            if not os.path.exists(macro_dir):
                os.makedirs(macro_dir)
            if os.path.exists(clonedir):
                for f in os.listdir(clonedir):
                    if f.lower().endswith(".fcmacro"):
                        utils.symlink(
                            os.path.join(clonedir, f), os.path.join(macro_dir, f)
                        )
                        FreeCAD.ParamGet(
                            "User parameter:Plugins/" + self.repo.name
                        ).SetString("destination", clonedir)
                        answer += "\n\n" + translate(
                            "AddonsInstaller",
                            "A macro has been installed and is available "
                            "under Macro -> Macros menu",
                        )
                        answer += ":\n<b>" + f + "</b>"
        self.update_metadata()
        self.success.emit(self.repo, answer)

    def check_python_dependencies(self, baseurl: str) -> Union[bool, str]:
        """checks if the repo contains a metadata.txt and check its contents"""

        ok = True
        message = ""
        depsurl = baseurl.replace("github.com", "raw.githubusercontent.com")
        if not depsurl.endswith("/"):
            depsurl += "/"
        depsurl += "master/metadata.txt"
        try:
            mu = utils.urlopen(depsurl)
        except Exception:
            return True, translate(
                "AddonsInstaller",
                "No metadata.txt found, cannot evaluate Python dependencies",
            )
        if mu:
            # metadata.txt found
            depsfile = mu.read()
            mu.close()

            # urllib2 gives us a bytelike object instead of a string.  Have to
            # consider that
            try:
                depsfile = depsfile.decode("utf-8")
            except AttributeError:
                pass

            deps = depsfile.split("\n")
            for line in deps:
                if line.startswith("workbenches="):
                    depswb = line.split("=")[1].split(",")
                    for wb in depswb:
                        if wb.strip():
                            if not wb.strip() in FreeCADGui.listWorkbenches().keys():
                                if (
                                    not wb.strip() + "Workbench"
                                    in FreeCADGui.listWorkbenches().keys()
                                ):
                                    ok = False
                                    message += (
                                        translate(
                                            "AddonsInstaller", "Missing workbench"
                                        )
                                        + ": "
                                        + wb
                                        + ", "
                                    )
                elif line.startswith("pylibs="):
                    depspy = line.split("=")[1].split(",")
                    for pl in depspy:
                        if pl.strip():
                            try:
                                __import__(pl.strip())
                            except ImportError:
                                ok = False
                                message += (
                                    translate(
                                        "AddonsInstaller", "Missing python module"
                                    )
                                    + ": "
                                    + pl
                                    + ", "
                                )
                elif line.startswith("optionalpylibs="):
                    opspy = line.split("=")[1].split(",")
                    for pl in opspy:
                        if pl.strip():
                            try:
                                __import__(pl.strip())
                            except ImportError:
                                message += translate(
                                    "AddonsInstaller",
                                    "Missing optional python module (doesn't prevent installing)",
                                )
                                message += ": " + pl + ", "
        if message and (not ok):
            final_message = translate(
                "AddonsInstaller",
                "Some errors were found that prevent installation of this workbench",
            )
            final_message += ": <b>" + message + "</b>. "
            final_message += translate(
                "AddonsInstaller", "Please install the missing components first."
            )
            message = final_message
        return ok, message

    def check_package_dependencies(self):
        # TODO: Use the dependencies set in the package.xml metadata
        pass

    def run_zip(self, zipdir: str) -> None:
        "downloads and unzip a zip version from a git repo"

        bakdir = None
        if os.path.exists(zipdir):
            bakdir = zipdir + ".bak"
            if os.path.exists(bakdir):
                shutil.rmtree(bakdir)
            os.rename(zipdir, bakdir)
        os.makedirs(zipdir)
        zipurl = utils.get_zip_url(self.repo)
        if not zipurl:
            self.failure.emit(
                self.repo,
                translate("AddonsInstaller", "Error: Unable to locate zip from")
                + " "
                + self.repo.name,
            )
            return
        try:
            u = utils.urlopen(zipurl)
        except Exception:
            self.failure.emit(
                self.repo,
                translate("AddonsInstaller", "Error: Unable to download")
                + " "
                + zipurl,
            )
            return
        if not u:
            self.failure.emit(
                self.repo,
                translate("AddonsInstaller", "Error: Unable to download")
                + " "
                + zipurl,
            )
            return

        data_size = u.headers["content-length"]

        current_thread = QtCore.QThread.currentThread()
        if data_size and data_size > 5 * 1024 * 1024:
            # Use an on-disk file and track download progress, if the zipfile
            # is over 5mb
            with tempfile.NamedTemporaryFile(delete=False) as temp:
                bytes_to_read = 16 * 1024
                bytes_read = 0
                while True:
                    if current_thread.isInterruptionRequested():
                        return
                    chunk = u.read(bytes_to_read)
                    if not chunk:
                        break
                    bytes_read += bytes_to_read
                    temp.write(chunk)
                    self.progress_made.emit(bytes_read, data_size)
            zfile = zipfile.ZipFile(temp)
        else:
            zfile = io.BytesIO()
            zfile.write(u.read())
            zfile = zipfile.ZipFile(zfile)
        master = zfile.namelist()[0]  # github will put everything in a subfolder
        zfile.extractall(zipdir)
        u.close()
        zfile.close()
        for filename in os.listdir(zipdir + os.sep + master):
            shutil.move(
                zipdir + os.sep + master + os.sep + filename, zipdir + os.sep + filename
            )
        os.rmdir(zipdir + os.sep + master)
        if bakdir:
            shutil.rmtree(bakdir)
        self.update_metadata()
        self.success.emit(
            self.repo,
            translate("AddonsInstaller", "Successfully installed") + " " + zipurl,
        )

    def update_metadata(self):
        basedir = FreeCAD.getUserAppDataDir()
        package_xml = os.path.join(basedir, "Mod", self.repo.name, "package.xml")
        if os.path.isfile(package_xml):
            self.repo.load_metadata_file(package_xml)
            self.repo.installed_version = self.repo.metadata.Version
            self.repo.updated_timestamp = datetime.now().timestamp()


class CheckSingleWorker(QtCore.QThread):
    """Worker to check for updates for a single addon"""

    updateAvailable = QtCore.Signal(bool)

    def __init__(self, name):

        QtCore.QThread.__init__(self)
        self.name = name

    def run(self):

        if not have_git or NOGIT:
            return
        FreeCAD.Console.PrintLog(
            "Checking for available updates of the " + self.name + " addon\n"
        )
        addondir = os.path.join(FreeCAD.getUserAppDataDir(), "Mod", self.name)
        if os.path.exists(addondir):
            if os.path.exists(addondir + os.sep + ".git"):
                gitrepo = git.Git(addondir)
                try:
                    gitrepo.fetch()
                    if "git pull" in gitrepo.status():
                        self.updateAvailable.emit(True)
                        return
                except Exception:
                    # can fail for any number of reasons, ex.  not being online
                    pass
        self.updateAvailable.emit(False)


class UpdateMetadataCacheWorker(QtCore.QThread):
    "Scan through all available packages and see if our local copy of package.xml needs to be updated"

    status_message = QtCore.Signal(str)
    progress_made = QtCore.Signal(int, int)
    done = QtCore.Signal()
    package_updated = QtCore.Signal(AddonManagerRepo)

    class AtomicCounter(object):
        def __init__(self, start=0):
            self.lock = threading.Lock()
            self.count = start

        def set(self, new_value):
            with self.lock:
                self.count = new_value

        def get(self):
            with self.lock:
                return self.count

        def increment(self):
            with self.lock:
                self.count += 1

        def decrement(self):
            with self.lock:
                self.count -= 1

    def __init__(self, repos):

        QtCore.QThread.__init__(self)
        self.repos = repos
        self.counter = UpdateMetadataCacheWorker.AtomicCounter()

    def run(self):
        current_thread = QtCore.QThread.currentThread()
        self.num_downloads_required = len(self.repos)
        self.progress_made.emit(0, self.num_downloads_required)
        self.status_message.emit(
            translate("AddonsInstaller", "Retrieving package metadata...")
        )
        store = os.path.join(
            FreeCAD.getUserCachePath(), "AddonManager", "PackageMetadata"
        )
        index_file = os.path.join(store, "index.json")
        self.index = {}
        if os.path.isfile(index_file):
            with open(index_file, "r") as f:
                index_string = f.read()
                self.index = json.loads(index_string)

        download_queue = (
            QtNetwork.QNetworkAccessManager()
        )  # Must be created on this thread
        download_queue.finished.connect(self.on_finished)

        self.downloaders = []
        for repo in self.repos:
            if repo.metadata_url:
                downloader = MetadataDownloadWorker(None, repo, self.index)
                downloader.start_fetch(download_queue)
                downloader.updated.connect(self.on_updated)
                self.downloaders.append(downloader)

        # Run a local event loop until we've processed all of the downloads:
        # this is local to this thread, and does not affect the main event loop
        ui_updater = QtCore.QTimer()
        ui_updater.timeout.connect(self.send_ui_update)
        ui_updater.start(100)  # Send an update back to the main thread every 100ms
        self.num_downloads_required = len(self.downloaders)
        self.num_downloads_completed = UpdateMetadataCacheWorker.AtomicCounter()
        aborted = False
        while True:
            if current_thread.isInterruptionRequested() and not aborted:
                for downloader in self.downloaders:
                    downloader.abort()
                aborted = True
            QtCore.QCoreApplication.processEvents(QtCore.QEventLoop.AllEvents)
            if self.num_downloads_completed.get() >= self.num_downloads_required:
                break

        if aborted:
            FreeCAD.Console.PrintMessage("Metadata update cancelled\n")
            return

        # Update and serialize the updated index, overwriting whatever was
        # there before
        for downloader in self.downloaders:
            self.index[downloader.repo.name] = downloader.last_sha1
        if not os.path.exists(store):
            os.makedirs(store)
        with open(index_file, "w") as f:
            json.dump(self.index, f, indent="  ")

        # Signal completion to our parent thread
        self.done.emit()
        self.stop = True

    def on_finished(self, reply):
        # Called by the QNetworkAccessManager's sub-threads when a fetch
        # process completed (in any state)
        self.num_downloads_completed.increment()
        reply.deleteLater()

    def on_updated(self, repo):
        # Called if this repo got new metadata and/or a new icon
        self.package_updated.emit(repo)

    def send_ui_update(self):
        self.progress_made.emit(
            self.num_downloads_completed.get(), self.num_downloads_required
        )


if have_git and not NOGIT:

    class GitProgressMonitor(git.RemoteProgress):
        """An object that receives git progress updates and transforms them into Qt signals"""

        progress_made = QtCore.Signal(int, int)
        info_message = QtCore.Signal(str)

        def __init__(self):
            super().__init__()

        def update(
            self,
            op_code: int,
            cur_count: Union[str, float],
            max_count: Union[str, float, None] = None,
            message: str = "",
        ) -> None:
            if max_count:
                self.progress_made.emit(int(cur_count), int(max_count))
            if message:
                self.info_message.emit(message)


class UpdateAllWorker(QtCore.QThread):
    """Update all listed packages, of any kind"""

    progress_made = QtCore.Signal(int, int)
    status_message = QtCore.Signal(str)
    success = QtCore.Signal(AddonManagerRepo)
    failure = QtCore.Signal(AddonManagerRepo)
    done = QtCore.Signal()

    def __init__(self, repos):
        super().__init__()
        self.repos = repos

    def run(self):
        self.progress_made.emit(0, len(self.repos))
        self.repo_queue = queue.Queue()
        current_thread = QtCore.QThread.currentThread()
        for repo in self.repos:
            self.repo_queue.put(repo)

        # Following the QNetworkAccessManager model, we'll spawn six threads to process these requests in parallel:
        workers = []
        for _ in range(6):
            worker = UpdateSingleWorker(self.repo_queue)
            worker.success.connect(self.on_success)
            worker.failure.connect(self.on_failure)
            worker.start()
            workers.append(worker)

        while not self.repo_queue.empty():
            if current_thread.isInterruptionRequested():
                for worker in workers:
                    worker.requestInterruption()
                    worker.wait()
                return
            # Ensure our signals propagate out by running an internal thread-local event loop
            QtCore.QCoreApplication.processEvents()

        self.repo_queue.join()

        # Make sure all of our child threads have fully exited:
        for i, worker in enumerate(workers):
            worker.wait()

        self.done.emit()

    def on_success(self, repo: AddonManagerRepo) -> None:
        self.progress_made.emit(self.repo_queue.qsize(), len(self.repos))
        self.success.emit(repo)

    def on_failure(self, repo: AddonManagerRepo) -> None:
        self.progress_made.emit(self.repo_queue.qsize(), len(self.repos))
        self.failure.emit(repo)


class UpdateSingleWorker(QtCore.QThread):
    success = QtCore.Signal(AddonManagerRepo)
    failure = QtCore.Signal(AddonManagerRepo)

    def __init__(self, repo_queue: queue.Queue):
        super().__init__()
        self.repo_queue = repo_queue

    def run(self):
        current_thread = QtCore.QThread.currentThread()
        while True:
            if current_thread.isInterruptionRequested():
                return
            try:
                repo = self.repo_queue.get_nowait()
            except queue.Empty:
                return
            if repo.repo_type == AddonManagerRepo.RepoType.MACRO:
                self.update_macro(repo)
            else:
                self.update_package(repo)
            self.repo_queue.task_done()

    def update_macro(self, repo: AddonManagerRepo):
        """Updating a macro happens in this function, in the current thread"""

        cache_path = os.path.join(
            FreeCAD.getUserCachePath(), "AddonManager", "MacroCache"
        )
        os.makedirs(cache_path, exist_ok=True)
        temp_install_succeeded = macro.install(cache_path)
        if not temp_install_succeeded:
            failed = True

        if not failed:
            failed = macro.install(self.macro_repo_dir)

        if not failed:
            self.success.emit(repo)
        else:
            self.failure.emit(repo)

    def update_package(self, repo: AddonManagerRepo):
        """Updating a package re-uses the package installation worker, so actually spawns another thread that we block on"""

        worker = InstallWorkbenchWorker(repo)
        worker.success.connect(lambda repo, _: self.success.emit(repo))
        worker.failure.connect(lambda repo, _: self.failure.emit(repo))
        worker.start()
        while True:
            # Ensure our signals propagate out by running an internal thread-local event loop
            QtCore.QCoreApplication.processEvents()
            if not worker.isRunning():
                break


#  @}