Just print out the requirements
506838
def requirements(collector):
    """"""
    out = sys.stdout
    artifact = collector.configuration['dashmat'].artifact
    if artifact not in (None, "", NotSpecified):
        if isinstance(artifact, six.string_types):
            out = open(artifact, 'w')
        else:
            out = artifact

    for active in collector.configuration['__imported__'].values():
        for requirement in active.requirements():
            out.write("{0}\n".format(requirement))
184152
function generateRequirementsFile(
  requirementsPath,
  targetFile,
  serverless,
  servicePath,
  options
) {
  if (
    options.usePoetry &&
    fse.existsSync(path.join(servicePath, 'pyproject.toml'))
  ) {
    filterRequirementsFile(
      path.join(servicePath, '.serverless/requirements.txt'),
      targetFile,
      options
    );
    serverless.cli.log(
      `Parsed requirements.txt from pyproject.toml in ${targetFile}...`
    );
  } else if (
    options.usePipenv &&
    fse.existsSync(path.join(servicePath, 'Pipfile'))
  ) {
    filterRequirementsFile(
      path.join(servicePath, '.serverless/requirements.txt'),
      targetFile,
      options
    );
    serverless.cli.log(
      `Parsed requirements.txt from Pipfile in ${targetFile}...`
    );
  } else {
    filterRequirementsFile(requirementsPath, targetFile, options);
    serverless.cli.log(
      `Generated requirements from ${requirementsPath} in ${targetFile}...`
    );
  }
}
85376
def parse_requirements(path):
    """"""
    requirements = []
    with open(path, "rt") as reqs_f:
        for line in reqs_f:
            line = line.strip()
            if line.startswith("-r"):
                fname = line.split()[1]
                inner_path = os.path.join(os.path.dirname(path), fname)
                requirements += parse_requirements(inner_path)
            elif line != "" and not line.startswith("#"):
                requirements.append(line)
    return requirements
89954
public static function validateRequirements()
    {

        $requirements = array(
            'version' => '',
            'spl' => '',
            'curl' => '',
            'dom' => ''
        );

        $version = str_replace('.', '', phpversion());

        if ($version < 5427) {
            $requirements['version'] = 'PagSeguroLibrary: PHP version 5.4.27 or greater is required.';
        }

        if (!function_exists('spl_autoload_register')) {
            $requirements['spl'] = 'PagSeguroLibrary: Standard PHP Library (SPL) is required.';
        }

        if (!function_exists('curl_init')) {
            $requirements['curl'] = 'PagSeguroLibrary: cURL library is required.';
        }

        if (!class_exists('DOMDocument')) {
            $requirements['dom'] = 'PagSeguroLibrary: DOM XML extension is required.';
        }

        return $requirements;
    }
305290
public function verifyRequirements()
    {
        $this->findRequiredFiles($this->requirements->getRequiredFiles());
        $this->findRequiredTokens(new FunctionFinder(), $this->requirements->getRequiredFunctions());
        $this->findRequiredTokens(new ClassFinder(), $this->requirements->getRequiredClasses());
        $this->findRequiredTokens(new LangFinder(), [$this->requirements->getRequiredStrings()]);
        $this->findRequiredTokens(new CapabilityFinder(), [$this->requirements->getRequiredCapabilities()]);
        $this->findRequiredTokens(new TableFinder(), [$this->requirements->getRequiredTables()]);
        $this->findRequiredTokens(new TablePrefixFinder(), [$this->requirements->getRequiredTablePrefix()]);
        $this->findRequiredTokens(new BehatTagFinder(), $this->requirements->getRequiredBehatTags());
    }
645030
def requirements(requirements_file):
    
    return [
        str(pkg.req) for pkg in parse_requirements(
            requirements_file, session=pip_download.PipSession()) if pkg.req is not None]
663670
def parse_requirements(filename):
    
    with open(filename, 'r') as f:
        lineiter = list(line.strip() for line in f)
    return [line for line in lineiter if line and not line.startswith("#")]
500155
def requirements_check():
    
    required_programs = [
        ('samtools',
         'http://samtools.sourceforge.net/'),
        ('bedtools',
         'http://bedtools.readthedocs.org/en/latest/'),
        ('bigWigToBedGraph',
         'http://hgdownload.cse.ucsc.edu/admin/exe/linux.x86_64/'),
        ('bedGraphToBigWig',
         'http://hgdownload.cse.ucsc.edu/admin/exe/linux.x86_64/'),
    ]
    for req, url in required_programs:
        try:
            p = subprocess.Popen(
                [req], stderr=subprocess.PIPE, stdout=subprocess.PIPE)
            stdout, stderr = p.communicate()
        except OSError:
            raise ValueError("Please install %s (%s)" % (req, url))
700301
def generate_requirements(output_path=None):
    
    from django.conf import settings
    reqs = set()
    
    for app in settings.INSTALLED_APPS:
        if app in mapping.keys():
            reqs |= set(mapping[app])
    if output_path is None:
        print "--extra-index-url=http://opensource.washingtontimes.com/pypi/simple/"
        for item in reqs:
            print item
    else:
        try:
            out_file = open(output_path, 'w')
            out_file.write("--extra-index-url=http://opensource.washingtontimes.com/pypi/simple/\n")
            for item in reqs:
                out_file.write("%s\n" % item)
        finally:
            out_file.close()
13779
def get_requirements(*args):
    """"""
    requirements = set()
    contents = get_contents(*args)
    for line in contents.splitlines():
        # Strip comments.
        line = re.sub(r'^#.*|\s#.*', '', line)
        # Ignore empty lines
        if line and not line.isspace():
            requirements.add(re.sub(r'\s+', '', line))
    return sorted(requirements)
489186
def _read_requirements(filename):
    """"""
    with open(filename) as requirements_file:
        contents = requirements_file.read()
    return [line.strip() for line in contents.splitlines() if _is_requirement(line)]
1304335
def requirements(fname):
    
    with open(fname) as f:
        for line in f:
            match = re.search('#egg=(.*)$', line)
            if match:
                yield match.groups()[0]
            else:
                yield line.strip()
1050617
def _resolve_requirements(self, requirements):
        
        try:
            dut_count = requirements["duts"]["*"]["count"]
        except KeyError:
            return []

        default_values = {
            "type": "hardware",
            "allowed_platforms": [],
            "nick": None,
        }

        default_values.update(requirements["duts"]["*"])
        del default_values["count"]
        dut_keys = list(default_values.keys())
        dut_keys.extend(["application", "location", "subtype"])

        dut_requirements = self.__generate_indexed_requirements(dut_count,
                                                                default_values,
                                                                requirements)

        # Match groups of duts defined with 1..40 notation.
        for key in requirements["duts"].keys():
            if not isinstance(key, string_types):
                continue
            match = re.search(r'([\d]{1,})\.\.([\d]{1,})', key)
            if match:
                first_dut_idx = int(match.group(1))
                last_dut_idx = int(match.group(2))
                for i in range(first_dut_idx, last_dut_idx+1):
                    for k in dut_keys:
                        if k in requirements["duts"][key]:
                            dut_requirements[i-1].set(k, copy.copy(requirements["duts"][key][k]))

        for idx, req in enumerate(dut_requirements):

            if isinstance(req.get("nick"), string_types):
                nick = req.get("nick")
                req.set("nick", ResourceConfig.__replace_base_variables(nick,
                                                                        len(dut_requirements),
                                                                        idx))
            self._solve_location(req, len(dut_requirements), idx)
        self._dut_requirements = dut_requirements
        return None
427362
def _parse_requirement(iterable):
    """"""
    deps = {}
    for line in iterable:
        line = line.strip()
        if not line or line[0] == '#':
            continue

        parsed_req = parse_fade_requirement(line)
        if parsed_req is None:
            continue
        repo, dependency = parsed_req
        deps.setdefault(repo, []).append(dependency)

    return deps
208718
function printResults(results){
    var output = "";
    var dependenciesTimes = [];
    var devDependenciesTimes = [];

    dependenciesTimes = Object.keys(results.moduleTimes.dependencies).map(function(depen){
        var val = results.moduleTimes.dependencies[depen];

        return [
            chalk.gray(depen),
            " : ",
            chalk.white(val === -1 ? "Cannot be required" : val)
        ];
    });

    devDependenciesTimes = Object.keys(results.moduleTimes.devDependencies).map(function(depen){
        var val = results.moduleTimes.devDependencies[depen];

        return [
            chalk.gray(depen),
            " : ",
            chalk.white(val === -1 ? "Cannot be required" : val)
        ];
    });

    if(dependenciesTimes.length > 0){
        output += chalk.white("Dependencies: \n");
        output += table(dependenciesTimes, {align: ["l", "l"]});
    }

    if(devDependenciesTimes.length > 0){
        output += chalk.white("\n\nDevDependencies: \n");
        output += table(devDependenciesTimes, {align : ["l", "l"]});
    }

    output += chalk.white("\n\nModule load time: " + (results.loadTime === -1 ? "Cannot be required" : results.loadTime));
    console.log(output);
}
417046
def local():
    """"""
    logger.info("Loading requirements from local file.")
    with open(REQUIREMENTS_FILE, 'r') as f:
        requirements = parse(f)
        for r in requirements:
            logger.debug("Creating new package: %r", r)
            create_package_version(r)
898496
def resolve_requirement_strings(self, interpreter, requirement_strings):
    """"""
    requirement_strings = sorted(requirement_strings)
    if len(requirement_strings) == 0:
      req_strings_id = 'no_requirements'
    elif len(requirement_strings) == 1:
      req_strings_id = requirement_strings[0]
    else:
      req_strings_id = hash_all(requirement_strings)

    path = os.path.realpath(os.path.join(self.workdir, str(interpreter.identity), req_strings_id))
    if not os.path.isdir(path):
      reqs = [PythonRequirement(req_str) for req_str in requirement_strings]
      with safe_concurrent_creation(path) as safe_path:
        pex_builder = PexBuilderWrapper.Factory.create(
          builder=PEXBuilder(path=safe_path, interpreter=interpreter, copy=True),
          log=self.context.log)
        pex_builder.add_resolved_requirements(reqs)
        pex_builder.freeze()
    return PEX(path, interpreter=interpreter)