Run all the methods
761630
def cowbat(self):
        
        logging.info('Beginning COWBAT database downloads')
        if self.overwrite or not os.path.isdir(os.path.join(self.databasepath, 'genesippr')):
            self.sipprverse_targets(databasepath=self.databasepath)
        if self.overwrite or not os.path.isdir(os.path.join(self.databasepath, 'coregenome')):
            self.cowbat_targets(databasepath=self.databasepath)
        if self.overwrite or not os.path.isdir(os.path.join(self.databasepath, 'ConFindr')):
            self.confindr_targets()
        if self.overwrite or not os.path.isdir(os.path.join(self.databasepath, 'mash')):
            self.mash(databasepath=self.databasepath)
        if self.overwrite or not os.path.isdir(os.path.join(self.databasepath, 'MLST')):
            self.mlst(databasepath=self.databasepath)
        if self.overwrite or not os.path.isdir(os.path.join(self.databasepath, 'rMLST')):
            self.rmlst(databasepath=self.databasepath,
                       credentials=self.credentials)
        if self.overwrite or not os.path.isdir(os.path.join(self.databasepath, 'univec')):
            self.univec(databasepath=self.databasepath)
        if self.overwrite or not os.path.isdir(os.path.join(self.databasepath, 'resfinder')):
            self.cge_db_downloader(databasepath=self.databasepath,
                                   analysistype='resfinder',
                                   dbname='resfinder_db')
        if self.overwrite or not os.path.isdir(os.path.join(self.databasepath, 'virulence')):
            self.cge_db_downloader(databasepath=self.databasepath,
                                   analysistype='virulence',
                                   dbname='virulencefinder_db')
        if self.overwrite or not os.path.isdir(os.path.join(self.databasepath, 'serosippr')):
            self.cge_db_downloader(databasepath=self.databasepath,
                                   analysistype='serosippr',
                                   dbname='serotypefinder_db')
        if self.overwrite or not os.path.isdir(os.path.join(self.databasepath, 'pointfinder')):
            self.cge_db_downloader(databasepath=self.databasepath,
                                   analysistype='pointfinder',
                                   dbname='pointfinder_db')
        if self.overwrite or not os.path.isdir(os.path.join(self.databasepath, 'clark')):
            self.clark(databasepath=self.databasepath)
        if self.overwrite or not os.path.isdir(os.path.join(self.databasepath, 'mob_suite')):
            self.mob_suite_targets()
34897
public function run()
    {
        echo Html::beginTag('div', ['class' => 'page-sidebar-wrapper']);
        echo Html::beginTag('div', ['class' => 'page-sidebar navbar-collapse collapse']);
        echo Menu::widget([
            'items' => $this->items,
            'encodeLabels' => false,
            'options' => ['class' => 'page-sidebar-menu', 'data-keep-expanded' => "false", 'data-auto-scroll' => "true", 'data-slide-speed' => 200],
            'submenuTemplate' => "\n<ul class=\"sub-menu\">\n{items}\n</ul>\n"
        ]);
        echo Html::endTag('div');   // page-sidebar-wrapper
        echo Html::endTag('div');   // page-sidebar
    }
880451
def run(self):
        """"""
        while True:
            try:
                self.perform_iteration()
            except Exception:
                traceback.print_exc()
                pass

            time.sleep(ray_constants.REPORTER_UPDATE_INTERVAL_MS / 1000)
369508
def run(self):
        
        run_command = (
            settings.project_customization.runfile.read_text().split()
        )
        chmod_string = (
            "chmod +x "
            + settings.project_customization.runfile.absolute().as_posix()
        )
        subprocess.run(chmod_string.split())
        subprocess.run(
            run_command, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr
        )
404092
def run_all(scopes = {})
      UI.clear(force: true)
      UI.action_with_scopes("Run", scopes)
      Runner.new.run(:run_all, scopes)
    end
409191
def run(ast)
      ast = [ast] unless ast.is_a?(Array)

      # pre-load all the built-in definitions.
      @constant_loader.run(ast)

      ast.each { |node| iterate(node) }

      freeze
    end
1165676
public function run() {
		
		// various set-up options
		$options                 = array();
		$options["patternPaths"] = $this->patternPaths;
		$patternDataStore        = PatternData::get();
		$stringLoader            = Template::getStringLoader();
		
		// load the pattern loader
		$patternEngineBasePath   = PatternEngine::getInstance()->getBasePath();
		$patternLoaderClass      = $patternEngineBasePath."\Loaders\PatternLoader";
		$patternLoader           = new $patternLoaderClass($options);
		
		// parse all of the CSS in the project
		$kss = new Parser(Config::getOption("sourceDir"));
		
		foreach ($patternDataStore as $patternStoreKey => $patternStoreData) {
			
			if ($patternStoreData["category"] == "pattern") {
				
				$kssSection = "";
				
				try {
					$kssSection = $kss->getSection($patternStoreKey);
				} catch(\Exception $e) {
					$kssSection = "";
				}
				
				// see if this pattern has a section in the loaded KSS
				if (!empty($kssSection)) {
					
					// update the name and desc based on the KSS
					PatternData::setPatternOption($patternStoreKey, "name", $kssSection->getTitle());
					PatternData::setPatternOption($patternStoreKey, "desc", $kssSection->getDescription());
					PatternData::setPatternOption($patternStoreKey, "descExists", true);
					
					// find the kss modifiers
					$modifiers = $kssSection->getModifiers();
					
					if (!empty($modifiers)) {
						
						$patternModifiers = array();
						
						// work through each modifier
						foreach ($modifiers as $modifier) {
							
							$name               = $modifier->getName();
							$class              = $modifier->getClassName();
							$desc               = $modifier->getDescription();
							$code               = "";
							$modifierCodeExists = false;
							
							// if it's not a pseudo class render it
							if (strpos($name,":") !== false) {
								
								$data    = Data::getPatternSpecificData($patternStoreKey);
								$data    = array_merge($data,array("styleModifier" => $class));
								
								$srcPath = (isset($patternStoreData["pseudo"])) ? PatternData::getPatternOption($patternStoreData["original"],"pathName") : $patternStoreData["pathName"];
								$code    = $patternLoader->render(array("pattern" => $srcPath, "data" => $data));
								
								$modifierCodeExists    = true;
								
							}
							
							// add pattern modifier info
							$patternModifiers[] = array("modifierName"       => $name,
														"modifierDesc"       => $desc,
														"modifierCode"       => $code,
														"modifierCodeExists" => $modifierCodeExists);
							
							$patternModifiersOutput[] = array("modifierName" => $name,
														      "modifierDesc" => $desc);
							
						}
						
						// this is silly but keeps it looking cleaner to me
						$patternModifierData = array("patternModifiers" => $patternModifiers);
						$patternModifierOutputData = array("patternModifiersExist" => true, "patternModifiers" => $patternModifiersOutput);
						
						// grab extra sections based on KSS syntax
						if (!empty($kssSection->getCompatibility())) {
							$patternModifierData["compatibility"]             = $kssSection->getCompatibility();
							$patternModifierData["compatibilityExists"]       = true;
							$patternModifierOutputData["compatibility"]       = $kssSection->getCompatibility();
							$patternModifierOutputData["compatibilityExists"] = true;
						}
						if (!empty($kssSection->getExperimental())) {
							$patternModifierData["experimental"]              = $kssSection->getExperimental();
							$patternModifierData["experimentalExists"]        = true;
							$patternModifierOutputData["experimental"]        = $kssSection->getExperimental();
							$patternModifierOutputData["experimentalExists"]  = true;
						}
						if (!empty($kssSection->getDeprecated())) {
							$patternModifierData["deprected"]                 = $kssSection->getDeprecated();
							$patternModifierData["deprecatedExists"]          = true;
							$patternModifierOutputData["deprecated"]          = $kssSection->getDeprecated();
							$patternModifierOutputData["deprecatedExists"]    = true;
						}
						if (!empty($kssSection->getParameters())) {
							$patternModifierData["parameters"]                = $kssSection->getParameters();
							$patternModifierData["parametersExist"]           = true;
							$patternModifierOutputData["parameters"]          = $kssSection->getParameters();
							$patternModifierOutputData["parametersExists"]    = true;
						}
						
						// render the views for the plug-in
						$partialViewDescAddition    = $stringLoader->render(array("string" => $this->descTemplate, "data" => $patternModifierData));
						$partialViewExampleAddition = $stringLoader->render(array("string" => $this->exampleTemplate, "data" => $patternModifierData));
						
						// add the views to the appropriate containers in the patterndata::$store
						PatternData::setPatternOptionArray($patternStoreKey, "partialViewDescAdditions", $partialViewDescAddition);
						PatternData::setPatternOptionArray($patternStoreKey, "partialViewExampleAdditions", $partialViewExampleAddition);
						PatternData::setPatternOptionArray($patternStoreKey, "extraOutput", $patternModifierOutputData, "patternLabPluginKSS");
						
					}
					
				}
				
			}
			
		}
		
		unset($kss);
		
	}
166799
def run(self):
        """"""
        for wsock in self.wsocks:
            wsock.run()
        for api in self.apis:
            api.run()
480169
public function run()
    {
        $this->init();

        // Loop forever, except when a maximum number of requests is configured
        $requestsHandled = 0;
        while ($this->maxRequests === null || $requestsHandled < $this->maxRequests) {
            $this->doStep();
            $requestsHandled++;
        }
    }
70238
public function run($method) {
		$this->$method();
		$reflection = new \ReflectionClass($this);
		$packages = \Skeleton\Core\Skeleton::get_all();
		$filename = $reflection->getFileName();

		if (substr(Config::$migration_directory, -1) == '/') {
			$migration_directory = substr(Config::$migration_directory, 0, -1);
		} else {
			$migration_directory = Config::$migration_directory;
		}

		if (dirname($filename) == $migration_directory) {
			Runner::set_version('project', $this->get_version());
			return;
		}

		$migration_package = null;
		foreach ($packages as $package) {
			if (strpos($package->migration_path, dirname($filename)) === 0) {
				$migration_package = $package;
			}
		}

		if ($migration_package === null) {
			throw new \Exception('No package found');
		}

		Runner::set_version($migration_package->name, $this->get_version());
	}
109713
public function run()
    {

         //Get The Models To put In Database
        $models = collect([
                    'Post' => Post::class,
                    'Tag' => Tag::class,
                    'Category' => Category::class
                     ]);

        //Each Model Got His Attribues
        $columns = collect([
               'Post' => [
                    'title' => [
                        'required|max:150',
                        'text',
                        true,
                        null
                    ],
                    'slug' => [
                        'required|unique:posts,slug',
                        'text',
                        true,
                        null
                    ],
                    'content' => [
                        'required',
                        'rich_text_box',
                        false,
                        null
                    ],
                    'description' => [
                        'required|max:250',
                        'text_area',
                        false,
                        null
                    ],
                    'featured' => [
                        null,
                        'checkbox',
                        false,
                        null
                    ],
                    'tags' => [
                        null,
                        'tags',
                        false,
                        null
                    ],
                    'category' => [
                        'required',
                        'category',
                        false,
                        null
                    ],
                    'image' => [
                        'required|mimes:jpeg,bmp,png',
                        'image',
                        true,
                        null
                    ],
                    'status' => [
                        null,
                        'status',
                        true,
                        [
                            [
                                'value' => 'PUBLISHED',
                                'option' => 'PUBLISHED'
                            ],
                            [
                                'value' => 'PENDING',
                                'option' => 'PENDING'
                            ],
                            [
                                'value' => 'DRAFT',
                                'option' => 'DRAFT'
                            ]
                        ],
                    ]
                ],
               'Tag' => [
                    'name' => [
                        'required|max:156',
                        'text',
                        true,
                        null
                    ],
                    'slug' => [
                        'required|max:100|unique:tags,slug',
                        'string',
                        true,
                        null
                    ]
                ],
               'Category' => [
                    'name' => [
                        'required|max:156',
                        'text',
                        true,
                        null
                    ],
                    'slug' => [
                        'required|max:100|unique:categories,slug',
                        'string',
                        true,
                        null
                    ]
                ]
               ]);
      $settings = collect([
        'title' => [
            'Site Title',
            'text'
        ],
        'description' => [
            'Site Description',
            'text'
        ],
        'logo' => [
            'Site Logo',
            'image'
        ],
        'google_analytics_client_id' => [
            'Google Api Id',
            'text'
        ]
      ]);


        $this->command->info('Laramin Data Seeder');

        $this->command->info('Seed Settings');
        $settings->each(function($value,$index) {
            $this->command->info('Creating Settings for '.$index);
            Settings::create([
                    'key' => $index,
                    'display_name' => $value[0],
                    'type' => $value[1],
            ]);
        });


        $models->each(function ($model, $index) use ($columns) {
            $this->command->info('Creating Data Type to '.$index);

            $res = DataType::create([
                        'name' => $index,
                        'menu' => true,
                        'model' =>  $index,
                        'slug' => strtolower($index),
                    ]);
            $id = $res->id;
            $columns->filter(function ($item, $key) use ($index, $id) {
                return $key == $index;
            })->Flatmap(function ($item, $key) use ($id) {
                return $item;
            })->each(function ($item, $key) use ($id) {
                $this->command->info('Creating Data Info '.$key.' for '.DataType::find($id)->name);

                DataInfo::create([
                        'data_types_id' => $id,
                        'column' => $key,
                        'type' => $item[1],
                        'validation' => $item[0] == null ? NULL : json_encode($item[0]),
                        'details' => $item[3] == null ? NULL : json_encode($item[3]),
                        'display' => $item[2]
                    ]);
            });
        });
    }
1136977
public function run()
    {
        $topdir = $this->getBasePath();

        foreach (scandir($topdir) as $filename) {

            // Skip directory link files
            if (($filename == '.') || ($filename == '..')) {
                continue;
            }

            if (is_dir($topdir . DIRECTORY_SEPARATOR . $filename)) {
                // Recurse into lower level directory, providing the namespace
                $this->loadFiles($filename, $filename);
            }
        }
    }
725207
def run_all(self):
        # type: () -> None
        
        logger.debug("Creating batch session")
        session = Session()

        for section_id in self.parser.sections():
            self.run_job(section_id, session=session)
1068257
def run(self):
        """"""
        self.logger.info("Running main flask method on port " +
                         str(self.settings['FLASK_PORT']))
        self.app.run(host='0.0.0.0', port=self.settings['FLASK_PORT'])
314641
def run(self):
        '''
        
        '''

        # Parse the stdin into a global event object
        stdin = self.read_stdin()
        self.event = self.read_event(stdin)

        # Prepare global settings
        self.settings = get_settings()
        self.api_settings = self.get_api_settings()

        # Prepare command line arguments and
        self.parser = argparse.ArgumentParser()

        # set up the 2.x to 1.x event mapping argument
        self.parser.add_argument("--map-v2-event-into-v1",
                                 action="store_true",
                                 default=False,
                                 dest="v2event")

        if hasattr(self, 'setup'):
            self.setup()
        (self.options, self.remain) = self.parser.parse_known_args()

        # map the event if required
        if (self.options.v2event or
                os.environ.get("SENSU_MAP_V2_EVENT_INTO_V1")):
            self.event = map_v2_event_into_v1(self.event)

        # Filter (deprecated) and handle
        self.filter()
        self.handle()
799529
public function run()
    {

        // register the default autoloader
        require SERVER_AUTOLOADER;

        // create a local copy of the manager instance
        $manager = $this->manager;

        // query whether the manager has an application with class loaders/annotation registries to be registered
        if (method_exists($manager, 'getApplication') && $application = $manager->getApplication()) {
            $application->registerClassLoaders();
            $application->registerAnnotationRegistries();
        }

        // stop the manager if an apropriate method exists
        if (method_exists($manager, 'stop')) {
            $manager->stop();
        }
    }
1355389
def run(self):
        
        progress_printer = ProgressPrinter(self.different_items.total_items(), msg_verb='sending')
        upload_settings = UploadSettings(self.config, self.remote_store.data_service, progress_printer,
                                         self.project_name_or_id, self.file_upload_post_processor)
        project_uploader = ProjectUploader(upload_settings)
        project_uploader.run(self.local_project)
        progress_printer.finished()