summaryrefslogtreecommitdiff
path: root/lib/sqlalchemy/util
diff options
context:
space:
mode:
Diffstat (limited to 'lib/sqlalchemy/util')
-rw-r--r--lib/sqlalchemy/util/__init__.py170
-rw-r--r--lib/sqlalchemy/util/_collections.py122
-rw-r--r--lib/sqlalchemy/util/compat.py100
-rw-r--r--lib/sqlalchemy/util/deprecations.py35
-rw-r--r--lib/sqlalchemy/util/langhelpers.py423
-rw-r--r--lib/sqlalchemy/util/queue.py2
-rw-r--r--lib/sqlalchemy/util/topological.py12
7 files changed, 546 insertions, 318 deletions
diff --git a/lib/sqlalchemy/util/__init__.py b/lib/sqlalchemy/util/__init__.py
index d8c28d6af..103225e2a 100644
--- a/lib/sqlalchemy/util/__init__.py
+++ b/lib/sqlalchemy/util/__init__.py
@@ -5,42 +5,146 @@
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
-from .compat import callable, cmp, reduce, \
- threading, py3k, py33, py36, py2k, jython, pypy, cpython, win32, \
- pickle, dottedgetter, parse_qsl, namedtuple, next, reraise, \
- raise_from_cause, text_type, safe_kwarg, string_types, int_types, \
- binary_type, nested, \
- quote_plus, with_metaclass, print_, itertools_filterfalse, u, ue, b,\
- unquote_plus, unquote, b64decode, b64encode, byte_buffer, itertools_filter,\
- iterbytes, StringIO, inspect_getargspec, zip_longest
+from .compat import (
+ callable,
+ cmp,
+ reduce,
+ threading,
+ py3k,
+ py33,
+ py36,
+ py2k,
+ jython,
+ pypy,
+ cpython,
+ win32,
+ pickle,
+ dottedgetter,
+ parse_qsl,
+ namedtuple,
+ next,
+ reraise,
+ raise_from_cause,
+ text_type,
+ safe_kwarg,
+ string_types,
+ int_types,
+ binary_type,
+ nested,
+ quote_plus,
+ with_metaclass,
+ print_,
+ itertools_filterfalse,
+ u,
+ ue,
+ b,
+ unquote_plus,
+ unquote,
+ b64decode,
+ b64encode,
+ byte_buffer,
+ itertools_filter,
+ iterbytes,
+ StringIO,
+ inspect_getargspec,
+ zip_longest,
+)
-from ._collections import KeyedTuple, ImmutableContainer, immutabledict, \
- Properties, OrderedProperties, ImmutableProperties, OrderedDict, \
- OrderedSet, IdentitySet, OrderedIdentitySet, column_set, \
- column_dict, ordered_column_set, populate_column_dict, unique_list, \
- UniqueAppender, PopulateDict, EMPTY_SET, to_list, to_set, \
- to_column_set, update_copy, flatten_iterator, has_intersection, \
- LRUCache, ScopedRegistry, ThreadLocalRegistry, WeakSequence, \
- coerce_generator_arg, lightweight_named_tuple, collections_abc, \
- has_dupes
+from ._collections import (
+ KeyedTuple,
+ ImmutableContainer,
+ immutabledict,
+ Properties,
+ OrderedProperties,
+ ImmutableProperties,
+ OrderedDict,
+ OrderedSet,
+ IdentitySet,
+ OrderedIdentitySet,
+ column_set,
+ column_dict,
+ ordered_column_set,
+ populate_column_dict,
+ unique_list,
+ UniqueAppender,
+ PopulateDict,
+ EMPTY_SET,
+ to_list,
+ to_set,
+ to_column_set,
+ update_copy,
+ flatten_iterator,
+ has_intersection,
+ LRUCache,
+ ScopedRegistry,
+ ThreadLocalRegistry,
+ WeakSequence,
+ coerce_generator_arg,
+ lightweight_named_tuple,
+ collections_abc,
+ has_dupes,
+)
-from .langhelpers import iterate_attributes, class_hierarchy, \
- portable_instancemethod, unbound_method_to_callable, \
- getargspec_init, format_argspec_init, format_argspec_plus, \
- get_func_kwargs, get_cls_kwargs, decorator, as_interface, \
- memoized_property, memoized_instancemethod, md5_hex, \
- group_expirable_memoized_property, dependencies, decode_slice, \
- monkeypatch_proxied_specials, asbool, bool_or_str, coerce_kw_type,\
- duck_type_collection, assert_arg_type, symbol, dictlike_iteritems,\
- classproperty, set_creation_order, warn_exception, warn, NoneType,\
- constructor_copy, methods_equivalent, chop_traceback, asint,\
- generic_repr, counter, PluginLoader, hybridproperty, hybridmethod, \
- safe_reraise, quoted_token_parser,\
- get_callable_argspec, only_once, attrsetter, ellipses_string, \
- warn_limited, map_bits, MemoizedSlots, EnsureKWArgType, wrap_callable
+from .langhelpers import (
+ iterate_attributes,
+ class_hierarchy,
+ portable_instancemethod,
+ unbound_method_to_callable,
+ getargspec_init,
+ format_argspec_init,
+ format_argspec_plus,
+ get_func_kwargs,
+ get_cls_kwargs,
+ decorator,
+ as_interface,
+ memoized_property,
+ memoized_instancemethod,
+ md5_hex,
+ group_expirable_memoized_property,
+ dependencies,
+ decode_slice,
+ monkeypatch_proxied_specials,
+ asbool,
+ bool_or_str,
+ coerce_kw_type,
+ duck_type_collection,
+ assert_arg_type,
+ symbol,
+ dictlike_iteritems,
+ classproperty,
+ set_creation_order,
+ warn_exception,
+ warn,
+ NoneType,
+ constructor_copy,
+ methods_equivalent,
+ chop_traceback,
+ asint,
+ generic_repr,
+ counter,
+ PluginLoader,
+ hybridproperty,
+ hybridmethod,
+ safe_reraise,
+ quoted_token_parser,
+ get_callable_argspec,
+ only_once,
+ attrsetter,
+ ellipses_string,
+ warn_limited,
+ map_bits,
+ MemoizedSlots,
+ EnsureKWArgType,
+ wrap_callable,
+)
-from .deprecations import warn_deprecated, warn_pending_deprecation, \
- deprecated, pending_deprecation, inject_docstring_text
+from .deprecations import (
+ warn_deprecated,
+ warn_pending_deprecation,
+ deprecated,
+ pending_deprecation,
+ inject_docstring_text,
+)
# things that used to be not always available,
# but are now as of current support Python versions
diff --git a/lib/sqlalchemy/util/_collections.py b/lib/sqlalchemy/util/_collections.py
index 43440134a..67be0e6bf 100644
--- a/lib/sqlalchemy/util/_collections.py
+++ b/lib/sqlalchemy/util/_collections.py
@@ -10,8 +10,13 @@
from __future__ import absolute_import
import weakref
import operator
-from .compat import threading, itertools_filterfalse, string_types, \
- binary_types, collections_abc
+from .compat import (
+ threading,
+ itertools_filterfalse,
+ string_types,
+ binary_types,
+ collections_abc,
+)
from . import py2k
import types
@@ -77,7 +82,7 @@ class KeyedTuple(AbstractKeyedTuple):
t.__dict__.update(zip(labels, vals))
else:
labels = []
- t.__dict__['_labels'] = labels
+ t.__dict__["_labels"] = labels
return t
@property
@@ -139,8 +144,7 @@ class ImmutableContainer(object):
class immutabledict(ImmutableContainer, dict):
- clear = pop = popitem = setdefault = \
- update = ImmutableContainer._immutable
+ clear = pop = popitem = setdefault = update = ImmutableContainer._immutable
def __new__(cls, *args):
new = dict.__new__(cls)
@@ -151,7 +155,7 @@ class immutabledict(ImmutableContainer, dict):
pass
def __reduce__(self):
- return immutabledict, (dict(self), )
+ return immutabledict, (dict(self),)
def union(self, d):
if not d:
@@ -173,10 +177,10 @@ class immutabledict(ImmutableContainer, dict):
class Properties(object):
"""Provide a __getattr__/__setattr__ interface over a dict."""
- __slots__ = '_data',
+ __slots__ = ("_data",)
def __init__(self, data):
- object.__setattr__(self, '_data', data)
+ object.__setattr__(self, "_data", data)
def __len__(self):
return len(self._data)
@@ -185,7 +189,9 @@ class Properties(object):
return iter(list(self._data.values()))
def __dir__(self):
- return dir(super(Properties, self)) + [str(k) for k in self._data.keys()]
+ return dir(super(Properties, self)) + [
+ str(k) for k in self._data.keys()
+ ]
def __add__(self, other):
return list(self) + list(other)
@@ -203,10 +209,10 @@ class Properties(object):
self._data[key] = obj
def __getstate__(self):
- return {'_data': self._data}
+ return {"_data": self._data}
def __setstate__(self, state):
- object.__setattr__(self, '_data', state['_data'])
+ object.__setattr__(self, "_data", state["_data"])
def __getattr__(self, key):
try:
@@ -266,7 +272,7 @@ class ImmutableProperties(ImmutableContainer, Properties):
class OrderedDict(dict):
"""A dict that returns keys/values/items in the order they were added."""
- __slots__ = '_list',
+ __slots__ = ("_list",)
def __reduce__(self):
return OrderedDict, (self.items(),)
@@ -294,7 +300,7 @@ class OrderedDict(dict):
def update(self, ____sequence=None, **kwargs):
if ____sequence is not None:
- if hasattr(____sequence, 'keys'):
+ if hasattr(____sequence, "keys"):
for key in ____sequence.keys():
self.__setitem__(key, ____sequence[key])
else:
@@ -323,6 +329,7 @@ class OrderedDict(dict):
return [(key, self[key]) for key in self._list]
if py2k:
+
def itervalues(self):
return iter(self.values())
@@ -402,7 +409,7 @@ class OrderedSet(set):
return self.union(other)
def __repr__(self):
- return '%s(%r)' % (self.__class__.__name__, self._list)
+ return "%s(%r)" % (self.__class__.__name__, self._list)
__str__ = __repr__
@@ -502,13 +509,13 @@ class IdentitySet(object):
pair = self._members.popitem()
return pair[1]
except KeyError:
- raise KeyError('pop from an empty set')
+ raise KeyError("pop from an empty set")
def clear(self):
self._members.clear()
def __cmp__(self, other):
- raise TypeError('cannot compare sets using cmp()')
+ raise TypeError("cannot compare sets using cmp()")
def __eq__(self, other):
if isinstance(other, IdentitySet):
@@ -527,8 +534,9 @@ class IdentitySet(object):
if len(self) > len(other):
return False
- for m in itertools_filterfalse(other._members.__contains__,
- iter(self._members.keys())):
+ for m in itertools_filterfalse(
+ other._members.__contains__, iter(self._members.keys())
+ ):
return False
return True
@@ -548,8 +556,9 @@ class IdentitySet(object):
if len(self) < len(other):
return False
- for m in itertools_filterfalse(self._members.__contains__,
- iter(other._members.keys())):
+ for m in itertools_filterfalse(
+ self._members.__contains__, iter(other._members.keys())
+ ):
return False
return True
@@ -635,7 +644,8 @@ class IdentitySet(object):
members = self._member_id_tuples()
other = _iter_id(iterable)
result._members.update(
- self._working_set(members).symmetric_difference(other))
+ self._working_set(members).symmetric_difference(other)
+ )
return result
def _member_id_tuples(self):
@@ -667,10 +677,10 @@ class IdentitySet(object):
return iter(self._members.values())
def __hash__(self):
- raise TypeError('set objects are unhashable')
+ raise TypeError("set objects are unhashable")
def __repr__(self):
- return '%s(%r)' % (type(self).__name__, list(self._members.values()))
+ return "%s(%r)" % (type(self).__name__, list(self._members.values()))
class WeakSequence(object):
@@ -689,8 +699,9 @@ class WeakSequence(object):
return len(self._storage)
def __iter__(self):
- return (obj for obj in
- (ref() for ref in self._storage) if obj is not None)
+ return (
+ obj for obj in (ref() for ref in self._storage) if obj is not None
+ )
def __getitem__(self, index):
try:
@@ -732,6 +743,7 @@ class PopulateDict(dict):
self[key] = val = self.creator(key)
return val
+
# Define collections that are capable of storing
# ColumnElement objects as hashable keys/elements.
# At this point, these are mostly historical, things
@@ -745,20 +757,21 @@ populate_column_dict = PopulateDict
_getters = PopulateDict(operator.itemgetter)
_property_getters = PopulateDict(
- lambda idx: property(operator.itemgetter(idx)))
+ lambda idx: property(operator.itemgetter(idx))
+)
def unique_list(seq, hashfunc=None):
seen = set()
seen_add = seen.add
if not hashfunc:
- return [x for x in seq
- if x not in seen
- and not seen_add(x)]
+ return [x for x in seq if x not in seen and not seen_add(x)]
else:
- return [x for x in seq
- if hashfunc(x) not in seen
- and not seen_add(hashfunc(x))]
+ return [
+ x
+ for x in seq
+ if hashfunc(x) not in seen and not seen_add(hashfunc(x))
+ ]
class UniqueAppender(object):
@@ -773,9 +786,9 @@ class UniqueAppender(object):
self._unique = {}
if via:
self._data_appender = getattr(data, via)
- elif hasattr(data, 'append'):
+ elif hasattr(data, "append"):
self._data_appender = data.append
- elif hasattr(data, 'add'):
+ elif hasattr(data, "add"):
self._data_appender = data.add
def append(self, item):
@@ -798,8 +811,9 @@ def coerce_generator_arg(arg):
def to_list(x, default=None):
if x is None:
return default
- if not isinstance(x, collections_abc.Iterable) or \
- isinstance(x, string_types + binary_types):
+ if not isinstance(x, collections_abc.Iterable) or isinstance(
+ x, string_types + binary_types
+ ):
return [x]
elif isinstance(x, list):
return x
@@ -815,9 +829,7 @@ def has_intersection(set_, iterable):
"""
# TODO: optimize, write in C, etc.
- return bool(
- set_.intersection([i for i in iterable if i.__hash__])
- )
+ return bool(set_.intersection([i for i in iterable if i.__hash__]))
def to_set(x):
@@ -854,7 +866,7 @@ def flatten_iterator(x):
"""
for elem in x:
- if not isinstance(elem, str) and hasattr(elem, '__iter__'):
+ if not isinstance(elem, str) and hasattr(elem, "__iter__"):
for y in flatten_iterator(elem):
yield y
else:
@@ -871,9 +883,9 @@ class LRUCache(dict):
"""
- __slots__ = 'capacity', 'threshold', 'size_alert', '_counter', '_mutex'
+ __slots__ = "capacity", "threshold", "size_alert", "_counter", "_mutex"
- def __init__(self, capacity=100, threshold=.5, size_alert=None):
+ def __init__(self, capacity=100, threshold=0.5, size_alert=None):
self.capacity = capacity
self.threshold = threshold
self.size_alert = size_alert
@@ -929,10 +941,10 @@ class LRUCache(dict):
if size_alert:
size_alert = False
self.size_alert(self)
- by_counter = sorted(dict.values(self),
- key=operator.itemgetter(2),
- reverse=True)
- for item in by_counter[self.capacity:]:
+ by_counter = sorted(
+ dict.values(self), key=operator.itemgetter(2), reverse=True
+ )
+ for item in by_counter[self.capacity :]:
try:
del self[item[0]]
except KeyError:
@@ -946,17 +958,22 @@ _lw_tuples = LRUCache(100)
def lightweight_named_tuple(name, fields):
- hash_ = (name, ) + tuple(fields)
+ hash_ = (name,) + tuple(fields)
tp_cls = _lw_tuples.get(hash_)
if tp_cls:
return tp_cls
tp_cls = type(
- name, (_LW,),
- dict([
- (field, _property_getters[idx])
- for idx, field in enumerate(fields) if field is not None
- ] + [('__slots__', ())])
+ name,
+ (_LW,),
+ dict(
+ [
+ (field, _property_getters[idx])
+ for idx, field in enumerate(fields)
+ if field is not None
+ ]
+ + [("__slots__", ())]
+ ),
)
tp_cls._real_fields = fields
@@ -1077,6 +1094,7 @@ def has_dupes(sequence, target):
return True
return False
+
# .index version. the two __contains__ calls as well
# as .index() and isinstance() slow this down.
# def has_dupes(sequence, target):
diff --git a/lib/sqlalchemy/util/compat.py b/lib/sqlalchemy/util/compat.py
index b01471edf..553624b49 100644
--- a/lib/sqlalchemy/util/compat.py
+++ b/lib/sqlalchemy/util/compat.py
@@ -20,9 +20,9 @@ py32 = sys.version_info >= (3, 2)
py3k = sys.version_info >= (3, 0)
py2k = sys.version_info < (3, 0)
py265 = sys.version_info >= (2, 6, 5)
-jython = sys.platform.startswith('java')
-pypy = hasattr(sys, 'pypy_version_info')
-win32 = sys.platform.startswith('win')
+jython = sys.platform.startswith("java")
+pypy = hasattr(sys, "pypy_version_info")
+win32 = sys.platform.startswith("win")
cpython = not pypy and not jython # TODO: something better for this ?
contextmanager = contextlib.contextmanager
@@ -30,8 +30,9 @@ dottedgetter = operator.attrgetter
namedtuple = collections.namedtuple
next = next
-ArgSpec = collections.namedtuple("ArgSpec",
- ["args", "varargs", "keywords", "defaults"])
+ArgSpec = collections.namedtuple(
+ "ArgSpec", ["args", "varargs", "keywords", "defaults"]
+)
try:
import threading
@@ -58,40 +59,43 @@ if py3k:
from io import BytesIO as byte_buffer
from io import StringIO
from itertools import zip_longest
- from urllib.parse import (quote_plus, unquote_plus, parse_qsl, quote, unquote)
-
- string_types = str,
- binary_types = bytes,
+ from urllib.parse import (
+ quote_plus,
+ unquote_plus,
+ parse_qsl,
+ quote,
+ unquote,
+ )
+
+ string_types = (str,)
+ binary_types = (bytes,)
binary_type = bytes
text_type = str
- int_types = int,
+ int_types = (int,)
iterbytes = iter
itertools_filterfalse = itertools.filterfalse
itertools_filter = filter
itertools_imap = map
- exec_ = getattr(builtins, 'exec')
- import_ = getattr(builtins, '__import__')
+ exec_ = getattr(builtins, "exec")
+ import_ = getattr(builtins, "__import__")
print_ = getattr(builtins, "print")
def b(s):
return s.encode("latin-1")
def b64decode(x):
- return base64.b64decode(x.encode('ascii'))
-
+ return base64.b64decode(x.encode("ascii"))
def b64encode(x):
- return base64.b64encode(x).decode('ascii')
+ return base64.b64encode(x).decode("ascii")
def cmp(a, b):
return (a > b) - (a < b)
def inspect_getargspec(func):
- return ArgSpec(
- *inspect_getfullargspec(func)[0:4]
- )
+ return ArgSpec(*inspect_getfullargspec(func)[0:4])
def reraise(tp, value, tb=None, cause=None):
if cause is not None:
@@ -110,8 +114,11 @@ if py3k:
if py32:
callable = callable
else:
+
def callable(fn):
- return hasattr(fn, '__call__')
+ return hasattr(fn, "__call__")
+
+
else:
import base64
import ConfigParser as configparser
@@ -129,8 +136,8 @@ else:
except ImportError:
import pickle
- string_types = basestring,
- binary_types = bytes,
+ string_types = (basestring,)
+ binary_types = (bytes,)
binary_type = str
text_type = unicode
int_types = int, long
@@ -153,9 +160,9 @@ else:
def exec_(func_text, globals_, lcl=None):
if lcl is None:
- exec('exec func_text in globals_')
+ exec("exec func_text in globals_")
else:
- exec('exec func_text in globals_, lcl')
+ exec("exec func_text in globals_, lcl")
def iterbytes(buf):
return (ord(byte) for byte in buf)
@@ -186,24 +193,32 @@ else:
# not as nice as that of Py3K, but at least preserves
# the code line where the issue occurred
- exec("def reraise(tp, value, tb=None, cause=None):\n"
- " if cause is not None:\n"
- " assert cause is not value, 'Same cause emitted'\n"
- " raise tp, value, tb\n")
+ exec(
+ "def reraise(tp, value, tb=None, cause=None):\n"
+ " if cause is not None:\n"
+ " assert cause is not value, 'Same cause emitted'\n"
+ " raise tp, value, tb\n"
+ )
if py35:
from inspect import formatannotation
def inspect_formatargspec(
- args, varargs=None, varkw=None, defaults=None,
- kwonlyargs=(), kwonlydefaults={}, annotations={},
- formatarg=str,
- formatvarargs=lambda name: '*' + name,
- formatvarkw=lambda name: '**' + name,
- formatvalue=lambda value: '=' + repr(value),
- formatreturns=lambda text: ' -> ' + text,
- formatannotation=formatannotation):
+ args,
+ varargs=None,
+ varkw=None,
+ defaults=None,
+ kwonlyargs=(),
+ kwonlydefaults={},
+ annotations={},
+ formatarg=str,
+ formatvarargs=lambda name: "*" + name,
+ formatvarkw=lambda name: "**" + name,
+ formatvalue=lambda value: "=" + repr(value),
+ formatreturns=lambda text: " -> " + text,
+ formatannotation=formatannotation,
+ ):
"""Copy formatargspec from python 3.7 standard library.
Python 3 has deprecated formatargspec and requested that Signature
@@ -221,7 +236,7 @@ if py35:
def formatargandannotation(arg):
result = formatarg(arg)
if arg in annotations:
- result += ': ' + formatannotation(annotations[arg])
+ result += ": " + formatannotation(annotations[arg])
return result
specs = []
@@ -237,7 +252,7 @@ if py35:
specs.append(formatvarargs(formatargandannotation(varargs)))
else:
if kwonlyargs:
- specs.append('*')
+ specs.append("*")
if kwonlyargs:
for kwonlyarg in kwonlyargs:
@@ -249,10 +264,12 @@ if py35:
if varkw is not None:
specs.append(formatvarkw(formatargandannotation(varkw)))
- result = '(' + ', '.join(specs) + ')'
- if 'return' in annotations:
- result += formatreturns(formatannotation(annotations['return']))
+ result = "(" + ", ".join(specs) + ")"
+ if "return" in annotations:
+ result += formatreturns(formatannotation(annotations["return"]))
return result
+
+
else:
from inspect import formatargspec as inspect_formatargspec
@@ -330,4 +347,5 @@ def with_metaclass(meta, *bases):
if this_bases is None:
return type.__new__(cls, name, (), d)
return meta(name, bases, d)
- return metaclass('temporary_class', None, {})
+
+ return metaclass("temporary_class", None, {})
diff --git a/lib/sqlalchemy/util/deprecations.py b/lib/sqlalchemy/util/deprecations.py
index 9000cc795..e6612f075 100644
--- a/lib/sqlalchemy/util/deprecations.py
+++ b/lib/sqlalchemy/util/deprecations.py
@@ -40,8 +40,7 @@ def deprecated(version, message=None, add_deprecation_to_docstring=True):
"""
if add_deprecation_to_docstring:
- header = ".. deprecated:: %s %s" % \
- (version, (message or ''))
+ header = ".. deprecated:: %s %s" % (version, (message or ""))
else:
header = None
@@ -50,13 +49,18 @@ def deprecated(version, message=None, add_deprecation_to_docstring=True):
def decorate(fn):
return _decorate_with_warning(
- fn, exc.SADeprecationWarning,
- message % dict(func=fn.__name__), header)
+ fn,
+ exc.SADeprecationWarning,
+ message % dict(func=fn.__name__),
+ header,
+ )
+
return decorate
-def pending_deprecation(version, message=None,
- add_deprecation_to_docstring=True):
+def pending_deprecation(
+ version, message=None, add_deprecation_to_docstring=True
+):
"""Decorates a function and issues a pending deprecation warning on use.
:param version:
@@ -74,8 +78,7 @@ def pending_deprecation(version, message=None,
"""
if add_deprecation_to_docstring:
- header = ".. deprecated:: %s (pending) %s" % \
- (version, (message or ''))
+ header = ".. deprecated:: %s (pending) %s" % (version, (message or ""))
else:
header = None
@@ -84,8 +87,12 @@ def pending_deprecation(version, message=None,
def decorate(fn):
return _decorate_with_warning(
- fn, exc.SAPendingDeprecationWarning,
- message % dict(func=fn.__name__), header)
+ fn,
+ exc.SAPendingDeprecationWarning,
+ message % dict(func=fn.__name__),
+ header,
+ )
+
return decorate
@@ -95,7 +102,8 @@ def _sanitize_restructured_text(text):
if type_ in ("func", "meth"):
name += "()"
return name
- return re.sub(r'\:(\w+)\:`~?\.?(.+?)`', repl, text)
+
+ return re.sub(r"\:(\w+)\:`~?\.?(.+?)`", repl, text)
def _decorate_with_warning(func, wtype, message, docstring_header=None):
@@ -108,7 +116,7 @@ def _decorate_with_warning(func, wtype, message, docstring_header=None):
warnings.warn(message, wtype, stacklevel=3)
return fn(*args, **kwargs)
- doc = func.__doc__ is not None and func.__doc__ or ''
+ doc = func.__doc__ is not None and func.__doc__ or ""
if docstring_header is not None:
docstring_header %= dict(func=func.__name__)
@@ -118,6 +126,7 @@ def _decorate_with_warning(func, wtype, message, docstring_header=None):
decorated.__doc__ = doc
return decorated
+
import textwrap
@@ -135,7 +144,7 @@ def _dedent_docstring(text):
def inject_docstring_text(doctext, injecttext, pos):
doctext = _dedent_docstring(doctext or "")
- lines = doctext.split('\n')
+ lines = doctext.split("\n")
injectlines = textwrap.dedent(injecttext).split("\n")
if injectlines[0]:
injectlines.insert(0, "")
diff --git a/lib/sqlalchemy/util/langhelpers.py b/lib/sqlalchemy/util/langhelpers.py
index 7e387f4f2..6a286998b 100644
--- a/lib/sqlalchemy/util/langhelpers.py
+++ b/lib/sqlalchemy/util/langhelpers.py
@@ -25,7 +25,7 @@ from . import _collections
def md5_hex(x):
if compat.py3k:
- x = x.encode('utf-8')
+ x = x.encode("utf-8")
m = hashlib.md5()
m.update(x)
return m.hexdigest()
@@ -49,7 +49,7 @@ class safe_reraise(object):
"""
- __slots__ = ('warn_only', '_exc_info')
+ __slots__ = ("warn_only", "_exc_info")
def __init__(self, warn_only=False):
self.warn_only = warn_only
@@ -61,7 +61,7 @@ class safe_reraise(object):
# see #2703 for notes
if type_ is None:
exc_type, exc_value, exc_tb = self._exc_info
- self._exc_info = None # remove potential circular references
+ self._exc_info = None # remove potential circular references
if not self.warn_only:
compat.reraise(exc_type, exc_value, exc_tb)
else:
@@ -71,8 +71,9 @@ class safe_reraise(object):
warn(
"An exception has occurred during handling of a "
"previous exception. The previous exception "
- "is:\n %s %s\n" % (self._exc_info[0], self._exc_info[1]))
- self._exc_info = None # remove potential circular references
+ "is:\n %s %s\n" % (self._exc_info[0], self._exc_info[1])
+ )
+ self._exc_info = None # remove potential circular references
compat.reraise(type_, value, traceback)
@@ -84,7 +85,7 @@ def decode_slice(slc):
"""
ret = []
for x in slc.start, slc.stop, slc.step:
- if hasattr(x, '__index__'):
+ if hasattr(x, "__index__"):
x = x.__index__()
ret.append(x)
return tuple(ret)
@@ -93,9 +94,10 @@ def decode_slice(slc):
def _unique_symbols(used, *bases):
used = set(used)
for base in bases:
- pool = itertools.chain((base,),
- compat.itertools_imap(lambda i: base + str(i),
- range(1000)))
+ pool = itertools.chain(
+ (base,),
+ compat.itertools_imap(lambda i: base + str(i), range(1000)),
+ )
for sym in pool:
if sym not in used:
used.add(sym)
@@ -122,21 +124,25 @@ def decorator(target):
raise Exception("not a decoratable function")
spec = compat.inspect_getfullargspec(fn)
names = tuple(spec[0]) + spec[1:3] + (fn.__name__,)
- targ_name, fn_name = _unique_symbols(names, 'target', 'fn')
+ targ_name, fn_name = _unique_symbols(names, "target", "fn")
metadata = dict(target=targ_name, fn=fn_name)
metadata.update(format_argspec_plus(spec, grouped=False))
- metadata['name'] = fn.__name__
- code = """\
+ metadata["name"] = fn.__name__
+ code = (
+ """\
def %(name)s(%(args)s):
return %(target)s(%(fn)s, %(apply_kw)s)
-""" % metadata
- decorated = _exec_code_in_env(code,
- {targ_name: target, fn_name: fn},
- fn.__name__)
- decorated.__defaults__ = getattr(fn, 'im_func', fn).__defaults__
+"""
+ % metadata
+ )
+ decorated = _exec_code_in_env(
+ code, {targ_name: target, fn_name: fn}, fn.__name__
+ )
+ decorated.__defaults__ = getattr(fn, "im_func", fn).__defaults__
decorated.__wrapped__ = fn
return update_wrapper(decorated, fn)
+
return update_wrapper(decorate, target)
@@ -155,31 +161,38 @@ def public_factory(target, location):
if isinstance(target, type):
fn = target.__init__
callable_ = target
- doc = "Construct a new :class:`.%s` object. \n\n"\
- "This constructor is mirrored as a public API function; "\
- "see :func:`~%s` "\
- "for a full usage and argument description." % (
- target.__name__, location, )
+ doc = (
+ "Construct a new :class:`.%s` object. \n\n"
+ "This constructor is mirrored as a public API function; "
+ "see :func:`~%s` "
+ "for a full usage and argument description."
+ % (target.__name__, location)
+ )
else:
fn = callable_ = target
- doc = "This function is mirrored; see :func:`~%s` "\
+ doc = (
+ "This function is mirrored; see :func:`~%s` "
"for a description of arguments." % location
+ )
location_name = location.split(".")[-1]
spec = compat.inspect_getfullargspec(fn)
del spec[0][0]
metadata = format_argspec_plus(spec, grouped=False)
- metadata['name'] = location_name
- code = """\
+ metadata["name"] = location_name
+ code = (
+ """\
def %(name)s(%(args)s):
return cls(%(apply_kw)s)
-""" % metadata
- env = {'cls': callable_, 'symbol': symbol}
+"""
+ % metadata
+ )
+ env = {"cls": callable_, "symbol": symbol}
exec(code, env)
decorated = env[location_name]
decorated.__doc__ = fn.__doc__
decorated.__module__ = "sqlalchemy" + location.rsplit(".", 1)[0]
- if compat.py2k or hasattr(fn, '__func__'):
+ if compat.py2k or hasattr(fn, "__func__"):
fn.__func__.__doc__ = doc
else:
fn.__doc__ = doc
@@ -187,7 +200,6 @@ def %(name)s(%(args)s):
class PluginLoader(object):
-
def __init__(self, group, auto_fn=None):
self.group = group
self.impls = {}
@@ -211,14 +223,13 @@ class PluginLoader(object):
except ImportError:
pass
else:
- for impl in pkg_resources.iter_entry_points(
- self.group, name):
+ for impl in pkg_resources.iter_entry_points(self.group, name):
self.impls[name] = impl.load
return impl.load()
raise exc.NoSuchModuleError(
- "Can't load plugin: %s:%s" %
- (self.group, name))
+ "Can't load plugin: %s:%s" % (self.group, name)
+ )
def register(self, name, modulepath, objname):
def load():
@@ -226,6 +237,7 @@ class PluginLoader(object):
for token in modulepath.split(".")[1:]:
mod = getattr(mod, token)
return getattr(mod, objname)
+
self.impls[name] = load
@@ -245,10 +257,13 @@ def get_cls_kwargs(cls, _set=None):
if toplevel:
_set = set()
- ctr = cls.__dict__.get('__init__', False)
+ ctr = cls.__dict__.get("__init__", False)
- has_init = ctr and isinstance(ctr, types.FunctionType) and \
- isinstance(ctr.__code__, types.CodeType)
+ has_init = (
+ ctr
+ and isinstance(ctr, types.FunctionType)
+ and isinstance(ctr.__code__, types.CodeType)
+ )
if has_init:
names, has_kw = inspect_func_args(ctr)
@@ -262,7 +277,7 @@ def get_cls_kwargs(cls, _set=None):
if get_cls_kwargs(c, _set) is None:
break
- _set.discard('self')
+ _set.discard("self")
return _set
@@ -278,7 +293,9 @@ try:
has_kw = bool(co.co_flags & CO_VARKEYWORDS)
return args, has_kw
+
except ImportError:
+
def inspect_func_args(fn):
names, _, has_kw, _ = compat.inspect_getargspec(fn)
return names, bool(has_kw)
@@ -309,23 +326,26 @@ def get_callable_argspec(fn, no_self=False, _is_init=False):
elif inspect.isfunction(fn):
if _is_init and no_self:
spec = compat.inspect_getargspec(fn)
- return compat.ArgSpec(spec.args[1:], spec.varargs,
- spec.keywords, spec.defaults)
+ return compat.ArgSpec(
+ spec.args[1:], spec.varargs, spec.keywords, spec.defaults
+ )
else:
return compat.inspect_getargspec(fn)
elif inspect.ismethod(fn):
if no_self and (_is_init or fn.__self__):
spec = compat.inspect_getargspec(fn.__func__)
- return compat.ArgSpec(spec.args[1:], spec.varargs,
- spec.keywords, spec.defaults)
+ return compat.ArgSpec(
+ spec.args[1:], spec.varargs, spec.keywords, spec.defaults
+ )
else:
return compat.inspect_getargspec(fn.__func__)
elif inspect.isclass(fn):
return get_callable_argspec(
- fn.__init__, no_self=no_self, _is_init=True)
- elif hasattr(fn, '__func__'):
+ fn.__init__, no_self=no_self, _is_init=True
+ )
+ elif hasattr(fn, "__func__"):
return compat.inspect_getargspec(fn.__func__)
- elif hasattr(fn, '__call__'):
+ elif hasattr(fn, "__call__"):
if inspect.ismethod(fn.__call__):
return get_callable_argspec(fn.__call__, no_self=no_self)
else:
@@ -375,13 +395,14 @@ def format_argspec_plus(fn, grouped=True):
if spec[0]:
self_arg = spec[0][0]
elif spec[1]:
- self_arg = '%s[0]' % spec[1]
+ self_arg = "%s[0]" % spec[1]
else:
self_arg = None
if compat.py3k:
apply_pos = compat.inspect_formatargspec(
- spec[0], spec[1], spec[2], None, spec[4])
+ spec[0], spec[1], spec[2], None, spec[4]
+ )
num_defaults = 0
if spec[3]:
num_defaults += len(spec[3])
@@ -396,19 +417,31 @@ def format_argspec_plus(fn, grouped=True):
name_args = spec[0]
if num_defaults:
- defaulted_vals = name_args[0 - num_defaults:]
+ defaulted_vals = name_args[0 - num_defaults :]
else:
defaulted_vals = ()
apply_kw = compat.inspect_formatargspec(
- name_args, spec[1], spec[2], defaulted_vals,
- formatvalue=lambda x: '=' + x)
+ name_args,
+ spec[1],
+ spec[2],
+ defaulted_vals,
+ formatvalue=lambda x: "=" + x,
+ )
if grouped:
- return dict(args=args, self_arg=self_arg,
- apply_pos=apply_pos, apply_kw=apply_kw)
+ return dict(
+ args=args,
+ self_arg=self_arg,
+ apply_pos=apply_pos,
+ apply_kw=apply_kw,
+ )
else:
- return dict(args=args[1:-1], self_arg=self_arg,
- apply_pos=apply_pos[1:-1], apply_kw=apply_kw[1:-1])
+ return dict(
+ args=args[1:-1],
+ self_arg=self_arg,
+ apply_pos=apply_pos[1:-1],
+ apply_kw=apply_kw[1:-1],
+ )
def format_argspec_init(method, grouped=True):
@@ -422,14 +455,17 @@ def format_argspec_init(method, grouped=True):
"""
if method is object.__init__:
- args = grouped and '(self)' or 'self'
+ args = grouped and "(self)" or "self"
else:
try:
return format_argspec_plus(method, grouped=grouped)
except TypeError:
- args = (grouped and '(self, *args, **kwargs)'
- or 'self, *args, **kwargs')
- return dict(self_arg='self', args=args, apply_pos=args, apply_kw=args)
+ args = (
+ grouped
+ and "(self, *args, **kwargs)"
+ or "self, *args, **kwargs"
+ )
+ return dict(self_arg="self", args=args, apply_pos=args, apply_kw=args)
def getargspec_init(method):
@@ -445,9 +481,9 @@ def getargspec_init(method):
return compat.inspect_getargspec(method)
except TypeError:
if method is object.__init__:
- return (['self'], None, None, None)
+ return (["self"], None, None, None)
else:
- return (['self'], 'args', 'kwargs', None)
+ return (["self"], "args", "kwargs", None)
def unbound_method_to_callable(func_or_cls):
@@ -479,8 +515,9 @@ def generic_repr(obj, additional_kw=(), to_inspect=None, omit_kwarg=()):
vargs = None
for i, insp in enumerate(to_inspect):
try:
- (_args, _vargs, vkw, defaults) = \
- compat.inspect_getargspec(insp.__init__)
+ (_args, _vargs, vkw, defaults) = compat.inspect_getargspec(
+ insp.__init__
+ )
except TypeError:
continue
else:
@@ -493,16 +530,17 @@ def generic_repr(obj, additional_kw=(), to_inspect=None, omit_kwarg=()):
else:
pos_args.extend(_args[1:])
else:
- kw_args.update([
- (arg, missing) for arg in _args[1:-default_len]
- ])
+ kw_args.update(
+ [(arg, missing) for arg in _args[1:-default_len]]
+ )
if default_len:
- kw_args.update([
- (arg, default)
- for arg, default
- in zip(_args[-default_len:], defaults)
- ])
+ kw_args.update(
+ [
+ (arg, default)
+ for arg, default in zip(_args[-default_len:], defaults)
+ ]
+ )
output = []
output.extend(repr(getattr(obj, arg, None)) for arg in pos_args)
@@ -516,7 +554,7 @@ def generic_repr(obj, additional_kw=(), to_inspect=None, omit_kwarg=()):
try:
val = getattr(obj, arg, missing)
if val is not missing and val != defval:
- output.append('%s=%r' % (arg, val))
+ output.append("%s=%r" % (arg, val))
except Exception:
pass
@@ -525,7 +563,7 @@ def generic_repr(obj, additional_kw=(), to_inspect=None, omit_kwarg=()):
try:
val = getattr(obj, arg, missing)
if val is not missing and val != defval:
- output.append('%s=%r' % (arg, val))
+ output.append("%s=%r" % (arg, val))
except Exception:
pass
@@ -538,16 +576,19 @@ class portable_instancemethod(object):
"""
- __slots__ = 'target', 'name', 'kwargs', '__weakref__'
+ __slots__ = "target", "name", "kwargs", "__weakref__"
def __getstate__(self):
- return {'target': self.target, 'name': self.name,
- 'kwargs': self.kwargs}
+ return {
+ "target": self.target,
+ "name": self.name,
+ "kwargs": self.kwargs,
+ }
def __setstate__(self, state):
- self.target = state['target']
- self.name = state['name']
- self.kwargs = state.get('kwargs', ())
+ self.target = state["target"]
+ self.name = state["name"]
+ self.kwargs = state.get("kwargs", ())
def __init__(self, meth, kwargs=()):
self.target = meth.__self__
@@ -583,8 +624,11 @@ def class_hierarchy(cls):
if compat.py2k:
if isinstance(c, types.ClassType):
continue
- bases = (_ for _ in c.__bases__
- if _ not in hier and not isinstance(_, types.ClassType))
+ bases = (
+ _
+ for _ in c.__bases__
+ if _ not in hier and not isinstance(_, types.ClassType)
+ )
else:
bases = (_ for _ in c.__bases__ if _ not in hier)
@@ -593,11 +637,12 @@ def class_hierarchy(cls):
hier.add(b)
if compat.py3k:
- if c.__module__ == 'builtins' or not hasattr(c, '__subclasses__'):
+ if c.__module__ == "builtins" or not hasattr(c, "__subclasses__"):
continue
else:
- if c.__module__ == '__builtin__' or not hasattr(
- c, '__subclasses__'):
+ if c.__module__ == "__builtin__" or not hasattr(
+ c, "__subclasses__"
+ ):
continue
for s in [_ for _ in c.__subclasses__() if _ not in hier]:
@@ -622,26 +667,45 @@ def iterate_attributes(cls):
break
-def monkeypatch_proxied_specials(into_cls, from_cls, skip=None, only=None,
- name='self.proxy', from_instance=None):
+def monkeypatch_proxied_specials(
+ into_cls,
+ from_cls,
+ skip=None,
+ only=None,
+ name="self.proxy",
+ from_instance=None,
+):
"""Automates delegation of __specials__ for a proxying type."""
if only:
dunders = only
else:
if skip is None:
- skip = ('__slots__', '__del__', '__getattribute__',
- '__metaclass__', '__getstate__', '__setstate__')
- dunders = [m for m in dir(from_cls)
- if (m.startswith('__') and m.endswith('__') and
- not hasattr(into_cls, m) and m not in skip)]
+ skip = (
+ "__slots__",
+ "__del__",
+ "__getattribute__",
+ "__metaclass__",
+ "__getstate__",
+ "__setstate__",
+ )
+ dunders = [
+ m
+ for m in dir(from_cls)
+ if (
+ m.startswith("__")
+ and m.endswith("__")
+ and not hasattr(into_cls, m)
+ and m not in skip
+ )
+ ]
for method in dunders:
try:
fn = getattr(from_cls, method)
- if not hasattr(fn, '__call__'):
+ if not hasattr(fn, "__call__"):
continue
- fn = getattr(fn, 'im_func', fn)
+ fn = getattr(fn, "im_func", fn)
except AttributeError:
continue
try:
@@ -649,11 +713,13 @@ def monkeypatch_proxied_specials(into_cls, from_cls, skip=None, only=None,
fn_args = compat.inspect_formatargspec(spec[0])
d_args = compat.inspect_formatargspec(spec[0][1:])
except TypeError:
- fn_args = '(self, *args, **kw)'
- d_args = '(*args, **kw)'
+ fn_args = "(self, *args, **kw)"
+ d_args = "(*args, **kw)"
- py = ("def %(method)s%(fn_args)s: "
- "return %(name)s.%(method)s%(d_args)s" % locals())
+ py = (
+ "def %(method)s%(fn_args)s: "
+ "return %(name)s.%(method)s%(d_args)s" % locals()
+ )
env = from_instance is not None and {name: from_instance} or {}
compat.exec_(py, env)
@@ -667,8 +733,9 @@ def monkeypatch_proxied_specials(into_cls, from_cls, skip=None, only=None,
def methods_equivalent(meth1, meth2):
"""Return True if the two methods are the same implementation."""
- return getattr(meth1, '__func__', meth1) is getattr(
- meth2, '__func__', meth2)
+ return getattr(meth1, "__func__", meth1) is getattr(
+ meth2, "__func__", meth2
+ )
def as_interface(obj, cls=None, methods=None, required=None):
@@ -705,12 +772,12 @@ def as_interface(obj, cls=None, methods=None, required=None):
"""
if not cls and not methods:
- raise TypeError('a class or collection of method names are required')
+ raise TypeError("a class or collection of method names are required")
if isinstance(cls, type) and isinstance(obj, cls):
return obj
- interface = set(methods or [m for m in dir(cls) if not m.startswith('_')])
+ interface = set(methods or [m for m in dir(cls) if not m.startswith("_")])
implemented = set(dir(obj))
complies = operator.ge
@@ -727,15 +794,17 @@ def as_interface(obj, cls=None, methods=None, required=None):
# No dict duck typing here.
if not isinstance(obj, dict):
- qualifier = complies is operator.gt and 'any of' or 'all of'
- raise TypeError("%r does not implement %s: %s" % (
- obj, qualifier, ', '.join(interface)))
+ qualifier = complies is operator.gt and "any of" or "all of"
+ raise TypeError(
+ "%r does not implement %s: %s"
+ % (obj, qualifier, ", ".join(interface))
+ )
class AnonymousInterface(object):
"""A callable-holding shell."""
if cls:
- AnonymousInterface.__name__ = 'Anonymous' + cls.__name__
+ AnonymousInterface.__name__ = "Anonymous" + cls.__name__
found = set()
for method, impl in dictlike_iteritems(obj):
@@ -749,8 +818,10 @@ def as_interface(obj, cls=None, methods=None, required=None):
if complies(found, required):
return AnonymousInterface
- raise TypeError("dictionary does not contain required keys %s" %
- ', '.join(required - found))
+ raise TypeError(
+ "dictionary does not contain required keys %s"
+ % ", ".join(required - found)
+ )
class memoized_property(object):
@@ -791,6 +862,7 @@ def memoized_instancemethod(fn):
memo.__doc__ = fn.__doc__
self.__dict__[fn.__name__] = memo
return result
+
return update_wrapper(oneshot, fn)
@@ -831,14 +903,14 @@ class MemoizedSlots(object):
raise AttributeError(key)
def __getattr__(self, key):
- if key.startswith('_memoized'):
+ if key.startswith("_memoized"):
raise AttributeError(key)
- elif hasattr(self, '_memoized_attr_%s' % key):
- value = getattr(self, '_memoized_attr_%s' % key)()
+ elif hasattr(self, "_memoized_attr_%s" % key):
+ value = getattr(self, "_memoized_attr_%s" % key)()
setattr(self, key, value)
return value
- elif hasattr(self, '_memoized_method_%s' % key):
- fn = getattr(self, '_memoized_method_%s' % key)
+ elif hasattr(self, "_memoized_method_%s" % key):
+ fn = getattr(self, "_memoized_method_%s" % key)
def oneshot(*args, **kw):
result = fn(*args, **kw)
@@ -847,6 +919,7 @@ class MemoizedSlots(object):
memo.__doc__ = fn.__doc__
setattr(self, key, memo)
return result
+
oneshot.__doc__ = fn.__doc__
return oneshot
else:
@@ -859,12 +932,14 @@ def dependency_for(modulename, add_to_all=False):
# unfortunately importlib doesn't work that great either
tokens = modulename.split(".")
mod = compat.import_(
- ".".join(tokens[0:-1]), globals(), locals(), [tokens[-1]])
+ ".".join(tokens[0:-1]), globals(), locals(), [tokens[-1]]
+ )
mod = getattr(mod, tokens[-1])
setattr(mod, obj.__name__, obj)
if add_to_all and hasattr(mod, "__all__"):
mod.__all__.append(obj.__name__)
return obj
+
return decorate
@@ -891,10 +966,7 @@ class dependencies(object):
for dep in deps:
tokens = dep.split(".")
self.import_deps.append(
- dependencies._importlater(
- ".".join(tokens[0:-1]),
- tokens[-1]
- )
+ dependencies._importlater(".".join(tokens[0:-1]), tokens[-1])
)
def __call__(self, fn):
@@ -902,7 +974,7 @@ class dependencies(object):
spec = compat.inspect_getfullargspec(fn)
spec_zero = list(spec[0])
- hasself = spec_zero[0] in ('self', 'cls')
+ hasself = spec_zero[0] in ("self", "cls")
for i in range(len(import_deps)):
spec[0][i + (1 if hasself else 0)] = "import_deps[%r]" % i
@@ -915,13 +987,13 @@ class dependencies(object):
outer_spec = format_argspec_plus(spec, grouped=False)
- code = 'lambda %(args)s: fn(%(apply_kw)s)' % {
- "args": outer_spec['args'],
- "apply_kw": inner_spec['apply_kw']
+ code = "lambda %(args)s: fn(%(apply_kw)s)" % {
+ "args": outer_spec["args"],
+ "apply_kw": inner_spec["apply_kw"],
}
decorated = eval(code, locals())
- decorated.__defaults__ = getattr(fn, 'im_func', fn).__defaults__
+ decorated.__defaults__ = getattr(fn, "im_func", fn).__defaults__
return update_wrapper(decorated, fn)
@classmethod
@@ -961,26 +1033,27 @@ class dependencies(object):
raise ImportError(
"importlater.resolve_all() hasn't "
"been called (this is %s %s)"
- % (self._il_path, self._il_addtl))
+ % (self._il_path, self._il_addtl)
+ )
return getattr(self._initial_import, self._il_addtl)
def _resolve(self):
dependencies._unresolved.discard(self)
self._initial_import = compat.import_(
- self._il_path, globals(), locals(),
- [self._il_addtl])
+ self._il_path, globals(), locals(), [self._il_addtl]
+ )
def __getattr__(self, key):
- if key == 'module':
- raise ImportError("Could not resolve module %s"
- % self._full_path)
+ if key == "module":
+ raise ImportError(
+ "Could not resolve module %s" % self._full_path
+ )
try:
attr = getattr(self.module, key)
except AttributeError:
raise AttributeError(
- "Module %s has no attribute '%s'" %
- (self._full_path, key)
+ "Module %s has no attribute '%s'" % (self._full_path, key)
)
self.__dict__[key] = attr
return attr
@@ -990,9 +1063,9 @@ class dependencies(object):
def asbool(obj):
if isinstance(obj, compat.string_types):
obj = obj.strip().lower()
- if obj in ['true', 'yes', 'on', 'y', 't', '1']:
+ if obj in ["true", "yes", "on", "y", "t", "1"]:
return True
- elif obj in ['false', 'no', 'off', 'n', 'f', '0']:
+ elif obj in ["false", "no", "off", "n", "f", "0"]:
return False
else:
raise ValueError("String is not true/false: %r" % obj)
@@ -1004,11 +1077,13 @@ def bool_or_str(*text):
boolean, or one of a set of "alternate" string values.
"""
+
def bool_or_value(obj):
if obj in text:
return obj
else:
return asbool(obj)
+
return bool_or_value
@@ -1026,9 +1101,11 @@ def coerce_kw_type(kw, key, type_, flexi_bool=True):
when coercing to boolean.
"""
- if key in kw and (
- not isinstance(type_, type) or not isinstance(kw[key], type_)
- ) and kw[key] is not None:
+ if (
+ key in kw
+ and (not isinstance(type_, type) or not isinstance(kw[key], type_))
+ and kw[key] is not None
+ ):
if type_ is bool and flexi_bool:
kw[key] = asbool(kw[key])
else:
@@ -1044,8 +1121,8 @@ def constructor_copy(obj, cls, *args, **kw):
names = get_cls_kwargs(cls)
kw.update(
- (k, obj.__dict__[k]) for k in names.difference(kw)
- if k in obj.__dict__)
+ (k, obj.__dict__[k]) for k in names.difference(kw) if k in obj.__dict__
+ )
return cls(*args, **kw)
@@ -1072,10 +1149,11 @@ def duck_type_collection(specimen, default=None):
property is present, return that preferentially.
"""
- if hasattr(specimen, '__emulates__'):
+ if hasattr(specimen, "__emulates__"):
# canonicalize set vs sets.Set to a standard: the builtin set
- if (specimen.__emulates__ is not None and
- issubclass(specimen.__emulates__, set)):
+ if specimen.__emulates__ is not None and issubclass(
+ specimen.__emulates__, set
+ ):
return set
else:
return specimen.__emulates__
@@ -1088,11 +1166,11 @@ def duck_type_collection(specimen, default=None):
elif isa(specimen, dict):
return dict
- if hasattr(specimen, 'append'):
+ if hasattr(specimen, "append"):
return list
- elif hasattr(specimen, 'add'):
+ elif hasattr(specimen, "add"):
return set
- elif hasattr(specimen, 'set'):
+ elif hasattr(specimen, "set"):
return dict
else:
return default
@@ -1104,41 +1182,43 @@ def assert_arg_type(arg, argtype, name):
else:
if isinstance(argtype, tuple):
raise exc.ArgumentError(
- "Argument '%s' is expected to be one of type %s, got '%s'" %
- (name, ' or '.join("'%s'" % a for a in argtype), type(arg)))
+ "Argument '%s' is expected to be one of type %s, got '%s'"
+ % (name, " or ".join("'%s'" % a for a in argtype), type(arg))
+ )
else:
raise exc.ArgumentError(
- "Argument '%s' is expected to be of type '%s', got '%s'" %
- (name, argtype, type(arg)))
+ "Argument '%s' is expected to be of type '%s', got '%s'"
+ % (name, argtype, type(arg))
+ )
def dictlike_iteritems(dictlike):
"""Return a (key, value) iterator for almost any dict-like object."""
if compat.py3k:
- if hasattr(dictlike, 'items'):
+ if hasattr(dictlike, "items"):
return list(dictlike.items())
else:
- if hasattr(dictlike, 'iteritems'):
+ if hasattr(dictlike, "iteritems"):
return dictlike.iteritems()
- elif hasattr(dictlike, 'items'):
+ elif hasattr(dictlike, "items"):
return iter(dictlike.items())
- getter = getattr(dictlike, '__getitem__', getattr(dictlike, 'get', None))
+ getter = getattr(dictlike, "__getitem__", getattr(dictlike, "get", None))
if getter is None:
- raise TypeError(
- "Object '%r' is not dict-like" % dictlike)
+ raise TypeError("Object '%r' is not dict-like" % dictlike)
+
+ if hasattr(dictlike, "iterkeys"):
- if hasattr(dictlike, 'iterkeys'):
def iterator():
for key in dictlike.iterkeys():
yield key, getter(key)
+
return iterator()
- elif hasattr(dictlike, 'keys'):
+ elif hasattr(dictlike, "keys"):
return iter((key, getter(key)) for key in dictlike.keys())
else:
- raise TypeError(
- "Object '%r' is not dict-like" % dictlike)
+ raise TypeError("Object '%r' is not dict-like" % dictlike)
class classproperty(property):
@@ -1207,7 +1287,8 @@ class _symbol(int):
def __repr__(self):
return "symbol(%r)" % self.name
-_symbol.__name__ = 'symbol'
+
+_symbol.__name__ = "symbol"
class symbol(object):
@@ -1231,6 +1312,7 @@ class symbol(object):
``doc`` here.
"""
+
symbols = {}
_lock = compat.threading.Lock()
@@ -1292,9 +1374,11 @@ class _hash_limit_string(compat.text_type):
"""
+
def __new__(cls, value, num, args):
- interpolated = (value % args) + \
- (" (this warning may be suppressed after %d occurrences)" % num)
+ interpolated = (value % args) + (
+ " (this warning may be suppressed after %d occurrences)" % num
+ )
self = super(_hash_limit_string, cls).__new__(cls, interpolated)
self._hash = hash("%s_%d" % (value, hash(interpolated) % num))
return self
@@ -1340,8 +1424,8 @@ def only_once(fn):
return go
-_SQLA_RE = re.compile(r'sqlalchemy/([a-z_]+/){0,2}[a-z_]+\.py')
-_UNITTEST_RE = re.compile(r'unit(?:2|test2?/)')
+_SQLA_RE = re.compile(r"sqlalchemy/([a-z_]+/){0,2}[a-z_]+\.py")
+_UNITTEST_RE = re.compile(r"unit(?:2|test2?/)")
def chop_traceback(tb, exclude_prefix=_UNITTEST_RE, exclude_suffix=_SQLA_RE):
@@ -1363,18 +1447,17 @@ def chop_traceback(tb, exclude_prefix=_UNITTEST_RE, exclude_suffix=_SQLA_RE):
start += 1
while start <= end and exclude_suffix.search(tb[end]):
end -= 1
- return tb[start:end + 1]
+ return tb[start : end + 1]
+
NoneType = type(None)
def attrsetter(attrname):
- code = \
- "def set(obj, value):"\
- " obj.%s = value" % attrname
+ code = "def set(obj, value):" " obj.%s = value" % attrname
env = locals().copy()
exec(code, env)
- return env['set']
+ return env["set"]
class EnsureKWArgType(type):
@@ -1382,6 +1465,7 @@ class EnsureKWArgType(type):
don't already.
"""
+
def __init__(cls, clsname, bases, clsdict):
fn_reg = cls.ensure_kwarg
if fn_reg:
@@ -1396,9 +1480,9 @@ class EnsureKWArgType(type):
super(EnsureKWArgType, cls).__init__(clsname, bases, clsdict)
def _wrap_w_kw(self, fn):
-
def wrap(*arg, **kw):
return fn(*arg)
+
return update_wrapper(wrap, fn)
@@ -1410,15 +1494,15 @@ def wrap_callable(wrapper, fn):
object with __call__ method
"""
- if hasattr(fn, '__name__'):
+ if hasattr(fn, "__name__"):
return update_wrapper(wrapper, fn)
else:
_f = wrapper
_f.__name__ = fn.__class__.__name__
- if hasattr(fn, '__module__'):
+ if hasattr(fn, "__module__"):
_f.__module__ = fn.__module__
- if hasattr(fn.__call__, '__doc__') and fn.__call__.__doc__:
+ if hasattr(fn.__call__, "__doc__") and fn.__call__.__doc__:
_f.__doc__ = fn.__call__.__doc__
elif fn.__doc__:
_f.__doc__ = fn.__doc__
@@ -1468,4 +1552,3 @@ def quoted_token_parser(value):
idx += 1
return ["".join(token) for token in result]
-
diff --git a/lib/sqlalchemy/util/queue.py b/lib/sqlalchemy/util/queue.py
index 640f70ea9..5e56e855a 100644
--- a/lib/sqlalchemy/util/queue.py
+++ b/lib/sqlalchemy/util/queue.py
@@ -23,7 +23,7 @@ from time import time as _time
from .compat import threading
-__all__ = ['Empty', 'Full', 'Queue']
+__all__ = ["Empty", "Full", "Queue"]
class Empty(Exception):
diff --git a/lib/sqlalchemy/util/topological.py b/lib/sqlalchemy/util/topological.py
index 5f516d67e..95391c31b 100644
--- a/lib/sqlalchemy/util/topological.py
+++ b/lib/sqlalchemy/util/topological.py
@@ -10,7 +10,7 @@
from ..exc import CircularDependencyError
from .. import util
-__all__ = ['sort', 'sort_as_subsets', 'find_cycles']
+__all__ = ["sort", "sort_as_subsets", "find_cycles"]
def sort_as_subsets(tuples, allitems, deterministic_order=False):
@@ -33,7 +33,7 @@ def sort_as_subsets(tuples, allitems, deterministic_order=False):
raise CircularDependencyError(
"Circular dependency detected.",
find_cycles(tuples, allitems),
- _gen_edges(edges)
+ _gen_edges(edges),
)
todo.difference_update(output)
@@ -79,7 +79,7 @@ def find_cycles(tuples, allitems):
top = stack[-1]
for node in edges[top]:
if node in stack:
- cyc = stack[stack.index(node):]
+ cyc = stack[stack.index(node) :]
todo.difference_update(cyc)
output.update(cyc)
@@ -93,8 +93,4 @@ def find_cycles(tuples, allitems):
def _gen_edges(edges):
- return set([
- (right, left)
- for left in edges
- for right in edges[left]
- ])
+ return set([(right, left) for left in edges for right in edges[left]])
View Lorry Controller Status