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 __init__(self, ns_resolver, name, package, parents, meta=None,
imports=None):
super(MuranoClass, self).__init__(ns_resolver, name, package)
self._methods = {}
self._properties = {}
self._config = {}
self._extension_class = None
if (self._name == constants.CORE_LIBRARY_OBJECT or
parents is utils.NO_VALUE):
self._parents = []
else:
self._parents = parents or [
package.find_class(constants.CORE_LIBRARY_OBJECT)]
for p in self._parents:
if p.usage not in self._allowed_usages:
raise exceptions.InvalidInheritanceError(
u'Type {0} cannot have parent with Usage {1}'.format(
self.name, p.usage))
remappings = self._build_parent_remappings()
self._parents = self._adjusted_parents(remappings)
self._context = None
self._exported_context = None
self._meta = dslmeta.MetaData(meta, dsl_types.MetaTargets.Type, self)
self._meta_values = None
self._imports = list(self._resolve_imports(imports))
def __init__(self,
package_loader,
name,
version=None,
runtime_version=None,
requirements=None,
meta=None):
super(MuranoPackage, self).__init__()
self._package_loader = weakref.proxy(package_loader)
self._name = name
self._version = helpers.parse_version(version)
self._runtime_version = helpers.parse_version(runtime_version)
self._requirements = {
name: semantic_version.Spec('==' + str(self._version.major))
}
if name != constants.CORE_LIBRARY:
self._requirements[constants.CORE_LIBRARY] = \
semantic_version.Spec('==0')
self._classes = {}
self._imported_types = {object, murano_object.MuranoObject}
for key, value in six.iteritems(requirements or {}):
self._requirements[key] = helpers.parse_version_spec(value)
self._load_queue = {}
self._native_load_queue = {}
if self.name == constants.CORE_LIBRARY:
principal_objects.register(self)
self._package_class = self._create_package_class()
self._meta = lambda: dslmeta.MetaData(meta, dsl_types.MetaTargets.
Package, self._package_class)
def __init__(self, declaring_type, property_name, declaration):
super(MuranoProperty, self).__init__(declaration, declaring_type)
self._property_name = property_name
self._declaring_type = weakref.ref(declaring_type)
self._meta = meta.MetaData(declaration.get('Meta'),
dsl_types.MetaTargets.Property,
declaring_type)
self._meta_values = None
def __init__(self, murano_method, method_name, arg_name, declaration):
super(MuranoMethodArgument,
self).__init__(declaration, murano_method.declaring_type)
self._method_name = method_name
self._arg_name = arg_name
self._murano_method = weakref.ref(murano_method)
self._meta = meta.MetaData(declaration.get('Meta'),
dsl_types.MetaTargets.Argument,
self.murano_method.declaring_type)
def __init__(self, declaring_type, property_name, declaration):
super(MuranoProperty, self).__init__(declaration, declaring_type)
self._property_name = property_name
self._declaring_type = weakref.ref(declaring_type)
self._usage = declaration.get('Usage') or dsl_types.PropertyUsages.In
if self._usage not in dsl_types.PropertyUsages.All:
raise exceptions.DslSyntaxError(
'Unknown usage {0}. Must be one of ({1})'.format(
self._usage, ', '.join(dsl_types.PropertyUsages.All)))
self._meta = meta.MetaData(declaration.get('Meta'),
dsl_types.MetaTargets.Property,
declaring_type)
self._meta_values = None
def __init__(self, murano_method, method_name, arg_name, declaration):
super(MuranoMethodArgument,
self).__init__(declaration, murano_method.declaring_type)
self._method_name = method_name
self._arg_name = arg_name
self._murano_method = weakref.ref(murano_method)
self._meta = meta.MetaData(declaration.get('Meta'),
dsl_types.MetaTargets.Argument,
self.murano_method.declaring_type)
self._usage = declaration.get('Usage') or \
dsl_types.MethodArgumentUsages.Standard
if self._usage not in dsl_types.MethodArgumentUsages.All:
raise exceptions.DslSyntaxError(
'Unknown usage {0}. Must be one of ({1})'.format(
self._usage,
', '.join(dsl_types.MethodArgumentUsages.All)))
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)
