def __init__(self, definition, target, scope_type):
scope_type = weakref.ref(scope_type)
definition = helpers.list_value(definition)
factories = []
used_types = set()
for d in definition:
if isinstance(d, dict):
if len(d) != 1:
raise ValueError('Invalid Meta format')
name = next(iter(d.keys()))
props = d[name] or {}
else:
name = d
props = {}
type_obj = helpers.resolve_type(name, scope_type())
if type_obj.usage != dsl_types.ClassUsages.Meta:
raise ValueError('Only Meta classes can be attached')
if target not in type_obj.targets:
raise ValueError(
u'Meta class {} is not applicable here'.format(
type_obj.name))
if type_obj in used_types and (
type_obj.cardinality != dsl_types.MetaCardinality.Many):
raise ValueError('Cannot attach several Meta instances '
'with cardinality One')
used_types.add(type_obj)
factory_maker = lambda template: \
lambda context: helpers.get_object_store().load(
template, owner=None,
context=context, scope_type=scope_type())
factories.append(factory_maker({type_obj: props}))
self._meta_factories = factories
self._meta = None
def _register_mpl_classes(self, data, name=None):
type_obj = self._classes.get(name)
if type_obj is not None:
return type_obj
if callable(data):
data = data()
data = helpers.list_value(data)
unnamed_class = None
last_ns = {}
for cls_data in data:
last_ns = cls_data.setdefault('Namespaces', last_ns.copy())
if len(cls_data) == 1:
continue
cls_name = cls_data.get('Name')
if not cls_name:
if unnamed_class:
raise exceptions.AmbiguousClassName(name)
unnamed_class = cls_data
else:
ns_resolver = namespace_resolver.NamespaceResolver(last_ns)
cls_name = ns_resolver.resolve_name(cls_name)
if cls_name == name:
type_obj = murano_type.create(cls_data, self, cls_name,
ns_resolver)
self._classes[name] = type_obj
else:
self._load_queue.setdefault(cls_name, cls_data)
if type_obj is None and unnamed_class:
unnamed_class['Name'] = name
return self._register_mpl_classes(unnamed_class, name)
return type_obj
def _register_mpl_classes(self, data, name=None):
type_obj = self._classes.get(name)
if type_obj is not None:
return type_obj
if callable(data):
data = data()
data = helpers.list_value(data)
unnamed_class = None
last_ns = {}
for cls_data in data:
last_ns = cls_data.setdefault('Namespaces', last_ns.copy())
if len(cls_data) == 1:
continue
cls_name = cls_data.get('Name')
if not cls_name:
if unnamed_class:
raise exceptions.AmbiguousClassName(name)
unnamed_class = cls_data
else:
ns_resolver = namespace_resolver.NamespaceResolver(last_ns)
cls_name = ns_resolver.resolve_name(cls_name)
if cls_name == name:
type_obj = murano_type.create(
cls_data, self, cls_name, ns_resolver)
self._classes[name] = type_obj
else:
self._load_queue.setdefault(cls_name, cls_data)
if type_obj is None and unnamed_class:
unnamed_class['Name'] = name
return self._register_mpl_classes(unnamed_class, name)
return type_obj
def __init__(self, definition, target, scope_type):
scope_type = weakref.ref(scope_type)
definition = helpers.list_value(definition)
factories = []
used_types = set()
for d in definition:
if isinstance(d, dict):
if len(d) != 1:
raise ValueError('Invalid Meta format')
name = next(iter(d.keys()))
props = d[name] or {}
else:
name = d
props = {}
type_obj = helpers.resolve_type(name, scope_type())
if type_obj.usage != dsl_types.ClassUsages.Meta:
raise ValueError('Only Meta classes can be attached')
if target not in type_obj.targets:
raise ValueError(
u'Meta class {} is not applicable here'.format(
type_obj.name))
if type_obj in used_types and (
type_obj.cardinality != dsl_types.MetaCardinality.Many):
raise ValueError('Cannot attach several Meta instances '
'with cardinality One')
used_types.add(type_obj)
factory_maker = lambda template: \
lambda context, store: helpers.instantiate(
template, owner=None, object_store=store,
context=context, scope_type=scope_type())
factories.append(factory_maker({type_obj: props}))
self._meta_factories = factories
self._meta = None
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 _resolve_imports(self, imports):
seen = {self.name}
for imp in helpers.list_value(imports):
if imp in seen:
continue
type = helpers.resolve_type(imp, self)
if type in seen:
continue
seen.add(imp)
seen.add(type)
yield type
def _resolve_imports(self, imports):
seen = {self.name}
for imp in helpers.list_value(imports):
if imp in seen:
continue
type = helpers.resolve_type(imp, self)
if type in seen:
continue
seen.add(imp)
seen.add(type)
yield type
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, body):
body = helpers.list_value(body)
self.code_block = list(map(expressions.parse_expression, body))
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)
def __init__(self, body):
body = helpers.list_value(body)
self.code_block = list(map(expressions.parse_expression, body))
