def context(self):
if not self._context:
self._context = yaql_integration.create_empty_context()
for m in self._iterate_unique_methods():
self._context.register_function(
m.yaql_function_definition,
name=m.yaql_function_definition.name)
return self._context
def context(self):
if not self._context:
self._context = yaql_integration.create_empty_context()
for m in self._iterate_unique_methods():
self._context.register_function(
m.yaql_function_definition,
name=m.yaql_function_definition.name)
return self._context
def setUp(self):
super(TestAgentListener, self).setUp()
# Register Agent class
self.package_loader.load_package('io.murano', None).register_class(
agent_listener.AgentListener)
model = om.Object('AgentListenerTests')
self.runner = self.new_runner(model)
self.context = yaql_integration.create_empty_context()
self.context[constants.CTX_EXECUTION_SESSION] = \
execution_session.ExecutionSession()
def setUp(self):
super(TestAgentListener, self).setUp()
# Register Agent class
self.package_loader.load_package('io.murano', None).register_class(
agent_listener.AgentListener)
model = om.Object('AgentListenerTests')
self.runner = self.new_runner(model)
self.context = yaql_integration.create_empty_context()
self.context[constants.CTX_THIS] = mock.MagicMock(
dsl.MuranoObjectInterface)
def setUp(self):
super(TestAgentListener, self).setUp()
# Register Agent class
self.package_loader.load_package('io.murano', None).register_class(
agent_listener.AgentListener)
model = om.Object(
'AgentListenerTests')
self.runner = self.new_runner(model)
self.context = yaql_integration.create_empty_context()
self.context[constants.CTX_ENVIRONMENT] = environment.Environment()
def exported_context(self):
if not self._exported_context:
self._exported_context = yaql_integration.create_empty_context()
for m in self._iterate_unique_methods():
if m.usage == dsl_types.MethodUsages.Extension:
if m.instance_stub:
self._exported_context.register_function(
m.instance_stub, name=m.instance_stub.name)
if m.static_stub:
self._exported_context.register_function(
m.static_stub, name=m.static_stub.name)
return self._exported_context
def setUp(self):
super(TestAgentListener, self).setUp()
# Register Agent class
self.package_loader.load_package('io.murano', None).register_class(
agent_listener.AgentListener)
model = om.Object(
'AgentListenerTests')
self.runner = self.new_runner(model)
self.context = yaql_integration.create_empty_context()
self.context[constants.CTX_THIS] = mock.MagicMock(
dsl.MuranoObjectInterface)
def exported_context(self):
if not self._exported_context:
self._exported_context = yaql_integration.create_empty_context()
for m in self._iterate_unique_methods():
if m.usage == dsl_types.MethodUsages.Extension:
if m.instance_stub:
self._exported_context.register_function(
m.instance_stub, name=m.instance_stub.name)
if m.static_stub:
self._exported_context.register_function(
m.static_stub, name=m.static_stub.name)
return self._exported_context
def get_context(runtime_version):
context = yaql_integration.create_empty_context()
context.register_function(base64decode)
context.register_function(base64encode)
context.register_function(pselect)
context.register_function(bind)
context.register_function(random_name)
context.register_function(patch_)
context.register_function(logger)
if runtime_version <= constants.RUNTIME_VERSION_1_1:
context.register_function(substr)
context.register_function(first_or_default)
root_context = yaql_integration.create_context(runtime_version)
for t in ('to_lower', 'to_upper', 'trim', 'join', 'split',
'starts_with', 'ends_with', 'matches', 'replace', 'flatten'):
for spec in utils.to_extension_method(t, root_context):
context.register_function(spec)
return context
def get_context(runtime_version):
context = yaql_integration.create_empty_context()
context.register_function(base64decode)
context.register_function(base64encode)
context.register_function(pselect)
context.register_function(bind)
context.register_function(random_name)
context.register_function(patch_)
context.register_function(logger)
if runtime_version <= constants.RUNTIME_VERSION_1_1:
context.register_function(substr)
context.register_function(first_or_default)
root_context = yaql_integration.create_context(runtime_version)
for t in ('to_lower', 'to_upper', 'trim', 'join', 'split',
'starts_with', 'ends_with', 'matches', 'replace',
'flatten'):
for spec in utils.to_extension_method(t, root_context):
context.register_function(spec)
return context
def context(self):
if not self._context:
ctx = None
for imp in reversed(self._imports):
if ctx is None:
ctx = imp.exported_context
else:
ctx = helpers.link_contexts(ctx, imp.exported_context)
if ctx is None:
self._context = yaql_integration.create_empty_context()
else:
self._context = ctx.create_child_context()
for m in self._iterate_unique_methods():
if m.instance_stub:
self._context.register_function(
m.instance_stub, name=m.instance_stub.name)
if m.static_stub:
self._context.register_function(
m.static_stub, name=m.static_stub.name)
return self._context
def context(self):
if not self._context:
ctx = None
for imp in reversed(self._imports):
if ctx is None:
ctx = imp.exported_context
else:
ctx = helpers.link_contexts(ctx, imp.exported_context)
if ctx is None:
self._context = yaql_integration.create_empty_context()
else:
self._context = ctx.create_child_context()
for m in self._iterate_unique_methods():
if m.instance_stub:
self._context.register_function(
m.instance_stub, name=m.instance_stub.name)
if m.static_stub:
self._context.register_function(
m.static_stub, name=m.static_stub.name)
return self._context
def _create_context(self, root_context):
@specs.parameter("name", yaqltypes.StringConstant())
def get_context_data(name):
def set_data(value):
if not name or name == "$" or name == "$this":
raise ValueError("Cannot assign to {0}".format(name))
ctx = root_context
while constants.CTX_VARIABLE_SCOPE not in ctx:
ctx = ctx.parent
ctx[name] = value
return LhsExpression.Property(lambda: root_context[name], set_data)
@specs.parameter("this", LhsExpression.Property)
@specs.parameter("key", yaqltypes.Keyword())
def attribution(this, key):
def setter(src_property, value):
src = src_property.get()
if isinstance(src, utils.MappingType):
src_property.set(utils.FrozenDict(itertools.chain(six.iteritems(src), ((key, value),))))
elif isinstance(src, dsl_types.MuranoObject):
src.set_property(key, value, root_context)
else:
raise ValueError("attribution may only be applied to " "objects and dictionaries")
def getter(src):
if isinstance(src, utils.MappingType):
return src.get(key, {})
elif isinstance(src, dsl_types.MuranoObject):
self._current_obj = src
self._current_obj_name = key
try:
return src.get_property(key, root_context)
except exceptions.UninitializedPropertyAccessError:
return {}
else:
raise ValueError("attribution may only be applied to " "objects and dictionaries")
return LhsExpression.Property(lambda: getter(this.get()), lambda value: setter(this, value))
@specs.parameter("this", LhsExpression.Property)
@specs.parameter("index", yaqltypes.Lambda(with_context=True))
def indexation(this, index):
index = index(root_context)
def getter(src):
if utils.is_sequence(src):
return src[index]
else:
raise ValueError("indexation may only be applied to lists")
def setter(src_property, value):
src = src_property.get()
if utils.is_sequence(src):
src_property.set(src[:index] + (value,) + src[index + 1 :])
elif isinstance(src, utils.MappingType):
attribution(src_property, index).set(value)
if isinstance(index, int):
return LhsExpression.Property(lambda: getter(this.get()), lambda value: setter(this, value))
else:
return attribution(this, index)
context = yaql_integration.create_empty_context()
context.register_function(get_context_data, "#get_context_data")
context.register_function(attribution, "#operator_.")
context.register_function(indexation, "#indexer")
return context
def _create_context(self, root_context):
@specs.parameter('path', yaqltypes.Lambda(with_context=True))
def get_context_data(path):
path = path(root_context)
def set_data(value):
if not path or path == '$' or path == '$this':
raise ValueError()
root_context[path] = value
return LhsExpression.Property(lambda: root_context[path], set_data)
@specs.parameter('this', LhsExpression.Property)
@specs.parameter('key', yaqltypes.Keyword())
def attribution(this, key):
def setter(src_property, value):
src = src_property.get()
if isinstance(src, utils.MappingType):
src_property.set(
utils.FrozenDict(
itertools.chain(src.iteritems(),
((key, value), ))))
elif isinstance(src, dsl_types.MuranoObject):
src.set_property(key, value, root_context)
else:
raise ValueError('attribution may only be applied to '
'objects and dictionaries')
def getter(src):
if isinstance(src, utils.MappingType):
return src.get(key, {})
elif isinstance(src, dsl_types.MuranoObject):
self._current_obj = src
self._current_obj_name = key
try:
return src.get_property(key, root_context)
except exceptions.UninitializedPropertyAccessError:
return {}
else:
raise ValueError('attribution may only be applied to '
'objects and dictionaries')
return LhsExpression.Property(lambda: getter(this.get()),
lambda value: setter(this, value))
@specs.parameter('this', LhsExpression.Property)
@specs.parameter('index', yaqltypes.Lambda(with_context=True))
def indexation(this, index):
index = index(root_context)
def getter(src):
if utils.is_sequence(src):
return src[index]
else:
raise ValueError('indexation may only be applied to lists')
def setter(src_property, value):
src = src_property.get()
if utils.is_sequence(src):
src_property.set(src[:index] + (value, ) + src[index + 1:])
if isinstance(index, types.IntType):
return LhsExpression.Property(
lambda: getter(this.get()),
lambda value: setter(this, value))
else:
return attribution(this, index)
context = yaql_integration.create_empty_context()
context.register_function(get_context_data, '#get_context_data')
context.register_function(attribution, '#operator_.')
context.register_function(indexation, '#indexer')
return context
def _create_context(self, root_context):
@specs.parameter('name', yaqltypes.StringConstant())
def get_context_data(name):
def set_data(value):
if not name or name == '$' or name == '$this':
raise ValueError('Cannot assign to {0}'.format(name))
ctx = root_context
while constants.CTX_VARIABLE_SCOPE not in ctx:
ctx = ctx.parent
ctx[name] = value
return LhsExpression.Property(lambda: root_context[name], set_data)
@specs.parameter('this', LhsExpression.Property)
@specs.parameter('key', yaqltypes.Keyword())
def attribution(this, key):
def setter(src_property, value):
src = src_property.get()
if isinstance(src, utils.MappingType):
src_property.set(
utils.FrozenDict(
itertools.chain(six.iteritems(src),
((key, value), ))))
elif isinstance(src, dsl_types.MuranoObject):
src.set_property(key, value, root_context)
elif isinstance(
src,
(dsl_types.MuranoTypeReference, dsl_types.MuranoType)):
if isinstance(src, dsl_types.MuranoTypeReference):
mc = src.type
else:
mc = src
mc.set_property(key, value, root_context)
else:
raise ValueError('attribution may only be applied to '
'objects and dictionaries')
def getter(src):
if isinstance(src, utils.MappingType):
return src.get(key, {})
elif isinstance(src, dsl_types.MuranoObject):
self._current_obj = src
self._current_obj_name = key
try:
return src.get_property(key, root_context)
except exceptions.UninitializedPropertyAccessError:
return {}
else:
raise ValueError('attribution may only be applied to '
'objects and dictionaries')
return LhsExpression.Property(lambda: getter(this.get()),
lambda value: setter(this, value))
@specs.parameter('this', LhsExpression.Property)
@specs.parameter('index', yaqltypes.Lambda(with_context=True))
def indexation(this, index):
index = index(root_context)
def getter(src):
if utils.is_sequence(src):
return src[index]
else:
raise ValueError('indexation may only be applied to lists')
def setter(src_property, value):
src = src_property.get()
if utils.is_sequence(src):
src_property.set(src[:index] + (value, ) + src[index + 1:])
elif isinstance(src, utils.MappingType):
attribution(src_property, index).set(value)
if isinstance(index, int):
return LhsExpression.Property(
lambda: getter(this.get()),
lambda value: setter(this, value))
else:
return attribution(this, index)
def _wrap_type_reference(tr):
return LhsExpression.Property(lambda: tr, self._invalid_target)
@specs.parameter('prefix', yaqltypes.Keyword())
@specs.parameter('name', yaqltypes.Keyword())
@specs.name('#operator_:')
def ns_resolve(prefix, name):
return _wrap_type_reference(
yaql_functions.ns_resolve(context, prefix, name))
@specs.parameter('name', yaqltypes.Keyword())
@specs.name('#unary_operator_:')
def ns_resolve_unary(context, name):
return _wrap_type_reference(
yaql_functions.ns_resolve_unary(context, name))
@specs.parameter('object_', dsl_types.MuranoObject)
def type_(object_):
return _wrap_type_reference(yaql_functions.type_(object_))
@specs.name('type')
@specs.parameter('cls', dsl.MuranoTypeParameter())
def type_from_name(cls):
return _wrap_type_reference(cls)
context = yaql_integration.create_empty_context()
context.register_function(get_context_data, '#get_context_data')
context.register_function(attribution, '#operator_.')
context.register_function(indexation, '#indexer')
context.register_function(ns_resolve)
context.register_function(ns_resolve_unary)
context.register_function(type_)
context.register_function(type_from_name)
return context
def get_restricted_context():
context = yaql_integration.create_empty_context()
context.register_function(config)
context.register_function(config_default)
return context
def _create_new_ctx(self, mock_funcs):
mock_context = yaql_integration.create_empty_context()
for mock_func in mock_funcs:
mock_context.register_function(mock_func)
return mock_context
def _create_context(self, root_context):
@specs.parameter('name', yaqltypes.StringConstant())
def get_context_data(name):
def set_data(value):
if not name or name == '$' or name == '$this':
raise ValueError('Cannot assign to {0}'.format(name))
ctx = root_context
while constants.CTX_VARIABLE_SCOPE not in ctx:
ctx = ctx.parent
ctx[name] = value
return LhsExpression.Property(
lambda: root_context[name], set_data)
@specs.parameter('this', LhsExpression.Property)
@specs.parameter('key', yaqltypes.Keyword())
def attribution(this, key):
def setter(src_property, value):
src = src_property.get()
if isinstance(src, utils.MappingType):
src_property.set(
utils.FrozenDict(
itertools.chain(
six.iteritems(src),
((key, value),))))
elif isinstance(src, dsl_types.MuranoObject):
src.set_property(key, value, root_context)
elif isinstance(src, (
dsl_types.MuranoTypeReference,
dsl_types.MuranoType)):
if isinstance(src, dsl_types.MuranoTypeReference):
mc = src.type
else:
mc = src
mc.set_property(key, value, root_context)
else:
raise ValueError(
'attribution may only be applied to '
'objects and dictionaries')
def getter(src):
if isinstance(src, utils.MappingType):
return src.get(key, {})
elif isinstance(src, dsl_types.MuranoObject):
self._current_obj = src
self._current_obj_name = key
try:
return src.get_property(key, root_context)
except exceptions.UninitializedPropertyAccessError:
return {}
else:
raise ValueError(
'attribution may only be applied to '
'objects and dictionaries')
return LhsExpression.Property(
lambda: getter(this.get()),
lambda value: setter(this, value))
@specs.parameter('this', LhsExpression.Property)
@specs.parameter('index', yaqltypes.Lambda(with_context=True))
def indexation(this, index):
index = index(root_context)
def getter(src):
if utils.is_sequence(src):
return src[index]
else:
raise ValueError('indexation may only be applied to lists')
def setter(src_property, value):
src = src_property.get()
if utils.is_sequence(src):
src_property.set(src[:index] + (value,) + src[index + 1:])
elif isinstance(src, utils.MappingType):
attribution(src_property, index).set(value)
if isinstance(index, int):
return LhsExpression.Property(
lambda: getter(this.get()),
lambda value: setter(this, value))
else:
return attribution(this, index)
def _wrap_type_reference(tr):
return LhsExpression.Property(lambda: tr, self._invalid_target)
@specs.parameter('prefix', yaqltypes.Keyword())
@specs.parameter('name', yaqltypes.Keyword())
@specs.name('#operator_:')
def ns_resolve(prefix, name):
return _wrap_type_reference(
yaql_functions.ns_resolve(context, prefix, name))
@specs.parameter('name', yaqltypes.Keyword())
@specs.name('#unary_operator_:')
def ns_resolve_unary(context, name):
return _wrap_type_reference(
yaql_functions.ns_resolve_unary(context, name))
@specs.parameter('object_', dsl_types.MuranoObject)
def type_(object_):
return _wrap_type_reference(yaql_functions.type_(object_))
@specs.name('type')
@specs.parameter('cls', dsl.MuranoTypeParameter())
def type_from_name(cls):
return _wrap_type_reference(cls)
context = yaql_integration.create_empty_context()
context.register_function(get_context_data, '#get_context_data')
context.register_function(attribution, '#operator_.')
context.register_function(indexation, '#indexer')
context.register_function(ns_resolve)
context.register_function(ns_resolve_unary)
context.register_function(type_)
context.register_function(type_from_name)
return context
def _create_new_ctx(self, mock_funcs):
mock_context = yaql_integration.create_empty_context()
for mock_func in mock_funcs:
mock_context.register_function(mock_func)
return mock_context
def get_restricted_context():
context = yaql_integration.create_empty_context()
context.register_function(config)
context.register_function(config_default)
return context
def _create_context(self, root_context):
@specs.parameter('path', yaqltypes.Lambda(with_context=True))
def get_context_data(path):
path = path(root_context)
def set_data(value):
if not path or path == '$' or path == '$this':
raise ValueError()
root_context[path] = value
return LhsExpression.Property(
lambda: root_context[path], set_data)
@specs.parameter('this', LhsExpression.Property)
@specs.parameter('key', yaqltypes.Keyword())
def attribution(this, key):
def setter(src_property, value):
src = src_property.get()
if isinstance(src, utils.MappingType):
src_property.set(
utils.FrozenDict(
itertools.chain(
src.iteritems(),
((key, value),))))
elif isinstance(src, dsl_types.MuranoObject):
src.set_property(key, value, root_context)
else:
raise ValueError(
'attribution may only be applied to '
'objects and dictionaries')
def getter(src):
if isinstance(src, utils.MappingType):
return src.get(key, {})
elif isinstance(src, dsl_types.MuranoObject):
self._current_obj = src
self._current_obj_name = key
try:
return src.get_property(key, root_context)
except exceptions.UninitializedPropertyAccessError:
return {}
else:
raise ValueError(
'attribution may only be applied to '
'objects and dictionaries')
return LhsExpression.Property(
lambda: getter(this.get()),
lambda value: setter(this, value))
@specs.parameter('this', LhsExpression.Property)
@specs.parameter('index', yaqltypes.Lambda(with_context=True))
def indexation(this, index):
index = index(root_context)
def getter(src):
if utils.is_sequence(src):
return src[index]
else:
raise ValueError('indexation may only be applied to lists')
def setter(src_property, value):
src = src_property.get()
if utils.is_sequence(src):
src_property.set(src[:index] + (value,) + src[index + 1:])
if isinstance(index, types.IntType):
return LhsExpression.Property(
lambda: getter(this.get()),
lambda value: setter(this, value))
else:
return attribution(this, index)
context = yaql_integration.create_empty_context()
context.register_function(get_context_data, '#get_context_data')
context.register_function(attribution, '#operator_.')
context.register_function(indexation, '#indexer')
return context
