Exemple #1
0
def get_requirements(path):
    try:
        from pip.download import PipSession
        parsed_file = parse_requirements(path, session=PipSession())
    except (ImportError, TypeError):
        parsed_file = parse_requirements(path)
    return [str(ir.req) for ir in parsed_file]
Exemple #2
0
def downloaded_reqs_from_path(path, argv):
    """Return a list of DownloadedReqs representing the requirements parsed
    out of a given requirements file.

    :arg path: The path to the requirements file
    :arg argv: The commandline args, starting after the subcommand

    """
    finder = package_finder(argv)

    def downloaded_reqs(parsed_reqs):
        """Just avoid repeating this list comp."""
        return [DownloadedReq(req, argv, finder) for req in parsed_reqs]

    try:
        return downloaded_reqs(parse_requirements(
            path, options=EmptyOptions(), finder=finder))
    except TypeError:
        # session is a required kwarg as of pip 6.0 and will raise
        # a TypeError if missing. It needs to be a PipSession instance,
        # but in older versions we can't import it from pip.download
        # (nor do we need it at all) so we only import it in this except block
        from pip.download import PipSession
        return downloaded_reqs(parse_requirements(
            path, options=EmptyOptions(), session=PipSession(), finder=finder))
Exemple #3
0
    def test_simple(self):
        prefix = 'prefix'
        version = 'version'
        source_dir = 'source dir'
        names = ['requirements.txt']
        requirements = [
            req.InstallRequirement.from_line('some-package>1'),
            req.InstallRequirement.from_line('other-package'),
        ]

        self.mox.StubOutWithMock(deps, 'get_requirement_filenames')
        deps.get_requirement_filenames(
            where=source_dir, only=None, group=prefix,
            version=version).AndReturn(names)

        self.mox.StubOutWithMock(req, 'parse_requirements')
        req.parse_requirements(
            'requirements.txt',
            options=mox.IgnoreArg()).AndReturn(requirements)

        self.mox.StubOutWithMock(os.path, 'exists')
        os.path.exists('requirements.txt').AndReturn(True)

        self.mox.ReplayAll()

        reqs = deps.find_requirements(source_dir, group=prefix,
                                      version=version)

        self.mox.VerifyAll()
        self.assertEqual(['some-package>1', 'other-package'], reqs)
Exemple #4
0
def get_requirements(filename):
    try:
        reqs = list(parse_requirements(filename))
    except TypeError:
        reqs = list(parse_requirements(filename, session=uuid.uuid1()))

    return [str(r.req) for r in reqs]
Exemple #5
0
def get_requirements(source):
    try:
        install_reqs = parse_requirements(source, session=uuid.uuid1())
    except TypeError:
        # Older version of pip.
        install_reqs = parse_requirements(source)
    return set([str(ir.req) for ir in install_reqs])
Exemple #6
0
    def populate_requirement_set(requirement_set, args, options, finder,
                                 session, name, wheel_cache):
        """
        Marshal cmd line args into a requirement set.
        """
        for filename in options.constraints:
            for req in parse_requirements(
                    filename,
                    constraint=True, finder=finder, options=options,
                    session=session, wheel_cache=wheel_cache):
                requirement_set.add_requirement(req)

        for req in args:
            requirement_set.add_requirement(
                InstallRequirement.from_line(
                    req, None, isolated=options.isolated_mode,
                    wheel_cache=wheel_cache
                )
            )

        for req in options.editables:
            requirement_set.add_requirement(
                InstallRequirement.from_editable(
                    req,
                    default_vcs=options.default_vcs,
                    isolated=options.isolated_mode,
                    wheel_cache=wheel_cache
                )
            )

        found_req_in_file = False
        for filename in options.requirements:
            for req in parse_requirements(
                    filename,
                    finder=finder, options=options, session=session,
                    wheel_cache=wheel_cache):
                found_req_in_file = True
                requirement_set.add_requirement(req)
        # If --require-hashes was a line in a requirements file, tell
        # RequirementSet about it:
        requirement_set.require_hashes = options.require_hashes

        if not (args or options.editables or found_req_in_file):
            opts = {'name': name}
            if options.find_links:
                msg = ('You must give at least one requirement to '
                       '%(name)s (maybe you meant "pip %(name)s '
                       '%(links)s"?)' %
                       dict(opts, links=' '.join(options.find_links)))
            else:
                msg = ('You must give at least one requirement '
                       'to %(name)s (see "pip help %(name)s")' % opts)
            logger.warning(msg)
Exemple #7
0
def _parse_requirements(path, finder):
    try:
        # list() so the generator that is parse_requirements() actually runs
        # far enough to report a TypeError
        return list(parse_requirements(path, options=EmptyOptions(), finder=finder))
    except TypeError:
        # session is a required kwarg as of pip 6.0 and will raise
        # a TypeError if missing. It needs to be a PipSession instance,
        # but in older versions we can't import it from pip.download
        # (nor do we need it at all) so we only import it in this except block
        from pip.download import PipSession

        return list(parse_requirements(path, options=EmptyOptions(), session=PipSession(), finder=finder))
def parse_reqs(reqs_file):
    """ parse the requirements """
    options = Option("--workaround")
    options.skip_requirements_regex = None
    # Hack for old pip versions: Versions greater than 1.x
    # have a required parameter "sessions" in parse_requierements
    if pip.__version__.startswith("1."):
        install_reqs = parse_requirements(reqs_file, options=options)
    else:
        from pip.download import PipSession  # pylint:disable=E0611

        options.isolated_mode = False
        install_reqs = parse_requirements(reqs_file, options=options, session=PipSession)  # pylint:disable=E1123
    return [str(ir.req) for ir in install_reqs]
def get_requirements(source):

    try:
        install_reqs = parse_requirements(source, session=uuid.uuid1())
    except TypeError:
        # Older version of pip.
        install_reqs = parse_requirements(source)
    required = set([str(ir.req) for ir in install_reqs])

    # Temp situation: transition from PIL to Pillow, add a hook so people can
    # skip installing Pillow.
    if os.path.exists('/tmp/PHOTOLOGUE_NO_PILLOW'):
        required = [item for item in required if not item.startswith('Pillow')]
    return required
Exemple #10
0
def get_install_requirements(fname):

    ReqOpts = collections.namedtuple('ReqOpts', [
        'skip_requirements_regex',
        'default_vcs',
        'isolated_mode',
    ])

    opts = ReqOpts(None, 'git', False)
    params = {'options': opts}

    requires = []
    dependency_links = []

    pip_version = StrictVersion(pip.__version__)
    session_support_since = StrictVersion('1.5.0')
    if pip_version >= session_support_since:
        from pip.download import PipSession
        session = PipSession()
        params.update({'session': session})

    for ir in parse_requirements(fname, **params):
        if ir is not None:
            if ir.url is not None:
                dependency_links.append(str(ir.url))
            if ir.req is not None:
                requires.append(str(ir.req))
        return requires, dependency_links
Exemple #11
0
 def parse(self, reqs_filepath):
     ext_reqs, loc_reqs = [], []
     for raw_req in parse_requirements(reqs_filepath, session=self.session):
         ext_subreqs, loc_subreqs = self._process_requirement(raw_req)
         ext_reqs.extend(ext_subreqs)
         loc_reqs.extend(loc_subreqs)
     return ext_reqs, loc_reqs
def load_pip_requirements(fp):
    reqs, deps = [], []
    for r in parse_requirements(fp, session=PipSession()):
        if r.url is not None:
            deps.append(str(r.url))
        reqs.append(str(r.req))
    return reqs, deps
Exemple #13
0
def get_requirements():
    reqs = []
    for filename in ["requirements-base.txt", "requirements-dashboard.txt", "requirements-setuptools.txt"]:
        # parse_requirements() returns generator of pip.req.InstallRequirement objects
        install_reqs = parse_requirements(filename)
        reqs += [str(ir.req) for ir in install_reqs]
    return reqs
Exemple #14
0
def main():
    with open(os.path.join(os.path.dirname(__file__), 'README.rst')) as f:
        long_description = f.read()

    install_reqs = parse_requirements(os.path.join(os.path.dirname(__file__), 'requirements.txt'))

    setup(
        name='czchen-dl',
        version='0.0.0',
        author='ChangZhuo Chen (陳昌倬)',
        author_email='*****@*****.**',
        url='https://github.com/czchen/czchen-dl.git',
        description='czchen downloader',
        long_description=long_description,
        packages=[
            'czchendl'
        ],
        install_reqs=install_reqs,
        entry_points={
            'console_scripts': [
                'czchen-dl = czchendl.console:main',
            ],
        },
        classifiers=[
            'Development Status :: 1 - Planning',
            'Environment :: Console',
            'License :: OST Approved :: MIT License',
            'Operating System :: OS Independent',
            'Programming Language :: Python :: 3 :: Only',
            'Programming Language :: Python :: 3.4',
        ]
    )
Exemple #15
0
    def test_no_pip_freeze_mishaps(self):
        # See https://caremad.io/2013/07/setup-vs-requirement/
        # We are trying to stop:
        # - 'pip freeze' leaking things we don't actually depend on into
        #   requirements.txt (think pip-tools etc)
        # - Removing a dependency from requirements but not its own
        #   dependencies - for example, if we removed django-redis we might
        #   want to remove redis

        requirements = parse_requirements('requirements.txt',
                                          session=self.requests.Session())
        packages_a = set(p.name for p in requirements) - self.ignore

        setup_py = pkg_resources.require('ten-self-service[test,docs]')
        packages_b = set(p.project_name for p in setup_py) - self.ignore

        # Separate assertions so that we can easily see whats wrong - checking
        # equality would work but wouldn't tell us what was wrong

        # Check for packages in setup.py but not requirements.txt
        # If you are adding a new dep, you might need to 'pip freeze'
        # If you are removing a dep, you forgot to remove it from setup.py
        self.assertEqual(packages_b - packages_a, set())

        # Check for packages in requirements.txt but not setup.py
        # If you are adding a new dep, add the *direct dependency* to setup.py.
        #    E.g. if you added django-redis to a project you would end up
        #    adding django-redis to setup.py and django-redis and redis to
        #    requirements.txt
        # If you are removing a dep, you forgot to remove it from requirements
        self.assertEqual(packages_a - packages_b, set())
Exemple #16
0
def parse_requirements(requirements_files=None):
    """
    Parses requirements files and returns a list of requirements.

    Returned list would be like::

        ['foo', 'bar>=X.X', ...]

    :param requirements_files: List of requirements files. The default
     is ['requirements.txt', 'tools/pip-requires'].
    :return: List of requirements.
    """
    requirements_files = requirements_files or [
        'requirements.txt',
        'tools/pip-requires',
    ]

    requirements = []
    for f in requirements_files:
        if not os.path.isfile(f):
            continue

        for r in pip_req.parse_requirements(f, session=PipSession()):
            requirements.append(str(r.req))

    return requirements
Exemple #17
0
def requirements():
    """

    :return:
    """
    install_reqs = parse_requirements('requirements.txt')
    return [str(req.req) for req in install_reqs]
    def handle_noargs(self, **options):
        if options["requirements"]:
            req_files = options["requirements"]
        elif os.path.exists("requirements.txt"):
            req_files = ["requirements.txt"]
        elif os.path.exists("requirements"):
            req_files = ["requirements/{0}".format(f) for f in os.listdir("requirements")
                         if os.path.isfile(os.path.join("requirements", f)) and
                         f.lower().endswith(".txt")]
        else:
            sys.exit("requirements not found")

        self.reqs = {}
        for filename in req_files:
            class Object(object):
                pass
            mockoptions = Object()
            mockoptions.default_vcs = "git"
            mockoptions.skip_requirements_regex = None
            for req in parse_requirements(filename, options=mockoptions):
                self.reqs[req.name] = {
                    "pip_req": req,
                    "url": req.url,
                }

        if options["github_api_token"]:
            self.github_api_token = options["github_api_token"]
        elif os.environ.get("GITHUB_API_TOKEN"):
            self.github_api_token = os.environ.get("GITHUB_API_TOKEN")
        else:
            self.github_api_token = None  # only 50 requests per hour

        self.check_pypi()
        self.check_github()
        self.check_other()
Exemple #19
0
def main():
    python_version = sys.version_info
    if python_version < (2, 6):
        print ("This library requires Python version >=2.6, "
               "You have version %d.%d" % python_version[:2])
        sys.exit(1)

    setup(
        name='pyhgvs',
        version='0.9.4',
        description='HGVS name parsing and formatting',
        long_description=description,
        author='Matt Rasmussen',
        author_email='*****@*****.**',
        packages=['pyhgvs', 'pyhgvs.tests'],
        include_package_data=True,
        package_data={
            '': ['requirements-dev.txt'],
        },
        scripts=[],
        install_requires=['pip>=1.2'],
        tests_require=[str(line.req) for line in
                       parse_requirements('requirements-dev.txt',
                                          session=PipSession())],
    )
def parse_reqs(reqs_file):
    ''' parse the requirements '''
    options = Option("--workaround")
    options.skip_requirements_regex = None
    options.isolated_mode = True
    install_reqs = parse_requirements(reqs_file, options=options, session=PipSession())
    return [str(ir.req) for ir in install_reqs]
Exemple #21
0
def get_install_requirements():

    ReqOpts = collections.namedtuple(
        'ReqOpts',
        ['skip_requirements_regex', 'default_vcs', 'isolated_mode']
    )

    opts = ReqOpts(None, 'git', False)

    requires = []
    dependency_links = []

    req_args = ['requirements.txt']
    req_kwargs = {'options': opts}

    pip_version_info = _version_tuple(pip.__version__)

    if pip_version_info >= (6, 0):
        from pip.download import PipSession
        session = PipSession()
        req_kwargs['session'] = session

    for ir in parse_requirements(*req_args, **req_kwargs):
        if ir is not None:
            if pip_version_info >= (6, 0):
                if ir.link is not None:
                    dependency_links.append(str(ir.url))
            else:
                if ir.url is not None:
                    dependency_links.append(str(ir.url))
            if ir.req is not None:
                requires.append(str(ir.req))
    return requires, dependency_links
def get_requires(rname='requirements.txt'):
    this_dir = os.path.realpath(os.path.dirname(__file__))
    fname = os.path.join(this_dir, rname)
    reqs = parse_requirements(fname)
    res = [str(ir.req) for ir in reqs]

    return res
Exemple #23
0
 def run(self, options, args):
     with self._build_session(options) as session:
         format_control = pip.index.FormatControl(set(), set())
         wheel_cache = WheelCache(options.cache_dir, format_control)
         requirement_set = RequirementSet(
             build_dir=None,
             src_dir=None,
             download_dir=None,
             isolated=options.isolated_mode,
             session=session,
             wheel_cache=wheel_cache,
         )
         for name in args:
             requirement_set.add_requirement(
                 InstallRequirement.from_line(
                     name, isolated=options.isolated_mode,
                     wheel_cache=wheel_cache
                 )
             )
         for filename in options.requirements:
             for req in parse_requirements(
                     filename,
                     options=options,
                     session=session,
                     wheel_cache=wheel_cache):
                 requirement_set.add_requirement(req)
         if not requirement_set.has_requirements:
             raise InstallationError(
                 'You must give at least one requirement to %(name)s (see '
                 '"pip help %(name)s")' % dict(name=self.name)
             )
         requirement_set.uninstall(auto_confirm=options.yes)
 def parse_file(self, file):
     """Parse single file."""
     try:
         file_dir = os.path.dirname(file)
         if os.path.exists(file_dir):
             os.chdir(file_dir)
         try:
             if has_pipsession:
                 return req.parse_requirements(file, options=self, finder=self,
                                               session=PipSession())
             else:
                 return req.parse_requirements(file, options=self, finder=self)
         finally:
             os.chdir(self.buildout['buildout']['directory'])
     except SystemExit:
         raise RuntimeError("Can't parse {0}".format(file))
Exemple #25
0
def find_requirements(where=None, group=None, only=None, version=None):
    """Generates requirements based on given prefix and version.

    It works similar to find_packages function. It accepts where argument
    and yields install requiremnets.

    Note that this function will not search for requirement files recursively -
    it expects that all files are in the same directory.

    Args:
        where: a directory where requirement files resides
        group: a configuration prefix, like 'devel', ['prod', 'stage']
        only: the same as group, but will ommit base requiremnets
        version: what version of python to use, current by default

    Returns:
        a list of requiremnets
    """

    class FakeOptions(object):
        skip_requirements_regex = None
        default_vcs = ''

    reqs = []

    for filename in get_requirement_filenames(where=where, group=group,
                                              only=only, version=version):
        if os.path.exists(filename):
            for install_req in req.parse_requirements(filename,
                                                      options=FakeOptions()):
                reqs.append(str(install_req.req))

    return reqs
Exemple #26
0
def main():
    args = parse_arguments()

    # show some output
    pip_log.logger.consumers.extend([(pip_log.logger.level_for_integer(3), sys.stdout)])

    finder = index.PackageFinder([], [], use_mirrors=True)
    reqs = pip_req.parse_requirements(args.x_file, finder=finder, options=args)
 
    tmpdir = tempfile.mkdtemp(prefix='cheese')
    try:
        for d in ("build", "src"):
            os.mkdir(os.path.join(tmpdir, d))
        req_set = pip_req.RequirementSet(
            build_dir=os.path.join(tmpdir, "build"),
            src_dir=os.path.join(tmpdir, "src"),
            download_dir=args.x_download)
        req_set.ignore_installed = True
        for req in reqs:
            req_set.add_requirement(req)
        req_set.prepare_files(finder)

        # exit if user only wanted the downloads
        if args.x_download:
            return

        # upload all packages
        for req in req_set.successfully_downloaded:
            build_dir = req.build_location(req_set.build_dir)
            upload_project(args.x_chishop, build_dir)
    finally:
        shutil.rmtree(tmpdir)
        pass
def build_wheels(command, wheelhouse, files):
    print command, wheelhouse, files
    if not os.path.isdir(wheelhouse):
        print('Wheelhouse %s not found.' % wheelhouse)
        return 0

    for filename in files:
        if not os.path.isfile(filename):
            print('Requirements file not found: %s' % filename)
            return 1
        for req in list(parse_requirements(filename, session=object())):
            reqname = req.name
            specs = req.req.specs
            if len(specs) != 1:
                print('Skipping wheel, multiple requirements for %s' % reqname)
            op, version = specs[0]
            if op != '==':
                print('Skipping wheel, non-exact requirement for %s' % reqname)
            pattern = os.path.join(wheelhouse,
                                   '%s-%s-*.whl' % (reqname, version))
            found = glob(pattern)
            if found:
                print ('Skipping build, wheel already exists: %s' % found)
                continue
            os.system('%s %s==%s' % (command, reqname, version))

    return 0
Exemple #28
0
    def run(self, options, args):
        super(UninstallCommand, self).run(options, args)
        if not options.remove_uninstalled:
            return

        with self._build_session(options) as session:
            requirement_set = RequirementSet(
                build_dir=None,
                src_dir=None,
                download_dir=None,
                isolated=options.isolated_mode,
                session=session,
            )

            for name in args:
                requirement_set.add_requirement(
                    InstallRequirement.from_line(
                        name, isolated=options.isolated_mode
                    )
                )
            for filename in options.requirements:
                for req in parse_requirements(
                        filename,
                        options=options,
                        session=session):
                    requirement_set.add_requirement(req)

            if not requirement_set.has_requirements:
                return

            here = os.getcwd()
            requirements_file = os.path.abspath(os.path.join(here, options.save_file))
            requirements = self._parse_requirements(requirement_set.requirements.values())
            self._update_requirements_file(requirements_file, remove_requirements=requirements, session=session)
Exemple #29
0
def get_requirements(req_specs, requirement_files=None):
    """ Get set of requirements from pip-like input arguments

    Parameters
    ----------
    req_specs : sequence
        sequence of requirement specifiers, maybe with versions
    requirement_files : None or sequence, optional
        sequence of filenames or URLs with requirements

    Returns
    -------
    requirement_set : RequiremenSet instance
        Pip requirements set
    """
    if requirement_files is None:
        requirement_files = []
    session = PipSession()
    requirement_set = RequirementSet(
        build_dir=None,
        src_dir=None,
        download_dir=None,
        session=session,
    )
    for name in req_specs:
        requirement_set.add_requirement(
            InstallRequirement.from_line(name))
    for filename in requirement_files:
        for req in parse_requirements(filename, session=session):
            requirement_set.add_requirement(req)
    return requirement_set
Exemple #30
0
def run_setup():
  here = os.path.abspath(os.path.dirname(__file__))
  README = open(os.path.join(here, 'Readme.md')).read()

  version = '0.1'

  install_reqs = parse_requirements(os.path.join(here, 'requirements.txt'), session=False)
  reqs = [str(ir.req) for ir in install_reqs]
  setup(name='sql_kernel',
      version=version,
      description="SQL Kernel for Jupyter",
      long_description=README,
      classifiers=[
          'Development Status :: 3 - Alpha',
          'Environment :: Console',
          'License :: OSI Approved :: MIT License',
          'Topic :: Database',
          'Topic :: Database :: Front-Ends',
          'Programming Language :: Python :: 3',
          'Programming Language :: Python :: 2',
      ],
      keywords='database jupyter sqlalchemy ipython dbms',
      author='Robin Aly',
      author_email='*****@*****.**',
      url='bitbucket.org/alyr/sql_kernel',
      license='MIT',
      packages=find_packages('src'),
      package_dir = {'': 'src'},
      include_package_data=True,
      zip_safe=False,
      install_requires=reqs,
  )
Exemple #31
0
import pip

from setuptools import setup, find_packages
from pip.req import parse_requirements

import skeppa

if sys.argv[-1] == "publish":
    os.system("python setup.py sdist upload")
    sys.exit()

package_exclude = ("tests*", "examples*")
packages = find_packages(exclude=package_exclude)

# Handle requirements
requires = parse_requirements("requirements/install.txt",
                              session=pip.download.PipSession())
install_requires = [str(ir.req) for ir in requires]

# requires = parse_requirements("requirements/tests.txt",
# session=pip.download.PipSession())
# tests_require = [str(ir.req) for ir in requires]

# Convert markdown to rst
try:
    from pypandoc import convert
    long_description = convert("README.md", "rst")
except:
    long_description = ""

setup(
    name="skeppa",
Exemple #32
0
     'License :: OSI Approved :: MIT License',
     'Operating System :: OS Independent',
     'Programming Language :: Python',
     'Programming Language :: Python :: 2',
     'Programming Language :: Python :: 2.6',
     'Programming Language :: Python :: 2.7',
     'Topic :: Software Development :: Libraries :: Python Modules',
 ],
 keywords='irc bot helga',
 author='Shaun Duncan',
 author_email='*****@*****.**',
 url='https://github.com/shaunduncan/helga',
 license='MIT',
 packages=find_packages(),
 install_requires=[
     str(req.req) for req in parse_requirements('requirements.txt')
 ],
 tests_require=[
     'freezegun',
     'mock',
     'pretend',
     'tox',
     'pytest',
 ],
 cmdclass={'test': PyTest},
 entry_points=dict(
     helga_plugins=[
         'dubstep      = helga.plugins.dubstep:dubstep',
         'facts        = helga.plugins.facts:facts',
         'giphy        = helga.plugins.giphy:giphy',
         'help         = helga.plugins.help:help',
Exemple #33
0
from setuptools import setup, find_packages
from pip.req import parse_requirements
import uuid

# parse_requirements() returns generator of pip.req.InstallRequirement objects
install_reqs = parse_requirements('requirements.txt', session=uuid.uuid1())

# reqs is a list of requirement
# e.g. ['django==1.5.1', 'mezzanine==1.4.6']
reqs = [str(ir.req) for ir in install_reqs]

version = '1.0'

setup(
    name='routerGen',
    version=version,
    py_modules=[''],
    packages=find_packages(),
    install_requires=reqs,
    include_package_data=True,
    description = 'generate cisco configs for your lab',
    author = 'Francesco Marangione',
    author_email = '*****@*****.**',
    url = 'https://github.com/mft3000/routerGen', # use the URL to the github repo
    download_url = 'https://github.com/mft3000/routerGen/tarball/%s' % version,
    keywords = ['lab', 'Cisco', 'networking'],
    classifiers = [],
)
Exemple #34
0
from setuptools import setup
from pip.req import parse_requirements
import sys, os
sys.path.append("wutu/")
sys.path.append("wutu/compiler/")

install_reqs = list(parse_requirements("requirements.txt", session={}))


def version():
    import version
    return version.get_version()


setup(name="wutu",
      version=version(),
      description="A minimalistic python-angular framework",
      author="Šarūnas Navickas",
      author_email="*****@*****.**",
      url="https://github.com/zaibacu/wutu",
      license="MIT",
      packages=["wutu", "wutu.compiler"],
      install_requires=[str(ir.req) for ir in install_reqs],
      test_suite="nose.collector",
      tests_require=["nose"])
Exemple #35
0
def get_requirements():
    install_reqs = parse_requirements('requirements.txt', session='tf-layers')
    return [str(ir.req) for ir in install_reqs]
Exemple #36
0
# -*- coding: utf-8 -*-
from setuptools import setup, find_packages
from pip.req import parse_requirements
import re, ast

# get version from __version__ variable in transport_management_system/__init__.py
_version_re = re.compile(r'__version__\s+=\s+(.*)')

with open('transport_management_system/__init__.py', 'rb') as f:
    version = str(
        ast.literal_eval(
            _version_re.search(f.read().decode('utf-8')).group(1)))

requirements = parse_requirements("requirements.txt", session="")

setup(name='transport_management_system',
      version=version,
      description='Provide transportation solution for your business need.',
      author='Vishal Dhayagude',
      author_email='*****@*****.**',
      packages=find_packages(),
      zip_safe=False,
      include_package_data=True,
      install_requires=[str(ir.req) for ir in requirements],
      dependency_links=[str(ir._link) for ir in requirements if ir._link])
Exemple #37
0
import os
from setuptools import setup, find_packages
from pip.req import parse_requirements
from pip.download import PipSession

install_reqs = parse_requirements("requirements.txt", session=PipSession())
reqs = [str(ir.req) for ir in install_reqs]

setup(name="gpspy3",
      version="0.1.0",
      packages=find_packages(),
      author="",
      author_email="",
      description=(""),
      license="",
      keywords="",
      url="",
      install_requires=reqs)
Exemple #38
0
with open("VERSION.txt", "r") as f:
    version = f.read().strip()
    """
        作为一个合格的模块,应该要有版本号哦。
    """
setup(
    name='scrapy_suger',  # 模块名称
    version=version,  # 安装框架后的版本号
    description='A mini spider framework, like Scrapy',  # 描述
    packages=find_packages(exclude=[]),  # 不排除任何文件
    author='amourbrus',
    author_email='*****@*****.**',
    license='Apache License v2',  # 遵循的Linux软件发行协议
    package_data={'': ['*.*']},  # 获取任意文件名任意后缀的文件
    url='#',
    install_requires=[
        str(ir.req)
        for ir in parse_requirements("requirements.txt", session=False)
    ],  #所需的运行环境,读取requirements文件,自动安装运行环境
    zip_safe=False,  # 表示在Windows中可以正常卸载
    classifiers=[
        'Programming Language :: Python',
        'Operating System :: Microsoft :: Windows',
        'Operating System :: Unix',
        'Programming Language :: Python :: 2.7',
        'Programming Language :: Python :: 3.4',
        'Programming Language :: Python :: 3.5',
        'Programming Language :: Python :: 3.6',
    ],
)
Exemple #39
0
def cli(verbose, dry_run, pre, rebuild, find_links, index_url, extra_index_url,
        client_cert, trusted_host, header, index, emit_trusted_host, annotate,
        upgrade, upgrade_packages, output_file, allow_unsafe, generate_hashes,
        src_files, max_rounds):
    """Compiles requirements.txt from requirements.in specs."""
    log.verbose = verbose

    if len(src_files) == 0:
        if os.path.exists(DEFAULT_REQUIREMENTS_FILE):
            src_files = (DEFAULT_REQUIREMENTS_FILE, )
        elif os.path.exists('setup.py'):
            src_files = ('setup.py', )
            if not output_file:
                output_file = 'requirements.txt'
        else:
            raise click.BadParameter(("If you do not specify an input file, "
                                      "the default is {} or setup.py"
                                      ).format(DEFAULT_REQUIREMENTS_FILE))

    if len(src_files) == 1 and src_files[0] == '-':
        if not output_file:
            raise click.BadParameter(
                '--output-file is required if input is from stdin')

    if len(src_files) > 1 and not output_file:
        raise click.BadParameter(
            '--output-file is required if two or more input files are given.')

    if output_file:
        dst_file = output_file
    else:
        base_name = src_files[0].rsplit('.', 1)[0]
        dst_file = base_name + '.txt'

    if upgrade and upgrade_packages:
        raise click.BadParameter(
            'Only one of --upgrade or --upgrade-package can be provided as an argument.'
        )

    ###
    # Setup
    ###

    pip_command = get_pip_command()

    pip_args = []
    if find_links:
        for link in find_links:
            pip_args.extend(['-f', link])
    if index_url:
        pip_args.extend(['-i', index_url])
    if extra_index_url:
        for extra_index in extra_index_url:
            pip_args.extend(['--extra-index-url', extra_index])
    if client_cert:
        pip_args.extend(['--client-cert', client_cert])
    if pre:
        pip_args.extend(['--pre'])
    if trusted_host:
        for host in trusted_host:
            pip_args.extend(['--trusted-host', host])

    pip_options, _ = pip_command.parse_args(pip_args)

    session = pip_command._build_session(pip_options)
    repository = PyPIRepository(pip_options, session)

    # Pre-parse the inline package upgrade specs: they should take precedence
    # over the stuff in the requirements files
    upgrade_packages = [
        InstallRequirement.from_line(pkg) for pkg in upgrade_packages
    ]

    # Proxy with a LocalRequirementsRepository if --upgrade is not specified
    # (= default invocation)
    if not (upgrade or upgrade_packages) and os.path.exists(dst_file):
        ireqs = parse_requirements(dst_file,
                                   finder=repository.finder,
                                   session=repository.session,
                                   options=pip_options)
        existing_pins = {
            key_from_req(ireq.req): ireq
            for ireq in ireqs if is_pinned_requirement(ireq)
        }
        repository = LocalRequirementsRepository(existing_pins, repository)

    log.debug('Using indexes:')
    # remove duplicate index urls before processing
    repository.finder.index_urls = list(dedup(repository.finder.index_urls))
    for index_url in repository.finder.index_urls:
        log.debug('  {}'.format(index_url))

    if repository.finder.find_links:
        log.debug('')
        log.debug('Configuration:')
        for find_link in repository.finder.find_links:
            log.debug('  -f {}'.format(find_link))

    ###
    # Parsing/collecting initial requirements
    ###

    constraints = []
    for src_file in src_files:
        is_setup_file = os.path.basename(src_file) == 'setup.py'
        if is_setup_file or src_file == '-':
            # pip requires filenames and not files. Since we want to support
            # piping from stdin, we need to briefly save the input from stdin
            # to a temporary file and have pip read that.  also used for
            # reading requirements from install_requires in setup.py.
            tmpfile = tempfile.NamedTemporaryFile(mode='wt', delete=False)
            if is_setup_file:
                from distutils.core import run_setup
                dist = run_setup(src_file)
                tmpfile.write('\n'.join(dist.install_requires))
            else:
                tmpfile.write(sys.stdin.read())
            tmpfile.flush()
            constraints.extend(
                parse_requirements(tmpfile.name,
                                   finder=repository.finder,
                                   session=repository.session,
                                   options=pip_options))
        else:
            constraints.extend(
                parse_requirements(src_file,
                                   finder=repository.finder,
                                   session=repository.session,
                                   options=pip_options))

    # Check the given base set of constraints first
    Resolver.check_constraints(constraints)

    try:
        resolver = Resolver(constraints,
                            repository,
                            prereleases=pre,
                            clear_caches=rebuild,
                            allow_unsafe=allow_unsafe)
        results = resolver.resolve(max_rounds=max_rounds)
        if generate_hashes:
            hashes = resolver.resolve_hashes(results)
        else:
            hashes = None
    except PipToolsError as e:
        log.error(str(e))
        sys.exit(2)

    log.debug('')

    ##
    # Output
    ##

    # Compute reverse dependency annotations statically, from the
    # dependency cache that the resolver has populated by now.
    #
    # TODO (1a): reverse deps for any editable package are lost
    #            what SHOULD happen is that they are cached in memory, just
    #            not persisted to disk!
    #
    # TODO (1b): perhaps it's easiest if the dependency cache has an API
    #            that could take InstallRequirements directly, like:
    #
    #                cache.set(ireq, ...)
    #
    #            then, when ireq is editable, it would store in
    #
    #              editables[egg_name][link_without_fragment] = deps
    #              editables['pip-tools']['git+...ols.git@future'] = {'click>=3.0', 'six'}
    #
    #            otherwise:
    #
    #              self[as_name_version_tuple(ireq)] = {'click>=3.0', 'six'}
    #
    reverse_dependencies = None
    if annotate:
        reverse_dependencies = resolver.reverse_dependencies(results)

    writer = OutputWriter(src_files,
                          dst_file,
                          dry_run=dry_run,
                          emit_header=header,
                          emit_index=index,
                          emit_trusted_host=emit_trusted_host,
                          annotate=annotate,
                          generate_hashes=generate_hashes,
                          default_index_url=repository.DEFAULT_INDEX_URL,
                          index_urls=repository.finder.index_urls,
                          trusted_hosts=pip_options.trusted_hosts,
                          format_control=repository.finder.format_control)
    writer.write(results=results,
                 reverse_dependencies=reverse_dependencies,
                 primary_packages={
                     key_from_req(ireq.req)
                     for ireq in constraints if not ireq.constraint
                 },
                 markers={
                     key_from_req(ireq.req): ireq.markers
                     for ireq in constraints if ireq.markers
                 },
                 hashes=hashes)

    if dry_run:
        log.warning('Dry-run, so nothing updated.')
Exemple #40
0
import pip.download

from pip.req import parse_requirements

from setuptools import setup

setup(name='ansible-toolkit',
      version='1.3.2',
      description='The missing Ansible tools',
      url='http://github.com/dellis23/ansible-toolkit',
      author='Daniel Ellis',
      author_email='*****@*****.**',
      license='GPLv3',
      install_requires=[
          str(pkg.req)
          for pkg in parse_requirements('requirements.txt',
                                        session=pip.download.PipSession())
      ],
      tests_require=[
          str(pkg.req)
          for pkg in parse_requirements('test-requirements.txt',
                                        session=pip.download.PipSession())
      ],
      packages=['ansible_toolkit'],
      scripts=[
          'bin/atk-git-diff',
          'bin/atk-show-vars',
          'bin/atk-show-template',
          'bin/atk-vault',
      ])
Exemple #41
0
#!/usr/bin/env python

from setuptools import setup
from pip.req import parse_requirements
import os

package_root = os.path.abspath(os.path.dirname(__file__))
requirements_txt = os.path.join(package_root, 'requirements.txt')
requires = [
    str(r.req) for r in parse_requirements(requirements_txt, session=False)
]

setup(
    name='linebot',
    version='0.3.2',
    packages=['linebot'],
    install_requires=requires,
    author='Satoshi SUZUKI',
    author_email='*****@*****.**',
    description=('A client library for LINE BOT'),
    license='MIT',
    url='https://github.com/studio3104/line-bot-sdk-python',
)
Exemple #42
0
#!/usr/bin/env python
from setuptools import setup
from pip.req import parse_requirements

install_reqs = parse_requirements("requirements.txt", session=False)
reqs = [str(ir.req) for ir in install_reqs]
classifiers = [
    'Development Status :: 2 - Pre-Alpha', 'Environment :: Console',
    'Operating System :: OS Independent',
    'Programming Language :: Python :: 2',
    'Programming Language :: Python :: 3', 'Topic :: Communications :: Chat'
]

setup(
    name='groupmebot',
    version='0.0.2',
    packages=['groupmebot'],
    url='https://github.com/clayscode/GroupMeBot',
    author='',
    author_email='',
    install_requires=reqs,
    classifiers=classifiers,
    description="Interactive client for GroupMe messaging system",
    keywords='groupme messaging client console interactive',
    entry_points={'console_scripts': ['groupmebot=groupmebot.__main__:main']})
Exemple #43
0
#  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       #
#  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   #
#  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    #
#  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    #
#  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     #
#  THE POSSIBILITY OF SUCH DAMAGE.                                            #
# ----------------------------------------------------------------------------#

import os
import pip
import sys
from pip.req import parse_requirements
from setuptools import setup, find_packages


requirements = [str(requirement.req) for requirement in parse_requirements(
    'requirements.txt', session=pip.download.PipSession())]

# Python Version check
if not sys.version_info[0] == 2:
    sys.exit('Python 3 is not supported')

# Python 2.7.9 sub-version check
if sys.version_info[1] <= 7 and sys.version_info[2] < 9:
    sys.exit('Python 2.7.9+ versions are only supported')

# Get the long description from the README file
with open('README.md') as f:
    long_description = f.read()

setup(
    name='liota',
Exemple #44
0
import os
import uuid
from setuptools import setup, find_packages

try:
    from pip.req import parse_requirements
except ImportError:
    raise ImportError('You should install pip')

REQUIREMENTS = [
    str(ir.req) for ir in parse_requirements(os.path.join(
        os.path.dirname(__file__), 'requirements.txt'),
                                             session=uuid.uuid1())
]

setup(name='chineseMarkov',
      version='0.1.3',
      description='Chinese Sentence Generator',
      long_description=open('README.md').read(),
      author='Kimice',
      author_email='*****@*****.**',
      url='https://github.com/Kimice/ChineseMarkov',
      license='GPLv3',
      packages=find_packages(exclude=[
          'test',
      ]),
      install_requires=REQUIREMENTS)
Exemple #45
0
def check_dependencies():
    """Check installed requirements vs. specified requirements

    This prints out a list of dependencies where the version installed
    is not the same as the one specified in the requirements files.

    It also exits immediately. At some point we might want to change
    it from doing that, but not today.

    If you want to skip this check, set SKIP_CHECK=1 in your
    environment.

    .. Note::

       This only works for packaged requirements. It does not work for
       requirements downloaded in a tarball from github. Those
       requirements get put in the "unsatisfyable" requirements list
       and this will tell you how many there are.

       Generally we should minimize those requirements as much as
       possible.

    """
    # Import this here because not all environments have pip.
    from pip.req import parse_requirements
    from pip.download import PipSession

    req_path = path('requirements')
    req_files = [os.path.join(req_path, fn) for fn in os.listdir(req_path)]

    reqs = list(
        chain(*(parse_requirements(
            path, options=EmptyOptions(), session=PipSession())
                for path in req_files)))

    unsatisfied_reqs = []
    unsatisfyable_reqs = []
    for req in reqs:
        if req.url and 'github.com' in req.url:
            unsatisfyable_reqs.append(req)
            continue

        req.check_if_exists()

        if not req.satisfied_by:
            unsatisfied_reqs.append(req)

    if unsatisfyable_reqs:
        print 'There are %d requirements that cannot be checked.' % (
            len(unsatisfyable_reqs))

    if unsatisfied_reqs:
        print 'The following requirements are not satsifed:'
        print ''

        for req in unsatisfied_reqs:
            print 'UNSATISFIED:', req.req

        print ''
        print 'Update your virtual environment by doing:'
        print ''
        print '    ./peep.sh install -r requirements/requirements.txt'
        print ''
        print 'or run with SKIP_CHECK=1 .'
        sys.exit(1)
Exemple #46
0
 def get_requirements(cls, file='requirements.txt'):
     from pip.req import parse_requirements
     return list(parse_requirements(file))
Exemple #47
0
here = os.path.abspath(os.path.dirname(__file__))
try:
    with open(os.path.join(here, '../README.md')) as f:
        README = f.read()
    with open(os.path.join(here, '../CHANGES.md')) as f:
        CHANGES = f.read()
except:
    README = ''
    CHANGES = ''

reqs = './requirements.txt'
if len(sys.argv) > 1 and sys.argv[1] in ['develop', 'test']:
    reqs = './requirements-dev.txt'

install_reqs = parse_requirements(os.path.join(here, reqs))

setup(
    name='ebs-snapshots',
    version=version.VERSION,
    description='Automates creation and removal of Amazon EBS snapshots',
    author='Clever',
    author_email='*****@*****.**',
    url='https://github.com/Clever/ebs-snapshots/',
    long_description=README + '\n\n' + CHANGES,
    packages=find_packages(exclude=['*.tests']),
    install_requires=[str(ir.req) for ir in install_reqs],
    setup_requires=['nose>=1.0'],
    test_suite='test',
)
Exemple #48
0
import os
from pip.req import parse_requirements
from setuptools import setup, find_packages
from cert_issuer import __version__

here = os.path.abspath(os.path.dirname(__file__))

install_reqs = parse_requirements('requirements.txt', session=False)
reqs = [str(ir.req) for ir in install_reqs]

with open(os.path.join(here, 'README.md')) as fp:
    long_description = fp.read()

setup(
    name='cert-issuer',
    version=__version__,
    url='https://github.com/blockchain-certificates/cert-issuer',
    license='MIT',
    author='Blockcerts',
    author_email='*****@*****.**',
    description='Issues blockchain certificates using the Bitcoin blockchain',
    long_description=long_description,
    packages=find_packages(),
    include_package_data=True,
    install_requires=reqs,
    entry_points={
        'console_scripts': [
            'cert-issuer = cert_issuer.__main__:cert_issuer_main',
        ]
    })
Exemple #49
0
from setuptools import setup
from pip.req import parse_requirements

# pip requirements parsing code taken from http://stackoverflow.com/a/16624700
# parse_requirements() returns generator of pip.req.InstallRequirement objects
install_reqs = parse_requirements('requirements.txt')

# reqs is a list of requirement
# e.g. ['django==1.5.1', 'mezzanine==1.4.6']
reqs = [str(ir.req) for ir in install_reqs]

setup(name='finder',
      version='0.1dev',
      long_description=open('README.md').read(),
      install_requires=reqs)
Exemple #50
0
from setuptools import setup
import sys
import os
from pip.req import parse_requirements

PACKAGE_DIR = {'': 'machmail'}
README = open("README.md").read()
LICENSE = open("LICENSE").read()
AUTHOR_EMAIL = '*****@*****.**'

REQ = os.path.dirname(os.path.realpath(__file__)) + "/requirements.txt"
install_reqs = parse_requirements(REQ, session=False)

# reqs is a list of requirement
# e.g. ['django==1.5.1', 'mezzanine==1.4.6']
reqs = [str(ir.req) for ir in install_reqs]


def get_version(dir, package_name):
    """Get version string from package in non-module sub-dir.
    """
    path = './{}'.format(dir)
    sys.path.insert(0, path)
    version = __import__(package_name).__version__
    return version


# setup function
setup(
    name='machmail',
    # package metadata
Exemple #51
0
def parse_reqs(filename):
    """Parse setup requirements from a requirements.txt file."""
    install_reqs = parse_requirements(filename, session=False)
    return [str(ir.req) for ir in install_reqs]
Exemple #52
0
from setuptools import setup, find_packages
from setuptools.command.test import test as TestCommand
import sys
import uuid

from jirafs import __version__ as version_string

requirements_path = os.path.join(
    os.path.dirname(__file__),
    'requirements.txt',
)
try:
    from pip.req import parse_requirements
    requirements = [
        str(req.req)
        for req in parse_requirements(requirements_path, session=uuid.uuid1())
    ]
except ImportError:
    requirements = []
    with open(requirements_path, 'r') as in_:
        requirements = [
            req for req in in_.readlines()
            if not req.startswith('-') and not req.startswith('#')
        ]


class Tox(TestCommand):
    def finalize_options(self):
        TestCommand.finalize_options(self)
        self.test_args = []
        self.test_suite = True
Exemple #53
0
#!/usr/bin/env python3.7

import os
from setuptools import setup, find_packages
from pip.req import parse_requirements

setup_dir = os.path.dirname(os.path.realpath(__file__))
path_req = os.path.join(setup_dir, 'requirements.txt')
install_reqs = parse_requirements(path_req, session=False)

reqs = [str(ir.req) for ir in install_reqs]

setup(name='MrMime',
      author='sLoPPydrive',
      description='Pokemon GO client library mimicing the original app',
      version='0.9.0',
      url='https://github.com/SenorKarlos/MrMime',
      download_url="https://github.com/SenorKarlos/MrMime/releases",
      packages=find_packages(),
      install_requires=reqs)
Exemple #54
0
# See the License for the specific language governing permissions and
# limitations under the License.

from pip.download import PipSession
from pip.req import parse_requirements
from setuptools import setup, find_packages
from os import path

here = path.abspath(path.dirname(__file__))

with open(path.join(here, 'README.rst')) as f:
    readme = f.read()

requirements = [
    str(ir.req)
    for ir in parse_requirements('requirements.txt', session=PipSession())
]

test_requirements = [
    str(ir.req)
    for ir in parse_requirements('requirements_test.txt', session=PipSession())
]

setup(name='deeptracy_core',
      version='0.0.34',
      author='BBVA',
      url="https://github.com/BBVA/deeptracy-core",
      description='Deeptracy Dependency Checker',
      long_description=readme,
      packages=find_packages(),
      keywords='deeptracy core',
#!/usr/bin/env python

import json
import sys
from pip.req import parse_requirements
from pip.download import PipSession
from pip._vendor import pkg_resources
from pip._vendor.six import print_

requirements = [pkg_resources.Requirement.parse(str(req.req)) for req
                in parse_requirements(sys.argv[1], session=PipSession()) if req.req != None]

transform = lambda dist: {
        'name': dist.project_name,
        'version': dist.version,
        'location': dist.location,
        'dependencies': list(map(lambda dependency: dependency.project_name, dist.requires())),
        }

packages = [transform(dist) for dist
            in pkg_resources.working_set.resolve(requirements)]

print_(json.dumps(packages))
Exemple #56
0
try:
    from setuptools import setup, Command
except ImportError:
    from distutils.core import setup

import sys
import uuid

from pip.req import parse_requirements

ldclient_version = '5.0.3'

# parse_requirements() returns generator of pip.req.InstallRequirement objects
install_reqs = parse_requirements('requirements.txt', session=uuid.uuid1())
python26_reqs = parse_requirements('python2.6-requirements.txt',
                                   session=uuid.uuid1())
test_reqs = parse_requirements('test-requirements.txt', session=uuid.uuid1())
redis_reqs = parse_requirements('redis-requirements.txt', session=uuid.uuid1())

# reqs is a list of requirement
# e.g. ['django==1.5.1', 'mezzanine==1.4.6']
reqs = [str(ir.req) for ir in install_reqs]
python26reqs = [str(ir.req) for ir in python26_reqs]
testreqs = [str(ir.req) for ir in test_reqs]
redisreqs = [str(ir.req) for ir in redis_reqs]


class PyTest(Command):
    user_options = []

    def initialize_options(self):
Exemple #57
0
    # Precise has an old version of pip that lacks PipSession.
    PipSession = None
from pip.req import parse_requirements
from setuptools import setup, find_packages

if PipSession is not None:
    pip_session = PipSession()
    kwargs = dict(session=pip_session)
else:
    # The parse_requirements in the precise version of pip is broken
    # and requires options.skip_requirements_regex to be present.
    from collections import namedtuple
    options = namedtuple('Options', 'skip_requirements_regex')
    kwargs = dict(options=options(skip_requirements_regex=None))

requirements = parse_requirements("requirements.txt", **kwargs)
test_requirements = parse_requirements("test-requirements.txt", **kwargs)
install_requires = [str(req.req) for req in requirements]
tests_require = [str(req.req) for req in test_requirements]

setup(
    name='jujugui',
    version='2.0.3',
    description='jujugui',
    classifiers=[
        "Programming Language :: Python",
        "Framework :: Pyramid",
        "Topic :: Internet :: WWW/HTTP",
        "Topic :: Internet :: WWW/HTTP :: WSGI :: Application",
    ],
    author='Juju UI Engineering Team',
Exemple #58
0
#!/usr/bin/env python

from pip.req import parse_requirements
from setuptools import setup, find_packages

install_reqs = parse_requirements('requirements.txt', session='hack')

setup(name='trf',
      version='0.1',
      description='A tool to calculate text readability features',
      author='Akihiko Watanabe, Soichiro Murakami, and Akira Miyazawa',
      author_email='{watanabe, murakami}@lr.pi.titech.ac.jp, [email protected]',
      url='https://github.com/aistairc/trf',
      packages=find_packages("trf"),
      install_requires=install_reqs)
#      package_data={'', ['']},
from distutils.core import setup
from setuptools import find_packages
from pip.req import parse_requirements


PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))


with open(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'README.rst')) as readme:
    README = readme.read()

# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))

# parse_requirements() returns generator of pip.req.InstallRequirement objects
install_requirements = parse_requirements(os.path.join(PROJECT_ROOT, 'requirements.txt'), session=uuid.uuid1())

# e.g. ['django', 'google-api-python-client']
requirements = [str(ir.req) for ir in install_requirements]

setup(
    name='django-autotranslate',
    version='1.0.1',
    packages=find_packages(),
    install_requires=requirements,
    include_package_data=True,
    license='MIT License',
    description='A simple Django app to automatically translate the pot (`.po`) files generated by django\'s '
                'makemessages command using google translate.',
    long_description=README,
    url='https://github.com/ankitpopli1891/django-autotranslate/',
Exemple #60
0
from pip.req import parse_requirements
from pip.download import PipSession

setup(
    name='vprof',
    version='0.2',
    packages=['vprof'],
    description="Visual profiler for Python",
    url='http://github.com/nvdv/vprof',
    license='BSD',
    author='nvdv',
    include_package_data=True,
    keywords=['debugging', 'profiling'],
    entry_points={'console_scripts': ['vprof = vprof.__main__:main']},
    classifiers=[
        'Development Status :: 3 - Alpha',
        'Environment :: Web Environment',
        'Intended Audience :: Developers',
        'Programming Language :: Python',
        'Programming Language :: Python :: 2',
        'Programming Language :: Python :: 2.7',
        'Programming Language :: Python :: 3',
        'Programming Language :: Python :: 3.5',
        'Topic :: Software Development',
    ],
    install_requires=[
        str(req.req)
        for req in parse_requirements('requirements.txt', session=PipSession())
    ],
)