3D-printing/Cura
1
0
Fork 0
mirror of https://github.com/Ultimaker/Cura.git synced 2025-07-06 14:37:29 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Add typing in WorkspaceDialog.py

Browse source 
In response to feedback comment https://github.com/Ultimaker/Cura/pull/8142#discussion_r464309170

CURA-7609
This commit is contained in:
Kostas Karmas 2020-08-03 17:31:21 +02:00
parent 6c59616e39
commit 9ad046654a
1 changed files with 57 additions and 54 deletions
Download patch file Download diff file Expand all files Collapse all files

111
plugins/3MFReader/WorkspaceDialog.py
View file

@ -1,5 +1,6 @@
# Copyright (c) 2016 Ultimaker B.V.
# Cura is released under the terms of the LGPLv3 or higher.
from typing import List, Optional, Dict
from PyQt5.QtCore import pyqtSignal, QObject, pyqtProperty, QCoreApplication
from UM.FlameProfiler import pyqtSlot
@ -65,7 +66,7 @@ class WorkspaceDialog(QObject):
qualityTypeChanged = pyqtSignal()
intentNameChanged = pyqtSignal()
machineNameChanged = pyqtSignal()
updatableMachinesChanged = pyqtSignal()
updatableMachineNamesChanged = pyqtSignal()
materialLabelsChanged = pyqtSignal()
objectsOnPlateChanged = pyqtSignal()
numUserSettingsChanged = pyqtSignal()
@ -84,33 +85,33 @@ class WorkspaceDialog(QObject):
self.isPrinterGroupChanged.emit()
@pyqtProperty(str, notify=variantTypeChanged)
def variantType(self):
def variantType(self) -> str:
return self._variant_type
def setVariantType(self, variant_type):
def setVariantType(self, variant_type: str) -> None:
if self._variant_type != variant_type:
self._variant_type = variant_type
self.variantTypeChanged.emit()
@pyqtProperty(str, notify=machineTypeChanged)
def machineType(self):
def machineType(self) -> str:
return self._machine_type
def setMachineType(self, machine_type):
def setMachineType(self, machine_type: str) -> None:
self._machine_type = machine_type
self.machineTypeChanged.emit()
def setNumUserSettings(self, num_user_settings):
def setNumUserSettings(self, num_user_settings: int) -> None:
if self._num_user_settings != num_user_settings:
self._num_user_settings = num_user_settings
self.numVisibleSettingsChanged.emit()
@pyqtProperty(int, notify=numUserSettingsChanged)
def numUserSettings(self):
def numUserSettings(self) -> int:
return self._num_user_settings
@pyqtProperty(bool, notify=objectsOnPlateChanged)
def hasObjectsOnPlate(self):
def hasObjectsOnPlate(self) -> bool:
return self._objects_on_plate
def setHasObjectsOnPlate(self, objects_on_plate):
@ -119,10 +120,10 @@ class WorkspaceDialog(QObject):
self.objectsOnPlateChanged.emit()
@pyqtProperty("QVariantList", notify = materialLabelsChanged)
def materialLabels(self):
def materialLabels(self) -> List[str]:
return self._material_labels
def setMaterialLabels(self, material_labels):
def setMaterialLabels(self, material_labels: List[str]) -> None:
if self._material_labels != material_labels:
self._material_labels = material_labels
self.materialLabelsChanged.emit()
@ -137,49 +138,49 @@ class WorkspaceDialog(QObject):
self.extrudersChanged.emit()
@pyqtProperty(str, notify = machineNameChanged)
def machineName(self):
def machineName(self) -> str:
return self._machine_name
def setMachineName(self, machine_name):
def setMachineName(self, machine_name: str) -> None:
if self._machine_name != machine_name:
self._machine_name = machine_name
self.machineNameChanged.emit()
@pyqtProperty("QVariantList", notify = updatableMachinesChanged)
def updatableMachines(self):
@pyqtProperty("QVariantList", notify = updatableMachineNamesChanged)
def updatableMachineNames(self) -> List[str]:
return self._updatable_machines
def setUpdatableMachines(self, updatable_machines):
def setUpdatableMachineNames(self, updatable_machines: List[str]) -> None:
if self._updatable_machines != updatable_machines:
self._updatable_machines = sorted(updatable_machines)
self.updatableMachinesChanged.emit()
self.updatableMachineNamesChanged.emit()
@pyqtProperty(int, notify = updatableMachinesChanged)
def updatableMachinesCount(self):
@pyqtProperty(int, notify = updatableMachineNamesChanged)
def updatableMachineNamesCount(self) -> int:
return len(self._updatable_machines)
@pyqtProperty(str, notify=qualityTypeChanged)
def qualityType(self):
def qualityType(self) -> str:
return self._quality_type
def setQualityType(self, quality_type):
def setQualityType(self, quality_type: str) -> None:
if self._quality_type != quality_type:
self._quality_type = quality_type
self.qualityTypeChanged.emit()
@pyqtProperty(int, notify=numSettingsOverridenByQualityChangesChanged)
def numSettingsOverridenByQualityChanges(self):
def numSettingsOverridenByQualityChanges(self) -> int:
return self._num_settings_overridden_by_quality_changes
def setNumSettingsOverriddenByQualityChanges(self, num_settings_overridden_by_quality_changes):
def setNumSettingsOverriddenByQualityChanges(self, num_settings_overridden_by_quality_changes: int) -> None:
self._num_settings_overridden_by_quality_changes = num_settings_overridden_by_quality_changes
self.numSettingsOverridenByQualityChangesChanged.emit()
@pyqtProperty(str, notify=qualityNameChanged)
def qualityName(self):
def qualityName(self) -> str:
return self._quality_name
def setQualityName(self, quality_name):
def setQualityName(self, quality_name: str) -> None:
if self._quality_name != quality_name:
self._quality_name = quality_name
self.qualityNameChanged.emit()
@ -194,86 +195,86 @@ class WorkspaceDialog(QObject):
self.intentNameChanged.emit()
@pyqtProperty(str, notify=activeModeChanged)
def activeMode(self):
def activeMode(self) -> str:
return self._active_mode
def setActiveMode(self, active_mode):
def setActiveMode(self, active_mode: int) -> None:
if active_mode == 0:
self._active_mode = i18n_catalog.i18nc("@title:tab", "Recommended")
else:
self._active_mode = i18n_catalog.i18nc("@title:tab", "Custom")
self.activeModeChanged.emit()
@pyqtProperty(int, notify = hasVisibleSettingsFieldChanged)
def hasVisibleSettingsField(self):
@pyqtProperty(bool, notify = hasVisibleSettingsFieldChanged)
def hasVisibleSettingsField(self) -> bool:
return self._has_visible_settings_field
def setHasVisibleSettingsField(self, has_visible_settings_field):
def setHasVisibleSettingsField(self, has_visible_settings_field: bool) -> None:
self._has_visible_settings_field = has_visible_settings_field
self.hasVisibleSettingsFieldChanged.emit()
@pyqtProperty(int, constant = True)
def totalNumberOfSettings(self):
def totalNumberOfSettings(self) -> int:
general_definition_containers = ContainerRegistry.getInstance().findDefinitionContainers(id = "fdmprinter")
if not general_definition_containers:
return 0
return len(general_definition_containers[0].getAllKeys())
@pyqtProperty(int, notify = numVisibleSettingsChanged)
def numVisibleSettings(self):
def numVisibleSettings(self) -> int:
return self._num_visible_settings
def setNumVisibleSettings(self, num_visible_settings):
def setNumVisibleSettings(self, num_visible_settings: int) -> None:
if self._num_visible_settings != num_visible_settings:
self._num_visible_settings = num_visible_settings
self.numVisibleSettingsChanged.emit()
@pyqtProperty(bool, notify = machineConflictChanged)
def machineConflict(self):
def machineConflict(self) -> bool:
return self._has_machine_conflict
@pyqtProperty(bool, notify=qualityChangesConflictChanged)
def qualityChangesConflict(self):
def qualityChangesConflict(self) -> bool:
return self._has_quality_changes_conflict
@pyqtProperty(bool, notify=materialConflictChanged)
def materialConflict(self):
def materialConflict(self) -> bool:
return self._has_material_conflict
@pyqtSlot(str, str)
def setResolveStrategy(self, key, strategy):
def setResolveStrategy(self, key: str, strategy: str) -> None:
if key in self._result:
self._result[key] = strategy
def getMachineToOverride(self):
def getMachineToOverride(self) -> str:
return self._override_machine
@pyqtSlot(str)
def setMachineToOverride(self, machine_name):
def setMachineToOverride(self, machine_name: str) -> None:
self._override_machine = machine_name
@pyqtSlot()
def closeBackend(self):
def closeBackend(self) -> None:
"""Close the backend: otherwise one could end up with "Slicing..."""
Application.getInstance().getBackend().close()
def setMaterialConflict(self, material_conflict):
def setMaterialConflict(self, material_conflict: bool) -> None:
if self._has_material_conflict != material_conflict:
self._has_material_conflict = material_conflict
self.materialConflictChanged.emit()
def setMachineConflict(self, machine_conflict):
def setMachineConflict(self, machine_conflict: bool) -> None:
if self._has_machine_conflict != machine_conflict:
self._has_machine_conflict = machine_conflict
self.machineConflictChanged.emit()
def setQualityChangesConflict(self, quality_changes_conflict):
def setQualityChangesConflict(self, quality_changes_conflict: bool) -> None:
if self._has_quality_changes_conflict != quality_changes_conflict:
self._has_quality_changes_conflict = quality_changes_conflict
self.qualityChangesConflictChanged.emit()
def getResult(self):
def getResult(self) -> Dict[str, Optional[str]]:
if "machine" in self._result and not self._updatable_machines:
self._result["machine"] = None
if "quality_changes" in self._result and not self._has_quality_changes_conflict:
@ -290,11 +291,13 @@ class WorkspaceDialog(QObject):
return self._result
def _createViewFromQML(self):
path = os.path.join(PluginRegistry.getInstance().getPluginPath("3MFReader"), self._qml_url)
self._view = Application.getInstance().createQmlComponent(path, {"manager": self})
def _createViewFromQML(self) -> None:
three_mf_reader_path = PluginRegistry.getInstance().getPluginPath("3MFReader")
if three_mf_reader_path:
path = os.path.join(three_mf_reader_path, self._qml_url)
self._view = Application.getInstance().createQmlComponent(path, {"manager": self})
def show(self):
def show(self) -> None:
# Emit signal so the right thread actually shows the view.
if threading.current_thread() != threading.main_thread():
self._lock.acquire()
@ -307,7 +310,7 @@ class WorkspaceDialog(QObject):
self.showDialogSignal.emit()
@pyqtSlot()
def notifyClosed(self):
def notifyClosed(self) -> None:
"""Used to notify the dialog so the lock can be released."""
self._result = {} # The result should be cleared before hide, because after it is released the main thread lock
@ -317,7 +320,7 @@ class WorkspaceDialog(QObject):
except:
pass
def hide(self):
def hide(self) -> None:
self._visible = False
self._view.hide()
try:
@ -326,7 +329,7 @@ class WorkspaceDialog(QObject):
pass
@pyqtSlot(bool)
def _onVisibilityChanged(self, visible):
def _onVisibilityChanged(self, visible: bool) -> None:
if not visible:
try:
self._lock.release()
@ -334,17 +337,17 @@ class WorkspaceDialog(QObject):
pass
@pyqtSlot()
def onOkButtonClicked(self):
def onOkButtonClicked(self) -> None:
self._view.hide()
self.hide()
@pyqtSlot()
def onCancelButtonClicked(self):
def onCancelButtonClicked(self) -> None:
self._result = {}
self._view.hide()
self.hide()
def waitForClose(self):
def waitForClose(self) -> None:
"""Block thread until the dialog is closed."""
if self._visible:
@ -357,7 +360,7 @@ class WorkspaceDialog(QObject):
time.sleep(1 / 50)
QCoreApplication.processEvents() # Ensure that the GUI does not freeze.
def __show(self):
def __show(self) -> None:
if self._view is None:
self._createViewFromQML()
if self._view: