Run the application
775791
public function runApplication()
    {
        $routeCollection = $this->createRouteCollection();
        $dispatcher = $routeCollection->getDispatcher();

        $request = $this->createRequest();
        $response = $dispatcher->dispatch($request->getMethod(), $request->getPathInfo());
        $response->send();
    }
715544
def run(self):
        '''
        
        '''
        self.thread = Thread(target=self.__processQueue)
        self.thread.start()
361110
def run(**kwargs):
    
    from sampleproject.app import app

    app.update_settings(**kwargs)
    app.run()
748489
public function run()
    {
        if (file_exists($this->parameters['previous'])) {
            $oldManifest = new common_ext_Manifest($this->parameters['previous']);
        } else {
            $this->err('Manifest ' . $this->parameters['previous'] . ' not found', true);
        }
        if (file_exists($this->parameters['current'])) {
            $newManifest = new common_ext_Manifest($this->parameters['current']);
        } else {
            $this->err('Manifest ' . $this->parameters['current'] . ' not found', true);
        }
        
        $out = $this->parameters['output'];
        
        $diff = new taoDevTools_models_ExtDiff($oldManifest, $newManifest);
        file_put_contents($out, $diff->exportDiffToPhp());
    }
1295965
def start(self):
        '''  '''
        self._app.run(host=self._host, port=self._port)
166518
def run(self):
        
        with open('src/lsqfit/__init__.py', 'a') as lsfile:
            lsfile.write("\n__version__ = '%s'\n" % LSQFIT_VERSION)
        _build_py.run(self)
1334707
public function run()
    {
        session_start();
        self::$_app = $this;
        if (empty($this->_runtimePath)) {
            $this->_runtimePath = $this->_basePath . '/runtime';
        }
        $application = $this->getComponent('application');
        $application->runController();
    }
1242267
public function run()
    {
        // Add registered command to console 
        foreach ($this->commands as $command) {
            $this->consoleApp->add($command);
        }

        $this->consoleApp->run();
    }
1120954
public function run()
    {
        if ('cli' === php_sapi_name()) {
            // do run console application

            $input = new ArgvInput();
            $env = $input->getParameterOption(['--env', '-e'], getenv('SYMFONY_ENV') ?: 'dev');
            $debug = '0' !== getenv('SYMFONY_DEBUG') && !$input->hasParameterOption(['--no-debug', '']) && 'prod' !== $env;

            if ($debug || $this->debug) {
                Debug::enable();
            }

            $application = new Application($this->getKernel());
            $application->run($input);
        } else {
            // do run web application
            $request = Request::createFromGlobals();

            $kernel = $this->getKernel();

            if (!$this->debug) {
                $kernel->loadClassCache();
            }

            if ($this->cacheClass && class_exists($this->cacheClass)) {
                // add (or uncomment) this new line!
                // wrap the default AppKernel with the AppCache one
                $cacheClass = $this->cacheClass;
                $kernel = new $cacheClass($kernel);
            }

            // actually execute the kernel, which turns the request into a response
            // by dispatching events, calling a controller, and returning the response
            $response = $kernel->handle($request);

            // send the headers and echo the content
            $response->send();

            // triggers the kernel.terminate event
            $kernel->terminate($request, $response);
        }
    }
610061
public function run()
    {
        $this->command('PASS', $this->connection->getPassword());
        $this->command('NICK', $this->connection->getNickname());

        $this->grantAll();

        $this->setLogIn();
        $this->dispatch('tweech.authenticated', new Event());

        $ticker = new Ticker($this);
        $ticker->run();

        $chatreader = new ChatReader($this);
        $chatreader->handleSockets();
        $chatreader->run();
    }
1235354
def run(self):
        
        self.loop = asyncio.new_event_loop()
        self.loop.run_until_complete(self.open_async())
166799
def run(self):
        """"""
        for wsock in self.wsocks:
            wsock.run()
        for api in self.apis:
            api.run()
1190532
def run_with_werkzeug(self, **options):
        """"""
        threaded = self.threads is not None and (self.threads > 0)
        self.app.run(
            host=self.host,
            port=self.port,
            debug=self.debug,
            threaded=threaded,
            **options
        )
904315
public function run()
    {
        $this->toggleTyp = is_array($this->label) ? 'switch' : 'button';
        switch($this->toggleTyp) {
            case 'button':
                $this->renderButton();
                break;
            case 'switch':
                $this->renderButtonGroup();
                break;
        }

        CookieButtonAsset::register($this->view);
        $this->getView()->registerJs("CookieButton.init('".$this->params."');", View::POS_READY);
    }
197008
def main(**kwargs):
    """"""
    options = ApplicationOptions(**kwargs)
    Event.configure(is_logging_enabled=options.event_logging)
    application = Application(options)
    application.run(options.definition)
796898
def run():
    """"""
    import optparse

    parser = optparse.OptionParser(usage=r"%prog [<options>] [file ...]")
    parser.add_option(
        "-p", "--spread", type="float", default=3.0, help="Rainbow spread"
    )
    parser.add_option(
        "-F", "--freq", type="float", default=0.1, help="Rainbow frequency"
    )
    parser.add_option("-S", "--seed", type="int", default=0, help="Rainbow seed")
    parser.add_option(
        "-a",
        "--animate",
        action="store_true",
        default=False,
        help="Enable psychedelics",
    )
    parser.add_option(
        "-d", "--duration", type="int", default=12, help="Animation duration"
    )
    parser.add_option(
        "-s", "--speed", type="float", default=20.0, help="Animation speed"
    )
    parser.add_option(
        "-f",
        "--force",
        action="store_true",
        default=False,
        help="Force colour even when stdout is not a tty",
    )

    parser.add_option(
        "-3", action="store_const", dest="mode", const=8, help="Force 3 bit colour mode"
    )
    parser.add_option(
        "-4",
        action="store_const",
        dest="mode",
        const=16,
        help="Force 4 bit colour mode",
    )
    parser.add_option(
        "-8",
        action="store_const",
        dest="mode",
        const=256,
        help="Force 8 bit colour mode",
    )

    parser.add_option(
        "-c",
        "--charset-py2",
        default="utf-8",
        help="Manually set a charset to convert from, for python 2.7",
    )

    options, args = parser.parse_args()
    options.os = random.randint(0, 256) if options.seed == 0 else options.seed
    options.mode = options.mode or detect_mode()

    lolcat = LolCat(mode=options.mode)

    if not args:
        args = ["-"]

    for filename in args:
        if filename == "-":
            lolcat.cat(sys.stdin, options)
        else:
            try:
                with open(filename, "r") as handle:
                    lolcat.cat(handle, options)
            except IOError as error:
                sys.stderr.write(str(error) + "\n")
1302427
public function run()
	{
		parent::run();
		echo $this->render('widget', [
			'id' => $this->getId(),
			'services' => $this->services,
			'action' => $this->action,
			'popup' => $this->popup,
			'assetBundle' => $this->assetBundle,
		]);
	}