Start coroutine. runs on_start coroutine and then
        runs the _step coroutine where the body of the behaviour
        is called.
433482
async def _start(self):
        
        self.agent._alive.wait()
        try:
            await self.on_start()
        except Exception as e:
            logger.error("Exception running on_start in behaviour {}: {}".format(self, e))
            self.kill(exit_code=e)
        await self._step()
        self._is_done.clear()
616360
def run(self):
        
        self._connect()
        super(irc.bot.SingleServerIRCBot, self).start()
445241
public function run()
    {
        $prefix = $this->notifyPrefix;
        
        $this->addNotification($prefix.'_start_run_tasks');
        
        foreach ($this->runSteps as $actionName => $stepInfos) {
            $context = null;
            if ($stepInfos->context !== null) {
                $context = $stepInfos->context;
            }
            
            if ($stepInfos->callback === null) {
                $this->addNotification($prefix.'_exec_'.$actionName, $context);
                continue;
            }
            
            $this->addNotification($prefix.'_run_'.$actionName, $context);

            if (is_callable($stepInfos->callback)) {
                $callback = $stepInfos->callback;
                $callback();
            }

            $this->addNotification($prefix.'_done_'.$actionName, $context);
        }
        
        $this->addNotification($prefix.'_end_run_tasks');
    }
287440
def start(self):
        
        self.running = True
        while self.running:
            self.update_prompt()
            try:
                self.cmdloop()
            except KeyboardInterrupt:
                print()
            except botocore.exceptions.BotoCoreError as e:
                print(e)
            except ParseException as e:
                print(self.engine.pformat_exc(e))
            except Exception:
                traceback.print_exc()
            self.engine.reset()
1015359
def run
      @started_at = Time.now
      max_cycles = 1

      while true do
        if @cycle < max_cycles
          step
        else
          diff = Time.now - @started_at
          max_cycles = (diff * @clock_cycle)
        end
      end
    end
705483
def run(self):
        
        LOGGER.info('%s v%s started', self.APPNAME, self.VERSION)
        self.setup()
        while not any([self.is_stopping, self.is_stopped]):
            self.set_state(self.STATE_SLEEPING)
            try:
                signum = self.pending_signals.get(True, self.wake_interval)
            except queue.Empty:
                pass
            else:
                self.process_signal(signum)
                if any([self.is_stopping, self.is_stopped]):
                    break
            self.set_state(self.STATE_ACTIVE)
            self.process()
947960
def start(self):
        
        if not self._is_running:
            self._do_run = True
            self._thread.start()
        return self
884234
def start(self):
        
        t=threading.Thread(target=self._consume)
        t.start()
61012
def run(self, endpoint: str, loop: AbstractEventLoop = None):
        
        if not loop:
            loop = asyncio.get_event_loop()

        try:
            loop.run_until_complete(self.run_async(endpoint))
        except KeyboardInterrupt:
            self._shutdown()
549556
def start(self):
        
        if self.running:
            self.stop()

        self._thread = threading.Thread(target=self._wrapped_target)
        self._thread.daemon = True
        self._thread.start()
180840
def run(self): # No "_" in the name, but nevertheless, running in the backed
        
        self.preRun_()
        self.running=True
        
        while(self.running):
            if (self.active): # activated: shared mem client has been reserved
                self.cycle_()
            else:
                if (self.verbose): print(self.pre, "sleep")
                time.sleep(0.2)
            self.handleSignal_()
            
        self.postRun_()
767196
def run(self):
        
        self._connection = self.connect()
        self._connection.ioloop.start()
1040011
async def start(self):
        
        for track, task in self.__tracks.items():
            if task is None:
                self.__tracks[track] = asyncio.ensure_future(blackhole_consume(track))
1145081
def run(self, switch_queue):
        
        self.switch_queue = switch_queue
        self.quit = False

        Thread(target=self._watchdog_queue).start()
        Thread(target=self._watchdog_time).start()
651038
def start(self, blocking=False):
        
        self.debug("()")
        super(SensorClient, self).start(blocking=False)
        try:
            a_thread = threading.Thread(
                target=self._thread_wrapper,
                args=(self._packet_loop,)
            )
            a_thread.daemon = True
            a_thread.start()
        except:
            self.exception("Failed to run packet loop")
            raise SensorStartException("Packet loop failed")
        self.info("Started")
        # Blocking - call StartStopable.start
        super(Sensor, self).start(blocking)
817507
def start(self) -> None:
        
        self._setup()

        if self._run_control_loop:
            asyncio.set_event_loop(asyncio.new_event_loop())
            self._heartbeat_reciever.start()
            self._logger.info(' Start Loop')
            return self.loop.start()
        else:
            self._logger.debug(' run_control_loop == False')
267010
def run(entry_point, drivers, loop = None):
    ''' 
    '''
    program = setup(entry_point, drivers)
    dispose = program.run()
    if loop == None:
        loop = asyncio.get_event_loop()

    loop.run_forever()
    dispose()