ansible-later/testenv/lib/python2.7/site-packages/toolz/_signatures.py

830 lines
22 KiB
Python
Raw Normal View History

2019-04-23 11:04:27 +00:00
"""Internal module for better introspection of builtins.
The main functions are ``is_builtin_valid_args``, ``is_builtin_partial_args``,
and ``has_unknown_args``. Other functions in this module support these three.
Notably, we create a ``signatures`` registry to enable introspection of
builtin functions in any Python version. This includes builtins that
have more than one valid signature. Currently, the registry includes
builtins from ``builtins``, ``functools``, ``itertools``, and ``operator``
modules. More can be added as requested. We don't guarantee full coverage.
Everything in this module should be regarded as implementation details.
Users should try to not use this module directly.
"""
import functools
import inspect
import itertools
import operator
from .compatibility import PY3, import_module
from .functoolz import (is_partial_args, is_arity, has_varargs,
has_keywords, num_required_args)
if PY3: # pragma: py2 no cover
import builtins
else: # pragma: py3 no cover
import __builtin__ as builtins
# We mock builtin callables using lists of tuples with lambda functions.
#
# The tuple spec is (num_position_args, lambda_func, keyword_only_args).
#
# num_position_args:
# - The number of positional-only arguments. If not specified,
# all positional arguments are considered positional-only.
#
# lambda_func:
# - lambda function that matches a signature of a builtin, but does
# not include keyword-only arguments.
#
# keyword_only_args: (optional)
# - Tuple of keyword-only argumemts.
module_info = {}
module_info[builtins] = dict(
abs=[
lambda x: None],
all=[
lambda iterable: None],
any=[
lambda iterable: None],
apply=[
lambda object: None,
lambda object, args: None,
lambda object, args, kwargs: None],
ascii=[
lambda obj: None],
bin=[
lambda number: None],
bool=[
lambda x=False: None],
buffer=[
lambda object: None,
lambda object, offset: None,
lambda object, offset, size: None],
bytearray=[
lambda: None,
lambda int: None,
lambda string, encoding='utf8', errors='strict': None],
callable=[
lambda obj: None],
chr=[
lambda i: None],
classmethod=[
lambda function: None],
cmp=[
lambda x, y: None],
coerce=[
lambda x, y: None],
complex=[
lambda real=0, imag=0: None],
delattr=[
lambda obj, name: None],
dict=[
lambda **kwargs: None,
lambda mapping, **kwargs: None],
dir=[
lambda: None,
lambda object: None],
divmod=[
lambda x, y: None],
enumerate=[
(0, lambda iterable, start=0: None)],
eval=[
lambda source: None,
lambda source, globals: None,
lambda source, globals, locals: None],
execfile=[
lambda filename: None,
lambda filename, globals: None,
lambda filename, globals, locals: None],
file=[
(0, lambda name, mode='r', buffering=-1: None)],
filter=[
lambda function, iterable: None],
float=[
lambda x=0.0: None],
format=[
lambda value: None,
lambda value, format_spec: None],
frozenset=[
lambda: None,
lambda iterable: None],
getattr=[
lambda object, name: None,
lambda object, name, default: None],
globals=[
lambda: None],
hasattr=[
lambda obj, name: None],
hash=[
lambda obj: None],
hex=[
lambda number: None],
id=[
lambda obj: None],
input=[
lambda: None,
lambda prompt: None],
int=[
lambda x=0: None,
(0, lambda x, base=10: None)],
intern=[
lambda string: None],
isinstance=[
lambda obj, class_or_tuple: None],
issubclass=[
lambda cls, class_or_tuple: None],
iter=[
lambda iterable: None,
lambda callable, sentinel: None],
len=[
lambda obj: None],
list=[
lambda: None,
lambda iterable: None],
locals=[
lambda: None],
long=[
lambda x=0: None,
(0, lambda x, base=10: None)],
map=[
lambda func, sequence, *iterables: None],
memoryview=[
(0, lambda object: None)],
next=[
lambda iterator: None,
lambda iterator, default: None],
object=[
lambda: None],
oct=[
lambda number: None],
ord=[
lambda c: None],
pow=[
lambda x, y: None,
lambda x, y, z: None],
property=[
lambda fget=None, fset=None, fdel=None, doc=None: None],
range=[
lambda stop: None,
lambda start, stop: None,
lambda start, stop, step: None],
raw_input=[
lambda: None,
lambda prompt: None],
reduce=[
lambda function, sequence: None,
lambda function, sequence, initial: None],
reload=[
lambda module: None],
repr=[
lambda obj: None],
reversed=[
lambda sequence: None],
round=[
(0, lambda number, ndigits=0: None)],
set=[
lambda: None,
lambda iterable: None],
setattr=[
lambda obj, name, value: None],
slice=[
lambda stop: None,
lambda start, stop: None,
lambda start, stop, step: None],
staticmethod=[
lambda function: None],
sum=[
lambda iterable: None,
lambda iterable, start: None],
super=[
lambda type: None,
lambda type, obj: None],
tuple=[
lambda: None,
lambda iterable: None],
type=[
lambda object: None,
lambda name, bases, dict: None],
unichr=[
lambda i: None],
unicode=[
lambda object: None,
lambda string='', encoding='utf8', errors='strict': None],
vars=[
lambda: None,
lambda object: None],
xrange=[
lambda stop: None,
lambda start, stop: None,
lambda start, stop, step: None],
zip=[
lambda *iterables: None],
__build_class__=[
(2, lambda func, name, *bases, **kwds: None, ('metaclass',))],
__import__=[
(0, lambda name, globals=None, locals=None, fromlist=None,
level=None: None)],
)
module_info[builtins]['exec'] = [
lambda source: None,
lambda source, globals: None,
lambda source, globals, locals: None]
if PY3: # pragma: py2 no cover
module_info[builtins].update(
bytes=[
lambda: None,
lambda int: None,
lambda string, encoding='utf8', errors='strict': None],
compile=[
(0, lambda source, filename, mode, flags=0,
dont_inherit=False, optimize=-1: None)],
max=[
(1, lambda iterable: None, ('default', 'key',)),
(1, lambda arg1, arg2, *args: None, ('key',))],
min=[
(1, lambda iterable: None, ('default', 'key',)),
(1, lambda arg1, arg2, *args: None, ('key',))],
open=[
(0, lambda file, mode='r', buffering=-1, encoding=None,
errors=None, newline=None, closefd=True, opener=None: None)],
sorted=[
(1, lambda iterable: None, ('key', 'reverse'))],
str=[
lambda object='', encoding='utf', errors='strict': None],
)
module_info[builtins]['print'] = [
(0, lambda *args: None, ('sep', 'end', 'file', 'flush',))]
else: # pragma: py3 no cover
module_info[builtins].update(
bytes=[
lambda object='': None],
compile=[
(0, lambda source, filename, mode, flags=0,
dont_inherit=False: None)],
max=[
(1, lambda iterable, *args: None, ('key',))],
min=[
(1, lambda iterable, *args: None, ('key',))],
open=[
(0, lambda file, mode='r', buffering=-1: None)],
sorted=[
lambda iterable, cmp=None, key=None, reverse=False: None],
str=[
lambda object='': None],
)
module_info[builtins]['print'] = [
(0, lambda *args: None, ('sep', 'end', 'file',))]
module_info[functools] = dict(
cmp_to_key=[
(0, lambda mycmp: None)],
partial=[
lambda func, *args, **kwargs: None],
partialmethod=[
lambda func, *args, **kwargs: None],
reduce=[
lambda function, sequence: None,
lambda function, sequence, initial: None],
)
module_info[itertools] = dict(
accumulate=[
(0, lambda iterable, func=None: None)],
chain=[
lambda *iterables: None],
combinations=[
(0, lambda iterable, r: None)],
combinations_with_replacement=[
(0, lambda iterable, r: None)],
compress=[
(0, lambda data, selectors: None)],
count=[
lambda start=0, step=1: None],
cycle=[
lambda iterable: None],
dropwhile=[
lambda predicate, iterable: None],
filterfalse=[
lambda function, sequence: None],
groupby=[
(0, lambda iterable, key=None: None)],
ifilter=[
lambda function, sequence: None],
ifilterfalse=[
lambda function, sequence: None],
imap=[
lambda func, sequence, *iterables: None],
islice=[
lambda iterable, stop: None,
lambda iterable, start, stop: None,
lambda iterable, start, stop, step: None],
izip=[
lambda *iterables: None],
izip_longest=[
(0, lambda *iterables: None, ('fillvalue',))],
permutations=[
(0, lambda iterable, r=0: None)],
repeat=[
(0, lambda object, times=0: None)],
starmap=[
lambda function, sequence: None],
takewhile=[
lambda predicate, iterable: None],
tee=[
lambda iterable: None,
lambda iterable, n: None],
zip_longest=[
(0, lambda *iterables: None, ('fillvalue',))],
)
if PY3: # pragma: py2 no cover
module_info[itertools].update(
product=[
(0, lambda *iterables: None, ('repeat',))],
)
else: # pragma: py3 no cover
module_info[itertools].update(
product=[
lambda *iterables: None],
)
module_info[operator] = dict(
__abs__=[
lambda a: None],
__add__=[
lambda a, b: None],
__and__=[
lambda a, b: None],
__concat__=[
lambda a, b: None],
__contains__=[
lambda a, b: None],
__delitem__=[
lambda a, b: None],
__delslice__=[
lambda a, b, c: None],
__div__=[
lambda a, b: None],
__eq__=[
lambda a, b: None],
__floordiv__=[
lambda a, b: None],
__ge__=[
lambda a, b: None],
__getitem__=[
lambda a, b: None],
__getslice__=[
lambda a, b, c: None],
__gt__=[
lambda a, b: None],
__iadd__=[
lambda a, b: None],
__iand__=[
lambda a, b: None],
__iconcat__=[
lambda a, b: None],
__idiv__=[
lambda a, b: None],
__ifloordiv__=[
lambda a, b: None],
__ilshift__=[
lambda a, b: None],
__imatmul__=[
lambda a, b: None],
__imod__=[
lambda a, b: None],
__imul__=[
lambda a, b: None],
__index__=[
lambda a: None],
__inv__=[
lambda a: None],
__invert__=[
lambda a: None],
__ior__=[
lambda a, b: None],
__ipow__=[
lambda a, b: None],
__irepeat__=[
lambda a, b: None],
__irshift__=[
lambda a, b: None],
__isub__=[
lambda a, b: None],
__itruediv__=[
lambda a, b: None],
__ixor__=[
lambda a, b: None],
__le__=[
lambda a, b: None],
__lshift__=[
lambda a, b: None],
__lt__=[
lambda a, b: None],
__matmul__=[
lambda a, b: None],
__mod__=[
lambda a, b: None],
__mul__=[
lambda a, b: None],
__ne__=[
lambda a, b: None],
__neg__=[
lambda a: None],
__not__=[
lambda a: None],
__or__=[
lambda a, b: None],
__pos__=[
lambda a: None],
__pow__=[
lambda a, b: None],
__repeat__=[
lambda a, b: None],
__rshift__=[
lambda a, b: None],
__setitem__=[
lambda a, b, c: None],
__setslice__=[
lambda a, b, c, d: None],
__sub__=[
lambda a, b: None],
__truediv__=[
lambda a, b: None],
__xor__=[
lambda a, b: None],
_abs=[
lambda x: None],
_compare_digest=[
lambda a, b: None],
abs=[
lambda a: None],
add=[
lambda a, b: None],
and_=[
lambda a, b: None],
attrgetter=[
lambda attr, *args: None],
concat=[
lambda a, b: None],
contains=[
lambda a, b: None],
countOf=[
lambda a, b: None],
delitem=[
lambda a, b: None],
delslice=[
lambda a, b, c: None],
div=[
lambda a, b: None],
eq=[
lambda a, b: None],
floordiv=[
lambda a, b: None],
ge=[
lambda a, b: None],
getitem=[
lambda a, b: None],
getslice=[
lambda a, b, c: None],
gt=[
lambda a, b: None],
iadd=[
lambda a, b: None],
iand=[
lambda a, b: None],
iconcat=[
lambda a, b: None],
idiv=[
lambda a, b: None],
ifloordiv=[
lambda a, b: None],
ilshift=[
lambda a, b: None],
imatmul=[
lambda a, b: None],
imod=[
lambda a, b: None],
imul=[
lambda a, b: None],
index=[
lambda a: None],
indexOf=[
lambda a, b: None],
inv=[
lambda a: None],
invert=[
lambda a: None],
ior=[
lambda a, b: None],
ipow=[
lambda a, b: None],
irepeat=[
lambda a, b: None],
irshift=[
lambda a, b: None],
is_=[
lambda a, b: None],
is_not=[
lambda a, b: None],
isCallable=[
lambda a: None],
isMappingType=[
lambda a: None],
isNumberType=[
lambda a: None],
isSequenceType=[
lambda a: None],
isub=[
lambda a, b: None],
itemgetter=[
lambda item, *args: None],
itruediv=[
lambda a, b: None],
ixor=[
lambda a, b: None],
le=[
lambda a, b: None],
length_hint=[
lambda obj: None,
lambda obj, default: None],
lshift=[
lambda a, b: None],
lt=[
lambda a, b: None],
matmul=[
lambda a, b: None],
methodcaller=[
lambda name, *args, **kwargs: None],
mod=[
lambda a, b: None],
mul=[
lambda a, b: None],
ne=[
lambda a, b: None],
neg=[
lambda a: None],
not_=[
lambda a: None],
or_=[
lambda a, b: None],
pos=[
lambda a: None],
pow=[
lambda a, b: None],
repeat=[
lambda a, b: None],
rshift=[
lambda a, b: None],
sequenceIncludes=[
lambda a, b: None],
setitem=[
lambda a, b, c: None],
setslice=[
lambda a, b, c, d: None],
sub=[
lambda a, b: None],
truediv=[
lambda a, b: None],
truth=[
lambda a: None],
xor=[
lambda a, b: None],
)
module_info['toolz'] = dict(
curry=[
(0, lambda *args, **kwargs: None)],
excepts=[
(0, lambda exc, func, handler=None: None)],
flip=[
(0, lambda func=None, a=None, b=None: None)],
juxt=[
(0, lambda *funcs: None)],
memoize=[
(0, lambda func=None, cache=None, key=None: None)],
)
module_info['toolz.functoolz'] = dict(
Compose=[
(0, lambda funcs: None)],
InstanceProperty=[
(0, lambda fget=None, fset=None, fdel=None, doc=None,
classval=None: None)],
)
if PY3: # pragma: py2 no cover
def num_pos_args(sigspec):
""" Return the number of positional arguments. ``f(x, y=1)`` has 1"""
return sum(1 for x in sigspec.parameters.values()
if x.kind == x.POSITIONAL_OR_KEYWORD
and x.default is x.empty)
def get_exclude_keywords(num_pos_only, sigspec):
""" Return the names of position-only arguments if func has **kwargs"""
if num_pos_only == 0:
return ()
has_kwargs = any(x.kind == x.VAR_KEYWORD
for x in sigspec.parameters.values())
if not has_kwargs:
return ()
pos_args = list(sigspec.parameters.values())[:num_pos_only]
return tuple(x.name for x in pos_args)
def signature_or_spec(func):
try:
return inspect.signature(func)
except (ValueError, TypeError) as e:
return e
else: # pragma: py3 no cover
def num_pos_args(sigspec):
""" Return the number of positional arguments. ``f(x, y=1)`` has 1"""
if sigspec.defaults:
return len(sigspec.args) - len(sigspec.defaults)
return len(sigspec.args)
def get_exclude_keywords(num_pos_only, sigspec):
""" Return the names of position-only arguments if func has **kwargs"""
if num_pos_only == 0:
return ()
has_kwargs = sigspec.keywords is not None
if not has_kwargs:
return ()
return tuple(sigspec.args[:num_pos_only])
def signature_or_spec(func):
try:
return inspect.getargspec(func)
except TypeError as e:
return e
def expand_sig(sig):
""" Convert the signature spec in ``module_info`` to add to ``signatures``
The input signature spec is one of:
- ``lambda_func``
- ``(num_position_args, lambda_func)``
- ``(num_position_args, lambda_func, keyword_only_args)``
The output signature spec is:
``(num_position_args, lambda_func, keyword_exclude, sigspec)``
where ``keyword_exclude`` includes keyword only arguments and, if variadic
keywords is present, the names of position-only argument. The latter is
included to support builtins such as ``partial(func, *args, **kwargs)``,
which allows ``func=`` to be used as a keyword even though it's the name
of a positional argument.
"""
if isinstance(sig, tuple):
if len(sig) == 3:
num_pos_only, func, keyword_only = sig
assert isinstance(sig[-1], tuple)
else:
num_pos_only, func = sig
keyword_only = ()
sigspec = signature_or_spec(func)
else:
func = sig
sigspec = signature_or_spec(func)
num_pos_only = num_pos_args(sigspec)
keyword_only = ()
keyword_exclude = get_exclude_keywords(num_pos_only, sigspec)
return (num_pos_only, func, keyword_only + keyword_exclude, sigspec)
signatures = {}
def create_signature_registry(module_info=module_info, signatures=signatures):
for module, info in module_info.items():
if isinstance(module, str):
module = import_module(module)
for name, sigs in info.items():
if hasattr(module, name):
new_sigs = tuple(expand_sig(sig) for sig in sigs)
signatures[getattr(module, name)] = new_sigs
def check_valid(sig, args, kwargs):
""" Like ``is_valid_args`` for the given signature spec"""
num_pos_only, func, keyword_exclude, sigspec = sig
if len(args) < num_pos_only:
return False
if keyword_exclude:
kwargs = dict(kwargs)
for item in keyword_exclude:
kwargs.pop(item, None)
try:
func(*args, **kwargs)
return True
except TypeError:
return False
def _is_valid_args(func, args, kwargs):
""" Like ``is_valid_args`` for builtins in our ``signatures`` registry"""
if func not in signatures:
return None
sigs = signatures[func]
return any(check_valid(sig, args, kwargs) for sig in sigs)
def check_partial(sig, args, kwargs):
""" Like ``is_partial_args`` for the given signature spec"""
num_pos_only, func, keyword_exclude, sigspec = sig
if len(args) < num_pos_only:
pad = (None,) * (num_pos_only - len(args))
args = args + pad
if keyword_exclude:
kwargs = dict(kwargs)
for item in keyword_exclude:
kwargs.pop(item, None)
return is_partial_args(func, args, kwargs, sigspec)
def _is_partial_args(func, args, kwargs):
""" Like ``is_partial_args`` for builtins in our ``signatures`` registry"""
if func not in signatures:
return None
sigs = signatures[func]
return any(check_partial(sig, args, kwargs) for sig in sigs)
def check_arity(n, sig):
num_pos_only, func, keyword_exclude, sigspec = sig
if keyword_exclude or num_pos_only > n:
return False
return is_arity(n, func, sigspec)
def _is_arity(n, func):
if func not in signatures:
return None
sigs = signatures[func]
checks = [check_arity(n, sig) for sig in sigs]
if all(checks):
return True
elif any(checks):
return None
return False
def check_varargs(sig):
num_pos_only, func, keyword_exclude, sigspec = sig
return has_varargs(func, sigspec)
def _has_varargs(func):
if func not in signatures:
return None
sigs = signatures[func]
checks = [check_varargs(sig) for sig in sigs]
if all(checks):
return True
elif any(checks): # pragma: py2 no cover
return None
return False
def check_keywords(sig):
num_pos_only, func, keyword_exclude, sigspec = sig
if keyword_exclude:
return True
return has_keywords(func, sigspec)
def _has_keywords(func):
if func not in signatures:
return None
sigs = signatures[func]
checks = [check_keywords(sig) for sig in sigs]
if all(checks):
return True
elif any(checks):
return None
return False
def check_required_args(sig):
num_pos_only, func, keyword_exclude, sigspec = sig
return num_required_args(func, sigspec)
def _num_required_args(func):
if func not in signatures:
return None
sigs = signatures[func]
vals = [check_required_args(sig) for sig in sigs]
val = vals[0]
if all(x == val for x in vals):
return val
return None