Starts the Application.

    :return: Definition success.
    :rtype: bool
8223
def main():
    

    args = get_command_line_arguments()
    return build_toc_tree(args.title,
                          args.input,
                          args.output,
                          args.content_directory)
436748
def start(self):
        
        self.running = True
        self.thread = threading.Thread(target=self._main_loop)
        self.thread.start()
803276
def start(self):
        
        if self.running:
            raise RuntimeError("client already running")

        self._main_task = asyncio.ensure_future(
            self._main(),
            loop=self._loop
        )
        self._main_task.add_done_callback(self._on_main_done)
621207
def start(self):
        
        self.connect()
        if not self.isAlive():
            super(WAMPClient,self).start()
        self.hello()
        return self
968921
def main():
    
    arguments = docopt(__doc__)
    if arguments['init']:
        return_code = init()
        sys.exit(return_code)

    run_converter(arguments)
11506
def running(self):
        
        try:
            return (self._process is not None and
                    self._process.state() != self._process.NotRunning)
        except RuntimeError:
            return False
69408
public static function start()
    {
        /*
            session_id() will continue to return id even after session_write_close()
        */
        if (\session_status() === PHP_SESSION_ACTIVE) {
            return true;
        }
        if (\headers_sent()) {
            return false;
        }
        self::setCfg(array());  // makes sure all default's determined and set
        $success = \session_start();
        \bdk\Debug::_info('started', \session_id());
        if (self::$cfgStatic['regenOnStart']) {
            self::regenerateId();
        }
        return $success;
    }
463213
def start(self):
        
        if not global_sdk_config.sdk_enabled():
            return

        with self._lock:
            if not self._started:
                self._rule_poller.start()
                self._target_poller.start()
                self._started = True
924522
def on_startup(self):
        

        LOGGER.debug("> Calling '{0}' Component Framework 'on_startup' method.".format(self.__class__.__name__))

        self.refresh_nodes.emit()
        return True
98504
def start(self):
        
        with self._lock:
            if self.is_alive:
                return

            self._thread = threading.Thread(
                target=self._thread_main, name=_WORKER_THREAD_NAME)
            self._thread.daemon = True
            self._thread.start()
            atexit.register(self._export_pending_data)
1134693
def startup(self):
        
        self.runner.info_log("Startup")

        if self.browser_config.config.get('enable_proxy'):
            self.start_proxy()
230534
public final boolean start() {

        if (running || booting || stopping || terminated) {
            // do nothing if this instance is not stopped
            return false;
        } else {
            // mark this instance started
            booting = true;
            running = true;

            onStarted();

            return true;
        }
    }
1215239
def start(self):
        
        self._assert_not_running()
        if self._configs.clear_log:
            self.clear_adb_log()
        self._start()
1272940
def launch(self):
        
        #os.system(self.fullname) # gives permission denied seeing it needs to be chmod +x
        import subprocess
        try:
            retcode = subprocess.call(self.fullname, shell=True)
            if retcode < 0:
                print("Child was terminated by signal", -retcode, file=sys.stderr)
                return False
            else:
                print("Child returned", retcode, file=sys.stderr)
                return True
        except OSError as e:
            print("Execution failed:", e, file=sys.stderr)
            return False
1238834
def start(self, attach=False):
        
        if self.state()['running']:
            logger.info('is already running.', extra={'formatter': 'container', 'container': self.name})
            return True
        else:
            try:
                logger.info(
                    'is being started.', extra={'formatter': 'container', 'container': self.name}
                )

                # returns None on success
                self.client.start(self.id)
                if self._transcribe:
                    self.start_transcribing()

            except APIError as e:
                #
                # This is some bs... I assume that its needed because of dockers changes in 1.18 api.
                # I will resolve this next week when we stop passing properties to start.

                if e.response.status_code == 500:
                    self.client.start(self.id)
                else:
                    raise RuntimeError("Docker Error: {0}".format(e.explanation))

            if attach:
                self.attach()
                exit_code = self.wait()

            else:
                exit_code = self._wait_for_exit_code()

            return True if exit_code == 0 else False
636996
def start(self, *args, **kwargs):#pylint:disable=unused-argument
        
        restart = kwargs.get('restart', True)
        return self.run(restart)
488178
def start(self):
        
        component = Component(self.config, self.handlers)
        component.run()