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_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)