1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
|
# Copyright (c) 2019 Ultimaker B.V.
# Uranium is released under the terms of the LGPLv3 or higher.
from typing import Any, Dict, List, Optional, Set, TYPE_CHECKING
import UM.Decorators
from UM.Logger import Logger
from UM.Signal import Signal
from UM.Settings.PropertyEvaluationContext import PropertyEvaluationContext
if TYPE_CHECKING:
from UM.Application import Application
from UM.Settings.InstanceContainer import InstanceContainer
from UM.Settings.SettingDefinition import SettingDefinition
@UM.Decorators.interface
class ContainerInterface:
"""Shared interface between setting container types"""
def __init__(self, *args, **kwargs):
pass
def getId(self) -> str:
"""Get the ID of the container.
The ID should be unique, machine readable and machine writable. It is
intended to be used for example when referencing the container in
configuration files or when writing a file to disk.
:return: The unique ID of this container.
"""
pass
def getName(self) -> str:
"""Get the human-readable name of this container.
This should return a human-readable name for the container, that can be
used in the interface.
:return: The name of this container.
"""
pass
def getMetaData(self) -> Dict[str, Any]:
"""Get all metadata of this container.
This returns a dictionary containing all the metadata for this container.
How this metadata is used depends on the application.
:return: The metadata for this container.
"""
pass
def getMetaDataEntry(self, entry: str, default: Any = None) -> Any:
"""Get the value of a single metadata entry.
:param entry: The key of the metadata to retrieve.
:param default: The default value to return if the entry cannot be found.
:return: The value of the metadata corresponding to `name`, or `default`
when the entry could not be found.
"""
pass
def getProperty(self, key: str, property_name: str, context: Optional[PropertyEvaluationContext] = None) -> Any:
"""Get the value of a property of the container item.
:param key: The key of the item to retrieve a property from.
:param property_name: The name of the property to retrieve.
:return: The specified property value of the container item corresponding to key, or None if not found.
"""
pass
def hasProperty(self, key: str, property_name: str) -> bool:
"""Get whether the container item has a specific property.
:param key: The key of the item to check the property from.
:param name: The name of the property to check for.
:return: True if the specified item has the property, or False if it
doesn't.
"""
pass
def getAllKeys(self) -> Set[str]:
"""Get all the setting keys known to this container.
:return: Set of keys.
"""
pass
def serialize(self, ignored_metadata_keys: Optional[Set[str]] = None) -> str:
"""Serialize this container to a string.
The serialized representation of the container can be used to write the
container to disk or send it over the network.
:param ignored_metadata_keys: A set of keys that should be ignored when
it serializes the metadata.
:return: A string representation of this container.
"""
pass
def setProperty(self, key: str, property_name: str, property_value: Any, container: "ContainerInterface" = None, set_from_cache: bool = False) -> None:
"""Change a property of a container item.
:param key: The key of the item to change the property of.
:param property_name: The name of the property to change.
:param property_value: The new value of the property.
:param container: The container to use for retrieving values when
changing the property triggers property updates. Defaults to None, which
means use the current container.
:param set_from_cache: Flag to indicate that the property was set from
cache. This triggers the behavior that the read_only and setDirty are
ignored.
"""
pass
# Should return false (or even throw an exception) if trust (or other verification) is invalidated.
def _trustHook(self, file_name: Optional[str]) -> bool:
return True
def deserialize(self, serialized: str, file_name: Optional[str] = None) -> str:
"""Deserialize the container from a string representation.
This should replace the contents of this container with those in the serialized
representation.
:param serialized: A serialized string containing a container that should be deserialized.
"""
if not self._trustHook(file_name):
return ""
return self._updateSerialized(serialized, file_name = file_name)
@classmethod
def deserializeMetadata(cls, serialized: str, container_id: str) -> List[Dict[str, Any]]:
"""Deserialize just the metadata from a string representation.
:param serialized: A string representing one or more containers that
should be deserialized.
:param container_id: The ID of the (base) container is already known and
provided here.
:return: A list of the metadata of all containers found in the document.
"""
Logger.log("w", "Class {class_name} hasn't implemented deserializeMetadata!".format(class_name = cls.__name__))
return []
@classmethod
def _updateSerialized(cls, serialized: str, file_name: Optional[str] = None) -> str:
"""Updates the given serialized data to the latest version."""
configuration_type = cls.getConfigurationTypeFromSerialized(serialized)
version = cls.getVersionFromSerialized(serialized)
if configuration_type is not None and version is not None:
from UM.VersionUpgradeManager import VersionUpgradeManager
result = VersionUpgradeManager.getInstance().updateFilesData(configuration_type, version,
[serialized],
[file_name if file_name else ""])
if result is not None:
serialized = result.files_data[0]
return serialized
@classmethod
def getLoadingPriority(cls) -> int:
return 9001 #Goku wins!
@classmethod
def getConfigurationTypeFromSerialized(cls, serialized: str) -> Optional[str]:
"""Gets the configuration type of the given serialized data. (used by __updateSerialized())"""
pass
@classmethod
def getVersionFromSerialized(cls, serialized: str) -> Optional[int]:
"""Gets the version of the given serialized data. (used by __updateSerialized())"""
pass
def getPath(self) -> str:
"""Get the path used to create this InstanceContainer."""
pass
def setPath(self, path: str) -> None:
"""Set the path used to create this InstanceContainer"""
pass
def isDirty(self) -> bool:
pass
def setDirty(self, dirty: bool) -> None:
pass
propertyChanged = None # type: Signal
metaDataChanged = None # type: Signal
@UM.Decorators.interface
class DefinitionContainerInterface(ContainerInterface):
def findDefinitions(self, **kwargs: Any) -> List["SettingDefinition"]:
raise NotImplementedError()
def setProperty(self, key: str, property_name: str, property_value: Any, container: "ContainerInterface" = None, set_from_cache: bool = False) -> None:
raise TypeError("Can't change properties in definition containers.")
def getInheritedFiles(self) -> List[str]:
raise NotImplementedError()
@UM.Decorators.interface
class ContainerRegistryInterface:
"""Shared interface between setting container types"""
def findContainers(self, *, ignore_case: bool = False, **kwargs: Any) -> List[ContainerInterface]:
raise NotImplementedError()
def findDefinitionContainers(self, **kwargs: Any) -> List[DefinitionContainerInterface]:
raise NotImplementedError()
@classmethod
def getApplication(cls) -> "Application":
raise NotImplementedError()
def getEmptyInstanceContainer(self) -> "InstanceContainer":
raise NotImplementedError()
def isReadOnly(self, container_id: str) -> bool:
raise NotImplementedError()
def setExplicitReadOnly(self, container_id: str) -> None:
raise NotImplementedError()
def isExplicitReadOnly(self, container_id: str) -> bool:
raise NotImplementedError()
|
