def fixSingleExtrusionMachineExtruderDefinition(self, global_stack: "GlobalStack") -> None:
container_registry = ContainerRegistry.getInstance()
expected_extruder_definition_0_id = global_stack.getMetaDataEntry("machine_extruder_trains")["0"]
extruder_stack_0 = global_stack.extruders.get("0")
# At this point, extruder stacks for this machine may not have been loaded yet. In this case, need to look in
# the container registry as well.
if not global_stack.extruders:
extruder_trains = container_registry.findContainerStacks(type = "extruder_train",
machine = global_stack.getId())
if extruder_trains:
for extruder in extruder_trains:
if extruder.getMetaDataEntry("position") == "0":
extruder_stack_0 = extruder
break
if extruder_stack_0 is None:
Logger.log("i", "No extruder stack for global stack [%s], create one", global_stack.getId())
# Single extrusion machine without an ExtruderStack, create it
from cura.Settings.CuraStackBuilder import CuraStackBuilder
CuraStackBuilder.createExtruderStackWithDefaultSetup(global_stack, 0)
elif extruder_stack_0.definition.getId() != expected_extruder_definition_0_id:
Logger.log("e", "Single extruder printer [{printer}] expected extruder [{expected}], but got [{got}]. I'm making it [{expected}].".format(
printer = global_stack.getId(), expected = expected_extruder_definition_0_id, got = extruder_stack_0.definition.getId()))
extruder_definition = container_registry.findDefinitionContainers(id = expected_extruder_definition_0_id)[0]
extruder_stack_0.definition = extruder_definition
def _fixSingleExtrusionMachineExtruderDefinition(self, global_stack: "GlobalStack") -> None:
container_registry = ContainerRegistry.getInstance()
expected_extruder_definition_0_id = global_stack.getMetaDataEntry("machine_extruder_trains")["0"]
extruder_stack_0 = global_stack.extruders.get("0")
# At this point, extruder stacks for this machine may not have been loaded yet. In this case, need to look in
# the container registry as well.
if not global_stack.extruders:
extruder_trains = container_registry.findContainerStacks(type = "extruder_train",
machine = global_stack.getId())
if extruder_trains:
for extruder in extruder_trains:
if extruder.getMetaDataEntry("position") == "0":
extruder_stack_0 = extruder
break
if extruder_stack_0 is None:
Logger.log("i", "No extruder stack for global stack [%s], create one", global_stack.getId())
# Single extrusion machine without an ExtruderStack, create it
from cura.Settings.CuraStackBuilder import CuraStackBuilder
CuraStackBuilder.createExtruderStackWithDefaultSetup(global_stack, 0)
elif extruder_stack_0.definition.getId() != expected_extruder_definition_0_id:
Logger.log("e", "Single extruder printer [{printer}] expected extruder [{expected}], but got [{got}]. I'm making it [{expected}].".format(
printer = global_stack.getId(), expected = expected_extruder_definition_0_id, got = extruder_stack_0.definition.getId()))
extruder_definition = container_registry.findDefinitionContainers(id = expected_extruder_definition_0_id)[0]
extruder_stack_0.definition = extruder_definition
def deserialize(self,
serialized: str,
file_name: Optional[str] = None) -> str:
# update the serialized data first
serialized = super().deserialize(serialized, file_name)
new_containers = self._containers.copy()
while len(new_containers) < len(_ContainerIndexes.IndexTypeMap):
new_containers.append(self._empty_instance_container)
# Validate and ensure the list of containers matches with what we expect
for index, type_name in _ContainerIndexes.IndexTypeMap.items():
container = None
try:
container = new_containers[index]
except IndexError:
pass
if type_name == "definition":
if not container or not isinstance(container,
DefinitionContainer):
definition = self.findContainer(
container_type=DefinitionContainer)
if not definition:
raise InvalidContainerStackError(
"Stack {id} does not have a definition!".format(
id=self.getId()))
new_containers[index] = definition
continue
if not container or container.getMetaDataEntry(
"type") != type_name:
actual_container = self.findContainer(type=type_name)
if actual_container:
new_containers[index] = actual_container
else:
new_containers[index] = self._empty_instance_container
self._containers = new_containers
# CURA-5281
# Some stacks can have empty definition_changes containers which will cause problems.
# Make sure that all stacks here have non-empty definition_changes containers.
if isinstance(new_containers[_ContainerIndexes.DefinitionChanges],
type(self._empty_instance_container)):
from cura.Settings.CuraStackBuilder import CuraStackBuilder
CuraStackBuilder.createDefinitionChangesContainer(
self,
self.getId() + "_settings")
## TODO; Deserialize the containers.
return serialized
def _reset(self):
global_stack = self._application.getMachineManager().activeMachine
if not global_stack:
return
# Make sure there is a definition_changes container to store the machine settings
definition_changes_id = global_stack.definitionChanges.getId()
if isEmptyContainer(definition_changes_id):
CuraStackBuilder.createDefinitionChangesContainer(global_stack,
global_stack.getName() + "_settings")
# Disable auto-slicing while the MachineAction is showing
if self._backend: # This sometimes triggers before backend is loaded.
self._backend.disableTimer()
def _create_machine(self, device_id: str) -> None:
"""Creates a machine. Called when user adds a discovered machine.
Args:
device_id: device identifier.
"""
Logger.log('d', 'Creating machine with device id %s.', device_id)
device = cast(MPSM2NetworkedPrinterOutputDevice,
self._discovered_devices.get(device_id))
if device is None:
return
machine_manager = CuraApplication.getInstance().getMachineManager()
machine = machine_manager.getMachine(
'monoprice_select_mini_v2', {_METADATA_MPSM2_KEY: device_id})
if machine is None:
new_machine = CuraStackBuilder.createMachine(
device.name, device.printerType)
if not new_machine:
Logger.log('e', 'Failed to create a new machine.')
return
new_machine.setMetaDataEntry('group_name', device.name)
new_machine.setMetaDataEntry(_METADATA_MPSM2_KEY, device.key)
CuraApplication.getInstance().getMachineManager().setActiveMachine(
new_machine.getId())
_connect_to_output_device(device, new_machine)
self._create_heartbeat_thread(device.ipAddress)
def test_createMachine(application, container_registry, definition_container, global_variant, material_instance_container, quality_container, quality_changes_container):
variant_manager = MagicMock(name = "Variant Manager")
quality_manager = MagicMock(name = "Quality Manager")
global_variant_node = MagicMock( name = "global variant node")
global_variant_node.getContainer = MagicMock(return_value = global_variant)
variant_manager.getDefaultVariantNode = MagicMock(return_value = global_variant_node)
quality_group = QualityGroup(name = "zomg", quality_type = "normal")
quality_group.node_for_global = MagicMock(name = "Node for global")
quality_group.node_for_global.getContainer = MagicMock(return_value = quality_container)
quality_manager.getQualityGroups = MagicMock(return_value = {"normal": quality_group})
application.getContainerRegistry = MagicMock(return_value=container_registry)
application.getVariantManager = MagicMock(return_value = variant_manager)
application.getQualityManager = MagicMock(return_value = quality_manager)
application.empty_material_container = material_instance_container
application.empty_quality_container = quality_container
application.empty_quality_changes_container = quality_changes_container
metadata = definition_container.getMetaData()
metadata["machine_extruder_trains"] = {}
metadata["preferred_quality_type"] = "normal"
container_registry.addContainer(definition_container)
with patch("cura.CuraApplication.CuraApplication.getInstance", MagicMock(return_value=application)):
machine = CuraStackBuilder.createMachine("Whatever", "Test Definition")
assert machine.quality == quality_container
assert machine.definition == definition_container
assert machine.variant == global_variant
def dumpAllMachinesDefaultSettings(self, output_dir: str) -> None:
yaml.add_representer(OrderedDict, represent_ordereddict)
# Make sure the output directory exists
os.makedirs(output_dir, mode=0o775, exist_ok=True)
container_registry = self._application.getContainerRegistry()
machine_manager = self._application.getMachineManager()
machine_definition_metadata_list = container_registry.findDefinitionContainersMetadata(
type="machine")
machine_definition_metadata_list = sorted(
machine_definition_metadata_list, key=lambda x: x["id"])
for machine_def_metadata in machine_definition_metadata_list:
machine_def_id = machine_def_metadata["id"]
machine_name = "{}_1".format(machine_def_metadata["name"])
file_name = os.path.join(output_dir,
"{}.yaml".format(machine_def_id))
Logger.log("i", "Creating machine [%s] ...", machine_def_id)
global_stack = CuraStackBuilder.createMachine(
machine_name, machine_def_id)
# Some resolve functions depends on the active machine, so this machine needs to be activated first.
machine_manager.setActiveMachine(global_stack.getId())
self.dumpGlobalStack(global_stack, file_name)
Logger.log("i", "All machines processed, Exiting Cura ...")
sys.exit(0)
def _fixSingleExtrusionMachineExtruderDefinition(self, global_stack: "GlobalStack") -> None:
expected_extruder_definition_0_id = global_stack.getMetaDataEntry("machine_extruder_trains")["0"]
extruder_stack_0 = global_stack.extruders.get("0")
if extruder_stack_0 is None:
Logger.log("i", "No extruder stack for global stack [%s], create one", global_stack.getId())
# Single extrusion machine without an ExtruderStack, create it
from cura.Settings.CuraStackBuilder import CuraStackBuilder
CuraStackBuilder.createExtruderStackWithDefaultSetup(global_stack, 0)
elif extruder_stack_0.definition.getId() != expected_extruder_definition_0_id:
Logger.log("e", "Single extruder printer [{printer}] expected extruder [{expected}], but got [{got}]. I'm making it [{expected}].".format(
printer = global_stack.getId(), expected = expected_extruder_definition_0_id, got = extruder_stack_0.definition.getId()))
container_registry = ContainerRegistry.getInstance()
extruder_definition = container_registry.findDefinitionContainers(id = expected_extruder_definition_0_id)[0]
extruder_stack_0.definition = extruder_definition
def fixSingleExtrusionMachineExtruderDefinition(
self, global_stack: "GlobalStack") -> None:
container_registry = ContainerRegistry.getInstance()
expected_extruder_definition_0_id = global_stack.getMetaDataEntry(
"machine_extruder_trains")["0"]
try:
extruder_stack_0 = global_stack.extruderList[0]
except IndexError:
extruder_stack_0 = None
# At this point, extruder stacks for this machine may not have been loaded yet. In this case, need to look in
# the container registry as well.
if not global_stack.extruderList:
extruder_trains = container_registry.findContainerStacks(
type="extruder_train", machine=global_stack.getId())
if extruder_trains:
for extruder in extruder_trains:
if extruder.getMetaDataEntry("position") == "0":
extruder_stack_0 = extruder
break
if extruder_stack_0 is None:
Logger.log("i",
"No extruder stack for global stack [%s], create one",
global_stack.getId())
# Single extrusion machine without an ExtruderStack, create it
from cura.Settings.CuraStackBuilder import CuraStackBuilder
CuraStackBuilder.createExtruderStackWithDefaultSetup(
global_stack, 0)
elif extruder_stack_0.definition.getId(
) != expected_extruder_definition_0_id:
Logger.log(
"e",
"Single extruder printer [{printer}] expected extruder [{expected}], but got [{got}]. I'm making it [{expected}]."
.format(printer=global_stack.getId(),
expected=expected_extruder_definition_0_id,
got=extruder_stack_0.definition.getId()))
try:
extruder_definition = container_registry.findDefinitionContainers(
id=expected_extruder_definition_0_id)[0]
except IndexError:
# It still needs to break, but we want to know what extruder ID made it break.
msg = "Unable to find extruder definition with the id [%s]" % expected_extruder_definition_0_id
Logger.logException("e", msg)
raise IndexError(msg)
extruder_stack_0.definition = extruder_definition
def test_createExtruderStack(application, definition_container, global_variant, material_instance_container, quality_container, quality_changes_container):
application.empty_material_container = material_instance_container
application.empty_quality_container = quality_container
application.empty_quality_changes_container = quality_changes_container
with patch("cura.CuraApplication.CuraApplication.getInstance", MagicMock(return_value=application)):
extruder_stack = CuraStackBuilder.createExtruderStack("Whatever", definition_container, "meh", 0, global_variant, material_instance_container, quality_container)
assert extruder_stack.variant == global_variant
assert extruder_stack.material == material_instance_container
assert extruder_stack.quality == quality_container
def setHeatedChamber(self, heated_bed = True):
global_container_stack = Application.getInstance().getGlobalContainerStack()
if global_container_stack:
# Make sure there is a definition_changes container to store the machine settings
definition_changes_container = global_container_stack.definitionChanges
if definition_changes_container == ContainerRegistry.getInstance().getEmptyInstanceContainer():
definition_changes_container = CuraStackBuilder.createDefinitionChangesContainer(
global_container_stack, global_container_stack.getId() + "_settings")
definition_changes_container.setProperty("machine_heated_chamber", "value", heated_bed)
self.heatedChamberChanged.emit()
def _onActiveExtruderStackChanged(self):
extruder_container_stack = ExtruderManager.getInstance().getActiveExtruderStack()
if not self._global_container_stack or not extruder_container_stack:
return
# Make sure there is a definition_changes container to store the machine settings
definition_changes_container = extruder_container_stack.definitionChanges
if definition_changes_container == self._empty_container:
definition_changes_container = CuraStackBuilder.createDefinitionChangesContainer(
extruder_container_stack, extruder_container_stack.getId() + "_settings")
def _onActiveExtruderStackChanged(self):
extruder_container_stack = ExtruderManager.getInstance().getActiveExtruderStack()
if not self._global_container_stack or not extruder_container_stack:
return
# Make sure there is a definition_changes container to store the machine settings
definition_changes_container = extruder_container_stack.definitionChanges
if definition_changes_container == self._empty_container:
definition_changes_container = CuraStackBuilder.createDefinitionChangesContainer(
extruder_container_stack, extruder_container_stack.getId() + "_settings")
def deserialize(self, serialized: str, file_name: Optional[str] = None) -> str:
# update the serialized data first
serialized = super().deserialize(serialized, file_name)
new_containers = self._containers.copy()
while len(new_containers) < len(_ContainerIndexes.IndexTypeMap):
new_containers.append(self._empty_instance_container)
# Validate and ensure the list of containers matches with what we expect
for index, type_name in _ContainerIndexes.IndexTypeMap.items():
container = None
try:
container = new_containers[index]
except IndexError:
pass
if type_name == "definition":
if not container or not isinstance(container, DefinitionContainer):
definition = self.findContainer(container_type = DefinitionContainer)
if not definition:
raise InvalidContainerStackError("Stack {id} does not have a definition!".format(id = self.getId()))
new_containers[index] = definition
continue
if not container or container.getMetaDataEntry("type") != type_name:
actual_container = self.findContainer(type = type_name)
if actual_container:
new_containers[index] = actual_container
else:
new_containers[index] = self._empty_instance_container
self._containers = new_containers
# CURA-5281
# Some stacks can have empty definition_changes containers which will cause problems.
# Make sure that all stacks here have non-empty definition_changes containers.
if isinstance(new_containers[_ContainerIndexes.DefinitionChanges], type(self._empty_instance_container)):
from cura.Settings.CuraStackBuilder import CuraStackBuilder
CuraStackBuilder.createDefinitionChangesContainer(self, self.getId() + "_settings")
## TODO; Deserialize the containers.
return serialized
def test_createMachineWithUnknownDefinition(application, container_registry):
application.getContainerRegistry = MagicMock(
return_value=container_registry)
with patch("cura.CuraApplication.CuraApplication.getInstance",
MagicMock(return_value=application)):
with patch(
"UM.ConfigurationErrorMessage.ConfigurationErrorMessage.getInstance"
) as mocked_config_error:
assert CuraStackBuilder.createMachine("Whatever", "NOPE") is None
assert mocked_config_error.addFaultyContainers.called_with("NOPE")
def applyGcodeFlavorFix(self, apply_fix: bool) -> None:
global_container_stack = self._application.getGlobalContainerStack()
if not global_container_stack:
return
gcode_flavor = "RepRap (Marlin/Sprinter)" if apply_fix else "UltiGCode"
if global_container_stack.getProperty("machine_gcode_flavor", "value") == gcode_flavor:
# No need to add a definition_changes container if the setting is not going to be changed
return
# Make sure there is a definition_changes container to store the machine settings
definition_changes_container = global_container_stack.definitionChanges
if definition_changes_container == ContainerRegistry.getInstance().getEmptyInstanceContainer():
definition_changes_container = CuraStackBuilder.createDefinitionChangesContainer(
global_container_stack, global_container_stack.getId() + "_settings")
definition_changes_container.setProperty("machine_gcode_flavor", "value", gcode_flavor)
# Update the has_materials metadata flag after switching gcode flavor
definition = global_container_stack.getBottom()
if (
not definition or
definition.getProperty("machine_gcode_flavor", "value") != "UltiGCode" or
definition.getMetaDataEntry("has_materials", False)
):
# In other words: only continue for the UM2 (extended), but not for the UM2+
return
has_materials = global_container_stack.getProperty("machine_gcode_flavor", "value") != "UltiGCode"
material_container = global_container_stack.material
if has_materials:
global_container_stack.setMetaDataEntry("has_materials", True)
# Set the material container to a sane default
if material_container == ContainerRegistry.getInstance().getEmptyInstanceContainer():
search_criteria = {
"type": "material",
"definition": "fdmprinter",
"id": global_container_stack.getMetaDataEntry("preferred_material")
}
materials = ContainerRegistry.getInstance().findInstanceContainers(**search_criteria)
if materials:
global_container_stack.material = materials[0]
else:
# The metadata entry is stored in an ini, and ini files are parsed as strings only.
# Because any non-empty string evaluates to a boolean True, we have to remove the entry to make it False.
if "has_materials" in global_container_stack.getMetaData():
global_container_stack.removeMetaDataEntry("has_materials")
global_container_stack.material = ContainerRegistry.getInstance().getEmptyInstanceContainer()
self._application.globalContainerStackChanged.emit()
def setHeatedBed(self, heated_bed = True):
global_container_stack = Application.getInstance().getGlobalContainerStack()
if global_container_stack:
# Make sure there is a definition_changes container to store the machine settings
definition_changes_container = global_container_stack.definitionChanges
if definition_changes_container == ContainerRegistry.getInstance().getEmptyInstanceContainer():
definition_changes_container = CuraStackBuilder.createDefinitionChangesContainer(
global_container_stack, global_container_stack.getId() + "_settings")
definition_changes_container.setProperty("machine_heated_bed", "value", heated_bed)
self.heatedBedChanged.emit()
def _reset(self):
if not self._global_container_stack:
return
# Make sure there is a definition_changes container to store the machine settings
definition_changes_id = self._global_container_stack.definitionChanges.getId()
if self._isEmptyDefinitionChanges(definition_changes_id):
CuraStackBuilder.createDefinitionChangesContainer(self._global_container_stack,
self._global_container_stack.getName() + "_settings")
# Notify the UI in which container to store the machine settings data
from cura.Settings.CuraContainerStack import _ContainerIndexes
container_index = _ContainerIndexes.DefinitionChanges
if container_index != self._container_index:
self._container_index = container_index
self.containerIndexChanged.emit()
# Disable auto-slicing while the MachineAction is showing
if self._backend: # This sometimes triggers before backend is loaded.
self._backend.disableTimer()
def _createMachineFromDiscoveredDevice(self, key: str) -> None:
device = self._remote_clusters[key]
if not device:
return
# Create a new machine and activate it.
# We do not use use MachineManager.addMachine here because we need to set the cluster ID before activating it.
new_machine = CuraStackBuilder.createMachine(device.name, device.printerType)
if not new_machine:
Logger.log("e", "Failed creating a new machine")
return
new_machine.setMetaDataEntry(self.META_CLUSTER_ID, device.key)
CuraApplication.getInstance().getMachineManager().setActiveMachine(new_machine.getId())
self._connectToOutputDevice(device, new_machine)
def test_createExtruderStack(application, definition_container, global_variant,
material_instance_container, quality_container,
quality_changes_container):
application.empty_material_container = material_instance_container
application.empty_quality_container = quality_container
application.empty_quality_changes_container = quality_changes_container
with patch("cura.CuraApplication.CuraApplication.getInstance",
MagicMock(return_value=application)):
extruder_stack = CuraStackBuilder.createExtruderStack(
"Whatever", definition_container, "meh", 0, global_variant,
material_instance_container, quality_container)
assert extruder_stack.variant == global_variant
assert extruder_stack.material == material_instance_container
assert extruder_stack.quality == quality_container
def _createMachineFromDiscoveredDevice(self, key: str, activate: bool = True) -> None:
device = self._remote_clusters[key]
if not device:
return
# Create a new machine.
# We do not use use MachineManager.addMachine here because we need to set the cluster ID before activating it.
new_machine = CuraStackBuilder.createMachine(device.name, device.printerType)
if not new_machine:
Logger.log("e", "Failed creating a new machine")
return
self._setOutputDeviceMetadata(device, new_machine)
if activate:
CuraApplication.getInstance().getMachineManager().setActiveMachine(new_machine.getId())
def test_createMachine(application, container_registry, definition_container,
global_variant, material_instance_container,
quality_container, intent_container,
quality_changes_container):
variant_manager = MagicMock(name="Variant Manager")
quality_manager = MagicMock(name="Quality Manager")
global_variant_node = MagicMock(name="global variant node")
global_variant_node.container = global_variant
variant_manager.getDefaultVariantNode = MagicMock(
return_value=global_variant_node)
quality_group = QualityGroup(name="zomg", quality_type="normal")
quality_group.node_for_global = MagicMock(name="Node for global")
quality_group.node_for_global.container = quality_container
quality_manager.getQualityGroups = MagicMock(
return_value={"normal": quality_group})
application.getContainerRegistry = MagicMock(
return_value=container_registry)
application.empty_material_container = material_instance_container
application.empty_quality_container = quality_container
application.empty_intent_container = intent_container
application.empty_quality_changes_container = quality_changes_container
application.empty_variant_container = global_variant
metadata = definition_container.getMetaData()
metadata["machine_extruder_trains"] = {}
metadata["preferred_quality_type"] = "normal"
container_registry.addContainer(definition_container)
quality_node = MagicMock()
machine_node = MagicMock()
machine_node.preferredGlobalQuality = MagicMock(return_value=quality_node)
quality_node.container = quality_container
# Patch out the creation of MachineNodes since that isn't under test (and would require quite a bit of extra setup)
with patch("cura.Machines.ContainerTree.MachineNode",
MagicMock(return_value=machine_node)):
with patch("cura.CuraApplication.CuraApplication.getInstance",
MagicMock(return_value=application)):
machine = CuraStackBuilder.createMachine("Whatever",
"Test Definition")
assert machine.quality == quality_container
assert machine.definition == definition_container
assert machine.variant == global_variant
def applyGcodeFlavorFix(self, apply_fix: bool) -> None:
global_container_stack = self._application.getGlobalContainerStack()
if not global_container_stack:
return
gcode_flavor = "RepRap (Marlin/Sprinter)" if apply_fix else "UltiGCode"
if global_container_stack.getProperty("machine_gcode_flavor", "value") == gcode_flavor:
# No need to add a definition_changes container if the setting is not going to be changed
return
# Make sure there is a definition_changes container to store the machine settings
definition_changes_container = global_container_stack.definitionChanges
if definition_changes_container == ContainerRegistry.getInstance().getEmptyInstanceContainer():
definition_changes_container = CuraStackBuilder.createDefinitionChangesContainer(
global_container_stack, global_container_stack.getId() + "_settings")
definition_changes_container.setProperty("machine_gcode_flavor", "value", gcode_flavor)
# Update the has_materials metadata flag after switching gcode flavor
definition = global_container_stack.getBottom()
if not definition or definition.getProperty("machine_gcode_flavor", "value") != "UltiGCode" or definition.getMetaDataEntry("has_materials", False):
# In other words: only continue for the UM2 (extended), but not for the UM2+
return
has_materials = global_container_stack.getProperty("machine_gcode_flavor", "value") != "UltiGCode"
material_container = global_container_stack.material
if has_materials:
global_container_stack.setMetaDataEntry("has_materials", True)
# Set the material container to a sane default
if material_container == ContainerRegistry.getInstance().getEmptyInstanceContainer():
search_criteria = { "type": "material", "definition": "fdmprinter", "id": global_container_stack.getMetaDataEntry("preferred_material")}
materials = ContainerRegistry.getInstance().findInstanceContainers(**search_criteria)
if materials:
global_container_stack.material = materials[0]
else:
# The metadata entry is stored in an ini, and ini files are parsed as strings only.
# Because any non-empty string evaluates to a boolean True, we have to remove the entry to make it False.
if "has_materials" in global_container_stack.getMetaData():
global_container_stack.removeMetaDataEntry("has_materials")
global_container_stack.material = ContainerRegistry.getInstance().getEmptyInstanceContainer()
self._application.globalContainerStackChanged.emit()
def _createMachineFromDiscoveredDevice(self, device_id: str) -> None:
device = self._discovered_devices.get(device_id)
if device is None:
return
# Create a new machine and activate it.
# We do not use use MachineManager.addMachine here because we need to set the network key before activating it.
# If we do not do this the auto-pairing with the cloud-equivalent device will not work.
new_machine = CuraStackBuilder.createMachine(device.name,
device.printerType)
if not new_machine:
Logger.log("e", "Failed creating a new machine")
return
new_machine.setMetaDataEntry(self.META_NETWORK_KEY, device.key)
CuraApplication.getInstance().getMachineManager().setActiveMachine(
new_machine.getId())
self._connectToOutputDevice(device, new_machine)
self._showCloudFlowMessage(device)
def _reset(self):
if not self._global_container_stack:
return
# Make sure there is a definition_changes container to store the machine settings
definition_changes_container = self._global_container_stack.definitionChanges
if definition_changes_container == self._empty_container:
definition_changes_container = CuraStackBuilder.createDefinitionChangesContainer(
self._global_container_stack, self._global_container_stack.getName() + "_settings")
# Notify the UI in which container to store the machine settings data
container_index = self._global_container_stack.getContainerIndex(definition_changes_container)
if container_index != self._container_index:
self._container_index = container_index
self.containerIndexChanged.emit()
# Disable auto-slicing while the MachineAction is showing
if self._backend: # This sometimes triggers before backend is loaded.
self._backend.disableTimer()
def _reset(self):
if not self._global_container_stack:
return
# Make sure there is a definition_changes container to store the machine settings
definition_changes_container = self._global_container_stack.definitionChanges
if definition_changes_container == self._empty_container:
definition_changes_container = CuraStackBuilder.createDefinitionChangesContainer(
self._global_container_stack, self._global_container_stack.getName() + "_settings")
# Notify the UI in which container to store the machine settings data
container_index = self._global_container_stack.getContainerIndex(definition_changes_container)
if container_index != self._container_index:
self._container_index = container_index
self.containerIndexChanged.emit()
# Disable auto-slicing while the MachineAction is showing
if self._backend: # This sometimes triggers before backend is loaded.
self._backend.disableTimer()
def test_createMachine(application, container_registry, definition_container,
global_variant, material_instance_container,
quality_container, quality_changes_container):
variant_manager = MagicMock(name="Variant Manager")
quality_manager = MagicMock(name="Quality Manager")
global_variant_node = MagicMock(name="global variant node")
global_variant_node.getContainer = MagicMock(return_value=global_variant)
variant_manager.getDefaultVariantNode = MagicMock(
return_value=global_variant_node)
quality_group = QualityGroup(name="zomg", quality_type="normal")
quality_group.node_for_global = MagicMock(name="Node for global")
quality_group.node_for_global.getContainer = MagicMock(
return_value=quality_container)
quality_manager.getQualityGroups = MagicMock(
return_value={"normal": quality_group})
application.getContainerRegistry = MagicMock(
return_value=container_registry)
application.getVariantManager = MagicMock(return_value=variant_manager)
application.getQualityManager = MagicMock(return_value=quality_manager)
application.empty_material_container = material_instance_container
application.empty_quality_container = quality_container
application.empty_quality_changes_container = quality_changes_container
metadata = definition_container.getMetaData()
metadata["machine_extruder_trains"] = {}
metadata["preferred_quality_type"] = "normal"
container_registry.addContainer(definition_container)
with patch("cura.CuraApplication.CuraApplication.getInstance",
MagicMock(return_value=application)):
machine = CuraStackBuilder.createMachine("Whatever", "Test Definition")
assert machine.quality == quality_container
assert machine.definition == definition_container
assert machine.variant == global_variant
def test_createMachineWithUnknownDefinition(application, container_registry):
application.getContainerRegistry = MagicMock(return_value=container_registry)
with patch("cura.CuraApplication.CuraApplication.getInstance", MagicMock(return_value=application)):
with patch("UM.ConfigurationErrorMessage.ConfigurationErrorMessage.getInstance") as mocked_config_error:
assert CuraStackBuilder.createMachine("Whatever", "NOPE") is None
assert mocked_config_error.addFaultyContainers.called_with("NOPE")
