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)