diff --git a/cura/PrinterOutput/NetworkedPrinterOutputDevice.py b/cura/PrinterOutput/NetworkedPrinterOutputDevice.py index 35d2ce014a..9a3be936a2 100644 --- a/cura/PrinterOutput/NetworkedPrinterOutputDevice.py +++ b/cura/PrinterOutput/NetworkedPrinterOutputDevice.py @@ -147,6 +147,9 @@ class NetworkedPrinterOutputDevice(PrinterOutputDevice): request.setHeader(QNetworkRequest.UserAgentHeader, self._user_agent) return request + def createFormPart(self, content_header: str, data: bytes, content_type: Optional[str] = None) -> QHttpPart: + return self._createFormPart(content_header, data, content_type) + def _createFormPart(self, content_header: str, data: bytes, content_type: Optional[str] = None) -> QHttpPart: part = QHttpPart() diff --git a/plugins/UM3NetworkPrinting/src/SendMaterialJob.py b/plugins/UM3NetworkPrinting/src/SendMaterialJob.py index 62b98bcdbd..6763901151 100644 --- a/plugins/UM3NetworkPrinting/src/SendMaterialJob.py +++ b/plugins/UM3NetworkPrinting/src/SendMaterialJob.py @@ -1,21 +1,20 @@ # Copyright (c) 2018 Ultimaker B.V. # Cura is released under the terms of the LGPLv3 or higher. +import json +import os +import urllib.parse +from typing import Dict, TYPE_CHECKING, Set -import json # To decode the list of materials from the printer reply. -import os # To walk over material files. -import os.path # To filter on material files. -import urllib.parse # For getting material IDs from their file names. -from typing import Dict, TYPE_CHECKING +from PyQt5.QtNetwork import QNetworkReply, QNetworkRequest -from PyQt5.QtNetwork import QNetworkReply, QNetworkRequest # To listen to the reply from the printer. - -from UM.Job import Job # The interface we're implementing. +from UM.Job import Job from UM.Logger import Logger -from UM.MimeTypeDatabase import MimeTypeDatabase # To strip the extensions of the material profile files. +from UM.MimeTypeDatabase import MimeTypeDatabase from UM.Resources import Resources -from UM.Settings.ContainerRegistry import ContainerRegistry # To find the GUIDs of materials. -from cura.CuraApplication import CuraApplication # For the resource types. -from plugins.UM3NetworkPrinting.src.Models import ClusterMaterial, LocalMaterial +from cura.CuraApplication import CuraApplication + +# Absolute imports don't work in plugins +from .Models import ClusterMaterial, LocalMaterial if TYPE_CHECKING: from .ClusterUM3OutputDevice import ClusterUM3OutputDevice @@ -25,95 +24,136 @@ if TYPE_CHECKING: # # This way it won't freeze up the interface while sending those materials. class SendMaterialJob(Job): + def __init__(self, device: "ClusterUM3OutputDevice") -> None: super().__init__() self.device = device # type: ClusterUM3OutputDevice + self._application = CuraApplication.getInstance() # type: CuraApplication ## Send the request to the printer and register a callback def run(self) -> None: self.device.get("materials/", on_finished = self.sendMissingMaterials) - ## Process the reply from the printer and determine which materials should be updated and sent to the printer + ## Process the materials reply from the printer. # - # \param reply The reply from the printer, a json file - def sendMissingMaterials(self, reply: QNetworkReply) -> None: - if reply.attribute(QNetworkRequest.HttpStatusCodeAttribute) != 200: # Got an error from the HTTP request. - Logger.log("e", "Couldn't request current material storage on printer. Not syncing materials.") + # \param reply The reply from the printer, a json file. + def _onGetRemoteMaterials(self, reply: QNetworkReply) -> None: + + # Got an error from the HTTP request. If we did not receive a 200 something happened. + if reply.attribute(QNetworkRequest.HttpStatusCodeAttribute) != 200: + Logger.log("e", "Error fetching materials from printer: %s", reply.errorString()) return - # Collect materials from the printer's reply + # Collect materials from the printer's reply and send the missing ones if needed. try: remote_materials_by_guid = self._parseReply(reply) - except json.JSONDecodeError: - Logger.log("e", "Request material storage on printer: I didn't understand the printer's answer.") - return - except KeyError: - Logger.log("e", "Request material storage on printer: Printer's answer was missing GUIDs.") - return + self._sendMissingMaterials(remote_materials_by_guid) + except json.JSONDecodeError as e: + Logger.log("e", "Error parsing materials from printer: %s", e) + except KeyError as e: + Logger.log("e", "Error parsing materials from printer: %s", e) + + ## Determine which materials should be updated and send them to the printer. + # + # \param remote_materials_by_guid The remote materials by GUID. + def _sendMissingMaterials(self, remote_materials_by_guid: Dict[str, ClusterMaterial]) -> None: # Collect local materials local_materials_by_guid = self._getLocalMaterials() + if len(local_materials_by_guid) == 0: + Logger.log("d", "There are no local materials to synchronize with the printer.") + return # Find out what materials are new or updated and must be sent to the printer - materials_to_send = { - material.id - for guid, material in local_materials_by_guid.items() - if guid not in remote_materials_by_guid or - material.version > remote_materials_by_guid[guid].version - } + material_ids_to_send = self._determineMaterialsToSend(local_materials_by_guid, remote_materials_by_guid) + if len(material_ids_to_send) == 0: + Logger.log("d", "There are no remote materials to update.") + return # Send materials to the printer - self.sendMaterialsToPrinter(materials_to_send) + self._sendMaterials(material_ids_to_send) - ## Send the materials to the printer + ## From the local and remote materials, determine which ones should be synchronized. # - # The given materials will be loaded from disk en sent to to printer. The given id's will be mathed with - # filenames of the locally stored materials + # Makes a Set containing only the materials that are not on the printer yet or the ones that are newer in Cura. # - # \param materials_to_send A set with id's of materials that must be sent - def sendMaterialsToPrinter(self, materials_to_send) -> None: - for file_path in Resources.getAllResourcesOfType(CuraApplication.ResourceTypes.MaterialInstanceContainer): + # \param local_materials The local materials by GUID. + # \param remote_materials The remote materials by GUID. + @staticmethod + def _determineMaterialsToSend(local_materials: Dict[str, LocalMaterial], + remote_materials: Dict[str, ClusterMaterial]) -> Set[str]: + return { + material.id for guid, material in local_materials.items() + if guid not in remote_materials or material.version > remote_materials[guid].version + } + + ## Send the materials to the printer. + # + # The given materials will be loaded from disk en sent to to printer. + # The given id's will be matched with filenames of the locally stored materials. + # + # \param materials_to_send A set with id's of materials that must be sent. + def _sendMaterials(self, materials_to_send: Set[str]) -> None: + file_paths = Resources.getAllResourcesOfType(CuraApplication.ResourceTypes.MaterialInstanceContainer) + + # Find all local material files and send them if needed. + for file_path in file_paths: try: mime_type = MimeTypeDatabase.getMimeTypeForFile(file_path) except MimeTypeDatabase.MimeTypeNotFoundError: - continue # Not the sort of file we'd like to send then. - - _, file_name = os.path.split(file_path) - material_id = urllib.parse.unquote_plus(mime_type.stripExtension(file_name)) - - if material_id not in materials_to_send: continue + file_name = os.path.basename(file_path) + material_id = urllib.parse.unquote_plus(mime_type.stripExtension(file_name)) + if material_id not in materials_to_send: + # If the material does not have to be sent we skip it. + continue + + self._sendMaterialFile(file_path, file_name, material_id) + + ## Send a single material file to the printer. + # + # Also add the material signature file if that is available. + # + # \param file_path The path of the material file. + # \param file_name The name of the material file. + # \param material_id The ID of the material in the file. + def _sendMaterialFile(self, file_path: str, file_name: str, material_id: str) -> None: + parts = [] + + # Add the material file. with open(file_path, "rb") as f: - parts.append( - self.device._createFormPart("name=\"file\"; filename=\"{file_name}\"".format(file_name = file_name), - f.read())) - signature_file_path = file_path + ".sig" + parts.append(self.device.createFormPart("name=\"file\"; filename=\"{file_name}\"" + .format(file_name = file_name), f.read())) + + # Add the material signature file if needed. + signature_file_path = "{}.sig".format(file_path) if os.path.exists(signature_file_path): - _, signature_file_name = os.path.split(signature_file_path) + signature_file_name = os.path.basename(signature_file_path) with open(signature_file_path, "rb") as f: - parts.append(self.device._createFormPart( - "name=\"signature_file\"; filename=\"{file_name}\"".format(file_name = signature_file_name), - f.read())) + parts.append(self.device.createFormPart("name=\"signature_file\"; filename=\"{file_name}\"" + .format(file_name = signature_file_name), f.read())) Logger.log("d", "Syncing material {material_id} with cluster.".format(material_id = material_id)) self.device.postFormWithParts(target = "materials/", parts = parts, on_finished = self.sendingFinished) ## Check a reply from an upload to the printer and log an error when the call failed - def sendingFinished(self, reply: QNetworkReply) -> None: + @staticmethod + def sendingFinished(reply: QNetworkReply) -> None: if reply.attribute(QNetworkRequest.HttpStatusCodeAttribute) != 200: - Logger.log("e", "Received error code from printer when syncing material: {code}".format( - code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute))) - Logger.log("e", reply.readAll().data().decode("utf-8")) + Logger.log("e", "Received error code from printer when syncing material: {code}, {text}".format( + code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute), + text = reply.errorString() + )) ## Parse the reply from the printer # # Parses the reply to a "/materials" request to the printer # - # \return a dictionary of ClustMaterial objects by GUID + # \return a dictionary of ClusterMaterial objects by GUID # \throw json.JSONDecodeError Raised when the reply does not contain a valid json string - # \throw KeyErrror Raised when on of the materials does not include a valid guid + # \throw KeyError Raised when on of the materials does not include a valid guid @classmethod def _parseReply(cls, reply: QNetworkReply) -> Dict[str, ClusterMaterial]: remote_materials_list = json.loads(reply.readAll().data().decode("utf-8")) @@ -124,17 +164,21 @@ class SendMaterialJob(Job): # Only the new newest version of the local materials is returned # # \return a dictionary of LocalMaterial objects by GUID - @classmethod - def _getLocalMaterials(cls): - result = {} - for material in ContainerRegistry.getInstance().findContainersMetadata(type = "material"): - try: - localMaterial = LocalMaterial(**material) + def _getLocalMaterials(self) -> Dict[str, LocalMaterial]: + result = {} # type: Dict[str, LocalMaterial] + container_registry = self._application.getContainerRegistry() + material_containers = container_registry.findContainersMetadata(type = "material") - if localMaterial.GUID not in result or localMaterial.version > result.get(localMaterial.GUID).version: - result[localMaterial.GUID] = localMaterial - except (ValueError): - Logger.log("e", "Material {material_id} has invalid version number {number}.".format( - material_id = material["id"], number = material["version"])) + # Find the latest version of all material containers in the registry. + for m in material_containers: + try: + material = LocalMaterial(**m) + if material.GUID not in result or material.version > result.get(material.GUID).version: + result[material.GUID] = material + except ValueError as e: + Logger.log("w", "Local material {material_id} has invalid values: {e}".format( + material_id = m["id"], + e = e + )) return result