py-kms no longer supports python2 (continuation)

py-kms/pykms_Format.py

@@ -1,38 +1,22 @@
 #!/usr/bin/env python3
 
-from __future__ import print_function, unicode_literals
 import re
 import sys
 import os
 from collections import OrderedDict
 import logging
-
+from io import StringIO
-try:
+import queue as Queue
-    # Python 2.x imports
-    from StringIO import StringIO
-    import Queue as Queue
-except ImportError:
-    # Python 3.x imports
-    from io import StringIO
-    import queue as Queue
-
-pyver = sys.version_info[:2]
 
 #----------------------------------------------------------------------------------------------------------------------------------------------------------
 
 def enco(strg, typ = 'latin-1'):
-    if pyver >= (3, 0):
+    if isinstance(strg, str):
-        if isinstance(strg, str):
+        return strg.encode(typ)
-            return strg.encode(typ)
-    else:
-            return strg
 
 def deco(strg, typ = 'latin-1'):
-    if pyver >= (3, 0):
+    if isinstance(strg, bytes):
-        if isinstance(strg, bytes):
+        return strg.decode(typ)
-            return strg.decode(typ)
-    else:
-            return strg
             
 def byterize(obj):
     
@@ -44,11 +28,10 @@ def byterize(obj):
             for subkey in subdictio:
                 do_encode(subdictio, subkey)
 
-    if pyver >= (3, 0):
+    objdict = obj.__dict__['fields']
-        objdict = obj.__dict__['fields']
+    for field in objdict:
-        for field in objdict:
+        do_encode(objdict, field)
-            do_encode(objdict, field)
+
-            
     return obj
 
 
@@ -186,17 +169,6 @@ def unshell_message(ansi_string, count):
     return msgcolored, count
 
 #-------------------------------------------------------------------------------------------------------------------------------------------------------
-# https://stackoverflow.com/questions/230751/how-to-flush-output-of-print-function
-if pyver < (3, 3):
-    old_print = print
-    
-    def print(*args, **kwargs):
-        flush = kwargs.pop('flush', False)
-        old_print(*args, **kwargs)
-        if flush:
-            file = kwargs.get('file', sys.stdout)
-            file.flush() if file is not None else sys.stdout.flush()
-
 # based on: https://ryanjoneil.github.io/posts/2014-02-14-capturing-stdout-in-a-python-child-process.html
 queue_print = Queue.Queue()
 

py-kms/pykms_GuiBase.py

@@ -10,6 +10,7 @@ from tkinter import ttk
 from tkinter import messagebox
 from tkinter import filedialog
 import tkinter.font as tkFont
+
 from pykms_Server import srv_options, srv_version, srv_config, server_terminate, serverqueue, serverthread
 from pykms_GuiMisc import ToolTip, TextDoubleScroll, TextRedirect, ListboxOfRadiobuttons
 from pykms_GuiMisc import custom_background, custom_pages
@@ -25,13 +26,8 @@ gui_description         = "A GUI for py-kms."
 ##---------------------------------------------------------------------------------------------------------------------------------------------------------
 def get_ip_address():
         if os.name == 'posix':
-                try:
+                import subprocess
-                        # Python 2.x import
+                ip = subprocess.getoutput("hostname -I")
-                        import commands 
-                except ImportError:
-                        #Python 3.x import
-                        import subprocess as commands 
-                ip = commands.getoutput("hostname -I")
         elif os.name == 'nt':
                 import socket
                 ip = socket.gethostbyname(socket.gethostname())

py-kms/pykms_GuiMisc.py

@@ -9,6 +9,7 @@ import threading
 import tkinter as tk
 from tkinter import ttk
 import tkinter.font as tkFont
+
 from pykms_Format import MsgMap, unshell_message, unformat_message
 
 #------------------------------------------------------------------------------------------------------------------------------------------------------------

py-kms/pykms_Misc.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
 
-from __future__ import print_function
 import sys
 import logging
 import os
 import argparse
 from logging.handlers import RotatingFileHandler
+
 from pykms_Format import ColorExtraMap, ShellMessage, pretty_printer
 
 #------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -88,12 +88,7 @@ class LevelFormatter(logging.Formatter):
 
 # based on https://github.com/jruere/multiprocessing-logging (license LGPL-3.0)
 from multiprocessing import Queue as MPQueue
-try:
+import queue as Queue
-    # Python 2.x imports
-    import Queue as Queue
-except ImportError:
-    # Python 3.x imports
-    import queue as Queue
 import threading
 
 class MultiProcessingLogHandler(logging.Handler):

py-kms/pykms_Selectors.py

@@ -1,588 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-    SPDX-License-Identifier: MIT
-    Backport of selectors.py from Python 3.5+ to support Python < 3.4
-    Also has the behavior specified in PEP 475 which is to retry syscalls
-    in the case of an EINTR error. This module is required because selectors34
-    does not follow this behavior and instead returns that no dile descriptor
-    events have occurred rather than retry the syscall. The decision to drop
-    support for select.devpoll is made to maintain 100% test coverage.
-    
-    link: https://github.com/netdata/netdata/blob/master/collectors/python.d.plugin/python_modules/urllib3/util/selectors.py
-"""
-
-import errno
-import math
-import select
-import socket
-import sys
-import time
-from collections import namedtuple, Mapping
-
-try:
-    monotonic = time.monotonic
-except (AttributeError, ImportError):  # Python 3.3<
-    from pykms_Time import monotonic
-
-EVENT_READ = (1 << 0)
-EVENT_WRITE = (1 << 1)
-
-HAS_SELECT = True  # Variable that shows whether the platform has a selector.
-_SYSCALL_SENTINEL = object()  # Sentinel in case a system call returns None.
-_DEFAULT_SELECTOR = None
-
-
-class SelectorError(Exception):
-    def __init__(self, errcode):
-        super(SelectorError, self).__init__()
-        self.errno = errcode
-
-    def __repr__(self):
-        return "<SelectorError errno={0}>".format(self.errno)
-
-    def __str__(self):
-        return self.__repr__()
-
-
-def _fileobj_to_fd(fileobj):
-    """ Return a file descriptor from a file object. If
-    given an integer will simply return that integer back. """
-    if isinstance(fileobj, int):
-        fd = fileobj
-    else:
-        try:
-            fd = int(fileobj.fileno())
-        except (AttributeError, TypeError, ValueError):
-            raise ValueError("Invalid file object: {0!r}".format(fileobj))
-    if fd < 0:
-        raise ValueError("Invalid file descriptor: {0}".format(fd))
-    return fd
-
-
-# Determine which function to use to wrap system calls because Python 3.5+
-# already handles the case when system calls are interrupted.
-if sys.version_info >= (3, 5):
-    def _syscall_wrapper(func, _, *args, **kwargs):
-        """ This is the short-circuit version of the below logic
-        because in Python 3.5+ all system calls automatically restart
-        and recalculate their timeouts. """
-        try:
-            return func(*args, **kwargs)
-        except (OSError, IOError, select.error) as e:
-            errcode = None
-            if hasattr(e, "errno"):
-                errcode = e.errno
-            raise SelectorError(errcode)
-else:
-    def _syscall_wrapper(func, recalc_timeout, *args, **kwargs):
-        """ Wrapper function for syscalls that could fail due to EINTR.
-        All functions should be retried if there is time left in the timeout
-        in accordance with PEP 475. """
-        timeout = kwargs.get("timeout", None)
-        if timeout is None:
-            expires = None
-            recalc_timeout = False
-        else:
-            timeout = float(timeout)
-            if timeout < 0.0:  # Timeout less than 0 treated as no timeout.
-                expires = None
-            else:
-                expires = monotonic() + timeout
-
-        args = list(args)
-        if recalc_timeout and "timeout" not in kwargs:
-            raise ValueError(
-                "Timeout must be in args or kwargs to be recalculated")
-
-        result = _SYSCALL_SENTINEL
-        while result is _SYSCALL_SENTINEL:
-            try:
-                result = func(*args, **kwargs)
-            # OSError is thrown by select.select
-            # IOError is thrown by select.epoll.poll
-            # select.error is thrown by select.poll.poll
-            # Aren't we thankful for Python 3.x rework for exceptions?
-            except (OSError, IOError, select.error) as e:
-                # select.error wasn't a subclass of OSError in the past.
-                errcode = None
-                if hasattr(e, "errno"):
-                    errcode = e.errno
-                elif hasattr(e, "args"):
-                    errcode = e.args[0]
-
-                # Also test for the Windows equivalent of EINTR.
-                is_interrupt = (errcode == errno.EINTR or (hasattr(errno, "WSAEINTR") and
-                                                           errcode == errno.WSAEINTR))
-
-                if is_interrupt:
-                    if expires is not None:
-                        current_time = monotonic()
-                        if current_time > expires:
-                            raise OSError(errno=errno.ETIMEDOUT)
-                        if recalc_timeout:
-                            if "timeout" in kwargs:
-                                kwargs["timeout"] = expires - current_time
-                    continue
-                if errcode:
-                    raise SelectorError(errcode)
-                else:
-                    raise
-        return result
-
-
-SelectorKey = namedtuple('SelectorKey', ['fileobj', 'fd', 'events', 'data'])
-
-
-class _SelectorMapping(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("{0!r} is not registered.".format(fileobj))
-
-    def __iter__(self):
-        return iter(self._selector._fd_to_key)
-
-
-class BaseSelector(object):
-    """ Abstract Selector class
-
-    A selector supports registering file objects to be monitored
-    for specific I/O events.
-
-    A file object is a file descriptor or any object with a
-    `fileno()` method. An arbitrary object can be attached to the
-    file object which can be used for example to store context info,
-    a callback, etc.
-
-    A selector can use various implementations (select(), poll(), epoll(),
-    and kqueue()) depending on the platform. The 'DefaultSelector' class uses
-    the most efficient implementation for the current platform.
-    """
-    def __init__(self):
-        # Maps file descriptors to keys.
-        self._fd_to_key = {}
-
-        # Read-only mapping returned by get_map()
-        self._map = _SelectorMapping(self)
-
-    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. 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:
-
-            # Search through all our mapped keys.
-            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):
-        """ Register a file object for a set of events to monitor. """
-        if (not events) or (events & ~(EVENT_READ | EVENT_WRITE)):
-            raise ValueError("Invalid events: {0!r}".format(events))
-
-        key = SelectorKey(fileobj, self._fileobj_lookup(fileobj), events, data)
-
-        if key.fd in self._fd_to_key:
-            raise KeyError("{0!r} (FD {1}) is already registered"
-                           .format(fileobj, key.fd))
-
-        self._fd_to_key[key.fd] = key
-        return key
-
-    def unregister(self, fileobj):
-        """ Unregister a file object from being monitored. """
-        try:
-            key = self._fd_to_key.pop(self._fileobj_lookup(fileobj))
-        except KeyError:
-            raise KeyError("{0!r} is not registered".format(fileobj))
-
-        # Getting the fileno of a closed socket on Windows errors with EBADF.
-        except socket.error as e:  # Platform-specific: Windows.
-            if e.errno != errno.EBADF:
-                raise
-            else:
-                for key in self._fd_to_key.values():
-                    if key.fileobj is fileobj:
-                        self._fd_to_key.pop(key.fd)
-                        break
-                else:
-                    raise KeyError("{0!r} is not registered".format(fileobj))
-        return key
-
-    def modify(self, fileobj, events, data=None):
-        """ Change a registered file object monitored events and data. """
-        # NOTE: Some subclasses optimize this operation even further.
-        try:
-            key = self._fd_to_key[self._fileobj_lookup(fileobj)]
-        except KeyError:
-            raise KeyError("{0!r} is not registered".format(fileobj))
-
-        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 select(self, timeout=None):
-        """ Perform the actual selection until some monitored file objects
-        are ready or the timeout expires. """
-        raise NotImplementedError()
-
-    def close(self):
-        """ Close the selector. This must be called to ensure that all
-        underlying resources are freed. """
-        self._fd_to_key.clear()
-        self._map = None
-
-    def get_key(self, fileobj):
-        """ Return the key associated with a registered file object. """
-        mapping = self.get_map()
-        if mapping is None:
-            raise RuntimeError("Selector is closed")
-        try:
-            return mapping[fileobj]
-        except KeyError:
-            raise KeyError("{0!r} is not registered".format(fileobj))
-
-    def get_map(self):
-        """ Return a mapping of file objects to selector keys """
-        return self._map
-
-    def _key_from_fd(self, fd):
-        """ Return the key associated to a given file descriptor
-         Return None if it is not found. """
-        try:
-            return self._fd_to_key[fd]
-        except KeyError:
-            return None
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *args):
-        self.close()
-
-
-# Almost all platforms have select.select()
-if hasattr(select, "select"):
-    class SelectSelector(BaseSelector):
-        """ Select-based selector. """
-        def __init__(self):
-            super(SelectSelector, self).__init__()
-            self._readers = set()
-            self._writers = set()
-
-        def register(self, fileobj, events, data=None):
-            key = super(SelectSelector, self).register(fileobj, events, data)
-            if events & EVENT_READ:
-                self._readers.add(key.fd)
-            if events & EVENT_WRITE:
-                self._writers.add(key.fd)
-            return key
-
-        def unregister(self, fileobj):
-            key = super(SelectSelector, self).unregister(fileobj)
-            self._readers.discard(key.fd)
-            self._writers.discard(key.fd)
-            return key
-
-        def _select(self, r, w, timeout=None):
-            """ Wrapper for select.select because timeout is a positional arg """
-            return select.select(r, w, [], timeout)
-
-        def select(self, timeout=None):
-            # Selecting on empty lists on Windows errors out.
-            if not len(self._readers) and not len(self._writers):
-                return []
-
-            timeout = None if timeout is None else max(timeout, 0.0)
-            ready = []
-            r, w, _ = _syscall_wrapper(self._select, True, self._readers,
-                                       self._writers, timeout)
-            r = set(r)
-            w = set(w)
-            for fd in r | w:
-                events = 0
-                if fd in r:
-                    events |= EVENT_READ
-                if fd in w:
-                    events |= EVENT_WRITE
-
-                key = self._key_from_fd(fd)
-                if key:
-                    ready.append((key, events & key.events))
-            return ready
-
-
-if hasattr(select, "poll"):
-    class PollSelector(BaseSelector):
-        """ Poll-based selector """
-        def __init__(self):
-            super(PollSelector, self).__init__()
-            self._poll = select.poll()
-
-        def register(self, fileobj, events, data=None):
-            key = super(PollSelector, self).register(fileobj, events, data)
-            event_mask = 0
-            if events & EVENT_READ:
-                event_mask |= select.POLLIN
-            if events & EVENT_WRITE:
-                event_mask |= select.POLLOUT
-            self._poll.register(key.fd, event_mask)
-            return key
-
-        def unregister(self, fileobj):
-            key = super(PollSelector, self).unregister(fileobj)
-            self._poll.unregister(key.fd)
-            return key
-
-        def _wrap_poll(self, timeout=None):
-            """ Wrapper function for select.poll.poll() so that
-            _syscall_wrapper can work with only seconds. """
-            if timeout is not None:
-                if timeout <= 0:
-                    timeout = 0
-                else:
-                    # select.poll.poll() has a resolution of 1 millisecond,
-                    # round away from zero to wait *at least* timeout seconds.
-                    timeout = math.ceil(timeout * 1e3)
-
-            result = self._poll.poll(timeout)
-            return result
-
-        def select(self, timeout=None):
-            ready = []
-            fd_events = _syscall_wrapper(self._wrap_poll, True, timeout=timeout)
-            for fd, event_mask in fd_events:
-                events = 0
-                if event_mask & ~select.POLLIN:
-                    events |= EVENT_WRITE
-                if event_mask & ~select.POLLOUT:
-                    events |= EVENT_READ
-
-                key = self._key_from_fd(fd)
-                if key:
-                    ready.append((key, events & key.events))
-
-            return ready
-
-
-if hasattr(select, "epoll"):
-    class EpollSelector(BaseSelector):
-        """ Epoll-based selector """
-        def __init__(self):
-            super(EpollSelector, self).__init__()
-            self._epoll = select.epoll()
-
-        def fileno(self):
-            return self._epoll.fileno()
-
-        def register(self, fileobj, events, data=None):
-            key = super(EpollSelector, self).register(fileobj, events, data)
-            events_mask = 0
-            if events & EVENT_READ:
-                events_mask |= select.EPOLLIN
-            if events & EVENT_WRITE:
-                events_mask |= select.EPOLLOUT
-            _syscall_wrapper(self._epoll.register, False, key.fd, events_mask)
-            return key
-
-        def unregister(self, fileobj):
-            key = super(EpollSelector, self).unregister(fileobj)
-            try:
-                _syscall_wrapper(self._epoll.unregister, False, key.fd)
-            except SelectorError:
-                # This can occur when the fd was closed since registry.
-                pass
-            return key
-
-        def select(self, timeout=None):
-            if timeout is not None:
-                if timeout <= 0:
-                    timeout = 0.0
-                else:
-                    # select.epoll.poll() has a resolution of 1 millisecond
-                    # but luckily takes seconds so we don't need a wrapper
-                    # like PollSelector. Just for better rounding.
-                    timeout = math.ceil(timeout * 1e3) * 1e-3
-                timeout = float(timeout)
-            else:
-                timeout = -1.0  # epoll.poll() must have a float.
-
-            # We always want at least 1 to ensure that select can be called
-            # with no file descriptors registered. Otherwise will fail.
-            max_events = max(len(self._fd_to_key), 1)
-
-            ready = []
-            fd_events = _syscall_wrapper(self._epoll.poll, True,
-                                         timeout=timeout,
-                                         maxevents=max_events)
-            for fd, event_mask in fd_events:
-                events = 0
-                if event_mask & ~select.EPOLLIN:
-                    events |= EVENT_WRITE
-                if event_mask & ~select.EPOLLOUT:
-                    events |= EVENT_READ
-
-                key = self._key_from_fd(fd)
-                if key:
-                    ready.append((key, events & key.events))
-            return ready
-
-        def close(self):
-            self._epoll.close()
-            super(EpollSelector, self).close()
-
-
-if hasattr(select, "kqueue"):
-    class KqueueSelector(BaseSelector):
-        """ Kqueue / Kevent-based selector """
-        def __init__(self):
-            super(KqueueSelector, self).__init__()
-            self._kqueue = select.kqueue()
-
-        def fileno(self):
-            return self._kqueue.fileno()
-
-        def register(self, fileobj, events, data=None):
-            key = super(KqueueSelector, self).register(fileobj, events, data)
-            if events & EVENT_READ:
-                kevent = select.kevent(key.fd,
-                                       select.KQ_FILTER_READ,
-                                       select.KQ_EV_ADD)
-
-                _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
-
-            if events & EVENT_WRITE:
-                kevent = select.kevent(key.fd,
-                                       select.KQ_FILTER_WRITE,
-                                       select.KQ_EV_ADD)
-
-                _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
-
-            return key
-
-        def unregister(self, fileobj):
-            key = super(KqueueSelector, self).unregister(fileobj)
-            if key.events & EVENT_READ:
-                kevent = select.kevent(key.fd,
-                                       select.KQ_FILTER_READ,
-                                       select.KQ_EV_DELETE)
-                try:
-                    _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
-                except SelectorError:
-                    pass
-            if key.events & EVENT_WRITE:
-                kevent = select.kevent(key.fd,
-                                       select.KQ_FILTER_WRITE,
-                                       select.KQ_EV_DELETE)
-                try:
-                    _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
-                except SelectorError:
-                    pass
-
-            return key
-
-        def select(self, timeout=None):
-            if timeout is not None:
-                timeout = max(timeout, 0)
-
-            max_events = len(self._fd_to_key) * 2
-            ready_fds = {}
-
-            kevent_list = _syscall_wrapper(self._kqueue.control, True,
-                                           None, max_events, timeout)
-
-            for kevent in kevent_list:
-                fd = kevent.ident
-                event_mask = kevent.filter
-                events = 0
-                if event_mask == select.KQ_FILTER_READ:
-                    events |= EVENT_READ
-                if event_mask == select.KQ_FILTER_WRITE:
-                    events |= EVENT_WRITE
-
-                key = self._key_from_fd(fd)
-                if key:
-                    if key.fd not in ready_fds:
-                        ready_fds[key.fd] = (key, events & key.events)
-                    else:
-                        old_events = ready_fds[key.fd][1]
-                        ready_fds[key.fd] = (key, (events | old_events) & key.events)
-
-            return list(ready_fds.values())
-
-        def close(self):
-            self._kqueue.close()
-            super(KqueueSelector, self).close()
-
-
-if not hasattr(select, 'select'):  # Platform-specific: AppEngine
-    HAS_SELECT = False
-
-
-def _can_allocate(struct):
-    """ Checks that select structs can be allocated by the underlying
-    operating system, not just advertised by the select module. We don't
-    check select() because we'll be hopeful that most platforms that
-    don't have it available will not advertise it. (ie: GAE) """
-    try:
-        # select.poll() objects won't fail until used.
-        if struct == 'poll':
-            p = select.poll()
-            p.poll(0)
-
-        # All others will fail on allocation.
-        else:
-            getattr(select, struct)().close()
-        return True
-    except (OSError, AttributeError) as e:
-        return False
-
-
-# Choose the best implementation, roughly:
-# kqueue == epoll > poll > select. Devpoll not supported. (See above)
-# select() also can't accept a FD > FD_SETSIZE (usually around 1024)
-def DefaultSelector():
-    """ This function serves as a first call for DefaultSelector to
-    detect if the select module is being monkey-patched incorrectly
-    by eventlet, greenlet, and preserve proper behavior. """
-    global _DEFAULT_SELECTOR
-    if _DEFAULT_SELECTOR is None:
-        if _can_allocate('kqueue'):
-            _DEFAULT_SELECTOR = KqueueSelector
-        elif _can_allocate('epoll'):
-            _DEFAULT_SELECTOR = EpollSelector
-        elif _can_allocate('poll'):
-            _DEFAULT_SELECTOR = PollSelector
-        elif hasattr(select, 'select'):
-            _DEFAULT_SELECTOR = SelectSelector
-        else:  # Platform-specific: AppEngine
-            raise ValueError('Platform does not have a selector')
-    return _DEFAULT_SELECTOR()

py-kms/pykms_Server.py

@@ -14,6 +14,7 @@ import socketserver
 import queue as Queue
 import selectors
 from time import monotonic as time
+
 import pykms_RpcBind, pykms_RpcRequest
 from pykms_RpcBase import rpcBase
 from pykms_Dcerpc import MSRPCHeader

py-kms/pykms_Time.py

@@ -1,174 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-  monotonic
-  ~~~~~~~~~
-
-  This module provides a ``monotonic()`` function which returns the
-  value (in fractional seconds) of a clock which never goes backwards.
-
-  On Python 3.3 or newer, ``monotonic`` will be an alias of
-  ``time.monotonic`` from the standard library. On older versions,
-  it will fall back to an equivalent implementation:
-
-  +-------------+----------------------------------------+
-  | Linux, BSD  | ``clock_gettime(3)``                   |
-  +-------------+----------------------------------------+
-  | Windows     | ``GetTickCount`` or ``GetTickCount64`` |
-  +-------------+----------------------------------------+
-  | OS X        | ``mach_absolute_time``                 |
-  +-------------+----------------------------------------+
-
-  If no suitable implementation exists for the current platform,
-  attempting to import this module (or to import from it) will
-  cause a ``RuntimeError`` exception to be raised.
-
-
-  Copyright 2014, 2015, 2016 Ori Livneh <ori@wikimedia.org>
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-  
-  link: https://github.com/atdt/monotonic/blob/master/monotonic.py
-
-"""
-
-import time
-
-
-__all__ = ('monotonic',)
-
-
-try:
-    monotonic = time.monotonic
-except AttributeError:
-    import ctypes
-    import ctypes.util
-    import os
-    import sys
-    import threading
-    try:
-        if sys.platform == 'darwin':  # OS X, iOS
-            # See Technical Q&A QA1398 of the Mac Developer Library:
-            #  <https://developer.apple.com/library/mac/qa/qa1398/>
-            libc = ctypes.CDLL('/usr/lib/libc.dylib', use_errno=True)
-
-            class mach_timebase_info_data_t(ctypes.Structure):
-                """System timebase info. Defined in <mach/mach_time.h>."""
-                _fields_ = (('numer', ctypes.c_uint32),
-                            ('denom', ctypes.c_uint32))
-
-            mach_absolute_time = libc.mach_absolute_time
-            mach_absolute_time.restype = ctypes.c_uint64
-
-            timebase = mach_timebase_info_data_t()
-            libc.mach_timebase_info(ctypes.byref(timebase))
-            ticks_per_second = timebase.numer / timebase.denom * 1.0e9
-
-            def monotonic():
-                """Monotonic clock, cannot go backward."""
-                return mach_absolute_time() / ticks_per_second
-
-        elif sys.platform.startswith('win32') or sys.platform.startswith('cygwin'):
-            if sys.platform.startswith('cygwin'):
-                # Note: cygwin implements clock_gettime (CLOCK_MONOTONIC = 4) since
-                # version 1.7.6. Using raw WinAPI for maximum version compatibility.
-
-                # Ugly hack using the wrong calling convention (in 32-bit mode) 
-                # because ctypes has no windll under cygwin (and it also seems that 
-                # the code letting you select stdcall in _ctypes doesn't exist under 
-                # the preprocessor definitions relevant to cygwin).
-                # This is 'safe' because:
-                # 1. The ABI of GetTickCount and GetTickCount64 is identical for 
-                #    both calling conventions because they both have no parameters.
-                # 2. libffi masks the problem because after making the call it doesn't
-                #    touch anything through esp and epilogue code restores a correct
-                #    esp from ebp afterwards.
-                try:
-                    kernel32 = ctypes.cdll.kernel32
-                except OSError:  # 'No such file or directory'
-                    kernel32 = ctypes.cdll.LoadLibrary('kernel32.dll')
-            else:
-                kernel32 = ctypes.windll.kernel32
-
-            GetTickCount64 = getattr(kernel32, 'GetTickCount64', None)
-            if GetTickCount64:
-                # Windows Vista / Windows Server 2008 or newer.
-                GetTickCount64.restype = ctypes.c_ulonglong
-
-                def monotonic():
-                    """Monotonic clock, cannot go backward."""
-                    return GetTickCount64() / 1000.0
-
-            else:
-                # Before Windows Vista.
-                GetTickCount = kernel32.GetTickCount
-                GetTickCount.restype = ctypes.c_uint32
-
-                get_tick_count_lock = threading.Lock()
-                get_tick_count_last_sample = 0
-                get_tick_count_wraparounds = 0
-
-                def monotonic():
-                    """Monotonic clock, cannot go backward."""
-                    global get_tick_count_last_sample
-                    global get_tick_count_wraparounds
-
-                    with get_tick_count_lock:
-                        current_sample = GetTickCount()
-                        if current_sample < get_tick_count_last_sample:
-                            get_tick_count_wraparounds += 1
-                        get_tick_count_last_sample = current_sample
-
-                        final_milliseconds = get_tick_count_wraparounds << 32
-                        final_milliseconds += get_tick_count_last_sample
-                        return final_milliseconds / 1000.0
-
-        else:
-            try:
-                clock_gettime = ctypes.CDLL(ctypes.util.find_library('c'),
-                                            use_errno=True).clock_gettime
-            except Exception:
-                clock_gettime = ctypes.CDLL(ctypes.util.find_library('rt'),
-                                            use_errno=True).clock_gettime
-
-            class timespec(ctypes.Structure):
-                """Time specification, as described in clock_gettime(3)."""
-                _fields_ = (('tv_sec', ctypes.c_long),
-                            ('tv_nsec', ctypes.c_long))
-
-            if sys.platform.startswith('linux'):
-                CLOCK_MONOTONIC = 1
-            elif sys.platform.startswith('freebsd'):
-                CLOCK_MONOTONIC = 4
-            elif sys.platform.startswith('sunos5'):
-                CLOCK_MONOTONIC = 4
-            elif 'bsd' in sys.platform:
-                CLOCK_MONOTONIC = 3
-            elif sys.platform.startswith('aix'):
-                CLOCK_MONOTONIC = ctypes.c_longlong(10)
-
-            def monotonic():
-                """Monotonic clock, cannot go backward."""
-                ts = timespec()
-                if clock_gettime(CLOCK_MONOTONIC, ctypes.pointer(ts)):
-                    errno = ctypes.get_errno()
-                    raise OSError(errno, os.strerror(errno))
-                return ts.tv_sec + ts.tv_nsec / 1.0e9
-
-        # Perform a sanity-check.
-        if monotonic() - monotonic() > 0:
-            raise ValueError('monotonic() is not monotonic!')
-
-    except Exception as e:
-        raise RuntimeError('no suitable implementation for this system: ' + repr(e))