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 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 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)
