def _get_contract_factory(cls, action_func):
def payload(context, value, *args, **kwargs):
instance = object.__new__(cls)
instance.value = value
instance.context = context
instance.__init__(*args, **kwargs)
return action_func(instance)
name = yaql_integration.CONVENTION.convert_function_name(cls.name)
try:
init_spec = specs.get_function_definition(
helpers.function(cls.__init__),
name=name,
method=True,
convention=yaql_integration.CONVENTION)
except AttributeError:
init_spec = specs.get_function_definition(lambda self: None,
name=name,
method=True)
init_spec.parameters['self'] = specs.ParameterDefinition(
'self', yaqltypes.PythonType(object, nullable=True), 0)
init_spec.insert_parameter(
specs.ParameterDefinition('?1', yaqltypes.Context(), 0))
init_spec.payload = payload
return init_spec
def _build_mpl_wrapper_function_definition(murano_method):
def payload(__context, __sender, *args, **kwargs):
executor = helpers.get_executor(__context)
return murano_method.invoke(executor, __sender, args, kwargs,
__context, True)
fd = specs.FunctionDefinition(murano_method.name,
payload,
is_function=False,
is_method=True)
for i, (name,
arg_spec) in enumerate(murano_method.arguments_scheme.iteritems(),
2):
p = specs.ParameterDefinition(name,
ContractedValue(arg_spec),
position=i,
default=dsl.NO_VALUE)
fd.parameters[name] = p
fd.set_parameter(
specs.ParameterDefinition('__context', yaqltypes.Context(), 0))
fd.set_parameter(
specs.ParameterDefinition(
'__sender', yaqltypes.PythonType(dsl_types.MuranoObject, False),
1))
return fd
def get_function_definition(func):
body = func
param_type_func = lambda name: _infer_parameter_type(name, None)
is_method = False
if inspect.ismethod(func):
is_method = True
body = func.im_func
param_type_func = lambda name: _infer_parameter_type(
name, func.im_class.__name__)
fd = specs.get_function_definition(body,
convention=CONVENTION,
parameter_type_func=param_type_func)
if is_method:
fd.is_method = True
fd.is_function = False
fd.set_parameter(0,
yaqltypes.PythonType(func.im_class),
overwrite=True)
name = getattr(func, '__murano_name', None)
if name:
fd.name = name
fd.insert_parameter(specs.ParameterDefinition('?1', yaqltypes.Context(),
0))
def payload(__context, *args, **kwargs):
with helpers.contextual(__context):
return body(*args, **kwargs)
fd.payload = payload
return fd
def _create_basic_mpl_stub(murano_method, reserve_params, payload,
check_first_arg):
fd = specs.FunctionDefinition(murano_method.name,
payload,
is_function=False,
is_method=True)
i = reserve_params + 1
varargs = False
kwargs = False
for name, arg_spec in murano_method.arguments_scheme.items():
position = i
if arg_spec.usage == dsl_types.MethodArgumentUsages.VarArgs:
name = '*'
varargs = True
elif arg_spec.usage == dsl_types.MethodArgumentUsages.KwArgs:
name = '**'
position = None
kwargs = True
p = specs.ParameterDefinition(
name,
ContractedValue(arg_spec, with_check=check_first_arg),
position=position,
default=dsl.NO_VALUE)
check_first_arg = False
fd.parameters[name] = p
i += 1
if not varargs:
fd.parameters['*'] = specs.ParameterDefinition(
'*',
value_type=yaqltypes.PythonType(object, nullable=True),
position=i)
if not kwargs:
fd.parameters['**'] = specs.ParameterDefinition(
'**', value_type=yaqltypes.PythonType(object, nullable=True))
fd.set_parameter(
specs.ParameterDefinition('__context', yaqltypes.Context(), 0))
fd.meta[constants.META_MURANO_METHOD] = murano_method
return fd
def get_function_definition(func, murano_method, original_name):
cls = murano_method.declaring_type.extension_class
def param_type_func(name):
return None if not cls else _infer_parameter_type(name, cls.__name__)
body = func
if (cls is None or helpers.inspect_is_method(cls, original_name)
or helpers.inspect_is_classmethod(cls, original_name)):
body = helpers.function(func)
fd = specs.get_function_definition(body,
convention=CONVENTION,
parameter_type_func=param_type_func)
fd.is_method = True
fd.is_function = False
if not cls or helpers.inspect_is_method(cls, original_name):
fd.set_parameter(0,
dsl.MuranoObjectParameter(
murano_method.declaring_type),
overwrite=True)
if cls and helpers.inspect_is_classmethod(cls, original_name):
_remove_first_parameter(fd)
body = func
name = getattr(func, '__murano_name', None)
if name:
fd.name = name
fd.insert_parameter(specs.ParameterDefinition('?1', yaqltypes.Context(),
0))
is_static = cls and (helpers.inspect_is_static(cls, original_name)
or helpers.inspect_is_classmethod(cls, original_name))
if is_static:
fd.insert_parameter(
specs.ParameterDefinition('?2', yaqltypes.PythonType(object), 1))
def payload(__context, __self, *args, **kwargs):
with helpers.contextual(__context):
__context[constants.CTX_NAMES_SCOPE] = \
murano_method.declaring_type
return body(__self.extension, *args, **kwargs)
def static_payload(__context, __receiver, *args, **kwargs):
with helpers.contextual(__context):
__context[constants.CTX_NAMES_SCOPE] = \
murano_method.declaring_type
return body(*args, **kwargs)
if is_static:
fd.payload = static_payload
else:
fd.payload = payload
fd.meta[constants.META_MURANO_METHOD] = murano_method
return fd
# third part of random name up to 2 chars
# (1295 is last 2-digit number in base-36, 1296 is first 3-digit number)
suffix = helpers.int2base(counter, 36)
_random_string_counter = (counter + 1) % 1296
return prefix + timestamp + suffix
def _name(context):
name = context.get_data[
catalog_forms.WF_MANAGEMENT_NAME]['application_name']
return name
@specs.parameter('template_name', yaqltypes.String())
@specs.parameter('parameter_name', yaqltypes.String(nullable=True))
@specs.parameter('id_only', yaqltypes.PythonType(bool, nullable=True))
def _ref(context, template_name, parameter_name=None, id_only=None):
service = context['?service']
data = None
if not parameter_name:
parameter_name = template_name
# add special symbol to avoid collisions with regular parameters
# and prevent it from overwriting '?service' context variable
parameter_name = '#' + parameter_name
if parameter_name in service.parameters:
data = service.parameters[parameter_name]
elif template_name in service.templates:
data = helpers.evaluate(service.templates[template_name], context)
service.parameters[parameter_name] = data
if not isinstance(data, dict):
return None
Execution exception: Assertion failed
yaql> 12.assert($ < 20)
12
yaql> [].assert($, "Failed assertion")
Execution exception: Failed assertion
"""
if utils.is_iterator(obj):
obj = utils.memorize(obj, engine)
if not condition(obj):
raise AssertionError(message)
return obj
@specs.name('#call')
@specs.parameter('callable_',
yaqltypes.PythonType(object, False, validators=(callable, )))
def call(callable_, *args, **kwargs):
""":yaql:call
Evaluates function with specified args and kwargs and returns the
result.
This function is used to transform expressions like '$foo(args, kwargs)'
to '#call($foo, args, kwargs)'.
Note that to use this functionality 'delegate' mode has to be enabled.
:signature: call(callable, args, kwargs)
:arg callable: callable function
:argType callable: python type
:arg args: sequence of items to be used for calling
:argType args: sequence
:arg kwargs: dictionary with kwargs to be used for calling
def set_parameter(self,
name,
value_type=None,
nullable=None,
alias=None,
overwrite=False):
if isinstance(name, ParameterDefinition):
if name.name in self.parameters and not overwrite:
raise exceptions.DuplicateParameterDecoratorException(
function_name=self.name or self.payload.__name__,
param_name=name.name)
self.parameters[name.name] = name
return name
if six.PY2:
spec = inspect.getargspec(self.payload)
if isinstance(name, int):
if 0 <= name < len(spec.args):
name = spec.args[name]
elif name == len(spec.args) and spec.varargs is not None:
name = spec.varargs
else:
raise IndexError('argument position is out of range')
arg_name = name
if name == spec.keywords:
position = None
arg_name = '**'
elif name == spec.varargs:
position = len(spec.args)
arg_name = '*'
elif name not in spec.args:
raise exceptions.NoParameterFoundException(
function_name=self.name or self.payload.__name__,
param_name=name)
else:
position = spec.args.index(name)
default = NO_DEFAULT
if spec.defaults is not None and name in spec.args:
index = spec.args.index(name) - len(spec.args)
if index >= -len(spec.defaults):
default = spec.defaults[index]
else:
spec = inspect.getfullargspec(self.payload)
if isinstance(name, int):
if 0 <= name < len(spec.args):
name = spec.args[name]
elif name == len(spec.args) and spec.varargs is not None:
name = spec.varargs
else:
raise IndexError('argument position is out of range')
arg_name = name
if name == spec.varkw:
position = None
arg_name = '**'
elif name == spec.varargs:
position = len(spec.args)
arg_name = '*'
elif name in spec.kwonlyargs:
position = None
elif name not in spec.args:
raise exceptions.NoParameterFoundException(
function_name=self.name or self.payload.__name__,
param_name=name)
else:
position = spec.args.index(name)
default = NO_DEFAULT
if spec.defaults is not None and name in spec.args:
index = spec.args.index(name) - len(spec.args)
if index >= -len(spec.defaults):
default = spec.defaults[index]
elif spec.kwonlydefaults is not None:
default = spec.kwonlydefaults.get(name, NO_DEFAULT)
if arg_name in self.parameters and not overwrite:
raise exceptions.DuplicateParameterDecoratorException(
function_name=self.name or self.payload.__name__,
param_name=name)
yaql_type = value_type
p_nullable = nullable
if value_type is None:
if p_nullable is None:
p_nullable = True
base_type = object \
if default in (None, NO_DEFAULT, utils.NO_VALUE) \
else type(default)
yaql_type = yaqltypes.PythonType(base_type, p_nullable)
elif not isinstance(value_type, yaqltypes.SmartType):
if p_nullable is None:
p_nullable = default is None
yaql_type = yaqltypes.PythonType(value_type, p_nullable)
pd = ParameterDefinition(name, yaql_type, position, alias, default)
self.parameters[arg_name] = pd
return pd
return right(left)
@specs.method
@specs.parameter('condition', yaqltypes.Lambda())
@specs.parameter('message', yaqltypes.String())
def assert__(engine, obj, condition, message=u'Assertion failed'):
if utils.is_iterator(obj):
obj = utils.memorize(obj, engine)
if not condition(obj):
raise AssertionError(message)
return obj
@specs.name('#call')
@specs.parameter('callable_', yaqltypes.PythonType(
object, False, validators=(six.callable,)))
def call(callable_, *args, **kwargs):
return callable_(*args, **kwargs)
@specs.parameter('func', yaqltypes.Lambda())
def lambda_(func):
return func
@specs.name('#operator_.')
@specs.parameter('name', yaqltypes.Keyword())
@specs.inject('func', yaqltypes.Delegate(use_convention=False))
def get_property(func, obj, name):
func_name = '#property#{0}'.format(name)
return func(func_name, obj)
