"""Configure command adapted from h5py"""

description = "Discover ZMQ version and features"

# DON'T REMOVE: distutils demands these be here even if they do nothing.

user_options = []

boolean_options = []

def initialize_options(self):

pass

def finalize_options(self):

pass

tempdir = 'detect'

def create_tempdir(self):

self.erase_tempdir()

os.mkdir(self.tempdir)

if sys.platform.startswith('win'):

# fetch libzmq.dll into local dir

local_dll = pjoin(self.tempdir, 'libzmq.dll')

if ZMQ is None and not os.path.exists(local_dll):

fatal("ZMQ directory must be specified on Windows via setup.cfg or 'python setup.py configure --zmq=/path/to/zeromq2'")

try:

shutil.copy(pjoin(ZMQ, 'lib', 'libzmq.dll'), local_dll)

except Exception:

if not os.path.exists(local_dll):

warn("Could not copy libzmq into zmq/, which is usually necessary on Windows."

"Please specify zmq prefix via configure --zmq=/path/to/zmq or copy "

"libzmq into zmq/ manually.")

def erase_tempdir(self):

try:

shutil.rmtree(self.tempdir)

except Exception:

pass

def getcached(self):

return loadpickle('configure.pickle')

def check_zmq_version(self):

zmq = ZMQ

if zmq is not None and not os.path.isdir(zmq):

fatal("Custom zmq directory \"%s\" does not exist" % zmq)

config = self.getcached()

if config is None or config['options'] != COMPILER_SETTINGS:

self.run()

config = self.config

else:

self.config = config

vers = config['vers']

vs = v_str(vers)

if vers < min_zmq:

fatal("Detected ZMQ version: %s, but depend on zmq >= %s"%(

vs, v_str(min_zmq))

+'\n Using ZMQ=%s'%(zmq or 'unspecified'))

pyzmq_version = extract_version().strip('abcdefghijklmnopqrstuvwxyz')

if vs < pyzmq_version:

warn("Detected ZMQ version: %s, but pyzmq targets zmq %s."%(

vs, pyzmq_version))

warn("libzmq features and fixes introduced after %s will be unavailable."%vs)

print('*'*42)

elif vs >= '3.0':

warn("Detected ZMQ version: %s. pyzmq's support for libzmq-dev is experimental."%vs)

print('*'*42)

if sys.platform.startswith('win'):

# fetch libzmq.dll into local dir

local_dll = localpath('zmq','libzmq.dll')

if zmq is None and not os.path.exists(local_dll):

fatal("ZMQ directory must be specified on Windows via setup.cfg or 'python setup.py configure --zmq=/path/to/zeromq2'")

try:

shutil.copy(pjoin(zmq, 'lib', 'libzmq.dll'), local_dll)

except Exception:

if not os.path.exists(local_dll):

warn("Could not copy libzmq into zmq/, which is usually necessary on Windows."

"Please specify zmq prefix via configure --zmq=/path/to/zmq or copy "

"libzmq into zmq/ manually.")

def run(self):

self.create_tempdir()

settings = copy.copy(COMPILER_SETTINGS)

if doing_bdist and not sys.platform.startswith('win'):

# rpath slightly differently here, because libzmq not in .. but ../zmq:

settings['library_dirs'] = ['zmq']

if sys.platform == 'darwin':

pass

# unused rpath args for OSX:

# settings['extra_link_args'] = ['-Wl,-rpath','-Wl,$ORIGIN/../zmq']

else:

settings['runtime_library_dirs'] = ['$ORIGIN/../zmq']

try:

print ("*"*42)

print ("Configure: Autodetecting ZMQ settings...")

print (" Custom ZMQ dir: %s" % (ZMQ,))

config = detect_zmq(self.tempdir, **settings)

except Exception:

etype = sys.exc_info()[0]

if etype is CompileError:

action = 'compile'

elif etype is LinkError:

action = 'link'

else:

action = 'run'

fatal("""

Failed to %s ZMQ test program. Please check to make sure:

* You have a C compiler installed

* A development version of Python is installed (including header files)

* A development version of ZMQ >= %s is installed (including header files)

* If ZMQ is not in a default location, supply the argument --zmq=<path>

* If you did recently install ZMQ to a default location,

try rebuilding the ld cache with `sudo ldconfig`

or specify zmq's location with `--zmq=/usr/local`

"""%(action, v_str(min_zmq)))

else:

savepickle('configure.pickle', config)

print (" ZMQ version detected: %s" % v_str(config['vers']))

finally:

print ("*"*42)

self.erase_tempdir()

"""Custom distutils command to run the test suite."""

user_options = [ ]

def initialize_options(self):

self._dir = os.getcwd()

def finalize_options(self):

pass

def run_nose(self):

"""Run the test suite with nose."""

return nose.core.TestProgram(argv=["", '-vv', pjoin(self._dir, 'zmq', 'tests')])

def run_unittest(self):

"""Finds all the tests modules in zmq/tests/ and runs them."""

testfiles = [ ]

for t in glob(pjoin(self._dir, 'zmq', 'tests', '*.py')):

name = splitext(basename(t))[0]

if name.startswith('test_'):

testfiles.append('.'.join(

['zmq.tests', name])

)

tests = TestLoader().loadTestsFromNames(testfiles)

t = TextTestRunner(verbosity = 2)

t.run(tests)

def run(self):

"""Run the test suite, with nose, or unittest if nose is unavailable"""

# crude check for inplace build:

try:

import zmq

except ImportError:

print_exc()

fatal('\n '.join(["Could not import zmq!",

"You must build pyzmq with 'python setup.py build_ext --inplace' for 'python setup.py test' to work.",

"If you did build pyzmq in-place, then this is a real error."]))

sys.exit(1)

if nose is None:

print ("nose unavailable, falling back on unittest. Skipped tests will appear as ERRORs.")

return self.run_unittest()

else:

"""find the current git revision and add it to zmq.core.verion.__revision__"""

user_options = [ ]

def initialize_options(self):

self.version_pyx = pjoin('zmq','core','version.pyx')

def run(self):

try:

p = Popen('git log -1'.split(), stdin=PIPE, stdout=PIPE, stderr=PIPE)

except IOError:

print ("No git found, skipping git revision")

return

if p.wait():

print ("checking git branch failed")

print (p.stderr.read())

return

line = p.stdout.readline().decode().strip()

if not line.startswith('commit'):

print ("bad commit line: %r"%line)

return

rev = line.split()[-1]

# now that we have the git revision, we can apply it to version.pyx

with open(self.version_pyx) as f:

lines = f.readlines()

for i,line in enumerate(lines):

if line.startswith('__revision__'):

lines[i] = "__revision__ = '%s'\n"%rev

break

with open(self.version_pyx, 'w') as f:

f.writelines(lines)

def finalize_options(self):

"""Custom distutils command to clean the .so and .pyc files."""

user_options = [ ]

def initialize_options(self):

self._clean_me = []

self._clean_trees = []

for root, dirs, files in list(os.walk('zmq')):

for f in files:

if os.path.splitext(f)[-1] in ('.pyc', '.so', '.o', '.pyd'):

self._clean_me.append(pjoin(root, f))

for d in dirs:

if d == '__pycache__':

self._clean_trees.append(pjoin(root, d))

for d in ('build',):

if os.path.exists(d):

self._clean_trees.append(d)

bundled = glob(pjoin('zmq', 'libzmq*'))

self._clean_me.extend(bundled)

def finalize_options(self):

pass

def run(self):

for clean_me in self._clean_me:

try:

os.unlink(clean_me)

except Exception:

pass

for clean_tree in self._clean_trees:

try:

shutil.rmtree(clean_tree)

except Exception:

"""Custom sdist that ensures Cython has compiled all pyx files to c."""

def initialize_options(self):

sdist.initialize_options(self)

self._pyxfiles = []

for root, dirs, files in os.walk('zmq'):

for f in files:

if f.endswith('.pyx'):

self._pyxfiles.append(pjoin(root, f))

def run(self):

if 'cython' in cmdclass:

self.run_command('cython')

else:

for pyxfile in self._pyxfiles:

cfile = pyxfile[:-3]+'c'

msg = "C-source file '%s' not found."%(cfile)+\

" Run 'setup.py cython' before sdist."

assert os.path.isfile(cfile), msg

"""subclass of build that copies libzmq if doing bdist."""

def run(self):

if doing_bdist and not sys.platform.startswith('win'):

# always rebuild before bdist, because linking may be wrong:

self.run_command('clean')

copy_and_patch_libzmq(ZMQ, 'libzmq'+lib_ext)

"""Subclass build_ext to get clearer report if Cython is neccessary."""

def check_cython_extensions(self, extensions):

for ext in extensions:

for src in ext.sources:

if not os.path.exists(src):

fatal("""Cython-generated file '%s' not found.

Cython is required to compile pyzmq from a development branch.

Please install Cython or download a release package of pyzmq.

"""%src)

def build_extensions(self):

self.check_cython_extensions(self.extensions)

self.check_extensions_list(self.extensions)

for ext in self.extensions:

self.build_extension(ext)

def run(self):

# check version, to prevent confusing undefined constant errors

configure = self.distribution.get_command_obj('configure')

configure.check_zmq_version()

core = {'constants': [libzmq],

'error':[libzmq],

'poll':[libzmq, socket],

'stopwatch':[libzmq, pxd('core','stopwatch')],

'context':[context, libzmq],

'message':[libzmq, buffers, message],

'socket':[context, message, socket, libzmq, buffers],

'device':[libzmq, socket, context],

'version':[libzmq],

},

devices = {

'monitoredqueue':[buffers, libzmq, monqueue, socket, context],

},

utils = {

'initthreads':[libzmq],

'rebuffer':[buffers],

}

"""Custom distutils command subclassed from Cython.Distutils.build_ext

to compile pyx->c, and stop there. All this does is override the

C-compile method build_extension() with a no-op."""

def build_extension(self, ext):

def run(self):

configure = self.distribution.get_command_obj('configure')

configure.check_zmq_version()

'zmq.core':['*.pxd'],

'zmq.devices':['*.pxd'],

'zmq.utils':['*.pxd', '*.h'],

"""extract pyzmq version from core/version.pyx, so it's not multiply defined"""

with open(pjoin('zmq', 'core', 'version.pyx')) as f:

line = f.readline()

while not line.startswith("__version__"):

line = f.readline()

exec(line, globals())

if 'bdist_msi' in sys.argv:

# msi has strict version requirements, which requires that

# we strip any dev suffix

return re.match(r'\d+(\.\d+)+', __version__).group()

else:

"""

PyZMQ is a lightweight and super-fast messaging library built on top of

the ZeroMQ library (http://www.zeromq.org).