Source code
Revision control
Copy as Markdown
Other Tools
#include "Python.h"
#include "structmember.h"
// Include order important
#include "_multilib/defs.h"
#include "_multilib/istr.h"
#include "_multilib/pair_list.h"
#include "_multilib/dict.h"
#include "_multilib/iter.h"
#include "_multilib/views.h"
static PyObject *collections_abc_mapping;
static PyObject *collections_abc_mut_mapping;
static PyObject *collections_abc_mut_multi_mapping;
static PyTypeObject multidict_type;
static PyTypeObject cimultidict_type;
static PyTypeObject multidict_proxy_type;
static PyTypeObject cimultidict_proxy_type;
static PyObject *repr_func;
#define MultiDict_CheckExact(o) (Py_TYPE(o) == &multidict_type)
#define CIMultiDict_CheckExact(o) (Py_TYPE(o) == &cimultidict_type)
#define MultiDictProxy_CheckExact(o) (Py_TYPE(o) == &multidict_proxy_type)
#define CIMultiDictProxy_CheckExact(o) (Py_TYPE(o) == &cimultidict_proxy_type)
/* Helper macro for something like isinstance(obj, Base) */
#define _MultiDict_Check(o) \
((MultiDict_CheckExact(o)) || \
(CIMultiDict_CheckExact(o)) || \
(MultiDictProxy_CheckExact(o)) || \
(CIMultiDictProxy_CheckExact(o)))
/******************** Internal Methods ********************/
/* Forward declaration */
static PyObject *multidict_items(MultiDictObject *self);
static inline PyObject *
_multidict_getone(MultiDictObject *self, PyObject *key, PyObject *_default)
{
PyObject *val = pair_list_get_one(&self->pairs, key);
if (val == NULL &&
PyErr_ExceptionMatches(PyExc_KeyError) &&
_default != NULL)
{
PyErr_Clear();
Py_INCREF(_default);
return _default;
}
return val;
}
static inline int
_multidict_eq(MultiDictObject *self, MultiDictObject *other)
{
Py_ssize_t pos1 = 0,
pos2 = 0;
Py_hash_t h1 = 0,
h2 = 0;
PyObject *identity1 = NULL,
*identity2 = NULL,
*value1 = NULL,
*value2 = NULL;
int cmp_identity = 0,
cmp_value = 0;
if (self == other) {
return 1;
}
if (pair_list_len(&self->pairs) != pair_list_len(&other->pairs)) {
return 0;
}
while (_pair_list_next(&self->pairs, &pos1, &identity1, NULL, &value1, &h1) &&
_pair_list_next(&other->pairs, &pos2, &identity2, NULL, &value2, &h2))
{
if (h1 != h2) {
return 0;
}
cmp_identity = PyObject_RichCompareBool(identity1, identity2, Py_NE);
if (cmp_identity < 0) {
return -1;
}
cmp_value = PyObject_RichCompareBool(value1, value2, Py_NE);
if (cmp_value < 0) {
return -1;
}
if (cmp_identity || cmp_value) {
return 0;
}
}
return 1;
}
static inline int
_multidict_update_items(MultiDictObject *self, pair_list_t *pairs)
{
return pair_list_update(&self->pairs, pairs);
}
static inline int
_multidict_append_items(MultiDictObject *self, pair_list_t *pairs)
{
PyObject *key = NULL,
*value = NULL;
Py_ssize_t pos = 0;
while (_pair_list_next(pairs, &pos, NULL, &key, &value, NULL)) {
if (pair_list_add(&self->pairs, key, value) < 0) {
return -1;
}
}
return 0;
}
static inline int
_multidict_append_items_seq(MultiDictObject *self, PyObject *arg,
const char *name)
{
PyObject *key = NULL,
*value = NULL,
*item = NULL,
*iter = PyObject_GetIter(arg);
if (iter == NULL) {
return -1;
}
while ((item = PyIter_Next(iter)) != NULL) {
if (PyTuple_CheckExact(item)) {
if (PyTuple_GET_SIZE(item) != 2) {
goto invalid_type;
}
key = PyTuple_GET_ITEM(item, 0);
Py_INCREF(key);
value = PyTuple_GET_ITEM(item, 1);
Py_INCREF(value);
}
else if (PyList_CheckExact(item)) {
if (PyList_GET_SIZE(item) != 2) {
goto invalid_type;
}
key = PyList_GET_ITEM(item, 0);
Py_INCREF(key);
value = PyList_GET_ITEM(item, 1);
Py_INCREF(value);
}
else if (PySequence_Check(item)) {
if (PySequence_Size(item) != 2) {
goto invalid_type;
}
key = PySequence_GetItem(item, 0);
value = PySequence_GetItem(item, 1);
} else {
goto invalid_type;
}
if (pair_list_add(&self->pairs, key, value) < 0) {
goto fail;
}
Py_CLEAR(key);
Py_CLEAR(value);
Py_CLEAR(item);
}
Py_DECREF(iter);
if (PyErr_Occurred()) {
return -1;
}
return 0;
invalid_type:
PyErr_Format(
PyExc_TypeError,
"%s takes either dict or list of (key, value) pairs",
name,
NULL
);
goto fail;
fail:
Py_XDECREF(key);
Py_XDECREF(value);
Py_XDECREF(item);
Py_DECREF(iter);
return -1;
}
static inline int
_multidict_list_extend(PyObject *list, PyObject *target_list)
{
PyObject *item = NULL,
*iter = PyObject_GetIter(target_list);
if (iter == NULL) {
return -1;
}
while ((item = PyIter_Next(iter)) != NULL) {
if (PyList_Append(list, item) < 0) {
Py_DECREF(item);
Py_DECREF(iter);
return -1;
}
Py_DECREF(item);
}
Py_DECREF(iter);
if (PyErr_Occurred()) {
return -1;
}
return 0;
}
static inline int
_multidict_extend_with_args(MultiDictObject *self, PyObject *arg,
PyObject *kwds, const char *name, int do_add)
{
PyObject *arg_items = NULL, /* tracked by GC */
*kwds_items = NULL; /* new reference */
pair_list_t *pairs = NULL;
int err = 0;
if (kwds && !PyArg_ValidateKeywordArguments(kwds)) {
return -1;
}
// TODO: mb can be refactored more clear
if (_MultiDict_Check(arg) && kwds == NULL) {
if (MultiDict_CheckExact(arg) || CIMultiDict_CheckExact(arg)) {
pairs = &((MultiDictObject*)arg)->pairs;
} else if (MultiDictProxy_CheckExact(arg) || CIMultiDictProxy_CheckExact(arg)) {
pairs = &((MultiDictProxyObject*)arg)->md->pairs;
}
if (do_add) {
return _multidict_append_items(self, pairs);
}
return _multidict_update_items(self, pairs);
}
if (PyObject_HasAttrString(arg, "items")) {
if (_MultiDict_Check(arg)) {
arg_items = multidict_items((MultiDictObject*)arg);
} else {
arg_items = PyMapping_Items(arg);
}
if (arg_items == NULL) {
return -1;
}
} else {
arg_items = arg;
Py_INCREF(arg_items);
}
if (kwds) {
PyObject *tmp = PySequence_List(arg_items);
Py_DECREF(arg_items);
arg_items = tmp;
if (arg_items == NULL) {
return -1;
}
kwds_items = PyDict_Items(kwds);
if (kwds_items == NULL) {
Py_DECREF(arg_items);
return -1;
}
err = _multidict_list_extend(arg_items, kwds_items);
Py_DECREF(kwds_items);
if (err < 0) {
Py_DECREF(arg_items);
return -1;
}
}
if (do_add) {
err = _multidict_append_items_seq(self, arg_items, name);
} else {
err = pair_list_update_from_seq(&self->pairs, arg_items);
}
Py_DECREF(arg_items);
return err;
}
static inline int
_multidict_extend_with_kwds(MultiDictObject *self, PyObject *kwds,
const char *name, int do_add)
{
PyObject *arg = NULL;
int err = 0;
if (!PyArg_ValidateKeywordArguments(kwds)) {
return -1;
}
arg = PyDict_Items(kwds);
if (do_add) {
err = _multidict_append_items_seq(self, arg, name);
} else {
err = pair_list_update_from_seq(&self->pairs, arg);
}
Py_DECREF(arg);
return err;
}
static inline int
_multidict_extend(MultiDictObject *self, PyObject *args, PyObject *kwds,
const char *name, int do_add)
{
PyObject *arg = NULL;
if (args && PyObject_Length(args) > 1) {
PyErr_Format(
PyExc_TypeError,
"%s takes at most 1 positional argument (%zd given)",
name, PyObject_Length(args), NULL
);
return -1;
}
if (args && PyObject_Length(args) > 0) {
if (!PyArg_UnpackTuple(args, name, 0, 1, &arg)) {
return -1;
}
if (_multidict_extend_with_args(self, arg, kwds, name, do_add) < 0) {
return -1;
}
} else if (kwds && PyObject_Length(kwds) > 0) {
if (_multidict_extend_with_kwds(self, kwds, name, do_add) < 0) {
return -1;
}
}
return 0;
}
static inline PyObject *
_multidict_copy(MultiDictObject *self, PyTypeObject *multidict_tp_object)
{
MultiDictObject *new_multidict = NULL;
PyObject *arg_items = NULL,
*items = NULL;
new_multidict = (MultiDictObject*)PyType_GenericNew(
multidict_tp_object, NULL, NULL);
if (new_multidict == NULL) {
return NULL;
}
if (multidict_tp_object->tp_init(
(PyObject*)new_multidict, NULL, NULL) < 0)
{
return NULL;
}
items = multidict_items(self);
if (items == NULL) {
goto fail;
}
// TODO: "Implementation looks as slow as possible ..."
arg_items = PyTuple_New(1);
if (arg_items == NULL) {
goto fail;
}
Py_INCREF(items);
PyTuple_SET_ITEM(arg_items, 0, items);
if (_multidict_extend(
new_multidict, arg_items, NULL, "copy", 1) < 0)
{
goto fail;
}
Py_DECREF(items);
Py_DECREF(arg_items);
return (PyObject*)new_multidict;
fail:
Py_XDECREF(items);
Py_XDECREF(arg_items);
Py_DECREF(new_multidict);
return NULL;
}
static inline PyObject *
_multidict_proxy_copy(MultiDictProxyObject *self, PyTypeObject *type)
{
PyObject *new_multidict = PyType_GenericNew(type, NULL, NULL);
if (new_multidict == NULL) {
goto fail;
}
if (type->tp_init(new_multidict, NULL, NULL) < 0) {
goto fail;
}
if (_multidict_extend_with_args(
(MultiDictObject*)new_multidict, (PyObject*)self, NULL, "copy", 1) < 0)
{
goto fail;
}
return new_multidict;
fail:
Py_XDECREF(new_multidict);
return NULL;
}
/******************** Base Methods ********************/
static inline PyObject *
multidict_getall(MultiDictObject *self, PyObject *args, PyObject *kwds)
{
PyObject *list = NULL,
*key = NULL,
*_default = NULL;
static char *getall_keywords[] = {"key", "default", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getall",
getall_keywords, &key, &_default))
{
return NULL;
}
list = pair_list_get_all(&self->pairs, key);
if (list == NULL &&
PyErr_ExceptionMatches(PyExc_KeyError) &&
_default != NULL)
{
PyErr_Clear();
Py_INCREF(_default);
return _default;
}
return list;
}
static inline PyObject *
multidict_getone(MultiDictObject *self, PyObject *args, PyObject *kwds)
{
PyObject *key = NULL,
*_default = NULL;
static char *getone_keywords[] = {"key", "default", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getone",
getone_keywords, &key, &_default))
{
return NULL;
}
return _multidict_getone(self, key, _default);
}
static inline PyObject *
multidict_get(MultiDictObject *self, PyObject *args, PyObject *kwds)
{
PyObject *key = NULL,
*_default = Py_None,
*ret;
static char *getone_keywords[] = {"key", "default", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getone",
getone_keywords, &key, &_default))
{
return NULL;
}
ret = _multidict_getone(self, key, _default);
return ret;
}
static inline PyObject *
multidict_keys(MultiDictObject *self)
{
return multidict_keysview_new((PyObject*)self);
}
static inline PyObject *
multidict_items(MultiDictObject *self)
{
return multidict_itemsview_new((PyObject*)self);
}
static inline PyObject *
multidict_values(MultiDictObject *self)
{
return multidict_valuesview_new((PyObject*)self);
}
static inline PyObject *
multidict_reduce(MultiDictObject *self)
{
PyObject *items = NULL,
*items_list = NULL,
*args = NULL,
*result = NULL;
items = multidict_items(self);
if (items == NULL) {
goto ret;
}
items_list = PySequence_List(items);
if (items_list == NULL) {
goto ret;
}
args = PyTuple_Pack(1, items_list);
if (args == NULL) {
goto ret;
}
result = PyTuple_Pack(2, Py_TYPE(self), args);
ret:
Py_XDECREF(args);
Py_XDECREF(items_list);
Py_XDECREF(items);
return result;
}
static inline PyObject *
multidict_repr(PyObject *self)
{
return PyObject_CallFunctionObjArgs(
repr_func, self, NULL);
}
static inline Py_ssize_t
multidict_mp_len(MultiDictObject *self)
{
return pair_list_len(&self->pairs);
}
static inline PyObject *
multidict_mp_subscript(MultiDictObject *self, PyObject *key)
{
return _multidict_getone(self, key, NULL);
}
static inline int
multidict_mp_as_subscript(MultiDictObject *self, PyObject *key, PyObject *val)
{
if (val == NULL) {
return pair_list_del(&self->pairs, key);
} else {
return pair_list_replace(&self->pairs, key, val);
}
}
static inline int
multidict_sq_contains(MultiDictObject *self, PyObject *key)
{
return pair_list_contains(&self->pairs, key);
}
static inline PyObject *
multidict_tp_iter(MultiDictObject *self)
{
return multidict_keys_iter_new(self);
}
static inline PyObject *
multidict_tp_richcompare(PyObject *self, PyObject *other, int op)
{
// TODO: refactoring me with love
int cmp = 0;
if (op != Py_EQ && op != Py_NE) {
Py_RETURN_NOTIMPLEMENTED;
}
if (MultiDict_CheckExact(other) || CIMultiDict_CheckExact(other)) {
cmp = _multidict_eq(
(MultiDictObject*)self,
(MultiDictObject*)other
);
if (cmp < 0) {
return NULL;
}
if (op == Py_NE) {
cmp = !cmp;
}
return PyBool_FromLong(cmp);
}
if (MultiDictProxy_CheckExact(other) || CIMultiDictProxy_CheckExact(other)) {
cmp = _multidict_eq(
(MultiDictObject*)self,
((MultiDictProxyObject*)other)->md
);
if (cmp < 0) {
return NULL;
}
if (op == Py_NE) {
cmp = !cmp;
}
return PyBool_FromLong(cmp);
}
cmp = PyObject_IsInstance(other, (PyObject*)collections_abc_mapping);
if (cmp < 0) {
return NULL;
}
if (cmp) {
cmp = pair_list_eq_to_mapping(&((MultiDictObject*)self)->pairs, other);
if (cmp < 0) {
return NULL;
}
if (op == Py_NE) {
cmp = !cmp;
}
return PyBool_FromLong(cmp);
}
Py_RETURN_NOTIMPLEMENTED;
}
static inline void
multidict_tp_dealloc(MultiDictObject *self)
{
PyObject_GC_UnTrack(self);
Py_TRASHCAN_SAFE_BEGIN(self);
if (self->weaklist != NULL) {
PyObject_ClearWeakRefs((PyObject *)self);
};
pair_list_dealloc(&self->pairs);
Py_TYPE(self)->tp_free((PyObject *)self);
Py_TRASHCAN_SAFE_END(self);
}
static inline int
multidict_tp_traverse(MultiDictObject *self, visitproc visit, void *arg)
{
return pair_list_traverse(&self->pairs, visit, arg);
}
static inline int
multidict_tp_clear(MultiDictObject *self)
{
return pair_list_clear(&self->pairs);
}
PyDoc_STRVAR(multidict_getall_doc,
"Return a list of all values matching the key.");
PyDoc_STRVAR(multidict_getone_doc,
"Get first value matching the key.");
PyDoc_STRVAR(multidict_get_doc,
"Get first value matching the key.\n\nThe method is alias for .getone().");
PyDoc_STRVAR(multidict_keys_doc,
"Return a new view of the dictionary's keys.");
PyDoc_STRVAR(multidict_items_doc,
"Return a new view of the dictionary's items *(key, value) pairs).");
PyDoc_STRVAR(multidict_values_doc,
"Return a new view of the dictionary's values.");
/******************** MultiDict ********************/
static inline int
multidict_tp_init(MultiDictObject *self, PyObject *args, PyObject *kwds)
{
if (pair_list_init(&self->pairs) < 0) {
return -1;
}
if (_multidict_extend(self, args, kwds, "MultiDict", 1) < 0) {
return -1;
}
return 0;
}
static inline PyObject *
multidict_add(MultiDictObject *self, PyObject *args, PyObject *kwds)
{
PyObject *key = NULL,
*val = NULL;
static char *kwlist[] = {"key", "value", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO:add",
kwlist, &key, &val))
{
return NULL;
}
if (pair_list_add(&self->pairs, key, val) < 0) {
return NULL;
}
Py_RETURN_NONE;
}
static inline PyObject *
multidict_copy(MultiDictObject *self)
{
return _multidict_copy(self, &multidict_type);
}
static inline PyObject *
multidict_extend(MultiDictObject *self, PyObject *args, PyObject *kwds)
{
if (_multidict_extend(self, args, kwds, "extend", 1) < 0) {
return NULL;
}
Py_RETURN_NONE;
}
static inline PyObject *
multidict_clear(MultiDictObject *self)
{
if (pair_list_clear(&self->pairs) < 0) {
return NULL;
}
Py_RETURN_NONE;
}
static inline PyObject *
multidict_setdefault(MultiDictObject *self, PyObject *args, PyObject *kwds)
{
PyObject *key = NULL,
*_default = NULL;
static char *setdefault_keywords[] = {"key", "default", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:setdefault",
setdefault_keywords, &key, &_default))
{
return NULL;
}
return pair_list_set_default(&self->pairs, key, _default);
}
static inline PyObject *
multidict_popone(MultiDictObject *self, PyObject *args, PyObject *kwds)
{
PyObject *key = NULL,
*_default = NULL,
*ret_val = NULL;
static char *popone_keywords[] = {"key", "default", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:popone",
popone_keywords, &key, &_default))
{
return NULL;
}
ret_val = pair_list_pop_one(&self->pairs, key);
if (ret_val == NULL &&
PyErr_ExceptionMatches(PyExc_KeyError) &&
_default != NULL)
{
PyErr_Clear();
Py_INCREF(_default);
return _default;
}
return ret_val;
}
static inline PyObject *
multidict_popall(MultiDictObject *self, PyObject *args, PyObject *kwds)
{
PyObject *key = NULL,
*_default = NULL,
*ret_val = NULL;
static char *popall_keywords[] = {"key", "default", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:popall",
popall_keywords, &key, &_default))
{
return NULL;
}
ret_val = pair_list_pop_all(&self->pairs, key);
if (ret_val == NULL &&
PyErr_ExceptionMatches(PyExc_KeyError) &&
_default != NULL)
{
PyErr_Clear();
Py_INCREF(_default);
return _default;
}
return ret_val;
}
static inline PyObject *
multidict_popitem(MultiDictObject *self)
{
return pair_list_pop_item(&self->pairs);
}
static inline PyObject *
multidict_update(MultiDictObject *self, PyObject *args, PyObject *kwds)
{
if (_multidict_extend(self, args, kwds, "update", 0) < 0) {
return NULL;
}
Py_RETURN_NONE;
}
PyDoc_STRVAR(multidict_add_doc,
"Add the key and value, not overwriting any previous value.");
PyDoc_STRVAR(multidict_copy_doc,
"Return a copy of itself.");
PyDoc_STRVAR(multdicit_method_extend_doc,
"Extend current MultiDict with more values.\n\
This method must be used instead of update.");
PyDoc_STRVAR(multidict_clear_doc,
"Remove all items from MultiDict");
PyDoc_STRVAR(multidict_setdefault_doc,
"Return value for key, set value to default if key is not present.");
PyDoc_STRVAR(multidict_popone_doc,
"Remove the last occurrence of key and return the corresponding value.\n\n\
If key is not found, default is returned if given, otherwise KeyError is \
raised.\n");
PyDoc_STRVAR(multidict_popall_doc,
"Remove all occurrences of key and return the list of corresponding values.\n\n\
If key is not found, default is returned if given, otherwise KeyError is \
raised.\n");
PyDoc_STRVAR(multidict_popitem_doc,
"Remove and return an arbitrary (key, value) pair.");
PyDoc_STRVAR(multidict_update_doc,
"Update the dictionary from *other*, overwriting existing keys.");
#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 9
#define multidict_class_getitem Py_GenericAlias
#else
static inline PyObject *
multidict_class_getitem(PyObject *self, PyObject *arg)
{
Py_INCREF(self);
return self;
}
#endif
PyDoc_STRVAR(sizeof__doc__,
"D.__sizeof__() -> size of D in memory, in bytes");
static inline PyObject *
_multidict_sizeof(MultiDictObject *self)
{
Py_ssize_t size = sizeof(MultiDictObject);
if (self->pairs.pairs != self->pairs.buffer) {
size += (Py_ssize_t)sizeof(pair_t) * self->pairs.capacity;
}
return PyLong_FromSsize_t(size);
}
static PySequenceMethods multidict_sequence = {
.sq_contains = (objobjproc)multidict_sq_contains,
};
static PyMappingMethods multidict_mapping = {
.mp_length = (lenfunc)multidict_mp_len,
.mp_subscript = (binaryfunc)multidict_mp_subscript,
.mp_ass_subscript = (objobjargproc)multidict_mp_as_subscript,
};
static PyMethodDef multidict_methods[] = {
{
"getall",
(PyCFunction)multidict_getall,
METH_VARARGS | METH_KEYWORDS,
multidict_getall_doc
},
{
"getone",
(PyCFunction)multidict_getone,
METH_VARARGS | METH_KEYWORDS,
multidict_getone_doc
},
{
"get",
(PyCFunction)multidict_get,
METH_VARARGS | METH_KEYWORDS,
multidict_get_doc
},
{
"keys",
(PyCFunction)multidict_keys,
METH_NOARGS,
multidict_keys_doc
},
{
"items",
(PyCFunction)multidict_items,
METH_NOARGS,
multidict_items_doc
},
{
"values",
(PyCFunction)multidict_values,
METH_NOARGS,
multidict_values_doc
},
{
"add",
(PyCFunction)multidict_add,
METH_VARARGS | METH_KEYWORDS,
multidict_add_doc
},
{
"copy",
(PyCFunction)multidict_copy,
METH_NOARGS,
multidict_copy_doc
},
{
"extend",
(PyCFunction)multidict_extend,
METH_VARARGS | METH_KEYWORDS,
multdicit_method_extend_doc
},
{
"clear",
(PyCFunction)multidict_clear,
METH_NOARGS,
multidict_clear_doc
},
{
"setdefault",
(PyCFunction)multidict_setdefault,
METH_VARARGS | METH_KEYWORDS,
multidict_setdefault_doc
},
{
"popone",
(PyCFunction)multidict_popone,
METH_VARARGS | METH_KEYWORDS,
multidict_popone_doc
},
{
"pop",
(PyCFunction)multidict_popone,
METH_VARARGS | METH_KEYWORDS,
multidict_popone_doc
},
{
"popall",
(PyCFunction)multidict_popall,
METH_VARARGS | METH_KEYWORDS,
multidict_popall_doc
},
{
"popitem",
(PyCFunction)multidict_popitem,
METH_NOARGS,
multidict_popitem_doc
},
{
"update",
(PyCFunction)multidict_update,
METH_VARARGS | METH_KEYWORDS,
multidict_update_doc
},
{
"__reduce__",
(PyCFunction)multidict_reduce,
METH_NOARGS,
NULL,
},
{
"__class_getitem__",
(PyCFunction)multidict_class_getitem,
METH_O | METH_CLASS,
NULL
},
{
"__sizeof__",
(PyCFunction)_multidict_sizeof,
METH_NOARGS,
sizeof__doc__,
},
{
NULL,
NULL
} /* sentinel */
};
PyDoc_STRVAR(MultDict_doc,
"Dictionary with the support for duplicate keys.");
static PyTypeObject multidict_type = {
PyVarObject_HEAD_INIT(NULL, 0)
"multidict._multidict.MultiDict", /* tp_name */
sizeof(MultiDictObject), /* tp_basicsize */
.tp_dealloc = (destructor)multidict_tp_dealloc,
.tp_repr = (reprfunc)multidict_repr,
.tp_as_sequence = &multidict_sequence,
.tp_as_mapping = &multidict_mapping,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
.tp_doc = MultDict_doc,
.tp_traverse = (traverseproc)multidict_tp_traverse,
.tp_clear = (inquiry)multidict_tp_clear,
.tp_richcompare = (richcmpfunc)multidict_tp_richcompare,
.tp_weaklistoffset = offsetof(MultiDictObject, weaklist),
.tp_iter = (getiterfunc)multidict_tp_iter,
.tp_methods = multidict_methods,
.tp_init = (initproc)multidict_tp_init,
.tp_alloc = PyType_GenericAlloc,
.tp_new = PyType_GenericNew,
.tp_free = PyObject_GC_Del,
};
/******************** CIMultiDict ********************/
static inline int
cimultidict_tp_init(MultiDictObject *self, PyObject *args, PyObject *kwds)
{
if (ci_pair_list_init(&self->pairs) < 0) {
return -1;
}
if (_multidict_extend(self, args, kwds, "CIMultiDict", 1) < 0) {
return -1;
}
return 0;
}
static inline PyObject *
cimultidict_copy(MultiDictObject *self)
{
return _multidict_copy(self, &cimultidict_type);
}
PyDoc_STRVAR(cimultidict_copy_doc,
"Return a copy of itself.");
static PyMethodDef cimultidict_methods[] = {
{
"copy",
(PyCFunction)cimultidict_copy,
METH_NOARGS,
cimultidict_copy_doc
},
{
NULL,
NULL
} /* sentinel */
};
PyDoc_STRVAR(CIMultDict_doc,
"Dictionary with the support for duplicate case-insensitive keys.");
static PyTypeObject cimultidict_type = {
PyVarObject_HEAD_INIT(NULL, 0)
"multidict._multidict.CIMultiDict", /* tp_name */
sizeof(MultiDictObject), /* tp_basicsize */
.tp_dealloc = (destructor)multidict_tp_dealloc,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
.tp_doc = CIMultDict_doc,
.tp_traverse = (traverseproc)multidict_tp_traverse,
.tp_clear = (inquiry)multidict_tp_clear,
.tp_weaklistoffset = offsetof(MultiDictObject, weaklist),
.tp_methods = cimultidict_methods,
.tp_base = &multidict_type,
.tp_init = (initproc)cimultidict_tp_init,
.tp_alloc = PyType_GenericAlloc,
.tp_new = PyType_GenericNew,
.tp_free = PyObject_GC_Del,
};
/******************** MultiDictProxy ********************/
static inline int
multidict_proxy_tp_init(MultiDictProxyObject *self, PyObject *args,
PyObject *kwds)
{
PyObject *arg = NULL;
MultiDictObject *md = NULL;
if (!PyArg_UnpackTuple(args, "multidict._multidict.MultiDictProxy",
0, 1, &arg))
{
return -1;
}
if (arg == NULL) {
PyErr_Format(
PyExc_TypeError,
"__init__() missing 1 required positional argument: 'arg'"
);
return -1;
}
if (!MultiDictProxy_CheckExact(arg) &&
!CIMultiDict_CheckExact(arg) &&
!MultiDict_CheckExact(arg))
{
PyErr_Format(
PyExc_TypeError,
"ctor requires MultiDict or MultiDictProxy instance, "
"not <classs '%s'>",
Py_TYPE(arg)->tp_name
);
return -1;
}
md = (MultiDictObject*)arg;
if (MultiDictProxy_CheckExact(arg)) {
md = ((MultiDictProxyObject*)arg)->md;
}
Py_INCREF(md);
self->md = md;
return 0;
}
static inline PyObject *
multidict_proxy_getall(MultiDictProxyObject *self, PyObject *args,
PyObject *kwds)
{
return multidict_getall(self->md, args, kwds);
}
static inline PyObject *
multidict_proxy_getone(MultiDictProxyObject *self, PyObject *args,
PyObject *kwds)
{
return multidict_getone(self->md, args, kwds);
}
static inline PyObject *
multidict_proxy_get(MultiDictProxyObject *self, PyObject *args,
PyObject *kwds)
{
return multidict_get(self->md, args, kwds);
}
static inline PyObject *
multidict_proxy_keys(MultiDictProxyObject *self)
{
return multidict_keys(self->md);
}
static inline PyObject *
multidict_proxy_items(MultiDictProxyObject *self)
{
return multidict_items(self->md);
}
static inline PyObject *
multidict_proxy_values(MultiDictProxyObject *self)
{
return multidict_values(self->md);
}
static inline PyObject *
multidict_proxy_copy(MultiDictProxyObject *self)
{
return _multidict_proxy_copy(self, &multidict_type);
}
static inline PyObject *
multidict_proxy_reduce(MultiDictProxyObject *self)
{
PyErr_Format(
PyExc_TypeError,
"can't pickle %s objects", Py_TYPE(self)->tp_name
);
return NULL;
}
static inline Py_ssize_t
multidict_proxy_mp_len(MultiDictProxyObject *self)
{
return multidict_mp_len(self->md);
}
static inline PyObject *
multidict_proxy_mp_subscript(MultiDictProxyObject *self, PyObject *key)
{
return multidict_mp_subscript(self->md, key);
}
static inline int
multidict_proxy_sq_contains(MultiDictProxyObject *self, PyObject *key)
{
return multidict_sq_contains(self->md, key);
}
static inline PyObject *
multidict_proxy_tp_iter(MultiDictProxyObject *self)
{
return multidict_tp_iter(self->md);
}
static inline PyObject *
multidict_proxy_tp_richcompare(MultiDictProxyObject *self, PyObject *other,
int op)
{
return multidict_tp_richcompare((PyObject*)self->md, other, op);
}
static inline void
multidict_proxy_tp_dealloc(MultiDictProxyObject *self)
{
PyObject_GC_UnTrack(self);
if (self->weaklist != NULL) {
PyObject_ClearWeakRefs((PyObject *)self);
};
Py_XDECREF(self->md);
Py_TYPE(self)->tp_free((PyObject *)self);
}
static inline int
multidict_proxy_tp_traverse(MultiDictProxyObject *self, visitproc visit,
void *arg)
{
Py_VISIT(self->md);
return 0;
}
static inline int
multidict_proxy_tp_clear(MultiDictProxyObject *self)
{
Py_CLEAR(self->md);
return 0;
}
static PySequenceMethods multidict_proxy_sequence = {
.sq_contains = (objobjproc)multidict_proxy_sq_contains,
};
static PyMappingMethods multidict_proxy_mapping = {
.mp_length = (lenfunc)multidict_proxy_mp_len,
.mp_subscript = (binaryfunc)multidict_proxy_mp_subscript,
};
static PyMethodDef multidict_proxy_methods[] = {
{
"getall",
(PyCFunction)multidict_proxy_getall,
METH_VARARGS | METH_KEYWORDS,
multidict_getall_doc
},
{
"getone",
(PyCFunction)multidict_proxy_getone,
METH_VARARGS | METH_KEYWORDS,
multidict_getone_doc
},
{
"get",
(PyCFunction)multidict_proxy_get,
METH_VARARGS | METH_KEYWORDS,
multidict_get_doc
},
{
"keys",
(PyCFunction)multidict_proxy_keys,
METH_NOARGS,
multidict_keys_doc
},
{
"items",
(PyCFunction)multidict_proxy_items,
METH_NOARGS,
multidict_items_doc
},
{
"values",
(PyCFunction)multidict_proxy_values,
METH_NOARGS,
multidict_values_doc
},
{
"copy",
(PyCFunction)multidict_proxy_copy,
METH_NOARGS,
multidict_copy_doc
},
{
"__reduce__",
(PyCFunction)multidict_proxy_reduce,
METH_NOARGS,
NULL
},
{
"__class_getitem__",
(PyCFunction)multidict_class_getitem,
METH_O | METH_CLASS,
NULL
},
{
NULL,
NULL
} /* sentinel */
};
PyDoc_STRVAR(MultDictProxy_doc,
"Read-only proxy for MultiDict instance.");
static PyTypeObject multidict_proxy_type = {
PyVarObject_HEAD_INIT(NULL, 0)
"multidict._multidict.MultiDictProxy", /* tp_name */
sizeof(MultiDictProxyObject), /* tp_basicsize */
.tp_dealloc = (destructor)multidict_proxy_tp_dealloc,
.tp_repr = (reprfunc)multidict_repr,
.tp_as_sequence = &multidict_proxy_sequence,
.tp_as_mapping = &multidict_proxy_mapping,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
.tp_doc = MultDictProxy_doc,
.tp_traverse = (traverseproc)multidict_proxy_tp_traverse,
.tp_clear = (inquiry)multidict_proxy_tp_clear,
.tp_richcompare = (richcmpfunc)multidict_proxy_tp_richcompare,
.tp_weaklistoffset = offsetof(MultiDictProxyObject, weaklist),
.tp_iter = (getiterfunc)multidict_proxy_tp_iter,
.tp_methods = multidict_proxy_methods,
.tp_init = (initproc)multidict_proxy_tp_init,
.tp_alloc = PyType_GenericAlloc,
.tp_new = PyType_GenericNew,
.tp_free = PyObject_GC_Del,
};
/******************** CIMultiDictProxy ********************/
static inline int
cimultidict_proxy_tp_init(MultiDictProxyObject *self, PyObject *args,
PyObject *kwds)
{
PyObject *arg = NULL;
MultiDictObject *md = NULL;
if (!PyArg_UnpackTuple(args, "multidict._multidict.CIMultiDictProxy",
1, 1, &arg))
{
return -1;
}
if (arg == NULL) {
PyErr_Format(
PyExc_TypeError,
"__init__() missing 1 required positional argument: 'arg'"
);
return -1;
}
if (!CIMultiDictProxy_CheckExact(arg) && !CIMultiDict_CheckExact(arg)) {
PyErr_Format(
PyExc_TypeError,
"ctor requires CIMultiDict or CIMultiDictProxy instance, "
"not <class '%s'>",
Py_TYPE(arg)->tp_name
);
return -1;
}
md = (MultiDictObject*)arg;
if (CIMultiDictProxy_CheckExact(arg)) {
md = ((MultiDictProxyObject*)arg)->md;
}
Py_INCREF(md);
self->md = md;
return 0;
}
static inline PyObject *
cimultidict_proxy_copy(MultiDictProxyObject *self)
{
return _multidict_proxy_copy(self, &cimultidict_type);
}
PyDoc_STRVAR(CIMultDictProxy_doc,
"Read-only proxy for CIMultiDict instance.");
PyDoc_STRVAR(cimultidict_proxy_copy_doc,
"Return copy of itself");
static PyMethodDef cimultidict_proxy_methods[] = {
{
"copy",
(PyCFunction)cimultidict_proxy_copy,
METH_NOARGS,
cimultidict_proxy_copy_doc
},
{
NULL,
NULL
} /* sentinel */
};
static PyTypeObject cimultidict_proxy_type = {
PyVarObject_HEAD_INIT(NULL, 0)
"multidict._multidict.CIMultiDictProxy", /* tp_name */
sizeof(MultiDictProxyObject), /* tp_basicsize */
.tp_dealloc = (destructor)multidict_proxy_tp_dealloc,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
.tp_doc = CIMultDictProxy_doc,
.tp_traverse = (traverseproc)multidict_proxy_tp_traverse,
.tp_clear = (inquiry)multidict_proxy_tp_clear,
.tp_richcompare = (richcmpfunc)multidict_proxy_tp_richcompare,
.tp_weaklistoffset = offsetof(MultiDictProxyObject, weaklist),
.tp_methods = cimultidict_proxy_methods,
.tp_base = &multidict_proxy_type,
.tp_init = (initproc)cimultidict_proxy_tp_init,
.tp_alloc = PyType_GenericAlloc,
.tp_new = PyType_GenericNew,
.tp_free = PyObject_GC_Del,
};
/******************** Other functions ********************/
static inline PyObject *
getversion(PyObject *self, PyObject *md)
{
pair_list_t *pairs = NULL;
if (MultiDict_CheckExact(md) || CIMultiDict_CheckExact(md)) {
pairs = &((MultiDictObject*)md)->pairs;
} else if (MultiDictProxy_CheckExact(md) || CIMultiDictProxy_CheckExact(md)) {
pairs = &((MultiDictProxyObject*)md)->md->pairs;
} else {
PyErr_Format(PyExc_TypeError, "unexpected type");
return NULL;
}
return PyLong_FromUnsignedLong(pair_list_version(pairs));
}
/******************** Module ********************/
static inline void
module_free(void *m)
{
Py_CLEAR(collections_abc_mapping);
Py_CLEAR(collections_abc_mut_mapping);
Py_CLEAR(collections_abc_mut_multi_mapping);
}
static PyMethodDef multidict_module_methods[] = {
{
"getversion",
(PyCFunction)getversion,
METH_O
},
{
NULL,
NULL
} /* sentinel */
};
static PyModuleDef multidict_module = {
PyModuleDef_HEAD_INIT, /* m_base */
"_multidict", /* m_name */
.m_size = -1,
.m_methods = multidict_module_methods,
.m_free = (freefunc)module_free,
};
PyMODINIT_FUNC
PyInit__multidict()
{
PyObject *module = NULL,
*reg_func_call_result = NULL;
#define WITH_MOD(NAME) \
Py_CLEAR(module); \
module = PyImport_ImportModule(NAME); \
if (module == NULL) { \
goto fail; \
}
#define GET_MOD_ATTR(VAR, NAME) \
VAR = PyObject_GetAttrString(module, NAME); \
if (VAR == NULL) { \
goto fail; \
}
if (multidict_views_init() < 0) {
goto fail;
}
if (multidict_iter_init() < 0) {
goto fail;
}
if (istr_init() < 0) {
goto fail;
}
if (PyType_Ready(&multidict_type) < 0 ||
PyType_Ready(&cimultidict_type) < 0 ||
PyType_Ready(&multidict_proxy_type) < 0 ||
PyType_Ready(&cimultidict_proxy_type) < 0)
{
goto fail;
}
WITH_MOD("collections.abc");
GET_MOD_ATTR(collections_abc_mapping, "Mapping");
WITH_MOD("multidict._abc");
GET_MOD_ATTR(collections_abc_mut_mapping, "MultiMapping");
WITH_MOD("multidict._abc");
GET_MOD_ATTR(collections_abc_mut_multi_mapping, "MutableMultiMapping");
WITH_MOD("multidict._multidict_base");
GET_MOD_ATTR(repr_func, "_mdrepr");
/* Register in _abc mappings (CI)MultiDict and (CI)MultiDictProxy */
reg_func_call_result = PyObject_CallMethod(
collections_abc_mut_mapping,
"register", "O",
(PyObject*)&multidict_proxy_type
);
if (reg_func_call_result == NULL) {
goto fail;
}
Py_DECREF(reg_func_call_result);
reg_func_call_result = PyObject_CallMethod(
collections_abc_mut_mapping,
"register", "O",
(PyObject*)&cimultidict_proxy_type
);
if (reg_func_call_result == NULL) {
goto fail;
}
Py_DECREF(reg_func_call_result);
reg_func_call_result = PyObject_CallMethod(
collections_abc_mut_multi_mapping,
"register", "O",
(PyObject*)&multidict_type
);
if (reg_func_call_result == NULL) {
goto fail;
}
Py_DECREF(reg_func_call_result);
reg_func_call_result = PyObject_CallMethod(
collections_abc_mut_multi_mapping,
"register", "O",
(PyObject*)&cimultidict_type
);
if (reg_func_call_result == NULL) {
goto fail;
}
Py_DECREF(reg_func_call_result);
/* Instantiate this module */
module = PyModule_Create(&multidict_module);
Py_INCREF(&istr_type);
if (PyModule_AddObject(
module, "istr", (PyObject*)&istr_type) < 0)
{
goto fail;
}
Py_INCREF(&multidict_type);
if (PyModule_AddObject(
module, "MultiDict", (PyObject*)&multidict_type) < 0)
{
goto fail;
}
Py_INCREF(&cimultidict_type);
if (PyModule_AddObject(
module, "CIMultiDict", (PyObject*)&cimultidict_type) < 0)
{
goto fail;
}
Py_INCREF(&multidict_proxy_type);
if (PyModule_AddObject(
module, "MultiDictProxy", (PyObject*)&multidict_proxy_type) < 0)
{
goto fail;
}
Py_INCREF(&cimultidict_proxy_type);
if (PyModule_AddObject(
module, "CIMultiDictProxy", (PyObject*)&cimultidict_proxy_type) < 0)
{
goto fail;
}
return module;
fail:
Py_XDECREF(collections_abc_mapping);
Py_XDECREF(collections_abc_mut_mapping);
Py_XDECREF(collections_abc_mut_multi_mapping);
return NULL;
#undef WITH_MOD
#undef GET_MOD_ATTR
}