def LabelFactory(model ,path):
binding = Binding(context=model, path=path)
label = Label(path='label')
binding.setter = lambda value: label.set_text(value)
if label.is_loaded:
binding.apply_binding()
return label
def evaluate_function_call(self, node, bindings):
params = node.args.accept(self, bindings)
func_name = node.name.accept(self, bindings)
funcBinding = Binding(func_name[0].parent)
funcBinding.bindings = func_name[0].bindings.copy()
function = func_name[1]
for x in range(len(params)):
funcBinding.setValue(list(funcBinding.bindings.keys())[x],params[x])
return function.accept(self, funcBinding)
def rename(self, old_name, new_name):
""" Binds a new name to an object. """
if len(old_name) == 0 or len(new_name) == 0:
raise InvalidNameError('empty name')
# Parse the names.
old_components = self._parse_name(old_name)
new_components = self._parse_name(new_name)
# If there is axactly one component in BOTH names then the operation
# takes place ENTIRELY in this context.
if len(old_components) == 1 and len(new_components) == 1:
# Is the old name actually bound?
if not self._is_bound(old_name):
raise NameNotFoundError(old_name)
# Is the new name already bound?
if self._is_bound(new_name):
raise NameAlreadyBoundError(new_name)
# Do the actual rename.
self._rename(old_name, new_name)
# Lookup the object that we are renaming to use in the event
# notification.
obj = self._lookup(new_name)
# Trait event notification.
self.object_renamed = NamingEvent(
old_binding=Binding(name=old_name, obj=obj, context=self),
new_binding=Binding(name=new_name, obj=obj, context=self))
else:
# fixme: This really needs to be transactional in case the bind
# succeeds but the unbind fails. To be safe should we just not
# support cross-context renaming for now?!?!
#
# Lookup the object.
obj = self.lookup(old_name)
# Bind the new name.
self.bind(new_name, obj)
# Unbind the old one.
self.unbind(old_name)
return
def create_subcontext(self, name):
""" Creates a sub-context. """
if len(name) == 0:
raise InvalidNameError('empty name')
# Parse the name.
components = self._parse_name(name)
# If there is exactly one component in the name then the operation
# takes place in this context.
if len(components) == 1:
atom = components[0]
# Is the name already bound?
if self._is_bound(atom):
raise NameAlreadyBoundError(name)
# Do the actual creation of the sub-context.
sub = self._create_subcontext(atom)
# Trait event notification.
self.object_added = NamingEvent(
new_binding=Binding(name=name, obj=sub, context=self))
# Otherwise, attempt to continue resolution into the next context.
else:
if not self._is_bound(components[0]):
raise NameNotFoundError(components[0])
next_context = self._get_next_context(components[0])
sub = next_context.create_subcontext('/'.join(components[1:]))
return sub
def _list_bindings(self):
""" Lists the bindings in this context.
"""
result = [ Binding(name=n, obj=o, context=self) for n, o, t in \
self._get_contributed_context_items() ]
return result
def _list_bindings(self):
""" Lists the bindings in this context. """
bindings = []
for name, value in self.namespace.items():
bindings.append(
Binding(name=name, obj=self._lookup(name), context=self))
return bindings
def __init__(self, path: str = None, binding: Binding = None):
Viewer.__init__(self)
Label.__init__(self)
self.path = 'label' if path is None else path
# ...
if binding is not None:
binding.setter = lambda value: self.set_text(value)
# ...
pass
def bind(self, name, obj, make_contexts=False):
""" Binds a name to an object.
If 'make_contexts' is True then any missing intermediate contexts are
created automatically.
"""
if len(name) == 0:
raise InvalidNameError('empty name')
# Parse the name.
components = self._parse_name(name)
# If there is exactly one component in the name then the operation
# takes place in this context.
if len(components) == 1:
atom = components[0]
# Is the name already bound?
if self._is_bound(atom):
raise NameAlreadyBoundError(name)
# Do the actual bind.
self._bind(atom, obj)
# Trait event notification.
self.object_added = NamingEvent(
new_binding=Binding(name=name, obj=obj, context=self))
# Otherwise, attempt to continue resolution into the next context.
else:
if not self._is_bound(components[0]):
if make_contexts:
self._create_subcontext(components[0])
else:
raise NameNotFoundError(components[0])
next_context = self._get_next_context(components[0])
next_context.bind('/'.join(components[1:]), obj, make_contexts)
return
def refresh(self):
""" Refresh the context to reflect changes in the file system. """
# fixme: This needs more work 'cos if we refresh a context then we
# will load new copies of serialized Python objects!
# This causes the initializer to run again the next time the trait is
# accessed.
self.reset_traits(['_name_to_filename_map'])
# Clear out the cache.
self._cache = {}
# fixme: This is a bit hacky since the context in the binding may
# not be None!
self.context_changed = NamingEvent(
new_binding=Binding(name=self.name, obj=self, context=None))
return
def rebind(self, name, obj, make_contexts=False):
""" Binds an object to a name that may already be bound.
If 'make_contexts' is True then any missing intermediate contexts are
created automatically.
The object may be a different object but may also be the same object
that is already bound to the specified name. The name may or may not be
already used. Think of this as a safer version of 'bind' since this
one will never raise an exception regarding a name being used.
"""
if len(name) == 0:
raise InvalidNameError('empty name')
# Parse the name.
components = self._parse_name(name)
# If there is exactly one component in the name then the operation
# takes place in this context.
if len(components) == 1:
# Do the actual rebind.
self._rebind(components[0], obj)
# Trait event notification.
self.object_changed = NamingEvent(
new_binding=Binding(name=name, obj=obj, context=self))
# Otherwise, attempt to continue resolution into the next context.
else:
if not self._is_bound(components[0]):
if make_contexts:
self._create_subcontext(components[0])
else:
raise NameNotFoundError(components[0])
next_context = self._get_next_context(components[0])
next_context.rebind('/'.join(components[1:]), obj, make_contexts)
return
def destroy_subcontext(self, name):
""" Destroys a sub-context. """
if len(name) == 0:
raise InvalidNameError('empty name')
# Parse the name.
components = self._parse_name(name)
# If there is exactly one component in the name then the operation
# takes place in this context.
if len(components) == 1:
atom = components[0]
if not self._is_bound(atom):
raise NameNotFoundError(name)
obj = self._lookup(atom)
if not self._is_context(atom):
raise NotContextError(name)
# Do the actual destruction of the sub-context.
self._destroy_subcontext(atom)
# Trait event notification.
self.object_removed = NamingEvent(
old_binding=Binding(name=name, obj=obj, context=self))
# Otherwise, attempt to continue resolution into the next context.
else:
if not self._is_bound(components[0]):
raise NameNotFoundError(components[0])
next_context = self._get_next_context(components[0])
next_context.destroy_subcontext('/'.join(components[1:]))
return
def unbind(self, name):
""" Unbinds a name. """
if len(name) == 0:
raise InvalidNameError('empty name')
# Parse the name.
components = self._parse_name(name)
# If there is exactly one component in the name then the operation
# takes place in this context.
if len(components) == 1:
atom = components[0]
if not self._is_bound(atom):
raise NameNotFoundError(name)
# Lookup the object that we are unbinding to use in the event
# notification.
obj = self._lookup(atom)
# Do the actual unbind.
self._unbind(atom)
# Trait event notification.
self.object_removed = NamingEvent(
old_binding=Binding(name=name, obj=obj, context=self))
# Otherwise, attempt to continue resolution into the next context.
else:
if not self._is_bound(components[0]):
raise NameNotFoundError(components[0])
next_context = self._get_next_context(components[0])
next_context.unbind('/'.join(components[1:]))
return
def _lookup_binding(self, name):
""" Looks up the binding for a name in this context. """
return Binding(name=name, obj=self._lookup(name), context=self)
def evaluate_code(self, node):
g_binding = Binding({}, None)
for exp in node.expressions:
value = exp.accept(self, g_binding)
return value
def evaluate_parameters(self, node, bindings):
func_binding = Binding(bindings)
for p in node.params:
func_binding.createVal(p.accept(self, bindings))
return func_binding