static PyObject * python_orblag( PyObject *self, PyObject *args ) { char *usage = "Usage: _orblag(orb, match, reject)\n"; int orbfd; char *match = 0; char *reject = 0; char err[STRSZ]; double rc; int ilaggard; int nlaggards; ClientLag *cl = 0; Laggards *laggards = 0; PyObject *laggards_obj; PyObject *clientlag_obj; PyObject *obj; if( ! PyArg_ParseTuple( args, "izz", &orbfd, &match, &reject) ) { if( ! PyErr_Occurred() ) { PyErr_SetString( PyExc_RuntimeError, usage ); } return NULL; } rc = orblag( orbfd, match, reject, &laggards ); if( rc < 0 ) { sprintf( err, "Error: orblag returned %f\n", rc ); PyErr_SetString( PyExc_RuntimeError, err ); return NULL; } nlaggards = maxtbl( laggards->list ); laggards_obj = PyTuple_New( nlaggards ); for( ilaggard = 0; ilaggard < nlaggards; ilaggard++ ) { cl = gettbl( laggards->list, ilaggard ); clientlag_obj = PyTuple_New( 5 ); PyTuple_SetItem( clientlag_obj, 0, PyFloat_FromDouble( cl->lag ) ); PyTuple_SetItem( clientlag_obj, 1, PyInt_FromLong( (long) cl->thread ) ); PyTuple_SetItem( clientlag_obj, 2, PyInt_FromLong( (long) cl->pktid ) ); PyTuple_SetItem( clientlag_obj, 3, PyString_FromString( cl->who ) ); PyTuple_SetItem( clientlag_obj, 4, PyString_FromString( cl->what ) ); PyTuple_SetItem( laggards_obj, ilaggard, clientlag_obj ); } obj = Py_BuildValue( "iiiiO", laggards->oldest, laggards->newest, laggards->maxpktid, laggards->range, laggards_obj ); freeLaggards( laggards ); return obj; }
void interpret_notification(PyObject* dict, const void *pnotif, int size) { const union sctp_notification *notif = pnotif; PyDict_SetItemString(dict, "type", PyInt_FromLong(notif->sn_header.sn_type)); PyDict_SetItemString(dict, "flags", PyInt_FromLong(notif->sn_header.sn_flags)); PyDict_SetItemString(dict, "length", PyInt_FromLong(notif->sn_header.sn_length)); switch (notif->sn_header.sn_type) { case SCTP_ASSOC_CHANGE: { const struct sctp_assoc_change* n = &(notif->sn_assoc_change); PyDict_SetItemString(dict, "state", PyInt_FromLong(n->sac_state)); PyDict_SetItemString(dict, "error", PyInt_FromLong(n->sac_error)); PyDict_SetItemString(dict, "outbound_streams", PyInt_FromLong(n->sac_outbound_streams)); PyDict_SetItemString(dict, "inbound_streams", PyInt_FromLong(n->sac_inbound_streams)); PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->sac_assoc_id)); } break; case SCTP_PEER_ADDR_CHANGE: { const struct sctp_paddr_change* n = &(notif->sn_paddr_change); char caddr[256]; int family; int len; int port; PyObject* oaddr; if (from_sockaddr((struct sockaddr*) &(n->spc_aaddr), &family, &len, &port, caddr, sizeof(caddr))) { oaddr = PyTuple_New(2); PyTuple_SetItem(oaddr, 0, PyString_FromString(caddr)); PyTuple_SetItem(oaddr, 1, PyInt_FromLong(port)); } else { // something went wrong oaddr = Py_None; Py_INCREF(Py_None); } PyDict_SetItemString(dict, "addr", oaddr); PyDict_SetItemString(dict, "state", PyInt_FromLong(n->spc_state)); PyDict_SetItemString(dict, "error", PyInt_FromLong(n->spc_error)); PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->spc_assoc_id)); } break; case SCTP_SEND_FAILED: { const struct sctp_send_failed* n = &(notif->sn_send_failed); const char* cdata = ((char*) notif) + sizeof(struct sctp_send_failed); int ldata = size - sizeof(struct sctp_send_failed); if (ldata >= 0) { PyObject* info = PyDict_New(); interpret_sndrcvinfo(info, &(n->ssf_info)); PyDict_SetItemString(dict, "_info", info); PyDict_SetItemString(dict, "error", PyInt_FromLong(n->ssf_error)); PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->ssf_assoc_id)); PyDict_SetItemString(dict, "data", PyString_FromStringAndSize(cdata, ldata)); } } break; case SCTP_REMOTE_ERROR: { const struct sctp_remote_error* n = &(notif->sn_remote_error); const char* cdata = ((char*) notif) + sizeof(struct sctp_remote_error); int ldata = size - sizeof(struct sctp_remote_error); if (ldata >= 0) { PyDict_SetItemString(dict, "error", PyInt_FromLong(n->sre_error)); PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->sre_assoc_id)); PyDict_SetItemString(dict, "data", PyString_FromStringAndSize(cdata, ldata)); } } break; case SCTP_SHUTDOWN_EVENT: { const struct sctp_shutdown_event* n = &(notif->sn_shutdown_event); PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->sse_assoc_id)); } break; case SCTP_PARTIAL_DELIVERY_EVENT: { const struct sctp_pdapi_event* n = &(notif->sn_pdapi_event); PyDict_SetItemString(dict, "indication", PyInt_FromLong(n->pdapi_indication)); PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->pdapi_assoc_id)); } break; case SCTP_ADAPTATION_INDICATION: { const struct sctp_adaptation_event* n = &(notif->sn_adaptation_event); PyDict_SetItemString(dict, "adaptation_ind", PyInt_FromLong(n->sai_adaptation_ind)); PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->sai_assoc_id)); } break; } }
static PyObject* get_status(PyObject* dummy, PyObject* args) { PyObject* ret = 0; PyObject* dict; PyObject* dict2; PyObject* oassoc_id; PyObject* oaddr; char caddr[256]; int family, len, port; int fd; struct sctp_status v; socklen_t lv = sizeof(v); int ok; ok = PyArg_ParseTuple(args, "iOO", &fd, &dict, &dict2) && \ PyDict_Check(dict) && PyDict_Check(dict2); ok = ok && (oassoc_id = PyDict_GetItemString(dict, "assoc_id")); ok = ok && PyInt_Check(oassoc_id); if (! ok) { return ret; } bzero(&v, sizeof(v)); v.sstat_assoc_id = PyInt_AsLong(oassoc_id); if (getsockopt(fd, SOL_SCTP, SCTP_STATUS, &v, &lv)) { PyErr_SetFromErrno(PyExc_IOError); } else { PyDict_SetItemString(dict, "state", PyInt_FromLong(v.sstat_state)); PyDict_SetItemString(dict, "rwnd", PyInt_FromLong(v.sstat_rwnd)); PyDict_SetItemString(dict, "unackdata", PyInt_FromLong(v.sstat_unackdata)); PyDict_SetItemString(dict, "penddata", PyInt_FromLong(v.sstat_penddata)); PyDict_SetItemString(dict, "instrms", PyInt_FromLong(v.sstat_instrms)); PyDict_SetItemString(dict, "outstrms", PyInt_FromLong(v.sstat_outstrms)); PyDict_SetItemString(dict, "fragmentation_point", PyInt_FromLong(v.sstat_fragmentation_point)); if (from_sockaddr((struct sockaddr*) &(v.sstat_primary.spinfo_address), &family, &len, &port, caddr, sizeof(caddr))) { oaddr = PyTuple_New(2); PyTuple_SetItem(oaddr, 0, PyString_FromString(caddr)); PyTuple_SetItem(oaddr, 1, PyInt_FromLong(port)); } else { // something went wrong oaddr = Py_None; Py_INCREF(Py_None); } PyDict_SetItemString(dict2, "sockaddr", oaddr); PyDict_SetItemString(dict2, "assoc_id", PyInt_FromLong(v.sstat_primary.spinfo_assoc_id)); PyDict_SetItemString(dict2, "state", PyInt_FromLong(v.sstat_primary.spinfo_state)); PyDict_SetItemString(dict2, "cwnd", PyInt_FromLong(v.sstat_primary.spinfo_cwnd)); PyDict_SetItemString(dict2, "srtt", PyInt_FromLong(v.sstat_primary.spinfo_srtt)); PyDict_SetItemString(dict2, "rto", PyInt_FromLong(v.sstat_primary.spinfo_rto)); PyDict_SetItemString(dict2, "mtu", PyInt_FromLong(v.sstat_primary.spinfo_mtu)); ret = Py_None; Py_INCREF(ret); } return ret; }
void *uwsgi_python_tracebacker_thread(void *foobar) { struct iovec iov[11]; PyObject *new_thread = uwsgi_python_setup_thread("uWSGITraceBacker"); if (!new_thread) return NULL; struct sockaddr_un so_sun; socklen_t so_sun_len = 0; char *str_wid = uwsgi_num2str(uwsgi.mywid); char *sock_path = uwsgi_concat2(up.tracebacker, str_wid); int current_defer_accept = uwsgi.no_defer_accept; uwsgi.no_defer_accept = 1; int fd = bind_to_unix(sock_path, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket); if (fd < 0) { uwsgi.no_defer_accept = current_defer_accept; free(str_wid); free(sock_path); return NULL; } uwsgi.no_defer_accept = current_defer_accept; PyObject *traceback_module = PyImport_ImportModule("traceback"); if (!traceback_module) { free(str_wid); free(sock_path); close(fd); return NULL; } PyObject *traceback_dict = PyModule_GetDict(traceback_module); PyObject *extract_stack = PyDict_GetItemString(traceback_dict, "extract_stack"); PyObject *sys_module = PyImport_ImportModule("sys"); PyObject *sys_dict = PyModule_GetDict(sys_module); PyObject *_current_frames = PyDict_GetItemString(sys_dict, "_current_frames"); uwsgi_log("python tracebacker for worker %d available on %s\n", uwsgi.mywid, sock_path); for(;;) { UWSGI_RELEASE_GIL; int client_fd = accept(fd, (struct sockaddr *) &so_sun, &so_sun_len); if (client_fd < 0) { uwsgi_error("accept()"); UWSGI_GET_GIL; continue; } UWSGI_GET_GIL; // here is the core of the tracebacker PyObject *current_frames = PyEval_CallObject(_current_frames, (PyObject *)NULL); if (!current_frames) goto end2; PyObject *current_frames_items = PyObject_GetAttrString(current_frames, "items"); if (!current_frames_items) goto end; PyObject *frames_ret = PyEval_CallObject(current_frames_items, (PyObject *)NULL); if (!frames_ret) goto end3; PyObject *frames_iter = PyObject_GetIter(frames_ret); if (!frames_iter) goto end4; // we have the first frame, lets parse it if (write(client_fd, "*** uWSGI Python tracebacker output ***\n\n", 41) < 0) { uwsgi_error("write()"); } PyObject *frame = PyIter_Next(frames_iter); while(frame) { PyObject *thread_id = PyTuple_GetItem(frame, 0); if (!thread_id) goto next2; PyObject *stack = PyTuple_GetItem(frame, 1); if (!stack) goto next2; PyObject *arg_tuple = PyTuple_New(1); PyTuple_SetItem(arg_tuple, 0, stack); Py_INCREF(stack); PyObject *stacktrace = PyEval_CallObject( extract_stack, arg_tuple); Py_DECREF(arg_tuple); if (!stacktrace) goto next2; PyObject *stacktrace_iter = PyObject_GetIter(stacktrace); if (!stacktrace_iter) { Py_DECREF(stacktrace); goto next2;} PyObject *st_items = PyIter_Next(stacktrace_iter); // we have the first traceback item while(st_items) { #ifdef PYTHREE int thread_name_need_free = 0; #endif PyObject *st_filename = PyTuple_GetItem(st_items, 0); if (!st_filename) { Py_DECREF(st_items); goto next; } PyObject *st_lineno = PyTuple_GetItem(st_items, 1); if (!st_lineno) {Py_DECREF(st_items); goto next;} PyObject *st_name = PyTuple_GetItem(st_items, 2); if (!st_name) {Py_DECREF(st_items); goto next;} PyObject *st_line = PyTuple_GetItem(st_items, 3); iov[0].iov_base = "thread_id = "; iov[0].iov_len = 12; iov[1].iov_base = uwsgi_python_get_thread_name(thread_id); if (!iov[1].iov_base) { iov[1].iov_base = "<UnnamedPythonThread>"; } #ifdef PYTHREE else { thread_name_need_free = 1; } #endif iov[1].iov_len = strlen(iov[1].iov_base); iov[2].iov_base = " filename = "; iov[2].iov_len = 12; #ifdef PYTHREE PyObject *st_filename_utf8 = PyUnicode_AsUTF8String(st_filename); if (!st_filename_utf8) { if (thread_name_need_free) free(iov[1].iov_base); goto next; } iov[3].iov_base = PyString_AsString(st_filename_utf8); #else iov[3].iov_base = PyString_AsString(st_filename); #endif iov[3].iov_len = strlen(iov[3].iov_base); iov[4].iov_base = " lineno = "; iov[4].iov_len = 10 ; iov[5].iov_base = uwsgi_num2str(PyInt_AsLong(st_lineno)); iov[5].iov_len = strlen(iov[5].iov_base); iov[6].iov_base = " function = "; iov[6].iov_len = 12 ; #ifdef PYTHREE PyObject *st_name_utf8 = PyUnicode_AsUTF8String(st_name); if (!st_name_utf8) { if (thread_name_need_free) free(iov[1].iov_base); Py_DECREF(st_filename_utf8); goto next; } iov[7].iov_base = PyString_AsString(st_name_utf8); #else iov[7].iov_base = PyString_AsString(st_name); #endif iov[7].iov_len = strlen(iov[7].iov_base); iov[8].iov_base = ""; iov[8].iov_len = 0 ; iov[9].iov_base = ""; iov[9].iov_len = 0; iov[10].iov_base = "\n"; iov[10].iov_len = 1; #ifdef PYTHREE PyObject *st_line_utf8 = NULL; #endif if (st_line) { iov[8].iov_base = " line = "; iov[8].iov_len = 8; #ifdef PYTHREE PyObject *st_line_utf8 = PyUnicode_AsUTF8String(st_line); if (!st_line_utf8) { if (thread_name_need_free) free(iov[1].iov_base); Py_DECREF(st_filename_utf8); Py_DECREF(st_name_utf8); goto next; } iov[9].iov_base = PyString_AsString(st_line_utf8); #else iov[9].iov_base = PyString_AsString(st_line); #endif iov[9].iov_len = strlen(iov[9].iov_base); } if (writev(client_fd, iov, 11) < 0) { uwsgi_error("writev()"); } // free the line_no free(iov[5].iov_base); Py_DECREF(st_items); #ifdef PYTHREE Py_DECREF(st_filename_utf8); Py_DECREF(st_name_utf8); if (st_line_utf8) { Py_DECREF(st_line_utf8); } if (thread_name_need_free) free(iov[1].iov_base); #endif st_items = PyIter_Next(stacktrace_iter); } if (write(client_fd, "\n", 1) < 0) { uwsgi_error("write()"); } next: Py_DECREF(stacktrace_iter); Py_DECREF(stacktrace); next2: Py_DECREF(frame); frame = PyIter_Next(frames_iter); } Py_DECREF(frames_iter); end4: Py_DECREF(frames_ret); end3: Py_DECREF(current_frames_items); end: Py_DECREF(current_frames); end2: close(client_fd); } return NULL; }
static LIST* call_python_function(RULE* r, FRAME* frame) { LIST* result = 0; PyObject* arguments = PyTuple_New(frame->args->count); int i ; PyObject* py_result; for(i = 0; i < frame->args->count; ++i) { PyObject* arg = PyList_New(0); LIST* l = lol_get( frame->args, i); for(; l; l = l->next) { PyObject* v = PyString_FromString(l->string); /* Steals reference to 'v' */ PyList_Append(arg, v); } /* Steals reference to 'arg' */ PyTuple_SetItem(arguments, i, arg); } py_result = PyObject_CallObject(r->python_function, arguments); Py_DECREF(arguments); if (py_result != NULL) { if (PyList_Check(py_result)) { int size = PyList_Size(py_result); int i; for(i = 0; i < size; ++i) { PyObject* item = PyList_GetItem(py_result, i); if (PyString_Check(item)) { result = list_new(result, newstr(PyString_AsString(item))); } else { fprintf(stderr, "Non-string object returned by Python call\n"); } } } else if (PyInstance_Check(py_result)) { static char instance_name[1000]; static char imported_method_name[1000]; module_t* m; PyObject* method; PyObject* method_name = PyString_FromString("foo"); RULE* r; fprintf(stderr, "Got instance!\n"); snprintf(instance_name, 1000, "pyinstance%d", python_instance_number); snprintf(imported_method_name, 1000, "pyinstance%d.foo", python_instance_number); ++python_instance_number; m = bindmodule(instance_name); /* This is expected to get bound method. */ method = PyObject_GetAttr(py_result, method_name); r = bindrule( imported_method_name, root_module() ); r->python_function = method; result = list_new(0, newstr(instance_name)); Py_DECREF(method_name); } else if (py_result == Py_None) { result = L0; } else { fprintf(stderr, "Non-list object returned by Python call\n"); } Py_DECREF(py_result); } else { PyErr_Print(); fprintf(stderr,"Call failed\n"); } return result; }
PyObject *uwsgi_paste_loader(void *arg1) { char *paste = (char *) arg1; PyObject *paste_module, *paste_dict, *paste_loadapp; PyObject *paste_arg, *paste_app; uwsgi_log( "Loading paste environment: %s\n", paste); if (up.paste_logger) { PyObject *paste_logger_dict = get_uwsgi_pydict("paste.script.util.logging_config"); if (paste_logger_dict) { PyObject *paste_logger_fileConfig = PyDict_GetItemString(paste_logger_dict, "fileConfig"); if (paste_logger_fileConfig) { PyObject *paste_logger_arg = PyTuple_New(1); if (!paste_logger_arg) { PyErr_Print(); exit(UWSGI_FAILED_APP_CODE); } PyTuple_SetItem(paste_logger_arg, 0, UWSGI_PYFROMSTRING(paste+7)); if (python_call(paste_logger_fileConfig, paste_logger_arg, 0, NULL)) { PyErr_Print(); } } } } paste_module = PyImport_ImportModule("paste.deploy"); if (!paste_module) { PyErr_Print(); exit(UWSGI_FAILED_APP_CODE); } paste_dict = PyModule_GetDict(paste_module); if (!paste_dict) { PyErr_Print(); exit(UWSGI_FAILED_APP_CODE); } paste_loadapp = PyDict_GetItemString(paste_dict, "loadapp"); if (!paste_loadapp) { PyErr_Print(); exit(UWSGI_FAILED_APP_CODE); } paste_arg = PyTuple_New(1); if (!paste_arg) { PyErr_Print(); exit(UWSGI_FAILED_APP_CODE); } if (PyTuple_SetItem(paste_arg, 0, UWSGI_PYFROMSTRING(paste))) { PyErr_Print(); exit(UWSGI_FAILED_APP_CODE); } paste_app = PyEval_CallObject(paste_loadapp, paste_arg); if (!paste_app) { PyErr_Print(); exit(UWSGI_FAILED_APP_CODE); } return paste_app; }
/** ****************************************************************************************************** * Iterates over the hosts in the cluster and creates the list to be returned to the python client. * * @param err as_error object * @param command Request string sent from the python client * @param nodes_tuple List containing details of each host * @param return_value List t o be returned back to the python client * @param host_index Index of the list nodes_tuple * @param index Index of the list to be returned. * * Returns information about a host. ********************************************************************************************************/ static PyObject * AerospikeClient_GetNodes_Returnlist(as_error* err, PyObject * command, PyObject * nodes_tuple[], PyObject * return_value, uint32_t host_index, Py_ssize_t index) { char* tok = NULL; char* saved = NULL; PyObject * value_tok = NULL; bool break_flag = false; tok = strtok_r(PyStr_AsString(command), INFO_REQUEST_RESPONSE_DELIMITER, &saved); if (tok == NULL) { as_error_update(err, AEROSPIKE_ERR_CLIENT, "Unable to get addr in service"); goto CLEANUP; } while (tok != NULL && (host_index < MAX_HOST_COUNT)) { tok = strtok_r(NULL, IP_PORT_DELIMITER, &saved); #if defined(__APPLE__) if (tok == NULL || saved == NULL) { #else if (tok == NULL || *saved == '\0') { #endif goto CLEANUP; } nodes_tuple[host_index] = PyTuple_New(2); value_tok = PyStr_FromString(tok); PyTuple_SetItem(nodes_tuple[host_index], 0 , value_tok); //Py_DECREF(value_tok); if(strcmp(PyStr_AsString(command),"response_services_p")) { tok = strtok_r(NULL, HOST_DELIMITER, &saved); if (tok == NULL) { as_error_update(err, AEROSPIKE_ERR_CLIENT, "Unable to get port"); goto CLEANUP; } if (strstr(tok, INFO_RESPONSE_END)) { tok = strtok_r(tok, INFO_RESPONSE_END, &saved); break_flag = true; } } else { tok = strtok_r(NULL, INFO_RESPONSE_END, &saved); if (tok == NULL) { as_error_update(err, AEROSPIKE_ERR_CLIENT, "Unable to get port in service"); goto CLEANUP; } } value_tok = PyInt_FromString(tok, NULL, 10); PyTuple_SetItem(nodes_tuple[host_index], 1 , value_tok); PyList_Insert(return_value, index , nodes_tuple[host_index]); Py_DECREF(nodes_tuple[host_index]); index++; host_index++; if (break_flag == true) { goto CLEANUP; } } CLEANUP: if ( err->code != AEROSPIKE_OK ) { PyObject * py_err = NULL; error_to_pyobject(err, &py_err); PyObject *exception_type = raise_exception(err); PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return return_value; } /** ****************************************************************************************************** * Returns data about the nodes to AerospikeClient_GetNodes. * * @param self AerospikeClient object * * Returns a list containing the details of the nodes. ********************************************************************************************************/ static PyObject * AerospikeClient_GetNodes_Invoke( AerospikeClient * self) { PyObject * response_services_p = NULL; PyObject * response_service_p = NULL; PyObject * nodes_tuple[MAX_HOST_COUNT] = {0}; PyObject * return_value = PyList_New(0); as_error err; 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; } PyObject * py_req_str = NULL; py_req_str = PyStr_FromString("services"); response_services_p = AerospikeClient_InfoNode_Invoke(self, py_req_str, NULL, NULL); Py_DECREF(py_req_str); if(!response_services_p) { as_error_update(&err, AEROSPIKE_ERR_CLIENT, "Services call returned an error"); goto CLEANUP; } py_req_str = PyStr_FromString("service"); response_service_p = AerospikeClient_InfoNode_Invoke(self, py_req_str, NULL, NULL); Py_DECREF(py_req_str); if(!response_service_p) { as_error_update(&err, AEROSPIKE_ERR_CLIENT, "Service call returned an error"); goto CLEANUP; } return_value = AerospikeClient_GetNodes_Returnlist(&err, response_service_p, nodes_tuple, return_value, 0, 0); if( return_value ) return_value = AerospikeClient_GetNodes_Returnlist(&err, response_services_p, nodes_tuple, return_value, 1, 1); CLEANUP: if(response_services_p) { Py_DECREF(response_services_p); } if(response_service_p) { Py_DECREF(response_service_p); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL; error_to_pyobject(&err, &py_err); PyObject *exception_type = raise_exception(&err); PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return return_value; }
static PyObject * coordinator_convert(PyObject * self, PyObject * args) { char * shape_name; double extent[4]; int pixel_width = 0; int pixel_height = 0; int fixed_ratio = 1; int offset_x = 0; int offset_y = 0; int pan_offset_x = 0; int pan_offset_y = 0; double scaleX = 0.9; double scaleY = 0.9; double ratioX = 0.0; double ratioY = 0.0; int startX = 0; int startY = 0; int margin_x = 0; int margin_y = 0; int offset_from_upperleft = 1; SHPHandle hSHP; PyObject * cobject; PyObject * region; PyObject * zoom_region; if (!PyArg_ParseTuple(args, "O!siiiiiiOO", &PyCObject_Type, &cobject, &shape_name, &pixel_width, &pixel_height, &offset_x, &offset_y, &pan_offset_x, &pan_offset_y, ®ion, &zoom_region)) return NULL; hSHP = PyCObject_AsVoidPtr(cobject); int nEntities; int nShapeType; double adfBoundsMin[4], adfBoundsMax[4]; int i,j,k,s,nParts,count,numPoints; SHPGetInfo(hSHP, &nEntities, &nShapeType, adfBoundsMin, adfBoundsMax); extent[0] = adfBoundsMin[0]; extent[1] = adfBoundsMin[1]; extent[2] = adfBoundsMax[0]; extent[3] = adfBoundsMax[1]; if (PyList_Size(region) > 0) { for (i =0; i<4;++i) extent[i] = PyFloat_AsDouble(PyList_GetItem(region,i)); } double view_width = fabs(extent[0] - extent[2]); double view_height = fabs(extent[1] - extent[3]); if (fixed_ratio == 1) { if ((double)(pixel_width)/(double)(pixel_height) < view_width/view_height) { ratioX = pixel_width/view_width; ratioY = ratioX; startY = (int)((pixel_height-view_height*ratioY)/2.0); } else { ratioY = pixel_height/view_height; ratioX = ratioY; startX = (int)((pixel_width-view_width*ratioX)/2.0); } } else { ratioX = pixel_width / view_width; ratioY = pixel_height / view_height; } margin_x = (int)(pixel_width * (1-scaleX) / 2.0); margin_y = (int)(pixel_height* (1-scaleY) / 2.0); double x,y,tmp_px,tmp_py,prev_x,prev_y,one_pixel_view_x,one_pixel_view_y; // get zoom parameters if (PyList_Size(zoom_region) > 0) { for (i =0; i<4;++i) extent[i] = PyFloat_AsDouble(PyList_GetItem(zoom_region,i)); view_width = fabs(extent[0] - extent[2]); view_height = fabs(extent[1] - extent[3]); if ((double)(pixel_width)/(double)(pixel_height) < view_width/view_height) { ratioX = pixel_width/view_width; ratioY = ratioX; startY = (int)((pixel_height-view_height*ratioY)/2.0); } else { ratioY = pixel_height/view_height; ratioX = ratioY; startX = (int)((pixel_width-view_width*ratioX)/2.0); } margin_x = (int)(pixel_width * (1-scaleX) / 2.0); margin_y = (int)(pixel_height* (1-scaleY) / 2.0); } // converter coordinators PyObject * objects = PyDict_GetItemString(map_dict, shape_name); if (objects == NULL) return PyList_New(0); PyObject * list = NULL, * parts = NULL, * point = NULL; PyObject *vertices = NULL, *px = NULL, *py =NULL; PyObject *_point=NULL,*_px=NULL,*_py=NULL; PyObject *polygon=NULL,*part = NULL; list = PyList_New(nEntities); for (i=0; i< nEntities; i++) { if (nShapeType == SHPT_POINT || nShapeType == SHPT_POINTZ) { _point = PyList_GetItem(objects, i); _px = PyTuple_GetItem(_point, 0); _py = PyTuple_GetItem(_point, 1); x = PyFloat_AsDouble(_px); y = PyFloat_AsDouble(_py); tmp_px = pan_offset_x + startX + ratioX * (x - extent[0]); tmp_px = round(offset_x + tmp_px * scaleX + margin_x); tmp_py = pixel_height - pan_offset_y - startY - ratioY * (y-extent[1]); tmp_py = round(offset_y + tmp_py * scaleY + margin_y); px = PyInt_FromLong((int)tmp_px); py = PyInt_FromLong((int)tmp_py); point = PyTuple_New(2); PyTuple_SetItem(point, 0, px); PyTuple_SetItem(point, 1, py); PyList_SetItem(list, i, point); } else if (nShapeType == SHPT_POLYGON || nShapeType == SHPT_POLYGONZ) { polygon = PyList_GetItem(objects, i); nParts = (int)PyList_Size(polygon); parts = PyList_New(nParts); for (j=0; j < nParts; j++) { part = PyList_GetItem(polygon, j); numPoints = (int)PyList_Size(part); vertices = PyTuple_New(numPoints); for (k=0; k < numPoints; k++) { _point = PyList_GetItem(part, k); _px = PyTuple_GetItem(_point, 0); _py = PyTuple_GetItem(_point, 1); x = PyFloat_AsDouble(_px); y = PyFloat_AsDouble(_py); tmp_px = pan_offset_x + startX + ratioX * (x - extent[0]); tmp_px = offset_x + tmp_px * scaleX + margin_x; tmp_py = pixel_height - pan_offset_y - startY - ratioY * (y-extent[1]); tmp_py = offset_y + tmp_py * scaleY + margin_y; px = PyInt_FromLong((int)tmp_px); py = PyInt_FromLong((int)tmp_py); point = PyTuple_New(2); PyTuple_SetItem(point, 0, px); PyTuple_SetItem(point, 1, py); PyTuple_SetItem(vertices, k, point); } PyList_SetItem(parts,j,vertices); } PyList_SetItem(list, i, parts); } } return list; }
static PyObject * read_centroids(PyObject * self, PyObject * args) { SHPHandle hSHP; PyObject * cobject; if (!PyArg_ParseTuple(args, "O!", &PyCObject_Type, &cobject)) return NULL; hSHP = PyCObject_AsVoidPtr(cobject); int nEntities; int nShapeType; SHPGetInfo(hSHP, &nEntities, &nShapeType, NULL, NULL); PyObject * list = NULL, * parts = NULL, * point = NULL, *px = NULL, *py = NULL; SHPObject * psCShape; int i,j,count; double x,y; list = PyList_New(nEntities); for (i=0; i< nEntities; i++) { psCShape = SHPReadObject( hSHP, i); if (psCShape->nSHPType == SHPT_POINT || psCShape->nSHPType == SHPT_POINTZ) { /* x = psCShape->centroidXX[0]; y = psCShape->centroidYY[0]; point = Py_BuildValue("(dd)", x,y); PyList_SetItem(list, i, point); */ return PyList_New(0); } else if (psCShape->nSHPType == SHPT_POLYGON || psCShape->nSHPType == SHPT_POLYGONZ) { // read polygons from shp file count = psCShape->nParts > 1 ? psCShape->nParts : 1; parts = PyList_New(count); for (j=0; j <psCShape->nParts; j++) { x = psCShape->centroidXX[j]; y = psCShape->centroidYY[j]; //point = Py_BuildValue("(dd)", x,y); px = PyFloat_FromDouble(x); py = PyFloat_FromDouble(y); point = PyTuple_New(2); PyTuple_SetItem(point, 0, px); PyTuple_SetItem(point, 1, py); PyList_SetItem(parts,j,point); } PyList_SetItem(list, i, parts); } SHPDestroyObject(psCShape); } return list; }
void embed_sim_init(gpi_sim_info_t *info) { FENTER int i; /* Check that we are not already initialised */ if (pEventFn) return; // Find the simulation root gpi_sim_hdl dut = gpi_get_root_handle(getenv("TOPLEVEL")); if (dut == NULL) { fprintf(stderr, "Unable to find root instance!\n"); gpi_sim_end(); return; } PyObject *cocotb_module, *cocotb_init, *cocotb_args, *cocotb_retval; PyObject *simlog_obj, *simlog_func; PyObject *argv_list, *argc, *arg_dict, *arg_value; cocotb_module = NULL; arg_dict = NULL; //Ensure that the current thread is ready to callthe Python C API PyGILState_STATE gstate = PyGILState_Ensure(); if (get_module_ref(COCOTB_MODULE, &cocotb_module)) goto cleanup; // Create a logger object simlog_obj = PyObject_GetAttrString(cocotb_module, "log"); if (simlog_obj == NULL) { PyErr_Print(); fprintf(stderr, "Failed to to get simlog object\n"); } simlog_func = PyObject_GetAttrString(simlog_obj, "_printRecord"); if (simlog_func == NULL) { PyErr_Print(); fprintf(stderr, "Failed to get the _printRecord method"); goto cleanup; } if (!PyCallable_Check(simlog_func)) { PyErr_Print(); fprintf(stderr, "_printRecord is not callable"); goto cleanup; } set_log_handler(simlog_func); Py_DECREF(simlog_func); simlog_func = PyObject_GetAttrString(simlog_obj, "_willLog"); if (simlog_func == NULL) { PyErr_Print(); fprintf(stderr, "Failed to get the _willLog method"); goto cleanup; } if (!PyCallable_Check(simlog_func)) { PyErr_Print(); fprintf(stderr, "_willLog is not callable"); goto cleanup; } set_log_filter(simlog_func); argv_list = PyList_New(0); for (i = 0; i < info->argc; i++) { arg_value = PyString_FromString(info->argv[i]); PyList_Append(argv_list, arg_value); } arg_dict = PyModule_GetDict(cocotb_module); PyDict_SetItemString(arg_dict, "argv", argv_list); argc = PyInt_FromLong(info->argc); PyDict_SetItemString(arg_dict, "argc", argc); if (!PyCallable_Check(simlog_func)) { PyErr_Print(); fprintf(stderr, "_printRecord is not callable"); goto cleanup; } gpi_print_registered_impl(); LOG_INFO("Running on %s version %s", info->product, info->version); LOG_INFO("Python interpreter initialised and cocotb loaded!"); // Now that logging has been set up ok we initialise the testbench if (-1 == PyObject_SetAttrString(cocotb_module, "SIM_NAME", PyString_FromString(info->product))) { PyErr_Print(); fprintf(stderr, "Unable to set SIM_NAME"); goto cleanup; } // Set languare in use const char *lang = getenv("TOPLEVEL_LANG"); if (!lang) fprintf(stderr, "You should really set TOPLEVEL_LANG to \"verilog/vhdl\""); else { if (-1 == PyObject_SetAttrString(cocotb_module, "LANGUAGE", PyString_FromString(lang))) { fprintf(stderr, "Unable to set LANGUAGE"); goto cleanup; } } // Hold onto a reference to our _fail_test function pEventFn = PyObject_GetAttrString(cocotb_module, "_sim_event"); if (!PyCallable_Check(pEventFn)) { PyErr_Print(); fprintf(stderr, "cocotb._sim_event is not callable"); goto cleanup; } Py_INCREF(pEventFn); cocotb_init = PyObject_GetAttrString(cocotb_module, "_initialise_testbench"); // New reference if (cocotb_init == NULL || !PyCallable_Check(cocotb_init)) { if (PyErr_Occurred()) PyErr_Print(); fprintf(stderr, "Cannot find function \"%s\"\n", "_initialise_testbench"); Py_DECREF(cocotb_init); goto cleanup; } cocotb_args = PyTuple_New(1); PyTuple_SetItem(cocotb_args, 0, PyLong_FromLong((long)dut)); // Note: This function “steals” a reference to o. cocotb_retval = PyObject_CallObject(cocotb_init, cocotb_args); if (cocotb_retval != NULL) { LOG_DEBUG("_initialise_testbench successful"); Py_DECREF(cocotb_retval); } else { PyErr_Print(); fprintf(stderr,"Call failed\n"); gpi_sim_end(); goto cleanup; } FEXIT cleanup: if (cocotb_module) { Py_DECREF(cocotb_module); } if (arg_dict) { Py_DECREF(arg_dict); } PyGILState_Release(gstate); }
static PyObject* _adjust_players(PyObject* self, PyObject* args) { PyObject* list_obj; PyObject* seq; int size, i = 0; // get the list from the arguments // note: "O" flag means it's a python object if (!PyArg_ParseTuple(args, "O", &list_obj)) { return NULL; } // verify that it's actually a list seq = PySequence_Fast(list_obj, "expected a list"); if (!seq) { return NULL; } // get the list size size = PySequence_Size(seq); if (size < 0) { return NULL; } // create a vector of players to hold our soon-to-be-created player objects std::vector<Player*> players; PyObject* py_tuple; for (i = 0; i < size; ++i) { // create a new player object Player* p = new Player(); // get the current item from the list, which happens to be a tuple (mu, sigma, rank) py_tuple = PySequence_Fast_GET_ITEM(seq, i); // convert the tuple items into their c types p->mu = PyFloat_AsDouble(PyTuple_GetItem(py_tuple, 0)); p->sigma = PyFloat_AsDouble(PyTuple_GetItem(py_tuple, 1)); p->rank = (int)PyInt_AsLong(PyTuple_GetItem(py_tuple, 2)); // add the player to the players vector players.push_back(p); } // run trueskill on the players TrueSkill ts; ts.adjust_players(players); // create the result list PyObject* result = PyList_New(size); for (i = 0; i < size; ++i) { // create a tuple and set it's values for the player PyObject* py_tuple; py_tuple = PyTuple_New(3); PyTuple_SetItem(py_tuple, 0, PyFloat_FromDouble(players[i]->mu)); PyTuple_SetItem(py_tuple, 1, PyFloat_FromDouble(players[i]->sigma)); PyTuple_SetItem(py_tuple, 2, PyInt_FromLong((long)players[i]->rank)); // push the tuple onto the list PyList_SetItem(result, i, py_tuple); } // return the list return result; }
static PyObject * RtAudio_getDeviceInfo(PyRtAudio *self, PyObject *args) { int device; RtAudioDeviceInfo info; PyObject *name = NULL; PyObject *probed = NULL; PyObject *outputChannels = NULL; PyObject *inputChannels = NULL; PyObject *duplexChannels = NULL; PyObject *isDefault = NULL; PyObject *sampleRates = NULL; PyObject *nativeFormats = NULL; PyObject *deviceInfo = NULL; if(!PyArg_ParseTuple(args, "i", &device)) return NULL; try { info = self->rtaudio->getDeviceInfo(device); } catch(RtError &error) { PyErr_Format(RtAudioError, error.getMessageString()); return NULL; } name = PyString_FromString(info.name.c_str()); if(name == NULL) return NULL; if(info.probed) { probed = Py_True; Py_INCREF(Py_True); } else { probed = Py_False; Py_INCREF(Py_False); } outputChannels = PyInt_FromLong(info.outputChannels); if(outputChannels == NULL) goto fail; inputChannels = PyInt_FromLong(info.inputChannels); if(inputChannels == NULL) goto fail; duplexChannels = PyInt_FromLong(info.duplexChannels); if(duplexChannels == NULL) goto fail; if(info.isDefault) { isDefault = Py_True; Py_INCREF(Py_True); } else { isDefault = Py_False; Py_INCREF(Py_False); } sampleRates = PyTuple_New(info.sampleRates.size()); if(sampleRates == NULL) goto fail; for(uint i=0; i < info.sampleRates.size(); i++) { PyObject *rate = PyInt_FromLong(info.sampleRates[i]); if(rate == NULL) goto fail; if(PyTuple_SetItem(sampleRates, i, rate)) { Py_DECREF(rate); goto fail; } } nativeFormats = PyLong_FromUnsignedLong(info.nativeFormats); if(nativeFormats == NULL) return NULL; deviceInfo = PyDict_New(); if(deviceInfo == NULL) goto fail; if(PyDict_SetItemString(deviceInfo, "name", name)) goto fail; if(PyDict_SetItemString(deviceInfo, "probed", probed)) goto fail; if(PyDict_SetItemString(deviceInfo, "outputChannels", outputChannels)) goto fail; if(PyDict_SetItemString(deviceInfo, "inputChannels", inputChannels)) goto fail; if(PyDict_SetItemString(deviceInfo, "deviceChannels", duplexChannels)) goto fail; if(PyDict_SetItemString(deviceInfo, "isDefault", isDefault)) goto fail; if(PyDict_SetItemString(deviceInfo, "sampleRates", sampleRates)) goto fail; if(PyDict_SetItemString(deviceInfo, "nativeFormats", nativeFormats)) goto fail; return deviceInfo; fail: Py_XDECREF(name); Py_XDECREF(probed); Py_XDECREF(outputChannels); Py_XDECREF(inputChannels); Py_XDECREF(duplexChannels); Py_XDECREF(isDefault); Py_XDECREF(sampleRates); Py_XDECREF(nativeFormats); Py_XDECREF(deviceInfo); return NULL; }
PyObject * ot_pvw_receive(PyObject *self, PyObject *args) { PyObject *py_state, *py_choices, *py_return = NULL; struct dm_ddh_crs crs; struct dm_ddh_pk pk; struct ddh_sk sk; struct ddh_ctxt ctxt; struct state *st; int num_ots; unsigned int N, msglength, err = 0; double start, end; if (!PyArg_ParseTuple(args, "OOII", &py_state, &py_choices, &N, &msglength)) return NULL; st = (struct state *) PyCapsule_GetPointer(py_state, NULL); if (st == NULL) return NULL; if (N != 2) { PyErr_SetString(PyExc_RuntimeError, "N must be 2"); return NULL; } if ((num_ots = PySequence_Length(py_choices)) == -1) return NULL; start = current_time(); // FIXME: choice of mode should not be hardcoded dm_ddh_crs_setup(&crs, EXT, &st->p); end = current_time(); fprintf(stderr, "CRS setup: %f\n", end - start); dm_ddh_pk_setup(&pk); ddh_sk_setup(&sk); ddh_ctxt_setup(&ctxt); py_return = PyTuple_New(num_ots); start = current_time(); for (int j = 0; j < num_ots; ++j) { unsigned int choice; // double start, end; choice = PyLong_AsLong(PySequence_GetItem(py_choices, j)); // start = current_time(); dm_ddh_keygen(&pk, &sk, choice, &crs, &st->p); // end = current_time(); // fprintf(stderr, "ddh keygen: %f\n", end - start); // start = current_time(); send_dm_ddh_pk(&pk, st); // end = current_time(); // fprintf(stderr, "send dm ddh pk: %f\n", end - start); for (unsigned int b = 0; b <= 1; ++b) { char *msg; PyObject *str; // start = current_time(); receive_ddh_ctxt(&ctxt, st); // end = current_time(); // fprintf(stderr, "receive dm ddh ctxt: %f\n", end - start); // start = current_time(); msg = dm_ddh_dec(&sk, &ctxt, &st->p); // end = current_time(); // fprintf(stderr, "decrypt ddh ctxt: %f\n", end - start); str = PyString_FromStringAndSize(msg, msglength); free(msg); if (str == NULL) { err = 1; goto cleanup; } if (choice == b) { PyTuple_SetItem(py_return, j, str); } } } end = current_time(); fprintf(stderr, "OT: %f\n", end - start); cleanup: ddh_ctxt_cleanup(&ctxt); ddh_sk_cleanup(&sk); dm_ddh_pk_cleanup(&pk); dm_ddh_crs_cleanup(&crs); if (err) return NULL; else return py_return; }
static PyObject * python_orbclients( PyObject *self, PyObject *args ) { char *usage = "Usage: _orbclients(orb)\n"; int orbfd; Orbclient *oc = 0; double atime; int nclients; int iclient; int rc; char *ip; struct in_addr addr; PyObject *obj; PyObject *client_obj; if( ! PyArg_ParseTuple( args, "i", &orbfd ) ) { if( ! PyErr_Occurred() ) { PyErr_SetString( PyExc_RuntimeError, usage ); } return NULL; } rc = orbclients( orbfd, &atime, &oc, &nclients ); if( rc < 0 ) { PyErr_SetString( PyExc_RuntimeError, "error querying orb clients" ); return NULL; } obj = PyTuple_New( nclients ); for( iclient = 0; iclient < nclients; iclient++ ) { memcpy( &addr.s_addr, oc[iclient].address, 4 ); ip = inet_ntoa( addr ); client_obj = PyDict_New(); PyDict_SetItemString( client_obj, "lastpkt", Py_BuildValue( "f", oc[iclient].lastpkt ) ); PyDict_SetItemString( client_obj, "started", Py_BuildValue( "f", oc[iclient].started ) ); PyDict_SetItemString( client_obj, "read", PyInt_FromLong( (long) oc[iclient].read ) ); PyDict_SetItemString( client_obj, "pid", Py_BuildValue( "i", oc[iclient].pid ) ); PyDict_SetItemString( client_obj, "bytes", PyInt_FromLong( (long) oc[iclient].bytes ) ); PyDict_SetItemString( client_obj, "packets", PyInt_FromLong( (long) oc[iclient].packets ) ); PyDict_SetItemString( client_obj, "pktid", Py_BuildValue( "i", oc[iclient].pktid ) ); PyDict_SetItemString( client_obj, "port", Py_BuildValue( "i", oc[iclient].port ) ); PyDict_SetItemString( client_obj, "address", Py_BuildValue( "s", ip ) ); PyDict_SetItemString( client_obj, "thread", Py_BuildValue( "i", oc[iclient].thread ) ); PyDict_SetItemString( client_obj, "fd", Py_BuildValue( "i", oc[iclient].fd ) ); PyDict_SetItemString( client_obj, "nreject", Py_BuildValue( "i", oc[iclient].nreject ) ); PyDict_SetItemString( client_obj, "nselect", Py_BuildValue( "i", oc[iclient].nselect ) ); PyDict_SetItemString( client_obj, "errors", Py_BuildValue( "i", oc[iclient].errors ) ); PyDict_SetItemString( client_obj, "priority", Py_BuildValue( "i", oc[iclient].priority ) ); PyDict_SetItemString( client_obj, "lastrequest", Py_BuildValue( "i", oc[iclient].lastrequest ) ); PyDict_SetItemString( client_obj, "mymessages", Py_BuildValue( "i", oc[iclient].mymessages ) ); PyDict_SetItemString( client_obj, "nrequests", PyInt_FromLong( (long) oc[iclient].nrequests ) ); PyDict_SetItemString( client_obj, "nwrites", PyInt_FromLong( (long) oc[iclient].nwrites ) ); PyDict_SetItemString( client_obj, "nreads", PyInt_FromLong( (long) oc[iclient].nreads ) ); PyDict_SetItemString( client_obj, "written", PyInt_FromLong( (long) oc[iclient].written ) ); PyDict_SetItemString( client_obj, "perm", PyString_FromFormat( "%c", oc[iclient].perm ) ); PyDict_SetItemString( client_obj, "what", Py_BuildValue( "s", oc[iclient].what ) ); PyDict_SetItemString( client_obj, "host", Py_BuildValue( "s", oc[iclient].host ) ); PyDict_SetItemString( client_obj, "who", Py_BuildValue( "s", oc[iclient].who ) ); PyDict_SetItemString( client_obj, "select", Py_BuildValue( "s", oc[iclient].select ) ); PyDict_SetItemString( client_obj, "reject", Py_BuildValue( "s", oc[iclient].reject ) ); PyTuple_SetItem( obj, iclient, client_obj ); } return Py_BuildValue( "fO", atime, obj ); }
int main(int argc, char** argv) { // 初始化Python //在使用Python系统前,必须使用Py_Initialize对其 //进行初始化。它会载入Python的内建模块并添加系统路 //径到模块搜索路径中。这个函数没有返回值,检查系统 //是否初始化成功需要使用Py_IsInitialized。 Py_Initialize(); // 检查初始化是否成功 if ( !Py_IsInitialized() ) { return -1; } // 添加当前路径 //把输入的字符串作为Python代码直接运行,返回0 //表示成功,-1表示有错。大多时候错误都是因为字符串 //中有语法错误。 PyRun_SimpleString("import sys"); PyRun_SimpleString("sys.path.append('./')"); PyObject *pName,*pModule,*pDict,*pFunc,*pArgs; // 载入名为pytest的脚本 pName = PyString_FromString("pytest"); pModule = PyImport_Import(pName); if ( !pModule ) { printf("can't find pytest.py"); getchar(); return -1; } pDict = PyModule_GetDict(pModule); if ( !pDict ) { return -1; } // 找出函数名为add的函数 pFunc = PyDict_GetItemString(pDict, "add"); if ( !pFunc || !PyCallable_Check(pFunc) ) { printf("can't find function [add]"); getchar(); return -1; } // 参数进栈 *pArgs; pArgs = PyTuple_New(2); // PyObject* Py_BuildValue(char *format, ...) // 把C++的变量转换成一个Python对象。当需要从 // C++传递变量到Python时,就会使用这个函数。此函数 // 有点类似C的printf,但格式不同。常用的格式有 // s 表示字符串, // i 表示整型变量, // f 表示浮点数, // O 表示一个Python对象。 PyTuple_SetItem(pArgs, 0, Py_BuildValue("l",3)); PyTuple_SetItem(pArgs, 1, Py_BuildValue("l",4)); // 调用Python函数 PyObject_CallObject(pFunc, pArgs); //下面这段是查找函数foo 并执行foo pFunc = PyDict_GetItemString(pDict, "foo"); if ( !pFunc || !PyCallable_Check(pFunc) ) { printf("can't find function [foo]"); getchar(); return -1; } pArgs = PyTuple_New(1); PyTuple_SetItem(pArgs, 0, Py_BuildValue("l",2)); // PyObject_CallObject(pFunc, pArgs); Py_DECREF(pName); Py_DECREF(pArgs); Py_DECREF(pModule); // 关闭Python Py_Finalize(); return 0; }
static PyObject * read_objects(PyObject * self, PyObject * args) { SHPHandle hSHP; PyObject * cobject; char * shape_name; if (!PyArg_ParseTuple(args, "O!s", &PyCObject_Type, &cobject, &shape_name)) return NULL; hSHP = PyCObject_AsVoidPtr(cobject); // check if already in memory if (map_dict != NULL) { PyObject * result = PyDict_GetItemString(map_dict, shape_name); if (result != NULL) return result; } int nEntities; int nShapeType; SHPGetInfo(hSHP, &nEntities, &nShapeType, NULL, NULL); PyObject * list = NULL, * parts = NULL, * point = NULL, *vertices = NULL, *px = NULL, *py = NULL; SHPObject * psCShape; int i,j,k,s,count,numPoints; double x,y; list = PyList_New(nEntities); for (i=0; i< nEntities; i++) { psCShape = SHPReadObject( hSHP, i); if (psCShape->nSHPType == SHPT_POINT || psCShape->nSHPType == SHPT_POINTZ) { // read points from shp file numPoints = psCShape->nVertices; for (j=0; j < numPoints; j++) { x = psCShape->padfX[j]; y = psCShape->padfY[j]; //point = Py_BuildValue("(dd)", x,y); px = PyFloat_FromDouble(x); py = PyFloat_FromDouble(y); point = PyTuple_New(2); PyTuple_SetItem(point, 0, px); PyTuple_SetItem(point, 1, py); PyList_SetItem(list, i, point); } } else if (psCShape->nSHPType == SHPT_POLYGON || psCShape->nSHPType == SHPT_POLYGONZ) { // read polygons from shp file count = psCShape->nParts > 1 ? psCShape->nParts : 1; parts = PyList_New(count); for (j=0; j <psCShape->nParts; j++) { if ( j < psCShape->nParts - 1) numPoints = psCShape->panPartStart[j+1] - psCShape->panPartStart[j]; else numPoints = psCShape->nVertices - psCShape->panPartStart[j]; s = psCShape->panPartStart[j]; vertices = PyList_New(numPoints); for (k=0; k < numPoints; k++) { x = psCShape->padfX[s+k]; y = psCShape->padfY[s+k]; px = PyFloat_FromDouble(x); py = PyFloat_FromDouble(y); point = PyTuple_New(2); PyTuple_SetItem(point, 0, px); PyTuple_SetItem(point, 1, py); PyList_SetItem(vertices, k, point); } PyList_SetItem(parts,j,vertices); } PyList_SetItem(list, i, parts); } SHPDestroyObject(psCShape); } // store the list if (map_dict == NULL) { map_dict = PyDict_New(); } PyDict_SetItemString(map_dict, shape_name, list); //Py_DECREF(list); return list; }
static PyObject* take_action(PyObject *arg_types, PyObject *children_list, int speculative, D_ParseNode *dd, PyObject *string_list, int n_children, struct D_Parser *parser, void **children, int pn_offset, PyObject *action) { int i; int arg_count = PyList_Size(arg_types); D_ParserPyInterface *ppi = d_interface(parser); PyObject *arglist = PyTuple_New(arg_count); PyObject *globals_holder = NULL; PyObject *result = NULL; Py_INCREF(children_list); PyTuple_SetItem(arglist, 0, children_list); for (i=1; i<arg_count; i++) { PyObject *item = PyList_GetItem(arg_types, i); int type = PyInt_AsLong(item); if (type == 1) { PyTuple_SetItem(arglist, i, Py_BuildValue("i", speculative)); } else if (type == 2) { if (!dd->user.inced_global_state) { dd->user.inced_global_state = 1; } globals_holder = PyList_New(1); Py_INCREF(dd->globals); PyList_SetItem(globals_holder, 0, dd->globals); PyTuple_SetItem(arglist, i, globals_holder); } else if (type == 3) { Py_INCREF(string_list); PyTuple_SetItem(arglist, i, string_list); } else if (type == 4) { PyObject* nodes = PyList_New(n_children); int j; for (j=0; j<n_children; j++) { PyList_SetItem(nodes, j, make_py_node(parser, D_PN(children[j], pn_offset))); } PyTuple_SetItem(arglist, i, nodes); } else if (type == 5) { PyTuple_SetItem(arglist, i, make_py_node(parser, dd)); } else if (type == 6) { Py_INCREF(Py_None); PyTuple_SetItem(arglist, i, Py_None); } else if (type == 7) { Py_INCREF(ppi->self); PyTuple_SetItem(arglist, i, ppi->self); } } result = PyEval_CallObject(action, arglist); if (globals_holder) { Py_DECREF(dd->globals); dd->globals = PyList_GetItem(globals_holder, 0); Py_INCREF(dd->globals); } Py_DECREF(arglist); return result; }
/** * @brief Sets the address where the request for the Apertium-APY will be sent * * The address will not be set if there is no response from an APY server <br> * pythonInit() must have been called before or an error will occur (the module is not loaded) * @param address Pointer to a string with the new address * @param port Pointer to a string with the new port. NULL if no port is needed * @param order Position this address will take in the list. Negative value to append at the end * @param force Any number that is not 0 indicates the function to forcefully change the address, * despite not receiving an answer from the server * @return 1 if the call was successful and the address was set, or 0 otherwise */ int setAPYAddress(char* address, char* port, int order, int force){ char* msg; PyObject *pFunc, *pArg, *pArgs, *new_address; if (iface_module != NULL) { pFunc = PyObject_GetAttrString(iface_module, "setAPYAddress"); if (pFunc) { pArgs = PyTuple_New(4); pArg = PyBytes_FromString(address); PyTuple_SetItem(pArgs, 0, pArg); pArg = port == NULL ? Py_None : PyBytes_FromString(port); PyTuple_SetItem(pArgs, 1, pArg); PyTuple_SetItem(pArgs, 2, order > -1 ? PyLong_FromLong(order) : Py_None); PyTuple_SetItem(pArgs, 3, force == 0 ? Py_False : Py_True); new_address = PyObject_CallObject(pFunc, pArgs); Py_XDECREF(pArgs); Py_XDECREF(pFunc); if (new_address != NULL){ if(new_address != Py_None){ if(files_module != NULL){ pFunc = PyObject_GetAttrString(files_module, "setKey"); if (pFunc) { pArgs = PyTuple_New(2); PyTuple_SetItem(pArgs, 0, PyUnicode_FromString("apyAddress")); PyTuple_SetItem(pArgs, 1, new_address); PyObject_CallObject(pFunc, pArgs); Py_XDECREF(new_address); } else{ Py_XDECREF(new_address); return 0; } } else{ notify_error("Module: \'apertiumFiles\' is not loaded"); return 0; } return 1; } else{ msg = malloc(sizeof(char)*(strlen(address)+(port == NULL ? 0 : strlen(port))+100)); if(port != NULL){ sprintf(msg,"No response from server at %s:%s",address,port); } else{ sprintf(msg,"No response from server at %s",address); } notify_error(msg); free(msg); return 0; } } else { return 0; } } else { return 0; } Py_XDECREF(pFunc); } else { notify_error("Module: \'apertiumInterfaceAPY\' is not loaded"); return 0; } }
int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThreadState *interpreter, int app_type) { PyObject *app_list = NULL, *applications = NULL; if (uwsgi_apps_cnt >= uwsgi.max_apps) { uwsgi_log("ERROR: you cannot load more than %d apps in a worker\n", uwsgi.max_apps); return -1; } int id = uwsgi_apps_cnt; int multiapp = 0; int i; struct uwsgi_app *wi; time_t now = uwsgi_now(); if (uwsgi_get_app_id(NULL, wsgi_req->appid, wsgi_req->appid_len, -1) != -1) { uwsgi_log( "mountpoint %.*s already configured. skip.\n", wsgi_req->appid_len, wsgi_req->appid); return -1; } wi = &uwsgi_apps[id]; memset(wi, 0, sizeof(struct uwsgi_app)); wi->modifier1 = python_plugin.modifier1; wi->mountpoint_len = wsgi_req->appid_len < 0xff ? wsgi_req->appid_len : (0xff-1); strncpy(wi->mountpoint, wsgi_req->appid, wi->mountpoint_len); // dynamic chdir ? if (wsgi_req->chdir_len > 0) { strncpy(wi->chdir, wsgi_req->chdir, wsgi_req->chdir_len < 0xff ? wsgi_req->chdir_len : (0xff-1)); #ifdef UWSGI_DEBUG uwsgi_debug("chdir to %s\n", wi->chdir); #endif if (chdir(wi->chdir)) { uwsgi_error("chdir()"); } } // Initialize a new environment for the new interpreter // reload "os" environ to allow dynamic setenv() if (up.reload_os_env) { char **e, *p; PyObject *k, *env_value; PyObject *os_module = PyImport_ImportModule("os"); if (os_module) { PyObject *os_module_dict = PyModule_GetDict(os_module); PyObject *py_environ = PyDict_GetItemString(os_module_dict, "environ"); if (py_environ) { for (e = environ; *e != NULL; e++) { p = strchr(*e, '='); if (p == NULL) continue; k = PyString_FromStringAndSize(*e, (int)(p-*e)); if (k == NULL) { PyErr_Print(); continue; } env_value = PyString_FromString(p+1); if (env_value == NULL) { PyErr_Print(); Py_DECREF(k); continue; } #ifdef UWSGI_DEBUG uwsgi_log("%s = %s\n", PyString_AsString(k), PyString_AsString(env_value)); #endif if (PyObject_SetItem(py_environ, k, env_value)) { PyErr_Print(); } Py_DECREF(k); Py_DECREF(env_value); } } } } if (interpreter == NULL && id) { wi->interpreter = Py_NewInterpreter(); if (!wi->interpreter) { uwsgi_log( "unable to initialize the new python interpreter\n"); exit(1); } PyThreadState_Swap(wi->interpreter); init_pyargv(); // we need to inizialize an embedded module for every interpreter init_uwsgi_embedded_module(); init_uwsgi_vars(); } else if (interpreter) { wi->interpreter = interpreter; } else { wi->interpreter = up.main_thread; } if (wsgi_req->home_len) { set_dyn_pyhome(wsgi_req->home, wsgi_req->home_len); } if (wsgi_req->touch_reload_len > 0 && wsgi_req->touch_reload_len < 0xff) { struct stat trst; strncpy(wi->touch_reload, wsgi_req->touch_reload, wsgi_req->touch_reload_len); if (!stat(wi->touch_reload, &trst)) { wi->touch_reload_mtime = trst.st_mtime; } } wi->callable = up.loaders[loader](arg1); if (!wi->callable) { uwsgi_log("unable to load app %d (mountpoint='%s') (callable not found or import error)\n", id, wi->mountpoint); goto doh; } // the module contains multiple apps if (PyDict_Check((PyObject *)wi->callable)) { applications = wi->callable; uwsgi_log("found a multiapp module...\n"); app_list = PyDict_Keys(applications); multiapp = PyList_Size(app_list); if (multiapp < 1) { uwsgi_log("you have to define at least one app in the apllications dictionary\n"); goto doh; } PyObject *app_mnt = PyList_GetItem(app_list, 0); if (!PyString_Check(app_mnt)) { uwsgi_log("the app mountpoint must be a string\n"); goto doh; } char *tmp_mountpoint = PyString_AsString(app_mnt); wi->mountpoint_len = strlen(wi->mountpoint) < 0xff ? strlen(wi->mountpoint) : (0xff-1); strncpy(wi->mountpoint, tmp_mountpoint, wi->mountpoint_len); wsgi_req->appid = wi->mountpoint; wsgi_req->appid_len = wi->mountpoint_len; #ifdef UWSGI_DEBUG uwsgi_log("main mountpoint = %s\n", wi->mountpoint); #endif wi->callable = PyDict_GetItem(applications, app_mnt); if (PyString_Check((PyObject *) wi->callable)) { PyObject *callables_dict = get_uwsgi_pydict((char *)arg1); if (callables_dict) { wi->callable = PyDict_GetItem(callables_dict, (PyObject *)wi->callable); } } } Py_INCREF((PyObject *)wi->callable); wi->environ = malloc(sizeof(PyObject*)*uwsgi.cores); if (!wi->environ) { uwsgi_error("malloc()"); exit(1); } for(i=0; i<uwsgi.cores; i++) { wi->environ[i] = PyDict_New(); if (!wi->environ[i]) { uwsgi_log("unable to allocate new env dictionary for app\n"); exit(1); } } wi->argc = 1; if (app_type == PYTHON_APP_TYPE_WSGI) { #ifdef UWSGI_DEBUG uwsgi_log("-- WSGI callable selected --\n"); #endif wi->request_subhandler = uwsgi_request_subhandler_wsgi; wi->response_subhandler = uwsgi_response_subhandler_wsgi; wi->argc = 2; } else if (app_type == PYTHON_APP_TYPE_WEB3) { #ifdef UWSGI_DEBUG uwsgi_log("-- Web3 callable selected --\n"); #endif wi->request_subhandler = uwsgi_request_subhandler_web3; wi->response_subhandler = uwsgi_response_subhandler_web3; } else if (app_type == PYTHON_APP_TYPE_PUMP) { #ifdef UWSGI_DEBUG uwsgi_log("-- Pump callable selected --\n"); #endif wi->request_subhandler = uwsgi_request_subhandler_pump; wi->response_subhandler = uwsgi_response_subhandler_pump; } wi->args = malloc(sizeof(PyObject*)*uwsgi.cores); if (!wi->args) { uwsgi_error("malloc()"); exit(1); } for(i=0; i<uwsgi.cores; i++) { wi->args[i] = PyTuple_New(wi->argc); if (!wi->args[i]) { uwsgi_log("unable to allocate new tuple for app args\n"); exit(1); } // add start_response on WSGI app Py_INCREF((PyObject *)up.wsgi_spitout); if (app_type == PYTHON_APP_TYPE_WSGI) { if (PyTuple_SetItem(wi->args[i], 1, up.wsgi_spitout)) { uwsgi_log("unable to set start_response in args tuple\n"); exit(1); } } } if (app_type == PYTHON_APP_TYPE_WSGI) { // prepare sendfile() for WSGI app wi->sendfile = PyCFunction_New(uwsgi_sendfile_method, NULL); wi->eventfd_read = PyCFunction_New(uwsgi_eventfd_read_method, NULL); wi->eventfd_write = PyCFunction_New(uwsgi_eventfd_write_method, NULL); } // cache most used values wi->error = PyFile_FromFile(stderr, "wsgi_errors", "w", NULL); Py_INCREF((PyObject *)wi->error); wi->gateway_version = PyTuple_New(2); PyTuple_SetItem(wi->gateway_version, 0, PyInt_FromLong(1)); PyTuple_SetItem(wi->gateway_version, 1, PyInt_FromLong(0)); Py_INCREF((PyObject *)wi->gateway_version); wi->uwsgi_version = PyString_FromString(UWSGI_VERSION); Py_INCREF((PyObject *)wi->uwsgi_version); wi->uwsgi_node = PyString_FromString(uwsgi.hostname); Py_INCREF((PyObject *)wi->uwsgi_node); if (uwsgi.threads > 1 && id) { // if we have multiple threads we need to initialize a PyThreadState for each one for(i=0; i<uwsgi.threads; i++) { //uwsgi_log("%p\n", uwsgi.core[i]->ts[id]); uwsgi.workers[uwsgi.mywid].cores[i].ts[id] = PyThreadState_New( ((PyThreadState *)wi->interpreter)->interp); if (!uwsgi.workers[uwsgi.mywid].cores[i].ts[id]) { uwsgi_log("unable to allocate new PyThreadState structure for app %s", wi->mountpoint); goto doh; } } PyThreadState_Swap((PyThreadState *) pthread_getspecific(up.upt_save_key) ); } else if (interpreter == NULL && id) { PyThreadState_Swap(up.main_thread); } const char *default_app = ""; if ((wsgi_req->appid_len == 0 || (wsgi_req->appid_len = 1 && wsgi_req->appid[0] == '/')) && uwsgi.default_app == -1) { default_app = " (default app)" ; uwsgi.default_app = id; } wi->started_at = now; wi->startup_time = uwsgi_now() - now; if (app_type == PYTHON_APP_TYPE_WSGI) { uwsgi_log( "WSGI app %d (mountpoint='%.*s') ready in %d seconds on interpreter %p pid: %d%s\n", id, wi->mountpoint_len, wi->mountpoint, (int) wi->startup_time, wi->interpreter, (int) getpid(), default_app); } else if (app_type == PYTHON_APP_TYPE_WEB3) { uwsgi_log( "Web3 app %d (mountpoint='%.*s') ready in %d seconds on interpreter %p pid: %d%s\n", id, wi->mountpoint_len, wi->mountpoint, (int) wi->startup_time, wi->interpreter, (int) getpid(), default_app); } else if (app_type == PYTHON_APP_TYPE_PUMP) { uwsgi_log( "Pump app %d (mountpoint='%.*s') ready in %d seconds on interpreter %p pid: %d%s\n", id, wi->mountpoint_len, wi->mountpoint, (int) wi->startup_time, wi->interpreter, (int) getpid(), default_app); } uwsgi_apps_cnt++; if (multiapp > 1) { for(i=1; i<multiapp; i++) { PyObject *app_mnt = PyList_GetItem(app_list, i); if (!PyString_Check(app_mnt)) { uwsgi_log("applications dictionary key must be a string, skipping.\n"); continue; } wsgi_req->appid = PyString_AsString(app_mnt); wsgi_req->appid_len = strlen(wsgi_req->appid); PyObject *a_callable = PyDict_GetItem(applications, app_mnt); if (PyString_Check(a_callable)) { PyObject *callables_dict = get_uwsgi_pydict((char *)arg1); if (callables_dict) { a_callable = PyDict_GetItem(callables_dict, a_callable); } } if (!a_callable) { uwsgi_log("skipping broken app %s\n", wsgi_req->appid); continue; } init_uwsgi_app(LOADER_CALLABLE, a_callable, wsgi_req, wi->interpreter, app_type); } } // emulate COW uwsgi_emulate_cow_for_apps(id); return id; doh: if (PyErr_Occurred()) PyErr_Print(); if (interpreter == NULL && id) { Py_EndInterpreter(wi->interpreter); if (uwsgi.threads > 1) { PyThreadState_Swap((PyThreadState *) pthread_getspecific(up.upt_save_key)); } else { PyThreadState_Swap(up.main_thread); } } return -1; }
/** * @brief Initializes the Python environment * * Loads both the apertiumFiles and apertiumInterfaceAPY modules, which are used by the plugin.<br> * All the functions in this file require this to be first called in order to work properly * @param filename Name of the file where the preferences for the plugin will be stored */ void pythonInit(const char* filename){ PyObject *pFunc, *pArgs, *addresses; Py_SetProgramName(NULL); Py_Initialize(); files_module = PyImport_ImportModule("apertiumpluginutils.apertiumFiles"); if (files_module != NULL) { pFunc = PyObject_GetAttrString(files_module, "setFile"); if (pFunc) { pArgs = PyTuple_New(1); PyTuple_SetItem(pArgs, 0, PyUnicode_FromString(filename)); PyObject_CallObject(pFunc, pArgs); Py_XDECREF(pArgs); } else { return; } Py_XDECREF(pFunc); pFunc = PyObject_GetAttrString(files_module, "read"); if (pFunc) { pArgs = PyTuple_New(0); PyObject_CallObject(pFunc, pArgs); Py_XDECREF(pArgs); } else { return; } Py_XDECREF(pFunc); pFunc = PyObject_GetAttrString(files_module, "getKey"); if (pFunc) { pArgs = PyTuple_New(1); PyTuple_SetItem(pArgs, 0, PyUnicode_FromString("apyAddress")); addresses = PyObject_CallObject(pFunc, pArgs); if(addresses == NULL || addresses == Py_None){ Py_XDECREF(pArgs); Py_XDECREF(pFunc); return; } Py_XDECREF(pArgs); } else { return; } Py_XDECREF(pFunc); } else { notify_error_popup("Failed to load module: \'apertiumFiles\'"); return; } iface_module = PyImport_ImportModule("apertiumpluginutils.apertiumInterfaceAPY"); if (iface_module != NULL) { pFunc = PyObject_GetAttrString(iface_module, "setAPYList"); if (pFunc) { pArgs = PyTuple_New(1); PyTuple_SetItem(pArgs, 0, addresses); if(PyObject_CallObject(pFunc, pArgs) == NULL){ Py_XDECREF(pFunc); Py_XDECREF(addresses); notify_error_popup("Error on setAPYList(result is null)"); return; } } else { notify_error_popup("Error on setAPYList(pfunc)"); return; } Py_XDECREF(pFunc); Py_XDECREF(addresses); } else{ notify_error_popup("Failed to load module: \'apertiumInterfaceAPY\'"); return; } }
int importPythonModule (char *binImg1_data, int binImg1_data_len, char *binImg2_data, char binImg2_data_len) { PyObject *pName, *pModule, *pDict, *pFunc; PyObject *pArgs, *pValue; int i; Py_Initialize(); pName = PyUnicode_DecodeFSDefault("face"); /* Error checking of pName left out */ pModule = PyImport_Import(pName); Py_DECREF(pName); if (pModule != NULL) { /* pFunc is a new reference */ pFunc = PyObject_GetAttrString(pModule, "get_images_from_cpp"); if (pFunc && PyCallable_Check(pFunc)) { pArgs = PyTuple_New(2); pValue = PyBytes_FromStringAndSize ( binImg2_data, binImg1_data_len);; if (!pValue) { Py_DECREF(pArgs); Py_DECREF(pModule); fprintf(stderr, "Cannot convert argument\n"); return 1; } /* pValue reference stolen here: */ PyTuple_SetItem(pArgs, 0, pValue); pValue = PyBytes_FromStringAndSize ( binImg2_data, binImg2_data_len);; if (!pValue) { Py_DECREF(pArgs); Py_DECREF(pModule); fprintf(stderr, "Cannot convert argument\n"); return 1; } /* pValue reference stolen here: */ PyTuple_SetItem(pArgs, 1, pValue); pValue = PyObject_CallObject(pFunc, pArgs); Py_DECREF(pArgs); if (pValue != NULL) { printf("Result of call: %f\n", PyLong_AsDouble(pValue)); Py_DECREF(pValue); } else { Py_DECREF(pFunc); Py_DECREF(pModule); PyErr_Print(); fprintf(stderr,"Call failed\n"); return 1; } } else { if (PyErr_Occurred()) { PyErr_Print(); } fprintf(stderr, "Cannot find function \"%s\"\n", "get_images_from_cpp"); } Py_XDECREF(pFunc); Py_DECREF(pModule); } else { PyErr_Print(); fprintf(stderr, "Failed to load \"%s\"\n", "face"); return 1; } Py_Finalize(); return 0; }
static void python_process_event(int cpu, void *data, int size __unused, unsigned long long nsecs, char *comm) { PyObject *handler, *retval, *context, *t, *obj; static char handler_name[256]; struct format_field *field; unsigned long long val; unsigned long s, ns; struct event *event; unsigned n = 0; int type; int pid; t = PyTuple_New(MAX_FIELDS); if (!t) Py_FatalError("couldn't create Python tuple"); type = trace_parse_common_type(data); event = find_cache_event(type); if (!event) die("ug! no event found for type %d", type); pid = trace_parse_common_pid(data); sprintf(handler_name, "%s__%s", event->system, event->name); s = nsecs / NSECS_PER_SEC; ns = nsecs - s * NSECS_PER_SEC; scripting_context->event_data = data; context = PyCObject_FromVoidPtr(scripting_context, NULL); PyTuple_SetItem(t, n++, PyString_FromString(handler_name)); PyTuple_SetItem(t, n++, PyCObject_FromVoidPtr(scripting_context, NULL)); PyTuple_SetItem(t, n++, PyInt_FromLong(cpu)); PyTuple_SetItem(t, n++, PyInt_FromLong(s)); PyTuple_SetItem(t, n++, PyInt_FromLong(ns)); PyTuple_SetItem(t, n++, PyInt_FromLong(pid)); PyTuple_SetItem(t, n++, PyString_FromString(comm)); for (field = event->format.fields; field; field = field->next) { if (field->flags & FIELD_IS_STRING) { int offset; if (field->flags & FIELD_IS_DYNAMIC) { offset = *(int *)(data + field->offset); offset &= 0xffff; } else offset = field->offset; obj = PyString_FromString((char *)data + offset); } else { /* FIELD_IS_NUMERIC */ val = read_size(data + field->offset, field->size); if (field->flags & FIELD_IS_SIGNED) { if ((long long)val >= LONG_MIN && (long long)val <= LONG_MAX) obj = PyInt_FromLong(val); else obj = PyLong_FromLongLong(val); } else { if (val <= LONG_MAX) obj = PyInt_FromLong(val); else obj = PyLong_FromUnsignedLongLong(val); } } PyTuple_SetItem(t, n++, obj); } if (_PyTuple_Resize(&t, n) == -1) Py_FatalError("error resizing Python tuple"); handler = PyDict_GetItemString(main_dict, handler_name); if (handler && PyCallable_Check(handler)) { retval = PyObject_CallObject(handler, t); if (retval == NULL) handler_call_die(handler_name); } else { handler = PyDict_GetItemString(main_dict, "trace_unhandled"); if (handler && PyCallable_Check(handler)) { if (_PyTuple_Resize(&t, N_COMMON_FIELDS) == -1) Py_FatalError("error resizing Python tuple"); retval = PyObject_CallObject(handler, t); if (retval == NULL) handler_call_die("trace_unhandled"); } } Py_DECREF(t); }
static PyObject *Py_FindObjects(PyObject *obj, PyObject *args) { PyArrayObject *input = NULL; PyObject *result = NULL, *tuple = NULL, *start = NULL, *end = NULL; PyObject *slc = NULL; int jj; npy_intp max_label; npy_intp ii, *regions = NULL; if (!PyArg_ParseTuple(args, "O&n", NI_ObjectToInputArray, &input, &max_label)) goto exit; if (max_label < 0) max_label = 0; if (max_label > 0) { if (PyArray_NDIM(input) > 0) { regions = (npy_intp*)malloc(2 * max_label * PyArray_NDIM(input) * sizeof(npy_intp)); } else { regions = (npy_intp*)malloc(max_label * sizeof(npy_intp)); } if (!regions) { PyErr_NoMemory(); goto exit; } } if (!NI_FindObjects(input, max_label, regions)) goto exit; result = PyList_New(max_label); if (!result) { PyErr_NoMemory(); goto exit; } for(ii = 0; ii < max_label; ii++) { npy_intp idx = PyArray_NDIM(input) > 0 ? 2 * PyArray_NDIM(input) * ii : ii; if (regions[idx] >= 0) { PyObject *tuple = PyTuple_New(PyArray_NDIM(input)); if (!tuple) { PyErr_NoMemory(); goto exit; } for(jj = 0; jj < PyArray_NDIM(input); jj++) { start = PyLong_FromSsize_t(regions[idx + jj]); end = PyLong_FromSsize_t(regions[idx + jj + PyArray_NDIM(input)]); if (!start || !end) { PyErr_NoMemory(); goto exit; } slc = PySlice_New(start, end, NULL); if (!slc) { PyErr_NoMemory(); goto exit; } Py_XDECREF(start); Py_XDECREF(end); start = end = NULL; PyTuple_SetItem(tuple, jj, slc); slc = NULL; } PyList_SetItem(result, ii, tuple); tuple = NULL; } else { Py_INCREF(Py_None); PyList_SetItem(result, ii, Py_None); } } Py_INCREF(result); exit: Py_XDECREF(input); Py_XDECREF(result); Py_XDECREF(tuple); Py_XDECREF(start); Py_XDECREF(end); Py_XDECREF(slc); free(regions); if (PyErr_Occurred()) { Py_XDECREF(result); return NULL; } else { return result; } }
/** ******************************************************************************************************* * This callback will be called with the results with aerospike_batch_exists(). * * @param err Error object * @param records An array of as_batch_read_record entries * @param py_recs The pyobject to be filled in with the return * value * * Returns boolean value(true or false). ******************************************************************************************************* */ static void batch_exists_recs(as_error *err, as_batch_read_records* records, PyObject **py_recs) { // Loop over records array as_vector* list = &records->list; for (uint32_t i = 0; i < list->size; i++) { as_batch_read_record* batch = as_vector_get(list, i); PyObject * rec = PyDict_New(); PyObject * p_key = NULL; PyObject * py_rec = NULL; py_rec = PyTuple_New(2); p_key = PyTuple_New(4); if ( batch->key.ns && strlen(batch->key.ns) > 0 ) { PyTuple_SetItem(p_key, 0, PyStr_FromString(batch->key.ns)); } if ( batch->key.set && strlen(batch->key.set) > 0 ) { PyTuple_SetItem(p_key, 1, PyStr_FromString(batch->key.set)); } if ( batch->key.valuep ) { switch(((as_val*)(batch->key.valuep))->type){ case AS_INTEGER: PyTuple_SetItem(p_key, 2, PyInt_FromLong((long)batch->key.value.integer.value)); break; case AS_STRING: PyTuple_SetItem(p_key, 2, PyStr_FromString((const char *)batch->key.value.string.value)); break; default: break; } } else { Py_INCREF(Py_None); PyTuple_SetItem(p_key, 2, Py_None); } if (batch->key.digest.init) { PyTuple_SetItem(p_key, 3, PyByteArray_FromStringAndSize((char *) batch->key.digest.value, AS_DIGEST_VALUE_SIZE)); } PyTuple_SetItem(py_rec, 0, p_key); if ( batch->result == AEROSPIKE_OK ){ PyObject *py_gen = PyInt_FromLong((long)batch->record.gen); PyDict_SetItemString( rec, "gen", py_gen ); Py_DECREF(py_gen); PyObject *py_ttl = PyInt_FromLong((long)batch->record.ttl); PyDict_SetItemString( rec, "ttl", py_ttl ); Py_DECREF(py_ttl); PyTuple_SetItem(py_rec, 1, rec); PyList_SetItem( *py_recs, i, py_rec ); } else if (batch->result == AEROSPIKE_ERR_RECORD_NOT_FOUND){ Py_DECREF(rec); Py_INCREF(Py_None); PyTuple_SetItem(py_rec, 1, Py_None); PyList_SetItem( *py_recs, i, py_rec); } } }
/** * @brief Python entry point for MSER * * @param pyArray * @param delta * @param max_area * @param min_area * @param max_variation * @param min_diversity * @return */ PyObject * vl_mser_python( PyArrayObject & pyArray, double delta, double max_area, double min_area, double max_variation, double min_diversity) { // check data type assert(pyArray.descr->type_num == PyArray_UBYTE); assert(pyArray.flags & NPY_FORTRAN); unsigned char * data = (unsigned char *) pyArray.data; unsigned int width = pyArray.dimensions[0]; unsigned int height = pyArray.dimensions[1]; VlMserFilt *filt = 0; int i, j, dof, nframes, q; vl_uint const *regions; float const *frames; npy_intp nregions; // image dims const int ndims = 2; int dims[ndims]; dims[0] = width; dims[1] = height; // mser filter filt = vl_mser_new(ndims, dims); // set parameters if (delta >= 0) vl_mser_set_delta(filt, (vl_mser_pix) delta); if (max_area >= 0) vl_mser_set_max_area(filt, max_area); if (min_area >= 0) vl_mser_set_min_area(filt, min_area); if (max_variation >= 0) vl_mser_set_max_variation(filt, max_variation); if (min_diversity >= 0) vl_mser_set_min_diversity(filt, min_diversity); // do mser computation vl_mser_process(filt, (vl_mser_pix*) data); // fit ellipses vl_mser_ell_fit(filt); // get results nregions = (npy_intp) vl_mser_get_regions_num(filt); regions = vl_mser_get_regions(filt); nframes = vl_mser_get_ell_num(filt); dof = vl_mser_get_ell_dof(filt); frames = vl_mser_get_ell(filt); // convert results to PyArrayObjects npy_intp odims[2]; odims[0] = dof; odims[1] = nframes; // allocate pyarray objects PyArrayObject * _regions = (PyArrayObject*) PyArray_SimpleNew( 1, (npy_intp*) &nregions, PyArray_DOUBLE); PyArrayObject * _frames = (PyArrayObject*) PyArray_NewFromDescr( &PyArray_Type, PyArray_DescrFromType(PyArray_DOUBLE), 2, odims, NULL, NULL, NPY_F_CONTIGUOUS, NULL); // check if valid pointers assert(_regions); assert(_frames); // fill pyarray objects double * _regions_buf = (double *) _regions->data; for (i = 0; i < nregions; ++i) { _regions_buf[i] = regions[i]; } double * _frames_buf = (double *) _frames->data; for (j = 0; j < dof; ++j) { for (i = 0; i < nframes; ++i) { _frames_buf[i * dof + j] = frames[i * dof + j]; //+ ((j < ndims) ? 1.0 : 0.0); } } // cleanup vl_mser_delete (filt) ; // construct tuple to return both results: (regions, frames) PyObject * tuple = PyTuple_New(2); PyTuple_SetItem(tuple, 0, PyArray_Return(_regions)); PyTuple_SetItem(tuple, 1, PyArray_Return(_frames)); return tuple; }
/** ******************************************************************************************************* * This callback will be called with the results with aerospike_batch_exists(). * * @param results An array of n as_batch_read entries * @param n The number of results from the batch request * @param udata The return value to be filled with result of * exists_many() * * Returns boolean value(true or false). ******************************************************************************************************* */ static bool batch_exists_cb(const as_batch_read* results, uint32_t n, void* udata) { // Typecast udata back to PyObject PyObject * py_recs = (PyObject *) udata; // Loop over results array for ( uint32_t i =0; i < n; i++ ){ PyObject * rec = PyDict_New(); PyObject * py_rec = NULL; PyObject * p_key = NULL; py_rec = PyTuple_New(2); p_key = PyTuple_New(4); if ( results[i].key->ns && strlen(results[i].key->ns) > 0 ) { PyTuple_SetItem(p_key, 0, PyStr_FromString(results[i].key->ns)); } if ( results[i].key->set && strlen(results[i].key->set) > 0 ) { PyTuple_SetItem(p_key, 1, PyStr_FromString(results[i].key->set)); } if ( results[i].key->valuep ) { switch(((as_val*)(results[i].key->valuep))->type){ case AS_INTEGER: PyTuple_SetItem(p_key, 2, PyInt_FromLong((long)results[i].key->value.integer.value)); break; case AS_STRING: PyTuple_SetItem(p_key, 2, PyStr_FromString((const char *)results[i].key->value.string.value)); break; default: break; } } else { Py_INCREF(Py_None); PyTuple_SetItem(p_key, 2, Py_None); } if (results[i].key->digest.init) { PyTuple_SetItem(p_key, 3, PyByteArray_FromStringAndSize((char *) results[i].key->digest.value, AS_DIGEST_VALUE_SIZE)); } PyTuple_SetItem(py_rec, 0, p_key); if ( results[i].result == AEROSPIKE_OK ){ PyObject *py_gen = PyInt_FromLong((long)results[i].record.gen); PyDict_SetItemString( rec, "gen", py_gen ); Py_DECREF(py_gen); PyObject *py_ttl = PyInt_FromLong((long)results[i].record.ttl); PyDict_SetItemString( rec, "ttl", py_ttl ); Py_DECREF(py_ttl); PyTuple_SetItem(py_rec, 1, rec); if ( PyList_SetItem( py_recs, i, py_rec ) ){ return false; } } else if (results[i].result == AEROSPIKE_ERR_RECORD_NOT_FOUND){ Py_DECREF(rec); Py_INCREF(Py_None); PyTuple_SetItem(py_rec, 1, Py_None); if( PyList_SetItem( py_recs, i, py_rec)){ return false; } } } return true; }
static PyObject* sctp_recv_msg(PyObject* dummy, PyObject* args) { int fd, max_len; struct sockaddr_storage sfrom; socklen_t sfrom_len = sizeof(sfrom); int family; int len; int port; char cfrom[256]; char *msg; int size; int flags; struct sctp_sndrcvinfo sinfo; PyObject* notification = PyDict_New(); PyObject* ret = 0; PyObject* oaddr = 0; if (! PyArg_ParseTuple(args, "ii", &fd, &max_len)) { return ret; } msg = malloc(max_len); if (! msg) { PyErr_SetString(PyExc_MemoryError, "Out of memory, malloc() failed"); return ret; } bzero(&sfrom, sizeof(sfrom)); bzero(&sinfo, sizeof(sinfo)); size = sctp_recvmsg(fd, msg, max_len, (struct sockaddr*) &sfrom, &sfrom_len, &sinfo, &flags); if (size < 0) { free(msg); PyErr_SetFromErrno(PyExc_IOError); return ret; } if (flags & MSG_NOTIFICATION) { interpret_notification(notification, msg, size); size = -1; } else { interpret_sndrcvinfo(notification, &sinfo); } if (from_sockaddr((struct sockaddr*) &sfrom, &family, &len, &port, cfrom, sizeof(cfrom))) { oaddr = PyTuple_New(2); PyTuple_SetItem(oaddr, 0, PyString_FromString(cfrom)); PyTuple_SetItem(oaddr, 1, PyInt_FromLong(port)); } else { // something went wrong oaddr = Py_None; Py_INCREF(Py_None); } ret = PyTuple_New(4); PyTuple_SetItem(ret, 0, oaddr); PyTuple_SetItem(ret, 1, PyInt_FromLong(flags)); if (size >= 0) { PyTuple_SetItem(ret, 2, PyString_FromStringAndSize(msg, size)); } else { PyTuple_SetItem(ret, 2, Py_None); Py_INCREF(Py_None); } PyTuple_SetItem(ret, 3, notification); free(msg); return ret; }
int python_exec2(struct sip_msg *_msg, char *method_name, char *mystr) { PyObject *pFunc, *pArgs, *pValue, *pResult; PyObject *msg; int rval; PyEval_AcquireLock(); PyThreadState_Swap(myThreadState); pFunc = PyObject_GetAttrString(handler_obj, method_name); if (pFunc == NULL || !PyCallable_Check(pFunc)) { LM_ERR("%s not found or is not callable\n", method_name); Py_XDECREF(pFunc); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } msg = newmsgobject(_msg); if (msg == NULL) { LM_ERR("can't create MSGtype instance\n"); Py_DECREF(pFunc); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } pArgs = PyTuple_New(mystr == NULL ? 1 : 2); if (pArgs == NULL) { LM_ERR("PyTuple_New() has failed\n"); msg_invalidate(msg); Py_DECREF(msg); Py_DECREF(pFunc); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } PyTuple_SetItem(pArgs, 0, msg); /* Tuple steals msg */ if (mystr != NULL) { pValue = PyString_FromString(mystr); if (pValue == NULL) { LM_ERR("PyString_FromString(%s) has failed\n", mystr); msg_invalidate(msg); Py_DECREF(pArgs); Py_DECREF(pFunc); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } PyTuple_SetItem(pArgs, 1, pValue); /* Tuple steals pValue */ } pResult = PyObject_CallObject(pFunc, pArgs); msg_invalidate(msg); Py_DECREF(pArgs); Py_DECREF(pFunc); if (PyErr_Occurred()) { Py_XDECREF(pResult); python_handle_exception("python_exec2"); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } if (pResult == NULL) { LM_ERR("PyObject_CallObject() returned NULL\n"); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } rval = PyInt_AsLong(pResult); Py_DECREF(pResult); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return rval; }
void Pywrap::AddArgument (unsigned int argument) { PyTuple_SetItem(args, index, PyInt_FromSize_t(argument)); index++; }
static gboolean wrap_frame_done_cb (GdkPixbufLoader *loader, GdkPixbufFrame *frame, gpointer data) { PyObject *result, *func, *func_data, *frame_python, *loader_python; PyObject *func_data_orig; PyObject *crap; int check; long ret; int func_data_length; //PyGTK_BLOCK_THREADS dbg(); func = (PyObject *) gtk_object_get_data (GTK_OBJECT (loader), "py_frame_done_cb_func"); func_data_orig = (PyObject *) gtk_object_get_data (GTK_OBJECT (loader), "py_frame_done_cb_data"); Py_XINCREF (func_data_orig); /*FIXME check if frame_python == NULL ? */ frame_python = PyGdkPixbuf_FrameNew (frame); if (!PyTuple_Check (func_data_orig)) { dprint ("f**k, func_data_orig isn't a tuple.\n"); PyErr_SetString (PyExc_TypeError, "func_data_orig isn't a tuple"); goto error; } func_data_length = PyTuple_Size (func_data_orig); dprint ("func_data_length == %d\n", func_data_length); func_data = PyTuple_New (func_data_length + 2); if (func_data == NULL) goto error; //if (!PyList_Check (func_data)) // dprint ("f**k, func_data isn't a list.\n"); //Py_XINCREF (func_data); loader_python = PyGtk_New ((GtkObject *) loader); //Py_XINCREF (loader_python); // crap = PyTuple_GetItem (func_data, 0); //, loader_python); // PyObject_Print (crap, stderr, Py_PRINT_RAW); // Py_XDECREF (crap); check = PyTuple_SetItem (func_data, 0, loader_python); //check = PyList_SetItem (func_data, 0, loader_python); dprint ("tried to set item\n"); if (check != 0) { //dprint ("error appending Loader to arg tuple %d\n", check); //Py_XDECREF (func_data); //Py_XDECREF (frame_python); //return TRUE; //PyErr_SetString (PyExc_RuntimeError, // "error appending frame to arg tuple\n"); goto error; } check = PyTuple_SetItem (func_data, 1, frame_python); //check = PyList_SetItem (func_data, 1, frame_python); if (check != 0) { //dprint ("error appending frame to arg tuple %d\n", check); goto error; } result = PyObject_CallObject (func, func_data); if (result == NULL) { //PyErr_Print (); //PyErr_Clear (); //PyObject_Print (func, stderr, Py_PRINT_RAW); //dprint ("error calling function\n"); goto error; } if (PyInt_Check (result)) ret = PyInt_AsLong (result); else { dprint ("return value of cb isn't an int??\n"); Py_XDECREF (result); PyErr_SetString (PyExc_RuntimeError, "return value of cb isn't an int??\n"); goto error; } Py_XDECREF (result); return (gboolean) ret; error: Py_XDECREF (func_data); Py_XDECREF (frame_python); //dprint ("error calling frame_done_cb\n"); //if (0) //(PyGtk_FatalExceptions) if (PyGtk_FatalExceptions) { //PyErr_Print (); //PyErr_Clear (); gtk_main_quit (); } else { PyErr_Print (); PyErr_Clear (); } //PyGTK_UNBLOCK_THREADS return TRUE; }