/** ******************************************************************************************************* * Increments a numeric value in a bin. * * @param self AerospikeClient object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns an integer status. 0(Zero) is success value. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************* */ PyObject * AerospikeClient_Increment(AerospikeClient * self, PyObject * args, PyObject * kwds) { // Initialize error as_error err; as_error_init(&err); // Python Function Arguments PyObject * py_key = NULL; PyObject * py_policy = NULL; PyObject * py_result = NULL; PyObject * py_bin = NULL; PyObject * py_meta = NULL; PyObject * py_offset_value = 0; as_key key; as_policy_operate operate_policy; as_policy_operate *operate_policy_p = NULL; // Python Function Keyword Arguments static char * kwlist[] = {"key", "bin", "offset", "meta", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "OOO|OO:increment", kwlist, &py_key, &py_bin, &py_offset_value, &py_meta, &py_policy) == false ) { return NULL; } if (!self || !self->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } py_result = AerospikeClient_convert_pythonObj_to_asType(self, &err, py_key, py_policy, &key, &operate_policy, &operate_policy_p); if (!py_result) { goto CLEANUP; } else { Py_DECREF(py_result); } PyObject * py_list = NULL; py_list = create_pylist(py_list, AS_OPERATOR_INCR, py_bin, py_offset_value); py_result = AerospikeClient_Operate_Invoke(self, &err, &key, py_list, py_meta, operate_policy_p); if (py_list) { Py_DECREF(py_list); } if (err.code != AEROSPIKE_OK) { as_error_update(&err, err.code, NULL); goto CLEANUP; } else if (py_result == NULL) { return NULL; } else { Py_DECREF(py_result); } CLEANUP: if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL; error_to_pyobject(&err, &py_err); PyObject *exception_type = raise_exception(&err); if(PyObject_HasAttrString(exception_type, "key")) { PyObject_SetAttrString(exception_type, "key", py_key); } if(PyObject_HasAttrString(exception_type, "bin")) { PyObject_SetAttrString(exception_type, "bin", py_bin); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return PyLong_FromLong(0); }
static PyObject * OscBank_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { int i; PyObject *tabletmp, *freqtmp=NULL, *spreadtmp=NULL, *slopetmp=NULL, *frndftmp=NULL, *frndatmp=NULL, *arndftmp=NULL, *arndatmp=NULL, *multmp=NULL, *addtmp=NULL; OscBank *self; self = (OscBank *)type->tp_alloc(type, 0); self->freq = PyFloat_FromDouble(100.0); self->spread = PyFloat_FromDouble(1.0); self->slope = PyFloat_FromDouble(0.9); self->frndf = PyFloat_FromDouble(1.0); self->frnda = PyFloat_FromDouble(0.0); self->arndf = PyFloat_FromDouble(1.0); self->arnda = PyFloat_FromDouble(0.0); self->stages = 24; self->fjit = 0; self->lastFreq = self->lastSpread = -1.0; self->lastFjit = -1; self->ftime = 1.0; self->finc = 0.0; self->atime = 1.0; self->ainc = 0.0; self->modebuffer[0] = 0; self->modebuffer[1] = 0; self->modebuffer[2] = 0; self->modebuffer[3] = 0; self->modebuffer[4] = 0; self->modebuffer[5] = 0; self->modebuffer[6] = 0; self->modebuffer[7] = 0; self->modebuffer[8] = 0; INIT_OBJECT_COMMON Stream_setFunctionPtr(self->stream, OscBank_compute_next_data_frame); self->mode_func_ptr = OscBank_setProcMode; static char *kwlist[] = {"table", "freq", "spread", "slope", "frndf", "frnda", "arndf", "arnda", "num", "fjit", "mul", "add", NULL}; if (! PyArg_ParseTupleAndKeywords(args, kwds, "O|OOOOOOOiiOO", kwlist, &tabletmp, &freqtmp, &spreadtmp, &slopetmp, &frndftmp, &frndatmp, &arndftmp, &arndatmp, &self->stages, &self->fjit, &multmp, &addtmp)) Py_RETURN_NONE; if ( PyObject_HasAttrString((PyObject *)tabletmp, "getTableStream") == 0 ) { PyErr_SetString(PyExc_TypeError, "\"table\" argument of OscBank must be a PyoTableObject.\n"); Py_RETURN_NONE; } Py_XDECREF(self->table); self->table = PyObject_CallMethod((PyObject *)tabletmp, "getTableStream", ""); if (freqtmp) { PyObject_CallMethod((PyObject *)self, "setFreq", "O", freqtmp); } if (spreadtmp) { PyObject_CallMethod((PyObject *)self, "setSpread", "O", spreadtmp); } if (slopetmp) { PyObject_CallMethod((PyObject *)self, "setSlope", "O", slopetmp); } if (frndftmp) { PyObject_CallMethod((PyObject *)self, "setFrndf", "O", frndftmp); } if (frndatmp) { PyObject_CallMethod((PyObject *)self, "setFrnda", "O", frndatmp); } if (arndftmp) { PyObject_CallMethod((PyObject *)self, "setArndf", "O", arndftmp); } if (arndatmp) { PyObject_CallMethod((PyObject *)self, "setArnda", "O", arndatmp); } if (multmp) { PyObject_CallMethod((PyObject *)self, "setMul", "O", multmp); } if (addtmp) { PyObject_CallMethod((PyObject *)self, "setAdd", "O", addtmp); } PyObject_CallMethod(self->server, "addStream", "O", self->stream); (*self->mode_func_ptr)(self); self->pointerPos = (MYFLT *)realloc(self->pointerPos, self->stages * sizeof(MYFLT)); self->frequencies = (MYFLT *)realloc(self->frequencies, self->stages * sizeof(MYFLT)); self->fOldValues = (MYFLT *)realloc(self->fOldValues, self->stages * sizeof(MYFLT)); self->fValues = (MYFLT *)realloc(self->fValues, self->stages * sizeof(MYFLT)); self->fDiffs = (MYFLT *)realloc(self->fDiffs, self->stages * sizeof(MYFLT)); self->aOldValues = (MYFLT *)realloc(self->aOldValues, self->stages * sizeof(MYFLT)); self->aValues = (MYFLT *)realloc(self->aValues, self->stages * sizeof(MYFLT)); self->aDiffs = (MYFLT *)realloc(self->aDiffs, self->stages * sizeof(MYFLT)); for (i=0; i<self->stages; i++) { self->pointerPos[i] = self->frequencies[i] = self->fOldValues[i] = self->fValues[i] = self->fDiffs[i] = self->aOldValues[i] = self->aValues[i] = self->aDiffs[i] = 0.0; } self->amplitude = 1. / self->stages; Server_generateSeed((Server *)self->server, OSCBANK_ID); return (PyObject *)self; }
/* * * Tests for and converts a Python datetime.datetime or datetime.date * object into a NumPy pandas_datetimestruct. * * While the C API has PyDate_* and PyDateTime_* functions, the following * implementation just asks for attributes, and thus supports * datetime duck typing. The tzinfo time zone conversion would require * this style of access anyway. * * 'out_bestunit' gives a suggested unit based on whether the object * was a datetime.date or datetime.datetime object. * * If 'apply_tzinfo' is 1, this function uses the tzinfo to convert * to UTC time, otherwise it returns the struct with the local time. * * Returns -1 on error, 0 on success, and 1 (with no error set) * if obj doesn't have the neeeded date or datetime attributes. */ int convert_pydatetime_to_datetimestruct(PyObject *obj, pandas_datetimestruct *out, PANDAS_DATETIMEUNIT *out_bestunit, int apply_tzinfo) { PyObject *tmp; int isleap; /* Initialize the output to all zeros */ memset(out, 0, sizeof(pandas_datetimestruct)); out->month = 1; out->day = 1; /* Need at least year/month/day attributes */ if (!PyObject_HasAttrString(obj, "year") || !PyObject_HasAttrString(obj, "month") || !PyObject_HasAttrString(obj, "day")) { return 1; } /* Get the year */ tmp = PyObject_GetAttrString(obj, "year"); if (tmp == NULL) { return -1; } out->year = PyInt_AsLong(tmp); if (out->year == -1 && PyErr_Occurred()) { Py_DECREF(tmp); return -1; } Py_DECREF(tmp); /* Get the month */ tmp = PyObject_GetAttrString(obj, "month"); if (tmp == NULL) { return -1; } out->month = PyInt_AsLong(tmp); if (out->month == -1 && PyErr_Occurred()) { Py_DECREF(tmp); return -1; } Py_DECREF(tmp); /* Get the day */ tmp = PyObject_GetAttrString(obj, "day"); if (tmp == NULL) { return -1; } out->day = PyInt_AsLong(tmp); if (out->day == -1 && PyErr_Occurred()) { Py_DECREF(tmp); return -1; } Py_DECREF(tmp); /* Validate that the month and day are valid for the year */ if (out->month < 1 || out->month > 12) { goto invalid_date; } isleap = is_leapyear(out->year); if (out->day < 1 || out->day > days_per_month_table[isleap][out->month - 1]) { goto invalid_date; } /* Check for time attributes (if not there, return success as a date) */ if (!PyObject_HasAttrString(obj, "hour") || !PyObject_HasAttrString(obj, "minute") || !PyObject_HasAttrString(obj, "second") || !PyObject_HasAttrString(obj, "microsecond")) { /* The best unit for date is 'D' */ if (out_bestunit != NULL) { *out_bestunit = PANDAS_FR_D; } return 0; } /* Get the hour */ tmp = PyObject_GetAttrString(obj, "hour"); if (tmp == NULL) { return -1; } out->hour = PyInt_AsLong(tmp); if (out->hour == -1 && PyErr_Occurred()) { Py_DECREF(tmp); return -1; } Py_DECREF(tmp); /* Get the minute */ tmp = PyObject_GetAttrString(obj, "minute"); if (tmp == NULL) { return -1; } out->min = PyInt_AsLong(tmp); if (out->min == -1 && PyErr_Occurred()) { Py_DECREF(tmp); return -1; } Py_DECREF(tmp); /* Get the second */ tmp = PyObject_GetAttrString(obj, "second"); if (tmp == NULL) { return -1; } out->sec = PyInt_AsLong(tmp); if (out->sec == -1 && PyErr_Occurred()) { Py_DECREF(tmp); return -1; } Py_DECREF(tmp); /* Get the microsecond */ tmp = PyObject_GetAttrString(obj, "microsecond"); if (tmp == NULL) { return -1; } out->us = PyInt_AsLong(tmp); if (out->us == -1 && PyErr_Occurred()) { Py_DECREF(tmp); return -1; } Py_DECREF(tmp); if (out->hour < 0 || out->hour >= 24 || out->min < 0 || out->min >= 60 || out->sec < 0 || out->sec >= 60 || out->us < 0 || out->us >= 1000000) { goto invalid_time; } /* Apply the time zone offset if it exists */ if (apply_tzinfo && PyObject_HasAttrString(obj, "tzinfo")) { tmp = PyObject_GetAttrString(obj, "tzinfo"); if (tmp == NULL) { return -1; } if (tmp == Py_None) { Py_DECREF(tmp); } else { PyObject *offset; int seconds_offset, minutes_offset; /* The utcoffset function should return a timedelta */ offset = PyObject_CallMethod(tmp, "utcoffset", "O", obj); if (offset == NULL) { Py_DECREF(tmp); return -1; } Py_DECREF(tmp); /* * The timedelta should have a function "total_seconds" * which contains the value we want. */ tmp = PyObject_CallMethod(offset, "total_seconds", ""); if (tmp == NULL) { return -1; } seconds_offset = PyInt_AsLong(tmp); if (seconds_offset == -1 && PyErr_Occurred()) { Py_DECREF(tmp); return -1; } Py_DECREF(tmp); /* Convert to a minutes offset and apply it */ minutes_offset = seconds_offset / 60; add_minutes_to_datetimestruct(out, -minutes_offset); } } /* The resolution of Python's datetime is 'us' */ if (out_bestunit != NULL) { *out_bestunit = PANDAS_FR_us; } return 0; invalid_date: PyErr_Format(PyExc_ValueError, "Invalid date (%d,%d,%d) when converting to NumPy datetime", (int)out->year, (int)out->month, (int)out->day); return -1; invalid_time: PyErr_Format(PyExc_ValueError, "Invalid time (%d,%d,%d,%d) when converting " "to NumPy datetime", (int)out->hour, (int)out->min, (int)out->sec, (int)out->us); return -1; }
//------------------------------------------------------------------------------------- bool InitProgressHandler::process() { if(error_) { Baseapp::getSingleton().dispatcher().breakProcessing(); return false; } Network::Channel* pChannel = Components::getSingleton().getBaseappmgrChannel(); if(pChannel == NULL) return true; if(Baseapp::getSingleton().idClient().getSize() == 0) return true; if(delayTicks_++ < 1) return true; // 只有第一个baseapp上会创建EntityAutoLoader来自动加载数据库实体 if(g_componentGroupOrder == 1) { if(autoLoadState_ == -1) { autoLoadState_ = 0; pEntityAutoLoader_ = new EntityAutoLoader(networkInterface_, this); return true; } else if(autoLoadState_ == 0) { // 必须等待EntityAutoLoader执行完毕 // EntityAutoLoader执行完毕会设置autoLoadState_ = 1 return true; } } pEntityAutoLoader_ = NULL; if(!baseappReady_) { baseappReady_ = true; SCOPED_PROFILE(SCRIPTCALL_PROFILE); // 所有脚本都加载完毕 PyObject* pyResult = PyObject_CallMethod(Baseapp::getSingleton().getEntryScript().get(), const_cast<char*>("onBaseAppReady"), const_cast<char*>("O"), PyBool_FromLong((g_componentGroupOrder == 1) ? 1 : 0)); if(pyResult != NULL) Py_DECREF(pyResult); else SCRIPT_ERROR_CHECK(); return true; } float v = 0.0f; bool completed = false; if(PyObject_HasAttrString(Baseapp::getSingleton().getEntryScript().get(), "onReadyForLogin") > 0) { SCOPED_PROFILE(SCRIPTCALL_PROFILE); // 回调获得是否能够登录 PyObject* pyResult = PyObject_CallMethod(Baseapp::getSingleton().getEntryScript().get(), const_cast<char*>("onReadyForLogin"), const_cast<char*>("O"), PyBool_FromLong((g_componentGroupOrder == 1) ? 1 : 0)); if(pyResult != NULL) { completed = (pyResult == Py_True); if(!completed) { v = (float)PyFloat_AsDouble(pyResult); if (PyErr_Occurred()) { SCRIPT_ERROR_CHECK(); Py_DECREF(pyResult); return true; } } else { v = 100.f; } Py_DECREF(pyResult); } else { SCRIPT_ERROR_CHECK(); return true; } } else { v = 100.f; completed = true; } if(v >= 0.9999f) { v = 100.f; completed = true; } Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject(); (*pBundle).newMessage(BaseappmgrInterface::onBaseappInitProgress); (*pBundle) << g_componentID << v; pChannel->send(pBundle); if(completed) { delete this; return false; } return true; }
/* This is the write call back registered within the event loop */ void write_cb(struct ev_loop *loop, struct ev_io *w, int revents) { char response[MAXHEADER]; int stop=0; //0: not stop, 1: stop, 2: stop and call tp close int ret; //python_handler return struct client *cli= ((struct client*) (((char*)w) - offsetof(struct client,ev_write))); if (cli->response_iter_sent==-2) { //we must send an header or an error ret=python_handler(cli); //look for python callback and execute it if (ret==0) //look for python callback and execute it { //uri not found str_append3(response,"HTTP/1.0 500 Not found\r\nContent-Type: text/html\r\nServer: ", VERSION ,"\r\n\r\n<html><head><title>Page not found</head><body><p>Page not found!!!</p></body></html>", MAXHEADER); write_cli(cli,response, strlen(response), revents); stop=1; } else if (ret==-411) { str_append3(response,"HTTP/1.0 411 Length Required\r\nContent-Type: text/html\r\nServer: ", VERSION, "\r\n\r\n<html><head><title>Length Required</head><body><p>Length Required!!!</p></body></html>", MAXHEADER); write_cli(cli,response, strlen(response), revents); stop=1; } else if (ret==-500) { str_append3(response,"HTTP/1.0 500 Internal Server Error\r\nContent-Type: text/html\r\nServer: ", VERSION, "\r\n\r\n<html><head><title>Internal Server Error</head><body><p>Internal Server Error!!!</p></body></html>", MAXHEADER); write_cli(cli,response, strlen(response), revents); stop=1; } else if (ret==-501) { //problem to parse the request str_append3(response,"HTTP/1.0 501 Not Implemented\r\nContent-Type: text/html\r\nServer: ", VERSION, "\r\n\r\n<html><head><title>Not Implemented</head><body><p>Not Implemented!!!</p></body></html>", MAXHEADER); write_cli(cli,response, strlen(response), revents); stop=1; } else { //uri found, we thus send the html header write_cli(cli, cli->response_header, cli->response_header_length, revents); cli->response_iter_sent++; //-1: header sent } } else if (strcmp(cli->cmd,"HEAD")==0) { //we don't send additonal data for a HEAD command stop=2; } else { //we let the python developer to manage other HTTP command if ((PyList_Check(cli->response_content)) && (cli->response_content_obj==NULL)) //we treat list object { cli->response_iter_sent++; if (cli->response_iter_sent<PyList_Size(cli->response_content)) { PyObject *pydummy = PyList_GetItem(cli->response_content, cli->response_iter_sent); char *buff; #if (PY_VERSION_HEX < 0x02050000) int buflen; if (PyObject_AsReadBuffer(pydummy, (const void **) &buff, &buflen)==0) #else Py_ssize_t buflen; if (PyObject_AsReadBuffer(pydummy, (const void **) &buff, &buflen)==0) #endif { // if this is a readable buffer, we send it. Other else, we ignore it. if (write_cli(cli, buff, buflen, revents)==0) { cli->response_iter_sent=PyList_Size(cli->response_content); //break the for loop } } else { printf("The item %i of your list is not a string!!!! It will be skipped\n",cli->response_iter_sent); } } else // all iterations has been sent { stop=2; } } else if (PyFile_Check(cli->response_content) && (cli->response_content_obj==NULL)) // we treat file object { if (cli->response_iter_sent==-1) // we need to initialise the file descriptor { cli->response_fp=PyFile_AsFile(cli->response_content); } cli->response_iter_sent++; char buff[MAX_BUFF]=""; size_t len=fread(buff, sizeof(char), MAX_BUFF, cli->response_fp); if ((int)len==0) { stop=2; } else { if (write_cli(cli,buff, len, revents)==0) { stop=2; } if ((int)len<MAX_BUFF) { //we have send the whole file stop=2; } } //free(buff); } else if (PyIter_Check(cli->response_content_obj)) //we treat Iterator object { cli->response_iter_sent++; PyObject *pyelem = cli->response_content; if (pyelem == NULL) { stop = 2; } else { char *buff; #if (PY_VERSION_HEX < 0x02050000) int buflen; if (PyObject_AsReadBuffer(pyelem, (const void **) &buff, &buflen)==0) #else Py_ssize_t buflen; if (PyObject_AsReadBuffer(pyelem, (const void **) &buff, &buflen)==0) #endif { // if this is a readable buffer, we send it. Other else, we ignore it. if (write_cli(cli, buff, buflen, revents)==0) { stop=2; //break the iterator loop } } else { printf("The item %i of your iterator is not a string!!!! It will be skipped\n",cli->response_iter_sent); } Py_DECREF(pyelem); cli->response_content = PyIter_Next(cli->response_content_obj); if (cli->response_content==NULL) { if (debug) { printf("host=%s,port=%i iterator ended uri=%s\n", cli->remote_addr, cli->remote_port, cli->uri ); } stop=2; } } } else { printf("wsgi output of is neither a list neither a fileobject\n"); //PyErr_SetString(PyExc_TypeError, "Result must be a list or a fileobject"); stop=1; } }// end of GET OR POST request if (stop==2) { if (cli->response_content!=NULL) { if (PyObject_HasAttrString(cli->response_content, "close")) { PyObject *pydummy=PyObject_GetAttrString(cli->response_content, "close"); PyObject_CallFunction(pydummy, NULL); Py_DECREF(pydummy); } } ev_io_stop(EV_A_ w); close_connection(cli); } if (stop==1) { ev_io_stop(EV_A_ w); close_connection(cli); } }
int ObjectRow_PyObject__init(ObjectRow_PyObject *self, PyObject *args, PyObject *kwargs) { PyObject *pytmp, *pydesc, *cursor, *row, *o_type, *pickle_dict = 0; struct module_state *mstate; if (!PyArg_ParseTuple(args, "OO|O!", &cursor, &row, &PyDict_Type, &pickle_dict)) return -1; mstate = GETSTATE_FROMTYPE(self); if (pickle_dict) { /* If row or cursor weren't specified, then we require the third arg * (pickle_dict) be a dictionary, and we basically behave as this dict. * We do this for example from Database.add() */ self->pickle = pickle_dict; Py_INCREF(self->pickle); self->row = Py_None; Py_INCREF(self->row); self->desc = Py_None; Py_INCREF(self->desc); return 0; } /* First argument is the db cursor from which we fetch the row description * and object types. Or, it is a 2-tuple of same. */ if (PyTuple_Check(cursor)) { self->desc = PySequence_GetItem(cursor, 0); // new ref self->object_types = PySequence_GetItem(cursor, 1); // new ref } else if (!PyObject_HasAttrString(cursor, "_db")) { PyErr_Format(PyExc_ValueError, "First argument is not a Cursor or tuple object"); return -1; } else { PyObject *weak_db = PyObject_GetAttrString(cursor, "_db"); // new ref PyObject *db = PyWeakref_GetObject(weak_db); // borrowed ref self->object_types = PyObject_GetAttrString(db, "_object_types"); // new ref self->desc = PyObject_GetAttrString(cursor, "description"); // new ref Py_XDECREF(weak_db); } self->row = row; self->type_name = PySequence_GetItem(row, 0); // new ref if (!PyString_Check(self->type_name) && !PyUnicode_Check(self->type_name)) { Py_XDECREF(self->desc); Py_XDECREF(self->object_types); PyErr_Format(PyExc_ValueError, "First element of row must be object type"); return -1; } o_type = PyDict_GetItem(self->object_types, self->type_name); // borrowed ref self->attrs = PySequence_GetItem(o_type, 1); // new ref if (!self->attrs) { char *type_name; #if PY_MAJOR_VERSION >= 3 PyObject *bytes = PyUnicode_AsUTF8String(self->type_name); type_name = strdup(PyBytes_AS_STRING(bytes)); Py_DECREF(bytes); #else type_name = strdup(PyString_AsString(self->type_name)); #endif PyErr_Format(PyExc_ValueError, "Object type '%s' not defined.", type_name); free(type_name); Py_XDECREF(self->desc); Py_XDECREF(self->object_types); return -1; } /* For the queries dict key we use the address of the desc object rather * than the desc itself. desc is a tuple, and if we use it as a key it * will result in a hash() on the desc for each row which is much more * expensive. pysqlite passes us the same description tuple object for * each row in a query so it is safe to use the address. */ pydesc = PyLong_FromVoidPtr(self->desc); pytmp = PyDict_GetItem(mstate->queries, pydesc); self->query_info = pytmp ? (QueryInfo *)PyCObject_AsVoidPtr(pytmp) : NULL; if (!self->query_info) { /* This is a row for a query we haven't seen before, so we need to do * some initial setup. Most of what we do here is convert row and * attribute metadata into convenient data structures for later access. */ PyObject **desc_tuple = PySequence_Fast_ITEMS(self->desc); PyObject *key, *value; int i = 0; Py_ssize_t pos = 0; self->query_info = (QueryInfo *)malloc(sizeof(QueryInfo)); self->query_info->refcount = 0; self->query_info->pickle_idx = -1; self->query_info->idxmap = PyDict_New(); /* Iterate over the columns from the SQL query and keep track of * attribute names and their indexes within the row tuple. Start at * index 2 because index 0 and 1 are internal (the object type name * literal and type id). */ for (i = 2; i < PySequence_Length(self->desc); i++) { PyObject **desc_col = PySequence_Fast_ITEMS(desc_tuple[i]); ObjectAttribute *attr = (ObjectAttribute *)malloc(sizeof(ObjectAttribute)); attr->pickled = 0; attr->index = i; if (PyStr_Compare(desc_col[0], "pickle") == 0) self->query_info->pickle_idx = i; pytmp = PyCObject_FromVoidPtr(attr, free); PyDict_SetItem(self->query_info->idxmap, desc_col[0], pytmp); Py_DECREF(pytmp); } /* Now iterate over the kaa.db object attribute dict, storing the * type of each attribute, its flags, and figure out whether or not * we need to look in the pickle for that attribute. */ while (PyDict_Next(self->attrs, &pos, &key, &value)) { pytmp = PyDict_GetItem(self->query_info->idxmap, key); ObjectAttribute *attr = pytmp ? (ObjectAttribute *)PyCObject_AsVoidPtr(pytmp) : NULL; if (!attr) { attr = (ObjectAttribute *)malloc(sizeof(ObjectAttribute)); attr->index = -1; pytmp = PyCObject_FromVoidPtr(attr, free); PyDict_SetItem(self->query_info->idxmap, key, pytmp); Py_DECREF(pytmp); } attr->type = PySequence_Fast_GET_ITEM(value, 0); attr->flags = PyInt_AsLong(PySequence_Fast_GET_ITEM(value, 1)); attr->named_ivtidx = PyObject_RichCompareBool(PySequence_Fast_GET_ITEM(value, 2), key, Py_EQ) == 1; if (IS_ATTR_INDEXED_IGNORE_CASE(attr->flags) || attr->flags & ATTR_SIMPLE) // attribute is set to ignore case, or it's ATTR_SIMPLE, so we // need to look in the pickle for this attribute. attr->pickled = 1; else attr->pickled = 0; } /* Create a hash table that maps object type ids to type names. */ pos = 0; self->query_info->type_names = PyDict_New(); while (PyDict_Next(self->object_types, &pos, &key, &value)) { PyObject *type_id = PySequence_Fast_GET_ITEM(value, 0); PyDict_SetItem(self->query_info->type_names, type_id, key); } pytmp = PyCObject_FromVoidPtr(self->query_info, NULL); PyDict_SetItem(mstate->queries, pydesc, pytmp); Py_DECREF(pytmp); } Py_DECREF(pydesc); self->query_info->refcount++; if (self->query_info->pickle_idx >= 0) { // Pickle column included in row. Set _pickle member to True which // indicates the pickle data was fetched, but just hasn't yet been // unpickled. if (PySequence_Fast_GET_ITEM(self->row, self->query_info->pickle_idx) != Py_None) self->has_pickle = 1; self->pickle = Py_True; } else self->pickle = Py_False; Py_INCREF(self->pickle); Py_INCREF(self->row); if (pickle_dict && pickle_dict != Py_None) { Py_DECREF(self->pickle); self->pickle = pickle_dict; Py_INCREF(self->pickle); self->has_pickle = self->unpickled = 1; } return 0; }
EventFunctor::EventFunctor(bp::object pyObject) : pyFunction(pyObject) { bool bad = false; // Check to make sure its a callable object if (0 == PyObject_HasAttrString(pyObject.ptr(), "__call__")) { // If not, lets throw an exception to warn the user PyErr_SetString(PyExc_TypeError, "Handler must be a callable object"); bad = true; } else { int expectedArgs = 1; // Handle function objects vs. functions // * Free python functions have a 'func_code' attributes // * For python function objects, their __call__ method has func_code bp::object func_code; bp::object func_defaults; if (0 == PyObject_HasAttrString(pyObject.ptr(), "func_code")) { // Function object, need to increment count for 'self' expectedArgs += 1; func_code = pyObject.attr("__call__").attr("func_code"); func_defaults = pyObject.attr("__call__").attr("func_defaults"); } else { func_code = pyObject.attr("func_code"); func_defaults = pyObject.attr("func_defaults"); // Handle instancemethod type callable if (0 != PyObject_HasAttrString(pyObject.ptr(), "im_self")) expectedArgs += 1; } // Determine the number of default arguments int defaultArgCount = 0; if (Py_None != func_defaults.ptr()) defaultArgCount = bp::len(func_defaults); int maxArgCount = bp::extract<int>(func_code.attr("co_argcount")); // 0x4 in the flags means we have a function signature with *args int flags = bp::extract<int>(func_code.attr("co_flags")); // Argument count with default arguments considered int minArgCount = maxArgCount - defaultArgCount; // To many arguments if (minArgCount > expectedArgs) { PyErr_SetString(PyExc_TypeError, "Handler has to many args, expected 1"); bad = true; } // Note: 0x08 if flags means **kwargs in signature // To few arguments and no "*args" in signature else if ((maxArgCount < expectedArgs) && !(flags & 4)) { PyErr_SetString(PyExc_TypeError, "Handler has too few args, expected 1"); bad = true; } } if (bad) bp::throw_error_already_set(); }
Config* PyGLPSParse2Config(PyObject *, PyObject *args, PyObject *kws) { PyObject *conf = NULL, *extra_defs = Py_None; const char *path = NULL; const char *pnames[] = {"config", "path", "extra", NULL}; if(!PyArg_ParseTupleAndKeywords(args, kws, "O|zO", (char**)pnames, &conf, &path, &extra_defs)) return NULL; GLPSParser parser; if(extra_defs==Py_None) { // no-op } else if(PyDict_Check(extra_defs)) { PyObject *key, *value; Py_ssize_t pos = 0; while(PyDict_Next(extra_defs, &pos, &key, &value)) { PyRef<> keyx(key, borrow()); PyCString keystr(keyx); Config::value_t curval; if(PyNumber_Check(value)) { PyRef<> pyf(PyNumber_Float(value)); curval = PyFloat_AsDouble(pyf.py()); } else if(PyString_Check(value)) { PyRef<> valuex(value, borrow()); PyCString valstr(valuex); curval = valstr.c_str(); } else { PyErr_SetString(PyExc_ValueError, "extra {} can contain only numbers or strings"); return NULL; } parser.setVar(keystr.c_str(), curval); } } else { PyErr_SetString(PyExc_ValueError, "'extra' must be a dict"); return NULL; } PyGetBuf buf; std::auto_ptr<Config> C; PyRef<> listref; if(PyObject_HasAttrString(conf, "read")) { // file-like PyCString pyname; if(!path && PyObject_HasAttrString(conf, "name")) { path = pyname.c_str(pydirname(PyObject_GetAttrString(conf, "name"))); } PyRef<> pybytes(PyObject_CallMethod(conf, "read", "")); if(!buf.get(pybytes.py())) { PyErr_SetString(PyExc_TypeError, "read() must return a buffer"); return NULL; } C.reset(parser.parse_byte((const char*)buf.data(), buf.size(), path)); } else if(buf.get(conf)) { C.reset(parser.parse_byte((const char*)buf.data(), buf.size(), path)); #if PY_MAJOR_VERSION >= 3 } else if(PyUnicode_Check(conf)) { // py3 str (aka unicode) doesn't implement buffer iface PyCString buf; const char *cbuf = buf.c_str(conf); C.reset(parser.parse_byte(cbuf, strlen(cbuf), path)); #endif } else { if(PyDict_Check(conf)) { listref.reset(PyMapping_Items(conf)); conf = listref.py(); } if(PyList_Check(conf)) { C.reset(list2conf(conf)); } else { throw std::invalid_argument("'config' must be dict, list of tuples, or byte buffer"); } } return C.release(); }
PyObject *PythonModules::loadModule(QString modulePath, bool reload, bool *firstLoad) { PyObject *pModule = nullptr; if (modulePath.isEmpty()) { // should have been checked earlier already, but who knows ... callback->logError(tr("Empty module path name, nothing to load...")); return pModule; } PyGILState_STATE lgstate; lgstate = PyGILState_Ensure(); if (!modulesPath.contains(modulePath)) { qDebug() << "Instanciating the module for the first time " << modulePath; QString moduleName = getModuleNameFromFile(modulePath); if (!checkModuleNameAndPath(modulePath, moduleName)) { // checking if the module is already there from another file PyGILState_Release(lgstate); return pModule; } pModule = PyImport_ImportModule(moduleName.toUtf8().data()); // new reference if (!checkPyError()) { callback->logError(tr("Module \"%1\" could not be loaded:\n %2").arg(modulePath).arg(errorMessage)); pModule = nullptr; } else { if (!checkModuleNameAndPath(modulePath, moduleName)) { // checking if the module loaded comes from the file that was supplied Py_XDECREF(pModule); pModule = nullptr; PyGILState_Release(lgstate); return pModule; } if (PyObject_HasAttrString(pModule, MAIN_FUNCTION_NAME) != 1) { callback->logError(tr("The python module %2 does not have the %1 method").arg(QString::fromUtf8(MAIN_FUNCTION_NAME)).arg(moduleName)); Py_XDECREF(pModule); pModule = nullptr; PyGILState_Release(lgstate); return pModule; } else { modulesPath.insert(modulePath,pModule); if (firstLoad != nullptr) *firstLoad = true; } } } else if (reload) { qDebug() << "Reloading module" << modulePath; PyObject *oldModule = modulesPath.take(modulePath); // the module object is either going to be replaced or cleared // clearing global objects (we don't care about any error message here) PyObject * attr = PyObject_GetAttrString(oldModule,INBOUND_ATTR_NAME); PyErr_Clear(); Py_XDECREF(attr); attr = PyObject_GetAttrString(oldModule,ISTWOWAY_ATTR_NAME); PyErr_Clear(); Py_XDECREF(attr); attr = PyObject_GetAttrString(oldModule,PARAMS_ATTR_NAME); PyErr_Clear(); Py_XDECREF(attr); attr = PyObject_GetAttrString(oldModule,PARAMS_NAMES_ATTR_NAME); PyErr_Clear(); Py_XDECREF(attr); // reloading pModule = PyImport_ReloadModule(oldModule); // new ref ?? if (pModule != oldModule) { Py_XDECREF(oldModule); // clearing the old module object if the new ref is different } if (!checkPyError()) { callback->logError(tr("Error(s) while reloading the module %1, removing it from the the registered modules.\n%2").arg(modulePath).arg(errorMessage)); pModule = nullptr; } else { modulesPath.insert(modulePath,pModule); } } else { qDebug() << "no reload, taking the module as it is already" << modulePath; pModule = modulesPath.value(modulePath); } PyGILState_Release(lgstate); return pModule; }
static int ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, int buflen, int recursive) { int i; if (!PyObject_HasAttrString(mod, "__path__")) return 1; for (i = 0; ; i++) { PyObject *item = PySequence_GetItem(fromlist, i); int hasit; if (item == NULL) { if (PyErr_ExceptionMatches(PyExc_IndexError)) { PyErr_Clear(); return 1; } return 0; } if (!PyString_Check(item)) { PyErr_SetString(PyExc_TypeError, "Item in ``from list'' not a string"); Py_DECREF(item); return 0; } if (PyString_AS_STRING(item)[0] == '*') { PyObject *all; Py_DECREF(item); /* See if the package defines __all__ */ if (recursive) continue; /* Avoid endless recursion */ all = PyObject_GetAttrString(mod, "__all__"); if (all == NULL) PyErr_Clear(); else { if (!ensure_fromlist(mod, all, buf, buflen, 1)) return 0; Py_DECREF(all); } continue; } hasit = PyObject_HasAttr(mod, item); if (!hasit) { char *subname = PyString_AS_STRING(item); PyObject *submod; char *p; if (buflen + strlen(subname) >= MAXPATHLEN) { PyErr_SetString(PyExc_ValueError, "Module name too long"); Py_DECREF(item); return 0; } p = buf + buflen; *p++ = '.'; strcpy(p, subname); submod = import_submodule(mod, subname, buf); Py_XDECREF(submod); if (submod == NULL) { Py_DECREF(item); return 0; } } Py_DECREF(item); } /* NOTREACHED */ }
NPY_NO_EXPORT int PyArray_DTypeFromObjectHelper(PyObject *obj, int maxdims, PyArray_Descr **out_dtype, int string_type) { int i, size; PyArray_Descr *dtype = NULL; PyObject *ip; #if PY_VERSION_HEX >= 0x02060000 Py_buffer buffer_view; #endif /* Check if it's an ndarray */ if (PyArray_Check(obj)) { dtype = PyArray_DESCR((PyArrayObject *)obj); Py_INCREF(dtype); goto promote_types; } /* Check if it's a NumPy scalar */ if (PyArray_IsScalar(obj, Generic)) { if (!string_type) { dtype = PyArray_DescrFromScalar(obj); if (dtype == NULL) { goto fail; } } else { int itemsize; PyObject *temp; if (string_type == NPY_STRING) { if ((temp = PyObject_Str(obj)) == NULL) { return -1; } #if defined(NPY_PY3K) #if PY_VERSION_HEX >= 0x03030000 itemsize = PyUnicode_GetLength(temp); #else itemsize = PyUnicode_GET_SIZE(temp); #endif #else itemsize = PyString_GET_SIZE(temp); #endif } else if (string_type == NPY_UNICODE) { #if defined(NPY_PY3K) if ((temp = PyObject_Str(obj)) == NULL) { #else if ((temp = PyObject_Unicode(obj)) == NULL) { #endif return -1; } itemsize = PyUnicode_GET_DATA_SIZE(temp); #ifndef Py_UNICODE_WIDE itemsize <<= 1; #endif } else { goto fail; } Py_DECREF(temp); if (*out_dtype != NULL && (*out_dtype)->type_num == string_type && (*out_dtype)->elsize >= itemsize) { return 0; } dtype = PyArray_DescrNewFromType(string_type); if (dtype == NULL) { goto fail; } dtype->elsize = itemsize; } goto promote_types; } /* Check if it's a Python scalar */ dtype = _array_find_python_scalar_type(obj); if (dtype != NULL) { if (string_type) { int itemsize; PyObject *temp; if (string_type == NPY_STRING) { if ((temp = PyObject_Str(obj)) == NULL) { return -1; } #if defined(NPY_PY3K) #if PY_VERSION_HEX >= 0x03030000 itemsize = PyUnicode_GetLength(temp); #else itemsize = PyUnicode_GET_SIZE(temp); #endif #else itemsize = PyString_GET_SIZE(temp); #endif } else if (string_type == NPY_UNICODE) { #if defined(NPY_PY3K) if ((temp = PyObject_Str(obj)) == NULL) { #else if ((temp = PyObject_Unicode(obj)) == NULL) { #endif return -1; } itemsize = PyUnicode_GET_DATA_SIZE(temp); #ifndef Py_UNICODE_WIDE itemsize <<= 1; #endif } else { goto fail; } Py_DECREF(temp); if (*out_dtype != NULL && (*out_dtype)->type_num == string_type && (*out_dtype)->elsize >= itemsize) { return 0; } dtype = PyArray_DescrNewFromType(string_type); if (dtype == NULL) { goto fail; } dtype->elsize = itemsize; } goto promote_types; } /* Check if it's an ASCII string */ if (PyBytes_Check(obj)) { int itemsize = PyString_GET_SIZE(obj); /* If it's already a big enough string, don't bother type promoting */ if (*out_dtype != NULL && (*out_dtype)->type_num == NPY_STRING && (*out_dtype)->elsize >= itemsize) { return 0; } dtype = PyArray_DescrNewFromType(NPY_STRING); if (dtype == NULL) { goto fail; } dtype->elsize = itemsize; goto promote_types; } /* Check if it's a Unicode string */ if (PyUnicode_Check(obj)) { int itemsize = PyUnicode_GET_DATA_SIZE(obj); #ifndef Py_UNICODE_WIDE itemsize <<= 1; #endif /* * If it's already a big enough unicode object, * don't bother type promoting */ if (*out_dtype != NULL && (*out_dtype)->type_num == NPY_UNICODE && (*out_dtype)->elsize >= itemsize) { return 0; } dtype = PyArray_DescrNewFromType(NPY_UNICODE); if (dtype == NULL) { goto fail; } dtype->elsize = itemsize; goto promote_types; } #if PY_VERSION_HEX >= 0x02060000 /* PEP 3118 buffer interface */ memset(&buffer_view, 0, sizeof(Py_buffer)); if (PyObject_GetBuffer(obj, &buffer_view, PyBUF_FORMAT|PyBUF_STRIDES) == 0 || PyObject_GetBuffer(obj, &buffer_view, PyBUF_FORMAT) == 0) { PyErr_Clear(); dtype = _descriptor_from_pep3118_format(buffer_view.format); PyBuffer_Release(&buffer_view); if (dtype) { goto promote_types; } } else if (PyObject_GetBuffer(obj, &buffer_view, PyBUF_STRIDES) == 0 || PyObject_GetBuffer(obj, &buffer_view, PyBUF_SIMPLE) == 0) { PyErr_Clear(); dtype = PyArray_DescrNewFromType(NPY_VOID); dtype->elsize = buffer_view.itemsize; PyBuffer_Release(&buffer_view); goto promote_types; } else { PyErr_Clear(); } #endif /* The array interface */ ip = PyObject_GetAttrString(obj, "__array_interface__"); if (ip != NULL) { if (PyDict_Check(ip)) { PyObject *typestr; #if defined(NPY_PY3K) PyObject *tmp = NULL; #endif typestr = PyDict_GetItemString(ip, "typestr"); #if defined(NPY_PY3K) /* Allow unicode type strings */ if (PyUnicode_Check(typestr)) { tmp = PyUnicode_AsASCIIString(typestr); typestr = tmp; } #endif if (typestr && PyBytes_Check(typestr)) { dtype =_array_typedescr_fromstr(PyBytes_AS_STRING(typestr)); #if defined(NPY_PY3K) if (tmp == typestr) { Py_DECREF(tmp); } #endif Py_DECREF(ip); if (dtype == NULL) { goto fail; } goto promote_types; } } Py_DECREF(ip); } else { PyErr_Clear(); } /* The array struct interface */ ip = PyObject_GetAttrString(obj, "__array_struct__"); if (ip != NULL) { PyArrayInterface *inter; char buf[40]; if (NpyCapsule_Check(ip)) { inter = (PyArrayInterface *)NpyCapsule_AsVoidPtr(ip); if (inter->two == 2) { PyOS_snprintf(buf, sizeof(buf), "|%c%d", inter->typekind, inter->itemsize); dtype = _array_typedescr_fromstr(buf); Py_DECREF(ip); if (dtype == NULL) { goto fail; } goto promote_types; } } Py_DECREF(ip); } else { PyErr_Clear(); } /* The old buffer interface */ #if !defined(NPY_PY3K) if (PyBuffer_Check(obj)) { dtype = PyArray_DescrNewFromType(NPY_VOID); if (dtype == NULL) { goto fail; } dtype->elsize = Py_TYPE(obj)->tp_as_sequence->sq_length(obj); PyErr_Clear(); goto promote_types; } #endif /* The __array__ attribute */ if (PyObject_HasAttrString(obj, "__array__")) { ip = PyObject_CallMethod(obj, "__array__", NULL); if(ip && PyArray_Check(ip)) { dtype = PyArray_DESCR((PyArrayObject *)ip); Py_INCREF(dtype); Py_DECREF(ip); goto promote_types; } Py_XDECREF(ip); if (PyErr_Occurred()) { goto fail; } } /* Not exactly sure what this is about... */ #if !defined(NPY_PY3K) if (PyInstance_Check(obj)) { dtype = _use_default_type(obj); if (dtype == NULL) { goto fail; } else { goto promote_types; } } #endif /* * If we reached the maximum recursion depth without hitting one * of the above cases, the output dtype should be OBJECT */ if (maxdims == 0 || !PySequence_Check(obj)) { if (*out_dtype == NULL || (*out_dtype)->type_num != NPY_OBJECT) { Py_XDECREF(*out_dtype); *out_dtype = PyArray_DescrFromType(NPY_OBJECT); if (*out_dtype == NULL) { return -1; } } return 0; } /* Recursive case */ size = PySequence_Size(obj); if (size < 0) { goto fail; } /* Recursive call for each sequence item */ for (i = 0; i < size; ++i) { int res; ip = PySequence_GetItem(obj, i); if (ip == NULL) { goto fail; } res = PyArray_DTypeFromObjectHelper(ip, maxdims - 1, out_dtype, string_type); if (res < 0) { Py_DECREF(ip); goto fail; } else if (res > 0) { Py_DECREF(ip); return res; } Py_DECREF(ip); } return 0; promote_types: /* Set 'out_dtype' if it's NULL */ if (*out_dtype == NULL) { if (!string_type && dtype->type_num == NPY_STRING) { Py_DECREF(dtype); return RETRY_WITH_STRING; } if (!string_type && dtype->type_num == NPY_UNICODE) { Py_DECREF(dtype); return RETRY_WITH_UNICODE; } *out_dtype = dtype; return 0; } /* Do type promotion with 'out_dtype' */ else { PyArray_Descr *res_dtype = PyArray_PromoteTypes(dtype, *out_dtype); Py_DECREF(dtype); if (res_dtype == NULL) { return -1; } if (!string_type && res_dtype->type_num == NPY_UNICODE && (*out_dtype)->type_num != NPY_UNICODE) { Py_DECREF(res_dtype); return RETRY_WITH_UNICODE; } if (!string_type && res_dtype->type_num == NPY_STRING && (*out_dtype)->type_num != NPY_STRING) { Py_DECREF(res_dtype); return RETRY_WITH_STRING; } Py_DECREF(*out_dtype); *out_dtype = res_dtype; return 0; } fail: Py_XDECREF(*out_dtype); *out_dtype = NULL; return -1; } #undef RETRY_WITH_STRING #undef RETRY_WITH_UNICODE /* new reference */ NPY_NO_EXPORT PyArray_Descr * _array_typedescr_fromstr(char *c_str) { PyArray_Descr *descr = NULL; PyObject *stringobj = PyString_FromString(c_str); if (stringobj == NULL) { return NULL; } if (PyArray_DescrConverter(stringobj, &descr) != NPY_SUCCEED) { Py_DECREF(stringobj); return NULL; } Py_DECREF(stringobj); return descr; } NPY_NO_EXPORT int check_and_adjust_index(npy_intp *index, npy_intp max_item, int axis) { /* Check that index is valid, taking into account negative indices */ if ((*index < -max_item) || (*index >= max_item)) { /* Try to be as clear as possible about what went wrong. */ if (axis >= 0) { PyErr_Format(PyExc_IndexError, "index %"NPY_INTP_FMT" is out of bounds " "for axis %d with size %"NPY_INTP_FMT, *index, axis, max_item); } else { PyErr_Format(PyExc_IndexError, "index %"NPY_INTP_FMT" is out of bounds " "for size %"NPY_INTP_FMT, *index, max_item); } return -1; } /* adjust negative indices */ if (*index < 0) { *index += max_item; } return 0; } NPY_NO_EXPORT char * index2ptr(PyArrayObject *mp, npy_intp i) { npy_intp dim0; if (PyArray_NDIM(mp) == 0) { PyErr_SetString(PyExc_IndexError, "0-d arrays can't be indexed"); return NULL; } dim0 = PyArray_DIMS(mp)[0]; if (check_and_adjust_index(&i, dim0, 0) < 0) return NULL; if (i == 0) { return PyArray_DATA(mp); } return PyArray_BYTES(mp)+i*PyArray_STRIDES(mp)[0]; }
static CPyStreamWrapper* CPyStreamWrapper_New (PyObject *obj) { CPyStreamWrapper *wrapper; #ifdef WITH_THREAD PyInterpreterState* interp; PyThreadState* thread; #endif if (!obj) { PyErr_SetString (PyExc_ValueError, "obj must not be NULL"); return NULL; } wrapper = PyMem_New (CPyStreamWrapper, 1); if (!wrapper) return NULL; wrapper->read = NULL; wrapper->write = NULL; wrapper->seek = NULL; wrapper->tell = NULL; wrapper->close = NULL; #ifdef WITH_THREAD PyEval_InitThreads (); thread = PyThreadState_Get (); interp = thread->interp; wrapper->thread = PyThreadState_New (interp); #endif if (PyObject_HasAttrString (obj, "read")) { wrapper->read = PyObject_GetAttrString (obj, "read"); if (wrapper->read && !PyCallable_Check (wrapper->read)) { Py_DECREF (wrapper->read); wrapper->read = NULL; } } if (PyObject_HasAttrString (obj, "write")) { wrapper->write = PyObject_GetAttrString (obj, "write"); if (wrapper->write && !PyCallable_Check (wrapper->write)) { Py_DECREF (wrapper->write); wrapper->write = NULL; } } if (PyObject_HasAttrString (obj, "seek")) { wrapper->seek = PyObject_GetAttrString (obj, "seek"); if (wrapper->seek && !PyCallable_Check (wrapper->seek)) { Py_DECREF (wrapper->seek); wrapper->seek = NULL; } } if (PyObject_HasAttrString (obj, "tell")) { wrapper->tell = PyObject_GetAttrString (obj, "tell"); if (wrapper->tell && !PyCallable_Check (wrapper->tell)) { Py_DECREF (wrapper->tell); wrapper->tell = NULL; } } if (PyObject_HasAttrString (obj, "close")) { wrapper->close = PyObject_GetAttrString (obj, "close"); if (wrapper->close && !PyCallable_Check (wrapper->close)) { Py_DECREF (wrapper->close); wrapper->close = NULL; } } return wrapper; }
static void Object_beginTypeContext (JSOBJ _obj, JSONTypeContext *tc, JSONObjectEncoder *enc) { PyObject *obj, *objRepr, *exc; TypeContext *pc; PRINTMARK(); if (!_obj) { tc->type = JT_INVALID; return; } obj = (PyObject*) _obj; tc->prv = PyObject_Malloc(sizeof(TypeContext)); pc = (TypeContext *) tc->prv; if (!pc) { tc->type = JT_INVALID; PyErr_NoMemory(); return; } pc->newObj = NULL; pc->dictObj = NULL; pc->itemValue = NULL; pc->itemName = NULL; pc->iterator = NULL; pc->attrList = NULL; pc->index = 0; pc->size = 0; pc->longValue = 0; pc->rawJSONValue = NULL; if (PyIter_Check(obj)) { PRINTMARK(); goto ISITERABLE; } if (PyBool_Check(obj)) { PRINTMARK(); tc->type = (obj == Py_True) ? JT_TRUE : JT_FALSE; return; } else if (PyLong_Check(obj)) { PRINTMARK(); pc->PyTypeToJSON = PyLongToINT64; tc->type = JT_LONG; GET_TC(tc)->longValue = PyLong_AsLongLong(obj); exc = PyErr_Occurred(); if (!exc) { return; } if (exc && PyErr_ExceptionMatches(PyExc_OverflowError)) { PyErr_Clear(); pc->PyTypeToJSON = PyLongToUINT64; tc->type = JT_ULONG; GET_TC(tc)->unsignedLongValue = PyLong_AsUnsignedLongLong(obj); exc = PyErr_Occurred(); if (exc && PyErr_ExceptionMatches(PyExc_OverflowError)) { PRINTMARK(); goto INVALID; } } return; } else if (PyInt_Check(obj)) { PRINTMARK(); #ifdef _LP64 pc->PyTypeToJSON = PyIntToINT64; tc->type = JT_LONG; #else pc->PyTypeToJSON = PyIntToINT32; tc->type = JT_INT; #endif return; } else if (PyString_Check(obj)) { PRINTMARK(); pc->PyTypeToJSON = PyStringToUTF8; tc->type = JT_UTF8; return; } else if (PyUnicode_Check(obj)) { PRINTMARK(); pc->PyTypeToJSON = PyUnicodeToUTF8; tc->type = JT_UTF8; return; } else if (PyFloat_Check(obj) || (type_decimal && PyObject_IsInstance(obj, type_decimal))) { PRINTMARK(); pc->PyTypeToJSON = PyFloatToDOUBLE; tc->type = JT_DOUBLE; return; } else if (obj == Py_None) { PRINTMARK(); tc->type = JT_NULL; return; } ISITERABLE: if (PyDict_Check(obj)) { PRINTMARK(); tc->type = JT_OBJECT; SetupDictIter(obj, pc, enc); Py_INCREF(obj); return; } else if (PyList_Check(obj)) { PRINTMARK(); tc->type = JT_ARRAY; pc->iterEnd = List_iterEnd; pc->iterNext = List_iterNext; pc->iterGetValue = List_iterGetValue; pc->iterGetName = List_iterGetName; GET_TC(tc)->index = 0; GET_TC(tc)->size = PyList_GET_SIZE( (PyObject *) obj); return; } else if (PyTuple_Check(obj)) { PRINTMARK(); tc->type = JT_ARRAY; pc->iterEnd = Tuple_iterEnd; pc->iterNext = Tuple_iterNext; pc->iterGetValue = Tuple_iterGetValue; pc->iterGetName = Tuple_iterGetName; GET_TC(tc)->index = 0; GET_TC(tc)->size = PyTuple_GET_SIZE( (PyObject *) obj); GET_TC(tc)->itemValue = NULL; return; } if (UNLIKELY(PyObject_HasAttrString(obj, "toDict"))) { PyObject* toDictFunc = PyObject_GetAttrString(obj, "toDict"); PyObject* tuple = PyTuple_New(0); PyObject* toDictResult = PyObject_Call(toDictFunc, tuple, NULL); Py_DECREF(tuple); Py_DECREF(toDictFunc); if (toDictResult == NULL) { goto INVALID; } if (!PyDict_Check(toDictResult)) { Py_DECREF(toDictResult); tc->type = JT_NULL; return; } PRINTMARK(); tc->type = JT_OBJECT; SetupDictIter(toDictResult, pc, enc); return; } else if (UNLIKELY(PyObject_HasAttrString(obj, "__json__"))) { PyObject* toJSONFunc = PyObject_GetAttrString(obj, "__json__"); PyObject* tuple = PyTuple_New(0); PyObject* toJSONResult = PyObject_Call(toJSONFunc, tuple, NULL); Py_DECREF(tuple); Py_DECREF(toJSONFunc); if (toJSONResult == NULL) { goto INVALID; } if (PyErr_Occurred()) { Py_DECREF(toJSONResult); goto INVALID; } if (!PyString_Check(toJSONResult) && !PyUnicode_Check(toJSONResult)) { Py_DECREF(toJSONResult); PyErr_Format (PyExc_TypeError, "expected string"); goto INVALID; } PRINTMARK(); pc->PyTypeToJSON = PyRawJSONToUTF8; tc->type = JT_RAW; GET_TC(tc)->rawJSONValue = toJSONResult; return; } PRINTMARK(); PyErr_Clear(); objRepr = PyObject_Repr(obj); PyErr_Format (PyExc_TypeError, "%s is not JSON serializable", PyString_AS_STRING(objRepr)); Py_DECREF(objRepr); INVALID: PRINTMARK(); tc->type = JT_INVALID; PyObject_Free(tc->prv); tc->prv = NULL; return; }
void reportPythonError( const QString& moduleName ) { // Print the Error if ( PyErr_Occurred() ) { PyObject* exception,* value,* traceback; PyErr_Fetch( &exception, &value, &traceback ); PyErr_NormalizeException( &exception, &value, &traceback ); // Set sys. variables for exception tracking PySys_SetObject( "last_type", exception ); PySys_SetObject( "last_value", value ); PySys_SetObject( "last_traceback", traceback ); PyObject* exceptionName = PyObject_GetAttrString( exception, "__name__" ); // Do we have a detailed description of the error ? PyObject* error = value != 0 ? PyObject_Str( value ) : 0; if ( !error ) { if ( !moduleName.isNull() ) { Console::instance()->log( LOG_ERROR, QString( "An error occured while compiling \"%1\": %2" ).arg( moduleName ).arg( PyString_AsString( exceptionName ) ) ); } else { Console::instance()->log( LOG_ERROR, QString( "An error occured: %1" ).arg( PyString_AsString( exceptionName ) ) ); } } else { if ( !moduleName.isNull() ) { Console::instance()->log( LOG_ERROR, QString( "An error occured in \"%1\": %2" ).arg( moduleName ).arg( PyString_AsString( exceptionName ) ) ); } else { Console::instance()->log( LOG_ERROR, QString( "An error occured: %1" ).arg( PyString_AsString( exceptionName ) ) ); } Console::instance()->log( LOG_PYTHON, QString( "%1: %2" ).arg( PyString_AsString( exceptionName ) ).arg( PyString_AsString( error ) ), false ); Py_XDECREF( error ); } // Don't print a traceback for syntax errors if ( PyErr_GivenExceptionMatches( exception, PyExc_SyntaxError ) ) { Py_XDECREF( traceback ); traceback = 0; } // Dump a traceback while ( traceback ) { if ( !PyObject_HasAttrString( traceback, "tb_frame" ) ) break; PyObject* frame = PyObject_GetAttrString( traceback, "tb_frame" ); if ( !PyObject_HasAttrString( frame, "f_code" ) ) { Py_XDECREF( frame ); break; } PyObject* code = PyObject_GetAttrString( frame, "f_code" ); if ( !PyObject_HasAttrString( code, "co_filename" ) || !PyObject_HasAttrString( code, "co_name" ) ) { Py_XDECREF( frame ); Py_XDECREF( code ); break; } PyObject* pyFilename = PyObject_GetAttrString( code, "co_filename" ); PyObject* pyFunction = PyObject_GetAttrString( code, "co_name" ); QString filename = PyString_AsString( pyFilename ); QString function = PyString_AsString( pyFunction ); Py_XDECREF( pyFilename ); Py_XDECREF( pyFunction ); Py_XDECREF( code ); Py_XDECREF( frame ); PyObject* pyLine = PyObject_GetAttrString( traceback, "tb_lineno" ); unsigned int line = PyInt_AsLong( pyLine ); Py_XDECREF( pyLine ); // Print it Console::instance()->log( LOG_PYTHON, QString( "File '%1',%2 in '%3'" ).arg( filename ).arg( line ).arg( function ), false ); // Switch Frames PyObject* newtb = PyObject_GetAttrString( traceback, "tb_next" ); Py_XDECREF( traceback ); traceback = newtb; } Py_XDECREF( exceptionName ); Py_XDECREF( exception ); Py_XDECREF( value ); Py_XDECREF( traceback ); } }
/** ******************************************************************************************************* * This function invokes csdk's API to remove particular record. * * @param self AerospikeClient object * @param py_key The key under which to store the record * @param generation The generation value * @param py_policy The optional policy parameters * * Returns 0 on success. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************* */ PyObject * AerospikeClient_Remove_Invoke( AerospikeClient * self, PyObject * py_key, PyObject * py_meta, PyObject * py_policy) { // Aerospike Client Arguments as_error err; as_policy_remove remove_policy; as_policy_remove * remove_policy_p = NULL; as_key key; // Initialisation flags bool key_initialised = false; // Initialize error as_error_init(&err); if (!self || !self->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python key object to as_key pyobject_to_key(&err, py_key, &key); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } // Key is initialised successfully key_initialised = true; // Convert python policy object to as_policy_exists if (py_policy) { pyobject_to_policy_remove(&err, py_policy, &remove_policy, &remove_policy_p, &self->as->config.policies.remove); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } else { if ( py_meta && PyDict_Check(py_meta) ) { PyObject * py_gen = PyDict_GetItemString(py_meta, "gen"); if( py_gen != NULL ){ if ( PyInt_Check(py_gen) ) { remove_policy_p->generation = (uint16_t) PyInt_AsLong(py_gen); } else if ( PyLong_Check(py_gen) ) { remove_policy_p->generation = (uint16_t) PyLong_AsLongLong(py_gen); if((uint16_t)-1 == remove_policy_p->generation) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "integer value for gen exceeds sys.maxsize"); goto CLEANUP; } } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Generation should be an int or long"); } } } } } // Invoke operation aerospike_key_remove(self->as, &err, remove_policy_p, &key); if(err.code != AEROSPIKE_OK) { as_error_update(&err, err.code, NULL); } CLEANUP: if (key_initialised == true){ // Destroy the key if it is initialised successfully. as_key_destroy(&key); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL; error_to_pyobject(&err, &py_err); PyObject *exception_type = raise_exception(&err); if(PyObject_HasAttrString(exception_type, "key")) { PyObject_SetAttrString(exception_type, "key", py_key); } if(PyObject_HasAttrString(exception_type, "bin")) { PyObject_SetAttrString(exception_type, "bin", Py_None); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return PyLong_FromLong(0); }
/** ******************************************************************************************************* * This function applies a registered udf module on a particular record. * * @param self AerospikeClient object * @param py_key The key under which to store the record. * @param py_module The module name. * @param py_function The UDF function to be applied on a record. * @param py_arglist The arguments to the UDF function * @param py_policy The optional policy parameters * * Returns the result of UDF function. ******************************************************************************************************* */ PyObject * AerospikeClient_Apply_Invoke( AerospikeClient * self, PyObject * py_key, PyObject * py_module, PyObject * py_function, PyObject * py_arglist, PyObject * py_policy) { // Python Return Value PyObject * py_result = NULL; // Aerospike Client Arguments as_error err; as_policy_apply apply_policy; as_policy_apply * apply_policy_p = NULL; as_key key; char * module = NULL; char * function = NULL; as_list * arglist = NULL; as_val * result = NULL; PyObject * py_umodule = NULL; PyObject * py_ufunction = NULL; as_static_pool static_pool; memset(&static_pool, 0, sizeof(static_pool)); // Initialisation flags bool key_initialised = false; // Initialize error as_error_init(&err); if( !PyList_Check(py_arglist) ){ PyErr_SetString(PyExc_TypeError, "expected UDF method arguments in a 'list'"); return NULL; } if (!self || !self->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } self->is_client_put_serializer = false; // Convert python key object to as_key pyobject_to_key(&err, py_key, &key); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } // Key is initialiased successfully key_initialised = true; // Convert python list to as_list pyobject_to_list(self, &err, py_arglist, &arglist, &static_pool, SERIALIZER_PYTHON); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } if ( PyUnicode_Check(py_module) ){ py_umodule = PyUnicode_AsUTF8String(py_module); module = PyString_AsString(py_umodule); } else if ( PyString_Check(py_module) ) { module = PyString_AsString(py_module); } else { as_error_update(&err, AEROSPIKE_ERR_CLIENT, "udf module argument must be a string or unicode string"); goto CLEANUP; } if ( PyUnicode_Check(py_function) ){ py_ufunction = PyUnicode_AsUTF8String(py_function); function = PyString_AsString(py_ufunction); } else if ( PyString_Check(py_function) ) { function = PyString_AsString(py_function); } else { as_error_update(&err, AEROSPIKE_ERR_CLIENT, "function name must be a string or unicode string"); goto CLEANUP; } // Invoke operation aerospike_key_apply(self->as, &err, apply_policy_p, &key, module, function, arglist, &result); if ( err.code == AEROSPIKE_OK ) { val_to_pyobject(self, &err, result, &py_result); } else { as_error_update(&err, err.code, NULL); } CLEANUP: if (py_umodule) { Py_DECREF(py_umodule); } if (py_ufunction) { Py_DECREF(py_ufunction); } if (key_initialised == true){ // Destroy the key if it is initialised successfully. as_key_destroy(&key); } as_list_destroy(arglist); as_val_destroy(result); if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL; error_to_pyobject(&err, &py_err); PyObject *exception_type = raise_exception(&err); if(PyObject_HasAttrString(exception_type, "key")) { PyObject_SetAttrString(exception_type, "key", py_key); } if(PyObject_HasAttrString(exception_type, "bin")) { PyObject_SetAttrString(exception_type, "bin", Py_None); } if(PyObject_HasAttrString(exception_type, "module")) { PyObject_SetAttrString(exception_type, "module", py_module); } if(PyObject_HasAttrString(exception_type, "func")) { PyObject_SetAttrString(exception_type, "func", py_function); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return py_result; }
/* * Recursively examines the object to determine an appropriate dtype * to use for converting to an ndarray. * * 'obj' is the object to be converted to an ndarray. * * 'maxdims' is the maximum recursion depth. * * 'out_contains_na' gets set to 1 if an np.NA object is encountered. * The NA does not affect the dtype produced, so if this is set to 1 * and the result is for an array without NA support, the dtype should * be switched to NPY_OBJECT. When adding multi-NA support, this should * also signal whether just regular NAs or NAs with payloads were seen. * * 'out_dtype' should be either NULL or a minimal starting dtype when * the function is called. It is updated with the results of type * promotion. This dtype does not get updated when processing NA objects. * This is reset to NULL on failure. * * Returns 0 on success, -1 on failure. */ NPY_NO_EXPORT int PyArray_DTypeFromObject(PyObject *obj, int maxdims, int *out_contains_na, PyArray_Descr **out_dtype) { int i, size; PyArray_Descr *dtype = NULL; PyObject *ip; #if PY_VERSION_HEX >= 0x02060000 Py_buffer buffer_view; #endif /* Check if it's an ndarray */ if (PyArray_Check(obj)) { /* Check for any NAs in the array */ int containsna = PyArray_ContainsNA((PyArrayObject *)obj, NULL, NULL); if (containsna == -1) { goto fail; } else if (containsna) { *out_contains_na = 1; } dtype = PyArray_DESCR((PyArrayObject *)obj); Py_INCREF(dtype); goto promote_types; } /* Check if it's a NumPy scalar */ if (PyArray_IsScalar(obj, Generic)) { dtype = PyArray_DescrFromScalar(obj); if (dtype == NULL) { goto fail; } goto promote_types; } /* Check if it's a Python scalar */ dtype = _array_find_python_scalar_type(obj); if (dtype != NULL) { goto promote_types; } /* Check if it's an NA */ if (NpyNA_Check(obj)) { *out_contains_na = 1; return 0; } /* Check if it's an ASCII string */ if (PyBytes_Check(obj)) { int itemsize = PyString_GET_SIZE(obj); /* If it's already a big enough string, don't bother type promoting */ if (*out_dtype != NULL && (*out_dtype)->type_num == NPY_STRING && (*out_dtype)->elsize >= itemsize) { return 0; } dtype = PyArray_DescrNewFromType(NPY_STRING); if (dtype == NULL) { goto fail; } dtype->elsize = itemsize; goto promote_types; } /* Check if it's a Unicode string */ if (PyUnicode_Check(obj)) { int itemsize = PyUnicode_GET_DATA_SIZE(obj); #ifndef Py_UNICODE_WIDE itemsize <<= 1; #endif /* * If it's already a big enough unicode object, * don't bother type promoting */ if (*out_dtype != NULL && (*out_dtype)->type_num == NPY_UNICODE && (*out_dtype)->elsize >= itemsize) { return 0; } dtype = PyArray_DescrNewFromType(NPY_UNICODE); if (dtype == NULL) { goto fail; } dtype->elsize = itemsize; goto promote_types; } #if PY_VERSION_HEX >= 0x02060000 /* PEP 3118 buffer interface */ memset(&buffer_view, 0, sizeof(Py_buffer)); if (PyObject_GetBuffer(obj, &buffer_view, PyBUF_FORMAT|PyBUF_STRIDES) == 0 || PyObject_GetBuffer(obj, &buffer_view, PyBUF_FORMAT) == 0) { PyErr_Clear(); dtype = _descriptor_from_pep3118_format(buffer_view.format); PyBuffer_Release(&buffer_view); if (dtype) { goto promote_types; } } else if (PyObject_GetBuffer(obj, &buffer_view, PyBUF_STRIDES) == 0 || PyObject_GetBuffer(obj, &buffer_view, PyBUF_SIMPLE) == 0) { PyErr_Clear(); dtype = PyArray_DescrNewFromType(NPY_VOID); dtype->elsize = buffer_view.itemsize; PyBuffer_Release(&buffer_view); goto promote_types; } else { PyErr_Clear(); } #endif /* The array interface */ ip = PyObject_GetAttrString(obj, "__array_interface__"); if (ip != NULL) { if (PyDict_Check(ip)) { PyObject *typestr; typestr = PyDict_GetItemString(ip, "typestr"); if (typestr && PyString_Check(typestr)) { dtype =_array_typedescr_fromstr(PyString_AS_STRING(typestr)); Py_DECREF(ip); if (dtype == NULL) { goto fail; } goto promote_types; } } Py_DECREF(ip); } else { PyErr_Clear(); } /* The array struct interface */ ip = PyObject_GetAttrString(obj, "__array_struct__"); if (ip != NULL) { PyArrayInterface *inter; char buf[40]; if (NpyCapsule_Check(ip)) { inter = (PyArrayInterface *)NpyCapsule_AsVoidPtr(ip); if (inter->two == 2) { PyOS_snprintf(buf, sizeof(buf), "|%c%d", inter->typekind, inter->itemsize); dtype = _array_typedescr_fromstr(buf); Py_DECREF(ip); if (dtype == NULL) { goto fail; } goto promote_types; } } Py_DECREF(ip); } else { PyErr_Clear(); } /* The old buffer interface */ #if !defined(NPY_PY3K) if (PyBuffer_Check(obj)) { dtype = PyArray_DescrNewFromType(NPY_VOID); if (dtype == NULL) { goto fail; } dtype->elsize = Py_TYPE(obj)->tp_as_sequence->sq_length(obj); PyErr_Clear(); goto promote_types; } #endif /* The __array__ attribute */ if (PyObject_HasAttrString(obj, "__array__")) { ip = PyObject_CallMethod(obj, "__array__", NULL); if(ip && PyArray_Check(ip)) { dtype = PyArray_DESCR((PyArrayObject *)ip); Py_INCREF(dtype); Py_DECREF(ip); goto promote_types; } Py_XDECREF(ip); if (PyErr_Occurred()) { goto fail; } } /* Not exactly sure what this is about... */ #if !defined(NPY_PY3K) if (PyInstance_Check(obj)) { dtype = _use_default_type(obj); if (dtype == NULL) { goto fail; } else { goto promote_types; } } #endif /* * If we reached the maximum recursion depth without hitting one * of the above cases, the output dtype should be OBJECT */ if (maxdims == 0 || !PySequence_Check(obj)) { if (*out_dtype == NULL || (*out_dtype)->type_num != NPY_OBJECT) { Py_XDECREF(*out_dtype); *out_dtype = PyArray_DescrFromType(NPY_OBJECT); if (*out_dtype == NULL) { return -1; } } return 0; } /* Recursive case */ size = PySequence_Size(obj); if (size < 0) { goto fail; } /* Recursive call for each sequence item */ for (i = 0; i < size; ++i) { ip = PySequence_GetItem(obj, i); if (ip==NULL) { goto fail; } if (PyArray_DTypeFromObject(ip, maxdims - 1, out_contains_na, out_dtype) < 0) { Py_DECREF(ip); goto fail; } Py_DECREF(ip); } return 0; promote_types: /* Set 'out_dtype' if it's NULL */ if (*out_dtype == NULL) { *out_dtype = dtype; return 0; } /* Do type promotion with 'out_dtype' */ else { PyArray_Descr *res_dtype = PyArray_PromoteTypes(dtype, *out_dtype); Py_DECREF(dtype); if (res_dtype == NULL) { return -1; } Py_DECREF(*out_dtype); *out_dtype = res_dtype; return 0; } fail: Py_XDECREF(*out_dtype); *out_dtype = NULL; return -1; }
/** ******************************************************************************************************* * This function applies a registered udf module on a particular record. * * @param self AerospikeClient object * @param py_key The key under which the record is stored. * @param py_policy The dictionary of policies * * Returns a tuple of record having key and meta sequentially. ******************************************************************************************************* */ extern PyObject * AerospikeClient_Exists_Invoke( AerospikeClient * self, PyObject * py_key, PyObject * py_policy) { // Python Return Value PyObject * py_result = NULL; // Aerospike Client Arguments as_error err; as_policy_read read_policy; as_policy_read * read_policy_p = NULL; as_key key; as_record * rec = NULL; // Initialisation flags bool key_initialised = false; // Initialize error as_error_init(&err); if (!self || !self->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python key object to as_key pyobject_to_key(&err, py_key, &key); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } // key is initialised successfully key_initialised = true; // Convert python policy object to as_policy_exists pyobject_to_policy_read(&err, py_policy, &read_policy, &read_policy_p, &self->as->config.policies.read); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } // Invoke operation aerospike_key_exists(self->as, &err, read_policy_p, &key, &rec); if ( err.code == AEROSPIKE_OK ) { PyObject * py_result_key = NULL; PyObject * py_result_meta = NULL; key_to_pyobject(&err, &key, &py_result_key); metadata_to_pyobject(&err, rec, &py_result_meta); py_result = PyTuple_New(2); PyTuple_SetItem(py_result, 0, py_result_key); PyTuple_SetItem(py_result, 1, py_result_meta); } else if( err.code == AEROSPIKE_ERR_RECORD_NOT_FOUND ) { as_error_reset(&err); PyObject * py_result_key = NULL; PyObject * py_result_meta = Py_None; key_to_pyobject(&err, &key, &py_result_key); py_result = PyTuple_New(2); PyTuple_SetItem(py_result, 0, py_result_key); PyTuple_SetItem(py_result, 1, py_result_meta); Py_INCREF(py_result_meta); } else { as_error_update(&err, err.code, NULL); } CLEANUP: if (key_initialised == true){ // Destroy the key if it is initialised successfully. as_key_destroy(&key); } as_record_destroy(rec); if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL; error_to_pyobject(&err, &py_err); PyObject *exception_type = raise_exception(&err); if(PyObject_HasAttrString(exception_type, "key")) { PyObject_SetAttrString(exception_type, "key", py_key); } if(PyObject_HasAttrString(exception_type, "bin")) { PyObject_SetAttrString(exception_type, "bin", Py_None); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); } return py_result; }
/** ******************************************************************************************************** * Select values from a begin key to end key corresponding to a value up to a maximum count applying a lua filter. * * @param self AerospikeLList object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns a list of ldt contents. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************** */ PyObject * AerospikeLList_Range_Limit(AerospikeLList * self, PyObject * args, PyObject * kwds) { char* filter_name = NULL; PyObject* py_count = NULL; PyObject * py_args = NULL; PyObject* py_policy = NULL; PyObject* py_from_value = NULL; PyObject* py_end_value = NULL; PyObject* py_elements_list = NULL; PyObject* py_filter_name = NULL; as_policy_apply apply_policy; as_policy_apply* apply_policy_p = NULL; as_list* arg_list = NULL; as_list* elements_list = NULL; as_val* from_val = NULL; as_val* end_val = NULL; as_static_pool static_pool; memset(&static_pool, 0, sizeof(static_pool)); as_error err; as_error_init(&err); static char * kwlist[] = {"start_value", "end_value", "count", "function", "args", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "OOO|OOO:range_limit", kwlist, &py_from_value, &py_end_value, &py_count, &py_filter_name, &py_args, &py_policy)== false ) { return NULL; } if (!self || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->client->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } uint32_t count = 0; if (PyInt_Check(py_count)) { count = PyInt_AsLong(py_count); } else if (PyLong_Check(py_count)) { count = PyLong_AsLong(py_count); if (count == (uint32_t)-1 && PyErr_Occurred()) { if (PyErr_ExceptionMatches(PyExc_OverflowError)) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize"); goto CLEANUP; } } } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Count should be an integer or long"); goto CLEANUP; } if(py_filter_name) { if(PyStr_Check(py_filter_name)) { filter_name = PyStr_AsString(py_filter_name); } else if(py_filter_name != Py_None) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filter name should be string or None"); goto CLEANUP; } } if ( py_args && !py_filter_name) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filter arguments without filter name"); goto CLEANUP; } if ( !PyList_Check(py_args) && (py_args != Py_None)) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid filter argument(type)"); goto CLEANUP; } if (py_args != Py_None) { pyobject_to_list(self->client, &err, py_args, &arg_list, &static_pool, SERIALIZER_PYTHON); } if( py_from_value != Py_None && py_end_value != Py_None ) { pyobject_to_val(self->client, &err, py_from_value, &from_val, &static_pool, SERIALIZER_PYTHON); pyobject_to_val(self->client, &err, py_end_value, &end_val, &static_pool, SERIALIZER_PYTHON); } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Begin or end key cannot be None"); goto CLEANUP; } Py_BEGIN_ALLOW_THREADS aerospike_llist_range_limit(self->client->as, &err, apply_policy_p, &self->key, &self->llist, from_val, end_val, count, filter_name, arg_list, &elements_list); Py_END_ALLOW_THREADS if(err.code != AEROSPIKE_OK) { goto CLEANUP; } list_to_pyobject(self->client, &err, elements_list, &py_elements_list); CLEANUP: if (elements_list) { as_list_destroy(elements_list); } if(from_val) { as_val_destroy(from_val); } if(end_val) { as_val_destroy(end_val); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL, *py_key = NULL; PyObject *exception_type = raise_exception(&err); error_to_pyobject(&err, &py_err); if (PyObject_HasAttrString(exception_type, "key")) { key_to_pyobject(&err, &self->key, &py_key); PyObject_SetAttrString(exception_type, "key", py_key); Py_DECREF(py_key); } if (PyObject_HasAttrString(exception_type, "bin")) { PyObject *py_bins = PyStr_FromString((char *)&self->bin_name); PyObject_SetAttrString(exception_type, "bin", py_bins); Py_DECREF(py_bins); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return py_elements_list; }
PyObject* objToJSONFile(PyObject* self, PyObject *args, PyObject *kwargs) { PyObject *data; PyObject *file; PyObject *string; PyObject *write; PyObject *argtuple; PRINTMARK(); if (!PyArg_ParseTuple (args, "OO", &data, &file)) { return NULL; } if (!PyObject_HasAttrString (file, "write")) { PyErr_Format (PyExc_TypeError, "expected file"); return NULL; } write = PyObject_GetAttrString (file, "write"); if (!PyCallable_Check (write)) { Py_XDECREF(write); PyErr_Format (PyExc_TypeError, "expected file"); return NULL; } argtuple = PyTuple_Pack(1, data); string = objToJSON (self, argtuple, kwargs); if (string == NULL) { Py_XDECREF(write); Py_XDECREF(argtuple); return NULL; } Py_XDECREF(argtuple); argtuple = PyTuple_Pack (1, string); if (argtuple == NULL) { Py_XDECREF(write); return NULL; } if (PyObject_CallObject (write, argtuple) == NULL) { Py_XDECREF(write); Py_XDECREF(argtuple); return NULL; } Py_XDECREF(write); Py_DECREF(argtuple); Py_XDECREF(string); PRINTMARK(); Py_RETURN_NONE; }
/** ******************************************************************************************************** * Scan the list and apply a predicate filter. * * @param self AerospikeLList object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns a list of elements from the list after applying predicate. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************** */ PyObject * AerospikeLList_Filter(AerospikeLList * self, PyObject * args, PyObject * kwds) { char* filter_name = NULL; PyObject * py_args = NULL; PyObject* py_policy = NULL; as_policy_apply apply_policy; as_policy_apply* apply_policy_p = NULL; as_list* arg_list = NULL; as_list* elements_list = NULL; as_static_pool static_pool; memset(&static_pool, 0, sizeof(static_pool)); as_error err; as_error_init(&err); static char * kwlist[] = {"function", "args", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "|sOO:filter", kwlist, &filter_name, &py_args, &py_policy) == false ) { return NULL; } if (!self || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->client->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } if ( py_args && !filter_name) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filter arguments without filter name"); goto CLEANUP; } if ( py_args && !PyList_Check(py_args)) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid filter argument(type)"); goto CLEANUP; } if (py_args) { pyobject_to_list(self->client, &err, py_args, &arg_list, &static_pool, SERIALIZER_PYTHON); } Py_BEGIN_ALLOW_THREADS aerospike_llist_filter(self->client->as, &err, apply_policy_p, &self->key, &self->llist, filter_name, arg_list, &elements_list); Py_END_ALLOW_THREADS if (err.code != AEROSPIKE_OK) { as_error_update(&err, err.code, NULL); goto CLEANUP; } PyObject* py_list = NULL; list_to_pyobject(self->client, &err, elements_list, &py_list); CLEANUP: if (elements_list) { as_list_destroy(elements_list); } if (arg_list) { as_list_destroy(arg_list); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL, *py_key = NULL; PyObject *exception_type = raise_exception(&err); error_to_pyobject(&err, &py_err); if(PyObject_HasAttrString(exception_type, "key")) { key_to_pyobject(&err, &self->key, &py_key); PyObject_SetAttrString(exception_type, "key", py_key); Py_DECREF(py_key); } if(PyObject_HasAttrString(exception_type, "bin")) { PyObject *py_bins = PyStr_FromString((char *)&self->bin_name); PyObject_SetAttrString(exception_type, "bin", py_bins); Py_DECREF(py_bins); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return py_list; }
PyObject * AerospikeQuery_Foreach(AerospikeQuery * self, PyObject * args, PyObject * kwds) { // Python Function Arguments PyObject * py_callback = NULL; PyObject * py_policy = NULL; // Python Function Keyword Arguments static char * kwlist[] = {"callback", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|O:foreach", kwlist, &py_callback, &py_policy) == false ) { as_query_destroy(&self->query); return NULL; } // Initialize callback user data LocalData data; data.callback = py_callback; data.client = self->client; as_error_init(&data.error); // Aerospike Client Arguments as_error err; as_policy_query query_policy; as_policy_query * query_policy_p = NULL; // Initialize error as_error_init(&err); if (!self || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_exists pyobject_to_policy_query(&err, py_policy, &query_policy, &query_policy_p, &self->client->as->config.policies.query); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } // We are spawning multiple threads PyThreadState * _save = PyEval_SaveThread(); // Invoke operation aerospike_query_foreach(self->client->as, &err, query_policy_p, &self->query, each_result, &data); // We are done using multiple threads PyEval_RestoreThread(_save); if (data.error.code != AEROSPIKE_OK) { as_error_update(&data.error, data.error.code, NULL); goto CLEANUP; } CLEANUP: if ( self->query.apply.arglist ){ as_arraylist_destroy( (as_arraylist *) self->query.apply.arglist ); } self->query.apply.arglist = NULL; if ( err.code != AEROSPIKE_OK || data.error.code != AEROSPIKE_OK ) { PyObject * py_err = NULL; PyObject *exception_type = NULL; if ( err.code != AEROSPIKE_OK ){ error_to_pyobject(&err, &py_err); exception_type = raise_exception(&err); } if ( data.error.code != AEROSPIKE_OK ){ error_to_pyobject(&data.error, &py_err); exception_type = raise_exception(&data.error); } if(PyObject_HasAttrString(exception_type, "name")) { PyObject_SetAttrString(exception_type, "name", Py_None); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } Py_INCREF(Py_None); return Py_None; }
/** ******************************************************************************************************** * Add an object to the list. * * @param self AerospikeLList object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns an integer status. 0(Zero) is success value. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************** */ PyObject * AerospikeLList_Add(AerospikeLList * self, PyObject * args, PyObject * kwds) { PyObject* py_value = NULL; PyObject* py_policy = NULL; as_policy_apply apply_policy; as_policy_apply* apply_policy_p = NULL; as_val * val = NULL; as_static_pool static_pool; memset(&static_pool, 0, sizeof(static_pool)); as_error err; as_error_init(&err); static char * kwlist[] = {"element", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|O:add", kwlist, &py_value, &py_policy) == false ) { return NULL; } if (!self || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->client->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } pyobject_to_val(self->client, &err, py_value, &val, &static_pool, SERIALIZER_PYTHON); if (err.code != AEROSPIKE_OK) { goto CLEANUP; } Py_BEGIN_ALLOW_THREADS aerospike_llist_add(self->client->as, &err, apply_policy_p, &self->key, &self->llist, val); Py_END_ALLOW_THREADS if(err.code != AEROSPIKE_OK) { as_error_update(&err, err.code, NULL); } CLEANUP: if (val) { as_val_destroy(val); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL, *py_key = NULL; PyObject *exception_type = raise_exception(&err); error_to_pyobject(&err, &py_err); if(PyObject_HasAttrString(exception_type, "key")) { key_to_pyobject(&err, &self->key, &py_key); PyObject_SetAttrString(exception_type, "key", py_key); Py_DECREF(py_key); } if(PyObject_HasAttrString(exception_type, "bin")) { PyObject *py_bins = PyStr_FromString((char *)&self->bin_name); PyObject_SetAttrString(exception_type, "bin", py_bins); Py_DECREF(py_bins); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return PyLong_FromLong(0); }
//! Executes given method of app/model int py_execute(const char *app, const char *model, const char *method, PyObject *py_args, PyObject **py_ret) { /*! * Loads app/model.py and calls method with given arguments. If app or module is null, this * function will execute specified method on CORE module. * * @app Application * @model Model * @method Method * @py_args Arguments * @py_ret Pointer to returned value * @return 0 on success, -1 on missing file, -2 on Python error, -3 on access denied, -4 on PolicyKit error * */ PyObject *py_mod_script, *py_mod_builtin; PyObject *py_dict_script, *py_dict_builtin; PyObject *py_code, *py_method_code, *py_kwargs, *py_func = NULL; PyMethodDef *py_method; PyObject *py_module, *py_dict, *py_list; PyObject *py_dict_core; PyObject *py_mod_core; // Add core module directory to sys.path py_module = PyImport_ImportModule("sys"); py_dict = PyModule_GetDict(py_module); py_list = PyDict_GetItemString(py_dict, "path"); PyList_Insert(py_list, 0, PyString_FromString(config_dir_modules)); // Put CSL methods into __builtin__ py_mod_builtin = PyImport_AddModule("__builtin__"); py_dict_builtin = PyModule_GetDict(py_mod_builtin); for (py_method = methods; py_method->ml_name; py_method++) { py_method_code = PyCFunction_New(py_method, NULL); PyDict_SetItemString(py_dict_builtin, py_method->ml_name, py_method_code); } // If model and application name given, try to execute method on registered script if (model != NULL && app != NULL) { // Import script int size = strlen(config_dir_scripts) + 1 + strlen(model) + 1 + strlen(app) + 3 + 1; char *fn_script = malloc(size); if (fn_script == NULL) oom(); snprintf(fn_script, size, "%s/%s/%s.py", config_dir_scripts, model, app); fn_script[size - 1] = 0; // Check script existance if (access(fn_script, R_OK) != 0) { log_error("Unable to find script: %s\n", fn_script); PyErr_Format(PyExc_COMAR_Internal, "Unable to find '%s'", fn_script); free(fn_script); return -1; } // Load script file char *code = load_file(fn_script, NULL); if (!code) { log_error("Unable to read script: %s\n", fn_script); PyErr_Format(PyExc_COMAR_Internal, "Unable to read '%s'", fn_script); free(fn_script); return -1; } // Compile script py_code = Py_CompileString(code, fn_script, Py_file_input); free(code); if (!py_code) { log_error("Unable to compile script: %s\n", fn_script); free(fn_script); return -2; } // Import script as "csl" module py_mod_script = PyImport_ExecCodeModule("csl", py_code); if (!py_mod_script) { log_error("Unable to exec code module script: %s\n", fn_script); free(fn_script); return -2; } free(fn_script); // Look for 'method()' in script py_dict_script = PyModule_GetDict(py_mod_script); py_func = PyDict_GetItemString(py_dict_script, method); } // Else, execute method on core module else { // Import core module py_mod_core = PyImport_ImportModule("core"); if (!py_mod_core) { log_error("Unable to import core module.\n"); return -2; } // Look for 'method()' in script py_dict_core = PyModule_GetDict(py_mod_core); py_func = PyDict_GetItemString(py_dict_core, method); } // Finally, run method if (!py_func) { if (config_ignore_missing) { Py_INCREF(Py_None); *py_ret = Py_None; } else { PyErr_Format(PyExc_COMAR_Missing, "Method '%s' is not defined in script", method); return -2; } } else if (!PyCallable_Check(py_func)) { PyErr_Format(PyExc_COMAR_Script, "Method '%s' is not callable in script", method); return -2; } else { // Check if PolicyKit action defined at runtime if (PyObject_HasAttrString(py_func, "policy_action_id")) { const char *action_id = PyString_AsString(PyObject_GetAttrString(py_func, "policy_action_id")); const char *sender = dbus_message_get_sender(my_proc.bus_msg); PolKitResult result; if (policy_check(sender, action_id, &result) == 0) { if (result != POLKIT_RESULT_YES) { PyErr_Format(PyExc_PolicyKit, action_id); return -3; } } else { PyErr_Format(PyExc_PolicyKit, "error"); return -4; } } py_kwargs = PyDict_New(); *py_ret = PyObject_Call(py_func, py_args, py_kwargs); if (!*py_ret) { return -2; } } return 0; }
/** ******************************************************************************************************** * Get the current item count of the list. * * @param self AerospikeLList object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns the size of list. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************** */ PyObject * AerospikeLList_Size(AerospikeLList * self, PyObject * args, PyObject * kwds) { long size = 0; PyObject* py_policy = NULL; as_policy_apply apply_policy; as_policy_apply* apply_policy_p = NULL; as_error err; as_error_init(&err); static char * kwlist[] = {"policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "|O:size", kwlist, &py_policy) == false ) { return NULL; } if (!self || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->client->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { as_error_update(&err, err.code, NULL); goto CLEANUP; } Py_BEGIN_ALLOW_THREADS aerospike_llist_size(self->client->as, &err, apply_policy_p, &self->key, &self->llist, (uint32_t *)&size); Py_END_ALLOW_THREADS CLEANUP: if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL, *py_key = NULL; PyObject *exception_type = raise_exception(&err); error_to_pyobject(&err, &py_err); if(PyObject_HasAttrString(exception_type, "key")) { key_to_pyobject(&err, &self->key, &py_key); PyObject_SetAttrString(exception_type, "key", py_key); Py_DECREF(py_key); } if(PyObject_HasAttrString(exception_type, "bin")) { PyObject *py_bins = PyStr_FromString((char *)&self->bin_name); PyObject_SetAttrString(exception_type, "bin", py_bins); Py_DECREF(py_bins); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return PyLong_FromLong(size); }
static PyObject * growl_PostDictionary(CFStringRef name, PyObject *self, PyObject *args) { int i, j; PyObject *inputDict; PyObject *pKeys = NULL; PyObject *pKey, *pValue; CFMutableDictionaryRef note = CFDictionaryCreateMutable(kCFAllocatorDefault, /*capacity*/ 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &inputDict)) goto error; pKeys = PyDict_Keys(inputDict); for (i = 0; i < PyList_Size(pKeys); ++i) { CFStringRef convertedKey; /* Converting the PyDict key to NSString and used for key in note */ pKey = PyList_GetItem(pKeys, i); if (!pKey) // Exception already set goto error; pValue = PyDict_GetItem(inputDict, pKey); if (!pValue) { // XXX Neeed a real Error message here. PyErr_SetString(PyExc_TypeError," "); goto error; } if (PyUnicode_Check(pKey)) { convertedKey = CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8 *)PyUnicode_AS_DATA(pKey), PyUnicode_GET_DATA_SIZE(pKey), kCFStringEncodingUnicode, false); } else if (PyString_Check(pKey)) { convertedKey = CFStringCreateWithCString(kCFAllocatorDefault, PyString_AsString(pKey), kCFStringEncodingUTF8); } else { PyErr_SetString(PyExc_TypeError,"The Dict keys must be strings/unicode"); goto error; } /* Converting the PyDict value to NSString or NSData based on class */ if (PyString_Check(pValue)) { CFStringRef convertedValue = CFStringCreateWithCString(kCFAllocatorDefault, PyString_AS_STRING(pValue), kCFStringEncodingUTF8); CFDictionarySetValue(note, convertedKey, convertedValue); CFRelease(convertedValue); } else if (PyUnicode_Check(pValue)) { CFStringRef convertedValue = CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8 *)PyUnicode_AS_DATA(pValue), PyUnicode_GET_DATA_SIZE(pValue), kCFStringEncodingUnicode, false); CFDictionarySetValue(note, convertedKey, convertedValue); CFRelease(convertedValue); } else if (PyInt_Check(pValue)) { long v = PyInt_AS_LONG(pValue); CFNumberRef convertedValue = CFNumberCreate(kCFAllocatorDefault, kCFNumberLongType, &v); CFDictionarySetValue(note, convertedKey, convertedValue); CFRelease(convertedValue); } else if (pValue == Py_None) { CFDataRef convertedValue = CFDataCreate(kCFAllocatorDefault, NULL, 0); CFDictionarySetValue(note, convertedKey, convertedValue); CFRelease(convertedValue); } else if (PyList_Check(pValue)) { int size = PyList_Size(pValue); CFMutableArrayRef listHolder = CFArrayCreateMutable(kCFAllocatorDefault, size, &kCFTypeArrayCallBacks); for (j = 0; j < size; ++j) { PyObject *lValue = PyList_GetItem(pValue, j); if (PyString_Check(lValue)) { CFStringRef convertedValue = CFStringCreateWithCString(kCFAllocatorDefault, PyString_AS_STRING(lValue), kCFStringEncodingUTF8); CFArrayAppendValue(listHolder, convertedValue); CFRelease(convertedValue); } else if (PyUnicode_Check(lValue)) { CFStringRef convertedValue = CFStringCreateWithBytes(kCFAllocatorDefault, (const UInt8 *)PyUnicode_AS_DATA(lValue), PyUnicode_GET_DATA_SIZE(lValue), kCFStringEncodingUnicode, false); CFArrayAppendValue(listHolder, convertedValue); CFRelease(convertedValue); } else { CFRelease(convertedKey); PyErr_SetString(PyExc_TypeError,"The lists must only contain strings"); goto error; } } CFDictionarySetValue(note, convertedKey, listHolder); CFRelease(listHolder); } else if (PyObject_HasAttrString(pValue, "rawImageData")) { PyObject *lValue = PyObject_GetAttrString(pValue, "rawImageData"); if (!lValue) { goto error; } else if (PyString_Check(lValue)) { CFDataRef convertedValue = CFDataCreate(kCFAllocatorDefault, (const UInt8 *)PyString_AsString(lValue), PyString_Size(lValue)); CFDictionarySetValue(note, convertedKey, convertedValue); CFRelease(convertedValue); } else { CFRelease(convertedKey); PyErr_SetString(PyExc_TypeError, "Icon with rawImageData attribute present must ensure it is a string."); goto error; } } else { CFRelease(convertedKey); PyErr_SetString(PyExc_TypeError, "Value is not of Str/List"); goto error; } CFRelease(convertedKey); } Py_BEGIN_ALLOW_THREADS CFNotificationCenterPostNotification(CFNotificationCenterGetDistributedCenter(), /*name*/ name, /*object*/ NULL, /*userInfo*/ note, /*deliverImmediately*/ false); CFRelease(note); Py_END_ALLOW_THREADS Py_DECREF(pKeys); Py_INCREF(Py_None); return Py_None; error: CFRelease(note); Py_XDECREF(pKeys); return NULL; }
/** ******************************************************************************************************** * Select values from the end of list up to a maximum count. * * @param self AerospikeLList object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns a list of ldt contents. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************** */ PyObject * AerospikeLList_Find_Last(AerospikeLList * self, PyObject * args, PyObject * kwds) { PyObject* py_count = NULL; PyObject* py_policy = NULL; PyObject* py_elements_list = NULL; as_policy_apply apply_policy; as_policy_apply* apply_policy_p = NULL; as_list* elements_list = NULL; as_static_pool static_pool; memset(&static_pool, 0, sizeof(static_pool)); as_error err; as_error_init(&err); static char * kwlist[] = {"count", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|O:find_last", kwlist, &py_count, &py_policy)== false ) { return NULL; } if (!self || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->client->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } uint32_t count = 0; if ( PyInt_Check(py_count)) { count = PyInt_AsLong(py_count); } else if( PyLong_Check(py_count) ) { count = PyLong_AsLong(py_count); if (count == (uint32_t)-1 && PyErr_Occurred()) { if (PyErr_ExceptionMatches(PyExc_OverflowError)) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize"); goto CLEANUP; } } } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Count should be an integer or long"); goto CLEANUP; } Py_BEGIN_ALLOW_THREADS aerospike_llist_find_last(self->client->as, &err, apply_policy_p, &self->key, &self->llist, count, &elements_list); Py_END_ALLOW_THREADS if(err.code != AEROSPIKE_OK) { goto CLEANUP; } list_to_pyobject(self->client, &err, elements_list, &py_elements_list); CLEANUP: if (elements_list) { as_list_destroy(elements_list); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL, *py_key = NULL; PyObject *exception_type = raise_exception(&err); error_to_pyobject(&err, &py_err); if (PyObject_HasAttrString(exception_type, "key")) { key_to_pyobject(&err, &self->key, &py_key); PyObject_SetAttrString(exception_type, "key", py_key); Py_DECREF(py_key); } if (PyObject_HasAttrString(exception_type, "bin")) { PyObject *py_bins = PyStr_FromString((char *)&self->bin_name); PyObject_SetAttrString(exception_type, "bin", py_bins); Py_DECREF(py_bins); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return py_elements_list; }
/** ******************************************************************************************************* * Multiple operations on a single record * * @param self AerospikeClient object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns tuple of bins on success if read operation is given. * Otherwise returns 0 on success for other operations. ******************************************************************************************************* */ PyObject * AerospikeClient_Operate(AerospikeClient * self, PyObject * args, PyObject * kwds) { // Initialize error as_error err; as_error_init(&err); // Python Function Arguments PyObject * py_key = NULL; PyObject * py_list = NULL; PyObject * py_policy = NULL; PyObject * py_result = NULL; PyObject * py_meta = NULL; as_key key; as_policy_operate operate_policy; as_policy_operate *operate_policy_p = NULL; // Python Function Keyword Arguments static char * kwlist[] = {"key", "list", "meta", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO:operate", kwlist, &py_key, &py_list, &py_meta, &py_policy) == false ) { return NULL; } if (!self || !self->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } py_result = AerospikeClient_convert_pythonObj_to_asType(self, &err, py_key, py_policy, &key, &operate_policy, &operate_policy_p); if (!py_result) { goto CLEANUP; } else { Py_DECREF(py_result); } if ( py_list != NULL && PyList_Check(py_list) ) { py_result = AerospikeClient_Operate_Invoke(self, &err, &key, py_list, py_meta, operate_policy_p); } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Operations should be of type list"); goto CLEANUP; } CLEANUP: if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL; error_to_pyobject(&err, &py_err); PyObject *exception_type = raise_exception(&err); if(PyObject_HasAttrString(exception_type, "key")) { PyObject_SetAttrString(exception_type, "key", py_key); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return py_result; }
void *uwsgi_python_autoreloader_thread(void *foobar) { PyObject *new_thread = uwsgi_python_setup_thread("uWSGIAutoReloader"); if (!new_thread) return NULL; PyObject *modules = PyImport_GetModuleDict(); if (uwsgi.mywid == 1) { uwsgi_log("Python auto-reloader enabled\n"); } PyObject *times_dict = PyDict_New(); char *filename; for(;;) { UWSGI_RELEASE_GIL; sleep(up.auto_reload); UWSGI_GET_GIL; // do not start monitoring til the first app is loaded (required for lazy mode) if (uwsgi_apps_cnt == 0) continue; #ifdef UWSGI_PYTHON_OLD int pos = 0; #else Py_ssize_t pos = 0; #endif PyObject *mod_name, *mod; while (PyDict_Next(modules, &pos, &mod_name, &mod)) { int found = 0; struct uwsgi_string_list *usl = up.auto_reload_ignore; while(usl) { if (!strcmp(usl->value, PyString_AsString(mod_name))) { found = 1; break; } usl = usl->next; } if (found) continue; if (!PyObject_HasAttrString(mod, "__file__")) continue; PyObject *mod_file = PyObject_GetAttrString(mod, "__file__"); if (!mod_file) continue; #ifdef PYTHREE PyObject *zero = PyUnicode_AsUTF8String(mod_file); char *mod_filename = PyString_AsString(zero); #else char *mod_filename = PyString_AsString(mod_file); #endif if (!mod_filename) { #ifdef PYTHREE Py_DECREF(zero); #endif continue; } char *ext = strrchr(mod_filename, '.'); if (ext && (!strcmp(ext+1, "pyc") || !strcmp(ext+1, "pyd") || !strcmp(ext+1, "pyo"))) { filename = uwsgi_concat2n(mod_filename, strlen(mod_filename)-1, "", 0); } else { filename = uwsgi_concat2(mod_filename, ""); } if (uwsgi_check_python_mtime(times_dict, filename)) { UWSGI_RELEASE_GIL; return NULL; } free(filename); #ifdef PYTHREE Py_DECREF(zero); #endif } } return NULL; }