#!/usr/bin/env python # -*- coding: utf-8 -*- # *************************************************************************** # * * # * Copyright (c) 2015 Yorik van Havre * # * Copyright (c) 2022 FreeCAD Project Association * # * * # * 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 shutil import stat import tempfile import hashlib import threading import json from datetime import date, timedelta from typing import Dict, List from PySide2 import QtGui, QtCore, QtWidgets import FreeCAD import FreeCADGui from addonmanager_workers_startup import ( CreateAddonListWorker, LoadPackagesFromCacheWorker, LoadMacrosFromCacheWorker, CheckWorkbenchesForUpdatesWorker, CacheMacroCodeWorker, GetMacroDetailsWorker, ) from addonmanager_workers_installation import ( InstallWorkbenchWorker, DependencyInstallationWorker, UpdateMetadataCacheWorker, UpdateAllWorker, UpdateSingleWorker, ) from addonmanager_workers_utility import ConnectionChecker import addonmanager_utilities as utils import AddonManager_rc from package_list import PackageList, PackageListItemModel from package_details import PackageDetails from Addon import Addon from install_to_toolbar import ( ask_to_install_toolbar_button, remove_custom_toolbar_button, ) from manage_python_dependencies import ( check_for_python_package_updates, CheckForPythonPackageUpdatesWorker, PythonPackageManager, ) import NetworkManager translate = FreeCAD.Qt.translate __title__ = "FreeCAD Addon Manager Module" __author__ = "Yorik van Havre", "Jonathan Wiedemann", "Kurt Kremitzki", "Chris Hennes" __url__ = "http://www.freecad.org" """ FreeCAD Addon Manager Module Fetches various types of addons from a variety of sources. Built-in sources are: * https://github.com/FreeCAD/FreeCAD-addons * https://github.com/FreeCAD/FreeCAD-macros * https://wiki.freecad.org/ Additional git sources may be configure via user preferences. You need a working internet connection, and optionally the GitPython package installed. """ # \defgroup ADDONMANAGER AddonManager # \ingroup ADDONMANAGER # \brief The Addon Manager allows users to install workbenches and macros made by other users # @{ def QT_TRANSLATE_NOOP(ctx, txt): return txt ADDON_MANAGER_DEVELOPER_MODE = False class CommandAddonManager: """The main Addon Manager class and FreeCAD command""" workers = [ "connection_checker", "create_addon_list_worker", "check_worker", "show_worker", "showmacro_worker", "macro_worker", "install_worker", "update_metadata_cache_worker", "load_macro_metadata_worker", "update_all_worker", "dependency_installation_worker", "check_for_python_package_updates_worker", ] lock = threading.Lock() restart_required = False def __init__(self): FreeCADGui.addPreferencePage( os.path.join(os.path.dirname(__file__), "AddonManagerOptions.ui"), translate("AddonsInstaller", "Addon Manager"), ) self.allowed_packages = set() allow_file = os.path.join( os.path.dirname(__file__), "ALLOWED_PYTHON_PACKAGES.txt" ) if os.path.exists(allow_file): with open(allow_file, "r", encoding="utf8") as f: lines = f.readlines() for line in lines: if line and len(line) > 0 and line[0] != "#": self.allowed_packages.add(line.strip()) else: FreeCAD.PrintWarning( translate( "AddonsInstaller", "Addon Manager installation problem: could not locate ALLOWED_PYTHON_PACKAGES.txt", ) + "\n" ) # Silence some pylint errors: self.check_worker = None self.check_for_python_package_updates_worker = None self.install_worker = None self.update_all_worker = None def GetResources(self) -> Dict[str, str]: return { "Pixmap": "AddonManager", "MenuText": QT_TRANSLATE_NOOP("Std_AddonMgr", "&Addon manager"), "ToolTip": QT_TRANSLATE_NOOP( "Std_AddonMgr", "Manage external workbenches, macros, and preference packs", ), "Group": "Tools", } def Activated(self) -> None: NetworkManager.InitializeNetworkManager() # display first use dialog if needed pref = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Addons") readWarning = pref.GetBool("readWarning2022", False) global ADDON_MANAGER_DEVELOPER_MODE ADDON_MANAGER_DEVELOPER_MODE = pref.GetBool("developerMode", False) if not readWarning: warning_dialog = FreeCADGui.PySideUic.loadUi( os.path.join(os.path.dirname(__file__), "first_run.ui") ) warning_dialog.setWindowFlag(QtCore.Qt.WindowStaysOnTopHint, True) autocheck = pref.GetBool("AutoCheck", False) download_macros = pref.GetBool("DownloadMacros", False) proxy_string = pref.GetString("ProxyUrl", "") if pref.GetBool("NoProxyCheck", True): proxy_option = 0 elif pref.GetBool("SystemProxyCheck", False): proxy_option = 1 elif pref.GetBool("UserProxyCheck", False): proxy_option = 2 def toggle_proxy_list(option: int): if option == 2: warning_dialog.lineEditProxy.show() else: warning_dialog.lineEditProxy.hide() warning_dialog.checkBoxAutoCheck.setChecked(autocheck) warning_dialog.checkBoxDownloadMacroMetadata.setChecked(download_macros) warning_dialog.comboBoxProxy.setCurrentIndex(proxy_option) toggle_proxy_list(proxy_option) if proxy_option == 2: warning_dialog.lineEditProxy.setText(proxy_string) warning_dialog.comboBoxProxy.currentIndexChanged.connect(toggle_proxy_list) warning_dialog.labelWarning.setStyleSheet( f"color:{utils.warning_color_string()};font-weight:bold;" ) if warning_dialog.exec() == QtWidgets.QDialog.Accepted: readWarning = True pref.SetBool("readWarning2022", True) pref.SetBool("AutoCheck", warning_dialog.checkBoxAutoCheck.isChecked()) pref.SetBool( "DownloadMacros", warning_dialog.checkBoxDownloadMacroMetadata.isChecked(), ) if warning_dialog.checkBoxDownloadMacroMetadata.isChecked(): self.trigger_recache = True selected_proxy_option = warning_dialog.comboBoxProxy.currentIndex() if selected_proxy_option == 0: pref.SetBool("NoProxyCheck", True) pref.SetBool("SystemProxyCheck", False) pref.SetBool("UserProxyCheck", False) elif selected_proxy_option == 1: pref.SetBool("NoProxyCheck", False) pref.SetBool("SystemProxyCheck", True) pref.SetBool("UserProxyCheck", False) else: pref.SetBool("NoProxyCheck", False) pref.SetBool("SystemProxyCheck", False) pref.SetBool("UserProxyCheck", True) pref.SetString("ProxyUrl", warning_dialog.lineEditProxy.text()) if readWarning: # Check the connection in a new thread, so FreeCAD stays responsive self.connection_checker = ConnectionChecker() self.connection_checker.success.connect(self.launch) self.connection_checker.failure.connect(self.network_connection_failed) self.connection_checker.start() # If it takes longer than a half second to check the connection, show a message: self.connection_message_timer = QtCore.QTimer.singleShot( 500, self.show_connection_check_message ) def show_connection_check_message(self): if not self.connection_checker.isFinished(): self.connection_check_message = QtWidgets.QMessageBox( QtWidgets.QMessageBox.Information, translate("AddonsInstaller", "Checking connection"), translate("AddonsInstaller", "Checking for connection to GitHub..."), QtWidgets.QMessageBox.Cancel, ) self.connection_check_message.buttonClicked.connect( self.cancel_network_check ) self.connection_check_message.show() def cancel_network_check(self, button): if not self.connection_checker.isFinished(): self.connection_checker.success.disconnect(self.launch) self.connection_checker.failure.disconnect(self.network_connection_failed) self.connection_checker.requestInterruption() self.connection_checker.wait(500) self.connection_check_message.close() def network_connection_failed(self, message: str) -> None: # This must run on the main GUI thread if hasattr(self, "connection_check_message") and self.connection_check_message: self.connection_check_message.close() if HAVE_QTNETWORK: QtWidgets.QMessageBox.critical( None, translate("AddonsInstaller", "Connection failed"), message ) else: QtWidgets.QMessageBox.critical( None, translate("AddonsInstaller", "Missing dependency"), translate( "AddonsInstaller", "Could not import QtNetwork -- see Report View for details. Addon Manager unavailable.", ), ) def launch(self) -> None: """Shows the Addon Manager UI""" # create the dialog self.dialog = FreeCADGui.PySideUic.loadUi( os.path.join(os.path.dirname(__file__), "AddonManager.ui") ) # self.dialog.setWindowFlag(QtCore.Qt.WindowStaysOnTopHint, True) # cleanup the leftovers from previous runs self.macro_repo_dir = FreeCAD.getUserMacroDir(True) self.packages_with_updates = set() self.startup_sequence = [] self.cleanup_workers() self.determine_cache_update_status() # restore window geometry from stored state pref = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Addons") w = pref.GetInt("WindowWidth", 800) h = pref.GetInt("WindowHeight", 600) self.dialog.resize(w, h) # If we are checking for updates automatically, hide the Check for updates button: autocheck = pref.GetBool("AutoCheck", False) if autocheck: self.dialog.buttonCheckForUpdates.hide() else: self.dialog.buttonUpdateAll.hide() # Set up the listing of packages using the model-view-controller architecture self.packageList = PackageList(self.dialog) self.item_model = PackageListItemModel() self.packageList.setModel(self.item_model) self.dialog.contentPlaceholder.hide() self.dialog.layout().replaceWidget( self.dialog.contentPlaceholder, self.packageList ) self.packageList.show() # Package details start out hidden self.packageDetails = PackageDetails(self.dialog) self.packageDetails.hide() index = self.dialog.layout().indexOf(self.packageList) self.dialog.layout().insertWidget(index, self.packageDetails) # set nice icons to everything, by theme with fallback to FreeCAD icons self.dialog.setWindowIcon(QtGui.QIcon(":/icons/AddonManager.svg")) self.dialog.buttonUpdateAll.setIcon(QtGui.QIcon(":/icons/button_valid.svg")) self.dialog.buttonCheckForUpdates.setIcon( QtGui.QIcon(":/icons/view-refresh.svg") ) self.dialog.buttonClose.setIcon( QtGui.QIcon.fromTheme("close", QtGui.QIcon(":/icons/process-stop.svg")) ) self.dialog.buttonPauseUpdate.setIcon( QtGui.QIcon.fromTheme( "pause", QtGui.QIcon(":/icons/media-playback-stop.svg") ) ) # enable/disable stuff self.dialog.buttonUpdateAll.setEnabled(False) self.hide_progress_widgets() self.dialog.buttonUpdateCache.setEnabled(False) self.dialog.buttonUpdateCache.setText( translate("AddonsInstaller", "Starting up...") ) # Only shown if there are available Python package updates self.dialog.buttonUpdateDependencies.hide() # connect slots self.dialog.rejected.connect(self.reject) self.dialog.buttonUpdateAll.clicked.connect(self.update_all) self.dialog.buttonClose.clicked.connect(self.dialog.reject) self.dialog.buttonUpdateCache.clicked.connect(self.on_buttonUpdateCache_clicked) self.dialog.buttonPauseUpdate.clicked.connect(self.stop_update) self.dialog.buttonCheckForUpdates.clicked.connect( lambda: self.force_check_updates(standalone=True) ) self.dialog.buttonUpdateDependencies.clicked.connect( self.show_python_updates_dialog ) self.packageList.itemSelected.connect(self.table_row_activated) self.packageList.setEnabled(False) self.packageDetails.execute.connect(self.executemacro) self.packageDetails.install.connect(self.resolve_dependencies) self.packageDetails.uninstall.connect(self.remove) self.packageDetails.update.connect(self.update) self.packageDetails.back.connect(self.on_buttonBack_clicked) self.packageDetails.update_status.connect(self.status_updated) # center the dialog over the FreeCAD window mw = FreeCADGui.getMainWindow() self.dialog.move( mw.frameGeometry().topLeft() + mw.rect().center() - self.dialog.rect().center() ) # set info for the progress bar: self.dialog.progressBar.setMaximum(1000) # begin populating the table in a set of sub-threads self.startup() # set the label text to start with self.show_information(translate("AddonsInstaller", "Loading addon information")) if hasattr(self, "connection_check_message") and self.connection_check_message: self.connection_check_message.close() # rock 'n roll!!! self.dialog.exec_() def cleanup_workers(self, wait=False) -> None: """Ensure that no workers are running by explicitly asking them to stop and waiting for them until they do""" for worker in self.workers: if hasattr(self, worker): thread = getattr(self, worker) if thread: if not thread.isFinished(): thread.blockSignals(True) thread.requestInterruption() for worker in self.workers: if hasattr(self, worker): thread = getattr(self, worker) if thread: if not thread.isFinished(): finished = thread.wait(500) if not finished: FreeCAD.Console.PrintWarning( translate( "AddonsInstaller", "Worker process {} is taking a long time to stop...\n", ).format(worker) ) def determine_cache_update_status(self) -> None: """Determine whether we need to update the cache, based on user preference, and previous cache update status. Sets self.update_cache to either True or False.""" # Figure out our cache update frequency: there is a combo box in the preferences dialog with three # options: never, daily, and weekly. Check that first, but allow it to be overridden by a more specific # DaysBetweenUpdates selection, if the user has provided it. For that parameter we use: # -1: Only manual updates (default) # 0: Update every launch # >0: Update every n days pref = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Addons") self.update_cache = False if hasattr(self, "trigger_recache") and self.trigger_recache: self.update_cache = True update_frequency = pref.GetInt("UpdateFrequencyComboEntry", 0) if update_frequency == 0: days_between_updates = -1 elif update_frequency == 1: days_between_updates = 1 elif update_frequency == 2: days_between_updates = 7 days_between_updates = pref.GetInt("DaysBetweenUpdates", days_between_updates) last_cache_update_string = pref.GetString("LastCacheUpdate", "never") cache_path = FreeCAD.getUserCachePath() am_path = os.path.join(cache_path, "AddonManager") if last_cache_update_string == "never": self.update_cache = True elif days_between_updates > 0: if hasattr(date, "fromisoformat"): last_cache_update = date.fromisoformat(last_cache_update_string) else: # Python 3.6 and earlier don't have date.fromisoformat date_re = re.compile( "([0-9]{4})-?(1[0-2]|0[1-9])-?(3[01]|0[1-9]|[12][0-9])" ) matches = date_re.match(last_cache_update_string) last_cache_update = date( int(matches.group(1)), int(matches.group(2)), int(matches.group(3)) ) delta_update = timedelta(days=days_between_updates) if date.today() >= last_cache_update + delta_update: self.update_cache = True elif days_between_updates == 0: self.update_cache = True elif not os.path.isdir(am_path): self.update_cache = True stopfile = utils.get_cache_file_name("CACHE_UPDATE_INTERRUPTED") if os.path.exists(stopfile): self.update_cache = True os.remove(stopfile) FreeCAD.Console.PrintMessage( translate( "AddonsInstaller", "Previous cache process was interrupted, restarting...\n", ) ) # See if the user has changed the custom repos list since our last re-cache: stored_hash = pref.GetString("CustomRepoHash", "") custom_repos = pref.GetString("CustomRepositories", "") if custom_repos: hasher = hashlib.sha1() hasher.update(custom_repos.encode("utf-8")) new_hash = hasher.hexdigest() else: new_hash = "" if new_hash != stored_hash: stored_hash = pref.SetString("CustomRepoHash", new_hash) self.update_cache = True FreeCAD.Console.PrintMessage( translate( "AddonsInstaller", "Custom repo list changed, forcing recache...\n", ) ) def reject(self) -> None: """called when the window has been closed""" # save window geometry for next use pref = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Addons") pref.SetInt("WindowWidth", self.dialog.width()) pref.SetInt("WindowHeight", self.dialog.height()) # ensure all threads are finished before closing oktoclose = True worker_killed = False self.startup_sequence = [] for worker in self.workers: if hasattr(self, worker): thread = getattr(self, worker) if thread: if not thread.isFinished(): thread.blockSignals(True) thread.requestInterruption() worker_killed = True oktoclose = False while not oktoclose: oktoclose = True for worker in self.workers: if hasattr(self, worker): thread = getattr(self, worker) if thread: thread.wait(25) if not thread.isFinished(): oktoclose = False QtCore.QCoreApplication.processEvents(QtCore.QEventLoop.AllEvents) # Write the cache data if it's safe to do so: if not worker_killed: for repo in self.item_model.repos: if repo.repo_type == Addon.Kind.MACRO: self.cache_macro(repo) else: self.cache_package(repo) self.write_package_cache() self.write_macro_cache() else: self.write_cache_stopfile() FreeCAD.Console.PrintLog( "Not writing the cache because a process was forcibly terminated and the state is unknown.\n" ) if self.restart_required: # display restart dialog m = QtWidgets.QMessageBox() m.setWindowTitle(translate("AddonsInstaller", "Addon manager")) m.setWindowIcon(QtGui.QIcon(":/icons/AddonManager.svg")) m.setText( translate( "AddonsInstaller", "You must restart FreeCAD for changes to take effect.", ) ) m.setIcon(m.Warning) m.setStandardButtons(m.Ok | m.Cancel) m.setDefaultButton(m.Cancel) okBtn = m.button(QtWidgets.QMessageBox.StandardButton.Ok) cancelBtn = m.button(QtWidgets.QMessageBox.StandardButton.Cancel) okBtn.setText(translate("AddonsInstaller", "Restart now")) cancelBtn.setText(translate("AddonsInstaller", "Restart later")) ret = m.exec_() if ret == m.Ok: # restart FreeCAD after a delay to give time to this dialog to close QtCore.QTimer.singleShot(1000, utils.restart_freecad) def startup(self) -> None: """Downloads the available packages listings and populates the table This proceeds in four stages: first, the main GitHub repository is queried for a list of possible addons. Each addon is specified as a git submodule with name and branch information. The actual specific commit ID of the submodule (as listed on Github) is ignored. Any extra repositories specified by the user are appended to this list. Second, the list of macros is downloaded from the FreeCAD/FreeCAD-macros repository and the wiki Third, each of these items is queried for a package.xml metadata file. If that file exists it is downloaded, cached, and any icons that it references are also downloaded and cached. Finally, for workbenches that are not contained within a package (e.g. they provide no metadata), an additional git query is made to see if an update is available. Macros are checked for file changes. Each of these stages is launched in a separate thread to ensure that the UI remains responsive, and the operation can be cancelled. Each stage is also subject to caching, so may return immediately, if no cache update has been requested. """ # Each function in this list is expected to launch a thread and connect its completion signal # to self.do_next_startup_phase, or to shortcut to calling self.do_next_startup_phase if it # is not launching a worker self.startup_sequence = [ self.populate_packages_table, self.activate_table_widgets, self.populate_macros, self.update_metadata_cache, self.check_updates, self.check_python_updates, ] pref = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Addons") if pref.GetBool("DownloadMacros", False): self.startup_sequence.append(self.load_macro_metadata) selection = pref.GetString("SelectedAddon", "") if selection: self.startup_sequence.insert(2, lambda: self.select_addon(selection)) pref.SetString("SelectedAddon", "") if ADDON_MANAGER_DEVELOPER_MODE: self.startup_sequence.append(self.validate) self.current_progress_region = 0 self.number_of_progress_regions = len(self.startup_sequence) self.do_next_startup_phase() def do_next_startup_phase(self) -> None: """Pop the top item in self.startup_sequence off the list and run it""" if len(self.startup_sequence) > 0: phase_runner = self.startup_sequence.pop(0) self.current_progress_region += 1 phase_runner() else: self.hide_progress_widgets() self.update_cache = False self.dialog.buttonUpdateCache.setEnabled(True) self.dialog.buttonUpdateCache.setText( translate("AddonsInstaller", "Refresh local cache") ) pref = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Addons") pref.SetString("LastCacheUpdate", date.today().isoformat()) self.packageList.item_filter.invalidateFilter() def populate_packages_table(self) -> None: self.item_model.clear() use_cache = not self.update_cache if use_cache: if os.path.isfile(utils.get_cache_file_name("package_cache.json")): with open(utils.get_cache_file_name("package_cache.json"), "r") as f: data = f.read() try: from_json = json.loads(data) if len(from_json) == 0: use_cache = False except Exception as e: use_cache = False else: use_cache = False if not use_cache: self.update_cache = True # Make sure to trigger the other cache updates, if the json file was missing self.create_addon_list_worker = CreateAddonListWorker() self.create_addon_list_worker.status_message.connect(self.show_information) self.create_addon_list_worker.addon_repo.connect(self.add_addon_repo) self.update_progress_bar(10, 100) self.create_addon_list_worker.finished.connect( self.do_next_startup_phase ) # Link to step 2 self.create_addon_list_worker.start() else: self.create_addon_list_worker = LoadPackagesFromCacheWorker( utils.get_cache_file_name("package_cache.json") ) self.create_addon_list_worker.addon_repo.connect(self.add_addon_repo) self.update_progress_bar(10, 100) self.create_addon_list_worker.finished.connect( self.do_next_startup_phase ) # Link to step 2 self.create_addon_list_worker.start() def cache_package(self, repo: Addon): if not hasattr(self, "package_cache"): self.package_cache = {} self.package_cache[repo.name] = repo.to_cache() def write_package_cache(self): if hasattr(self, "package_cache"): package_cache_path = utils.get_cache_file_name("package_cache.json") with open(package_cache_path, "w") as f: f.write(json.dumps(self.package_cache, indent=" ")) def activate_table_widgets(self) -> None: self.packageList.setEnabled(True) self.packageList.ui.lineEditFilter.setFocus() self.do_next_startup_phase() def populate_macros(self) -> None: macro_cache_file = utils.get_cache_file_name("macro_cache.json") cache_is_bad = True if os.path.isfile(macro_cache_file): size = os.path.getsize(macro_cache_file) if size > 1000: # Make sure there is actually data in there cache_is_bad = False if cache_is_bad: if not self.update_cache: self.update_cache = True # Make sure to trigger the other cache updates, if the json file was missing self.create_addon_list_worker = CreateAddonListWorker() self.create_addon_list_worker.status_message.connect(self.show_information) self.create_addon_list_worker.addon_repo.connect(self.add_addon_repo) self.update_progress_bar(10, 100) self.create_addon_list_worker.finished.connect( self.do_next_startup_phase ) # Link to step 2 self.create_addon_list_worker.start() else: # It's already been done in the previous step (TODO: Refactor to eliminate this step) self.do_next_startup_phase() else: self.macro_worker = LoadMacrosFromCacheWorker( utils.get_cache_file_name("macro_cache.json") ) self.macro_worker.add_macro_signal.connect(self.add_addon_repo) self.macro_worker.finished.connect(self.do_next_startup_phase) self.macro_worker.start() def cache_macro(self, repo: Addon): if not hasattr(self, "macro_cache"): self.macro_cache = [] if repo.macro is not None: self.macro_cache.append(repo.macro.to_cache()) else: FreeCAD.Console.PrintError( f"Addon Manager: Internal error, cache_macro called on non-macro {repo.name}\n" ) def write_macro_cache(self): if not hasattr(self, "macro_cache"): return macro_cache_path = utils.get_cache_file_name("macro_cache.json") with open(macro_cache_path, "w") as f: f.write(json.dumps(self.macro_cache, indent=" ")) self.macro_cache = [] def update_metadata_cache(self) -> None: if self.update_cache: self.update_metadata_cache_worker = UpdateMetadataCacheWorker( self.item_model.repos ) self.update_metadata_cache_worker.status_message.connect( self.show_information ) self.update_metadata_cache_worker.finished.connect( self.do_next_startup_phase ) # Link to step 4 self.update_metadata_cache_worker.progress_made.connect( self.update_progress_bar ) self.update_metadata_cache_worker.package_updated.connect( self.on_package_updated ) self.update_metadata_cache_worker.start() else: self.do_next_startup_phase() def on_buttonUpdateCache_clicked(self) -> None: self.update_cache = True cache_path = FreeCAD.getUserCachePath() am_path = os.path.join(cache_path, "AddonManager") try: shutil.rmtree(am_path, onerror=self.remove_readonly) except Exception: pass self.dialog.buttonUpdateCache.setEnabled(False) self.dialog.buttonUpdateCache.setText( translate("AddonsInstaller", "Updating cache...") ) self.startup() # Recaching implies checking for updates, regardless of the user's autocheck option self.startup_sequence.remove(self.check_updates) self.startup_sequence.append(self.force_check_updates) def on_package_updated(self, repo: Addon) -> None: """Called when the named package has either new metadata or a new icon (or both)""" with self.lock: repo.icon = self.get_icon(repo, update=True) self.item_model.reload_item(repo) def load_macro_metadata(self) -> None: if self.update_cache: self.load_macro_metadata_worker = CacheMacroCodeWorker( self.item_model.repos ) self.load_macro_metadata_worker.status_message.connect( self.show_information ) self.load_macro_metadata_worker.update_macro.connect( self.on_package_updated ) self.load_macro_metadata_worker.progress_made.connect( self.update_progress_bar ) self.load_macro_metadata_worker.finished.connect(self.do_next_startup_phase) self.load_macro_metadata_worker.start() else: self.do_next_startup_phase() def select_addon(self, name: str) -> None: found = False for addon in self.item_model.repos: if addon.name == name: self.table_row_activated(addon) found = True break if not found: FreeCAD.Console.PrintWarning( translate( "AddonsInstaller", "Could not find addon '{}' to select\n" ).format(name) ) self.do_next_startup_phase() def check_updates(self) -> None: "checks every installed addon for available updates" pref = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Addons") autocheck = pref.GetBool("AutoCheck", False) if not autocheck: FreeCAD.Console.PrintLog( "Addon Manager: Skipping update check because AutoCheck user preference is False\n" ) self.do_next_startup_phase() return if not self.packages_with_updates: self.force_check_updates(standalone=False) else: self.do_next_startup_phase() def force_check_updates(self, standalone=False) -> None: if hasattr(self, "check_worker"): thread = self.check_worker if thread: if not thread.isFinished(): self.do_next_startup_phase() return self.dialog.buttonUpdateAll.setText( translate("AddonsInstaller", "Checking for updates...") ) self.packages_with_updates.clear() self.dialog.buttonUpdateAll.show() self.dialog.buttonCheckForUpdates.setDisabled(True) self.check_worker = CheckWorkbenchesForUpdatesWorker(self.item_model.repos) self.check_worker.finished.connect(self.do_next_startup_phase) self.check_worker.finished.connect(self.update_check_complete) self.check_worker.progress_made.connect(self.update_progress_bar) if standalone: self.current_progress_region = 1 self.number_of_progress_regions = 1 self.check_worker.update_status.connect(self.status_updated) self.check_worker.start() self.enable_updates(len(self.packages_with_updates)) def status_updated(self, repo: Addon) -> None: self.item_model.reload_item(repo) if repo.status() == Addon.Status.UPDATE_AVAILABLE: self.packages_with_updates.add(repo) self.enable_updates(len(self.packages_with_updates)) elif repo.status() == Addon.Status.PENDING_RESTART: self.restart_required = True def enable_updates(self, number_of_updates: int) -> None: """enables the update button""" if number_of_updates: s = translate( "AddonsInstaller", "Apply {} update(s)", "", number_of_updates ) self.dialog.buttonUpdateAll.setText(s.format(number_of_updates)) self.dialog.buttonUpdateAll.setEnabled(True) elif hasattr(self, "check_worker") and self.check_worker.isRunning(): self.dialog.buttonUpdateAll.setText( translate("AddonsInstaller", "Checking for updates...") ) else: self.dialog.buttonUpdateAll.setText( translate("AddonsInstaller", "No updates available") ) self.dialog.buttonUpdateAll.setEnabled(False) def update_check_complete(self) -> None: self.enable_updates(len(self.packages_with_updates)) self.dialog.buttonCheckForUpdates.setEnabled(True) def check_python_updates(self) -> None: if hasattr(self, "check_for_python_package_updates_worker"): thread = self.check_for_python_package_updates_worker if thread: if not thread.isFinished(): self.do_next_startup_phase() return self.check_for_python_package_updates_worker = ( CheckForPythonPackageUpdatesWorker() ) self.check_for_python_package_updates_worker.python_package_updates_available.connect( lambda: self.dialog.buttonUpdateDependencies.show() ) self.check_for_python_package_updates_worker.finished.connect( self.do_next_startup_phase ) self.check_for_python_package_updates_worker.start() def show_python_updates_dialog(self) -> None: if not hasattr(self, "manage_python_packages_dialog"): self.manage_python_packages_dialog = PythonPackageManager() self.manage_python_packages_dialog.show() def add_addon_repo(self, addon_repo: Addon) -> None: """adds a workbench to the list""" if addon_repo.icon is None or addon_repo.icon.isNull(): addon_repo.icon = self.get_icon(addon_repo) for repo in self.item_model.repos: if repo.name == addon_repo.name: # self.item_model.reload_item(repo) # If we want to have later additions supersede earlier return self.item_model.append_item(addon_repo) def get_icon(self, repo: Addon, update: bool = False) -> QtGui.QIcon: """Returns an icon for an Addon. Uses a cached icon if possible, unless update is True, in which case the icon is regenerated.""" if not update and repo.icon and not repo.icon.isNull() and repo.icon.isValid(): return repo.icon path = ":/icons/" + repo.name.replace(" ", "_") if repo.repo_type == Addon.Kind.WORKBENCH: path += "_workbench_icon.svg" default_icon = QtGui.QIcon(":/icons/document-package.svg") elif repo.repo_type == Addon.Kind.MACRO: if repo.macro and repo.macro.icon: if os.path.isabs(repo.macro.icon): path = repo.macro.icon default_icon = QtGui.QIcon(":/icons/document-python.svg") else: path = os.path.join( os.path.dirname(repo.macro.src_filename), repo.macro.icon ) default_icon = QtGui.QIcon(":/icons/document-python.svg") elif repo.macro and repo.macro.xpm: cache_path = FreeCAD.getUserCachePath() am_path = os.path.join(cache_path, "AddonManager", "MacroIcons") os.makedirs(am_path, exist_ok=True) path = os.path.join(am_path, repo.name + "_icon.xpm") if not os.path.exists(path): with open(path, "w") as f: f.write(repo.macro.xpm) default_icon = QtGui.QIcon(repo.macro.xpm) else: path += "_macro_icon.svg" default_icon = QtGui.QIcon(":/icons/document-python.svg") elif repo.repo_type == Addon.Kind.PACKAGE: # The cache might not have been downloaded yet, check to see if it's there... if os.path.isfile(repo.get_cached_icon_filename()): path = repo.get_cached_icon_filename() elif repo.contains_workbench(): path += "_workbench_icon.svg" default_icon = QtGui.QIcon(":/icons/document-package.svg") elif repo.contains_macro(): path += "_macro_icon.svg" default_icon = QtGui.QIcon(":/icons/document-python.svg") else: default_icon = QtGui.QIcon(":/icons/document-package.svg") if QtCore.QFile.exists(path): addonicon = QtGui.QIcon(path) else: addonicon = default_icon repo.icon = addonicon return addonicon def table_row_activated(self, selected_repo: Addon) -> None: """a row was activated, show the relevant data""" self.packageList.hide() self.packageDetails.show() self.packageDetails.show_repo(selected_repo) def show_information(self, message: str) -> None: """shows generic text in the information pane""" self.dialog.labelStatusInfo.setText(message) self.dialog.labelStatusInfo.repaint() def show_workbench(self, repo: Addon) -> None: self.packageList.hide() self.packageDetails.show() self.packageDetails.show_repo(repo) def on_buttonBack_clicked(self) -> None: self.packageDetails.hide() self.packageList.show() def append_to_repos_list(self, repo: Addon) -> None: """this function allows threads to update the main list of workbenches""" self.item_model.append_item(repo) # @dataclass(frozen) class MissingDependencies: """Encapsulates a group of four types of dependencies: * Internal workbenches -> wbs * External addons -> external_addons * Required Python packages -> python_required * Optional Python packages -> python_optional """ def __init__(self, repo: Addon, all_repos: List[Addon]): deps = Addon.Dependencies() repo_name_dict = dict() for r in all_repos: repo_name_dict[repo.name] = r repo_name_dict[repo.display_name] = r repo.walk_dependency_tree(repo_name_dict, deps) self.external_addons = [] for dep in deps.required_external_addons: if dep.status() == Addon.Status.NOT_INSTALLED: self.external_addons.append(dep) # Now check the loaded addons to see if we are missing an internal workbench: wbs = [wb.lower() for wb in FreeCADGui.listWorkbenches()] self.wbs = [] for dep in deps.internal_workbenches: if dep.lower() + "workbench" not in wbs: if dep.lower() == "plot": # Special case for plot, which is no longer a full workbench: try: __import__("Plot") except ImportError: # Plot might fail for a number of reasons self.wbs.append(dep) FreeCAD.Console.PrintLog("Failed to import Plot module") else: self.wbs.append(dep) # Check the Python dependencies: self.python_required = [] for py_dep in deps.python_required: if py_dep not in self.python_required: try: __import__(py_dep) except ImportError: self.python_required.append(py_dep) self.python_optional = [] for py_dep in deps.python_optional: try: __import__(py_dep) except ImportError: self.python_optional.append(py_dep) self.wbs.sort() self.external_addons.sort() self.python_required.sort() self.python_optional.sort() self.python_optional = [ option for option in self.python_optional if option not in self.python_required ] def update_allowed_packages_list(self) -> None: FreeCAD.Console.PrintLog( "Attempting to fetch remote copy of ALLOWED_PYTHON_PACKAGES.txt...\n" ) p = NetworkManager.AM_NETWORK_MANAGER.blocking_get( "https://raw.githubusercontent.com/FreeCAD/FreeCAD-addons/master/ALLOWED_PYTHON_PACKAGES.txt" ) if p: FreeCAD.Console.PrintLog( "Remote ALLOWED_PYTHON_PACKAGES.txt file located, overriding locally-installed copy\n" ) p = p.data().decode("utf8") lines = p.split("\n") self.allowed_packages.clear() # Unset the locally-defined list for line in lines: if line and len(line) > 0 and line[0] != "#": self.allowed_packages.add(line.strip()) else: FreeCAD.Console.PrintLog( "Could not fetch remote ALLOWED_PYTHON_PACKAGES.txt, using local copy\n" ) def handle_disallowed_python(self, python_required: List[str]) -> bool: """Determine if we are missing any required Python packages that are not in the allowed packages list. If so, display a message to the user, and return True. Otherwise return False.""" bad_packages = [] self.update_allowed_packages_list() for dep in python_required: if dep not in self.allowed_packages: bad_packages.append(dep) for dep in bad_packages: python_required.remove(dep) if bad_packages: message = ( "

" + translate( "AddonsInstaller", "This addon requires Python packages that are not installed, and cannot be installed automatically. To use this workbench you must install the following Python packages manually:", ) + "

" message += "To ignore this error and install anyway, press OK." r = QtWidgets.QMessageBox.critical( self.dialog, translate("AddonsInstaller", "Missing Requirement"), message, QtWidgets.QMessageBox.Ok | QtWidgets.QMessageBox.Cancel, ) FreeCAD.Console.PrintMessage( translate( "AddonsInstaller", "The following Python packages are allowed to be automatically installed", ) + ":\n" ) for package in self.allowed_packages: FreeCAD.Console.PrintMessage(f" * {package}\n") if r == QtWidgets.QMessageBox.Ok: # Force the installation to proceed return False else: return True else: return False def report_missing_workbenches(self, addon_name: str, wbs) -> bool: if len(wbs) == 1: name = wbs[0] message = translate( "AddonsInstaller", "Addon '{}' requires '{}', which is not available in your copy of FreeCAD.", ).format(addon_name, name) else: message = ( "

" + translate( "AddonsInstaller", "Addon '{}' requires the following workbenches, which are not available in your copy of FreeCAD:", ).format(addon_name) + "

" message += translate("AddonsInstaller", "Press OK to install anyway.") r = QtWidgets.QMessageBox.critical( self.dialog, translate("AddonsInstaller", "Missing Requirement"), message, QtWidgets.QMessageBox.Ok | QtWidgets.QMessageBox.Cancel, ) if r == QtWidgets.QMessageBox.Ok: return True else: return False def display_dep_resolution_dialog(self, missing, repo: Addon) -> None: self.dependency_dialog = FreeCADGui.PySideUic.loadUi( os.path.join(os.path.dirname(__file__), "dependency_resolution_dialog.ui") ) self.dependency_dialog.setWindowFlag(QtCore.Qt.WindowStaysOnTopHint, True) for addon in missing.external_addons: self.dependency_dialog.listWidgetAddons.addItem(addon) for mod in missing.python_required: self.dependency_dialog.listWidgetPythonRequired.addItem(mod) for mod in missing.python_optional: item = QtWidgets.QListWidgetItem(mod) item.setFlags(item.flags() | QtCore.Qt.ItemIsUserCheckable) item.setCheckState(QtCore.Qt.Unchecked) self.dependency_dialog.listWidgetPythonOptional.addItem(item) self.dependency_dialog.buttonBox.button( QtWidgets.QDialogButtonBox.Yes ).clicked.connect(lambda: self.dependency_dialog_yes_clicked(repo)) self.dependency_dialog.buttonBox.button( QtWidgets.QDialogButtonBox.Ignore ).clicked.connect(lambda: self.dependency_dialog_ignore_clicked(repo)) self.dependency_dialog.buttonBox.button( QtWidgets.QDialogButtonBox.Cancel ).setDefault(True) self.dependency_dialog.exec() def resolve_dependencies(self, repo: Addon) -> None: if not repo: return missing = CommandAddonManager.MissingDependencies(repo, self.item_model.repos) if self.handle_disallowed_python(missing.python_required): return good_packages = [] for dep in missing.python_optional: if dep in self.allowed_packages: good_packages.append(dep) else: FreeCAD.Console.PrintWarning( translate( "AddonsInstaller", "Optional dependency on {} ignored because it is not in the allow-list\n", ).format(dep) ) missing.python_optional = good_packages if missing.wbs: r = self.report_missing_workbenches(repo.display_name, missing.wbs) if r == False: return if ( missing.external_addons or missing.python_required or missing.python_optional ): # Recoverable: ask the user if they want to install the missing deps self.display_dep_resolution_dialog(missing, repo) else: # No missing deps, just install self.install(repo) def dependency_dialog_yes_clicked(self, repo: Addon) -> None: # Get the lists out of the dialog: addons = [] for row in range(self.dependency_dialog.listWidgetAddons.count()): item = self.dependency_dialog.listWidgetAddons.item(row) name = item.text() for repo in self.item_model.repos: if repo.name == name or repo.display_name == name: addons.append(repo) python_required = [] for row in range(self.dependency_dialog.listWidgetPythonRequired.count()): item = self.dependency_dialog.listWidgetPythonRequired.item(row) python_required.append(item.text()) python_optional = [] for row in range(self.dependency_dialog.listWidgetPythonOptional.count()): item = self.dependency_dialog.listWidgetPythonOptional.item(row) if item.checkState() == QtCore.Qt.Checked: python_optional.append(item.text()) self.dependency_installation_worker = DependencyInstallationWorker( addons, python_required, python_optional ) self.dependency_installation_worker.no_python_exe.connect( lambda: self.no_python_exe(repo) ) self.dependency_installation_worker.no_pip.connect( lambda command: self.no_pip(command, repo) ) self.dependency_installation_worker.failure.connect( self.dependency_installation_failure ) self.dependency_installation_worker.success.connect(lambda: self.install(repo)) self.dependency_installation_dialog = QtWidgets.QMessageBox( QtWidgets.QMessageBox.Information, translate("AddonsInstaller", "Installing dependencies"), translate("AddonsInstaller", "Installing dependencies") + "...", QtWidgets.QMessageBox.Cancel, self.dialog, ) self.dependency_installation_dialog.rejected.connect( self.cancel_dependency_installation ) self.dependency_installation_dialog.show() self.dependency_installation_worker.start() def no_python_exe(self, repo: Addon) -> None: if hasattr(self, "dependency_installation_dialog"): self.dependency_installation_dialog.hide() result = QtWidgets.QMessageBox.critical( self.dialog, translate("AddonsInstaller", "Cannot execute Python"), translate( "AddonsInstaller", "Failed to automatically locate your Python executable, or the path is set incorrectly. Please check the Addon Manager preferences setting for the path to Python.", ) + "\n\n" + translate( "AddonsInstaller", "Dependencies could not be installed. Continue with installation of {} anyway?", ).format(repo.name), QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No, ) if result == QtWidgets.QMessageBox.Yes: self.install(repo) def no_pip(self, command: str, repo: Addon) -> None: if hasattr(self, "dependency_installation_dialog"): self.dependency_installation_dialog.hide() result = QtWidgets.QMessageBox.critical( self.dialog, translate("AddonsInstaller", "Cannot execute pip"), translate( "AddonsInstaller", "Failed to execute pip, which may be missing from your Python installation. Please ensure your system has pip installed and try again. The failed command was: ", ) + f"\n\n{command}\n\n" + translate( "AddonsInstaller", "Continue with installation of {} anyway?", ).format(repo.name), QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No, ) if result == QtWidgets.QMessageBox.Yes: self.install(repo) def dependency_installation_failure(self, short_message: str, details: str) -> None: if hasattr(self, "dependency_installation_dialog"): self.dependency_installation_dialog.hide() FreeCAD.Console.PrintError(details) QtWidgets.QMessageBox.critical( self.dialog, translate("AddonsInstaller", "Package installation failed"), short_message + "\n\n" + translate("AddonsInstaller", "See Report View for detailed failure log."), QtWidgets.QMessageBox.Cancel, ) def dependency_dialog_ignore_clicked(self, repo: Addon) -> None: self.install(repo) def cancel_dependency_installation(self) -> None: self.dependency_installation_worker.blockSignals(True) self.dependency_installation_worker.requestInterruption() self.dependency_installation_dialog.hide() def install(self, repo: Addon) -> None: """installs or updates a workbench, macro, or package""" if hasattr(self, "install_worker") and self.install_worker: if self.install_worker.isRunning(): return if hasattr(self, "dependency_installation_dialog"): self.dependency_installation_dialog.hide() if not repo: return if ( repo.repo_type == Addon.Kind.WORKBENCH or repo.repo_type == Addon.Kind.PACKAGE ): self.show_progress_widgets() self.install_worker = InstallWorkbenchWorker(repo) self.install_worker.status_message.connect(self.show_information) self.current_progress_region = 1 self.number_of_progress_regions = 1 self.install_worker.progress_made.connect(self.update_progress_bar) self.install_worker.success.connect(self.on_package_installed) self.install_worker.failure.connect(self.on_installation_failed) self.install_worker.start() elif repo.repo_type == Addon.Kind.MACRO: macro = repo.macro # To try to ensure atomicity, test the installation into a temp directory first, # and assume if that worked we have good odds of the real installation working failed = False errors = [] with tempfile.TemporaryDirectory() as dir: temp_install_succeeded, error_list = macro.install(dir) if not temp_install_succeeded: failed = True errors = error_list if not failed: real_install_succeeded, errors = macro.install(self.macro_repo_dir) if not real_install_succeeded: failed = True else: utils.update_macro_installation_details(repo) if not failed: message = translate( "AddonsInstaller", "Macro successfully installed. The macro is now available from the Macros dialog.", ) self.on_package_installed(repo, message) else: message = ( translate("AddonsInstaller", "Installation of macro failed") + ":" ) for error in errors: message += "\n * " message += error self.on_installation_failed(repo, message) def update(self, repo: Addon) -> None: self.install(repo) def mark_repo_update_available(self, repo: Addon, available: bool) -> None: if available: repo.set_status(Addon.Status.UPDATE_AVAILABLE) else: repo.set_status(Addon.Status.NO_UPDATE_AVAILABLE) self.item_model.reload_item(repo) self.packageDetails.show_repo(repo) def update_all(self) -> None: """Asynchronously apply all available updates: individual failures are noted, but do not stop other updates""" if hasattr(self, "update_all_worker") and self.update_all_worker: if self.update_all_worker.isRunning(): return self.subupdates_succeeded = [] self.subupdates_failed = [] self.show_progress_widgets() self.current_progress_region = 1 self.number_of_progress_regions = 1 self.update_all_worker = UpdateAllWorker(self.packages_with_updates) self.update_all_worker.progress_made.connect(self.update_progress_bar) self.update_all_worker.status_message.connect(self.show_information) self.update_all_worker.success.connect( lambda repo: self.subupdates_succeeded.append(repo) ) self.update_all_worker.failure.connect( lambda repo: self.subupdates_failed.append(repo) ) self.update_all_worker.finished.connect(self.on_update_all_completed) self.update_all_worker.start() def on_update_all_completed(self) -> None: self.hide_progress_widgets() def get_package_list(message: str, repos: List[Addon], threshold: int): """To ensure that the list doesn't get too long for the dialog, cut it off at some threshold""" num_updates = len(repos) if num_updates < threshold: result = "".join([repo.name + "\n" for repo in repos]) else: result = translate( "AddonsInstaller", "{} total, see Report view for list", "Describes the number of updates that were completed ('{}' is replaced by the number of updates)", ).format(num_updates) for repo in repos: FreeCAD.Console.PrintMessage(f"{message}: {repo.name}\n") return result if not self.subupdates_failed: message = ( translate( "AddonsInstaller", "All packages were successfully updated", ) + ": \n" ) message += get_package_list( translate("AddonsInstaller", "Succeeded"), self.subupdates_succeeded, 15 ) elif not self.subupdates_succeeded: message = ( translate("AddonsInstaller", "All packages updates failed:") + "\n" ) message += get_package_list( translate("AddonsInstaller", "Failed"), self.subupdates_failed, 15 ) else: message = ( translate( "AddonsInstaller", "Some packages updates failed.", ) + "\n\n" + translate( "AddonsInstaller", "Succeeded", ) + ":\n" ) message += get_package_list( translate("AddonsInstaller", "Succeeded"), self.subupdates_succeeded, 8 ) message += "\n\n" message += translate("AddonsInstaller", "Failed") + ":\n" message += get_package_list( translate("AddonsInstaller", "Failed"), self.subupdates_failed, 8 ) for installed_repo in self.subupdates_succeeded: if installed_repo.contains_workbench(): self.restart_required = True installed_repo.set_status(Addon.Status.PENDING_RESTART) else: installed_repo.set_status(Addon.Status.NO_UPDATE_AVAILABLE) self.item_model.reload_item(installed_repo) for requested_repo in self.packages_with_updates: if installed_repo.name == requested_repo.name: self.packages_with_updates.remove(installed_repo) break self.enable_updates(len(self.packages_with_updates)) QtWidgets.QMessageBox.information( self.dialog, translate("AddonsInstaller", "Update report"), message, QtWidgets.QMessageBox.Close, ) def hide_progress_widgets(self) -> None: """hides the progress bar and related widgets""" self.dialog.labelStatusInfo.hide() self.dialog.progressBar.hide() self.dialog.buttonPauseUpdate.hide() self.packageList.ui.lineEditFilter.setFocus() def show_progress_widgets(self) -> None: if self.dialog.progressBar.isHidden(): self.dialog.progressBar.show() self.dialog.buttonPauseUpdate.show() self.dialog.labelStatusInfo.show() def update_progress_bar(self, current_value: int, max_value: int) -> None: """Update the progress bar, showing it if it's hidden""" max_value = max_value if max_value > 0 else 1 if current_value < 0: current_value = 0 elif current_value > max_value: current_value = max_value self.show_progress_widgets() region_size = 100.0 / self.number_of_progress_regions completed_region_portion = (self.current_progress_region - 1) * region_size current_region_portion = (float(current_value) / float(max_value)) * region_size value = completed_region_portion + current_region_portion self.dialog.progressBar.setValue( value * 10 ) # Out of 1000 segments, so it moves sort of smoothly self.dialog.progressBar.repaint() def stop_update(self) -> None: self.cleanup_workers() self.hide_progress_widgets() self.write_cache_stopfile() self.dialog.buttonUpdateCache.setEnabled(True) self.dialog.buttonUpdateCache.setText( translate("AddonsInstaller", "Refresh local cache") ) def write_cache_stopfile(self) -> None: stopfile = utils.get_cache_file_name("CACHE_UPDATE_INTERRUPTED") with open(stopfile, "w", encoding="utf8") as f: f.write( "This file indicates that a cache operation was interrupted, and " "the cache is in an unknown state. It will be deleted next time " "AddonManager recaches." ) def on_package_installed(self, repo: Addon, message: str) -> None: self.hide_progress_widgets() QtWidgets.QMessageBox.information( self.dialog, translate("AddonsInstaller", "Installation succeeded"), message, QtWidgets.QMessageBox.Close, ) if repo.contains_workbench(): repo.set_status(Addon.Status.PENDING_RESTART) self.restart_required = True else: repo.set_status(Addon.Status.NO_UPDATE_AVAILABLE) self.item_model.reload_item(repo) self.packageDetails.show_repo(repo) if repo.repo_type == Addon.Kind.MACRO: ask_to_install_toolbar_button(repo) if repo in self.packages_with_updates: self.packages_with_updates.remove(repo) self.enable_updates(len(self.packages_with_updates)) def on_installation_failed(self, _: Addon, message: str) -> None: self.hide_progress_widgets() QtWidgets.QMessageBox.warning( self.dialog, translate("AddonsInstaller", "Installation failed"), message, QtWidgets.QMessageBox.Close, ) def executemacro(self, repo: Addon) -> None: """executes a selected macro""" macro = repo.macro if not macro or not macro.code: return if macro.is_installed(): macro_path = os.path.join(self.macro_repo_dir, macro.filename) FreeCADGui.open(str(macro_path)) self.dialog.hide() FreeCADGui.SendMsgToActiveView("Run") else: with tempfile.TemporaryDirectory() as dir: temp_install_succeeded = macro.install(dir) if not temp_install_succeeded: message = translate( "AddonsInstaller", "Execution of macro failed. See console for failure details.", ) self.on_installation_failed(repo, message) return else: macro_path = os.path.join(dir, macro.filename) FreeCADGui.open(str(macro_path)) self.dialog.hide() FreeCADGui.SendMsgToActiveView("Run") def remove_readonly(self, func, path, _) -> None: """Remove a read-only file.""" os.chmod(path, stat.S_IWRITE) func(path) def remove(self, repo: Addon) -> None: """uninstalls a macro or workbench""" confirm = QtWidgets.QMessageBox.question( self.dialog, translate("AddonsInstaller", "Confirm remove"), translate( "AddonsInstaller", "Are you sure you want to uninstall this Addon?" ), QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.Cancel, ) if confirm == QtWidgets.QMessageBox.Cancel: return if ( repo.repo_type == Addon.Kind.WORKBENCH or repo.repo_type == Addon.Kind.PACKAGE ): basedir = FreeCAD.getUserAppDataDir() moddir = basedir + os.sep + "Mod" clonedir = moddir + os.sep + repo.name # First remove any macros that were copied or symlinked in, as long as they have not been modified macro_dir = FreeCAD.getUserMacroDir(True) if os.path.exists(macro_dir) and os.path.exists(clonedir): for macro_filename in os.listdir(clonedir): if macro_filename.lower().endswith(".fcmacro"): mod_macro_path = os.path.join(clonedir, macro_filename) macro_path = os.path.join(macro_dir, macro_filename) if not os.path.isfile(macro_path): continue # Load both files (one may be a symlink of the other, this will still work in that case) with open(mod_macro_path) as f1: f1_contents = f1.read() with open(macro_path) as f2: f2_contents = f2.read() if f1_contents == f2_contents: os.remove(macro_path) else: FreeCAD.Console.PrintMessage( translate( "AddonsInstaller", "Macro {} has local changes in the macros directory, so is not being removed by this uninstall process.\n", ).format(macro_filename) ) # Second, run the Addon's "uninstall.py" script, if it exists uninstall_script = os.path.join(clonedir, "uninstall.py") if os.path.exists(uninstall_script): try: with open(uninstall_script, "r") as f: exec(f.read()) except Exception: FreeCAD.Console.PrintError( translate( "AddonsInstaller", "Execution of Addon's uninstall.py script failed. Proceeding with uninstall...", ) + "\n" ) if os.path.exists(clonedir): shutil.rmtree(clonedir, onerror=self.remove_readonly) self.item_model.update_item_status( repo.name, Addon.Status.NOT_INSTALLED ) if repo.contains_workbench(): self.restart_required = True self.packageDetails.show_repo(repo) else: self.dialog.textBrowserReadMe.setText( translate( "AddonsInstaller", "Unable to remove this addon with the Addon Manager.", ) ) elif repo.repo_type == Addon.Kind.MACRO: macro = repo.macro if macro.remove(): remove_custom_toolbar_button(repo) FreeCAD.Console.PrintMessage( translate("AddonsInstaller", "Successfully uninstalled {}").format( repo.name ) + "\n" ) self.item_model.update_item_status( repo.name, Addon.Status.NOT_INSTALLED ) self.packageDetails.show_repo(repo) else: FreeCAD.Console.PrintMessage( translate( "AddonsInstaller", "Failed to uninstall {}. Please remove manually.", ).format(repo.name) + "\n" ) def validate(self): """Developer tool: check all repos for validity and print report""" FreeCAD.Console.PrintLog(f"\n\nADDON MANAGER DEVELOPER MODE CHECKS\n") FreeCAD.Console.PrintLog(f"-----------------------------------\n") counter = 0 for addon in self.item_model.repos: counter += 1 self.update_progress_bar(counter, len(self.item_model.repos)) if addon.metadata is not None: self.validate_package_xml(addon) elif addon.repo_type == Addon.Kind.MACRO: if addon.macro.parsed: if len(addon.macro.icon) == 0 and len(addon.macro.xpm) == 0: FreeCAD.Console.PrintLog( f"Macro '{addon.name}' does not have an icon\n" ) else: FreeCAD.Console.PrintLog( f"Addon '{addon.name}' does not have a package.xml file\n" ) FreeCAD.Console.PrintLog(f"-----------------------------------\n\n") self.do_next_startup_phase() def validate_package_xml(self, addon: Addon): if addon.metadata is None: return # The package.xml standard has some required elements that the basic XML reader is not actually checking # for. In developer mode, actually make sure that all of the rules are being followed for each element. errors = [] # Top-level required elements if not addon.metadata.Name or len(addon.metadata.Name) == 0: errors.append( f"No top-level element found, or element is empty" ) if not addon.metadata.Version or addon.metadata.Version == "0.0.0": errors.append( f"No top-level element found, or element is invalid" ) # if not addon.metadata.Date or len(addon.metadata.Date) == 0: # errors.append(f"No top-level element found, or element is invalid") if not addon.metadata.Description or len(addon.metadata.Description) == 0: errors.append( f"No top-level element found, or element is invalid" ) maintainers = addon.metadata.Maintainer if len(maintainers) == 0: errors.append(f"No top-level found, at least one is required") for maintainer in maintainers: if len(maintainer["email"]) == 0: errors.append( f"No email address specified for maintainer '{maintainer['name']}'" ) licenses = addon.metadata.License if len(licenses) == 0: errors.append(f"No top-level found, at least one is required") urls = addon.metadata.Urls if len(urls) == 0: errors.append( f"No elements found, at least a repo url must be provided" ) else: found_repo = False found_readme = False for url in urls: if url["type"] == "repository": found_repo = True if len(url["branch"]) == 0: errors.append( " element is missing the 'branch' attribute" ) elif url["type"] == "readme": found_readme = True location = url["location"] p = NetworkManager.AM_NETWORK_MANAGER.blocking_get(location) if not p: errors.append( f"Could not access specified readme at {location}" ) else: p = p.data().decode("utf8") if "" in p: pass else: errors.append( f"Readme data found at {location} does not appear to be rendered HTML" ) if not found_repo: errors.append("No repo url specified") if not found_readme: errors.append( "No readme url specified (not required, but highly recommended)" ) contents = addon.metadata.Content if not contents or len(contents) == 0: errors.append("No content items found") missing_icon = True if addon.metadata.Icon and len(addon.metadata.Icon) > 0: missing_icon = False else: if "workbench" in contents: wb = contents["workbench"][0] if wb.Icon: missing_icon = False if missing_icon: errors.append(f"No element found, or element is invalid") if "workbench" in contents: for wb in contents["workbench"]: errors.extend(self.validate_workbench_metadata(wb)) if "preferencepack" in contents: for wb in contents["preferencepack"]: errors.extend(self.validate_preference_pack_metadata(wb)) if len(errors) > 0: FreeCAD.Console.PrintLog( f"Errors found in package.xml file for '{addon.name}'\n" ) for error in errors: FreeCAD.Console.PrintLog(f" * {error}\n") def validate_workbench_metadata(self, workbench) -> List[str]: errors = [] if not workbench.Classname or len(workbench.Classname) == 0: errors.append("No specified for workbench") return errors def validate_preference_pack_metadata(self, pack) -> List[str]: errors = [] if not pack.Name or len(pack.Name) == 0: errors.append("No specified for preference pack") return errors # @}