diff options
Diffstat (limited to 'vim/bundle/YouCompleteMe/third_party')
33 files changed, 0 insertions, 3295 deletions
diff --git a/vim/bundle/YouCompleteMe b/vim/bundle/YouCompleteMe new file mode 160000 +Subproject 0de1c0c9bb13ce82172b472c676035cd47cf6a6 diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/CHANGES b/vim/bundle/YouCompleteMe/third_party/pythonfutures/CHANGES deleted file mode 100755 index 81df636..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/CHANGES +++ /dev/null @@ -1,44 +0,0 @@ -2.1.4 -===== - -- Ported the library again from Python 3.2.5 to get the latest bug fixes - - -2.1.3 -===== - -- Fixed race condition in wait(return_when=ALL_COMPLETED) - (http://bugs.python.org/issue14406) -- thanks Ralf Schmitt -- Added missing setUp() methods to several test classes - - -2.1.2 -===== - -- Fixed installation problem on Python 3.1 - - -2.1.1 -===== - -- Fixed missing 'concurrent' package declaration in setup.py - - -2.1 -=== - -- Moved the code from the 'futures' package to 'concurrent.futures' to provide - a drop in backport that matches the code in Python 3.2 standard library -- Deprecated the old 'futures' package - - -2.0 -=== - -- Changed implementation to match PEP 3148 - - -1.0 -=== - -Initial release. diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/LICENSE b/vim/bundle/YouCompleteMe/third_party/pythonfutures/LICENSE deleted file mode 100755 index c430db0..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -Copyright 2009 Brian Quinlan. All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - 2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -THIS SOFTWARE IS PROVIDED BY BRIAN QUINLAN "AS IS" AND ANY EXPRESS OR IMPLIED -WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT -HALL THE FREEBSD PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, -INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE -OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/__init__.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/__init__.py deleted file mode 100755 index b36383a..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from pkgutil import extend_path - -__path__ = extend_path(__path__, __name__) diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/__init__.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/__init__.py deleted file mode 100755 index b5231f8..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/__init__.py +++ /dev/null @@ -1,18 +0,0 @@ -# Copyright 2009 Brian Quinlan. All Rights Reserved. -# Licensed to PSF under a Contributor Agreement. - -"""Execute computations asynchronously using threads or processes.""" - -__author__ = 'Brian Quinlan (brian@sweetapp.com)' - -from concurrent.futures._base import (FIRST_COMPLETED, - FIRST_EXCEPTION, - ALL_COMPLETED, - CancelledError, - TimeoutError, - Future, - Executor, - wait, - as_completed) -from concurrent.futures.process import ProcessPoolExecutor -from concurrent.futures.thread import ThreadPoolExecutor diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/_base.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/_base.py deleted file mode 100755 index 8ed69b7..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/_base.py +++ /dev/null @@ -1,574 +0,0 @@ -# Copyright 2009 Brian Quinlan. All Rights Reserved. -# Licensed to PSF under a Contributor Agreement. - -from __future__ import with_statement -import logging -import threading -import time - -try: - from collections import namedtuple -except ImportError: - from concurrent.futures._compat import namedtuple - -__author__ = 'Brian Quinlan (brian@sweetapp.com)' - -FIRST_COMPLETED = 'FIRST_COMPLETED' -FIRST_EXCEPTION = 'FIRST_EXCEPTION' -ALL_COMPLETED = 'ALL_COMPLETED' -_AS_COMPLETED = '_AS_COMPLETED' - -# Possible future states (for internal use by the futures package). -PENDING = 'PENDING' -RUNNING = 'RUNNING' -# The future was cancelled by the user... -CANCELLED = 'CANCELLED' -# ...and _Waiter.add_cancelled() was called by a worker. -CANCELLED_AND_NOTIFIED = 'CANCELLED_AND_NOTIFIED' -FINISHED = 'FINISHED' - -_FUTURE_STATES = [ - PENDING, - RUNNING, - CANCELLED, - CANCELLED_AND_NOTIFIED, - FINISHED -] - -_STATE_TO_DESCRIPTION_MAP = { - PENDING: "pending", - RUNNING: "running", - CANCELLED: "cancelled", - CANCELLED_AND_NOTIFIED: "cancelled", - FINISHED: "finished" -} - -# Logger for internal use by the futures package. -LOGGER = logging.getLogger("concurrent.futures") - -class Error(Exception): - """Base class for all future-related exceptions.""" - pass - -class CancelledError(Error): - """The Future was cancelled.""" - pass - -class TimeoutError(Error): - """The operation exceeded the given deadline.""" - pass - -class _Waiter(object): - """Provides the event that wait() and as_completed() block on.""" - def __init__(self): - self.event = threading.Event() - self.finished_futures = [] - - def add_result(self, future): - self.finished_futures.append(future) - - def add_exception(self, future): - self.finished_futures.append(future) - - def add_cancelled(self, future): - self.finished_futures.append(future) - -class _AsCompletedWaiter(_Waiter): - """Used by as_completed().""" - - def __init__(self): - super(_AsCompletedWaiter, self).__init__() - self.lock = threading.Lock() - - def add_result(self, future): - with self.lock: - super(_AsCompletedWaiter, self).add_result(future) - self.event.set() - - def add_exception(self, future): - with self.lock: - super(_AsCompletedWaiter, self).add_exception(future) - self.event.set() - - def add_cancelled(self, future): - with self.lock: - super(_AsCompletedWaiter, self).add_cancelled(future) - self.event.set() - -class _FirstCompletedWaiter(_Waiter): - """Used by wait(return_when=FIRST_COMPLETED).""" - - def add_result(self, future): - super(_FirstCompletedWaiter, self).add_result(future) - self.event.set() - - def add_exception(self, future): - super(_FirstCompletedWaiter, self).add_exception(future) - self.event.set() - - def add_cancelled(self, future): - super(_FirstCompletedWaiter, self).add_cancelled(future) - self.event.set() - -class _AllCompletedWaiter(_Waiter): - """Used by wait(return_when=FIRST_EXCEPTION and ALL_COMPLETED).""" - - def __init__(self, num_pending_calls, stop_on_exception): - self.num_pending_calls = num_pending_calls - self.stop_on_exception = stop_on_exception - self.lock = threading.Lock() - super(_AllCompletedWaiter, self).__init__() - - def _decrement_pending_calls(self): - with self.lock: - self.num_pending_calls -= 1 - if not self.num_pending_calls: - self.event.set() - - def add_result(self, future): - super(_AllCompletedWaiter, self).add_result(future) - self._decrement_pending_calls() - - def add_exception(self, future): - super(_AllCompletedWaiter, self).add_exception(future) - if self.stop_on_exception: - self.event.set() - else: - self._decrement_pending_calls() - - def add_cancelled(self, future): - super(_AllCompletedWaiter, self).add_cancelled(future) - self._decrement_pending_calls() - -class _AcquireFutures(object): - """A context manager that does an ordered acquire of Future conditions.""" - - def __init__(self, futures): - self.futures = sorted(futures, key=id) - - def __enter__(self): - for future in self.futures: - future._condition.acquire() - - def __exit__(self, *args): - for future in self.futures: - future._condition.release() - -def _create_and_install_waiters(fs, return_when): - if return_when == _AS_COMPLETED: - waiter = _AsCompletedWaiter() - elif return_when == FIRST_COMPLETED: - waiter = _FirstCompletedWaiter() - else: - pending_count = sum( - f._state not in [CANCELLED_AND_NOTIFIED, FINISHED] for f in fs) - - if return_when == FIRST_EXCEPTION: - waiter = _AllCompletedWaiter(pending_count, stop_on_exception=True) - elif return_when == ALL_COMPLETED: - waiter = _AllCompletedWaiter(pending_count, stop_on_exception=False) - else: - raise ValueError("Invalid return condition: %r" % return_when) - - for f in fs: - f._waiters.append(waiter) - - return waiter - -def as_completed(fs, timeout=None): - """An iterator over the given futures that yields each as it completes. - - Args: - fs: The sequence of Futures (possibly created by different Executors) to - iterate over. - timeout: The maximum number of seconds to wait. If None, then there - is no limit on the wait time. - - Returns: - An iterator that yields the given Futures as they complete (finished or - cancelled). - - Raises: - TimeoutError: If the entire result iterator could not be generated - before the given timeout. - """ - if timeout is not None: - end_time = timeout + time.time() - - with _AcquireFutures(fs): - finished = set( - f for f in fs - if f._state in [CANCELLED_AND_NOTIFIED, FINISHED]) - pending = set(fs) - finished - waiter = _create_and_install_waiters(fs, _AS_COMPLETED) - - try: - for future in finished: - yield future - - while pending: - if timeout is None: - wait_timeout = None - else: - wait_timeout = end_time - time.time() - if wait_timeout < 0: - raise TimeoutError( - '%d (of %d) futures unfinished' % ( - len(pending), len(fs))) - - waiter.event.wait(wait_timeout) - - with waiter.lock: - finished = waiter.finished_futures - waiter.finished_futures = [] - waiter.event.clear() - - for future in finished: - yield future - pending.remove(future) - - finally: - for f in fs: - f._waiters.remove(waiter) - -DoneAndNotDoneFutures = namedtuple( - 'DoneAndNotDoneFutures', 'done not_done') -def wait(fs, timeout=None, return_when=ALL_COMPLETED): - """Wait for the futures in the given sequence to complete. - - Args: - fs: The sequence of Futures (possibly created by different Executors) to - wait upon. - timeout: The maximum number of seconds to wait. If None, then there - is no limit on the wait time. - return_when: Indicates when this function should return. The options - are: - - FIRST_COMPLETED - Return when any future finishes or is - cancelled. - FIRST_EXCEPTION - Return when any future finishes by raising an - exception. If no future raises an exception - then it is equivalent to ALL_COMPLETED. - ALL_COMPLETED - Return when all futures finish or are cancelled. - - Returns: - A named 2-tuple of sets. The first set, named 'done', contains the - futures that completed (is finished or cancelled) before the wait - completed. The second set, named 'not_done', contains uncompleted - futures. - """ - with _AcquireFutures(fs): - done = set(f for f in fs - if f._state in [CANCELLED_AND_NOTIFIED, FINISHED]) - not_done = set(fs) - done - - if (return_when == FIRST_COMPLETED) and done: - return DoneAndNotDoneFutures(done, not_done) - elif (return_when == FIRST_EXCEPTION) and done: - if any(f for f in done - if not f.cancelled() and f.exception() is not None): - return DoneAndNotDoneFutures(done, not_done) - - if len(done) == len(fs): - return DoneAndNotDoneFutures(done, not_done) - - waiter = _create_and_install_waiters(fs, return_when) - - waiter.event.wait(timeout) - for f in fs: - f._waiters.remove(waiter) - - done.update(waiter.finished_futures) - return DoneAndNotDoneFutures(done, set(fs) - done) - -class Future(object): - """Represents the result of an asynchronous computation.""" - - def __init__(self): - """Initializes the future. Should not be called by clients.""" - self._condition = threading.Condition() - self._state = PENDING - self._result = None - self._exception = None - self._waiters = [] - self._done_callbacks = [] - - def _invoke_callbacks(self): - for callback in self._done_callbacks: - try: - callback(self) - except Exception: - LOGGER.exception('exception calling callback for %r', self) - - def __repr__(self): - with self._condition: - if self._state == FINISHED: - if self._exception: - return '<Future at %s state=%s raised %s>' % ( - hex(id(self)), - _STATE_TO_DESCRIPTION_MAP[self._state], - self._exception.__class__.__name__) - else: - return '<Future at %s state=%s returned %s>' % ( - hex(id(self)), - _STATE_TO_DESCRIPTION_MAP[self._state], - self._result.__class__.__name__) - return '<Future at %s state=%s>' % ( - hex(id(self)), - _STATE_TO_DESCRIPTION_MAP[self._state]) - - def cancel(self): - """Cancel the future if possible. - - Returns True if the future was cancelled, False otherwise. A future - cannot be cancelled if it is running or has already completed. - """ - with self._condition: - if self._state in [RUNNING, FINISHED]: - return False - - if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]: - return True - - self._state = CANCELLED - self._condition.notify_all() - - self._invoke_callbacks() - return True - - def cancelled(self): - """Return True if the future has cancelled.""" - with self._condition: - return self._state in [CANCELLED, CANCELLED_AND_NOTIFIED] - - def running(self): - """Return True if the future is currently executing.""" - with self._condition: - return self._state == RUNNING - - def done(self): - """Return True of the future was cancelled or finished executing.""" - with self._condition: - return self._state in [CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED] - - def __get_result(self): - if self._exception: - raise self._exception - else: - return self._result - - def add_done_callback(self, fn): - """Attaches a callable that will be called when the future finishes. - - Args: - fn: A callable that will be called with this future as its only - argument when the future completes or is cancelled. The callable - will always be called by a thread in the same process in which - it was added. If the future has already completed or been - cancelled then the callable will be called immediately. These - callables are called in the order that they were added. - """ - with self._condition: - if self._state not in [CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED]: - self._done_callbacks.append(fn) - return - fn(self) - - def result(self, timeout=None): - """Return the result of the call that the future represents. - - Args: - timeout: The number of seconds to wait for the result if the future - isn't done. If None, then there is no limit on the wait time. - - Returns: - The result of the call that the future represents. - - Raises: - CancelledError: If the future was cancelled. - TimeoutError: If the future didn't finish executing before the given - timeout. - Exception: If the call raised then that exception will be raised. - """ - with self._condition: - if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]: - raise CancelledError() - elif self._state == FINISHED: - return self.__get_result() - - self._condition.wait(timeout) - - if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]: - raise CancelledError() - elif self._state == FINISHED: - return self.__get_result() - else: - raise TimeoutError() - - def exception(self, timeout=None): - """Return the exception raised by the call that the future represents. - - Args: - timeout: The number of seconds to wait for the exception if the - future isn't done. If None, then there is no limit on the wait - time. - - Returns: - The exception raised by the call that the future represents or None - if the call completed without raising. - - Raises: - CancelledError: If the future was cancelled. - TimeoutError: If the future didn't finish executing before the given - timeout. - """ - - with self._condition: - if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]: - raise CancelledError() - elif self._state == FINISHED: - return self._exception - - self._condition.wait(timeout) - - if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]: - raise CancelledError() - elif self._state == FINISHED: - return self._exception - else: - raise TimeoutError() - - # The following methods should only be used by Executors and in tests. - def set_running_or_notify_cancel(self): - """Mark the future as running or process any cancel notifications. - - Should only be used by Executor implementations and unit tests. - - If the future has been cancelled (cancel() was called and returned - True) then any threads waiting on the future completing (though calls - to as_completed() or wait()) are notified and False is returned. - - If the future was not cancelled then it is put in the running state - (future calls to running() will return True) and True is returned. - - This method should be called by Executor implementations before - executing the work associated with this future. If this method returns - False then the work should not be executed. - - Returns: - False if the Future was cancelled, True otherwise. - - Raises: - RuntimeError: if this method was already called or if set_result() - or set_exception() was called. - """ - with self._condition: - if self._state == CANCELLED: - self._state = CANCELLED_AND_NOTIFIED - for waiter in self._waiters: - waiter.add_cancelled(self) - # self._condition.notify_all() is not necessary because - # self.cancel() triggers a notification. - return False - elif self._state == PENDING: - self._state = RUNNING - return True - else: - LOGGER.critical('Future %s in unexpected state: %s', - id(self.future), - self.future._state) - raise RuntimeError('Future in unexpected state') - - def set_result(self, result): - """Sets the return value of work associated with the future. - - Should only be used by Executor implementations and unit tests. - """ - with self._condition: - self._result = result - self._state = FINISHED - for waiter in self._waiters: - waiter.add_result(self) - self._condition.notify_all() - self._invoke_callbacks() - - def set_exception(self, exception): - """Sets the result of the future as being the given exception. - - Should only be used by Executor implementations and unit tests. - """ - with self._condition: - self._exception = exception - self._state = FINISHED - for waiter in self._waiters: - waiter.add_exception(self) - self._condition.notify_all() - self._invoke_callbacks() - -class Executor(object): - """This is an abstract base class for concrete asynchronous executors.""" - - def submit(self, fn, *args, **kwargs): - """Submits a callable to be executed with the given arguments. - - Schedules the callable to be executed as fn(*args, **kwargs) and returns - a Future instance representing the execution of the callable. - - Returns: - A Future representing the given call. - """ - raise NotImplementedError() - - def map(self, fn, *iterables, **kwargs): - """Returns a iterator equivalent to map(fn, iter). - - Args: - fn: A callable that will take as many arguments as there are - passed iterables. - timeout: The maximum number of seconds to wait. If None, then there - is no limit on the wait time. - - Returns: - An iterator equivalent to: map(func, *iterables) but the calls may - be evaluated out-of-order. - - Raises: - TimeoutError: If the entire result iterator could not be generated - before the given timeout. - Exception: If fn(*args) raises for any values. - """ - timeout = kwargs.get('timeout') - if timeout is not None: - end_time = timeout + time.time() - - fs = [self.submit(fn, *args) for args in zip(*iterables)] - - try: - for future in fs: - if timeout is None: - yield future.result() - else: - yield future.result(end_time - time.time()) - finally: - for future in fs: - future.cancel() - - def shutdown(self, wait=True): - """Clean-up the resources associated with the Executor. - - It is safe to call this method several times. Otherwise, no other - methods can be called after this one. - - Args: - wait: If True then shutdown will not return until all running - futures have finished executing and the resources used by the - executor have been reclaimed. - """ - pass - - def __enter__(self): - return self - - def __exit__(self, exc_type, exc_val, exc_tb): - self.shutdown(wait=True) - return False diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/_compat.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/_compat.py deleted file mode 100755 index 1146232..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/_compat.py +++ /dev/null @@ -1,101 +0,0 @@ -from keyword import iskeyword as _iskeyword -from operator import itemgetter as _itemgetter -import sys as _sys - - -def namedtuple(typename, field_names): - """Returns a new subclass of tuple with named fields. - - >>> Point = namedtuple('Point', 'x y') - >>> Point.__doc__ # docstring for the new class - 'Point(x, y)' - >>> p = Point(11, y=22) # instantiate with positional args or keywords - >>> p[0] + p[1] # indexable like a plain tuple - 33 - >>> x, y = p # unpack like a regular tuple - >>> x, y - (11, 22) - >>> p.x + p.y # fields also accessable by name - 33 - >>> d = p._asdict() # convert to a dictionary - >>> d['x'] - 11 - >>> Point(**d) # convert from a dictionary - Point(x=11, y=22) - >>> p._replace(x=100) # _replace() is like str.replace() but targets named fields - Point(x=100, y=22) - - """ - - # Parse and validate the field names. Validation serves two purposes, - # generating informative error messages and preventing template injection attacks. - if isinstance(field_names, basestring): - field_names = field_names.replace(',', ' ').split() # names separated by whitespace and/or commas - field_names = tuple(map(str, field_names)) - for name in (typename,) + field_names: - if not all(c.isalnum() or c=='_' for c in name): - raise ValueError('Type names and field names can only contain alphanumeric characters and underscores: %r' % name) - if _iskeyword(name): - raise ValueError('Type names and field names cannot be a keyword: %r' % name) - if name[0].isdigit(): - raise ValueError('Type names and field names cannot start with a number: %r' % name) - seen_names = set() - for name in field_names: - if name.startswith('_'): - raise ValueError('Field names cannot start with an underscore: %r' % name) - if name in seen_names: - raise ValueError('Encountered duplicate field name: %r' % name) - seen_names.add(name) - - # Create and fill-in the class template - numfields = len(field_names) - argtxt = repr(field_names).replace("'", "")[1:-1] # tuple repr without parens or quotes - reprtxt = ', '.join('%s=%%r' % name for name in field_names) - dicttxt = ', '.join('%r: t[%d]' % (name, pos) for pos, name in enumerate(field_names)) - template = '''class %(typename)s(tuple): - '%(typename)s(%(argtxt)s)' \n - __slots__ = () \n - _fields = %(field_names)r \n - def __new__(_cls, %(argtxt)s): - return _tuple.__new__(_cls, (%(argtxt)s)) \n - @classmethod - def _make(cls, iterable, new=tuple.__new__, len=len): - 'Make a new %(typename)s object from a sequence or iterable' - result = new(cls, iterable) - if len(result) != %(numfields)d: - raise TypeError('Expected %(numfields)d arguments, got %%d' %% len(result)) - return result \n - def __repr__(self): - return '%(typename)s(%(reprtxt)s)' %% self \n - def _asdict(t): - 'Return a new dict which maps field names to their values' - return {%(dicttxt)s} \n - def _replace(_self, **kwds): - 'Return a new %(typename)s object replacing specified fields with new values' - result = _self._make(map(kwds.pop, %(field_names)r, _self)) - if kwds: - raise ValueError('Got unexpected field names: %%r' %% kwds.keys()) - return result \n - def __getnewargs__(self): - return tuple(self) \n\n''' % locals() - for i, name in enumerate(field_names): - template += ' %s = _property(_itemgetter(%d))\n' % (name, i) - - # Execute the template string in a temporary namespace and - # support tracing utilities by setting a value for frame.f_globals['__name__'] - namespace = dict(_itemgetter=_itemgetter, __name__='namedtuple_%s' % typename, - _property=property, _tuple=tuple) - try: - exec(template, namespace) - except SyntaxError: - e = _sys.exc_info()[1] - raise SyntaxError(e.message + ':\n' + template) - result = namespace[typename] - - # For pickling to work, the __module__ variable needs to be set to the frame - # where the named tuple is created. Bypass this step in enviroments where - # sys._getframe is not defined (Jython for example). - if hasattr(_sys, '_getframe'): - result.__module__ = _sys._getframe(1).f_globals.get('__name__', '__main__') - - return result diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/process.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/process.py deleted file mode 100755 index 98684f8..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/process.py +++ /dev/null @@ -1,363 +0,0 @@ -# Copyright 2009 Brian Quinlan. All Rights Reserved. -# Licensed to PSF under a Contributor Agreement. - -"""Implements ProcessPoolExecutor. - -The follow diagram and text describe the data-flow through the system: - -|======================= In-process =====================|== Out-of-process ==| - -+----------+ +----------+ +--------+ +-----------+ +---------+ -| | => | Work Ids | => | | => | Call Q | => | | -| | +----------+ | | +-----------+ | | -| | | ... | | | | ... | | | -| | | 6 | | | | 5, call() | | | -| | | 7 | | | | ... | | | -| Process | | ... | | Local | +-----------+ | Process | -| Pool | +----------+ | Worker | | #1..n | -| Executor | | Thread | | | -| | +----------- + | | +-----------+ | | -| | <=> | Work Items | <=> | | <= | Result Q | <= | | -| | +------------+ | | +-----------+ | | -| | | 6: call() | | | | ... | | | -| | | future | | | | 4, result | | | -| | | ... | | | | 3, except | | | -+----------+ +------------+ +--------+ +-----------+ +---------+ - -Executor.submit() called: -- creates a uniquely numbered _WorkItem and adds it to the "Work Items" dict -- adds the id of the _WorkItem to the "Work Ids" queue - -Local worker thread: -- reads work ids from the "Work Ids" queue and looks up the corresponding - WorkItem from the "Work Items" dict: if the work item has been cancelled then - it is simply removed from the dict, otherwise it is repackaged as a - _CallItem and put in the "Call Q". New _CallItems are put in the "Call Q" - until "Call Q" is full. NOTE: the size of the "Call Q" is kept small because - calls placed in the "Call Q" can no longer be cancelled with Future.cancel(). -- reads _ResultItems from "Result Q", updates the future stored in the - "Work Items" dict and deletes the dict entry - -Process #1..n: -- reads _CallItems from "Call Q", executes the calls, and puts the resulting - _ResultItems in "Request Q" -""" - -from __future__ import with_statement -import atexit -import multiprocessing -import threading -import weakref -import sys - -from concurrent.futures import _base - -try: - import queue -except ImportError: - import Queue as queue - -__author__ = 'Brian Quinlan (brian@sweetapp.com)' - -# Workers are created as daemon threads and processes. This is done to allow the -# interpreter to exit when there are still idle processes in a -# ProcessPoolExecutor's process pool (i.e. shutdown() was not called). However, -# allowing workers to die with the interpreter has two undesirable properties: -# - The workers would still be running during interpretor shutdown, -# meaning that they would fail in unpredictable ways. -# - The workers could be killed while evaluating a work item, which could -# be bad if the callable being evaluated has external side-effects e.g. -# writing to a file. -# -# To work around this problem, an exit handler is installed which tells the -# workers to exit when their work queues are empty and then waits until the -# threads/processes finish. - -_threads_queues = weakref.WeakKeyDictionary() -_shutdown = False - -def _python_exit(): - global _shutdown - _shutdown = True - items = list(_threads_queues.items()) - for t, q in items: - q.put(None) - for t, q in items: - t.join() - -# Controls how many more calls than processes will be queued in the call queue. -# A smaller number will mean that processes spend more time idle waiting for -# work while a larger number will make Future.cancel() succeed less frequently -# (Futures in the call queue cannot be cancelled). -EXTRA_QUEUED_CALLS = 1 - -class _WorkItem(object): - def __init__(self, future, fn, args, kwargs): - self.future = future - self.fn = fn - self.args = args - self.kwargs = kwargs - -class _ResultItem(object): - def __init__(self, work_id, exception=None, result=None): - self.work_id = work_id - self.exception = exception - self.result = result - -class _CallItem(object): - def __init__(self, work_id, fn, args, kwargs): - self.work_id = work_id - self.fn = fn - self.args = args - self.kwargs = kwargs - -def _process_worker(call_queue, result_queue): - """Evaluates calls from call_queue and places the results in result_queue. - - This worker is run in a separate process. - - Args: - call_queue: A multiprocessing.Queue of _CallItems that will be read and - evaluated by the worker. - result_queue: A multiprocessing.Queue of _ResultItems that will written - to by the worker. - shutdown: A multiprocessing.Event that will be set as a signal to the - worker that it should exit when call_queue is empty. - """ - while True: - call_item = call_queue.get(block=True) - if call_item is None: - # Wake up queue management thread - result_queue.put(None) - return - try: - r = call_item.fn(*call_item.args, **call_item.kwargs) - except BaseException: - e = sys.exc_info()[1] - result_queue.put(_ResultItem(call_item.work_id, - exception=e)) - else: - result_queue.put(_ResultItem(call_item.work_id, - result=r)) - -def _add_call_item_to_queue(pending_work_items, - work_ids, - call_queue): - """Fills call_queue with _WorkItems from pending_work_items. - - This function never blocks. - - Args: - pending_work_items: A dict mapping work ids to _WorkItems e.g. - {5: <_WorkItem...>, 6: <_WorkItem...>, ...} - work_ids: A queue.Queue of work ids e.g. Queue([5, 6, ...]). Work ids - are consumed and the corresponding _WorkItems from - pending_work_items are transformed into _CallItems and put in - call_queue. - call_queue: A multiprocessing.Queue that will be filled with _CallItems - derived from _WorkItems. - """ - while True: - if call_queue.full(): - return - try: - work_id = work_ids.get(block=False) - except queue.Empty: - return - else: - work_item = pending_work_items[work_id] - - if work_item.future.set_running_or_notify_cancel(): - call_queue.put(_CallItem(work_id, - work_item.fn, - work_item.args, - work_item.kwargs), - block=True) - else: - del pending_work_items[work_id] - continue - -def _queue_management_worker(executor_reference, - processes, - pending_work_items, - work_ids_queue, - call_queue, - result_queue): - """Manages the communication between this process and the worker processes. - - This function is run in a local thread. - - Args: - executor_reference: A weakref.ref to the ProcessPoolExecutor that owns - this thread. Used to determine if the ProcessPoolExecutor has been - garbage collected and that this function can exit. - process: A list of the multiprocessing.Process instances used as - workers. - pending_work_items: A dict mapping work ids to _WorkItems e.g. - {5: <_WorkItem...>, 6: <_WorkItem...>, ...} - work_ids_queue: A queue.Queue of work ids e.g. Queue([5, 6, ...]). - call_queue: A multiprocessing.Queue that will be filled with _CallItems - derived from _WorkItems for processing by the process workers. - result_queue: A multiprocessing.Queue of _ResultItems generated by the - process workers. - """ - nb_shutdown_processes = [0] - def shutdown_one_process(): - """Tell a worker to terminate, which will in turn wake us again""" - call_queue.put(None) - nb_shutdown_processes[0] += 1 - while True: - _add_call_item_to_queue(pending_work_items, - work_ids_queue, - call_queue) - - result_item = result_queue.get(block=True) - if result_item is not None: - work_item = pending_work_items[result_item.work_id] - del pending_work_items[result_item.work_id] - - if result_item.exception: - work_item.future.set_exception(result_item.exception) - else: - work_item.future.set_result(result_item.result) - # Check whether we should start shutting down. - executor = executor_reference() - # No more work items can be added if: - # - The interpreter is shutting down OR - # - The executor that owns this worker has been collected OR - # - The executor that owns this worker has been shutdown. - if _shutdown or executor is None or executor._shutdown_thread: - # Since no new work items can be added, it is safe to shutdown - # this thread if there are no pending work items. - if not pending_work_items: - while nb_shutdown_processes[0] < len(processes): - shutdown_one_process() - # If .join() is not called on the created processes then - # some multiprocessing.Queue methods may deadlock on Mac OS - # X. - for p in processes: - p.join() - call_queue.close() - return - del executor - -_system_limits_checked = False -_system_limited = None -def _check_system_limits(): - global _system_limits_checked, _system_limited - if _system_limits_checked: - if _system_limited: - raise NotImplementedError(_system_limited) - _system_limits_checked = True - try: - import os - nsems_max = os.sysconf("SC_SEM_NSEMS_MAX") - except (AttributeError, ValueError): - # sysconf not available or setting not available - return - if nsems_max == -1: - # indetermine limit, assume that limit is determined - # by available memory only - return - if nsems_max >= 256: - # minimum number of semaphores available - # according to POSIX - return - _system_limited = "system provides too few semaphores (%d available, 256 necessary)" % nsems_max - raise NotImplementedError(_system_limited) - -class ProcessPoolExecutor(_base.Executor): - def __init__(self, max_workers=None): - """Initializes a new ProcessPoolExecutor instance. - - Args: - max_workers: The maximum number of processes that can be used to - execute the given calls. If None or not given then as many - worker processes will be created as the machine has processors. - """ - _check_system_limits() - - if max_workers is None: - self._max_workers = multiprocessing.cpu_count() - else: - self._max_workers = max_workers - - # Make the call queue slightly larger than the number of processes to - # prevent the worker processes from idling. But don't make it too big - # because futures in the call queue cannot be cancelled. - self._call_queue = multiprocessing.Queue(self._max_workers + - EXTRA_QUEUED_CALLS) - self._result_queue = multiprocessing.Queue() - self._work_ids = queue.Queue() - self._queue_management_thread = None - self._processes = set() - - # Shutdown is a two-step process. - self._shutdown_thread = False - self._shutdown_lock = threading.Lock() - self._queue_count = 0 - self._pending_work_items = {} - - def _start_queue_management_thread(self): - # When the executor gets lost, the weakref callback will wake up - # the queue management thread. - def weakref_cb(_, q=self._result_queue): - q.put(None) - if self._queue_management_thread is None: - self._queue_management_thread = threading.Thread( - target=_queue_management_worker, - args=(weakref.ref(self, weakref_cb), - self._processes, - self._pending_work_items, - self._work_ids, - self._call_queue, - self._result_queue)) - self._queue_management_thread.daemon = True - self._queue_management_thread.start() - _threads_queues[self._queue_management_thread] = self._result_queue - - def _adjust_process_count(self): - for _ in range(len(self._processes), self._max_workers): - p = multiprocessing.Process( - target=_process_worker, - args=(self._call_queue, - self._result_queue)) - p.start() - self._processes.add(p) - - def submit(self, fn, *args, **kwargs): - with self._shutdown_lock: - if self._shutdown_thread: - raise RuntimeError('cannot schedule new futures after shutdown') - - f = _base.Future() - w = _WorkItem(f, fn, args, kwargs) - - self._pending_work_items[self._queue_count] = w - self._work_ids.put(self._queue_count) - self._queue_count += 1 - # Wake up queue management thread - self._result_queue.put(None) - - self._start_queue_management_thread() - self._adjust_process_count() - return f - submit.__doc__ = _base.Executor.submit.__doc__ - - def shutdown(self, wait=True): - with self._shutdown_lock: - self._shutdown_thread = True - if self._queue_management_thread: - # Wake up queue management thread - self._result_queue.put(None) - if wait: - self._queue_management_thread.join() - # To reduce the risk of openning too many files, remove references to - # objects that use file descriptors. - self._queue_management_thread = None - self._call_queue = None - self._result_queue = None - self._processes = None - shutdown.__doc__ = _base.Executor.shutdown.__doc__ - -atexit.register(_python_exit) diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/thread.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/thread.py deleted file mode 100755 index a45959d..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/concurrent/futures/thread.py +++ /dev/null @@ -1,138 +0,0 @@ -# Copyright 2009 Brian Quinlan. All Rights Reserved. -# Licensed to PSF under a Contributor Agreement. - -"""Implements ThreadPoolExecutor.""" - -from __future__ import with_statement -import atexit -import threading -import weakref -import sys - -from concurrent.futures import _base - -try: - import queue -except ImportError: - import Queue as queue - -__author__ = 'Brian Quinlan (brian@sweetapp.com)' - -# Workers are created as daemon threads. This is done to allow the interpreter -# to exit when there are still idle threads in a ThreadPoolExecutor's thread -# pool (i.e. shutdown() was not called). However, allowing workers to die with -# the interpreter has two undesirable properties: -# - The workers would still be running during interpretor shutdown, -# meaning that they would fail in unpredictable ways. -# - The workers could be killed while evaluating a work item, which could -# be bad if the callable being evaluated has external side-effects e.g. -# writing to a file. -# -# To work around this problem, an exit handler is installed which tells the -# workers to exit when their work queues are empty and then waits until the -# threads finish. - -_threads_queues = weakref.WeakKeyDictionary() -_shutdown = False - -def _python_exit(): - global _shutdown - _shutdown = True - items = list(_threads_queues.items()) - for t, q in items: - q.put(None) - for t, q in items: - t.join() - -atexit.register(_python_exit) - -class _WorkItem(object): - def __init__(self, future, fn, args, kwargs): - self.future = future - self.fn = fn - self.args = args - self.kwargs = kwargs - - def run(self): - if not self.future.set_running_or_notify_cancel(): - return - - try: - result = self.fn(*self.args, **self.kwargs) - except BaseException: - e = sys.exc_info()[1] - self.future.set_exception(e) - else: - self.future.set_result(result) - -def _worker(executor_reference, work_queue): - try: - while True: - work_item = work_queue.get(block=True) - if work_item is not None: - work_item.run() - continue - executor = executor_reference() - # Exit if: - # - The interpreter is shutting down OR - # - The executor that owns the worker has been collected OR - # - The executor that owns the worker has been shutdown. - if _shutdown or executor is None or executor._shutdown: - # Notice other workers - work_queue.put(None) - return - del executor - except BaseException: - _base.LOGGER.critical('Exception in worker', exc_info=True) - -class ThreadPoolExecutor(_base.Executor): - def __init__(self, max_workers): - """Initializes a new ThreadPoolExecutor instance. - - Args: - max_workers: The maximum number of threads that can be used to - execute the given calls. - """ - self._max_workers = max_workers - self._work_queue = queue.Queue() - self._threads = set() - self._shutdown = False - self._shutdown_lock = threading.Lock() - - def submit(self, fn, *args, **kwargs): - with self._shutdown_lock: - if self._shutdown: - raise RuntimeError('cannot schedule new futures after shutdown') - - f = _base.Future() - w = _WorkItem(f, fn, args, kwargs) - - self._work_queue.put(w) - self._adjust_thread_count() - return f - submit.__doc__ = _base.Executor.submit.__doc__ - - def _adjust_thread_count(self): - # When the executor gets lost, the weakref callback will wake up - # the worker threads. - def weakref_cb(_, q=self._work_queue): - q.put(None) - # TODO(bquinlan): Should avoid creating new threads if there are more - # idle threads than items in the work queue. - if len(self._threads) < self._max_workers: - t = threading.Thread(target=_worker, - args=(weakref.ref(self, weakref_cb), - self._work_queue)) - t.daemon = True - t.start() - self._threads.add(t) - _threads_queues[t] = self._work_queue - - def shutdown(self, wait=True): - with self._shutdown_lock: - self._shutdown = True - self._work_queue.put(None) - if wait: - for t in self._threads: - t.join() - shutdown.__doc__ = _base.Executor.shutdown.__doc__ diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/crawl.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/crawl.py deleted file mode 100755 index 86e0af7..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/crawl.py +++ /dev/null @@ -1,74 +0,0 @@ -"""Compare the speed of downloading URLs sequentially vs. using futures.""" - -import functools -import time -import timeit -import sys - -try: - from urllib2 import urlopen -except ImportError: - from urllib.request import urlopen - -from concurrent.futures import (as_completed, ThreadPoolExecutor, - ProcessPoolExecutor) - -URLS = ['http://www.google.com/', - 'http://www.apple.com/', - 'http://www.ibm.com', - 'http://www.thisurlprobablydoesnotexist.com', - 'http://www.slashdot.org/', - 'http://www.python.org/', - 'http://www.bing.com/', - 'http://www.facebook.com/', - 'http://www.yahoo.com/', - 'http://www.youtube.com/', - 'http://www.blogger.com/'] - -def load_url(url, timeout): - kwargs = {'timeout': timeout} if sys.version_info >= (2, 6) else {} - return urlopen(url, **kwargs).read() - -def download_urls_sequential(urls, timeout=60): - url_to_content = {} - for url in urls: - try: - url_to_content[url] = load_url(url, timeout=timeout) - except: - pass - return url_to_content - -def download_urls_with_executor(urls, executor, timeout=60): - try: - url_to_content = {} - future_to_url = dict((executor.submit(load_url, url, timeout), url) - for url in urls) - - for future in as_completed(future_to_url): - try: - url_to_content[future_to_url[future]] = future.result() - except: - pass - return url_to_content - finally: - executor.shutdown() - -def main(): - for name, fn in [('sequential', - functools.partial(download_urls_sequential, URLS)), - ('processes', - functools.partial(download_urls_with_executor, - URLS, - ProcessPoolExecutor(10))), - ('threads', - functools.partial(download_urls_with_executor, - URLS, - ThreadPoolExecutor(10)))]: - sys.stdout.write('%s: ' % name.ljust(12)) - start = time.time() - url_map = fn() - sys.stdout.write('%.2f seconds (%d of %d downloaded)\n' % - (time.time() - start, len(url_map), len(URLS))) - -if __name__ == '__main__': - main() diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/docs/conf.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/docs/conf.py deleted file mode 100755 index 124cd51..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/docs/conf.py +++ /dev/null @@ -1,194 +0,0 @@ -# -*- coding: utf-8 -*- -# -# futures documentation build configuration file, created by -# sphinx-quickstart on Wed Jun 3 19:35:34 2009. -# -# This file is execfile()d with the current directory set to its containing dir. -# -# Note that not all possible configuration values are present in this -# autogenerated file. -# -# All configuration values have a default; values that are commented out -# serve to show the default. - -import sys, os - -# If extensions (or modules to document with autodoc) are in another directory, -# add these directories to sys.path here. If the directory is relative to the -# documentation root, use os.path.abspath to make it absolute, like shown here. -#sys.path.append(os.path.abspath('.')) - -# -- General configuration ----------------------------------------------------- - -# Add any Sphinx extension module names here, as strings. They can be extensions -# coming with Sphinx (named 'sphinx.ext.*') or your custom ones. -extensions = [] - -# Add any paths that contain templates here, relative to this directory. -templates_path = ['_templates'] - -# The suffix of source filenames. -source_suffix = '.rst' - -# The encoding of source files. -#source_encoding = 'utf-8' - -# The master toctree document. -master_doc = 'index' - -# General information about the project. -project = u'futures' -copyright = u'2009-2011, Brian Quinlan' - -# The version info for the project you're documenting, acts as replacement for -# |version| and |release|, also used in various other places throughout the -# built documents. -# -# The short X.Y version. -version = '2.1.3' -# The full version, including alpha/beta/rc tags. -release = '2.1.3' - -# The language for content autogenerated by Sphinx. Refer to documentation -# for a list of supported languages. -#language = None - -# There are two options for replacing |today|: either, you set today to some -# non-false value, then it is used: -#today = '' -# Else, today_fmt is used as the format for a strftime call. -#today_fmt = '%B %d, %Y' - -# List of documents that shouldn't be included in the build. -#unused_docs = [] - -# List of directories, relative to source directory, that shouldn't be searched -# for source files. -exclude_trees = ['_build'] - -# The reST default role (used for this markup: `text`) to use for all documents. -#default_role = None - -# If true, '()' will be appended to :func: etc. cross-reference text. -#add_function_parentheses = True - -# If true, the current module name will be prepended to all description -# unit titles (such as .. function::). -#add_module_names = True - -# If true, sectionauthor and moduleauthor directives will be shown in the -# output. They are ignored by default. -#show_authors = False - -# The name of the Pygments (syntax highlighting) style to use. -pygments_style = 'sphinx' - -# A list of ignored prefixes for module index sorting. -#modindex_common_prefix = [] - - -# -- Options for HTML output --------------------------------------------------- - -# The theme to use for HTML and HTML Help pages. Major themes that come with -# Sphinx are currently 'default' and 'sphinxdoc'. -html_theme = 'default' - -# Theme options are theme-specific and customize the look and feel of a theme -# further. For a list of options available for each theme, see the -# documentation. -#html_theme_options = {} - -# Add any paths that contain custom themes here, relative to this directory. -#html_theme_path = [] - -# The name for this set of Sphinx documents. If None, it defaults to -# "<project> v<release> documentation". -#html_title = None - -# A shorter title for the navigation bar. Default is the same as html_title. -#html_short_title = None - -# The name of an image file (relative to this directory) to place at the top -# of the sidebar. -#html_logo = None - -# The name of an image file (within the static path) to use as favicon of the -# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 -# pixels large. -#html_favicon = None - -# Add any paths that contain custom static files (such as style sheets) here, -# relative to this directory. They are copied after the builtin static files, -# so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ['_static'] - -# If not '', a 'Last updated on:' timestamp is inserted at every page bottom, -# using the given strftime format. -#html_last_updated_fmt = '%b %d, %Y' - -# If true, SmartyPants will be used to convert quotes and dashes to -# typographically correct entities. -#html_use_smartypants = True - -# Custom sidebar templates, maps document names to template names. -#html_sidebars = {} - -# Additional templates that should be rendered to pages, maps page names to -# template names. -#html_additional_pages = {} - -# If false, no module index is generated. -#html_use_modindex = True - -# If false, no index is generated. -#html_use_index = True - -# If true, the index is split into individual pages for each letter. -#html_split_index = False - -# If true, links to the reST sources are added to the pages. -#html_show_sourcelink = True - -# If true, an OpenSearch description file will be output, and all pages will -# contain a <link> tag referring to it. The value of this option must be the -# base URL from which the finished HTML is served. -#html_use_opensearch = '' - -# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml"). -#html_file_suffix = '' - -# Output file base name for HTML help builder. -htmlhelp_basename = 'futuresdoc' - - -# -- Options for LaTeX output -------------------------------------------------- - -# The paper size ('letter' or 'a4'). -#latex_paper_size = 'letter' - -# The font size ('10pt', '11pt' or '12pt'). -#latex_font_size = '10pt' - -# Grouping the document tree into LaTeX files. List of tuples -# (source start file, target name, title, author, documentclass [howto/manual]). -latex_documents = [ - ('index', 'futures.tex', u'futures Documentation', - u'Brian Quinlan', 'manual'), -] - -# The name of an image file (relative to this directory) to place at the top of -# the title page. -#latex_logo = None - -# For "manual" documents, if this is true, then toplevel headings are parts, -# not chapters. -#latex_use_parts = False - -# Additional stuff for the LaTeX preamble. -#latex_preamble = '' - -# Documents to append as an appendix to all manuals. -#latex_appendices = [] - -# If false, no module index is generated. -#latex_use_modindex = True diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/docs/index.rst b/vim/bundle/YouCompleteMe/third_party/pythonfutures/docs/index.rst deleted file mode 100755 index 525ce6a..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/docs/index.rst +++ /dev/null @@ -1,345 +0,0 @@ -:mod:`concurrent.futures` --- Asynchronous computation -====================================================== - -.. module:: concurrent.futures - :synopsis: Execute computations asynchronously using threads or processes. - -The :mod:`concurrent.futures` module provides a high-level interface for -asynchronously executing callables. - -The asynchronous execution can be be performed by threads using -:class:`ThreadPoolExecutor` or seperate processes using -:class:`ProcessPoolExecutor`. Both implement the same interface, which is -defined by the abstract :class:`Executor` class. - -Executor Objects ----------------- - -:class:`Executor` is an abstract class that provides methods to execute calls -asynchronously. It should not be used directly, but through its two -subclasses: :class:`ThreadPoolExecutor` and :class:`ProcessPoolExecutor`. - -.. method:: Executor.submit(fn, *args, **kwargs) - - Schedules the callable to be executed as *fn*(*\*args*, *\*\*kwargs*) and - returns a :class:`Future` representing the execution of the callable. - -:: - - with ThreadPoolExecutor(max_workers=1) as executor: - future = executor.submit(pow, 323, 1235) - print(future.result()) - -.. method:: Executor.map(func, *iterables, timeout=None) - - Equivalent to map(*func*, *\*iterables*) but func is executed asynchronously - and several calls to *func* may be made concurrently. The returned iterator - raises a :exc:`TimeoutError` if :meth:`__next__()` is called and the result - isn't available after *timeout* seconds from the original call to - :meth:`map()`. *timeout* can be an int or float. If *timeout* is not - specified or ``None`` then there is no limit to the wait time. If a call - raises an exception then that exception will be raised when its value is - retrieved from the iterator. - -.. method:: Executor.shutdown(wait=True) - - Signal the executor that it should free any resources that it is using when - the currently pending futures are done executing. Calls to - :meth:`Executor.submit` and :meth:`Executor.map` made after shutdown will - raise :exc:`RuntimeError`. - - If *wait* is `True` then this method will not return until all the pending - futures are done executing and the resources associated with the executor - have been freed. If *wait* is `False` then this method will return - immediately and the resources associated with the executor will be freed - when all pending futures are done executing. Regardless of the value of - *wait*, the entire Python program will not exit until all pending futures - are done executing. - - You can avoid having to call this method explicitly if you use the `with` - statement, which will shutdown the `Executor` (waiting as if - `Executor.shutdown` were called with *wait* set to `True`): - -:: - - import shutil - with ThreadPoolExecutor(max_workers=4) as e: - e.submit(shutil.copy, 'src1.txt', 'dest1.txt') - e.submit(shutil.copy, 'src2.txt', 'dest2.txt') - e.submit(shutil.copy, 'src3.txt', 'dest3.txt') - e.submit(shutil.copy, 'src3.txt', 'dest4.txt') - - -ThreadPoolExecutor Objects --------------------------- - -The :class:`ThreadPoolExecutor` class is an :class:`Executor` subclass that uses -a pool of threads to execute calls asynchronously. - -Deadlock can occur when the callable associated with a :class:`Future` waits on -the results of another :class:`Future`. For example: - -:: - - import time - def wait_on_b(): - time.sleep(5) - print(b.result()) # b will never complete because it is waiting on a. - return 5 - - def wait_on_a(): - time.sleep(5) - print(a.result()) # a will never complete because it is waiting on b. - return 6 - - - executor = ThreadPoolExecutor(max_workers=2) - a = executor.submit(wait_on_b) - b = executor.submit(wait_on_a) - -And: - -:: - - def wait_on_future(): - f = executor.submit(pow, 5, 2) - # This will never complete because there is only one worker thread and - # it is executing this function. - print(f.result()) - - executor = ThreadPoolExecutor(max_workers=1) - executor.submit(wait_on_future) - -.. class:: ThreadPoolExecutor(max_workers) - - Executes calls asynchronously using at pool of at most *max_workers* threads. - -.. _threadpoolexecutor-example: - -ThreadPoolExecutor Example -^^^^^^^^^^^^^^^^^^^^^^^^^^ -:: - - from concurrent import futures - import urllib.request - - URLS = ['http://www.foxnews.com/', - 'http://www.cnn.com/', - 'http://europe.wsj.com/', - 'http://www.bbc.co.uk/', - 'http://some-made-up-domain.com/'] - - def load_url(url, timeout): - return urllib.request.urlopen(url, timeout=timeout).read() - - with futures.ThreadPoolExecutor(max_workers=5) as executor: - future_to_url = dict((executor.submit(load_url, url, 60), url) - for url in URLS) - - for future in futures.as_completed(future_to_url): - url = future_to_url[future] - if future.exception() is not None: - print('%r generated an exception: %s' % (url, - future.exception())) - else: - print('%r page is %d bytes' % (url, len(future.result()))) - -ProcessPoolExecutor Objects ---------------------------- - -The :class:`ProcessPoolExecutor` class is an :class:`Executor` subclass that -uses a pool of processes to execute calls asynchronously. -:class:`ProcessPoolExecutor` uses the :mod:`multiprocessing` module, which -allows it to side-step the :term:`Global Interpreter Lock` but also means that -only picklable objects can be executed and returned. - -Calling :class:`Executor` or :class:`Future` methods from a callable submitted -to a :class:`ProcessPoolExecutor` will result in deadlock. - -.. class:: ProcessPoolExecutor(max_workers=None) - - Executes calls asynchronously using a pool of at most *max_workers* - processes. If *max_workers* is ``None`` or not given then as many worker - processes will be created as the machine has processors. - -.. _processpoolexecutor-example: - -ProcessPoolExecutor Example -^^^^^^^^^^^^^^^^^^^^^^^^^^^ -:: - - import math - - PRIMES = [ - 112272535095293, - 112582705942171, - 112272535095293, - 115280095190773, - 115797848077099, - 1099726899285419] - - def is_prime(n): - if n % 2 == 0: - return False - - sqrt_n = int(math.floor(math.sqrt(n))) - for i in range(3, sqrt_n + 1, 2): - if n % i == 0: - return False - return True - - def main(): - with futures.ProcessPoolExecutor() as executor: - for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)): - print('%d is prime: %s' % (number, prime)) - - if __name__ == '__main__': - main() - -Future Objects --------------- - -The :class:`Future` class encapulates the asynchronous execution of a callable. -:class:`Future` instances are created by :meth:`Executor.submit`. - -.. method:: Future.cancel() - - Attempt to cancel the call. If the call is currently being executed then - it cannot be cancelled and the method will return `False`, otherwise the call - will be cancelled and the method will return `True`. - -.. method:: Future.cancelled() - - Return `True` if the call was successfully cancelled. - -.. method:: Future.running() - - Return `True` if the call is currently being executed and cannot be - cancelled. - -.. method:: Future.done() - - Return `True` if the call was successfully cancelled or finished running. - -.. method:: Future.result(timeout=None) - - Return the value returned by the call. If the call hasn't yet completed then - this method will wait up to *timeout* seconds. If the call hasn't completed - in *timeout* seconds then a :exc:`TimeoutError` will be raised. *timeout* can - be an int or float.If *timeout* is not specified or ``None`` then there is no - limit to the wait time. - - If the future is cancelled before completing then :exc:`CancelledError` will - be raised. - - If the call raised then this method will raise the same exception. - -.. method:: Future.exception(timeout=None) - - Return the exception raised by the call. If the call hasn't yet completed - then this method will wait up to *timeout* seconds. If the call hasn't - completed in *timeout* seconds then a :exc:`TimeoutError` will be raised. - *timeout* can be an int or float. If *timeout* is not specified or ``None`` - then there is no limit to the wait time. - - If the future is cancelled before completing then :exc:`CancelledError` will - be raised. - - If the call completed without raising then ``None`` is returned. - -.. method:: Future.add_done_callback(fn) - - Attaches the callable *fn* to the future. *fn* will be called, with the - future as its only argument, when the future is cancelled or finishes - running. - - Added callables are called in the order that they were added and are always - called in a thread belonging to the process that added them. If the callable - raises an :exc:`Exception` then it will be logged and ignored. If the - callable raises another :exc:`BaseException` then the behavior is not - defined. - - If the future has already completed or been cancelled then *fn* will be - called immediately. - -Internal Future Methods -^^^^^^^^^^^^^^^^^^^^^^^ - -The following :class:`Future` methods are meant for use in unit tests and -:class:`Executor` implementations. - -.. method:: Future.set_running_or_notify_cancel() - - This method should only be called by :class:`Executor` implementations before - executing the work associated with the :class:`Future` and by unit tests. - - If the method returns `False` then the :class:`Future` was cancelled i.e. - :meth:`Future.cancel` was called and returned `True`. Any threads waiting - on the :class:`Future` completing (i.e. through :func:`as_completed` or - :func:`wait`) will be woken up. - - If the method returns `True` then the :class:`Future` was not cancelled - and has been put in the running state i.e. calls to - :meth:`Future.running` will return `True`. - - This method can only be called once and cannot be called after - :meth:`Future.set_result` or :meth:`Future.set_exception` have been - called. - -.. method:: Future.set_result(result) - - Sets the result of the work associated with the :class:`Future` to *result*. - - This method should only be used by Executor implementations and unit tests. - -.. method:: Future.set_exception(exception) - - Sets the result of the work associated with the :class:`Future` to the - :class:`Exception` *exception*. - - This method should only be used by Executor implementations and unit tests. - -Module Functions ----------------- - -.. function:: wait(fs, timeout=None, return_when=ALL_COMPLETED) - - Wait for the :class:`Future` instances (possibly created by different - :class:`Executor` instances) given by *fs* to complete. Returns a named - 2-tuple of sets. The first set, named "done", contains the futures that - completed (finished or were cancelled) before the wait completed. The second - set, named "not_done", contains uncompleted futures. - - *timeout* can be used to control the maximum number of seconds to wait before - returning. *timeout* can be an int or float. If *timeout* is not specified or - ``None`` then there is no limit to the wait time. - - *return_when* indicates when this function should return. It must be one of - the following constants: - - +-----------------------------+----------------------------------------+ - | Constant | Description | - +=============================+========================================+ - | :const:`FIRST_COMPLETED` | The function will return when any | - | | future finishes or is cancelled. | - +-----------------------------+----------------------------------------+ - | :const:`FIRST_EXCEPTION` | The function will return when any | - | | future finishes by raising an | - | | exception. If no future raises an | - | | exception then it is equivalent to | - | | `ALL_COMPLETED`. | - +-----------------------------+----------------------------------------+ - | :const:`ALL_COMPLETED` | The function will return when all | - | | futures finish or are cancelled. | - +-----------------------------+----------------------------------------+ - -.. function:: as_completed(fs, timeout=None) - - Returns an iterator over the :class:`Future` instances (possibly created - by different :class:`Executor` instances) given by *fs* that yields futures - as they complete (finished or were cancelled). Any futures that completed - before :func:`as_completed()` was called will be yielded first. The returned - iterator raises a :exc:`TimeoutError` if :meth:`__next__()` is called and - the result isn't available after *timeout* seconds from the original call - to :func:`as_completed()`. *timeout* can be an int or float. If *timeout* - is not specified or ``None`` then there is no limit to the wait time. diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/docs/make.bat b/vim/bundle/YouCompleteMe/third_party/pythonfutures/docs/make.bat deleted file mode 100755 index 3e8021b..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/docs/make.bat +++ /dev/null @@ -1,112 +0,0 @@ -@ECHO OFF - -REM Command file for Sphinx documentation - -set SPHINXBUILD=sphinx-build -set ALLSPHINXOPTS=-d _build/doctrees %SPHINXOPTS% . -if NOT "%PAPER%" == "" ( - set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% -) - -if "%1" == "" goto help - -if "%1" == "help" ( - :help - echo.Please use `make ^<target^>` where ^<target^> is one of - echo. html to make standalone HTML files - echo. dirhtml to make HTML files named index.html in directories - echo. pickle to make pickle files - echo. json to make JSON files - echo. htmlhelp to make HTML files and a HTML help project - echo. qthelp to make HTML files and a qthelp project - echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter - echo. changes to make an overview over all changed/added/deprecated items - echo. linkcheck to check all external links for integrity - echo. doctest to run all doctests embedded in the documentation if enabled - goto end -) - -if "%1" == "clean" ( - for /d %%i in (_build\*) do rmdir /q /s %%i - del /q /s _build\* - goto end -) - -if "%1" == "html" ( - %SPHINXBUILD% -b html %ALLSPHINXOPTS% _build/html - echo. - echo.Build finished. The HTML pages are in _build/html. - goto end -) - -if "%1" == "dirhtml" ( - %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% _build/dirhtml - echo. - echo.Build finished. The HTML pages are in _build/dirhtml. - goto end -) - -if "%1" == "pickle" ( - %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% _build/pickle - echo. - echo.Build finished; now you can process the pickle files. - goto end -) - -if "%1" == "json" ( - %SPHINXBUILD% -b json %ALLSPHINXOPTS% _build/json - echo. - echo.Build finished; now you can process the JSON files. - goto end -) - -if "%1" == "htmlhelp" ( - %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% _build/htmlhelp - echo. - echo.Build finished; now you can run HTML Help Workshop with the ^ -.hhp project file in _build/htmlhelp. - goto end -) - -if "%1" == "qthelp" ( - %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% _build/qthelp - echo. - echo.Build finished; now you can run "qcollectiongenerator" with the ^ -.qhcp project file in _build/qthelp, like this: - echo.^> qcollectiongenerator _build\qthelp\futures.qhcp - echo.To view the help file: - echo.^> assistant -collectionFile _build\qthelp\futures.ghc - goto end -) - -if "%1" == "latex" ( - %SPHINXBUILD% -b latex %ALLSPHINXOPTS% _build/latex - echo. - echo.Build finished; the LaTeX files are in _build/latex. - goto end -) - -if "%1" == "changes" ( - %SPHINXBUILD% -b changes %ALLSPHINXOPTS% _build/changes - echo. - echo.The overview file is in _build/changes. - goto end -) - -if "%1" == "linkcheck" ( - %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% _build/linkcheck - echo. - echo.Link check complete; look for any errors in the above output ^ -or in _build/linkcheck/output.txt. - goto end -) - -if "%1" == "doctest" ( - %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% _build/doctest - echo. - echo.Testing of doctests in the sources finished, look at the ^ -results in _build/doctest/output.txt. - goto end -) - -:end diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/futures/__init__.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/futures/__init__.py deleted file mode 100755 index 8f8b234..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/futures/__init__.py +++ /dev/null @@ -1,24 +0,0 @@ -# Copyright 2009 Brian Quinlan. All Rights Reserved. -# Licensed to PSF under a Contributor Agreement. - -"""Execute computations asynchronously using threads or processes.""" - -import warnings - -from concurrent.futures import (FIRST_COMPLETED, - FIRST_EXCEPTION, - ALL_COMPLETED, - CancelledError, - TimeoutError, - Future, - Executor, - wait, - as_completed, - ProcessPoolExecutor, - ThreadPoolExecutor) - -__author__ = 'Brian Quinlan (brian@sweetapp.com)' - -warnings.warn('The futures package has been deprecated. ' - 'Use the concurrent.futures package instead.', - DeprecationWarning) diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/futures/process.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/futures/process.py deleted file mode 100755 index e9d37b1..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/futures/process.py +++ /dev/null @@ -1 +0,0 @@ -from concurrent.futures import ProcessPoolExecutor diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/futures/thread.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/futures/thread.py deleted file mode 100755 index f6bd05d..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/futures/thread.py +++ /dev/null @@ -1 +0,0 @@ -from concurrent.futures import ThreadPoolExecutor diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/primes.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/primes.py deleted file mode 100755 index 0da2b3e..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/primes.py +++ /dev/null @@ -1,50 +0,0 @@ -from __future__ import with_statement -import math -import time -import sys - -from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor - -PRIMES = [ - 112272535095293, - 112582705942171, - 112272535095293, - 115280095190773, - 115797848077099, - 117450548693743, - 993960000099397] - -def is_prime(n): - if n % 2 == 0: - return False - - sqrt_n = int(math.floor(math.sqrt(n))) - for i in range(3, sqrt_n + 1, 2): - if n % i == 0: - return False - return True - -def sequential(): - return list(map(is_prime, PRIMES)) - -def with_process_pool_executor(): - with ProcessPoolExecutor(10) as executor: - return list(executor.map(is_prime, PRIMES)) - -def with_thread_pool_executor(): - with ThreadPoolExecutor(10) as executor: - return list(executor.map(is_prime, PRIMES)) - -def main(): - for name, fn in [('sequential', sequential), - ('processes', with_process_pool_executor), - ('threads', with_thread_pool_executor)]: - sys.stdout.write('%s: ' % name.ljust(12)) - start = time.time() - if fn() != [True] * len(PRIMES): - sys.stdout.write('failed\n') - else: - sys.stdout.write('%.2f seconds\n' % (time.time() - start)) - -if __name__ == '__main__': - main() diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/setup.cfg b/vim/bundle/YouCompleteMe/third_party/pythonfutures/setup.cfg deleted file mode 100755 index 0a9f4f5..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/setup.cfg +++ /dev/null @@ -1,6 +0,0 @@ -[build_sphinx] -source-dir = docs -build-dir = build/sphinx - -[upload_docs] -upload-dir = build/sphinx/html diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/setup.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/setup.py deleted file mode 100755 index c08461e..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/setup.py +++ /dev/null @@ -1,33 +0,0 @@ -#!/usr/bin/env python -import sys - -extras = {} -try: - from setuptools import setup - extras['zip_safe'] = False - if sys.version_info < (2, 6): - extras['install_requires'] = ['multiprocessing'] -except ImportError: - from distutils.core import setup - -setup(name='futures', - version='2.1.4', - description='Backport of the concurrent.futures package from Python 3.2', - author='Brian Quinlan', - author_email='brian@sweetapp.com', - maintainer='Alex Gronholm', - maintainer_email='alex.gronholm+pypi@nextday.fi', - url='http://code.google.com/p/pythonfutures', - download_url='http://pypi.python.org/pypi/futures/', - packages=['futures', 'concurrent', 'concurrent.futures'], - license='BSD', - classifiers=['License :: OSI Approved :: BSD License', - 'Development Status :: 5 - Production/Stable', - 'Intended Audience :: Developers', - 'Programming Language :: Python :: 2.5', - 'Programming Language :: Python :: 2.6', - 'Programming Language :: Python :: 2.7', - 'Programming Language :: Python :: 3', - 'Programming Language :: Python :: 3.1'], - **extras - ) diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/test_futures.py b/vim/bundle/YouCompleteMe/third_party/pythonfutures/test_futures.py deleted file mode 100755 index dd7fd3e..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/test_futures.py +++ /dev/null @@ -1,723 +0,0 @@ -from __future__ import with_statement -import os -import subprocess -import sys -import threading -import functools -import contextlib -import logging -import re -import time - -from concurrent import futures -from concurrent.futures._base import ( - PENDING, RUNNING, CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED, Future) - -try: - import unittest2 as unittest -except ImportError: - import unittest - -try: - from StringIO import StringIO -except ImportError: - from io import StringIO - -try: - from test import test_support -except ImportError: - from test import support as test_support - -try: - next -except NameError: - next = lambda x: x.next() - - -def reap_threads(func): - """Use this function when threads are being used. This will - ensure that the threads are cleaned up even when the test fails. - If threading is unavailable this function does nothing. - """ - @functools.wraps(func) - def decorator(*args): - key = test_support.threading_setup() - try: - return func(*args) - finally: - test_support.threading_cleanup(*key) - return decorator - - -# Executing the interpreter in a subprocess -def _assert_python(expected_success, *args, **env_vars): - cmd_line = [sys.executable] - if not env_vars: - cmd_line.append('-E') - # Need to preserve the original environment, for in-place testing of - # shared library builds. - env = os.environ.copy() - # But a special flag that can be set to override -- in this case, the - # caller is responsible to pass the full environment. - if env_vars.pop('__cleanenv', None): - env = {} - env.update(env_vars) - cmd_line.extend(args) - p = subprocess.Popen(cmd_line, stdin=subprocess.PIPE, - stdout=subprocess.PIPE, stderr=subprocess.PIPE, - env=env) - try: - out, err = p.communicate() - finally: - subprocess._cleanup() - p.stdout.close() - p.stderr.close() - rc = p.returncode - err = strip_python_stderr(err) - if (rc and expected_success) or (not rc and not expected_success): - raise AssertionError( - "Process return code is %d, " - "stderr follows:\n%s" % (rc, err.decode('ascii', 'ignore'))) - return rc, out, err - - -def assert_python_ok(*args, **env_vars): - """ - Assert that running the interpreter with `args` and optional environment - variables `env_vars` is ok and return a (return code, stdout, stderr) tuple. - """ - return _assert_python(True, *args, **env_vars) - - -def strip_python_stderr(stderr): - """Strip the stderr of a Python process from potential debug output - emitted by the interpreter. - - This will typically be run on the result of the communicate() method - of a subprocess.Popen object. - """ - stderr = re.sub(r"\[\d+ refs\]\r?\n?$".encode(), "".encode(), stderr).strip() - return stderr - - -@contextlib.contextmanager -def captured_stderr(): - """Return a context manager used by captured_stdout/stdin/stderr - that temporarily replaces the sys stream *stream_name* with a StringIO.""" - logging_stream = StringIO() - handler = logging.StreamHandler(logging_stream) - logging.root.addHandler(handler) - - try: - yield logging_stream - finally: - logging.root.removeHandler(handler) - - -def create_future(state=PENDING, exception=None, result=None): - f = Future() - f._state = state - f._exception = exception - f._result = result - return f - - -PENDING_FUTURE = create_future(state=PENDING) -RUNNING_FUTURE = create_future(state=RUNNING) -CANCELLED_FUTURE = create_future(state=CANCELLED) -CANCELLED_AND_NOTIFIED_FUTURE = create_future(state=CANCELLED_AND_NOTIFIED) -EXCEPTION_FUTURE = create_future(state=FINISHED, exception=IOError()) -SUCCESSFUL_FUTURE = create_future(state=FINISHED, result=42) - - -def mul(x, y): - return x * y - - -def sleep_and_raise(t): - time.sleep(t) - raise Exception('this is an exception') - -def sleep_and_print(t, msg): - time.sleep(t) - print(msg) - sys.stdout.flush() - - -class ExecutorMixin: - worker_count = 5 - - def setUp(self): - self.t1 = time.time() - try: - self.executor = self.executor_type(max_workers=self.worker_count) - except NotImplementedError: - e = sys.exc_info()[1] - self.skipTest(str(e)) - self._prime_executor() - - def tearDown(self): - self.executor.shutdown(wait=True) - dt = time.time() - self.t1 - if test_support.verbose: - print("%.2fs" % dt) - self.assertLess(dt, 60, "synchronization issue: test lasted too long") - - def _prime_executor(self): - # Make sure that the executor is ready to do work before running the - # tests. This should reduce the probability of timeouts in the tests. - futures = [self.executor.submit(time.sleep, 0.1) - for _ in range(self.worker_count)] - - for f in futures: - f.result() - - -class ThreadPoolMixin(ExecutorMixin): - executor_type = futures.ThreadPoolExecutor - - -class ProcessPoolMixin(ExecutorMixin): - executor_type = futures.ProcessPoolExecutor - - -class ExecutorShutdownTest(unittest.TestCase): - def test_run_after_shutdown(self): - self.executor.shutdown() - self.assertRaises(RuntimeError, - self.executor.submit, - pow, 2, 5) - - def test_interpreter_shutdown(self): - # Test the atexit hook for shutdown of worker threads and processes - rc, out, err = assert_python_ok('-c', """if 1: - from concurrent.futures import %s - from time import sleep - from test_futures import sleep_and_print - t = %s(5) - t.submit(sleep_and_print, 1.0, "apple") - """ % (self.executor_type.__name__, self.executor_type.__name__)) - # Errors in atexit hooks don't change the process exit code, check - # stderr manually. - self.assertFalse(err) - self.assertEqual(out.strip(), "apple".encode()) - - def test_hang_issue12364(self): - fs = [self.executor.submit(time.sleep, 0.1) for _ in range(50)] - self.executor.shutdown() - for f in fs: - f.result() - - -class ThreadPoolShutdownTest(ThreadPoolMixin, ExecutorShutdownTest): - def _prime_executor(self): - pass - - def test_threads_terminate(self): - self.executor.submit(mul, 21, 2) - self.executor.submit(mul, 6, 7) - self.executor.submit(mul, 3, 14) - self.assertEqual(len(self.executor._threads), 3) - self.executor.shutdown() - for t in self.executor._threads: - t.join() - - def test_context_manager_shutdown(self): - with futures.ThreadPoolExecutor(max_workers=5) as e: - executor = e - self.assertEqual(list(e.map(abs, range(-5, 5))), - [5, 4, 3, 2, 1, 0, 1, 2, 3, 4]) - - for t in executor._threads: - t.join() - - def test_del_shutdown(self): - executor = futures.ThreadPoolExecutor(max_workers=5) - executor.map(abs, range(-5, 5)) - threads = executor._threads - del executor - - for t in threads: - t.join() - - -class ProcessPoolShutdownTest(ProcessPoolMixin, ExecutorShutdownTest): - def _prime_executor(self): - pass - - def test_processes_terminate(self): - self.executor.submit(mul, 21, 2) - self.executor.submit(mul, 6, 7) - self.executor.submit(mul, 3, 14) - self.assertEqual(len(self.executor._processes), 5) - processes = self.executor._processes - self.executor.shutdown() - - for p in processes: - p.join() - - def test_context_manager_shutdown(self): - with futures.ProcessPoolExecutor(max_workers=5) as e: - processes = e._processes - self.assertEqual(list(e.map(abs, range(-5, 5))), - [5, 4, 3, 2, 1, 0, 1, 2, 3, 4]) - - for p in processes: - p.join() - - def test_del_shutdown(self): - executor = futures.ProcessPoolExecutor(max_workers=5) - list(executor.map(abs, range(-5, 5))) - queue_management_thread = executor._queue_management_thread - processes = executor._processes - del executor - - queue_management_thread.join() - for p in processes: - p.join() - - -class WaitTests(unittest.TestCase): - - def test_first_completed(self): - future1 = self.executor.submit(mul, 21, 2) - future2 = self.executor.submit(time.sleep, 1.5) - - done, not_done = futures.wait( - [CANCELLED_FUTURE, future1, future2], - return_when=futures.FIRST_COMPLETED) - - self.assertEqual(set([future1]), done) - self.assertEqual(set([CANCELLED_FUTURE, future2]), not_done) - - def test_first_completed_some_already_completed(self): - future1 = self.executor.submit(time.sleep, 1.5) - - finished, pending = futures.wait( - [CANCELLED_AND_NOTIFIED_FUTURE, SUCCESSFUL_FUTURE, future1], - return_when=futures.FIRST_COMPLETED) - - self.assertEqual( - set([CANCELLED_AND_NOTIFIED_FUTURE, SUCCESSFUL_FUTURE]), - finished) - self.assertEqual(set([future1]), pending) - - def test_first_exception(self): - future1 = self.executor.submit(mul, 2, 21) - future2 = self.executor.submit(sleep_and_raise, 1.5) - future3 = self.executor.submit(time.sleep, 3) - - finished, pending = futures.wait( - [future1, future2, future3], - return_when=futures.FIRST_EXCEPTION) - - self.assertEqual(set([future1, future2]), finished) - self.assertEqual(set([future3]), pending) - - def test_first_exception_some_already_complete(self): - future1 = self.executor.submit(divmod, 21, 0) - future2 = self.executor.submit(time.sleep, 1.5) - - finished, pending = futures.wait( - [SUCCESSFUL_FUTURE, - CANCELLED_FUTURE, - CANCELLED_AND_NOTIFIED_FUTURE, - future1, future2], - return_when=futures.FIRST_EXCEPTION) - - self.assertEqual(set([SUCCESSFUL_FUTURE, - CANCELLED_AND_NOTIFIED_FUTURE, - future1]), finished) - self.assertEqual(set([CANCELLED_FUTURE, future2]), pending) - - def test_first_exception_one_already_failed(self): - future1 = self.executor.submit(time.sleep, 2) - - finished, pending = futures.wait( - [EXCEPTION_FUTURE, future1], - return_when=futures.FIRST_EXCEPTION) - - self.assertEqual(set([EXCEPTION_FUTURE]), finished) - self.assertEqual(set([future1]), pending) - - def test_all_completed(self): - future1 = self.executor.submit(divmod, 2, 0) - future2 = self.executor.submit(mul, 2, 21) - - finished, pending = futures.wait( - [SUCCESSFUL_FUTURE, - CANCELLED_AND_NOTIFIED_FUTURE, - EXCEPTION_FUTURE, - future1, - future2], - return_when=futures.ALL_COMPLETED) - - self.assertEqual(set([SUCCESSFUL_FUTURE, - CANCELLED_AND_NOTIFIED_FUTURE, - EXCEPTION_FUTURE, - future1, - future2]), finished) - self.assertEqual(set(), pending) - - def test_timeout(self): - future1 = self.executor.submit(mul, 6, 7) - future2 = self.executor.submit(time.sleep, 3) - - finished, pending = futures.wait( - [CANCELLED_AND_NOTIFIED_FUTURE, - EXCEPTION_FUTURE, - SUCCESSFUL_FUTURE, - future1, future2], - timeout=1.5, - return_when=futures.ALL_COMPLETED) - - self.assertEqual(set([CANCELLED_AND_NOTIFIED_FUTURE, - EXCEPTION_FUTURE, - SUCCESSFUL_FUTURE, - future1]), finished) - self.assertEqual(set([future2]), pending) - - -class ThreadPoolWaitTests(ThreadPoolMixin, WaitTests): - - def test_pending_calls_race(self): - # Issue #14406: multi-threaded race condition when waiting on all - # futures. - event = threading.Event() - def future_func(): - event.wait() - oldswitchinterval = sys.getcheckinterval() - sys.setcheckinterval(1) - try: - fs = set(self.executor.submit(future_func) for i in range(100)) - event.set() - futures.wait(fs, return_when=futures.ALL_COMPLETED) - finally: - sys.setcheckinterval(oldswitchinterval) - - -class ProcessPoolWaitTests(ProcessPoolMixin, WaitTests): - pass - - -class AsCompletedTests(unittest.TestCase): - # TODO(brian@sweetapp.com): Should have a test with a non-zero timeout. - def test_no_timeout(self): - future1 = self.executor.submit(mul, 2, 21) - future2 = self.executor.submit(mul, 7, 6) - - completed = set(futures.as_completed( - [CANCELLED_AND_NOTIFIED_FUTURE, - EXCEPTION_FUTURE, - SUCCESSFUL_FUTURE, - future1, future2])) - self.assertEqual(set( - [CANCELLED_AND_NOTIFIED_FUTURE, - EXCEPTION_FUTURE, - SUCCESSFUL_FUTURE, - future1, future2]), - completed) - - def test_zero_timeout(self): - future1 = self.executor.submit(time.sleep, 2) - completed_futures = set() - try: - for future in futures.as_completed( - [CANCELLED_AND_NOTIFIED_FUTURE, - EXCEPTION_FUTURE, - SUCCESSFUL_FUTURE, - future1], - timeout=0): - completed_futures.add(future) - except futures.TimeoutError: - pass - - self.assertEqual(set([CANCELLED_AND_NOTIFIED_FUTURE, - EXCEPTION_FUTURE, - SUCCESSFUL_FUTURE]), - completed_futures) - - -class ThreadPoolAsCompletedTests(ThreadPoolMixin, AsCompletedTests): - pass - - -class ProcessPoolAsCompletedTests(ProcessPoolMixin, AsCompletedTests): - pass - - -class ExecutorTest(unittest.TestCase): - # Executor.shutdown() and context manager usage is tested by - # ExecutorShutdownTest. - def test_submit(self): - future = self.executor.submit(pow, 2, 8) - self.assertEqual(256, future.result()) - - def test_submit_keyword(self): - future = self.executor.submit(mul, 2, y=8) - self.assertEqual(16, future.result()) - - def test_map(self): - self.assertEqual( - list(self.executor.map(pow, range(10), range(10))), - list(map(pow, range(10), range(10)))) - - def test_map_exception(self): - i = self.executor.map(divmod, [1, 1, 1, 1], [2, 3, 0, 5]) - self.assertEqual(next(i), (0, 1)) - self.assertEqual(next(i), (0, 1)) - self.assertRaises(ZeroDivisionError, next, i) - - def test_map_timeout(self): - results = [] - try: - for i in self.executor.map(time.sleep, - [0, 0, 3], - timeout=1.5): - results.append(i) - except futures.TimeoutError: - pass - else: - self.fail('expected TimeoutError') - - self.assertEqual([None, None], results) - - -class ThreadPoolExecutorTest(ThreadPoolMixin, ExecutorTest): - pass - - -class ProcessPoolExecutorTest(ProcessPoolMixin, ExecutorTest): - pass - - -class FutureTests(unittest.TestCase): - def test_done_callback_with_result(self): - callback_result = [None] - def fn(callback_future): - callback_result[0] = callback_future.result() - - f = Future() - f.add_done_callback(fn) - f.set_result(5) - self.assertEqual(5, callback_result[0]) - - def test_done_callback_with_exception(self): - callback_exception = [None] - def fn(callback_future): - callback_exception[0] = callback_future.exception() - - f = Future() - f.add_done_callback(fn) - f.set_exception(Exception('test')) - self.assertEqual(('test',), callback_exception[0].args) - - def test_done_callback_with_cancel(self): - was_cancelled = [None] - def fn(callback_future): - was_cancelled[0] = callback_future.cancelled() - - f = Future() - f.add_done_callback(fn) - self.assertTrue(f.cancel()) - self.assertTrue(was_cancelled[0]) - - def test_done_callback_raises(self): - with captured_stderr() as stderr: - raising_was_called = [False] - fn_was_called = [False] - - def raising_fn(callback_future): - raising_was_called[0] = True - raise Exception('doh!') - - def fn(callback_future): - fn_was_called[0] = True - - f = Future() - f.add_done_callback(raising_fn) - f.add_done_callback(fn) - f.set_result(5) - self.assertTrue(raising_was_called) - self.assertTrue(fn_was_called) - self.assertIn('Exception: doh!', stderr.getvalue()) - - def test_done_callback_already_successful(self): - callback_result = [None] - def fn(callback_future): - callback_result[0] = callback_future.result() - - f = Future() - f.set_result(5) - f.add_done_callback(fn) - self.assertEqual(5, callback_result[0]) - - def test_done_callback_already_failed(self): - callback_exception = [None] - def fn(callback_future): - callback_exception[0] = callback_future.exception() - - f = Future() - f.set_exception(Exception('test')) - f.add_done_callback(fn) - self.assertEqual(('test',), callback_exception[0].args) - - def test_done_callback_already_cancelled(self): - was_cancelled = [None] - def fn(callback_future): - was_cancelled[0] = callback_future.cancelled() - - f = Future() - self.assertTrue(f.cancel()) - f.add_done_callback(fn) - self.assertTrue(was_cancelled[0]) - - def test_repr(self): - self.assertRegexpMatches(repr(PENDING_FUTURE), - '<Future at 0x[0-9a-f]+ state=pending>') - self.assertRegexpMatches(repr(RUNNING_FUTURE), - '<Future at 0x[0-9a-f]+ state=running>') - self.assertRegexpMatches(repr(CANCELLED_FUTURE), - '<Future at 0x[0-9a-f]+ state=cancelled>') - self.assertRegexpMatches(repr(CANCELLED_AND_NOTIFIED_FUTURE), - '<Future at 0x[0-9a-f]+ state=cancelled>') - self.assertRegexpMatches( - repr(EXCEPTION_FUTURE), - '<Future at 0x[0-9a-f]+ state=finished raised IOError>') - self.assertRegexpMatches( - repr(SUCCESSFUL_FUTURE), - '<Future at 0x[0-9a-f]+ state=finished returned int>') - - def test_cancel(self): - f1 = create_future(state=PENDING) - f2 = create_future(state=RUNNING) - f3 = create_future(state=CANCELLED) - f4 = create_future(state=CANCELLED_AND_NOTIFIED) - f5 = create_future(state=FINISHED, exception=IOError()) - f6 = create_future(state=FINISHED, result=5) - - self.assertTrue(f1.cancel()) - self.assertEqual(f1._state, CANCELLED) - - self.assertFalse(f2.cancel()) - self.assertEqual(f2._state, RUNNING) - - self.assertTrue(f3.cancel()) - self.assertEqual(f3._state, CANCELLED) - - self.assertTrue(f4.cancel()) - self.assertEqual(f4._state, CANCELLED_AND_NOTIFIED) - - self.assertFalse(f5.cancel()) - self.assertEqual(f5._state, FINISHED) - - self.assertFalse(f6.cancel()) - self.assertEqual(f6._state, FINISHED) - - def test_cancelled(self): - self.assertFalse(PENDING_FUTURE.cancelled()) - self.assertFalse(RUNNING_FUTURE.cancelled()) - self.assertTrue(CANCELLED_FUTURE.cancelled()) - self.assertTrue(CANCELLED_AND_NOTIFIED_FUTURE.cancelled()) - self.assertFalse(EXCEPTION_FUTURE.cancelled()) - self.assertFalse(SUCCESSFUL_FUTURE.cancelled()) - - def test_done(self): - self.assertFalse(PENDING_FUTURE.done()) - self.assertFalse(RUNNING_FUTURE.done()) - self.assertTrue(CANCELLED_FUTURE.done()) - self.assertTrue(CANCELLED_AND_NOTIFIED_FUTURE.done()) - self.assertTrue(EXCEPTION_FUTURE.done()) - self.assertTrue(SUCCESSFUL_FUTURE.done()) - - def test_running(self): - self.assertFalse(PENDING_FUTURE.running()) - self.assertTrue(RUNNING_FUTURE.running()) - self.assertFalse(CANCELLED_FUTURE.running()) - self.assertFalse(CANCELLED_AND_NOTIFIED_FUTURE.running()) - self.assertFalse(EXCEPTION_FUTURE.running()) - self.assertFalse(SUCCESSFUL_FUTURE.running()) - - def test_result_with_timeout(self): - self.assertRaises(futures.TimeoutError, - PENDING_FUTURE.result, timeout=0) - self.assertRaises(futures.TimeoutError, - RUNNING_FUTURE.result, timeout=0) - self.assertRaises(futures.CancelledError, - CANCELLED_FUTURE.result, timeout=0) - self.assertRaises(futures.CancelledError, - CANCELLED_AND_NOTIFIED_FUTURE.result, timeout=0) - self.assertRaises(IOError, EXCEPTION_FUTURE.result, timeout=0) - self.assertEqual(SUCCESSFUL_FUTURE.result(timeout=0), 42) - - def test_result_with_success(self): - # TODO(brian@sweetapp.com): This test is timing dependant. - def notification(): - # Wait until the main thread is waiting for the result. - time.sleep(1) - f1.set_result(42) - - f1 = create_future(state=PENDING) - t = threading.Thread(target=notification) - t.start() - - self.assertEqual(f1.result(timeout=5), 42) - - def test_result_with_cancel(self): - # TODO(brian@sweetapp.com): This test is timing dependant. - def notification(): - # Wait until the main thread is waiting for the result. - time.sleep(1) - f1.cancel() - - f1 = create_future(state=PENDING) - t = threading.Thread(target=notification) - t.start() - - self.assertRaises(futures.CancelledError, f1.result, timeout=5) - - def test_exception_with_timeout(self): - self.assertRaises(futures.TimeoutError, - PENDING_FUTURE.exception, timeout=0) - self.assertRaises(futures.TimeoutError, - RUNNING_FUTURE.exception, timeout=0) - self.assertRaises(futures.CancelledError, - CANCELLED_FUTURE.exception, timeout=0) - self.assertRaises(futures.CancelledError, - CANCELLED_AND_NOTIFIED_FUTURE.exception, timeout=0) - self.assertTrue(isinstance(EXCEPTION_FUTURE.exception(timeout=0), - IOError)) - self.assertEqual(SUCCESSFUL_FUTURE.exception(timeout=0), None) - - def test_exception_with_success(self): - def notification(): - # Wait until the main thread is waiting for the exception. - time.sleep(1) - with f1._condition: - f1._state = FINISHED - f1._exception = IOError() - f1._condition.notify_all() - - f1 = create_future(state=PENDING) - t = threading.Thread(target=notification) - t.start() - - self.assertTrue(isinstance(f1.exception(timeout=5), IOError)) - -@reap_threads -def test_main(): - try: - test_support.run_unittest(ProcessPoolExecutorTest, - ThreadPoolExecutorTest, - ProcessPoolWaitTests, - ThreadPoolWaitTests, - ProcessPoolAsCompletedTests, - ThreadPoolAsCompletedTests, - FutureTests, - ProcessPoolShutdownTest, - ThreadPoolShutdownTest) - finally: - test_support.reap_children() - -if __name__ == "__main__": - test_main() diff --git a/vim/bundle/YouCompleteMe/third_party/pythonfutures/tox.ini b/vim/bundle/YouCompleteMe/third_party/pythonfutures/tox.ini deleted file mode 100755 index c1ff2f1..0000000 --- a/vim/bundle/YouCompleteMe/third_party/pythonfutures/tox.ini +++ /dev/null @@ -1,8 +0,0 @@ -[tox] -envlist = py26,py27,py31 - -[testenv] -commands={envpython} test_futures.py [] - -[testenv:py26] -deps=unittest2 diff --git a/vim/bundle/YouCompleteMe/third_party/requests-futures/.gitignore b/vim/bundle/YouCompleteMe/third_party/requests-futures/.gitignore deleted file mode 100644 index 0f0a128..0000000 --- a/vim/bundle/YouCompleteMe/third_party/requests-futures/.gitignore +++ /dev/null @@ -1,4 +0,0 @@ -build/ -dist/ -*.egg-info/ -*.pyc diff --git a/vim/bundle/YouCompleteMe/third_party/requests-futures/.travis.yml b/vim/bundle/YouCompleteMe/third_party/requests-futures/.travis.yml deleted file mode 100644 index ada4746..0000000 --- a/vim/bundle/YouCompleteMe/third_party/requests-futures/.travis.yml +++ /dev/null @@ -1,11 +0,0 @@ -language: python -python: - - 2.7 - - 3.2 - - 3.3 -env: HTTPBIN_URL=http://httpbin.org/ -script: python test_requests_futures.py -install: pip install -r requirements-python-2.7.txt -notifications: - email: - - rwmcfa1@neces.com diff --git a/vim/bundle/YouCompleteMe/third_party/requests-futures/LICENSE b/vim/bundle/YouCompleteMe/third_party/requests-futures/LICENSE deleted file mode 100644 index 2a2a0c6..0000000 --- a/vim/bundle/YouCompleteMe/third_party/requests-futures/LICENSE +++ /dev/null @@ -1,13 +0,0 @@ -Copyright 2013 Ross McFarland - - 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. diff --git a/vim/bundle/YouCompleteMe/third_party/requests-futures/MANIFEST.in b/vim/bundle/YouCompleteMe/third_party/requests-futures/MANIFEST.in deleted file mode 100644 index b9d5079..0000000 --- a/vim/bundle/YouCompleteMe/third_party/requests-futures/MANIFEST.in +++ /dev/null @@ -1 +0,0 @@ -include README.rst LICENSE test_requests_futures.py requirements-python-2.7.txt requirements-python-3.2.txt diff --git a/vim/bundle/YouCompleteMe/third_party/requests-futures/README.rst b/vim/bundle/YouCompleteMe/third_party/requests-futures/README.rst deleted file mode 100644 index 5a25b22..0000000 --- a/vim/bundle/YouCompleteMe/third_party/requests-futures/README.rst +++ /dev/null @@ -1,110 +0,0 @@ -Asynchronous Python HTTP Requests for Humans -============================================ - -.. image:: https://travis-ci.org/ross/requests-futures.png?branch=master - :target: https://travis-ci.org/ross/requests-futures - -Small add-on for the python requests_ http library. Makes use of python 3.2's -`concurrent.futures`_ or the backport_ for prior versions of python. - -The additional API and changes are minimal and strives to avoid surprises. - -The following synchronous code: - -.. code-block:: python - - from requests import Session - - session = Session() - # first requests starts and blocks until finished - response_one = session.get('http://httpbin.org/get') - # second request starts once first is finished - response_two = session.get('http://httpbin.org/get?foo=bar') - # both requests are complete - print('response one status: {0}'.format(response_one.status_code)) - print(response_one.content) - print('response two status: {0}'.format(response_two.status_code)) - print(response_two.content) - -Can be translated to make use of futures, and thus be asynchronous by creating -a FuturesSession and catching the returned Future in place of Response. The -Response can be retrieved by calling the result method on the Future: - -.. code-block:: python - - from requests_futures.sessions import FuturesSession - - session = FuturesSession() - # first request is started in background - future_one = session.get('http://httpbin.org/get') - # second requests is started immediately - future_two = session.get('http://httpbin.org/get?foo=bar') - # wait for the first request to complete, if it hasn't already - response_one = future_one.result() - print('response one status: {0}'.format(response_one.status_code)) - print(response_one.content) - # wait for the second request to complete, if it hasn't already - response_two = future_two.result() - print('response two status: {0}'.format(response_two.status_code)) - print(response_two.content) - -By default a ThreadPoolExecutor is created with 2 workers. If you would like to -adjust that value or share a executor across multiple sessions you can provide -one to the FuturesSession constructor. - -.. code-block:: python - - from concurrent.futures import ThreadPoolExecutor - from requests_futures.sessions import FuturesSession - - session = FuturesSession(executor=ThreadPoolExecutor(max_workers=10)) - # ... - -As a shortcut in case of just increasing workers number you can pass -`max_workers` straight to the `FuturesSession` constructor: - -.. code-block:: python - - from requests_futures.sessions import FuturesSession - session = FuturesSession(max_workers=10) - -That's it. The api of requests.Session is preserved without any modifications -beyond returning a Future rather than Response. As with all futures exceptions -are shifted (thrown) to the future.result() call so try/except blocks should be -moved there. - -Working in the Background -========================= - -There is one additional parameter to the various request functions, -background_callback, which allows you to work with the Response objects in the -background thread. This can be useful for shifting work out of the foreground, -for a simple example take json parsing. - -.. code-block:: python - - from pprint import pprint - from requests_futures.sessions import FuturesSession - - session = FuturesSession() - - def bg_cb(sess, resp): - # parse the json storing the result on the response object - resp.data = resp.json() - - future = session.get('http://httpbin.org/get', background_callback=bg_cb) - # do some other stuff, send some more requests while this one works - response = future.result() - print('response status {0}'.format(response.status_code)) - # data will have been attached to the response object in the background - pprint(response.data) - - -Installation -============ - - pip install requests-futures - -.. _`requests`: https://github.com/kennethreitz/requests -.. _`concurrent.futures`: http://docs.python.org/dev/library/concurrent.futures.html -.. _backport: https://pypi.python.org/pypi/futures diff --git a/vim/bundle/YouCompleteMe/third_party/requests-futures/requests_futures/__init__.py b/vim/bundle/YouCompleteMe/third_party/requests-futures/requests_futures/__init__.py deleted file mode 100644 index af7acae..0000000 --- a/vim/bundle/YouCompleteMe/third_party/requests-futures/requests_futures/__init__.py +++ /dev/null @@ -1,28 +0,0 @@ -# -*- coding: utf-8 -*- - -# Requests Futures - -""" -async requests HTTP library -~~~~~~~~~~~~~~~~~~~~~ - - -""" - -__title__ = 'requests-futures' -__version__ = '0.9.4' -__build__ = 0x000000 -__author__ = 'Ross McFarland' -__license__ = 'Apache 2.0' -__copyright__ = 'Copyright 2013 Ross McFarland' - -# Set default logging handler to avoid "No handler found" warnings. -import logging -try: # Python 2.7+ - from logging import NullHandler -except ImportError: - class NullHandler(logging.Handler): - def emit(self, record): - pass - -logging.getLogger(__name__).addHandler(NullHandler()) diff --git a/vim/bundle/YouCompleteMe/third_party/requests-futures/requests_futures/sessions.py b/vim/bundle/YouCompleteMe/third_party/requests-futures/requests_futures/sessions.py deleted file mode 100644 index ad2af1b..0000000 --- a/vim/bundle/YouCompleteMe/third_party/requests-futures/requests_futures/sessions.py +++ /dev/null @@ -1,73 +0,0 @@ -# -*- coding: utf-8 -*- -""" -requests_futures -~~~~~~~~~~~~~~~~ - -This module provides a small add-on for the requests http library. It makes use -of python 3.3's concurrent.futures or the futures backport for previous -releases of python. - - from requests_futures import FuturesSession - - session = FuturesSession() - # request is run in the background - future = session.get('http://httpbin.org/get') - # ... do other stuff ... - # wait for the request to complete, if it hasn't already - response = future.result() - print('response status: {0}'.format(response.status_code)) - print(response.content) - -""" - -from concurrent.futures import ThreadPoolExecutor -from requests import Session -from requests.adapters import DEFAULT_POOLSIZE, HTTPAdapter - -class FuturesSession(Session): - - def __init__(self, executor=None, max_workers=2, *args, **kwargs): - """Creates a FuturesSession - - Notes - ~~~~~ - - * ProcessPoolExecutor is not supported b/c Response objects are - not picklable. - - * If you provide both `executor` and `max_workers`, the latter is - ignored and provided executor is used as is. - """ - super(FuturesSession, self).__init__(*args, **kwargs) - if executor is None: - executor = ThreadPoolExecutor(max_workers=max_workers) - # set connection pool size equal to max_workers if needed - if max_workers > DEFAULT_POOLSIZE: - adapter_kwargs = dict(pool_connections=max_workers, - pool_maxsize=max_workers) - self.mount('https://', HTTPAdapter(**adapter_kwargs)) - self.mount('http://', HTTPAdapter(**adapter_kwargs)) - - self.executor = executor - - def request(self, *args, **kwargs): - """Maintains the existing api for Session.request. - - Used by all of the higher level methods, e.g. Session.get. - - The background_callback param allows you to do some processing on the - response in the background, e.g. call resp.json() so that json parsing - happens in the background thread. - """ - func = sup = super(FuturesSession, self).request - - background_callback = kwargs.pop('background_callback', None) - if background_callback: - def wrap(*args_, **kwargs_): - resp = sup(*args_, **kwargs_) - background_callback(self, resp) - return resp - - func = wrap - - return self.executor.submit(func, *args, **kwargs) diff --git a/vim/bundle/YouCompleteMe/third_party/requests-futures/requirements-python-2.7.txt b/vim/bundle/YouCompleteMe/third_party/requests-futures/requirements-python-2.7.txt deleted file mode 100644 index e70089a..0000000 --- a/vim/bundle/YouCompleteMe/third_party/requests-futures/requirements-python-2.7.txt +++ /dev/null @@ -1,2 +0,0 @@ -futures -requests>=1.2.0 diff --git a/vim/bundle/YouCompleteMe/third_party/requests-futures/requirements-python-3.2.txt b/vim/bundle/YouCompleteMe/third_party/requests-futures/requirements-python-3.2.txt deleted file mode 100644 index f250822..0000000 --- a/vim/bundle/YouCompleteMe/third_party/requests-futures/requirements-python-3.2.txt +++ /dev/null @@ -1 +0,0 @@ -requests>=1.2.0 diff --git a/vim/bundle/YouCompleteMe/third_party/requests-futures/setup.py b/vim/bundle/YouCompleteMe/third_party/requests-futures/setup.py deleted file mode 100644 index 3f100d7..0000000 --- a/vim/bundle/YouCompleteMe/third_party/requests-futures/setup.py +++ /dev/null @@ -1,56 +0,0 @@ -#!/usr/bin/env python - -import os -import sys - -import requests_futures - -try: - from setuptools import setup -except ImportError: - from distutils.core import setup - -if sys.argv[-1] == 'publish': - os.system('python setup.py sdist upload') - sys.exit() - -packages = [ - 'requests_futures', -] - -requires = [ - 'requests>=1.2.0' -] - -if sys.version_info < (3, 2): - requires.append('futures>=2.1.3') - -setup( - name='requests-futures', - version=requests_futures.__version__, - description='Asynchronous Python HTTP for Humans.', - long_description=open('README.rst').read(), - author='Ross McFarland', - author_email='rwmcfa1@neces.com', - packages=packages, - package_dir={'requests_futures': 'requests_futures'}, - package_data={'requests_futures': ['LICENSE', 'README.rst']}, - include_package_data=True, - install_requires=requires, - license='Apache License v2', - url='https://github.com/ross/requests-futures', - zip_safe=False, - classifiers=( - 'Development Status :: 5 - Production/Stable', - 'Intended Audience :: Developers', - 'Natural Language :: English', - 'License :: OSI Approved :: Apache Software License', - 'Programming Language :: Python', - 'Programming Language :: Python :: 2.6', - 'Programming Language :: Python :: 2.7', - 'Programming Language :: Python :: 3', - 'Programming Language :: Python :: 3.1', - 'Programming Language :: Python :: 3.2', - 'Programming Language :: Python :: 3.3', - ), -) diff --git a/vim/bundle/YouCompleteMe/third_party/requests-futures/test_requests_futures.py b/vim/bundle/YouCompleteMe/third_party/requests-futures/test_requests_futures.py deleted file mode 100644 index b41836e..0000000 --- a/vim/bundle/YouCompleteMe/third_party/requests-futures/test_requests_futures.py +++ /dev/null @@ -1,84 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -"""Tests for Requests.""" - -from concurrent.futures import Future -from requests import Response -from os import environ -from requests_futures.sessions import FuturesSession -from unittest import TestCase, main - -HTTPBIN = environ.get('HTTPBIN_URL', 'http://httpbin.org/') - -def httpbin(*suffix): - """Returns url for HTTPBIN resource.""" - return HTTPBIN + '/'.join(suffix) - - -class RequestsTestCase(TestCase): - - def test_futures_session(self): - # basic futures get - sess = FuturesSession() - future = sess.get(httpbin('get')) - self.assertIsInstance(future, Future) - resp = future.result() - self.assertIsInstance(resp, Response) - self.assertEqual(200, resp.status_code) - - # non-200, 404 - future = sess.get(httpbin('status/404')) - resp = future.result() - self.assertEqual(404, resp.status_code) - - def cb(s, r): - self.assertIsInstance(s, FuturesSession) - self.assertIsInstance(r, Response) - # add the parsed json data to the response - r.data = r.json() - - future = sess.get(httpbin('get'), background_callback=cb) - # this should block until complete - resp = future.result() - self.assertEqual(200, resp.status_code) - # make sure the callback was invoked - self.assertTrue(hasattr(resp, 'data')) - - def rasing_cb(s, r): - raise Exception('boom') - - future = sess.get(httpbin('get'), background_callback=rasing_cb) - with self.assertRaises(Exception) as cm: - resp = future.result() - self.assertEqual('boom', cm.exception.args[0]) - - def test_max_workers(self): - """ Tests the `max_workers` shortcut. """ - from concurrent.futures import ThreadPoolExecutor - session = FuturesSession() - self.assertEqual(session.executor._max_workers, 2) - session = FuturesSession(max_workers=5) - self.assertEqual(session.executor._max_workers, 5) - session = FuturesSession(executor=ThreadPoolExecutor(max_workers=10)) - self.assertEqual(session.executor._max_workers, 10) - session = FuturesSession(executor=ThreadPoolExecutor(max_workers=10), - max_workers=5) - self.assertEqual(session.executor._max_workers, 10) - - def test_redirect(self): - """ Tests for the ability to cleanly handle redirects. """ - sess = FuturesSession() - future = sess.get(httpbin('redirect-to?url=get')) - self.assertIsInstance(future, Future) - resp = future.result() - self.assertIsInstance(resp, Response) - self.assertEqual(200, resp.status_code) - - future = sess.get(httpbin('redirect-to?url=status/404')) - resp = future.result() - self.assertEqual(404, resp.status_code) - - -if __name__ == '__main__': - main() diff --git a/vim/bundle/YouCompleteMe/third_party/retries/retries.py b/vim/bundle/YouCompleteMe/third_party/retries/retries.py deleted file mode 100644 index da7fa48..0000000 --- a/vim/bundle/YouCompleteMe/third_party/retries/retries.py +++ /dev/null @@ -1,79 +0,0 @@ -#!/usr/bin/env python -# -# Copyright 2012 by Jeff Laughlin Consulting LLC -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - - -import sys -from time import sleep - -# Source: https://gist.github.com/n1ywb/2570004 - -def example_exc_handler(tries_remaining, exception, delay): - """Example exception handler; prints a warning to stderr. - - tries_remaining: The number of tries remaining. - exception: The exception instance which was raised. - """ - print >> sys.stderr, "Caught '%s', %d tries remaining, sleeping for %s seconds" % (exception, tries_remaining, delay) - - -def retries(max_tries, delay=1, backoff=2, exceptions=(Exception,), hook=None): - """Function decorator implementing retrying logic. - - delay: Sleep this many seconds * backoff * try number after failure - backoff: Multiply delay by this factor after each failure - exceptions: A tuple of exception classes; default (Exception,) - hook: A function with the signature myhook(tries_remaining, exception); - default None - - The decorator will call the function up to max_tries times if it raises - an exception. - - By default it catches instances of the Exception class and subclasses. - This will recover after all but the most fatal errors. You may specify a - custom tuple of exception classes with the 'exceptions' argument; the - function will only be retried if it raises one of the specified - exceptions. - - Additionally you may specify a hook function which will be called prior - to retrying with the number of remaining tries and the exception instance; - see given example. This is primarily intended to give the opportunity to - log the failure. Hook is not called after failure if no retries remain. - """ - def dec(func): - def f2(*args, **kwargs): - mydelay = delay - tries = reversed(range(max_tries)) - for tries_remaining in tries: - try: - return func(*args, **kwargs) - except exceptions as e: - if tries_remaining > 0: - if hook is not None: - hook(tries_remaining, e, mydelay) - sleep(mydelay) - mydelay = mydelay * backoff - else: - raise - else: - break - return f2 - return dec |