def test_multi_layer_laziness_ambiguity(self): @specs.parameter('a', yaqltypes.Lambda()) def f1(a, b): return a() + b @specs.parameter('a', yaqltypes.Lambda()) def f2(a, b): return a() + b @specs.parameter('b', yaqltypes.Lambda()) def f3(a, b): return -a - b() @specs.parameter('a', yaqltypes.Lambda()) def f4(a, b): return -a() + b context1 = self.context.create_child_context() context1.register_function(f1, name='foo') context1.register_function(f2, name='bar') context2 = context1.create_child_context() context2.register_function(f3, name='foo') context2.register_function(f4, name='bar') self.assertRaises( exceptions.AmbiguousFunctionException, self.eval, 'foo(12, 13)', context=context2) self.assertEqual( 1, self.eval('bar(12, 13)', context=context2))
def prepare_validate_context(root_context): @specs.parameter('value', nullable=True) @specs.method def int_(value): if value is None or isinstance( value, int) and not isinstance(value, bool): return value raise exceptions.ContractViolationException() @specs.parameter('value', nullable=True) @specs.method def string(value): if value is None or isinstance(value, six.string_types): return value raise exceptions.ContractViolationException() @specs.parameter('value', nullable=True) @specs.method def bool_(value): if value is None or isinstance(value, bool): return value raise exceptions.ContractViolationException() @specs.parameter('value', nullable=True) @specs.method def not_null(value): if value is None: raise exceptions.ContractViolationException() return value @specs.parameter('value', nullable=True) @specs.parameter('predicate', yaqltypes.Lambda(with_context=True)) @specs.method def check(value, predicate): if predicate(root_context.create_child_context(), value): return value raise exceptions.ContractViolationException() @specs.parameter('type', dsl.MuranoTypeParameter( nullable=False, context=root_context)) @specs.parameter('value', nullable=True) @specs.parameter('version_spec', yaqltypes.String(True)) @specs.method def class_(value, type, version_spec=None): if helpers.is_instance_of( value, type.type.name, version_spec or helpers.get_names_scope(root_context)): return value raise exceptions.ContractViolationException() context = root_context.create_child_context() context.register_function(int_) context.register_function(string) context.register_function(bool_) context.register_function(check) context.register_function(not_null) context.register_function(class_) return context
def test_invalid_method(self): self.assertRaises(exceptions.InvalidMethodException, self.context.register_function, lambda: 1, name='f', method=True) @specs.parameter('x', yaqltypes.Lambda()) def func(x): return x self.assertRaises(exceptions.InvalidMethodException, self.context.register_function, func, name='f2', method=True)
def test_single_layer_laziness_ambiguity(self): @specs.parameter('a', yaqltypes.Lambda()) def f1(a): return a() def f2(a): return -a def f3(a, b): return a + b context1 = self.context.create_child_context() context1.register_function(f1, name='f') context1.register_function(f2, name='f') context1.register_function(f3, name='f') self.assertRaises( exceptions.AmbiguousFunctionException, self.eval, 'f(2 * $)', data=3, context=context1) self.assertEqual(25, self.eval('f(12, 13)', context=context1))
for i, t in enumerate(match.groups(), 1): rec = {'value': t, 'start': match.start(i), 'end': match.end(i)} context['$' + str(i + 1)] = rec for key, value, in match.groupdict().values(): rec = { 'value': value, 'start': match.start(value), 'end': match.end(value) } context['$' + key] = rec @specs.parameter('regexp', REGEX_TYPE) @specs.parameter('string', yaqltypes.String()) @specs.parameter('selector', yaqltypes.Lambda(with_context=True)) @specs.method def search(context, regexp, string, selector=None): """:yaql:search Search substring which matches regexp. Returns selector applied to dictionary {"start" => ..., "end" => ..., "value" => ...} where appropriate values describe start of substring, its end and itself. By default, if no selector is specified, returns only substring. null is a return value if there is no substring which matches regexp. :signature: regexp.search(string, selector => null) :receiverArg regexp: regex pattern :argType regexp: regex object :arg string: string to find match in :argType string: string
@specs.name('#get_context_data') def get_context_data(name, context): """:yaql:getContextData Returns the context value by its name. This function is system and can be overridden to change the way of getting context data. :signature: getContextData(name) :arg name: value's key name :argType name: string :returnType: any (value type) """ return context[name] @specs.parameter('expr', yaqltypes.Lambda(method=True)) @specs.name('#operator_.') def op_dot(receiver, expr): """:yaql:operator . Returns expr evaluated on receiver. :signature: receiver.expr :arg receiver: object to evaluate expression :argType receiver: any :arg expr: expression :argType expr: expression that can be evaluated as a method :returnType: expression result type .. code::
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from yaql.language import specs from yaql.language import utils as yaqlutils from yaql.language import yaqltypes from nailgun.logger import logger from nailgun.utils import datadiff _UNDEFINED = object() @specs.parameter('expression', yaqltypes.Lambda()) def get_new(expression, context): return expression(context['$%new']) @specs.parameter('expression', yaqltypes.Lambda()) def get_old(expression, context): try: return expression(context['$%old']) except Exception as e: # exception in evaluation on old data interprets # we return special sentinel to check that data was actually changed # we cannot use empty object here, because new data can be empty # as well, and in this case there is no chance to detect # data was changed or not logger.debug('Cannot evaluate expression on old data: %s', e)
@specs.name('new') @specs.parameter('owner', dsl.MuranoObjectParameter(nullable=True, decorate=False)) @specs.parameter('model', utils.MappingType) def new_from_model(context, model, owner=None): object_store = helpers.get_object_store() return object_store.load(model, owner, context=context, scope_type=helpers.get_names_scope(context)) @specs.parameter('object_', dsl.MuranoObjectParameter(decorate=False)) @specs.parameter('func', yaqltypes.Lambda()) def super_(context, object_, func=None): cast_type = helpers.get_type(context) if func is None: return [object_.cast(type) for type in cast_type.parents] return map(func, super_(context, object_)) @specs.parameter('object_', dsl.MuranoObjectParameter(decorate=False)) @specs.parameter('func', yaqltypes.Lambda()) def psuper(context, object_, func=None): if func is None: return super_(context, object_) return helpers.parallel_select(super_(context, object_), func)
# not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from yaql.language import specs from yaql.language import yaqltypes @specs.parameter('left', yaqltypes.Lambda()) @specs.parameter('right', yaqltypes.Lambda()) @specs.name('#operator_and') def and_(left, right): return left() and right() @specs.parameter('left', yaqltypes.Lambda()) @specs.parameter('right', yaqltypes.Lambda()) @specs.name('#operator_or') def or_(left, right): return left() or right() @specs.name('#unary_operator_not') def not_(arg):
@specs.parameter('value', yaqltypes.String()) @specs.extension_method def base64encode(value): return base64.b64encode(value) @specs.parameter('value', yaqltypes.String()) @specs.extension_method def base64decode(value): return base64.b64decode(value) @specs.parameter('collection', yaqltypes.Iterable()) @specs.parameter('composer', yaqltypes.Lambda()) @specs.extension_method def pselect(collection, composer): return helpers.parallel_select(collection, composer) @specs.parameter('mappings', collections.Mapping) @specs.extension_method def bind(obj, mappings): if isinstance(obj, types.StringTypes) and obj.startswith('$'): value = _convert_macro_parameter(obj[1:], mappings) if value is not None: return value elif utils.is_sequence(obj): return [bind(t, mappings) for t in obj] elif isinstance(obj, collections.Mapping):
def prepare_transform_context(root_context, this, owner, default, calling_type): @specs.parameter('value', nullable=True) @specs.method def int_(value): if value is dsl.NO_VALUE: value = default if value is None: return None try: return int(value) except Exception: raise exceptions.ContractViolationException( 'Value {0} violates int() contract'.format( format_scalar(value))) @specs.parameter('value', nullable=True) @specs.method def string(value): if value is dsl.NO_VALUE: value = default if value is None: return None try: return six.text_type(value) except Exception: raise exceptions.ContractViolationException( 'Value {0} violates string() contract'.format( format_scalar(value))) @specs.parameter('value', nullable=True) @specs.method def bool_(value): if value is dsl.NO_VALUE: value = default if value is None: return None return True if value else False @specs.parameter('value', nullable=True) @specs.method def not_null(value): if isinstance(value, TypeScheme.ObjRef): return value if value is None: raise exceptions.ContractViolationException( 'null value violates notNull() contract') return value @specs.parameter('value', nullable=True) @specs.method def error(value): raise exceptions.ContractViolationException('error() contract') @specs.parameter('value', nullable=True) @specs.parameter('predicate', yaqltypes.Lambda(with_context=True)) @specs.parameter('msg', yaqltypes.String(nullable=True)) @specs.method def check(value, predicate, msg=None): if isinstance(value, TypeScheme.ObjRef) or predicate( root_context.create_child_context(), value): return value else: if not msg: msg = "Value {0} doesn't match predicate".format( format_scalar(value)) raise exceptions.ContractViolationException(msg) @specs.parameter('obj', TypeScheme.ObjRef, nullable=True) @specs.name('owned') @specs.method def owned_ref(obj): if obj is None: return None if isinstance(obj, TypeScheme.ObjRef): return obj @specs.parameter('obj', dsl_types.MuranoObject) @specs.method def owned(obj): p = obj.owner while p is not None: if p is this: return obj p = p.owner raise exceptions.ContractViolationException( 'Object {0} violates owned() contract'.format(obj)) @specs.parameter('obj', TypeScheme.ObjRef, nullable=True) @specs.name('not_owned') @specs.method def not_owned_ref(obj): if isinstance(obj, TypeScheme.ObjRef): return obj if obj is None: return None @specs.parameter('obj', dsl_types.MuranoObject) @specs.method def not_owned(obj): try: owned(obj) except exceptions.ContractViolationException: return obj else: raise exceptions.ContractViolationException( 'Object {0} violates notOwned() contract'.format(obj)) @specs.parameter('name', dsl.MuranoTypeParameter(nullable=False, context=root_context)) @specs.parameter('default_name', dsl.MuranoTypeParameter(nullable=True, context=root_context)) @specs.parameter('value', nullable=True) @specs.parameter('version_spec', yaqltypes.String(True)) @specs.method def class_(value, name, default_name=None, version_spec=None): object_store = helpers.get_object_store() if not default_name: default_name = name murano_class = name.type if isinstance(value, TypeScheme.ObjRef): value = value.object_id if value is None: return None if isinstance(value, dsl_types.MuranoObject): obj = value elif isinstance(value, dsl_types.MuranoObjectInterface): obj = value.object elif isinstance(value, utils.MappingType): obj = object_store.load(value, owner, context=root_context, default_type=default_name, scope_type=calling_type) elif isinstance(value, six.string_types): obj = object_store.get(value) if obj is None: if not object_store.initializing: raise exceptions.NoObjectFoundError(value) else: return TypeScheme.ObjRef(value) else: raise exceptions.ContractViolationException( 'Value {0} cannot be represented as class {1}'.format( format_scalar(value), name)) if not helpers.is_instance_of( obj, murano_class.name, version_spec or helpers.get_type(root_context)): raise exceptions.ContractViolationException( 'Object of type {0} is not compatible with ' 'requested type {1}'.format(obj.type.name, murano_class)) return obj @specs.parameter('type_', dsl.MuranoTypeParameter(nullable=False, context=root_context)) @specs.parameter('default_type', dsl.MuranoTypeParameter(nullable=True, context=root_context)) @specs.parameter('value', nullable=True) @specs.parameter('version_spec', yaqltypes.String(True)) @specs.parameter('exclude_properties', yaqltypes.Sequence(nullable=True)) @specs.method def template(engine, value, type_, exclude_properties=None, default_type=None, version_spec=None): object_store = helpers.get_object_store() passkey = None if not default_type: default_type = type_ murano_class = type_.type if value is None: return None if isinstance(value, dsl_types.MuranoObject): obj = value elif isinstance(value, dsl_types.MuranoObjectInterface): obj = value.object elif isinstance(value, utils.MappingType): passkey = utils.create_marker('<Contract Passkey>') if exclude_properties: parsed = helpers.parse_object_definition( value, calling_type, context) props = dsl.to_mutable(parsed['properties'], engine) for p in exclude_properties: helpers.patch_dict(props, p, passkey) parsed['properties'] = props value = helpers.assemble_object_definition(parsed) with helpers.thread_local_attribute( constants.TL_CONTRACT_PASSKEY, passkey): with helpers.thread_local_attribute( constants.TL_OBJECTS_DRY_RUN, True): obj = object_store.load(value, owner, context=context, default_type=default_type, scope_type=calling_type) else: raise exceptions.ContractViolationException( 'Value {0} cannot be represented as class {1}'.format( format_scalar(value), type_)) if not helpers.is_instance_of( obj, murano_class.name, version_spec or helpers.get_type(root_context)): raise exceptions.ContractViolationException( 'Object of type {0} is not compatible with ' 'requested type {1}'.format(obj.type.name, type_)) with helpers.thread_local_attribute(constants.TL_CONTRACT_PASSKEY, passkey): result = serializer.serialize(obj.real_this, object_store.executor, dsl_types.DumpTypes.Mixed) if exclude_properties: for p in exclude_properties: helpers.patch_dict(result, p, utils.NO_VALUE) return result context = root_context.create_child_context() context.register_function(int_) context.register_function(string) context.register_function(bool_) context.register_function(check) context.register_function(not_null) context.register_function(error) context.register_function(class_) context.register_function(template) context.register_function(owned_ref) context.register_function(owned) context.register_function(not_owned_ref) context.register_function(not_owned) return context
def dict_(delegate, *tuples): return delegate('dict', tuples) @specs.method @specs.parameter('collection', yaqltypes.Iterable()) def to_list(collection): return list(collection) def tuple_(*args): return args @specs.parameter('collection', yaqltypes.Iterable()) @specs.parameter('index_expression', yaqltypes.Lambda()) def indexer(collection, index_expression): if isinstance(collection, utils.SequenceType): index = index_expression() if isinstance(index, int) and not isinstance(index, bool): return collection[index] return six.moves.filter(index_expression, collection) @specs.parameter('start', int) @specs.parameter('stop', int, nullable=True) @specs.extension_method def range_(start, stop=None): if stop is None: return itertools.count(start) else:
def prepare_transform_context(root_context, this, owner, default, calling_type): @specs.parameter('value', nullable=True) @specs.method def int_(value): if value is dsl.NO_VALUE: value = default if value is None: return None try: return int(value) except Exception: raise exceptions.ContractViolationException( 'Value {0} violates int() contract'.format( format_scalar(value))) @specs.parameter('value', nullable=True) @specs.method def string(value): if value is dsl.NO_VALUE: value = default if value is None: return None try: return six.text_type(value) except Exception: raise exceptions.ContractViolationException( 'Value {0} violates string() contract'.format( format_scalar(value))) @specs.parameter('value', nullable=True) @specs.method def bool_(value): if value is dsl.NO_VALUE: value = default if value is None: return None return True if value else False @specs.parameter('value', nullable=True) @specs.method def not_null(value): if isinstance(value, TypeScheme.ObjRef): return value if value is None: raise exceptions.ContractViolationException( 'null value violates notNull() contract') return value @specs.parameter('value', nullable=True) @specs.method def error(value): raise exceptions.ContractViolationException('error() contract') @specs.parameter('value', nullable=True) @specs.parameter('predicate', yaqltypes.Lambda(with_context=True)) @specs.parameter('msg', yaqltypes.String(nullable=True)) @specs.method def check(value, predicate, msg=None): if isinstance(value, TypeScheme.ObjRef) or predicate( root_context.create_child_context(), value): return value else: if not msg: msg = "Value {0} doesn't match predicate".format( format_scalar(value)) raise exceptions.ContractViolationException(msg) @specs.parameter('obj', TypeScheme.ObjRef, nullable=True) @specs.name('owned') @specs.method def owned_ref(obj): if obj is None: return None if isinstance(obj, TypeScheme.ObjRef): return obj @specs.parameter('obj', dsl_types.MuranoObject) @specs.method def owned(obj): p = obj.owner while p is not None: if p is this: return obj p = p.owner raise exceptions.ContractViolationException( 'Object {0} violates owned() contract'.format(obj)) @specs.parameter('obj', TypeScheme.ObjRef, nullable=True) @specs.name('not_owned') @specs.method def not_owned_ref(obj): if isinstance(obj, TypeScheme.ObjRef): return obj if obj is None: return None @specs.parameter('obj', dsl_types.MuranoObject) @specs.method def not_owned(obj): try: owned(obj) except exceptions.ContractViolationException: return obj else: raise exceptions.ContractViolationException( 'Object {0} violates notOwned() contract'.format(obj)) @specs.parameter('name', dsl.MuranoTypeParameter( nullable=False, context=root_context)) @specs.parameter('default_name', dsl.MuranoTypeParameter( nullable=True, context=root_context)) @specs.parameter('value', nullable=True) @specs.parameter('version_spec', yaqltypes.String(True)) @specs.method def class_(value, name, default_name=None, version_spec=None): object_store = None if this is None else this.object_store if not default_name: default_name = name murano_class = name.type if value is None: return None if isinstance(value, dsl_types.MuranoObject): obj = value elif isinstance(value, dsl_types.MuranoObjectInterface): obj = value.object elif isinstance(value, utils.MappingType): obj = helpers.instantiate( value, owner, object_store, root_context, calling_type, default_name) elif isinstance(value, six.string_types) and object_store: obj = object_store.get(value) if obj is None: if not object_store.initializing: raise exceptions.NoObjectFoundError(value) else: return TypeScheme.ObjRef(value) else: raise exceptions.ContractViolationException( 'Value {0} cannot be represented as class {1}'.format( format_scalar(value), name)) if not helpers.is_instance_of( obj, murano_class.name, version_spec or helpers.get_type(root_context)): raise exceptions.ContractViolationException( 'Object of type {0} is not compatible with ' 'requested type {1}'.format(obj.type.name, name)) return obj context = root_context.create_child_context() context.register_function(int_) context.register_function(string) context.register_function(bool_) context.register_function(check) context.register_function(not_null) context.register_function(error) context.register_function(class_) context.register_function(owned_ref) context.register_function(owned) context.register_function(not_owned_ref) context.register_function(not_owned) return context
# License for the specific language governing permissions and limitations # under the License. from yaql.language import specs from yaql.language import yaqltypes @specs.parameter('args', yaqltypes.MappingRule()) @specs.no_kwargs def switch(*args): for mapping in args: if mapping.source(): return mapping.destination() @specs.parameter('args', yaqltypes.Lambda()) def select_case(*args): index = 0 for f in args: if f(): return index index += 1 return index @specs.parameter('args', yaqltypes.Lambda()) def select_all_cases(*args): for i, f in enumerate(args): if f(): yield i
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
original_context, mock_context).create_child_context() else: result_context = original_context return result_context def create_root_context(self, runtime_version): root_context = super(MockContextManager, self).create_root_context(runtime_version) constext = root_context.create_child_context() constext.register_function(inject_method_with_str, name='inject') constext.register_function(inject_method_with_yaql_expr, name='inject') constext.register_function(with_original) return constext @specs.parameter('kwargs', yaqltypes.Lambda(with_context=True)) def with_original(context, **kwargs): new_context = context.create_child_context() original_context = context[constants.CTX_ORIGINAL_CONTEXT] for k, v in six.iteritems(kwargs): new_context['$' + k] = v(original_context) return new_context @specs.parameter('target', yaqltypes.AnyOf(dsl.MuranoTypeParameter(), dsl.MuranoObjectParameter())) @specs.parameter('target_method', yaqltypes.String()) @specs.parameter('mock_object', dsl.MuranoObjectParameter()) @specs.parameter('mock_name', yaqltypes.String())
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
return self.compare(self.obj, other.obj) == 0 def __le__(self, other): return self.compare(self.obj, other.obj) <= 0 def __ge__(self, other): return self.compare(self.obj, other.obj) >= 0 def __ne__(self, other): return self.compare(self.obj, other.obj) != 0 outer_self.sorted = sorted(outer_self.collection, key=Comparator) @specs.parameter('collection', yaqltypes.Iterable()) @specs.parameter('predicate', yaqltypes.Lambda()) @specs.method def where(collection, predicate): return six.moves.filter(predicate, collection) @specs.parameter('collection', yaqltypes.Iterable()) @specs.parameter('selector', yaqltypes.Lambda()) @specs.method def select(collection, selector): return six.moves.map(selector, collection) @specs.parameter('collection', yaqltypes.Iterable()) @specs.parameter('attribute', yaqltypes.Keyword(expand=False)) @specs.inject('operator', yaqltypes.Delegate('#operator_.'))
@specs.parameter('items', yaqltypes.Iterable()) @specs.no_kwargs def dict__(items, engine): result = {} for t in items: it = iter(t) key = next(it) value = next(it) result[key] = value utils.limit_memory_usage(engine, (1, result)) return utils.FrozenDict(result) @specs.parameter('collection', yaqltypes.Iterable()) @specs.parameter('key_selector', yaqltypes.Lambda()) @specs.parameter('value_selector', yaqltypes.Lambda()) @specs.method def to_dict(collection, engine, key_selector, value_selector=None): result = {} for t in collection: key = key_selector(t) value = t if value_selector is None else value_selector(t) result[key] = value utils.limit_memory_usage(engine, (1, result)) return result @specs.parameter('d', utils.MappingType, alias='dict') @specs.parameter('key', yaqltypes.Keyword()) @specs.name('#operator_.')
def prepare_context(root_context, this, owner, default): @specs.parameter('value', nullable=True) @specs.method def int_(value): if value is dsl.NO_VALUE: value = default if value is None: return None try: return int(value) except Exception: raise exceptions.ContractViolationException( 'Value {0} violates int() contract'.format(value)) @specs.parameter('value', nullable=True) @specs.method def string(value): if value is dsl.NO_VALUE: value = default if value is None: return None try: return unicode(value) except Exception: raise exceptions.ContractViolationException( 'Value {0} violates string() contract'.format(value)) @specs.parameter('value', nullable=True) @specs.method def bool_(value): if value is dsl.NO_VALUE: value = default if value is None: return None return True if value else False @specs.parameter('value', nullable=True) @specs.method def not_null(value): if isinstance(value, TypeScheme.ObjRef): return value if value is None: raise exceptions.ContractViolationException( 'null value violates notNull() contract') return value @specs.parameter('value', nullable=True) @specs.method def error(value): raise exceptions.ContractViolationException('error() contract') @specs.parameter('value', nullable=True) @specs.parameter('predicate', yaqltypes.Lambda(with_context=True)) @specs.method def check(value, predicate): if isinstance(value, TypeScheme.ObjRef) or predicate( root_context.create_child_context(), value): return value else: raise exceptions.ContractViolationException( "Value {0} doesn't match predicate".format(value)) @specs.parameter('obj', TypeScheme.ObjRef, nullable=True) @specs.name('owned') @specs.method def owned_ref(obj): if obj is None: return None if isinstance(obj, TypeScheme.ObjRef): return obj @specs.parameter('obj', dsl_types.MuranoObject) @specs.method def owned(obj): p = obj.owner while p is not None: if p is this: return obj p = p.owner raise exceptions.ContractViolationException( 'Object {0} violates owned() contract'.format(obj.object_id)) @specs.parameter('obj', TypeScheme.ObjRef, nullable=True) @specs.name('not_owned') @specs.method def not_owned_ref(obj): if isinstance(obj, TypeScheme.ObjRef): return obj if obj is None: return None @specs.parameter('obj', dsl_types.MuranoObject) @specs.method def not_owned(obj): try: owned(obj) except exceptions.ContractViolationException: return obj else: raise exceptions.ContractViolationException( 'Object {0} violates notOwned() contract'.format( obj.object_id)) @specs.parameter('name', dsl.MuranoTypeName(False, root_context)) @specs.parameter('default_name', dsl.MuranoTypeName(True, root_context)) @specs.parameter('value', nullable=True) @specs.parameter('version_spec', yaqltypes.String(True)) @specs.method def class_(value, name, default_name=None, version_spec=None): object_store = this.object_store if not default_name: default_name = name murano_class = name.murano_class if value is None: return None if isinstance(value, dsl_types.MuranoObject): obj = value elif isinstance(value, dsl_types.MuranoObjectInterface): obj = value.object elif isinstance(value, utils.MappingType): if '?' not in value: new_value = { '?': { 'id': uuid.uuid4().hex, 'type': default_name.murano_class.name, 'classVersion': str(default_name.murano_class.version) } } new_value.update(value) value = new_value obj = object_store.load(value, owner, root_context, defaults=default) elif isinstance(value, types.StringTypes): obj = object_store.get(value) if obj is None: if not object_store.initializing: raise exceptions.NoObjectFoundError(value) else: return TypeScheme.ObjRef(value) else: raise exceptions.ContractViolationException( 'Value {0} cannot be represented as class {1}'.format( value, name)) if not helpers.is_instance_of( obj, murano_class.name, version_spec or helpers.get_type(root_context)): raise exceptions.ContractViolationException( 'Object of type {0} is not compatible with ' 'requested type {1}'.format(obj.type.name, name)) return obj context = root_context.create_child_context() context.register_function(int_) context.register_function(string) context.register_function(bool_) context.register_function(check) context.register_function(not_null) context.register_function(error) context.register_function(class_) context.register_function(owned_ref) context.register_function(owned) context.register_function(not_owned_ref) context.register_function(not_owned) return context