def _onInstanceNameChanged(self, instance, old_name):
file_name = urllib.parse.quote_plus(old_name)
try:
path = Resources.getStoragePath(Resources.MachineInstances, file_name + ".cfg")
os.remove(path)
path = Resources.getStoragePath(Resources.MachineInstanceProfiles, file_name + ".curaprofile")
os.remove(path)
except FileNotFoundError:
pass
#Update machine instance name for all profiles attached to this machine instance
for profile in self._profiles:
if profile.isReadOnly() or profile.getMachineInstanceName() != old_name:
continue
file_name = urllib.parse.quote_plus(profile.getName()) + ".cfg"
try:
path = Resources.getStoragePath(Resources.Profiles, file_name)
os.remove(path)
except FileNotFoundError:
pass
profile.setMachineInstanceName(instance.getName())
self.machineInstanceNameChanged.emit(instance)
def initialize(self) -> None:
self._installation_dirs_dict["materials"] = Resources.getStoragePath(
CuraApplication.ResourceTypes.MaterialInstanceContainer)
self._installation_dirs_dict["qualities"] = Resources.getStoragePath(
CuraApplication.ResourceTypes.QualityInstanceContainer)
super().initialize()
def removeMachineInstance(self, instance):
if instance not in self._machine_instances:
return
self._machine_instances.remove(instance)
instance.nameChanged.disconnect(self._onInstanceNameChanged)
file_name = urllib.parse.quote_plus(instance.getName())
try:
path = Resources.getStoragePath(Resources.MachineInstances,
file_name + ".cfg")
os.remove(path)
path = Resources.getStoragePath(Resources.MachineInstanceProfiles,
file_name + ".cfg")
os.remove(path)
except FileNotFoundError:
pass
self.machineInstancesChanged.emit()
if self._active_machine == instance:
try:
self.setActiveMachineInstance(self._machine_instances[0])
except:
self.setActiveMachineInstance(None)
def __init__(self, parent=None):
super().__init__(parent)
self._installation_dirs_dict["materials"] = Resources.getStoragePath(
CuraApplication.ResourceTypes.MaterialInstanceContainer)
self._installation_dirs_dict["qualities"] = Resources.getStoragePath(
CuraApplication.ResourceTypes.QualityInstanceContainer)
def saveStack(self, stack):
if not stack.isDirty():
return
try:
data = stack.serialize()
except NotImplementedError:
return
except Exception:
Logger.logException(
"e", "An exception occurred when serializing container %s",
stack.getId())
return
mime_type = ContainerRegistry.getMimeTypeForContainer(type(stack))
file_name = urllib.parse.quote_plus(
stack.getId()) + "." + mime_type.preferredSuffix
stack_type = stack.getMetaDataEntry("type", None)
path = None
if not stack_type or stack_type == "machine":
path = Resources.getStoragePath(self.ResourceTypes.MachineStack,
file_name)
elif stack_type == "extruder_train":
path = Resources.getStoragePath(self.ResourceTypes.ExtruderStack,
file_name)
if path:
stack.setPath(path)
with SaveFile(path, "wt") as f:
f.write(data)
def loadAllScripts(self) -> None:
if self._loaded_scripts: # Already loaded.
return
# The PostProcessingPlugin path is for built-in scripts.
# The Resources path is where the user should store custom scripts.
# The Preferences path is legacy, where the user may previously have stored scripts.
for root in [
PluginRegistry.getInstance().getPluginPath(
"PostProcessingPlugin"),
Resources.getStoragePath(Resources.Resources),
Resources.getStoragePath(Resources.Preferences)
]:
if root is None:
continue
path = os.path.join(root, "scripts")
if not os.path.isdir(path):
try:
os.makedirs(path)
except OSError:
Logger.log(
"w", "Unable to create a folder for scripts: " + path)
continue
self.loadScripts(path)
def _onInstanceNameChanged(self, instance, old_name):
file_name = urllib.parse.quote_plus(old_name)
try:
path = Resources.getStoragePath(Resources.MachineInstances,
file_name + ".cfg")
os.remove(path)
path = Resources.getStoragePath(Resources.MachineInstanceProfiles,
file_name + ".curaprofile")
os.remove(path)
except FileNotFoundError:
pass
#Update machine instance name for all profiles attached to this machine instance
for profile in self._profiles:
if profile.isReadOnly(
) or profile.getMachineInstanceName() != old_name:
continue
file_name = urllib.parse.quote_plus(profile.getName()) + ".cfg"
try:
path = Resources.getStoragePath(Resources.Profiles, file_name)
os.remove(path)
except FileNotFoundError:
pass
profile.setMachineInstanceName(instance.getName())
self.machineInstanceNameChanged.emit(instance)
def saveAll(self) -> None:
for instance in self.findInstanceContainers():
if not instance.isDirty():
continue
try:
data = instance.serialize()
except NotImplementedError:
# Serializing is not supported so skip this container
continue
except Exception:
Logger.logException("e", "An exception occurred trying to serialize container %s", instance.getId())
continue
mime_type = self.getMimeTypeForContainer(type(instance))
if mime_type is not None:
file_name = urllib.parse.quote_plus(instance.getId()) + "." + mime_type.preferredSuffix
path = Resources.getStoragePath(Resources.InstanceContainers, file_name)
with SaveFile(path, "wt") as f:
f.write(data)
for stack in self.findContainerStacks():
if not stack.isDirty():
continue
try:
data = stack.serialize()
except NotImplementedError:
# Serializing is not supported so skip this container
continue
except Exception:
Logger.logException("e", "An exception occurred trying to serialize container %s", stack.getId())
continue
mime_type = self.getMimeTypeForContainer(type(stack))
if mime_type is not None:
file_name = urllib.parse.quote_plus(stack.getId()) + "." + mime_type.preferredSuffix
path = Resources.getStoragePath(Resources.ContainerStacks, file_name)
with SaveFile(path, "wt") as f:
f.write(data)
for definition in self.findDefinitionContainers():
try:
data = definition.serialize()
except NotImplementedError:
# Serializing is not supported so skip this container
continue
except Exception:
Logger.logException("e", "An exception occurred trying to serialize container %s", definition.getId())
continue
mime_type = self.getMimeTypeForContainer(type(definition))
if mime_type is not None:
file_name = urllib.parse.quote_plus(definition.getId()) + "." + mime_type.preferredSuffix
path = Resources.getStoragePath(Resources.DefinitionContainers, file_name)
with SaveFile(path, "wt") as f:
f.write(data)
def _installPackage(self, installation_package_data: dict):
package_info = installation_package_data["package_info"]
filename = installation_package_data["filename"]
package_id = package_info["package_id"]
if not os.path.exists(filename):
Logger.log(
"w",
"Package [%s] file '%s' is missing, cannot install this package",
package_id, filename)
return
Logger.log("i", "Installing package [%s] from file [%s]", package_id,
filename)
# If it's installed, remove it first and then install
if package_id in self._installed_package_dict:
self._purgePackage(package_id)
# Install the package
with zipfile.ZipFile(filename, "r") as archive:
temp_dir = tempfile.TemporaryDirectory()
archive.extractall(temp_dir.name)
from cura.CuraApplication import CuraApplication
installation_dirs_dict = {
"materials":
Resources.getStoragePath(
CuraApplication.ResourceTypes.MaterialInstanceContainer),
"qualities":
Resources.getStoragePath(
CuraApplication.ResourceTypes.QualityInstanceContainer),
"plugins":
os.path.abspath(Resources.getStoragePath(Resources.Plugins)),
}
for sub_dir_name, installation_root_dir in installation_dirs_dict.items(
):
src_dir_path = os.path.join(temp_dir.name, "files",
sub_dir_name)
dst_dir_path = os.path.join(installation_root_dir, package_id)
if not os.path.exists(src_dir_path):
continue
# Need to rename the container files so they don't get ID conflicts
to_rename_files = sub_dir_name not in ("plugins", )
self.__installPackageFiles(
package_id,
src_dir_path,
dst_dir_path,
need_to_rename_files=to_rename_files)
# Remove the file
os.remove(filename)
def saveMachineInstances(self):
if self._active_machine:
Preferences.getInstance().setValue("machines/active_instance", self._active_machine.getName())
for instance in self._machine_instances:
file_name = urllib.parse.quote_plus(instance.getName()) + ".cfg"
instance.saveToFile(Resources.getStoragePath(Resources.MachineInstances, file_name))
file_name = urllib.parse.quote_plus(instance.getName()) + ".curaprofile"
instance.getWorkingProfile().saveToFile(Resources.getStoragePath(Resources.MachineInstanceProfiles, file_name))
def saveAll(self) -> None:
for instance in self.findInstanceContainers():
if not instance.isDirty():
continue
try:
data = instance.serialize()
except NotImplementedError:
# Serializing is not supported so skip this container
continue
except Exception:
Logger.logException("e", "An exception occurred trying to serialize container %s", instance.getId())
continue
mime_type = self.getMimeTypeForContainer(type(instance))
if mime_type is not None:
file_name = urllib.parse.quote_plus(instance.getId()) + "." + mime_type.preferredSuffix
path = Resources.getStoragePath(Resources.InstanceContainers, file_name)
with SaveFile(path, "wt") as f:
f.write(data)
for stack in self.findContainerStacks():
if not stack.isDirty():
continue
try:
data = stack.serialize()
except NotImplementedError:
# Serializing is not supported so skip this container
continue
except Exception:
Logger.logException("e", "An exception occurred trying to serialize container %s", stack.getId())
continue
mime_type = self.getMimeTypeForContainer(type(stack))
if mime_type is not None:
file_name = urllib.parse.quote_plus(stack.getId()) + "." + mime_type.preferredSuffix
path = Resources.getStoragePath(Resources.ContainerStacks, file_name)
with SaveFile(path, "wt") as f:
f.write(data)
for definition in self.findDefinitionContainers():
try:
data = definition.serialize()
except NotImplementedError:
# Serializing is not supported so skip this container
continue
except Exception:
Logger.logException("e", "An exception occurred trying to serialize container %s", definition.getId())
continue
mime_type = self.getMimeTypeForContainer(type(definition))
if mime_type is not None:
file_name = urllib.parse.quote_plus(definition.getId()) + "." + mime_type.preferredSuffix
path = Resources.getStoragePath(Resources.DefinitionContainers, file_name)
with SaveFile(path, "wt") as f:
f.write(data)
def _onExit(self):
for instance in ContainerRegistry.getInstance().findInstanceContainers(
):
if not instance.isDirty():
continue
try:
data = instance.serialize()
except NotImplementedError:
continue
except Exception:
Logger.logException(
"e", "An exception occurred when serializing container %s",
instance.getId())
continue
file_name = urllib.parse.quote_plus(instance.getId()) + ".inst.cfg"
instance_type = instance.getMetaDataEntry("type")
path = None
if instance_type == "material":
path = Resources.getStoragePath(
self.ResourceTypes.MaterialInstanceContainer, file_name)
elif instance_type == "quality":
path = Resources.getStoragePath(
self.ResourceTypes.QualityInstanceContainer, file_name)
elif instance_type == "user":
path = Resources.getStoragePath(
self.ResourceTypes.UserInstanceContainer, file_name)
elif instance_type == "variant":
path = Resources.getStoragePath(
self.ResourceTypes.VariantInstanceContainer, file_name)
if path:
with SaveFile(path, "wt", -1, "utf-8") as f:
f.write(data)
for stack in ContainerRegistry.getInstance().findContainerStacks():
if not stack.isDirty():
continue
try:
data = stack.serialize()
except NotImplementedError:
continue
except Exception:
Logger.logException(
"e", "An exception occurred when serializing container %s",
instance.getId())
continue
file_name = urllib.parse.quote_plus(stack.getId()) + ".stack.cfg"
path = Resources.getStoragePath(self.ResourceTypes.MachineStack,
file_name)
with SaveFile(path, "wt", -1, "utf-8") as f:
f.write(data)
def saveSettings(self):
if not self._started: # Do not do saving during application start
return
self.waitConfigLockFile()
# When starting Cura, we check for the lockFile which is created and deleted here
with lockFile(self._config_lock_filename):
for instance in ContainerRegistry.getInstance(
).findInstanceContainers():
if not instance.isDirty():
continue
try:
data = instance.serialize()
except NotImplementedError:
continue
except Exception:
Logger.logException(
"e",
"An exception occurred when serializing container %s",
instance.getId())
continue
mime_type = ContainerRegistry.getMimeTypeForContainer(
type(instance))
file_name = urllib.parse.quote_plus(
instance.getId()) + "." + mime_type.preferredSuffix
instance_type = instance.getMetaDataEntry("type")
path = None
if instance_type == "material":
path = Resources.getStoragePath(
self.ResourceTypes.MaterialInstanceContainer,
file_name)
elif instance_type == "quality" or instance_type == "quality_changes":
path = Resources.getStoragePath(
self.ResourceTypes.QualityInstanceContainer, file_name)
elif instance_type == "user":
path = Resources.getStoragePath(
self.ResourceTypes.UserInstanceContainer, file_name)
elif instance_type == "variant":
path = Resources.getStoragePath(
self.ResourceTypes.VariantInstanceContainer, file_name)
elif instance_type == "definition_changes":
path = Resources.getStoragePath(
self.ResourceTypes.MachineStack, file_name)
if path:
instance.setPath(path)
with SaveFile(path, "wt") as f:
f.write(data)
for stack in ContainerRegistry.getInstance().findContainerStacks():
self.saveStack(stack)
def saveAll(self):
for instance in self.findInstanceContainers():
if not instance.isDirty():
continue
try:
data = instance.serialize()
except NotImplementedError:
# Serializing is not supported so skip this container
continue
except Exception:
Logger.logException("e", "An exception occurred trying to serialize container %s", instance.getId())
continue
file_name = urllib.parse.quote_plus(instance.getId()) + ".inst.cfg"
path = Resources.getStoragePath(Resources.InstanceContainers, file_name)
with SaveFile(path, "wt", -1, "utf-8") as f:
f.write(data)
for stack in self.findContainerStacks():
if not stack.isDirty():
continue
try:
data = stack.serialize()
except NotImplementedError:
# Serializing is not supported so skip this container
continue
except Exception:
Logger.logException("e", "An exception occurred trying to serialize container %s", stack.getId())
continue
file_name = urllib.parse.quote_plus(stack.getId()) + ".stack.cfg"
path = Resources.getStoragePath(Resources.ContainerStacks, file_name)
with SaveFile(path, "wt", -1, "utf-8") as f:
f.write(data)
for definition in self.findDefinitionContainers():
try:
data = definition.serialize()
except NotImplementedError:
# Serializing is not supported so skip this container
continue
except Exception:
Logger.logException("e", "An exception occurred trying to serialize container %s", instance.getId())
continue
file_name = urllib.parse.quote_plus(definition.getId()) + ".def.cfg"
path = Resources.getStoragePath(Resources.DefinitionContainers, file_name)
with SaveFile(path, "wt", -1, "utf-8") as f:
f.write(data)
def _installPackage(self, installation_package_data: dict):
package_info = installation_package_data["package_info"]
filename = installation_package_data["filename"]
package_id = package_info["package_id"]
Logger.log("i", "Installing package [%s] from file [%s]", package_id, filename)
# Load the cached package file and extract all contents to a temporary directory
if not os.path.exists(filename):
Logger.log("w", "Package [%s] file '%s' is missing, cannot install this package", package_id, filename)
return
try:
with zipfile.ZipFile(filename, "r") as archive:
temp_dir = tempfile.TemporaryDirectory()
archive.extractall(temp_dir.name)
except Exception:
Logger.logException("e", "Failed to install package from file [%s]", filename)
return
from cura.CuraApplication import CuraApplication
installation_dirs_dict = {
"materials": Resources.getStoragePath(CuraApplication.ResourceTypes.MaterialInstanceContainer),
"qualities": Resources.getStoragePath(CuraApplication.ResourceTypes.QualityInstanceContainer),
"plugins": os.path.abspath(Resources.getStoragePath(Resources.Plugins)),
}
# Remove it first and then install
try:
self._purgePackage(package_id)
except:
Logger.log("e", "There was an error deleting the package {package} during updating.".format(package = package_id))
return
# Copy the folders there
for sub_dir_name, installation_root_dir in installation_dirs_dict.items():
src_dir_path = os.path.join(temp_dir.name, "files", sub_dir_name)
dst_dir_path = os.path.join(installation_root_dir, package_id)
if not os.path.exists(src_dir_path):
continue
self.__installPackageFiles(package_id, src_dir_path, dst_dir_path)
# Remove the file
try:
os.remove(filename)
except Exception:
Logger.log("w", "Tried to delete file [%s], but it failed", filename)
# Move the info to the installed list of packages only when it succeeds
self._installed_package_dict[package_id] = self._to_install_package_dict[package_id]
def saveMachineInstances(self):
if self._active_machine:
Preferences.getInstance().setValue("machines/active_instance",
self._active_machine.getName())
for instance in self._machine_instances:
file_name = urllib.parse.quote_plus(instance.getName()) + ".cfg"
instance.saveToFile(
Resources.getStoragePath(Resources.MachineInstances,
file_name))
file_name = urllib.parse.quote_plus(
instance.getName()) + ".curaprofile"
instance.getWorkingProfile().saveToFile(
Resources.getStoragePath(Resources.MachineInstanceProfiles,
file_name))
def saveSettings(self):
if not self._started: # Do not do saving during application start
return
for instance in ContainerRegistry.getInstance().findInstanceContainers():
if not instance.isDirty():
continue
try:
data = instance.serialize()
except NotImplementedError:
continue
except Exception:
Logger.logException("e", "An exception occurred when serializing container %s", instance.getId())
continue
file_name = urllib.parse.quote_plus(instance.getId()) + ".inst.cfg"
instance_type = instance.getMetaDataEntry("type")
path = None
if instance_type == "material":
path = Resources.getStoragePath(self.ResourceTypes.MaterialInstanceContainer, file_name)
elif instance_type == "quality":
path = Resources.getStoragePath(self.ResourceTypes.QualityInstanceContainer, file_name)
elif instance_type == "user":
path = Resources.getStoragePath(self.ResourceTypes.UserInstanceContainer, file_name)
elif instance_type == "variant":
path = Resources.getStoragePath(self.ResourceTypes.VariantInstanceContainer, file_name)
if path:
with SaveFile(path, "wt", -1, "utf-8") as f:
f.write(data)
for stack in ContainerRegistry.getInstance().findContainerStacks():
if not stack.isDirty():
continue
try:
data = stack.serialize()
except NotImplementedError:
continue
except Exception:
Logger.logException("e", "An exception occurred when serializing container %s", instance.getId())
continue
file_name = urllib.parse.quote_plus(stack.getId()) + ".stack.cfg"
path = Resources.getStoragePath(self.ResourceTypes.MachineStack, file_name)
with SaveFile(path, "wt", -1, "utf-8") as f:
f.write(data)
def test_loadLegacyFileRenamed(container_registry):
#Create a temporary file for the registry to load.
stacks_folder = os.path.join(os.path.dirname(os.path.abspath(__file__)), "stacks")
temp_file = os.path.join(stacks_folder, "temporary.stack.cfg")
temp_file_source = os.path.join(stacks_folder, "MachineLegacy.stack.cfg")
shutil.copyfile(temp_file_source, temp_file)
#Mock some dependencies.
UM.Settings.ContainerStack.setContainerRegistry(container_registry)
Resources.getAllResourcesOfType = unittest.mock.MagicMock(return_value = [temp_file]) #Return a temporary file that we'll make for this test.
def findContainers(container_type = 0, id = None):
if id == "MachineLegacy":
return None
container = UM.Settings.ContainerRegistry._EmptyInstanceContainer(id)
container.getNextStack = unittest.mock.MagicMock()
return [container]
old_find_containers = container_registry.findContainers
container_registry.findContainers = findContainers
with unittest.mock.patch("cura.Settings.GlobalStack.GlobalStack.findContainer"):
container_registry.load()
container_registry.findContainers = old_find_containers
container_registry.saveAll()
print("all containers in registry", container_registry._containers)
assert not os.path.isfile(temp_file)
mime_type = container_registry.getMimeTypeForContainer(GlobalStack)
file_name = urllib.parse.quote_plus("MachineLegacy") + "." + mime_type.preferredSuffix
path = Resources.getStoragePath(Resources.ContainerStacks, file_name)
assert os.path.isfile(path)
def _installPlugin(self, plugin_id: str, plugin_path: str) -> None:
Logger.log("i", "Attempting to install a new plugin %s from file '%s'",
plugin_id, plugin_path)
local_plugin_path = os.path.join(
Resources.getStoragePath(Resources.Resources), "plugins")
if plugin_id in self._bundled_plugin_cache:
del self._bundled_plugin_cache[plugin_id]
try:
with zipfile.ZipFile(plugin_path, "r") as zip_ref:
plugin_folder = os.path.join(local_plugin_path, plugin_id)
# Overwrite the existing plugin if already installed
if os.path.isdir(plugin_folder):
shutil.rmtree(plugin_folder, ignore_errors=True)
os.makedirs(plugin_folder, exist_ok=True)
# Extract all files
for info in zip_ref.infolist():
extracted_path = zip_ref.extract(info.filename,
path=plugin_folder)
permissions = os.stat(extracted_path).st_mode
os.chmod(extracted_path, permissions
| stat.S_IEXEC) # Make these files executable.
except: # Installing a new plugin should never crash the application.
Logger.logException(
"e",
"An exception occurred while installing plugin {path}".format(
path=plugin_path))
if plugin_id in self._disabled_plugins:
self._disabled_plugins.remove(plugin_id)
def uninstallPlugin(self, plugin_id: str):
Logger.log("d", "Uninstall plugin got ID: %s", plugin_id)
plugin_folder = os.path.join(
Resources.getStoragePath(Resources.Resources), "plugins")
plugin_path = os.path.join(plugin_folder, plugin_id)
Logger.log("i", "Attempting to uninstall %s", plugin_path)
result = {"status": "error", "message": "", "id": plugin_id}
success_message = i18n_catalog.i18nc(
"@info:status",
"The plugin has been removed.\nPlease re-start the application to finish uninstall."
)
try:
shutil.rmtree(plugin_path)
except:
Logger.logException("d",
"An exception occurred while uninstalling %s",
plugin_path)
result["message"] = i18n_catalog.i18nc(
"@info:status", "Failed to uninstall plugin")
return result
result["status"] = "ok"
result["message"] = success_message
return result
def __init__(self, application, parent=None):
super().__init__(parent)
self._application = application
self._container_registry = self._application.getContainerRegistry()
self._plugin_registry = self._application.getPluginRegistry()
#JSON files that keep track of all installed packages.
self._user_package_management_file_path = None #type: str
self._bundled_package_management_file_path = None #type: str
for search_path in Resources.getSearchPaths():
candidate_bundled_path = os.path.join(search_path,
"bundled_packages.json")
if os.path.exists(candidate_bundled_path):
self._bundled_package_management_file_path = candidate_bundled_path
for search_path in (Resources.getDataStoragePath(),
Resources.getConfigStoragePath()):
candidate_user_path = os.path.join(search_path, "packages.json")
if os.path.exists(candidate_user_path):
self._user_package_management_file_path = candidate_user_path
if self._user_package_management_file_path is None: #Doesn't exist yet.
self._user_package_management_file_path = os.path.join(
Resources.getDataStoragePath(), "packages.json")
self._installation_dirs_dict = {
"plugins":
os.path.abspath(Resources.getStoragePath(Resources.Plugins))
} # type: Dict[str, str]
self._bundled_package_dict = {} # A dict of all bundled packages
self._installed_package_dict = {} # A dict of all installed packages
self._to_remove_package_set = set(
) # A set of packages that need to be removed at the next start
self._to_install_package_dict = {
} # A dict of packages that need to be installed at the next start
def adjust_theme(self):
"""
Makes the tooltips wider, if displaying articles in the tooltips.
"""
# Previous versions of the Settings Guide may create a theme, which may become outdated in newer versions.
# We need to remove it and widen the tooltips in a different way.
application = CuraApplication.getInstance()
preferences = application.getPreferences()
preferences.addPreference(
"general/theme",
application.default_theme) # May not exist yet at this point.
current_theme = preferences.getValue("general/theme")
if current_theme and current_theme.endswith("_settingsguideadjust"):
preferences.setValue("general/theme",
current_theme[:-len("_settingsguideadjust")])
# Look for Settings Guide adjusted themes in the resources folder.
theme_path = os.path.dirname(
Resources.getStoragePath(Resources.Themes, ""))
try:
for theme_folder in os.listdir(theme_path):
if theme_folder.endswith("_settingsguideadjust"):
shutil.rmtree(os.path.join(theme_path, theme_folder))
except EnvironmentError as e:
# Perhaps no rights? Well, just leave the extra theme in then. Nothing to be done about it.
Logger.error(
"Unable to remove Settings Guide deprecated theme: {err}".
format(err=str(e)))
def saveContainer(self, container: "ContainerInterface") -> None:
try:
data = container.serialize()
except NotImplementedError:
return
except Exception:
Logger.logException("e", "An exception occurred when serializing container %s", container.getId())
return
mime_type = ContainerRegistry.getMimeTypeForContainer(type(container))
file_name = urllib.parse.quote_plus(container.getId()) + "." + mime_type.preferredSuffix
container_type = container.getMetaDataEntry("type")
resource_types = ContainerRegistry.getInstance().getResourceTypes()
if container_type in resource_types:
path = Resources.getStoragePath(resource_types[container_type], file_name)
with SaveFile(path, "wt") as f:
f.write(data)
container.setPath(path)
# Register it internally as being saved
self._id_to_path[container.getId()] = path
self._id_to_mime[container.getId()] = self._pathToMime(path)
base_file = container.getMetaData().get("base_file")
if base_file:
for container_md in ContainerRegistry.getInstance().findContainersMetadata(base_file = base_file):
self._id_to_path[container_md["id"]] = path
self._id_to_mime[container_md["id"]] = self._pathToMime(path)
else:
Logger.log("w", "Dirty container [%s] is not saved because the resource type is unknown in ContainerRegistry", container_type)
def _installPlugin(self, plugin_id: str, plugin_path: str) -> None:
Logger.log("i", "Attempting to install a new plugin %s from file '%s'", plugin_id, plugin_path)
local_plugin_path = os.path.join(Resources.getStoragePath(Resources.Resources), "plugins")
if plugin_id in self._bundled_plugin_cache:
del self._bundled_plugin_cache[plugin_id]
try:
with zipfile.ZipFile(plugin_path, "r") as zip_ref:
plugin_folder = os.path.join(local_plugin_path, plugin_id)
# Overwrite the existing plugin if already installed
if os.path.isdir(plugin_folder):
shutil.rmtree(plugin_folder, ignore_errors = True)
os.makedirs(plugin_folder, exist_ok = True)
# Extract all files
for info in zip_ref.infolist():
extracted_path = zip_ref.extract(info.filename, path = plugin_folder)
permissions = os.stat(extracted_path).st_mode
os.chmod(extracted_path, permissions | stat.S_IEXEC) # Make these files executable.
except: # Installing a new plugin should never crash the application.
Logger.logException("e", "An exception occurred while installing plugin {path}".format(path = plugin_path))
if plugin_id in self._disabled_plugins:
self._disabled_plugins.remove(plugin_id)
def __init__(self, image_reader):
super(CDTUI, self).__init__()
self.image_reader = image_reader
self._ui_view = None
self.show_config_ui_trigger.connect(self._actualShowConfigUI)
self._aspect = 1
self.closeTopButtonFace = True
self.reversePathToration = False
self.splitWord = False
self.image_color_invert = False
self._ui_lock = threading.Lock()
self._cancelled = False
self._disable_size_callbacks = False
pkFile = os.path.join(
os.path.join(Resources.getStoragePath(Resources.Resources),
'plugins'), 'CDTUI.pk')
self._pkDat = []
if os.path.exists(pkFile):
try:
self._pkDat = pickle.load(open(pkFile, 'rb'))
if isinstance(self._pkDat, list) and len(self._pkDat) == 6:
self.peak_height = self._pkDat[0]
self._offset = self._pkDat[1]
self._slopeHeight = self._pkDat[2]
self.closeTopButtonFace = self._pkDat[3]
self.reversePathToration = self._pkDat[4]
self.splitWord = self._pkDat[5]
except:
None
def _createView(self):
Logger.log("d", "Creating post processing plugin view.")
## Load all scripts in the scripts folders
for root in [
PluginRegistry.getInstance().getPluginPath(
"PostProcessingPlugin"),
Resources.getStoragePath(Resources.Preferences)
]:
path = os.path.join(root, "scripts")
if not os.path.isdir(path):
try:
os.makedirs(path)
except OSError:
Logger.log(
"w", "Unable to create a folder for scripts: " + path)
continue
self.loadAllScripts(path)
# Create the plugin dialog component
path = os.path.join(
PluginRegistry.getInstance().getPluginPath("PostProcessingPlugin"),
"PostProcessingPlugin.qml")
self._view = Application.getInstance().createQmlComponent(
path, {"manager": self})
Logger.log("d", "Post processing view created.")
# Create the save button component
Application.getInstance().addAdditionalComponent(
"saveButton",
self._view.findChild(QObject, "postProcessingSaveAreaButton"))
def loadAllScripts(self) -> None:
"""Load all scripts from all paths where scripts can be found.
This should probably only be done on init.
"""
if self._loaded_scripts: # Already loaded.
return
# The PostProcessingPlugin path is for built-in scripts.
# The Resources path is where the user should store custom scripts.
# The Preferences path is legacy, where the user may previously have stored scripts.
resource_folders = [
PluginRegistry.getInstance().getPluginPath("PostProcessingPlugin"),
Resources.getStoragePath(Resources.Preferences)
]
resource_folders.extend(
Resources.getAllPathsForType(Resources.Resources))
for root in resource_folders:
if root is None:
continue
path = os.path.join(root, "scripts")
if not os.path.isdir(path):
try:
os.makedirs(path)
except OSError:
Logger.log(
"w", "Unable to create a folder for scripts: " + path)
continue
self.loadScripts(path)
def windowClosed(self):
Logger.log("d", "Shutting down %s", self.getApplicationName())
try:
self.getMachineManager().saveAll()
except Exception as e:
Logger.log("e", "Exception while saving machines: %s", repr(e))
try:
Preferences.getInstance().writeToFile(
Resources.getStoragePath(Resources.Preferences,
self.getApplicationName() + ".cfg"))
except Exception as e:
Logger.log("e", "Exception while saving preferences: %s", repr(e))
try:
self.applicationShuttingDown.emit()
except Exception as e:
Logger.log("e", "Exception while emitting shutdown signal: %s",
repr(e))
try:
self.getBackend().close()
except Exception as e:
Logger.log("e", "Exception while closing backend: %s", repr(e))
self.quit()
def test_loadLegacyFileRenamed(container_registry):
#Create a temporary file for the registry to load.
stacks_folder = os.path.join(os.path.dirname(os.path.abspath(__file__)), "stacks")
temp_file = os.path.join(stacks_folder, "temporary.stack.cfg")
temp_file_source = os.path.join(stacks_folder, "MachineLegacy.stack.cfg")
shutil.copyfile(temp_file_source, temp_file)
#Mock some dependencies.
UM.Settings.ContainerStack.setContainerRegistry(container_registry)
Resources.getAllResourcesOfType = unittest.mock.MagicMock(return_value = [temp_file]) #Return a temporary file that we'll make for this test.
def findContainers(container_type = 0, id = None):
if id == "MachineLegacy":
return None
container = UM.Settings.ContainerRegistry._EmptyInstanceContainer(id)
container.getNextStack = unittest.mock.MagicMock()
return [container]
old_find_containers = container_registry.findContainers
container_registry.findContainers = findContainers
with unittest.mock.patch("cura.Settings.GlobalStack.GlobalStack.findContainer"):
container_registry.load()
container_registry.findContainers = old_find_containers
container_registry.saveAll()
print("all containers in registry", container_registry._containers)
assert not os.path.isfile(temp_file)
mime_type = container_registry.getMimeTypeForContainer(GlobalStack)
file_name = urllib.parse.quote_plus("MachineLegacy") + "." + mime_type.preferredSuffix
path = Resources.getStoragePath(Resources.ContainerStacks, file_name)
assert os.path.isfile(path)
def windowClosed(self, save_data: bool = True) -> None:
Logger.log("d", "Shutting down %s", self.getApplicationName())
self._shutting_down = True
if save_data:
try:
Preferences.getInstance().writeToFile(
Resources.getStoragePath(
Resources.Preferences,
self.getApplicationName() + ".cfg"))
except Exception as e:
Logger.log("e", "Exception while saving preferences: %s",
repr(e))
try:
self.applicationShuttingDown.emit()
except Exception as e:
Logger.log("e", "Exception while emitting shutdown signal: %s",
repr(e))
try:
self.getBackend().close()
except Exception as e:
Logger.log("e", "Exception while closing backend: %s", repr(e))
self.quit()
def _saveCachedDefinition(self, definition: DefinitionContainer) -> None:
cache_path = Resources.getStoragePath(
Resources.Cache, "definitions",
Application.getInstance().getVersion(), definition.id)
# Ensure the cache path exists.
try:
os.makedirs(os.path.dirname(cache_path), exist_ok=True)
except PermissionError:
Logger.log(
"w",
"The definition cache for definition {definition_id} failed to save because you don't have permissions to write in the cache directory."
.format(definition_id=definition.getId()))
return # No rights to save it. Better give up.
try:
with open(cache_path, "wb") as f:
pickle.dump(definition, f, pickle.HIGHEST_PROTOCOL)
except RecursionError:
# Sometimes a recursion error in pickling occurs here.
# The cause is unknown. It must be some circular reference in the definition instances or definition containers.
# Instead of saving a partial cache and raising an exception, simply fail to save the cache.
# See CURA-4024.
Logger.log(
"w",
"The definition cache for definition {definition_id} failed to pickle."
.format(definition_id=definition.getId()))
if os.path.exists(cache_path):
os.remove(
cache_path
) # The pickling might be half-complete, which causes EOFError in Pickle when you load it later.
def __init__(self,
application: "QtApplication",
parent: Optional[QObject] = None) -> None:
super().__init__(parent)
self._application = application
self._container_registry = self._application.getContainerRegistry()
self._plugin_registry = self._application.getPluginRegistry()
# JSON files that keep track of all installed packages.
self._user_package_management_file_path = None # type: Optional[str]
self._bundled_package_management_file_paths = [] # type: List[str]
for search_path in Resources.getAllPathsForType(
Resources.BundledPackages):
if not os.path.isdir(search_path):
continue
# Load all JSON files that are located in the bundled_packages directory.
for file_name in os.listdir(search_path):
if not file_name.endswith(".json"):
continue
file_path = os.path.join(search_path, file_name)
if not os.path.isfile(file_path):
continue
self._bundled_package_management_file_paths.append(file_path)
Logger.log(
"i", "Found bundled packages JSON file: {location}".format(
location=file_path))
for search_path in (Resources.getDataStoragePath(),
Resources.getConfigStoragePath()):
candidate_user_path = os.path.join(search_path, "packages.json")
if os.path.exists(candidate_user_path):
self._user_package_management_file_path = candidate_user_path
if self._user_package_management_file_path is None: # Doesn't exist yet.
self._user_package_management_file_path = os.path.join(
Resources.getDataStoragePath(), "packages.json")
self._installation_dirs_dict = {
"plugins":
os.path.abspath(Resources.getStoragePath(Resources.Plugins))
} # type: Dict[str, str]
self._bundled_package_dict = {
} # type: Dict[str, Dict[str, Any]] # A dict of all bundled packages
self._installed_package_dict = {
} # type: Dict[str, Dict[str, Any]] # A dict of all installed packages
self._to_remove_package_set = set(
) # type: Set[str] # A set of packages that need to be removed at the next start
self._to_install_package_dict = {
} # type: Dict[str, Dict[str, Any]] # A dict of packages that need to be installed at the next start
self._dismissed_packages = set(
) # type: Set[str] # A set of packages that are dismissed by the user
# There can be plugins that provide remote packages (and thus, newer / different versions for a package).
self._available_package_versions = {
} # type: Dict[str, Set[UMVersion]]
self._packages_with_update_available = set() # type: Set[str]
def _saveCachedDefinition(self, definition):
cache_path = Resources.getStoragePath(Resources.Cache, "definitions", self.getApplication().getVersion(), definition.id)
# Ensure the cache path exists
os.makedirs(os.path.dirname(cache_path), exist_ok=True)
with open(cache_path, "wb") as f:
pickle.dump(definition, f)
def windowClosed(self):
self.getMachineManager().saveAll()
Preferences.getInstance().writeToFile(
Resources.getStoragePath(Resources.Preferences,
self.getApplicationName() + ".cfg"))
self.applicationShuttingDown.emit()
self.getBackend().close()
self.quit()
def _saveCachedDefinition(self, definition):
cache_path = Resources.getStoragePath(Resources.Cache, "definitions", self.getApplication().getVersion(), definition.id)
# Ensure the cache path exists
os.makedirs(os.path.dirname(cache_path), exist_ok=True)
with open(cache_path, "wb") as f:
pickle.dump(definition, f)
def _removePlugin(self, plugin_id: str) -> None:
plugin_folder = os.path.join(
Resources.getStoragePath(Resources.Resources), "plugins")
plugin_path = os.path.join(plugin_folder, plugin_id)
Logger.log("i", "Attempting to remove plugin '%s' from directory '%s'",
plugin_id, plugin_path)
shutil.rmtree(plugin_path)
def getLockFilename(self) -> str:
"""Get the lock filename including full path
Dependent on when you call this function, Resources.getConfigStoragePath may return different paths
"""
return Resources.getStoragePath(
Resources.Resources,
self._application.getApplicationLockFilename())
def installPlugin(self, plugin_path: str):
Logger.log("d", "Install plugin got path: %s", plugin_path)
plugin_path = QUrl(plugin_path).toLocalFile()
Logger.log("i", "Attempting to install a new plugin %s", plugin_path)
local_plugin_path = os.path.join(Resources.getStoragePath(Resources.Resources), "plugins")
plugin_folder = ""
result = {"status": "error", "message": "", "id": ""}
success_message = i18n_catalog.i18nc("@info:status", "The plugin has been installed.\nPlease re-start the application to activate the plugin.")
try:
with zipfile.ZipFile(plugin_path, "r") as zip_ref:
plugin_id = None
for file in zip_ref.infolist():
if file.filename.endswith("/"):
plugin_id = file.filename.strip("/")
break
if plugin_id is None:
result["message"] = i18n_catalog.i18nc("@info:status", "Failed to install plugin from <filename>{0}</filename>:\n<message>{1}</message>", plugin_path, "Invalid plugin file")
return result
result["id"] = plugin_id
plugin_folder = os.path.join(local_plugin_path, plugin_id)
if os.path.isdir(plugin_folder): # Plugin is already installed by user (so not a bundled plugin)
metadata = {}
with zip_ref.open(plugin_id + "/plugin.json") as metadata_file:
metadata = json.loads(metadata_file.read().decode("utf-8"))
if "version" in metadata:
new_version = Version(metadata["version"])
old_version = Version(self.getMetaData(plugin_id)["plugin"]["version"])
if new_version > old_version:
zip_ref.extractall(plugin_folder)
result["status"] = "ok"
result["message"] = success_message
return result
Logger.log("w", "The plugin was already installed. Unable to install it again!")
result["status"] = "duplicate"
result["message"] = i18n_catalog.i18nc("@info:status", "Failed to install the plugin;\n<message>{0}</message>", "Plugin was already installed")
return result
elif plugin_id in self._plugins:
# Plugin is already installed, but not by the user (eg; this is a bundled plugin)
# TODO: Right now we don't support upgrading bundled plugins at all, but we might do so in the future.
result["message"] = i18n_catalog.i18nc("@info:status", "Failed to install the plugin;\n<message>{0}</message>", "Unable to upgrade or install bundled plugins.")
return result
zip_ref.extractall(plugin_folder)
except: # Installing a new plugin should never crash the application.
Logger.logException("d", "An exception occurred while installing plugin {path}".format(path = plugin_path))
result["message"] = i18n_catalog.i18nc("@info:status", "Failed to install plugin from <filename>{0}</filename>:\n<message>{1}</message>", plugin_folder, "Invalid plugin file")
return result
result["status"] = "ok"
result["message"] = success_message
return result
def installPlugin(self, plugin_path: str):
plugin_path = QUrl(plugin_path).toLocalFile()
Logger.log("d", "Attempting to install a new plugin %s", plugin_path)
local_plugin_path = os.path.join(Resources.getStoragePath(Resources.Resources), "plugins")
plugin_folder = ""
result = {"status": "error", "message": "", "id": ""}
success_message = i18n_catalog.i18nc("@info:status", "The plugin has been installed.\n Please re-start the application to activate the plugin.")
try:
with zipfile.ZipFile(plugin_path, "r") as zip_ref:
plugin_id = None
for file in zip_ref.infolist():
if file.filename.endswith("/"):
plugin_id = file.filename.strip("/")
break
if plugin_id is None:
result["message"] = i18n_catalog.i18nc("@info:status", "Failed to install plugin from <filename>{0}</filename>:\n<message>{1}</message>", plugin_path, "Invalid plugin file")
return result
result["id"] = plugin_id
plugin_folder = os.path.join(local_plugin_path, plugin_id)
if os.path.isdir(plugin_folder): # Plugin is already installed by user (so not a bundled plugin)
metadata = {}
with zip_ref.open(plugin_id + "/plugin.json") as metadata_file:
metadata = json.loads(metadata_file.read().decode("utf-8"))
if "version" in metadata:
new_version = Version(metadata["version"])
old_version = Version(self.getMetaData(plugin_id)["plugin"]["version"])
if new_version > old_version:
zip_ref.extractall(plugin_folder)
result["status"] = "ok"
result["message"] = success_message
return result
Logger.log("w", "The plugin was already installed. Unable to install it again!")
result["status"] = "duplicate"
result["message"] = i18n_catalog.i18nc("@info:status", "Failed to install the plugin; \n<message>{0}</message>", "Plugin was already installed")
return result
elif plugin_id in self._plugins:
# Plugin is already installed, but not by the user (eg; this is a bundled plugin)
# TODO: Right now we don't support upgrading bundled plugins at all, but we might do so in the future.
result["message"] = i18n_catalog.i18nc("@info:status", "Failed to install the plugin; \n<message>{0}</message>", "Unable to upgrade or instal bundled plugins.")
return result
zip_ref.extractall(plugin_folder)
except: # Installing a new plugin should never crash the application.
Logger.logException("d", "An exception occurred while installing plugin ")
result["message"] = i18n_catalog.i18nc("@info:status", "Failed to install plugin from <filename>{0}</filename>:\n<message>{1}</message>", plugin_folder, "Invalid plugin file")
return result
result["status"] = "ok"
result["message"] = success_message
return result
def _onProfileNameChanged(self, profile, old_name):
file_name = urllib.parse.quote_plus(old_name) + ".cfg"
try:
path = Resources.getStoragePath(Resources.Profiles, file_name)
os.remove(path)
except FileNotFoundError:
pass
self.profileNameChanged.emit(profile)
def _onInstanceNameChanged(self, instance, old_name):
file_name = urllib.parse.quote_plus(old_name) + ".cfg"
try:
path = Resources.getStoragePath(Resources.MachineInstances, file_name)
os.remove(path)
except FileNotFoundError:
pass
self.machineInstanceNameChanged.emit(instance)
def _removePlugin(self, plugin_id: str) -> None:
plugin_folder = os.path.join(Resources.getStoragePath(Resources.Resources), "plugins")
plugin_path = os.path.join(plugin_folder, plugin_id)
if plugin_id in self._bundled_plugin_cache:
del self.bundled_plugin_cache[plugin_id]
Logger.log("i", "Attempting to remove plugin '%s' from directory '%s'", plugin_id, plugin_path)
shutil.rmtree(plugin_path)
def __init__(self, file_name):
super().__init__()
self._logger = logging.getLogger(self._name) # Create python logger
self._logger.setLevel(logging.DEBUG)
# Do not try to save to the app dir as it may not be writeable or may not be the right
# location to save the log file. Instead, try and save in the settings location since
# that should be writeable.
self.setFileName(Resources.getStoragePath(Resources.Resources, file_name))
def _onTimeout(self):
self._saving = True # To prevent the save process from triggering another autosave.
Logger.log("d", "Autosaving preferences, instances and profiles")
Application.getInstance().saveSettings()
Preferences.getInstance().writeToFile(Resources.getStoragePath(Resources.Preferences, Application.getInstance().getApplicationName() + ".cfg"))
self._saving = False
def saveProfiles(self):
try:
for profile in self._profiles:
if profile.isReadOnly() or not profile.hasChangedSettings():
continue
file_name = urllib.parse.quote_plus(profile.getName()) + ".cfg"
profile.saveToFile(Resources.getStoragePath(Resources.Profiles, file_name))
except AttributeError:
pass
def removeMachine(self, machine):
self._machines.remove(machine)
try:
path = Resources.getStoragePath(Resources.SettingsLocation, urllib.parse.quote_plus(machine.getName()) + ".cfg")
os.remove(path)
except FileNotFoundError:
pass
self.machinesChanged.emit()
def _installPackage(self, installation_package_data: dict):
package_info = installation_package_data["package_info"]
filename = installation_package_data["filename"]
package_id = package_info["package_id"]
if not os.path.exists(filename):
Logger.log("w", "Package [%s] file '%s' is missing, cannot install this package", package_id, filename)
return
Logger.log("i", "Installing package [%s] from file [%s]", package_id, filename)
# If it's installed, remove it first and then install
if package_id in self._installed_package_dict:
self._purgePackage(package_id)
# Install the package
with zipfile.ZipFile(filename, "r") as archive:
temp_dir = tempfile.TemporaryDirectory()
archive.extractall(temp_dir.name)
from cura.CuraApplication import CuraApplication
installation_dirs_dict = {
"materials": Resources.getStoragePath(CuraApplication.ResourceTypes.MaterialInstanceContainer),
"quality": Resources.getStoragePath(CuraApplication.ResourceTypes.QualityInstanceContainer),
"plugins": os.path.abspath(Resources.getStoragePath(Resources.Plugins)),
}
for sub_dir_name, installation_root_dir in installation_dirs_dict.items():
src_dir_path = os.path.join(temp_dir.name, "files", sub_dir_name)
dst_dir_path = os.path.join(installation_root_dir, package_id)
if not os.path.exists(src_dir_path):
continue
# Need to rename the container files so they don't get ID conflicts
to_rename_files = sub_dir_name not in ("plugins",)
self.__installPackageFiles(package_id, src_dir_path, dst_dir_path, need_to_rename_files= to_rename_files)
# Remove the file
os.remove(filename)
def __init__(self, file_name: str) -> None:
super().__init__()
self._logger = logging.getLogger(self._name) # Create python logger
self._logger.setLevel(logging.DEBUG)
self._show_once = set() # type: Set[str]
# Do not try to save to the app dir as it may not be writeable or may not be the right
# location to save the log file. Instead, try and save in the settings location since
# that should be writeable.
self.setFileName(Resources.getStoragePath(Resources.Resources, file_name))
VersionUpgradeManager.getInstance().registerIgnoredFile(file_name)
def __init__(self, file_name):
super().__init__()
self._logger = logging.getLogger(self._name) #Create python logger
self._logger.setLevel(logging.DEBUG)
if hasattr(sys, "frozen"):
# Running in py2exe or py2app context, do not try to save to the app dir as it may not be writeable.
# instead, try and save in the settings location since that should be writeable.
self.setFileName(Resources.getStoragePath(Resources.Resources, file_name))
else:
self.setFileName(file_name)
def saveProfiles(self):
try:
Preferences.getInstance().setValue("machines/active_profile", self._active_profile.getName())
for profile in self._profiles:
if profile.isReadOnly():
continue
file_name = urllib.parse.quote_plus(profile.getName()) + ".cfg"
profile.saveToFile(Resources.getStoragePath(Resources.Profiles, file_name))
except AttributeError:
pass
def saveSettings(self):
if not self._started: # Do not do saving during application start
return
self.waitConfigLockFile()
# When starting Cura, we check for the lockFile which is created and deleted here
with lockFile(self._config_lock_filename):
for instance in ContainerRegistry.getInstance().findInstanceContainers():
if not instance.isDirty():
continue
try:
data = instance.serialize()
except NotImplementedError:
continue
except Exception:
Logger.logException("e", "An exception occurred when serializing container %s", instance.getId())
continue
mime_type = ContainerRegistry.getMimeTypeForContainer(type(instance))
file_name = urllib.parse.quote_plus(instance.getId()) + "." + mime_type.preferredSuffix
instance_type = instance.getMetaDataEntry("type")
path = None
if instance_type == "material":
path = Resources.getStoragePath(self.ResourceTypes.MaterialInstanceContainer, file_name)
elif instance_type == "quality" or instance_type == "quality_changes":
path = Resources.getStoragePath(self.ResourceTypes.QualityInstanceContainer, file_name)
elif instance_type == "user":
path = Resources.getStoragePath(self.ResourceTypes.UserInstanceContainer, file_name)
elif instance_type == "variant":
path = Resources.getStoragePath(self.ResourceTypes.VariantInstanceContainer, file_name)
if path:
instance.setPath(path)
with SaveFile(path, "wt") as f:
f.write(data)
for stack in ContainerRegistry.getInstance().findContainerStacks():
self.saveStack(stack)
def loadProfiles(self):
storage_path = Resources.getStoragePathForType(Resources.Profiles)
dirs = Resources.getAllPathsForType(Resources.Profiles)
for dir in dirs:
if not os.path.isdir(dir):
continue
read_only = dir != storage_path
for root, dirs, files in os.walk(dir):
for file_name in files:
path = os.path.join(root, file_name)
if os.path.isdir(path):
continue
profile = Profile(self, read_only)
try:
profile.loadFromFile(path)
except Exception as e:
Logger.log("e", "An exception occurred loading Profile %s: %s", path, str(e))
continue
if not self.findProfile(profile.getName(), variant_name = profile.getMachineVariantName(), material_name = profile.getMaterialName(), instance = self._active_machine):
self._profiles.append(profile)
profile.nameChanged.connect(self._onProfileNameChanged)
for instance in self._machine_instances:
try:
file_name = urllib.parse.quote_plus(instance.getName()) + ".curaprofile"
instance.getWorkingProfile().loadFromFile(Resources.getStoragePath(Resources.MachineInstanceProfiles, file_name))
except Exception as e:
Logger.log("w", "Could not load working profile: %s: %s", file_name, str(e))
self._setDefaultVariantMaterialProfile(instance)
self._protect_working_profile = True
if self._active_machine:
profile_name = self._active_machine.getActiveProfileName()
if profile_name == "":
profile_name = "Normal Quality"
profile = self.findProfile(self._active_machine.getActiveProfileName(), instance = self._active_machine)
if profile:
self.setActiveProfile(profile)
else:
profiles = self.getProfiles(instance = self._active_machine)
if len(profiles) > 0:
self.setActiveProfile(profiles[0])
self.profilesChanged.emit()
self._protect_working_profile = False
def saveSettings(self):
if not self._started: # Do not do saving during application start
return
for instance in ContainerRegistry.getInstance().findInstanceContainers():
if not instance.isDirty():
continue
try:
data = instance.serialize()
except NotImplementedError:
continue
except Exception:
Logger.logException("e", "An exception occurred when serializing container %s", instance.getId())
continue
mime_type = ContainerRegistry.getMimeTypeForContainer(type(instance))
file_name = urllib.parse.quote_plus(instance.getId()) + "." + mime_type.preferredSuffix
instance_type = instance.getMetaDataEntry("type")
path = None
if instance_type == "material":
path = Resources.getStoragePath(self.ResourceTypes.MaterialInstanceContainer, file_name)
elif instance_type == "quality" or instance_type == "quality_changes":
path = Resources.getStoragePath(self.ResourceTypes.QualityInstanceContainer, file_name)
elif instance_type == "user":
path = Resources.getStoragePath(self.ResourceTypes.UserInstanceContainer, file_name)
elif instance_type == "variant":
path = Resources.getStoragePath(self.ResourceTypes.VariantInstanceContainer, file_name)
if path:
instance.setPath(path)
with SaveFile(path, "wt", -1, "utf-8") as f:
f.write(data)
for stack in ContainerRegistry.getInstance().findContainerStacks():
if not stack.isDirty():
continue
try:
data = stack.serialize()
except NotImplementedError:
continue
except Exception:
Logger.logException("e", "An exception occurred when serializing container %s", instance.getId())
continue
mime_type = ContainerRegistry.getMimeTypeForContainer(type(stack))
file_name = urllib.parse.quote_plus(stack.getId()) + "." + mime_type.preferredSuffix
stack_type = stack.getMetaDataEntry("type", None)
path = None
if not stack_type or stack_type == "machine":
path = Resources.getStoragePath(self.ResourceTypes.MachineStack, file_name)
elif stack_type == "extruder_train":
path = Resources.getStoragePath(self.ResourceTypes.ExtruderStack, file_name)
if path:
stack.setPath(path)
with SaveFile(path, "wt", -1, "utf-8") as f:
f.write(data)
def removeMachineInstance(self, instance):
if instance not in self._machine_instances:
return
self._machine_instances.remove(instance)
instance.nameChanged.disconnect(self._onInstanceNameChanged)
file_name = urllib.parse.quote_plus(instance.getName())
try:
path = Resources.getStoragePath(Resources.MachineInstances, file_name + ".cfg")
os.remove(path)
path = Resources.getStoragePath(Resources.MachineInstanceProfiles, file_name + ".cfg")
os.remove(path)
except FileNotFoundError:
pass
self.machineInstancesChanged.emit()
if self._active_machine == instance:
try:
self.setActiveMachineInstance(self._machine_instances[0])
except:
self.setActiveMachineInstance(None)
def saveStack(self, stack):
if not stack.isDirty():
return
try:
data = stack.serialize()
except NotImplementedError:
return
except Exception:
Logger.logException("e", "An exception occurred when serializing container %s", stack.getId())
return
mime_type = ContainerRegistry.getMimeTypeForContainer(type(stack))
file_name = urllib.parse.quote_plus(stack.getId()) + "." + mime_type.preferredSuffix
stack_type = stack.getMetaDataEntry("type", None)
path = None
if not stack_type or stack_type == "machine":
path = Resources.getStoragePath(self.ResourceTypes.MachineStack, file_name)
elif stack_type == "extruder_train":
path = Resources.getStoragePath(self.ResourceTypes.ExtruderStack, file_name)
if path:
stack.setPath(path)
with SaveFile(path, "wt") as f:
f.write(data)
def _onTimeout(self):
Logger.log("d", "Autosaving preferences, instances and profiles")
if self._save_preferences:
Preferences.getInstance().writeToFile(Resources.getStoragePath(Resources.Preferences, Application.getInstance().getApplicationName() + ".cfg"))
if self._save_instances:
Application.getInstance().getMachineManager().saveMachineInstances()
if self._save_profiles:
Application.getInstance().getMachineManager().saveProfiles()
self._save_preferences = False
self._save_instances = False
self._save_profiles = False
def removeProfile(self, profile):
if profile not in self._profiles:
return
self._profiles.remove(profile)
profile.nameChanged.disconnect(self._onProfileNameChanged)
try:
path = Resources.getStoragePath(Resources.Profiles, urllib.parse.quote_plus(profile.getName()) + ".cfg")
os.remove(path)
except FileNotFoundError:
pass
self.profilesChanged.emit()
if profile == self._active_profile:
self.setActiveProfile(self._profiles[0])
def _saveCachedDefinition(self, definition: DefinitionContainer):
cache_path = Resources.getStoragePath(Resources.Cache, "definitions", self._application.getVersion(), definition.id)
# Ensure the cache path exists
os.makedirs(os.path.dirname(cache_path), exist_ok=True)
try:
with open(cache_path, "wb") as f:
pickle.dump(definition, f, pickle.HIGHEST_PROTOCOL)
except RecursionError:
#Sometimes a recursion error in pickling occurs here.
#The cause is unknown. It must be some circular reference in the definition instances or definition containers.
#Instead of saving a partial cache and raising an exception, simply fail to save the cache.
#See CURA-4024.
Logger.log("w", "The definition cache for definition {definition_id} failed to pickle.".format(definition_id = definition.getId()))
if os.path.exists(cache_path):
os.remove(cache_path) #The pickling might be half-complete, which causes EOFError in Pickle when you load it later.
def _deleteFiles(self, container):
for resource_type in self._resource_types:
mime_type_name = ""
for name, container_type in self.__mime_type_map.items():
if container_type == container.__class__:
mime_type_name = name
break
else:
return
mime_type = MimeTypeDatabase.getMimeType(mime_type_name)
for suffix in mime_type.suffixes:
try:
path = Resources.getStoragePath(resource_type, urllib.parse.quote_plus(container.getId()) + "." + suffix)
if os.path.isfile(path):
os.remove(path)
except Exception:
continue
def __init__(self, application: "QtApplication", parent: Optional[QObject] = None) -> None:
super().__init__(parent)
self._application = application
self._container_registry = self._application.getContainerRegistry()
self._plugin_registry = self._application.getPluginRegistry()
# JSON files that keep track of all installed packages.
self._user_package_management_file_path = None # type: Optional[str]
self._bundled_package_management_file_paths = [] # type: List[str]
for search_path in Resources.getAllPathsForType(Resources.BundledPackages):
if not os.path.isdir(search_path):
continue
# Load all JSON files that are located in the bundled_packages directory.
for file_name in os.listdir(search_path):
if not file_name.endswith(".json"):
continue
file_path = os.path.join(search_path, file_name)
if not os.path.isfile(file_path):
continue
self._bundled_package_management_file_paths.append(file_path)
Logger.log("i", "Found bundled packages JSON file: {location}".format(location = file_path))
for search_path in (Resources.getDataStoragePath(), Resources.getConfigStoragePath()):
candidate_user_path = os.path.join(search_path, "packages.json")
if os.path.exists(candidate_user_path):
self._user_package_management_file_path = candidate_user_path
if self._user_package_management_file_path is None: # Doesn't exist yet.
self._user_package_management_file_path = os.path.join(Resources.getDataStoragePath(), "packages.json")
self._installation_dirs_dict = {"plugins": os.path.abspath(Resources.getStoragePath(Resources.Plugins))} # type: Dict[str, str]
self._bundled_package_dict = {} # type: Dict[str, Dict[str, Any]] # A dict of all bundled packages
self._installed_package_dict = {} # type: Dict[str, Dict[str, Any]] # A dict of all installed packages
self._to_remove_package_set = set() # type: Set[str] # A set of packages that need to be removed at the next start
self._to_install_package_dict = {} # type: Dict[str, Dict[str, Any]] # A dict of packages that need to be installed at the next start
# There can be plugins that provide remote packages (and thus, newer / different versions for a package).
self._available_package_versions = {} # type: Dict[str, Set[UMVersion]]
self._packages_with_update_available = set() # type: Set[str]
