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)