[Pkg-bitcoin-commits] [python-quamash] 69/78: Merge branch 'gh45' into gh66
Jonas Smedegaard
dr at jones.dk
Tue Dec 19 01:19:57 UTC 2017
This is an automated email from the git hooks/post-receive script.
js pushed a commit to annotated tag debian/0.6.0_dfsg-1
in repository python-quamash.
commit 9c0c66b75f57d4c47b8c81df672829ce3004a4d9
Merge: e5fc6b1 e8de434
Author: Mark Thomas West Harviston <mark.harviston at gmail.com>
Date: Sun Nov 19 23:07:59 2017 -0800
Merge branch 'gh45' into gh66
quamash/__init__.py | 30 ++--
quamash/_unix.py | 435 ++++++++++++++++++++++++++--------------------------
quamash/_windows.py | 3 -
3 files changed, 237 insertions(+), 231 deletions(-)
diff --cc quamash/__init__.py
index abdf05f,18a617e..7ceaf58
--- a/quamash/__init__.py
+++ b/quamash/__init__.py
@@@ -171,55 -171,27 +171,47 @@@ def _make_signaller(qtimpl_qtcore, *arg
return Signaller()
- if os.name == 'nt':
- from . import _windows
- _baseclass = _windows.baseclass
- else:
- from . import _unix
- _baseclass = _unix.baseclass
-
-
+ at with_logger
class _SimpleTimer(QtCore.QObject):
- def __init__(self, timeout, callback):
+ def __init__(self):
super().__init__()
- self.callback = callback
- self.timer_id = self.startTimer(timeout)
- self.stopped = False
-
- def timerEvent(self, event): # noqa
- assert self.timer_id == event.timerId()
- if self.stopped:
- self.killTimer(self.timer_id)
- elif event.timerId() == self.timer_id:
- self.callback()
- self.killTimer(self.timer_id)
- self.stopped = True
+ self.__callbacks = {}
+ self._stopped = False
+
+ def add_callback(self, handle, delay=0):
+ timerid = self.startTimer(delay * 1000)
+ self._logger.debug("Registering timer id {0}".format(timerid))
+ assert timerid not in self.__callbacks
+ self.__callbacks[timerid] = handle
+ return handle
+
+ def timerEvent(self, event): # noqa: N802
+ timerid = event.timerId()
+ self._logger.debug("Timer event on id {0}".format(timerid))
+ if self._stopped:
+ self._logger.debug("Timer stopped, killing {}".format(timerid))
+ self.killTimer(timerid)
+ del self.__callbacks[timerid]
+ else:
+ try:
+ handle = self.__callbacks[timerid]
+ except KeyError as e:
+ self._logger.debug(str(e))
+ pass
+ else:
+ if handle._cancelled:
+ self._logger.debug("Handle {} cancelled".format(handle))
+ else:
+ self._logger.debug("Calling handle {}".format(handle))
+ handle._run()
+ finally:
+ del self.__callbacks[timerid]
+ handle = None
+ self.killTimer(timerid)
def stop(self):
- self.stopped = True
-
- def cancel(self):
- self.stopped = True
+ self._logger.debug("Stopping timers")
+ self._stopped = True
@with_logger
@@@ -591,5 -582,24 +583,25 @@@ class _QEventLoop
# In some cases, the error method itself fails, don't have a lot of options in that case
try:
cls._logger.error(*args, **kwds)
- except:
+ except: # noqa E722
sys.stderr.write('{!r}, {!r}\n'.format(args, kwds))
+
++
+ from ._unix import _SelectorEventLoop
+ QSelectorEventLoop = type('QSelectorEventLoop', (_QEventLoop, _SelectorEventLoop), {})
+
+ if os.name == 'nt':
+ from ._windows import _ProactorEventLoop
+ QIOCPEventLoop = type('QIOCPEventLoop', (_QEventLoop, _ProactorEventLoop), {})
+ QEventLoop = QIOCPEventLoop
+ else:
+ QEventLoop = QSelectorEventLoop
+
+
+ class _Cancellable:
+ def __init__(self, timer, loop):
+ self.__timer = timer
+ self.__loop = loop
+
+ def cancel(self):
+ self.__timer.stop()
diff --cc quamash/_unix.py
index b471899,913cd44..57283cb
--- a/quamash/_unix.py
+++ b/quamash/_unix.py
@@@ -1,223 -1,218 +1,220 @@@
- # © 2014 Mark Harviston <mark.harviston at gmail.com>
- # © 2014 Arve Knudsen <arve.knudsen at gmail.com>
- # BSD License
-
- """UNIX specific Quamash functionality."""
-
- import asyncio
- from asyncio import selectors
- import collections
-
- from . import QtCore, with_logger
-
-
- EVENT_READ = (1 << 0)
- EVENT_WRITE = (1 << 1)
-
-
- def _fileobj_to_fd(fileobj):
- """
- Return a file descriptor from a file object.
-
- Parameters:
- fileobj -- file object or file descriptor
-
- Returns:
- corresponding file descriptor
-
- Raises:
+ # © 2014 Mark Harviston <mark.harviston at gmail.com>
+ # © 2014 Arve Knudsen <arve.knudsen at gmail.com>
+ # BSD License
+
+ """UNIX specific Quamash functionality."""
+
+ import asyncio
+ from asyncio import selectors
+ import collections
+
+ from . import QtCore, with_logger
+
+
+ EVENT_READ = (1 << 0)
+ EVENT_WRITE = (1 << 1)
+
+
+ def _fileobj_to_fd(fileobj):
+ """
+ Return a file descriptor from a file object.
+
+ Parameters:
+ fileobj -- file object or file descriptor
+
+ Returns:
+ corresponding file descriptor
+
+ Raises:
- ValueError if the object is invalid
- """
+ ValueError if the object is invalid
-
++
+ """
- if isinstance(fileobj, int):
- fd = fileobj
- else:
- try:
- fd = int(fileobj.fileno())
- except (AttributeError, TypeError, ValueError) as ex:
- raise ValueError("Invalid file object: {!r}".format(fileobj)) from ex
- if fd < 0:
- raise ValueError("Invalid file descriptor: {}".format(fd))
- return fd
-
-
- class _SelectorMapping(collections.Mapping):
-
- """Mapping of file objects to selector keys."""
-
- def __init__(self, selector):
- self._selector = selector
-
- def __len__(self):
- return len(self._selector._fd_to_key)
-
- def __getitem__(self, fileobj):
- try:
- fd = self._selector._fileobj_lookup(fileobj)
- return self._selector._fd_to_key[fd]
- except KeyError:
- raise KeyError("{!r} is not registered".format(fileobj)) from None
-
- def __iter__(self):
- return iter(self._selector._fd_to_key)
-
-
- @with_logger
- class _Selector(selectors.BaseSelector):
- def __init__(self, parent):
- # this maps file descriptors to keys
- self._fd_to_key = {}
- # read-only mapping returned by get_map()
- self.__map = _SelectorMapping(self)
- self.__read_notifiers = {}
- self.__write_notifiers = {}
- self.__parent = parent
-
- def select(self, *args, **kwargs):
- """Implement abstract method even though we don't need it."""
- raise NotImplementedError
-
- def _fileobj_lookup(self, fileobj):
- """Return a file descriptor from a file object.
-
- This wraps _fileobj_to_fd() to do an exhaustive search in case
- the object is invalid but we still have it in our map. This
- is used by unregister() so we can unregister an object that
- was previously registered even if it is closed. It is also
- used by _SelectorMapping.
- """
- try:
- return _fileobj_to_fd(fileobj)
- except ValueError:
- # Do an exhaustive search.
- for key in self._fd_to_key.values():
- if key.fileobj is fileobj:
- return key.fd
- # Raise ValueError after all.
- raise
-
- def register(self, fileobj, events, data=None):
- if (not events) or (events & ~(EVENT_READ | EVENT_WRITE)):
- raise ValueError("Invalid events: {!r}".format(events))
-
- key = selectors.SelectorKey(fileobj, self._fileobj_lookup(fileobj), events, data)
-
- if key.fd in self._fd_to_key:
- raise KeyError("{!r} (FD {}) is already registered".format(fileobj, key.fd))
-
- self._fd_to_key[key.fd] = key
-
- if events & EVENT_READ:
- notifier = QtCore.QSocketNotifier(key.fd, QtCore.QSocketNotifier.Read)
- notifier.activated.connect(self.__on_read_activated)
- self.__read_notifiers[key.fd] = notifier
- if events & EVENT_WRITE:
- notifier = QtCore.QSocketNotifier(key.fd, QtCore.QSocketNotifier.Write)
- notifier.activated.connect(self.__on_write_activated)
- self.__write_notifiers[key.fd] = notifier
-
- return key
-
- def __on_read_activated(self, fd):
- self._logger.debug('File {} ready to read'.format(fd))
- key = self._key_from_fd(fd)
- if key:
- self.__parent._process_event(key, EVENT_READ & key.events)
-
- def __on_write_activated(self, fd):
- self._logger.debug('File {} ready to write'.format(fd))
- key = self._key_from_fd(fd)
- if key:
- self.__parent._process_event(key, EVENT_WRITE & key.events)
-
- def unregister(self, fileobj):
- def drop_notifier(notifiers):
- try:
- notifier = notifiers.pop(key.fd)
- except KeyError:
- pass
- else:
- notifier.activated.disconnect()
-
- try:
- key = self._fd_to_key.pop(self._fileobj_lookup(fileobj))
- except KeyError:
- raise KeyError("{!r} is not registered".format(fileobj)) from None
-
- drop_notifier(self.__read_notifiers)
- drop_notifier(self.__write_notifiers)
-
- return key
-
- def modify(self, fileobj, events, data=None):
- try:
- key = self._fd_to_key[self._fileobj_lookup(fileobj)]
- except KeyError:
- raise KeyError("{!r} is not registered".format(fileobj)) from None
- if events != key.events:
- self.unregister(fileobj)
- key = self.register(fileobj, events, data)
- elif data != key.data:
- # Use a shortcut to update the data.
- key = key._replace(data=data)
- self._fd_to_key[key.fd] = key
- return key
-
- def close(self):
- self._logger.debug('Closing')
- self._fd_to_key.clear()
- self.__read_notifiers.clear()
- self.__write_notifiers.clear()
-
- def get_map(self):
- return self.__map
-
- def _key_from_fd(self, fd):
- """
- Return the key associated to a given file descriptor.
-
- Parameters:
- fd -- file descriptor
-
- Returns:
+ if isinstance(fileobj, int):
+ fd = fileobj
+ else:
+ try:
+ fd = int(fileobj.fileno())
+ except (AttributeError, TypeError, ValueError) as ex:
+ raise ValueError("Invalid file object: {!r}".format(fileobj)) from ex
+ if fd < 0:
+ raise ValueError("Invalid file descriptor: {}".format(fd))
+ return fd
+
+
+ class _SelectorMapping(collections.Mapping):
+
+ """Mapping of file objects to selector keys."""
+
+ def __init__(self, selector):
+ self._selector = selector
+
+ def __len__(self):
+ return len(self._selector._fd_to_key)
+
+ def __getitem__(self, fileobj):
+ try:
+ fd = self._selector._fileobj_lookup(fileobj)
+ return self._selector._fd_to_key[fd]
+ except KeyError:
+ raise KeyError("{!r} is not registered".format(fileobj)) from None
+
+ def __iter__(self):
+ return iter(self._selector._fd_to_key)
+
+
+ @with_logger
+ class _Selector(selectors.BaseSelector):
+ def __init__(self, parent):
+ # this maps file descriptors to keys
+ self._fd_to_key = {}
+ # read-only mapping returned by get_map()
+ self.__map = _SelectorMapping(self)
+ self.__read_notifiers = {}
+ self.__write_notifiers = {}
+ self.__parent = parent
+
+ def select(self, *args, **kwargs):
+ """Implement abstract method even though we don't need it."""
+ raise NotImplementedError
+
+ def _fileobj_lookup(self, fileobj):
+ """Return a file descriptor from a file object.
+
+ This wraps _fileobj_to_fd() to do an exhaustive search in case
+ the object is invalid but we still have it in our map. This
+ is used by unregister() so we can unregister an object that
+ was previously registered even if it is closed. It is also
+ used by _SelectorMapping.
+ """
+ try:
+ return _fileobj_to_fd(fileobj)
+ except ValueError:
+ # Do an exhaustive search.
+ for key in self._fd_to_key.values():
+ if key.fileobj is fileobj:
+ return key.fd
+ # Raise ValueError after all.
+ raise
+
+ def register(self, fileobj, events, data=None):
+ if (not events) or (events & ~(EVENT_READ | EVENT_WRITE)):
+ raise ValueError("Invalid events: {!r}".format(events))
+
+ key = selectors.SelectorKey(fileobj, self._fileobj_lookup(fileobj), events, data)
+
+ if key.fd in self._fd_to_key:
+ raise KeyError("{!r} (FD {}) is already registered".format(fileobj, key.fd))
+
+ self._fd_to_key[key.fd] = key
+
+ if events & EVENT_READ:
+ notifier = QtCore.QSocketNotifier(key.fd, QtCore.QSocketNotifier.Read)
+ notifier.activated.connect(self.__on_read_activated)
+ self.__read_notifiers[key.fd] = notifier
+ if events & EVENT_WRITE:
+ notifier = QtCore.QSocketNotifier(key.fd, QtCore.QSocketNotifier.Write)
+ notifier.activated.connect(self.__on_write_activated)
+ self.__write_notifiers[key.fd] = notifier
+
+ return key
+
+ def __on_read_activated(self, fd):
+ self._logger.debug('File {} ready to read'.format(fd))
+ key = self._key_from_fd(fd)
+ if key:
+ self.__parent._process_event(key, EVENT_READ & key.events)
+
+ def __on_write_activated(self, fd):
+ self._logger.debug('File {} ready to write'.format(fd))
+ key = self._key_from_fd(fd)
+ if key:
+ self.__parent._process_event(key, EVENT_WRITE & key.events)
+
+ def unregister(self, fileobj):
+ def drop_notifier(notifiers):
+ try:
+ notifier = notifiers.pop(key.fd)
+ except KeyError:
+ pass
+ else:
+ notifier.activated.disconnect()
+
+ try:
+ key = self._fd_to_key.pop(self._fileobj_lookup(fileobj))
+ except KeyError:
+ raise KeyError("{!r} is not registered".format(fileobj)) from None
+
+ drop_notifier(self.__read_notifiers)
+ drop_notifier(self.__write_notifiers)
+
+ return key
+
+ def modify(self, fileobj, events, data=None):
+ try:
+ key = self._fd_to_key[self._fileobj_lookup(fileobj)]
+ except KeyError:
+ raise KeyError("{!r} is not registered".format(fileobj)) from None
+ if events != key.events:
+ self.unregister(fileobj)
+ key = self.register(fileobj, events, data)
+ elif data != key.data:
+ # Use a shortcut to update the data.
+ key = key._replace(data=data)
+ self._fd_to_key[key.fd] = key
+ return key
+
+ def close(self):
+ self._logger.debug('Closing')
+ self._fd_to_key.clear()
+ self.__read_notifiers.clear()
+ self.__write_notifiers.clear()
+
+ def get_map(self):
+ return self.__map
+
+ def _key_from_fd(self, fd):
+ """
+ Return the key associated to a given file descriptor.
+
+ Parameters:
+ fd -- file descriptor
+
+ Returns:
- corresponding key, or None if not found
+ corresponding key, or None if not found
-
- """
- try:
- return self._fd_to_key[fd]
- except KeyError:
- return None
-
-
- class _SelectorEventLoop(asyncio.SelectorEventLoop):
- def __init__(self):
- self._signal_safe_callbacks = []
-
- selector = _Selector(self)
- asyncio.SelectorEventLoop.__init__(self, selector)
-
- def _before_run_forever(self):
- pass
-
- def _after_run_forever(self):
- pass
-
- def _process_event(self, key, mask):
- """Selector has delivered us an event."""
- self._logger.debug('Processing event with key {} and mask {}'.format(key, mask))
- fileobj, (reader, writer) = key.fileobj, key.data
- if mask & selectors.EVENT_READ and reader is not None:
- if reader._cancelled:
- self.remove_reader(fileobj)
- else:
- self._logger.debug('Invoking reader callback: {}'.format(reader))
- reader._run()
- if mask & selectors.EVENT_WRITE and writer is not None:
- if writer._cancelled:
- self.remove_writer(fileobj)
- else:
- self._logger.debug('Invoking writer callback: {}'.format(writer))
++
+ """
+ try:
+ return self._fd_to_key[fd]
+ except KeyError:
+ return None
+
+
+ class _SelectorEventLoop(asyncio.SelectorEventLoop):
+ def __init__(self):
+ self._signal_safe_callbacks = []
+
+ selector = _Selector(self)
+ asyncio.SelectorEventLoop.__init__(self, selector)
+
+ def _before_run_forever(self):
+ pass
+
+ def _after_run_forever(self):
+ pass
+
+ def _process_event(self, key, mask):
+ """Selector has delivered us an event."""
+ self._logger.debug('Processing event with key {} and mask {}'.format(key, mask))
+ fileobj, (reader, writer) = key.fileobj, key.data
+ if mask & selectors.EVENT_READ and reader is not None:
+ if reader._cancelled:
+ self.remove_reader(fileobj)
+ else:
+ self._logger.debug('Invoking reader callback: {}'.format(reader))
+ reader._run()
+ if mask & selectors.EVENT_WRITE and writer is not None:
+ if writer._cancelled:
+ self.remove_writer(fileobj)
+ else:
+ self._logger.debug('Invoking writer callback: {}'.format(writer))
- writer._run()
+ writer._run()
-
-
- baseclass = _SelectorEventLoop
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-bitcoin/python-quamash.git
More information about the Pkg-bitcoin-commits
mailing list