From 2f9c90a3b513379deaf06e9b2577c79e80298d69 Mon Sep 17 00:00:00 2001 From: Matt Page Date: Thu, 21 Dec 2023 19:49:10 -0800 Subject: [PATCH 1/9] Convert most collections.deque methods to use clinic Convert most methods on collections.deque to use clinic. This will allow us to use clinic's `@critical_section` directive when making deques thread-safe for `--gil-disabled`, simplifying the implementation. --- .../pycore_global_objects_fini_generated.h | 1 + Include/internal/pycore_global_strings.h | 1 + .../internal/pycore_runtime_init_generated.h | 1 + .../internal/pycore_unicodeobject_generated.h | 3 + Modules/_collectionsmodule.c | 462 +++++++++++------- Modules/clinic/_collectionsmodule.c.h | 420 +++++++++++++++- 6 files changed, 712 insertions(+), 176 deletions(-) diff --git a/Include/internal/pycore_global_objects_fini_generated.h b/Include/internal/pycore_global_objects_fini_generated.h index 89ec8cbbbcd649..affed52d989344 100644 --- a/Include/internal/pycore_global_objects_fini_generated.h +++ b/Include/internal/pycore_global_objects_fini_generated.h @@ -1043,6 +1043,7 @@ _PyStaticObjects_CheckRefcnt(PyInterpreterState *interp) { _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(max_length)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(maxdigits)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(maxevents)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(maxlen)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(maxmem)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(maxsplit)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(maxvalue)); diff --git a/Include/internal/pycore_global_strings.h b/Include/internal/pycore_global_strings.h index 62c3ee3ae2a0bd..8fc0f154737ba0 100644 --- a/Include/internal/pycore_global_strings.h +++ b/Include/internal/pycore_global_strings.h @@ -532,6 +532,7 @@ struct _Py_global_strings { STRUCT_FOR_ID(max_length) STRUCT_FOR_ID(maxdigits) STRUCT_FOR_ID(maxevents) + STRUCT_FOR_ID(maxlen) STRUCT_FOR_ID(maxmem) STRUCT_FOR_ID(maxsplit) STRUCT_FOR_ID(maxvalue) diff --git a/Include/internal/pycore_runtime_init_generated.h b/Include/internal/pycore_runtime_init_generated.h index 1defa39f816e78..1b596c874e370e 100644 --- a/Include/internal/pycore_runtime_init_generated.h +++ b/Include/internal/pycore_runtime_init_generated.h @@ -1041,6 +1041,7 @@ extern "C" { INIT_ID(max_length), \ INIT_ID(maxdigits), \ INIT_ID(maxevents), \ + INIT_ID(maxlen), \ INIT_ID(maxmem), \ INIT_ID(maxsplit), \ INIT_ID(maxvalue), \ diff --git a/Include/internal/pycore_unicodeobject_generated.h b/Include/internal/pycore_unicodeobject_generated.h index be9baa3eebecfc..519e8d23d69840 100644 --- a/Include/internal/pycore_unicodeobject_generated.h +++ b/Include/internal/pycore_unicodeobject_generated.h @@ -1437,6 +1437,9 @@ _PyUnicode_InitStaticStrings(PyInterpreterState *interp) { string = &_Py_ID(maxevents); assert(_PyUnicode_CheckConsistency(string, 1)); _PyUnicode_InternInPlace(interp, &string); + string = &_Py_ID(maxlen); + assert(_PyUnicode_CheckConsistency(string, 1)); + _PyUnicode_InternInPlace(interp, &string); string = &_Py_ID(maxmem); assert(_PyUnicode_CheckConsistency(string, 1)); _PyUnicode_InternInPlace(interp, &string); diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c index c8cd53de5e2262..3e3e05dcc5f693 100644 --- a/Modules/_collectionsmodule.c +++ b/Modules/_collectionsmodule.c @@ -44,8 +44,11 @@ find_module_state_by_def(PyTypeObject *type) /*[clinic input] module _collections class _tuplegetter "_tuplegetterobject *" "clinic_state()->tuplegetter_type" +class _collections.deque "dequeobject *" "clinic_state()->deque_type" [clinic start generated code]*/ -/*[clinic end generated code: output=da39a3ee5e6b4b0d input=7356042a89862e0e]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=a033cc2a8476b3f1]*/ + +typedef struct dequeobject dequeobject; /* We can safely assume type to be the defining class, * since tuplegetter is not a base type */ @@ -53,6 +56,12 @@ class _tuplegetter "_tuplegetterobject *" "clinic_state()->tuplegetter_type" #include "clinic/_collectionsmodule.c.h" #undef clinic_state +/*[python input] +class dequeobject_converter(self_converter): + type = "dequeobject *" +[python start generated code]*/ +/*[python end generated code: output=da39a3ee5e6b4b0d input=b6ae4a3ff852be2f]*/ + /* collections module implementation of a deque() datatype Written and maintained by Raymond D. Hettinger */ @@ -121,7 +130,7 @@ typedef struct BLOCK { struct BLOCK *rightlink; } block; -typedef struct { +struct dequeobject { PyObject_VAR_HEAD block *leftblock; block *rightblock; @@ -132,7 +141,7 @@ typedef struct { Py_ssize_t numfreeblocks; block *freeblocks[MAXFREEBLOCKS]; PyObject *weakreflist; -} dequeobject; +}; /* For debug builds, add error checking to track the endpoints * in the chain of links. The goal is to make sure that link @@ -219,8 +228,17 @@ deque_new(PyTypeObject *type, PyObject *args, PyObject *kwds) return (PyObject *)deque; } +/*[clinic input] +_collections.deque.pop + + deque: dequeobject + +Remove and return the rightmost element. +[clinic start generated code]*/ + static PyObject * -deque_pop(dequeobject *deque, PyObject *unused) +_collections_deque_pop_impl(dequeobject *deque) +/*[clinic end generated code: output=2d4ef1dcd5113ae6 input=b4873fc20283d8d6]*/ { PyObject *item; block *prevblock; @@ -254,10 +272,17 @@ deque_pop(dequeobject *deque, PyObject *unused) return item; } -PyDoc_STRVAR(pop_doc, "Remove and return the rightmost element."); +/*[clinic input] +_collections.deque.popleft + + deque: dequeobject + +Remove and return the rightmost element. +[clinic start generated code]*/ static PyObject * -deque_popleft(dequeobject *deque, PyObject *unused) +_collections_deque_popleft_impl(dequeobject *deque) +/*[clinic end generated code: output=8cd77178b5116aba input=39d64df4664392d3]*/ { PyObject *item; block *prevblock; @@ -292,8 +317,6 @@ deque_popleft(dequeobject *deque, PyObject *unused) return item; } -PyDoc_STRVAR(popleft_doc, "Remove and return the leftmost element."); - /* The deque's size limit is d.maxlen. The limit can be zero or positive. * If there is no limit, then d.maxlen == -1. * @@ -326,7 +349,7 @@ deque_append_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen) deque->rightindex++; deque->rightblock->data[deque->rightindex] = item; if (NEEDS_TRIM(deque, maxlen)) { - PyObject *olditem = deque_popleft(deque, NULL); + PyObject *olditem = _collections_deque_popleft_impl(deque); Py_DECREF(olditem); } else { deque->state++; @@ -334,16 +357,25 @@ deque_append_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen) return 0; } +/*[clinic input] +_collections.deque.append + + deque: dequeobject + item: object + / + +Add an element to the right side of the deque. +[clinic start generated code]*/ + static PyObject * -deque_append(dequeobject *deque, PyObject *item) +_collections_deque_append(dequeobject *deque, PyObject *item) +/*[clinic end generated code: output=fc44cc7b9dcb0180 input=803e0d976a2e2620]*/ { if (deque_append_internal(deque, Py_NewRef(item), deque->maxlen) < 0) return NULL; Py_RETURN_NONE; } -PyDoc_STRVAR(append_doc, "Add an element to the right side of the deque."); - static inline int deque_appendleft_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen) { @@ -362,7 +394,7 @@ deque_appendleft_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen) deque->leftindex--; deque->leftblock->data[deque->leftindex] = item; if (NEEDS_TRIM(deque, deque->maxlen)) { - PyObject *olditem = deque_pop(deque, NULL); + PyObject *olditem = _collections_deque_pop_impl(deque); Py_DECREF(olditem); } else { deque->state++; @@ -370,16 +402,25 @@ deque_appendleft_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen) return 0; } +/*[clinic input] +_collections.deque.appendleft + + deque: dequeobject + item: object + / + +Add an element to the left side of the deque. +[clinic start generated code]*/ + static PyObject * -deque_appendleft(dequeobject *deque, PyObject *item) +_collections_deque_appendleft(dequeobject *deque, PyObject *item) +/*[clinic end generated code: output=f1b75022fbccf8bb input=481442915f0f6465]*/ { if (deque_appendleft_internal(deque, Py_NewRef(item), deque->maxlen) < 0) return NULL; Py_RETURN_NONE; } -PyDoc_STRVAR(appendleft_doc, "Add an element to the left side of the deque."); - static PyObject* finalize_iterator(PyObject *it) { @@ -410,8 +451,19 @@ consume_iterator(PyObject *it) return finalize_iterator(it); } +/*[clinic input] +_collections.deque.extend + + deque: dequeobject + iterable: object + / + +Extend the right side of the deque with elements from the iterable +[clinic start generated code]*/ + static PyObject * -deque_extend(dequeobject *deque, PyObject *iterable) +_collections_deque_extend(dequeobject *deque, PyObject *iterable) +/*[clinic end generated code: output=a58014bf32cb0b9d input=5a75e68f72ed8f09]*/ { PyObject *it, *item; PyObject *(*iternext)(PyObject *); @@ -423,7 +475,7 @@ deque_extend(dequeobject *deque, PyObject *iterable) PyObject *s = PySequence_List(iterable); if (s == NULL) return NULL; - result = deque_extend(deque, s); + result = _collections_deque_extend(deque, s); Py_DECREF(s); return result; } @@ -454,11 +506,19 @@ deque_extend(dequeobject *deque, PyObject *iterable) return finalize_iterator(it); } -PyDoc_STRVAR(extend_doc, -"Extend the right side of the deque with elements from the iterable"); +/*[clinic input] +_collections.deque.extendleft + + deque: dequeobject + iterable: object + / + +Extend the left side of the deque with elements from the iterable +[clinic start generated code]*/ static PyObject * -deque_extendleft(dequeobject *deque, PyObject *iterable) +_collections_deque_extendleft(dequeobject *deque, PyObject *iterable) +/*[clinic end generated code: output=0a0df3269097f284 input=8dae4c4f9d852a4c]*/ { PyObject *it, *item; PyObject *(*iternext)(PyObject *); @@ -470,7 +530,7 @@ deque_extendleft(dequeobject *deque, PyObject *iterable) PyObject *s = PySequence_List(iterable); if (s == NULL) return NULL; - result = deque_extendleft(deque, s); + result = _collections_deque_extendleft(deque, s); Py_DECREF(s); return result; } @@ -501,15 +561,12 @@ deque_extendleft(dequeobject *deque, PyObject *iterable) return finalize_iterator(it); } -PyDoc_STRVAR(extendleft_doc, -"Extend the left side of the deque with elements from the iterable"); - static PyObject * deque_inplace_concat(dequeobject *deque, PyObject *other) { PyObject *result; - result = deque_extend(deque, other); + result = _collections_deque_extend(deque, other); if (result == NULL) return result; Py_INCREF(deque); @@ -517,8 +574,17 @@ deque_inplace_concat(dequeobject *deque, PyObject *other) return (PyObject *)deque; } +/*[clinic input] +_collections.deque.copy + + deque: dequeobject + +Return a shallow copy of a deque. +[clinic start generated code]*/ + static PyObject * -deque_copy(PyObject *deque, PyObject *Py_UNUSED(ignored)) +_collections_deque_copy_impl(dequeobject *deque) +/*[clinic end generated code: output=af1e3831be813117 input=f575fc72c00333d4]*/ { PyObject *result; dequeobject *old_deque = (dequeobject *)deque; @@ -535,9 +601,9 @@ deque_copy(PyObject *deque, PyObject *Py_UNUSED(ignored)) /* Fast path for the deque_repeat() common case where len(deque) == 1 */ if (Py_SIZE(deque) == 1) { PyObject *item = old_deque->leftblock->data[old_deque->leftindex]; - rv = deque_append(new_deque, item); + rv = _collections_deque_append(new_deque, item); } else { - rv = deque_extend(new_deque, deque); + rv = _collections_deque_extend(new_deque, (PyObject *)deque); } if (rv != NULL) { Py_DECREF(rv); @@ -547,7 +613,8 @@ deque_copy(PyObject *deque, PyObject *Py_UNUSED(ignored)) return NULL; } if (old_deque->maxlen < 0) - result = PyObject_CallOneArg((PyObject *)(Py_TYPE(deque)), deque); + result = PyObject_CallOneArg((PyObject *)(Py_TYPE(deque)), + (PyObject *)deque); else result = PyObject_CallFunction((PyObject *)(Py_TYPE(deque)), "Oi", deque, old_deque->maxlen, NULL); @@ -561,7 +628,18 @@ deque_copy(PyObject *deque, PyObject *Py_UNUSED(ignored)) return result; } -PyDoc_STRVAR(copy_doc, "Return a shallow copy of a deque."); +/*[clinic input] +_collections.deque.__copy__ = _collections.deque.copy + +Return a shallow copy of a deque. +[clinic start generated code]*/ + +static PyObject * +_collections_deque___copy___impl(dequeobject *deque) +/*[clinic end generated code: output=c4c31949334138fd input=9d78c00375929799]*/ +{ + return _collections_deque_copy_impl(deque); +} static PyObject * deque_concat(dequeobject *deque, PyObject *other) @@ -580,10 +658,10 @@ deque_concat(dequeobject *deque, PyObject *other) return NULL; } - new_deque = deque_copy((PyObject *)deque, NULL); + new_deque = _collections_deque_copy_impl(deque); if (new_deque == NULL) return NULL; - result = deque_extend((dequeobject *)new_deque, other); + result = _collections_deque_extend((dequeobject *)new_deque, other); if (result == NULL) { Py_DECREF(new_deque); return NULL; @@ -669,22 +747,29 @@ deque_clear(dequeobject *deque) alternate_method: while (Py_SIZE(deque)) { - item = deque_pop(deque, NULL); + item = _collections_deque_pop_impl(deque); assert (item != NULL); Py_DECREF(item); } return 0; } +/*[clinic input] +_collections.deque.clear + + deque: dequeobject + +Remove all elements from the deque. +[clinic start generated code]*/ + static PyObject * -deque_clearmethod(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +_collections_deque_clear_impl(dequeobject *deque) +/*[clinic end generated code: output=0f0b9d60188bf83b input=9c003117680a7abf]*/ { deque_clear(deque); Py_RETURN_NONE; } -PyDoc_STRVAR(clear_doc, "Remove all elements from the deque."); - static PyObject * deque_inplace_repeat(dequeobject *deque, Py_ssize_t n) { @@ -750,7 +835,7 @@ deque_inplace_repeat(dequeobject *deque, Py_ssize_t n) n = (deque->maxlen + size - 1) / size; for (i = 0 ; i < n-1 ; i++) { - rv = deque_extend(deque, seq); + rv = _collections_deque_extend(deque, seq); if (rv == NULL) { Py_DECREF(seq); return NULL; @@ -768,7 +853,7 @@ deque_repeat(dequeobject *deque, Py_ssize_t n) dequeobject *new_deque; PyObject *rv; - new_deque = (dequeobject *)deque_copy((PyObject *) deque, NULL); + new_deque = (dequeobject *)_collections_deque_copy_impl(deque); if (new_deque == NULL) return NULL; rv = deque_inplace_repeat(new_deque, n); @@ -925,36 +1010,36 @@ _deque_rotate(dequeobject *deque, Py_ssize_t n) return rv; } -static PyObject * -deque_rotate(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) -{ - Py_ssize_t n=1; +/*[clinic input] +_collections.deque.rotate - if (!_PyArg_CheckPositional("deque.rotate", nargs, 0, 1)) { - return NULL; - } - if (nargs) { - PyObject *index = _PyNumber_Index(args[0]); - if (index == NULL) { - return NULL; - } - n = PyLong_AsSsize_t(index); - Py_DECREF(index); - if (n == -1 && PyErr_Occurred()) { - return NULL; - } - } + deque: dequeobject + n: Py_ssize_t = 1 + / +Rotate the deque n steps to the right. If n is negative, rotates left. +[clinic start generated code]*/ + +static PyObject * +_collections_deque_rotate_impl(dequeobject *deque, Py_ssize_t n) +/*[clinic end generated code: output=5a9df290cc0d3adf input=0d7f4900fe866917]*/ +{ if (!_deque_rotate(deque, n)) Py_RETURN_NONE; return NULL; } -PyDoc_STRVAR(rotate_doc, -"Rotate the deque n steps to the right (default n=1). If n is negative, rotates left."); +/*[clinic input] +_collections.deque.reverse + + deque: dequeobject + +Reverse *IN PLACE* +[clinic start generated code]*/ static PyObject * -deque_reverse(dequeobject *deque, PyObject *unused) +_collections_deque_reverse_impl(dequeobject *deque) +/*[clinic end generated code: output=8f859d206158686e input=651e0257414fac22]*/ { block *leftblock = deque->leftblock; block *rightblock = deque->rightblock; @@ -991,11 +1076,19 @@ deque_reverse(dequeobject *deque, PyObject *unused) Py_RETURN_NONE; } -PyDoc_STRVAR(reverse_doc, -"D.reverse() -- reverse *IN PLACE*"); +/*[clinic input] +_collections.deque.count + + deque: dequeobject + v: object + / + +Return number of occurrences of v +[clinic start generated code]*/ static PyObject * -deque_count(dequeobject *deque, PyObject *v) +_collections_deque_count(dequeobject *deque, PyObject *v) +/*[clinic end generated code: output=4fd47b6bf522f071 input=38d3b9f0f9993e26]*/ { block *b = deque->leftblock; Py_ssize_t index = deque->leftindex; @@ -1030,9 +1123,6 @@ deque_count(dequeobject *deque, PyObject *v) return PyLong_FromSsize_t(count); } -PyDoc_STRVAR(count_doc, -"D.count(value) -- return number of occurrences of value"); - static int deque_contains(dequeobject *deque, PyObject *v) { @@ -1071,22 +1161,33 @@ deque_len(dequeobject *deque) return Py_SIZE(deque); } +/*[clinic input] +@text_signature "($self, value, [start, [stop]])" +_collections.deque.index + + deque: dequeobject + v: object + start: object(converter='_PyEval_SliceIndexNotNone', type='Py_ssize_t', c_default='0') = NULL + stop: object(converter='_PyEval_SliceIndexNotNone', type='Py_ssize_t', c_default='Py_SIZE(deque)') = NULL + / + +Return first index of value. + +Raises ValueError if the value is not present. +[clinic start generated code]*/ + static PyObject * -deque_index(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) +_collections_deque_index_impl(dequeobject *deque, PyObject *v, + Py_ssize_t start, Py_ssize_t stop) +/*[clinic end generated code: output=5b2a991d7315b3cf input=b31d3a5c49cb8725]*/ { - Py_ssize_t i, n, start=0, stop=Py_SIZE(deque); - PyObject *v, *item; + Py_ssize_t i, n; + PyObject *item; block *b = deque->leftblock; Py_ssize_t index = deque->leftindex; size_t start_state = deque->state; int cmp; - if (!_PyArg_ParseStack(args, nargs, "O|O&O&:index", &v, - _PyEval_SliceIndexNotNone, &start, - _PyEval_SliceIndexNotNone, &stop)) { - return NULL; - } - if (start < 0) { start += Py_SIZE(deque); if (start < 0) @@ -1138,10 +1239,6 @@ deque_index(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) return NULL; } -PyDoc_STRVAR(index_doc, -"D.index(value, [start, [stop]]) -- return first index of value.\n" -"Raises ValueError if the value is not present."); - /* insert(), remove(), and delitem() are implemented in terms of rotate() for simplicity and reasonable performance near the end points. If for some reason these methods become popular, it is not @@ -1150,32 +1247,39 @@ PyDoc_STRVAR(index_doc, boost (by moving each pointer only once instead of twice). */ +/*[clinic input] +_collections.deque.insert + + deque: dequeobject + index: Py_ssize_t + value: object + / + +Insert value before index +[clinic start generated code]*/ + static PyObject * -deque_insert(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) +_collections_deque_insert_impl(dequeobject *deque, Py_ssize_t index, + PyObject *value) +/*[clinic end generated code: output=f913d56fc97caddf input=0593cc27bffa766a]*/ { - Py_ssize_t index; Py_ssize_t n = Py_SIZE(deque); - PyObject *value; PyObject *rv; - if (!_PyArg_ParseStack(args, nargs, "nO:insert", &index, &value)) { - return NULL; - } - if (deque->maxlen == Py_SIZE(deque)) { PyErr_SetString(PyExc_IndexError, "deque already at its maximum size"); return NULL; } if (index >= n) - return deque_append(deque, value); + return _collections_deque_append(deque, value); if (index <= -n || index == 0) - return deque_appendleft(deque, value); + return _collections_deque_appendleft(deque, value); if (_deque_rotate(deque, -index)) return NULL; if (index < 0) - rv = deque_append(deque, value); + rv = _collections_deque_append(deque, value); else - rv = deque_appendleft(deque, value); + rv = _collections_deque_appendleft(deque, value); if (rv == NULL) return NULL; Py_DECREF(rv); @@ -1184,12 +1288,6 @@ deque_insert(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) Py_RETURN_NONE; } -PyDoc_STRVAR(insert_doc, -"D.insert(index, object) -- insert object before index"); - -PyDoc_STRVAR(remove_doc, -"D.remove(value) -- remove first occurrence of value."); - static int valid_index(Py_ssize_t i, Py_ssize_t limit) { @@ -1246,15 +1344,26 @@ deque_del_item(dequeobject *deque, Py_ssize_t i) assert (i >= 0 && i < Py_SIZE(deque)); if (_deque_rotate(deque, -i)) return -1; - item = deque_popleft(deque, NULL); + item = _collections_deque_popleft_impl(deque); rv = _deque_rotate(deque, i); assert (item != NULL); Py_DECREF(item); return rv; } +/*[clinic input] +_collections.deque.remove + + deque: dequeobject + value: object + / + +Remove first occurrence of value. +[clinic start generated code]*/ + static PyObject * -deque_remove(dequeobject *deque, PyObject *value) +_collections_deque_remove(dequeobject *deque, PyObject *value) +/*[clinic end generated code: output=6e44d24b93f7109e input=d53d4a0b082137f6]*/ { PyObject *item; block *b = deque->leftblock; @@ -1375,8 +1484,17 @@ deque_traverse(dequeobject *deque, visitproc visit, void *arg) return 0; } +/*[clinic input] +_collections.deque.__reduce__ + + deque: dequeobject + +Return state information for pickling. +[clinic start generated code]*/ + static PyObject * -deque_reduce(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +_collections_deque___reduce___impl(dequeobject *deque) +/*[clinic end generated code: output=98e9eed251df2133 input=4210e061fc57e988]*/ { PyObject *state, *it; @@ -1510,40 +1628,38 @@ deque_richcompare(PyObject *v, PyObject *w, int op) return NULL; } +/*[clinic input] +@text_signature "($self, iterable=None, maxlen=None)" +_collections.deque.__init__ + + deque: dequeobject + iterable: object = NULL + maxlen: object = NULL + +A list-like sequence optimized for data accesses near its endpoints. +[clinic start generated code]*/ + static int -deque_init(dequeobject *deque, PyObject *args, PyObject *kwdargs) -{ - PyObject *iterable = NULL; - PyObject *maxlenobj = NULL; - Py_ssize_t maxlen = -1; - char *kwlist[] = {"iterable", "maxlen", 0}; +_collections_deque___init___impl(dequeobject *deque, PyObject *iterable, + PyObject *maxlen) +/*[clinic end generated code: output=9fbb306da99f6694 input=2966a2a0176e4506]*/ - if (kwdargs == NULL && PyTuple_GET_SIZE(args) <= 2) { - if (PyTuple_GET_SIZE(args) > 0) { - iterable = PyTuple_GET_ITEM(args, 0); - } - if (PyTuple_GET_SIZE(args) > 1) { - maxlenobj = PyTuple_GET_ITEM(args, 1); - } - } else { - if (!PyArg_ParseTupleAndKeywords(args, kwdargs, "|OO:deque", kwlist, - &iterable, &maxlenobj)) - return -1; - } - if (maxlenobj != NULL && maxlenobj != Py_None) { - maxlen = PyLong_AsSsize_t(maxlenobj); - if (maxlen == -1 && PyErr_Occurred()) +{ + Py_ssize_t maxlenval = -1; + if (maxlen != NULL && maxlen != Py_None) { + maxlenval = PyLong_AsSsize_t(maxlen); + if (maxlenval == -1 && PyErr_Occurred()) return -1; - if (maxlen < 0) { + if (maxlenval < 0) { PyErr_SetString(PyExc_ValueError, "maxlen must be non-negative"); return -1; } } - deque->maxlen = maxlen; + deque->maxlen = maxlenval; if (Py_SIZE(deque) > 0) deque_clear(deque); if (iterable != NULL) { - PyObject *rv = deque_extend(deque, iterable); + PyObject *rv = _collections_deque_extend(deque, iterable); if (rv == NULL) return -1; Py_DECREF(rv); @@ -1551,8 +1667,17 @@ deque_init(dequeobject *deque, PyObject *args, PyObject *kwdargs) return 0; } +/*[clinic input] +_collections.deque.__sizeof__ + + deque: dequeobject + +Return the size of the deque in memory, in bytes +[clinic start generated code]*/ + static PyObject * -deque_sizeof(dequeobject *deque, void *unused) +_collections_deque___sizeof___impl(dequeobject *deque) +/*[clinic end generated code: output=1a66234430a294a3 input=c0c535e64766f446]*/ { size_t res = _PyObject_SIZE(Py_TYPE(deque)); size_t blocks; @@ -1563,9 +1688,6 @@ deque_sizeof(dequeobject *deque, void *unused) return PyLong_FromSize_t(res); } -PyDoc_STRVAR(sizeof_doc, -"D.__sizeof__() -- size of D in memory, in bytes"); - static PyObject * deque_get_maxlen(dequeobject *deque, void *Py_UNUSED(ignored)) { @@ -1574,6 +1696,22 @@ deque_get_maxlen(dequeobject *deque, void *Py_UNUSED(ignored)) return PyLong_FromSsize_t(deque->maxlen); } +static PyObject *deque_reviter(dequeobject *deque); + +/*[clinic input] +_collections.deque.__reversed__ + + deque: dequeobject + +Return a reverse iterator over the deque. +[clinic start generated code]*/ + +static PyObject * +_collections_deque___reversed___impl(dequeobject *deque) +/*[clinic end generated code: output=c6980fed84a53cc6 input=8b6299d6d60ea01a]*/ +{ + return deque_reviter(deque); +} /* deque object ********************************************************/ @@ -1584,47 +1722,26 @@ static PyGetSetDef deque_getset[] = { }; static PyObject *deque_iter(dequeobject *deque); -static PyObject *deque_reviter(dequeobject *deque, PyObject *Py_UNUSED(ignored)); -PyDoc_STRVAR(reversed_doc, - "D.__reversed__() -- return a reverse iterator over the deque"); static PyMethodDef deque_methods[] = { - {"append", (PyCFunction)deque_append, - METH_O, append_doc}, - {"appendleft", (PyCFunction)deque_appendleft, - METH_O, appendleft_doc}, - {"clear", (PyCFunction)deque_clearmethod, - METH_NOARGS, clear_doc}, - {"__copy__", deque_copy, - METH_NOARGS, copy_doc}, - {"copy", deque_copy, - METH_NOARGS, copy_doc}, - {"count", (PyCFunction)deque_count, - METH_O, count_doc}, - {"extend", (PyCFunction)deque_extend, - METH_O, extend_doc}, - {"extendleft", (PyCFunction)deque_extendleft, - METH_O, extendleft_doc}, - {"index", _PyCFunction_CAST(deque_index), - METH_FASTCALL, index_doc}, - {"insert", _PyCFunction_CAST(deque_insert), - METH_FASTCALL, insert_doc}, - {"pop", (PyCFunction)deque_pop, - METH_NOARGS, pop_doc}, - {"popleft", (PyCFunction)deque_popleft, - METH_NOARGS, popleft_doc}, - {"__reduce__", (PyCFunction)deque_reduce, - METH_NOARGS, reduce_doc}, - {"remove", (PyCFunction)deque_remove, - METH_O, remove_doc}, - {"__reversed__", (PyCFunction)deque_reviter, - METH_NOARGS, reversed_doc}, - {"reverse", (PyCFunction)deque_reverse, - METH_NOARGS, reverse_doc}, - {"rotate", _PyCFunction_CAST(deque_rotate), - METH_FASTCALL, rotate_doc}, - {"__sizeof__", (PyCFunction)deque_sizeof, - METH_NOARGS, sizeof_doc}, + _COLLECTIONS_DEQUE_APPEND_METHODDEF + _COLLECTIONS_DEQUE_APPENDLEFT_METHODDEF + _COLLECTIONS_DEQUE_CLEAR_METHODDEF + _COLLECTIONS_DEQUE___COPY___METHODDEF + _COLLECTIONS_DEQUE_COPY_METHODDEF + _COLLECTIONS_DEQUE_COUNT_METHODDEF + _COLLECTIONS_DEQUE_EXTEND_METHODDEF + _COLLECTIONS_DEQUE_EXTENDLEFT_METHODDEF + _COLLECTIONS_DEQUE_INDEX_METHODDEF + _COLLECTIONS_DEQUE_INSERT_METHODDEF + _COLLECTIONS_DEQUE_POP_METHODDEF + _COLLECTIONS_DEQUE_POPLEFT_METHODDEF + _COLLECTIONS_DEQUE___REDUCE___METHODDEF + _COLLECTIONS_DEQUE_REMOVE_METHODDEF + _COLLECTIONS_DEQUE___REVERSED___METHODDEF + _COLLECTIONS_DEQUE_REVERSE_METHODDEF + _COLLECTIONS_DEQUE_ROTATE_METHODDEF + _COLLECTIONS_DEQUE___SIZEOF___METHODDEF {"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS, PyDoc_STR("See PEP 585")}, {NULL, NULL} /* sentinel */ @@ -1635,23 +1752,18 @@ static PyMemberDef deque_members[] = { {NULL}, }; -PyDoc_STRVAR(deque_doc, -"deque([iterable[, maxlen]]) --> deque object\n\ -\n\ -A list-like sequence optimized for data accesses near its endpoints."); - static PyType_Slot deque_slots[] = { {Py_tp_dealloc, deque_dealloc}, {Py_tp_repr, deque_repr}, {Py_tp_hash, PyObject_HashNotImplemented}, {Py_tp_getattro, PyObject_GenericGetAttr}, - {Py_tp_doc, (void *)deque_doc}, + {Py_tp_doc, (void *)_collections_deque___init____doc__}, {Py_tp_traverse, deque_traverse}, {Py_tp_clear, deque_clear}, {Py_tp_richcompare, deque_richcompare}, {Py_tp_iter, deque_iter}, {Py_tp_getset, deque_getset}, - {Py_tp_init, deque_init}, + {Py_tp_init, _collections_deque___init__}, {Py_tp_alloc, PyType_GenericAlloc}, {Py_tp_new, deque_new}, {Py_tp_free, PyObject_GC_Del}, @@ -1834,7 +1946,7 @@ static PyType_Spec dequeiter_spec = { /*********************** Deque Reverse Iterator **************************/ static PyObject * -deque_reviter(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +deque_reviter(dequeobject *deque) { dequeiterobject *it; collections_state *state = find_module_state_by_def(Py_TYPE(deque)); @@ -1889,7 +2001,7 @@ dequereviter_new(PyTypeObject *type, PyObject *args, PyObject *kwds) return NULL; assert(type == state->dequereviter_type); - it = (dequeiterobject*)deque_reviter((dequeobject *)deque, NULL); + it = (dequeiterobject *)deque_reviter((dequeobject *)deque); if (!it) return NULL; /* consume items from the queue */ diff --git a/Modules/clinic/_collectionsmodule.c.h b/Modules/clinic/_collectionsmodule.c.h index 591ab50c76a8e8..f6302b6019ab3c 100644 --- a/Modules/clinic/_collectionsmodule.c.h +++ b/Modules/clinic/_collectionsmodule.c.h @@ -2,9 +2,427 @@ preserve [clinic start generated code]*/ +#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE) +# include "pycore_gc.h" // PyGC_Head +# include "pycore_runtime.h" // _Py_ID() +#endif #include "pycore_abstract.h" // _PyNumber_Index() #include "pycore_modsupport.h" // _PyArg_CheckPositional() +PyDoc_STRVAR(_collections_deque_pop__doc__, +"pop($self, /)\n" +"--\n" +"\n" +"Remove and return the rightmost element."); + +#define _COLLECTIONS_DEQUE_POP_METHODDEF \ + {"pop", (PyCFunction)_collections_deque_pop, METH_NOARGS, _collections_deque_pop__doc__}, + +static PyObject * +_collections_deque_pop_impl(dequeobject *deque); + +static PyObject * +_collections_deque_pop(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +{ + return _collections_deque_pop_impl(deque); +} + +PyDoc_STRVAR(_collections_deque_popleft__doc__, +"popleft($self, /)\n" +"--\n" +"\n" +"Remove and return the rightmost element."); + +#define _COLLECTIONS_DEQUE_POPLEFT_METHODDEF \ + {"popleft", (PyCFunction)_collections_deque_popleft, METH_NOARGS, _collections_deque_popleft__doc__}, + +static PyObject * +_collections_deque_popleft_impl(dequeobject *deque); + +static PyObject * +_collections_deque_popleft(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +{ + return _collections_deque_popleft_impl(deque); +} + +PyDoc_STRVAR(_collections_deque_append__doc__, +"append($self, item, /)\n" +"--\n" +"\n" +"Add an element to the right side of the deque."); + +#define _COLLECTIONS_DEQUE_APPEND_METHODDEF \ + {"append", (PyCFunction)_collections_deque_append, METH_O, _collections_deque_append__doc__}, + +PyDoc_STRVAR(_collections_deque_appendleft__doc__, +"appendleft($self, item, /)\n" +"--\n" +"\n" +"Add an element to the left side of the deque."); + +#define _COLLECTIONS_DEQUE_APPENDLEFT_METHODDEF \ + {"appendleft", (PyCFunction)_collections_deque_appendleft, METH_O, _collections_deque_appendleft__doc__}, + +PyDoc_STRVAR(_collections_deque_extend__doc__, +"extend($self, iterable, /)\n" +"--\n" +"\n" +"Extend the right side of the deque with elements from the iterable"); + +#define _COLLECTIONS_DEQUE_EXTEND_METHODDEF \ + {"extend", (PyCFunction)_collections_deque_extend, METH_O, _collections_deque_extend__doc__}, + +PyDoc_STRVAR(_collections_deque_extendleft__doc__, +"extendleft($self, iterable, /)\n" +"--\n" +"\n" +"Extend the left side of the deque with elements from the iterable"); + +#define _COLLECTIONS_DEQUE_EXTENDLEFT_METHODDEF \ + {"extendleft", (PyCFunction)_collections_deque_extendleft, METH_O, _collections_deque_extendleft__doc__}, + +PyDoc_STRVAR(_collections_deque_copy__doc__, +"copy($self, /)\n" +"--\n" +"\n" +"Return a shallow copy of a deque."); + +#define _COLLECTIONS_DEQUE_COPY_METHODDEF \ + {"copy", (PyCFunction)_collections_deque_copy, METH_NOARGS, _collections_deque_copy__doc__}, + +static PyObject * +_collections_deque_copy_impl(dequeobject *deque); + +static PyObject * +_collections_deque_copy(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +{ + return _collections_deque_copy_impl(deque); +} + +PyDoc_STRVAR(_collections_deque___copy____doc__, +"__copy__($self, /)\n" +"--\n" +"\n" +"Return a shallow copy of a deque."); + +#define _COLLECTIONS_DEQUE___COPY___METHODDEF \ + {"__copy__", (PyCFunction)_collections_deque___copy__, METH_NOARGS, _collections_deque___copy____doc__}, + +static PyObject * +_collections_deque___copy___impl(dequeobject *deque); + +static PyObject * +_collections_deque___copy__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +{ + return _collections_deque___copy___impl(deque); +} + +PyDoc_STRVAR(_collections_deque_clear__doc__, +"clear($self, /)\n" +"--\n" +"\n" +"Remove all elements from the deque."); + +#define _COLLECTIONS_DEQUE_CLEAR_METHODDEF \ + {"clear", (PyCFunction)_collections_deque_clear, METH_NOARGS, _collections_deque_clear__doc__}, + +static PyObject * +_collections_deque_clear_impl(dequeobject *deque); + +static PyObject * +_collections_deque_clear(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +{ + return _collections_deque_clear_impl(deque); +} + +PyDoc_STRVAR(_collections_deque_rotate__doc__, +"rotate($self, n=1, /)\n" +"--\n" +"\n" +"Rotate the deque n steps to the right. If n is negative, rotates left."); + +#define _COLLECTIONS_DEQUE_ROTATE_METHODDEF \ + {"rotate", _PyCFunction_CAST(_collections_deque_rotate), METH_FASTCALL, _collections_deque_rotate__doc__}, + +static PyObject * +_collections_deque_rotate_impl(dequeobject *deque, Py_ssize_t n); + +static PyObject * +_collections_deque_rotate(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) +{ + PyObject *return_value = NULL; + Py_ssize_t n = 1; + + if (!_PyArg_CheckPositional("rotate", nargs, 0, 1)) { + goto exit; + } + if (nargs < 1) { + goto skip_optional; + } + { + Py_ssize_t ival = -1; + PyObject *iobj = _PyNumber_Index(args[0]); + if (iobj != NULL) { + ival = PyLong_AsSsize_t(iobj); + Py_DECREF(iobj); + } + if (ival == -1 && PyErr_Occurred()) { + goto exit; + } + n = ival; + } +skip_optional: + return_value = _collections_deque_rotate_impl(deque, n); + +exit: + return return_value; +} + +PyDoc_STRVAR(_collections_deque_reverse__doc__, +"reverse($self, /)\n" +"--\n" +"\n" +"Reverse *IN PLACE*"); + +#define _COLLECTIONS_DEQUE_REVERSE_METHODDEF \ + {"reverse", (PyCFunction)_collections_deque_reverse, METH_NOARGS, _collections_deque_reverse__doc__}, + +static PyObject * +_collections_deque_reverse_impl(dequeobject *deque); + +static PyObject * +_collections_deque_reverse(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +{ + return _collections_deque_reverse_impl(deque); +} + +PyDoc_STRVAR(_collections_deque_count__doc__, +"count($self, v, /)\n" +"--\n" +"\n" +"Return number of occurrences of v"); + +#define _COLLECTIONS_DEQUE_COUNT_METHODDEF \ + {"count", (PyCFunction)_collections_deque_count, METH_O, _collections_deque_count__doc__}, + +PyDoc_STRVAR(_collections_deque_index__doc__, +"index($self, value, [start, [stop]])\n" +"--\n" +"\n" +"Return first index of value.\n" +"\n" +"Raises ValueError if the value is not present."); + +#define _COLLECTIONS_DEQUE_INDEX_METHODDEF \ + {"index", _PyCFunction_CAST(_collections_deque_index), METH_FASTCALL, _collections_deque_index__doc__}, + +static PyObject * +_collections_deque_index_impl(dequeobject *deque, PyObject *v, + Py_ssize_t start, Py_ssize_t stop); + +static PyObject * +_collections_deque_index(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) +{ + PyObject *return_value = NULL; + PyObject *v; + Py_ssize_t start = 0; + Py_ssize_t stop = Py_SIZE(deque); + + if (!_PyArg_CheckPositional("index", nargs, 1, 3)) { + goto exit; + } + v = args[0]; + if (nargs < 2) { + goto skip_optional; + } + if (!_PyEval_SliceIndexNotNone(args[1], &start)) { + goto exit; + } + if (nargs < 3) { + goto skip_optional; + } + if (!_PyEval_SliceIndexNotNone(args[2], &stop)) { + goto exit; + } +skip_optional: + return_value = _collections_deque_index_impl(deque, v, start, stop); + +exit: + return return_value; +} + +PyDoc_STRVAR(_collections_deque_insert__doc__, +"insert($self, index, value, /)\n" +"--\n" +"\n" +"Insert value before index"); + +#define _COLLECTIONS_DEQUE_INSERT_METHODDEF \ + {"insert", _PyCFunction_CAST(_collections_deque_insert), METH_FASTCALL, _collections_deque_insert__doc__}, + +static PyObject * +_collections_deque_insert_impl(dequeobject *deque, Py_ssize_t index, + PyObject *value); + +static PyObject * +_collections_deque_insert(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) +{ + PyObject *return_value = NULL; + Py_ssize_t index; + PyObject *value; + + if (!_PyArg_CheckPositional("insert", nargs, 2, 2)) { + goto exit; + } + { + Py_ssize_t ival = -1; + PyObject *iobj = _PyNumber_Index(args[0]); + if (iobj != NULL) { + ival = PyLong_AsSsize_t(iobj); + Py_DECREF(iobj); + } + if (ival == -1 && PyErr_Occurred()) { + goto exit; + } + index = ival; + } + value = args[1]; + return_value = _collections_deque_insert_impl(deque, index, value); + +exit: + return return_value; +} + +PyDoc_STRVAR(_collections_deque_remove__doc__, +"remove($self, value, /)\n" +"--\n" +"\n" +"Remove first occurrence of value."); + +#define _COLLECTIONS_DEQUE_REMOVE_METHODDEF \ + {"remove", (PyCFunction)_collections_deque_remove, METH_O, _collections_deque_remove__doc__}, + +PyDoc_STRVAR(_collections_deque___reduce____doc__, +"__reduce__($self, /)\n" +"--\n" +"\n" +"Return state information for pickling."); + +#define _COLLECTIONS_DEQUE___REDUCE___METHODDEF \ + {"__reduce__", (PyCFunction)_collections_deque___reduce__, METH_NOARGS, _collections_deque___reduce____doc__}, + +static PyObject * +_collections_deque___reduce___impl(dequeobject *deque); + +static PyObject * +_collections_deque___reduce__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +{ + return _collections_deque___reduce___impl(deque); +} + +PyDoc_STRVAR(_collections_deque___init____doc__, +"deque($self, iterable=None, maxlen=None)\n" +"--\n" +"\n" +"A list-like sequence optimized for data accesses near its endpoints."); + +static int +_collections_deque___init___impl(dequeobject *deque, PyObject *iterable, + PyObject *maxlen); + +static int +_collections_deque___init__(PyObject *deque, PyObject *args, PyObject *kwargs) +{ + int return_value = -1; + #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE) + + #define NUM_KEYWORDS 2 + static struct { + PyGC_Head _this_is_not_used; + PyObject_VAR_HEAD + PyObject *ob_item[NUM_KEYWORDS]; + } _kwtuple = { + .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS) + .ob_item = { &_Py_ID(iterable), &_Py_ID(maxlen), }, + }; + #undef NUM_KEYWORDS + #define KWTUPLE (&_kwtuple.ob_base.ob_base) + + #else // !Py_BUILD_CORE + # define KWTUPLE NULL + #endif // !Py_BUILD_CORE + + static const char * const _keywords[] = {"iterable", "maxlen", NULL}; + static _PyArg_Parser _parser = { + .keywords = _keywords, + .fname = "deque", + .kwtuple = KWTUPLE, + }; + #undef KWTUPLE + PyObject *argsbuf[2]; + PyObject * const *fastargs; + Py_ssize_t nargs = PyTuple_GET_SIZE(args); + Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0; + PyObject *iterable = NULL; + PyObject *maxlen = NULL; + + fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 2, 0, argsbuf); + if (!fastargs) { + goto exit; + } + if (!noptargs) { + goto skip_optional_pos; + } + if (fastargs[0]) { + iterable = fastargs[0]; + if (!--noptargs) { + goto skip_optional_pos; + } + } + maxlen = fastargs[1]; +skip_optional_pos: + return_value = _collections_deque___init___impl((dequeobject *)deque, iterable, maxlen); + +exit: + return return_value; +} + +PyDoc_STRVAR(_collections_deque___sizeof____doc__, +"__sizeof__($self, /)\n" +"--\n" +"\n" +"Return the size of the deque in memory, in bytes"); + +#define _COLLECTIONS_DEQUE___SIZEOF___METHODDEF \ + {"__sizeof__", (PyCFunction)_collections_deque___sizeof__, METH_NOARGS, _collections_deque___sizeof____doc__}, + +static PyObject * +_collections_deque___sizeof___impl(dequeobject *deque); + +static PyObject * +_collections_deque___sizeof__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +{ + return _collections_deque___sizeof___impl(deque); +} + +PyDoc_STRVAR(_collections_deque___reversed____doc__, +"__reversed__($self, /)\n" +"--\n" +"\n" +"Return a reverse iterator over the deque."); + +#define _COLLECTIONS_DEQUE___REVERSED___METHODDEF \ + {"__reversed__", (PyCFunction)_collections_deque___reversed__, METH_NOARGS, _collections_deque___reversed____doc__}, + +static PyObject * +_collections_deque___reversed___impl(dequeobject *deque); + +static PyObject * +_collections_deque___reversed__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +{ + return _collections_deque___reversed___impl(deque); +} + PyDoc_STRVAR(_collections__count_elements__doc__, "_count_elements($module, mapping, iterable, /)\n" "--\n" @@ -72,4 +490,4 @@ tuplegetter_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) exit: return return_value; } -/*[clinic end generated code: output=c896a72f8c45930d input=a9049054013a1b77]*/ +/*[clinic end generated code: output=bfdddc7a5fbf9b08 input=a9049054013a1b77]*/ From eefd9948baa803a34a620343bcdf157f4a225e71 Mon Sep 17 00:00:00 2001 From: "blurb-it[bot]" <43283697+blurb-it[bot]@users.noreply.github.com> Date: Thu, 11 Jan 2024 22:58:46 +0000 Subject: [PATCH 2/9] =?UTF-8?q?=F0=9F=93=9C=F0=9F=A4=96=20Added=20by=20blu?= =?UTF-8?q?rb=5Fit.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../2024-01-11-22-58-45.gh-issue-112050.hDuvDW.rst | 1 + 1 file changed, 1 insertion(+) create mode 100644 Misc/NEWS.d/next/Core and Builtins/2024-01-11-22-58-45.gh-issue-112050.hDuvDW.rst diff --git a/Misc/NEWS.d/next/Core and Builtins/2024-01-11-22-58-45.gh-issue-112050.hDuvDW.rst b/Misc/NEWS.d/next/Core and Builtins/2024-01-11-22-58-45.gh-issue-112050.hDuvDW.rst new file mode 100644 index 00000000000000..d5e98bfb6169c4 --- /dev/null +++ b/Misc/NEWS.d/next/Core and Builtins/2024-01-11-22-58-45.gh-issue-112050.hDuvDW.rst @@ -0,0 +1 @@ +Convert most methods on collections.deque to use Argument Clinic. This is in preparation for making deques thread-safe when the GIL is disabled. To do so, we'll use Clinic's critical_section directive. From 991f686c111bb1e339410384984b1dc862e0779b Mon Sep 17 00:00:00 2001 From: Matt Page Date: Thu, 11 Jan 2024 15:25:18 -0800 Subject: [PATCH 3/9] Fix error in docstring for popleft We pop the leftmost, not the rightmost. --- Modules/_collectionsmodule.c | 4 ++-- Modules/clinic/_collectionsmodule.c.h | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c index 3e3e05dcc5f693..c0fb4c4ec303e4 100644 --- a/Modules/_collectionsmodule.c +++ b/Modules/_collectionsmodule.c @@ -277,12 +277,12 @@ _collections.deque.popleft deque: dequeobject -Remove and return the rightmost element. +Remove and return the leftmost element. [clinic start generated code]*/ static PyObject * _collections_deque_popleft_impl(dequeobject *deque) -/*[clinic end generated code: output=8cd77178b5116aba input=39d64df4664392d3]*/ +/*[clinic end generated code: output=8cd77178b5116aba input=0ca92ec89734848a]*/ { PyObject *item; block *prevblock; diff --git a/Modules/clinic/_collectionsmodule.c.h b/Modules/clinic/_collectionsmodule.c.h index f6302b6019ab3c..bd2d78eb09fe06 100644 --- a/Modules/clinic/_collectionsmodule.c.h +++ b/Modules/clinic/_collectionsmodule.c.h @@ -31,7 +31,7 @@ PyDoc_STRVAR(_collections_deque_popleft__doc__, "popleft($self, /)\n" "--\n" "\n" -"Remove and return the rightmost element."); +"Remove and return the leftmost element."); #define _COLLECTIONS_DEQUE_POPLEFT_METHODDEF \ {"popleft", (PyCFunction)_collections_deque_popleft, METH_NOARGS, _collections_deque_popleft__doc__}, @@ -490,4 +490,4 @@ tuplegetter_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) exit: return return_value; } -/*[clinic end generated code: output=bfdddc7a5fbf9b08 input=a9049054013a1b77]*/ +/*[clinic end generated code: output=5c65de75bddef4ad input=a9049054013a1b77]*/ From 37c4c05a0f89b025ce81e89bf18186cfc4aace7e Mon Sep 17 00:00:00 2001 From: Matt Page Date: Thu, 11 Jan 2024 15:33:09 -0800 Subject: [PATCH 4/9] Make docstring for __init__ more closely resemble the original The original version is ``` deque([iterable[, maxlen]]) --> deque object ``` The latter part seems redundant so has been omitted. --- Modules/_collectionsmodule.c | 4 ++-- Modules/clinic/_collectionsmodule.c.h | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c index c0fb4c4ec303e4..fbd45ccc241e7c 100644 --- a/Modules/_collectionsmodule.c +++ b/Modules/_collectionsmodule.c @@ -1629,7 +1629,7 @@ deque_richcompare(PyObject *v, PyObject *w, int op) } /*[clinic input] -@text_signature "($self, iterable=None, maxlen=None)" +@text_signature "([iterable[, maxlen]])" _collections.deque.__init__ deque: dequeobject @@ -1642,7 +1642,7 @@ A list-like sequence optimized for data accesses near its endpoints. static int _collections_deque___init___impl(dequeobject *deque, PyObject *iterable, PyObject *maxlen) -/*[clinic end generated code: output=9fbb306da99f6694 input=2966a2a0176e4506]*/ +/*[clinic end generated code: output=9fbb306da99f6694 input=aa6219250dc91d12]*/ { Py_ssize_t maxlenval = -1; diff --git a/Modules/clinic/_collectionsmodule.c.h b/Modules/clinic/_collectionsmodule.c.h index bd2d78eb09fe06..69b87a33e073a8 100644 --- a/Modules/clinic/_collectionsmodule.c.h +++ b/Modules/clinic/_collectionsmodule.c.h @@ -321,7 +321,7 @@ _collections_deque___reduce__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) } PyDoc_STRVAR(_collections_deque___init____doc__, -"deque($self, iterable=None, maxlen=None)\n" +"deque([iterable[, maxlen]])\n" "--\n" "\n" "A list-like sequence optimized for data accesses near its endpoints."); @@ -490,4 +490,4 @@ tuplegetter_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) exit: return return_value; } -/*[clinic end generated code: output=5c65de75bddef4ad input=a9049054013a1b77]*/ +/*[clinic end generated code: output=8f7f860b44810b2c input=a9049054013a1b77]*/ From 35c16c20c69b5dc76bc26fb9a6ec91e1c4b16adb Mon Sep 17 00:00:00 2001 From: Matt Page Date: Wed, 17 Jan 2024 10:52:54 -0800 Subject: [PATCH 5/9] Add missing periods in deque docstrings --- Modules/_collectionsmodule.c | 24 ++++++++++++------------ Modules/clinic/_collectionsmodule.c.h | 14 +++++++------- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c index fbd45ccc241e7c..dd0f0491ace01a 100644 --- a/Modules/_collectionsmodule.c +++ b/Modules/_collectionsmodule.c @@ -458,12 +458,12 @@ _collections.deque.extend iterable: object / -Extend the right side of the deque with elements from the iterable +Extend the right side of the deque with elements from the iterable. [clinic start generated code]*/ static PyObject * _collections_deque_extend(dequeobject *deque, PyObject *iterable) -/*[clinic end generated code: output=a58014bf32cb0b9d input=5a75e68f72ed8f09]*/ +/*[clinic end generated code: output=a58014bf32cb0b9d input=e021ff3e1c2cd868]*/ { PyObject *it, *item; PyObject *(*iternext)(PyObject *); @@ -513,12 +513,12 @@ _collections.deque.extendleft iterable: object / -Extend the left side of the deque with elements from the iterable +Extend the left side of the deque with elements from the iterable. [clinic start generated code]*/ static PyObject * _collections_deque_extendleft(dequeobject *deque, PyObject *iterable) -/*[clinic end generated code: output=0a0df3269097f284 input=8dae4c4f9d852a4c]*/ +/*[clinic end generated code: output=0a0df3269097f284 input=31a1bfe62f99746b]*/ { PyObject *it, *item; PyObject *(*iternext)(PyObject *); @@ -1034,12 +1034,12 @@ _collections.deque.reverse deque: dequeobject -Reverse *IN PLACE* +Reverse *IN PLACE*. [clinic start generated code]*/ static PyObject * _collections_deque_reverse_impl(dequeobject *deque) -/*[clinic end generated code: output=8f859d206158686e input=651e0257414fac22]*/ +/*[clinic end generated code: output=8f859d206158686e input=db89ccbd043ccf3c]*/ { block *leftblock = deque->leftblock; block *rightblock = deque->rightblock; @@ -1083,12 +1083,12 @@ _collections.deque.count v: object / -Return number of occurrences of v +Return number of occurrences of v. [clinic start generated code]*/ static PyObject * _collections_deque_count(dequeobject *deque, PyObject *v) -/*[clinic end generated code: output=4fd47b6bf522f071 input=38d3b9f0f9993e26]*/ +/*[clinic end generated code: output=4fd47b6bf522f071 input=45addc7d85e4a336]*/ { block *b = deque->leftblock; Py_ssize_t index = deque->leftindex; @@ -1255,13 +1255,13 @@ _collections.deque.insert value: object / -Insert value before index +Insert value before index. [clinic start generated code]*/ static PyObject * _collections_deque_insert_impl(dequeobject *deque, Py_ssize_t index, PyObject *value) -/*[clinic end generated code: output=f913d56fc97caddf input=0593cc27bffa766a]*/ +/*[clinic end generated code: output=f913d56fc97caddf input=6c381062f9dcab0a]*/ { Py_ssize_t n = Py_SIZE(deque); PyObject *rv; @@ -1672,12 +1672,12 @@ _collections.deque.__sizeof__ deque: dequeobject -Return the size of the deque in memory, in bytes +Return the size of the deque in memory, in bytes. [clinic start generated code]*/ static PyObject * _collections_deque___sizeof___impl(dequeobject *deque) -/*[clinic end generated code: output=1a66234430a294a3 input=c0c535e64766f446]*/ +/*[clinic end generated code: output=1a66234430a294a3 input=3d6a0b57c12c6f11]*/ { size_t res = _PyObject_SIZE(Py_TYPE(deque)); size_t blocks; diff --git a/Modules/clinic/_collectionsmodule.c.h b/Modules/clinic/_collectionsmodule.c.h index 69b87a33e073a8..9d7e182bf69101 100644 --- a/Modules/clinic/_collectionsmodule.c.h +++ b/Modules/clinic/_collectionsmodule.c.h @@ -67,7 +67,7 @@ PyDoc_STRVAR(_collections_deque_extend__doc__, "extend($self, iterable, /)\n" "--\n" "\n" -"Extend the right side of the deque with elements from the iterable"); +"Extend the right side of the deque with elements from the iterable."); #define _COLLECTIONS_DEQUE_EXTEND_METHODDEF \ {"extend", (PyCFunction)_collections_deque_extend, METH_O, _collections_deque_extend__doc__}, @@ -76,7 +76,7 @@ PyDoc_STRVAR(_collections_deque_extendleft__doc__, "extendleft($self, iterable, /)\n" "--\n" "\n" -"Extend the left side of the deque with elements from the iterable"); +"Extend the left side of the deque with elements from the iterable."); #define _COLLECTIONS_DEQUE_EXTENDLEFT_METHODDEF \ {"extendleft", (PyCFunction)_collections_deque_extendleft, METH_O, _collections_deque_extendleft__doc__}, @@ -182,7 +182,7 @@ PyDoc_STRVAR(_collections_deque_reverse__doc__, "reverse($self, /)\n" "--\n" "\n" -"Reverse *IN PLACE*"); +"Reverse *IN PLACE*."); #define _COLLECTIONS_DEQUE_REVERSE_METHODDEF \ {"reverse", (PyCFunction)_collections_deque_reverse, METH_NOARGS, _collections_deque_reverse__doc__}, @@ -200,7 +200,7 @@ PyDoc_STRVAR(_collections_deque_count__doc__, "count($self, v, /)\n" "--\n" "\n" -"Return number of occurrences of v"); +"Return number of occurrences of v."); #define _COLLECTIONS_DEQUE_COUNT_METHODDEF \ {"count", (PyCFunction)_collections_deque_count, METH_O, _collections_deque_count__doc__}, @@ -255,7 +255,7 @@ PyDoc_STRVAR(_collections_deque_insert__doc__, "insert($self, index, value, /)\n" "--\n" "\n" -"Insert value before index"); +"Insert value before index."); #define _COLLECTIONS_DEQUE_INSERT_METHODDEF \ {"insert", _PyCFunction_CAST(_collections_deque_insert), METH_FASTCALL, _collections_deque_insert__doc__}, @@ -391,7 +391,7 @@ PyDoc_STRVAR(_collections_deque___sizeof____doc__, "__sizeof__($self, /)\n" "--\n" "\n" -"Return the size of the deque in memory, in bytes"); +"Return the size of the deque in memory, in bytes."); #define _COLLECTIONS_DEQUE___SIZEOF___METHODDEF \ {"__sizeof__", (PyCFunction)_collections_deque___sizeof__, METH_NOARGS, _collections_deque___sizeof____doc__}, @@ -490,4 +490,4 @@ tuplegetter_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) exit: return return_value; } -/*[clinic end generated code: output=8f7f860b44810b2c input=a9049054013a1b77]*/ +/*[clinic end generated code: output=5f817800f678ca2d input=a9049054013a1b77]*/ From 875433bb793d8663c50e759df1e70432e8a64dd9 Mon Sep 17 00:00:00 2001 From: Matt Page Date: Wed, 17 Jan 2024 11:04:23 -0800 Subject: [PATCH 6/9] Use consistent names for value params Use `value` everywhere (not `v` in some places) --- Modules/_collectionsmodule.c | 20 ++++++++++---------- Modules/clinic/_collectionsmodule.c.h | 14 +++++++------- 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c index dd0f0491ace01a..62f2866c06220d 100644 --- a/Modules/_collectionsmodule.c +++ b/Modules/_collectionsmodule.c @@ -1080,15 +1080,15 @@ _collections_deque_reverse_impl(dequeobject *deque) _collections.deque.count deque: dequeobject - v: object + value: object / -Return number of occurrences of v. +Return number of occurrences of value. [clinic start generated code]*/ static PyObject * -_collections_deque_count(dequeobject *deque, PyObject *v) -/*[clinic end generated code: output=4fd47b6bf522f071 input=45addc7d85e4a336]*/ +_collections_deque_count(dequeobject *deque, PyObject *value) +/*[clinic end generated code: output=af6b1cb43c292e51 input=3cf536abfdeda205]*/ { block *b = deque->leftblock; Py_ssize_t index = deque->leftindex; @@ -1101,7 +1101,7 @@ _collections_deque_count(dequeobject *deque, PyObject *v) while (--n >= 0) { CHECK_NOT_END(b); item = Py_NewRef(b->data[index]); - cmp = PyObject_RichCompareBool(item, v, Py_EQ); + cmp = PyObject_RichCompareBool(item, value, Py_EQ); Py_DECREF(item); if (cmp < 0) return NULL; @@ -1166,7 +1166,7 @@ deque_len(dequeobject *deque) _collections.deque.index deque: dequeobject - v: object + value: object start: object(converter='_PyEval_SliceIndexNotNone', type='Py_ssize_t', c_default='0') = NULL stop: object(converter='_PyEval_SliceIndexNotNone', type='Py_ssize_t', c_default='Py_SIZE(deque)') = NULL / @@ -1177,9 +1177,9 @@ Raises ValueError if the value is not present. [clinic start generated code]*/ static PyObject * -_collections_deque_index_impl(dequeobject *deque, PyObject *v, +_collections_deque_index_impl(dequeobject *deque, PyObject *value, Py_ssize_t start, Py_ssize_t stop) -/*[clinic end generated code: output=5b2a991d7315b3cf input=b31d3a5c49cb8725]*/ +/*[clinic end generated code: output=7c30082173b46d2b input=4cc5446d58d4335e]*/ { Py_ssize_t i, n; PyObject *item; @@ -1219,7 +1219,7 @@ _collections_deque_index_impl(dequeobject *deque, PyObject *v, while (--n >= 0) { CHECK_NOT_END(b); item = b->data[index]; - cmp = PyObject_RichCompareBool(item, v, Py_EQ); + cmp = PyObject_RichCompareBool(item, value, Py_EQ); if (cmp > 0) return PyLong_FromSsize_t(stop - n - 1); if (cmp < 0) @@ -1235,7 +1235,7 @@ _collections_deque_index_impl(dequeobject *deque, PyObject *v, index = 0; } } - PyErr_Format(PyExc_ValueError, "%R is not in deque", v); + PyErr_Format(PyExc_ValueError, "%R is not in deque", value); return NULL; } diff --git a/Modules/clinic/_collectionsmodule.c.h b/Modules/clinic/_collectionsmodule.c.h index 9d7e182bf69101..86b34ec8099972 100644 --- a/Modules/clinic/_collectionsmodule.c.h +++ b/Modules/clinic/_collectionsmodule.c.h @@ -197,10 +197,10 @@ _collections_deque_reverse(dequeobject *deque, PyObject *Py_UNUSED(ignored)) } PyDoc_STRVAR(_collections_deque_count__doc__, -"count($self, v, /)\n" +"count($self, value, /)\n" "--\n" "\n" -"Return number of occurrences of v."); +"Return number of occurrences of value."); #define _COLLECTIONS_DEQUE_COUNT_METHODDEF \ {"count", (PyCFunction)_collections_deque_count, METH_O, _collections_deque_count__doc__}, @@ -217,21 +217,21 @@ PyDoc_STRVAR(_collections_deque_index__doc__, {"index", _PyCFunction_CAST(_collections_deque_index), METH_FASTCALL, _collections_deque_index__doc__}, static PyObject * -_collections_deque_index_impl(dequeobject *deque, PyObject *v, +_collections_deque_index_impl(dequeobject *deque, PyObject *value, Py_ssize_t start, Py_ssize_t stop); static PyObject * _collections_deque_index(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) { PyObject *return_value = NULL; - PyObject *v; + PyObject *value; Py_ssize_t start = 0; Py_ssize_t stop = Py_SIZE(deque); if (!_PyArg_CheckPositional("index", nargs, 1, 3)) { goto exit; } - v = args[0]; + value = args[0]; if (nargs < 2) { goto skip_optional; } @@ -245,7 +245,7 @@ _collections_deque_index(dequeobject *deque, PyObject *const *args, Py_ssize_t n goto exit; } skip_optional: - return_value = _collections_deque_index_impl(deque, v, start, stop); + return_value = _collections_deque_index_impl(deque, value, start, stop); exit: return return_value; @@ -490,4 +490,4 @@ tuplegetter_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) exit: return return_value; } -/*[clinic end generated code: output=5f817800f678ca2d input=a9049054013a1b77]*/ +/*[clinic end generated code: output=564d113856aeef1c input=a9049054013a1b77]*/ From 3600a40733cd6fb0bda340f0560dd6992016e4ea Mon Sep 17 00:00:00 2001 From: Matt Page Date: Wed, 17 Jan 2024 15:26:35 -0800 Subject: [PATCH 7/9] Drop the `_collections_`, it's cleaner Use the `as` clinic directive to minimize the changes to function names and arguments. --- Modules/_collectionsmodule.c | 211 +++++++++++++------------- Modules/clinic/_collectionsmodule.c.h | 199 ++++++++++++------------ 2 files changed, 204 insertions(+), 206 deletions(-) diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c index 62f2866c06220d..32b69b3e546f67 100644 --- a/Modules/_collectionsmodule.c +++ b/Modules/_collectionsmodule.c @@ -229,7 +229,7 @@ deque_new(PyTypeObject *type, PyObject *args, PyObject *kwds) } /*[clinic input] -_collections.deque.pop +_collections.deque.pop as deque_pop deque: dequeobject @@ -237,8 +237,8 @@ Remove and return the rightmost element. [clinic start generated code]*/ static PyObject * -_collections_deque_pop_impl(dequeobject *deque) -/*[clinic end generated code: output=2d4ef1dcd5113ae6 input=b4873fc20283d8d6]*/ +deque_pop_impl(dequeobject *deque) +/*[clinic end generated code: output=2e5f7890c4251f07 input=eb6e6d020f877dec]*/ { PyObject *item; block *prevblock; @@ -273,7 +273,7 @@ _collections_deque_pop_impl(dequeobject *deque) } /*[clinic input] -_collections.deque.popleft +_collections.deque.popleft as deque_popleft deque: dequeobject @@ -281,8 +281,8 @@ Remove and return the leftmost element. [clinic start generated code]*/ static PyObject * -_collections_deque_popleft_impl(dequeobject *deque) -/*[clinic end generated code: output=8cd77178b5116aba input=0ca92ec89734848a]*/ +deque_popleft_impl(dequeobject *deque) +/*[clinic end generated code: output=62b154897097ff68 input=acb41b9af50a9d9b]*/ { PyObject *item; block *prevblock; @@ -349,7 +349,7 @@ deque_append_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen) deque->rightindex++; deque->rightblock->data[deque->rightindex] = item; if (NEEDS_TRIM(deque, maxlen)) { - PyObject *olditem = _collections_deque_popleft_impl(deque); + PyObject *olditem = deque_popleft_impl(deque); Py_DECREF(olditem); } else { deque->state++; @@ -358,7 +358,7 @@ deque_append_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen) } /*[clinic input] -_collections.deque.append +_collections.deque.append as deque_append deque: dequeobject item: object @@ -368,8 +368,8 @@ Add an element to the right side of the deque. [clinic start generated code]*/ static PyObject * -_collections_deque_append(dequeobject *deque, PyObject *item) -/*[clinic end generated code: output=fc44cc7b9dcb0180 input=803e0d976a2e2620]*/ +deque_append(dequeobject *deque, PyObject *item) +/*[clinic end generated code: output=507b13efc4853ecc input=f112b83c380528e3]*/ { if (deque_append_internal(deque, Py_NewRef(item), deque->maxlen) < 0) return NULL; @@ -394,7 +394,7 @@ deque_appendleft_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen) deque->leftindex--; deque->leftblock->data[deque->leftindex] = item; if (NEEDS_TRIM(deque, deque->maxlen)) { - PyObject *olditem = _collections_deque_pop_impl(deque); + PyObject *olditem = deque_pop_impl(deque); Py_DECREF(olditem); } else { deque->state++; @@ -403,7 +403,7 @@ deque_appendleft_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen) } /*[clinic input] -_collections.deque.appendleft +_collections.deque.appendleft as deque_appendleft deque: dequeobject item: object @@ -413,8 +413,8 @@ Add an element to the left side of the deque. [clinic start generated code]*/ static PyObject * -_collections_deque_appendleft(dequeobject *deque, PyObject *item) -/*[clinic end generated code: output=f1b75022fbccf8bb input=481442915f0f6465]*/ +deque_appendleft(dequeobject *deque, PyObject *item) +/*[clinic end generated code: output=de0335a64800ffd8 input=bbdaa60a3e956062]*/ { if (deque_appendleft_internal(deque, Py_NewRef(item), deque->maxlen) < 0) return NULL; @@ -452,7 +452,7 @@ consume_iterator(PyObject *it) } /*[clinic input] -_collections.deque.extend +_collections.deque.extend as deque_extend deque: dequeobject iterable: object @@ -462,8 +462,8 @@ Extend the right side of the deque with elements from the iterable. [clinic start generated code]*/ static PyObject * -_collections_deque_extend(dequeobject *deque, PyObject *iterable) -/*[clinic end generated code: output=a58014bf32cb0b9d input=e021ff3e1c2cd868]*/ +deque_extend(dequeobject *deque, PyObject *iterable) +/*[clinic end generated code: output=a3a6e74d17063f8d input=cfebfd34d5383339]*/ { PyObject *it, *item; PyObject *(*iternext)(PyObject *); @@ -475,7 +475,7 @@ _collections_deque_extend(dequeobject *deque, PyObject *iterable) PyObject *s = PySequence_List(iterable); if (s == NULL) return NULL; - result = _collections_deque_extend(deque, s); + result = deque_extend(deque, s); Py_DECREF(s); return result; } @@ -507,7 +507,7 @@ _collections_deque_extend(dequeobject *deque, PyObject *iterable) } /*[clinic input] -_collections.deque.extendleft +_collections.deque.extendleft as deque_extendleft deque: dequeobject iterable: object @@ -517,8 +517,8 @@ Extend the left side of the deque with elements from the iterable. [clinic start generated code]*/ static PyObject * -_collections_deque_extendleft(dequeobject *deque, PyObject *iterable) -/*[clinic end generated code: output=0a0df3269097f284 input=31a1bfe62f99746b]*/ +deque_extendleft(dequeobject *deque, PyObject *iterable) +/*[clinic end generated code: output=2dba946c50498c67 input=f4820e695a6f9416]*/ { PyObject *it, *item; PyObject *(*iternext)(PyObject *); @@ -530,7 +530,7 @@ _collections_deque_extendleft(dequeobject *deque, PyObject *iterable) PyObject *s = PySequence_List(iterable); if (s == NULL) return NULL; - result = _collections_deque_extendleft(deque, s); + result = deque_extendleft(deque, s); Py_DECREF(s); return result; } @@ -566,7 +566,7 @@ deque_inplace_concat(dequeobject *deque, PyObject *other) { PyObject *result; - result = _collections_deque_extend(deque, other); + result = deque_extend(deque, other); if (result == NULL) return result; Py_INCREF(deque); @@ -575,7 +575,7 @@ deque_inplace_concat(dequeobject *deque, PyObject *other) } /*[clinic input] -_collections.deque.copy +_collections.deque.copy as deque_copy deque: dequeobject @@ -583,8 +583,8 @@ Return a shallow copy of a deque. [clinic start generated code]*/ static PyObject * -_collections_deque_copy_impl(dequeobject *deque) -/*[clinic end generated code: output=af1e3831be813117 input=f575fc72c00333d4]*/ +deque_copy_impl(dequeobject *deque) +/*[clinic end generated code: output=6409b3d1ad2898b5 input=0e22f138bc1fcbee]*/ { PyObject *result; dequeobject *old_deque = (dequeobject *)deque; @@ -601,9 +601,9 @@ _collections_deque_copy_impl(dequeobject *deque) /* Fast path for the deque_repeat() common case where len(deque) == 1 */ if (Py_SIZE(deque) == 1) { PyObject *item = old_deque->leftblock->data[old_deque->leftindex]; - rv = _collections_deque_append(new_deque, item); + rv = deque_append(new_deque, item); } else { - rv = _collections_deque_extend(new_deque, (PyObject *)deque); + rv = deque_extend(new_deque, (PyObject *)deque); } if (rv != NULL) { Py_DECREF(rv); @@ -629,16 +629,16 @@ _collections_deque_copy_impl(dequeobject *deque) } /*[clinic input] -_collections.deque.__copy__ = _collections.deque.copy +_collections.deque.__copy__ as deque___copy__ = _collections.deque.copy Return a shallow copy of a deque. [clinic start generated code]*/ static PyObject * -_collections_deque___copy___impl(dequeobject *deque) -/*[clinic end generated code: output=c4c31949334138fd input=9d78c00375929799]*/ +deque___copy___impl(dequeobject *deque) +/*[clinic end generated code: output=7c5821504342bf23 input=fce05df783e7912b]*/ { - return _collections_deque_copy_impl(deque); + return deque_copy_impl(deque); } static PyObject * @@ -658,10 +658,10 @@ deque_concat(dequeobject *deque, PyObject *other) return NULL; } - new_deque = _collections_deque_copy_impl(deque); + new_deque = deque_copy_impl(deque); if (new_deque == NULL) return NULL; - result = _collections_deque_extend((dequeobject *)new_deque, other); + result = deque_extend((dequeobject *)new_deque, other); if (result == NULL) { Py_DECREF(new_deque); return NULL; @@ -747,7 +747,7 @@ deque_clear(dequeobject *deque) alternate_method: while (Py_SIZE(deque)) { - item = _collections_deque_pop_impl(deque); + item = deque_pop_impl(deque); assert (item != NULL); Py_DECREF(item); } @@ -755,7 +755,7 @@ deque_clear(dequeobject *deque) } /*[clinic input] -_collections.deque.clear +_collections.deque.clear as deque_clearmethod deque: dequeobject @@ -763,8 +763,8 @@ Remove all elements from the deque. [clinic start generated code]*/ static PyObject * -_collections_deque_clear_impl(dequeobject *deque) -/*[clinic end generated code: output=0f0b9d60188bf83b input=9c003117680a7abf]*/ +deque_clearmethod_impl(dequeobject *deque) +/*[clinic end generated code: output=79b2513e097615c1 input=20488eb932f89f9e]*/ { deque_clear(deque); Py_RETURN_NONE; @@ -835,7 +835,7 @@ deque_inplace_repeat(dequeobject *deque, Py_ssize_t n) n = (deque->maxlen + size - 1) / size; for (i = 0 ; i < n-1 ; i++) { - rv = _collections_deque_extend(deque, seq); + rv = deque_extend(deque, seq); if (rv == NULL) { Py_DECREF(seq); return NULL; @@ -853,7 +853,7 @@ deque_repeat(dequeobject *deque, Py_ssize_t n) dequeobject *new_deque; PyObject *rv; - new_deque = (dequeobject *)_collections_deque_copy_impl(deque); + new_deque = (dequeobject *)deque_copy_impl(deque); if (new_deque == NULL) return NULL; rv = deque_inplace_repeat(new_deque, n); @@ -1011,7 +1011,7 @@ _deque_rotate(dequeobject *deque, Py_ssize_t n) } /*[clinic input] -_collections.deque.rotate +_collections.deque.rotate as deque_rotate deque: dequeobject n: Py_ssize_t = 1 @@ -1021,8 +1021,8 @@ Rotate the deque n steps to the right. If n is negative, rotates left. [clinic start generated code]*/ static PyObject * -_collections_deque_rotate_impl(dequeobject *deque, Py_ssize_t n) -/*[clinic end generated code: output=5a9df290cc0d3adf input=0d7f4900fe866917]*/ +deque_rotate_impl(dequeobject *deque, Py_ssize_t n) +/*[clinic end generated code: output=96c2402a371eb15d input=d22070f49cc06c76]*/ { if (!_deque_rotate(deque, n)) Py_RETURN_NONE; @@ -1030,7 +1030,7 @@ _collections_deque_rotate_impl(dequeobject *deque, Py_ssize_t n) } /*[clinic input] -_collections.deque.reverse +_collections.deque.reverse as deque_reverse deque: dequeobject @@ -1038,8 +1038,8 @@ Reverse *IN PLACE*. [clinic start generated code]*/ static PyObject * -_collections_deque_reverse_impl(dequeobject *deque) -/*[clinic end generated code: output=8f859d206158686e input=db89ccbd043ccf3c]*/ +deque_reverse_impl(dequeobject *deque) +/*[clinic end generated code: output=bdeebc2cf8c1f064 input=f139787f406101c9]*/ { block *leftblock = deque->leftblock; block *rightblock = deque->rightblock; @@ -1077,7 +1077,7 @@ _collections_deque_reverse_impl(dequeobject *deque) } /*[clinic input] -_collections.deque.count +_collections.deque.count as deque_count deque: dequeobject value: object @@ -1087,8 +1087,8 @@ Return number of occurrences of value. [clinic start generated code]*/ static PyObject * -_collections_deque_count(dequeobject *deque, PyObject *value) -/*[clinic end generated code: output=af6b1cb43c292e51 input=3cf536abfdeda205]*/ +deque_count(dequeobject *deque, PyObject *value) +/*[clinic end generated code: output=39594ae05ff15239 input=dd7593184e23fe32]*/ { block *b = deque->leftblock; Py_ssize_t index = deque->leftindex; @@ -1163,7 +1163,7 @@ deque_len(dequeobject *deque) /*[clinic input] @text_signature "($self, value, [start, [stop]])" -_collections.deque.index +_collections.deque.index as deque_index deque: dequeobject value: object @@ -1177,9 +1177,9 @@ Raises ValueError if the value is not present. [clinic start generated code]*/ static PyObject * -_collections_deque_index_impl(dequeobject *deque, PyObject *value, - Py_ssize_t start, Py_ssize_t stop) -/*[clinic end generated code: output=7c30082173b46d2b input=4cc5446d58d4335e]*/ +deque_index_impl(dequeobject *deque, PyObject *value, Py_ssize_t start, + Py_ssize_t stop) +/*[clinic end generated code: output=754c388d6c6a8cfe input=8e3f101d57b012b1]*/ { Py_ssize_t i, n; PyObject *item; @@ -1248,7 +1248,7 @@ _collections_deque_index_impl(dequeobject *deque, PyObject *value, */ /*[clinic input] -_collections.deque.insert +_collections.deque.insert as deque_insert deque: dequeobject index: Py_ssize_t @@ -1259,9 +1259,8 @@ Insert value before index. [clinic start generated code]*/ static PyObject * -_collections_deque_insert_impl(dequeobject *deque, Py_ssize_t index, - PyObject *value) -/*[clinic end generated code: output=f913d56fc97caddf input=6c381062f9dcab0a]*/ +deque_insert_impl(dequeobject *deque, Py_ssize_t index, PyObject *value) +/*[clinic end generated code: output=ef4d2c15d5532b80 input=3e5c1c120d70c0e6]*/ { Py_ssize_t n = Py_SIZE(deque); PyObject *rv; @@ -1271,15 +1270,15 @@ _collections_deque_insert_impl(dequeobject *deque, Py_ssize_t index, return NULL; } if (index >= n) - return _collections_deque_append(deque, value); + return deque_append(deque, value); if (index <= -n || index == 0) - return _collections_deque_appendleft(deque, value); + return deque_appendleft(deque, value); if (_deque_rotate(deque, -index)) return NULL; if (index < 0) - rv = _collections_deque_append(deque, value); + rv = deque_append(deque, value); else - rv = _collections_deque_appendleft(deque, value); + rv = deque_appendleft(deque, value); if (rv == NULL) return NULL; Py_DECREF(rv); @@ -1344,7 +1343,7 @@ deque_del_item(dequeobject *deque, Py_ssize_t i) assert (i >= 0 && i < Py_SIZE(deque)); if (_deque_rotate(deque, -i)) return -1; - item = _collections_deque_popleft_impl(deque); + item = deque_popleft_impl(deque); rv = _deque_rotate(deque, i); assert (item != NULL); Py_DECREF(item); @@ -1352,7 +1351,7 @@ deque_del_item(dequeobject *deque, Py_ssize_t i) } /*[clinic input] -_collections.deque.remove +_collections.deque.remove as deque_remove deque: dequeobject value: object @@ -1362,8 +1361,8 @@ Remove first occurrence of value. [clinic start generated code]*/ static PyObject * -_collections_deque_remove(dequeobject *deque, PyObject *value) -/*[clinic end generated code: output=6e44d24b93f7109e input=d53d4a0b082137f6]*/ +deque_remove(dequeobject *deque, PyObject *value) +/*[clinic end generated code: output=49e1666d612fe911 input=d972f32d15990880]*/ { PyObject *item; block *b = deque->leftblock; @@ -1485,7 +1484,7 @@ deque_traverse(dequeobject *deque, visitproc visit, void *arg) } /*[clinic input] -_collections.deque.__reduce__ +_collections.deque.__reduce__ as deque___reduce__ deque: dequeobject @@ -1493,8 +1492,8 @@ Return state information for pickling. [clinic start generated code]*/ static PyObject * -_collections_deque___reduce___impl(dequeobject *deque) -/*[clinic end generated code: output=98e9eed251df2133 input=4210e061fc57e988]*/ +deque___reduce___impl(dequeobject *deque) +/*[clinic end generated code: output=cb85d9e0b7d2c5ad input=991a933a5bc7a526]*/ { PyObject *state, *it; @@ -1630,36 +1629,36 @@ deque_richcompare(PyObject *v, PyObject *w, int op) /*[clinic input] @text_signature "([iterable[, maxlen]])" -_collections.deque.__init__ +_collections.deque.__init__ as deque___init__ deque: dequeobject iterable: object = NULL - maxlen: object = NULL + maxlen as maxlenobj: object = NULL A list-like sequence optimized for data accesses near its endpoints. [clinic start generated code]*/ static int -_collections_deque___init___impl(dequeobject *deque, PyObject *iterable, - PyObject *maxlen) -/*[clinic end generated code: output=9fbb306da99f6694 input=aa6219250dc91d12]*/ +deque___init___impl(dequeobject *deque, PyObject *iterable, + PyObject *maxlenobj) +/*[clinic end generated code: output=548e947960679dd9 input=8a87b7bfabea2cdf]*/ { - Py_ssize_t maxlenval = -1; - if (maxlen != NULL && maxlen != Py_None) { - maxlenval = PyLong_AsSsize_t(maxlen); - if (maxlenval == -1 && PyErr_Occurred()) + Py_ssize_t maxlen = -1; + if (maxlenobj != NULL && maxlenobj != Py_None) { + maxlen = PyLong_AsSsize_t(maxlenobj); + if (maxlen == -1 && PyErr_Occurred()) return -1; - if (maxlenval < 0) { + if (maxlen < 0) { PyErr_SetString(PyExc_ValueError, "maxlen must be non-negative"); return -1; } } - deque->maxlen = maxlenval; + deque->maxlen = maxlen; if (Py_SIZE(deque) > 0) deque_clear(deque); if (iterable != NULL) { - PyObject *rv = _collections_deque_extend(deque, iterable); + PyObject *rv = deque_extend(deque, iterable); if (rv == NULL) return -1; Py_DECREF(rv); @@ -1668,7 +1667,7 @@ _collections_deque___init___impl(dequeobject *deque, PyObject *iterable, } /*[clinic input] -_collections.deque.__sizeof__ +_collections.deque.__sizeof__ as deque___sizeof__ deque: dequeobject @@ -1676,8 +1675,8 @@ Return the size of the deque in memory, in bytes. [clinic start generated code]*/ static PyObject * -_collections_deque___sizeof___impl(dequeobject *deque) -/*[clinic end generated code: output=1a66234430a294a3 input=3d6a0b57c12c6f11]*/ +deque___sizeof___impl(dequeobject *deque) +/*[clinic end generated code: output=4d36e9fb4f30bbaf input=4e7c9a00c03c3290]*/ { size_t res = _PyObject_SIZE(Py_TYPE(deque)); size_t blocks; @@ -1699,7 +1698,7 @@ deque_get_maxlen(dequeobject *deque, void *Py_UNUSED(ignored)) static PyObject *deque_reviter(dequeobject *deque); /*[clinic input] -_collections.deque.__reversed__ +_collections.deque.__reversed__ as deque___reversed__ deque: dequeobject @@ -1707,8 +1706,8 @@ Return a reverse iterator over the deque. [clinic start generated code]*/ static PyObject * -_collections_deque___reversed___impl(dequeobject *deque) -/*[clinic end generated code: output=c6980fed84a53cc6 input=8b6299d6d60ea01a]*/ +deque___reversed___impl(dequeobject *deque) +/*[clinic end generated code: output=3e7e7e715883cf2e input=3d494c25a6fe5c7e]*/ { return deque_reviter(deque); } @@ -1724,24 +1723,24 @@ static PyGetSetDef deque_getset[] = { static PyObject *deque_iter(dequeobject *deque); static PyMethodDef deque_methods[] = { - _COLLECTIONS_DEQUE_APPEND_METHODDEF - _COLLECTIONS_DEQUE_APPENDLEFT_METHODDEF - _COLLECTIONS_DEQUE_CLEAR_METHODDEF - _COLLECTIONS_DEQUE___COPY___METHODDEF - _COLLECTIONS_DEQUE_COPY_METHODDEF - _COLLECTIONS_DEQUE_COUNT_METHODDEF - _COLLECTIONS_DEQUE_EXTEND_METHODDEF - _COLLECTIONS_DEQUE_EXTENDLEFT_METHODDEF - _COLLECTIONS_DEQUE_INDEX_METHODDEF - _COLLECTIONS_DEQUE_INSERT_METHODDEF - _COLLECTIONS_DEQUE_POP_METHODDEF - _COLLECTIONS_DEQUE_POPLEFT_METHODDEF - _COLLECTIONS_DEQUE___REDUCE___METHODDEF - _COLLECTIONS_DEQUE_REMOVE_METHODDEF - _COLLECTIONS_DEQUE___REVERSED___METHODDEF - _COLLECTIONS_DEQUE_REVERSE_METHODDEF - _COLLECTIONS_DEQUE_ROTATE_METHODDEF - _COLLECTIONS_DEQUE___SIZEOF___METHODDEF + DEQUE_APPEND_METHODDEF + DEQUE_APPENDLEFT_METHODDEF + DEQUE_CLEARMETHOD_METHODDEF + DEQUE___COPY___METHODDEF + DEQUE_COPY_METHODDEF + DEQUE_COUNT_METHODDEF + DEQUE_EXTEND_METHODDEF + DEQUE_EXTENDLEFT_METHODDEF + DEQUE_INDEX_METHODDEF + DEQUE_INSERT_METHODDEF + DEQUE_POP_METHODDEF + DEQUE_POPLEFT_METHODDEF + DEQUE___REDUCE___METHODDEF + DEQUE_REMOVE_METHODDEF + DEQUE___REVERSED___METHODDEF + DEQUE_REVERSE_METHODDEF + DEQUE_ROTATE_METHODDEF + DEQUE___SIZEOF___METHODDEF {"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS, PyDoc_STR("See PEP 585")}, {NULL, NULL} /* sentinel */ @@ -1757,13 +1756,13 @@ static PyType_Slot deque_slots[] = { {Py_tp_repr, deque_repr}, {Py_tp_hash, PyObject_HashNotImplemented}, {Py_tp_getattro, PyObject_GenericGetAttr}, - {Py_tp_doc, (void *)_collections_deque___init____doc__}, + {Py_tp_doc, (void *)deque___init____doc__}, {Py_tp_traverse, deque_traverse}, {Py_tp_clear, deque_clear}, {Py_tp_richcompare, deque_richcompare}, {Py_tp_iter, deque_iter}, {Py_tp_getset, deque_getset}, - {Py_tp_init, _collections_deque___init__}, + {Py_tp_init, deque___init__}, {Py_tp_alloc, PyType_GenericAlloc}, {Py_tp_new, deque_new}, {Py_tp_free, PyObject_GC_Del}, diff --git a/Modules/clinic/_collectionsmodule.c.h b/Modules/clinic/_collectionsmodule.c.h index 86b34ec8099972..7352d7ca9fcb92 100644 --- a/Modules/clinic/_collectionsmodule.c.h +++ b/Modules/clinic/_collectionsmodule.c.h @@ -9,146 +9,146 @@ preserve #include "pycore_abstract.h" // _PyNumber_Index() #include "pycore_modsupport.h" // _PyArg_CheckPositional() -PyDoc_STRVAR(_collections_deque_pop__doc__, +PyDoc_STRVAR(deque_pop__doc__, "pop($self, /)\n" "--\n" "\n" "Remove and return the rightmost element."); -#define _COLLECTIONS_DEQUE_POP_METHODDEF \ - {"pop", (PyCFunction)_collections_deque_pop, METH_NOARGS, _collections_deque_pop__doc__}, +#define DEQUE_POP_METHODDEF \ + {"pop", (PyCFunction)deque_pop, METH_NOARGS, deque_pop__doc__}, static PyObject * -_collections_deque_pop_impl(dequeobject *deque); +deque_pop_impl(dequeobject *deque); static PyObject * -_collections_deque_pop(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +deque_pop(dequeobject *deque, PyObject *Py_UNUSED(ignored)) { - return _collections_deque_pop_impl(deque); + return deque_pop_impl(deque); } -PyDoc_STRVAR(_collections_deque_popleft__doc__, +PyDoc_STRVAR(deque_popleft__doc__, "popleft($self, /)\n" "--\n" "\n" "Remove and return the leftmost element."); -#define _COLLECTIONS_DEQUE_POPLEFT_METHODDEF \ - {"popleft", (PyCFunction)_collections_deque_popleft, METH_NOARGS, _collections_deque_popleft__doc__}, +#define DEQUE_POPLEFT_METHODDEF \ + {"popleft", (PyCFunction)deque_popleft, METH_NOARGS, deque_popleft__doc__}, static PyObject * -_collections_deque_popleft_impl(dequeobject *deque); +deque_popleft_impl(dequeobject *deque); static PyObject * -_collections_deque_popleft(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +deque_popleft(dequeobject *deque, PyObject *Py_UNUSED(ignored)) { - return _collections_deque_popleft_impl(deque); + return deque_popleft_impl(deque); } -PyDoc_STRVAR(_collections_deque_append__doc__, +PyDoc_STRVAR(deque_append__doc__, "append($self, item, /)\n" "--\n" "\n" "Add an element to the right side of the deque."); -#define _COLLECTIONS_DEQUE_APPEND_METHODDEF \ - {"append", (PyCFunction)_collections_deque_append, METH_O, _collections_deque_append__doc__}, +#define DEQUE_APPEND_METHODDEF \ + {"append", (PyCFunction)deque_append, METH_O, deque_append__doc__}, -PyDoc_STRVAR(_collections_deque_appendleft__doc__, +PyDoc_STRVAR(deque_appendleft__doc__, "appendleft($self, item, /)\n" "--\n" "\n" "Add an element to the left side of the deque."); -#define _COLLECTIONS_DEQUE_APPENDLEFT_METHODDEF \ - {"appendleft", (PyCFunction)_collections_deque_appendleft, METH_O, _collections_deque_appendleft__doc__}, +#define DEQUE_APPENDLEFT_METHODDEF \ + {"appendleft", (PyCFunction)deque_appendleft, METH_O, deque_appendleft__doc__}, -PyDoc_STRVAR(_collections_deque_extend__doc__, +PyDoc_STRVAR(deque_extend__doc__, "extend($self, iterable, /)\n" "--\n" "\n" "Extend the right side of the deque with elements from the iterable."); -#define _COLLECTIONS_DEQUE_EXTEND_METHODDEF \ - {"extend", (PyCFunction)_collections_deque_extend, METH_O, _collections_deque_extend__doc__}, +#define DEQUE_EXTEND_METHODDEF \ + {"extend", (PyCFunction)deque_extend, METH_O, deque_extend__doc__}, -PyDoc_STRVAR(_collections_deque_extendleft__doc__, +PyDoc_STRVAR(deque_extendleft__doc__, "extendleft($self, iterable, /)\n" "--\n" "\n" "Extend the left side of the deque with elements from the iterable."); -#define _COLLECTIONS_DEQUE_EXTENDLEFT_METHODDEF \ - {"extendleft", (PyCFunction)_collections_deque_extendleft, METH_O, _collections_deque_extendleft__doc__}, +#define DEQUE_EXTENDLEFT_METHODDEF \ + {"extendleft", (PyCFunction)deque_extendleft, METH_O, deque_extendleft__doc__}, -PyDoc_STRVAR(_collections_deque_copy__doc__, +PyDoc_STRVAR(deque_copy__doc__, "copy($self, /)\n" "--\n" "\n" "Return a shallow copy of a deque."); -#define _COLLECTIONS_DEQUE_COPY_METHODDEF \ - {"copy", (PyCFunction)_collections_deque_copy, METH_NOARGS, _collections_deque_copy__doc__}, +#define DEQUE_COPY_METHODDEF \ + {"copy", (PyCFunction)deque_copy, METH_NOARGS, deque_copy__doc__}, static PyObject * -_collections_deque_copy_impl(dequeobject *deque); +deque_copy_impl(dequeobject *deque); static PyObject * -_collections_deque_copy(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +deque_copy(dequeobject *deque, PyObject *Py_UNUSED(ignored)) { - return _collections_deque_copy_impl(deque); + return deque_copy_impl(deque); } -PyDoc_STRVAR(_collections_deque___copy____doc__, +PyDoc_STRVAR(deque___copy____doc__, "__copy__($self, /)\n" "--\n" "\n" "Return a shallow copy of a deque."); -#define _COLLECTIONS_DEQUE___COPY___METHODDEF \ - {"__copy__", (PyCFunction)_collections_deque___copy__, METH_NOARGS, _collections_deque___copy____doc__}, +#define DEQUE___COPY___METHODDEF \ + {"__copy__", (PyCFunction)deque___copy__, METH_NOARGS, deque___copy____doc__}, static PyObject * -_collections_deque___copy___impl(dequeobject *deque); +deque___copy___impl(dequeobject *deque); static PyObject * -_collections_deque___copy__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +deque___copy__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) { - return _collections_deque___copy___impl(deque); + return deque___copy___impl(deque); } -PyDoc_STRVAR(_collections_deque_clear__doc__, +PyDoc_STRVAR(deque_clearmethod__doc__, "clear($self, /)\n" "--\n" "\n" "Remove all elements from the deque."); -#define _COLLECTIONS_DEQUE_CLEAR_METHODDEF \ - {"clear", (PyCFunction)_collections_deque_clear, METH_NOARGS, _collections_deque_clear__doc__}, +#define DEQUE_CLEARMETHOD_METHODDEF \ + {"clear", (PyCFunction)deque_clearmethod, METH_NOARGS, deque_clearmethod__doc__}, static PyObject * -_collections_deque_clear_impl(dequeobject *deque); +deque_clearmethod_impl(dequeobject *deque); static PyObject * -_collections_deque_clear(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +deque_clearmethod(dequeobject *deque, PyObject *Py_UNUSED(ignored)) { - return _collections_deque_clear_impl(deque); + return deque_clearmethod_impl(deque); } -PyDoc_STRVAR(_collections_deque_rotate__doc__, +PyDoc_STRVAR(deque_rotate__doc__, "rotate($self, n=1, /)\n" "--\n" "\n" "Rotate the deque n steps to the right. If n is negative, rotates left."); -#define _COLLECTIONS_DEQUE_ROTATE_METHODDEF \ - {"rotate", _PyCFunction_CAST(_collections_deque_rotate), METH_FASTCALL, _collections_deque_rotate__doc__}, +#define DEQUE_ROTATE_METHODDEF \ + {"rotate", _PyCFunction_CAST(deque_rotate), METH_FASTCALL, deque_rotate__doc__}, static PyObject * -_collections_deque_rotate_impl(dequeobject *deque, Py_ssize_t n); +deque_rotate_impl(dequeobject *deque, Py_ssize_t n); static PyObject * -_collections_deque_rotate(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) +deque_rotate(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) { PyObject *return_value = NULL; Py_ssize_t n = 1; @@ -172,40 +172,40 @@ _collections_deque_rotate(dequeobject *deque, PyObject *const *args, Py_ssize_t n = ival; } skip_optional: - return_value = _collections_deque_rotate_impl(deque, n); + return_value = deque_rotate_impl(deque, n); exit: return return_value; } -PyDoc_STRVAR(_collections_deque_reverse__doc__, +PyDoc_STRVAR(deque_reverse__doc__, "reverse($self, /)\n" "--\n" "\n" "Reverse *IN PLACE*."); -#define _COLLECTIONS_DEQUE_REVERSE_METHODDEF \ - {"reverse", (PyCFunction)_collections_deque_reverse, METH_NOARGS, _collections_deque_reverse__doc__}, +#define DEQUE_REVERSE_METHODDEF \ + {"reverse", (PyCFunction)deque_reverse, METH_NOARGS, deque_reverse__doc__}, static PyObject * -_collections_deque_reverse_impl(dequeobject *deque); +deque_reverse_impl(dequeobject *deque); static PyObject * -_collections_deque_reverse(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +deque_reverse(dequeobject *deque, PyObject *Py_UNUSED(ignored)) { - return _collections_deque_reverse_impl(deque); + return deque_reverse_impl(deque); } -PyDoc_STRVAR(_collections_deque_count__doc__, +PyDoc_STRVAR(deque_count__doc__, "count($self, value, /)\n" "--\n" "\n" "Return number of occurrences of value."); -#define _COLLECTIONS_DEQUE_COUNT_METHODDEF \ - {"count", (PyCFunction)_collections_deque_count, METH_O, _collections_deque_count__doc__}, +#define DEQUE_COUNT_METHODDEF \ + {"count", (PyCFunction)deque_count, METH_O, deque_count__doc__}, -PyDoc_STRVAR(_collections_deque_index__doc__, +PyDoc_STRVAR(deque_index__doc__, "index($self, value, [start, [stop]])\n" "--\n" "\n" @@ -213,15 +213,15 @@ PyDoc_STRVAR(_collections_deque_index__doc__, "\n" "Raises ValueError if the value is not present."); -#define _COLLECTIONS_DEQUE_INDEX_METHODDEF \ - {"index", _PyCFunction_CAST(_collections_deque_index), METH_FASTCALL, _collections_deque_index__doc__}, +#define DEQUE_INDEX_METHODDEF \ + {"index", _PyCFunction_CAST(deque_index), METH_FASTCALL, deque_index__doc__}, static PyObject * -_collections_deque_index_impl(dequeobject *deque, PyObject *value, - Py_ssize_t start, Py_ssize_t stop); +deque_index_impl(dequeobject *deque, PyObject *value, Py_ssize_t start, + Py_ssize_t stop); static PyObject * -_collections_deque_index(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) +deque_index(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) { PyObject *return_value = NULL; PyObject *value; @@ -245,27 +245,26 @@ _collections_deque_index(dequeobject *deque, PyObject *const *args, Py_ssize_t n goto exit; } skip_optional: - return_value = _collections_deque_index_impl(deque, value, start, stop); + return_value = deque_index_impl(deque, value, start, stop); exit: return return_value; } -PyDoc_STRVAR(_collections_deque_insert__doc__, +PyDoc_STRVAR(deque_insert__doc__, "insert($self, index, value, /)\n" "--\n" "\n" "Insert value before index."); -#define _COLLECTIONS_DEQUE_INSERT_METHODDEF \ - {"insert", _PyCFunction_CAST(_collections_deque_insert), METH_FASTCALL, _collections_deque_insert__doc__}, +#define DEQUE_INSERT_METHODDEF \ + {"insert", _PyCFunction_CAST(deque_insert), METH_FASTCALL, deque_insert__doc__}, static PyObject * -_collections_deque_insert_impl(dequeobject *deque, Py_ssize_t index, - PyObject *value); +deque_insert_impl(dequeobject *deque, Py_ssize_t index, PyObject *value); static PyObject * -_collections_deque_insert(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) +deque_insert(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) { PyObject *return_value = NULL; Py_ssize_t index; @@ -287,51 +286,51 @@ _collections_deque_insert(dequeobject *deque, PyObject *const *args, Py_ssize_t index = ival; } value = args[1]; - return_value = _collections_deque_insert_impl(deque, index, value); + return_value = deque_insert_impl(deque, index, value); exit: return return_value; } -PyDoc_STRVAR(_collections_deque_remove__doc__, +PyDoc_STRVAR(deque_remove__doc__, "remove($self, value, /)\n" "--\n" "\n" "Remove first occurrence of value."); -#define _COLLECTIONS_DEQUE_REMOVE_METHODDEF \ - {"remove", (PyCFunction)_collections_deque_remove, METH_O, _collections_deque_remove__doc__}, +#define DEQUE_REMOVE_METHODDEF \ + {"remove", (PyCFunction)deque_remove, METH_O, deque_remove__doc__}, -PyDoc_STRVAR(_collections_deque___reduce____doc__, +PyDoc_STRVAR(deque___reduce____doc__, "__reduce__($self, /)\n" "--\n" "\n" "Return state information for pickling."); -#define _COLLECTIONS_DEQUE___REDUCE___METHODDEF \ - {"__reduce__", (PyCFunction)_collections_deque___reduce__, METH_NOARGS, _collections_deque___reduce____doc__}, +#define DEQUE___REDUCE___METHODDEF \ + {"__reduce__", (PyCFunction)deque___reduce__, METH_NOARGS, deque___reduce____doc__}, static PyObject * -_collections_deque___reduce___impl(dequeobject *deque); +deque___reduce___impl(dequeobject *deque); static PyObject * -_collections_deque___reduce__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +deque___reduce__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) { - return _collections_deque___reduce___impl(deque); + return deque___reduce___impl(deque); } -PyDoc_STRVAR(_collections_deque___init____doc__, +PyDoc_STRVAR(deque___init____doc__, "deque([iterable[, maxlen]])\n" "--\n" "\n" "A list-like sequence optimized for data accesses near its endpoints."); static int -_collections_deque___init___impl(dequeobject *deque, PyObject *iterable, - PyObject *maxlen); +deque___init___impl(dequeobject *deque, PyObject *iterable, + PyObject *maxlenobj); static int -_collections_deque___init__(PyObject *deque, PyObject *args, PyObject *kwargs) +deque___init__(PyObject *deque, PyObject *args, PyObject *kwargs) { int return_value = -1; #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE) @@ -364,7 +363,7 @@ _collections_deque___init__(PyObject *deque, PyObject *args, PyObject *kwargs) Py_ssize_t nargs = PyTuple_GET_SIZE(args); Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0; PyObject *iterable = NULL; - PyObject *maxlen = NULL; + PyObject *maxlenobj = NULL; fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 2, 0, argsbuf); if (!fastargs) { @@ -379,48 +378,48 @@ _collections_deque___init__(PyObject *deque, PyObject *args, PyObject *kwargs) goto skip_optional_pos; } } - maxlen = fastargs[1]; + maxlenobj = fastargs[1]; skip_optional_pos: - return_value = _collections_deque___init___impl((dequeobject *)deque, iterable, maxlen); + return_value = deque___init___impl((dequeobject *)deque, iterable, maxlenobj); exit: return return_value; } -PyDoc_STRVAR(_collections_deque___sizeof____doc__, +PyDoc_STRVAR(deque___sizeof____doc__, "__sizeof__($self, /)\n" "--\n" "\n" "Return the size of the deque in memory, in bytes."); -#define _COLLECTIONS_DEQUE___SIZEOF___METHODDEF \ - {"__sizeof__", (PyCFunction)_collections_deque___sizeof__, METH_NOARGS, _collections_deque___sizeof____doc__}, +#define DEQUE___SIZEOF___METHODDEF \ + {"__sizeof__", (PyCFunction)deque___sizeof__, METH_NOARGS, deque___sizeof____doc__}, static PyObject * -_collections_deque___sizeof___impl(dequeobject *deque); +deque___sizeof___impl(dequeobject *deque); static PyObject * -_collections_deque___sizeof__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +deque___sizeof__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) { - return _collections_deque___sizeof___impl(deque); + return deque___sizeof___impl(deque); } -PyDoc_STRVAR(_collections_deque___reversed____doc__, +PyDoc_STRVAR(deque___reversed____doc__, "__reversed__($self, /)\n" "--\n" "\n" "Return a reverse iterator over the deque."); -#define _COLLECTIONS_DEQUE___REVERSED___METHODDEF \ - {"__reversed__", (PyCFunction)_collections_deque___reversed__, METH_NOARGS, _collections_deque___reversed____doc__}, +#define DEQUE___REVERSED___METHODDEF \ + {"__reversed__", (PyCFunction)deque___reversed__, METH_NOARGS, deque___reversed____doc__}, static PyObject * -_collections_deque___reversed___impl(dequeobject *deque); +deque___reversed___impl(dequeobject *deque); static PyObject * -_collections_deque___reversed__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) +deque___reversed__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) { - return _collections_deque___reversed___impl(deque); + return deque___reversed___impl(deque); } PyDoc_STRVAR(_collections__count_elements__doc__, @@ -490,4 +489,4 @@ tuplegetter_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) exit: return return_value; } -/*[clinic end generated code: output=564d113856aeef1c input=a9049054013a1b77]*/ +/*[clinic end generated code: output=0284b71df2a403ec input=a9049054013a1b77]*/ From b7bc0b25e69a28c1ff706fc21661d1c1ae882e9a Mon Sep 17 00:00:00 2001 From: Matt Page Date: Wed, 17 Jan 2024 17:56:05 -0800 Subject: [PATCH 8/9] Reuse existing argument names --- Modules/_collectionsmodule.c | 29 +++++++++++++-------------- Modules/clinic/_collectionsmodule.c.h | 19 +++++++++--------- 2 files changed, 23 insertions(+), 25 deletions(-) diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c index 32b69b3e546f67..ef77d34b10e47b 100644 --- a/Modules/_collectionsmodule.c +++ b/Modules/_collectionsmodule.c @@ -1080,15 +1080,15 @@ deque_reverse_impl(dequeobject *deque) _collections.deque.count as deque_count deque: dequeobject - value: object + value as v: object / Return number of occurrences of value. [clinic start generated code]*/ static PyObject * -deque_count(dequeobject *deque, PyObject *value) -/*[clinic end generated code: output=39594ae05ff15239 input=dd7593184e23fe32]*/ +deque_count(dequeobject *deque, PyObject *v) +/*[clinic end generated code: output=7405d289d94d7b9b input=1892925260ff5d78]*/ { block *b = deque->leftblock; Py_ssize_t index = deque->leftindex; @@ -1101,7 +1101,7 @@ deque_count(dequeobject *deque, PyObject *value) while (--n >= 0) { CHECK_NOT_END(b); item = Py_NewRef(b->data[index]); - cmp = PyObject_RichCompareBool(item, value, Py_EQ); + cmp = PyObject_RichCompareBool(item, v, Py_EQ); Py_DECREF(item); if (cmp < 0) return NULL; @@ -1166,7 +1166,7 @@ deque_len(dequeobject *deque) _collections.deque.index as deque_index deque: dequeobject - value: object + value as v: object start: object(converter='_PyEval_SliceIndexNotNone', type='Py_ssize_t', c_default='0') = NULL stop: object(converter='_PyEval_SliceIndexNotNone', type='Py_ssize_t', c_default='Py_SIZE(deque)') = NULL / @@ -1177,9 +1177,9 @@ Raises ValueError if the value is not present. [clinic start generated code]*/ static PyObject * -deque_index_impl(dequeobject *deque, PyObject *value, Py_ssize_t start, +deque_index_impl(dequeobject *deque, PyObject *v, Py_ssize_t start, Py_ssize_t stop) -/*[clinic end generated code: output=754c388d6c6a8cfe input=8e3f101d57b012b1]*/ +/*[clinic end generated code: output=df45132753175ef9 input=140210c099830f64]*/ { Py_ssize_t i, n; PyObject *item; @@ -1219,7 +1219,7 @@ deque_index_impl(dequeobject *deque, PyObject *value, Py_ssize_t start, while (--n >= 0) { CHECK_NOT_END(b); item = b->data[index]; - cmp = PyObject_RichCompareBool(item, value, Py_EQ); + cmp = PyObject_RichCompareBool(item, v, Py_EQ); if (cmp > 0) return PyLong_FromSsize_t(stop - n - 1); if (cmp < 0) @@ -1235,7 +1235,7 @@ deque_index_impl(dequeobject *deque, PyObject *value, Py_ssize_t start, index = 0; } } - PyErr_Format(PyExc_ValueError, "%R is not in deque", value); + PyErr_Format(PyExc_ValueError, "%R is not in deque", v); return NULL; } @@ -1629,7 +1629,7 @@ deque_richcompare(PyObject *v, PyObject *w, int op) /*[clinic input] @text_signature "([iterable[, maxlen]])" -_collections.deque.__init__ as deque___init__ +_collections.deque.__init__ as deque_init deque: dequeobject iterable: object = NULL @@ -1639,9 +1639,8 @@ A list-like sequence optimized for data accesses near its endpoints. [clinic start generated code]*/ static int -deque___init___impl(dequeobject *deque, PyObject *iterable, - PyObject *maxlenobj) -/*[clinic end generated code: output=548e947960679dd9 input=8a87b7bfabea2cdf]*/ +deque_init_impl(dequeobject *deque, PyObject *iterable, PyObject *maxlenobj) +/*[clinic end generated code: output=7084a39d71218dcd input=5ebdffc48a2d27ae]*/ { Py_ssize_t maxlen = -1; @@ -1756,13 +1755,13 @@ static PyType_Slot deque_slots[] = { {Py_tp_repr, deque_repr}, {Py_tp_hash, PyObject_HashNotImplemented}, {Py_tp_getattro, PyObject_GenericGetAttr}, - {Py_tp_doc, (void *)deque___init____doc__}, + {Py_tp_doc, (void *)deque_init__doc__}, {Py_tp_traverse, deque_traverse}, {Py_tp_clear, deque_clear}, {Py_tp_richcompare, deque_richcompare}, {Py_tp_iter, deque_iter}, {Py_tp_getset, deque_getset}, - {Py_tp_init, deque___init__}, + {Py_tp_init, deque_init}, {Py_tp_alloc, PyType_GenericAlloc}, {Py_tp_new, deque_new}, {Py_tp_free, PyObject_GC_Del}, diff --git a/Modules/clinic/_collectionsmodule.c.h b/Modules/clinic/_collectionsmodule.c.h index 7352d7ca9fcb92..60fb12a2231619 100644 --- a/Modules/clinic/_collectionsmodule.c.h +++ b/Modules/clinic/_collectionsmodule.c.h @@ -217,21 +217,21 @@ PyDoc_STRVAR(deque_index__doc__, {"index", _PyCFunction_CAST(deque_index), METH_FASTCALL, deque_index__doc__}, static PyObject * -deque_index_impl(dequeobject *deque, PyObject *value, Py_ssize_t start, +deque_index_impl(dequeobject *deque, PyObject *v, Py_ssize_t start, Py_ssize_t stop); static PyObject * deque_index(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) { PyObject *return_value = NULL; - PyObject *value; + PyObject *v; Py_ssize_t start = 0; Py_ssize_t stop = Py_SIZE(deque); if (!_PyArg_CheckPositional("index", nargs, 1, 3)) { goto exit; } - value = args[0]; + v = args[0]; if (nargs < 2) { goto skip_optional; } @@ -245,7 +245,7 @@ deque_index(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs) goto exit; } skip_optional: - return_value = deque_index_impl(deque, value, start, stop); + return_value = deque_index_impl(deque, v, start, stop); exit: return return_value; @@ -319,18 +319,17 @@ deque___reduce__(dequeobject *deque, PyObject *Py_UNUSED(ignored)) return deque___reduce___impl(deque); } -PyDoc_STRVAR(deque___init____doc__, +PyDoc_STRVAR(deque_init__doc__, "deque([iterable[, maxlen]])\n" "--\n" "\n" "A list-like sequence optimized for data accesses near its endpoints."); static int -deque___init___impl(dequeobject *deque, PyObject *iterable, - PyObject *maxlenobj); +deque_init_impl(dequeobject *deque, PyObject *iterable, PyObject *maxlenobj); static int -deque___init__(PyObject *deque, PyObject *args, PyObject *kwargs) +deque_init(PyObject *deque, PyObject *args, PyObject *kwargs) { int return_value = -1; #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE) @@ -380,7 +379,7 @@ deque___init__(PyObject *deque, PyObject *args, PyObject *kwargs) } maxlenobj = fastargs[1]; skip_optional_pos: - return_value = deque___init___impl((dequeobject *)deque, iterable, maxlenobj); + return_value = deque_init_impl((dequeobject *)deque, iterable, maxlenobj); exit: return return_value; @@ -489,4 +488,4 @@ tuplegetter_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) exit: return return_value; } -/*[clinic end generated code: output=0284b71df2a403ec input=a9049054013a1b77]*/ +/*[clinic end generated code: output=3633a5cbc23e8440 input=a9049054013a1b77]*/ From 934fd2ea57d363c9b96e0b9fc249b0b5124cbf7b Mon Sep 17 00:00:00 2001 From: "Erlend E. Aasland" Date: Mon, 29 Jan 2024 15:37:13 +0100 Subject: [PATCH 9/9] Update Misc/NEWS.d/next/Core and Builtins/2024-01-11-22-58-45.gh-issue-112050.hDuvDW.rst --- .../2024-01-11-22-58-45.gh-issue-112050.hDuvDW.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Misc/NEWS.d/next/Core and Builtins/2024-01-11-22-58-45.gh-issue-112050.hDuvDW.rst b/Misc/NEWS.d/next/Core and Builtins/2024-01-11-22-58-45.gh-issue-112050.hDuvDW.rst index d5e98bfb6169c4..e5f3d5ea0cea25 100644 --- a/Misc/NEWS.d/next/Core and Builtins/2024-01-11-22-58-45.gh-issue-112050.hDuvDW.rst +++ b/Misc/NEWS.d/next/Core and Builtins/2024-01-11-22-58-45.gh-issue-112050.hDuvDW.rst @@ -1 +1 @@ -Convert most methods on collections.deque to use Argument Clinic. This is in preparation for making deques thread-safe when the GIL is disabled. To do so, we'll use Clinic's critical_section directive. +Convert :class:`collections.deque` to use Argument Clinic.