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:

from cassandra import __version__

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)

try:

# List only subdirectories in the given directory

subdirectories = [name for dir in directory_path for name in os.listdir(dir)

if os.path.isdir(os.path.join(directory_path, name))]

return subdirectories

except Exception:

libev_hb_paths = ["/opt/homebrew/Cellar/libev", os.path.expanduser('~/homebrew/Cellar/libev')]

for hb_path in libev_hb_paths:

if not os.path.exists(hb_path):

continue

versions = [dir for dir in get_subdriname(hb_path) if dir[0] in "0123456789"]

if not versions:

continue

picked_version = sorted(versions, reverse=True)[0]

resulted_path = os.path.join(hb_path, picked_version, 'include')

warnings.warn("found libev headers in '%s'" % resulted_path)

return [resulted_path]

warnings.warn("did not find libev headers in '%s'" % libev_hb_paths)

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

include_dirs=libev_includes,

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:

_needs_stub = False

error_message = """

""" if is_windows else """

def run(self):

try:

self._setup_extensions()

build_ext.run(self)

except PlatformError as exc:

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

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

if CASS_DRIVER_BUILD_EXTENSIONS_ARE_MUST:

raise

def build_extensions(self):

if build_concurrency is None or 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, fix_extension_class(ext))

except (CCompilerError, ExecError,

PlatformError, IOError) as exc:

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

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

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

if CASS_DRIVER_BUILD_EXTENSIONS_ARE_MUST:

raise

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:

sys.stderr.write("Appending libev extension %s" % libev_ext)

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', 'shard_info']

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,

compiler_directives={'language_level': 3},

exclude_failures=not CASS_DRIVER_BUILD_EXTENSIONS_ARE_MUST,

))

self.extensions.extend(cythonize(

NoPatchExtension("*", ["cassandra/*.pyx"], extra_compile_args=compile_args),

nthreads=build_concurrency,

compiler_directives={'language_level': 3},

))

except Exception:

sys.stderr.write("Failed to cythonize one or more modules. These will not be compiled as extensions (optional).\n")

if CASS_DRIVER_BUILD_EXTENSIONS_ARE_MUST:

"""

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

return True

try:

from setuptools._distutils.ccompiler import new_compiler

from setuptools._distutils.sysconfig import customize_compiler

from setuptools.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)

try:

# We must be able to initialize the compiler if it has that method

if hasattr(compiler, "initialize"):

compiler.initialize()

except:

return False

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:

for exe in executables:

if not shutil.which(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}}

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>=3.0.11,<4'

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")