Run the module setup

This method will be called if the ZFTool setup modules command will be executed.
1662
public function runSetup()
    {
        if ($this->params->forceIsActive) {
            $this->createRootCategory()
                 ->createDefaultTypes()
                 ->createDefaultPriorities();
        }

        if ($this->getParams()->createSampleData) {
            $this->createSampleData();
        }
    }
163212
public function run() : void
    {
        $hooks = $this->getHooksToInstall();

        foreach ($hooks as $hook => $ask) {
            $this->installHook($hook, ($ask && !$this->force));
        }
    }
47459
def run(self, argv):
        """"""
        try:
            self.options, remainder = self.parser.parse_known_args(argv)
            self._configure_logging()

            if self.options.relative_plugins:
                curdir = os.getcwd()
                sys.path.insert(0, curdir)
                pkg_resources.working_set.add_entry(curdir)


            try:
                self._load_commands_for_current_dir()
            except pkg_resources.DistributionNotFound as e:
                try:
                    error_msg = repr(e)
                except:
                    error_msg = 'Unknown Error'

                log.error('Failed to load project commands with error '
                          '``%s``, have you installed your project?' % error_msg)

        except Exception as err:
            if hasattr(self, 'options'):
                debug = self.options.debug
            else:
                debug = True

            if debug:
                log.exception(err)
            else:
                log.error(err)

            return 1

        return self._run_subcommand(remainder)
699510
function run()
    {
        // Load Modules Within Event Execution Wrapper that can handle errors
        // with failure callable of event
        $self = $this; $modules = $this->modules_enabled;
        $this->event()->then(function() use ($self, $modules) {
            $self->moduleManager()->loadModules($modules);
        });

        // each error during execution of sapi event listeners must handled within sapi
        // handle errors when modules loaded successfully!
        $this->event()
            ->onFailure(function($exception, $event) {
                /** @var $event EventHeapOfSapi */
                $this->_run_handleException($exception, $event);
                $event->shutdown();
            })
            ->trigger(EventHeapOfSapi::EVENT_APP_BOOTSTRAP)
            ->trigger(EventHeapOfSapi::EVENT_APP_MATCH_REQUEST)
            ->trigger(EventHeapOfSapi::EVENT_APP_DISPATCH)
            ->trigger(EventHeapOfSapi::EVENT_APP_RENDER)
            ->trigger(EventHeapOfSapi::EVENT_APP_FINISH)
        ;
    }
498409
def run(self):
        '''  '''

        # Announce versions
        self.versions()

        # Sample/Tag info and Help
        self.tags()
        print '\n%s' % self.workbench.help('cli')

        # Now that we have the Workbench connection spun up, we register some stuff
        # with the embedded IPython interpreter and than spin it up
        # cfg = IPython.config.loader.Config()
        cfg = Config()
        cfg.InteractiveShellEmbed.autocall = 2
        cfg.InteractiveShellEmbed.colors = 'Linux'
        cfg.InteractiveShellEmbed.color_info = True
        cfg.InteractiveShellEmbed.autoindent = True
        cfg.InteractiveShellEmbed.deep_reload = True
        cfg.PromptManager.in_template = (
            r'{color.LightPurple}{short_md5}{color.Yellow}{prompt_deco}{color.LightBlue} Workbench{color.Green}[\#]> ')
        # cfg.PromptManager.out_template = ''

        # Create the IPython shell
        self.ipshell = IPython.terminal.embed.InteractiveShellEmbed(
            config=cfg, banner1='', exit_msg='\nWorkbench has SuperCowPowers...')

        # Register our transformer, the shell will use this for 'shortcut' commands
        auto_quoter = auto_quote_xform.AutoQuoteTransformer(self.ipshell, self.ipshell.prefilter_manager)
        auto_quoter.register_command_set(self.command_set)

        # Setting up some Pandas options
        pd.set_option('display.width', 140)
        pd.set_option('max_colwidth', 15)

        # Start up the shell with our set of workbench commands
        self.ipshell(local_ns=self.command_dict)
867658
public function run()
    {
        Assertion::notEmpty(
            $this->loaders,
            'No loader attached.',
            DataAggregatorException::NO_LOADER_ATTACHED
        );

        foreach ($this->loaders as $identifier => $loader) {
            $this->executeLoader($loader);
        }
    }
783982
def run_module(self, resource, args=None, stdin=None, stdout=None):
        
        perform_doa = self.project.prefs.get('perform_doi', True)
        perform_doa = self.project.prefs.get('perform_doa', perform_doa)
        receiver = self.object_info.doa_data_received
        if not perform_doa:
            receiver = None
        runner = rope.base.oi.doa.PythonFileRunner(
            self, resource, args, stdin, stdout, receiver)
        runner.add_finishing_observer(self.module_cache.forget_all_data)
        runner.run()
        return runner
601833
def run_modules(self):
    """"""

    def _run_module_thread(module_description):
      """Runs the module's process() function.

      Waits for any blockers to have finished before running process(), then
      sets an Event flag declaring the module has completed.
      """
      for blocker in module_description['wants']:
        self.events[blocker].wait()
      module = self._module_pool[module_description['name']]
      try:
        module.process()
      except DFTimewolfError as error:
        self.add_error(error.message, critical=True)
      except Exception as error:  # pylint: disable=broad-except
        self.add_error(
            'An unknown error occurred: {0!s}\nFull traceback:\n{1:s}'.format(
                error, traceback.format_exc()),
            critical=True)
      print('Module {0:s} completed'.format(module_description['name']))
      self.events[module_description['name']].set()
      self.cleanup()

    threads = []
    for module_description in self.recipe['modules']:
      t = threading.Thread(
          target=_run_module_thread,
          args=(module_description, )
      )
      threads.append(t)
      t.start()
    for t in threads:
      t.join()

    self.check_errors(is_global=True)
274042
def run(self):
        
        self.call_plugins("on_run")
        if vars(self.arguments).get("version", None):
            self.logger.info("{app_name}: {version}".format(app_name=self.app_name, version=self.version))
        else:
            if self.arguments.command == "main":
                self.main()
            else:
                self.subcommands[self.arguments.command].run()
        self.call_plugins("on_end")
1224359
final public function run()
    {
        \Devil::registerApplication($this);
        if ($moduleID = $this->url->isModuleRequested()) {
            if ($module = $this->loadModule($moduleID)) {
                if ($module->beforeRun()) {
                    $this->url->useModule($moduleID);
                    $module->run();
                    $module->afterRun();
                } else {
                    $module->errorRun();
                }
            } else {
                throw new HttpException(HttpException::NOT_FOUND);
            }
        } else {
           parent::run();
        }
    }
757856
public function run()
    {
        if (!class_exists(CustomisationExtension::class)) {
            return;
        }
        $contents = $this->load();

        $this->updateSiteBundleLoader($contents);

        if (!$contents->isEmpty()) {
            $this->save($contents);
        }
    }
592672
protected function run()
    {
        if (Daemon::$process instanceof Master) {
            Daemon::$process->unregisterSignals();
        }
        EventLoop::init();
        Daemon::$process = $this;
        if (Daemon::$logpointerAsync) {
            Daemon::$logpointerAsync->fd = null;
            Daemon::$logpointerAsync = null;
        }
        class_exists('Timer');

        if (Daemon::$config->autogc->value > 0) {
            gc_enable();
        } else {
            gc_disable();
        }
        $this->prepareSystemEnv();
        $this->registerEventSignals();
        FileSystem::init(); // re-init
        FileSystem::initEvent();
        Daemon::openLogs();

        $this->fileWatcher = new FileWatcher();
        $this->IPCManager = Daemon::$appResolver->getInstanceByAppName('\PHPDaemon\IPCManager\IPCManager');
        if (!$this->IPCManager) {
            $this->log('cannot instantiate IPCManager');
        }

        EventLoop::$instance->run();
    }
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)
1253639
def run(self):
        
        os.system("cp python-bugzilla.spec /tmp")
        try:
            os.system("rm -rf python-bugzilla-%s" % get_version())
            self.run_command('sdist')
            os.system('rpmbuild -ta --clean dist/python-bugzilla-%s.tar.gz' %
                      get_version())
        finally:
            os.system("mv /tmp/python-bugzilla.spec .")
630605
def run(self):
        """"""
        self._make_lib_file_symbolic_links()
        self._copy_each_include_files_to_include_dir()
        self._make_dep_lib_file_sym_links_and_copy_include_files()
        self.setup_py.add_patchs_to_build_without_pkg_config(
            self.rpm.lib_dir, self.rpm.include_dir
        )
        self.setup_py.apply_and_save()
        self._build_and_install()
489901
public function run($module)
    {
        $moduleSettings = $module->getInfo('settings');
        $isTheme = $this->isTheme($module->getId());
        if (!$isTheme || ($isTheme && is_array($moduleSettings))) {
            $this->addModuleSettings($moduleSettings, $module->getId());
        }
    }
108271
public function runModule()
    {
        if ($this->status->run === true) {
            return;
        }
        
        $runnerFile   = $this->obtainRunnerFile();
        $initFunction = function() use ($runnerFile) {
            if (empty($runnerFile)) {
                return;
            }
            
            require(realpath($runnerFile));
        };

        $this->status->run = true;
        $initFunction();
    }