1 files changed, 155 insertions, 0 deletions
diff --git a/.emacs.d.back/.python-environments/default/lib/python3.7/site-packages/epc/utils.py b/.emacs.d.back/.python-environments/default/lib/python3.7/site-packages/epc/utils.py
new file mode 100644
index 00000000..ec3570c4
--- /dev/null
+++ b/.emacs.d.back/.python-environments/default/lib/python3.7/site-packages/epc/utils.py
@@ -0,0 +1,155 @@
+# Copyright (C) 2012-  Takafumi Arakaki
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import logging
+import itertools
+import functools
+import threading
+import warnings
+
+from .py3compat import Queue
+
+
+def func_call_as_str(name, *args, **kwds):
+    """
+    Return arguments and keyword arguments as formatted string
+
+    >>> func_call_as_str('f', 1, 2, a=1)
+    'f(1, 2, a=1)'
+
+    """
+    return '{0}({1})'.format(
+        name,
+        ', '.join(itertools.chain(
+            map('{0!r}'.format, args),
+            map('{0[0]!s}={0[1]!r}'.format, sorted(kwds.items())))))
+
+
+def autolog(level):
+    if isinstance(level, str):
+        level = getattr(logging, level.upper())
+
+    def wrapper(method):
+        @functools.wraps(method)
+        def new_method(self, *args, **kwds):
+            funcname = ".".join([self.__class__.__name__, method.__name__])
+            self.logger.log(level, "(AutoLog) Called: %s",
+                            func_call_as_str(funcname, *args, **kwds))
+            ret = method(self, *args, **kwds)
+            self.logger.log(level, "(AutoLog) Returns: %s(...) = %r",
+                            funcname, ret)
+            return ret
+        return new_method
+    return wrapper
+
+
+def deprecated(func):
+    """
+    Decorator for marking function as deprecated
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        warnings.warn(
+            '{0} is deprecated.'.format(func.__name__),
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        return func(*args, **kwargs)
+    return wrapper
+
+
+def newname(template):
+    global _counter
+    _counter = _counter + 1
+    return template.format(_counter)
+_counter = 0
+
+
+def newthread(template="EPCThread-{0}", **kwds):
+    """
+    Instantiate :class:`threading.Thread` with an appropriate name.
+    """
+    if not isinstance(template, str):
+        template = '{0}.{1}-{{0}}'.format(template.__module__,
+                                          template.__class__.__name__)
+    return threading.Thread(
+        name=newname(template), **kwds)
+
+
+class ThreadedIterator(object):
+
+    def __init__(self, iterable):
+        self._original_iterable = iterable
+        self.queue = Queue.Queue()
+        self.thread = newthread(self, target=self._target)
+        self.thread.daemon = True
+        self._sentinel = object()
+        self.thread.start()
+
+    def _target(self):
+        for result in self._original_iterable:
+            self.queue.put(result)
+        self.stop()
+
+    def stop(self):
+        self.queue.put(self._sentinel)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        got = self.queue.get()
+        if got is self._sentinel:
+            raise StopIteration
+        return got
+    next = __next__  # for PY2
+
+
+def callwith(context_manager):
+    """
+    A decorator to wrap execution of function with a context manager.
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwds):
+            with context_manager:
+                return func(*args, **kwds)
+        return wrapper
+    return decorator
+
+
+def _define_thread_safe_methods(methodnames, lockname):
+    def define(cls, name):
+        def wrapper(self, *args, **kwds):
+            with getattr(self, lockname):
+                return method(self, *args, **kwds)
+        method = getattr(cls, name)
+        setattr(cls, name, wrapper)
+
+    def decorator(cls):
+        for name in methodnames:
+            define(cls, name)
+        return cls
+    return decorator
+
+
+@_define_thread_safe_methods(
+    ['__getitem__', '__setitem__', '__delitem__', 'pop'], '_lock')
+class LockingDict(dict):
+
+    def __init__(self, *args, **kwds):
+        super(LockingDict, self).__init__(*args, **kwds)
+        self._lock = threading.Lock()