Restructure codebase - part 1

plugins/UM3NetworkPrinting/src/Models/BaseCloudModel.py

@@ -0,0 +1,55 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from datetime import datetime, timezone
+from typing import Dict, Union, TypeVar, Type, List, Any
+
+from plugins.UM3NetworkPrinting.src.Models.BaseModel import BaseModel
+
+
+## Base class for the models used in the interface with the Ultimaker cloud APIs.
+class BaseCloudModel(BaseModel):
+    ## Checks whether the two models are equal.
+    #  \param other: The other model.
+    #  \return True if they are equal, False if they are different.
+    def __eq__(self, other):
+        return type(self) == type(other) and self.toDict() == other.toDict()
+
+    ## Checks whether the two models are different.
+    #  \param other: The other model.
+    #  \return True if they are different, False if they are the same.
+    def __ne__(self, other) -> bool:
+        return type(self) != type(other) or self.toDict() != other.toDict()
+
+    ## Converts the model into a serializable dictionary
+    def toDict(self) -> Dict[str, Any]:
+        return self.__dict__
+
+    # Type variable used in the parse methods below, which should be a subclass of BaseModel.
+    T = TypeVar("T", bound=BaseModel)
+
+    ## Parses a single model.
+    #  \param model_class: The model class.
+    #  \param values: The value of the model, which is usually a dictionary, but may also be already parsed.
+    #  \return An instance of the model_class given.
+    @staticmethod
+    def parseModel(model_class: Type[T], values: Union[T, Dict[str, Any]]) -> T:
+        if isinstance(values, dict):
+            return model_class(**values)
+        return values
+
+    ## Parses a list of models.
+    #  \param model_class: The model class.
+    #  \param values: The value of the list. Each value is usually a dictionary, but may also be already parsed.
+    #  \return A list of instances of the model_class given.
+    @classmethod
+    def parseModels(cls, model_class: Type[T], values: List[Union[T, Dict[str, Any]]]) -> List[T]:
+        return [cls.parseModel(model_class, value) for value in values]
+
+    ## Parses the given date string.
+    #  \param date: The date to parse.
+    #  \return The parsed date.
+    @staticmethod
+    def parseDate(date: Union[str, datetime]) -> datetime:
+        if isinstance(date, datetime):
+            return date
+        return datetime.strptime(date, "%Y-%m-%dT%H:%M:%S.%fZ").replace(tzinfo=timezone.utc)

plugins/UM3NetworkPrinting/src/Models/BaseModel.py

@@ -0,0 +1,9 @@
+## Base model that maps kwargs to instance attributes.
+class BaseModel:
+    def __init__(self, **kwargs) -> None:
+        self.__dict__.update(kwargs)
+        self.validate()
+
+    # Validates the model, raising an exception if the model is invalid.
+    def validate(self) -> None:
+        pass

plugins/UM3NetworkPrinting/src/Models/CloudClusterBuildPlate.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from .BaseCloudModel import BaseCloudModel
+
+
+##  Class representing a cluster printer
+#  Spec: https://api-staging.ultimaker.com/connect/v1/spec
+class CloudClusterBuildPlate(BaseCloudModel):
+    ## Create a new build plate
+    #  \param type: The type of buildplate glass or aluminium
+    def __init__(self, type: str = "glass", **kwargs) -> None:
+        self.type = type
+        super().__init__(**kwargs)

plugins/UM3NetworkPrinting/src/Models/CloudClusterPrintCoreConfiguration.py

@@ -0,0 +1,52 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from typing import Union, Dict, Optional, Any
+
+from cura.PrinterOutput.Models.ExtruderConfigurationModel import ExtruderConfigurationModel
+from cura.PrinterOutput.Models.ExtruderOutputModel import ExtruderOutputModel
+from .CloudClusterPrinterConfigurationMaterial import CloudClusterPrinterConfigurationMaterial
+from .BaseCloudModel import BaseCloudModel
+
+
+##  Class representing a cloud cluster printer configuration
+#  Spec: https://api-staging.ultimaker.com/connect/v1/spec
+class CloudClusterPrintCoreConfiguration(BaseCloudModel):
+    ## Creates a new cloud cluster printer configuration object
+    #  \param extruder_index: The position of the extruder on the machine as list index. Numbered from left to right.
+    #  \param material: The material of a configuration object in a cluster printer. May be in a dict or an object.
+    #  \param nozzle_diameter: The diameter of the print core at this position in millimeters, e.g. '0.4'.
+    #  \param print_core_id: The type of print core inserted at this position, e.g. 'AA 0.4'.
+    def __init__(self, extruder_index: int,
+                 material: Union[None, Dict[str, Any], CloudClusterPrinterConfigurationMaterial],
+                 print_core_id: Optional[str] = None, **kwargs) -> None:
+        self.extruder_index = extruder_index
+        self.material = self.parseModel(CloudClusterPrinterConfigurationMaterial, material) if material else None
+        self.print_core_id = print_core_id
+        super().__init__(**kwargs)
+
+    ## Updates the given output model.
+    #  \param model - The output model to update.
+    def updateOutputModel(self, model: ExtruderOutputModel) -> None:
+        if self.print_core_id is not None:
+            model.updateHotendID(self.print_core_id)
+
+        if self.material:
+            active_material = model.activeMaterial
+            if active_material is None or active_material.guid != self.material.guid:
+                material = self.material.createOutputModel()
+                model.updateActiveMaterial(material)
+        else:
+            model.updateActiveMaterial(None)
+
+    ## Creates a configuration model
+    def createConfigurationModel(self) -> ExtruderConfigurationModel:
+        model = ExtruderConfigurationModel(position = self.extruder_index)
+        self.updateConfigurationModel(model)
+        return model
+
+    ## Creates a configuration model
+    def updateConfigurationModel(self, model: ExtruderConfigurationModel) -> ExtruderConfigurationModel:
+        model.setHotendID(self.print_core_id)
+        if self.material:
+            model.setMaterial(self.material.createOutputModel())
+        return model

plugins/UM3NetworkPrinting/src/Models/CloudClusterPrintJobConfigurationChange.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from typing import Optional
+
+from .BaseCloudModel import BaseCloudModel
+
+
+## Model for the types of changes that are needed before a print job can start
+#  Spec: https://api-staging.ultimaker.com/connect/v1/spec
+class CloudClusterPrintJobConfigurationChange(BaseCloudModel):
+    ## Creates a new print job constraint.
+    #  \param type_of_change: The type of configuration change, one of: "material", "print_core_change"
+    #  \param index: The hotend slot or extruder index to change
+    #  \param target_id: Target material guid or hotend id
+    #  \param origin_id: Original/current material guid or hotend id
+    #  \param target_name: Target material name or hotend id
+    #  \param origin_name: Original/current material name or hotend id
+    def __init__(self, type_of_change: str, target_id: str, origin_id: str,
+                 index: Optional[int] = None, target_name: Optional[str] = None, origin_name: Optional[str] = None,
+                 **kwargs) -> None:
+        self.type_of_change = type_of_change
+        self.index = index
+        self.target_id = target_id
+        self.origin_id = origin_id
+        self.target_name = target_name
+        self.origin_name = origin_name
+        super().__init__(**kwargs)

plugins/UM3NetworkPrinting/src/Models/CloudClusterPrintJobConstraint.py

@@ -0,0 +1,16 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from typing import Optional
+
+from .BaseCloudModel import BaseCloudModel
+
+
+## Class representing a cloud cluster print job constraint
+#  Spec: https://api-staging.ultimaker.com/connect/v1/spec
+class CloudClusterPrintJobConstraints(BaseCloudModel):
+    ## Creates a new print job constraint.
+    #  \param require_printer_name: Unique name of the printer that this job should be printed on.
+    #       Should be one of the unique_name field values in the cluster, e.g. 'ultimakersystem-ccbdd30044ec'
+    def __init__(self, require_printer_name: Optional[str] = None, **kwargs) -> None:
+        self.require_printer_name = require_printer_name
+        super().__init__(**kwargs)

plugins/UM3NetworkPrinting/src/Models/CloudClusterPrintJobImpediment.py

@@ -0,0 +1,15 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from .BaseCloudModel import BaseCloudModel
+
+
+## Class representing the reasons that prevent this job from being printed on the associated printer
+#  Spec: https://api-staging.ultimaker.com/connect/v1/spec
+class CloudClusterPrintJobImpediment(BaseCloudModel):
+    ## Creates a new print job constraint.
+    #  \param translation_key: A string indicating a reason the print cannot be printed, such as 'does_not_fit_in_build_volume'
+    #  \param severity: A number indicating the severity of the problem, with higher being more severe
+    def __init__(self, translation_key: str, severity: int, **kwargs) -> None:
+        self.translation_key = translation_key
+        self.severity = severity
+        super().__init__(**kwargs)

plugins/UM3NetworkPrinting/src/Models/CloudClusterPrintJobStatus.py

@@ -0,0 +1,133 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from typing import List, Optional, Union, Dict, Any
+
+from cura.PrinterOutput.Models.PrinterConfigurationModel import PrinterConfigurationModel
+from plugins.UM3NetworkPrinting.src.Models.UM3PrintJobOutputModel import UM3PrintJobOutputModel
+from plugins.UM3NetworkPrinting.src.Models.ConfigurationChangeModel import ConfigurationChangeModel
+from plugins.UM3NetworkPrinting.src.Cloud.CloudOutputController import CloudOutputController
+from .BaseCloudModel import BaseCloudModel
+from .CloudClusterBuildPlate import CloudClusterBuildPlate
+from .CloudClusterPrintJobConfigurationChange import CloudClusterPrintJobConfigurationChange
+from .CloudClusterPrintJobImpediment import CloudClusterPrintJobImpediment
+from .CloudClusterPrintCoreConfiguration import CloudClusterPrintCoreConfiguration
+from .CloudClusterPrintJobConstraint import CloudClusterPrintJobConstraints
+
+
+## Model for the status of a single print job in a cluster.
+#  Spec: https://api-staging.ultimaker.com/connect/v1/spec
+class CloudClusterPrintJobStatus(BaseCloudModel):
+    ## Creates a new cloud print job status model.
+    #  \param assigned_to: The name of the printer this job is assigned to while being queued.
+    #  \param configuration: The required print core configurations of this print job.
+    #  \param constraints: Print job constraints object.
+    #  \param created_at: The timestamp when the job was created in Cura Connect.
+    #  \param force: Allow this job to be printed despite of mismatching configurations.
+    #  \param last_seen: The number of seconds since this job was checked.
+    #  \param machine_variant: The machine type that this job should be printed on.Coincides with the machine_type field
+    #       of the printer object.
+    #  \param name: The name of the print job. Usually the name of the .gcode file.
+    #  \param network_error_count: The number of errors encountered when requesting data for this print job.
+    #  \param owner: The name of the user who added the print job to Cura Connect.
+    #  \param printer_uuid: UUID of the printer that the job is currently printing on or assigned to.
+    #  \param started: Whether the job has started printing or not.
+    #  \param status: The status of the print job.
+    #  \param time_elapsed: The remaining printing time in seconds.
+    #  \param time_total: The total printing time in seconds.
+    #  \param uuid: UUID of this print job. Should be used for identification purposes.
+    #  \param deleted_at: The time when this print job was deleted.
+    #  \param printed_on_uuid: UUID of the printer used to print this job.
+    #  \param configuration_changes_required: List of configuration changes the printer this job is associated with
+    #       needs to make in order to be able to print this job
+    #  \param build_plate: The build plate (type) this job needs to be printed on.
+    #  \param compatible_machine_families: Family names of machines suitable for this print job
+    #  \param impediments_to_printing: A list of reasons that prevent this job from being printed on the associated
+    #       printer
+    def __init__(self, created_at: str, force: bool, machine_variant: str, name: str, started: bool, status: str,
+                 time_total: int, uuid: str,
+                 configuration: List[Union[Dict[str, Any], CloudClusterPrintCoreConfiguration]],
+                 constraints: List[Union[Dict[str, Any], CloudClusterPrintJobConstraints]],
+                 last_seen: Optional[float] = None, network_error_count: Optional[int] = None,
+                 owner: Optional[str] = None, printer_uuid: Optional[str] = None, time_elapsed: Optional[int] = None,
+                 assigned_to: Optional[str] = None, deleted_at: Optional[str] = None,
+                 printed_on_uuid: Optional[str] = None,
+                 configuration_changes_required: List[
+                     Union[Dict[str, Any], CloudClusterPrintJobConfigurationChange]] = None,
+                 build_plate: Union[Dict[str, Any], CloudClusterBuildPlate] = None,
+                 compatible_machine_families: List[str] = None,
+                 impediments_to_printing: List[Union[Dict[str, Any], CloudClusterPrintJobImpediment]] = None,
+                 **kwargs) -> None:
+        self.assigned_to = assigned_to
+        self.configuration = self.parseModels(CloudClusterPrintCoreConfiguration, configuration)
+        self.constraints = self.parseModels(CloudClusterPrintJobConstraints, constraints)
+        self.created_at = created_at
+        self.force = force
+        self.last_seen = last_seen
+        self.machine_variant = machine_variant
+        self.name = name
+        self.network_error_count = network_error_count
+        self.owner = owner
+        self.printer_uuid = printer_uuid
+        self.started = started
+        self.status = status
+        self.time_elapsed = time_elapsed
+        self.time_total = time_total
+        self.uuid = uuid
+        self.deleted_at = deleted_at
+        self.printed_on_uuid = printed_on_uuid
+
+        self.configuration_changes_required = self.parseModels(CloudClusterPrintJobConfigurationChange,
+                                                               configuration_changes_required) \
+            if configuration_changes_required else []
+        self.build_plate = self.parseModel(CloudClusterBuildPlate, build_plate) if build_plate else None
+        self.compatible_machine_families = compatible_machine_families if compatible_machine_families else []
+        self.impediments_to_printing = self.parseModels(CloudClusterPrintJobImpediment, impediments_to_printing) \
+            if impediments_to_printing else []
+
+        super().__init__(**kwargs)
+
+    ## Creates an UM3 print job output model based on this cloud cluster print job.
+    #  \param printer: The output model of the printer
+    def createOutputModel(self, controller: CloudOutputController) -> UM3PrintJobOutputModel:
+        model = UM3PrintJobOutputModel(controller, self.uuid, self.name)
+        self.updateOutputModel(model)
+        return model
+
+    ## Creates a new configuration model
+    def _createConfigurationModel(self) -> PrinterConfigurationModel:
+        extruders = [extruder.createConfigurationModel() for extruder in self.configuration or ()]
+        configuration = PrinterConfigurationModel()
+        configuration.setExtruderConfigurations(extruders)
+        return configuration
+
+    ## Updates an UM3 print job output model based on this cloud cluster print job.
+    #  \param model: The model to update.
+    def updateOutputModel(self, model: UM3PrintJobOutputModel) -> None:
+        model.updateConfiguration(self._createConfigurationModel())
+        model.updateTimeTotal(self.time_total)
+        model.updateTimeElapsed(self.time_elapsed)
+        model.updateOwner(self.owner)
+        model.updateState(self.status)
+        model.setCompatibleMachineFamilies(self.compatible_machine_families)
+        model.updateTimeTotal(self.time_total)
+        model.updateTimeElapsed(self.time_elapsed)
+        model.updateOwner(self.owner)
+
+        status_set_by_impediment = False
+        for impediment in self.impediments_to_printing:
+            # TODO: impediment.severity is defined as int, this will not work, is there a translation?
+            if impediment.severity == "UNFIXABLE":
+                status_set_by_impediment = True
+                model.updateState("error")
+                break
+
+        if not status_set_by_impediment:
+            model.updateState(self.status)
+
+        model.updateConfigurationChanges(
+            [ConfigurationChangeModel(
+                type_of_change = change.type_of_change,
+                index = change.index if change.index else 0,
+                target_name = change.target_name if change.target_name else "",
+                origin_name = change.origin_name if change.origin_name else "")
+                for change in self.configuration_changes_required])

plugins/UM3NetworkPrinting/src/Models/CloudClusterPrinterConfigurationMaterial.py

@@ -0,0 +1,55 @@
+from typing import Optional
+
+from UM.Logger import Logger
+from cura.CuraApplication import CuraApplication
+from cura.PrinterOutput.Models.MaterialOutputModel import MaterialOutputModel
+from .BaseCloudModel import BaseCloudModel
+
+
+##  Class representing a cloud cluster printer configuration
+#  Spec: https://api-staging.ultimaker.com/connect/v1/spec
+class CloudClusterPrinterConfigurationMaterial(BaseCloudModel):
+    ## Creates a new material configuration model.
+    #  \param brand: The brand of material in this print core, e.g. 'Ultimaker'.
+    #  \param color: The color of material in this print core, e.g. 'Blue'.
+    #  \param guid: he GUID of the material in this print core, e.g. '506c9f0d-e3aa-4bd4-b2d2-23e2425b1aa9'.
+    #  \param material: The type of material in this print core, e.g. 'PLA'.
+    def __init__(self, brand: Optional[str] = None, color: Optional[str] = None, guid: Optional[str] = None,
+                 material: Optional[str] = None, **kwargs) -> None:
+        self.guid = guid
+        self.brand = brand
+        self.color = color
+        self.material = material
+        super().__init__(**kwargs)
+
+    ## Creates a material output model based on this cloud printer material.
+    def createOutputModel(self) -> MaterialOutputModel:
+        material_manager = CuraApplication.getInstance().getMaterialManager()
+        material_group_list = material_manager.getMaterialGroupListByGUID(self.guid) or []
+
+        # Sort the material groups by "is_read_only = True" first, and then the name alphabetically.
+        read_only_material_group_list = list(filter(lambda x: x.is_read_only, material_group_list))
+        non_read_only_material_group_list = list(filter(lambda x: not x.is_read_only, material_group_list))
+        material_group = None
+        if read_only_material_group_list:
+            read_only_material_group_list = sorted(read_only_material_group_list, key = lambda x: x.name)
+            material_group = read_only_material_group_list[0]
+        elif non_read_only_material_group_list:
+            non_read_only_material_group_list = sorted(non_read_only_material_group_list, key = lambda x: x.name)
+            material_group = non_read_only_material_group_list[0]
+
+        if material_group:
+            container = material_group.root_material_node.getContainer()
+            color = container.getMetaDataEntry("color_code")
+            brand = container.getMetaDataEntry("brand")
+            material_type = container.getMetaDataEntry("material")
+            name = container.getName()
+        else:
+            Logger.log("w", "Unable to find material with guid {guid}. Using data as provided by cluster"
+                       .format(guid = self.guid))
+            color = self.color
+            brand = self.brand
+            material_type = self.material
+            name = "Empty" if self.material == "empty" else "Unknown"
+
+        return MaterialOutputModel(guid = self.guid, type = material_type, brand = brand, color = color, name = name)

plugins/UM3NetworkPrinting/src/Models/CloudClusterPrinterStatus.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from typing import List, Union, Dict, Optional, Any
+
+from cura.PrinterOutput.PrinterOutputController import PrinterOutputController
+from cura.PrinterOutput.Models.PrinterOutputModel import PrinterOutputModel
+from .CloudClusterBuildPlate import CloudClusterBuildPlate
+from .CloudClusterPrintCoreConfiguration import CloudClusterPrintCoreConfiguration
+from .BaseCloudModel import BaseCloudModel
+
+
+##  Class representing a cluster printer
+#  Spec: https://api-staging.ultimaker.com/connect/v1/spec
+class CloudClusterPrinterStatus(BaseCloudModel):
+    ## Creates a new cluster printer status
+    #  \param enabled: A printer can be disabled if it should not receive new jobs. By default every printer is enabled.
+    #  \param firmware_version: Firmware version installed on the printer. Can differ for each printer in a cluster.
+    #  \param friendly_name: Human readable name of the printer. Can be used for identification purposes.
+    #  \param ip_address: The IP address of the printer in the local network.
+    #  \param machine_variant: The type of printer. Can be 'Ultimaker 3' or 'Ultimaker 3ext'.
+    #  \param status: The status of the printer.
+    #  \param unique_name: The unique name of the printer in the network.
+    #  \param uuid: The unique ID of the printer, also known as GUID.
+    #  \param configuration: The active print core configurations of this printer.
+    #  \param reserved_by: A printer can be claimed by a specific print job.
+    #  \param maintenance_required: Indicates if maintenance is necessary
+    #  \param firmware_update_status: Whether the printer's firmware is up-to-date, value is one of: "up_to_date",
+    #         "pending_update", "update_available", "update_in_progress", "update_failed", "update_impossible"
+    #  \param latest_available_firmware: The version of the latest firmware that is available
+    #  \param build_plate: The build plate that is on the printer
+    def __init__(self, enabled: bool, firmware_version: str, friendly_name: str, ip_address: str, machine_variant: str,
+                 status: str, unique_name: str, uuid: str,
+                 configuration: List[Union[Dict[str, Any], CloudClusterPrintCoreConfiguration]],
+                 reserved_by: Optional[str] = None, maintenance_required: Optional[bool] = None,
+                 firmware_update_status: Optional[str] = None, latest_available_firmware: Optional[str] = None,
+                 build_plate: Union[Dict[str, Any], CloudClusterBuildPlate] = None, **kwargs) -> None:
+
+        self.configuration = self.parseModels(CloudClusterPrintCoreConfiguration, configuration)
+        self.enabled = enabled
+        self.firmware_version = firmware_version
+        self.friendly_name = friendly_name
+        self.ip_address = ip_address
+        self.machine_variant = machine_variant
+        self.status = status
+        self.unique_name = unique_name
+        self.uuid = uuid
+        self.reserved_by = reserved_by
+        self.maintenance_required = maintenance_required
+        self.firmware_update_status = firmware_update_status
+        self.latest_available_firmware = latest_available_firmware
+        self.build_plate = self.parseModel(CloudClusterBuildPlate, build_plate) if build_plate else None
+        super().__init__(**kwargs)
+
+    ## Creates a new output model.
+    #  \param controller - The controller of the model.
+    def createOutputModel(self, controller: PrinterOutputController) -> PrinterOutputModel:
+        model = PrinterOutputModel(controller, len(self.configuration), firmware_version = self.firmware_version)
+        self.updateOutputModel(model)
+        return model
+
+    ## Updates the given output model.
+    #  \param model - The output model to update.
+    def updateOutputModel(self, model: PrinterOutputModel) -> None:
+        model.updateKey(self.uuid)
+        model.updateName(self.friendly_name)
+        model.updateType(self.machine_variant)
+        model.updateState(self.status if self.enabled else "disabled")
+        model.updateBuildplate(self.build_plate.type if self.build_plate else "glass")
+
+        for configuration, extruder_output, extruder_config in \
+                zip(self.configuration, model.extruders, model.printerConfiguration.extruderConfigurations):
+            configuration.updateOutputModel(extruder_output)
+            configuration.updateConfigurationModel(extruder_config)

plugins/UM3NetworkPrinting/src/Models/CloudClusterResponse.py

@@ -0,0 +1,39 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from typing import Optional
+
+from .BaseCloudModel import BaseCloudModel
+
+
+##  Class representing a cloud connected cluster.
+#  Spec: https://api-staging.ultimaker.com/connect/v1/spec
+class CloudClusterResponse(BaseCloudModel):
+    ## Creates a new cluster response object.
+    #  \param cluster_id: The secret unique ID, e.g. 'kBEeZWEifXbrXviO8mRYLx45P8k5lHVGs43XKvRniPg='.
+    #  \param host_guid: The unique identifier of the print cluster host, e.g. 'e90ae0ac-1257-4403-91ee-a44c9b7e8050'.
+    #  \param host_name: The name of the printer as configured during the Wi-Fi setup. Used as identifier for end users.
+    #  \param is_online: Whether this cluster is currently connected to the cloud.
+    #  \param status: The status of the cluster authentication (active or inactive).
+    #  \param host_version: The firmware version of the cluster host. This is where the Stardust client is running on.
+    #  \param host_internal_ip: The internal IP address of the host printer.
+    #  \param friendly_name: The human readable name of the host printer.
+    #  \param printer_type: The machine type of the host printer.
+    def __init__(self, cluster_id: str, host_guid: str, host_name: str, is_online: bool, status: str,
+                 host_internal_ip: Optional[str] = None, host_version: Optional[str] = None,
+                 friendly_name: Optional[str] = None, printer_type: str = "ultimaker3", **kwargs) -> None:
+        self.cluster_id = cluster_id
+        self.host_guid = host_guid
+        self.host_name = host_name
+        self.status = status
+        self.is_online = is_online
+        self.host_version = host_version
+        self.host_internal_ip = host_internal_ip
+        self.friendly_name = friendly_name
+        self.printer_type = printer_type
+        super().__init__(**kwargs)
+
+    # Validates the model, raising an exception if the model is invalid.
+    def validate(self) -> None:
+        super().validate()
+        if not self.cluster_id:
+            raise ValueError("cluster_id is required on CloudCluster")

plugins/UM3NetworkPrinting/src/Models/CloudClusterStatus.py

@@ -0,0 +1,26 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from datetime import datetime
+from typing import List, Dict, Union, Any
+
+from .CloudClusterPrinterStatus import CloudClusterPrinterStatus
+from .CloudClusterPrintJobStatus import CloudClusterPrintJobStatus
+from .BaseCloudModel import BaseCloudModel
+
+
+# Model that represents the status of the cluster for the cloud
+#  Spec: https://api-staging.ultimaker.com/connect/v1/spec
+class CloudClusterStatus(BaseCloudModel):
+    ## Creates a new cluster status model object.
+    #  \param printers: The latest status of each printer in the cluster.
+    #  \param print_jobs: The latest status of each print job in the cluster.
+    #  \param generated_time: The datetime when the object was generated on the server-side.
+    def __init__(self,
+                 printers: List[Union[CloudClusterPrinterStatus, Dict[str, Any]]],
+                 print_jobs: List[Union[CloudClusterPrintJobStatus, Dict[str, Any]]],
+                 generated_time: Union[str, datetime],
+                 **kwargs) -> None:
+        self.generated_time = self.parseDate(generated_time)
+        self.printers = self.parseModels(CloudClusterPrinterStatus, printers)
+        self.print_jobs = self.parseModels(CloudClusterPrintJobStatus, print_jobs)
+        super().__init__(**kwargs)

plugins/UM3NetworkPrinting/src/Models/CloudError.py

@@ -0,0 +1,28 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from typing import Dict, Optional, Any
+
+from .BaseCloudModel import BaseCloudModel
+
+
+## Class representing errors generated by the cloud servers, according to the JSON-API standard.
+#  Spec: https://api-staging.ultimaker.com/connect/v1/spec
+class CloudError(BaseCloudModel):
+    ## Creates a new error object.
+    #  \param id: Unique identifier for this particular occurrence of the problem.
+    #  \param title: A short, human-readable summary of the problem that SHOULD NOT change from occurrence to occurrence
+    #       of the problem, except for purposes of localization.
+    #  \param code: An application-specific error code, expressed as a string value.
+    #  \param detail: A human-readable explanation specific to this occurrence of the problem. Like title, this field's
+    #       value can be localized.
+    #  \param http_status: The HTTP status code applicable to this problem, converted to string.
+    #  \param meta: Non-standard meta-information about the error, depending on the error code.
+    def __init__(self, id: str, code: str, title: str, http_status: str, detail: Optional[str] = None,
+                 meta: Optional[Dict[str, Any]] = None, **kwargs) -> None:
+        self.id = id
+        self.code = code
+        self.http_status = http_status
+        self.title = title
+        self.detail = detail
+        self.meta = meta
+        super().__init__(**kwargs)

plugins/UM3NetworkPrinting/src/Models/CloudPrintJobResponse.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from typing import Optional
+
+from .BaseCloudModel import BaseCloudModel
+
+
+# Model that represents the response received from the cloud after requesting to upload a print job
+#  Spec: https://api-staging.ultimaker.com/cura/v1/spec
+class CloudPrintJobResponse(BaseCloudModel):
+    ## Creates a new print job response model.
+    #  \param job_id: The job unique ID, e.g. 'kBEeZWEifXbrXviO8mRYLx45P8k5lHVGs43XKvRniPg='.
+    #  \param status: The status of the print job.
+    #  \param status_description: Contains more details about the status, e.g. the cause of failures.
+    #  \param download_url: A signed URL to download the resulting status. Only available when the job is finished.
+    #  \param job_name: The name of the print job.
+    #  \param slicing_details: Model for slice information.
+    #  \param upload_url: The one-time use URL where the toolpath must be uploaded to (only if status is uploading).
+    #  \param content_type: The content type of the print job (e.g. text/plain or application/gzip)
+    #  \param generated_time: The datetime when the object was generated on the server-side.
+    def __init__(self, job_id: str, status: str, download_url: Optional[str] = None, job_name: Optional[str] = None,
+                 upload_url: Optional[str] = None, content_type: Optional[str] = None,
+                 status_description: Optional[str] = None, slicing_details: Optional[dict] = None, **kwargs) -> None:
+        self.job_id = job_id
+        self.status = status
+        self.download_url = download_url
+        self.job_name = job_name
+        self.upload_url = upload_url
+        self.content_type = content_type
+        self.status_description = status_description
+        # TODO: Implement slicing details
+        self.slicing_details = slicing_details
+        super().__init__(**kwargs)

plugins/UM3NetworkPrinting/src/Models/CloudPrintJobUploadRequest.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from .BaseCloudModel import BaseCloudModel
+
+
+# Model that represents the request to upload a print job to the cloud
+#  Spec: https://api-staging.ultimaker.com/cura/v1/spec
+class CloudPrintJobUploadRequest(BaseCloudModel):
+    ## Creates a new print job upload request.
+    #  \param job_name: The name of the print job.
+    #  \param file_size: The size of the file in bytes.
+    #  \param content_type: The content type of the print job (e.g. text/plain or application/gzip)
+    def __init__(self, job_name: str, file_size: int, content_type: str, **kwargs) -> None:
+        self.job_name = job_name
+        self.file_size = file_size
+        self.content_type = content_type
+        super().__init__(**kwargs)

plugins/UM3NetworkPrinting/src/Models/CloudPrintResponse.py

@@ -0,0 +1,23 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from datetime import datetime
+from typing import Optional, Union
+
+from .BaseCloudModel import BaseCloudModel
+
+
+# Model that represents the responses received from the cloud after requesting a job to be printed.
+#  Spec: https://api-staging.ultimaker.com/connect/v1/spec
+class CloudPrintResponse(BaseCloudModel):
+    ## Creates a new print response object.
+    #  \param job_id: The unique ID of a print job inside of the cluster. This ID is generated by Cura Connect.
+    #  \param status: The status of the print request (queued or failed).
+    #  \param generated_time: The datetime when the object was generated on the server-side.
+    #  \param cluster_job_id: The unique ID of a print job inside of the cluster. This ID is generated by Cura Connect.
+    def __init__(self, job_id: str, status: str, generated_time: Union[str, datetime],
+                 cluster_job_id: Optional[str] = None, **kwargs) -> None:
+        self.job_id = job_id
+        self.status = status
+        self.cluster_job_id = cluster_job_id
+        self.generated_time = self.parseDate(generated_time)
+        super().__init__(**kwargs)

plugins/UM3NetworkPrinting/src/Models/ClusterMaterial.py

@@ -0,0 +1,15 @@
+##  Class representing a material that was fetched from the cluster API.
+from plugins.UM3NetworkPrinting.src.Models.BaseModel import BaseModel
+
+
+class ClusterMaterial(BaseModel):
+    def __init__(self, guid: str, version: int, **kwargs) -> None:
+        self.guid = guid  # type: str
+        self.version = version  # type: int
+        super().__init__(**kwargs)
+
+    def validate(self) -> None:
+        if not self.guid:
+            raise ValueError("guid is required on ClusterMaterial")
+        if not self.version:
+            raise ValueError("version is required on ClusterMaterial")

plugins/UM3NetworkPrinting/src/Models/ConfigurationChangeModel.py

@@ -0,0 +1,39 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from PyQt5.QtCore import pyqtProperty, QObject
+
+BLOCKING_CHANGE_TYPES = [
+    "material_insert", "buildplate_change"
+]
+
+
+class ConfigurationChangeModel(QObject):
+    def __init__(self, type_of_change: str, index: int, target_name: str, origin_name: str) -> None:
+        super().__init__()
+        self._type_of_change = type_of_change
+                                    # enum = ["material", "print_core_change"]
+        self._can_override = self._type_of_change not in BLOCKING_CHANGE_TYPES
+        self._index = index
+        self._target_name = target_name
+        self._origin_name = origin_name
+
+    @pyqtProperty(int, constant = True)
+    def index(self) -> int:
+        return self._index
+
+    @pyqtProperty(str, constant = True)
+    def typeOfChange(self) -> str:
+        return self._type_of_change
+
+    @pyqtProperty(str, constant = True)
+    def targetName(self) -> str:
+        return self._target_name
+
+    @pyqtProperty(str, constant = True)
+    def originName(self) -> str:
+        return self._origin_name
+
+    @pyqtProperty(bool, constant = True)
+    def canOverride(self) -> bool:
+        return self._can_override

plugins/UM3NetworkPrinting/src/Models/LocalMaterial.py

@@ -0,0 +1,20 @@
+##  Class representing a local material that was fetched from the container registry.
+from plugins.UM3NetworkPrinting.src.Models.BaseModel import BaseModel
+
+
+class LocalMaterial(BaseModel):
+    def __init__(self, GUID: str, id: str, version: int, **kwargs) -> None:
+        self.GUID = GUID  # type: str
+        self.id = id  # type: str
+        self.version = version  # type: int
+        super().__init__(**kwargs)
+
+    #
+    def validate(self) -> None:
+        super().validate()
+        if not self.GUID:
+            raise ValueError("guid is required on LocalMaterial")
+        if not self.version:
+            raise ValueError("version is required on LocalMaterial")
+        if not self.id:
+            raise ValueError("id is required on LocalMaterial")

plugins/UM3NetworkPrinting/src/Models/UM3PrintJobOutputModel.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+from typing import List
+
+from PyQt5.QtCore import pyqtProperty, pyqtSignal
+
+from cura.PrinterOutput.Models.PrintJobOutputModel import PrintJobOutputModel
+from cura.PrinterOutput.PrinterOutputController import PrinterOutputController
+from plugins.UM3NetworkPrinting.src.Models.ConfigurationChangeModel import ConfigurationChangeModel
+
+
+class UM3PrintJobOutputModel(PrintJobOutputModel):
+    configurationChangesChanged = pyqtSignal()
+
+    def __init__(self, output_controller: "PrinterOutputController", key: str = "", name: str = "", parent=None) -> None:
+        super().__init__(output_controller, key, name, parent)
+        self._configuration_changes = []    # type: List[ConfigurationChangeModel]
+
+    @pyqtProperty("QVariantList", notify=configurationChangesChanged)
+    def configurationChanges(self) -> List[ConfigurationChangeModel]:
+        return self._configuration_changes
+
+    def updateConfigurationChanges(self, changes: List[ConfigurationChangeModel]) -> None:
+        if len(self._configuration_changes) == 0 and len(changes) == 0:
+            return
+        self._configuration_changes = changes
+        self.configurationChangesChanged.emit()