def deserialize(self, serialized: str, file_name: Optional[str] = None) -> str: # update the serialized data first serialized = super().deserialize(serialized, file_name) parsed, is_valid = self.readAndValidateSerialized(serialized) # Update properties with the data from the JSON old_id = self.getId( ) #The ID must be set via the constructor. Retain it. self._metadata = parsed["metadata"] self._metadata["id"] = old_id self._metadata["name"] = parsed["name"] self._metadata[ "version"] = self.Version #Guaranteed to be equal to what's in the parsed data by the validation. self._metadata["container_type"] = DefinitionContainer for key, value in parsed["settings"].items(): definition = SettingDefinition(key, self, None, self._i18n_catalog) definition.deserialize(value) self._definitions.append(definition) for definition in self._definitions: self._updateRelations(definition) return serialized
def _onContainerLoadComplete(self, container_id): container = ContainerRegistry.getInstance().findContainers( id=container_id)[0] if not isinstance(container, DefinitionContainer): # skip containers that are not definitions return if container.getMetaDataEntry("type") == "extruder": # skip extruder definitions return material_category = container.findDefinitions(key="material") linear_advance_setting = container.findDefinitions( key=self._setting_key) if material_category and not linear_advance_setting: # this machine doesn't have a Linear Advance setting yet material_category = material_category[0] linear_advance_definition = SettingDefinition( self._setting_key, container, material_category, self._i18n_catalog) linear_advance_definition.deserialize(self._setting_dict) # add the setting to the already existing meterial settingdefinition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff material_category._children.append(linear_advance_definition) container._definition_cache[ self._setting_key] = linear_advance_definition container._updateRelations(linear_advance_definition)
def _onContainerLoadComplete(self, container_id): if not ContainerRegistry.getInstance().isLoaded(container_id): # skip containers that could not be loaded, or subsequent findContainers() will cause an infinite loop return try: container = ContainerRegistry.getInstance().findContainers(id = container_id)[0] except IndexError: # the container no longer exists return if not isinstance(container, DefinitionContainer): # skip containers that are not definitions return if container.getMetaDataEntry("type") == "extruder": # skip extruder definitions return platform_adhesion_category = container.findDefinitions(key="platform_adhesion") fh_setting = container.findDefinitions(key=list(self._settings_dict.keys())[0]) if platform_adhesion_category and not fh_setting: # this machine doesn't have a zoffset setting yet platform_adhesion_category = platform_adhesion_category[0] for setting_key, setting_dict in self._settings_dict.items(): setting_definition = SettingDefinition(setting_key, container, platform_adhesion_category, self._i18n_catalog) setting_definition.deserialize(setting_dict) # add the setting to the already existing platform adhesion settingdefinition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff platform_adhesion_category._children.append(setting_definition) container._definition_cache[setting_key] = setting_definition container._updateRelations(setting_definition)
def _onContainerLoadComplete(self, container_id): if not ContainerRegistry.getInstance().isLoaded(container_id): # skip containers that could not be loaded, or subsequent findContainers() will cause an infinite loop return try: container = ContainerRegistry.getInstance().findContainers(id = container_id)[0] except IndexError: # the container no longer exists return if not isinstance(container, DefinitionContainer): # skip containers that are not definitions return if container.getMetaDataEntry("type") == "extruder": # skip extruder definitions return cooling_category = container.findDefinitions(key="cooling") cooling_chamber_setting = container.findDefinitions(key=list(self._settings_dict.keys())[0]) if cooling_category and not cooling_chamber_setting: # this machine doesn't have a cooling chamber setting yet cooling_category = cooling_category[0] for setting_key, setting_dict in self._settings_dict.items(): definition = SettingDefinition(setting_key, container, cooling_category, self._i18n_catalog) definition.deserialize(setting_dict) cooling_category._children.append(definition) container._definition_cache[setting_key] = definition container._updateRelations(definition)
def benchmark_findDefinitions(benchmark, filter, match_count): definition = SettingDefinition("test", None) definition.deserialize({ "label": "Test", "type": "int", "default_value": 10, "description": "Test Setting", "children": { "test_child_1": { "label": "Test Child 1", "type": "int", "default_value": 20, "description": "Test Child Setting 1" }, "test_child_2": { "label": "Test Child 2", "type": "int", "default_value": 20, "description": "Test Child Setting 2" } } }) result = benchmark(definition.findDefinitions, **filter) assert len(result) == match_count
def _onContainerLoadComplete(self, container_id: str) -> None: if not ContainerRegistry.getInstance().isLoaded(container_id): # skip containers that could not be loaded, or subsequent findContainers() will cause an infinite loop return try: container = ContainerRegistry.getInstance().findContainers(id = container_id)[0] except IndexError: # the container no longer exists return if not isinstance(container, DefinitionContainer): # skip containers that are not definitions return if container.getMetaDataEntry("type") == "extruder": # skip extruder definitions return try: category = container.findDefinitions(key="blackmagic")[0] except IndexError: Logger.log("e", "Could not find parent category setting to add settings to") return for setting_key in self._settings_dict.keys(): setting_definition = SettingDefinition(setting_key, container, category, self._i18n_catalog) setting_definition.deserialize(self._settings_dict[setting_key]) # add the setting to the already existing blackmagic settingdefinition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff category._children.append(setting_definition) container._definition_cache[setting_key] = setting_definition self._expanded_categories = self._application.expandedCategories.copy() self._updateAddedChildren(container, setting_definition) self._application.setExpandedCategories(self._expanded_categories) self._expanded_categories = [] # type: List[str] container._updateRelations(setting_definition) preferences = self._application.getPreferences() if not preferences.getValue("arcwelderplugin/settings_made_visible"): setting_keys = self._getAllSettingKeys(self._settings_dict) visible_settings = preferences.getValue("general/visible_settings") visible_settings_changed = False for key in setting_keys: if key not in visible_settings: visible_settings += ";%s" % key visible_settings_changed = True if visible_settings_changed: preferences.setValue("general/visible_settings", visible_settings) preferences.setValue("arcwelderplugin/settings_made_visible", True)
def create_and_attach_setting(self, container, setting_key, setting_dict, parent): parent_category = container.findDefinitions(key=parent) definition = container.findDefinitions(key=setting_key) if parent_category and not definition: # this machine doesn't have a scalable extra prime setting yet parent_category = parent_category[0] setting_definition = SettingDefinition(setting_key, container, parent_category, self._i18n_catalog) setting_definition.deserialize(setting_dict) parent_category._children.append(setting_definition) container._definition_cache[setting_key] = setting_definition container._updateRelations(setting_definition)
def deserialize(self, serialized): # update the serialized data first serialized = super().deserialize(serialized) parsed = self._readAndValidateSerialized(serialized) # Update properties with the data from the JSON self._name = parsed["name"] self._metadata = parsed["metadata"] for key, value in parsed["settings"].items(): definition = SettingDefinition(key, self, None, self._i18n_catalog) definition.deserialize(value) self._definitions.append(definition) for definition in self._definitions: self._updateRelations(definition)
def _onContainerLoadComplete(self, container_id): if not ContainerRegistry.getInstance().isLoaded(container_id): # skip containers that could not be loaded, or subsequent findContainers() will cause an infinite loop return try: container = ContainerRegistry.getInstance().findContainers(id = container_id)[0] except IndexError: # the container no longer exists return if not isinstance(container, DefinitionContainer): # skip containers that are not definitions return if container.getMetaDataEntry("type") == "extruder": # skip extruder definitions return machine_settings_category = container.findDefinitions(key="machine_settings") printer_settings_category = container.findDefinitions(key=self._category_key) if machine_settings_category and not printer_settings_category: # this machine doesn't have a printer_settings category yet machine_settings_category = machine_settings_category[0] printer_settings_category = SettingDefinition(self._category_key, container, None, self._i18n_catalog) category_dict = self._category_dict category_dict["children"] = OrderedDict() for setting in machine_settings_category.children: if setting.key not in self._hidden_settings: setting_dict = setting.serialize_to_dict() # Some settings values come out of serialize_to_dict with a = prepended, which does not deserialize nicely for key in ["value", "enabled", "minimum_value", "maximum_value", "minimum_value_warning", "maximum_value_warning"]: if key in setting_dict and setting_dict[key][0] == "=": setting_dict[key] = setting_dict[key][1:] # Boolean values are deserialised as string for (key, value) in setting_dict.items(): if value == "True": setting_dict[key] = True if value == "False": setting_dict[key] = False category_dict["children"][setting.key] = setting_dict printer_settings_category.deserialize(category_dict) container.addDefinition(printer_settings_category) container._updateRelations(printer_settings_category)
def _onContainerLoadComplete(self, container_id: str) -> None: if not ContainerRegistry.getInstance().isLoaded(container_id): # skip containers that could not be loaded, or subsequent findContainers() will cause an infinite loop return try: container = ContainerRegistry.getInstance().findContainers( id=container_id)[0] except IndexError: # the container no longer exists return if not isinstance(container, DefinitionContainer): # skip containers that are not definitions return if container.getMetaDataEntry("type") == "extruder": # skip extruder definitions return try: material_category = container.findDefinitions(key="material")[0] except IndexError: Logger.log( "e", "Could not find parent category setting to add settings to") return for setting_key in self._settings_dict.keys(): setting_definition = SettingDefinition(setting_key, container, material_category, self._i18n_catalog) setting_definition.deserialize(self._settings_dict[setting_key]) # add the setting to the already existing material settingdefinition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff material_category._children.append(setting_definition) container._definition_cache[setting_key] = setting_definition self._expanded_categories = self._application.expandedCategories.copy( ) self._updateAddedChildren(container, setting_definition) self._application.setExpandedCategories(self._expanded_categories) self._expanded_categories = [] # type: List[str] container._updateRelations(setting_definition)
def _onContainerLoadComplete(self, container_id): container = ContainerRegistry.getInstance().findContainers( id=container_id)[0] if not isinstance(container, DefinitionContainer): # skip containers that are not definitions return if container.getMetaDataEntry("type") == "extruder": # skip extruder definitions return material_settings_category = container.findDefinitions(key="material") klipper_settings_category = container.findDefinitions( key=self._category_key) if material_settings_category and not klipper_settings_category: # this machine doesn't have a GCODE Offset setting yet material_settings_category = material_settings_category[0] klipper_settings_category = SettingDefinition( self._category_key, container, None, self._i18n_catalog) category_dict = self._category_dict category_dict["children"] = OrderedDict() klipper_gcode_offset_definition = SettingDefinition( self._setting_k_g_offset_key, container, klipper_settings_category, self._i18n_catalog) klipper_gcode_offset_definition.deserialize( self._setting_k_g_offset_dict) klipper_pa_definition = SettingDefinition( self._setting_k_pa_key, container, klipper_settings_category, self._i18n_catalog) klipper_pa_definition.deserialize(self._setting_k_pa_dict) klipper_pa_l_definition = SettingDefinition( self._setting_k_pa_l_key, container, klipper_settings_category, self._i18n_catalog) klipper_pa_l_definition.deserialize(self._setting_k_pa_l_dict) category_dict["children"][ self._setting_k_g_offset_key] = self._setting_k_g_offset_dict category_dict["children"][ self._setting_k_pa_key] = self._setting_k_pa_dict category_dict["children"][ self._setting_k_pa_l_key] = self._setting_k_pa_l_dict klipper_settings_category.deserialize(category_dict) container.addDefinition(klipper_settings_category) container._updateRelations(klipper_settings_category)
def deserialize(self, serialized: str, file_name: Optional[str] = None) -> str: # update the serialized data first serialized = super().deserialize(serialized, file_name) parsed, is_valid = self.readAndValidateSerialized(serialized) # Update properties with the data from the JSON old_id = self.getId() #The ID must be set via the constructor. Retain it. self._metadata = parsed["metadata"] self._metadata["id"] = old_id self._metadata["name"] = parsed["name"] self._metadata["version"] = self.Version #Guaranteed to be equal to what's in the parsed data by the validation. self._metadata["container_type"] = DefinitionContainer for key, value in parsed["settings"].items(): definition = SettingDefinition(key, self, None, self._i18n_catalog) definition.deserialize(value) self._definitions.append(definition) for definition in self._definitions: self._updateRelations(definition) return serialized
def deserialize(self, serialized): parsed = json.loads(serialized, object_pairs_hook=collections.OrderedDict) self._verifyJson(parsed) # Pre-process the JSON data to include inherited data and overrides if "inherits" in parsed: inherited = self._resolveInheritance(parsed["inherits"]) parsed = self._mergeDicts(inherited, parsed) if "overrides" in parsed: for key, value in parsed["overrides"].items(): setting = self._findInDict(parsed["settings"], key) if setting is None: Logger.log("w", "Unable to override setting %s", key) else: setting.update(value) # If we do not have metadata or settings the file is invalid if not "metadata" in parsed: raise InvalidDefinitionError("Missing required metadata section") if not "settings" in parsed: raise InvalidDefinitionError("Missing required settings section") # Update properties with the data from the JSON self._name = parsed["name"] self._metadata = parsed["metadata"] for key, value in parsed["settings"].items(): definition = SettingDefinition(key, self, None, self._i18n_catalog) definition.deserialize(value) self._definitions.append(definition) for definition in self._definitions: self._updateRelations(definition)
def _onContainerLoadComplete(self, container_id): container = ContainerRegistry.getInstance().findContainers( id=container_id)[0] if not isinstance(container, DefinitionContainer): # skip containers that are not definitions return if container.getMetaDataEntry("type") == "extruder": # skip extruder definitions return material_category1 = container.findDefinitions( key="material") # Pressure Advance material_category2 = container.findDefinitions( key="material") # Pressure Advance Lookahead speed_category1 = container.findDefinitions( key="speed") # square corner velocity speed_category4 = container.findDefinitions( key="speed") # acceleration speed_category2 = container.findDefinitions( key="speed") # acceleration to deceleration speed_category3 = container.findDefinitions( key="speed") # acceleration order pressure_advance_setting = container.findDefinitions( key=self._setting_key_klipper_pressure_advance) pressure_advance_lookahead_setting = container.findDefinitions( key=self._setting_key_klipper_pressure_advance_lookahead) square_corner_velocity_setting = container.findDefinitions( key=self._setting_key_square_corner_velocity) acceleration_setting = container.findDefinitions( key=self._setting_key_klipper_acceleration) acceleration_to_deceleration_setting = container.findDefinitions( key=self._setting_key_klipper_acceleration_to_deceleration) acceleration_order_setting = container.findDefinitions( key=self._setting_key_klipper_acceleration_order) # Pressure Advance Lookahead if material_category2 and not pressure_advance_lookahead_setting: # this machine doesn't have a Pressure Advance setting yet material_category2 = material_category2[0] pressure_advance_lookahead_definition = SettingDefinition( self._setting_key_klipper_pressure_advance_lookahead, container, material_category2, self._i18n_catalog) pressure_advance_lookahead_definition.deserialize( self._setting_dict_klipper_pressure_advance_lookahead) # add the setting to the already existing PA setting definition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff material_category2._children.append( pressure_advance_lookahead_definition) container._definition_cache[ self. _setting_key_klipper_pressure_advance_lookahead] = pressure_advance_lookahead_definition container._updateRelations(pressure_advance_lookahead_definition) # Pressure Advance if material_category1 and not pressure_advance_setting: # this machine doesn't have a Pressure Advance setting yet material_category1 = material_category1[0] pressure_advance_definition = SettingDefinition( self._setting_key_klipper_pressure_advance, container, material_category1, self._i18n_catalog) pressure_advance_definition.deserialize( self._setting_dict_klipper_pressure_advance) # add the setting to the already existing PA setting definition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff material_category1._children.append(pressure_advance_definition) container._definition_cache[ self. _setting_key_klipper_pressure_advance] = pressure_advance_definition container._updateRelations(pressure_advance_definition) # Square Corner Velocity if speed_category1 and not square_corner_velocity_setting: # this machine doesn't have a Square Corner Velocity setting yet speed_category1 = speed_category1[0] square_corner_velocity_definition = SettingDefinition( self._setting_key_square_corner_velocity, container, speed_category1, self._i18n_catalog) square_corner_velocity_definition.deserialize( self._setting_dict_square_corner_velocity) # add the setting to the already existing speed settingdefinition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff speed_category1._children.append(square_corner_velocity_definition) container._definition_cache[ self. _setting_key_square_corner_velocity] = square_corner_velocity_definition container._updateRelations(square_corner_velocity_definition) # Acceleration if speed_category4 and not acceleration_setting: # this machine doesn't have a Acceleration setting yet speed_category4 = speed_category4[0] klipper_acceleration_definition = SettingDefinition( self._setting_key_klipper_acceleration, container, speed_category4, self._i18n_catalog) klipper_acceleration_definition.deserialize( self._setting_dict_klipper_acceleration) # add the setting to the already existing speed settingdefinition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff speed_category4._children.append(klipper_acceleration_definition) container._definition_cache[ self. _setting_key_klipper_acceleration] = klipper_acceleration_definition container._updateRelations(klipper_acceleration_definition) # Acceleration to Deceleration if speed_category2 and not acceleration_to_deceleration_setting: # this machine doesn't have a Acceleration to deceleration setting yet speed_category2 = speed_category2[0] klipper_acceleration_to_deceleration_definition = SettingDefinition( self._setting_key_klipper_acceleration_to_deceleration, container, speed_category2, self._i18n_catalog) klipper_acceleration_to_deceleration_definition.deserialize( self._setting_dict_klipper_acceleration_to_deceleration) # add the setting to the already existing speed settingdefinition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff speed_category2._children.append( klipper_acceleration_to_deceleration_definition) container._definition_cache[ self. _setting_key_klipper_acceleration_to_deceleration] = klipper_acceleration_to_deceleration_definition container._updateRelations( klipper_acceleration_to_deceleration_definition) # Acceleration Order if speed_category3 and not acceleration_order_setting: # this machine doesn't have a Acceleration to deceleration setting yet speed_category3 = speed_category3[0] klipper_acceleration_order_definition = SettingDefinition( self._setting_key_klipper_acceleration_order, container, speed_category3, self._i18n_catalog) klipper_acceleration_order_definition.deserialize( self._setting_dict_klipper_acceleration_order) # add the setting to the already existing speed settingdefinition # private member access is naughty, but the alternative is to serialise, nix and deserialise the whole thing, # which breaks stuff speed_category3._children.append( klipper_acceleration_order_definition) container._definition_cache[ self. _setting_key_klipper_acceleration_order] = klipper_acceleration_order_definition container._updateRelations(klipper_acceleration_order_definition)