Exemplo n.º 1
0
static PyObject *
nsmallest(PyObject *self, PyObject *args)
{
    PyObject *heap=NULL, *elem, *iterable, *los, *it, *oldelem;
    Py_ssize_t i, n;
    int cmp;

    if (!PyArg_ParseTuple(args, "nO:nsmallest", &n, &iterable))
        return NULL;

    it = PyObject_GetIter(iterable);
    if (it == NULL)
        return NULL;

    heap = PyList_New(0);
    if (heap == NULL)
        goto fail;

    for (i=0 ; i<n ; i++ ){
        elem = PyIter_Next(it);
        if (elem == NULL) {
            if (PyErr_Occurred())
                goto fail;
            else
                goto sortit;
        }
        if (PyList_Append(heap, elem) == -1) {
            Py_DECREF(elem);
            goto fail;
        }
        Py_DECREF(elem);
    }
    n = PyList_GET_SIZE(heap);
    if (n == 0)
        goto sortit;

    for (i=n/2-1 ; i>=0 ; i--)
        if(_siftupmax((PyListObject *)heap, i) == -1)
            goto fail;

    los = PyList_GET_ITEM(heap, 0);
    while (1) {
        elem = PyIter_Next(it);
        if (elem == NULL) {
            if (PyErr_Occurred())
                goto fail;
            else
                goto sortit;
        }
        cmp = PyObject_RichCompareBool(elem, los, Py_LT);
        if (cmp == -1) {
            Py_DECREF(elem);
            goto fail;
        }
        if (cmp == 0) {
            Py_DECREF(elem);
            continue;
        }

        oldelem = PyList_GET_ITEM(heap, 0);
        PyList_SET_ITEM(heap, 0, elem);
        Py_DECREF(oldelem);
        if (_siftupmax((PyListObject *)heap, 0) == -1)
            goto fail;
        los = PyList_GET_ITEM(heap, 0);
    }

sortit:
    if (PyList_Sort(heap) == -1)
        goto fail;
    Py_DECREF(it);
    return heap;

fail:
    Py_DECREF(it);
    Py_XDECREF(heap);
    return NULL;
}
Exemplo n.º 2
0
static PyObject *
functools_reduce(PyObject *self, PyObject *args)
{
    PyObject *seq, *func, *result = NULL, *it;

    if (!PyArg_UnpackTuple(args, "reduce", 2, 3, &func, &seq, &result))
        return NULL;
    if (result != NULL)
        Py_INCREF(result);

    it = PyObject_GetIter(seq);
    if (it == NULL) {
        if (PyErr_ExceptionMatches(PyExc_TypeError))
            PyErr_SetString(PyExc_TypeError,
                            "reduce() arg 2 must support iteration");
        Py_XDECREF(result);
        return NULL;
    }

    if ((args = PyTuple_New(2)) == NULL)
        goto Fail;

    for (;;) {
        PyObject *op2;

        if (args->ob_refcnt > 1) {
            Py_DECREF(args);
            if ((args = PyTuple_New(2)) == NULL)
                goto Fail;
        }

        op2 = PyIter_Next(it);
        if (op2 == NULL) {
            if (PyErr_Occurred())
                goto Fail;
            break;
        }

        if (result == NULL)
            result = op2;
        else {
            PyTuple_SetItem(args, 0, result);
            PyTuple_SetItem(args, 1, op2);
            if ((result = PyEval_CallObject(func, args)) == NULL)
                goto Fail;
        }
    }

    Py_DECREF(args);

    if (result == NULL)
        PyErr_SetString(PyExc_TypeError,
                        "reduce() of empty sequence with no initial value");

    Py_DECREF(it);
    return result;

Fail:
    Py_XDECREF(args);
    Py_XDECREF(result);
    Py_DECREF(it);
    return NULL;
}
static int convertTo_QSet_0101QAbstractState(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QSet<QAbstractState *> **sipCppPtr = reinterpret_cast<QSet<QAbstractState *> **>(sipCppPtrV);

#line 456 "/home/tsheasha/GUC/Bachelors/android-python27/python-build/PyQt-x11-gpl-4.8/sip/QtCore/qset.sip"
    PyObject *it = PyObject_GetIter(sipPy), *itm;

    // Check the type if that is all that is required.
    if (sipIsErr == NULL)
    {
        if (it == NULL)
            return 0;

        while ((itm = PyIter_Next(it)) != NULL)
        {
            int ok = sipCanConvertToType(itm, sipType_QAbstractState, 0);

            Py_DECREF(itm);

            if (!ok)
            {
                Py_DECREF(it);
                return 0;
            }
        }

        Py_DECREF(it);
        return 1;
    }

    if (it == NULL)
    {
        *sipIsErr = 1;
        return 0;
    }

    QSet<QAbstractState *> *qs = new QSet<QAbstractState *>;

    while ((itm = PyIter_Next(it)) != NULL)
    {
        QAbstractState *t = reinterpret_cast<QAbstractState *>(sipConvertToType(itm, sipType_QAbstractState, sipTransferObj, 0, 0, sipIsErr));

        Py_DECREF(itm);

        if (*sipIsErr)
        {
            delete qs;
            Py_DECREF(it);
            return 0;
        }

        qs->insert(t);
    }

    Py_DECREF(it);

    *sipCppPtr = qs;

    return sipGetState(sipTransferObj);
#line 138 "sipQtCoreQSet0101QAbstractState.cpp"
}
Exemplo n.º 4
0
            PyObject* initialize(PyObject* self, PyObject *originalTimeSeries, PyObject *calculatedTimesSeries)
            {
                if (0 < PySequence_Size(PyObject_GetAttrString(self, "_errorValues"))) {
                    PyErr_SetString(PyExc_StandardError, "An ErrorMeasure can only be initialized once.");
                    return NULL;
                }

                PyObject_CallMethodObjArgs(originalTimeSeries,    PyString_FromString("sort_timeseries"), NULL);
                PyObject_CallMethodObjArgs(calculatedTimesSeries, PyString_FromString("sort_timeseries"), NULL);

                int index = 0;
                PyObject* orgPair;
                PyObject* calcPair;
                PyObject* local_error;

                PyObject* _errorValues = PyList_New(PyObject_Length(originalTimeSeries));
                PyObject* _errorDates = PyList_New(PyObject_Length(originalTimeSeries));
                PyObject* iterator1 = PyObject_GetIter(originalTimeSeries);

                while ((orgPair = PyIter_Next(iterator1))) {

                    PyObject* iterator2 = PyObject_GetIter(calculatedTimesSeries);

                    while ((calcPair = PyIter_Next(iterator2))) {
                        if (PyFloat_AsDouble(PySequence_GetItem(orgPair, 0)) != PyFloat_AsDouble(PySequence_GetItem(calcPair, 0)))
                            continue;

                        local_error = PyObject_CallMethodObjArgs(self, PyString_FromString("local_error"),
                                                                       PyList_GetSlice(orgPair, 1, PyList_Size(orgPair)),
                                                                       PyList_GetSlice(calcPair, 1, PyList_Size(calcPair)),
                                                                       NULL
                                                                );

                        //NotImplemented Exception
                        if(!local_error || PyErr_Occurred()) {
                            PyErr_SetString(PyExc_NotImplementedError, "");
                            return NULL;
                        }

                        PyList_SetItem(_errorValues, index, local_error);
                        PyList_SetItem(_errorDates, index, PySequence_GetItem(orgPair, 0));
                        ++index;

                        Py_DECREF(calcPair);
                    }

                    Py_DECREF(iterator2);
                    Py_DECREF(orgPair);
                }

                Py_DECREF(iterator1);

                //Cut off trailing zeroes
                _errorValues = PyList_GetSlice(_errorValues, 0, index);
                _errorDates = PyList_GetSlice(_errorDates, 0, index);

                //return False, if the error cannot be calculated
                double _minimalErrorCalculationPercentage = PyFloat_AsDouble(PyObject_GetAttrString(self, "_minimalErrorCalculationPercentage"));

                if(PyList_Size(_errorValues) < (_minimalErrorCalculationPercentage * (float)PyObject_Length(originalTimeSeries)))
                    Py_RETURN_FALSE;

                PyObject_SetAttrString(self, "_errorValues", _errorValues);
                PyObject_SetAttrString(self, "_errorDates", _errorDates);
                Py_RETURN_TRUE;
            }
static int convertTo_QList_0100QLowEnergyDescriptor(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QList<QLowEnergyDescriptor> **sipCppPtr = reinterpret_cast<QList<QLowEnergyDescriptor> **>(sipCppPtrV);

#line 66 "sip/QtCore/qpycore_qlist.sip"
    PyObject *iter = PyObject_GetIter(sipPy);

    if (!sipIsErr)
    {
        Py_XDECREF(iter);

        return (iter
#if PY_MAJOR_VERSION < 3
                && !PyString_Check(sipPy)
#endif
                && !PyUnicode_Check(sipPy));
    }

    if (!iter)
    {
        *sipIsErr = 1;

        return 0;
    }

    QList<QLowEnergyDescriptor> *ql = new QList<QLowEnergyDescriptor>;
 
    for (SIP_SSIZE_T i = 0; ; ++i)
    {
        PyErr_Clear();
        PyObject *itm = PyIter_Next(iter);

        if (!itm)
        {
            if (PyErr_Occurred())
            {
                delete ql;
                Py_DECREF(iter);
                *sipIsErr = 1;

                return 0;
            }

            break;
        }

        int state;
        QLowEnergyDescriptor *t = reinterpret_cast<QLowEnergyDescriptor *>(
                sipForceConvertToType(itm, sipType_QLowEnergyDescriptor, sipTransferObj,
                        SIP_NOT_NONE, &state, sipIsErr));

        if (*sipIsErr)
        {
            PyErr_Format(PyExc_TypeError,
                    "index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QLowEnergyDescriptor' is expected",
                    i, Py_TYPE(itm)->tp_name);

            Py_DECREF(itm);
            delete ql;
            Py_DECREF(iter);

            return 0;
        }

        ql->append(*t);

        sipReleaseType(t, sipType_QLowEnergyDescriptor, state);
        Py_DECREF(itm);
    }
 
    Py_DECREF(iter);

    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 142 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtBluetooth/sipQtBluetoothQList0100QLowEnergyDescriptor.cpp"
}
Exemplo n.º 6
0
/* function subhandler */
Datum
PLy_exec_function(FunctionCallInfo fcinfo, PLyProcedure *proc)
{
	Datum		rv;
	PyObject   *volatile plargs = NULL;
	PyObject   *volatile plrv = NULL;
	ErrorContextCallback plerrcontext;

	PG_TRY();
	{
		if (!proc->is_setof || proc->setof == NULL)
		{
			/*
			 * Simple type returning function or first time for SETOF
			 * function: actually execute the function.
			 */
			plargs = PLy_function_build_args(fcinfo, proc);
			plrv = PLy_procedure_call(proc, "args", plargs);
			if (!proc->is_setof)
			{
				/*
				 * SETOF function parameters will be deleted when last row is
				 * returned
				 */
				PLy_function_delete_args(proc);
			}
			Assert(plrv != NULL);
		}

		/*
		 * If it returns a set, call the iterator to get the next return item.
		 * We stay in the SPI context while doing this, because PyIter_Next()
		 * calls back into Python code which might contain SPI calls.
		 */
		if (proc->is_setof)
		{
			bool		has_error = false;
			ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;

			if (proc->setof == NULL)
			{
				/* first time -- do checks and setup */
				if (!rsi || !IsA(rsi, ReturnSetInfo) ||
					(rsi->allowedModes & SFRM_ValuePerCall) == 0)
				{
					ereport(ERROR,
							(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
							 errmsg("unsupported set function return mode"),
							 errdetail("PL/Python set-returning functions only support returning only value per call.")));
				}
				rsi->returnMode = SFRM_ValuePerCall;

				/* Make iterator out of returned object */
				proc->setof = PyObject_GetIter(plrv);
				Py_DECREF(plrv);
				plrv = NULL;

				if (proc->setof == NULL)
					ereport(ERROR,
							(errcode(ERRCODE_DATATYPE_MISMATCH),
							 errmsg("returned object cannot be iterated"),
							 errdetail("PL/Python set-returning functions must return an iterable object.")));
			}

			/* Fetch next from iterator */
			plrv = PyIter_Next(proc->setof);
			if (plrv)
				rsi->isDone = ExprMultipleResult;
			else
			{
				rsi->isDone = ExprEndResult;
				has_error = PyErr_Occurred() != NULL;
			}

			if (rsi->isDone == ExprEndResult)
			{
				/* Iterator is exhausted or error happened */
				Py_DECREF(proc->setof);
				proc->setof = NULL;

				Py_XDECREF(plargs);
				Py_XDECREF(plrv);

				PLy_function_delete_args(proc);

				if (has_error)
					PLy_elog(ERROR, "error fetching next item from iterator");

				/* Disconnect from the SPI manager before returning */
				if (SPI_finish() != SPI_OK_FINISH)
					elog(ERROR, "SPI_finish failed");

				fcinfo->isnull = true;
				return (Datum) NULL;
			}
		}

		/*
		 * Disconnect from SPI manager and then create the return values datum
		 * (if the input function does a palloc for it this must not be
		 * allocated in the SPI memory context because SPI_finish would free
		 * it).
		 */
		if (SPI_finish() != SPI_OK_FINISH)
			elog(ERROR, "SPI_finish failed");

		plerrcontext.callback = plpython_return_error_callback;
		plerrcontext.previous = error_context_stack;
		error_context_stack = &plerrcontext;

		/*
		 * If the function is declared to return void, the Python return value
		 * must be None. For void-returning functions, we also treat a None
		 * return value as a special "void datum" rather than NULL (as is the
		 * case for non-void-returning functions).
		 */
		if (proc->result.out.d.typoid == VOIDOID)
		{
			if (plrv != Py_None)
				ereport(ERROR,
						(errcode(ERRCODE_DATATYPE_MISMATCH),
						 errmsg("PL/Python function with return type \"void\" did not return None")));

			fcinfo->isnull = false;
			rv = (Datum) 0;
		}
		else if (plrv == Py_None)
		{
			fcinfo->isnull = true;
			if (proc->result.is_rowtype < 1)
				rv = InputFunctionCall(&proc->result.out.d.typfunc,
									   NULL,
									   proc->result.out.d.typioparam,
									   -1);
			else
				/* Tuple as None */
				rv = (Datum) NULL;
		}
		else if (proc->result.is_rowtype >= 1)
		{
			TupleDesc	desc;

			/* make sure it's not an unnamed record */
			Assert((proc->result.out.d.typoid == RECORDOID &&
					proc->result.out.d.typmod != -1) ||
				   (proc->result.out.d.typoid != RECORDOID &&
					proc->result.out.d.typmod == -1));

			desc = lookup_rowtype_tupdesc(proc->result.out.d.typoid,
										  proc->result.out.d.typmod);

			rv = PLyObject_ToCompositeDatum(&proc->result, desc, plrv);
			fcinfo->isnull = (rv == (Datum) NULL);
		}
		else
		{
			fcinfo->isnull = false;
			rv = (proc->result.out.d.func) (&proc->result.out.d, -1, plrv);
		}
	}
	PG_CATCH();
	{
		Py_XDECREF(plargs);
		Py_XDECREF(plrv);

		/*
		 * If there was an error the iterator might have not been exhausted
		 * yet. Set it to NULL so the next invocation of the function will
		 * start the iteration again.
		 */
		Py_XDECREF(proc->setof);
		proc->setof = NULL;

		PG_RE_THROW();
	}
	PG_END_TRY();

	error_context_stack = plerrcontext.previous;

	Py_XDECREF(plargs);
	Py_DECREF(plrv);

	return rv;
}
Exemplo n.º 7
0
static PyObject *
namespace_repr(_PyNamespaceObject *ns)
{
    int i, loop_error = 0;
    PyObject *pairs = NULL, *d = NULL, *keys = NULL, *keys_iter = NULL;
    PyObject *key;
    PyObject *separator, *pairsrepr, *repr = NULL;

    i = Py_ReprEnter((PyObject *)ns);
    if (i != 0) {
        return i > 0 ? PyUnicode_FromString("namespace(...)") : NULL;
    }

    pairs = PyList_New(0);
    if (pairs == NULL)
        goto error;

    d = ((_PyNamespaceObject *)ns)->ns_dict;
    assert(d != NULL);
    Py_INCREF(d);

    keys = PyDict_Keys(d);
    if (keys == NULL)
        goto error;
    if (PyList_Sort(keys) != 0)
        goto error;

    keys_iter = PyObject_GetIter(keys);
    if (keys_iter == NULL)
        goto error;

    while ((key = PyIter_Next(keys_iter)) != NULL) {
        if (PyUnicode_Check(key) && PyUnicode_GET_SIZE(key) > 0) {
            PyObject *value, *item;

            value = PyDict_GetItem(d, key);
            assert(value != NULL);

            item = PyUnicode_FromFormat("%S=%R", key, value);
            if (item == NULL) {
                loop_error = 1;
            }
            else {
                loop_error = PyList_Append(pairs, item);
                Py_DECREF(item);
            }
        }

        Py_DECREF(key);
        if (loop_error)
            goto error;
    }

    separator = PyUnicode_FromString(", ");
    if (separator == NULL)
        goto error;

    pairsrepr = PyUnicode_Join(separator, pairs);
    Py_DECREF(separator);
    if (pairsrepr == NULL)
        goto error;

    repr = PyUnicode_FromFormat("%s(%S)",
                                ((PyObject *)ns)->ob_type->tp_name, pairsrepr);
    Py_DECREF(pairsrepr);

error:
    Py_XDECREF(pairs);
    Py_XDECREF(d);
    Py_XDECREF(keys);
    Py_XDECREF(keys_iter);
    Py_ReprLeave((PyObject *)ns);

    return repr;
}
Exemplo n.º 8
0
PyObject *Client_gets_multi(PyClient *self, PyObject *okeys)
{
  //[ ] def gets_multi(self, keys):

  char *pKey;
  size_t cbKey;
  char *pData;
  size_t cbData;
  UINT64 cas;
  int flags;

  self->client->getBegin();

  PyObject *iterator = PyObject_GetIter(okeys);

  if (iterator == NULL)
  {
    return NULL;
  }

  PyObject *arg;

  while ( (arg = PyIter_Next(iterator)))
  {
    PyObject *ostr;

    if (PyString_Check(arg))
    {
      ostr = arg;
    }
    else
    {
      ostr = PyObject_Str(arg);
    }

    self->client->getKeyWrite(PyString_AS_STRING(ostr), PyString_GET_SIZE(ostr));
    if (ostr != arg)
    {
      Py_DECREF(ostr);
    }

    Py_DECREF(arg);
  }

  Py_DECREF(iterator);
  self->client->getFlush();

  PyObject *odict = PyDict_New();

  bool bError = false;

  while (self->client->getReadNext(&pKey, &cbKey, &pData, &cbData, &flags, &cas, &bError))
  {
    PyObject *okey  = PyString_FromStringAndSize(pKey, cbKey);
    PyObject *otuple = PyTuple_New(3);
    PyObject *ovalue = PyString_FromStringAndSize(pData, cbData);
    PyObject *oflags = PyInt_FromLong(flags);
    PyObject *ocas = PyLong_FromUnsignedLongLong(cas);

    PyTuple_SET_ITEM(otuple, 0, ovalue);
    PyTuple_SET_ITEM(otuple, 1, oflags);
    PyTuple_SET_ITEM(otuple, 2, ocas);
    PyDict_SetItem (odict, okey, otuple);

    Py_DECREF(otuple);
    Py_DECREF(okey);
  }

  if (bError)
  {
    Py_DECREF(odict);

    if (!PyErr_Occurred())
    {
      return PyErr_Format(PyExc_RuntimeError, "umemcache: %s", self->client->getError());
    }

    return NULL;
  }

  return odict;
}
Exemplo n.º 9
0
Arquivo: lists.c Projeto: rhn/snakeoil
static PyObject *
snakeoil_iflatten_instance_iternext(snakeoil_iflatten_instance *self) {
	PyObject *tail, *result, *iter;
	int n, res;

	if (self->in_iternext) {
		/* We do not allow this because it means our list could be
		 * manipulated while we are running. Exception raised matches
		 * what a generator raises if you try the same thing.
		 */
		PyErr_SetString(
			PyExc_ValueError,
			"Recursive calls to iflatten_instance.next are illegal");
		return NULL;
	}
	self->in_iternext = 1;

	/* Look at the final iterator on our stack: */
	while (n = PyList_GET_SIZE(self->iterables)) {
		tail = PyList_GET_ITEM(self->iterables, n - 1);

		/* See if it has any results left: */
		/* (This reference is borrowed from the list, but since we
		   disallow recursive calls in here it should be safe to not
		   increment it). */

		result = PyIter_Next(tail);
		if (result) {
			/* See if we need to iterate over this new result: */

			res = PyObject_IsInstance(result, self->skip_flattening);
			if (res == -1) {
				Py_DECREF(result);
				result = NULL;
			} else if (!res) {

				/* If it is an iterator add it to our chain, else return it. */
				iter = PyObject_GetIter(result);
				if (!iter) {
					/* If we get here PyObject_GetIter raised an exception.
					 * If it was TypeError we have a non-iterator we can
					 * just return, else we propagate the error.
					 */
					if (PyErr_ExceptionMatches(PyExc_TypeError)) {
						PyErr_Clear();
					} else {
						Py_DECREF(result);
						result = NULL;
					}
				}
				if (PyString_Check(result)) {
					/* Block infinite recursion of single char strings */
					Py_ssize_t len = PyObject_Length(result);
					if (-1 == len) {
						Py_DECREF(result);
						Py_DECREF(iter);
						return NULL;
					}
					if (len <= 1) {
						Py_CLEAR(iter);
					}
				}

				if (iter) {
					/* Iterable, append to our stack and continue.
					 * */
					Py_DECREF(result);
					result = NULL;
					res = PyList_Append(self->iterables, iter);
					Py_DECREF(iter);
					if (res != -1) {
						continue;
					}
					/* Fall through and propagate the error. */
				}
			}
		} else {
			/* PyIter_Next did not return an item. If this was not
			 * because of an error we should pop the exhausted
			 * iterable off and continue. */
			if (!PyErr_Occurred() &&
				PySequence_DelItem(self->iterables, n - 1) != -1) {
				continue;
			}
		}
		self->in_iternext = 0;
		return result;
	}

	/* We ran out of iterables entirely, so we are done */
	self->in_iternext = 0;
	return NULL;
}
Exemplo n.º 10
0
Arquivo: lists.c Projeto: rhn/snakeoil
static PyObject *
snakeoil_iflatten_func_new(PyTypeObject *type,
							  PyObject *args, PyObject *kwargs)
{
	snakeoil_iflatten_func *self;
	PyObject *l=NULL, *skip_func=NULL, *tmp;
	int res;

	if (kwargs && PyDict_Size(kwargs)) {
		PyErr_SetString(PyExc_TypeError,
						"iflatten_func takes no keyword arguments");
		return NULL;
	}
	if (!PyArg_UnpackTuple(args, "iflatten_func", 2, 2, &l, &skip_func)) {
		return NULL;
	}

	/* Check if we got a single argument that should be skipped. */
	tmp = PyObject_CallFunctionObjArgs(skip_func, l, NULL);
	if (!tmp) {
		return NULL;
	}
	// Py_(True|False) are singletons, thus we're trying to bypass
	// the PyObject_IsTrue triggering __nonzero__ protocol.
	if (tmp == Py_True) {
		res = 1;
	} else if (tmp == Py_False) {
		res = 0;
	} else {
		res = PyObject_IsTrue(tmp);
		if (res == -1) {
			Py_DECREF(tmp);
			return NULL;
		}
	}
	Py_DECREF(tmp);
	if (res) {
		PyObject *tuple = PyTuple_Pack(1, l);
		if (!tuple) {
			return NULL;
		}
		PyObject *iter = PyObject_GetIter(tuple);
		Py_DECREF(tuple);
		return iter;
	}

	self = (snakeoil_iflatten_func *)type->tp_alloc(type, 0);
	if (!self)
		return NULL;

	self->in_iternext = 0;

	if (!(self->iterables = build_initial_iterables(l))) {
		Py_DECREF(self);
		return NULL;
	}

	Py_INCREF(skip_func);
	self->skip_func = skip_func;

	return (PyObject *)self;
}
Exemplo n.º 11
0
static PyObject* Cache_loadstore(Cache* self, PyObject *args, PyObject *kwds)
{
    PyObject *addrs;
    unsigned int length = 1;
    int write_allocate = 1; 
    
    static char *kwlist[] = {"addrs", "length", "write_allocate", NULL};
    PyArg_ParseTupleAndKeywords(args, kwds, "O|Ii", kwlist, &addrs, &length, &write_allocate);
    
    // Get and check iterator
    PyObject *addrs_iter = PyObject_GetIter(addrs);
    if(addrs_iter == NULL) {
        PyErr_SetString(PyExc_ValueError, "addrs is not iteratable");
        return NULL;
    }
    
    // Iterate of elements in addrs
    PyObject *loadstore_item, *load_addrs, *store_addrs, *addr, *load_iter, *store_iter;
    while((loadstore_item = PyIter_Next(addrs_iter))) {
        if(!PySequence_Check(loadstore_item)) {
            PyErr_SetString(PyExc_ValueError, "addrs element does not provide a sequence protocol");
            return NULL;
        }
        // PySys_WriteStdout("LENGTH=%i\n", PySequence_Length(loadstore_item));
        if(PySequence_Length(loadstore_item) != 2){
            PyErr_SetString(PyExc_ValueError, "each addrs element needs exactly two elements");
            return NULL;
        }
        load_addrs = PySequence_GetItem(loadstore_item, 0);
        store_addrs = PySequence_GetItem(loadstore_item, 1);
        
        // Unless None (otherwise ignore loads)
        if(load_addrs != Py_None) {
            if(!PySequence_Check(load_addrs)) {
                PyErr_SetString(
                    PyExc_ValueError, "load element does not provide a sequence protocol");
                return NULL;
            }

            // FIXME maybe this is better: Pass along to iterstore
            //Cache_iterstore(self, store_addrs, length)
            
            // Iterate of elements in load_addrs
            load_iter = PyObject_GetIter(load_addrs);
            if(load_iter == NULL) {
                PyErr_SetString(PyExc_ValueError, "load address is not iteratable");
                return NULL;
            }
            while((addr = PyIter_Next(load_iter))) {
                // Each address is expanded to a certain length (default is 1)
                for(int i=0; i<length; i++) {
#if PY_MAJOR_VERSION >= 3
                    Cache__load(self, PyLong_AsUnsignedLongMask(addr)+i);
#else
                    Cache__load(self, PyLong_AsUnsignedLongMask(addr)+i);
#endif
                }
                Py_DECREF(addr);
            }
        }
        
        // Unless None (ortherwise ignore stores)
        
        if(store_addrs != Py_None) {
            if(!PySequence_Check(store_addrs)) {
                PyErr_SetString(
                    PyExc_ValueError, "store element does not provide a sequence protocol");
                return NULL;
            }
            
            // FIXME maybe this is better: Pass along to iterstore
            //Cache_iterload(self, load_addrs, length)
            
            // Iterate of elements in store_addrs
            store_iter = PyObject_GetIter(store_addrs);
            if(store_iter == NULL) {
                PyErr_SetString(PyExc_ValueError, "store address is not iteratable");
                return NULL;
            }
            while((addr = PyIter_Next(store_iter))) {
                // Each address is expanded to a certain length (default is 1)
                for(int i=0; i<length; i++) {
                    // Handle write-allocate
                    if(write_allocate) {
#if PY_MAJOR_VERSION >= 3
                        Cache__load(self, PyLong_AsUnsignedLongMask(addr)+i);
#else
                        Cache__load(self, PyLong_AsUnsignedLongMask(addr)+i);
#endif
                    }
#if PY_MAJOR_VERSION >= 3
                    Cache__store(self, PyLong_AsUnsignedLongMask(addr)+i);
#else
                    Cache__store(self, PyLong_AsUnsignedLongMask(addr)+i);
#endif
                }
                Py_DECREF(addr);
            }
        }
        
        Py_DECREF(load_addrs);
        Py_DECREF(store_addrs);
        Py_DECREF(loadstore_item);
    }
    Py_DECREF(addrs_iter);
    Py_RETURN_NONE;
}
Exemplo n.º 12
0
static PyObject *frputvect(PyObject *self, PyObject *args, PyObject *keywds) {
    FrFile *oFile;
    FrameH *frame;
    FrProcData *proc;
    FrAdcData *adc;
    FrSimData *sim;
    FrVect *vect;
    int verbose=0, nData, nBits, type, subType, arrayType;
    double dx, sampleRate, start;
    char blank[] = "";
    char *filename=NULL, *history=NULL;
    char channel[MAX_STR_LEN], x_unit[MAX_STR_LEN], y_unit[MAX_STR_LEN], kind[MAX_STR_LEN];
    PyObject *temp;
    char msg[MAX_STR_LEN];

    PyObject *channellist, *channellist_iter, *framedict, *array;
    PyArrayIterObject *arrayIter;
    PyArray_Descr *temp_descr;

    static char *kwlist[] = {"filename", "channellist", "history", "verbose",
                             NULL};

    /*--------------- unpack arguments --------------------*/
    verbose = 0;

    /* The | in the format string indicates the next arguments are
       optional.  They are simply not assigned anything. */
    if (!PyArg_ParseTupleAndKeywords(args, keywds, "sO|si", kwlist,
        &filename, &channellist, &history, &verbose)) {
        Py_RETURN_NONE;
    }

    FrLibSetLvl(verbose);

    if (history == NULL) {
        history = blank;
    }

    /*-------- create frames, create vectors, and fill them. ------*/

    // Channel-list must be any type of sequence
    if (!PySequence_Check(channellist)) {
        PyErr_SetNone(PyExc_TypeError);
        return NULL;
    }

    // Get channel name from first dictionary
    framedict = PySequence_GetItem(channellist, (Py_ssize_t)0);
    if (framedict == NULL) {
        PyErr_SetString(PyExc_ValueError, "channellist is empty!");
        return NULL;
    }

    PyDict_ExtractString(channel, framedict, "name");
    Py_XDECREF(framedict);
    if (PyErr_Occurred()) {return NULL;}

    if (verbose > 0) {
        printf("Creating frame %s...\n", channel);
    }

    frame = FrameNew(channel);
    if (frame == NULL) {
        snprintf(msg, MAX_STR_LEN, "FrameNew failed (%s)", FrErrorGetHistory());
        PyErr_SetString(PyExc_FrError, msg);
        return NULL;
    }

    if (verbose > 0) {
        printf("Now iterating...\n");
    }

    // Iterators allow one to deal with non-contiguous arrays
    channellist_iter = PyObject_GetIter(channellist);
    arrayIter = NULL;
    while ((framedict = PyIter_Next(channellist_iter))) {
        if (verbose > 0) {
            printf("In loop...\n");
        }

        // Extract quantities from dict -- all borrowed references
        PyDict_ExtractString(channel, framedict, "name");
        CHECK_ERROR;

        start = PyDict_ExtractDouble(framedict, "start");
        CHECK_ERROR;

        dx = PyDict_ExtractDouble(framedict, "dx");
        CHECK_ERROR;

        array = PyDict_GetItemString(framedict, "data");
        if (!PyArray_Check(array)) {
            snprintf(msg, MAX_STR_LEN, "data is not an array");
            PyErr_SetString(PyExc_TypeError, msg);
        }
        CHECK_ERROR;

        nData = PyArray_SIZE(array);
        nBits = PyArray_ITEMSIZE(array)*8;
        arrayType = PyArray_TYPE(array);

        // kind, x_unit, y_unit, type, and subType have default values
        temp = PyDict_GetItemString(framedict, "kind");
        if (temp != NULL) {strncpy(kind, PyString_AsString(temp), MAX_STR_LEN);}
        else {snprintf(kind, MAX_STR_LEN, "PROC");}

        temp = PyDict_GetItemString(framedict, "x_unit");
        if (temp != NULL) {strncpy(x_unit, PyString_AsString(temp), MAX_STR_LEN);}
        else {strncpy(x_unit, blank, MAX_STR_LEN);}

        temp = PyDict_GetItemString(framedict, "y_unit");
        if (temp != NULL) {strncpy(y_unit, PyString_AsString(temp), MAX_STR_LEN);}
        else {strncpy(y_unit, blank, MAX_STR_LEN);}

        temp = PyDict_GetItemString(framedict, "type");
        if (temp != NULL) {type = (int)PyInt_AsLong(temp);}
        else {type = 1;}

        temp = PyDict_GetItemString(framedict, "subType");
        if (temp != NULL) {subType = (int)PyInt_AsLong(temp);}
        else {subType = 0;}

        // check for errors
        CHECK_ERROR;
        if (dx <= 0 || array == NULL || nData==0) {
            temp = PyObject_Str(framedict);
            snprintf(msg, MAX_STR_LEN, "Input dictionary contents: %s", PyString_AsString(temp));
            Py_XDECREF(temp);
            FrameFree(frame);
            Py_XDECREF(framedict);
            Py_XDECREF(channellist_iter);
            PyErr_SetString(PyExc_ValueError, msg);
            return NULL;
        }


        if (verbose > 0) {
            printf("type = %d, subType = %d, start = %f, dx = %f\n",
                type, subType, start, dx);
        }

        sampleRate = 1./dx;

        if (verbose > 0) {
            printf("Now copying data to vector...\n");
        }

        // Create empty vector (-typecode ==> empty) with metadata,
        // then copy data to vector
        vect = NULL;
        arrayIter = (PyArrayIterObject *)PyArray_IterNew(array);
        if(arrayType == NPY_INT16) {
            vect = FrVectNew1D(channel,-FR_VECT_2S,nData,dx,x_unit,y_unit);
            while (arrayIter->index < arrayIter->size) {
                vect->dataS[arrayIter->index] = *((npy_int16 *)arrayIter->dataptr);
                PyArray_ITER_NEXT(arrayIter);}}
        else if(arrayType == NPY_INT32) {
            vect = FrVectNew1D(channel,-FR_VECT_4S,nData,dx,x_unit,y_unit);
            while (arrayIter->index < arrayIter->size) {
                vect->dataI[arrayIter->index] = *((npy_int32 *)arrayIter->dataptr);
                PyArray_ITER_NEXT(arrayIter);}}
        else if(arrayType == NPY_INT64) {
            vect = FrVectNew1D(channel,-FR_VECT_8S,nData,dx,x_unit,y_unit);
            while (arrayIter->index < arrayIter->size) {
                vect->dataL[arrayIter->index] = *((npy_int64 *)arrayIter->dataptr);
                PyArray_ITER_NEXT(arrayIter);}}
        else if(arrayType == NPY_UINT8) {
            vect = FrVectNew1D(channel,-FR_VECT_1U,nData,dx,x_unit,y_unit);
            while (arrayIter->index < arrayIter->size) {
                vect->dataU[arrayIter->index] = *((npy_uint8 *)arrayIter->dataptr);
                PyArray_ITER_NEXT(arrayIter);}}
        else if(arrayType == NPY_UINT16) {
            vect = FrVectNew1D(channel,-FR_VECT_2U,nData,dx,x_unit,y_unit);
            while (arrayIter->index < arrayIter->size) {
                vect->dataUS[arrayIter->index] = *((npy_uint16 *)arrayIter->dataptr);
                PyArray_ITER_NEXT(arrayIter);}}
        else if(arrayType == NPY_UINT32) {
            vect = FrVectNew1D(channel,-FR_VECT_4U,nData,dx,x_unit,y_unit);
            while (arrayIter->index < arrayIter->size) {
                vect->dataUI[arrayIter->index] = *((npy_uint32 *)arrayIter->dataptr);
                PyArray_ITER_NEXT(arrayIter);}}
        else if(arrayType == NPY_UINT64) {
            vect = FrVectNew1D(channel,-FR_VECT_8U,nData,dx,x_unit,y_unit);
            while (arrayIter->index < arrayIter->size) {
                vect->dataUL[arrayIter->index] = *((npy_uint64 *)arrayIter->dataptr);
                PyArray_ITER_NEXT(arrayIter);}}
        else if(arrayType == NPY_FLOAT32) {
            vect = FrVectNew1D(channel,-FR_VECT_4R,nData,dx,x_unit,y_unit);
            while (arrayIter->index < arrayIter->size) {
                vect->dataF[arrayIter->index] = *((npy_float32 *)arrayIter->dataptr);
                PyArray_ITER_NEXT(arrayIter);}}
        else if(arrayType == NPY_FLOAT64) {
            vect = FrVectNew1D(channel,-FR_VECT_8R,nData,dx,x_unit,y_unit);
            while (arrayIter->index < arrayIter->size) {
                vect->dataD[arrayIter->index] = *((npy_float64 *)arrayIter->dataptr);
                PyArray_ITER_NEXT(arrayIter);}}
        /* FrVects don't have complex pointers.  Numpy stores complex
           numbers in the same way, but we have to trick it into giving
           us a (real) float pointer. */
        else if(arrayType == NPY_COMPLEX64) {
            vect = FrVectNew1D(channel,-FR_VECT_8C,nData,dx,x_unit,y_unit);
            temp_descr = PyArray_DescrFromType(NPY_FLOAT32);
            temp = PyArray_View((PyArrayObject *)array, temp_descr, NULL);
            Py_XDECREF(temp_descr);
            Py_XDECREF(arrayIter);
            arrayIter = (PyArrayIterObject *)PyArray_IterNew(temp);
            while (arrayIter->index < arrayIter->size) {
                vect->dataF[arrayIter->index] = *((npy_float32 *)arrayIter->dataptr);
                PyArray_ITER_NEXT(arrayIter);}
            Py_XDECREF(temp);}
        else if(arrayType == NPY_COMPLEX128) {
            vect = FrVectNew1D(channel,-FR_VECT_16C,nData,dx,x_unit,y_unit);
            temp_descr = PyArray_DescrFromType(NPY_FLOAT64);
            temp = PyArray_View((PyArrayObject *)array, temp_descr, NULL);
            Py_XDECREF(temp_descr);
            Py_XDECREF(arrayIter);
            arrayIter = (PyArrayIterObject *)PyArray_IterNew(temp);
            while (arrayIter->index < arrayIter->size) {
                vect->dataD[arrayIter->index] = *((npy_float64 *)arrayIter->dataptr);
                PyArray_ITER_NEXT(arrayIter);}
            Py_XDECREF(temp);}
        else PyErr_SetString(PyExc_TypeError, msg);

        if (PyErr_Occurred()) {
            if (vect != NULL) FrVectFree(vect);
            FrameFree(frame);
            Py_XDECREF(framedict);
            Py_XDECREF(channellist_iter);
            Py_XDECREF(arrayIter);
            return NULL;
        }

        if (verbose > 0) {
            printf("Done copying...\n");
            FrameDump(frame, stdout, 6);
        }

        // Add Fr*Data to frame and attach vector to Fr*Data
        if (strncmp(kind, "PROC", MAX_STR_LEN)==0) {
            proc = FrProcDataNew(frame, channel, sampleRate, 1, nBits);
            FrVectFree(proc->data);
            proc->data = vect;
            proc->type = type;
            proc->subType = subType;
            frame->GTimeS = (npy_uint32)start;
            frame->GTimeN = (npy_uint32)((start-(frame->GTimeS))*1e9);
            if (type==1) {  // time series
                proc->tRange = nData*dx;
                frame->dt = nData*dx;
            } else if (type==2) {  // frequency series
                proc->fRange = nData*dx;
            }
        } else if (strncmp(kind, "ADC", MAX_STR_LEN)==0) {
            adc = FrAdcDataNew(frame, channel, sampleRate, 1, nBits);
            FrVectFree(adc->data);
            adc->data = vect;
            frame->dt = nData*dx;
            frame->GTimeS = (npy_uint32)start;
            frame->GTimeN = (npy_uint32)((start-(frame->GTimeS))*1e9);
        } else {// Already tested that kind is one of these strings above
            sim = FrSimDataNew(frame, channel, sampleRate, 1, nBits);
            FrVectFree(sim->data);
            sim->data = vect;
            frame->dt = nData*dx;
            frame->GTimeS = (npy_uint32)start;
            frame->GTimeN = (npy_uint32)((start-(frame->GTimeS))*1e9);
        }

        if (verbose > 0) {
            printf("Attached vect to frame.\n");
        }

        // Clean up (all python objects in loop should be borrowed references)
        Py_XDECREF(framedict);
        Py_XDECREF(arrayIter);
    } // end iteration over channellist

    Py_XDECREF(channellist_iter);
    // At this point, there should be no Python references left!

    /*------------- Write file -----------------------------*/
    oFile = FrFileONewH(filename, 1, history); // 1 ==> gzip contents

    if (oFile == NULL) {
        snprintf(msg, MAX_STR_LEN, "%s\n", FrErrorGetHistory());
        PyErr_SetString(PyExc_FrError, msg);
        FrFileOEnd(oFile);
        return NULL;
    }
    if (FrameWrite(frame, oFile) != FR_OK) {
        snprintf(msg, MAX_STR_LEN, "%s\n", FrErrorGetHistory());
        PyErr_SetString(PyExc_FrError, msg);
        FrFileOEnd(oFile);
        return NULL;
    }

    /* The FrFile owns data and vector memory. Do not free them separately. */
    FrFileOEnd(oFile);
    FrameFree(frame);
    Py_RETURN_NONE;
};
Exemplo n.º 13
0
static int convertTo_QJsonArray(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QJsonArray **sipCppPtr = reinterpret_cast<QJsonArray **>(sipCppPtrV);

#line 59 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtCore/qjsonarray.sip"
    PyObject *iter = PyObject_GetIter(sipPy);

    if (!sipIsErr)
    {
        Py_XDECREF(iter);

        return (iter
#if PY_MAJOR_VERSION < 3
                && !PyString_Check(sipPy)
#endif
                && !PyUnicode_Check(sipPy));
    }

    if (!iter)
    {
        *sipIsErr = 1;

        return 0;
    }

    QJsonArray *ql = new QJsonArray;
 
    for (SIP_SSIZE_T i = 0; ; ++i)
    {
        PyErr_Clear();
        PyObject *itm = PyIter_Next(iter);

        if (!itm)
        {
            if (PyErr_Occurred())
            {
                delete ql;
                Py_DECREF(iter);
                *sipIsErr = 1;

                return 0;
            }

            break;
        }

        int state;
        QJsonValue *t = reinterpret_cast<QJsonValue *>(
                sipForceConvertToType(itm, sipType_QJsonValue, sipTransferObj,
                        SIP_NOT_NONE, &state, sipIsErr));

        if (*sipIsErr)
        {
            PyErr_Format(PyExc_TypeError,
                    "index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QJsonValue' is expected",
                    i, Py_TYPE(itm)->tp_name);

            Py_DECREF(itm);
            delete ql;
            Py_DECREF(iter);

            return 0;
        }

        ql->append(*t);

        sipReleaseType(t, sipType_QJsonValue, state);
        Py_DECREF(itm);
    }
 
    Py_DECREF(iter);

    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 139 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtCore/sipQtCoreQJsonArray.cpp"
}
static PyObject *
KyotoDB_update(KyotoDB *self, PyObject *args, PyObject *kwds)
{
    Py_ssize_t size = PyTuple_Size(args);
    if (size > 1) {
        APR str(PyString_FromFormat("update expected at most 1 arguments, got %zd", size));
        PyErr_SetObject(PyExc_TypeError, str.get());
        return NULL;
    }

    if (size == 1) {
        APR obj(PyTuple_GetItem(args, 0));

        if (PyMapping_Check(obj.get())) {
            if (!KyotoDB_update_with_mapping(self, obj.get()))
                return NULL;
        } else {
            APR iterator (PyObject_GetIter(obj.get()));
            APR item;

            if (iterator == NULL) {
                PyErr_SetString(PyExc_RuntimeError, "object is not iterable");
                return NULL;
            }

            Py_ssize_t i = 0;
            while ((item = PyIter_Next(iterator.get())) != NULL) {
                if (!PySequence_Check(item.get())) {
                    APR str(PyString_FromFormat("cannot convert dictionary update sequence element #%zd to a sequence", i));
                    PyErr_SetObject(PyExc_TypeError, str.get());
                    return NULL;
                }
                if (PySequence_Size(item.get()) != 2) {
                    APR str(PyString_FromFormat("dictionary update sequence element #%zd has length %zd; 2 is required",
                                                i, PySequence_Size(item.get())));
                    PyErr_SetObject(PyExc_TypeError, str.get());
                    return NULL;
                }
                APR key(PySequence_GetItem(item.get(), 0));
                APR value(PySequence_GetItem(item.get(), 1));

                bool ok;
                std::string ckey = KyotoDB_dump(key, self->use_pickle, &ok);
                if (!ok)
                    return NULL;

                std::string cvalue = KyotoDB_dump(value, self->use_pickle, &ok);
                if (!ok)
                    return NULL;

                self->m_db->set(ckey, cvalue);
                i++;
            }
        }
    }

    if (kwds) {
        if (!KyotoDB_update_with_mapping(self, kwds))
            return NULL;
    }
    
    Py_RETURN_NONE;
}
static PyObject* _cbson_insert_message(PyObject* self, PyObject* args) {
    /* NOTE just using a random number as the request_id */
    struct module_state *state = GETSTATE(self);

    int request_id = rand();
    char* collection_name = NULL;
    int collection_name_length;
    PyObject* docs;
    PyObject* doc;
    PyObject* iterator;
    int before, cur_size, max_size = 0;
    int options = 0;
    unsigned char check_keys;
    unsigned char safe;
    unsigned char continue_on_error;
    unsigned char uuid_subtype;
    PyObject* last_error_args;
    buffer_t buffer;
    int length_location, message_length;
    PyObject* result;

    if (!PyArg_ParseTuple(args, "et#ObbObb",
                          "utf-8",
                          &collection_name,
                          &collection_name_length,
                          &docs, &check_keys, &safe,
                          &last_error_args,
                          &continue_on_error, &uuid_subtype)) {
        return NULL;
    }
    if (continue_on_error) {
        options += 1;
    }

    buffer = buffer_new();
    if (!buffer) {
        PyErr_NoMemory();
        PyMem_Free(collection_name);
        return NULL;
    }

    // save space for message length
    length_location = buffer_save_space(buffer, 4);
    if (length_location == -1) {
        PyMem_Free(collection_name);
        PyErr_NoMemory();
        return NULL;
    }
    if (!buffer_write_bytes(buffer, (const char*)&request_id, 4) ||
        !buffer_write_bytes(buffer,
                            "\x00\x00\x00\x00"
                            "\xd2\x07\x00\x00",
                            8) ||
        !buffer_write_bytes(buffer, (const char*)&options, 4) ||
        !buffer_write_bytes(buffer,
                            collection_name,
                            collection_name_length + 1)) {
        PyMem_Free(collection_name);
        buffer_free(buffer);
        return NULL;
    }

    iterator = PyObject_GetIter(docs);
    if (iterator == NULL) {
        PyObject* InvalidOperation = _error("InvalidOperation");
        PyErr_SetString(InvalidOperation, "input is not iterable");
        Py_DECREF(InvalidOperation);
        buffer_free(buffer);
        PyMem_Free(collection_name);
        return NULL;
    }
    while ((doc = PyIter_Next(iterator)) != NULL) {
        before = buffer_get_position(buffer);
        if (!write_dict(state->_cbson, buffer, doc, check_keys, uuid_subtype, 1)) {
            Py_DECREF(doc);
            Py_DECREF(iterator);
            buffer_free(buffer);
            PyMem_Free(collection_name);
            return NULL;
        }
        Py_DECREF(doc);
        cur_size = buffer_get_position(buffer) - before;
        max_size = (cur_size > max_size) ? cur_size : max_size;
    }
    Py_DECREF(iterator);

    if (PyErr_Occurred()) {
        buffer_free(buffer);
        PyMem_Free(collection_name);
        return NULL;
    }

    if (!max_size) {
        PyObject* InvalidOperation = _error("InvalidOperation");
        PyErr_SetString(InvalidOperation, "cannot do an empty bulk insert");
        Py_DECREF(InvalidOperation);
        buffer_free(buffer);
        PyMem_Free(collection_name);
        return NULL;
    }

    message_length = buffer_get_position(buffer) - length_location;
    memcpy(buffer_get_buffer(buffer) + length_location, &message_length, 4);

    if (safe) {
        if (!add_last_error(self, buffer, request_id, collection_name,
                            collection_name_length, last_error_args)) {
            buffer_free(buffer);
            PyMem_Free(collection_name);
            return NULL;
        }
    }

    PyMem_Free(collection_name);

    /* objectify buffer */
    result = Py_BuildValue("i" BYTES_FORMAT_STRING "i", request_id,
                           buffer_get_buffer(buffer),
                           buffer_get_position(buffer),
                           max_size);
    buffer_free(buffer);
    return result;
}
Exemplo n.º 16
0
static uint32_t pointless_export_py_rec(pointless_export_state_t* state, PyObject* py_object, uint32_t depth)
{
	// don't go too deep
	if (depth >= POINTLESS_MAX_DEPTH) {
		PyErr_SetString(PyExc_ValueError, "structure is too deep");
		state->is_error = 1;
		printf("line: %i\n", __LINE__);
		state->error_line = __LINE__;
		return POINTLESS_CREATE_VALUE_FAIL;
	}

	// check simple types first
	uint32_t handle = POINTLESS_CREATE_VALUE_FAIL;

	// return an error on failure
	#define RETURN_OOM(state) {PyErr_NoMemory(); (state)->is_error = 1; printf("line: %i\n", __LINE__); state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL;}
	#define RETURN_OOM_IF_FAIL(handle, state) if ((handle) == POINTLESS_CREATE_VALUE_FAIL) RETURN_OOM(state);

	// booleans, need this above integer check, cause PyInt_Check return 1 for booleans
	if (PyBool_Check(py_object)) {
		if (py_object == Py_True)
			handle = pointless_create_boolean_true(&state->c);
		else
			handle = pointless_create_boolean_false(&state->c);

		RETURN_OOM_IF_FAIL(handle, state);
	// integer
	} else if (PyInt_Check(py_object)) {
		long v = PyInt_AS_LONG(py_object);

		// unsigned
		if (v >= 0) {
			if (v > UINT32_MAX) {
				PyErr_Format(PyExc_ValueError, "integer too large for mere 32 bits");
				printf("line: %i\n", __LINE__);
				state->is_error = 1;
				state->error_line = __LINE__;
				return POINTLESS_CREATE_VALUE_FAIL;
			}

			handle = pointless_create_u32(&state->c, (uint32_t)v);
		// signed
		} else {
			if (!(INT32_MIN <= v && v <= INT32_MAX)) {
				PyErr_Format(PyExc_ValueError, "integer too large for mere 32 bits with a sign");
				printf("line: %i\n", __LINE__);
				state->is_error = 1;
				state->error_line = __LINE__;
				return POINTLESS_CREATE_VALUE_FAIL;
			}

			handle = pointless_create_i32(&state->c, (int32_t)v);
		}

		RETURN_OOM_IF_FAIL(handle, state);
	// long
	} else if (PyLong_Check(py_object)) {
		// this will raise an overflow error if number is outside the legal range of PY_LONG_LONG
		PY_LONG_LONG v = PyLong_AsLongLong(py_object);

		// if there was an exception, clear it, and set our own
		if (PyErr_Occurred()) {
			PyErr_Clear();
			PyErr_SetString(PyExc_ValueError, "value of long is way beyond what we can store right now");
			printf("line: %i\n", __LINE__);
			state->is_error = 1;
			state->error_line = __LINE__;
			return POINTLESS_CREATE_VALUE_FAIL;
		}

		// unsigned
		if (v >= 0) {
			if (v > UINT32_MAX) {
				PyErr_Format(PyExc_ValueError, "long too large for mere 32 bits");
				printf("line: %i\n", __LINE__);
				state->is_error = 1;
				state->error_line = __LINE__;
				return POINTLESS_CREATE_VALUE_FAIL;
			}

			handle = pointless_create_u32(&state->c, (uint32_t)v);
		// signed
		} else {
			if (!(INT32_MIN <= v && v <= INT32_MAX)) {
				PyErr_Format(PyExc_ValueError, "long too large for mere 32 bits with a sign");
				printf("line: %i\n", __LINE__);
				state->is_error = 1;
				state->error_line = __LINE__;
				return POINTLESS_CREATE_VALUE_FAIL;
			}

			handle = pointless_create_i32(&state->c, (int32_t)v);
		}

		RETURN_OOM_IF_FAIL(handle, state);
	// None object
	} else if (py_object == Py_None) {
		handle = pointless_create_null(&state->c);
		RETURN_OOM_IF_FAIL(handle, state);
	} else if (PyFloat_Check(py_object)) {
		handle = pointless_create_float(&state->c, (float)PyFloat_AS_DOUBLE(py_object));
		RETURN_OOM_IF_FAIL(handle, state);
	}

	if (handle != POINTLESS_CREATE_VALUE_FAIL)
		return handle;

	// remaining types are containers/big-values, which we track
	// either for space-savings or maintaining circular references

	// if object has been seen before, return its handle
	handle = pointless_export_get_seen(state, py_object);

	if (handle != POINTLESS_CREATE_VALUE_FAIL)
		return handle;

	// list/tuple object
	if (PyList_Check(py_object) || PyTuple_Check(py_object)) {
		// create and cache handle
		assert(is_container(py_object));

		handle = pointless_create_vector_value(&state->c);
		RETURN_OOM_IF_FAIL(handle, state);

		if (!pointless_export_set_seen(state, py_object, handle)) {
			RETURN_OOM(state);
		}

		// populate vector
		Py_ssize_t i, n_items = PyList_Check(py_object) ? PyList_GET_SIZE(py_object) : PyTuple_GET_SIZE(py_object);

		for (i = 0; i < n_items; i++) {
			PyObject* child = PyList_Check(py_object) ? PyList_GET_ITEM(py_object, i) : PyTuple_GET_ITEM(py_object, i);
			uint32_t child_handle = pointless_export_py_rec(state, child, depth + 1);

			if (child_handle == POINTLESS_CREATE_VALUE_FAIL)
				return child_handle;

			if (pointless_create_vector_value_append(&state->c, handle, child_handle) == POINTLESS_CREATE_VALUE_FAIL) {
				RETURN_OOM(state);
			}
		}

	// pointless value vectors
	} else if (PyPointlessVector_Check(py_object)) {
		// currently, we only support value vectors, they are simple
		PyPointlessVector* v = (PyPointlessVector*)py_object;
		const char* error = 0;

		switch(v->v->type) {
			case POINTLESS_VECTOR_VALUE:
			case POINTLESS_VECTOR_VALUE_HASHABLE:
				handle = pointless_recreate_value(&v->pp->p, v->v, &state->c, &error);

				if (handle == POINTLESS_CREATE_VALUE_FAIL) {
					printf("line: %i\n", __LINE__);
					state->is_error = 1;
					state->error_line = __LINE__;
					PyErr_Format(PyExc_ValueError, "pointless_recreate_value(): %s", error);
					return POINTLESS_CREATE_VALUE_FAIL;
				}

				break;
			case POINTLESS_VECTOR_I8:
				handle = pointless_create_vector_i8_owner(&state->c, pointless_reader_vector_i8(&v->pp->p, v->v) + v->slice_i, v->slice_n);
				break;
			case POINTLESS_VECTOR_U8:
				handle = pointless_create_vector_u8_owner(&state->c, pointless_reader_vector_u8(&v->pp->p, v->v) + v->slice_i, v->slice_n);
				break;
			case POINTLESS_VECTOR_I16:
				handle = pointless_create_vector_i16_owner(&state->c, pointless_reader_vector_i16(&v->pp->p, v->v) + v->slice_i, v->slice_n);
				break;
			case POINTLESS_VECTOR_U16:
				handle = pointless_create_vector_u16_owner(&state->c, pointless_reader_vector_u16(&v->pp->p, v->v) + v->slice_i, v->slice_n);
				break;
			case POINTLESS_VECTOR_I32:
				handle = pointless_create_vector_i32_owner(&state->c, pointless_reader_vector_i32(&v->pp->p, v->v) + v->slice_i, v->slice_n);
				break;
			case POINTLESS_VECTOR_U32:
				handle = pointless_create_vector_u32_owner(&state->c, pointless_reader_vector_u32(&v->pp->p, v->v) + v->slice_i, v->slice_n);
				break;
			case POINTLESS_VECTOR_I64:
				handle = pointless_create_vector_i64_owner(&state->c, pointless_reader_vector_i64(&v->pp->p, v->v) + v->slice_i, v->slice_n);
				break;
			case POINTLESS_VECTOR_U64:
				handle = pointless_create_vector_u64_owner(&state->c, pointless_reader_vector_u64(&v->pp->p, v->v) + v->slice_i, v->slice_n);
				break;
			case POINTLESS_VECTOR_FLOAT:
				handle = pointless_create_vector_float_owner(&state->c, pointless_reader_vector_float(&v->pp->p, v->v) + v->slice_i, v->slice_n);
				break;
			case POINTLESS_VECTOR_EMPTY:
				handle = pointless_create_vector_value(&state->c);
				break;
			default:
				state->error_line = __LINE__;
				printf("line: %i\n", __LINE__);
				state->is_error = 1;
				PyErr_SetString(PyExc_ValueError, "internal error: illegal type for primitive vector");
				return POINTLESS_CREATE_VALUE_FAIL;
		}

		RETURN_OOM_IF_FAIL(handle, state);

		if (!pointless_export_set_seen(state, py_object, handle)) {
			RETURN_OOM(state);
		}

	// python bytearray
	} else if (PyByteArray_Check(py_object)) {
		// create handle and hand over the memory
		Py_ssize_t n_items = PyByteArray_GET_SIZE(py_object);

		if (n_items > UINT32_MAX) {
			PyErr_SetString(PyExc_ValueError, "bytearray has too many items");
			state->error_line = __LINE__;
			printf("line: %i\n", __LINE__);
			state->is_error = 1;
			return POINTLESS_CREATE_VALUE_FAIL;
		}

		handle = pointless_create_vector_u8_owner(&state->c, (uint8_t*)PyByteArray_AS_STRING(py_object), (uint32_t)n_items);
		RETURN_OOM_IF_FAIL(handle, state);

		if (!pointless_export_set_seen(state, py_object, handle)) {
			RETURN_OOM(state);
		}

	// primitive vectors
	} else if (PyPointlessPrimVector_Check(py_object)) {
		// we just hand over the memory
		PyPointlessPrimVector* prim_vector = (PyPointlessPrimVector*)py_object;
		uint32_t n_items = pointless_dynarray_n_items(&prim_vector->array);
		void* data = prim_vector->array._data;

		switch (prim_vector->type) {
			case POINTLESS_PRIM_VECTOR_TYPE_I8:
				handle = pointless_create_vector_i8_owner(&state->c, (int8_t*)data, n_items);
				break;
			case POINTLESS_PRIM_VECTOR_TYPE_U8:
				handle = pointless_create_vector_u8_owner(&state->c, (uint8_t*)data, n_items);
				break;
			case POINTLESS_PRIM_VECTOR_TYPE_I16:
				handle = pointless_create_vector_i16_owner(&state->c, (int16_t*)data, n_items);
				break;
			case POINTLESS_PRIM_VECTOR_TYPE_U16:
				handle = pointless_create_vector_u16_owner(&state->c, (uint16_t*)data, n_items);
				break;
			case POINTLESS_PRIM_VECTOR_TYPE_I32:
				handle = pointless_create_vector_i32_owner(&state->c, (int32_t*)data, n_items);
				break;
			case POINTLESS_PRIM_VECTOR_TYPE_U32:
				handle = pointless_create_vector_u32_owner(&state->c, (uint32_t*)data, n_items);
				break;
			case POINTLESS_PRIM_VECTOR_TYPE_I64:
				handle = pointless_create_vector_i64_owner(&state->c, (int64_t*)data, n_items);
				break;
			case POINTLESS_PRIM_VECTOR_TYPE_U64:
				handle = pointless_create_vector_u64_owner(&state->c, (uint64_t*)data, n_items);
				break;
			case POINTLESS_PRIM_VECTOR_TYPE_FLOAT:
				handle = pointless_create_vector_float_owner(&state->c, (float*)data, n_items);
				break;
			default:
				PyErr_SetString(PyExc_ValueError, "internal error: illegal type for primitive vector");
				state->error_line = __LINE__;
				printf("line: %i\n", __LINE__);
				state->is_error = 1;
				return POINTLESS_CREATE_VALUE_FAIL;
		}

		RETURN_OOM_IF_FAIL(handle, state);

		if (!pointless_export_set_seen(state, py_object, handle)) {
			RETURN_OOM(state);
		}

	// unicode object
	} else if (PyUnicode_Check(py_object)) {
		// get it from python
		Py_UNICODE* python_buffer = PyUnicode_AS_UNICODE(py_object);

		// string must not contain zero's
		Py_ssize_t s_len_python = PyUnicode_GET_SIZE(py_object);

		#if Py_UNICODE_SIZE == 4
		uint32_t s_len_pointless = pointless_ucs4_len(python_buffer);
		#else
		uint32_t s_len_pointless = pointless_ucs2_len(python_buffer);
		#endif

		if (s_len_python < 0 || (uint64_t)s_len_python != s_len_pointless) {
			PyErr_SetString(PyExc_ValueError, "unicode string contains a zero, where it shouldn't");
			state->error_line = __LINE__;
			printf("line: %i\n", __LINE__);
			state->is_error = 1;
			return POINTLESS_CREATE_VALUE_FAIL;
		}

		#if Py_UNICODE_SIZE == 4
			if (state->unwiden_strings && pointless_is_ucs4_ascii((uint32_t*)python_buffer))
				handle = pointless_create_string_ucs4(&state->c, python_buffer);
			else
				handle = pointless_create_unicode_ucs4(&state->c, python_buffer);
		#else
			if (state->unwiden_strings && pointless_is_ucs2_ascii(python_buffer))
				handle = pointless_create_string_ucs2(&state->c, python_buffer);
			else
				handle = pointless_create_unicode_ucs2(&state->c, python_buffer);
		#endif

		RETURN_OOM_IF_FAIL(handle, state);

		if (!pointless_export_set_seen(state, py_object, handle)) {
			RETURN_OOM(state);
		}

	// string object
	} else if (PyString_Check(py_object)) {
		// get it from python
		uint8_t* python_buffer = (uint8_t*)PyString_AS_STRING(py_object);

		// string must not contain zero's
		Py_ssize_t s_len_python = PyString_GET_SIZE(py_object);
		uint32_t s_len_pointless = pointless_ascii_len(python_buffer);

		if (s_len_python < 0 || (uint64_t)s_len_python != s_len_pointless) {
			PyErr_SetString(PyExc_ValueError, "string contains a zero, where it shouldn't");
			state->error_line = __LINE__;
			printf("line: %i\n", __LINE__);
			state->is_error = 1;
			return POINTLESS_CREATE_VALUE_FAIL;
		}

		handle = pointless_create_string_ascii(&state->c, python_buffer);
		RETURN_OOM_IF_FAIL(handle, state);

		if (!pointless_export_set_seen(state, py_object, handle)) {
			RETURN_OOM(state);
		}

	// dict object
	} else if (PyDict_Check(py_object)) {
		handle = pointless_create_map(&state->c);
		RETURN_OOM_IF_FAIL(handle, state);

		if (!pointless_export_set_seen(state, py_object, handle)) {
			RETURN_OOM(state);
		}

		PyObject* key = 0;
		PyObject* value = 0;
		Py_ssize_t pos = 0;

		while (PyDict_Next(py_object, &pos, &key, &value)) {
			uint32_t key_handle = pointless_export_py_rec(state, key, depth + 1);
			uint32_t value_handle = pointless_export_py_rec(state, value, depth + 1);

			if (key_handle == POINTLESS_CREATE_VALUE_FAIL || value_handle == POINTLESS_CREATE_VALUE_FAIL)
				break;

			if (pointless_create_map_add(&state->c, handle, key_handle, value_handle) == POINTLESS_CREATE_VALUE_FAIL) {
				PyErr_SetString(PyExc_ValueError, "error adding key/value pair to map");
				state->error_line = __LINE__;
				printf("line: %i\n", __LINE__);
				state->is_error = 1;
				break;
			}
		}

		if (state->is_error) {
			return POINTLESS_CREATE_VALUE_FAIL;
		}

	// set object
	} else if (PyAnySet_Check(py_object)) {
		PyObject* iterator = PyObject_GetIter(py_object);
		PyObject* item = 0;

		if (iterator == 0) {
			printf("line: %i\n", __LINE__);
			state->is_error = 1;
			state->error_line = __LINE__;
			return POINTLESS_CREATE_VALUE_FAIL;
		}

		// get a handle
		handle = pointless_create_set(&state->c);
		RETURN_OOM_IF_FAIL(handle, state);

		// cache object
		if (!pointless_export_set_seen(state, py_object, handle)) {
			RETURN_OOM(state);
		}

		// iterate over it
		while ((item = PyIter_Next(iterator)) != 0) {
			uint32_t item_handle = pointless_export_py_rec(state, item, depth + 1);

			if (item_handle == POINTLESS_CREATE_VALUE_FAIL)
				break;

			if (pointless_create_set_add(&state->c, handle, item_handle) == POINTLESS_CREATE_VALUE_FAIL) {
				PyErr_SetString(PyExc_ValueError, "error adding item to set");
				printf("line: %i\n", __LINE__);
				state->is_error = 1;
				state->error_line = __LINE__;
				break;
			}
		}

		Py_DECREF(iterator);

		if (PyErr_Occurred()) {
			printf("line: %i\n", __LINE__);
			state->is_error = 1;
			state->error_line = __LINE__;
			return POINTLESS_CREATE_VALUE_FAIL;
		}

	// bitvector
	} else if (PyPointlessBitvector_Check(py_object)) {
		PyPointlessBitvector* bitvector = (PyPointlessBitvector*)py_object;

		if (bitvector->is_pointless) {
			uint32_t i, n_bits = pointless_reader_bitvector_n_bits(&bitvector->pointless_pp->p, bitvector->pointless_v);
			void* bits = pointless_calloc(ICEIL(n_bits, 8), 1);

			if (bits == 0) {
				RETURN_OOM(state);
			}

			for (i = 0; i < n_bits; i++) {
				if (pointless_reader_bitvector_is_set(&bitvector->pointless_pp->p, bitvector->pointless_v, i))
					bm_set_(bits, i);
			}

			if (state->normalize_bitvector)
				handle = pointless_create_bitvector(&state->c, bits, n_bits);
			else
				handle = pointless_create_bitvector_no_normalize(&state->c, bits, n_bits);
			pointless_free(bits);
			bits = 0;

		} else {
			if (state->normalize_bitvector)
				handle = pointless_create_bitvector(&state->c, bitvector->primitive_bits, bitvector->primitive_n_bits);
			else
				handle = pointless_create_bitvector_no_normalize(&state->c, bitvector->primitive_bits, bitvector->primitive_n_bits);
		}

		RETURN_OOM_IF_FAIL(handle, state);

		if (!pointless_export_set_seen(state, py_object, handle)) {
			RETURN_OOM(state);
		}

	} else if (PyPointlessSet_Check(py_object)) {
		PyPointlessSet* set = (PyPointlessSet*)py_object;
		const char* error = 0;
		handle = pointless_recreate_value(&set->pp->p, set->v, &state->c, &error);

		if (handle == POINTLESS_CREATE_VALUE_FAIL) {
			printf("line: %i\n", __LINE__);
			state->is_error = 1;
			state->error_line = __LINE__;
			PyErr_Format(PyExc_ValueError, "pointless_recreate_value(): %s", error);
			return POINTLESS_CREATE_VALUE_FAIL;
		}

		if (!pointless_export_set_seen(state, py_object, handle)) {
			RETURN_OOM(state);
		}

	} else if (PyPointlessMap_Check(py_object)) {
		PyPointlessMap* map = (PyPointlessMap*)py_object;
		const char* error = 0;
		handle = pointless_recreate_value(&map->pp->p, map->v, &state->c, &error);

		if (handle == POINTLESS_CREATE_VALUE_FAIL) {
			printf("line: %i\n", __LINE__);
			state->is_error = 1;
			state->error_line = __LINE__;
			PyErr_Format(PyExc_ValueError, "pointless_recreate_value(): %s", error);
			return POINTLESS_CREATE_VALUE_FAIL;
		}

		if (!pointless_export_set_seen(state, py_object, handle)) {
			RETURN_OOM(state);
		}

	// type not supported
	} else {
		PyErr_Format(PyExc_ValueError, "type <%s> not supported", py_object->ob_type->tp_name);
		state->error_line = __LINE__;
		printf("line: %i\n", __LINE__);
		state->is_error = 1;
	}

	#undef RETURN_OOM
	#undef RETURN_IF_OOM

	return handle;
}
Exemplo n.º 17
0
static PyObject *m_build_unpack_pair(PyObject *mod, PyObject *seqs) {

  // checked

  Py_ssize_t count = seqs? PyTuple_GET_SIZE(seqs): 0;
  Py_ssize_t index = 0;
  PyObject *tmp;

  if (! count) {
    Py_INCREF(SibNil);
    return SibNil;
  }

  PyObject *coll = PyList_New(0);

  while (index < count) {
    PyObject *item = PyTuple_GET_ITEM(seqs, index++);
    PyObject *work;

    if (SibNil_Check(item)) {
      // skip nil
      continue;

    } else if (SibPair_CheckExact(item)) {
      work = pair_unpack(item, NULL);

    } else {
      // todo: check for lists and tuples explicitly, and see if
      // they're zero-length. If so, avoid creating an iterator, just
      // continue to the next item.
      work = PyObject_GetIter(item);
    }

    if (! work) {
      Py_DECREF(coll);
      return NULL;
    }

    // why the everloving f**k isn't this a regular call?  tmp will be
    // NULL for exception, or a new PyNone reference if successful.
    tmp = _PyList_Extend((PyListObject *) coll, work);
    Py_CLEAR(work);

    if (! tmp) {
      Py_DECREF(coll);
      return NULL;

    } else {
      Py_CLEAR(tmp);
    }
  }

  if (! PyList_GET_SIZE(coll)) {
    // The collection didn't net any actual elements, so let's skip
    // out early and just return nil

    Py_DECREF(coll);
    Py_INCREF(SibNil);
    return SibNil;
  }

  // I wonder if there isn't a better way to do this. We end up
  // traversing the last cons pair twice, which means allocating a set
  // in order to avoid recursion. Is that too expensive?
  tmp = PyTuple_GET_ITEM(seqs, count - 1);
  if (SibPair_IsProper(tmp)) {
    if(PyList_Append(coll, SibNil)) {
      Py_DECREF(coll);
      return NULL;
    }
  }

  PyObject *result = SibPair_Cons(coll, 0);
  Py_DECREF(coll);
  return result;
}