static PyObject *parse_qs(PyObject *self, PyObject *args, PyObject *kw)
{
PyObject *pairs, *dict;
int i, n, len, lsize;
char *qs;
int keep_blank_values = 0;
int strict_parsing = 0; /* XXX not implemented */
char *keywords[] = { "qs", "keep_blank_values", "strict_parsing", 0 };
if (! PyArg_ParseTupleAndKeywords(args, kw, "s|ii", keywords, &qs, &keep_blank_values,
&strict_parsing))
return NULL; /* error */
/* split query string by '&' and ';' into a list of pairs */
/* PYTHON 2.5: 'PyList_New' uses Py_ssize_t for input parameters */
pairs = PyList_New(0);
if (pairs == NULL)
return NULL;
i = 0;
len = strlen(qs);
while (i < len) {
PyObject *pair;
char *cpair;
int j = 0;
/* PYTHON 2.5: 'PyString_FromStringAndSize' uses Py_ssize_t for input parameters */
pair = PyString_FromStringAndSize(NULL, len);
if (pair == NULL)
return NULL;
/* split by '&' or ';' */
cpair = PyString_AS_STRING(pair);
while ((qs[i] != '&') && (qs[i] != ';') && (i < len)) {
/* replace '+' with ' ' */
cpair[j] = (qs[i] == '+') ? ' ' : qs[i];
i++;
j++;
}
if (j) {
/* PYTHON 2.5: '_PyString_Resize' uses Py_ssize_t for input parameters */
_PyString_Resize(&pair, j);
if (pair)
PyList_Append(pairs, pair);
}
Py_XDECREF(pair);
i++;
}
/*
* now we have a list of "abc=def" string (pairs), let's split
* them all by '=' and put them in a dictionary.
*/
dict = PyDict_New();
if (dict == NULL)
return NULL;
/* PYTHON 2.5: 'PyList_Size' uses Py_ssize_t for input parameters */
lsize = PyList_Size(pairs);
n = 0;
while (n < lsize) {
PyObject *pair, *key, *val;
char *cpair, *ckey, *cval;
int k, v;
pair = PyList_GET_ITEM(pairs, n);
cpair = PyString_AS_STRING(pair);
len = strlen(cpair);
/* PYTHON 2.5: 'PyString_FromStringAndSize' uses Py_ssize_t for input parameters */
key = PyString_FromStringAndSize(NULL, len);
if (key == NULL)
return NULL;
/* PYTHON 2.5: 'PyString_FromStringAndSize' uses Py_ssize_t for input parameters */
val = PyString_FromStringAndSize(NULL, len);
if (val == NULL)
return NULL;
ckey = PyString_AS_STRING(key);
cval = PyString_AS_STRING(val);
i = 0;
k = 0;
v = 0;
while (i < len) {
if (cpair[i] != '=') {
ckey[k] = cpair[i];
k++;
i++;
}
else {
i++; /* skip '=' */
while (i < len) {
cval[v] = cpair[i];
v++;
i++;
}
}
}
ckey[k] = '\0';
cval[v] = '\0';
if (keep_blank_values || (v > 0)) {
ap_unescape_url(ckey);
ap_unescape_url(cval);
/* PYTHON 2.5: '_PyString_Resize' uses Py_ssize_t for input parameters */
_PyString_Resize(&key, strlen(ckey));
/* PYTHON 2.5: '_PyString_Resize' uses Py_ssize_t for input parameters */
_PyString_Resize(&val, strlen(cval));
if (key && val) {
ckey = PyString_AS_STRING(key);
cval = PyString_AS_STRING(val);
if (PyMapping_HasKeyString(dict, ckey)) {
PyObject *list;
list = PyDict_GetItem(dict, key);
PyList_Append(list, val);
/* PyDict_GetItem is a borrowed ref, no decref */
}
else {
PyObject *list;
list = Py_BuildValue("[O]", val);
PyDict_SetItem(dict, key, list);
Py_DECREF(list);
}
}
}
Py_XDECREF(key);
Py_XDECREF(val);
n++;
}
Py_DECREF(pairs);
return dict;
}
static PyObject *Scopeable__getattr__(PyObject *self, PyObject *args) {
char *attrname;
PyObject *val=NULL, *inDict, *masher;
if (!PyArg_ParseTuple(args, "Os", &self, &attrname)) {
return NULL;
}
inDict=((PyInstanceObject *)self)->in_dict;
masher=PyMapping_GetItemString(inDict, MASH);
if (PyObject_IsTrue(masher)
&& PyMapping_HasKeyString(masher, attrname)) {
val=PyMapping_GetItemString(masher, attrname);
}
else {
PyObject *dictList;
int len, i;
dictList=PyMapping_GetItemString(inDict, DICTLIST);
len=PyList_Size(dictList);
for (i=0;i<len;i++) {
PyObject *d=PyList_GetItem(dictList, i);
if (PyMapping_HasKeyString(d, attrname)) {
val=PyMapping_GetItemString(d, attrname);
break;
}
}
Py_DECREF(dictList);
}
if (val==NULL) {
/* check for special attribute "__all__" */
char *allattr="__all__";
if (!strncmp(attrname, allattr, strlen(allattr))) {
PyObject *mashed, *keys, *newargs;
newargs=PyTuple_New(1);
PyTuple_SetItem(newargs, 0, self);
REFCNT("self", self);
mashed=Scopeable_mash(NULL, newargs);
keys=PyMapping_Keys(mashed);
REFCNT("keys", keys);
Py_DECREF(mashed);
val=keys;
} else {
PyErr_SetString(PyExc_AttributeError, attrname);
}
}
Py_DECREF(masher);
return val;
}
static gboolean
py_dict_get_int (PyObject *py_dict,
const char *key,
int *val)
{
PyObject *py_val;
long x;
g_return_val_if_fail (py_dict != NULL, FALSE);
g_return_val_if_fail (key && *key, FALSE);
g_return_val_if_fail (val != NULL, FALSE);
if (! PyMapping_HasKeyString (py_dict, (char *) key))
return FALSE;
py_val = PyMapping_GetItemString (py_dict, (char *) key);
if (py_val == NULL || py_val == Py_None)
return FALSE;
if (! PyInt_Check (py_val)) {
Py_DECREF (py_val);
g_warning ("'%s' exists but is not an integer!", key);
return FALSE;
}
x = PyInt_AsLong (py_val);
*val = x;
Py_DECREF (py_val);
return TRUE;
}
KValueRef KPythonDict::Get(const char *name)
{
PyLockGIL lock;
if (PyMapping_HasKeyString(this->object, (char*) name) == 0)
return Value::Undefined;
PyObject* item = PyMapping_GetItemString(this->object, (char*) name);
if (item == 0 && PyErr_Occurred())
{
THROW_PYTHON_EXCEPTION;
}
try
{
KValueRef value = PythonUtils::ToKrollValue(item);
Py_DECREF(item);
return value;
}
catch (...)
{
Py_DECREF(item);
throw;
}
}
PyObject * AerospikeGeospatial_DoDumps(PyObject *geo_data, as_error *err)
{
PyObject *initresult = NULL;
PyObject* sysmodules = PyImport_GetModuleDict();
PyObject* json_module = NULL;
if (PyMapping_HasKeyString(sysmodules, "json")) {
json_module = PyMapping_GetItemString(sysmodules, "json");
} else {
json_module = PyImport_ImportModule("json");
}
if (!json_module) {
/* insert error handling here! and exit this function */
as_error_update(err, AEROSPIKE_ERR_CLIENT, "Unable to load json module");
} else {
PyObject *py_funcname = PyString_FromString("dumps");
Py_INCREF(json_module);
initresult = PyObject_CallMethodObjArgs(json_module, py_funcname, geo_data, NULL);
Py_DECREF(json_module);
Py_DECREF(py_funcname);
}
return initresult;
}
static gboolean
py_dict_get_string (PyObject *py_dict,
const char *key,
char **val)
{
PyObject *py_val;
char *x;
g_return_val_if_fail (py_dict != NULL, FALSE);
g_return_val_if_fail (key && *key, FALSE);
g_return_val_if_fail (val != NULL, FALSE);
if (! PyMapping_HasKeyString (py_dict, (char *) key))
return FALSE;
py_val = PyMapping_GetItemString (py_dict, (char *) key);
if (py_val == NULL || py_val == Py_None)
return FALSE;
if (! PyString_Check (py_val)) {
Py_DECREF (py_val);
g_warning ("'%s' exists but is not a string!", key);
return FALSE;
}
x = PyString_AsString (py_val);
*val = g_strdup (x);
Py_DECREF (py_val);
return TRUE;
}
static gboolean
py_dict_get_double (PyObject *py_dict,
const char *key,
double *val)
{
PyObject *py_val;
double x;
g_return_val_if_fail (py_dict != NULL, FALSE);
g_return_val_if_fail (key && *key, FALSE);
g_return_val_if_fail (val != NULL, FALSE);
if (! PyMapping_HasKeyString (py_dict, (char *) key))
return FALSE;
py_val = PyMapping_GetItemString (py_dict, (char *) key);
if (py_val == NULL || py_val == Py_None)
return FALSE;
if (! PyFloat_Check (py_val)) {
Py_DECREF (py_val);
g_warning ("'%s' exists but is not a float!", key);
return FALSE;
}
x = PyFloat_AsDouble (py_val);
*val = x;
Py_DECREF (py_val);
return TRUE;
}
int
ColMap_get(ColMap* self, char *colname)
{
PyObject* val = NULL;
if(!PyMapping_HasKeyString(self->map, colname)){
return -1;
}
val = PyMapping_GetItemString(self->map, colname);
if(val==NULL)
return -1;
return (int)PyInt_AsLong(val);
}
/* Return:
* 0 - Item not in dictionary
* -1 - Invalid data type for key in dictionary
* 1 - Success
*/
int
get_pydict_float_value(PyObject* pdict, char* key, double* pnum)
{
int cc = 1;
PyObject* dv;
if (!PyMapping_HasKeyString(pdict, key))
return 0;
dv = PyMapping_GetItemString(pdict, key);
if (!dv)
return 0; /* shouldn't happen */
cc = get_python_float_value(dv, pnum);
Py_DECREF(dv);
return cc;
}
/* Return:
* 0 - Item not in dictionary
* -1 - Invalid data type for key in dictionary
* 1 - Success
*/
int
get_pydict_int_value(PyObject* pdict, char* key, int* pint)
{
PyObject* dv;
int cc = 1;
if (!PyMapping_HasKeyString(pdict, key))
return 0;
dv = PyMapping_GetItemString(pdict, key);
if (!dv)
return 0; /* shouldn't happen */
cc = get_python_int_value(dv, pint);
Py_DECREF(dv);
return cc;
}
/* Get a string value from a python dictionary
* Return:
* 0 - Item not in dictionary
* -1 - Invalid data type for key in dictionary
* 1 - Success
*/
int
get_pydict_string_value(PyObject* pdict, char* key, char* bfr, int len)
{
PyObject* dv;
int cc = 1;
if (!PyMapping_HasKeyString(pdict, key))
return 0; /* Key not in dictionary */
dv = PyMapping_GetItemString(pdict, key);
if (!dv)
return 0; /* shouldn't happen */
cc = get_python_string_value(dv, bfr, len);
Py_DECREF(dv);
return cc;
}
/* Return:
* 0 - Item not in dictionary
* -1 - Invalid data type for key in dictionary
* 1 - Success
*/
int
get_pydict_callable_value(PyObject* pdict, char* key, PyObject** pobj)
{
PyObject* dv;
*pobj = NULL;
if (!PyMapping_HasKeyString(pdict, key))
return 0;
dv = PyMapping_GetItemString(pdict, key);
if (!dv)
return 0; /* shouldn't happen */
if (!PyCallable_Check(dv))
{
Py_DECREF(dv);
return -1;
}
*pobj = dv;
return 1;
}
static long _adbobj_have_possible_break(AdbObject *self, PyFrameObject *frame)
{
PyObject *filename;
PyObject *tuple;
int haveFileBP;
#ifdef DEBUG_PRINT
fprintf(stderr, "_adbobj_have_possible_break...\n");
#endif
if (PyDict_Size(__adb_breakpointList) < 1) {
// no breakpoints, no possible break
return 0;
}
if (PyMapping_HasKey(__adb_canonicCache, frame->f_code->co_filename)==0) {
// filename has not been mapped, so force a call to effective
return 1;
}
filename = PyDict_GetItem(__adb_canonicCache, frame->f_code->co_filename);
if (PyMapping_HasKey(__adb_breakpointFileList, filename)==1) {
// we have breakpoints for this file, do we have one for this line
// or a file global breakpoint?
tuple = Py_BuildValue("(Oi)", filename, frame->f_lineno);
haveFileBP = PyDict_GetItem(__adb_breakpointList, tuple) != NULL;
Py_DECREF(tuple);
if (haveFileBP) {
return 1;
}
// check for file global breakpoints
tuple = Py_BuildValue("(Oi)", filename, 0);
haveFileBP = PyDict_GetItem(__adb_breakpointList, tuple) != NULL;
Py_DECREF(tuple);
if (haveFileBP) {
return 1;
}
}
// check for global breakpoints
return PyMapping_HasKeyString(__adb_breakpointFileList, "");
}
int
x11_get_visual_info(Xine_PyObject *xine, PyObject *kwargs, void **visual_return,
driver_info_common **driver_info_return)
{
x11_visual_t vis;
x11_vo_user_data *user_data;
PyObject *window, *frame_output_callback, *dest_size_callback, *display_str;
Display *display = NULL;
if (PyMapping_HasKeyString(kwargs, "window")) {
window = PyDict_GetItemString(kwargs, "window");
if (!x11window_object_decompose(window, &vis.d, (Display **)&vis.display)) {
PyErr_Format(xine_error, "Error in window parameter.");
return 0;
}
} else if (PyMapping_HasKeyString(kwargs, "wid")) {
window = PyDict_GetItemString(kwargs, "wid");
vis.d = PyLong_AsUnsignedLong(window);
display_str = PyDict_GetItemString(kwargs, "display");
if (display_str)
display = XOpenDisplay(PyString_AsString(display_str));
else
display = XOpenDisplay(NULL);
vis.display = display;
} else {
PyErr_Format(PyExc_ValueError, "Missing window or wid parameter.");
return 0;
}
frame_output_callback = PyDict_GetItemString(kwargs, "frame_output_cb");
dest_size_callback = PyDict_GetItemString(kwargs, "dest_size_cb");
if (!frame_output_callback && !dest_size_callback) {
PyErr_Format(xine_error, "Must specify frame_output_cb or dest_size_cb");
return 0;
}
user_data = malloc(sizeof(x11_vo_user_data));
user_data->frame_output_callback = frame_output_callback;
user_data->dest_size_callback = dest_size_callback;
user_data->display = vis.display;
user_data->window_pyobject = window;
user_data->common.dealloc_cb = x11_driver_dealloc;
user_data->close_display_needed = display != NULL;
Py_INCREF(window);
if (frame_output_callback)
Py_INCREF(frame_output_callback);
if (dest_size_callback)
Py_INCREF(dest_size_callback);
vis.screen = DefaultScreen(vis.display);
vis.user_data = user_data;
vis.frame_output_cb = x11_frame_output_cb;
vis.dest_size_cb = x11_dest_size_cb;
*visual_return = malloc(sizeof(vis));
memcpy(*visual_return, &vis, sizeof(vis));
*driver_info_return = (driver_info_common *)user_data;
return 1;
}
/*
* Converts an LDAP message into a Python structure.
*
* On success, returns a list of dictionaries.
* On failure, returns NULL, and sets an error.
*
* The message m is always freed, regardless of return value.
*/
PyObject *
LDAPmessage_to_python(LDAP *ld, LDAPMessage *m)
{
/* we convert an LDAP message into a python structure.
* It is always a list of dictionaries.
* We always free m.
*/
PyObject* result;
LDAPMessage* entry;
result = PyList_New(0);
if (result == NULL) {
ldap_msgfree( m );
return NULL;
}
for(entry = ldap_first_entry(ld,m);
entry != NULL;
entry = ldap_next_entry(ld,entry))
{
char *dn;
char *attr;
BerElement *ber = NULL;
PyObject* entrytuple;
PyObject* attrdict;
dn = ldap_get_dn( ld, entry );
if (dn == NULL) {
Py_DECREF(result);
ldap_msgfree( m );
return LDAPerror( ld, "ldap_get_dn" );
}
attrdict = PyDict_New();
if (attrdict == NULL) {
Py_DECREF(result);
ldap_msgfree( m );
ldap_memfree(dn);
return NULL;
}
/* Fill attrdict with lists */
for( attr = ldap_first_attribute( ld, entry, &ber );
attr != NULL;
attr = ldap_next_attribute( ld, entry, ber )
) {
PyObject* valuelist;
struct berval ** bvals =
ldap_get_values_len( ld, entry, attr );
/* Find which list to append to */
if ( PyMapping_HasKeyString( attrdict, attr ) ) {
valuelist = PyMapping_GetItemString( attrdict, attr );
} else {
valuelist = PyList_New(0);
if (valuelist != NULL && PyMapping_SetItemString(attrdict,
attr, valuelist) == -1) {
Py_DECREF(valuelist);
valuelist = NULL; /* catch error later */
}
}
if (valuelist == NULL) {
Py_DECREF(attrdict);
Py_DECREF(result);
if (ber != NULL)
ber_free(ber, 0);
ldap_msgfree( m );
ldap_memfree(attr);
ldap_memfree(dn);
return NULL;
}
if (bvals != NULL) {
Py_ssize_t i;
for (i=0; bvals[i]; i++) {
PyObject *valuestr;
valuestr = LDAPberval_to_object(bvals[i]);
if (PyList_Append( valuelist, valuestr ) == -1) {
Py_DECREF(attrdict);
Py_DECREF(result);
Py_DECREF(valuestr);
Py_DECREF(valuelist);
if (ber != NULL)
ber_free(ber, 0);
ldap_msgfree( m );
ldap_memfree(attr);
ldap_memfree(dn);
return NULL;
}
Py_DECREF(valuestr);
}
ldap_value_free_len(bvals);
}
Py_DECREF( valuelist );
ldap_memfree(attr);
}
entrytuple = Py_BuildValue("(sO)", dn, attrdict);
ldap_memfree(dn);
Py_DECREF(attrdict);
PyList_Append(result, entrytuple);
Py_DECREF(entrytuple);
if (ber != NULL)
ber_free(ber, 0);
}
for(entry = ldap_first_reference(ld,m);
entry != NULL;
entry = ldap_next_reference(ld,entry))
{
char **refs = NULL;
PyObject* entrytuple;
PyObject* reflist = PyList_New(0);
if (reflist == NULL) {
Py_DECREF(result);
ldap_msgfree( m );
return NULL;
}
if (ldap_parse_reference(ld, entry, &refs, NULL, 0) != LDAP_SUCCESS) {
Py_DECREF(result);
ldap_msgfree( m );
return LDAPerror( ld, "ldap_parse_reference" );
}
if (refs) {
Py_ssize_t i;
for (i=0; refs[i] != NULL; i++) {
PyObject *refstr = PyString_FromString(refs[i]);
PyList_Append(reflist, refstr);
Py_DECREF(refstr);
}
ber_memvfree( (void **) refs );
}
entrytuple = Py_BuildValue("(sO)", NULL, reflist);
Py_DECREF(reflist);
PyList_Append(result, entrytuple);
Py_DECREF(entrytuple);
}
ldap_msgfree( m );
return result;
}
void
token_filter_init_from_py_dict (TokenFilter *filter,
PyObject *py_dict)
{
int x;
g_return_if_fail (filter != NULL);
token_filter_init (filter);
if (py_dict == NULL)
return;
if (py_dict_get_int (py_dict, "break_preference", &x))
filter->break_preference = (FilterResults) x;
if (py_dict_get_int (py_dict, "punctuation_preference", &x))
filter->punctuation_preference = (FilterResults) x;
py_dict_get_int (py_dict, "min_syllables", &filter->min_syllables);
py_dict_get_int (py_dict, "max_syllables", &filter->max_syllables);
py_dict_get_string (py_dict, "meter_left", &filter->meter_left);
py_dict_get_string (py_dict, "meter_right", &filter->meter_right);
py_dict_get_double (py_dict, "metric_error_lower_threshold",
&filter->metric_error_lower_threshold);
py_dict_get_double (py_dict, "metric_error_upper_threshold",
&filter->metric_error_upper_threshold);
if (PyMapping_HasKeyString (py_dict, "rhymes_with")) {
PyObject *py_val = PyMapping_GetItemString (py_dict, "rhymes_with");
if (py_val != Py_None) {
if (py_token_check (py_val)) {
filter->rhymes_with = token_from_py (py_val);
} else if (PyString_Check (py_val)) {
filter->rhymes_with = token_lookup (PyString_AsString (py_val));
} else {
g_warning ("Unknown type for 'rhymes_with'");
}
}
Py_DECREF (py_val);
}
if (py_dict_get_int (py_dict, "rhyme_type_lower_threshold", &x))
filter->rhyme_type_lower_threshold = (RhymeType) x;
if (py_dict_get_int (py_dict, "rhyme_type_upper_threshold", &x))
filter->rhyme_type_upper_threshold = (RhymeType) x;
if (py_dict_get_int (py_dict, "leading_preference", &x))
filter->leading_preference = (FilterResults) x;
if (py_dict_get_int (py_dict, "trailing_preference", &x))
filter->trailing_preference = (FilterResults) x;
if (py_dict_get_int (py_dict, "has_rhyme_threshold", &x))
filter->has_rhyme_threshold = x;
py_dict_get_double (py_dict, "rhyme_p_threshold", &filter->rhyme_p_threshold);
token_filter_optimize (filter);
}
static int python_stat_helper(PyObject *pRet, SMB_STRUCT_STAT *st)
{
PyObject *pValue;
#define VFS_PY_STAT_VALUE(_name, _member, _default) \
if ((pValue = PyMapping_GetItemString(pRet, _name))) { \
st-> _member = PyInt_AsUnsignedLongLongMask(pValue); \
Py_DECREF(pValue); \
} else { \
st-> _member = _default; \
}
#define VFS_PY_STAT_TIMESPEC_VALUE(_name, _member) \
do { \
VFS_PY_STAT_VALUE(_name, _member .tv_sec, 1); \
st-> _member .tv_nsec = 0; \
} while(0);
#define VFS_PY_STAT_LONG(_name, _value) \
do { \
v = 0; \
if ((pValue = PyMapping_GetItemString(pRet, _name))) { \
_value = PyInt_AsUnsignedLongLongMask(pValue); \
Py_DECREF(pValue); \
} \
} while(0);
VFS_PY_STAT_VALUE("st_dev", st_ex_dev, 1);
VFS_PY_STAT_VALUE("st_ino", st_ex_ino, 1);
VFS_PY_STAT_VALUE("st_nlink", st_ex_nlink, 1);
VFS_PY_STAT_VALUE("st_uid", st_ex_uid, 0);
VFS_PY_STAT_VALUE("st_gid", st_ex_gid, 0);
VFS_PY_STAT_VALUE("st_rdev", st_ex_gid, 1);
VFS_PY_STAT_VALUE("st_size", st_ex_size, 0);
VFS_PY_STAT_VALUE("st_blksize", st_ex_blksize, 512);
VFS_PY_STAT_VALUE("st_mode", st_ex_mode, 0);
if (PyMapping_HasKeyString(pRet, "st_blocks")) {
VFS_PY_STAT_VALUE("st_blocks", st_ex_blocks, 0);
} else {
st->st_ex_blocks = st->st_ex_size / 512;
if (st->st_ex_size % 512) st->st_ex_blocks++;
}
VFS_PY_STAT_TIMESPEC_VALUE("st_atime", st_ex_atime);
VFS_PY_STAT_TIMESPEC_VALUE("st_mtime", st_ex_mtime);
VFS_PY_STAT_TIMESPEC_VALUE("st_ctime", st_ex_ctime);
if (PyMapping_HasKeyString(pRet, "st_btime")) {
VFS_PY_STAT_TIMESPEC_VALUE("st_btime", st_ex_btime);
} else {
st->st_ex_btime.tv_sec = st->st_ex_ctime.tv_sec;
st->st_ex_btime.tv_nsec = 0;
}
st->st_ex_flags = 0;
st->st_ex_mask = 0;
st->vfs_private = 0;
st->st_ex_calculated_birthtime = 0;
Py_DECREF(pRet);
return 0;
}
/*
*******************************************************************************************************
* Checks serializer_policy.
* Serializes Py_Object (value) into as_bytes using serialization logic
* based on serializer_policy.
*
* @param serializer_policy The serializer_policy to be used to handle
* the serialization.
* @param bytes The as_bytes to be set.
* @param value The value to be serialized.
* @param error_p The as_error to be populated by the function
* with encountered error if any.
*******************************************************************************************************
*/
extern PyObject * serialize_based_on_serializer_policy(AerospikeClient * self,
int32_t serializer_policy,
as_bytes **bytes,
PyObject *value,
as_error *error_p)
{
uint8_t use_client_serializer = true;
PyObject* initresult = NULL;
if (self->is_client_put_serializer) {
if (serializer_policy == SERIALIZER_USER) {
if (!self->user_serializer_call_info.callback) {
use_client_serializer = false;
}
}
} else if (self->user_serializer_call_info.callback) {
serializer_policy = SERIALIZER_USER;
}
switch(serializer_policy) {
case SERIALIZER_NONE:
as_error_update(error_p, AEROSPIKE_ERR_PARAM,
"Cannot serialize: SERIALIZER_NONE selected");
goto CLEANUP;
case SERIALIZER_PYTHON:
{
/*
* Serialize bytearray as is and store them into database with
* type AS_BYTES_BLOB, unlike other values in case of
* SERIALIZER_PYTHON.
* This is a special case.
* Refer: AER-3589 for more details.
*/
if (PyByteArray_Check(value)) {
uint8_t *bytes_array = (uint8_t *) PyByteArray_AsString(value);
uint32_t bytes_array_len = (uint32_t) PyByteArray_Size(value);
set_as_bytes(bytes, bytes_array, bytes_array_len, AS_BYTES_BLOB, error_p);
} else {
/* get the sys.modules dictionary */
PyObject* sysmodules = PyImport_GetModuleDict();
PyObject* cpickle_module = NULL;
if(PyMapping_HasKeyString(sysmodules, "cPickle")) {
cpickle_module = PyMapping_GetItemString(sysmodules, "cPickle");
} else {
cpickle_module = PyImport_ImportModule("cPickle");
}
if(!cpickle_module) {
/* insert error handling here! and exit this function */
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to load cpickle module");
goto CLEANUP;
} else {
PyObject * py_funcname = PyStr_FromString("dumps");
Py_INCREF(cpickle_module);
initresult = PyObject_CallMethodObjArgs(cpickle_module,
py_funcname, value, NULL);
Py_DECREF(cpickle_module);
Py_DECREF(py_funcname);
if(!initresult) {
/* more error handling &c */
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to call dumps function");
goto CLEANUP;
} else {
Py_INCREF(initresult);
char *return_value = PyStr_AsString(initresult);
Py_ssize_t len = PyBytes_GET_SIZE(initresult);
set_as_bytes(bytes, (uint8_t *) return_value,
len, AS_BYTES_PYTHON, error_p);
Py_DECREF(initresult);
}
}
Py_XDECREF(cpickle_module);
}
}
break;
case SERIALIZER_JSON:
/*
* TODO:
* Handle JSON serialization after support for AS_BYTES_JSON
* is added in aerospike-client-c
*/
as_error_update(error_p, AEROSPIKE_ERR,
"Unable to serialize using standard json serializer");
goto CLEANUP;
case SERIALIZER_USER:
if (use_client_serializer) {
execute_user_callback(&self->user_serializer_call_info, bytes, &value, true, error_p);
if (AEROSPIKE_OK != (error_p->code)) {
goto CLEANUP;
}
} else {
if (is_user_serializer_registered) {
execute_user_callback(&user_serializer_call_info, bytes, &value, true, error_p);
if (AEROSPIKE_OK != (error_p->code)) {
goto CLEANUP;
}
} else if (self->user_serializer_call_info.callback) {
execute_user_callback(&self->user_serializer_call_info, bytes, &value, true, error_p);
if (AEROSPIKE_OK != (error_p->code)) {
goto CLEANUP;
}
} else {
as_error_update(error_p, AEROSPIKE_ERR,
"No serializer callback registered");
goto CLEANUP;
}
}
break;
default:
as_error_update(error_p, AEROSPIKE_ERR,
"Unsupported serializer");
goto CLEANUP;
}
CLEANUP:
Py_XDECREF(initresult);
if ( error_p->code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(error_p, &py_err);
PyObject *exception_type = raise_exception(error_p);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/*
*******************************************************************************************************
* Checks as_bytes->type.
* Deserializes as_bytes into Py_Object (retval) using deserialization logic
* based on as_bytes->type.
*
* @param bytes The as_bytes to be deserialized.
* @param retval The return zval to be populated with the
* deserialized value of the input as_bytes.
* @param error_p The as_error to be populated by the function
* with encountered error if any.
*******************************************************************************************************
*/
extern PyObject * deserialize_based_on_as_bytes_type(AerospikeClient * self,
as_bytes *bytes,
PyObject **retval,
as_error *error_p)
{
switch(as_bytes_get_type(bytes)) {
case AS_BYTES_PYTHON: {
PyObject* sysmodules = PyImport_GetModuleDict();
PyObject* cpickle_module = NULL;
if(PyMapping_HasKeyString(sysmodules, "cPickle")) {
cpickle_module = PyMapping_GetItemString(sysmodules, "cPickle");
} else {
cpickle_module = PyImport_ImportModule("cPickle");
}
PyObject* initresult = NULL;
if(!cpickle_module) {
/* insert error handling here! and exit this function */
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to load cpickle module");
goto CLEANUP;
} else {
char* bytes_val_p = (char*)bytes->value;
PyObject *py_value = PyStr_FromStringAndSize(bytes_val_p, as_bytes_size(bytes));
PyObject *py_funcname = PyStr_FromString("loads");
Py_INCREF(cpickle_module);
initresult = PyObject_CallMethodObjArgs(cpickle_module, py_funcname, py_value, NULL);
Py_DECREF(cpickle_module);
Py_DECREF(py_funcname);
Py_DECREF(py_value);
if(!initresult) {
/* more error handling &c */
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to call loads function");
goto CLEANUP;
} else {
*retval = initresult;
}
}
Py_XDECREF(cpickle_module);
}
break;
case AS_BYTES_BLOB: {
if (self->user_deserializer_call_info.callback) {
execute_user_callback(&self->user_deserializer_call_info, &bytes, retval, false, error_p);
if(AEROSPIKE_OK != (error_p->code)) {
uint32_t bval_size = as_bytes_size(bytes);
PyObject *py_val = PyByteArray_FromStringAndSize((char *) as_bytes_get(bytes), bval_size);
if (!py_val) {
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to deserialize bytes");
goto CLEANUP;
}
*retval = py_val;
as_error_update(error_p, AEROSPIKE_OK, NULL);
}
} else {
if (is_user_deserializer_registered) {
execute_user_callback(&user_deserializer_call_info, &bytes, retval, false, error_p);
if(AEROSPIKE_OK != (error_p->code)) {
uint32_t bval_size = as_bytes_size(bytes);
PyObject *py_val = PyByteArray_FromStringAndSize((char *) as_bytes_get(bytes), bval_size);
if (!py_val) {
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to deserialize bytes");
goto CLEANUP;
}
as_error_update(error_p, AEROSPIKE_OK, NULL);
*retval = py_val;
}
} else {
uint32_t bval_size = as_bytes_size(bytes);
PyObject *py_val = PyByteArray_FromStringAndSize((char *) as_bytes_get(bytes), bval_size);
if (!py_val) {
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to deserialize bytes");
goto CLEANUP;
}
*retval = py_val;
}
}
}
break;
case AS_BYTES_LDT: {
Py_INCREF(Py_None);
*retval = Py_None;
}
break;
default:
as_error_update(error_p, AEROSPIKE_ERR,
"Unable to deserialize bytes");
goto CLEANUP;
}
CLEANUP:
if ( error_p->code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(error_p, &py_err);
PyObject *exception_type = raise_exception(error_p);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
CvArr * PyArray_to_CvArr (PyObject * obj)
{
// let's try to create a temporary CvMat header that points to the
// data owned by obj and reflects its memory layout
CvArr * cvarr = NULL;
void * raw_data = 0;
long rows;
long cols;
long channels;
long step;
long mat_type = 7;
long element_size = 1;
// infer layout from array interface
PyObject * interface = PyObject_GetAttrString (obj, "__array_interface__");
// the array interface should be a dict
if (PyMapping_Check (interface))
{
if (PyMapping_HasKeyString (interface, (char*)"version") &&
PyMapping_HasKeyString (interface, (char*)"shape") &&
PyMapping_HasKeyString (interface, (char*)"typestr") &&
PyMapping_HasKeyString (interface, (char*)"data"))
{
PyObject * version = PyMapping_GetItemString (interface, (char*)"version");
PyObject * shape = PyMapping_GetItemString (interface, (char*)"shape");
PyObject * typestr = PyMapping_GetItemString (interface, (char*)"typestr");
PyObject * data = PyMapping_GetItemString (interface, (char*)"data");
if (!PyInt_Check (version) || PyInt_AsLong (version) != 3)
PyErr_SetString(PyExc_TypeError, "OpenCV understands version 3 of the __array_interface__ only");
else
{
if (!PyTuple_Check (shape) || PyTuple_Size (shape) < 2 || PyTuple_Size (shape) > 3)
PyErr_SetString(PyExc_TypeError, "arrays must have a shape with 2 or 3 dimensions");
else
{
rows = PyInt_AsLong (PyTuple_GetItem (shape, 0));
cols = PyInt_AsLong (PyTuple_GetItem (shape, 1));
channels = PyTuple_Size (shape) < 3 ? 1 : PyInt_AsLong (PyTuple_GetItem (shape, 2));
if (rows < 1 || cols < 1 || channels < 1 || channels > 4)
PyErr_SetString(PyExc_TypeError, "rows and columns must be positive, channels from 1 to 4");
else
{
// fprintf (stderr, "rows: %ld, cols: %ld, channels %ld\n", rows, cols, channels); fflush (stderr);
if (! PyTuple_Check (data) || PyTuple_Size (data) != 2 ||
!(PyInt_Check (PyTuple_GetItem (data,0)) || PyLong_Check (PyTuple_GetItem (data,0))) ||
!(PyBool_Check (PyTuple_GetItem (data,1)) && !PyInt_AsLong (PyTuple_GetItem (data,1))))
PyErr_SetString (PyExc_TypeError, "arrays must have a pointer to writeable data");
else
{
raw_data = PyLong_AsVoidPtr (PyTuple_GetItem (data,0));
// fprintf(stderr, "raw_data: %p\n", raw_data); fflush (stderr);
char * format_str = NULL;
Py_ssize_t len = 0;
if (!PyString_Check (typestr) || PyString_AsStringAndSize (typestr, & format_str, &len) == -1 || len !=3)
PyErr_SetString(PyExc_TypeError, "there is something wrong with the format string");
else
{
// fprintf(stderr, "format: %c %c\n", format_str[1], format_str[2]); fflush (stderr);
if (format_str[1] == 'u' && format_str[2] == '1')
{
element_size = 1;
mat_type = CV_MAKETYPE(CV_8U, channels);
}
else if (format_str[1] == 'i' && format_str[2] == '1')
{
element_size = 1;
mat_type = CV_MAKETYPE(CV_8S, channels);
}
else if (format_str[1] == 'u' && format_str[2] == '2')
{
element_size = 2;
mat_type = CV_MAKETYPE(CV_16U, channels);
}
else if (format_str[1] == 'i' && format_str[2] == '2')
{
element_size = 2;
mat_type = CV_MAKETYPE(CV_16S, channels);
}
else if (format_str[1] == 'i' && format_str[2] == '4')
{
element_size = 4;
mat_type = CV_MAKETYPE(CV_32S, channels);
}
else if (format_str[1] == 'f' && format_str[2] == '4')
{
element_size = 4;
mat_type = CV_MAKETYPE(CV_32F, channels);
}
else if (format_str[1] == 'f' && format_str[2] == '8')
{
element_size = 8;
mat_type = CV_MAKETYPE(CV_64F, channels);
}
else
{
PyErr_SetString(PyExc_TypeError, "unknown or unhandled element format");
mat_type = CV_USRTYPE1;
}
// handle strides if given
// TODO: implement stride handling
step = cols * channels * element_size;
if (PyMapping_HasKeyString (interface, (char*)"strides"))
{
PyObject * strides = PyMapping_GetItemString (interface, (char*)"strides");
if (strides != Py_None)
{
fprintf(stderr, "we have strides ... not handled!\n"); fflush (stderr);
PyErr_SetString(PyExc_TypeError, "arrays with strides not handled yet");
mat_type = CV_USRTYPE1; // use this to denote, we've got an error
}
Py_DECREF (strides);
}
// create matrix header if everything is okay
if (mat_type != CV_USRTYPE1)
{
CvMat * temp_matrix = cvCreateMatHeader (rows, cols, mat_type);
cvSetData (temp_matrix, raw_data, step);
cvarr = temp_matrix;
// fprintf(stderr, "step_size: %ld, type: %ld\n", step, mat_type); fflush (stderr);
}
}
}
}
}
}
Py_DECREF (data);
Py_DECREF (typestr);
Py_DECREF (shape);
Py_DECREF (version);
}
}
Py_DECREF (interface);
return cvarr;
}
static bool
CSAimported ()
{
return PyMapping_HasKeyString (PyImport_GetModuleDict (), (char*)"csa");
}
