Example #1
1
def main():
    setup_args = dict(
        name="gyagp",
        version=VERSION,
        download_url="http://www.gyagp.com/gyagp-%s.tar.gz" % VERSION,
        description="A small but full featured python project",
        long_description=get_description(),
        keywords=["gyagp"],
        author="Yang Gu",
        author_email="gyagp0@gmail.com",
        url="http://www.gyagp.com",
        platforms="Platform Independent",
        license="License :: OSI Approved :: BSD License",
        packages=["gyagp"],
        classifiers=[
            "Development Status :: 5 - Production/Stable",
            "Environment :: Console",
            "Natural Language :: English",
            "Operating System :: OS Independent",
            "Programming Language :: Python :: 2",
            "Topic :: Utilities",
            "Topic :: Software Development :: Libraries",
            "Topic :: Software Development :: Libraries :: Python Modules",
            "Intended Audience :: Developers",
            "License :: OSI Approved :: BSD License",
        ],
        install_requires=["pywin32"],
    )

    setup(**setup_args)
Example #2
1
def main(**kwargs):
    write_version_py(VERSION, ISRELEASED, "osprey/version.py")

    classifiers = """\
    Development Status :: 3 - Alpha
    Intended Audience :: Science/Research
    License :: OSI Approved :: Apache Software License
    Programming Language :: Python
    Programming Language :: Python :: 2.7
    Programming Language :: Python :: 3
    Programming Language :: Python :: 3.4
    Programming Language :: Python :: 3.5
    Operating System :: Unix
    Operating System :: MacOS
    Operating System :: Microsoft :: Windows
    Topic :: Scientific/Engineering
    Topic :: Scientific/Engineering :: Information Analysis"""
    setup(
        name="osprey",
        author="Robert T. McGibbon",
        author_email="rmcgibbo@gmail.com",
        url="https://github.com/msmbuilder/osprey",
        classifiers=[e.strip() for e in classifiers.splitlines()],
        platforms=["Windows", "Linux", "Mac OS-X", "Unix"],
        license="Apache Software License",
        download_url="https://pypi.python.org/pypi/osprey/",
        version=VERSION,
        packages=find_packages(),
        zip_safe=False,
        package_data={"osprey": ["data/*"]},
        entry_points={"console_scripts": ["osprey = osprey.cli.main:main"]},
        **kwargs
    )
Example #3
1
def main():
    setup(
        name="stcrestclient",
        version="1.3.2",
        author="Andrew Gillis",
        author_email="andrew.gillis@spirent.com",
        url="https://github.com/Spirent/py-stcrestclient",
        description="stcrestclient: Client modules for STC ReST API",
        long_description="See https://github.com/Spirent/py-stcrestclient#python-stc-rest-api-client-stcrestclient",
        license="http://www.opensource.org/licenses/mit-license.php",
        platforms=["unix", "linux", "osx", "cygwin", "win32"],
        keywords="Spirent TestCenter API",
        classifiers=[
            "Development Status :: 5 - Production/Stable",
            "Intended Audience :: Developers",
            "License :: OSI Approved :: MIT License",
            "Operating System :: POSIX",
            "Operating System :: Microsoft :: Windows",
            "Operating System :: MacOS :: MacOS X",
            "Topic :: Software Development :: Libraries",
            "Topic :: Utilities",
            "Programming Language :: Python",
            "Programming Language :: Python :: 2.7",
            "Programming Language :: Python :: 3",
        ],
        packages=["stcrestclient"],
        install_requires=["requests>=2.7"],
        zip_safe=True,
    )
Example #4
1
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.split("\n")) + setupinfo.get_trove_classifiers()),
        **setupinfo.extra_setup_args()
    )
Example #5
1
def run_setup(with_binary):
    features = {}
    if with_binary:
        features["speedups"] = speedups
    setup(
        name="MarkupSafe",
        version="0.16",
        url="http://github.com/mitsuhiko/markupsafe",
        license="BSD",
        author="Armin Ronacher",
        author_email="armin.ronacher@active-4.com",
        description="Implements a XML/HTML/XHTML Markup safe string for Python",
        long_description=readme,
        zip_safe=False,
        classifiers=[
            "Development Status :: 5 - Production/Stable",
            "Environment :: Web Environment",
            "Intended Audience :: Developers",
            "License :: OSI Approved :: BSD License",
            "Operating System :: OS Independent",
            "Programming Language :: Python",
            "Programming Language :: Python :: 3",
            "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
            "Topic :: Software Development :: Libraries :: Python Modules",
            "Topic :: Text Processing :: Markup :: HTML",
        ],
        packages=["markupsafe"],
        test_suite="markupsafe.tests.suite",
        include_package_data=True,
        cmdclass={"build_ext": ve_build_ext},
        features=features,
    )
Example #6
1
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 #7
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 #8
0
def do_setup():
    write_version_py()
    setup(
        name=NAME,
        version=VERSION,
        description=DESCRIPTION,
        long_description=LONG_DESCRIPTION,
        classifiers=CLASSIFIERS,
        author=AUTHOR,
        author_email=AUTHOR_EMAIL,
        url=URL,
        license=LICENSE,
        platforms=PLATFORMS,
        packages=find_packages(),
        # 1.7.0 give too much warning related to numpy.diagonal.
        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", "nose-parameterized>=0.5.0", "flake8<3"],
            "doc": ["Sphinx>=0.5.1", "pygments"],
        },
        package_data={
            "": ["*.txt", "*.rst", "*.cu", "*.cuh", "*.c", "*.sh", "*.pkl", "*.h", "*.cpp", "ChangeLog"],
            "theano.misc": ["*.sh"],
            "theano.d3viz": ["html/*", "css/*", "js/*"],
        },
        scripts=["bin/theano-cache", "bin/theano-nose", "bin/theano-test"],
        keywords=" ".join(
            ["theano", "math", "numerical", "symbolic", "blas", "numpy", "gpu", "autodiff", "differentiation"]
        ),
    )
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,
        cmdclass=cmdclass,
        ext_modules=ext_modules,
    )
Example #10
0
def main():

    setup(
        name="pyramid_redis_sessions",
        version=package_version,
        description="Pyramid web framework session factory backed by Redis",
        long_description=README + "\n\n" + CHANGES,
        classifiers=[
            "Intended Audience :: Developers",
            "Framework :: Pyramid",
            "Programming Language :: Python :: 2.7",
            "Programming Language :: Python :: 3.3",
            "Programming Language :: Python :: 3.4",
        ],
        keywords="pyramid session redis",
        author="Eric Rasmussen",
        author_email="eric@chromaticleaves.com",
        url="https://github.com/ericrasmussen/pyramid_redis_sessions",
        license="FreeBSD",
        packages=find_packages(),
        # test_suite='pyramid_redis_sessions.tests',
        test_suite="nose.collector",
        include_package_data=True,
        zip_safe=False,
        tests_require=testing_requires,
        install_requires=install_requires,
        entry_points="",
        extras_require={"testing": testing_extras, "docs": docs_extras},
    )
Example #11
0
def run_setup(params=None):
    argv = sys.argv
    command = argv[1] if len(argv) > 1 else None
    if not params or command == "sdist":
        params = {"cmdclass": {}}
    else:
        params = params()
    if command != "sdist":
        params["install_requires"] = install_requires
    if sys.platform == "darwin":
        params["cmdclass"]["install_data"] = osx_install_data
    else:
        params["cmdclass"]["install_data"] = install_data
    params.update(
        {
            "name": package_fullname,
            "version": mod.__version__,
            "author": mod.__author__,
            "author_email": mod.__contact__,
            "maintainer_email": mod.__contact__,
            "url": mod.__homepage__,
            "license": mod.__license__,
            "description": mod.__doc__,
            "long_description": read("README.rst"),
            "packages": packages,
            "package_data": {package_name: data_files},
            "classifiers": mod.CLASSIFIERS,
        }
    )
    setup(**params)
Example #12
0
def buildApp():
    sys.path.append("src")
    sys.path.append(GTK_DIR + "/lib/python2.5/site-packages")
    sys.path.append(GTK_DIR + "/lib/python2.5/site-packages/gtk-2.0")
    OPTIONS = {
        "argv_emulation": True,
        "excludes": "docutils,Crypto,dbus,OpenSSL,cairo,gtk,gobject,atk,pangocairo",
        "iconfile": "data/pixmaps/gajim.icns",
        "includes": "osx,ConfigParser,compiler,UserString,history_manager",
        "plist": {
            "LSMinimumSystemVersion": "10.4.0",
            "NSHumanReadableCopyright": "GNU General Public License",
            "CFBundleIdentifier": "org.gajim",
            "NSMainNibFile": "Gajim",
        },
    }
    setup(
        name=NAME,
        version=VERSION,
        description=DESCRIPTION,
        author=AUTHOR,
        url=URL,
        download_url=DOWNLOAD_URL,
        license=LICENSE,
        app=["src/gajim.py"],
        data_files=["data/nibs/Gajim.nib"],
        options={"py2app": OPTIONS},
        setup_requires=["py2app"],
    )
    return
Example #13
0
def run_setup():
    setup(
        name="workerprocess",
        version="0.1.2",
        description="A tool for creating external worker processes",
        keywords="",
        url="https://github.com/philipcristiano/worker_process",
        author="Philip Cristiano",
        author_email="worker_process@philipcristiano.com",
        license="BSD",
        packages=["workerprocess"],
        install_requires=[""],
        test_suite="tests",
        long_description=read("README.md"),
        zip_safe=True,
        classifiers=[
            "Development Status :: 2 - Pre-Alpha",
            "Intended Audience :: Developers",
            "License :: OSI Approved :: BSD License",
            "Operating System :: MacOS :: MacOS X",
            "Operating System :: POSIX",
            "Programming Language :: Python",
        ],
        entry_points="""
            [console_scripts]
        """,
    )
Example #14
0
def main():
    from imp import load_source
    from os import path
    from sys import argv

    if "--setuptools" in argv:
        argv.remove("--setuptools")
        from setuptools import setup, Extension
    else:
        from distutils.core import setup, Extension

    cptrace_ext = Extension("cptrace", sources=SOURCES)

    cptrace = load_source("version", path.join("cptrace", "version.py"))

    install_options = {
        "name": cptrace.PACKAGE,
        "version": cptrace.VERSION,
        "url": cptrace.WEBSITE,
        "download_url": cptrace.WEBSITE,
        "license": cptrace.LICENSE,
        "author": "Victor Stinner",
        "description": "python binding of ptrace written in C",
        "long_description": LONG_DESCRIPTION,
        "classifiers": CLASSIFIERS,
        "ext_modules": [cptrace_ext],
    }
    setup(**install_options)
Example #15
0
def build():
    """Build executable via py2app."""
    if platform.system() != "Darwin":
        print "Sorry, only works on Mac OS X!"
        sys.exit(1)

    # Clean up old build dir.
    clean()

    # Now build this.
    sys.argv[1] = "py2app"

    APP = ["upshot.py"]
    DATA_FILES = [("", glob.glob("resources/*")), ("", glob.glob("*.xib"))]
    OPTIONS = {
        "argv_emulation": False,
        "iconfile": "resources/UpShot.icns",
        "plist": {
            "LSUIElement": 1,
            "NSPrincipalClass": "UpShot",
            "NSHumanReadableCopyright": "Fred Wenzel",
            "CFBundleIdentifier": "com.fredericiana.upshot",
            "CFBundleVersion": RELEASE,
            "CFBundleShortVersionString": RELEASE,
        },
        "excludes": ["email"],
    }

    setup(name="UpShot", app=APP, data_files=DATA_FILES, options={"py2app": OPTIONS}, setup_requires=["py2app"])

    # Some cleanup.
    local("find dist/ -name .DS_Store -delete")
Example #16
0
def install():
    desc = googletrans.__doc__
    setup(
        name="py-googletrans",
        version="1.1.1",
        description=desc,
        long_description=desc,
        author="SuHun Han",
        author_email="ssut@ssut.me",
        url="https://github.com/ssut/py-googletrans",
        classifiers=[
            "Development Status :: 5 - Production/Stable",
            "Intended Audience :: Education",
            "Intended Audience :: End Users/Desktop",
            "License :: Freeware",
            "Operating System :: POSIX",
            "Operating System :: Microsoft :: Windows",
            "Operating System :: MacOS :: MacOS X",
            "Topic :: Education",
            "Programming Language :: Python",
            "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",
        ],
        packages=find_packages(),
        install_requires=["requests", "future"],
        scripts=["translate"],
    )
Example #17
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="https://github.com/translate/translate/releases/tag/" + version,
        platforms=["any"],
        classifiers=classifiers,
        packages=packages,
        data_files=datafiles,
        entry_points={"console_scripts": translatescripts},
        scripts=scripts,
        ext_modules=ext_modules,
        cmdclass=cmdclass,
        install_requires=parse_requirements("requirements/required.txt"),
        **kwargs
    )
Example #18
0
def run_setup(with_binary):
    features = {}
    if with_binary and speedups is not None:
        features["speedups"] = speedups

    setup(
        name="logs",
        version="0.2.1",
        license="MIT",
        url="https://github.com/simonz05/logs/",
        author="Simon Zimmermann",
        author_email="simon@insmo.com",
        description="Logs",
        long_description=__doc__,
        keywords="logs",
        platforms="any",
        packages=["logs"],
        scripts=["bin/log.py"],
        cmdclass=cmdclass,
        features=features,
        install_requires=["numpy"],
        classifiers=[
            "Development Status :: 2 - Pre-Alpha",
            "Intended Audience :: Developers",
            "License :: OSI Approved :: MIT License",
            "Operating System :: POSIX",
            "Programming Language :: Python",
            "Topic :: Software Development",
            "Topic :: Software Development :: Libraries",
        ],
    )
Example #19
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 #20
0
def main():
    version = get_git_version()

    with open("pyipmi/version.py", "w") as f:
        f.write("# This file was autogenerated by setup.py\n")
        f.write("__version__ = '%s'\n" % (version,))

    setup(
        name="pyipmi",
        version=version,
        description="Pure python IPMI library",
        author_email="michael.walle@kontron.com",
        packages=find_packages(exclude="test"),
        license="LGPLv2+",
        classifiers=[
            "Development Status :: 4 - Beta",
            "Environment :: Console",
            "License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)",
            "Natural Language :: English",
            "Operating System :: OS Independent",
            "Programming Language :: Python :: 2",
            "Programming Language :: Python :: 2.7",
            "Topic :: Software Development :: Libraries :: Python Modules",
        ],
        entry_points={"console_scripts": ["ipmitool.py = pyipmi.ipmitool:main"]},
        test_suite="tests",
    )
Example #21
0
def main():
    if sys.version_info[0] < 3:
        sys.exit("xonsh currently requires Python 3.4+")
    try:
        print(logo)
    except UnicodeEncodeError:
        pass
    with open(os.path.join(os.path.dirname(__file__), "README.rst"), "r") as f:
        readme = f.read()
    skw = dict(
        name="xonsh",
        description="an exotic, usable shell",
        long_description=readme,
        license="BSD",
        version=XONSH_VERSION,
        author="Anthony Scopatz",
        maintainer="Anthony Scopatz",
        author_email="scopatz@gmail.com",
        url="https://github.com/scopatz/xonsh",
        platforms="Cross Platform",
        classifiers=["Programming Language :: Python :: 3"],
        packages=["xonsh"],
        scripts=["scripts/xonsh"],
        cmdclass={"install": xinstall, "sdist": xsdist},
    )
    if HAVE_SETUPTOOLS:
        skw["setup_requires"] = ["ply"]
        skw["install_requires"] = ["ply"]
        skw["entry_points"] = {
            "pygments.lexers": ["xonsh = xonsh.pyghooks:XonshLexer", "xonshcon = xonsh.pyghooks:XonshConsoleLexer"]
        }
        skw["cmdclass"]["develop"] = xdevelop
    setup(**skw)
Example #22
0
def main(**kwargs):

    write_version_py(VERSION, ISRELEASED, "msmexplorer/version.py")

    setup(
        name=NAME,
        version=VERSION,
        description=("Visualizations for statistical models" "of biomolecular dynamics."),
        platforms=("Windows", "Linux", "Mac OS-X", "Unix"),
        classifiers=(
            "Intended Audience :: Science/Research",
            "License :: OSI Approved :: MIT License",
            "Programming Language :: Python",
            "Programming Language :: Python :: 3",
            "Programming Language :: Python :: 3.4",
            "Programming Language :: Python :: 3.5",
            "Operating System :: Unix",
            "Operating System :: MacOS",
            "Operating System :: Microsoft :: Windows",
            "Topic :: Scientific/Engineering",
        ),
        keywords=("visualizations", "biomolecular", "simulations", "markov state models"),
        author="Carlos Xavier Hernández",
        author_email="cxh@stanford.edu",
        url="https://github.com/cxhernandez/%s" % NAME,
        download_url="https://github.com/cxhernandez/%s/tarball/master" % NAME,
        license="LGPLv2+",
        packages=find_packages(),
        include_package_data=True,
        package_data={NAME: ["README.md", "requirements.txt"]},
        zip_safe=False,
        ext_modules=extensions,
        cmdclass={"build_ext": build_ext},
        **kwargs
    )
Example #23
0
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="fullstop audit violations",
        long_description=read("README.rst"),
        classifiers=CLASSIFIERS,
        test_suite="tests",
        packages=setuptools.find_packages(exclude=["tests", "tests.*"]),
        install_requires=install_reqs,
        setup_requires=["six", "flake8"],
        cmdclass=cmdclass,
        tests_require=["pytest-cov", "pytest"],
        command_options=command_options,
        entry_points={"console_scripts": CONSOLE_SCRIPTS},
    )
Example #24
0
def run_setup(ext_modules):
    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"],
        ext_modules=ext_modules,
        cmdclass=dict(build_ext=my_build_ext, sdist=sdist),
        install_requires=["greenlet"],
        classifiers=[
            "License :: OSI Approved :: MIT License",
            "Programming Language :: Python :: 2.5",
            "Programming Language :: Python :: 2.6",
            "Programming Language :: Python :: 2.7",
            "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 #25
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",
        ],
    )
Example #26
0
def do_setup():
    write_version_py()
    setup(
        name=NAME,
        version=VERSION,
        description=DESCRIPTION,
        long_description=LONG_DESCRIPTION,
        classifiers=CLASSIFIERS,
        author=AUTHOR,
        author_email=AUTHOR_EMAIL,
        url=URL,
        license=LICENSE,
        platforms=PLATFORMS,
        packages=find_packages(),
        install_requires=["numpy>=1.5.0", "scipy>=0.7.2"],
        package_data={
            "": ["*.txt", "*.rst", "*.cu", "*.cuh", "*.c", "*.sh", "*.pkl", "ChangeLog"],
            "theano.misc": ["*.sh"],
        },
        scripts=["bin/theano-cache", "bin/theano-nose", "bin/theano-test"],
        keywords=" ".join(
            ["theano", "math", "numerical", "symbolic", "blas", "numpy", "gpu", "autodiff", "differentiation"]
        ),
        cmdclass={"build_py": build_py, "build_scripts": build_scripts},
    )
Example #27
0
def run_setup(with_binary):
    features = {}
    if with_binary and speedups is not None:
        features["speedups"] = speedups
    setup(
        name="Logbook",
        version="0.11.4-dev",
        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,
        classifiers=[
            "Programming Language :: Python :: 2.6",
            "Programming Language :: Python :: 2.7",
            "Programming Language :: Python :: 3.3",
            "Programming Language :: Python :: 3.4",
            "Programming Language :: Python :: 3.5",
        ],
        features=features,
        install_requires=[],
        **extra
    )
Example #28
0
def main():
    """Main"""

    opts = dict(
        name="clamavmirror",
        version="0.0.3",
        description="ClamAV Signature Mirroring Tool",
        long_description=get_readme(),
        keywords="clamav mirror mirroring mirror-tool signatures",
        author="Andrew Colin Kissa",
        author_email="andrew@topdog.za.net",
        url="https://github.com/akissa/clamavmirror",
        license="MPL 2.0",
        packages=[],
        scripts=["bin/clamavmirror"],
        include_package_data=True,
        zip_safe=False,
        install_requires=["urllib3", "dnspython", "certifi"],
        classifiers=[
            "Development Status :: 4 - Beta",
            "Programming Language :: Python",
            "Programming Language :: Python :: 2.6",
            "Programming Language :: Python :: 2.7",
            "Topic :: Software Development :: Libraries :: Python Modules",
            "Intended Audience :: System Administrators",
            "Environment :: Console",
            "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
            "Natural Language :: English",
            "Operating System :: OS Independent",
        ],
    )
    setup(**opts)
Example #29
0
    def __init__(self):
        """Initialise and execute."""

        # The extension.
        extension = sys.argv[1]

        # Mac OS X application.
        if extension == "py2app":
            self.mac_setup()

        # Unsupported platform.
        else:
            raise RelaxError("The setuptools extension '%s' is not supported yet." % extension)

        # Generic setup args.
        self.args_generic()

        # Execute the setuptools setup() method to actually do something.
        setup(
            app=self.APP,
            name=self.NAME,
            version=self.VERSION,
            data_files=self.DATA_FILES,
            options=self.OPTIONS,
            setup_requires=self.REQUIRES,
        )
Example #30
0
def run_setup(with_binary):
    features = {}
    if with_binary and speedups is not None:
        features["speedups"] = speedups

    setup(
        name="activity-feed",
        version="2.6.4",
        license="MIT",
        url="https://github.com/simonz05/activity-feed/",
        author="Simon Zimmermann",
        author_email="simon@insmo.com",
        description="An Activity Feed for python",
        long_description=__doc__,
        keywords="redis",
        platforms="any",
        packages=["activity_feed"],
        install_requires=["redis", "leaderboard>=2.4.0,<=2.6.0"],
        cmdclass=cmdclass,
        features=features,
        test_suite="nose.collector",
        tests_require=["nose"],
        classifiers=[
            "Development Status :: 2 - Pre-Alpha",
            "Intended Audience :: Developers",
            "License :: OSI Approved :: MIT License",
            "Operating System :: POSIX",
            "Programming Language :: Python",
            "Topic :: Software Development",
            "Topic :: Software Development :: Libraries",
        ],
    )