def get_class_factory_definition(cls, murano_class): runtime_version = murano_class.package.runtime_version engine = choose_yaql_engine(runtime_version) def payload(__context, __sender, *args, **kwargs): assert __sender is None args = tuple(dsl.to_mutable(arg, engine) for arg in args) kwargs = dsl.to_mutable(kwargs, engine) with helpers.contextual(__context): return cls(*args, **kwargs) if hasattr(cls.__init__, 'im_func'): fd = specs.get_function_definition( cls.__init__.im_func, parameter_type_func=lambda name: _infer_parameter_type( name, cls.__init__.im_class.__name__), convention=CONVENTION) else: fd = specs.get_function_definition(lambda self: None) fd.meta[constants.META_NO_TRACE] = True fd.insert_parameter( specs.ParameterDefinition('?1', yaqltypes.Context(), position=0)) fd.is_method = True fd.is_function = False fd.name = '__init__' fd.payload = payload return fd
def get_class_factory_definition(cls, murano_class): runtime_version = murano_class.package.runtime_version engine = choose_yaql_engine(runtime_version) def payload(__context, __receiver, *args, **kwargs): args = tuple(dsl.to_mutable(arg, engine) for arg in args) kwargs = dsl.to_mutable(kwargs, engine) with helpers.contextual(__context): __context[constants.CTX_NAMES_SCOPE] = murano_class result = helpers.evaluate(cls(*args, **kwargs), __context) __receiver.object.extension = result try: fd = specs.get_function_definition( helpers.function(cls.__init__), parameter_type_func=lambda name: _infer_parameter_type( name, cls.__name__), convention=CONVENTION) except AttributeError: # __init__ is a slot wrapper inherited from object or other C type fd = specs.get_function_definition(lambda self: None) fd.meta[constants.META_NO_TRACE] = True fd.insert_parameter( specs.ParameterDefinition('?1', yaqltypes.Context(), position=0)) fd.is_method = True fd.is_function = False fd.name = '__init__' fd.payload = payload return fd
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 _infer_parameter_type(name): if name == 'context' or name == '__context': return yaqltypes.Context() elif name == 'engine' or name == '__engine': return yaqltypes.Engine() elif name == 'yaql_interface' or name == '__yaql_interface': return yaqltypes.YaqlInterface()
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
def _infer_parameter_type(name, class_name): if name == 'context': return yaqltypes.Context() if name == 'this': return dsl.ThisParameter() if name == 'interfaces': return dsl.InterfacesParameter() if name == 'yaql_engine': return yaqltypes.Engine() if name.startswith('__'): return _infer_parameter_type(name[2:], class_name) if class_name and name.startswith('_{0}__'.format(class_name)): return _infer_parameter_type(name[3 + len(class_name):], class_name)
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) for i, (name, arg_spec) in enumerate( six.iteritems(murano_method.arguments_scheme), reserve_params + 1): p = specs.ParameterDefinition( name, ContractedValue(arg_spec, with_check=check_first_arg), position=i, default=dsl.NO_VALUE) check_first_arg = False fd.parameters[name] = p fd.set_parameter(specs.ParameterDefinition( '__context', yaqltypes.Context(), 0)) fd.meta[constants.META_MURANO_METHOD] = murano_method 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
:signature: with([args]) :arg [args]: values to be stored under appropriate numbers $1, $2, ... :argType [args]: chain of any values :returnType: context object .. code:: yaql> with("ab", "cd") -> $1 + $2 "abcd" """ for i, t in enumerate(args, 1): context[str(i)] = t return context @specs.inject('__context__', yaqltypes.Context()) def let(__context__, *args, **kwargs): """:yaql:let Returns context object where args are stored with 1-based indexes and kwargs values are stored with appropriate keys. :signature: let([args], {kwargs}) :arg [args]: values to be stored under appropriate numbers $1, $2, ... :argType [args]: chain of any values :arg {kwargs}: values to be stored under appropriate keys :argType {kwargs}: chain of mappings :returnType: context object .. code::