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 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 _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_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