def test_find_argname(self):
sig = Signature(["a", "b", "c"], None, None, ["kwonly"])
assert sig.find_argname("a") == 0
assert sig.find_argname("b") == 1
assert sig.find_argname("c") == 2
assert sig.find_argname("d") == -1
assert sig.find_argname("kwonly") == 3
def test_blindargs(self):
space = DummySpace()
kwds = [("a", 3), ('b', 4)]
for i in range(4):
kwds_w = dict(kwds[:i])
keywords = kwds_w.keys()
keywords_w = kwds_w.values()
w_kwds = dict(kwds[i:])
if i == 3:
w_kwds = None
args = Arguments(space, [1, 2],
keywords[:],
keywords_w[:],
w_starstararg=w_kwds)
l = [None, None, None]
args._match_signature(None,
l,
Signature(["a", "b"], None, "**"),
blindargs=2)
assert l == [1, 2, {'a': 3, 'b': 4}]
args = Arguments(space, [1, 2],
keywords[:],
keywords_w[:],
w_starstararg=w_kwds)
l = [None, None, None]
py.test.raises(ArgErrUnknownKwds,
args._match_signature,
None,
l,
Signature(["a", "b"]),
blindargs=2)
def test_find_argname(self):
sig = Signature(["a", "b", "c"], None, None, ["kwonly"])
assert sig.find_argname("a") == 0
assert sig.find_argname("b") == 1
assert sig.find_argname("c") == 2
assert sig.find_argname("d") == -1
assert sig.find_argname("kwonly") == 3
def test_signature(self):
def c(space, w_x, w_y, hello_w):
pass
code = gateway.BuiltinCode(c, unwrap_spec=[gateway.ObjSpace,
gateway.W_Root,
gateway.W_Root,
'args_w'])
assert code.signature() == Signature(['x', 'y'], 'hello', None)
def d(self, w_boo):
pass
class W_X(W_Root):
pass
code = gateway.BuiltinCode(d, unwrap_spec= ['self',
gateway.W_Root], self_type=W_X)
assert code.signature() == Signature(['self', 'boo'], None, None)
def e(space, w_x, w_y, __args__):
pass
code = gateway.BuiltinCode(e, unwrap_spec=[gateway.ObjSpace,
gateway.W_Root,
gateway.W_Root,
gateway.Arguments])
assert code.signature() == Signature(['x', 'y'], 'args', 'keywords')
def f(space, index):
pass
code = gateway.BuiltinCode(f, unwrap_spec=[gateway.ObjSpace, "index"])
assert code.signature() == Signature(["index"], None, None)
def test_too_many(self):
sig0 = Signature([], None, None)
err = ArgErrTooMany(sig0, 0, 1, 0)
s = err.getmsg()
assert s == "takes 0 positional arguments but 1 was given"
err = ArgErrTooMany(sig0, 0, 2, 0)
s = err.getmsg()
assert s == "takes 0 positional arguments but 2 were given"
sig1 = Signature(['a'], None, None)
err = ArgErrTooMany(sig1, 0, 2, 0)
s = err.getmsg()
assert s == "takes 1 positional argument but 2 were given"
sig2 = Signature(['a', 'b'], None, None)
err = ArgErrTooMany(sig2, 0, 3, 0)
s = err.getmsg()
assert s == "takes 2 positional arguments but 3 were given"
err = ArgErrTooMany(sig2, 1, 3, 0)
s = err.getmsg()
assert s == "takes from 1 to 2 positional arguments but 3 were given"
err = ArgErrTooMany(sig0, 0, 1, 1)
s = err.getmsg()
assert s == "takes 0 positional arguments but 1 positional argument (and 1 keyword-only argument) were given"
err = ArgErrTooMany(sig0, 0, 2, 1)
s = err.getmsg()
assert s == "takes 0 positional arguments but 2 positional arguments (and 1 keyword-only argument) were given"
err = ArgErrTooMany(sig0, 0, 1, 2)
s = err.getmsg()
assert s == "takes 0 positional arguments but 1 positional argument (and 2 keyword-only arguments) were given"
def test_args_parsing(self):
space = DummySpace()
args = Arguments(space, [])
calls = []
def _match_signature(w_firstarg, scope_w, signature,
defaults_w=None, blindargs=0):
defaults_w = [] if defaults_w is None else defaults_w
calls.append((w_firstarg, scope_w, signature.argnames, signature.has_vararg(),
signature.has_kwarg(), defaults_w, blindargs))
args._match_signature = _match_signature
scope_w = args.parse_obj(None, "foo", Signature(["a", "b"], None, None))
assert len(calls) == 1
assert calls[0] == (None, [None, None], ["a", "b"], False, False,
[], 0)
assert calls[0][1] is scope_w
calls = []
scope_w = args.parse_obj(None, "foo", Signature(["a", "b"], "args", None),
blindargs=1)
assert len(calls) == 1
assert calls[0] == (None, [None, None, None], ["a", "b"], True, False,
[], 1)
calls = []
scope_w = args.parse_obj(None, "foo", Signature(["a", "b"], "args", "kw"),
defaults_w=['x', 'y'])
assert len(calls) == 1
assert calls[0] == (None, [None, None, None, None], ["a", "b"],
True, True,
["x", "y"], 0)
calls = []
scope_w = args.parse_obj("obj", "foo", Signature(["a", "b"], "args", "kw"),
defaults_w=['x', 'y'], blindargs=1)
assert len(calls) == 1
assert calls[0] == ("obj", [None, None, None, None], ["a", "b"],
True, True,
["x", "y"], 1)
class FakeArgErr(ArgErr):
def getmsg(self):
return "msg"
def _match_signature(*args):
raise FakeArgErr()
args._match_signature = _match_signature
excinfo = py.test.raises(OperationError, args.parse_obj, "obj", "foo",
Signature(["a", "b"], None, None))
assert excinfo.value.w_type is TypeError
assert excinfo.value.get_w_value(space) == "foo() msg"
def test_match0(self):
space = DummySpace()
args = Arguments(space, [])
l = []
args._match_signature(None, l, Signature([]))
assert len(l) == 0
l = [None, None]
args = Arguments(space, [])
py.test.raises(ArgErr, args._match_signature, None, l, Signature(["a"]))
args = Arguments(space, [])
py.test.raises(ArgErr, args._match_signature, None, l, Signature(["a"], "*"))
args = Arguments(space, [])
l = [None]
args._match_signature(None, l, Signature(["a"]), defaults_w=[1])
assert l == [1]
args = Arguments(space, [])
l = [None]
args._match_signature(None, l, Signature([], "*"))
assert l == [()]
args = Arguments(space, [])
l = [None]
args._match_signature(None, l, Signature([], None, "**"))
assert l == [{}]
args = Arguments(space, [])
l = [None, None]
py.test.raises(ArgErr, args._match_signature, 41, l, Signature([]))
args = Arguments(space, [])
l = [None]
args._match_signature(1, l, Signature(["a"]))
assert l == [1]
args = Arguments(space, [])
l = [None]
args._match_signature(1, l, Signature([], "*"))
assert l == [(1,)]
def cpython_code_signature(code):
"""Return a Signature instance."""
argcount = code.co_argcount
varnames = code.co_varnames
if we_are_translated():
kwonlyargcount = code.co_kwonlyargcount
else:
# for compatibility with CPython 2.7 code objects
kwonlyargcount = getattr(code, 'co_kwonlyargcount', 0)
assert argcount >= 0 # annotator hint
assert kwonlyargcount >= 0
argnames = list(varnames[:argcount])
if argcount < len(varnames):
kwonlyargs = list(varnames[argcount:argcount + kwonlyargcount])
else:
kwonlyargs = None
if code.co_flags & CO_VARARGS:
varargname = varnames[argcount]
argcount += 1
else:
varargname = None
if code.co_flags & CO_VARKEYWORDS:
kwargname = code.co_varnames[argcount + kwonlyargcount]
else:
kwargname = None
return Signature(argnames, varargname, kwargname, kwonlyargs)
def acquire(self, space, __args__):
(w_user, w_password, w_cclass, w_purity) = __args__.parse_obj(
None,
"acquire",
Signature(["user", "password", "cclass", "purity"]),
defaults_w=[None, None, None, space.w_False])
if self.homogeneous and (w_user or w_password):
raise OperationError(
get(space).w_ProgrammingError,
space.wrap("pool is homogeneous. "
"Proxy authentication is not possible."))
self.checkConnected(space)
if __args__.keywords:
keywords = __args__.keywords + ["pool"]
else:
keywords = ["pool"]
if __args__.keywords_w:
keywords_w = __args__.keywords_w + [space.wrap(self)]
else:
keywords_w = [space.wrap(self)]
newargs = Arguments(space, __args__.arguments_w, keywords, keywords_w)
return space.call_args(self.w_connectionType, newargs)
def test_argument_unicode(self):
space = DummySpace()
w_starstar = space.wrap({u'abc': 5})
args = Arguments(space, [], w_starstararg=w_starstar)
l = [None]
args._match_signature(None, l, Signature(['abc']))
assert len(l) == 1
assert l[0] == space.wrap(5)
def test_signature(self, space):
def c(space, w_x, w_y, hello_w):
pass
code = gateway.BuiltinCode(c,
unwrap_spec=[
gateway.ObjSpace, gateway.W_Root,
gateway.W_Root, 'args_w'
])
assert code.signature() == Signature(['x', 'y'], 'hello', None)
def d(self, w_boo):
pass
class W_X(W_Root):
pass
code = gateway.BuiltinCode(d,
unwrap_spec=['self', gateway.W_Root],
self_type=W_X)
assert code.signature() == Signature(['self', 'boo'], None, None)
def e(space, w_x, w_y, __args__):
pass
code = gateway.BuiltinCode(e,
unwrap_spec=[
gateway.ObjSpace, gateway.W_Root,
gateway.W_Root, gateway.Arguments
])
assert code.signature() == Signature(['x', 'y'], 'args', 'keywords')
def f(space, index):
pass
code = gateway.BuiltinCode(f, unwrap_spec=[gateway.ObjSpace, "index"])
assert code.signature() == Signature(["index"], None, None)
def f(space, __kwonly__, w_x):
pass
code = gateway.BuiltinCode(
f, unwrap_spec=[gateway.ObjSpace, "kwonly", W_Root])
assert code.signature() == Signature([], kwonlyargnames=['x'])
assert space.int_w(
space.getattr(code, space.newtext('co_kwonlyargcount'))) == 1
def test_posonly_error(self):
space = DummySpace()
sig = Signature([], posonlyargnames=["x", "y", "z"])
with pytest.raises(ArgErrPosonlyAsKwds) as info:
args = Arguments(space, [1, 2, 3, 4, 5], ["x"], [6])
l = [None] * 6
args._match_signature(None, l, sig)
assert info.value.getmsg() == "got an unexpected keyword argument 'x'"
def test_missing_args_method(self):
# got_nargs, nkwds, expected_nargs, has_vararg, has_kwarg,
# defaults_w, missing_args
sig = Signature([], None, None)
err = ArgErrCountMethod(1, 0, sig, None, 0)
s = err.getmsg()
assert s == "takes no arguments (1 given). Did you forget 'self' in the function definition?"
sig = Signature(['a'], None, None)
err = ArgErrCountMethod(0, 0, sig, [], 1)
s = err.getmsg()
assert s == "takes exactly 1 argument (0 given)"
sig = Signature(['self', 'b'], None, None)
err = ArgErrCountMethod(3, 0, sig, [], 0)
s = err.getmsg()
assert s == "takes exactly 2 arguments (3 given)"
sig = Signature(['a', 'b'], None, None)
err = ArgErrCountMethod(3, 0, sig, [], 0)
s = err.getmsg()
assert s == "takes exactly 2 arguments (3 given). Did you forget 'self' in the function definition?"
err = ArgErrCountMethod(3, 0, sig, ['a'], 0)
s = err.getmsg()
assert s == "takes at most 2 arguments (3 given). Did you forget 'self' in the function definition?"
sig = Signature(['a', 'b'], '*', None)
err = ArgErrCountMethod(1, 0, sig, [], 1)
s = err.getmsg()
assert s == "takes at least 2 arguments (1 given)"
err = ArgErrCountMethod(0, 1, sig, ['a'], 1)
s = err.getmsg()
assert s == "takes at least 1 non-keyword argument (0 given)"
sig = Signature(['a'], None, '**')
err = ArgErrCountMethod(2, 1, sig, [], 0)
s = err.getmsg()
assert s == "takes exactly 1 non-keyword argument (2 given). Did you forget 'self' in the function definition?"
err = ArgErrCountMethod(0, 1, sig, [], 1)
s = err.getmsg()
assert s == "takes exactly 1 non-keyword argument (0 given)"
sig = Signature(['a'], '*', '**')
err = ArgErrCountMethod(0, 1, sig, [], 1)
s = err.getmsg()
assert s == "takes at least 1 non-keyword argument (0 given)"
sig = Signature(['a'], None, '**')
err = ArgErrCountMethod(2, 1, sig, ['a'], 0)
s = err.getmsg()
assert s == "takes at most 1 non-keyword argument (2 given). Did you forget 'self' in the function definition?"
def test_match_kwds(self):
space = DummySpace()
for i in range(3):
kwds = [("c", 3)]
kwds_w = dict(kwds[:i])
keywords = kwds_w.keys()
keywords_w = kwds_w.values()
w_kwds = dummy_wrapped_dict(kwds[i:])
if i == 2:
w_kwds = None
assert len(keywords) == len(keywords_w)
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None]
args._match_signature(None, l, Signature(["a", "b", "c"]), defaults_w=[4])
assert l == [1, 2, 3]
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None, None]
args._match_signature(None, l, Signature(["a", "b", "b1", "c"]), defaults_w=[4, 5])
assert l == [1, 2, 4, 3]
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None, None]
args._match_signature(None, l, Signature(["a", "b", "c", "d"]), defaults_w=[4, 5])
assert l == [1, 2, 3, 5]
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None, None]
py.test.raises(ArgErr, args._match_signature, None, l,
Signature(["c", "b", "a", "d"]), defaults_w=[4, 5])
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None, None]
py.test.raises(ArgErr, args._match_signature, None, l,
Signature(["a", "b", "c1", "d"]), defaults_w=[4, 5])
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None]
args._match_signature(None, l, Signature(["a", "b"], None, "**"))
assert l == [1, 2, {'c': 3}]
def test_posonly(self):
space = DummySpace()
sig = Signature(["a", "b", "c"], posonlyargnames=["x", "y", "z"])
args = Arguments(space, [1, 2, 3, 4, 5, 6])
l = [None] * 6
args._match_signature(None, l, sig)
assert l == [1, 2, 3, 4, 5, 6]
args = Arguments(space, [1, 2, 3, 4, 5], ["c"], [6])
l = [None] * 6
args._match_signature(None, l, sig)
assert l == [1, 2, 3, 4, 5, 6]
def cpython_code_signature(code):
"""Return a Signature instance."""
argcount = code.co_argcount
varnames = code.co_varnames
assert argcount >= 0 # annotator hint
argnames = list(varnames[:argcount])
if code.co_flags & CO_VARARGS:
varargname = varnames[argcount]
argcount += 1
else:
varargname = None
kwargname = varnames[argcount] if code.co_flags & CO_VARKEYWORDS else None
return Signature(argnames, varargname, kwargname)
def cpython_code_signature(code):
"([list-of-arg-names], vararg-name-or-None, kwarg-name-or-None)."
argcount = code.co_argcount
varnames = code.co_varnames
assert argcount >= 0 # annotator hint
argnames = list(varnames[:argcount])
if code.co_flags & CO_VARARGS:
varargname = varnames[argcount]
argcount += 1
else:
varargname = None
kwargname = varnames[argcount] if code.co_flags & CO_VARKEYWORDS else None
return Signature(argnames, varargname, kwargname)
def test_match_kwds2(self):
space = DummySpace()
kwds = [("c", 3), ('d', 4)]
for i in range(4):
kwds_w = dict(kwds[:i])
keywords = kwds_w.keys()
keywords_w = kwds_w.values()
w_kwds = dummy_wrapped_dict(kwds[i:])
if i == 3:
w_kwds = None
args = Arguments(space, [1, 2], keywords, keywords_w, w_starstararg=w_kwds)
l = [None, None, None, None]
args._match_signature(None, l, Signature(["a", "b", "c"], None, "**"))
assert l == [1, 2, 3, {'d': 4}]
def test_posonly(self):
sig = Signature(["a", "b", "c"], posonlyargnames=["x", "y", "z"])
# posonly come first
assert sig.find_argname("x") == 0
assert sig.find_argname("y") == 1
assert sig.find_argname("z") == 2
assert sig.find_argname("a") == 3
assert sig.find_argname("b") == 4
assert sig.find_argname("c") == 5
assert sig.find_argname("d") == -1
def test_match4(self):
space = DummySpace()
values = [4, 5, 6, 7]
for havefirstarg in [0, 1]:
for i in range(len(values) - havefirstarg):
arglist = values[havefirstarg:i + havefirstarg]
starargs = tuple(values[i + havefirstarg:])
if havefirstarg:
firstarg = values[0]
else:
firstarg = None
args = Arguments(space, arglist, w_stararg=starargs)
l = [None, None, None, None]
args._match_signature(firstarg, l,
Signature(["a", "b", "c", "d"]))
assert l == [4, 5, 6, 7]
args = Arguments(space, arglist, w_stararg=starargs)
l = [None, None, None, None, None, None]
py.test.raises(ArgErr, args._match_signature, firstarg, l,
Signature(["a"]))
args = Arguments(space, arglist, w_stararg=starargs)
l = [None, None, None, None, None, None]
py.test.raises(ArgErr, args._match_signature, firstarg, l,
Signature(["a", "b", "c", "d", "e"]))
args = Arguments(space, arglist, w_stararg=starargs)
l = [None, None, None, None, None, None]
py.test.raises(ArgErr, args._match_signature, firstarg, l,
Signature(["a", "b", "c", "d", "e"], "*"))
l = [None, None, None, None, None]
args = Arguments(space, arglist, w_stararg=starargs)
args._match_signature(firstarg,
l,
Signature(["a", "b", "c", "d", "e"]),
defaults_w=[1])
assert l == [4, 5, 6, 7, 1]
for j in range(len(values)):
l = [None] * (j + 1)
args = Arguments(space, arglist, w_stararg=starargs)
args._match_signature(
firstarg, l,
Signature(["a", "b", "c", "d", "e"][:j], "*"))
assert l == values[:j] + [tuple(values[j:])]
l = [None, None, None, None, None]
args = Arguments(space, arglist, w_stararg=starargs)
args._match_signature(
firstarg, l, Signature(["a", "b", "c", "d"], None, "**"))
assert l == [4, 5, 6, 7, {}]
def test_missing_args(self):
# got_nargs, nkwds, expected_nargs, has_vararg, has_kwarg,
# defaults_w, missing_args
sig = Signature([], None, None)
err = ArgErrCount(1, 0, sig, None, None, 0)
s = err.getmsg()
assert s == "takes no arguments (1 given)"
sig = Signature(['a'], None, None)
err = ArgErrCount(0, 0, sig, [], None, 1)
s = err.getmsg()
assert s == "takes exactly 1 argument (0 given)"
sig = Signature(['a', 'b'], None, None)
err = ArgErrCount(3, 0, sig, [], None, 0)
s = err.getmsg()
assert s == "takes exactly 2 arguments (3 given)"
err = ArgErrCount(3, 0, sig, ['a'], None, 0)
s = err.getmsg()
assert s == "takes at most 2 arguments (3 given)"
sig = Signature(['a', 'b'], '*', None)
err = ArgErrCount(1, 0, sig, [], None, 1)
s = err.getmsg()
assert s == "takes at least 2 arguments (1 given)"
err = ArgErrCount(0, 1, sig, ['a'], None, 1)
s = err.getmsg()
assert s == "takes at least 1 non-keyword argument (0 given)"
sig = Signature(['a'], None, '**')
err = ArgErrCount(2, 1, sig, [], None, 0)
s = err.getmsg()
assert s == "takes exactly 1 non-keyword argument (2 given)"
err = ArgErrCount(0, 1, sig, [], None, 1)
s = err.getmsg()
assert s == "takes exactly 1 non-keyword argument (0 given)"
sig = Signature(['a'], '*', '**')
err = ArgErrCount(0, 1, sig, [], None, 1)
s = err.getmsg()
assert s == "takes at least 1 non-keyword argument (0 given)"
sig = Signature(['a'], None, '**')
err = ArgErrCount(2, 1, sig, ['a'], None, 0)
s = err.getmsg()
assert s == "takes at most 1 non-keyword argument (2 given)"
def test_starstarargs_special(self):
class kwargs(object):
def __init__(self, k, v):
self.k = k
self.v = v
class MyDummySpace(DummySpace):
def view_as_kwargs(self, kw):
if isinstance(kw, kwargs):
return kw.k, kw.v
return None, None
space = MyDummySpace()
for i in range(3):
kwds = [("c", 3)]
kwds_w = dict(kwds[:i])
keywords = kwds_w.keys()
keywords_w = kwds_w.values()
rest = dict(kwds[i:])
w_kwds = kwargs(rest.keys(), rest.values())
if i == 2:
w_kwds = None
assert len(keywords) == len(keywords_w)
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None]
args._match_signature(None, l, Signature(["a", "b", "c"]), defaults_w=[4])
assert l == [1, 2, 3]
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None, None]
args._match_signature(None, l, Signature(["a", "b", "b1", "c"]), defaults_w=[4, 5])
assert l == [1, 2, 4, 3]
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None, None]
args._match_signature(None, l, Signature(["a", "b", "c", "d"]), defaults_w=[4, 5])
assert l == [1, 2, 3, 5]
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None, None]
py.test.raises(ArgErr, args._match_signature, None, l,
Signature(["c", "b", "a", "d"]), defaults_w=[4, 5])
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None, None]
py.test.raises(ArgErr, args._match_signature, None, l,
Signature(["a", "b", "c1", "d"]), defaults_w=[4, 5])
args = Arguments(space, [1, 2], keywords[:], keywords_w[:], w_starstararg=w_kwds)
l = [None, None, None]
args._match_signature(None, l, Signature(["a", "b"], None, "**"))
assert l == [1, 2, {'c': 3}]
excinfo = py.test.raises(OperationError, Arguments, space, [], ["a"],
[1], w_starstararg=kwargs(["a"], [2]))
assert excinfo.value.w_type is TypeError
def signature(self):
return Signature(self.argnames, self.varargname, self.kwargname)
def test_helpers(self):
sig = Signature(["a", "b", "c"], None, None)
assert sig.num_argnames() == 3
assert not sig.has_vararg()
assert not sig.has_kwarg()
assert sig.scope_length() == 3
assert sig.getallvarnames() == ["a", "b", "c"]
sig = Signature(["a", "b", "c"], "c", None)
assert sig.num_argnames() == 3
assert sig.has_vararg()
assert not sig.has_kwarg()
assert sig.scope_length() == 4
assert sig.getallvarnames() == ["a", "b", "c", "c"]
sig = Signature(["a", "b", "c"], None, "c")
assert sig.num_argnames() == 3
assert not sig.has_vararg()
assert sig.has_kwarg()
assert sig.scope_length() == 4
assert sig.getallvarnames() == ["a", "b", "c", "c"]
sig = Signature(["a", "b", "c"], "d", "c")
assert sig.num_argnames() == 3
assert sig.has_vararg()
assert sig.has_kwarg()
assert sig.scope_length() == 5
assert sig.getallvarnames() == ["a", "b", "c", "d", "c"]
def signature(self):
return Signature(self.argnames, self.varargname, self.kwargname,
self.kwonlyargnames, self.posonlyargnames)
def test_tuply(self):
sig = Signature(["a", "b", "c"], "d", "e")
x, y, z = sig
assert x == ["a", "b", "c"]
assert y == "d"
assert z == "e"
append=interp2app(W_BytearrayObject.descr_append,
doc=BytearrayDocstrings.append.__doc__),
extend=interp2app(W_BytearrayObject.descr_extend,
doc=BytearrayDocstrings.extend.__doc__),
insert=interp2app(W_BytearrayObject.descr_insert,
doc=BytearrayDocstrings.insert.__doc__),
pop=interp2app(W_BytearrayObject.descr_pop,
doc=BytearrayDocstrings.pop.__doc__),
remove=interp2app(W_BytearrayObject.descr_remove,
doc=BytearrayDocstrings.remove.__doc__),
reverse=interp2app(W_BytearrayObject.descr_reverse,
doc=BytearrayDocstrings.reverse.__doc__),
)
W_BytearrayObject.typedef.flag_sequence_bug_compat = True
init_signature = Signature(['source', 'encoding', 'errors'], None, None)
init_defaults = [None, None, None]
# XXX share the code again with the stuff in listobject.py
def _delitem_slice_helper(space, items, start, step, slicelength):
if slicelength == 0:
return
if step < 0:
start = start + step * (slicelength - 1)
step = -step
if step == 1:
assert start >= 0
if slicelength > 0:
def test_eq(self):
sig1 = Signature(["a", "b", "c"], "d", "c")
sig2 = Signature(["a", "b", "c"], "d", "c")
assert sig1 == sig2
def test_helpers(self):
sig = Signature(["a", "b", "c"], None, None)
assert sig.num_argnames() == 3
assert not sig.has_vararg()
assert not sig.has_kwarg()
assert sig.scope_length() == 3
assert sig.getallvarnames() == ["a", "b", "c"]
sig = Signature(["a", "b", "c"], "c", None)
assert sig.num_argnames() == 3
assert sig.has_vararg()
assert not sig.has_kwarg()
assert sig.scope_length() == 4
assert sig.getallvarnames() == ["a", "b", "c", "c"]
sig = Signature(["a", "b", "c"], None, "c")
assert sig.num_argnames() == 3
assert not sig.has_vararg()
assert sig.has_kwarg()
assert sig.scope_length() == 4
assert sig.getallvarnames() == ["a", "b", "c", "c"]
sig = Signature(["a", "b", "c"], "d", "c", ["kwonly"])
assert sig.num_argnames() == 3
assert sig.has_vararg()
assert sig.has_kwarg()
assert sig.scope_length() == 5
assert sig.getallvarnames() == ["a", "b", "c", "d", "kwonly", "c"]
"too many decimal digits in format string")
result = result * 10 + digit
else:
break
i += 1
if i == start:
result = -1
return result, i
# Auto number state
ANS_INIT = 1
ANS_AUTO = 2
ANS_MANUAL = 3
format_signature = Signature([], 'args', 'kwargs')
def make_template_formatting_class(for_unicode):
class TemplateFormatter(object):
is_unicode = for_unicode
if for_unicode:
def wrap(self, u):
lgt = rutf8.check_utf8(u, True)
return self.space.newutf8(u, lgt)
else:
def wrap(self, s):
return self.space.newbytes(s)
