예제 #1
0
    def loadSettingsFromFile(self, file_name):
        with open(file_name, "rt", -1, "utf-8") as f:
            data = json.load(f, object_pairs_hook=collections.OrderedDict)

        self._i18n_catalog = i18nCatalog(os.path.basename(file_name))

        self._json_file = file_name

        if "id" in data:
            self._type_id = data["id"]

        if "platform" in data:
            self._platform_mesh = data["platform"]

        if "platform_texture" in data:
            self._platform_texture = data["platform_texture"]

        if "name" in data:
            self._type_name = data["name"]

        if "version" in data:
            self._type_version = str(data["version"])

        if "icon" in data:
            self._icon = data["icon"]

        if "inherits" in data:
            inherits_from = MachineSettings()
            inherits_from.loadSettingsFromFile(os.path.dirname(file_name) + "/" + data["inherits"])
            self._machine_settings = inherits_from._machine_settings
            self._categories = inherits_from._categories

        if "machine_settings" in data:
            for key, value in data["machine_settings"].items():
                setting = self.getSettingByKey(key)
                if not setting:
                    setting = Setting(key, self._i18n_catalog)
                    self.addSetting(setting)
                setting.fillByDict(value)

        if "categories" in data:
            for key, value in data["categories"].items():
                category = self.getSettingsCategory(key)
                if not category:
                    category = SettingsCategory(key, self._i18n_catalog, self)
                    self.addSettingsCategory(category)
                category.fillByDict(value)

        if "overrides" in data:
            for key, value in data["overrides"].items():
                setting = self.getSettingByKey(key)
                if not setting:
                    continue

                setting.fillByDict(value)

        for setting in self.getAllSettings():
            setting.valueChanged.connect(self.settingChanged)

        self.settingsLoaded.emit() #Emit signal that all settings are loaded (some setting stuff can only be done when all settings are loaded (eg; the conditional stuff)
예제 #2
0
class SettingTest(unittest.TestCase):
    def setUp(self):
        # Called before the first testfunction is executed
        self._setting = Setting("TestSetting", 10, "int")
        self._machine_settings = MachineSettings()
        category = SettingsCategory("TestCategory")
        #category.addSetting(self._setting)
        self._machine_settings.addSettingsCategory(category)
        self._machine_settings.loadSettingsFromFile(
            "tests/Settings/SettingData.json")

    def tearDown(self):
        # Called after the last testfunction was executed
        pass

    def test_getSettingByKey(self):
        self.assertEqual(
            self._machine_settings.getSettingByKey("TestSetting").getType(),
            self._setting.getType())
        self.assertEqual(
            self._machine_settings.getSettingByKey(
                "TestSetting").getDefaultValue(),
            self._setting.getDefaultValue())
        pass

    def test_category(self):
        pass

    def test_validatorTest(self):
        pass
예제 #3
0
    def test_parseValue(self, setting_type, data, result):
        setting = Setting(self._machine_manager,
                          "test",
                          self._catalog,
                          type=setting_type)

        assert setting.parseValue(data) == result
예제 #4
0
 def setUp(self):
     # Called before the first testfunction is executed
     self._setting = Setting("TestSetting", 10, "int")
     self._machine_settings = MachineSettings()
     category = SettingsCategory("TestCategory")
     #category.addSetting(self._setting)
     self._machine_settings.addSettingsCategory(category)
     self._machine_settings.loadSettingsFromFile(
         "tests/Settings/SettingData.json")
예제 #5
0
    def test_fillByDict(self, data):
        setting = Setting(self._machine_manager, "test", self._catalog)

        setting.fillByDict(data)

        assert setting.getType() == data["type"]
        assert setting.getDefaultValue() == data["default"]
        assert setting.getLabel() == data["label"]
        assert setting.getDescription() == data["description"]
        assert setting.isVisible()
예제 #6
0
    def loadAll(self):
        if self._loaded:
            return

        with open(self._path, "rt", -1, "utf-8") as f:
            self._json_data = json.load(f, object_pairs_hook=collections.OrderedDict)

        if not self._name:
            self.loadMetaData()

        self._i18n_catalog = i18nCatalog(os.path.basename(self._path))

        self._platform_mesh = self._json_data.get("platform", "")
        self._platform_texture = self._json_data.get("platform_texture", "")

        if "inherits" in self._json_data:
            inherits_from = MachineDefinition(self._machine_manager, Resources.getPath(Resources.MachineDefinitions, self._json_data["inherits"]))
            inherits_from.loadAll()

            self._machine_settings = inherits_from._machine_settings
            self._categories = inherits_from._categories

        if "machine_settings" in self._json_data:
            for key, value in self._json_data["machine_settings"].items():
                setting = self.getSetting(key)
                if not setting:
                    setting = Setting(self._machine_manager, key, self._i18n_catalog)
                    self._machine_settings.append(setting)
                setting.fillByDict(value)

        if "categories" in self._json_data:
            for key, value in self._json_data["categories"].items():
                category = self.getSettingsCategory(key)
                if not category:
                    category = SettingsCategory(self._machine_manager, key, self._i18n_catalog, self)
                    self._categories.append(category)
                category.fillByDict(value)

        if "overrides" in self._json_data:
            for key, value in self._json_data["overrides"].items():
                setting = self.getSetting(key)
                if not setting:
                    continue

                setting.fillByDict(value)

        self.settingsLoaded.emit()

        #self._json_data = None
        self._loaded = True
예제 #7
0
    def fillByDict(self, data):
        if "label" in data:
            self._label = self._i18n_catalog.i18nc(
                "{0} label".format(self._key), data["label"])
        if "visible" in data:
            self._visible = data["visible"]
        if "icon" in data:
            self._icon = data["icon"]
        if "settings" in data:
            for key, value in data["settings"].items():
                setting = self.getSetting(key)
                if not setting:
                    if "default" not in value and "type" not in value:
                        Logger.log(
                            "w", "Invalid setting definition for setting %s",
                            key)
                        continue

                    setting = Setting(self._machine_manager,
                                      key,
                                      self._i18n_catalog,
                                      type=value["type"])
                    setting.setCategory(self)
                    setting.setParent(self)
                    self._settings.append(setting)

                setting.fillByDict(value)
                setting.visibleChanged.connect(self._onSettingVisibleChanged)
                setting.defaultValueChanged.connect(self.defaultValueChanged)

        self._onSettingVisibleChanged(None)
예제 #8
0
 def setUp(self):
     # Called before the first testfunction is executed
     self._setting = Setting("TestSetting",10,"int")
     self._machine_settings = MachineSettings()
     category = SettingsCategory("TestCategory")
     #category.addSetting(self._setting)
     self._machine_settings.addSettingsCategory(category)
     self._machine_settings.loadSettingsFromFile("tests/Settings/SettingData.json")
예제 #9
0
    def test_fillByDict(self, data):
        setting = Setting(self._machine_manager, "test", self._catalog)

        setting.fillByDict(data)

        assert setting.getType() == data["type"]
        assert setting.getDefaultValue() == data["default"]
        assert setting.getLabel() == data["label"]
        assert setting.getDescription() == data["description"]
        assert setting.isVisible()
예제 #10
0
    def fillByDict(self, data):
        if "label" in data:
            self._label = self._i18n_catalog.i18nc("{0} label".format(self._key), data["label"])
        if "visible" in data:
            self._visible = data["visible"]
        if "icon" in data:
            self._icon = data["icon"]
        if "settings" in data:
            for key, value in data["settings"].items():
                setting = self.getSetting(key)
                if not setting:
                    if "default" not in value and "type" not in value:
                        Logger.log("w", "Invalid setting definition for setting %s", key)
                        continue

                    setting = Setting(self._machine_manager, key, self._i18n_catalog, type = value["type"])
                    setting.setCategory(self)
                    setting.setParent(self)
                    self._settings.append(setting)

                setting.fillByDict(value)
                setting.visibleChanged.connect(self._onSettingVisibleChanged)
                setting.defaultValueChanged.connect(self.defaultValueChanged)

        self._onSettingVisibleChanged(None)
예제 #11
0
    def test_fillByDict(self):
        setting = Setting(self._machine_manager, "test", self._catalog)

        data = {
            "type": "int",
            "default": 4,
            "label": "Test Setting",
            "description": "A Test Setting",
            "unit": "furlongs per fortnight",
            "visible": True
        }

        setting.fillByDict(data)

        self.assertEqual("int", setting.getType())
        self.assertEqual(4, setting.getDefaultValue())
        self.assertEqual("Test Setting", setting.getLabel())
        self.assertEqual("A Test Setting", setting.getDescription())
        self.assertEqual("furlongs per fortnight", setting.getUnit())
        self.assertTrue(setting.isVisible())
예제 #12
0
    def loadAll(self):
        if self._loaded:
            return

        with open(self._path, "rt", -1, "utf-8") as f:
            self._json_data = json.load(
                f, object_pairs_hook=collections.OrderedDict)

        if not self._name:
            self.loadMetaData()

        self._i18n_catalog = i18nCatalog(os.path.basename(self._path))

        self._platform_mesh = self._json_data.get("platform", "")
        self._platform_texture = self._json_data.get("platform_texture", "")

        if "inherits" in self._json_data:
            inherits_from = MachineDefinition(
                self._machine_manager,
                Resources.getPath(Resources.MachineDefinitions,
                                  self._json_data["inherits"]))
            inherits_from.loadAll()

            self._machine_settings = inherits_from._machine_settings
            self._categories = inherits_from._categories

        if "machine_settings" in self._json_data:
            for key, value in self._json_data["machine_settings"].items():
                setting = self.getSetting(key)
                if not setting:
                    setting = Setting(self._machine_manager, key,
                                      self._i18n_catalog)
                    self._machine_settings.append(setting)
                setting.fillByDict(value)

        if "categories" in self._json_data:
            for key, value in self._json_data["categories"].items():
                category = self.getSettingsCategory(key)
                if not category:
                    category = SettingsCategory(self._machine_manager, key,
                                                self._i18n_catalog, self)
                    self._categories.append(category)
                category.fillByDict(value)

        if "overrides" in self._json_data:
            for key, value in self._json_data["overrides"].items():
                setting = self.getSetting(key)
                if not setting:
                    continue

                setting.fillByDict(value)

        self.settingsLoaded.emit()

        #self._json_data = None
        self._loaded = True
예제 #13
0
    def test_construct(self):
        # Most basic construction, only required arguments.
        setting = Setting(self._machine_manager, "test", self._catalog)

        # This check is mostly to see if the object was constructed properly
        assert isinstance(setting, Setting)
        assert setting.getKey() == "test"

        # Construct with keyword arguments
        setting = Setting(
            self._machine_manager,
            "test",
            self._catalog,
            label="Test Setting",
            type="string",
        )

        assert isinstance(setting, Setting)
        assert setting.getKey() == "test"
        assert setting.getLabel() == "Test Setting"
        assert setting.getType() == "string"
예제 #14
0
    def fillByDict(self, data):
        if "label" in data:
            self._label = self._i18n_catalog.i18nc("{0} label".format(self._key), data["label"])
        if "visible" in data:
            self._visible = data["visible"]
        if "icon" in data:
            self._icon = data["icon"]
        if "settings" in data:
            for key, value in data["settings"].items():
                if "default" in value and "type" in value:
                    temp_setting = Setting(key, self._i18n_catalog, default = value["default"], type = value["type"])
                    temp_setting.setCategory(self)
                    temp_setting.setParent(self)
                    temp_setting.fillByDict(value)
                    temp_setting.visibleChanged.connect(self._onSettingVisibleChanged)
                    self._settings.append(temp_setting)

        self._onSettingVisibleChanged(None)
예제 #15
0
    def test_construct(self):
        # Most basic construction, only required arguments.
        setting = Setting(self._machine_manager, "test", self._catalog)

        # This check is mostly to see if the object was constructed properly
        assert isinstance(setting, Setting)
        assert setting.getKey() == "test"

        # Construct with keyword arguments
        setting = Setting(
            self._machine_manager, "test", self._catalog,
            label = "Test Setting",
            type = "string",
        )

        assert isinstance(setting, Setting)
        assert setting.getKey() == "test"
        assert setting.getLabel() == "Test Setting"
        assert setting.getType() == "string"
예제 #16
0
    def loadAll(self):
        if self._loaded:
            return

        with open(self._path, "rt", -1, "utf-8") as f:
            try:
                self._json_data = json.load(f, object_pairs_hook=collections.OrderedDict)
            except JSONDecodeError as e:
                raise SettingsError.InvalidFileError(self._path) from e

        if not self._name:
            self.loadMetaData()

        self._i18n_catalog = i18nCatalog(os.path.basename(self._path))

        self._platform_mesh = self._json_data.get("platform", "")
        self._platform_texture = self._json_data.get("platform_texture", "")

        if "inherits" in self._json_data:
            try:
                path = Resources.getPath(Resources.MachineDefinitions, self._json_data["inherits"])
            except FileNotFoundError as e:
                # If we cannot find the file in Resources, try and see if it can be found relative to this file.
                # This is primarily used by the unit tests.
                path = os.path.join(os.path.dirname(self._path), self._json_data["inherits"])
                if not os.path.exists(path):
                    raise FileNotFoundError("Could not find file {0} in Resources or next to {1}".format(self._json_data["inherits"], self._path)) from e

            inherits_from = MachineDefinition(self._machine_manager, path)
            inherits_from.loadAll()

            self._machine_settings = inherits_from._machine_settings
            self._categories = inherits_from._categories

        if "machine_settings" in self._json_data:
            for key, value in self._json_data["machine_settings"].items():
                setting = self.getSetting(key)
                if not setting:
                    setting = Setting(self._machine_manager, key, self._i18n_catalog)
                    self._machine_settings.append(setting)
                setting.fillByDict(value)

        if "categories" in self._json_data:
            for key, value in self._json_data["categories"].items():
                category = self.getSettingsCategory(key)
                if not category:
                    category = SettingsCategory(self._machine_manager, key, self._i18n_catalog, self)
                    self._categories.append(category)
                category.fillByDict(value)

        if "overrides" in self._json_data:
            for key, value in self._json_data["overrides"].items():
                setting = self.getSetting(key)
                if not setting:
                    continue

                setting.fillByDict(value)

        self.settingsLoaded.emit()

        #self._json_data = None
        self._loaded = True
예제 #17
0
    def loadSettingsFromFile(self, file_name):
        with open(file_name, "rt", -1, "utf-8") as f:
            data = json.load(f, object_pairs_hook=collections.OrderedDict)

        if "id" not in data or "name" not in data:
            raise SettingsError.InvalidFileError(file_name)

        if "version" not in data or data[
                "version"] != self.MachineDefinitionVersion:
            raise SettingsError.InvalidVersionError(file_name)

        self._i18n_catalog = i18nCatalog(os.path.basename(file_name))

        self._json_file = file_name

        self._type_id = data["id"]
        self._type_name = data["name"]

        if "platform" in data:
            self._platform_mesh = data["platform"]

        if "platform_texture" in data:
            self._platform_texture = data["platform_texture"]

        if "version" in data:
            self._type_version = str(data["version"])

        if "icon" in data:
            self._icon = data["icon"]

        if "inherits" in data:
            inherits_from = MachineSettings()
            inherits_from.loadSettingsFromFile(
                os.path.dirname(file_name) + "/" + data["inherits"])
            self._machine_settings = inherits_from._machine_settings
            self._categories = inherits_from._categories

        if "machine_settings" in data:
            for key, value in data["machine_settings"].items():
                setting = self.getSettingByKey(key)
                if not setting:
                    setting = Setting(key, self._i18n_catalog)
                    self.addSetting(setting)
                setting.fillByDict(value)

        if "categories" in data:
            for key, value in data["categories"].items():
                category = self.getSettingsCategory(key)
                if not category:
                    category = SettingsCategory(key, self._i18n_catalog, self)
                    self.addSettingsCategory(category)
                category.fillByDict(value)

        if "overrides" in data:
            for key, value in data["overrides"].items():
                setting = self.getSettingByKey(key)
                if not setting:
                    continue

                setting.fillByDict(value)

        for setting in self.getAllSettings():
            setting.valueChanged.connect(self.settingChanged)

        self.settingsLoaded.emit(
        )  #Emit signal that all settings are loaded (some setting stuff can only be done when all settings are loaded (eg; the conditional stuff)
예제 #18
0
    def test_fillByDictWithChildren(self):
        setting = Setting(self._machine_manager, "test", self._catalog)

        data = {
            "type":
            "int",
            "default":
            4,
            "label":
            "Test Setting",
            "description":
            "A Test Setting",
            "unit":
            "furlongs per fortnight",
            "visible":
            True,

            # Since python's dict is unordered but we want an ordered dict we
            # have to go through a bit of magic to make sure we define it as an
            # ordered dict.
            "children":
            collections.OrderedDict(
                sorted({
                    "test_child1": {
                        "type": "int",
                        "default": 9,
                        "label": "Test Child 1",
                        "description": "Test Setting Child 1",
                    },
                    "test_child2": {
                        "type": "int",
                        "default": 5,
                        "label": "Test Child 2",
                        "description": "Test Setting Child 2",
                        "inherit": False
                    },
                    "test_child3": {
                        "type": "int",
                        "default": 99,
                        "label": "Test Child 3",
                        "description": "Test Setting Child 3",
                        "inherit_function": "parent_value * 10"
                    }
                }.items(),
                       key=lambda k: k[0]))
        }

        setting.fillByDict(data)

        profile = Profile(setting)

        assert len(setting.getChildren()) == 3

        child1 = setting.getChildren()[0]
        child2 = setting.getChildren()[1]
        child3 = setting.getChildren()[2]

        # Children should keep the order in which they were defined
        assert child1.getKey() == "test_child1"
        assert child2.getKey() == "test_child2"
        assert child3.getKey() == "test_child3"

        # All children should have "setting" as their parent.
        assert child1.getParent() == setting
        assert child2.getParent() == setting
        assert child3.getParent() == setting

        # Child visibility should not affect parent visibility.
        assert setting.isVisible()

        # Child 1 uses default inheritance so should inherit its parent value
        assert child1.getDefaultValue(profile) == 4

        # Child 2 does not inherit so should return its default value
        assert child2.getDefaultValue(profile) == 5

        # Child 3 uses an inherit function and should return parent's value * 10.
        assert child3.getDefaultValue(profile) == 40
예제 #19
0
    def test_parseValue(self):
        setting = Setting(self._machine_manager,
                          "test",
                          self._catalog,
                          type="int")

        self.assertEqual(setting.parseValue("1"), 1)
        self.assertEqual(setting.parseValue(1), 1)
        self.assertEqual(setting.parseValue(True), 1)
        self.assertEqual(setting.parseValue(False), 0)
        self.assertEqual(setting.parseValue(1.1), 1)

        # An error value should return a default value valid for the setting type.
        self.assertEqual(setting.parseValue("something"), 0)

        setting = Setting(self._machine_manager,
                          "test",
                          self._catalog,
                          type="boolean")

        self.assertEqual(setting.parseValue("True"), True)
        self.assertEqual(setting.parseValue(1), True)
        self.assertEqual(setting.parseValue(1.0), True)
        self.assertEqual(setting.parseValue("False"), False)
        self.assertEqual(setting.parseValue(0), False)
        self.assertEqual(setting.parseValue(-1), True)

        # Value should be a valid python literal expression
        self.assertEqual(setting.parseValue("true"), False)

        setting = Setting(self._machine_manager,
                          "test",
                          self._catalog,
                          type="float")

        self.assertEqual(setting.parseValue("1.0"), 1.0)
        self.assertEqual(setting.parseValue(1), 1.0)
        self.assertEqual(setting.parseValue(True), 1.0)

        # Floats should also be able to be specified using , as decimal separator.
        self.assertEqual(setting.parseValue("1,0"), 1.0)

        self.assertEqual(setting.parseValue("something"), 0.0)
예제 #20
0
    def test_parseValue(self, setting_type, data, result):
        setting = Setting(self._machine_manager, "test", self._catalog, type = setting_type)

        assert setting.parseValue(data) == result
예제 #21
0
class SettingTest(unittest.TestCase):
    def setUp(self):
        # Called before the first testfunction is executed
        self._setting = Setting("TestSetting",10,"int")
        self._machine_settings = MachineSettings()
        category = SettingsCategory("TestCategory")
        #category.addSetting(self._setting)
        self._machine_settings.addSettingsCategory(category)
        self._machine_settings.loadSettingsFromFile("tests/Settings/SettingData.json")

    def tearDown(self):
        # Called after the last testfunction was executed
        pass

    def test_getSettingByKey(self):
        self.assertEqual(self._machine_settings.getSettingByKey("TestSetting").getType(), self._setting.getType())
        self.assertEqual(self._machine_settings.getSettingByKey("TestSetting").getDefaultValue(), self._setting.getDefaultValue())
        pass

    def test_category(self):
        pass

    def test_validatorTest(self):
        pass
예제 #22
0
    def test_fillByDictWithChildren(self):
        setting = Setting(self._machine_manager, "test", self._catalog)

        data = {
            "type": "int",
            "default": 4,
            "label": "Test Setting",
            "description": "A Test Setting",
            "unit": "furlongs per fortnight",
            "visible": True,

            # Since python's dict is unordered but we want an ordered dict we
            # have to go through a bit of magic to make sure we define it as an
            # ordered dict.
            "children": collections.OrderedDict(sorted({
                "test_child1": {
                    "type": "int",
                    "default": 9,
                    "label": "Test Child 1",
                    "description": "Test Setting Child 1",
                },
                "test_child2": {
                    "type": "int",
                    "default": 5,
                    "label": "Test Child 2",
                    "description": "Test Setting Child 2",
                    "inherit": False
                },
                "test_child3": {
                    "type": "int",
                    "default": 99,
                    "label": "Test Child 3",
                    "description": "Test Setting Child 3",
                    "inherit_function": "parent_value * 10"
                }
            }.items(), key = lambda k: k[0]))
        }

        setting.fillByDict(data)

        profile = Profile(setting)

        assert len(setting.getChildren()) == 3

        child1 = setting.getChildren()[0]
        child2 = setting.getChildren()[1]
        child3 = setting.getChildren()[2]

        # Children should keep the order in which they were defined
        assert child1.getKey() == "test_child1"
        assert child2.getKey() == "test_child2"
        assert child3.getKey() == "test_child3"

        # All children should have "setting" as their parent.
        assert child1.getParent() == setting
        assert child2.getParent() == setting
        assert child3.getParent() == setting

        # Child visibility should not affect parent visibility.
        assert setting.isVisible()

        # Child 1 uses default inheritance so should inherit its parent value
        assert child1.getDefaultValue(profile) == 4

        # Child 2 does not inherit so should return its default value
        assert child2.getDefaultValue(profile) == 5

        # Child 3 uses an inherit function and should return parent's value * 10.
        assert child3.getDefaultValue(profile) == 40
예제 #23
0
    def loadAll(self):
        if self._loaded:
            return

        with open(self._path, "rt", -1, "utf-8") as f:
            try:
                self._json_data = json.load(
                    f, object_pairs_hook=collections.OrderedDict)
            except JSONDecodeError as e:
                raise SettingsError.InvalidFileError(self._path) from e

        if not self._name:
            self.loadMetaData()

        self._i18n_catalog = i18nCatalog(os.path.basename(self._path))

        self._platform_mesh = self._json_data.get("platform", "")
        self._platform_texture = self._json_data.get("platform_texture", "")

        if "inherits" in self._json_data:
            try:
                path = Resources.getPath(Resources.MachineDefinitions,
                                         self._json_data["inherits"])
            except FileNotFoundError as e:
                # If we cannot find the file in Resources, try and see if it can be found relative to this file.
                # This is primarily used by the unit tests.
                path = os.path.join(os.path.dirname(self._path),
                                    self._json_data["inherits"])
                if not os.path.exists(path):
                    raise FileNotFoundError(
                        "Could not find file {0} in Resources or next to {1}".
                        format(self._json_data["inherits"], self._path)) from e

            inherits_from = MachineDefinition(self._machine_manager, path)
            inherits_from.loadAll()

            self._machine_settings = inherits_from._machine_settings
            self._categories = inherits_from._categories
            self._preferences = inherits_from._preferences

        if "machine_settings" in self._json_data:
            for key, value in self._json_data["machine_settings"].items():
                setting = self.getSetting(key)
                if not setting:
                    setting = Setting(self._machine_manager, key,
                                      self._i18n_catalog)
                    self._machine_settings.append(setting)
                setting.fillByDict(value)

        if "categories" in self._json_data:
            for key, value in self._json_data["categories"].items():
                category = self.getSettingsCategory(key)
                if not category:
                    category = SettingsCategory(self._machine_manager, key,
                                                self._i18n_catalog, self)
                    self._categories.append(category)
                category.fillByDict(value)

        if "overrides" in self._json_data:
            for key, value in self._json_data["overrides"].items():
                setting = self.getSetting(key)
                if not setting:
                    continue

                setting.fillByDict(value)

        if "machine_preferences" in self._json_data:
            for key, value in self._json_data["machine_preferences"].items():
                self._preferences[key] = value

        self.settingsLoaded.emit()

        self._loaded = True