def _register_native_class(self, cls, name):
if cls in self._imported_types:
return self._classes[name]
try:
m_class = self.find_class(name, False)
except exceptions.NoClassFound:
m_class = self._register_mpl_classes({'Name': name}, name)
m_class.extension_class = cls
for method_name in dir(cls):
if method_name.startswith('_'):
continue
method = getattr(cls, method_name)
if not any((helpers.inspect_is_method(cls, method_name),
helpers.inspect_is_static(cls, method_name),
helpers.inspect_is_classmethod(cls, method_name))):
continue
method_name_alias = (getattr(method, '__murano_name', None)
or specs.convert_function_name(
method_name, yaql_integration.CONVENTION))
m_class.add_method(method_name_alias, method, method_name)
self._imported_types.add(cls)
return m_class
def _register_native_class(self, cls, name):
if cls in self._imported_types:
return self._classes[name]
try:
m_class = self.find_class(name, False)
except exceptions.NoClassFound:
m_class = self._register_mpl_classes({'Name': name}, name)
m_class.extension_class = cls
for method_name in dir(cls):
if method_name.startswith('_'):
continue
method = getattr(cls, method_name)
if not any((
helpers.inspect_is_method(cls, method_name),
helpers.inspect_is_static(cls, method_name),
helpers.inspect_is_classmethod(cls, method_name))):
continue
method_name_alias = (getattr(
method, '__murano_name', None) or
specs.convert_function_name(
method_name, yaql_integration.CONVENTION))
m_class.add_method(method_name_alias, method, method_name)
self._imported_types.add(cls)
return m_class
def __init__(self, declaring_type, name, payload, original_name=None):
self._name = name
original_name = original_name or name
self._declaring_type = weakref.ref(declaring_type)
self._meta_values = None
if callable(payload):
if isinstance(payload, specs.FunctionDefinition):
self._body = payload
else:
self._body = yaql_integration.get_function_definition(
payload, weakref.proxy(self), original_name)
self._arguments_scheme = None
if any(
(helpers.inspect_is_static(declaring_type.extension_class,
original_name),
helpers.inspect_is_classmethod(declaring_type.extension_class,
original_name))):
self._usage = self._body.meta.get(
constants.META_USAGE, dsl_types.MethodUsages.Static)
if self._usage not in dsl_types.MethodUsages.StaticMethods:
raise ValueError('Invalid Usage for static method ' +
self.name)
else:
self._usage = (self._body.meta.get(constants.META_USAGE)
or dsl_types.MethodUsages.Runtime)
if self._usage not in dsl_types.MethodUsages.InstanceMethods:
raise ValueError('Invalid Usage for instance method ' +
self.name)
if (self._body.name.startswith('#')
or self._body.name.startswith('*')):
raise ValueError(
'Import of special yaql functions is forbidden')
self._meta = meta.MetaData(
self._body.meta.get(constants.META_MPL_META),
dsl_types.MetaTargets.Method, declaring_type)
else:
payload = payload or {}
self._body = macros.MethodBlock(payload.get('Body'), name)
self._usage = payload.get(
'Usage') or dsl_types.MethodUsages.Runtime
arguments_scheme = helpers.list_value(payload.get('Arguments'))
if isinstance(arguments_scheme, dict):
arguments_scheme = [{
key: value
} for key, value in six.iteritems(arguments_scheme)]
self._arguments_scheme = collections.OrderedDict()
for record in arguments_scheme:
if (not isinstance(record, dict) or len(record) > 1):
raise ValueError()
name = list(record.keys())[0]
self._arguments_scheme[name] = MuranoMethodArgument(
self, self.name, name, record[name])
self._meta = meta.MetaData(payload.get('Meta'),
dsl_types.MetaTargets.Method,
declaring_type)
self._instance_stub, self._static_stub = \
yaql_integration.build_stub_function_definitions(
weakref.proxy(self))
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_function_definition(func, murano_method, original_name):
cls = murano_method.declaring_type.extension_class
param_type_func = \
lambda name: 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 __init__(self, declaring_type, name, payload, original_name=None,
ephemeral=False):
self._name = name
original_name = original_name or name
self._declaring_type = weakref.ref(declaring_type)
self._meta_values = None
self_ref = self if ephemeral else weakref.proxy(self)
if callable(payload):
if isinstance(payload, specs.FunctionDefinition):
self._body = payload
else:
self._body = yaql_integration.get_function_definition(
payload, self_ref, original_name)
self._arguments_scheme = None
if declaring_type.extension_class and any((
helpers.inspect_is_static(
declaring_type.extension_class, original_name),
helpers.inspect_is_classmethod(
declaring_type.extension_class, original_name))):
self._usage = self._body.meta.get(
constants.META_USAGE, dsl_types.MethodUsages.Static)
if self._usage not in dsl_types.MethodUsages.StaticMethods:
raise ValueError(
'Invalid Usage for static method ' + self.name)
else:
self._usage = (self._body.meta.get(constants.META_USAGE) or
dsl_types.MethodUsages.Runtime)
if self._usage not in dsl_types.MethodUsages.InstanceMethods:
raise ValueError(
'Invalid Usage for instance method ' + self.name)
if (self._body.name.startswith('#') or
self._body.name.startswith('*')):
raise ValueError(
'Import of special yaql functions is forbidden')
self._meta = meta.MetaData(
self._body.meta.get(constants.META_MPL_META),
dsl_types.MetaTargets.Method,
declaring_type)
else:
payload = payload or {}
self._body = macros.MethodBlock(payload.get('Body'), name)
self._usage = payload.get(
'Usage') or dsl_types.MethodUsages.Runtime
arguments_scheme = helpers.list_value(payload.get('Arguments'))
if isinstance(arguments_scheme, dict):
arguments_scheme = [{key: value} for key, value in
six.iteritems(arguments_scheme)]
self._arguments_scheme = collections.OrderedDict()
for record in arguments_scheme:
if (not isinstance(record, dict) or
len(record) > 1):
raise ValueError()
name = list(record.keys())[0]
self._arguments_scheme[name] = MuranoMethodArgument(
self, self.name, name, record[name])
self._meta = meta.MetaData(
payload.get('Meta'),
dsl_types.MetaTargets.Method,
declaring_type)
self._instance_stub, self._static_stub = \
yaql_integration.build_stub_function_definitions(self_ref)
def __init__(self,
declaring_type,
name,
payload,
original_name=None,
ephemeral=False):
self._name = name
original_name = original_name or name
self._declaring_type = weakref.ref(declaring_type)
self._meta_values = None
self_ref = self if ephemeral else weakref.proxy(self)
if callable(payload):
if isinstance(payload, specs.FunctionDefinition):
self._body = payload
else:
self._body = yaql_integration.get_function_definition(
payload, self_ref, original_name)
self._arguments_scheme = None
self._scope = self._body.meta.get(constants.META_SCOPE)
if declaring_type.extension_class and any(
(helpers.inspect_is_static(declaring_type.extension_class,
original_name),
helpers.inspect_is_classmethod(declaring_type.extension_class,
original_name))):
self._usage = self._body.meta.get(
constants.META_USAGE, dsl_types.MethodUsages.Static)
if self._usage not in dsl_types.MethodUsages.StaticMethods:
raise ValueError('Invalid Usage for static method ' +
self.name)
else:
self._usage = (self._body.meta.get(constants.META_USAGE)
or dsl_types.MethodUsages.Runtime)
if self._usage not in dsl_types.MethodUsages.InstanceMethods:
raise ValueError('Invalid Usage for instance method ' +
self.name)
self._resolve_usage_and_scope()
if self._scope is None:
self._scope = dsl_types.MethodScopes.Session
if (self._body.name.startswith('#')
or self._body.name.startswith('*')):
raise ValueError(
'Import of special yaql functions is forbidden')
self._meta = meta.MetaData(
self._body.meta.get(constants.META_MPL_META),
dsl_types.MetaTargets.Method, declaring_type)
else:
payload = payload or {}
self._body = macros.MethodBlock(payload.get('Body'), name)
self._usage = payload.get(
'Usage') or dsl_types.MethodUsages.Runtime
self._scope = payload.get('Scope')
self._resolve_usage_and_scope()
if self._scope is None:
self._scope = dsl_types.MethodScopes.Session
arguments_scheme = helpers.list_value(payload.get('Arguments'))
if isinstance(arguments_scheme, dict):
arguments_scheme = [{
key: value
} for key, value in arguments_scheme.items()]
self._arguments_scheme = collections.OrderedDict()
seen_varargs = False
seen_kwargs = False
args_order_error = False
for record in arguments_scheme:
if not isinstance(record, dict) or len(record) > 1:
raise exceptions.DslSyntaxError(
'Invalid arguments declaration')
name = list(record.keys())[0]
argument = MuranoMethodArgument(self, self.name, name,
record[name])
usage = argument.usage
if (usage == dsl_types.MethodArgumentUsages.Standard
and (seen_kwargs or seen_varargs)):
args_order_error = True
elif usage == dsl_types.MethodArgumentUsages.VarArgs:
if seen_kwargs or seen_varargs:
args_order_error = True
seen_varargs = True
elif usage == dsl_types.MethodArgumentUsages.KwArgs:
if seen_kwargs:
args_order_error = True
seen_kwargs = True
if args_order_error:
raise exceptions.DslSyntaxError(
'Invalid argument order in method {0}'.format(
self.name))
else:
self._arguments_scheme[name] = argument
self._meta = meta.MetaData(payload.get('Meta'),
dsl_types.MetaTargets.Method,
declaring_type)
self._instance_stub, self._static_stub = \
yaql_integration.build_stub_function_definitions(self_ref)
def __init__(self, declaring_type, name, payload, original_name=None,
ephemeral=False):
self._name = name
original_name = original_name or name
self._declaring_type = weakref.ref(declaring_type)
self._meta_values = None
self_ref = self if ephemeral else weakref.proxy(self)
if callable(payload):
if isinstance(payload, specs.FunctionDefinition):
self._body = payload
else:
self._body = yaql_integration.get_function_definition(
payload, self_ref, original_name)
self._arguments_scheme = None
self._scope = self._body.meta.get(constants.META_SCOPE)
if declaring_type.extension_class and any((
helpers.inspect_is_static(
declaring_type.extension_class, original_name),
helpers.inspect_is_classmethod(
declaring_type.extension_class, original_name))):
self._usage = self._body.meta.get(
constants.META_USAGE, dsl_types.MethodUsages.Static)
if self._usage not in dsl_types.MethodUsages.StaticMethods:
raise ValueError(
'Invalid Usage for static method ' + self.name)
else:
self._usage = (self._body.meta.get(constants.META_USAGE) or
dsl_types.MethodUsages.Runtime)
if self._usage not in dsl_types.MethodUsages.InstanceMethods:
raise ValueError(
'Invalid Usage for instance method ' + self.name)
self._resolve_usage_and_scope()
if self._scope is None:
self._scope = dsl_types.MethodScopes.Session
if (self._body.name.startswith('#') or
self._body.name.startswith('*')):
raise ValueError(
'Import of special yaql functions is forbidden')
self._meta = meta.MetaData(
self._body.meta.get(constants.META_MPL_META),
dsl_types.MetaTargets.Method,
declaring_type)
else:
payload = payload or {}
self._body = macros.MethodBlock(payload.get('Body'), name)
self._usage = payload.get(
'Usage') or dsl_types.MethodUsages.Runtime
self._scope = payload.get('Scope')
self._resolve_usage_and_scope()
if self._scope is None:
self._scope = dsl_types.MethodScopes.Session
arguments_scheme = helpers.list_value(payload.get('Arguments'))
if isinstance(arguments_scheme, dict):
arguments_scheme = [{key: value} for key, value in
six.iteritems(arguments_scheme)]
self._arguments_scheme = collections.OrderedDict()
seen_varargs = False
seen_kwargs = False
args_order_error = False
for record in arguments_scheme:
if not isinstance(record, dict) or len(record) > 1:
raise exceptions.DslSyntaxError(
'Invalid arguments declaration')
name = list(record.keys())[0]
argument = MuranoMethodArgument(
self, self.name, name, record[name])
usage = argument.usage
if (usage == dsl_types.MethodArgumentUsages.Standard and
(seen_kwargs or seen_varargs)):
args_order_error = True
elif usage == dsl_types.MethodArgumentUsages.VarArgs:
if seen_kwargs or seen_varargs:
args_order_error = True
seen_varargs = True
elif usage == dsl_types.MethodArgumentUsages.KwArgs:
if seen_kwargs:
args_order_error = True
seen_kwargs = True
if args_order_error:
raise exceptions.DslSyntaxError(
'Invalid argument order in method {0}'.format(
self.name))
else:
self._arguments_scheme[name] = argument
self._meta = meta.MetaData(
payload.get('Meta'),
dsl_types.MetaTargets.Method,
declaring_type)
self._instance_stub, self._static_stub = \
yaql_integration.build_stub_function_definitions(self_ref)
