def main():
    assert (sys.version_info[0] >= 3 and sys.version_info[1] >= 4), \
        "Python version >= 3.4 required, got %r" % (sys.version_info,)

    version = get_version_string()

    setuptools.setup(
        name='python-base',
        version=version,
        packages=setuptools.find_packages(SRC_PATH),
        namespace_packages=setuptools.find_packages(SRC_PATH),
        package_dir={
            '': SRC_PATH,
        },
        scripts=sorted(list_scripts()),
        package_data={
            "base": ["VERSION"],
        },
        test_suite=TEST_PATH,
        cmdclass={'test': TestWithDiscovery},

        # metadata for upload to PyPI
        author="WibiData engineers",
        author_email="[email protected]",
        description='General purpose library for Python.',
        license='Apache License 2.0',
        keywords='python base flags tools workflow',
        url="http://wibidata.com",
    )

 def include_in(self, dist):
     # Called when master is enabled (default, or --with-master)
     dist.metadata.name = 'Bitten'
     dist.metadata.description = 'Continuous integration for Trac'
     dist.long_description = "A Trac plugin for collecting software " \
                             "metrics via continuous integration."""
     # Use full manifest when master is included
     egg_info.manifest_maker.template = "MANIFEST.in"
     # Include tests in source distribution
     if 'sdist' in dist.commands:
         dist.packages = find_packages()
     else:
         dist.packages = find_packages(exclude=['*tests*'])
     dist.test_suite = 'bitten.tests.suite'
     dist.package_data = {
           'bitten': ['htdocs/*.*',
                 'templates/*.html',
                 'templates/*.txt']}
     dist.entry_points['trac.plugins'] = [
                 'bitten.admin = bitten.admin',
                 'bitten.main = bitten.main',
                 'bitten.master = bitten.master',
                 'bitten.web_ui = bitten.web_ui',
                 'bitten.testing = bitten.report.testing',
                 'bitten.coverage = bitten.report.coverage',
                 'bitten.lint = bitten.report.lint',
                 'bitten.notify = bitten.notify',
                 'bitten.xmlrpc = bitten.xmlrpc']

def find_packages_v2(base_dir, namespace_packages=None):
    result = find_packages(base_dir)
    for np in (namespace_packages or []):
        result.append(np)
        result.extend(np + '.' + p for p in find_packages(os.path.join(base_dir, np.replace('.', os.path.sep))))

    return result

 def include_in(self, dist):
     # Called when master is enabled (default, or --with-master)
     dist.metadata.name = 'iTest'
     dist.metadata.description = 'Continuous integration for Spreadtrum'
     dist.long_description = "A Trac plugin for collecting software " \
                             "metrics via continuous integration."""
     # Use full manifest when master is included
     egg_info.manifest_maker.template = "MANIFEST.in"
     # Include tests in source distribution
     if 'sdist' in dist.commands:
         dist.packages = find_packages()
     else:
         dist.packages = find_packages(exclude=['*tests*'])
     dist.test_suite = 'iTest.tests.suite'
     dist.package_data = {
           'iTest': ['htdocs/*.*',
                 'htdocs/charts_library/*.swf',
                 'templates/*.html',
                 'templates/*.txt']}
     dist.entry_points['trac.plugins'] = [
                 'iTest.admin = iTest.admin',
                 'iTest.main = iTest.main',
                 #'iTest.master = iTest.master',
                 'iTest.web_ui = iTest.web_ui'
                 #'iTest.testing = iTest.report.testing',
                 #'iTest.coverage = iTest.report.coverage',
                 #'iTest.lint = iTest.report.lint',
                 #'iTest.notify = iTest.notify'
                 ]

 def find_packages(path):
     for f in os.listdir(path):
         if f[0] == '.':
             continue
         if os.path.isdir(os.path.join(path, f)) == True:
             next_path = os.path.join(path, f)
             if '__init__.py' in os.listdir(next_path):
                 packages.append(next_path.replace(os.sep, '.'))
             find_packages(next_path)

def get_packages_list():
    """Recursively find packages in lib.

    Return a list of packages (dot notation) suitable as packages parameter
    for distutils.
    """
    if 'linux' in sys.platform:
        return find_packages('lib', exclude=["cherrypy.*"])
    else:
        return find_packages('lib')

def setup_package():
    # Figure out whether to add ``*_requires = ['numpy']``.
    setup_requires = []
    try:
        import numpy
    except ImportError:
        setup_requires.append('numpy>=1.6, <2.0')

    # the long description is unavailable in a source distribution and not essential to build
    try:
        with open('doc/abstract.txt') as f:
            long_description = f.read()
    except:
        long_description = ''

    setup_args = dict(
        name=package_name,
        packages=find_packages(),
        version=__version__,
        author='Frederik Beaujean, Stephan Jahn',
        author_email='[email protected], [email protected]',
        url='https://github.com/fredRos/pypmc',
        description='A toolkit for adaptive importance sampling featuring implementations of variational Bayes, population Monte Carlo, and Markov chains.',
        long_description=long_description,
        license='GPLv2',
        setup_requires=setup_requires,
        install_requires=['numpy', 'scipy'],
        extras_require={'testing': ['nose'], 'plotting': ['matplotlib'], 'parallelization': ['mpi4py']},
        classifiers=['Development Status :: 4 - Beta',
                     'Intended Audience :: Developers',
                     'Intended Audience :: Science/Research',
                     'License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)',
                     'Operating System :: Unix',
                     'Programming Language :: Cython',
                     'Programming Language :: Python',
                     'Programming Language :: Python :: 2.7',
                     'Programming Language :: Python :: 3',
                     'Topic :: Scientific/Engineering',
                     'Topic :: Scientific/Engineering :: Mathematics',
        ],
        platforms=['Unix'],
    )

    if len(sys.argv) >= 2 and (
            '--help' in sys.argv[1:] or
            sys.argv[1] in ('--help-commands', 'egg_info', '--version',
                            'clean')):
        # For these actions, NumPy is not required.
        pass
    else:
        setup_args['packages'] = find_packages()
        setup_args['ext_modules'] = get_extensions()

    setup(**setup_args)

def main(with_binary):
    if with_binary:
        features = {'speedups': speedups}
    else:
        features = {}

    extra = {}

    # Python 3: run 2to3
    if sys.version_info >= (3,):
        extra['use_2to3'] = True

    setup(
        name='http-parser',
        version=VERSION,
        description=DESCRIPTION,
        long_description=LONG_DESCRIPTION,
        author='Benoit Chesneau',
        author_email='[email protected]',
        license='MIT',
        url='http://github.com/benoitc/http-parser',
        classifiers=CLASSIFIERS,
        packages=find_packages(),
        platforms=['any'],
        # data_files=[('http_parser',
        #     ['LICENSE', 'MANIFEST.in', 'NOTICE', 'README.rst', 'THANKS']
        # )],
        features=features,
        **extra
    )

def setup_package():
    setupinfo.set_version(version)

    setupinfo.write_version_py()

    setup(
        name=name,
        version=setupinfo.get_version(),
        description=description,
        long_description=long_description,
        url=url,
        author=author,
        author_email=author_email,
        keywords=keywords.strip(),
        license=license,
        packages=find_packages(),
        ext_modules=setupinfo.get_extensions(),
        install_requires=setupinfo.get_install_requirements(),
        tests_require=setupinfo.get_test_requirements(),
        test_suite="pyamf.tests.get_suite",
        zip_safe=False,
        extras_require=setupinfo.get_extras_require(),
        classifiers=(
            filter(None, classifiers.strip().split('\n')) +
            setupinfo.get_trove_classifiers()
        ),
        **setupinfo.extra_setup_args())

def main():
    name = "tangods-pynutaq"

    version = "0.5.0"

    description = "Device server for the Nutaq platform."

    author = "Antonio Milan Otero"

    author_email = "[email protected]"

    license = "GPLv3"

    url = "http://www.maxlab.lu.se"

    package_dir = {'': 'src'}

    exclude=["interlocksdiags"]
    packages = find_packages('src', exclude=exclude)

    scripts = [
        'scripts/Nutaq',
        'scripts/NutaqDiags'
    ]
    setup(name=name,
          version=version,
          description=description,
          author=author,
          author_email=author_email,
          license=license,
          url=url,
          package_dir=package_dir,
          packages=packages,
          scripts=scripts
    )

 def test_dir_with_dot_is_skipped(self):
     shutil.rmtree(os.path.join(self.dist_dir, 'pkg/subpkg/assets'))
     data_dir = self._mkdir('some.data', self.pkg_dir)
     self._touch('__init__.py', data_dir)
     self._touch('file.dat', data_dir)
     packages = find_packages(self.dist_dir)
     self.assertTrue('pkg.some.data' not in packages)

def setup_package():
    import numpy.distutils.misc_util
    from gofft.distutils.misc_util import get_extensions
    NP_DEP = numpy.distutils.misc_util.get_numpy_include_dirs()

    # semantic versioning
    MAJOR = 1
    MINOR = 0
    MICRO = 0
    VERSION = '%d.%d.%d' % (MAJOR, MINOR, MICRO)

    # package to be installed
    EXCLUDED = []
    PACKAGES = find_packages(exclude=EXCLUDED)

    REQUIREMENTS = [
        'numpy>=1.9.1',
        'scipy>=0.15.0',
    ]

    EXTENSIONS = get_extensions('gofft')

    metadata = dict(
        name='gofft',
        version=VERSION,
        description='Benchmark for Goertzel algorithm and scipy.fftpack.fft',
        url='https://github.com/NaleRaphael/goertzel-fft',
        packages=PACKAGES,
        ext_modules=EXTENSIONS,
        include_dirs=NP_DEP,
        install_requires=REQUIREMENTS
    )

    setup(**metadata)

def main():
    base_dir = dirname(__file__)
    setup(
        name='flaky',
        version='2.2.0',
        description='Plugin for nose or py.test that automatically reruns flaky tests.',
        long_description=open(join(base_dir, 'README.rst')).read(),
        author='Box',
        author_email='[email protected]',
        url='https://github.com/box/flaky',
        license=open(join(base_dir, 'LICENSE')).read(),
        packages=find_packages(exclude=['test']),
        test_suite='test',
        tests_require=['pytest', 'nose'],
        zip_safe=False,
        entry_points={
            'nose.plugins.0.10': [
                'flaky = flaky.flaky_nose_plugin:FlakyPlugin'
            ],
            'pytest11': [
                'flaky = flaky.flaky_pytest_plugin'
            ]
        },
        keywords='nose pytest plugin flaky tests rerun retry',
        classifiers=CLASSIFIERS,
    )

def autosetup():
	from setuptools import setup, find_packages
    
	with open(relative_path('requirements.txt'), 'rU') as f:
		requirements_txt = f.read().split("\n")

	# check if installed with git data (not via PyPi)
	with_git = os.path.isdir(relative_path('.git'))

	return setup(
		name			= "wikiquote-extractor",
		version			= "1.0",
		
		include_package_data = True,
		zip_safe		= False,
		packages		= find_packages(),
		
		entry_points	= {
			'console_scripts': [
				'wikiquote-extractor = wikiquote_extractor.app:main',
			]
		},
		
		setup_requires = ["setuptools_git >= 0.4.2"] if with_git else [],
		install_requires = requirements_txt,
	)

def main():
    base_dir = dirname(__file__)
    setup(
        base_dir=dirname(__file__),
        name='newrelic_marklogic_plugin',
        description='NewRelic plugin for monitoring MarkLogic.',
        long_description=open(join(base_dir, 'README.rst'), encoding='utf-8').read(),
        version='0.2.8',
        packages=find_packages(),
        url='https://github.com/marklogic-community/newrelic-plugin',
        license=open(join(base_dir, 'LICENSE'), encoding='utf-8').read(),
        author='James Fuller',
        author_email='[email protected]',
        classifiers=['Programming Language :: Python',
                     'Development Status :: 3 - Alpha',
                     'Natural Language :: English',
                     'Environment :: Console',
                     'Intended Audience :: Developers',
                     'License :: OSI Approved :: Apache Software License',
                     'Operating System :: OS Independent',
                     'Topic :: Software Development :: Libraries :: Python Modules'
                     ],
        scripts = [
            'scripts/newrelic_marklogic.py'
        ],
        platforms='any',
        install_requires=[
            'requests>=2.11.1'
        ],
    )

def do_setup():
    setup(
        name="django-pretty-times",
        version=VERSION,
        author="imtapps",
        author_email="[email protected]",
        description="pretty_times provides django template helpers for the py-pretty library.",
        long_description=open('README.txt', 'r').read(),
        url="http://github.com/imtapps/django-pretty-times",
        packages=find_packages(exclude=['example']),
        install_requires=REQUIREMENTS,
        tests_require=TEST_REQUIREMENTS,
        test_suite='runtests.runtests',
        zip_safe=False,
        classifiers = [
            "Development Status :: 3 - Alpha",
            "Environment :: Web Environment",
            "Framework :: Django",
            "Intended Audience :: Developers",
            "License :: OSI Approved :: BSD License",
            "Operating System :: OS Independent",
            "Programming Language :: Python",
            "Topic :: Software Development",
            "Topic :: Software Development :: Libraries :: Application Frameworks",
        ],
        cmdclass={
            'install_dev': InstallDependencies,
            'uninstall_dev': UninstallDependencies,
        }
    )

def main():
    setup(
        name='hookbox',
        version=hookbox.__version__,
        author='Michael Carter',
        author_email='[email protected]',
        url='http://hookbox.org',
        license='MIT License',
        description='HookBox is a Comet server and message queue that tightly integrates with your existing web application via web hooks and a REST interface.',
        long_description='',
        packages= find_packages(),
        package_data = find_package_data(),
        zip_safe = False,
        install_requires = _install_requires,
        entry_points = '''    
            [console_scripts]
            hookbox = hookbox.start:main
        ''',
        
        classifiers = [
            'Development Status :: 4 - Beta',
            'Environment :: Console',
            'Intended Audience :: Developers',
            'License :: OSI Approved :: MIT License',
            'Operating System :: OS Independent',
            'Programming Language :: Python',
            'Topic :: Software Development :: Libraries :: Python Modules'
        ],        
    )

def main():
    install_requires = [
    ]
    # if sys.version_info < (3, 4):
    #     install_requires.append("")
    packages = [full_package_name] + [(full_package_name + '.' + x) for x
                                      in find_packages(exclude=['tests'])]
    setup(
        name=full_package_name,
        version=version_str,
        description="""zip2tar, a zipfile to tar convertor without intermediate
        files""",
        install_requires=install_requires,
        long_description=open('README.rst').read(),
        url='https://bitbucket.org/ruamel/' + package_name,
        author='Anthon van der Neut',
        author_email='[email protected]',
        license="MIT license",
        package_dir={full_package_name: '.'},
        namespace_packages=[name_space],
        packages=packages,
        entry_points=mk_entry_points(full_package_name),
        cmdclass={'install_lib': MyInstallLib},
        classifiers=[
            'Development Status :: 4 - Beta',
            'Intended Audience :: Developers',
            'License :: OSI Approved :: MIT License',
            'Operating System :: OS Independent',
            'Programming Language :: Python :: 3',
        ]
    )

def run_setup(build_ext):
    extra_modules = None
    if build_ext:
        extra_modules = list()

        hv_module = Extension("deap.tools._hypervolume.hv", sources=["deap/tools/_hypervolume/_hv.c", "deap/tools/_hypervolume/hv.cpp"])
        extra_modules.append(hv_module)

    setup(name='deap',
          version=deap.__revision__,
          description='Distributed Evolutionary Algorithms in Python',
          long_description=read_md('README.md'),
          author='deap Development Team',
          author_email='[email protected]',
          url='https://www.github.com/deap',
          packages=find_packages(exclude=['examples']),
        #   packages=['deap', 'deap.tools', 'deap.tools._hypervolume', 'deap.benchmarks', 'deap.tests'],
          platforms=['any'],
          keywords=['evolutionary algorithms','genetic algorithms','genetic programming','cma-es','ga','gp','es','pso'],
          license='LGPL',
          classifiers=[
            'Development Status :: 4 - Beta',
            'Intended Audience :: Developers',
            'Intended Audience :: Education',
            'Intended Audience :: Science/Research',
            'License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)',
            'Programming Language :: Python',
            'Programming Language :: Python :: 3',
            'Topic :: Scientific/Engineering',
            'Topic :: Software Development',
            ],
         ext_modules = extra_modules,
         cmdclass = {"build_ext" : ve_build_ext},
         use_2to3=True
    )

def setup_package():
    # Assemble additional setup commands
    cmdclass = {}
    cmdclass["test"] = PyTest

    install_reqs = get_install_requirements("requirements.txt")

    command_options = {"test": {"test_suite": ("setup.py", "tests"), "cov": ("setup.py", MAIN_PACKAGE)}}
    if JUNIT_XML:
        command_options["test"]["junitxml"] = "setup.py", "junit.xml"
    if COVERAGE_XML:
        command_options["test"]["cov_xml"] = "setup.py", True
    if COVERAGE_HTML:
        command_options["test"]["cov_html"] = "setup.py", True

    setup(
        name=NAME,
        version=VERSION,
        url=URL,
        description=DESCRIPTION,
        author=AUTHOR,
        author_email=EMAIL,
        license=LICENSE,
        keywords=KEYWORDS,
        long_description=read("README.rst"),
        classifiers=CLASSIFIERS,
        test_suite="tests",
        packages=setuptools.find_packages(exclude=["tests", "tests.*"]),
        install_requires=install_reqs,
        setup_requires=["flake8"],
        cmdclass=cmdclass,
        tests_require=["pytest-cov", "pytest"],
        command_options=command_options,
        entry_points={"console_scripts": CONSOLE_SCRIPTS},
    )