Starts the output batch.
542060
void start(Handler<ConnectionOutputBatch> startHandler) {
    connection.doBatchStart(id, args);
    this.startHandler = startHandler;
  }
1009425
def start_transports(self):
        """"""
        self.transport = Transport(
            self.queue, self.batch_size, self.batch_interval,
            self.session_factory)
        thread = threading.Thread(target=self.transport.loop)
        self.threads.append(thread)
        thread.daemon = True
        thread.start()
614242
def start_output (self):
        
        super(CustomXMLLogger, self).start_output()
        self.xml_start_output()
        attrs = {"created": strformat.strtime(self.starttime)}
        self.xml_starttag(u'linkchecker', attrs)
        self.flush()
795771
def on_batch_begin(self, train, **kwargs:Any)->None:
        ""
        if train:
            self.lrs.append(self.opt.lr)
            self.moms.append(self.opt.mom)
759268
public void start(Path basetDir, Path sampleDir, SampleStartedCallback callback) {

        JettyMavenPluginStdoutListener listener = new JettyMavenPluginStdoutListener();
        MavenProject.load(basetDir).mvnw("-f", sampleDir.toString()).stdout(listener)
                .executeAsync();

        ExecutorContainer.get().execute(() -> {
            callback.onStarted(listener.isSuccess());
        });
    }
1095062
void start(final Handler<OutputGroup> startHandler) {
    connection.doGroupStart(id, name, args, parent);
    this.startHandler = startHandler;
  }
949352
private void start() {
        setStatus(STARTING);
        jobListener.beforeJobStart(parameters);
        recordTracker = new RecordTracker();
        metrics.setStartTime(System.currentTimeMillis());
        LOGGER.info("Batch size: {}", parameters.getBatchSize());
        LOGGER.info("Error threshold: {}", formatErrorThreshold(parameters.getErrorThreshold()));
        LOGGER.info("Jmx monitoring: {}", parameters.isJmxMonitoring());
        registerJobMonitor();
    }
175330
def start(self):
        """"""

        if self.log_filename:
            print('Output will be logged to `%s`.' % self.log_filename)

        start_time = time.strftime(self.timestamp_fmt)
        print('Started %s' % start_time)

        if self.log_filename:
            orig_stdout = sys.stdout
            orig_stderr = sys.stderr

            sys.stdout = self.log_file
            sys.stderr = self.log_file

            print('Started %s' % start_time)

        doit_main = DoitMain(self)
        doit_main.run(['run'])

        stop_time = time.strftime(self.timestamp_fmt)

        if self.log_filename:
            print('Stopped %s' % stop_time)
            print()

            sys.stdout = orig_stdout
            sys.stderr = orig_stderr
            self.log_file.close()

        print('Stopped %s' % stop_time)
453895
def start(self):
        """'"""
        self._process = threading.Thread(target=self._background_runner)
        self._process.start()
283564
def start(**kwargs):
  '''  '''

  output, err = cli_syncthing_adapter.start(**kwargs)
  click.echo("%s" % output, err=err)
1275135
def start(self, *args, **kwargs):
        
        queue = Queue()
        stdout_reader, stderr_reader = \
            self._create_readers(queue, *args, **kwargs)

        self.thread = threading.Thread(target=self._read,
                                       args=(stdout_reader,
                                             stderr_reader,
                                             queue))
        self.thread.daemon = True
        self.thread.start()
262633
protected function start()
    {
        $this->client->executeCommand(
            $this->client->createCommand('MONITOR')
        );
        $this->valid = true;
    }
1111168
def start_output (self):
        """"""
        super(GraphXMLLogger, self).start_output()
        self.xml_start_output()
        self.xml_starttag(u'GraphXML')
        self.xml_starttag(u'graph', attrs={u"isDirected": u"true"})
        self.flush()
575198
def launch(self):
        """"""
        # Make script file #
        self.make_script()
        # Do it #
        sbatch_out = sh.sbatch(self.script_path)
        jobs.expire()
        # Message #
        print Color.i_blu + "SLURM:" + Color.end + " " + str(sbatch_out),
        # Return id #
        self.id = int(re.findall("Submitted batch job ([0-9]+)", str(sbatch_out))[0])
        return self.id
365210
def run(self):
        ''''''
        with spawn_output_reader() as (stdout_capture, stdout_thread):
            with spawn_output_reader() as (stderr_capture, stderr_thread):
                context = starter_iocontext(stdout_capture, stderr_capture)
                status = self._exec(context)
        stdout_bytes = stdout_thread.join()
        stderr_bytes = stderr_thread.join()
        result = Result(status.code, stdout_bytes, stderr_bytes)
        if is_checked_error(status):
            raise StatusError(result, self)
        return result
595570
def start(self):
        
        # load default input data for the state
        self._root_state.input_data = self._root_state.get_default_input_values_for_state(self._root_state)
        self._root_state.output_data = self._root_state.create_output_dictionary_for_state(self._root_state)
        new_execution_history = self._add_new_execution_history()
        new_execution_history.push_state_machine_start_history_item(self, run_id_generator())
        self._root_state.start(new_execution_history)
1362076
@Override
  public void run() {
    MultipleObjectsBundle data = generator.loadData();
    if(LOG.isVerbose()) {
      LOG.verbose("Writing output ...");
    }
    try {
      if(outputFile.exists() && LOG.isVerbose()) {
        LOG.verbose("The file " + outputFile + " already exists, " + "the generator result will be APPENDED.");
      }

      try (OutputStreamWriter outStream = new FileWriter(outputFile, true)) {
        writeClusters(outStream, data);
      }
    }
    catch(IOException e) {
      throw new AbortException("IO Error in data generator.", e);
    }
    if(LOG.isVerbose()) {
      LOG.verbose("Done.");
    }
  }