cpython: dbf72357cb4a (original) (raw)
Mercurial > cpython
changeset 105670:dbf72357cb4a
Issue #28959: Added private macro PyDict_GET_SIZE for retrieving the size of dict. [#28959]
line wrap: on
line diff
--- a/Include/dictobject.h +++ b/Include/dictobject.h @@ -106,6 +106,8 @@ PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObj PyAPI_FUNC(PyObject *) PyDict_Copy(PyObject *mp); PyAPI_FUNC(int) PyDict_Contains(PyObject *mp, PyObject key); #ifndef Py_LIMITED_API +/ Get the number of items of a dictionary. */ +#define PyDict_GET_SIZE(mp) (assert(PyDict_Check(mp)),((PyDictObject *)mp)->ma_used) PyAPI_FUNC(int) _PyDict_Contains(PyObject *mp, PyObject *key, Py_hash_t hash); PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused); PyAPI_FUNC(void) _PyDict_MaybeUntrack(PyObject *mp);
--- a/Include/odictobject.h +++ b/Include/odictobject.h @@ -21,7 +21,7 @@ PyAPI_DATA(PyTypeObject) PyODictValues_T #define PyODict_Check(op) PyObject_TypeCheck(op, &PyODict_Type) #define PyODict_CheckExact(op) (Py_TYPE(op) == &PyODict_Type) -#define PyODict_SIZE(op) ((PyDictObject *)op)->ma_used +#define PyODict_SIZE(op) PyDict_GET_SIZE((op)) #define PyODict_HasKey(od, key) (PyMapping_HasKey(PyObject *)od, key) PyAPI_FUNC(PyObject *) PyODict_New(void);
--- a/Modules/_ctypes/_ctypes.c +++ b/Modules/_ctypes/_ctypes.c @@ -3684,7 +3684,7 @@ static PyObject * must be the same as len(inargs) + len(kwds), otherwise we have either too much or not enough arguments. */
- actual_args = PyTuple_GET_SIZE(inargs) + (kwds ? PyDict_GET_SIZE(kwds) : 0); if (actual_args != inargs_index) { /* When we have default values or named parameters, this error message is misleading. See unittests/test_paramflags.py
--- a/Modules/_datetimemodule.c +++ b/Modules/_datetimemodule.c @@ -3169,7 +3169,7 @@ tzinfo_reduce(PyObject *self) PyErr_Clear(); state = Py_None; dictptr = _PyObject_GetDictPtr(self);
if (dictptr && *dictptr && PyDict_Size(*dictptr)) {[](#l4.7)
if (dictptr && *dictptr && PyDict_GET_SIZE(*dictptr)) {[](#l4.8) state = *dictptr;[](#l4.9) }[](#l4.10) Py_INCREF(state);[](#l4.11)
--- a/Modules/_decimal/_decimal.c +++ b/Modules/_decimal/_decimal.c @@ -428,7 +428,7 @@ dict_as_flags(PyObject *val) return DEC_INVALID_SIGNALS; }
- if (PyDict_GET_SIZE(val) != SIGNAL_MAP_LEN) { PyErr_SetString(PyExc_KeyError, "invalid signal dict"); return DEC_INVALID_SIGNALS;
--- a/Modules/_elementtree.c +++ b/Modules/_elementtree.c @@ -150,7 +150,7 @@ list_join(PyObject* list) static int is_empty_dict(PyObject *obj) {
--- a/Modules/_functoolsmodule.c +++ b/Modules/_functoolsmodule.c @@ -84,7 +84,7 @@ partial_new(PyTypeObject *type, PyObject } Py_DECREF(nargs);
@@ -155,7 +155,7 @@ partial_call(partialobject *pto, PyObjec assert(PyTuple_Check(argappl)); }
- if (PyDict_GET_SIZE(pto->kw) == 0) { kwappl = kw; Py_XINCREF(kwappl); } @@ -713,7 +713,7 @@ lru_cache_make_key(PyObject *args, PyObj return args; }
- if (kwds && PyDict_GET_SIZE(kwds) > 0) { sorted_items = PyDict_Items(kwds); if (!sorted_items) return NULL;
@@ -933,7 +933,7 @@ bounded_lru_cache_wrapper(lru_cache_obje } lru_cache_append_link(self, link); Py_INCREF(result); /* for return */
self->full = (PyDict_Size(self->cache) >= self->maxsize);[](#l7.34)
} self->misses++; return result; @@ -1062,7 +1062,7 @@ lru_cache_cache_info(lru_cache_object *s { return PyObject_CallFunction(self->cache_info_type, "nnOn", self->hits, self->misses, self->maxsize_O,self->full = (PyDict_GET_SIZE(self->cache) >= self->maxsize);[](#l7.35)
PyDict_Size(self->cache));[](#l7.43)
PyDict_GET_SIZE(self->cache));[](#l7.44)
--- a/Modules/_operator.c +++ b/Modules/_operator.c @@ -1016,16 +1016,7 @@ methodcaller_repr(methodcallerobject *mc return PyUnicode_FromFormat("%s(...)", Py_TYPE(mc)->tp_name); }
- if (mc->kwds != NULL) {
numkwdargs = PyDict_Size(mc->kwds);[](#l8.8)if (numkwdargs < 0) {[](#l8.9)Py_ReprLeave((PyObject *)mc);[](#l8.10)return NULL;[](#l8.11)}[](#l8.12)- } else {
numkwdargs = 0;[](#l8.14)- }
- numkwdargs = mc->kwds != NULL ? PyDict_GET_SIZE(mc->kwds) : 0; numposargs = PyTuple_GET_SIZE(mc->args); numtotalargs = numposargs + numkwdargs; @@ -1092,7 +1083,7 @@ static PyObject * methodcaller_reduce(methodcallerobject *mc) { PyObject *newargs;
- if (!mc->kwds || PyDict_GET_SIZE(mc->kwds) == 0) { Py_ssize_t i; Py_ssize_t callargcount = PyTuple_GET_SIZE(mc->args); newargs = PyTuple_New(1 + callargcount);
--- a/Modules/_pickle.c +++ b/Modules/_pickle.c @@ -2787,10 +2787,10 @@ batch_dict_exact(PicklerObject *self, Py const char setitem_op = SETITEM; const char setitems_op = SETITEMS;
/* Special-case len(d) == 1 to save space. */ if (dict_size == 1) { @@ -2819,7 +2819,7 @@ batch_dict_exact(PicklerObject *self, Py } if (_Pickler_Write(self, &setitems_op, 1) < 0) return -1;
if (PyDict_Size(obj) != dict_size) {[](#l9.20)
if (PyDict_GET_SIZE(obj) != dict_size) {[](#l9.21) PyErr_Format([](#l9.22) PyExc_RuntimeError,[](#l9.23) "dictionary changed size during iteration");[](#l9.24)
@@ -2837,6 +2837,7 @@ save_dict(PicklerObject *self, PyObject char header[3]; Py_ssize_t len; int status = 0;
if (self->fast && !fast_save_enter(self, obj)) goto error; @@ -2855,14 +2856,10 @@ save_dict(PicklerObject *self, PyObject if (_Pickler_Write(self, header, len) < 0) goto error;
- /* Get dict size, and bow out early if empty. */
- if ((len = PyDict_Size(obj)) < 0)
goto error;[](#l9.39)
- if (memo_put(self, obj) < 0) goto error;
- if (PyDict_GET_SIZE(obj)) { /* Save the dict items. / if (PyDict_CheckExact(obj) && self->proto > 0) { / We can take certain shortcuts if we know this is a dict and
@@ -6878,7 +6875,7 @@ Unpickler_set_memo(UnpicklerObject *self Py_ssize_t i = 0; PyObject *key, *value;
new_memo_size = PyDict_Size(obj);[](#l9.53)
new_memo_size = PyDict_GET_SIZE(obj);[](#l9.54) new_memo = _Unpickler_NewMemo(new_memo_size);[](#l9.55) if (new_memo == NULL)[](#l9.56) return -1;[](#l9.57)
--- a/Modules/_sqlite/cache.c +++ b/Modules/_sqlite/cache.c @@ -162,7 +162,7 @@ PyObject* pysqlite_cache_get(pysqlite_Ca * entry in the cache, and make space if necessary by throwing the * least used item out of the cache. */
if (PyDict_Size(self->mapping) == self->size) {[](#l10.7)
if (PyDict_GET_SIZE(self->mapping) == self->size) {[](#l10.8) if (self->last) {[](#l10.9) node = self->last;[](#l10.10)
--- a/Modules/_struct.c +++ b/Modules/_struct.c @@ -2048,7 +2048,7 @@ cache_struct(PyObject *fmt) s_object = PyObject_CallFunctionObjArgs((PyObject *)(&PyStructType), fmt, NULL); if (s_object != NULL) {
if (PyDict_Size(cache) >= MAXCACHE)[](#l11.7)
if (PyDict_GET_SIZE(cache) >= MAXCACHE)[](#l11.8) PyDict_Clear(cache);[](#l11.9) /* Attempt to cache the result */[](#l11.10) if (PyDict_SetItem(cache, fmt, s_object) == -1)[](#l11.11)
--- a/Modules/itertoolsmodule.c +++ b/Modules/itertoolsmodule.c @@ -4180,7 +4180,7 @@ repeat_new(PyTypeObject *type, PyObject return NULL; if (kwds != NULL)
n_kwds = PyDict_Size(kwds);[](#l12.7)
/* Does user supply times argument? */ if ((PyTuple_Size(args) + n_kwds == 2) && cnt < 0) cnt = 0;n_kwds = PyDict_GET_SIZE(kwds);[](#l12.8)
@@ -4331,9 +4331,9 @@ zip_longest_new(PyTypeObject *type, PyOb PyObject *fillvalue = Py_None; Py_ssize_t tuplesize = PySequence_Length(args);
- if (kwds != NULL && PyDict_CheckExact(kwds) && PyDict_GET_SIZE(kwds) > 0) { fillvalue = PyDict_GetItemString(kwds, "fillvalue");
if (fillvalue == NULL || PyDict_Size(kwds) > 1) {[](#l12.19)
if (fillvalue == NULL || PyDict_GET_SIZE(kwds) > 1) {[](#l12.20) PyErr_SetString(PyExc_TypeError,[](#l12.21) "zip_longest() got an unexpected keyword argument");[](#l12.22) return NULL;[](#l12.23)
--- a/Modules/selectmodule.c +++ b/Modules/selectmodule.c @@ -353,7 +353,7 @@ update_ufd_array(pollObject *self) PyObject *key, *value; struct pollfd *old_ufds = self->ufds;
- self->ufd_len = PyDict_GET_SIZE(self->dict); PyMem_RESIZE(self->ufds, struct pollfd, self->ufd_len); if (self->ufds == NULL) { self->ufds = old_ufds;
--- a/Objects/abstract.c +++ b/Objects/abstract.c @@ -2409,8 +2409,7 @@ PyObject ** assert(nargs >= 0); assert(kwargs == NULL || PyDict_CheckExact(kwargs));
--- a/Objects/descrobject.c +++ b/Objects/descrobject.c @@ -1173,7 +1173,7 @@ wrapper_call(wrapperobject *wp, PyObject return (*wk)(self, args, wp->descr->d_wrapped, kwds); }
- if (kwds != NULL && (!PyDict_Check(kwds) || PyDict_GET_SIZE(kwds) != 0)) { PyErr_Format(PyExc_TypeError, "wrapper %s doesn't take keyword arguments", wp->descr->d_base->name);
--- a/Objects/funcobject.c +++ b/Objects/funcobject.c @@ -583,7 +583,7 @@ function_call(PyObject *func, PyObject * if (kw != NULL && PyDict_Check(kw)) { Py_ssize_t pos, i;
nk = PyDict_Size(kw);[](#l16.7)
nk = PyDict_GET_SIZE(kw);[](#l16.8) kwtuple = PyTuple_New(2*nk);[](#l16.9) if (kwtuple == NULL)[](#l16.10) return NULL;[](#l16.11)
--- a/Objects/methodobject.c +++ b/Objects/methodobject.c @@ -87,6 +87,7 @@ PyCFunction_Call(PyObject *func, PyObjec Py_ssize_t size; int flags;
- assert(kwds == NULL || PyDict_Check(kwds)); /* PyCFunction_Call() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ @@ -103,7 +104,7 @@ PyCFunction_Call(PyObject *func, PyObjec res = _PyCFunction_FastCallDict(func, stack, nargs, kwds); } else {
if (kwds != NULL && PyDict_Size(kwds) != 0) {[](#l17.15)
if (kwds != NULL && PyDict_GET_SIZE(kwds) != 0) {[](#l17.16) PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",[](#l17.17) f->m_ml->ml_name);[](#l17.18) return NULL;[](#l17.19)
@@ -176,7 +177,7 @@ PyObject * switch (flags) { case METH_NOARGS:
if (kwargs != NULL && PyDict_Size(kwargs) != 0) {[](#l17.24)
if (kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) {[](#l17.25) PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",[](#l17.26) func->m_ml->ml_name);[](#l17.27) return NULL;[](#l17.28)
@@ -193,7 +194,7 @@ PyObject * break; case METH_O:
if (kwargs != NULL && PyDict_Size(kwargs) != 0) {[](#l17.33)
if (kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) {[](#l17.34) PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",[](#l17.35) func->m_ml->ml_name);[](#l17.36) return NULL;[](#l17.37)
@@ -215,7 +216,7 @@ PyObject / Slow-path: create a temporary tuple */ PyObject *tuple;
if (!(flags & METH_KEYWORDS) && kwargs != NULL && PyDict_Size(kwargs) != 0) {[](#l17.42)
if (!(flags & METH_KEYWORDS) && kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) {[](#l17.43) PyErr_Format(PyExc_TypeError,[](#l17.44) "%.200s() takes no keyword arguments",[](#l17.45) func->m_ml->ml_name);[](#l17.46)
--- a/Objects/object.c +++ b/Objects/object.c @@ -1454,7 +1454,7 @@ none_dealloc(PyObject* ignore) static PyObject * none_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) {
- if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_GET_SIZE(kwargs))) { PyErr_SetString(PyExc_TypeError, "NoneType takes no arguments"); return NULL; } @@ -1573,7 +1573,7 @@ static PyMethodDef notimplemented_method static PyObject * notimplemented_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) {
- if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_GET_SIZE(kwargs))) { PyErr_SetString(PyExc_TypeError, "NotImplementedType takes no arguments"); return NULL; }
--- a/Objects/odictobject.c +++ b/Objects/odictobject.c @@ -2423,8 +2423,7 @@ mutablemapping_update(PyObject self, Py / now handle kwargs */ assert(kwargs == NULL || PyDict_Check(kwargs));
- if (kwargs != NULL && PyDict_GET_SIZE(kwargs)) { PyObject *items = PyDict_Items(kwargs); if (items == NULL) return NULL;
--- a/Objects/setobject.c +++ b/Objects/setobject.c @@ -981,7 +981,7 @@ set_update_internal(PySetObject *so, PyO PyObject *value; Py_ssize_t pos = 0; Py_hash_t hash;
Py_ssize_t dictsize = PyDict_Size(other);[](#l20.7)
Py_ssize_t dictsize = PyDict_GET_SIZE(other);[](#l20.8)
/* Do one big resize at the start, rather than * incrementally resizing as we insert new keys. Expect
--- a/Objects/sliceobject.c +++ b/Objects/sliceobject.c @@ -19,7 +19,7 @@ this type and there is exactly one in ex static PyObject * ellipsis_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) {
- if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_GET_SIZE(kwargs))) { PyErr_SetString(PyExc_TypeError, "EllipsisType takes no arguments"); return NULL; }
--- a/Objects/typeobject.c +++ b/Objects/typeobject.c @@ -902,7 +902,7 @@ type_call(PyTypeObject *type, PyObject * if (type == &PyType_Type && PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 && (kwds == NULL ||
(PyDict_Check(kwds) && PyDict_Size(kwds) == 0)))[](#l22.7)
(PyDict_Check(kwds) && PyDict_GET_SIZE(kwds) == 0)))[](#l22.8) return obj;[](#l22.9)
/* If the returned object is not an instance of type, @@ -1585,7 +1585,7 @@ set_mro_error(PyObject *to_merge, int *r } } }
off = PyOS_snprintf(buf, sizeof(buf), "Cannot create a [](#l22.19) consistent method resolution\norder (MRO) for bases"); @@ -2187,7 +2187,7 @@ type_init(PyObject *cls, PyObject *args, assert(kwds == NULL || PyDict_Check(kwds)); if (kwds != NULL && PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 &&
PyDict_Check(kwds) && PyDict_Size(kwds) != 0) {[](#l22.25)
PyDict_Check(kwds) && PyDict_GET_SIZE(kwds) != 0) {[](#l22.26) PyErr_SetString(PyExc_TypeError,[](#l22.27) "type.__init__() takes no keyword arguments");[](#l22.28) return -1;[](#l22.29)
@@ -2272,7 +2272,7 @@ type_new(PyTypeObject *metatype, PyObjec Note: We don't call PyType_CheckExact as that also allows subclasses */ if (metatype == &PyType_Type) { const Py_ssize_t nargs = PyTuple_GET_SIZE(args);
const Py_ssize_t nkwds = kwds == NULL ? 0 : PyDict_Size(kwds);[](#l22.34)
const Py_ssize_t nkwds = kwds == NULL ? 0 : PyDict_GET_SIZE(kwds);[](#l22.35)
if (nargs == 1 && nkwds == 0) { PyObject *x = PyTuple_GET_ITEM(args, 0); @@ -3416,7 +3416,7 @@ static int excess_args(PyObject *args, PyObject *kwds) { return PyTuple_GET_SIZE(args) ||
(kwds && PyDict_Check(kwds) && PyDict_Size(kwds));[](#l22.43)
(kwds && PyDict_Check(kwds) && PyDict_GET_SIZE(kwds));[](#l22.44)
} static int @@ -3894,7 +3894,7 @@ static PyObject * We also return None if the dict is empty to make the behavior consistent regardless whether the dict was initialized or not. This make unit testing easier. */
if (dict != NULL && *dict != NULL && PyDict_Size(*dict) > 0) {[](#l22.52)
if (dict != NULL && *dict != NULL && PyDict_GET_SIZE(*dict)) {[](#l22.53) state = *dict;[](#l22.54) }[](#l22.55) else {[](#l22.56)
@@ -3983,7 +3983,7 @@ static PyObject / If we found some slot attributes, pack them in a tuple along the original attribute dictionary. */
if (PyDict_Size(slots) > 0) {[](#l22.61)
if (PyDict_GET_SIZE(slots) > 0) {[](#l22.62) PyObject *state2;[](#l22.63)
state2 = PyTuple_Pack(2, state, slots); @@ -4175,7 +4175,7 @@ reduce_newobj(PyObject *obj) return NULL; } hasargs = (args != NULL);
- if (kwargs == NULL || PyDict_GET_SIZE(kwargs) == 0) { _Py_IDENTIFIER(newobj); PyObject *cls; Py_ssize_t i, n;
--- a/Python/ceval.c +++ b/Python/ceval.c @@ -5010,7 +5010,7 @@ PyObject * assert(kwargs == NULL || PyDict_Check(kwargs)); if (co->co_kwonlyargcount == 0 &&
(kwargs == NULL || PyDict_Size(kwargs) == 0) &&[](#l23.7)
{ /* Fast paths */(kwargs == NULL || PyDict_GET_SIZE(kwargs) == 0) &&[](#l23.8) co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE))[](#l23.9)
@@ -5028,7 +5028,7 @@ PyObject * if (kwargs != NULL) { Py_ssize_t pos, i;
nk = PyDict_Size(kwargs);[](#l23.16)
nk = PyDict_GET_SIZE(kwargs);[](#l23.17)
kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) {
--- a/Python/compile.c +++ b/Python/compile.c @@ -564,7 +564,7 @@ compiler_enter_scope(struct compiler *c, PyObject *tuple, *name, *zero; int res; assert(u->u_scope_type == COMPILER_SCOPE_CLASS);
assert(PyDict_Size(u->u_cellvars) == 0);[](#l24.7)
assert(PyDict_GET_SIZE(u->u_cellvars) == 0);[](#l24.8) name = _PyUnicode_FromId(&PyId___class__);[](#l24.9) if (!name) {[](#l24.10) compiler_unit_free(u);[](#l24.11)
@@ -591,7 +591,7 @@ compiler_enter_scope(struct compiler *c, } u->u_freevars = dictbytype(u->u_ste->ste_symbols, FREE, DEF_FREE_CLASS,
PyDict_Size(u->u_cellvars));[](#l24.16)
@@ -1128,7 +1128,7 @@ compiler_add_o(struct compiler *c, PyObj Py_DECREF(t); return -1; }
arg = PyDict_Size(dict);[](#l24.25)
arg = PyDict_GET_SIZE(dict);[](#l24.26) v = PyLong_FromSsize_t(arg);[](#l24.27) if (!v) {[](#l24.28) Py_DECREF(t);[](#l24.29)
@@ -1999,7 +1999,7 @@ compiler_class(struct compiler c, stmt_ } else { / No methods referenced class, so just return None */
assert(PyDict_Size(c->u->u_cellvars) == 0);[](#l24.34)
assert(PyDict_GET_SIZE(c->u->u_cellvars) == 0);[](#l24.35) ADDOP_O(c, LOAD_CONST, Py_None, consts);[](#l24.36) }[](#l24.37) ADDOP_IN_SCOPE(c, RETURN_VALUE);[](#l24.38)
@@ -5179,7 +5179,7 @@ static PyObject * dict_keys_inorder(PyObject *dict, Py_ssize_t offset) { PyObject *tuple, *k, *v;
tuple = PyTuple_New(size); if (tuple == NULL) @@ -5203,7 +5203,6 @@ compute_code_flags(struct compiler *c) { PySTEntryObject *ste = c->u->u_ste; int flags = 0;
- Py_ssize_t n; if (ste->ste_type == FunctionBlock) { flags |= CO_NEWLOCALS | CO_OPTIMIZED; if (ste->ste_nested)
@@ -5223,16 +5222,9 @@ compute_code_flags(struct compiler c) / (Only) inherit compilerflags in PyCF_MASK */ flags |= (c->c_flags->cf_flags & PyCF_MASK);
- n = PyDict_Size(c->u->u_freevars);
- if (n < 0)
return -1;[](#l24.62)- if (n == 0) {
n = PyDict_Size(c->u->u_cellvars);[](#l24.64)if (n < 0)[](#l24.65)return -1;[](#l24.66)if (n == 0) {[](#l24.67)flags |= CO_NOFREE;[](#l24.68)}[](#l24.69)
- if (!PyDict_GET_SIZE(c->u->u_freevars) &&
!PyDict_GET_SIZE(c->u->u_cellvars)) {[](#l24.71)
} return flags; @@ -5273,7 +5265,7 @@ makecode(struct compiler *c, struct asse if (!freevars) goto error;flags |= CO_NOFREE;[](#l24.72)
- nlocals = PyDict_GET_SIZE(c->u->u_varnames); assert(nlocals < INT_MAX); nlocals_int = Py_SAFE_DOWNCAST(nlocals, Py_ssize_t, int);
--- a/Python/getargs.c +++ b/Python/getargs.c @@ -1650,7 +1650,7 @@ vgetargskeywords(PyObject *args, PyObjec } nargs = PyTuple_GET_SIZE(args);
- nkeywords = (keywords == NULL) ? 0 : PyDict_GET_SIZE(keywords); if (nargs + nkeywords > len) { PyErr_Format(PyExc_TypeError, "%s%s takes at most %d argument%s (%zd given)",
@@ -2034,7 +2034,7 @@ vgetargskeywordsfast_impl(PyObject **arg } if (keywords != NULL) {
nkeywords = PyDict_Size(keywords);[](#l25.16)
} else if (kwnames != NULL) { nkeywords = PyTuple_GET_SIZE(kwnames);nkeywords = PyDict_GET_SIZE(keywords);[](#l25.17)
@@ -2421,7 +2421,7 @@ int PyErr_BadInternalCall(); return 0; }
PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments",