Merge branch 'master' into feature_firmware_updater

cura/PrinterOutput/ConfigurationModel.py

@@ -13,36 +13,42 @@ class ConfigurationModel(QObject):
 
     configurationChanged = pyqtSignal()
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
-        self._printer_type = None
+        self._printer_type = ""
         self._extruder_configurations = []     # type: List[ExtruderConfigurationModel]
-        self._buildplate_configuration = None
+        self._buildplate_configuration = ""
 
     def setPrinterType(self, printer_type):
         self._printer_type = printer_type
 
     @pyqtProperty(str, fset = setPrinterType, notify = configurationChanged)
-    def printerType(self):
+    def printerType(self) -> str:
         return self._printer_type
 
-    def setExtruderConfigurations(self, extruder_configurations):
-        self._extruder_configurations = extruder_configurations
+    def setExtruderConfigurations(self, extruder_configurations: List["ExtruderConfigurationModel"]):
+        if self._extruder_configurations != extruder_configurations:
+            self._extruder_configurations = extruder_configurations
+
+            for extruder_configuration in self._extruder_configurations:
+                extruder_configuration.extruderConfigurationChanged.connect(self.configurationChanged)
+
+            self.configurationChanged.emit()
 
     @pyqtProperty("QVariantList", fset = setExtruderConfigurations, notify = configurationChanged)
     def extruderConfigurations(self):
         return self._extruder_configurations
 
-    def setBuildplateConfiguration(self, buildplate_configuration):
+    def setBuildplateConfiguration(self, buildplate_configuration: str) -> None:
         self._buildplate_configuration = buildplate_configuration
 
     @pyqtProperty(str, fset = setBuildplateConfiguration, notify = configurationChanged)
-    def buildplateConfiguration(self):
+    def buildplateConfiguration(self) -> str:
         return self._buildplate_configuration
 
     ##  This method is intended to indicate whether the configuration is valid or not.
     #   The method checks if the mandatory fields are or not set
-    def isValid(self):
+    def isValid(self) -> bool:
         if not self._extruder_configurations:
             return False
         for configuration in self._extruder_configurations:

cura/PrinterOutput/ExtruderConfigurationModel.py

@@ -1,56 +1,67 @@
 # Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
+from typing import Optional
 
 from PyQt5.QtCore import pyqtProperty, QObject, pyqtSignal
 
+from cura.PrinterOutput.MaterialOutputModel import MaterialOutputModel
+
 
 class ExtruderConfigurationModel(QObject):
 
     extruderConfigurationChanged = pyqtSignal()
 
-    def __init__(self):
+    def __init__(self, position: int = -1) -> None:
         super().__init__()
-        self._position = -1
-        self._material = None
-        self._hotend_id = None
+        self._position = position  # type: int
+        self._material = None  # type: Optional[MaterialOutputModel]
+        self._hotend_id = None  # type: Optional[str]
 
-    def setPosition(self, position):
+    def setPosition(self, position: int) -> None:
         self._position = position
 
     @pyqtProperty(int, fset = setPosition, notify = extruderConfigurationChanged)
-    def position(self):
+    def position(self) -> int:
         return self._position
 
-    def setMaterial(self, material):
-        self._material = material
+    def setMaterial(self, material: Optional[MaterialOutputModel]) -> None:
+        if self._hotend_id != material:
+            self._material = material
+            self.extruderConfigurationChanged.emit()
 
     @pyqtProperty(QObject, fset = setMaterial, notify = extruderConfigurationChanged)
-    def material(self):
+    def activeMaterial(self) -> Optional[MaterialOutputModel]:
         return self._material
 
-    def setHotendID(self, hotend_id):
-        self._hotend_id = hotend_id
+    @pyqtProperty(QObject, fset=setMaterial, notify=extruderConfigurationChanged)
+    def material(self) -> Optional[MaterialOutputModel]:
+        return self._material
+
+    def setHotendID(self, hotend_id: Optional[str]) -> None:
+        if self._hotend_id != hotend_id:
+            self._hotend_id = hotend_id
+            self.extruderConfigurationChanged.emit()
 
     @pyqtProperty(str, fset = setHotendID, notify = extruderConfigurationChanged)
-    def hotendID(self):
+    def hotendID(self) -> Optional[str]:
         return self._hotend_id
 
     ##  This method is intended to indicate whether the configuration is valid or not.
     #   The method checks if the mandatory fields are or not set
     #   At this moment is always valid since we allow to have empty material and variants.
-    def isValid(self):
+    def isValid(self) -> bool:
         return True
 
-    def __str__(self):
+    def __str__(self) -> str:
         message_chunks = []
         message_chunks.append("Position: " + str(self._position))
         message_chunks.append("-")
-        message_chunks.append("Material: " + self.material.type if self.material else "empty")
+        message_chunks.append("Material: " + self.activeMaterial.type if self.activeMaterial else "empty")
         message_chunks.append("-")
         message_chunks.append("HotendID: " + self.hotendID if self.hotendID else "empty")
         return " ".join(message_chunks)
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         return hash(self) == hash(other)
 
     #   Calculating a hash function using the position of the extruder, the material GUID and the hotend id to check if is

cura/PrinterOutput/ExtruderOutputModel.py

@@ -12,64 +12,61 @@ if TYPE_CHECKING:
 
 
 class ExtruderOutputModel(QObject):
-    hotendIDChanged = pyqtSignal()
     targetHotendTemperatureChanged = pyqtSignal()
     hotendTemperatureChanged = pyqtSignal()
-    activeMaterialChanged = pyqtSignal()
+
     extruderConfigurationChanged = pyqtSignal()
     isPreheatingChanged = pyqtSignal()
 
-    def __init__(self, printer: "PrinterOutputModel", position, parent=None) -> None:
+    def __init__(self, printer: "PrinterOutputModel", position: int, parent=None) -> None:
         super().__init__(parent)
-        self._printer = printer
+        self._printer = printer  # type: PrinterOutputModel
         self._position = position
-        self._target_hotend_temperature = 0 # type: float
-        self._hotend_temperature = 0 # type: float
-        self._hotend_id = ""
-        self._active_material = None  # type: Optional[MaterialOutputModel]
-        self._extruder_configuration = ExtruderConfigurationModel()
-        self._extruder_configuration.position = self._position
+        self._target_hotend_temperature = 0.0  # type: float
+        self._hotend_temperature = 0.0  # type: float
 
         self._is_preheating = False
 
-    def getPrinter(self):
+        # The extruder output model wraps the configuration model. This way we can use the same config model for jobs
+        # and extruders alike.
+        self._extruder_configuration = ExtruderConfigurationModel()
+        self._extruder_configuration.position = self._position
+        self._extruder_configuration.extruderConfigurationChanged.connect(self.extruderConfigurationChanged)
+
+    def getPrinter(self) -> "PrinterOutputModel":
         return self._printer
 
-    def getPosition(self):
+    def getPosition(self) -> int:
         return self._position
 
     # Does the printer support pre-heating the bed at all
     @pyqtProperty(bool, constant=True)
-    def canPreHeatHotends(self):
+    def canPreHeatHotends(self) -> bool:
         if self._printer:
             return self._printer.canPreHeatHotends
         return False
 
-    @pyqtProperty(QObject, notify = activeMaterialChanged)
+    @pyqtProperty(QObject, notify = extruderConfigurationChanged)
     def activeMaterial(self) -> Optional["MaterialOutputModel"]:
-        return self._active_material
+        return self._extruder_configuration.activeMaterial
 
-    def updateActiveMaterial(self, material: Optional["MaterialOutputModel"]):
-        if self._active_material != material:
-            self._active_material = material
-            self._extruder_configuration.material = self._active_material
-            self.activeMaterialChanged.emit()
-            self.extruderConfigurationChanged.emit()
+    def updateActiveMaterial(self, material: Optional["MaterialOutputModel"]) -> None:
+        self._extruder_configuration.setMaterial(material)
 
     ##  Update the hotend temperature. This only changes it locally.
-    def updateHotendTemperature(self, temperature: float):
+    def updateHotendTemperature(self, temperature: float) -> None:
         if self._hotend_temperature != temperature:
             self._hotend_temperature = temperature
             self.hotendTemperatureChanged.emit()
 
-    def updateTargetHotendTemperature(self, temperature: float):
+    def updateTargetHotendTemperature(self, temperature: float) -> None:
         if self._target_hotend_temperature != temperature:
             self._target_hotend_temperature = temperature
             self.targetHotendTemperatureChanged.emit()
 
     ##  Set the target hotend temperature. This ensures that it's actually sent to the remote.
     @pyqtSlot(float)
-    def setTargetHotendTemperature(self, temperature: float):
+    def setTargetHotendTemperature(self, temperature: float) -> None:
         self._printer.getController().setTargetHotendTemperature(self._printer, self, temperature)
         self.updateTargetHotendTemperature(temperature)
 
@@ -81,30 +78,26 @@ class ExtruderOutputModel(QObject):
     def hotendTemperature(self) -> float:
         return self._hotend_temperature
 
-    @pyqtProperty(str, notify = hotendIDChanged)
+    @pyqtProperty(str, notify = extruderConfigurationChanged)
     def hotendID(self) -> str:
-        return self._hotend_id
+        return self._extruder_configuration.hotendID
 
-    def updateHotendID(self, id: str):
-        if self._hotend_id != id:
-            self._hotend_id = id
-            self._extruder_configuration.hotendID = self._hotend_id
-            self.hotendIDChanged.emit()
-            self.extruderConfigurationChanged.emit()
+    def updateHotendID(self, hotend_id: str) -> None:
+        self._extruder_configuration.setHotendID(hotend_id)
 
     @pyqtProperty(QObject, notify = extruderConfigurationChanged)
-    def extruderConfiguration(self):
+    def extruderConfiguration(self) -> Optional[ExtruderConfigurationModel]:
         if self._extruder_configuration.isValid():
             return self._extruder_configuration
         return None
 
-    def updateIsPreheating(self, pre_heating):
+    def updateIsPreheating(self, pre_heating: bool) -> None:
         if self._is_preheating != pre_heating:
             self._is_preheating = pre_heating
             self.isPreheatingChanged.emit()
 
     @pyqtProperty(bool, notify=isPreheatingChanged)
-    def isPreheating(self):
+    def isPreheating(self) -> bool:
         return self._is_preheating
 
     ##  Pre-heats the extruder before printer.
@@ -113,9 +106,9 @@ class ExtruderOutputModel(QObject):
     #   Celsius.
     #   \param duration How long the bed should stay warm, in seconds.
     @pyqtSlot(float, float)
-    def preheatHotend(self, temperature, duration):
+    def preheatHotend(self, temperature: float, duration: float) -> None:
         self._printer._controller.preheatHotend(self, temperature, duration)
 
     @pyqtSlot()
-    def cancelPreheatHotend(self):
-        self._printer._controller.cancelPreheatHotend(self)
+    def cancelPreheatHotend(self) -> None:
+        self._printer._controller.cancelPreheatHotend(self)

cura/PrinterOutput/NetworkedPrinterOutputDevice.py

@@ -53,21 +53,8 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
         self._sending_gcode = False
         self._compressing_gcode = False
         self._gcode = []                    # type: List[str]
-
         self._connection_state_before_timeout = None    # type: Optional[ConnectionState]
 
-        printer_type = self._properties.get(b"machine", b"").decode("utf-8")
-        printer_type_identifiers = {
-            "9066": "ultimaker3",
-            "9511": "ultimaker3_extended",
-            "9051": "ultimaker_s5"
-        }
-        self._printer_type = "Unknown"
-        for key, value in printer_type_identifiers.items():
-            if printer_type.startswith(key):
-                self._printer_type = value
-                break
-
     def requestWrite(self, nodes: List[SceneNode], file_name: Optional[str] = None, limit_mimetypes: bool = False, file_handler: Optional[FileHandler] = None, **kwargs: str) -> None:
         raise NotImplementedError("requestWrite needs to be implemented")
 
@@ -188,40 +175,55 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
         if reply in self._kept_alive_multiparts:
             del self._kept_alive_multiparts[reply]
 
-    def put(self, target: str, data: str, on_finished: Optional[Callable[[QNetworkReply], None]]) -> None:
+    def _validateManager(self) -> None:
         if self._manager is None:
             self._createNetworkManager()
         assert (self._manager is not None)
+
+    def put(self, target: str, data: str, on_finished: Optional[Callable[[QNetworkReply], None]]) -> None:
+        self._validateManager()
         request = self._createEmptyRequest(target)
         self._last_request_time = time()
-        reply = self._manager.put(request, data.encode())
-        self._registerOnFinishedCallback(reply, on_finished)
+        if self._manager is not None:
+            reply = self._manager.put(request, data.encode())
+            self._registerOnFinishedCallback(reply, on_finished)
+        else:
+            Logger.log("e", "Could not find manager.")
+
+    def delete(self, target: str, on_finished: Optional[Callable[[QNetworkReply], None]]) -> None:
+        self._validateManager()
+        request = self._createEmptyRequest(target)
+        self._last_request_time = time()
+        if self._manager is not None:
+            reply = self._manager.deleteResource(request)
+            self._registerOnFinishedCallback(reply, on_finished)
+        else:
+            Logger.log("e", "Could not find manager.")
 
     def get(self, target: str, on_finished: Optional[Callable[[QNetworkReply], None]]) -> None:
-        if self._manager is None:
-            self._createNetworkManager()
-        assert (self._manager is not None)
+        self._validateManager()
         request = self._createEmptyRequest(target)
         self._last_request_time = time()
-        reply = self._manager.get(request)
-        self._registerOnFinishedCallback(reply, on_finished)
+        if self._manager is not None:
+            reply = self._manager.get(request)
+            self._registerOnFinishedCallback(reply, on_finished)
+        else:
+            Logger.log("e", "Could not find manager.")
 
     def post(self, target: str, data: str, on_finished: Optional[Callable[[QNetworkReply], None]], on_progress: Callable = None) -> None:
-        if self._manager is None:
-            self._createNetworkManager()
-        assert (self._manager is not None)
+        self._validateManager()
         request = self._createEmptyRequest(target)
         self._last_request_time = time()
-        reply = self._manager.post(request, data)
-        if on_progress is not None:
-            reply.uploadProgress.connect(on_progress)
-        self._registerOnFinishedCallback(reply, on_finished)
+        if self._manager is not None:
+            reply = self._manager.post(request, data)
+            if on_progress is not None:
+                reply.uploadProgress.connect(on_progress)
+            self._registerOnFinishedCallback(reply, on_finished)
+        else:
+            Logger.log("e", "Could not find manager.")
 
     def postFormWithParts(self, target: str, parts: List[QHttpPart], on_finished: Optional[Callable[[QNetworkReply], None]], on_progress: Callable = None) -> QNetworkReply:
-
-        if self._manager is None:
-            self._createNetworkManager()
-        assert (self._manager is not None)
+        self._validateManager()
         request = self._createEmptyRequest(target, content_type=None)
         multi_post_part = QHttpMultiPart(QHttpMultiPart.FormDataType)
         for part in parts:
@@ -229,15 +231,18 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
 
         self._last_request_time = time()
 
-        reply = self._manager.post(request, multi_post_part)
+        if self._manager is not None:
+            reply = self._manager.post(request, multi_post_part)
 
-        self._kept_alive_multiparts[reply] = multi_post_part
+            self._kept_alive_multiparts[reply] = multi_post_part
 
-        if on_progress is not None:
-            reply.uploadProgress.connect(on_progress)
-        self._registerOnFinishedCallback(reply, on_finished)
+            if on_progress is not None:
+                reply.uploadProgress.connect(on_progress)
+            self._registerOnFinishedCallback(reply, on_finished)
 
-        return reply
+            return reply
+        else:
+            Logger.log("e", "Could not find manager.")
 
     def postForm(self, target: str, header_data: str, body_data: bytes, on_finished: Optional[Callable[[QNetworkReply], None]], on_progress: Callable = None) -> None:
         post_part = QHttpPart()
@@ -323,7 +328,7 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice):
 
     @pyqtProperty(str, constant = True)
     def printerType(self) -> str:
-        return self._printer_type
+        return self._properties.get(b"printer_type", b"Unknown").decode("utf-8")
 
     ## IP adress of this printer
     @pyqtProperty(str, constant = True)

cura/PrinterOutput/PrintJobOutputModel.py

@@ -2,11 +2,15 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from PyQt5.QtCore import pyqtSignal, pyqtProperty, QObject, pyqtSlot
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, List
+
+from PyQt5.QtCore import QUrl
+from PyQt5.QtGui import QImage
 
 if TYPE_CHECKING:
     from cura.PrinterOutput.PrinterOutputController import PrinterOutputController
     from cura.PrinterOutput.PrinterOutputModel import PrinterOutputModel
+    from cura.PrinterOutput.ConfigurationModel import ConfigurationModel
 
 
 class PrintJobOutputModel(QObject):
@@ -17,6 +21,9 @@ class PrintJobOutputModel(QObject):
     keyChanged = pyqtSignal()
     assignedPrinterChanged = pyqtSignal()
     ownerChanged = pyqtSignal()
+    configurationChanged = pyqtSignal()
+    previewImageChanged = pyqtSignal()
+    compatibleMachineFamiliesChanged = pyqtSignal()
 
     def __init__(self, output_controller: "PrinterOutputController", key: str = "", name: str = "", parent=None) -> None:
         super().__init__(parent)
@@ -29,6 +36,48 @@ class PrintJobOutputModel(QObject):
         self._assigned_printer = None  # type: Optional[PrinterOutputModel]
         self._owner = ""  # Who started/owns the print job?
 
+        self._configuration = None  # type: Optional[ConfigurationModel]
+        self._compatible_machine_families = []  # type: List[str]
+        self._preview_image_id = 0
+
+        self._preview_image = None  # type: Optional[QImage]
+
+    @pyqtProperty("QStringList", notify=compatibleMachineFamiliesChanged)
+    def compatibleMachineFamilies(self):
+        # Hack; Some versions of cluster will return a family more than once...
+        return set(self._compatible_machine_families)
+
+    def setCompatibleMachineFamilies(self, compatible_machine_families: List[str]) -> None:
+        if self._compatible_machine_families != compatible_machine_families:
+            self._compatible_machine_families = compatible_machine_families
+            self.compatibleMachineFamiliesChanged.emit()
+
+    @pyqtProperty(QUrl, notify=previewImageChanged)
+    def previewImageUrl(self):
+        self._preview_image_id += 1
+        # There is an image provider that is called "camera". In order to ensure that the image qml object, that
+        # requires a QUrl to function, updates correctly we add an increasing number. This causes to see the QUrl
+        # as new (instead of relying on cached version and thus forces an update.
+        temp = "image://print_job_preview/" + str(self._preview_image_id) + "/" + self._key
+        return QUrl(temp, QUrl.TolerantMode)
+
+    def getPreviewImage(self) -> Optional[QImage]:
+        return self._preview_image
+
+    def updatePreviewImage(self, preview_image: Optional[QImage]) -> None:
+        if self._preview_image != preview_image:
+            self._preview_image = preview_image
+            self.previewImageChanged.emit()
+
+    @pyqtProperty(QObject, notify=configurationChanged)
+    def configuration(self) -> Optional["ConfigurationModel"]:
+        return self._configuration
+
+    def updateConfiguration(self, configuration: Optional["ConfigurationModel"]) -> None:
+        if self._configuration != configuration:
+            self._configuration = configuration
+            self.configurationChanged.emit()
+
     @pyqtProperty(str, notify=ownerChanged)
     def owner(self):
         return self._owner

cura/PrinterOutput/PrinterOutputModel.py

@@ -37,7 +37,7 @@ class PrinterOutputModel(QObject):
         self._controller = output_controller
         self._controller.canUpdateFirmwareChanged.connect(self._onControllerCanUpdateFirmwareChanged)
         self._extruders = [ExtruderOutputModel(printer = self, position = i) for i in range(number_of_extruders)]
-        self._printer_configuration = ConfigurationModel()    # Indicates the current configuration setup in this printer
+        self._printer_configuration = ConfigurationModel()  # Indicates the current configuration setup in this printer
         self._head_position = Vector(0, 0, 0)
         self._active_print_job = None  # type: Optional[PrintJobOutputModel]
         self._firmware_version = firmware_version
@@ -45,9 +45,9 @@ class PrinterOutputModel(QObject):
         self._is_preheating = False
         self._printer_type = ""
         self._buildplate_name = None
-        # Update the printer configuration every time any of the extruders changes its configuration
-        for extruder in self._extruders:
-            extruder.extruderConfigurationChanged.connect(self._updateExtruderConfiguration)
+
+        self._printer_configuration.extruderConfigurations = [extruder.extruderConfiguration for extruder in
+                                                              self._extruders]
 
         self._camera = None
 
@@ -295,8 +295,4 @@ class PrinterOutputModel(QObject):
     def printerConfiguration(self):
         if self._printer_configuration.isValid():
             return self._printer_configuration
-        return None
-
-    def _updateExtruderConfiguration(self):
-        self._printer_configuration.extruderConfigurations = [extruder.extruderConfiguration for extruder in self._extruders]
-        self.configurationChanged.emit()
+        return None