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 __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)