Start the All-Linking process with the IM and device.
183538
async def start_all_linking(self, linkcode, group, address=None):
        """"""
        _LOGGING.info('Starting the All-Linking process')
        if address:
            linkdevice = self.plm.devices[Address(address).id]
            if not linkdevice:
                linkdevice = create(self.plm, address, None, None)
            _LOGGING.info('Attempting to link the PLM to device %s. ',
                          address)
            self.plm.start_all_linking(linkcode, group)
            asyncio.sleep(.5, loop=self.loop)
            linkdevice.enter_linking_mode(group=group)
        else:
            _LOGGING.info('Starting All-Linking on PLM. '
                          'Waiting for button press')
            self.plm.start_all_linking(linkcode, group)
            await asyncio.sleep(self.wait_time, loop=self.loop)

        _LOGGING.info('%d devices added to the All-Link Database',
                      len(self.plm.devices))
        await asyncio.sleep(.1, loop=self.loop)
283259
def cancel_all_linking(self):
        """"""
        self.logger.info("Cancel_all_linking for device %s", self.device_id)
        self.hub.direct_command(self.device_id, '02', '65')
1147473
def start(self):
        

        # Spawn the listening thread
        self.listen_thread = eventlet.spawn_n(self.listen)

        # Now do the initial load
        self.reload()
814364
def start(self):
        """"""
        old_start_count = self.__start_count
        self.__start_count += 1
        if old_start_count == 0:
            self.data_channel_start_event.fire()
621207
def start(self):
        
        self.connect()
        if not self.isAlive():
            super(WAMPClient,self).start()
        self.hello()
        return self
1084108
def start(self, program, start=None, stop=None, resolution=None,
              max_delay=None):
        """"""
        params = self._get_params(start=start, stop=stop,
                                  resolution=resolution,
                                  maxDelay=max_delay)
        self._transport.start(program, params)
380476
def connect(self):
        '''
        
        '''
        self._connect()

        try:
            self._listen()
        except (KeyboardInterrupt, SystemExit):
            pass
        finally:
            self.close()
857913
def start_program(linker = nil)
      initialize(linker || @linker)
      init = @linker.cpu_init
      set_state(:running)
      set_pc( Position.get(init).at )
    end
247676
def start(self):
        """"""
        if self.state != STATE_RUNNING:
            conn = self.loop.create_connection(
                lambda: self, self.host, self.port)
            task = self.loop.create_task(conn)
            task.add_done_callback(self.init_done)
            self.state = STATE_STARTING
1295197
def startup():
    
    model.setup()
    index.scan_index(config.content_folder)
    index.background_scan(config.content_folder)
633013
def start(self, wait=True, timeout=None, wait_polling_interval=None):
        
        self._logger.info("Starting b2g process")

        if timeout is None:
            timeout = self._timeout

        if wait_polling_interval is None:
            wait_polling_interval = self._wait_polling_interval

        if wait:
            self.wait_for_device_ready(timeout,
                                       after_first=lambda:self.shell_bool("start b2g",
                                                                          timeout=timeout))
        else:
            self.shell_bool("start b2g", timeout=timeout)
70666
def __start(self):
        
        thread = Thread(target=self.__loop, args=())
        thread.daemon = True  # daemonize thread
        thread.start()
        self.__enabled = True
1350647
def start(self):
        """"""
        self.clear()
        self.setDefaultPolicy()
        self.acceptIcmp()
        self.acceptInput('lo')
1318647
def start(self):
        
        if not self.thread_started:
            super(SkypeAPI, self).start()
            self.thread_started = True
497235
def start(self, device):
        

        super(NativeBLEVirtualInterface, self).start(device)
        self.set_advertising(True)
827886
def start(self):
        """"""
        self._websocket = AIOWSClient(loop=self._loop,
                                      session=self._session,
                                      url=self._ws_url,
                                      async_callback=self._async_ws_handler)
        self._websocket.start()
612202
def _start(self):
        """"""
        cls = self._get_manager_class(register_callables=True)
        ins = cls(address=self.addr, authkey=self.authkey)
        ins.start()
        return ins