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
