Python helpers.get_executor函数代码示例

 def convert(self, value, sender, context, function_spec, engine,
             *args, **kwargs):
     this = helpers.get_this(context)
     if isinstance(this, dsl_types.MuranoObject):
         executor = helpers.get_executor(context)
         return MuranoObjectInterface(this, executor)
     return this

def create_stack_trace(context, include_native_frames=True):
        stacktrace = yaql_integration.call_func(
            context, 'new', 'io.murano.StackTrace',
            includeNativeFrames=include_native_frames)
        executor = helpers.get_executor(context)
        return dsl.MuranoObjectInterface(
            stacktrace, executor)

 def extension_payload(__context, __receiver, *args, **kwargs):
     executor = helpers.get_executor(__context)
     args = tuple(dsl.to_mutable(arg, engine) for arg in args)
     kwargs = dsl.to_mutable(kwargs, engine)
     return helpers.evaluate(murano_method.invoke(
         executor, murano_method.declaring_type,
         (__receiver,) + args, kwargs, __context, True), __context)

 def get_meta(self, context):
     if self._meta_values is None:
         executor = helpers.get_executor()
         context = executor.create_type_context(
             self, caller_context=context)
         self._meta_values = dslmeta.merge_providers(
             self, lambda cls: cls._meta, context)
     return self._meta_values

def op_dot(context, sender, expr, operator):
    executor = helpers.get_executor(context)
    type_context = executor.context_manager.create_class_context(sender.type)
    obj_context = executor.context_manager.create_object_context(sender)
    ctx2 = linked_context.link(
        linked_context.link(context, type_context),
        obj_context)
    return operator(ctx2, sender, expr)

def new(__context, __type_name, __owner=None, __object_name=None, __extra=None, **parameters):
    object_store = helpers.get_object_store(__context)
    executor = helpers.get_executor(__context)
    new_context = __context.create_child_context()
    for key, value in six.iteritems(parameters):
        if utils.is_keyword(key):
            new_context[key] = value
    return __type_name.murano_class.new(__owner, object_store, executor, name=__object_name)(new_context, **parameters)

def dump(obj, serialization_type=serializer.DumpTypes.Serializable,
         ignore_upcasts=True):
    if serialization_type not in serializer.DumpTypes.All:
        raise ValueError('Invalid Serialization Type')
    executor = helpers.get_executor()
    if ignore_upcasts:
        obj = obj.real_this
    return serializer.serialize(obj, executor, serialization_type)

def op_dot(context, receiver, expr, operator):
    executor = helpers.get_executor()
    type_context = executor.context_manager.create_type_context(receiver.type)
    obj_context = executor.context_manager.create_object_context(receiver)
    ctx2 = helpers.link_contexts(
        helpers.link_contexts(context, type_context),
        obj_context)
    return operator(ctx2, receiver, expr)

 def invoke(context, this, *args):
     try:
         executor = helpers.get_executor(context)
         murano_class = helpers.get_type(context)
         return executor.invoke_method(name, this, context, murano_class, *args)
     except exceptions.NoMethodFound:
         raise yaql.exceptions.YaqlExecutionException()
     except exceptions.AmbiguousMethodName:
         raise yaql.exceptions.YaqlExecutionException()

        def __getattr__(self, item):
            executor = self.__executor or helpers.get_executor()

            def func(*args, **kwargs):
                self._insert_instruction()
                return self.__object.type.invoke(
                    item, executor, self.__object, args, kwargs,
                    helpers.get_context())
            return func

 def transform(self, value, this, owner, context, default=None):
     if default is None:
         default = self.default
     executor = helpers.get_executor(context)
     if isinstance(this, dsl_types.MuranoType):
         return self._contract.transform(
             value, executor.create_object_context(this),
             None, None, default, helpers.get_type(context))
     else:
         return self._contract.transform(
             value, executor.create_object_context(
                 this.cast(self._container_type())),
             this, owner, default, helpers.get_type(context))

 def validate(self, value, this, owner, context, default=None):
     if default is None:
         default = self.default
     executor = helpers.get_executor(context)
     if isinstance(this, dsl_types.MuranoClass):
         return self._contract(
             value, executor.create_object_context(this),
             None, None, default)
     else:
         return self._contract(
             value, executor.create_object_context(
                 this.cast(self._container_class())),
             this, owner, default)

    def get_meta(self, context):
        def meta_producer(cls):
            method = cls.methods.get(self.name)
            if method is None:
                return None
            return method._meta

        if self._meta_values is None:
            executor = helpers.get_executor(context)
            context = executor.create_type_context(
                self.declaring_type, caller_context=context)
            self._meta_values = meta.merge_providers(
                self.declaring_type, meta_producer, context)
        return self._meta_values

    def invoke(self, this, args, kwargs, context=None, skip_stub=False):
        if isinstance(this, dsl.MuranoObjectInterface):
            this = this.object
        if this and not self.declaring_type.is_compatible(this):
            raise Exception("'this' must be of compatible type")
        if not this and not self.is_static:
            raise Exception("A class instance is required")

        if isinstance(this, dsl_types.MuranoObject):
            this = this.cast(self.declaring_type)
        else:
            this = self.declaring_type
        executor = helpers.get_executor()
        return executor.invoke_method(
            self, this, context, args, kwargs, skip_stub)

    def load(self, value, parent, context, defaults=None):
        #tmp_store = ObjectStore(self._class_loader, self)

        if value is None:
            return None
        if '?' not in value or 'type' not in value['?']:
            raise ValueError()
        system_key = value['?']
        object_id = system_key['id']
        obj_type = system_key['type']
        class_obj = self._class_loader.get_class(obj_type)
        if not class_obj:
            raise ValueError()
        if object_id in self._store:
            obj = self._store[object_id]
        else:
            obj = class_obj.new(parent, self, context=context,
                                object_id=object_id, defaults=defaults)
            self._store[object_id] = obj
            self._designer_attributes_store[object_id] = \
                ObjectStore._get_designer_attributes(system_key)

        argspec = inspect.getargspec(obj.initialize).args
        if '_context' in argspec:
            value['_context'] = context
        if '_parent' in argspec:
            value['_parent'] = parent

        try:
            if parent is None:
                self._initializing = True
            obj.initialize(**value)
            if parent is None:
                self._initializing = False
                obj.initialize(**value)
        finally:
            if parent is None:
                self._initializing = False

        if not self.initializing:
            executor = helpers.get_executor(context)
            methods = obj.type.find_all_methods('initialize')
            methods.reverse()
            for method in methods:
                method.invoke(executor, obj, {})
        return obj