Run CheckTranslator.
166479
def translate(self):
        """"""
        visitor = CheckTranslator(self.document,
                                  contents=self.contents,
                                  filename=self.filename,
                                  ignore=self.ignore)
        self.document.walkabout(visitor)
        self.checkers += visitor.checkers
43499
protected function initTranslator(): void
    {
        $translator = new \Bluz\Translator\Translator();
        $translator->setOptions(Config::get('translator'));
        $translator->init();

        Translator::setInstance($translator);
    }
510247
def run_check(self, data):
        """"""
        if not data:
            sys.exit(1)
        data, sentences, chars, num_words = self.pre_check(data)
        w_dict = Counter(data)
        uniq_len, uncommon, uncom_len = self.gsl(w_dict)
        non_dchall_set = Counter({word: count for word, count in w_dict.items()
            if word and word not in self.dale_chall_words})
        diff_count = sum(non_dchall_set.values())
        dc_score = round(self.dale_chall(diff_count, num_words, sentences), 1)
        cli_score = round(self.coleman_liau(chars, num_words, sentences), 1)
        return uncommon, uncom_len, uniq_len, dc_score, cli_score
281140
def run
      if result = analyze
        synthesize(result)
      else
        puts parser.failure
        exit ERRNO_PARSE_ERROR
      end
    end
129057
def run(self):
    """"""
    compiler = new_compiler(compiler=self.compiler)
    if compiler.compiler_type == "msvc":
      self.define = [
          ("UNICODE", ""),
      ]

    else:
      command = "sh configure --disable-shared-libs"
      output = self._RunCommand(command)

      print_line = False
      for line in output.split("\n"):
        line = line.rstrip()
        if line == "configure:":
          print_line = True

        if print_line:
          print(line)

      self.define = [
          ("HAVE_CONFIG_H", ""),
          ("LOCALEDIR", "\"/usr/share/locale\""),
      ]

    build_ext.run(self)
191963
def verify(ctx):
    """"""
    oks = run_configurations(
        skipper(verify_environments),
        read_sections,
    )
    ctx.exit(0
             if False not in oks
             else 1)
906454
def _run_checks(self):
        '''
        '''
        if self.recipe is not None:

            # Does the recipe provided exist?
            if not os.path.exists(self.recipe):
                bot.error("Cannot find %s, is the path correct?" %self.recipe)
                sys.exit(1)

            # Ensure we carry fullpath
            self.recipe = os.path.abspath(self.recipe)
1201556
def run():
    
    # set the LOCPATH to find locale files in the virtualenv instance or
    # system /usr/share/locale location. needed by gettext
    # for translation files.
    os.environ['LOCPATH'] = os.path.join(sys.prefix, 'share', 'locale')
    if os.environ.get('LANGUAGE') == 'C':
        os.environ['LANGUAGE'] = 'en'
    _ostype = nn.provider_check()
    if not _ostype:
        raise UnableToFindProviderException
    import_str = 'netshow.%s.show' % _ostype
    nn.import_module(import_str).run()
1359017
def run(self, cmd):
        """"""
        import __main__
        dikt = __main__.__dict__
        return self.runctx(cmd, dikt, dikt)
1044795
public function run()
	{
	    $logger = \System::getContainer()->get('monolog.logger.contao');
	    
	    if (false === self::$_BackendUser && true === $this->isContao45())
	    {
	        $objTokenChecker = \System::getContainer()->get('contao.security.token_checker');
	        if ($objTokenChecker->hasBackendUser())
	        {
	            ModuleVisitorLog::writeLog( __METHOD__ , __LINE__ , ': BackendUser: Yes' );
	            self::$_BackendUser = true;
	        }
	        else
	        {
	            ModuleVisitorLog::writeLog( __METHOD__ , __LINE__ , ': BackendUser: No' );
	        }
	    }
	    
	    //Parameter holen
	    if ((int)\Input::get('vcid')  > 0)
	    {
	        $visitors_category_id = (int)\Input::get('vcid');
	        $this->visitorScreenSetDebugSettings($visitors_category_id);
	        $this->visitorScreenSetResolutions();
	        if ($this->_SCREEN !== false)
	        {
	            /* __________  __  ___   _____________   ________
	              / ____/ __ \/ / / / | / /_  __/  _/ | / / ____/
	             / /   / / / / / / /  |/ / / /  / //  |/ / / __
	            / /___/ /_/ / /_/ / /|  / / / _/ // /|  / /_/ /
	            \____/\____/\____/_/ |_/ /_/ /___/_/ |_/\____/ only
	            */
	            $objVisitors = \Database::getInstance()
                            ->prepare("SELECT
                                        tl_visitors.id AS id, visitors_block_time
                                    FROM
                                        tl_visitors
                                    LEFT JOIN
                                        tl_visitors_category ON (tl_visitors_category.id = tl_visitors.pid)
                                    WHERE
                                        pid = ? AND published = ?
                                    ORDER BY id , visitors_name")
                                ->limit(1)
                                ->execute($visitors_category_id,1);
	            if ($objVisitors->numRows < 1)
	            {
	                $logger->log(LogLevel::ERROR, 
	                             $GLOBALS['TL_LANG']['tl_visitors']['wrong_screen_catid'], 
	                             array('contao' => new ContaoContext('FrontendVisitors '. VISITORS_VERSION .'.'. VISITORS_BUILD, TL_ERROR)));
	            }
	            else
	            {
	                while ($objVisitors->next())
	                {
	                    $this->visitorScreenCountUpdate($objVisitors->id, $objVisitors->visitors_block_time, $visitors_category_id, self::$_BackendUser);
	    
	                }
	            }
	        } //SCREEN !== false
	    }
	    else
	    {
	        $logger->log(LogLevel::ERROR,
	                     $GLOBALS['TL_LANG']['tl_visitors']['wrong_screen_catid'],
	                     array('contao' => new ContaoContext('FrontendVisitors '. VISITORS_VERSION .'.'. VISITORS_BUILD, TL_ERROR)));
	    }
	    
	    //Pixel und raus hier
	    $objResponse = new Response( base64_decode('R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==') );
	    $objResponse->headers->set('Content-type', 'image/gif');
	    $objResponse->headers->set('Content-length', 43);
		return $objResponse;
	}
925341
def run(self):
        """"""
        self.console.load(self.lines, setup=self.setup, teardown=self.teardown)
        return self.console.interpret()
694121
def execute(self):
    """""""
    python_tgts = self.context.targets(
      lambda tgt: isinstance(tgt, (PythonTarget))
    )
    if not python_tgts:
      return 0
    interpreter_cache = PythonInterpreterCache.global_instance()
    with self.invalidated(self.get_targets(self._is_checked)) as invalidation_check:
      failure_count = 0
      tgts_by_compatibility, _ = interpreter_cache.partition_targets_by_compatibility(
        [vt.target for vt in invalidation_check.invalid_vts]
      )
      for filters, targets in tgts_by_compatibility.items():
        sources = self.calculate_sources([tgt for tgt in targets])
        if sources:
          allowed_interpreters = set(interpreter_cache.setup(filters=filters))
          if not allowed_interpreters:
            raise TaskError('No valid interpreters found for targets: {}\n(filters: {})'
                            .format(targets, filters))
          interpreter = min(allowed_interpreters)
          failure_count += self.checkstyle(interpreter, sources)
      if failure_count > 0 and self.get_options().fail:
        raise TaskError('{} Python Style issues found. You may try `./pants fmt <targets>`'
                        .format(failure_count))
      return failure_count
260467
def run(self):
        """"""
        pydocstyle.Error.explain = self.options['explain']
        filename, source = load_file(self.filename)
        for error in pydocstyle.PEP257Checker().check_source(source, filename):
            if not hasattr(error, 'code') or ignore(error.code):
                continue
            lineno = error.line
            offset = 0  # Column number starting from 0.
            explanation = error.explanation if pydocstyle.Error.explain else ''
            text = '{0} {1}{2}'.format(error.code, error.message.split(': ', 1)[1], explanation)
            yield lineno, offset, text, Main
298521
public void run() {
    String hostName = host != null ? host : "localhost";
    ServerTools.print("Starting LanguageTool " + JLanguageTool.VERSION +
            " (build date: " + JLanguageTool.BUILD_DATE + ", " + JLanguageTool.GIT_SHORT_ID + ") server on " + getProtocol() + "://" + hostName + ":" + port  + "...");
    server.start();
    isRunning = true;
    ServerTools.print("Server started");
  }
712329
def run(self, cmd, fn=None, globals=None, locals=None):
        """"""
        if globals is None:
            import __main__
            globals = __main__.__dict__
        if locals is None:
            locals = globals
        self.reset()
        if isinstance(cmd, str):
            str_cmd = cmd
            cmd = compile(str_cmd, fn or "<wdb>", "exec")
            self.compile_cache[id(cmd)] = str_cmd
        if fn:
            from linecache import getline
            lno = 1
            while True:
                line = getline(fn, lno, globals)
                if line is None:
                    lno = None
                    break
                if executable_line(line):
                    break
                lno += 1

        self.start_trace()
        if lno is not None:
            self.breakpoints.add(LineBreakpoint(fn, lno, temporary=True))
        try:
            execute(cmd, globals, locals)
        finally:
            self.stop_trace()
744820
public function run() {
		$this->directory_list = $this->list_directory( $this->language_files_dir );
		$this->translations   = $this->process_directory( $this->directory_list );
		$this->packages       = $this->create_packages();
		$this->create_language_packs();
		$this->create_json();
	}
254
def run_checks(collector):
    """"""
    artifact = collector.configuration["dashmat"].artifact
    chosen = artifact
    if chosen in (None, "", NotSpecified):
        chosen = None

    dashmat = collector.configuration["dashmat"]
    modules = collector.configuration["__active_modules__"]
    config_root = collector.configuration["config_root"]
    module_options = collector.configuration["modules"]

    datastore = JsonDataStore(os.path.join(config_root, "data.json"))
    if dashmat.redis_host:
        datastore = RedisDataStore(redis.Redis(dashmat.redis_host))

    scheduler = Scheduler(datastore)

    for name, module in modules.items():
        if chosen is None or name == chosen:
            server = module.make_server(module_options[name].server_options)
            scheduler.register(module, server, name)

    scheduler.twitch(force=True)