com.googler.python 1.1.2 → 1.1.4

package/python3.6.2/lib/python3.6/rlcompleter.py

@@ -1,205 +0,0 @@
-"""Word completion for GNU readline.
-
-The completer completes keywords, built-ins and globals in a selectable
-namespace (which defaults to __main__); when completing NAME.NAME..., it
-evaluates (!) the expression up to the last dot and completes its attributes.
-
-It's very cool to do "import sys" type "sys.", hit the completion key (twice),
-and see the list of names defined by the sys module!
-
-Tip: to use the tab key as the completion key, call
-
-    readline.parse_and_bind("tab: complete")
-
-Notes:
-
-- Exceptions raised by the completer function are *ignored* (and generally cause
-  the completion to fail).  This is a feature -- since readline sets the tty
-  device in raw (or cbreak) mode, printing a traceback wouldn't work well
-  without some complicated hoopla to save, reset and restore the tty state.
-
-- The evaluation of the NAME.NAME... form may cause arbitrary application
-  defined code to be executed if an object with a __getattr__ hook is found.
-  Since it is the responsibility of the application (or the user) to enable this
-  feature, I consider this an acceptable risk.  More complicated expressions
-  (e.g. function calls or indexing operations) are *not* evaluated.
-
-- When the original stdin is not a tty device, GNU readline is never
-  used, and this module (and the readline module) are silently inactive.
-
-"""
-
-import atexit
-import builtins
-import __main__
-
-__all__ = ["Completer"]
-
-class Completer:
-    def __init__(self, namespace = None):
-        """Create a new completer for the command line.
-
-        Completer([namespace]) -> completer instance.
-
-        If unspecified, the default namespace where completions are performed
-        is __main__ (technically, __main__.__dict__). Namespaces should be
-        given as dictionaries.
-
-        Completer instances should be used as the completion mechanism of
-        readline via the set_completer() call:
-
-        readline.set_completer(Completer(my_namespace).complete)
-        """
-
-        if namespace and not isinstance(namespace, dict):
-            raise TypeError('namespace must be a dictionary')
-
-        # Don't bind to namespace quite yet, but flag whether the user wants a
-        # specific namespace or to use __main__.__dict__. This will allow us
-        # to bind to __main__.__dict__ at completion time, not now.
-        if namespace is None:
-            self.use_main_ns = 1
-        else:
-            self.use_main_ns = 0
-            self.namespace = namespace
-
-    def complete(self, text, state):
-        """Return the next possible completion for 'text'.
-
-        This is called successively with state == 0, 1, 2, ... until it
-        returns None.  The completion should begin with 'text'.
-
-        """
-        if self.use_main_ns:
-            self.namespace = __main__.__dict__
-
-        if not text.strip():
-            if state == 0:
-                if _readline_available:
-                    readline.insert_text('\t')
-                    readline.redisplay()
-                    return ''
-                else:
-                    return '\t'
-            else:
-                return None
-
-        if state == 0:
-            if "." in text:
-                self.matches = self.attr_matches(text)
-            else:
-                self.matches = self.global_matches(text)
-        try:
-            return self.matches[state]
-        except IndexError:
-            return None
-
-    def _callable_postfix(self, val, word):
-        if callable(val):
-            word = word + "("
-        return word
-
-    def global_matches(self, text):
-        """Compute matches when text is a simple name.
-
-        Return a list of all keywords, built-in functions and names currently
-        defined in self.namespace that match.
-
-        """
-        import keyword
-        matches = []
-        seen = {"__builtins__"}
-        n = len(text)
-        for word in keyword.kwlist:
-            if word[:n] == text:
-                seen.add(word)
-                if word in {'finally', 'try'}:
-                    word = word + ':'
-                elif word not in {'False', 'None', 'True',
-                                  'break', 'continue', 'pass',
-                                  'else'}:
-                    word = word + ' '
-                matches.append(word)
-        for nspace in [self.namespace, builtins.__dict__]:
-            for word, val in nspace.items():
-                if word[:n] == text and word not in seen:
-                    seen.add(word)
-                    matches.append(self._callable_postfix(val, word))
-        return matches
-
-    def attr_matches(self, text):
-        """Compute matches when text contains a dot.
-
-        Assuming the text is of the form NAME.NAME....[NAME], and is
-        evaluable in self.namespace, it will be evaluated and its attributes
-        (as revealed by dir()) are used as possible completions.  (For class
-        instances, class members are also considered.)
-
-        WARNING: this can still invoke arbitrary C code, if an object
-        with a __getattr__ hook is evaluated.
-
-        """
-        import re
-        m = re.match(r"(\w+(\.\w+)*)\.(\w*)", text)
-        if not m:
-            return []
-        expr, attr = m.group(1, 3)
-        try:
-            thisobject = eval(expr, self.namespace)
-        except Exception:
-            return []
-
-        # get the content of the object, except __builtins__
-        words = set(dir(thisobject))
-        words.discard("__builtins__")
-
-        if hasattr(thisobject, '__class__'):
-            words.add('__class__')
-            words.update(get_class_members(thisobject.__class__))
-        matches = []
-        n = len(attr)
-        if attr == '':
-            noprefix = '_'
-        elif attr == '_':
-            noprefix = '__'
-        else:
-            noprefix = None
-        while True:
-            for word in words:
-                if (word[:n] == attr and
-                    not (noprefix and word[:n+1] == noprefix)):
-                    match = "%s.%s" % (expr, word)
-                    try:
-                        val = getattr(thisobject, word)
-                    except Exception:
-                        pass  # Include even if attribute not set
-                    else:
-                        match = self._callable_postfix(val, match)
-                    matches.append(match)
-            if matches or not noprefix:
-                break
-            if noprefix == '_':
-                noprefix = '__'
-            else:
-                noprefix = None
-        matches.sort()
-        return matches
-
-def get_class_members(klass):
-    ret = dir(klass)
-    if hasattr(klass,'__bases__'):
-        for base in klass.__bases__:
-            ret = ret + get_class_members(base)
-    return ret
-
-try:
-    import readline
-except ImportError:
-    _readline_available = False
-else:
-    readline.set_completer(Completer().complete)
-    # Release references early at shutdown (the readline module's
-    # contents are quasi-immortal, and the completer function holds a
-    # reference to globals).
-    atexit.register(lambda: readline.set_completer(None))
-    _readline_available = True

package/python3.6.2/lib/python3.6/runpy.py

@@ -1,294 +0,0 @@
-"""runpy.py - locating and running Python code using the module namespace
-
-Provides support for locating and running Python scripts using the Python
-module namespace instead of the native filesystem.
-
-This allows Python code to play nicely with non-filesystem based PEP 302
-importers when locating support scripts as well as when importing modules.
-"""
-# Written by Nick Coghlan <ncoghlan at gmail.com>
-#    to implement PEP 338 (Executing Modules as Scripts)
-
-
-import sys
-import importlib.machinery # importlib first so we can test #15386 via -m
-import importlib.util
-import types
-from pkgutil import read_code, get_importer
-
-__all__ = [
-    "run_module", "run_path",
-]
-
-class _TempModule(object):
-    """Temporarily replace a module in sys.modules with an empty namespace"""
-    def __init__(self, mod_name):
-        self.mod_name = mod_name
-        self.module = types.ModuleType(mod_name)
-        self._saved_module = []
-
-    def __enter__(self):
-        mod_name = self.mod_name
-        try:
-            self._saved_module.append(sys.modules[mod_name])
-        except KeyError:
-            pass
-        sys.modules[mod_name] = self.module
-        return self
-
-    def __exit__(self, *args):
-        if self._saved_module:
-            sys.modules[self.mod_name] = self._saved_module[0]
-        else:
-            del sys.modules[self.mod_name]
-        self._saved_module = []
-
-class _ModifiedArgv0(object):
-    def __init__(self, value):
-        self.value = value
-        self._saved_value = self._sentinel = object()
-
-    def __enter__(self):
-        if self._saved_value is not self._sentinel:
-            raise RuntimeError("Already preserving saved value")
-        self._saved_value = sys.argv[0]
-        sys.argv[0] = self.value
-
-    def __exit__(self, *args):
-        self.value = self._sentinel
-        sys.argv[0] = self._saved_value
-
-# TODO: Replace these helpers with importlib._bootstrap_external functions.
-def _run_code(code, run_globals, init_globals=None,
-              mod_name=None, mod_spec=None,
-              pkg_name=None, script_name=None):
-    """Helper to run code in nominated namespace"""
-    if init_globals is not None:
-        run_globals.update(init_globals)
-    if mod_spec is None:
-        loader = None
-        fname = script_name
-        cached = None
-    else:
-        loader = mod_spec.loader
-        fname = mod_spec.origin
-        cached = mod_spec.cached
-        if pkg_name is None:
-            pkg_name = mod_spec.parent
-    run_globals.update(__name__ = mod_name,
-                       __file__ = fname,
-                       __cached__ = cached,
-                       __doc__ = None,
-                       __loader__ = loader,
-                       __package__ = pkg_name,
-                       __spec__ = mod_spec)
-    exec(code, run_globals)
-    return run_globals
-
-def _run_module_code(code, init_globals=None,
-                    mod_name=None, mod_spec=None,
-                    pkg_name=None, script_name=None):
-    """Helper to run code in new namespace with sys modified"""
-    fname = script_name if mod_spec is None else mod_spec.origin
-    with _TempModule(mod_name) as temp_module, _ModifiedArgv0(fname):
-        mod_globals = temp_module.module.__dict__
-        _run_code(code, mod_globals, init_globals,
-                  mod_name, mod_spec, pkg_name, script_name)
-    # Copy the globals of the temporary module, as they
-    # may be cleared when the temporary module goes away
-    return mod_globals.copy()
-
-# Helper to get the full name, spec and code for a module
-def _get_module_details(mod_name, error=ImportError):
-    if mod_name.startswith("."):
-        raise error("Relative module names not supported")
-    pkg_name, _, _ = mod_name.rpartition(".")
-    if pkg_name:
-        # Try importing the parent to avoid catching initialization errors
-        try:
-            __import__(pkg_name)
-        except ImportError as e:
-            # If the parent or higher ancestor package is missing, let the
-            # error be raised by find_spec() below and then be caught. But do
-            # not allow other errors to be caught.
-            if e.name is None or (e.name != pkg_name and
-                    not pkg_name.startswith(e.name + ".")):
-                raise
-        # Warn if the module has already been imported under its normal name
-        existing = sys.modules.get(mod_name)
-        if existing is not None and not hasattr(existing, "__path__"):
-            from warnings import warn
-            msg = "{mod_name!r} found in sys.modules after import of " \
-                "package {pkg_name!r}, but prior to execution of " \
-                "{mod_name!r}; this may result in unpredictable " \
-                "behaviour".format(mod_name=mod_name, pkg_name=pkg_name)
-            warn(RuntimeWarning(msg))
-
-    try:
-        spec = importlib.util.find_spec(mod_name)
-    except (ImportError, AttributeError, TypeError, ValueError) as ex:
-        # This hack fixes an impedance mismatch between pkgutil and
-        # importlib, where the latter raises other errors for cases where
-        # pkgutil previously raised ImportError
-        msg = "Error while finding module specification for {!r} ({}: {})"
-        raise error(msg.format(mod_name, type(ex).__name__, ex)) from ex
-    if spec is None:
-        raise error("No module named %s" % mod_name)
-    if spec.submodule_search_locations is not None:
-        if mod_name == "__main__" or mod_name.endswith(".__main__"):
-            raise error("Cannot use package as __main__ module")
-        try:
-            pkg_main_name = mod_name + ".__main__"
-            return _get_module_details(pkg_main_name, error)
-        except error as e:
-            if mod_name not in sys.modules:
-                raise  # No module loaded; being a package is irrelevant
-            raise error(("%s; %r is a package and cannot " +
-                               "be directly executed") %(e, mod_name))
-    loader = spec.loader
-    if loader is None:
-        raise error("%r is a namespace package and cannot be executed"
-                                                                 % mod_name)
-    try:
-        code = loader.get_code(mod_name)
-    except ImportError as e:
-        raise error(format(e)) from e
-    if code is None:
-        raise error("No code object available for %s" % mod_name)
-    return mod_name, spec, code
-
-class _Error(Exception):
-    """Error that _run_module_as_main() should report without a traceback"""
-
-# XXX ncoghlan: Should this be documented and made public?
-# (Current thoughts: don't repeat the mistake that lead to its
-# creation when run_module() no longer met the needs of
-# mainmodule.c, but couldn't be changed because it was public)
-def _run_module_as_main(mod_name, alter_argv=True):
-    """Runs the designated module in the __main__ namespace
-
-       Note that the executed module will have full access to the
-       __main__ namespace. If this is not desirable, the run_module()
-       function should be used to run the module code in a fresh namespace.
-
-       At the very least, these variables in __main__ will be overwritten:
-           __name__
-           __file__
-           __cached__
-           __loader__
-           __package__
-    """
-    try:
-        if alter_argv or mod_name != "__main__": # i.e. -m switch
-            mod_name, mod_spec, code = _get_module_details(mod_name, _Error)
-        else:          # i.e. directory or zipfile execution
-            mod_name, mod_spec, code = _get_main_module_details(_Error)
-    except _Error as exc:
-        msg = "%s: %s" % (sys.executable, exc)
-        sys.exit(msg)
-    main_globals = sys.modules["__main__"].__dict__
-    if alter_argv:
-        sys.argv[0] = mod_spec.origin
-    return _run_code(code, main_globals, None,
-                     "__main__", mod_spec)
-
-def run_module(mod_name, init_globals=None,
-               run_name=None, alter_sys=False):
-    """Execute a module's code without importing it
-
-       Returns the resulting top level namespace dictionary
-    """
-    mod_name, mod_spec, code = _get_module_details(mod_name)
-    if run_name is None:
-        run_name = mod_name
-    if alter_sys:
-        return _run_module_code(code, init_globals, run_name, mod_spec)
-    else:
-        # Leave the sys module alone
-        return _run_code(code, {}, init_globals, run_name, mod_spec)
-
-def _get_main_module_details(error=ImportError):
-    # Helper that gives a nicer error message when attempting to
-    # execute a zipfile or directory by invoking __main__.py
-    # Also moves the standard __main__ out of the way so that the
-    # preexisting __loader__ entry doesn't cause issues
-    main_name = "__main__"
-    saved_main = sys.modules[main_name]
-    del sys.modules[main_name]
-    try:
-        return _get_module_details(main_name)
-    except ImportError as exc:
-        if main_name in str(exc):
-            raise error("can't find %r module in %r" %
-                              (main_name, sys.path[0])) from exc
-        raise
-    finally:
-        sys.modules[main_name] = saved_main
-
-
-def _get_code_from_file(run_name, fname):
-    # Check for a compiled file first
-    with open(fname, "rb") as f:
-        code = read_code(f)
-    if code is None:
-        # That didn't work, so try it as normal source code
-        with open(fname, "rb") as f:
-            code = compile(f.read(), fname, 'exec')
-    return code, fname
-
-def run_path(path_name, init_globals=None, run_name=None):
-    """Execute code located at the specified filesystem location
-
-       Returns the resulting top level namespace dictionary
-
-       The file path may refer directly to a Python script (i.e.
-       one that could be directly executed with execfile) or else
-       it may refer to a zipfile or directory containing a top
-       level __main__.py script.
-    """
-    if run_name is None:
-        run_name = "<run_path>"
-    pkg_name = run_name.rpartition(".")[0]
-    importer = get_importer(path_name)
-    # Trying to avoid importing imp so as to not consume the deprecation warning.
-    is_NullImporter = False
-    if type(importer).__module__ == 'imp':
-        if type(importer).__name__ == 'NullImporter':
-            is_NullImporter = True
-    if isinstance(importer, type(None)) or is_NullImporter:
-        # Not a valid sys.path entry, so run the code directly
-        # execfile() doesn't help as we want to allow compiled files
-        code, fname = _get_code_from_file(run_name, path_name)
-        return _run_module_code(code, init_globals, run_name,
-                                pkg_name=pkg_name, script_name=fname)
-    else:
-        # Finder is defined for path, so add it to
-        # the start of sys.path
-        sys.path.insert(0, path_name)
-        try:
-            # Here's where things are a little different from the run_module
-            # case. There, we only had to replace the module in sys while the
-            # code was running and doing so was somewhat optional. Here, we
-            # have no choice and we have to remove it even while we read the
-            # code. If we don't do this, a __loader__ attribute in the
-            # existing __main__ module may prevent location of the new module.
-            mod_name, mod_spec, code = _get_main_module_details()
-            with _TempModule(run_name) as temp_module, \
-                 _ModifiedArgv0(path_name):
-                mod_globals = temp_module.module.__dict__
-                return _run_code(code, mod_globals, init_globals,
-                                    run_name, mod_spec, pkg_name).copy()
-        finally:
-            try:
-                sys.path.remove(path_name)
-            except ValueError:
-                pass
-
-
-if __name__ == "__main__":
-    # Run the module specified as the next command line argument
-    if len(sys.argv) < 2:
-        print("No module specified for execution", file=sys.stderr)
-    else:
-        del sys.argv[0] # Make the requested module sys.argv[0]
-        _run_module_as_main(sys.argv[0])

package/python3.6.2/lib/python3.6/sched.py

@@ -1,170 +0,0 @@
-"""A generally useful event scheduler class.
-
-Each instance of this class manages its own queue.
-No multi-threading is implied; you are supposed to hack that
-yourself, or use a single instance per application.
-
-Each instance is parametrized with two functions, one that is
-supposed to return the current time, one that is supposed to
-implement a delay.  You can implement real-time scheduling by
-substituting time and sleep from built-in module time, or you can
-implement simulated time by writing your own functions.  This can
-also be used to integrate scheduling with STDWIN events; the delay
-function is allowed to modify the queue.  Time can be expressed as
-integers or floating point numbers, as long as it is consistent.
-
-Events are specified by tuples (time, priority, action, argument, kwargs).
-As in UNIX, lower priority numbers mean higher priority; in this
-way the queue can be maintained as a priority queue.  Execution of the
-event means calling the action function, passing it the argument
-sequence in "argument" (remember that in Python, multiple function
-arguments are be packed in a sequence) and keyword parameters in "kwargs".
-The action function may be an instance method so it
-has another way to reference private data (besides global variables).
-"""
-
-import time
-import heapq
-from collections import namedtuple
-try:
-    import threading
-except ImportError:
-    import dummy_threading as threading
-from time import monotonic as _time
-
-__all__ = ["scheduler"]
-
-class Event(namedtuple('Event', 'time, priority, action, argument, kwargs')):
-    __slots__ = []
-    def __eq__(s, o): return (s.time, s.priority) == (o.time, o.priority)
-    def __lt__(s, o): return (s.time, s.priority) <  (o.time, o.priority)
-    def __le__(s, o): return (s.time, s.priority) <= (o.time, o.priority)
-    def __gt__(s, o): return (s.time, s.priority) >  (o.time, o.priority)
-    def __ge__(s, o): return (s.time, s.priority) >= (o.time, o.priority)
-
-Event.time.__doc__ = ('''Numeric type compatible with the return value of the
-timefunc function passed to the constructor.''')
-Event.priority.__doc__ = ('''Events scheduled for the same time will be executed
-in the order of their priority.''')
-Event.action.__doc__ = ('''Executing the event means executing
-action(*argument, **kwargs)''')
-Event.argument.__doc__ = ('''argument is a sequence holding the positional
-arguments for the action.''')
-Event.kwargs.__doc__ = ('''kwargs is a dictionary holding the keyword
-arguments for the action.''')
-
-_sentinel = object()
-
-class scheduler:
-
-    def __init__(self, timefunc=_time, delayfunc=time.sleep):
-        """Initialize a new instance, passing the time and delay
-        functions"""
-        self._queue = []
-        self._lock = threading.RLock()
-        self.timefunc = timefunc
-        self.delayfunc = delayfunc
-
-    def enterabs(self, time, priority, action, argument=(), kwargs=_sentinel):
-        """Enter a new event in the queue at an absolute time.
-
-        Returns an ID for the event which can be used to remove it,
-        if necessary.
-
-        """
-        if kwargs is _sentinel:
-            kwargs = {}
-        event = Event(time, priority, action, argument, kwargs)
-        with self._lock:
-            heapq.heappush(self._queue, event)
-        return event # The ID
-
-    def enter(self, delay, priority, action, argument=(), kwargs=_sentinel):
-        """A variant that specifies the time as a relative time.
-
-        This is actually the more commonly used interface.
-
-        """
-        time = self.timefunc() + delay
-        return self.enterabs(time, priority, action, argument, kwargs)
-
-    def cancel(self, event):
-        """Remove an event from the queue.
-
-        This must be presented the ID as returned by enter().
-        If the event is not in the queue, this raises ValueError.
-
-        """
-        with self._lock:
-            self._queue.remove(event)
-            heapq.heapify(self._queue)
-
-    def empty(self):
-        """Check whether the queue is empty."""
-        with self._lock:
-            return not self._queue
-
-    def run(self, blocking=True):
-        """Execute events until the queue is empty.
-        If blocking is False executes the scheduled events due to
-        expire soonest (if any) and then return the deadline of the
-        next scheduled call in the scheduler.
-
-        When there is a positive delay until the first event, the
-        delay function is called and the event is left in the queue;
-        otherwise, the event is removed from the queue and executed
-        (its action function is called, passing it the argument).  If
-        the delay function returns prematurely, it is simply
-        restarted.
-
-        It is legal for both the delay function and the action
-        function to modify the queue or to raise an exception;
-        exceptions are not caught but the scheduler's state remains
-        well-defined so run() may be called again.
-
-        A questionable hack is added to allow other threads to run:
-        just after an event is executed, a delay of 0 is executed, to
-        avoid monopolizing the CPU when other threads are also
-        runnable.
-
-        """
-        # localize variable access to minimize overhead
-        # and to improve thread safety
-        lock = self._lock
-        q = self._queue
-        delayfunc = self.delayfunc
-        timefunc = self.timefunc
-        pop = heapq.heappop
-        while True:
-            with lock:
-                if not q:
-                    break
-                time, priority, action, argument, kwargs = q[0]
-                now = timefunc()
-                if time > now:
-                    delay = True
-                else:
-                    delay = False
-                    pop(q)
-            if delay:
-                if not blocking:
-                    return time - now
-                delayfunc(time - now)
-            else:
-                action(*argument, **kwargs)
-                delayfunc(0)   # Let other threads run
-
-    @property
-    def queue(self):
-        """An ordered list of upcoming events.
-
-        Events are named tuples with fields for:
-            time, priority, action, arguments, kwargs
-
-        """
-        # Use heapq to sort the queue rather than using 'sorted(self._queue)'.
-        # With heapq, two events scheduled at the same time will show in
-        # the actual order they would be retrieved.
-        with self._lock:
-            events = self._queue[:]
-        return list(map(heapq.heappop, [events]*len(events)))