def show_meta(self, trait_data, indent):
meta = ArgsDict({k: v for k, v in trait_data._asdict().items() \
if k not in 'traits'})
if len(meta) < 3:
return
self.seperator(indent)
for k, v in sorted(meta.items()):
self.columns(indent, color(k, style='bright'), v)
def current_state(self) -> dict:
layers = OrderedDict()
if hasattr(self.driver, 'CurrentRenderers'):
num_renderers = len(self.driver.CurrentRenderers)
if num_renderers > 0:
for layer_idx in range(0, num_renderers):
layer = self.client.get_layer(self.driver, layer_idx)
props = layer.GetAll('org.chemlab.UChroma.Layer')
layers[props['Key']] = ArgsDict(sorted({camel_to_snake(k): v \
for k, v in props.items()}.items()))
return layers
def get_args_dict(obj: HasTraits, incl_all=False):
"""
Return a dict of user-configurable traits for an object
:param obj: an instance of HasTraits
:param incl_all: If all items should be included, regardless of RO status
:return: dict of arguments
"""
argsdict = ArgsDict()
for k in sorted(obj._trait_values.keys()):
v = obj._trait_values[k]
trait = obj.traits()[k]
if incl_all or (not trait.get_metadata('hidden') and is_trait_writable(trait)):
argsdict[k] = v
return argsdict
def sparsedict(self, deep=True) -> OrderedDict:
"""
Returns a "sparse" ordereddict with the parent->child relationships
represented. This is used for serialization.
:return: The sparse dict representation
"""
self.__class__._traverse = False
fields = tuple([x for x in self.__slots__ if x not in ['parent', '_children']])
odict = ArgsDict({x: getattr(self, x) for x in fields})
if self._children is not None:
if deep:
odict['children'] = [child.sparsedict() for child in self._children]
else:
odict['children'] = self._children
self.__class__._traverse = True
return odict