static int AerospikeClient_Type_Init(AerospikeClient * self, PyObject * args, PyObject * kwds) { PyObject * py_config = NULL; static char * kwlist[] = {"config", NULL}; if ( PyArg_ParseTupleAndKeywords(args, kwds, "O:client", kwlist, &py_config) == false ) { return -1; } if ( ! PyDict_Check(py_config) ) { return -1; } as_config config; as_config_init(&config); bool lua_system_path = FALSE; bool lua_user_path = FALSE; PyObject * py_lua = PyDict_GetItemString(py_config, "lua"); if ( py_lua && PyDict_Check(py_lua) ) { PyObject * py_lua_system_path = PyDict_GetItemString(py_lua, "system_path"); if ( py_lua_system_path && PyString_Check(py_lua_system_path) ) { lua_system_path = TRUE; memcpy(config.lua.system_path, PyString_AsString(py_lua_system_path), AS_CONFIG_PATH_MAX_LEN); } PyObject * py_lua_user_path = PyDict_GetItemString(py_lua, "user_path"); if ( py_lua_user_path && PyString_Check(py_lua_user_path) ) { lua_user_path = TRUE; memcpy(config.lua.user_path, PyString_AsString(py_lua_user_path), AS_CONFIG_PATH_MAX_LEN); } } if ( ! lua_system_path ) { PyObject * py_prefix = PySys_GetObject("prefix"); if ( py_prefix && PyString_Check(py_prefix) ) { char * prefix = PyString_AsString(py_prefix); size_t prefix_len = strlen(prefix); char system_path[AS_CONFIG_PATH_MAX_LEN] = {0}; memcpy(system_path, prefix, strlen(prefix)); memcpy(system_path + prefix_len, "/aerospike/lua", AS_CONFIG_PATH_MAX_LEN - prefix_len); system_path[prefix_len + strlen("/aerospike/lua")] = '\0'; struct stat info; if( stat( system_path, &info ) == 0 && (info.st_mode & S_IFDIR) ) { memcpy(config.lua.system_path, system_path, AS_CONFIG_PATH_MAX_LEN); } else { memcpy(system_path + prefix_len, "/local/aerospike/lua", AS_CONFIG_PATH_MAX_LEN - prefix_len); system_path[prefix_len + strlen("/local/aerospike/lua")] = '\0'; if( stat( system_path, &info ) == 0 && (info.st_mode & S_IFDIR) ) { memcpy(config.lua.system_path, system_path, AS_CONFIG_PATH_MAX_LEN); } else { config.lua.system_path[0] = '\0'; } } } } if ( ! lua_user_path ) { memcpy(config.lua.user_path, ".", AS_CONFIG_PATH_MAX_LEN); } PyObject * py_hosts = PyDict_GetItemString(py_config, "hosts"); if ( py_hosts && PyList_Check(py_hosts) ) { int size = (int) PyList_Size(py_hosts); for ( int i = 0; i < size && i < AS_CONFIG_HOSTS_SIZE; i++ ) { char *addr = NULL; uint16_t port = 3000; PyObject * py_host = PyList_GetItem(py_hosts, i); PyObject * py_addr, * py_port; if( PyTuple_Check(py_host) && PyTuple_Size(py_host) == 2) { py_addr = PyTuple_GetItem(py_host, 0); if(PyString_Check(py_addr)) { addr = strdup(PyString_AsString(py_addr)); } py_port = PyTuple_GetItem(py_host,1); if( PyInt_Check(py_port) || PyLong_Check(py_port) ) { port = (uint16_t) PyLong_AsLong(py_port); } else { port = 0; } } else if ( PyString_Check(py_host) ) { addr = strdup( strtok( PyString_AsString(py_host), ":" ) ); addr = strtok(addr, ":"); char *temp = strtok(NULL, ":"); if(NULL != temp) { port = (uint16_t)atoi(temp); } } as_config_add_host(&config, addr, port); } } PyObject * py_shm = PyDict_GetItemString(py_config, "shm"); if (py_shm && PyDict_Check(py_shm) ) { config.use_shm = true; PyObject * py_shm_max_nodes = PyDict_GetItemString( py_shm, "shm_max_nodes" ); if(py_shm_max_nodes && PyInt_Check(py_shm_max_nodes) ) { config.shm_max_nodes = PyInt_AsLong(py_shm_max_nodes); } PyObject * py_shm_max_namespaces = PyDict_GetItemString(py_shm, "shm_max_namespaces"); if(py_shm_max_namespaces && PyInt_Check(py_shm_max_namespaces) ) { config.shm_max_namespaces = PyInt_AsLong(py_shm_max_namespaces); } PyObject* py_shm_takeover_threshold_sec = PyDict_GetItemString(py_shm, "shm_takeover_threshold_sec"); if(py_shm_takeover_threshold_sec && PyInt_Check(py_shm_takeover_threshold_sec) ) { config.shm_takeover_threshold_sec = PyInt_AsLong( py_shm_takeover_threshold_sec); } } self->is_client_put_serializer = false; self->user_serializer_call_info.callback = NULL; self->user_deserializer_call_info.callback = NULL; PyObject *py_serializer_option = PyDict_GetItemString(py_config, "serialization"); if (py_serializer_option && PyTuple_Check(py_serializer_option)) { PyObject *py_serializer = PyTuple_GetItem(py_serializer_option, 0); if (py_serializer && py_serializer != Py_None) { if (!PyCallable_Check(py_serializer)) { return -1; } memset(&self->user_serializer_call_info, 0, sizeof(self->user_serializer_call_info)); self->user_serializer_call_info.callback = py_serializer; } PyObject *py_deserializer = PyTuple_GetItem(py_serializer_option, 1); if (py_deserializer && py_deserializer != Py_None) { if (!PyCallable_Check(py_deserializer)) { return -1; } memset(&self->user_deserializer_call_info, 0, sizeof(self->user_deserializer_call_info)); self->user_deserializer_call_info.callback = py_deserializer; } } as_policies_init(&config.policies); PyObject * py_policies = PyDict_GetItemString(py_config, "policies"); if ( py_policies && PyDict_Check(py_policies)) { //global defaults setting PyObject * py_key_policy = PyDict_GetItemString(py_policies, "key"); if ( py_key_policy && PyInt_Check(py_key_policy) ) { config.policies.key = PyInt_AsLong(py_key_policy); } PyObject * py_timeout = PyDict_GetItemString(py_policies, "timeout"); if ( py_timeout && PyInt_Check(py_timeout) ) { config.policies.timeout = PyInt_AsLong(py_timeout); } PyObject * py_retry = PyDict_GetItemString(py_policies, "retry"); if ( py_retry && PyInt_Check(py_retry) ) { config.policies.retry = PyInt_AsLong(py_retry); } PyObject * py_exists = PyDict_GetItemString(py_policies, "exists"); if ( py_exists && PyInt_Check(py_exists) ) { config.policies.exists = PyInt_AsLong(py_exists); } PyObject * py_replica = PyDict_GetItemString(py_policies, "replica"); if ( py_replica && PyInt_Check(py_replica) ) { config.policies.replica = PyInt_AsLong(py_replica); } PyObject * py_consistency_level = PyDict_GetItemString(py_policies, "consistency_level"); if ( py_consistency_level && PyInt_Check(py_consistency_level) ) { config.policies.consistency_level = PyInt_AsLong(py_consistency_level); } PyObject * py_commit_level = PyDict_GetItemString(py_policies, "commit_level"); if ( py_commit_level && PyInt_Check(py_commit_level) ) { config.policies.commit_level = PyInt_AsLong(py_commit_level); } /* * Generation policy is removed from constructor. */ } //conn_timeout_ms PyObject * py_connect_timeout = PyDict_GetItemString(py_config, "connect_timeout"); if ( py_connect_timeout && PyInt_Check(py_connect_timeout) ) { config.conn_timeout_ms = PyInt_AsLong(py_connect_timeout); } self->as = aerospike_new(&config); return 0; }
int eMainloop::processOneEvent(unsigned int twisted_timeout, PyObject **res, ePyObject additional) { int return_reason = 0; /* get current time */ if (additional && !PyDict_Check(additional)) eFatal("additional, but it's not dict"); if (additional && !res) eFatal("additional, but no res"); long poll_timeout = -1; /* infinite in case of empty timer list */ { ePtrList<eTimer>::iterator it = m_timer_list.begin(); if (it != m_timer_list.end()) { eTimer *tmr = *it; timespec now; clock_gettime(CLOCK_MONOTONIC, &now); /* process all timers which are ready. first remove them out of the list. */ while (tmr->needsActivation(now)) { m_timer_list.erase(it); tmr->AddRef(); tmr->activate(); tmr->Release(); it = m_timer_list.begin(); if (it == m_timer_list.end()) break; tmr = *it; } it = m_timer_list.begin(); if (it != m_timer_list.end()) poll_timeout = timeout_usec((*it)->getNextActivation()); if (poll_timeout < 0) poll_timeout = 0; else /* convert us to ms */ poll_timeout /= 1000; } } if ((twisted_timeout > 0) && (poll_timeout > 0) && ((unsigned int)poll_timeout > twisted_timeout)) { poll_timeout = twisted_timeout; return_reason = 1; } int nativecount=notifiers.size(), fdcount=nativecount, ret=0; if (additional) fdcount += PyDict_Size(additional); // build the poll aray pollfd pfd[fdcount]; // make new pollfd array std::map<int,eSocketNotifier*>::iterator it = notifiers.begin(); int i=0; for (; i < nativecount; ++i, ++it) { it->second->state = 1; // running and in poll pfd[i].fd = it->first; pfd[i].events = it->second->getRequested(); } if (additional) { #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) typedef int Py_ssize_t; # define PY_SSIZE_T_MAX INT_MAX # define PY_SSIZE_T_MIN INT_MIN #endif PyObject *key, *val; Py_ssize_t pos=0; while (PyDict_Next(additional, &pos, &key, &val)) { pfd[i].fd = PyObject_AsFileDescriptor(key); pfd[i++].events = PyInt_AsLong(val); } } m_is_idle = 1; ++m_idle_count; if (this == eApp) { Py_BEGIN_ALLOW_THREADS ret = ::poll(pfd, fdcount, poll_timeout); Py_END_ALLOW_THREADS } else
PyObject * convertEpetraMultiVectorToDistAarray(const Epetra_MultiVector & emv) { // Initialization PyObject * dap = NULL; PyObject * dim_data = NULL; PyObject * dim_dict = NULL; PyObject * size = NULL; PyObject * buffer = NULL; Py_ssize_t ndim = 1; npy_intp dims[3]; // Get the underlying Epetra_BlockMap const Epetra_BlockMap & ebm = emv.Map(); // Allocate the DistArray object and set the version key value dap = PyDict_New(); if (!dap) goto fail; if (PyDict_SetItemString(dap, "__version__", PyString_FromString("0.9.0")) == -1) goto fail; // Get the Dimension Data and the number of dimensions. If the // underlying Epetra_BlockMap has variable element sizes, an error // will be detected here. dim_data = convertEpetraBlockMapToDimData(ebm, emv.NumVectors()); if (!dim_data) goto fail; ndim = PyTuple_Size(dim_data); // Assign the Dimension Data key value. if (PyDict_SetItemString(dap, "dim_data", dim_data) == -1) goto fail; // Extract the buffer dimensions from the Dimension Data, construct // the buffer and assign the buffer key value for (Py_ssize_t i = 0; i < ndim; ++i) { dim_dict = PyTuple_GetItem(dim_data, i); if (!dim_dict) goto fail; size = PyDict_GetItemString(dim_dict, "size"); if (!size) goto fail; dims[i] = PyInt_AsLong(size); if (PyErr_Occurred()) goto fail; } buffer = PyArray_SimpleNewFromData(ndim, dims, NPY_DOUBLE, (void*)emv[0]); if (!buffer) goto fail; if (PyDict_SetItemString(dap, "buffer", buffer) == -1) goto fail; // Return the DistArray Protocol object return dap; // Error handling fail: Py_XDECREF(dap); Py_XDECREF(dim_data); Py_XDECREF(dim_dict); Py_XDECREF(buffer); return NULL; }
static int child_init(int rank) { PyObject *pFunc, *pArgs, *pValue, *pResult; int rval; char *classname; PyEval_AcquireLock(); PyThreadState_Swap(myThreadState); // get instance class name classname = get_instance_class_name(_sr_apy_handler_obj); if (classname == NULL) { if (!PyErr_Occurred()) PyErr_Format(PyExc_AttributeError, "'module' instance has no class name"); python_handle_exception("child_init"); Py_DECREF(format_exc_obj); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } pFunc = PyObject_GetAttrString(_sr_apy_handler_obj, child_init_mname.s); if (pFunc == NULL) { python_handle_exception("child_init"); Py_XDECREF(pFunc); Py_DECREF(format_exc_obj); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } if (!PyCallable_Check(pFunc)) { if (!PyErr_Occurred()) PyErr_Format(PyExc_AttributeError, "class object '%s' has is not callable attribute '%s'", !classname ? "None" : classname, mod_init_fname.s); python_handle_exception("child_init"); Py_DECREF(format_exc_obj); Py_XDECREF(pFunc); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } pArgs = PyTuple_New(1); if (pArgs == NULL) { python_handle_exception("child_init"); Py_DECREF(format_exc_obj); Py_DECREF(pFunc); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } pValue = PyInt_FromLong((long)rank); if (pValue == NULL) { python_handle_exception("child_init"); Py_DECREF(format_exc_obj); Py_DECREF(pArgs); Py_DECREF(pFunc); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } PyTuple_SetItem(pArgs, 0, pValue); /* pValue has been stolen */ pResult = PyObject_CallObject(pFunc, pArgs); Py_DECREF(pFunc); Py_DECREF(pArgs); if (PyErr_Occurred()) { python_handle_exception("child_init"); Py_DECREF(format_exc_obj); Py_XDECREF(pResult); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } if (pResult == NULL) { LM_ERR("PyObject_CallObject() returned NULL but no exception!\n"); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } if (!PyInt_Check(pResult)) { if (!PyErr_Occurred()) PyErr_Format(PyExc_TypeError, "method '%s' of class '%s' should return 'int' type", child_init_mname.s, !classname ? "None" : classname); python_handle_exception("child_init"); Py_DECREF(format_exc_obj); Py_XDECREF(pResult); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return -1; } rval = PyInt_AsLong(pResult); Py_DECREF(pResult); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); return rval; }
int main(int argc, char *argv[]) { PyObject *pName, *pModule, *pDict, *pFunc; PyObject *pArgs, *pValue; int i; if (argc < 3) { fprintf(stderr,"Usage: call pythonfile funcname [args]\n"); return 1; } Py_Initialize(); pName = PyString_FromString(argv[1]); /* Error checking of pName left out */ pModule = PyImport_Import(pName); Py_DECREF(pName); if (pModule != NULL) { pFunc = PyObject_GetAttrString(pModule, argv[2]); /* pFunc is a new reference */ if (pFunc && PyCallable_Check(pFunc)) { pArgs = PyTuple_New(argc - 3); for (i = 0; i < argc - 3; ++i) { pValue = PyInt_FromLong(atoi(argv[i + 3])); if (!pValue) { Py_DECREF(pArgs); Py_DECREF(pModule); fprintf(stderr, "Cannot convert argument\n"); return 1; } /* pValue reference stolen here: */ PyTuple_SetItem(pArgs, i, pValue); } pValue = PyObject_CallObject(pFunc, pArgs); Py_DECREF(pArgs); if (pValue != NULL) { printf("Result of call: %ld\n", PyInt_AsLong(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", argv[2]); } Py_XDECREF(pFunc); Py_DECREF(pModule); } else { PyErr_Print(); fprintf(stderr, "Failed to load \"%s\"\n", argv[1]); return 1; } Py_Finalize(); return 0; }
static void gevent_loop() { if (!uwsgi.has_threads && uwsgi.mywid == 1) { uwsgi_log("!!! Running gevent without threads IS NOT recommended, enable them with --enable-threads !!!\n"); } if (uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT] < 30) { uwsgi_log("!!! Running gevent with a socket-timeout lower than 30 seconds is not recommended, tune it with --socket-timeout !!!\n"); } // get the GIL UWSGI_GET_GIL up.gil_get = gil_gevent_get; up.gil_release = gil_gevent_release; uwsgi.wait_write_hook = uwsgi_gevent_wait_write_hook; uwsgi.wait_read_hook = uwsgi_gevent_wait_read_hook; struct uwsgi_socket *uwsgi_sock = uwsgi.sockets; if (uwsgi.async < 2) { uwsgi_log("the gevent loop engine requires async mode (--async <n>)\n"); exit(1); } uwsgi.current_wsgi_req = uwsgi_gevent_current_wsgi_req; PyObject *gevent_dict = get_uwsgi_pydict("gevent"); if (!gevent_dict) uwsgi_pyexit; PyObject *gevent_version = PyDict_GetItemString(gevent_dict, "version_info"); if (!gevent_version) uwsgi_pyexit; if (PyInt_AsLong(PyTuple_GetItem(gevent_version, 0)) < 1) { uwsgi_log("uWSGI requires at least gevent 1.x version\n"); exit(1); } ugevent.spawn = PyDict_GetItemString(gevent_dict, "spawn"); if (!ugevent.spawn) uwsgi_pyexit; ugevent.signal = PyDict_GetItemString(gevent_dict, "signal"); if (!ugevent.signal) uwsgi_pyexit; ugevent.greenlet_switch = PyDict_GetItemString(gevent_dict, "sleep"); if (!ugevent.greenlet_switch) uwsgi_pyexit; ugevent.greenlet_switch_args = PyTuple_New(0); Py_INCREF(ugevent.greenlet_switch_args); PyObject *gevent_get_hub = PyDict_GetItemString(gevent_dict, "get_hub"); ugevent.hub = python_call(gevent_get_hub, PyTuple_New(0), 0, NULL); if (!ugevent.hub) uwsgi_pyexit; ugevent.get_current = PyDict_GetItemString(gevent_dict, "getcurrent"); if (!ugevent.get_current) uwsgi_pyexit; ugevent.get_current_args = PyTuple_New(0); Py_INCREF(ugevent.get_current_args); ugevent.hub_loop = PyObject_GetAttrString(ugevent.hub, "loop"); if (!ugevent.hub_loop) uwsgi_pyexit; // main greenlet waiting for connection (one greenlet per-socket) PyObject *uwsgi_gevent_main = PyCFunction_New(uwsgi_gevent_main_def, NULL); Py_INCREF(uwsgi_gevent_main); // greenlet to run at each request PyObject *uwsgi_request_greenlet = PyCFunction_New(uwsgi_gevent_request_def, NULL); Py_INCREF(uwsgi_request_greenlet); // pre-fill the greenlet args ugevent.greenlet_args = PyTuple_New(2); PyTuple_SetItem(ugevent.greenlet_args, 0, uwsgi_request_greenlet); if (uwsgi.signal_socket > -1) { // and these are the watcher for signal sockets ugevent.signal_watcher = PyObject_CallMethod(ugevent.hub_loop, "io", "ii", uwsgi.signal_socket, 1); if (!ugevent.signal_watcher) uwsgi_pyexit; ugevent.my_signal_watcher = PyObject_CallMethod(ugevent.hub_loop, "io", "ii", uwsgi.my_signal_socket, 1); if (!ugevent.my_signal_watcher) uwsgi_pyexit; PyObject *uwsgi_greenlet_signal = PyCFunction_New(uwsgi_gevent_signal_def, NULL); Py_INCREF(uwsgi_greenlet_signal); PyObject *uwsgi_greenlet_my_signal = PyCFunction_New(uwsgi_gevent_my_signal_def, NULL); Py_INCREF(uwsgi_greenlet_my_signal); PyObject *uwsgi_greenlet_signal_handler = PyCFunction_New(uwsgi_gevent_signal_handler_def, NULL); Py_INCREF(uwsgi_greenlet_signal_handler); ugevent.signal_args = PyTuple_New(2); PyTuple_SetItem(ugevent.signal_args, 0, uwsgi_greenlet_signal_handler); // start the two signal watchers if (!PyObject_CallMethod(ugevent.signal_watcher, "start", "O", uwsgi_greenlet_signal)) uwsgi_pyexit; if (!PyObject_CallMethod(ugevent.my_signal_watcher, "start", "O", uwsgi_greenlet_my_signal)) uwsgi_pyexit; } // start a greenlet for each socket ugevent.watchers = uwsgi_malloc(sizeof(PyObject *) * uwsgi_count_sockets(uwsgi.sockets)); int i = 0; while(uwsgi_sock) { // this is the watcher for server socket ugevent.watchers[i] = PyObject_CallMethod(ugevent.hub_loop, "io", "ii", uwsgi_sock->fd, 1); if (!ugevent.watchers[i]) uwsgi_pyexit; // start the main greenlet PyObject_CallMethod(ugevent.watchers[i], "start", "Ol", uwsgi_gevent_main,(long)uwsgi_sock); uwsgi_sock = uwsgi_sock->next; i++; } // patch goodbye_cruel_world uwsgi.gbcw_hook = uwsgi_gevent_gbcw; // map SIGHUP with gevent.signal PyObject *ge_signal_tuple = PyTuple_New(2); PyTuple_SetItem(ge_signal_tuple, 0, PyInt_FromLong(SIGHUP)); PyObject *uwsgi_gevent_unix_signal_handler = PyCFunction_New(uwsgi_gevent_unix_signal_handler_def, NULL); Py_INCREF(uwsgi_gevent_unix_signal_handler); PyTuple_SetItem(ge_signal_tuple, 1, uwsgi_gevent_unix_signal_handler); python_call(ugevent.signal, ge_signal_tuple, 0, NULL); for(;;) { if (!PyObject_CallMethod(ugevent.hub, "join", NULL)) { PyErr_Print(); } else { break; } } if (uwsgi.workers[uwsgi.mywid].manage_next_request == 0) { uwsgi_log("goodbye to the gevent Hub on worker %d (pid: %d)\n", uwsgi.mywid, uwsgi.mypid); if (ugevent.destroy) { exit(0); } exit(UWSGI_RELOAD_CODE); } uwsgi_log("the gevent Hub is no more :(\n"); }
int uwsgi_python_spooler(char *filename, char *buf, uint16_t len, char *body, size_t body_len) { static int random_seed_reset = 0; UWSGI_GET_GIL; PyObject *spool_dict = PyDict_New(); PyObject *spool_func, *pyargs, *ret; if (!random_seed_reset) { uwsgi_python_reset_random_seed(); random_seed_reset = 1; } if (!up.embedded_dict) { // ignore UWSGI_RELEASE_GIL; return 0; } spool_func = PyDict_GetItemString(up.embedded_dict, "spooler"); if (!spool_func) { // ignore UWSGI_RELEASE_GIL; return 0; } if (uwsgi_hooked_parse(buf, len, uwsgi_python_add_item, spool_dict)) { // malformed packet, destroy it UWSGI_RELEASE_GIL; return -2; } pyargs = PyTuple_New(1); PyDict_SetItemString(spool_dict, "spooler_task_name", PyString_FromString(filename)); if (body && body_len > 0) { PyDict_SetItemString(spool_dict, "body", PyString_FromStringAndSize(body, body_len)); } PyTuple_SetItem(pyargs, 0, spool_dict); ret = python_call(spool_func, pyargs, 0, NULL); if (ret) { if (!PyInt_Check(ret)) { // error, retry UWSGI_RELEASE_GIL; return -1; } int retval = (int) PyInt_AsLong(ret); UWSGI_RELEASE_GIL; return retval; } if (PyErr_Occurred()) PyErr_Print(); // error, retry UWSGI_RELEASE_GIL; return -1; }
it is in 0.3 of the list\n\ \n\ "; static PyObject *clistfns_contents(PyObject *self, PyObject *args) { int i; PyObject *items, *counts, *percentages; PyObject *countitems, *countitem; PyObject *key, *count, *perc; long c; double total; if(!PyArg_ParseTuple(args, "O", &items)) return NULL; if(!PySequence_Check(items)) { PyErr_SetString(PyExc_TypeError, "expected mapping type"); return NULL; } if((total = PySequence_Length(items)) == -1) { PyErr_SetString(PyExc_ValueError, "I couldn't get length of item."); return NULL; } counts = clistfns_count(self, args); if(!counts || PyErr_Occurred()) return NULL; if(!(percentages = PyDict_New())) { Py_DECREF(counts); return NULL; } /* Loop through every element in counts, calculating the probabilities. */ if(!(countitems = PyMapping_Items(counts))) { Py_DECREF(counts); Py_DECREF(percentages); return NULL; } /* Go through the loop, counting how often each item appears. */ i = 0; while(1) { if(!(countitem = PyList_GetItem(countitems, i))) { PyErr_Clear(); /* clear the exception set by PyList_GetItem */ break; /* no more numbers */ } key = PyTuple_GetItem(countitem, 0); count = PyTuple_GetItem(countitem, 1); c = PyInt_AsLong(count); perc = PyFloat_FromDouble((double)c / total); PyDict_SetItem(percentages, key, perc); Py_DECREF(perc); if(PyErr_Occurred()) /* PyDict_SetItem failed */ break; i++; } if(PyErr_Occurred()) { Py_DECREF(percentages); percentages = NULL; } Py_DECREF(countitems); Py_DECREF(counts); return percentages; }
static int parse_syntax_error(PyObject *err, PyObject **message, const char **filename, int *lineno, int *offset, const char **text) { long hold; PyObject *v; /* old style errors */ if (PyTuple_Check(err)) return PyArg_ParseTuple(err, "O(ziiz)", message, filename, lineno, offset, text); /* new style errors. `err' is an instance */ if (! (v = PyObject_GetAttrString(err, "msg"))) goto finally; *message = v; if (!(v = PyObject_GetAttrString(err, "filename"))) goto finally; if (v == Py_None) *filename = NULL; else if (! (*filename = PyString_AsString(v))) goto finally; Py_DECREF(v); if (!(v = PyObject_GetAttrString(err, "lineno"))) goto finally; hold = PyInt_AsLong(v); Py_DECREF(v); v = NULL; if (hold < 0 && PyErr_Occurred()) goto finally; *lineno = (int)hold; if (!(v = PyObject_GetAttrString(err, "offset"))) goto finally; if (v == Py_None) { *offset = -1; Py_DECREF(v); v = NULL; } else { hold = PyInt_AsLong(v); Py_DECREF(v); v = NULL; if (hold < 0 && PyErr_Occurred()) goto finally; *offset = (int)hold; } if (!(v = PyObject_GetAttrString(err, "text"))) goto finally; if (v == Py_None) *text = NULL; else if (! (*text = PyString_AsString(v))) goto finally; Py_DECREF(v); return 1; finally: Py_XDECREF(v); return 0; }
gboolean BoolFromPython(PyObject * o, const char *key) { char *s; int i; PyObject *o2; if (o == Py_None) { return FALSE; } if (!PyBool_Check(o)) { if (PyLong_Check(o)) { i = PyLong_AsLong(o); if (i == 0) return FALSE; else return TRUE; } #if PY_MAJOR_VERSION < 3 if (PyInt_Check(o)) { i = PyInt_AsLong(o); if (i == 0) return FALSE; else return TRUE; } if (PyString_Check(o)) { s = PyString_AsString(o); if (isdigit((int)s[0])) { i = atoi(s); if (i == 0) return FALSE; else return TRUE; } else if (strcasecmp(s, "yes") == 0) { return TRUE; } else if (strcasecmp(s, "true") == 0) { return TRUE; } else if (strcasecmp(s, "no") == 0) { return FALSE; } else if (strcasecmp(s, "false") == 0) { return FALSE; } else { PyErr_Format(PyExc_ValueError, "String value of '%s' doesn't seem to be boolean", key); return BOOL_INVALID; } } #endif if (PyUnicode_Check(o)) { o2 = PyUnicode_AsASCIIString(o); if (o2 == NULL) { return BOOL_INVALID; } s = PyBytes_AsString(o2); if (isdigit((int)s[0])) { i = atoi(s); Py_DECREF(o2); if (i == 0) return FALSE; else return TRUE; } else if (strcasecmp(s, "yes") == 0) { Py_DECREF(o2); return TRUE; } else if (strcasecmp(s, "true") == 0) { Py_DECREF(o2); return TRUE; } else if (strcasecmp(s, "no") == 0) { Py_DECREF(o2); return FALSE; } else if (strcasecmp(s, "false") == 0) { Py_DECREF(o2); return FALSE; } else { Py_DECREF(o2); PyErr_Format(PyExc_ValueError, "String value of '%s' doesn't seem to be boolean", key); return BOOL_INVALID; } } PyErr_Format(PyExc_ValueError, "Value of '%s' doesn't seem to be boolean", key); return BOOL_INVALID; } if (Py_False == o) return FALSE; else if (Py_True == o) return TRUE; PyErr_Format(PyExc_ValueError, "Bool value of '%s' doesn't seem to be boolean", key); return BOOL_INVALID; }
PyObject *py_uwsgi_gevent_request(PyObject * self, PyObject * args) { PyObject *py_wsgi_req = PyTuple_GetItem(args, 0); struct wsgi_request *wsgi_req = (struct wsgi_request *) PyLong_AsLong(py_wsgi_req); PyObject *greenlet_switch = NULL; PyObject *current_greenlet = GET_CURRENT_GREENLET; // another hack to retrieve the current wsgi_req; PyObject_SetAttrString(current_greenlet, "uwsgi_wsgi_req", py_wsgi_req); // if in edge-triggered mode read from socket now !!! if (wsgi_req->socket->edge_trigger) { int status = wsgi_req->socket->proto(wsgi_req); if (status < 0) { goto end; } goto request; } greenlet_switch = PyObject_GetAttrString(current_greenlet, "switch"); for(;;) { int ret = uwsgi.wait_read_hook(wsgi_req->fd, uwsgi.socket_timeout); wsgi_req->switches++; if (ret <= 0) { goto end; } int status = wsgi_req->socket->proto(wsgi_req); if (status < 0) { goto end; } else if (status == 0) { break; } } request: #ifdef UWSGI_ROUTING if (uwsgi_apply_routes(wsgi_req) == UWSGI_ROUTE_BREAK) { goto end; } #endif for(;;) { if (uwsgi.p[wsgi_req->uh->modifier1]->request(wsgi_req) <= UWSGI_OK) { goto end; } wsgi_req->switches++; // switch after each yield GEVENT_SWITCH; } end: if (greenlet_switch) { Py_DECREF(greenlet_switch); } Py_DECREF(current_greenlet); uwsgi_close_request(wsgi_req); free_req_queue; if (uwsgi.workers[uwsgi.mywid].manage_next_request == 0) { int running_cores = 0; int i; for(i=0;i<uwsgi.async;i++) { if (uwsgi.workers[uwsgi.mywid].cores[i].in_request) { running_cores++; } } if (running_cores == 0) { // no need to worry about freeing memory PyObject *uwsgi_dict = get_uwsgi_pydict("uwsgi"); if (uwsgi_dict) { PyObject *ae = PyDict_GetItemString(uwsgi_dict, "atexit"); if (ae) { python_call(ae, PyTuple_New(0), 0, NULL); } } } } else { // If we stopped any watcher due to being out of async workers, restart it. int i = 0; struct uwsgi_socket *uwsgi_sock = uwsgi.sockets; for (; uwsgi_sock; uwsgi_sock = uwsgi_sock->next, ++i) { PyObject *py_watcher_active = PyObject_GetAttrString(ugevent.watchers[i], "active"); if (py_watcher_active && PyBool_Check(py_watcher_active) && !PyInt_AsLong(py_watcher_active)) { start_watcher(i, uwsgi_sock); } Py_XDECREF(py_watcher_active); } } Py_INCREF(Py_None); return Py_None; }
int GetIntFromDict(PyObject * dict, const char *key) { PyObject *o; PyObject *o2; char *s; int i; o = PyDict_GetItemString(dict, key); if (o == NULL) { PyErr_Format(PyExc_ValueError, "Missing key in dictionary: %s", key); return INT_INVALID; } if (PyLong_Check(o)) { /* Well we loose here something, but it is intentional :-) */ return PyLong_AsLongLong(o); } #if PY_MAJOR_VERSION < 3 if (PyInt_Check(o)) { return PyInt_AsLong(o); } if (PyString_Check(o)) { s = PyString_AsString(o); if (isdigit((int)s[0])) { i = atoi(s); return i; } else { PyErr_Format(PyExc_ValueError, "Value of '%s' doesn't seem to be integer", key); return INT_INVALID; } } #endif if (PyUnicode_Check(o)) { o2 = PyUnicode_AsASCIIString(o); if (o2 == NULL) { return INT_INVALID; } s = PyBytes_AsString(o2); if (isdigit((int)s[0])) { i = atoi(s); Py_DECREF(o2); return i; } else { Py_DECREF(o2); PyErr_Format(PyExc_ValueError, "Value of '%s' doesn't seem to be integer", key); return INT_INVALID; } } PyErr_Format(PyExc_ValueError, "Value of '%s' doesn't seem to be integer", key); return INT_INVALID; }
static PyObject* Level2User_Join(PyObject * self, PyObject * args){ CThostFtdcLevel2UserApi * user = (CThostFtdcLevel2UserApi *) PyInt_AsLong(PyTuple_GET_ITEM(args, 0)); PyObject * ret = Py_BuildValue("i", user->Join()); return ret; }
int RM_cmd(int args, char** argv) { printf("Ross-MacDonald\n"); size_t const NB_ARGS = 12; PyObject *pName, *pModule, *pFunc; PyObject *pArgs, *pValue; if (args < NB_ARGS) { fprintf(stderr, "Not enough arguments\n"); return -1; } else if (strcmp("rm", argv[0]) != 0) { fprintf(stderr, "Incorrect call\n"); return -1; } Py_Initialize(); PyRun_SimpleString("import sys, os"); PyRun_SimpleString("sys.path.append('models')"); pName = PyString_FromString("RM"); pModule = PyImport_Import(pName); Py_DECREF(pName); if (pModule != NULL) { pFunc = PyObject_GetAttrString(pModule, "main"); if (pFunc && PyCallable_Check(pFunc)) { pArgs = PyTuple_New(NB_ARGS - 1); for (int i = 0; i < NB_ARGS; ++i) { pValue = PyFloat_FromDouble(atof(argv[i])); if (!pValue) { Py_DECREF(pArgs); Py_DECREF(pModule); fprintf(stderr, "Error arguments\n"); return -1; } PyTuple_SetItem(pArgs, i-1, pValue); } pValue = PyObject_CallObject(pFunc, pArgs); Py_DECREF(pArgs); if (pValue != NULL) { if (PyInt_AsLong(pValue) != 0) { printf("Call error\n"); } else { printf("Call success\n"); } 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", argv[2]); } Py_XDECREF(pFunc); Py_DECREF(pModule); } else { PyErr_Print(); fprintf(stderr, "Failed to load \"%s\"\n", argv[1]); return 1; } Py_Finalize(); return 0; }
static PyObject* bignumpy(PyObject* self, PyObject* args) { const char* filename = NULL; PyObject* dtype = NULL; PyObject* shape = Py_None; int fd; PyArrayObject* z; PyArray_Descr* descr; int nd = 0; npy_intp dims[BIGNUMPY_MAXDIMS]; npy_intp strides[BIGNUMPY_MAXDIMS]; size_t nelm; int i; npy_intp stride; PyObject* obj; struct BignumpyObject* bno; if (!PyArg_ParseTuple(args,"sO|O",&filename,&dtype,&shape)) return NULL; // We actually start with the type. If we can't figure out the size // it is useless to open the file. dtype can be almost anything, so // here, we create an array of zeros to get information about the // type using the actual numpy interface z = /*owned*/ (PyArrayObject*)PyObject_CallFunctionObjArgs(ZEROS,EMPTY,dtype,NULL); if (!z) return NULL; Py_INCREF(descr = PyArray_DESCR(z)); Py_DECREF(z); z = NULL; // OK, we can open the file. If it does not exist, we may have to create it fd = open(filename,O_RDWR|O_CREAT,0666); if (fd < 0) { Py_DECREF(descr); return PyErr_SetFromErrnoWithFilename(PyExc_OSError,filename); } // Figure out the current size of the file. struct stat status; if (fstat(fd,&status) < 0) { Py_DECREF(descr); close(fd); return PyErr_SetFromErrnoWithFilename(PyExc_OSError,filename); } //If the size is zero and we have a shape, // then we'll use ftruncate to change the size. If we have no shape, // assume shape is (size(file)/elsize,) if (shape == Py_None) { strides[nd] = descr->elsize; dims[nd++] = status.st_size/descr->elsize; } else { PyObject* iterator = PyObject_GetIter(shape); if (!iterator) { long v = PyInt_AsLong(shape); if (v == -1 && PyErr_Occurred()) { PyErr_SetString(PyExc_RuntimeError,"invalid shape"); Py_DECREF(descr); close(fd); return NULL; } dims[nd++] = v; } else { PyObject* item; while((item = PyIter_Next(iterator))) { if (nd >= BIGNUMPY_MAXDIMS) { Py_DECREF(iterator); Py_DECREF(item); Py_DECREF(descr); close(fd); PyErr_SetString(PyExc_RuntimeError,"shape has too many dimensions"); return NULL; } long v = PyInt_AsLong(item); if (v == -1 && PyErr_Occurred()) { Py_DECREF(iterator); Py_DECREF(item); Py_DECREF(descr); close(fd); PyErr_SetString(PyExc_RuntimeError,"invalid shape"); return NULL; } strides[nd] = 1; dims[nd++] = v; Py_DECREF(item); } Py_DECREF(iterator); } } // ---------------------------------------------------------------------- // Compute the number of required elements // ---------------------------------------------------------------------- nelm = 0; if (nd > 0) { nelm = 1; for(i=0;i<nd;++i) nelm *= dims[i]; } // ---------------------------------------------------------------------- // The strides include the element size. We compute from back to front // ---------------------------------------------------------------------- stride = descr->elsize; for(i=0;i<nd;++i) { strides[nd-1-i] = stride; stride *= dims[nd-1-i]; } // ---------------------------------------------------------------------- // Grow (but do not shrink) to be the expected size // ---------------------------------------------------------------------- off_t expected = nelm * descr->elsize; if (status.st_size < expected) { if (ftruncate(fd,expected) < 0) { Py_DECREF(descr); close(fd); return PyErr_SetFromErrnoWithFilename(PyExc_OSError,filename); } } // ---------------------------------------------------------------------- // At this point, we can map the values into memory // ---------------------------------------------------------------------- if (!expected) expected = 1; // mmap doesn't like 0 size void* m = mmap(NULL,expected,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0); if (m == MAP_FAILED) { Py_DECREF(descr); close(fd); return PyErr_SetFromErrnoWithFilename(PyExc_OSError,filename); } // ---------------------------------------------------------------------- // Make a C object to hold the map state (pointer and size); // ---------------------------------------------------------------------- obj = PyArray_NewFromDescr( &Bignumpy_Type, descr, /* steals reference */ nd, dims, strides, m, NPY_ARRAY_DEFAULT, NULL); bno = (struct BignumpyObject*)obj; bno->fd = fd; bno->map = m; bno->size = expected; return obj; }
/* ** CALL - perform library call */ static object * lib_call(amigalibobject *self, object *args) // call { object *dic; int LVO_value; ULONG regspec, orig_regspec; int pos=0; object *key, *value; /* the registers: */ ULONG reg[16]; if (!newgetargs(args, "(ii)O", &LVO_value, ®spec, &dic)) return NULL; if(!PyDict_Check(dic)) { err_setstr(TypeError, "2nd arg must be dictionary"); return NULL; } if(LVO_value>-30 || LVO_value%2) { err_setstr(ValueError, "illegal LVO value"); return NULL; } if(regspec<0 || regspec >0xFFFF) { err_setstr(ValueError, "illegal regspec"); return NULL; } orig_regspec=regspec; while(PyDict_Next(dic,&pos,&key,&value)) { int regnr = PyInt_AsLong(key); if(!PyInt_Check(key) || regnr<0 || regnr>15) { err_setstr(ValueError, "illegal key/regnr."); return NULL; } else { ULONG regval; if(!obj2reg(value,®val)) { err_setstr(ValueError, "illegal register value"); return NULL; } /* OK: the register `regnr' must get the value `regval' */ /* Check if register regnr indeed must get a value */ if(regspec & (1<<regnr)) { /* Yes, put value in register & clear register bit */ reg[regnr]=regval; regspec &= ~(1<<regnr); } else { err_setstr(ValueError, "registers not consistent with LVO spec"); return NULL; } } } /* Are there still registers to assign a value to? */ if(regspec) { err_setstr(ValueError, "too few arguments provided"); return NULL; } /* XXXX TODO: SHOULD PASS ARGUMENTS ALSO */ return newintobject( amigalibs_calllib(self->libbase, LVO_value,orig_regspec,reg)); }
/** * \ingroup python_interface_edgeseq * \brief Selects a subset of the edge sequence based on some criteria */ PyObject* igraphmodule_EdgeSeq_select(igraphmodule_EdgeSeqObject *self, PyObject *args) { igraphmodule_EdgeSeqObject *result; igraphmodule_GraphObject *gr; long i, j, n, m; gr=self->gref; result=igraphmodule_EdgeSeq_copy(self); if (result == 0) return NULL; /* First, filter by positional arguments */ n = PyTuple_Size(args); for (i=0; i<n; i++) { PyObject *item = PyTuple_GET_ITEM(args, i); if (item == Py_None) { /* None means: select nothing */ igraph_es_destroy(&result->es); igraph_es_none(&result->es); /* We can simply bail out here */ return (PyObject*)result; } else if (PyCallable_Check(item)) { /* Call the callable for every edge in the current sequence to * determine what's up */ igraph_bool_t was_excluded = 0; igraph_vector_t v; if (igraph_vector_init(&v, 0)) { igraphmodule_handle_igraph_error(); return 0; } m = PySequence_Size((PyObject*)result); for (j=0; j<m; j++) { PyObject *edge = PySequence_GetItem((PyObject*)result, j); PyObject *call_result; if (edge == 0) { Py_DECREF(result); igraph_vector_destroy(&v); return NULL; } call_result = PyObject_CallFunctionObjArgs(item, edge, NULL); if (call_result == 0) { Py_DECREF(edge); Py_DECREF(result); igraph_vector_destroy(&v); return NULL; } if (PyObject_IsTrue(call_result)) igraph_vector_push_back(&v, igraphmodule_Edge_get_index_long((igraphmodule_EdgeObject*)edge)); else was_excluded=1; Py_DECREF(call_result); Py_DECREF(edge); } if (was_excluded) { igraph_es_destroy(&result->es); if (igraph_es_vector_copy(&result->es, &v)) { Py_DECREF(result); igraph_vector_destroy(&v); igraphmodule_handle_igraph_error(); return NULL; } } igraph_vector_destroy(&v); } else if (PyInt_Check(item)) { /* Integers are treated specially: from now on, all remaining items * in the argument list must be integers and they will be used together * to restrict the edge set. Integers are interpreted as indices on the * edge set and NOT on the original, untouched edge sequence of the * graph */ igraph_vector_t v, v2; if (igraph_vector_init(&v, 0)) { igraphmodule_handle_igraph_error(); return 0; } if (igraph_vector_init(&v2, 0)) { igraph_vector_destroy(&v); igraphmodule_handle_igraph_error(); return 0; } if (igraph_es_as_vector(&gr->g, self->es, &v2)) { igraph_vector_destroy(&v); igraph_vector_destroy(&v2); igraphmodule_handle_igraph_error(); return 0; } m = igraph_vector_size(&v2); for (; i<n; i++) { PyObject *item2 = PyTuple_GET_ITEM(args, i); long idx; if (!PyInt_Check(item2)) { Py_DECREF(result); PyErr_SetString(PyExc_TypeError, "edge indices expected"); igraph_vector_destroy(&v); igraph_vector_destroy(&v2); return NULL; } idx = PyInt_AsLong(item2); if (idx >= m || idx < 0) { PyErr_SetString(PyExc_ValueError, "edge index out of range"); igraph_vector_destroy(&v); igraph_vector_destroy(&v2); return NULL; } if (igraph_vector_push_back(&v, VECTOR(v2)[idx])) { Py_DECREF(result); igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); igraph_vector_destroy(&v2); return NULL; } } igraph_vector_destroy(&v2); igraph_es_destroy(&result->es); if (igraph_es_vector_copy(&result->es, &v)) { Py_DECREF(result); igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); return NULL; } igraph_vector_destroy(&v); } else { /* Iterators and everything that was not handled directly */ PyObject *iter, *item2; igraph_vector_t v, v2; /* Allocate stuff */ if (igraph_vector_init(&v, 0)) { igraphmodule_handle_igraph_error(); return 0; } if (igraph_vector_init(&v2, 0)) { igraph_vector_destroy(&v); igraphmodule_handle_igraph_error(); return 0; } if (igraph_es_as_vector(&gr->g, self->es, &v2)) { igraph_vector_destroy(&v); igraph_vector_destroy(&v2); igraphmodule_handle_igraph_error(); return 0; } m = igraph_vector_size(&v2); /* Create an appropriate iterator */ if (PySlice_Check(item)) { /* Create an iterator from the slice (which is not iterable by default )*/ Py_ssize_t start, stop, step, sl; PyObject* range; igraph_bool_t ok; /* Casting to void* because Python 2.x expects PySliceObject* * but Python 3.x expects PyObject* */ ok = (PySlice_GetIndicesEx((void*)item, igraph_vector_size(&v2), &start, &stop, &step, &sl) == 0); if (ok) { range = igraphmodule_PyRange_create(start, stop, step); ok = (range != 0); } if (ok) { iter = PyObject_GetIter(range); Py_DECREF(range); ok = (iter != 0); } if (!ok) { igraph_vector_destroy(&v); igraph_vector_destroy(&v2); PyErr_SetString(PyExc_TypeError, "error while converting slice to iterator"); Py_DECREF(result); return 0; } } else { /* Simply create the iterator corresponding to the object */ iter = PyObject_GetIter(item); } /* Did we manage to get an iterator? */ if (iter == 0) { igraph_vector_destroy(&v); igraph_vector_destroy(&v2); PyErr_SetString(PyExc_TypeError, "invalid edge filter among positional arguments"); Py_DECREF(result); return 0; } /* Do the iteration */ while ((item2=PyIter_Next(iter)) != 0) { if (PyInt_Check(item2)) { long idx = PyInt_AsLong(item2); Py_DECREF(item2); if (idx >= m || idx < 0) { PyErr_SetString(PyExc_ValueError, "edge index out of range"); Py_DECREF(result); Py_DECREF(iter); igraph_vector_destroy(&v); igraph_vector_destroy(&v2); return NULL; } if (igraph_vector_push_back(&v, VECTOR(v2)[idx])) { Py_DECREF(result); Py_DECREF(iter); igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); igraph_vector_destroy(&v2); return NULL; } } else { /* We simply ignore elements that we don't know */ Py_DECREF(item2); } } /* Deallocate stuff */ igraph_vector_destroy(&v2); Py_DECREF(iter); if (PyErr_Occurred()) { igraph_vector_destroy(&v); Py_DECREF(result); return 0; } igraph_es_destroy(&result->es); if (igraph_es_vector_copy(&result->es, &v)) { Py_DECREF(result); igraphmodule_handle_igraph_error(); igraph_vector_destroy(&v); return NULL; } igraph_vector_destroy(&v); } } return (PyObject*)result; }
long int ofxPythonObject::asInt() const { if (isInt()) return PyInt_AsLong(get()->obj); return 0; }
static gboolean marshal_value(CORBA_TypeCode tc, gconstpointer *val, PyObject *value) { gboolean ret = FALSE; gint i; while (tc->kind == CORBA_tk_alias) tc = tc->subtypes[0]; switch (tc->kind) { case CORBA_tk_null: case CORBA_tk_void: ret = (value == Py_None); break; case CORBA_tk_short: alignval(val, ORBIT_ALIGNOF_CORBA_SHORT); getval(val, CORBA_short) = PyInt_AsLong(value); advanceptr(val, sizeof(CORBA_short)); if (!PyErr_Occurred()) ret = TRUE; break; case CORBA_tk_long: alignval(val, ORBIT_ALIGNOF_CORBA_LONG); getval(val, CORBA_long) = PyInt_AsLong(value); advanceptr(val, sizeof(CORBA_long)); if (!PyErr_Occurred()) ret = TRUE; break; case CORBA_tk_ushort: alignval(val, ORBIT_ALIGNOF_CORBA_SHORT); getval(val, CORBA_unsigned_short) = PyInt_AsLong(value); advanceptr(val, sizeof(CORBA_unsigned_short)); if (!PyErr_Occurred()) ret = TRUE; break; case CORBA_tk_ulong: case CORBA_tk_enum: alignval(val, ORBIT_ALIGNOF_CORBA_LONG); if (PyLong_Check(value)) getval(val, CORBA_unsigned_long) = PyLong_AsUnsignedLong(value); else getval(val, CORBA_unsigned_long) = PyInt_AsLong(value); advanceptr(val, sizeof(CORBA_unsigned_long)); if (!PyErr_Occurred()) ret = TRUE; break; case CORBA_tk_float: alignval(val, ORBIT_ALIGNOF_CORBA_FLOAT); getval(val, CORBA_float) = PyFloat_AsDouble(value); advanceptr(val, sizeof(CORBA_float)); if (!PyErr_Occurred()) ret = TRUE; break; case CORBA_tk_double: alignval(val, ORBIT_ALIGNOF_CORBA_DOUBLE); getval(val, CORBA_double) = PyFloat_AsDouble(value); advanceptr(val, sizeof(CORBA_double)); if (!PyErr_Occurred()) ret = TRUE; break; case CORBA_tk_boolean: getval(val, CORBA_boolean) = PyObject_IsTrue(value); advanceptr(val, sizeof(CORBA_boolean)); if (!PyErr_Occurred()) ret = TRUE; break; case CORBA_tk_char: if (PyString_Check(value) && PyString_Size(value) == 1) { getval(val, CORBA_char) = PyString_AsString(value)[0]; advanceptr(val, sizeof(CORBA_char)); ret = TRUE; } break; case CORBA_tk_octet: getval(val, CORBA_long) = PyInt_AsLong(value); advanceptr(val, sizeof(CORBA_octet)); if (!PyErr_Occurred()) ret = TRUE; break; case CORBA_tk_any: if (PyObject_TypeCheck(value, &PyCORBA_Any_Type)) { alignval(val, ORBIT_ALIGNOF_CORBA_ANY); CORBA_any__copy(&getval(val, CORBA_any), &((PyCORBA_Any *)value)->any); advanceptr(val, sizeof(CORBA_any)); ret = TRUE; } break; case CORBA_tk_TypeCode: alignval(val, ORBIT_ALIGNOF_CORBA_POINTER); if (PyObject_TypeCheck(value, &PyCORBA_TypeCode_Type)) { getval(val, CORBA_TypeCode) = (CORBA_TypeCode)CORBA_Object_duplicate( (CORBA_Object)((PyCORBA_TypeCode *)value)->tc, NULL); ret = TRUE; } advanceptr(val, sizeof(CORBA_TypeCode)); break; case CORBA_tk_Principal: g_warning("can't marshal Principal"); break; case CORBA_tk_objref: alignval(val, ORBIT_ALIGNOF_CORBA_POINTER); if (value == Py_None) { getval(val, CORBA_Object) = CORBA_OBJECT_NIL; ret = TRUE; } else if (PyObject_TypeCheck(value, &PyCORBA_Object_Type)) { CORBA_Object objref = ((PyCORBA_Object *)value)->objref; getval(val, CORBA_Object) = CORBA_Object_duplicate(objref, NULL); advanceptr(val, sizeof(CORBA_Object)); ret = TRUE; } break; case CORBA_tk_except: case CORBA_tk_struct: alignval(val, tc->c_align); for (i = 0; i < tc->sub_parts; i++) { gchar *pyname; PyObject *item; gboolean itemret; pyname = _pyorbit_escape_name(tc->subnames[i]); item = PyObject_GetAttrString(value, pyname); g_free(pyname); if (!item) break; itemret = marshal_value(tc->subtypes[i], val, item); Py_DECREF(item); if (!itemret) break; } if (i == tc->sub_parts) ret = TRUE; /* no error */ break; case CORBA_tk_union: { PyObject *discrim, *subval; CORBA_TypeCode subtc; gconstpointer body; int sz = 0; discrim = PyObject_GetAttrString(value, "_d"); if (!discrim) break; subval = PyObject_GetAttrString(value, "_v"); if (!subval) break; alignval(val, MAX(tc->c_align, tc->discriminator->c_align)); ret = marshal_value(tc->discriminator, val, discrim); if (!ret) { Py_DECREF(discrim); Py_DECREF(subval); break; } /* calculate allocation info */ for (i = 0; i < tc->sub_parts; i++) { sz = MAX(sz, ORBit_gather_alloc_info(tc->subtypes[i])); } subtc = get_union_tc(tc, discrim); Py_DECREF(discrim); if (!subtc) { Py_DECREF(subval); break; } alignval(val, tc->c_align); body = *val; ret = marshal_value(subtc, &body, subval); Py_DECREF(subval); advanceptr(val, sz); break; } case CORBA_tk_string: if (PyString_Check(value)) { /* error out if python string is longer than the bound * specified in the string typecode. */ if (tc->length > 0 && PyString_Size(value) > tc->length) break; alignval(val, ORBIT_ALIGNOF_CORBA_POINTER); getval(val, CORBA_string) = CORBA_string_dup(PyString_AsString(value)); advanceptr(val, sizeof(CORBA_char *)); ret = TRUE; } break; case CORBA_tk_sequence: if (PySequence_Check(value)) { CORBA_sequence_CORBA_octet *sval; gconstpointer seqval; gint i; /* error out if python sequence is longer than the bound * specified in the sequence typecode. */ if (tc->length > 0 && PySequence_Length(value) > tc->length) break; alignval(val, ORBIT_ALIGNOF_CORBA_SEQ); sval = (CORBA_sequence_CORBA_octet *)*val; if (CORBA_TypeCode_equal(tc->subtypes[0], TC_CORBA_octet, NULL) && PyString_Check(value)) { Py_ssize_t length; char *buffer; if (PyString_AsStringAndSize(value, &buffer, &length) == -1) ret = FALSE; else { sval->_release = CORBA_TRUE; sval->_buffer = ORBit_alloc_tcval(TC_CORBA_octet, length); memcpy(sval->_buffer, buffer, length); sval->_length = length; ret = TRUE; } } else { sval->_release = TRUE; sval->_length = PySequence_Length(value); sval->_buffer = ORBit_alloc_tcval(tc->subtypes[0], sval->_length); seqval = sval->_buffer; for (i = 0; i < sval->_length; i++) { PyObject *item = PySequence_GetItem(value, i); gboolean itemret; if (!item) break; itemret = marshal_value(tc->subtypes[0], &seqval, item); Py_DECREF(item); if (!itemret) break; } if (i == sval->_length) ret = TRUE; /* no error */ } advanceptr(val, sizeof(CORBA_sequence_CORBA_octet)); } break; case CORBA_tk_array: if (PySequence_Check(value) && PySequence_Length(value) == tc->length) { gint i; for (i = 0; i < tc->length; i++) { PyObject *item = PySequence_GetItem(value, i); gboolean itemret; if (!item) break; itemret = marshal_value(tc->subtypes[0], val, item); Py_DECREF(item); if (!itemret) break; } if (i == tc->length) ret = TRUE; /* no error */ } break; case CORBA_tk_longlong: alignval(val, ORBIT_ALIGNOF_CORBA_LONG_LONG); if (PyLong_Check(value)) getval(val, CORBA_long_long) = PyLong_AsLongLong(value); else getval(val, CORBA_long_long) = PyInt_AsLong(value); advanceptr(val, sizeof(CORBA_long_long)); if (!PyErr_Occurred()) ret = TRUE; break; case CORBA_tk_ulonglong: alignval(val, ORBIT_ALIGNOF_CORBA_LONG_LONG); if (PyLong_Check(value)) getval(val, CORBA_unsigned_long_long) =PyLong_AsUnsignedLongLong(value); else getval(val, CORBA_unsigned_long_long) = PyInt_AsLong(value); advanceptr(val, sizeof(CORBA_unsigned_long_long)); if (!PyErr_Occurred()) ret = TRUE; break; case CORBA_tk_longdouble: g_warning("can't marshal long double"); break; case CORBA_tk_wchar: if (PyUnicode_Check(value) && PyUnicode_GetSize(value) == 1) { alignval(val, ORBIT_ALIGNOF_CORBA_SHORT); getval(val, CORBA_wchar) = PyUnicode_AsUnicode(value)[0]; advanceptr(val, sizeof(CORBA_wchar)); ret = TRUE; } break; case CORBA_tk_wstring: if (PyUnicode_Check(value)) { int length = PyUnicode_GetSize(value); Py_UNICODE *unicode = PyUnicode_AsUnicode(value); CORBA_wchar *wstr; /* error out if python unicode string is longer than the * bound specified in the wstring typecode. */ if (tc->length > 0 && length > tc->length) break; alignval(val, ORBIT_ALIGNOF_CORBA_POINTER); wstr = CORBA_wstring_alloc(length); getval(val, CORBA_wstring) = wstr; for (i = 0; i < length; i++) { wstr[i] = unicode[i]; } advanceptr(val, sizeof(CORBA_wchar *)); ret = TRUE; } break; default: g_warning("unhandled typecode: %s (kind=%d)", tc->repo_id, tc->kind); break; } if (!ret) PyErr_Clear(); return ret; }
QList<PythonVariable> PythonEngine::variableList() { QStringList filter_name; filter_name << "__builtins__" << "StdoutCatcher" << "python_engine_stdout" << "result_pythonlab" << "python_engine_get_completion_interpreter" << "python_engine_get_completion_script" << "PythonLabRopeProject" << "pythonlab_rope_project" << "python_engine_pyflakes_check" << "CatchOutErr" << "agros2d_material_eval" << "chart" << "memory_chart" << "sgn" << "test" << "vtk_contours_actor" << "vtk_figure" << "vtk_geometry_actor" << "vtk_scalar_actor" << "help" << "__a2d_help__"; QStringList filter_type; filter_type << "builtin_function_or_method"; QList<PythonVariable> list; PyObject *keys = PyDict_Keys(m_dict); for (int i = 0; i < PyList_Size(keys); ++i) { PyObject *key = PyList_GetItem(keys, i); PyObject *value = PyDict_GetItem(m_dict, key); // variable PythonVariable var; // variable name var.name = PyString_AsString(key); // variable type var.type = value->ob_type->tp_name; // variable value if (var.type == "bool") { var.value = PyInt_AsLong(value) ? "True" : "False"; } else if (var.type == "int") { var.value = (int) PyInt_AsLong(value); } else if (var.type == "float") { var.value = PyFloat_AsDouble(value); } else if (var.type == "str") { var.value = PyString_AsString(value); } else if (var.type == "list") { var.value = QString("%1 items").arg(PyList_Size(value)); } else if (var.type == "tuple") { var.value = QString("%1 items").arg(PyTuple_Size(value)); } else if (var.type == "dict") { var.value = QString("%1 items").arg(PyDict_Size(value)); } else if (var.type == "numpy.ndarray") { var.value = ""; //TODO count } else if (var.type == "module") { var.value = PyString_AsString(PyObject_GetAttrString(value, "__name__")); } else if (var.type == "function" || var.type == "instance" || var.type == "classobj") { // qDebug() << value->ob_type->tp_name; } // append if (!filter_name.contains(var.name) && !filter_type.contains(var.type)) { list.append(var); } } Py_DECREF(keys); return list; }
struct pcmreader_s* open_pcmreader(PyObject* pcmreader_obj) { struct pcmreader_s* pcmreader = malloc(sizeof(struct pcmreader_s)); PyObject* attr; PyObject* audiotools_pcm; /*setup some placeholder values*/ pcmreader->pcmreader_obj = NULL; pcmreader->framelist_type = NULL; pcmreader->sample_rate = 0; pcmreader->channels = 0; pcmreader->channel_mask = 0; pcmreader->bits_per_sample = 0; pcmreader->bytes_per_sample = 0; pcmreader->callbacks = NULL; pcmreader->read = pcmreader_read; pcmreader->close = pcmreader_close; pcmreader->add_callback = pcmreader_add_callback; pcmreader->del = pcmreader_del; /*attempt to extract proper values from the pcmreader_obj*/ if ((attr = PyObject_GetAttrString(pcmreader_obj, "sample_rate")) == NULL) goto error; pcmreader->sample_rate = (unsigned int)PyInt_AsLong(attr); Py_DECREF(attr); if (PyErr_Occurred()) goto error; if ((attr = PyObject_GetAttrString(pcmreader_obj, "bits_per_sample")) == NULL) goto error; pcmreader->bits_per_sample = (unsigned int)PyInt_AsLong(attr); Py_DECREF(attr); if (PyErr_Occurred()) goto error; if ((attr = PyObject_GetAttrString(pcmreader_obj, "channels")) == NULL) goto error; pcmreader->channels = (unsigned int)PyInt_AsLong(attr); Py_DECREF(attr); if (PyErr_Occurred()) goto error; if ((attr = PyObject_GetAttrString(pcmreader_obj, "channel_mask")) == NULL) goto error; pcmreader->channel_mask = (unsigned int)PyInt_AsLong(attr); Py_DECREF(attr); if (PyErr_Occurred()) goto error; pcmreader->bytes_per_sample = pcmreader->bits_per_sample / 8; /*attach and incref the wrapped PCMReader object*/ pcmreader->pcmreader_obj = pcmreader_obj; Py_INCREF(pcmreader_obj); /*attach a pcm.FrameList type object for verification during reads*/ if ((audiotools_pcm = PyImport_ImportModule("audiotools.pcm")) == NULL) { goto error; } pcmreader->framelist_type = PyObject_GetAttrString(audiotools_pcm, "FrameList"); Py_DECREF(audiotools_pcm); return pcmreader; error: Py_XDECREF(pcmreader->pcmreader_obj); Py_XDECREF(pcmreader->framelist_type); free(pcmreader); return NULL; }
/** * \ingroup python_interface_vertexseq * \brief Selects a single vertex from the vertex sequence based on some criteria */ PyObject* igraphmodule_VertexSeq_find(igraphmodule_VertexSeqObject *self, PyObject *args) { PyObject *item; igraph_integer_t i; Py_ssize_t n; igraph_vit_t vit; if (!PyArg_ParseTuple(args, "O", &item)) return NULL; if (PyCallable_Check(item)) { /* Call the callable for every vertex in the current sequence and return * the first one for which it evaluates to True */ n = PySequence_Size((PyObject*)self); for (i=0; i<n; i++) { PyObject *vertex = PySequence_GetItem((PyObject*)self, i); PyObject *call_result; if (vertex == 0) return NULL; call_result = PyObject_CallFunctionObjArgs(item, vertex, NULL); if (call_result == 0) { Py_DECREF(vertex); return NULL; } if (PyObject_IsTrue(call_result)) { Py_DECREF(call_result); return vertex; /* reference passed to caller */ } Py_DECREF(call_result); Py_DECREF(vertex); } } else if (PyInt_Check(item)) { /* Integers are interpreted as indices on the vertex set and NOT on the * original, untouched vertex sequence of the graph */ return PySequence_GetItem((PyObject*)self, PyInt_AsLong(item)); } else if (PyBaseString_Check(item)) { /* Strings are interpreted as vertex names */ if (igraphmodule_get_vertex_id_by_name(&self->gref->g, item, &i)) return NULL; /* We now have the ID of the vertex in the graph. If the vertex sequence * itself represents the full vertex sequence of the graph, we can return * here. If not, we have to check whether the vertex sequence contains this * ID or not. */ if (igraph_vs_is_all(&self->vs)) return PySequence_GetItem((PyObject*)self, i); if (igraph_vit_create(&self->gref->g, self->vs, &vit)) { igraphmodule_handle_igraph_error(); return NULL; } for (n = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), n++) { if (IGRAPH_VIT_GET(vit) == i) { igraph_vit_destroy(&vit); return PySequence_GetItem((PyObject*)self, n); } } igraph_vit_destroy(&vit); PyErr_SetString(PyExc_ValueError, "vertex with the given name exists but not in the current sequence"); return NULL; } PyErr_SetString(PyExc_IndexError, "no such vertex"); return NULL; }
static PyObject * cbson_dumps (PyObject *self, PyObject *args) { const char *keystr; PyObject *doc; PyObject *key; PyObject *ret; PyObject *value; Py_ssize_t pos = 0; bson_t *b; size_t keylen; if (!PyArg_ParseTuple(args, "O", &doc)) { return NULL; } if (!PyDict_Check(doc)) { PyErr_SetString(PyExc_TypeError, "doc must be a dict."); return NULL; } b = bson_new(); while (PyDict_Next(doc, &pos, &key, &value)) { /* * TODO: Key validation. Make sure no NULL is present. Ensure valid UTF-8. */ if (PyString_Check(key)) { keystr = PyString_AS_STRING(key); keylen = PyString_GET_SIZE(key); } else if (PyUnicode_Check(key)) { /* * TODO: Convert to UTF-8. */ keystr = (const char *)PyUnicode_AS_UNICODE(key); keylen = PyUnicode_GET_SIZE(key); } else { PyErr_SetString(PyExc_TypeError, "key must be a string."); bson_destroy(b); return NULL; } if (value == Py_None) { if (!bson_append_null(b, keystr, keylen)) { goto failure; } } else if (PyString_Check(value)) { /* * TODO: Validate UTF-8. */ if (!bson_append_utf8(b, keystr, keylen, PyString_AS_STRING(value), PyString_GET_SIZE(value))) { goto failure; } } else if (PyUnicode_Check(value)) { /* * TODO: Convert and validate UTF-8. */ if (!bson_append_utf8(b, keystr, keylen, (const char *)PyUnicode_AS_UNICODE(value), PyUnicode_GET_SIZE(value))) { goto failure; } } else if (PyDateTime_Check(value)) { /* * TODO: Convert to msec since epoch. */ } else if (PyBool_Check(value)) { if (!bson_append_bool(b, keystr, keylen, (value == Py_True))) { goto failure; } } else if (PyLong_Check(value)) { if (!bson_append_int64(b, keystr, keylen, PyLong_AsLong(value))) { goto failure; } } else if (PyInt_Check(value)) { if (!bson_append_int32(b, keystr, keylen, PyInt_AsLong(value))) { goto failure; } } else if (PyFloat_Check(value)) { if (!bson_append_double(b, keystr, keylen, PyFloat_AsDouble(value))) { goto failure; } } else if (cbson_oid_check(value)) { if (!bson_append_oid(b, keystr, keylen, &((cbson_oid_t *)value)->oid)) { goto failure; } /* } else if (CHECK FOR REGEX) { */ /* } else if (CHECK FOR BINARY) { */ } else { goto failure; } } ret = PyString_FromStringAndSize((const char *)bson_get_data(b), b->len); bson_destroy(b); return ret; failure: PyErr_SetString(PyExc_TypeError, "Cannot encode type."); bson_destroy(b); return NULL; }
//============================================================================ // METHOD: SPELLpyValue::set //============================================================================ void SPELLpyValue::set( PyObject* pyValue ) { m_type = NONE; m_intValue = 0; m_boolValue = false; m_floatValue = 0.0; m_timeValue.set(0,0); m_stringValue = ""; if (pyValue == NULL) return; DEBUG("[PYVAL] Set value from " + PYREPR(pyValue)); if (pyValue != Py_None) { if (PyBool_Check(pyValue)) { m_type = BOOLEAN; m_boolValue = pyValue == Py_True; } else if (PyLong_Check(pyValue)) { DEBUG("[PYVAL] Long check"); m_type = LONG; m_intValue = PyLong_AsLongLong(pyValue); } else if (PyInt_Check(pyValue)) { DEBUG("[PYVAL] Int check"); m_type = LONG; m_intValue = PyInt_AsLong(pyValue); } else if (PyFloat_Check(pyValue)) { m_type = DOUBLE; m_floatValue = PyFloat_AsDouble(pyValue); } else if (SPELLpythonHelper::instance().isTime(pyValue)) { m_timeValue = SPELLpythonHelper::instance().evalTime(PYSSTR(pyValue)); if (m_timeValue.isDelta()) { m_type = RELTIME; } else { m_type = ABSTIME; } } else if (PyString_Check(pyValue)) { m_type = STRING; m_stringValue = PYSTR(pyValue); } else if (PyList_Check(pyValue)) { m_type = LIST; m_listValue.clear(); unsigned int numItems = PyList_Size(pyValue); for(unsigned int idx = 0; idx < numItems; idx++) { m_listValue.push_back( SPELLpyValue( PyList_GetItem( pyValue, idx) )); } } else if (PyDict_Check(pyValue)) { m_type = DICT; m_dictValue.clear(); PyObject* keys = PyDict_Keys(pyValue); unsigned int numItems = PyList_Size(keys); for(unsigned int idx = 0; idx < numItems; idx++) { PyObject* key = PyList_GetItem(keys,idx); PyObject* value = PyDict_GetItem( pyValue, key ); m_dictValue.insert( std::make_pair( PYSSTR(key), SPELLpyValue(value) ) ); } } else { THROW_EXCEPTION("Cannot create variable value", "Cannot infer type from value (" + PYREPR(pyValue) + ")", SPELL_ERROR_LANGUAGE); } SPELLpythonHelper::instance().checkError(); } }
/* Copies a Python int or long object to a signed 64-bit value * Returns 1 if successful or -1 on error */ int pyexe_integer_signed_copy_to_64bit( PyObject *integer_object, int64_t *value_64bit, libcerror_error_t **error ) { static char *function = "pyexe_integer_signed_copy_to_64bit"; int result = 0; #if defined( HAVE_LONG_LONG ) PY_LONG_LONG long_value = 0; #else long long_value = 0; #endif if( integer_object == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid integer object.", function ); return( -1 ); } PyErr_Clear(); result = PyObject_IsInstance( integer_object, (PyObject *) &PyLong_Type ); if( result == -1 ) { pyexe_error_fetch( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to determine if integer object is of type long.", function ); return( -1 ); } else if( result != 0 ) { PyErr_Clear(); #if defined( HAVE_LONG_LONG ) long_value = PyLong_AsLongLong( integer_object ); #else long_value = PyLong_AsLong( integer_object ); #endif } #if PY_MAJOR_VERSION < 3 if( result == 0 ) { PyErr_Clear(); result = PyObject_IsInstance( integer_object, (PyObject *) &PyInt_Type ); if( result == -1 ) { pyexe_error_fetch( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to determine if integer object is of type int.", function ); return( -1 ); } else if( result != 0 ) { PyErr_Clear(); long_value = PyInt_AsLong( integer_object ); } } #endif /* PY_MAJOR_VERSION < 3 */ if( result == 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unsupported integer object type.", function ); return( -1 ); } if( PyErr_Occurred() ) { pyexe_error_fetch( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to convert integer object to long.", function ); return( -1 ); } #if defined( HAVE_LONG_LONG ) && ( SIZEOF_LONG_LONG > 8 ) if( ( long_value < (PY_LONG_LONG) INT64_MIN ) || ( long_value > (PY_LONG_LONG) INT64_MAX ) ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS, "%s: invalid long value out of bounds.", function ); return( -1 ); } #elif ( SIZEOF_LONG > 8 ) if( ( long_value > (long) INT64_MIN ) || ( long_value > (long) INT64_MAX ) ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS, "%s: invalid long value out of bounds.", function ); return( -1 ); } #endif *value_64bit = (int64_t) long_value; return( 1 ); }
static int _buffer_format_string(PyArray_Descr *descr, _tmp_string_t *str, PyArrayObject* arr, Py_ssize_t *offset, char *active_byteorder) { int k; char _active_byteorder = '@'; Py_ssize_t _offset = 0; if (active_byteorder == NULL) { active_byteorder = &_active_byteorder; } if (offset == NULL) { offset = &_offset; } if (descr->subarray) { PyObject *item, *subarray_tuple; Py_ssize_t total_count = 1; Py_ssize_t dim_size; char buf[128]; int old_offset; int ret; if (PyTuple_Check(descr->subarray->shape)) { subarray_tuple = descr->subarray->shape; Py_INCREF(subarray_tuple); } else { subarray_tuple = Py_BuildValue("(O)", descr->subarray->shape); } _append_char(str, '('); for (k = 0; k < PyTuple_GET_SIZE(subarray_tuple); ++k) { if (k > 0) { _append_char(str, ','); } item = PyTuple_GET_ITEM(subarray_tuple, k); dim_size = PyNumber_AsSsize_t(item, NULL); PyOS_snprintf(buf, sizeof(buf), "%ld", (long)dim_size); _append_str(str, buf); total_count *= dim_size; } _append_char(str, ')'); Py_DECREF(subarray_tuple); old_offset = *offset; ret = _buffer_format_string(descr->subarray->base, str, arr, offset, active_byteorder); *offset = old_offset + (*offset - old_offset) * total_count; return ret; } else if (PyDataType_HASFIELDS(descr)) { int base_offset = *offset; _append_str(str, "T{"); for (k = 0; k < PyTuple_GET_SIZE(descr->names); ++k) { PyObject *name, *item, *offset_obj, *tmp; PyArray_Descr *child; char *p; Py_ssize_t len; int new_offset; name = PyTuple_GET_ITEM(descr->names, k); item = PyDict_GetItem(descr->fields, name); child = (PyArray_Descr*)PyTuple_GetItem(item, 0); offset_obj = PyTuple_GetItem(item, 1); new_offset = base_offset + PyInt_AsLong(offset_obj); /* Insert padding manually */ if (*offset > new_offset) { PyErr_SetString(PyExc_RuntimeError, "This should never happen: Invalid offset in " "buffer format string generation. Please " "report a bug to the Numpy developers."); return -1; } while (*offset < new_offset) { _append_char(str, 'x'); ++*offset; } /* Insert child item */ _buffer_format_string(child, str, arr, offset, active_byteorder); /* Insert field name */ #if defined(NPY_PY3K) /* FIXME: XXX -- should it use UTF-8 here? */ tmp = PyUnicode_AsUTF8String(name); #else tmp = name; #endif if (tmp == NULL || PyBytes_AsStringAndSize(tmp, &p, &len) < 0) { PyErr_SetString(PyExc_ValueError, "invalid field name"); return -1; } _append_char(str, ':'); while (len > 0) { if (*p == ':') { Py_DECREF(tmp); PyErr_SetString(PyExc_ValueError, "':' is not an allowed character in buffer " "field names"); return -1; } _append_char(str, *p); ++p; --len; } _append_char(str, ':'); #if defined(NPY_PY3K) Py_DECREF(tmp); #endif } _append_char(str, '}'); } else { int is_standard_size = 1; int is_native_only_type = (descr->type_num == NPY_LONGDOUBLE || descr->type_num == NPY_CLONGDOUBLE); #if NPY_SIZEOF_LONG_LONG != 8 is_native_only_type = is_native_only_type || ( descr->type_num == NPY_LONGLONG || descr->type_num == NPY_ULONGLONG); #endif *offset += descr->elsize; if (descr->byteorder == '=' && _is_natively_aligned_at(descr, arr, *offset)) { /* Prefer native types, to cater for Cython */ is_standard_size = 0; if (*active_byteorder != '@') { _append_char(str, '@'); *active_byteorder = '@'; } } else if (descr->byteorder == '=' && is_native_only_type) { /* Data types that have no standard size */ is_standard_size = 0; if (*active_byteorder != '^') { _append_char(str, '^'); *active_byteorder = '^'; } } else if (descr->byteorder == '<' || descr->byteorder == '>' || descr->byteorder == '=') { is_standard_size = 1; if (*active_byteorder != descr->byteorder) { _append_char(str, descr->byteorder); *active_byteorder = descr->byteorder; } if (is_native_only_type) { /* It's not possible to express native-only data types in non-native byte orders */ PyErr_Format(PyExc_ValueError, "cannot expose native-only dtype '%c' in " "non-native byte order '%c' via buffer interface", descr->type, descr->byteorder); } } switch (descr->type_num) { case NPY_BOOL: if (_append_char(str, '?')) return -1; break; case NPY_BYTE: if (_append_char(str, 'b')) return -1; break; case NPY_UBYTE: if (_append_char(str, 'B')) return -1; break; case NPY_SHORT: if (_append_char(str, 'h')) return -1; break; case NPY_USHORT: if (_append_char(str, 'H')) return -1; break; case NPY_INT: if (_append_char(str, 'i')) return -1; break; case NPY_UINT: if (_append_char(str, 'I')) return -1; break; case NPY_LONG: if (is_standard_size && (NPY_SIZEOF_LONG == 8)) { if (_append_char(str, 'q')) return -1; } else { if (_append_char(str, 'l')) return -1; } break; case NPY_ULONG: if (is_standard_size && (NPY_SIZEOF_LONG == 8)) { if (_append_char(str, 'Q')) return -1; } else { if (_append_char(str, 'L')) return -1; } break; case NPY_LONGLONG: if (_append_char(str, 'q')) return -1; break; case NPY_ULONGLONG: if (_append_char(str, 'Q')) return -1; break; case NPY_HALF: if (_append_char(str, 'e')) return -1; break; case NPY_FLOAT: if (_append_char(str, 'f')) return -1; break; case NPY_DOUBLE: if (_append_char(str, 'd')) return -1; break; case NPY_LONGDOUBLE: if (_append_char(str, 'g')) return -1; break; case NPY_CFLOAT: if (_append_str(str, "Zf")) return -1; break; case NPY_CDOUBLE: if (_append_str(str, "Zd")) return -1; break; case NPY_CLONGDOUBLE: if (_append_str(str, "Zg")) return -1; break; /* XXX: datetime */ /* XXX: timedelta */ case NPY_OBJECT: if (_append_char(str, 'O')) return -1; break; case NPY_STRING: { char buf[128]; PyOS_snprintf(buf, sizeof(buf), "%ds", descr->elsize); if (_append_str(str, buf)) return -1; break; } case NPY_UNICODE: { /* Numpy Unicode is always 4-byte */ char buf[128]; assert(descr->elsize % 4 == 0); PyOS_snprintf(buf, sizeof(buf), "%dw", descr->elsize / 4); if (_append_str(str, buf)) return -1; break; } case NPY_VOID: { /* Insert padding bytes */ char buf[128]; PyOS_snprintf(buf, sizeof(buf), "%dx", descr->elsize); if (_append_str(str, buf)) return -1; break; } default: PyErr_Format(PyExc_ValueError, "cannot include dtype '%c' in a buffer", descr->type); return -1; } } return 0; }
AerospikeQuery * AerospikeQuery_Where(AerospikeQuery * self, PyObject * args) { as_error err; int rc = 0; PyObject * py_arg1 = NULL; PyObject * py_arg2 = NULL; PyObject * py_arg3 = NULL; PyObject * py_arg4 = NULL; PyObject * py_arg5 = NULL; PyObject * py_arg6 = NULL; if ( PyArg_ParseTuple(args, "O|OOOOO:where", &py_arg1, &py_arg2, &py_arg3, &py_arg4, &py_arg5, &py_arg6) == false ) { return NULL; } 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; } if ( PyTuple_Check(py_arg1) ) { Py_ssize_t size = PyTuple_Size(py_arg1); if ( size < 1 ) { // If it ain't atleast 1, then raise error return NULL; } PyObject * py_op = PyTuple_GetItem(py_arg1, 0); PyObject * py_op_data = PyTuple_GetItem(py_arg1, 1); if ( PyInt_Check(py_op) && PyInt_Check(py_op_data)) { as_predicate_type op = (as_predicate_type) PyInt_AsLong(py_op); as_index_datatype op_data = (as_index_datatype) PyInt_AsLong(py_op_data); rc = AerospikeQuery_Where_Add( self, op, op_data, size > 2 ? PyTuple_GetItem(py_arg1, 2) : Py_None, size > 3 ? PyTuple_GetItem(py_arg1, 3) : Py_None, size > 4 ? PyTuple_GetItem(py_arg1, 4) : Py_None, size > 5 ? PyInt_AsLong(PyTuple_GetItem(py_arg1, 5)) : 0 ); } } else if ( (py_arg1) && PyStr_Check(py_arg1) && (py_arg2) && PyStr_Check(py_arg2) ) { char * op = PyStr_AsString(py_arg2); if ( strcmp(op, "equals") == 0 ) { if ( PyInt_Check(py_arg3) || PyLong_Check(py_arg3) ) { rc = AerospikeQuery_Where_Add( self, AS_PREDICATE_EQUAL, AS_INDEX_NUMERIC, py_arg1, py_arg3, Py_None, 0 ); } else if ( PyStr_Check(py_arg3) || PyUnicode_Check(py_arg3) ) { rc = AerospikeQuery_Where_Add( self, AS_PREDICATE_EQUAL, AS_INDEX_STRING, py_arg1, py_arg3, Py_None, 0 ); } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "predicate 'equals' expects a bin and string value."); PyObject * py_err = NULL; error_to_pyobject(&err, &py_err); PyErr_SetObject(PyExc_Exception, py_err); rc = 1; } } else if ( strcmp(op, "between") == 0 ) { rc = AerospikeQuery_Where_Add( self, AS_PREDICATE_RANGE, AS_INDEX_NUMERIC, py_arg1, py_arg3, py_arg4, 0 ); } else if ( strcmp(op, "contains") == 0 ) { int index_type = 0; int type = 0; if(PyInt_Check(py_arg3)) { index_type = PyInt_AsLong(py_arg3); } else if (PyLong_Check(py_arg3)) { index_type = PyLong_AsLongLong(py_arg3); if(-1 == index_type) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize"); goto CLEANUP; } } if(PyInt_Check(py_arg4)) { type = PyInt_AsLong(py_arg4); } else if ( PyLong_Check(py_arg4) ) { type = PyLong_AsLongLong(py_arg4); if(-1 == type) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize"); goto CLEANUP; } } if ( (PyInt_Check(py_arg5) || PyLong_Check(py_arg5)) && type == 1) { rc = AerospikeQuery_Where_Add( self, AS_PREDICATE_EQUAL, AS_INDEX_NUMERIC, py_arg1, py_arg5, Py_None, index_type ); } else if ( (PyStr_Check(py_arg5) || PyUnicode_Check(py_arg5)) && type == 0) { rc = AerospikeQuery_Where_Add( self, AS_PREDICATE_EQUAL, AS_INDEX_STRING, py_arg1, py_arg5, Py_None, index_type ); } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "predicate 'contains' expects a bin and a string or int value."); PyObject * py_err = NULL; error_to_pyobject(&err, &py_err); PyErr_SetObject(PyExc_Exception, py_err); rc = 1; } } else if ( strcmp(op, "range") == 0 ) { int index_type = 0; if(PyInt_Check(py_arg3)) { index_type = PyInt_AsLong(py_arg3); } else if (PyLong_Check(py_arg3)) { index_type = PyLong_AsLongLong(py_arg3); if(-1 == index_type) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize"); goto CLEANUP; } } if ( PyInt_Check(py_arg4) || PyLong_Check(py_arg4)) { rc = AerospikeQuery_Where_Add( self, AS_PREDICATE_RANGE, AS_INDEX_NUMERIC, py_arg1, py_arg5, py_arg6, index_type ); } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "predicate 'range' expects a bin and two numeric values."); PyObject * py_err = NULL; error_to_pyobject(&err, &py_err); PyErr_SetObject(PyExc_Exception, py_err); rc = 1; } } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "predicate '%s' is invalid.", op); PyObject * py_err = NULL; error_to_pyobject(&err, &py_err); PyErr_SetObject(PyExc_Exception, py_err); rc = 1; } // if ( PyInt_Check(py_op) ) { // rc = AerospikeQuery_Where_Add( // &self->query, // PyInt_AsLong(py_op), // size > 1 ? PyTuple_GetItem(py_predicate, 1) : Py_None, // size > 2 ? PyTuple_GetItem(py_predicate, 2) : Py_None, // size > 3 ? PyTuple_GetItem(py_predicate, 3) : Py_None // ); // } } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "predicate is invalid."); 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); as_query_destroy(&self->query); rc = 1; } CLEANUP: if ( rc == 1 ) { return NULL; } 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); TRACE(); return NULL; } Py_INCREF(self); return self; }
/** ******************************************************************************************************* * Registers a UDF module with the Aerospike DB. * @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_UDF_Put(AerospikeClient * self, PyObject *args, PyObject * kwds) { // Initialize error as_error err; as_error_init(&err); // Python Function Arguments PyObject * py_filename = NULL; long language = 0; PyObject * py_udf_type = NULL; PyObject * py_policy = NULL; PyObject * py_ustr = NULL; uint8_t * bytes = NULL; as_policy_info info_policy; as_policy_info *info_policy_p = NULL; // Python Function Keyword Arguments static char * kwlist[] = {"filename", "udf_type", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|lO:udf_put", kwlist, &py_filename, &language, &py_policy) == false ) { return NULL; } if(language != AS_UDF_TYPE_LUA) { as_error_update(&err, AEROSPIKE_ERR_CLIENT, "Invalid UDF language"); goto CLEANUP; } py_udf_type = PyLong_FromLong(language); 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 PyObject into a filename string char *filename = NULL; if (PyUnicode_Check(py_filename)) { py_ustr = PyUnicode_AsUTF8String(py_filename); filename = PyString_AsString(py_ustr); } else if (PyString_Check(py_filename)) { filename = PyString_AsString(py_filename); } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filename should be a string"); goto CLEANUP; } // Convert python object to policy_info pyobject_to_policy_info( &err, py_policy, &info_policy, &info_policy_p, &self->as->config.policies.info); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } as_udf_type udf_type = (as_udf_type)PyInt_AsLong(py_udf_type); // Convert lua file to content as_bytes content; FILE * file_p = fopen(filename,"r"); FILE * copy_file_p = NULL; char copy_filepath[AS_CONFIG_PATH_MAX_LEN] = {0}; uint32_t user_path_len = strlen(self->as->config.lua.user_path); memcpy( copy_filepath, self->as->config.lua.user_path, user_path_len); if ( self->as->config.lua.user_path[user_path_len-1] != '/' ) { memcpy( copy_filepath + user_path_len, "/", 1); user_path_len = user_path_len + 1; } char* extracted_filename = strrchr(filename, '/'); if (extracted_filename) { memcpy( copy_filepath + user_path_len, extracted_filename + 1, strlen(extracted_filename) - 1); copy_filepath[user_path_len + strlen(extracted_filename) - 1] = '\0'; } else { memcpy( copy_filepath + user_path_len, filename, strlen(filename)); copy_filepath[user_path_len + strlen(filename)] = '\0'; } if ( !file_p ) { as_error_update(&err, AEROSPIKE_ERR_LUA_FILE_NOT_FOUND, "cannot open script file"); goto CLEANUP; } bytes = (uint8_t *) malloc(SCRIPT_LEN_MAX); if ( bytes == NULL ) { as_error_update(&err, errno, "malloc failed"); goto CLEANUP; } int size = 0; uint8_t * buff = bytes; if (access(self->as->config.lua.user_path, W_OK) == 0) { copy_file_p = fopen(copy_filepath, "r"); if (!copy_file_p) { copy_file_p = fopen(copy_filepath, "w+"); int read = (int)fread(buff, 1, LUA_FILE_BUFFER_FRAME, file_p); if (read && fwrite(buff, 1, read, copy_file_p)) { while (read) { size += read; buff += read; read = (int)fread(buff, 1, LUA_FILE_BUFFER_FRAME, file_p); if (!fwrite(buff, 1, read, copy_file_p)) { break; } } } else { as_error_update(&err, AEROSPIKE_ERR_CLIENT, "Write of lua file to user path failed"); goto CLEANUP; } } else { int read = (int)fread(buff, 1, LUA_FILE_BUFFER_FRAME, file_p); while (read) { size += read; buff += read; read = (int)fread(buff, 1, LUA_FILE_BUFFER_FRAME, file_p); } } } else { as_error_update(&err, AEROSPIKE_ERR_CLIENT, "No permissions to write lua file to user path"); goto CLEANUP; } if (file_p) { fclose(file_p); } if (copy_file_p) { fclose(copy_file_p); } as_bytes_init_wrap(&content, bytes, size, true); // Invoke operation Py_BEGIN_ALLOW_THREADS aerospike_udf_put(self->as, &err, info_policy_p, filename, udf_type, &content); Py_END_ALLOW_THREADS if( err.code != AEROSPIKE_OK ) { as_error_update(&err, err.code, NULL); goto CLEANUP; } else { aerospike_udf_put_wait(self->as, &err, info_policy_p, as_basename(NULL, filename), 2000); } CLEANUP: if(bytes) { free(bytes); } if (py_ustr) { Py_DECREF(py_ustr); } 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, "module")) { PyObject_SetAttrString(exception_type, "module", Py_None); } if(PyObject_HasAttrString(exception_type, "func")) { PyObject_SetAttrString(exception_type, "func", Py_None); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return PyLong_FromLong(0); }
/* * * Tests for and converts a Python datetime.datetime or datetime.date * object into a NumPy pandas_datetimestruct. Uses tzinfo (if present) * to convert to UTC time. * * 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. * * Returns -1 on error, 0 on success, and 1 (with no error set) * if obj doesn't have the needed date or datetime attributes. */ int convert_pydatetime_to_datetimestruct(PyObject *obj, pandas_datetimestruct *out) { 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")) { 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 (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); } } 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; }
static int get_int_result(PyObject *pResult, int pos) { return (int)PyInt_AsLong(PyTuple_GetItem(pResult, pos)); }