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)