description = "generate or test documentation"

user_options = [("test", "t",

"run doctests instead of generating documentation")]

boolean_options = ["test"]

def initialize_options(self):

self.test = False

def finalize_options(self):

pass

def run(self):

if self.test:

path = "docs/_build/doctest"

mode = "doctest"

else:

path = "docs/_build/%s" % __version__

mode = "html"

try:

os.makedirs(path)

except:

pass

if has_subprocess:

# Prevent run with in-place extensions because cython-generated objects do not carry docstrings

# http://docs.cython.org/src/userguide/special_methods.html#docstrings

import glob

for f in glob.glob("cassandra/*.so"):

print("Removing '%s' to allow docs to run on pure python modules." %(f,))

os.unlink(f)

# Build io extension to make import and docstrings work

try:

output = subprocess.check_output(

["python", "setup.py", "build_ext", "--inplace", "--force", "--no-murmur3", "--no-cython"],

stderr=subprocess.STDOUT)

except subprocess.CalledProcessError as exc:

raise RuntimeError("Documentation step '%s' failed: %s: %s" % ("build_ext", exc, exc.output))

else:

print(output)

try:

output = subprocess.check_output(

["sphinx-build", "-b", mode, "docs", path],

stderr=subprocess.STDOUT)

except subprocess.CalledProcessError as exc:

raise RuntimeError("Documentation step '%s' failed: %s: %s" % (mode, exc, exc.output))

else:

print(output)

print("")

print("Documentation step '%s' performed, results here:" % mode)

sources=['cassandra/io/libevwrapper.c'],

include_dirs=['/usr/include/libev', '/usr/local/include', '/opt/local/include'],

libraries=['ev'],

# Older versions of setuptools.extension has a static flag which is set False before our

# setup_requires lands Cython. It causes our *.pyx sources to be renamed to *.c in

# the initializer.

# The other workaround would be to manually generate sources, but that bypasses a lot

# of the niceness cythonize embodies (setup build dir, conditional build, etc).

# Newer setuptools does not have this problem because it checks for cython dynamically.

# https://bitbucket.org/pypa/setuptools/commits/714c3144e08fd01a9f61d1c88411e76d2538b2e4

def __init__(self, *args, **kwargs):

# bypass the patched init if possible

if Extension.__bases__:

base, = Extension.__bases__

base.__init__(self, *args, **kwargs)

else:

error_message = """

""" if is_windows else """

def run(self):

try:

self._setup_extensions()

build_ext.run(self)

except DistutilsPlatformError as exc:

sys.stderr.write('%s\n' % str(exc))

warnings.warn(self.error_message % "C extensions.")

def build_extensions(self):

if build_concurrency > 1:

self.check_extensions_list(self.extensions)

import multiprocessing.pool

multiprocessing.pool.ThreadPool(processes=build_concurrency).map(self.build_extension, self.extensions)

else:

build_ext.build_extensions(self)

def build_extension(self, ext):

try:

build_ext.build_extension(self, ext)

except (CCompilerError, DistutilsExecError,

DistutilsPlatformError, IOError) as exc:

sys.stderr.write('%s\n' % str(exc))

name = "The %s extension" % (ext.name,)

warnings.warn(self.error_message % (name,))

def _setup_extensions(self):

# We defer extension setup until this command to leveraage 'setup_requires' pulling in Cython before we

# attempt to import anything

self.extensions = []

if try_murmur3:

self.extensions.append(murmur3_ext)

if try_libev:

self.extensions.append(libev_ext)

if try_cython:

try:

from Cython.Build import cythonize

cython_candidates = ['cluster', 'concurrent', 'connection', 'cqltypes', 'metadata',

'pool', 'protocol', 'query', 'util']

compile_args = [] if is_windows else ['-Wno-unused-function']

self.extensions.extend(cythonize(

[Extension('cassandra.%s' % m, ['cassandra/%s.py' % m],

extra_compile_args=compile_args)

for m in cython_candidates],

nthreads=build_concurrency,

exclude_failures=True))

self.extensions.extend(cythonize(NoPatchExtension("*", ["cassandra/*.pyx"], extra_compile_args=compile_args),

nthreads=build_concurrency))

except Exception:

"""

if os.environ.get('CASS_DRIVER_NO_PRE_BUILD_CHECK'):

return True

try:

from distutils.ccompiler import new_compiler

from distutils.sysconfig import customize_compiler

from distutils.dist import Distribution

# base build_ext just to emulate compiler option setup

be = build_ext(Distribution())

be.initialize_options()

be.finalize_options()

# First, make sure we have a Python include directory

have_python_include = any(os.path.isfile(os.path.join(p, 'Python.h')) for p in be.include_dirs)

if not have_python_include:

sys.stderr.write("Did not find 'Python.h' in %s.\n" % (be.include_dirs,))

return False

compiler = new_compiler(compiler=be.compiler)

customize_compiler(compiler)

executables = []

if compiler.compiler_type in ('unix', 'cygwin'):

executables = [compiler.executables[exe][0] for exe in ('compiler_so', 'linker_so')]

elif compiler.compiler_type == 'nt':

executables = [getattr(compiler, exe) for exe in ('cc', 'linker')]

if executables:

from distutils.spawn import find_executable

for exe in executables:

if not find_executable(exe):

sys.stderr.write("Failed to find %s for compiler type %s.\n" % (exe, compiler.compiler_type))

return False

except Exception as exc:

sys.stderr.write('%s\n' % str(exc))

sys.stderr.write("Failed pre-build check. Attempting anyway.\n")

# if we are unable to positively id the compiler type, or one of these assumptions fails,

# just proceed as we would have without the check

kw = {'cmdclass': {'doc': DocCommand}}

if gevent_nosetests is not None:

kw['cmdclass']['gevent_nosetests'] = gevent_nosetests

if eventlet_nosetests is not None:

kw['cmdclass']['eventlet_nosetests'] = eventlet_nosetests

kw['cmdclass']['build_ext'] = build_extensions

kw['ext_modules'] = [Extension('DUMMY', [])] # dummy extension makes sure build_ext is called for install

if try_cython:

# precheck compiler before adding to setup_requires

# we don't actually negate try_cython because:

# 1.) build_ext eats errors at compile time, letting the install complete while producing useful feedback

# 2.) there could be a case where the python environment has cython installed but the system doesn't have build tools

if pre_build_check():

cython_dep = 'Cython>=0.20,<0.25'

user_specified_cython_version = os.environ.get('CASS_DRIVER_ALLOWED_CYTHON_VERSION')

if user_specified_cython_version is not None:

cython_dep = 'Cython==%s' % (user_specified_cython_version,)

kw['setup_requires'] = [cython_dep]

else:

sys.stderr.write("Bypassing Cython setup requirement\n")

dependencies = ['six >=1.9']

if not PY3:

dependencies.append('futures')

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', 'cassandra.cqlengine'],

keywords='cassandra,cql,orm',

include_package_data=True,

install_requires=dependencies,

tests_require=['nose', 'mock<=1.0.1', 'PyYAML', 'pytz', 'sure'],

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.7',

'Programming Language :: Python :: 3.3',

'Programming Language :: Python :: 3.4',

'Programming Language :: Python :: Implementation :: CPython',

'Programming Language :: Python :: Implementation :: PyPy',

'Topic :: Software Development :: Libraries :: Python Modules'

],