static PyObject* IORequest_fd_get(IORequest *self, void *closure) {
return PyLong_FromLong(self->iocb.aio_fildes);
}
PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlMultiLineEdit, getBufferLimit)
{
return PyLong_FromLong(self->fThis->GetBufferLimit());
}
PyObject* NS(ErrorGetNum) (
PyObject *self
)
{
return PyLong_FromLong(MqErrorGetNumI(CONTEXT));
}
static PyObject *
Context_getDebug (Context *self, void *closure)
{
int d = smbc_getDebug (self->context);
return PyLong_FromLong (d);
}
/* Helper function for typy_fields which converts a single field to a
dictionary. Returns NULL on error. */
static PyObject *
convert_field (struct type *type, int field)
{
PyObject *result = field_new ();
PyObject *arg;
if (!result)
return NULL;
if (!field_is_static (&TYPE_FIELD (type, field)))
{
arg = PyLong_FromLong (TYPE_FIELD_BITPOS (type, field));
if (!arg)
goto fail;
if (PyObject_SetAttrString (result, "bitpos", arg) < 0)
goto failarg;
}
if (TYPE_FIELD_NAME (type, field))
arg = PyString_FromString (TYPE_FIELD_NAME (type, field));
else
{
arg = Py_None;
Py_INCREF (arg);
}
if (!arg)
goto fail;
if (PyObject_SetAttrString (result, "name", arg) < 0)
goto failarg;
arg = TYPE_FIELD_ARTIFICIAL (type, field) ? Py_True : Py_False;
Py_INCREF (arg);
if (PyObject_SetAttrString (result, "artificial", arg) < 0)
goto failarg;
if (TYPE_CODE (type) == TYPE_CODE_CLASS)
arg = field < TYPE_N_BASECLASSES (type) ? Py_True : Py_False;
else
arg = Py_False;
Py_INCREF (arg);
if (PyObject_SetAttrString (result, "is_base_class", arg) < 0)
goto failarg;
arg = PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field));
if (!arg)
goto fail;
if (PyObject_SetAttrString (result, "bitsize", arg) < 0)
goto failarg;
/* A field can have a NULL type in some situations. */
if (TYPE_FIELD_TYPE (type, field) == NULL)
{
arg = Py_None;
Py_INCREF (arg);
}
else
arg = type_to_type_object (TYPE_FIELD_TYPE (type, field));
if (!arg)
goto fail;
if (PyObject_SetAttrString (result, "type", arg) < 0)
goto failarg;
return result;
failarg:
Py_DECREF (arg);
fail:
Py_DECREF (result);
return NULL;
}
static PyObject *
warn_explicit(PyObject *category, PyObject *message,
PyObject *filename, int lineno,
PyObject *module, PyObject *registry, PyObject *sourceline)
{
PyObject *key = NULL, *text = NULL, *result = NULL, *lineno_obj = NULL;
PyObject *item = NULL;
PyObject *action;
int rc;
/* module can be None if a warning is emitted late during Python shutdown.
In this case, the Python warnings module was probably unloaded, filters
are no more available to choose as action. It is safer to ignore the
warning and do nothing. */
if (module == Py_None)
Py_RETURN_NONE;
if (registry && !PyDict_Check(registry) && (registry != Py_None)) {
PyErr_SetString(PyExc_TypeError, "'registry' must be a dict");
return NULL;
}
/* Normalize module. */
if (module == NULL) {
module = normalize_module(filename);
if (module == NULL)
return NULL;
}
else
Py_INCREF(module);
/* Normalize message. */
Py_INCREF(message); /* DECREF'ed in cleanup. */
rc = PyObject_IsInstance(message, PyExc_Warning);
if (rc == -1) {
goto cleanup;
}
if (rc == 1) {
text = PyObject_Str(message);
if (text == NULL)
goto cleanup;
category = (PyObject*)message->ob_type;
}
else {
text = message;
message = PyObject_CallFunction(category, "O", message);
if (message == NULL)
goto cleanup;
}
lineno_obj = PyLong_FromLong(lineno);
if (lineno_obj == NULL)
goto cleanup;
/* Create key. */
key = PyTuple_Pack(3, text, category, lineno_obj);
if (key == NULL)
goto cleanup;
if ((registry != NULL) && (registry != Py_None)) {
rc = already_warned(registry, key, 0);
if (rc == -1)
goto cleanup;
else if (rc == 1)
goto return_none;
/* Else this warning hasn't been generated before. */
}
action = get_filter(category, text, lineno, module, &item);
if (action == NULL)
goto cleanup;
if (PyUnicode_CompareWithASCIIString(action, "error") == 0) {
PyErr_SetObject(category, message);
goto cleanup;
}
/* Store in the registry that we've been here, *except* when the action
is "always". */
rc = 0;
if (PyUnicode_CompareWithASCIIString(action, "always") != 0) {
if (registry != NULL && registry != Py_None &&
PyDict_SetItem(registry, key, Py_True) < 0)
goto cleanup;
else if (PyUnicode_CompareWithASCIIString(action, "ignore") == 0)
goto return_none;
else if (PyUnicode_CompareWithASCIIString(action, "once") == 0) {
if (registry == NULL || registry == Py_None) {
registry = get_once_registry();
if (registry == NULL)
goto cleanup;
}
/* _once_registry[(text, category)] = 1 */
rc = update_registry(registry, text, category, 0);
}
else if (PyUnicode_CompareWithASCIIString(action, "module") == 0) {
/* registry[(text, category, 0)] = 1 */
if (registry != NULL && registry != Py_None)
rc = update_registry(registry, text, category, 0);
}
else if (PyUnicode_CompareWithASCIIString(action, "default") != 0) {
PyErr_Format(PyExc_RuntimeError,
"Unrecognized action (%R) in warnings.filters:\n %R",
action, item);
goto cleanup;
}
}
if (rc == 1) /* Already warned for this module. */
goto return_none;
if (rc == 0) {
PyObject *show_fxn = get_warnings_attr("showwarning");
if (show_fxn == NULL) {
if (PyErr_Occurred())
goto cleanup;
show_warning(filename, lineno, text, category, sourceline);
}
else {
PyObject *res;
if (!PyCallable_Check(show_fxn)) {
PyErr_SetString(PyExc_TypeError,
"warnings.showwarning() must be set to a "
"callable");
Py_DECREF(show_fxn);
goto cleanup;
}
res = PyObject_CallFunctionObjArgs(show_fxn, message, category,
filename, lineno_obj,
NULL);
Py_DECREF(show_fxn);
Py_XDECREF(res);
if (res == NULL)
goto cleanup;
}
}
else /* if (rc == -1) */
goto cleanup;
return_none:
result = Py_None;
Py_INCREF(result);
cleanup:
Py_XDECREF(item);
Py_XDECREF(key);
Py_XDECREF(text);
Py_XDECREF(lineno_obj);
Py_DECREF(module);
Py_XDECREF(message);
return result; /* Py_None or NULL. */
}
//-------------------------------------------------------------------------------------
PyObject* AllClients::pyGetID()
{
return PyLong_FromLong(id());
}
static PyObject* DCPolyhedralConvexShapeNumberOfPlanes(DCPolyhedralConvexShape* self, PyObject*)
{
DCOBJECT_VALIDATE(self->shape, NULL);
return PyLong_FromLong(self->shape->NumberOfPlanes());
}
static PyObject*
record_getfieldcount(msiobj* record, PyObject* args)
{
return PyLong_FromLong(MsiRecordGetFieldCount(record->h));
}
static int
Snmp_handle(int operation, netsnmp_session *session, int reqid,
netsnmp_pdu *response, void *magic)
{
PyObject *key, *defer, *results = NULL, *resultvalue = NULL,
*resultoid = NULL, *tmp;
struct ErrorException *e;
struct variable_list *vars;
int i;
long long counter64;
SnmpObject *self;
if ((key = PyInt_FromLong(reqid)) == NULL)
/* Unknown session, don't know what to do... */
return 1;
self = (SnmpObject *)magic;
if ((defer = PyDict_GetItem(self->defers, key)) == NULL)
return 1;
Py_INCREF(defer);
PyDict_DelItem(self->defers, key);
Py_DECREF(key);
/* We have our deferred object. We will be able to trigger callbacks and
* errbacks */
if (operation == NETSNMP_CALLBACK_OP_RECEIVED_MESSAGE) {
if (response->errstat != SNMP_ERR_NOERROR) {
for (e = SnmpErrorToException; e->name; e++) {
if (e->error == response->errstat) {
PyErr_SetString(e->exception, snmp_errstring(e->error));
goto fireexception;
}
}
PyErr_Format(SnmpException, "unknown error %ld", response->errstat);
goto fireexception;
}
} else {
PyErr_SetString(SnmpException, "Timeout");
goto fireexception;
}
if ((results = PyDict_New()) == NULL)
goto fireexception;
for (vars = response->variables; vars;
vars = vars->next_variable) {
/* Let's handle the value */
switch (vars->type) {
case SNMP_NOSUCHOBJECT:
PyErr_SetString(SnmpNoSuchObject, "No such object was found");
goto fireexception;
case SNMP_NOSUCHINSTANCE:
PyErr_SetString(SnmpNoSuchInstance, "No such instance exists");
goto fireexception;
case SNMP_ENDOFMIBVIEW:
if (PyDict_Size(results) == 0) {
PyErr_SetString(SnmpEndOfMibView,
"End of MIB was reached");
goto fireexception;
} else
continue;
case ASN_INTEGER:
resultvalue = PyLong_FromLong(*vars->val.integer);
break;
case ASN_UINTEGER:
case ASN_TIMETICKS:
case ASN_GAUGE:
case ASN_COUNTER:
resultvalue = PyLong_FromUnsignedLong(
(unsigned long)*vars->val.integer);
break;
case ASN_OCTET_STR:
resultvalue = PyString_FromStringAndSize(
(char*)vars->val.string, vars->val_len);
break;
case ASN_BIT_STR:
resultvalue = PyString_FromStringAndSize(
(char*)vars->val.bitstring, vars->val_len);
break;
case ASN_OBJECT_ID:
if ((resultvalue = PyTuple_New(
vars->val_len/sizeof(oid))) == NULL)
goto fireexception;
for (i = 0; i < vars->val_len/sizeof(oid); i++) {
if ((tmp = PyLong_FromLong(
vars->val.objid[i])) == NULL)
goto fireexception;
PyTuple_SetItem(resultvalue, i, tmp);
}
if ((resultvalue = Snmp_oid2string(resultvalue)) == NULL)
goto fireexception;
break;
case ASN_IPADDRESS:
if (vars->val_len < 4) {
PyErr_Format(SnmpException, "IP address is too short (%zd < 4)",
vars->val_len);
goto fireexception;
}
resultvalue = PyString_FromFormat("%d.%d.%d.%d",
vars->val.string[0],
vars->val.string[1],
vars->val.string[2],
vars->val.string[3]);
break;
case ASN_COUNTER64:
#ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
case ASN_OPAQUE_U64:
case ASN_OPAQUE_I64:
case ASN_OPAQUE_COUNTER64:
#endif /* NETSNMP_WITH_OPAQUE_SPECIAL_TYPES */
counter64 = ((unsigned long long)(vars->val.counter64->high) << 32) +
(unsigned long long)(vars->val.counter64->low);
resultvalue = PyLong_FromUnsignedLongLong(counter64);
break;
#ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
case ASN_OPAQUE_FLOAT:
resultvalue = PyFloat_FromDouble(*vars->val.floatVal);
break;
case ASN_OPAQUE_DOUBLE:
resultvalue = PyFloat_FromDouble(*vars->val.doubleVal);
break;
#endif /* NETSNMP_WITH_OPAQUE_SPECIAL_TYPES */
default:
PyErr_Format(SnmpException, "unknown type returned (%d)",
vars->type);
goto fireexception;
}
if (resultvalue == NULL) goto fireexception;
/* And now, the OID */
if ((resultoid = PyTuple_New(vars->name_length)) == NULL)
goto fireexception;
for (i = 0; i < vars->name_length; i++) {
if ((tmp = PyLong_FromLong(vars->name[i])) == NULL)
goto fireexception;
PyTuple_SetItem(resultoid, i, tmp);
}
if ((resultoid = Snmp_oid2string(resultoid)) == NULL)
goto fireexception;
/* Put into dictionary */
PyDict_SetItem(results, resultoid, resultvalue);
Py_CLEAR(resultoid);
Py_CLEAR(resultvalue);
}
if ((tmp = PyObject_GetAttrString(defer, "callback")) == NULL)
goto fireexception;
Py_DECREF(PyObject_CallMethod(reactor, "callLater", "iOO", 0, tmp, results));
Py_DECREF(tmp);
Py_DECREF(results);
Py_DECREF(defer);
Py_DECREF(self);
return 1;
fireexception:
Snmp_invokeerrback(defer);
Py_XDECREF(results);
Py_XDECREF(resultvalue);
Py_XDECREF(resultoid);
Py_DECREF(defer);
Py_DECREF(self);
return 1;
}
//-------------------------------------------------------------------------------------
PyObject* ClientApp::__py_getAppPublish(PyObject* self, PyObject* args)
{
return PyLong_FromLong(g_appPublish);
}
static PyObject* pyalpm_package_get_reason(AlpmPackage *self, void *closure) {
CHECK_IF_INITIALIZED();
return PyLong_FromLong(alpm_pkg_get_reason(self->c_data));
}
PyMODINIT_FUNC
init_multiprocessing(void)
{
PyObject *module, *temp, *value;
/* Initialize module */
module = Py_InitModule("_multiprocessing", module_methods);
if (!module)
return;
/* Get copy of objects from pickle */
temp = PyImport_ImportModule(PICKLE_MODULE);
if (!temp)
return;
pickle_dumps = PyObject_GetAttrString(temp, "dumps");
pickle_loads = PyObject_GetAttrString(temp, "loads");
pickle_protocol = PyObject_GetAttrString(temp, "HIGHEST_PROTOCOL");
Py_XDECREF(temp);
/* Get copy of BufferTooShort */
temp = PyImport_ImportModule("multiprocessing");
if (!temp)
return;
BufferTooShort = PyObject_GetAttrString(temp, "BufferTooShort");
Py_XDECREF(temp);
/* Add connection type to module */
if (PyType_Ready(&ConnectionType) < 0)
return;
Py_INCREF(&ConnectionType);
PyModule_AddObject(module, "Connection", (PyObject*)&ConnectionType);
#if defined(MS_WINDOWS) || \
(defined(HAVE_SEM_OPEN) && !defined(POSIX_SEMAPHORES_NOT_ENABLED))
/* Add SemLock type to module */
if (PyType_Ready(&SemLockType) < 0)
return;
Py_INCREF(&SemLockType);
{
PyObject *py_sem_value_max;
/* Some systems define SEM_VALUE_MAX as an unsigned value that
* causes it to be negative when used as an int (NetBSD). */
if ((int)(SEM_VALUE_MAX) < 0)
py_sem_value_max = PyLong_FromLong(INT_MAX);
else
py_sem_value_max = PyLong_FromLong(SEM_VALUE_MAX);
if (py_sem_value_max == NULL)
return;
PyDict_SetItemString(SemLockType.tp_dict, "SEM_VALUE_MAX",
py_sem_value_max);
}
PyModule_AddObject(module, "SemLock", (PyObject*)&SemLockType);
#endif
#ifdef MS_WINDOWS
/* Add PipeConnection to module */
if (PyType_Ready(&PipeConnectionType) < 0)
return;
Py_INCREF(&PipeConnectionType);
PyModule_AddObject(module, "PipeConnection",
(PyObject*)&PipeConnectionType);
/* Initialize win32 class and add to multiprocessing */
temp = create_win32_namespace();
if (!temp)
return;
PyModule_AddObject(module, "win32", temp);
/* Initialize the event handle used to signal Ctrl-C */
sigint_event = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!sigint_event) {
PyErr_SetFromWindowsErr(0);
return;
}
if (!SetConsoleCtrlHandler(ProcessingCtrlHandler, TRUE)) {
PyErr_SetFromWindowsErr(0);
return;
}
#endif
/* Add configuration macros */
temp = PyDict_New();
if (!temp)
return;
#define ADD_FLAG(name) \
value = Py_BuildValue("i", name); \
if (value == NULL) { Py_DECREF(temp); return; } \
if (PyDict_SetItemString(temp, #name, value) < 0) { \
Py_DECREF(temp); Py_DECREF(value); return; } \
Py_DECREF(value)
#if defined(HAVE_SEM_OPEN) && !defined(POSIX_SEMAPHORES_NOT_ENABLED)
ADD_FLAG(HAVE_SEM_OPEN);
#endif
#ifdef HAVE_SEM_TIMEDWAIT
ADD_FLAG(HAVE_SEM_TIMEDWAIT);
#endif
#ifdef HAVE_FD_TRANSFER
ADD_FLAG(HAVE_FD_TRANSFER);
#endif
#ifdef HAVE_BROKEN_SEM_GETVALUE
ADD_FLAG(HAVE_BROKEN_SEM_GETVALUE);
#endif
#ifdef HAVE_BROKEN_SEM_UNLINK
ADD_FLAG(HAVE_BROKEN_SEM_UNLINK);
#endif
if (PyModule_AddObject(module, "flags", temp) < 0)
return;
}
/**
*******************************************************************************************************
* This function invokes csdk's API's.
*
* @param self AerospikeClient object
* @param err The as_error to be populated by the function
* with the encountered error if any.
* @param key The C client's as_key that identifies the record.
* @param py_list The list containing op, bin and value.
* @param py_meta The metadata for the operation.
* @param operate_policy_p The value for operate policy.
*******************************************************************************************************
*/
static
PyObject * AerospikeClient_Operate_Invoke(
AerospikeClient * self, as_error *err,
as_key * key, PyObject * py_list, PyObject * py_meta,
as_policy_operate * operate_policy_p)
{
as_val* put_val = NULL;
char* bin = NULL;
char* val = NULL;
long offset = 0;
double double_offset = 0.0;
uint32_t ttl = 0;
long operation = 0;
int i = 0;
PyObject * py_rec = NULL;
PyObject * py_ustr = NULL;
PyObject * py_ustr1 = NULL;
PyObject * py_bin = NULL;
as_record * rec = NULL;
as_static_pool static_pool;
memset(&static_pool, 0, sizeof(static_pool));
as_operations ops;
Py_ssize_t size = PyList_Size(py_list);
as_operations_inita(&ops, size);
if (!self || !self->as) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if(py_meta) {
AerospikeClient_CheckForMeta(py_meta, &ops, err);
}
if (err->code != AEROSPIKE_OK) {
goto CLEANUP;
}
for ( i = 0; i < size; i++) {
PyObject * py_val = PyList_GetItem(py_list, i);
operation = -1;
offset = 0;
double_offset = 0.0;
if ( PyDict_Check(py_val) ) {
PyObject *key_op = NULL, *value = NULL;
PyObject * py_value = NULL;
Py_ssize_t pos = 0;
while (PyDict_Next(py_val, &pos, &key_op, &value)) {
if ( ! PyString_Check(key_op) ) {
as_error_update(err, AEROSPIKE_ERR_CLIENT, "A operation key must be a string.");
goto CLEANUP;
} else {
char * name = PyString_AsString(key_op);
if(!strcmp(name,"op") && (PyInt_Check(value) || PyLong_Check(value))) {
operation = PyInt_AsLong(value);
} else if (!strcmp(name, "bin")) {
py_bin = value;
} else if(!strcmp(name, "val")) {
py_value = value;
} else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "operation can contain only op, bin and val keys");
goto CLEANUP;
}
}
}
if (py_bin) {
if (PyUnicode_Check(py_bin)) {
py_ustr = PyUnicode_AsUTF8String(py_bin);
bin = PyString_AsString(py_ustr);
} else if (PyString_Check(py_bin)) {
bin = PyString_AsString(py_bin);
} else if (PyByteArray_Check(py_bin)) {
bin = PyByteArray_AsString(py_bin);
} else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Bin name should be of type string");
goto CLEANUP;
}
if (self->strict_types) {
if (strlen(bin) > AS_BIN_NAME_MAX_LEN) {
if (py_ustr) {
Py_DECREF(py_ustr);
py_ustr = NULL;
}
as_error_update(err, AEROSPIKE_ERR_BIN_NAME, "A bin name should not exceed 14 characters limit");
goto CLEANUP;
}
}
} else if (!py_bin && operation != AS_OPERATOR_TOUCH) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Bin is not given");
goto CLEANUP;
}
if (py_value) {
if (self->strict_types) {
if (check_type(self, py_value, operation, err)) {
goto CLEANUP;
}
}
} else if ((!py_value) && (operation != AS_OPERATOR_READ && operation != AS_OPERATOR_TOUCH)) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Value should be given");
goto CLEANUP;
}
switch(operation) {
case AS_OPERATOR_APPEND:
if (PyUnicode_Check(py_value)) {
py_ustr1 = PyUnicode_AsUTF8String(py_value);
val = PyString_AsString(py_ustr1);
as_operations_add_append_str(&ops, bin, val);
} else if (PyString_Check(py_value)) {
val = PyString_AsString(py_value);
as_operations_add_append_str(&ops, bin, val);
} else if (PyByteArray_Check(py_value)) {
as_bytes *bytes;
GET_BYTES_POOL(bytes, &static_pool, err);
serialize_based_on_serializer_policy(self, SERIALIZER_PYTHON, &bytes, py_value, err);
as_operations_add_append_raw(&ops, bin, bytes->value, bytes->size);
} else {
if (!self->strict_types || !strcmp(py_value->ob_type->tp_name, "aerospike.null")) {
as_operations *pointer_ops = &ops;
as_binop *binop = &pointer_ops->binops.entries[pointer_ops->binops.size++];
binop->op = AS_OPERATOR_APPEND;
initialize_bin_for_strictypes(self, err, py_value, binop, bin, &static_pool);
}
}
break;
case AS_OPERATOR_PREPEND:
if (PyUnicode_Check(py_value)) {
py_ustr1 = PyUnicode_AsUTF8String(py_value);
val = PyString_AsString(py_ustr1);
as_operations_add_prepend_str(&ops, bin, val);
} else if (PyString_Check(py_value)) {
val = PyString_AsString(py_value);
as_operations_add_prepend_str(&ops, bin, val);
} else if (PyByteArray_Check(py_value)) {
as_bytes *bytes;
GET_BYTES_POOL(bytes, &static_pool, err);
serialize_based_on_serializer_policy(self, SERIALIZER_PYTHON, &bytes, py_value, err);
as_operations_add_prepend_raw(&ops, bin, bytes->value, bytes->size);
} else {
if (!self->strict_types || !strcmp(py_value->ob_type->tp_name, "aerospike.null")) {
as_operations *pointer_ops = &ops;
as_binop *binop = &pointer_ops->binops.entries[pointer_ops->binops.size++];
binop->op = AS_OPERATOR_PREPEND;
initialize_bin_for_strictypes(self, err, py_value, binop, bin, &static_pool);
}
}
break;
case AS_OPERATOR_INCR:
if (PyInt_Check(py_value)) {
offset = PyInt_AsLong(py_value);
as_operations_add_incr(&ops, bin, offset);
} else if ( PyLong_Check(py_value) ) {
offset = PyLong_AsLong(py_value);
if (offset == -1 && PyErr_Occurred()) {
if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize");
goto CLEANUP;
}
}
as_operations_add_incr(&ops, bin, offset);
} else if (PyFloat_Check(py_value)) {
double_offset = PyFloat_AsDouble(py_value);
as_operations_add_incr_double(&ops, bin, double_offset);
} else {
if (!self->strict_types || !strcmp(py_value->ob_type->tp_name, "aerospike.null")) {
as_operations *pointer_ops = &ops;
as_binop *binop = &pointer_ops->binops.entries[pointer_ops->binops.size++];
binop->op = AS_OPERATOR_INCR;
initialize_bin_for_strictypes(self, err, py_value, binop, bin, &static_pool);
}
}
break;
case AS_OPERATOR_TOUCH:
ops.ttl = 0;
if (py_value && PyInt_Check(py_value)) {
ops.ttl = PyInt_AsLong(py_value);
} else if (py_value && PyLong_Check(py_value)) {
ttl = PyLong_AsLong(py_value);
if((uint32_t)-1 == ttl) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "integer value for ttl exceeds sys.maxsize");
goto CLEANUP;
}
ops.ttl = ttl;
}
as_operations_add_touch(&ops);
break;
case AS_OPERATOR_READ:
as_operations_add_read(&ops, bin);
break;
case AS_OPERATOR_WRITE:
pyobject_to_astype_write(self, err, bin, py_value, &put_val, &ops,
&static_pool, SERIALIZER_PYTHON);
if (err->code != AEROSPIKE_OK) {
goto CLEANUP;
}
as_operations_add_write(&ops, bin, (as_bin_value *) put_val);
break;
default:
if (self->strict_types) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Invalid operation given");
goto CLEANUP;
}
}
}
}
// Initialize record
as_record_init(rec, 0);
Py_BEGIN_ALLOW_THREADS
aerospike_key_operate(self->as, err, operate_policy_p, key, &ops, &rec);
Py_END_ALLOW_THREADS
if (err->code != AEROSPIKE_OK) {
as_error_update(err, err->code, NULL);
goto CLEANUP;
}
if(rec) {
record_to_pyobject(self, err, rec, key, &py_rec);
}
CLEANUP:
if (py_ustr) {
Py_DECREF(py_ustr);
}
if (py_ustr1) {
Py_DECREF(py_ustr1);
}
if (rec) {
as_record_destroy(rec);
}
if (key->valuep) {
as_key_destroy(key);
}
if (put_val) {
as_val_destroy(put_val);
}
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;
}
if (py_rec) {
return py_rec;
} else {
return PyLong_FromLong(0);
}
}
/**
*******************************************************************************************************
* This function invokes csdk's API's.
*
* @param self AerospikeClient object
* @param err The as_error to be populated by the function
* with the encountered error if any.
* @param key The C client's as_key that identifies the record.
* @param py_list The list containing op, bin and value.
* @param py_meta The metadata for the operation.
* @param operate_policy_p The value for operate policy.
*******************************************************************************************************
*/
static
PyObject * AerospikeClient_Operate_Invoke(
AerospikeClient * self, as_error *err,
as_key * key, PyObject * py_list, PyObject * py_meta,
as_policy_operate * operate_policy_p)
{
as_val* put_val = NULL;
char* bin = NULL;
char* val = NULL;
long offset = 0;
uint32_t ttl = 0;
long operation = 0;
int i = 0;
PyObject * py_rec = NULL;
PyObject * py_ustr = NULL;
PyObject * py_ustr1 = NULL;
PyObject * py_bin = NULL;
as_record * rec = NULL;
as_static_pool static_pool;
memset(&static_pool, 0, sizeof(static_pool));
as_operations ops;
Py_ssize_t size = PyList_Size(py_list);
as_operations_inita(&ops, size);
if (!self || !self->as) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if(py_meta) {
AerospikeClient_CheckForMeta(py_meta, &ops, err);
}
if (err->code != AEROSPIKE_OK) {
goto CLEANUP;
}
for ( i = 0; i < size; i++) {
PyObject * py_val = PyList_GetItem(py_list, i);
operation = -1;
offset = 0;
if ( PyDict_Check(py_val) ) {
PyObject *key_op = NULL, *value = NULL;
PyObject * py_value = NULL;
Py_ssize_t pos = 0;
while (PyDict_Next(py_val, &pos, &key_op, &value)) {
if ( ! PyString_Check(key_op) ) {
as_error_update(err, AEROSPIKE_ERR_CLIENT, "A operation key must be a string.");
goto CLEANUP;
} else {
char * name = PyString_AsString(key_op);
if(!strcmp(name,"op") && (PyInt_Check(value) || PyLong_Check(value))) {
operation = PyInt_AsLong(value);
} else if (!strcmp(name, "bin")) {
py_bin = value;
} else if(!strcmp(name, "val")) {
py_value = value;
} else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "operation can contain only op, bin and val keys");
goto CLEANUP;
}
}
}
if (py_bin) {
if (PyUnicode_Check(py_bin)) {
py_ustr = PyUnicode_AsUTF8String(py_bin);
bin = PyString_AsString(py_ustr);
} else if (PyString_Check(py_bin)) {
bin = PyString_AsString(py_bin);
} else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Bin name should be of type string");
goto CLEANUP;
}
} else if (!py_bin && operation != AS_OPERATOR_TOUCH) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Bin is not given");
goto CLEANUP;
}
if (py_value) {
if (check_type(py_value, operation, err)) {
goto CLEANUP;
} else if (PyString_Check(py_value) && (operation == AS_OPERATOR_INCR)) {
char * incr_string = PyString_AsString(py_value);
int incr_value = 0, sign = 1;
if (strlen(incr_string) > 15) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Unsupported string length for increment operation");
goto CLEANUP;
}
if (*incr_string == '-') {
incr_string = incr_string + 1;
sign = -1;
} else if (*incr_string == '+') {
incr_string = incr_string + 1;
sign = 1;
}
while (*incr_string != '\0') {
if (*incr_string >= 48 && *incr_string <= 57) {
incr_value = (incr_value * 10) + (*incr_string ^ 0x30);
} else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Unsupported operand type(s) for +: 'int' and 'str'");
goto CLEANUP;
}
incr_string = incr_string + 1;
}
incr_value = incr_value * sign;
py_value = PyInt_FromLong(incr_value);
}
} else if ((!py_value) && (operation != AS_OPERATOR_READ)) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Value should be given");
goto CLEANUP;
}
switch(operation) {
case AS_OPERATOR_APPEND:
if (PyUnicode_Check(py_value)) {
py_ustr1 = PyUnicode_AsUTF8String(py_value);
val = PyString_AsString(py_ustr1);
} else {
val = PyString_AsString(py_value);
}
as_operations_add_append_str(&ops, bin, val);
break;
case AS_OPERATOR_PREPEND:
if (PyUnicode_Check(py_value)) {
py_ustr1 = PyUnicode_AsUTF8String(py_value);
val = PyString_AsString(py_ustr1);
} else {
val = PyString_AsString(py_value);
}
as_operations_add_prepend_str(&ops, bin, val);
break;
case AS_OPERATOR_INCR:
if (PyInt_Check(py_value)) {
offset = PyInt_AsLong(py_value);
} else if ( PyLong_Check(py_value) ) {
offset = PyLong_AsLong(py_value);
if(-1 == offset) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize");
goto CLEANUP;
}
}
as_operations_add_incr(&ops, bin, offset);
break;
case AS_OPERATOR_TOUCH:
if (PyInt_Check(py_value)) {
ops.ttl = PyInt_AsLong(py_value);
} else if ( PyLong_Check(py_value) ) {
ttl = PyLong_AsLong(py_value);
if((uint32_t)-1 == ttl) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "integer value for ttl exceeds sys.maxsize");
goto CLEANUP;
}
ops.ttl = ttl;
}
as_operations_add_touch(&ops);
break;
case AS_OPERATOR_READ:
as_operations_add_read(&ops, bin);
break;
case AS_OPERATOR_WRITE:
pyobject_to_astype_write(err, bin, py_value, &put_val, &ops,
&static_pool, SERIALIZER_PYTHON);
if (err->code != AEROSPIKE_OK) {
goto CLEANUP;
}
as_operations_add_write(&ops, bin, (as_bin_value *) put_val);
break;
default:
as_error_update(err, AEROSPIKE_ERR_PARAM, "Invalid operation given");
}
}
}
// Initialize record
as_record_init(rec, 0);
aerospike_key_operate(self->as, err, operate_policy_p, key, &ops, &rec);
if (err->code != AEROSPIKE_OK) {
as_error_update(err, err->code, NULL);
goto CLEANUP;
}
if(rec) {
record_to_pyobject(err, rec, key, &py_rec);
}
CLEANUP:
if (py_ustr) {
Py_DECREF(py_ustr);
}
if (py_ustr1) {
Py_DECREF(py_ustr1);
}
if (rec) {
as_record_destroy(rec);
}
if (key->valuep) {
as_key_destroy(key);
}
if (put_val) {
as_val_destroy(put_val);
}
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;
}
if (py_rec) {
return py_rec;
} else {
return PyLong_FromLong(0);
}
}
/*
*******************************************************************************************************
* Checks serializer_policy.
* Serializes Py_Object (value) into as_bytes using serialization logic
* based on serializer_policy.
*
* @param serializer_policy The serializer_policy to be used to handle
* the serialization.
* @param bytes The as_bytes to be set.
* @param value The value to be serialized.
* @param error_p The as_error to be populated by the function
* with encountered error if any.
*******************************************************************************************************
*/
extern PyObject * serialize_based_on_serializer_policy(AerospikeClient * self,
int32_t serializer_policy,
as_bytes **bytes,
PyObject *value,
as_error *error_p)
{
uint8_t use_client_serializer = true;
PyObject* initresult = NULL;
if (self->is_client_put_serializer) {
if (serializer_policy == SERIALIZER_USER) {
if (!self->user_serializer_call_info.callback) {
use_client_serializer = false;
}
}
} else if (self->user_serializer_call_info.callback) {
serializer_policy = SERIALIZER_USER;
}
switch(serializer_policy) {
case SERIALIZER_NONE:
as_error_update(error_p, AEROSPIKE_ERR_PARAM,
"Cannot serialize: SERIALIZER_NONE selected");
goto CLEANUP;
case SERIALIZER_PYTHON:
{
/*
* Serialize bytearray as is and store them into database with
* type AS_BYTES_BLOB, unlike other values in case of
* SERIALIZER_PYTHON.
* This is a special case.
* Refer: AER-3589 for more details.
*/
if (PyByteArray_Check(value)) {
uint8_t *bytes_array = (uint8_t *) PyByteArray_AsString(value);
uint32_t bytes_array_len = (uint32_t) PyByteArray_Size(value);
set_as_bytes(bytes, bytes_array, bytes_array_len, AS_BYTES_BLOB, error_p);
} else {
/* get the sys.modules dictionary */
PyObject* sysmodules = PyImport_GetModuleDict();
PyObject* cpickle_module = NULL;
if(PyMapping_HasKeyString(sysmodules, "cPickle")) {
cpickle_module = PyMapping_GetItemString(sysmodules, "cPickle");
} else {
cpickle_module = PyImport_ImportModule("cPickle");
}
if(!cpickle_module) {
/* insert error handling here! and exit this function */
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to load cpickle module");
goto CLEANUP;
} else {
PyObject * py_funcname = PyStr_FromString("dumps");
Py_INCREF(cpickle_module);
initresult = PyObject_CallMethodObjArgs(cpickle_module,
py_funcname, value, NULL);
Py_DECREF(cpickle_module);
Py_DECREF(py_funcname);
if(!initresult) {
/* more error handling &c */
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to call dumps function");
goto CLEANUP;
} else {
Py_INCREF(initresult);
char *return_value = PyStr_AsString(initresult);
Py_ssize_t len = PyBytes_GET_SIZE(initresult);
set_as_bytes(bytes, (uint8_t *) return_value,
len, AS_BYTES_PYTHON, error_p);
Py_DECREF(initresult);
}
}
Py_XDECREF(cpickle_module);
}
}
break;
case SERIALIZER_JSON:
/*
* TODO:
* Handle JSON serialization after support for AS_BYTES_JSON
* is added in aerospike-client-c
*/
as_error_update(error_p, AEROSPIKE_ERR,
"Unable to serialize using standard json serializer");
goto CLEANUP;
case SERIALIZER_USER:
if (use_client_serializer) {
execute_user_callback(&self->user_serializer_call_info, bytes, &value, true, error_p);
if (AEROSPIKE_OK != (error_p->code)) {
goto CLEANUP;
}
} else {
if (is_user_serializer_registered) {
execute_user_callback(&user_serializer_call_info, bytes, &value, true, error_p);
if (AEROSPIKE_OK != (error_p->code)) {
goto CLEANUP;
}
} else if (self->user_serializer_call_info.callback) {
execute_user_callback(&self->user_serializer_call_info, bytes, &value, true, error_p);
if (AEROSPIKE_OK != (error_p->code)) {
goto CLEANUP;
}
} else {
as_error_update(error_p, AEROSPIKE_ERR,
"No serializer callback registered");
goto CLEANUP;
}
}
break;
default:
as_error_update(error_p, AEROSPIKE_ERR,
"Unsupported serializer");
goto CLEANUP;
}
CLEANUP:
Py_XDECREF(initresult);
if ( error_p->code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(error_p, &py_err);
PyObject *exception_type = raise_exception(error_p);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/**
*******************************************************************************************************
* Touch a record in 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_Touch(AerospikeClient * self, PyObject * args, PyObject * kwds)
{
// Initialize error
as_error err;
as_error_init(&err);
// Python Function Arguments
PyObject * py_key = NULL;
PyObject * py_policy = NULL;
PyObject * py_result = NULL;
PyObject * py_meta = NULL;
PyObject * py_touchvalue = 0;
as_key key;
as_policy_operate operate_policy;
as_policy_operate *operate_policy_p = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"key", "val", "meta", "policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO:touch", kwlist,
&py_key, &py_touchvalue, &py_meta, &py_policy) == false ) {
return NULL;
}
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
py_result = AerospikeClient_convert_pythonObj_to_asType(self, &err,
py_key, py_policy, &key, &operate_policy, &operate_policy_p);
if (!py_result) {
goto CLEANUP;
} else {
Py_DECREF(py_result);
}
PyObject * py_list = NULL;
py_list = create_pylist(py_list, AS_OPERATOR_TOUCH, NULL, py_touchvalue);
py_result = AerospikeClient_Operate_Invoke(self, &err, &key, py_list,
py_meta, operate_policy_p);
if (py_list) {
Py_DECREF(py_list);
}
if (err.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
} else if (py_result == NULL) {
return NULL;
} else {
Py_DECREF(py_result);
}
CLEANUP:
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
if(PyObject_HasAttrString(exception_type, "key")) {
PyObject_SetAttrString(exception_type, "key", py_key);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/*
*******************************************************************************************************
* Checks as_bytes->type.
* Deserializes as_bytes into Py_Object (retval) using deserialization logic
* based on as_bytes->type.
*
* @param bytes The as_bytes to be deserialized.
* @param retval The return zval to be populated with the
* deserialized value of the input as_bytes.
* @param error_p The as_error to be populated by the function
* with encountered error if any.
*******************************************************************************************************
*/
extern PyObject * deserialize_based_on_as_bytes_type(AerospikeClient * self,
as_bytes *bytes,
PyObject **retval,
as_error *error_p)
{
switch(as_bytes_get_type(bytes)) {
case AS_BYTES_PYTHON: {
PyObject* sysmodules = PyImport_GetModuleDict();
PyObject* cpickle_module = NULL;
if(PyMapping_HasKeyString(sysmodules, "cPickle")) {
cpickle_module = PyMapping_GetItemString(sysmodules, "cPickle");
} else {
cpickle_module = PyImport_ImportModule("cPickle");
}
PyObject* initresult = NULL;
if(!cpickle_module) {
/* insert error handling here! and exit this function */
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to load cpickle module");
goto CLEANUP;
} else {
char* bytes_val_p = (char*)bytes->value;
PyObject *py_value = PyStr_FromStringAndSize(bytes_val_p, as_bytes_size(bytes));
PyObject *py_funcname = PyStr_FromString("loads");
Py_INCREF(cpickle_module);
initresult = PyObject_CallMethodObjArgs(cpickle_module, py_funcname, py_value, NULL);
Py_DECREF(cpickle_module);
Py_DECREF(py_funcname);
Py_DECREF(py_value);
if(!initresult) {
/* more error handling &c */
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to call loads function");
goto CLEANUP;
} else {
*retval = initresult;
}
}
Py_XDECREF(cpickle_module);
}
break;
case AS_BYTES_BLOB: {
if (self->user_deserializer_call_info.callback) {
execute_user_callback(&self->user_deserializer_call_info, &bytes, retval, false, error_p);
if(AEROSPIKE_OK != (error_p->code)) {
uint32_t bval_size = as_bytes_size(bytes);
PyObject *py_val = PyByteArray_FromStringAndSize((char *) as_bytes_get(bytes), bval_size);
if (!py_val) {
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to deserialize bytes");
goto CLEANUP;
}
*retval = py_val;
as_error_update(error_p, AEROSPIKE_OK, NULL);
}
} else {
if (is_user_deserializer_registered) {
execute_user_callback(&user_deserializer_call_info, &bytes, retval, false, error_p);
if(AEROSPIKE_OK != (error_p->code)) {
uint32_t bval_size = as_bytes_size(bytes);
PyObject *py_val = PyByteArray_FromStringAndSize((char *) as_bytes_get(bytes), bval_size);
if (!py_val) {
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to deserialize bytes");
goto CLEANUP;
}
as_error_update(error_p, AEROSPIKE_OK, NULL);
*retval = py_val;
}
} else {
uint32_t bval_size = as_bytes_size(bytes);
PyObject *py_val = PyByteArray_FromStringAndSize((char *) as_bytes_get(bytes), bval_size);
if (!py_val) {
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to deserialize bytes");
goto CLEANUP;
}
*retval = py_val;
}
}
}
break;
case AS_BYTES_LDT: {
Py_INCREF(Py_None);
*retval = Py_None;
}
break;
default:
as_error_update(error_p, AEROSPIKE_ERR,
"Unable to deserialize bytes");
goto CLEANUP;
}
CLEANUP:
if ( error_p->code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(error_p, &py_err);
PyObject *exception_type = raise_exception(error_p);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
PyObject *success(PyObject *, PyObject *) {
return PyLong_FromLong(1234567L);
}
void weechat_python_init_module_weechat ()
#endif /* PY_MAJOR_VERSION >= 3 */
{
PyObject *weechat_module, *weechat_dict;
#if PY_MAJOR_VERSION >= 3
/* python >= 3.x */
weechat_module = PyModule_Create (&moduleDef);
#else
/* python <= 2.x */
weechat_module = Py_InitModule ("weechat", weechat_python_funcs);
#endif /* PY_MAJOR_VERSION >= 3 */
if (!weechat_module)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to initialize WeeChat "
"module"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME);
#if PY_MAJOR_VERSION >= 3
return NULL;
#else
return;
#endif /* PY_MAJOR_VERSION >= 3 */
}
/* define some constants */
weechat_dict = PyModule_GetDict(weechat_module);
PyDict_SetItemString(weechat_dict, "WEECHAT_RC_OK", PyLong_FromLong((long) WEECHAT_RC_OK));
PyDict_SetItemString(weechat_dict, "WEECHAT_RC_OK_EAT", PyLong_FromLong((long) WEECHAT_RC_OK_EAT));
PyDict_SetItemString(weechat_dict, "WEECHAT_RC_ERROR", PyLong_FromLong((long) WEECHAT_RC_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_READ_OK", PyLong_FromLong((long) WEECHAT_CONFIG_READ_OK));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_READ_MEMORY_ERROR", PyLong_FromLong((long) WEECHAT_CONFIG_READ_MEMORY_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_READ_FILE_NOT_FOUND", PyLong_FromLong((long) WEECHAT_CONFIG_READ_FILE_NOT_FOUND));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_WRITE_OK", PyLong_FromLong((long) WEECHAT_CONFIG_WRITE_OK));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_WRITE_ERROR", PyLong_FromLong((long) WEECHAT_CONFIG_WRITE_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_WRITE_MEMORY_ERROR", PyLong_FromLong((long) WEECHAT_CONFIG_WRITE_MEMORY_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_SET_OK_CHANGED", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_SET_OK_CHANGED));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_SET_ERROR", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_SET_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_UNSET_OK_RESET", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_UNSET_OK_RESET));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_UNSET_ERROR", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_UNSET_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_LIST_POS_SORT", PyUnicode_FromString(WEECHAT_LIST_POS_SORT));
PyDict_SetItemString(weechat_dict, "WEECHAT_LIST_POS_BEGINNING", PyUnicode_FromString(WEECHAT_LIST_POS_BEGINNING));
PyDict_SetItemString(weechat_dict, "WEECHAT_LIST_POS_END", PyUnicode_FromString(WEECHAT_LIST_POS_END));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOTLIST_LOW", PyUnicode_FromString(WEECHAT_HOTLIST_LOW));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOTLIST_MESSAGE", PyUnicode_FromString(WEECHAT_HOTLIST_MESSAGE));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOTLIST_PRIVATE", PyUnicode_FromString(WEECHAT_HOTLIST_PRIVATE));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOTLIST_HIGHLIGHT", PyUnicode_FromString(WEECHAT_HOTLIST_HIGHLIGHT));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_PROCESS_RUNNING", PyLong_FromLong((long) WEECHAT_HOOK_PROCESS_RUNNING));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_PROCESS_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_PROCESS_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_OK", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_OK));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_ADDRESS_NOT_FOUND", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_ADDRESS_NOT_FOUND));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_IP_ADDRESS_NOT_FOUND", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_IP_ADDRESS_NOT_FOUND));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_CONNECTION_REFUSED", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_CONNECTION_REFUSED));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_PROXY_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_PROXY_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_LOCAL_HOSTNAME_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_LOCAL_HOSTNAME_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_GNUTLS_INIT_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_GNUTLS_INIT_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_GNUTLS_HANDSHAKE_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_GNUTLS_HANDSHAKE_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_MEMORY_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_MEMORY_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_TIMEOUT", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_TIMEOUT));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_SOCKET_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_SOCKET_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_SIGNAL_STRING", PyUnicode_FromString(WEECHAT_HOOK_SIGNAL_STRING));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_SIGNAL_INT", PyUnicode_FromString(WEECHAT_HOOK_SIGNAL_INT));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_SIGNAL_POINTER", PyUnicode_FromString(WEECHAT_HOOK_SIGNAL_POINTER));
#if PY_MAJOR_VERSION >= 3
return weechat_module;
#endif /* PY_MAJOR_VERSION >= 3 */
}
static PyObject *
Notification_get_property(Notification *self, const gchar *prop_name)
{
g_return_val_if_fail(self != NULL, NULL);
g_return_val_if_fail(prop_name != NULL, NULL);
if (!self->notif)
{
PyErr_SetString(PyExc_RuntimeError,
"Notification instance not initialized properly");
return NULL;
}
if (g_str_equal(prop_name, "nmhdr"))
{
Py_INCREF(self->hdr);
return (PyObject *) self->hdr;
}
else if (g_str_equal(prop_name, "position"))
return PyInt_FromLong((glong) self->notif->position);
else if (g_str_equal(prop_name, "ch"))
return Py_BuildValue("c", self->notif->ch);
else if (g_str_equal(prop_name, "modifiers"))
return PyInt_FromLong((glong) self->notif->modifiers);
else if (g_str_equal(prop_name, "modification_type"))
return PyInt_FromLong((glong) self->notif->modificationType);
else if (g_str_equal(prop_name, "text"))
return PyString_FromString(self->notif->text);
else if (g_str_equal(prop_name, "length"))
return PyInt_FromLong((glong) self->notif->length);
else if (g_str_equal(prop_name, "lines_added"))
return PyInt_FromLong((glong) self->notif->linesAdded);
else if (g_str_equal(prop_name, "message"))
return PyInt_FromLong((glong) self->notif->message);
else if (g_str_equal(prop_name, "w_param"))
return PyLong_FromLong(self->notif->wParam);
else if (g_str_equal(prop_name, "l_param"))
return PyLong_FromLong(self->notif->lParam);
else if (g_str_equal(prop_name, "line"))
return PyInt_FromLong((glong) self->notif->line);
else if (g_str_equal(prop_name, "fold_level_now"))
return PyInt_FromLong((glong) self->notif->foldLevelNow);
else if (g_str_equal(prop_name, "fold_level_prev"))
return PyInt_FromLong((glong) self->notif->foldLevelPrev);
else if (g_str_equal(prop_name, "margin"))
return PyInt_FromLong((glong) self->notif->margin);
else if (g_str_equal(prop_name, "list_type"))
return PyInt_FromLong((glong) self->notif->listType);
else if (g_str_equal(prop_name, "x"))
return PyInt_FromLong((glong) self->notif->x);
else if (g_str_equal(prop_name, "y"))
return PyInt_FromLong((glong) self->notif->y);
else if (g_str_equal(prop_name, "token"))
return PyInt_FromLong((glong) self->notif->token);
else if (g_str_equal(prop_name, "annotation_lines_added"))
return PyInt_FromLong((glong) self->notif->annotationLinesAdded);
else if (g_str_equal(prop_name, "updated"))
return PyInt_FromLong((glong) self->notif->updated);
Py_RETURN_NONE;
}
/**
* This is the callback passed to the FSEvents API, which calls
* the Python callback function, in turn, by passing in event data
* as Python objects.
*
* :param stream_ref:
* A pointer to an ``FSEventStream`` instance.
* :param stream_callback_info_ref:
* Callback context information passed by the FSEvents API.
* This contains a reference to the Python callback that this
* function calls in turn with information about the events.
* :param num_events:
* An unsigned integer representing the number of events
* captured by the FSEvents API.
* :param event_paths:
* An array of NUL-terminated C strings representing event paths.
* :param event_flags:
* An array of ``FSEventStreamEventFlags`` unsigned integral
* mask values.
* :param event_ids:
* An array of 64-bit unsigned integers representing event
* identifiers.
*/
static void
watchdog_FSEventStreamCallback(ConstFSEventStreamRef stream_ref,
StreamCallbackInfo *stream_callback_info_ref,
size_t num_events,
const char *event_paths[],
const FSEventStreamEventFlags event_flags[],
const FSEventStreamEventId event_ids[])
{
UNUSED(stream_ref);
UNUSED(event_ids);
size_t i = 0;
PyObject *callback_result = NULL;
PyObject *path = NULL;
PyObject *flags = NULL;
PyObject *py_event_flags = NULL;
PyObject *py_event_paths = NULL;
PyThreadState *saved_thread_state = NULL;
/* Acquire interpreter lock and save original thread state. */
PyGILState_STATE gil_state = PyGILState_Ensure();
saved_thread_state = PyThreadState_Swap(stream_callback_info_ref->thread_state);
/* Convert event flags and paths to Python ints and strings. */
py_event_paths = PyList_New(num_events);
py_event_flags = PyList_New(num_events);
if (G_NOT(py_event_paths && py_event_flags))
{
Py_DECREF(py_event_paths);
Py_DECREF(py_event_flags);
return /*NULL*/;
}
for (i = 0; i < num_events; ++i)
{
#if PY_MAJOR_VERSION >= 3
path = PyUnicode_FromString(event_paths[i]);
flags = PyLong_FromLong(event_flags[i]);
#else
path = PyString_FromString(event_paths[i]);
flags = PyInt_FromLong(event_flags[i]);
#endif
if (G_NOT(path && flags))
{
Py_DECREF(py_event_paths);
Py_DECREF(py_event_flags);
return /*NULL*/;
}
PyList_SET_ITEM(py_event_paths, i, path);
PyList_SET_ITEM(py_event_flags, i, flags);
}
/* Call the Python callback function supplied by the stream information
* struct. The Python callback function should accept two arguments,
* both being Python lists:
*
* def python_callback(event_paths, event_flags):
* pass
*/
callback_result = \
PyObject_CallFunction(stream_callback_info_ref->python_callback,
"OO", py_event_paths, py_event_flags);
if (G_IS_NULL(callback_result))
{
if (G_NOT(PyErr_Occurred()))
{
PyErr_SetString(PyExc_ValueError, ERROR_CANNOT_CALL_CALLBACK);
}
CFRunLoopStop(stream_callback_info_ref->run_loop_ref);
}
/* Release the lock and restore thread state. */
PyThreadState_Swap(saved_thread_state);
PyGILState_Release(gil_state);
}
static PyObject *
Context_getTimeout (Context *self, void *closure)
{
int timeout = smbc_getTimeout (self->context);
return PyLong_FromLong (timeout);
}
PyObject *SCA_JoystickSensor::pyattr_get_num_buttons(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
SCA_JoystickSensor* self = static_cast<SCA_JoystickSensor*>(self_v);
DEV_Joystick *joy = ((SCA_JoystickManager *)self->m_eventmgr)->GetJoystickDevice(self->m_joyindex);
return PyLong_FromLong( joy ? JOYBUT_MAX : 0 );
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultTextNoteNode, getSubType)
{
return PyLong_FromLong(self->fThis->Note_GetSubType());
}
PyMODINIT_FUNC init_rtmidi(void)
#endif
{
PyEval_InitThreads();
PyObject* module;
if (PyType_Ready(getMidiMessageType()) < 0)
#if PK_PYTHON3
return 0;
#else
return;
#endif
if (PyType_Ready(&MidiIn_type) < 0)
#if PK_PYTHON3
return 0;
#else
return;
#endif
if (PyType_Ready(&MidiOut_type) < 0)
#if PK_PYTHON3
return 0;
#else
return;
#endif
#if PK_PYTHON3
module = PyModule_Create(&moduledef);
#else
module = Py_InitModule3("rtmidi._rtmidi", midi_methods, "RtMidi wrapper");
#endif
Py_INCREF((PyObject*) getMidiMessageType());
PyModule_AddObject(module, "MidiMessage", (PyObject*) getMidiMessageType());
Py_INCREF(&MidiIn_type);
PyModule_AddObject(module, "RtMidiIn", (PyObject *)&MidiIn_type);
Py_INCREF(&MidiOut_type);
PyModule_AddObject(module, "RtMidiOut", (PyObject *)&MidiOut_type);
PyObject *inDict = MidiIn_type.tp_dict;
PyObject *outDict = MidiOut_type.tp_dict;
PyDict_SetItemString(inDict, "UNSPECIFIED", PyLong_FromLong(RtMidi::UNSPECIFIED));
PyDict_SetItemString(outDict, "UNSPECIFIED", PyLong_FromLong(RtMidi::UNSPECIFIED));
PyDict_SetItemString(inDict, "MACOSX_CORE", PyLong_FromLong(RtMidi::MACOSX_CORE));
PyDict_SetItemString(outDict, "MACOSX_CORE", PyLong_FromLong(RtMidi::MACOSX_CORE));
PyDict_SetItemString(inDict, "LINUX_ALSA", PyLong_FromLong(RtMidi::LINUX_ALSA));
PyDict_SetItemString(outDict, "LINUX_ALSA", PyLong_FromLong(RtMidi::LINUX_ALSA));
PyDict_SetItemString(inDict, "UNIX_JACK", PyLong_FromLong(RtMidi::UNIX_JACK));
PyDict_SetItemString(outDict, "UNIX_JACK", PyLong_FromLong(RtMidi::UNIX_JACK));
PyDict_SetItemString(inDict, "WINDOWS_MM", PyLong_FromLong(RtMidi::WINDOWS_MM));
PyDict_SetItemString(outDict, "WINDOWS_MM", PyLong_FromLong(RtMidi::WINDOWS_MM));
PyDict_SetItemString(inDict, "RTMIDI_DUMMY", PyLong_FromLong(RtMidi::RTMIDI_DUMMY));
PyDict_SetItemString(outDict, "RTMIDI_DUMMY", PyLong_FromLong(RtMidi::RTMIDI_DUMMY));
char eName[32];
#if PK_WINDOWS
strcpy_s(eName, "rtmidi.Error");
#else
strcpy(eName, "rtmidi.Error");
#endif
rtmidi_Error = PyErr_NewException(eName, NULL, NULL);
Py_INCREF(rtmidi_Error);
PyModule_AddObject(module, "Error", rtmidi_Error);
#if PK_PYTHON3
return module;
#endif
}
PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlMultiLineEdit, getScrollPosition)
{
return PyLong_FromLong(self->fThis->GetScrollPosition());
}
static PyObject *uwsgi_Input_tell(uwsgi_Input *self, PyObject *args) {
return PyLong_FromLong(self->wsgi_req->post_pos);
}
void *
weechat_python_exec (struct t_plugin_script *script,
int ret_type, const char *function,
char *format, void **argv)
{
struct t_plugin_script *old_python_current_script;
PyThreadState *old_interpreter;
PyObject *evMain, *evDict, *evFunc, *rc;
void *argv2[16], *ret_value;
int i, argc, *ret_int;
/* PyEval_AcquireLock (); */
old_python_current_script = python_current_script;
old_interpreter = NULL;
if (script->interpreter)
{
old_interpreter = PyThreadState_Swap (NULL);
PyThreadState_Swap (script->interpreter);
}
evMain = PyImport_AddModule ((char *) "__main__");
evDict = PyModule_GetDict (evMain);
evFunc = PyDict_GetItemString (evDict, function);
if ( !(evFunc && PyCallable_Check (evFunc)) )
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to run function \"%s\""),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME, function);
/* PyEval_ReleaseThread (python_current_script->interpreter); */
if (old_interpreter)
PyThreadState_Swap (old_interpreter);
return NULL;
}
python_current_script = script;
if (argv && argv[0])
{
argc = strlen (format);
for (i = 0; i < 16; i++)
{
argv2[i] = (i < argc) ? argv[i] : NULL;
}
rc = PyObject_CallFunction (evFunc, format,
argv2[0], argv2[1],
argv2[2], argv2[3],
argv2[4], argv2[5],
argv2[6], argv2[7],
argv2[8], argv2[9],
argv2[10], argv2[11],
argv2[12], argv2[13],
argv2[14], argv2[15]);
}
else
{
rc = PyObject_CallFunction (evFunc, NULL);
}
ret_value = NULL;
/*
* ugly hack : rc = NULL while 'return weechat.WEECHAT_RC_OK ....
* because of '#define WEECHAT_RC_OK 0'
*/
if (rc == NULL)
rc = PyLong_FromLong ((long)0);
if (PyErr_Occurred())
{
PyErr_Print ();
Py_XDECREF(rc);
}
else if ((ret_type == WEECHAT_SCRIPT_EXEC_STRING) && (PyUnicode_Check (rc)))
{
ret_value = weechat_python_unicode_to_string (rc);
Py_XDECREF(rc);
}
else if ((ret_type == WEECHAT_SCRIPT_EXEC_STRING) && (PyBytes_Check (rc)))
{
if (PyBytes_AsString (rc))
ret_value = strdup (PyBytes_AsString (rc));
else
ret_value = NULL;
Py_XDECREF(rc);
}
else if ((ret_type == WEECHAT_SCRIPT_EXEC_INT) && (PY_INTEGER_CHECK(rc)))
{
ret_int = malloc (sizeof (*ret_int));
if (ret_int)
*ret_int = (int) PyLong_AsLong (rc);
ret_value = ret_int;
Py_XDECREF(rc);
}
else if (ret_type == WEECHAT_SCRIPT_EXEC_HASHTABLE)
{
ret_value = weechat_python_dict_to_hashtable (rc,
WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_STRING);
Py_XDECREF(rc);
}
else
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"%s\" must return "
"a valid value"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME, function);
}
if (!ret_value)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: error in function \"%s\""),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME, function);
}
/* PyEval_ReleaseThread (python_current_script->interpreter); */
python_current_script = old_python_current_script;
if (old_interpreter)
PyThreadState_Swap (old_interpreter);
return ret_value;
}
static PyObject* IORequest_submitted_get(IORequest *self, void *closure) {
return PyLong_FromLong(self->submitted);
}
