def __call__(self, options, args):
        sys.argv = [sys.argv[0]] + args
        assert setup is not None, "You must have setuptools installed to use SetupCLI"
        here = os.path.dirname(os.path.abspath(__file__))
        try:
            filename = os.path.join(here, 'README.txt')
            description = file(filename).read()
        except:    
            description = ''
        os.chdir(here)

        setup(name='ManifestDestiny',
              version=version,
              description="Universal manifests for Mozilla test harnesses",
              long_description=description,
              classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
              keywords='mozilla manifests',
              author='Jeff Hammel',
              author_email='jhammel@mozilla.com',
              url='https://wiki.mozilla.org/Auto-tools/Projects/ManifestDestiny',
              license='MPL',
              zip_safe=False,
              py_modules=['manifestparser'],
              install_requires=[
                  # -*- Extra requirements: -*-
                  ],
              entry_points="""
              [console_scripts]
              manifestparser = manifestparser:main
              """,
              )
Example #2
0
def main():
    if float(sys.version[:3])<2.6 or float(sys.version[:3])>=2.8:
        sys.stderr.write("CRITICAL: Python version must be 2.6 or 2.7!\n")
        sys.exit(1)

    setup(name="AREM",
          version="1.0.1",
          description="Aligning Reads by Expectation-Maximization.\nBased on MACS (Model Based Analysis for ChIP-Seq data)",
          author='Jake Biesinger; Daniel Newkirk; Alvin Chon; Yong Zhang; Tao (Foo) Liu',
          author_email='jake.biesinger@gmail.com; dnewkirk@uci.edu; achon@uci.edu; zy@jimmy.harvard.edu; taoliu@jimmy.harvard.edu',
          url='http://cbcl.ics.uci.edu/AREM',
          long_description=read('README'),
          package_dir={'AREM' : 'AREM'},
          packages=['AREM', 'AREM.IO'],
          scripts=['bin/arem','bin/elandmulti2bed','bin/elandresult2bed','bin/elandexport2bed',
                   'bin/sam2bed', 'bin/wignorm'],
          license = "Creative",
          classifiers=[
              'Development Status :: 4 - Beta',
              'Environment :: Console',
              'Intended Audience :: Developers',
              'Intended Audience :: Science/Research',
              'License :: OSI Approved :: Artistic License',
              'Operating System :: MacOS :: MacOS X',
              'Operating System :: Microsoft :: Windows',
              'Operating System :: POSIX',
              'Programming Language :: Python :: 2.6',
              'Programming Language :: Python :: 2.7',
              'Topic :: Scientific/Engineering :: Bio-Informatics'
              ],
          )
Example #3
0
def main():
    import io
    with io.open(os.path.join(HERE, 'README.rst'), 'r') as readme:
        setup(
            name                 = __project__,
            version              = __version__,
            description          = __doc__,
            long_description     = readme.read(),
            classifiers          = __classifiers__,
            author               = __author__,
            author_email         = __author_email__,
            url                  = __url__,
            license              = [
                c.rsplit('::', 1)[1].strip()
                for c in __classifiers__
                if c.startswith('License ::')
                ][0],
            keywords             = __keywords__,
            packages             = find_packages(),
            package_data         = {},
            include_package_data = True,
            platforms            = __platforms__,
            install_requires     = __requires__,
            extras_require       = __extra_requires__,
            zip_safe             = False,
            entry_points         = __entry_points__,
            )
Example #4
0
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='benoitc@e-engura.com',
        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
    )
Example #5
0
def run_setup(with_cext):
    kwargs = {}
    if with_cext:
        kwargs['ext_modules'] = ext_modules
    else:
        kwargs['ext_modules'] = []

    setup(
        name='Logbook',
        version=__version__,
        license='BSD',
        url='http://logbook.pocoo.org/',
        author='Armin Ronacher, Georg Brandl',
        author_email='armin.ronacher@active-4.com',
        description='A logging replacement for Python',
        long_description=__doc__,
        packages=['logbook'],
        zip_safe=False,
        platforms='any',
        cmdclass=cmdclass,
        tests_require=['pytest'],
        classifiers=[
            'Programming Language :: Python :: 2.6',
            'Programming Language :: Python :: 2.7',
            'Programming Language :: Python :: 3.2',
            'Programming Language :: Python :: 3.3',
            'Programming Language :: Python :: 3.4',
            'Programming Language :: Python :: 3.5',
        ],
        extras_require=extras_require,
        distclass=Distribution,
        **kwargs
    )
Example #6
0
def run_setup(ext_modules, run_make):
    if run_make:
        make()
    setup(
        name='gevent',
        version=__version__,
        description='Coroutine-based network library',
        long_description=read('README.rst'),
        author='Denis Bilenko',
        author_email='denis.bilenko@gmail.com',
        url='http://www.gevent.org/',
        packages=['gevent'],
        include_package_data=include_package_data,
        ext_modules=ext_modules,
        cmdclass=dict(build_ext=my_build_ext, sdist=sdist),
        install_requires=install_requires,
        zip_safe=False,
        classifiers=[
            "License :: OSI Approved :: MIT License",
            "Programming Language :: Python :: 2.6",
            "Programming Language :: Python :: 2.7",
            "Programming Language :: Python :: 3.3",
            "Programming Language :: Python :: 3.4",
            "Programming Language :: Python :: Implementation :: CPython",
            "Programming Language :: Python :: Implementation :: PyPy",
            "Operating System :: MacOS :: MacOS X",
            "Operating System :: POSIX",
            "Operating System :: Microsoft :: Windows",
            "Topic :: Internet",
            "Topic :: Software Development :: Libraries :: Python Modules",
            "Intended Audience :: Developers",
            "Development Status :: 4 - Beta"]
    )
Example #7
0
def main():
    install_requires = [
        ]
    packages = [full_package_name] + [(full_package_name + '.' + x) for x
                                     in find_packages(exclude=['tests'])]

    setup(
        name=full_package_name,
        version=version_str,
        description='a version of dict that keeps keys in '\
                    'insertion resp. sorted order',
        install_requires=[
        ],
        #install_requires=install_requires,
        long_description=open('README.rst').read(),
        url='https://bitbucket.org/ruamel/' + package_name,
        author='Anthon van der Neut',
        author_email='a.van.der.neut@ruamel.eu',
        license="MIT license",
        package_dir={full_package_name: '.'},
        namespace_packages=[name_space],
        packages=packages,
        ext_modules = [module1],
        cmdclass={'install_lib': MyInstallLib},
        classifiers=[
            'Development Status :: 4 - Beta',
            'Intended Audience :: System Administrators',
            'License :: OSI Approved :: MIT License',
            'Operating System :: POSIX :: Linux',
            'Programming Language :: Python',
        ],
    )
Example #8
0
def run_setup(with_binary):
    cmdclass = dict(test=TestCommand)
    if with_binary:
        kw = dict(
            ext_modules = [
                Extension("simplejson._speedups", ["simplejson/_speedups.c"]),
            ],
            cmdclass=dict(cmdclass, build_ext=ve_build_ext),
        )
    else:
        kw = dict(cmdclass=cmdclass)

    setup(
        name="simplejson",
        version=VERSION,
        description=DESCRIPTION,
        long_description=LONG_DESCRIPTION,
        classifiers=CLASSIFIERS,
        author="Bob Ippolito",
        author_email="bob@redivi.com",
        url="http://github.com/simplejson/simplejson",
        license="MIT License",
        packages=['simplejson', 'simplejson.tests'],
        platforms=['any'],
        **kw)
Example #9
0
def install(the_package,version,date):
    
    # imports
    try:
        from setuptools import setup
    except ImportError:
        from distutils.core import setup
        
    # test for requirements
    import_tests()
    
    # list all SUAVE sub packages
    #print 'Listing Packages and Sub-Packages:'
    packages = list_subpackages(the_package,verbose=False)
    packages = map( '.'.join, packages )

    # run the setup!!!
    setup(
        name = the_package,
        version = version, 
        description = 'SUAVE: Stanford University Aerospace Vehicle Environment',
        author = 'Stanford University Aerospace Design Lab (ADL)',
        author_email = 'suave-developers@lists.stanford.edu',
        maintainer = 'The Developers',
        url = 'suave.stanford.edu',
        packages = packages,
        include_package_data = True,
        license = 'CC BY-NC-SA 4.0',
        platforms = ['Win, Linux, Unix, Mac OS-X'],
        zip_safe  = False,
        long_description = read('../README.md')
    )  
    
    return
Example #10
0
def run_setup(extensions):
    kw = {'cmdclass': {'doc': DocCommand, 'gevent_nosetests': gevent_nosetests}}
    if extensions:
        kw['cmdclass']['build_ext'] = build_extensions
        kw['ext_modules'] = extensions

    dependencies = ['futures', 'scales', 'blist']
    if platform.python_implementation() != "CPython":
        dependencies.remove('blist')

    setup(
        name='cassandra-driver',
        version=__version__,
        description='Python driver for Cassandra',
        long_description=long_description,
        url='http://github.com/datastax/python-driver',
        author='Tyler Hobbs',
        author_email='tyler@datastax.com',
        packages=['cassandra', 'cassandra.io'],
        include_package_data=True,
        install_requires=dependencies,
        tests_require=['nose', 'mock', 'ccm', 'unittest2', 'PyYAML', 'pytz'],
        classifiers=[
            'Development Status :: 5 - Production/Stable',
            'Intended Audience :: Developers',
            'License :: OSI Approved :: Apache Software License',
            'Natural Language :: English',
            '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'
        ],
        **kw)
Example #11
0
def main():
    kwargs = dict(
        name='rrdtool',
        version=package_version,
        description='Python bindings for rrdtool',
        keywords=['rrdtool'],
        author='Christian Kroeger, Hye-Shik Chang',
        author_email='commx@commx.ws',
        license='LGPL',
        url='https://github.com/commx/python-rrdtool',
        classifiers=['License :: OSI Approved',
                     'Operating System :: POSIX',
                     'Operating System :: Unix',
                     'Operating System :: MacOS',
                     'Programming Language :: C',
                     'Programming Language :: Python',
                     'Programming Language :: Python :: 2.7',
                     'Programming Language :: Python :: 3.3',
                     'Programming Language :: Python :: 3.4',
                     'Programming Language :: Python :: 3.5',
        ],
        ext_modules=check_extensions(),
        test_suite='tests'
    )

    setup(**kwargs)
Example #12
0
def run_setup():
    if sys.argv[1] == 'build':
        shutil.copy('.libs/frontend.so', 'frontend.so')

    setup(name = 'thrift-py',
        version = '0.9.0',
        description = 'Thrift python compiler',
        author = ['Thrift Developers'],
        author_email = ['dev@thrift.apache.org'],
        url = 'http://thrift.apache.org',
        license = 'Apache License 2.0',
        packages = [
            'thrift_compiler',
            'thrift_compiler.generate',
        ],
        package_dir = {'thrift_compiler' : '.'},
        package_data = {'thrift_compiler':['frontend.so']},
        classifiers = [
            'Development Status :: 5 - Production/Stable',
            'Environment :: Console',
            'Intended Audience :: Developers',
            'Programming Language :: Python',
            'Programming Language :: Python :: 2',
            'Topic :: Software Development :: Libraries',
            'Topic :: System :: Networking'
        ],
        zip_safe = False,
    )
def main():
    if sys.version < required_python_version:
        s = "I'm sorry, but %s %s requires Python %s or later."
        print(s % (name, version, required_python_version))
        sys.exit(1)
    # set default location for "data_files" to
    # platform specific "site-packages" location
    for scheme in list(INSTALL_SCHEMES.values()):
        scheme['data'] = scheme['purelib']

    setup(
        name=name,
        version=version,
        description=desc,
        long_description=long_desc,
        classifiers=classifiers,
        author=author,
        author_email=author_email,
        url=url,
        license=cp_license,
        packages=packages,
        data_files=data_files,
        scripts=scripts,
        cmdclass=cmd_class,
    )
Example #14
0
def main():
    base_dir = dirname(__file__)
    install_requires = ['requests>=2.4.3', 'six>=1.4.0', 'requests-toolbelt>=0.4.0']
    redis_requires = ['redis>=2.10.3']
    jwt_requires = ['pyjwt>=1.3.0', 'cryptography>=0.9.2']
    if version_info < (3, 4):
        install_requires.append('enum34>=1.0.4')
    elif version_info < (2, 7):
        install_requires.append('ordereddict>=1.1')
    setup(
        name='boxsdk',
        version='1.3.2',
        description='Official Box Python SDK',
        long_description=open(join(base_dir, 'README.rst')).read(),
        author='Box',
        author_email='oss@box.com',
        url='http://opensource.box.com',
        packages=find_packages(exclude=['demo', 'docs', 'test']),
        install_requires=install_requires,
        extras_require={'jwt': jwt_requires, 'redis': redis_requires},
        tests_require=['pytest', 'pytest-xdist', 'mock', 'sqlalchemy', 'bottle', 'jsonpatch'],
        cmdclass={'test': PyTest},
        classifiers=CLASSIFIERS,
        keywords='box oauth2 sdk',
        license=open(join(base_dir, 'LICENSE')).read(),
    )
Example #15
0
def main():
    install_requires = ["py>=1.4.29"]  # pluggy is vendored in _pytest.vendored_packages
    extras_require = {}
    if has_environment_marker_support():
        extras_require[':python_version=="2.6" or python_version=="3.0" or python_version=="3.1"'] = ["argparse"]
        extras_require[':sys_platform=="win32"'] = ["colorama"]
    else:
        if sys.version_info < (2, 7) or (3,) <= sys.version_info < (3, 2):
            install_requires.append("argparse")
        if sys.platform == "win32":
            install_requires.append("colorama")

    setup(
        name="pytest",
        description="pytest: simple powerful testing with Python",
        long_description=long_description,
        version=get_version(),
        url="http://pytest.org",
        license="MIT license",
        platforms=["unix", "linux", "osx", "cygwin", "win32"],
        author="Holger Krekel, Bruno Oliveira, Ronny Pfannschmidt, Floris Bruynooghe, Brianna Laugher, Florian Bruhin and others",
        author_email="holger at merlinux.eu",
        entry_points=make_entry_points(),
        classifiers=classifiers,
        cmdclass={"test": PyTest},
        # the following should be enabled for release
        install_requires=install_requires,
        extras_require=extras_require,
        packages=["_pytest", "_pytest.assertion", "_pytest._code", "_pytest.vendored_packages"],
        py_modules=["pytest"],
        zip_safe=False,
    )
Example #16
0
def _setup(longdescription):
    setup(name=PKG,
          version=version,
          description='Python wrappers for a few algorithms from the Crypto++ library',
          long_description=longdescription,
          author='Zooko Wilcox-O\'Hearn',
          author_email='zooko@zooko.com',
          url='https://tahoe-lafs.org/trac/' + PKG,
          license='GNU GPL', # see README.rst for details -- there is also an alternative licence
          packages=["pycryptopp",
                    "pycryptopp.cipher",
                    "pycryptopp.hash",
                    "pycryptopp.publickey",
                    "pycryptopp.publickey.ed25519",
                    "pycryptopp.test",
                    ],
          include_package_data=True,
          exclude_package_data={
              '': [ '*.cpp', '*.hpp', ]
              },
          data_files=data_files,
          package_dir={"pycryptopp": "src/pycryptopp"},
          setup_requires=setup_requires,
          install_requires=install_requires,
          dependency_links=dependency_links,
          classifiers=trove_classifiers,
          ext_modules=ext_modules,
          test_suite=PKG+".test",
          zip_safe=False, # I prefer unzipped for easier access.
          cmdclass=commands,
          )
Example #17
0
def setup_cclib():

    doclines = __doc__.split("\n")

    setuptools.setup(
        name="cclib",
        version="1.5.3",
        url="http://cclib.github.io/",
        author="cclib development team",
        author_email="cclib-users@lists.sourceforge.net",
        maintainer="cclib development team",
        maintainer_email="cclib-users@lists.sourceforge.net",
        license="BSD 3-Clause License",
        description=doclines[0],
        long_description="\n".join(doclines[2:]),
        classifiers=classifiers.split("\n"),
        platforms=["Any."],
        packages=setuptools.find_packages(exclude=['*test*']),
        entry_points={
            'console_scripts': [
                'ccget=cclib.scripts.ccget:ccget',
                'ccwrite=cclib.scripts.ccwrite:main',
                'cda=cclib.scripts.cda:main'
            ]
        }

    )
Example #18
0
def build_extension(dir_name, extension_name, target_pydevd_name, force_cython, extended=False, has_pxd=False):
    pyx_file = os.path.join(os.path.dirname(__file__), dir_name, "%s.pyx" % (extension_name,))

    if target_pydevd_name != extension_name:
        # It MUST be there in this case!
        # (otherwise we'll have unresolved externals because the .c file had another name initially).
        import shutil

        # We must force cython in this case (but only in this case -- for the regular setup in the user machine, we
        # should always compile the .c file).
        force_cython = True

        new_pyx_file = os.path.join(os.path.dirname(__file__), dir_name, "%s.pyx" % (target_pydevd_name,))
        new_c_file = os.path.join(os.path.dirname(__file__), dir_name, "%s.c" % (target_pydevd_name,))
        shutil.copy(pyx_file, new_pyx_file)
        pyx_file = new_pyx_file
        if has_pxd:
            pxd_file = os.path.join(os.path.dirname(__file__), dir_name, "%s.pxd" % (extension_name,))
            new_pxd_file = os.path.join(os.path.dirname(__file__), dir_name, "%s.pxd" % (target_pydevd_name,))
            shutil.copy(pxd_file, new_pxd_file)
        assert os.path.exists(pyx_file)

    try:
        if force_cython:
            from Cython.Build import cythonize  # @UnusedImport
            ext_modules = cythonize([
                "%s/%s.pyx" % (dir_name, target_pydevd_name,),
            ])
        else:
            # Always compile the .c (and not the .pyx) file (which we should keep up-to-date by running build_tools/build.py).
            from distutils.extension import Extension
            ext_modules = [Extension("%s%s.%s" % (dir_name, "_ext" if extended else "", target_pydevd_name,),
                                     [os.path.join(dir_name, "%s.c" % target_pydevd_name), ],
                                     # uncomment to generate pdbs for visual studio.
                                     # extra_compile_args=["-Zi", "/Od"],
                                     # extra_link_args=["-debug"],
                                     )]

        setup(
            name='Cythonize',
            ext_modules=ext_modules
        )
    finally:
        if target_pydevd_name != extension_name:
            try:
                os.remove(new_pyx_file)
            except:
                import traceback
                traceback.print_exc()
            try:
                os.remove(new_c_file)
            except:
                import traceback
                traceback.print_exc()
            if has_pxd:
                try:
                    os.remove(new_pxd_file)
                except:
                    import traceback
                    traceback.print_exc()
Example #19
0
def main():
    name = "tangods-pynutaq"

    version = "0.5.0"

    description = "Device server for the Nutaq platform."

    author = "Antonio Milan Otero"

    author_email = "antonio.milan_otero@maxlab.lu.se"

    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
    )
Example #20
0
def main():
    setup(
        name='hookbox',
        version=hookbox.__version__,
        author='Michael Carter',
        author_email='CarterMichael@gmail.com',
        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'
        ],        
    )
Example #21
0
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())
Example #22
0
def setup_package():
    write_version_py()
    setup(
        name = NAME,
        version = VERSION,
        description = DESCRIPTION,
        long_description = LONG_DESCRIPTION,
        author = AUTHOR,
        author_email = AUTHOR_EMAIL,
        url = URL,
        download_url = DOWNLOAD_URL,
        license = LICENSE,
        keywords = KEYWORDS,
        classifiers = CLASSIFIERS,
        packages = PACKAGES,
        package_data = PACKAGE_DATA,
        setup_requires = SETUP_REQUIRES,
        extras_require = EXTRAS_REQUIRE,
        install_requires = INSTALL_REQUIRES,
        dependency_links = DEPENDENCY_LINKS,
        entry_points = ENTRY_POINTS,
        include_package_data = True,
        zip_safe = False,
        test_suite = 'Orange.testing.unit.tests.test_suite',
        cmdclass = cmdclass,
        ext_modules = ext_modules,
    )
Example #23
0
def main():

    setup(
        name = 'transloader',
        packages=['transloader'],
        package_dir = {'transloader':'transloader'},
        version = open('VERSION.txt').read().strip(),
        author='Mike Thornton',
        author_email='six8@devdetails.com',
        url='http://github.com/six8/transloader',
        download_url='http://github.com/six8/transloader',
        keywords=['transloadit'],
        license='MIT',
        description='A transloadit client',
        classifiers = [
            "Programming Language :: Python",
            "Development Status :: 3 - Alpha",
            "Intended Audience :: Developers",
            "License :: OSI Approved :: MIT License",
            "Natural Language :: English",
            "Topic :: Software Development :: Libraries :: Python Modules",
        ],
        long_description=open('README.rst').read(),
        install_requires = [
            'requests'
        ]
    )
Example #24
0
def install(appname):

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

    setup(
          name = appname,
          version = clipboard.VERSION,
          description = ''' A code analyzer without caring the C/C++ header files.
It works with Java, C/C++, JavaScript, Python, Objective C. Metrics includes cyclomatic complexity number etc.''',
          long_description =  readme,
          url = 'https://github.com/terryyin/clipboard',
          download_url='https://pypi.python.org/clipboard/',
          license='MIT',
          platforms='any',
          classifiers = ['Development Status :: 5 - Production/Stable',
                     'Intended Audience :: Developers',
                     'Intended Audience :: End Users/Desktop',
                     'License :: Freeware',
                     'Operating System :: POSIX',
                     'Operating System :: Microsoft :: Windows',
                     'Operating System :: MacOS :: MacOS X',
                     'Topic :: Software Development :: Quality Assurance',
                     'Programming Language :: Python',
                     'Programming Language :: Python :: 2.7',
                     'Programming Language :: Python :: 3.2',
                     'Programming Language :: Python :: 3.3'],
          py_modules = ['clipboard'],
          install_requires=['pyperclip'],
          author = 'Terry Yin',
          author_email = 'terry@odd-e.com',
          )
Example #25
0
def setup_package():
    write_version_py()
    setup(
        name=NAME,
        version=VERSION,
        description=DESCRIPTION,
        long_description=LONG_DESCRIPTION,
        author=AUTHOR,
        author_email=AUTHOR_EMAIL,
        maintainer=MAINTAINER,
        maintainer_email=MAINTAINER_EMAIL,
        url=URL,
        download_url=DOWNLOAD_URL,
        license=LICENSE,
        keywords=KEYWORDS,
        classifiers=CLASSIFIERS,
        packages=PACKAGES,
        package_data=PACKAGE_DATA,
        entry_points = ENTRY_POINTS,
        # extra setuptools args
        zip_safe=False,  # the package can run out of an .egg file
        include_package_data=True,
        install_requires=INSTALL_REQUIRES,
        setup_requires=SETUP_REQUIRES,
    )
Example #26
0
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='deap-users@googlegroups.com',
          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
    )
Example #27
0
def build_cocoa_base(cocoa_path):
    import objp.o2p
    import objp.p2o
    sys.path.insert(0, cocoa_path)
    import pyplugin
    objp.o2p.generate_objc_code(pyplugin.PyMainWindow, op.join(cocoa_path, 'autogen'))
    objp.o2p.generate_objc_code(pyplugin.PyTextHolder, op.join(cocoa_path, 'autogen'))
    textholder_spec = objp.o2p.spec_from_python_class(pyplugin.TextHolderView)
    objp.p2o.generate_python_proxy_code_from_clsspec([textholder_spec], 'build/TextHolderView.m')
    from setuptools import setup, Extension
    exts = [
        Extension("TextHolderView", ['build/TextHolderView.m', 'build/ObjP.m'],
            extra_link_args=["-framework", "Foundation"]),
    ]
    setup(
        script_args = ['build_ext', '--inplace'],
        ext_modules = exts,
    )
    pydest = 'build/py'
    if not op.exists(pydest):
        os.mkdir(pydest)
    shutil.copy('TextHolderView.so', pydest)
    shutil.copy(op.join(cocoa_path, 'pyplugin.py'), pydest)
    # For some strange reason, a "site.py" file is required at pydest.
    with open(op.join(pydest, 'site.py'), 'w'):
        pass
    from pluginbuilder import copy_embeddable_python_dylib, collect_dependencies
    copy_embeddable_python_dylib('build')
    collect_dependencies(op.join(cocoa_path, 'pyplugin.py'), pydest)
Example #28
0
def do_setup():
    setup(name=NAME,
          version=versioneer.get_version(),
          description=DESCRIPTION,
          long_description=LONG_DESCRIPTION,
          classifiers=CLASSIFIERS,
          author=AUTHOR,
          author_email=AUTHOR_EMAIL,
          url=URL,
          license=LICENSE,
          platforms=PLATFORMS,
          packages=find_packages(),
          cmdclass=versioneer.get_cmdclass(),
          install_requires=['numpy>=1.9.1', 'scipy>=0.14', 'six>=1.9.0'],
          # pygments is a dependency for Sphinx code highlight
          extras_require={
              'test': ['nose>=1.3.0', 'parameterized', 'flake8<3'],
              'doc': ['Sphinx>=0.5.1', 'pygments']
          },
          package_data={
              '': ['*.txt', '*.rst', '*.cu', '*.cuh', '*.c', '*.sh', '*.pkl',
                   '*.h', '*.cpp', 'ChangeLog', 'c_code/*'],
              'theano.misc': ['*.sh'],
              'theano.d3viz': ['html/*', 'css/*', 'js/*']
          },
          entry_points={
              'console_scripts': ['theano-cache = bin.theano_cache:main',
                                  'theano-nose = bin.theano_nose:main']
          },
          keywords=' '.join([
              'theano', 'math', 'numerical', 'symbolic', 'blas',
              'numpy', 'gpu', 'autodiff', 'differentiation'
          ]),
    )
Example #29
0
def dosetup(name, version, packages, datafiles, scripts, ext_modules=[]):
    from setuptools import setup
    description, long_description = __doc__.split("\n", 1)
    kwargs = {}
    if py2exe:
        kwargs["distclass"] = TranslateDistribution

    setup(name=name,
          version=version,
          license="GNU General Public License (GPL)",
          description=description,
          long_description=long_description,
          author="Translate",
          author_email="translate-devel@lists.sourceforge.net",
          url="http://toolkit.translatehouse.org/",
          download_url="http://sourceforge.net/projects/translate/files/Translate Toolkit/" + version,
          platforms=["any"],
          classifiers=classifiers,
          packages=packages,
          data_files=datafiles,
          scripts=scripts,
          ext_modules=ext_modules,
          cmdclass=cmdclass,
          install_requires=parse_requirements('requirements/required.txt'),
          **kwargs
    )
Example #30
0
def setup_package():
  setup(
      name = 'kegbot-pycore',
      version = VERSION,
      description = SHORT_DESCRIPTION,
      long_description = LONG_DESCRIPTION,
      author = 'Bevbot LLC',
      author_email = 'info@bevbot.com',
      url = 'https://kegbot.org/docs/pycore',
      packages = find_packages(exclude=['testdata']),
      namespace_packages = ['kegbot'],
      scripts = [
        'bin/kegboard_daemon.py',
        'bin/kegbot_core.py',
        'bin/lcd_daemon.py',
        'bin/rfid_daemon.py',
        'bin/test_flow.py',
      ],
      install_requires = [
        'kegbot-pyutils == 0.1.7',
        'kegbot-api >= 0.1.17',
        'kegbot-kegboard == 1.1.2',
        'redis >= 2.9.1, < 3.0',

        'python-gflags == 2.0',
      ],
      include_package_data = True,
  )