Process both the istio_mesh instance and process_mixer instance associated with this instance
970743
def check(self, instance):
        

        # Get the config for the istio_mesh instance
        istio_mesh_endpoint = instance.get('istio_mesh_endpoint')
        istio_mesh_config = self.config_map[istio_mesh_endpoint]

        # Process istio_mesh
        self.process(istio_mesh_config)

        # Get the config for the process_mixer instance
        process_mixer_endpoint = instance.get('mixer_endpoint')
        process_mixer_config = self.config_map[process_mixer_endpoint]

        # Process process_mixer
        self.process(process_mixer_config)
1011680
def process(self):
        
        self.modules.sort(key=lambda x: x.priority)

        for module in self.modules:
            transforms = module.transform(self.data)
            transforms.sort(key=lambda x: x.linenum, reverse=True)

            for transform in transforms:
                linenum = transform.linenum

                if isinstance(transform.data, basestring):
                    transform.data = [transform.data]

                if transform.oper == "prepend":
                    self.data[linenum:linenum] = transform.data

                elif transform.oper == "append":
                    self.data[linenum+1:linenum+1] = transform.data

                elif transform.oper == "swap":
                    self.data[linenum:linenum+1] = transform.data

                elif transform.oper == "drop":
                    self.data[linenum:linenum+1] = []

                elif transform.oper == "noop":
                    pass
992836
def process(self, processor:PreProcessors=None):
        ""
        if processor is not None: self.processor = processor
        self.processor = listify(self.processor)
        for p in self.processor: p.process(self)
        return self
1055944
private B newProcessBuilder(Class[] param_types, Object[] params)
    {
        if (process_builder_class != null)
        {
            try
            {
                Constructor<B> constructor = process_builder_class.getDeclaredConstructor(param_types);
                return constructor.newInstance(params);
            }
            catch (Exception e)
            {
                throw new QueujException(e);
            }
        }

        if (parent_queue != null)
            return (B)parent_queue.newProcessBuilder(param_types, params);

        // else
        throw new QueujException("No ProcessBuilder exists for Queue");
    }
312308
def from_events(self, instance, ev_args, ctx):
        
        obj = yield from self._process(instance, ev_args, ctx)
        self.__set__(instance, obj)
        return obj
712319
def process(self):
        ""
        xp,yp = self.get_processors()
        for ds,n in zip(self.lists, ['train','valid','test']): ds.process(xp, yp, name=n)
        #progress_bar clear the outputs so in some case warnings issued during processing disappear.
        for ds in self.lists:
            if getattr(ds, 'warn', False): warn(ds.warn)
        return self
935034
private void processOnce() throws CompilationFailedException, IOException, URISyntaxException {
        GroovyShell groovy = new GroovyShell(conf);
        setupContextClassLoader(groovy);
        groovy.run(getScriptSource(isScriptFile, script), args);
    }
521679
def _create_process_mixer_instance(self, instance):
        
        endpoint = instance.get('mixer_endpoint')
        if endpoint is None:
            raise CheckException("Unable to find mixer_endpoint in config file.")

        process_mixer_instance = deepcopy(instance)
        process_mixer_instance.update(
            {
                'namespace': self.MIXER_NAMESPACE,
                'prometheus_url': endpoint,
                'metrics': [
                    {
                        'go_gc_duration_seconds': 'go.gc_duration_seconds',
                        'go_goroutines': 'go.goroutines',
                        'go_info': 'go.info',
                        'go_memstats_alloc_bytes': 'go.memstats.alloc_bytes',
                        'go_memstats_alloc_bytes_total': 'go.memstats.alloc_bytes_total',
                        'go_memstats_buck_hash_sys_bytes': 'go.memstats.buck_hash_sys_bytes',
                        'go_memstats_frees_total': 'go.memstats.frees_total',
                        'go_memstats_gc_cpu_fraction': 'go.memstats.gc_cpu_fraction',
                        'go_memstats_gc_sys_bytes': 'go.memstats.gc_sys_bytes',
                        'go_memstats_heap_alloc_bytes': 'go.memstats.heap_alloc_bytes',
                        'go_memstats_heap_idle_bytes': 'go.memstats.heap_idle_bytes',
                        'go_memstats_heap_inuse_bytes': 'go.memstats.heap_inuse_bytes',
                        'go_memstats_heap_objects': 'go.memstats.heap_objects',
                        'go_memstats_heap_released_bytes': 'go.memstats.heap_released_bytes',
                        'go_memstats_heap_sys_bytes': 'go.memstats.heap_sys_bytes',
                        'go_memstats_last_gc_time_seconds': 'go.memstats.last_gc_time_seconds',
                        'go_memstats_lookups_total': 'go.memstats.lookups_total',
                        'go_memstats_mallocs_total': 'go.memstats.mallocs_total',
                        'go_memstats_mcache_inuse_bytes': 'go.memstats.mcache_inuse_bytes',
                        'go_memstats_mcache_sys_bytes': 'go.memstats.mcache_sys_bytes',
                        'go_memstats_mspan_inuse_bytes': 'go.memstats.mspan_inuse_bytes',
                        'go_memstats_mspan_sys_bytes': 'go.memstats.mspan_sys_bytes',
                        'go_memstats_next_gc_bytes': 'go.memstats.next_gc_bytes',
                        'go_memstats_other_sys_bytes': 'go.memstats.other_sys_bytes',
                        'go_memstats_stack_inuse_bytes': 'go.memstats.stack_inuse_bytes',
                        'go_memstats_stack_sys_bytes': 'go.memstats.stack_sys_bytes',
                        'go_memstats_sys_bytes': 'go.memstats.sys_bytes',
                        'go_threads': 'go.threads',
                        'grpc_server_handled_total': 'grpc.server.handled_total',
                        'grpc_server_handling_seconds': 'grpc.server.handling_seconds',
                        'grpc_server_msg_received_total': 'grpc.server.msg_received_total',
                        'grpc_server_msg_sent_total': 'grpc.server.msg_sent_total',
                        'grpc_server_started_total': 'grpc.server.started_total',
                        'mixer_adapter_dispatch_count': 'adapter.dispatch_count',
                        'mixer_adapter_dispatch_duration': 'adapter.dispatch_duration',
                        'mixer_adapter_old_dispatch_count': 'adapter.old_dispatch_count',
                        'mixer_adapter_old_dispatch_duration': 'adapter.old_dispatch_duration',
                        'mixer_config_resolve_actions': 'config.resolve_actions',
                        'mixer_config_resolve_count': 'config.resolve_count',
                        'mixer_config_resolve_duration': 'config.resolve_duration',
                        'mixer_config_resolve_rules': 'config.resolve_rules',
                        'process_cpu_seconds_total': 'process.cpu_seconds_total',
                        'process_max_fds': 'process.max_fds',
                        'process_open_fds': 'process.open_fds',
                        'process_resident_memory_bytes': 'process.resident_memory_bytes',
                        'process_start_time_seconds': 'process.start_time_seconds',
                        'process_virtual_memory_bytes': 'process.virtual_memory_bytes',
                    }
                ],
                # Defaults that were set when istio was based on PrometheusCheck
                'send_monotonic_counter': instance.get('send_monotonic_counter', False),
                'health_service_check': instance.get('health_service_check', False),
            }
        )

        return process_mixer_instance
697202
def build_sink_async(coro=None, *, mode=None, unpack: bool = False):
    
    _mode = mode

    def _build_sink_async(coro):
        @wraps(coro)
        def _wrapper(*args, mode=None, **kwargs) -> SinkAsync:
            if 'unpack' in kwargs:
                raise TypeError('"unpack" has to be defined by decorator')
            if mode is None:
                mode = MODE.CONCURRENT if _mode is None else _mode
            return SinkAsync(coro, *args, mode=mode, unpack=unpack, **kwargs)
        return _wrapper

    if coro:
        return _build_sink_async(coro)

    return _build_sink_async
993647
def mix1(servo1, servo2, mixtype=1, gain=0.5):
    ''''''
    (v1,v2) = mixer(servo1, servo2, mixtype=mixtype, gain=gain)
    return v1
999426
protected void parseProcessEnginePlugins(Element element, List<ProcessEnginePluginXml> plugins) {
    for (Element chidElement : element.elements()) {
      if(PLUGIN.equals(chidElement.getTagName())) {
        parseProcessEnginePlugin(chidElement, plugins);
      }
    }
  }
1025284
public function process() : void
    {
        if (isset($this->output)) {
            $this->output->call($this);
        } elseif (!$this->delegated) {
            self::$inout->error("Recipe is missing a call to `output` and did not delegate anything, not very useful probably...\n");
        }
    }
1244565
def process(self):
        """"""

        super(NativeBLEVirtualInterface, self).process()

        if (not self._stream_sm_running) and (not self.reports.empty()):
            self._stream_data()

        if (not self._trace_sm_running) and (not self.traces.empty()):
            self._send_trace()
623075
private Component applyPostProcessors(Component in, Context context, Arguments args)
    {
        Component out = in;

        for (final PostProcessor postProcessor : postProcessors)
        {
            out = postProcessor.process(out, context, args);
        }

        return out;
    }
791258
def runInParallel(*fns):
        
        proc = []
        for fn in fns:
            p = Process(target=fn)
            p.start()
            proc.append(p)
        for p in proc:
            p.join()
1107595
protected function _process()
	{
		$iface = 'MShop_Context_Item_Interface';
		if( !( $this->_additional instanceof $iface ) ) {
			throw new MW_Setup_Exception( sprintf( 'Additionally provided object is not of type "%1$s"', $iface ) );
		}

		$this->_msg( 'Adding default plugin data', 0 );
		$this->_status( '' );


		$ds = DIRECTORY_SEPARATOR;
		$pluginManager = MShop_Plugin_Manager_Factory::createManager( $this->_additional, 'Default' );


		$filename = dirname( __FILE__ ) . $ds . 'default'.  $ds . 'data'. $ds . 'plugin.php';

		if( ( $data = include( $filename ) ) == false ) {
			throw new MW_Setup_Exception( sprintf( 'No data file "%1$s" found', $filename ) );
		}

		if( isset( $data['plugin'] ) ) {
			$this->_addPluginData( $pluginManager, $data['plugin'] );
		}
	}
985757
def compose(other, *args)
      outcome = other.run(*args)

      raise Interrupt, outcome.errors if outcome.invalid?

      outcome.result
    end