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, 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 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_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_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)
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
def _create_static_mpl_stub(murano_method):
def payload(__context, __receiver, *args, **kwargs):
return murano_method.invoke(__receiver, args, kwargs, __context, True)
fd = _create_basic_mpl_stub(murano_method, 1, payload, False)
receiver_type = dsl.MuranoTypeParameter(weakref.proxy(
murano_method.declaring_type),
resolve_strings=False)
fd.set_parameter(specs.ParameterDefinition('__receiver', receiver_type, 1))
return fd
def _create_instance_mpl_stub(murano_method):
def payload(__context, __receiver, *args, **kwargs):
executor = helpers.get_executor(__context)
return murano_method.invoke(
executor, __receiver, args, kwargs, __context, True)
fd = _create_basic_mpl_stub(murano_method, 1, payload, False)
receiver_type = dsl.MuranoObjectParameter(
weakref.proxy(murano_method.declaring_type), decorate=False)
fd.set_parameter(specs.ParameterDefinition('__receiver', receiver_type, 1))
return fd
