summaryrefslogtreecommitdiffstats
path: root/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar
diff options
context:
space:
mode:
authorYaroslav Brustinov <ybrustin@cisco.com>2017-02-01 21:13:23 +0200
committerYaroslav Brustinov <ybrustin@cisco.com>2017-02-02 14:26:12 +0200
commit781d71db20b0c5acbe940eff1b1ef2f1b765ce54 (patch)
tree444ef9944a789eaf7d51729d8e84f0b1ab70bda4 /scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar
parent7b39a77194c736194b40a40fdd19928b98310959 (diff)
zmq os independent
Change-Id: Iaf5a782be4db26a979a7535454719e8e62b5969a Signed-off-by: Yaroslav Brustinov <ybrustin@cisco.com>
Diffstat (limited to 'scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar')
-rw-r--r--scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/__init__.py27
-rw-r--r--scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/attrsettr.py52
-rw-r--r--scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/constants.py98
-rw-r--r--scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/context.py190
-rw-r--r--scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/frame.py19
-rw-r--r--scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/poll.py161
-rw-r--r--scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/socket.py495
-rw-r--r--scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/tracker.py120
-rw-r--r--scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/version.py48
9 files changed, 0 insertions, 1210 deletions
diff --git a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/__init__.py b/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/__init__.py
deleted file mode 100644
index d0510a44..00000000
--- a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/__init__.py
+++ /dev/null
@@ -1,27 +0,0 @@
-"""pure-Python sugar wrappers for core 0MQ objects."""
-
-# Copyright (C) PyZMQ Developers
-# Distributed under the terms of the Modified BSD License.
-
-
-from zmq.sugar import (
- constants, context, frame, poll, socket, tracker, version
-)
-from zmq import error
-
-__all__ = ['constants']
-for submod in (
- constants, context, error, frame, poll, socket, tracker, version
-):
- __all__.extend(submod.__all__)
-
-from zmq.error import *
-from zmq.sugar.context import *
-from zmq.sugar.tracker import *
-from zmq.sugar.socket import *
-from zmq.sugar.constants import *
-from zmq.sugar.frame import *
-from zmq.sugar.poll import *
-# from zmq.sugar.stopwatch import *
-# from zmq.sugar._device import *
-from zmq.sugar.version import *
diff --git a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/attrsettr.py b/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/attrsettr.py
deleted file mode 100644
index 4bbd36d6..00000000
--- a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/attrsettr.py
+++ /dev/null
@@ -1,52 +0,0 @@
-# coding: utf-8
-"""Mixin for mapping set/getattr to self.set/get"""
-
-# Copyright (C) PyZMQ Developers
-# Distributed under the terms of the Modified BSD License.
-
-
-from . import constants
-
-class AttributeSetter(object):
-
- def __setattr__(self, key, value):
- """set zmq options by attribute"""
-
- # regular setattr only allowed for class-defined attributes
- for obj in [self] + self.__class__.mro():
- if key in obj.__dict__:
- object.__setattr__(self, key, value)
- return
-
- upper_key = key.upper()
- try:
- opt = getattr(constants, upper_key)
- except AttributeError:
- raise AttributeError("%s has no such option: %s" % (
- self.__class__.__name__, upper_key)
- )
- else:
- self._set_attr_opt(upper_key, opt, value)
-
- def _set_attr_opt(self, name, opt, value):
- """override if setattr should do something other than call self.set"""
- self.set(opt, value)
-
- def __getattr__(self, key):
- """get zmq options by attribute"""
- upper_key = key.upper()
- try:
- opt = getattr(constants, upper_key)
- except AttributeError:
- raise AttributeError("%s has no such option: %s" % (
- self.__class__.__name__, upper_key)
- )
- else:
- return self._get_attr_opt(upper_key, opt)
-
- def _get_attr_opt(self, name, opt):
- """override if getattr should do something other than call self.get"""
- return self.get(opt)
-
-
-__all__ = ['AttributeSetter']
diff --git a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/constants.py b/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/constants.py
deleted file mode 100644
index 88281176..00000000
--- a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/constants.py
+++ /dev/null
@@ -1,98 +0,0 @@
-"""0MQ Constants."""
-
-# Copyright (c) PyZMQ Developers.
-# Distributed under the terms of the Modified BSD License.
-
-from zmq.backend import constants
-from zmq.utils.constant_names import (
- base_names,
- switched_sockopt_names,
- int_sockopt_names,
- int64_sockopt_names,
- bytes_sockopt_names,
- fd_sockopt_names,
- ctx_opt_names,
- msg_opt_names,
-)
-
-#-----------------------------------------------------------------------------
-# Python module level constants
-#-----------------------------------------------------------------------------
-
-__all__ = [
- 'int_sockopts',
- 'int64_sockopts',
- 'bytes_sockopts',
- 'ctx_opts',
- 'ctx_opt_names',
- ]
-
-int_sockopts = set()
-int64_sockopts = set()
-bytes_sockopts = set()
-fd_sockopts = set()
-ctx_opts = set()
-msg_opts = set()
-
-
-if constants.VERSION < 30000:
- int64_sockopt_names.extend(switched_sockopt_names)
-else:
- int_sockopt_names.extend(switched_sockopt_names)
-
-_UNDEFINED = -9999
-
-def _add_constant(name, container=None):
- """add a constant to be defined
-
- optionally add it to one of the sets for use in get/setopt checkers
- """
- c = getattr(constants, name, _UNDEFINED)
- if c == _UNDEFINED:
- return
- globals()[name] = c
- __all__.append(name)
- if container is not None:
- container.add(c)
- return c
-
-for name in base_names:
- _add_constant(name)
-
-for name in int_sockopt_names:
- _add_constant(name, int_sockopts)
-
-for name in int64_sockopt_names:
- _add_constant(name, int64_sockopts)
-
-for name in bytes_sockopt_names:
- _add_constant(name, bytes_sockopts)
-
-for name in fd_sockopt_names:
- _add_constant(name, fd_sockopts)
-
-for name in ctx_opt_names:
- _add_constant(name, ctx_opts)
-
-for name in msg_opt_names:
- _add_constant(name, msg_opts)
-
-# ensure some aliases are always defined
-aliases = [
- ('DONTWAIT', 'NOBLOCK'),
- ('XREQ', 'DEALER'),
- ('XREP', 'ROUTER'),
-]
-for group in aliases:
- undefined = set()
- found = None
- for name in group:
- value = getattr(constants, name, -1)
- if value != -1:
- found = value
- else:
- undefined.add(name)
- if found is not None:
- for name in undefined:
- globals()[name] = found
- __all__.append(name)
diff --git a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/context.py b/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/context.py
deleted file mode 100644
index 692e0256..00000000
--- a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/context.py
+++ /dev/null
@@ -1,190 +0,0 @@
-# coding: utf-8
-"""Python bindings for 0MQ."""
-
-# Copyright (C) PyZMQ Developers
-# Distributed under the terms of the Modified BSD License.
-
-import atexit
-
-from zmq.backend import Context as ContextBase
-from . import constants
-from .attrsettr import AttributeSetter
-from .constants import ENOTSUP, ctx_opt_names
-from .socket import Socket
-from zmq.error import ZMQError
-
-# notice when exiting, to avoid triggering term on exit
-_exiting = False
-def _notice_atexit():
- global _exiting
- _exiting = True
-atexit.register(_notice_atexit)
-
-
-from zmq.utils.interop import cast_int_addr
-
-
-class Context(ContextBase, AttributeSetter):
- """Create a zmq Context
-
- A zmq Context creates sockets via its ``ctx.socket`` method.
- """
- sockopts = None
- _instance = None
- _shadow = False
-
- def __init__(self, io_threads=1, **kwargs):
- super(Context, self).__init__(io_threads=io_threads, **kwargs)
- if kwargs.get('shadow', False):
- self._shadow = True
- else:
- self._shadow = False
- self.sockopts = {}
-
-
- def __del__(self):
- """deleting a Context should terminate it, without trying non-threadsafe destroy"""
- if not self._shadow and not _exiting:
- self.term()
-
- def __enter__(self):
- return self
-
- def __exit__(self, *args, **kwargs):
- self.term()
-
- @classmethod
- def shadow(cls, address):
- """Shadow an existing libzmq context
-
- address is the integer address of the libzmq context
- or an FFI pointer to it.
-
- .. versionadded:: 14.1
- """
- address = cast_int_addr(address)
- return cls(shadow=address)
-
- @classmethod
- def shadow_pyczmq(cls, ctx):
- """Shadow an existing pyczmq context
-
- ctx is the FFI `zctx_t *` pointer
-
- .. versionadded:: 14.1
- """
- from pyczmq import zctx
-
- underlying = zctx.underlying(ctx)
- address = cast_int_addr(underlying)
- return cls(shadow=address)
-
- # static method copied from tornado IOLoop.instance
- @classmethod
- def instance(cls, io_threads=1):
- """Returns a global Context instance.
-
- Most single-threaded applications have a single, global Context.
- Use this method instead of passing around Context instances
- throughout your code.
-
- A common pattern for classes that depend on Contexts is to use
- a default argument to enable programs with multiple Contexts
- but not require the argument for simpler applications:
-
- class MyClass(object):
- def __init__(self, context=None):
- self.context = context or Context.instance()
- """
- if cls._instance is None or cls._instance.closed:
- cls._instance = cls(io_threads=io_threads)
- return cls._instance
-
- #-------------------------------------------------------------------------
- # Hooks for ctxopt completion
- #-------------------------------------------------------------------------
-
- def __dir__(self):
- keys = dir(self.__class__)
-
- for collection in (
- ctx_opt_names,
- ):
- keys.extend(collection)
- return keys
-
- #-------------------------------------------------------------------------
- # Creating Sockets
- #-------------------------------------------------------------------------
-
- @property
- def _socket_class(self):
- return Socket
-
- def socket(self, socket_type):
- """Create a Socket associated with this Context.
-
- Parameters
- ----------
- socket_type : int
- The socket type, which can be any of the 0MQ socket types:
- REQ, REP, PUB, SUB, PAIR, DEALER, ROUTER, PULL, PUSH, etc.
- """
- if self.closed:
- raise ZMQError(ENOTSUP)
- s = self._socket_class(self, socket_type)
- for opt, value in self.sockopts.items():
- try:
- s.setsockopt(opt, value)
- except ZMQError:
- # ignore ZMQErrors, which are likely for socket options
- # that do not apply to a particular socket type, e.g.
- # SUBSCRIBE for non-SUB sockets.
- pass
- return s
-
- def setsockopt(self, opt, value):
- """set default socket options for new sockets created by this Context
-
- .. versionadded:: 13.0
- """
- self.sockopts[opt] = value
-
- def getsockopt(self, opt):
- """get default socket options for new sockets created by this Context
-
- .. versionadded:: 13.0
- """
- return self.sockopts[opt]
-
- def _set_attr_opt(self, name, opt, value):
- """set default sockopts as attributes"""
- if name in constants.ctx_opt_names:
- return self.set(opt, value)
- else:
- self.sockopts[opt] = value
-
- def _get_attr_opt(self, name, opt):
- """get default sockopts as attributes"""
- if name in constants.ctx_opt_names:
- return self.get(opt)
- else:
- if opt not in self.sockopts:
- raise AttributeError(name)
- else:
- return self.sockopts[opt]
-
- def __delattr__(self, key):
- """delete default sockopts as attributes"""
- key = key.upper()
- try:
- opt = getattr(constants, key)
- except AttributeError:
- raise AttributeError("no such socket option: %s" % key)
- else:
- if opt not in self.sockopts:
- raise AttributeError(key)
- else:
- del self.sockopts[opt]
-
-__all__ = ['Context']
diff --git a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/frame.py b/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/frame.py
deleted file mode 100644
index 9f556c86..00000000
--- a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/frame.py
+++ /dev/null
@@ -1,19 +0,0 @@
-# coding: utf-8
-"""0MQ Frame pure Python methods."""
-
-# Copyright (C) PyZMQ Developers
-# Distributed under the terms of the Modified BSD License.
-
-
-from .attrsettr import AttributeSetter
-from zmq.backend import Frame as FrameBase
-
-
-class Frame(FrameBase, AttributeSetter):
- def __getitem__(self, key):
- # map Frame['User-Id'] to Frame.get('User-Id')
- return self.get(key)
-
-# keep deprecated alias
-Message = Frame
-__all__ = ['Frame', 'Message'] \ No newline at end of file
diff --git a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/poll.py b/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/poll.py
deleted file mode 100644
index c7b1d1bb..00000000
--- a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/poll.py
+++ /dev/null
@@ -1,161 +0,0 @@
-"""0MQ polling related functions and classes."""
-
-# Copyright (C) PyZMQ Developers
-# Distributed under the terms of the Modified BSD License.
-
-
-import zmq
-from zmq.backend import zmq_poll
-from .constants import POLLIN, POLLOUT, POLLERR
-
-#-----------------------------------------------------------------------------
-# Polling related methods
-#-----------------------------------------------------------------------------
-
-
-class Poller(object):
- """A stateful poll interface that mirrors Python's built-in poll."""
- sockets = None
- _map = {}
-
- def __init__(self):
- self.sockets = []
- self._map = {}
-
- def __contains__(self, socket):
- return socket in self._map
-
- def register(self, socket, flags=POLLIN|POLLOUT):
- """p.register(socket, flags=POLLIN|POLLOUT)
-
- Register a 0MQ socket or native fd for I/O monitoring.
-
- register(s,0) is equivalent to unregister(s).
-
- Parameters
- ----------
- socket : zmq.Socket or native socket
- A zmq.Socket or any Python object having a ``fileno()``
- method that returns a valid file descriptor.
- flags : int
- The events to watch for. Can be POLLIN, POLLOUT or POLLIN|POLLOUT.
- If `flags=0`, socket will be unregistered.
- """
- if flags:
- if socket in self._map:
- idx = self._map[socket]
- self.sockets[idx] = (socket, flags)
- else:
- idx = len(self.sockets)
- self.sockets.append((socket, flags))
- self._map[socket] = idx
- elif socket in self._map:
- # uregister sockets registered with no events
- self.unregister(socket)
- else:
- # ignore new sockets with no events
- pass
-
- def modify(self, socket, flags=POLLIN|POLLOUT):
- """Modify the flags for an already registered 0MQ socket or native fd."""
- self.register(socket, flags)
-
- def unregister(self, socket):
- """Remove a 0MQ socket or native fd for I/O monitoring.
-
- Parameters
- ----------
- socket : Socket
- The socket instance to stop polling.
- """
- idx = self._map.pop(socket)
- self.sockets.pop(idx)
- # shift indices after deletion
- for socket, flags in self.sockets[idx:]:
- self._map[socket] -= 1
-
- def poll(self, timeout=None):
- """Poll the registered 0MQ or native fds for I/O.
-
- Parameters
- ----------
- timeout : float, int
- The timeout in milliseconds. If None, no `timeout` (infinite). This
- is in milliseconds to be compatible with ``select.poll()``. The
- underlying zmq_poll uses microseconds and we convert to that in
- this function.
-
- Returns
- -------
- events : list of tuples
- The list of events that are ready to be processed.
- This is a list of tuples of the form ``(socket, event)``, where the 0MQ Socket
- or integer fd is the first element, and the poll event mask (POLLIN, POLLOUT) is the second.
- It is common to call ``events = dict(poller.poll())``,
- which turns the list of tuples into a mapping of ``socket : event``.
- """
- if timeout is None or timeout < 0:
- timeout = -1
- elif isinstance(timeout, float):
- timeout = int(timeout)
- return zmq_poll(self.sockets, timeout=timeout)
-
-
-def select(rlist, wlist, xlist, timeout=None):
- """select(rlist, wlist, xlist, timeout=None) -> (rlist, wlist, xlist)
-
- Return the result of poll as a lists of sockets ready for r/w/exception.
-
- This has the same interface as Python's built-in ``select.select()`` function.
-
- Parameters
- ----------
- timeout : float, int, optional
- The timeout in seconds. If None, no timeout (infinite). This is in seconds to be
- compatible with ``select.select()``. The underlying zmq_poll uses microseconds
- and we convert to that in this function.
- rlist : list of sockets/FDs
- sockets/FDs to be polled for read events
- wlist : list of sockets/FDs
- sockets/FDs to be polled for write events
- xlist : list of sockets/FDs
- sockets/FDs to be polled for error events
-
- Returns
- -------
- (rlist, wlist, xlist) : tuple of lists of sockets (length 3)
- Lists correspond to sockets available for read/write/error events respectively.
- """
- if timeout is None:
- timeout = -1
- # Convert from sec -> us for zmq_poll.
- # zmq_poll accepts 3.x style timeout in ms
- timeout = int(timeout*1000.0)
- if timeout < 0:
- timeout = -1
- sockets = []
- for s in set(rlist + wlist + xlist):
- flags = 0
- if s in rlist:
- flags |= POLLIN
- if s in wlist:
- flags |= POLLOUT
- if s in xlist:
- flags |= POLLERR
- sockets.append((s, flags))
- return_sockets = zmq_poll(sockets, timeout)
- rlist, wlist, xlist = [], [], []
- for s, flags in return_sockets:
- if flags & POLLIN:
- rlist.append(s)
- if flags & POLLOUT:
- wlist.append(s)
- if flags & POLLERR:
- xlist.append(s)
- return rlist, wlist, xlist
-
-#-----------------------------------------------------------------------------
-# Symbols to export
-#-----------------------------------------------------------------------------
-
-__all__ = [ 'Poller', 'select' ]
diff --git a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/socket.py b/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/socket.py
deleted file mode 100644
index c91589d7..00000000
--- a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/socket.py
+++ /dev/null
@@ -1,495 +0,0 @@
-# coding: utf-8
-"""0MQ Socket pure Python methods."""
-
-# Copyright (C) PyZMQ Developers
-# Distributed under the terms of the Modified BSD License.
-
-
-import codecs
-import random
-import warnings
-
-import zmq
-from zmq.backend import Socket as SocketBase
-from .poll import Poller
-from . import constants
-from .attrsettr import AttributeSetter
-from zmq.error import ZMQError, ZMQBindError
-from zmq.utils import jsonapi
-from zmq.utils.strtypes import bytes,unicode,basestring
-from zmq.utils.interop import cast_int_addr
-
-from .constants import (
- SNDMORE, ENOTSUP, POLLIN,
- int64_sockopt_names,
- int_sockopt_names,
- bytes_sockopt_names,
- fd_sockopt_names,
-)
-try:
- import cPickle
- pickle = cPickle
-except:
- cPickle = None
- import pickle
-
-try:
- DEFAULT_PROTOCOL = pickle.DEFAULT_PROTOCOL
-except AttributeError:
- DEFAULT_PROTOCOL = pickle.HIGHEST_PROTOCOL
-
-
-class Socket(SocketBase, AttributeSetter):
- """The ZMQ socket object
-
- To create a Socket, first create a Context::
-
- ctx = zmq.Context.instance()
-
- then call ``ctx.socket(socket_type)``::
-
- s = ctx.socket(zmq.ROUTER)
-
- """
- _shadow = False
-
- def __del__(self):
- if not self._shadow:
- self.close()
-
- # socket as context manager:
- def __enter__(self):
- """Sockets are context managers
-
- .. versionadded:: 14.4
- """
- return self
-
- def __exit__(self, *args, **kwargs):
- self.close()
-
- #-------------------------------------------------------------------------
- # Socket creation
- #-------------------------------------------------------------------------
-
- @classmethod
- def shadow(cls, address):
- """Shadow an existing libzmq socket
-
- address is the integer address of the libzmq socket
- or an FFI pointer to it.
-
- .. versionadded:: 14.1
- """
- address = cast_int_addr(address)
- return cls(shadow=address)
-
- #-------------------------------------------------------------------------
- # Deprecated aliases
- #-------------------------------------------------------------------------
-
- @property
- def socket_type(self):
- warnings.warn("Socket.socket_type is deprecated, use Socket.type",
- DeprecationWarning
- )
- return self.type
-
- #-------------------------------------------------------------------------
- # Hooks for sockopt completion
- #-------------------------------------------------------------------------
-
- def __dir__(self):
- keys = dir(self.__class__)
- for collection in (
- bytes_sockopt_names,
- int_sockopt_names,
- int64_sockopt_names,
- fd_sockopt_names,
- ):
- keys.extend(collection)
- return keys
-
- #-------------------------------------------------------------------------
- # Getting/Setting options
- #-------------------------------------------------------------------------
- setsockopt = SocketBase.set
- getsockopt = SocketBase.get
-
- def set_string(self, option, optval, encoding='utf-8'):
- """set socket options with a unicode object
-
- This is simply a wrapper for setsockopt to protect from encoding ambiguity.
-
- See the 0MQ documentation for details on specific options.
-
- Parameters
- ----------
- option : int
- The name of the option to set. Can be any of: SUBSCRIBE,
- UNSUBSCRIBE, IDENTITY
- optval : unicode string (unicode on py2, str on py3)
- The value of the option to set.
- encoding : str
- The encoding to be used, default is utf8
- """
- if not isinstance(optval, unicode):
- raise TypeError("unicode strings only")
- return self.set(option, optval.encode(encoding))
-
- setsockopt_unicode = setsockopt_string = set_string
-
- def get_string(self, option, encoding='utf-8'):
- """get the value of a socket option
-
- See the 0MQ documentation for details on specific options.
-
- Parameters
- ----------
- option : int
- The option to retrieve.
-
- Returns
- -------
- optval : unicode string (unicode on py2, str on py3)
- The value of the option as a unicode string.
- """
-
- if option not in constants.bytes_sockopts:
- raise TypeError("option %i will not return a string to be decoded"%option)
- return self.getsockopt(option).decode(encoding)
-
- getsockopt_unicode = getsockopt_string = get_string
-
- def bind_to_random_port(self, addr, min_port=49152, max_port=65536, max_tries=100):
- """bind this socket to a random port in a range
-
- Parameters
- ----------
- addr : str
- The address string without the port to pass to ``Socket.bind()``.
- min_port : int, optional
- The minimum port in the range of ports to try (inclusive).
- max_port : int, optional
- The maximum port in the range of ports to try (exclusive).
- max_tries : int, optional
- The maximum number of bind attempts to make.
-
- Returns
- -------
- port : int
- The port the socket was bound to.
-
- Raises
- ------
- ZMQBindError
- if `max_tries` reached before successful bind
- """
- for i in range(max_tries):
- try:
- port = random.randrange(min_port, max_port)
- self.bind('%s:%s' % (addr, port))
- except ZMQError as exception:
- if not exception.errno == zmq.EADDRINUSE:
- raise
- else:
- return port
- raise ZMQBindError("Could not bind socket to random port.")
-
- def get_hwm(self):
- """get the High Water Mark
-
- On libzmq ≥ 3, this gets SNDHWM if available, otherwise RCVHWM
- """
- major = zmq.zmq_version_info()[0]
- if major >= 3:
- # return sndhwm, fallback on rcvhwm
- try:
- return self.getsockopt(zmq.SNDHWM)
- except zmq.ZMQError as e:
- pass
-
- return self.getsockopt(zmq.RCVHWM)
- else:
- return self.getsockopt(zmq.HWM)
-
- def set_hwm(self, value):
- """set the High Water Mark
-
- On libzmq ≥ 3, this sets both SNDHWM and RCVHWM
- """
- major = zmq.zmq_version_info()[0]
- if major >= 3:
- raised = None
- try:
- self.sndhwm = value
- except Exception as e:
- raised = e
- try:
- self.rcvhwm = value
- except Exception:
- raised = e
-
- if raised:
- raise raised
- else:
- return self.setsockopt(zmq.HWM, value)
-
- hwm = property(get_hwm, set_hwm,
- """property for High Water Mark
-
- Setting hwm sets both SNDHWM and RCVHWM as appropriate.
- It gets SNDHWM if available, otherwise RCVHWM.
- """
- )
-
- #-------------------------------------------------------------------------
- # Sending and receiving messages
- #-------------------------------------------------------------------------
-
- def send_multipart(self, msg_parts, flags=0, copy=True, track=False):
- """send a sequence of buffers as a multipart message
-
- The zmq.SNDMORE flag is added to all msg parts before the last.
-
- Parameters
- ----------
- msg_parts : iterable
- A sequence of objects to send as a multipart message. Each element
- can be any sendable object (Frame, bytes, buffer-providers)
- flags : int, optional
- SNDMORE is handled automatically for frames before the last.
- copy : bool, optional
- Should the frame(s) be sent in a copying or non-copying manner.
- track : bool, optional
- Should the frame(s) be tracked for notification that ZMQ has
- finished with it (ignored if copy=True).
-
- Returns
- -------
- None : if copy or not track
- MessageTracker : if track and not copy
- a MessageTracker object, whose `pending` property will
- be True until the last send is completed.
- """
- for msg in msg_parts[:-1]:
- self.send(msg, SNDMORE|flags, copy=copy, track=track)
- # Send the last part without the extra SNDMORE flag.
- return self.send(msg_parts[-1], flags, copy=copy, track=track)
-
- def recv_multipart(self, flags=0, copy=True, track=False):
- """receive a multipart message as a list of bytes or Frame objects
-
- Parameters
- ----------
- flags : int, optional
- Any supported flag: NOBLOCK. If NOBLOCK is set, this method
- will raise a ZMQError with EAGAIN if a message is not ready.
- If NOBLOCK is not set, then this method will block until a
- message arrives.
- copy : bool, optional
- Should the message frame(s) be received in a copying or non-copying manner?
- If False a Frame object is returned for each part, if True a copy of
- the bytes is made for each frame.
- track : bool, optional
- Should the message frame(s) be tracked for notification that ZMQ has
- finished with it? (ignored if copy=True)
-
- Returns
- -------
- msg_parts : list
- A list of frames in the multipart message; either Frames or bytes,
- depending on `copy`.
-
- """
- parts = [self.recv(flags, copy=copy, track=track)]
- # have first part already, only loop while more to receive
- while self.getsockopt(zmq.RCVMORE):
- part = self.recv(flags, copy=copy, track=track)
- parts.append(part)
-
- return parts
-
- def send_string(self, u, flags=0, copy=True, encoding='utf-8'):
- """send a Python unicode string as a message with an encoding
-
- 0MQ communicates with raw bytes, so you must encode/decode
- text (unicode on py2, str on py3) around 0MQ.
-
- Parameters
- ----------
- u : Python unicode string (unicode on py2, str on py3)
- The unicode string to send.
- flags : int, optional
- Any valid send flag.
- encoding : str [default: 'utf-8']
- The encoding to be used
- """
- if not isinstance(u, basestring):
- raise TypeError("unicode/str objects only")
- return self.send(u.encode(encoding), flags=flags, copy=copy)
-
- send_unicode = send_string
-
- def recv_string(self, flags=0, encoding='utf-8'):
- """receive a unicode string, as sent by send_string
-
- Parameters
- ----------
- flags : int
- Any valid recv flag.
- encoding : str [default: 'utf-8']
- The encoding to be used
-
- Returns
- -------
- s : unicode string (unicode on py2, str on py3)
- The Python unicode string that arrives as encoded bytes.
- """
- b = self.recv(flags=flags)
- return b.decode(encoding)
-
- recv_unicode = recv_string
-
- def send_pyobj(self, obj, flags=0, protocol=DEFAULT_PROTOCOL):
- """send a Python object as a message using pickle to serialize
-
- Parameters
- ----------
- obj : Python object
- The Python object to send.
- flags : int
- Any valid send flag.
- protocol : int
- The pickle protocol number to use. The default is pickle.DEFAULT_PROTOCOl
- where defined, and pickle.HIGHEST_PROTOCOL elsewhere.
- """
- msg = pickle.dumps(obj, protocol)
- return self.send(msg, flags)
-
- def recv_pyobj(self, flags=0):
- """receive a Python object as a message using pickle to serialize
-
- Parameters
- ----------
- flags : int
- Any valid recv flag.
-
- Returns
- -------
- obj : Python object
- The Python object that arrives as a message.
- """
- s = self.recv(flags)
- return pickle.loads(s)
-
- def send_json(self, obj, flags=0, **kwargs):
- """send a Python object as a message using json to serialize
-
- Keyword arguments are passed on to json.dumps
-
- Parameters
- ----------
- obj : Python object
- The Python object to send
- flags : int
- Any valid send flag
- """
- msg = jsonapi.dumps(obj, **kwargs)
- return self.send(msg, flags)
-
- def recv_json(self, flags=0, **kwargs):
- """receive a Python object as a message using json to serialize
-
- Keyword arguments are passed on to json.loads
-
- Parameters
- ----------
- flags : int
- Any valid recv flag.
-
- Returns
- -------
- obj : Python object
- The Python object that arrives as a message.
- """
- msg = self.recv(flags)
- return jsonapi.loads(msg, **kwargs)
-
- _poller_class = Poller
-
- def poll(self, timeout=None, flags=POLLIN):
- """poll the socket for events
-
- The default is to poll forever for incoming
- events. Timeout is in milliseconds, if specified.
-
- Parameters
- ----------
- timeout : int [default: None]
- The timeout (in milliseconds) to wait for an event. If unspecified
- (or specified None), will wait forever for an event.
- flags : bitfield (int) [default: POLLIN]
- The event flags to poll for (any combination of POLLIN|POLLOUT).
- The default is to check for incoming events (POLLIN).
-
- Returns
- -------
- events : bitfield (int)
- The events that are ready and waiting. Will be 0 if no events were ready
- by the time timeout was reached.
- """
-
- if self.closed:
- raise ZMQError(ENOTSUP)
-
- p = self._poller_class()
- p.register(self, flags)
- evts = dict(p.poll(timeout))
- # return 0 if no events, otherwise return event bitfield
- return evts.get(self, 0)
-
- def get_monitor_socket(self, events=None, addr=None):
- """Return a connected PAIR socket ready to receive the event notifications.
-
- .. versionadded:: libzmq-4.0
- .. versionadded:: 14.0
-
- Parameters
- ----------
- events : bitfield (int) [default: ZMQ_EVENTS_ALL]
- The bitmask defining which events are wanted.
- addr : string [default: None]
- The optional endpoint for the monitoring sockets.
-
- Returns
- -------
- socket : (PAIR)
- The socket is already connected and ready to receive messages.
- """
- # safe-guard, method only available on libzmq >= 4
- if zmq.zmq_version_info() < (4,):
- raise NotImplementedError("get_monitor_socket requires libzmq >= 4, have %s" % zmq.zmq_version())
- if addr is None:
- # create endpoint name from internal fd
- addr = "inproc://monitor.s-%d" % self.FD
- if events is None:
- # use all events
- events = zmq.EVENT_ALL
- # attach monitoring socket
- self.monitor(addr, events)
- # create new PAIR socket and connect it
- ret = self.context.socket(zmq.PAIR)
- ret.connect(addr)
- return ret
-
- def disable_monitor(self):
- """Shutdown the PAIR socket (created using get_monitor_socket)
- that is serving socket events.
-
- .. versionadded:: 14.4
- """
- self.monitor(None, 0)
-
-
-__all__ = ['Socket']
diff --git a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/tracker.py b/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/tracker.py
deleted file mode 100644
index fb8c007f..00000000
--- a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/tracker.py
+++ /dev/null
@@ -1,120 +0,0 @@
-"""Tracker for zero-copy messages with 0MQ."""
-
-# Copyright (C) PyZMQ Developers
-# Distributed under the terms of the Modified BSD License.
-
-import time
-
-try:
- # below 3.3
- from threading import _Event as Event
-except (ImportError, AttributeError):
- # python throws ImportError, cython throws AttributeError
- from threading import Event
-
-from zmq.error import NotDone
-from zmq.backend import Frame
-
-class MessageTracker(object):
- """MessageTracker(*towatch)
-
- A class for tracking if 0MQ is done using one or more messages.
-
- When you send a 0MQ message, it is not sent immediately. The 0MQ IO thread
- sends the message at some later time. Often you want to know when 0MQ has
- actually sent the message though. This is complicated by the fact that
- a single 0MQ message can be sent multiple times using different sockets.
- This class allows you to track all of the 0MQ usages of a message.
-
- Parameters
- ----------
- *towatch : tuple of Event, MessageTracker, Message instances.
- This list of objects to track. This class can track the low-level
- Events used by the Message class, other MessageTrackers or
- actual Messages.
- """
- events = None
- peers = None
-
- def __init__(self, *towatch):
- """MessageTracker(*towatch)
-
- Create a message tracker to track a set of mesages.
-
- Parameters
- ----------
- *towatch : tuple of Event, MessageTracker, Message instances.
- This list of objects to track. This class can track the low-level
- Events used by the Message class, other MessageTrackers or
- actual Messages.
- """
- self.events = set()
- self.peers = set()
- for obj in towatch:
- if isinstance(obj, Event):
- self.events.add(obj)
- elif isinstance(obj, MessageTracker):
- self.peers.add(obj)
- elif isinstance(obj, Frame):
- if not obj.tracker:
- raise ValueError("Not a tracked message")
- self.peers.add(obj.tracker)
- else:
- raise TypeError("Require Events or Message Frames, not %s"%type(obj))
-
- @property
- def done(self):
- """Is 0MQ completely done with the message(s) being tracked?"""
- for evt in self.events:
- if not evt.is_set():
- return False
- for pm in self.peers:
- if not pm.done:
- return False
- return True
-
- def wait(self, timeout=-1):
- """mt.wait(timeout=-1)
-
- Wait for 0MQ to be done with the message or until `timeout`.
-
- Parameters
- ----------
- timeout : float [default: -1, wait forever]
- Maximum time in (s) to wait before raising NotDone.
-
- Returns
- -------
- None
- if done before `timeout`
-
- Raises
- ------
- NotDone
- if `timeout` reached before I am done.
- """
- tic = time.time()
- if timeout is False or timeout < 0:
- remaining = 3600*24*7 # a week
- else:
- remaining = timeout
- done = False
- for evt in self.events:
- if remaining < 0:
- raise NotDone
- evt.wait(timeout=remaining)
- if not evt.is_set():
- raise NotDone
- toc = time.time()
- remaining -= (toc-tic)
- tic = toc
-
- for peer in self.peers:
- if remaining < 0:
- raise NotDone
- peer.wait(timeout=remaining)
- toc = time.time()
- remaining -= (toc-tic)
- tic = toc
-
-__all__ = ['MessageTracker'] \ No newline at end of file
diff --git a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/version.py b/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/version.py
deleted file mode 100644
index ea8fbbc4..00000000
--- a/scripts/external_libs/pyzmq-14.5.0/python3/cel59/64bit/zmq/sugar/version.py
+++ /dev/null
@@ -1,48 +0,0 @@
-"""PyZMQ and 0MQ version functions."""
-
-# Copyright (C) PyZMQ Developers
-# Distributed under the terms of the Modified BSD License.
-
-
-from zmq.backend import zmq_version_info
-
-
-VERSION_MAJOR = 14
-VERSION_MINOR = 5
-VERSION_PATCH = 0
-VERSION_EXTRA = ""
-__version__ = '%i.%i.%i' % (VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH)
-
-if VERSION_EXTRA:
- __version__ = "%s-%s" % (__version__, VERSION_EXTRA)
- version_info = (VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, float('inf'))
-else:
- version_info = (VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH)
-
-__revision__ = ''
-
-def pyzmq_version():
- """return the version of pyzmq as a string"""
- if __revision__:
- return '@'.join([__version__,__revision__[:6]])
- else:
- return __version__
-
-def pyzmq_version_info():
- """return the pyzmq version as a tuple of at least three numbers
-
- If pyzmq is a development version, `inf` will be appended after the third integer.
- """
- return version_info
-
-
-def zmq_version():
- """return the version of libzmq as a string"""
- return "%i.%i.%i" % zmq_version_info()
-
-
-__all__ = ['zmq_version', 'zmq_version_info',
- 'pyzmq_version','pyzmq_version_info',
- '__version__', '__revision__'
-]
-