187 lines
7.8 KiB
Cython
187 lines
7.8 KiB
Cython
from .object cimport PyObject
|
||
from .pyport cimport uint64_t
|
||
|
||
cdef extern from "Python.h":
|
||
# On Python 2, PyDict_GetItemWithError is called _PyDict_GetItemWithError
|
||
"""
|
||
#if PY_MAJOR_VERSION <= 2
|
||
#define PyDict_GetItemWithError _PyDict_GetItemWithError
|
||
#endif
|
||
"""
|
||
|
||
############################################################################
|
||
# 7.4.1 Dictionary Objects
|
||
############################################################################
|
||
|
||
# PyDictObject
|
||
#
|
||
# This subtype of PyObject represents a Python dictionary object
|
||
# (i.e. the 'dict' type).
|
||
|
||
# PyTypeObject PyDict_Type
|
||
#
|
||
# This instance of PyTypeObject represents the Python dictionary
|
||
# type. This is exposed to Python programs as dict and
|
||
# types.DictType.
|
||
|
||
bint PyDict_Check(object p)
|
||
# Return true if p is a dict object or an instance of a subtype of
|
||
# the dict type.
|
||
|
||
bint PyDict_CheckExact(object p)
|
||
# Return true if p is a dict object, but not an instance of a
|
||
# subtype of the dict type.
|
||
|
||
dict PyDict_New()
|
||
# Return value: New reference.
|
||
# Return a new empty dictionary, or NULL on failure.
|
||
|
||
object PyDictProxy_New(object dict)
|
||
# Return value: New reference.
|
||
# Return a proxy object for a mapping which enforces read-only
|
||
# behavior. This is normally used to create a proxy to prevent
|
||
# modification of the dictionary for non-dynamic class types.
|
||
|
||
void PyDict_Clear(object p)
|
||
# Empty an existing dictionary of all key-value pairs.
|
||
|
||
int PyDict_Contains(object p, object key) except -1
|
||
# Determine if dictionary p contains key. If an item in p is
|
||
# matches key, return 1, otherwise return 0. On error, return
|
||
# -1. This is equivalent to the Python expression "key in p".
|
||
|
||
dict PyDict_Copy(object p)
|
||
# Return value: New reference.
|
||
# Return a new dictionary that contains the same key-value pairs as p.
|
||
|
||
int PyDict_SetItem(object p, object key, object val) except -1
|
||
# Insert value into the dictionary p with a key of key. key must
|
||
# be hashable; if it isn't, TypeError will be raised. Return 0 on
|
||
# success or -1 on failure.
|
||
|
||
int PyDict_SetItemString(object p, const char *key, object val) except -1
|
||
# Insert value into the dictionary p using key as a key. key
|
||
# should be a char*. The key object is created using
|
||
# PyString_FromString(key). Return 0 on success or -1 on failure.
|
||
|
||
int PyDict_DelItem(object p, object key) except -1
|
||
# Remove the entry in dictionary p with key key. key must be
|
||
# hashable; if it isn't, TypeError is raised. Return 0 on success
|
||
# or -1 on failure.
|
||
|
||
int PyDict_DelItemString(object p, const char *key) except -1
|
||
# Remove the entry in dictionary p which has a key specified by
|
||
# the string key. Return 0 on success or -1 on failure.
|
||
|
||
PyObject* PyDict_GetItem(object p, object key)
|
||
# Return value: Borrowed reference.
|
||
# Return the object from dictionary p which has a key key. Return
|
||
# NULL if the key key is not present, but without setting an
|
||
# exception.
|
||
|
||
PyObject* PyDict_GetItemWithError(object p, object key) except? NULL
|
||
# Return value: Borrowed reference.
|
||
# Variant of PyDict_GetItem() that does not suppress exceptions. Return
|
||
# NULL with an exception set if an exception occurred. Return NULL
|
||
# without an exception set if the key wasn’t present.
|
||
|
||
PyObject* PyDict_GetItemString(object p, const char *key)
|
||
# Return value: Borrowed reference.
|
||
# This is the same as PyDict_GetItem(), but key is specified as a
|
||
# char*, rather than a PyObject*.
|
||
|
||
PyObject* PyDict_SetDefault(object p, object key, object default) except NULL
|
||
# Return value: Borrowed reference.
|
||
# This is the same as the Python-level dict.setdefault(). If present, it
|
||
# returns the value corresponding to key from the dictionary p. If the key
|
||
# is not in the dict, it is inserted with value defaultobj and defaultobj
|
||
# is returned. This function evaluates the hash function of key only once,
|
||
# instead of evaluating it independently for the lookup and the insertion.
|
||
|
||
list PyDict_Items(object p)
|
||
# Return value: New reference.
|
||
# Return a PyListObject containing all the items from the
|
||
# dictionary, as in the dictionary method items() (see the Python
|
||
# Library Reference).
|
||
|
||
list PyDict_Keys(object p)
|
||
# Return value: New reference.
|
||
# Return a PyListObject containing all the keys from the
|
||
# dictionary, as in the dictionary method keys() (see the Python
|
||
# Library Reference).
|
||
|
||
list PyDict_Values(object p)
|
||
# Return value: New reference.
|
||
# Return a PyListObject containing all the values from the
|
||
# dictionary p, as in the dictionary method values() (see the
|
||
# Python Library Reference).
|
||
|
||
Py_ssize_t PyDict_Size(object p) except -1
|
||
# Return the number of items in the dictionary. This is equivalent
|
||
# to "len(p)" on a dictionary.
|
||
|
||
int PyDict_Next(object p, Py_ssize_t *ppos, PyObject* *pkey, PyObject* *pvalue)
|
||
# Iterate over all key-value pairs in the dictionary p. The int
|
||
# referred to by ppos must be initialized to 0 prior to the first
|
||
# call to this function to start the iteration; the function
|
||
# returns true for each pair in the dictionary, and false once all
|
||
# pairs have been reported. The parameters pkey and pvalue should
|
||
# either point to PyObject* variables that will be filled in with
|
||
# each key and value, respectively, or may be NULL. Any references
|
||
# returned through them are borrowed. ppos should not be altered
|
||
# during iteration. Its value represents offsets within the
|
||
# internal dictionary structure, and since the structure is
|
||
# sparse, the offsets are not consecutive.
|
||
# For example:
|
||
#
|
||
#object key, *value;
|
||
#int pos = 0;
|
||
#
|
||
#while (PyDict_Next(self->dict, &pos, &key, &value)) {
|
||
# /* do something interesting with the values... */
|
||
# ...
|
||
#}
|
||
# The dictionary p should not be mutated during iteration. It is
|
||
# safe (since Python 2.1) to modify the values of the keys as you
|
||
# iterate over the dictionary, but only so long as the set of keys
|
||
# does not change. For example:
|
||
# object key, *value;
|
||
# int pos = 0;
|
||
# while (PyDict_Next(self->dict, &pos, &key, &value)) {
|
||
# int i = PyInt_AS_LONG(value) + 1;
|
||
# object o = PyInt_FromLong(i);
|
||
# if (o == NULL)
|
||
# return -1;
|
||
# if (PyDict_SetItem(self->dict, key, o) < 0) {
|
||
# Py_DECREF(o);
|
||
# return -1;
|
||
# }
|
||
# Py_DECREF(o);
|
||
# }
|
||
|
||
int PyDict_Merge(object a, object b, int override) except -1
|
||
# Iterate over mapping object b adding key-value pairs to
|
||
# dictionary a. b may be a dictionary, or any object supporting
|
||
# PyMapping_Keys() and PyObject_GetItem(). If override is true,
|
||
# existing pairs in a will be replaced if a matching key is found
|
||
# in b, otherwise pairs will only be added if there is not a
|
||
# matching key in a. Return 0 on success or -1 if an exception was
|
||
# raised.
|
||
|
||
int PyDict_Update(object a, object b) except -1
|
||
# This is the same as PyDict_Merge(a, b, 1) in C, or a.update(b)
|
||
# in Python. Return 0 on success or -1 if an exception was raised.
|
||
|
||
int PyDict_MergeFromSeq2(object a, object seq2, int override) except -1
|
||
# Update or merge into dictionary a, from the key-value pairs in
|
||
# seq2. seq2 must be an iterable object producing iterable objects
|
||
# of length 2, viewed as key-value pairs. In case of duplicate
|
||
# keys, the last wins if override is true, else the first
|
||
# wins. Return 0 on success or -1 if an exception was
|
||
# raised. Equivalent Python (except for the return value):
|
||
#
|
||
#def PyDict_MergeFromSeq2(a, seq2, override):
|
||
# for key, value in seq2:
|
||
# if override or key not in a:
|
||
# a[key] = value
|