python_metadata.h File Reference

#include "core/metadata_db.h"
#include "core/metadata_object.h"
#include "Python.h"

Include dependency graph for python_metadata.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	MDQueryObject
struct	MetaDataObject

Macros
#define	MetaData_Check(v)   (((v)->ob_type == &MetaDataType))
#define	MetaData_Value(v)   ((*((MetaDataObject*)(v))->metadata))
#define	MDQuery_Check(v)   (((v)->ob_type == &MDQueryType))
#define	MDQuery_Value(v)   ((*((MDQueryObject*)(v))->query))
#define	RETURN_MDOBJECT(value)   return std::make_unique<MDObject>((MDLabel)label, value)

Functions
void	MDQuery_dealloc (MDQueryObject *self)
PyObject *	MDQuery_new (PyTypeObject *type, PyObject *args, PyObject *kwargs)
PyObject *	MDQuery_repr (PyObject *obj)
PyObject *	createMDValueRelational (PyObject *args, int op)
PyObject *	xmipp_MDValueRelational (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	xmipp_MDValueEQ (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	xmipp_MDValueNE (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	xmipp_MDValueLT (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	xmipp_MDValueLE (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	xmipp_MDValueGT (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	xmipp_MDValueGE (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	xmipp_MDValueRange (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	xmipp_addLabelAlias (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	xmipp_getNewAlias (PyObject *obj, PyObject *args, PyObject *kwargs)
void	MetaData_dealloc (MetaDataObject *self)
PyObject *	MetaData_new (PyTypeObject *type, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_aggregate (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_aggregateMdGroupBy (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_aggregateSingle (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_aggregateSingleInt (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_addIndex (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_join1 (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_join2 (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_joinNatural (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_importObjects (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_intersection (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_merge (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_operate (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_replace (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_readPlain (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_addPlain (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_setComment (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_getComment (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_unionAll (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_randomize (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_selectPart (PyObject *obj, PyObject *args, PyObject *kwargs)
int	MetaData_print (PyObject *obj, FILE *fp, int flags)
PyObject *	MetaData_repr (PyObject *obj)
PyObject *	MetaData_RichCompareBool (PyObject *obj, PyObject *obj2, int opid)
PyObject *	MetaData_read (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_readBlock (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_write (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_append (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_addObject (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_firstObject (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_lastObject (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_size (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_getParsedLines (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_isEmpty (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_getColumnFormat (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_setColumnFormat (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_setValue (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_setValueCol (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_removeLabel (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_getValue (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_getRow (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_setRow (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_getColumnValues (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_setColumnValues (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_getActiveLabels (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	xmipp_getBlocksInMetaDataFile (PyObject *obj, PyObject *args)
PyObject *	MetaData_getMaxStringLength (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_containsLabel (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_addLabel (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_addItemId (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_fillConstant (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_fillRandom (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_fillExpand (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_copyColumn (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_renameColumn (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_copyColumnTo (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_removeObjects (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_removeDisabled (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_makeAbsPath (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_clear (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_iter (PyObject *obj)
PyObject *	MetaData_iternext (PyObject *obj)
PyObject *	MetaData_sort (PyObject *obj, PyObject *args, PyObject *kwargs)
PyObject *	MetaData_removeDuplicates (PyObject *obj, PyObject *args, PyObject *kwargs)
std::unique_ptr< MDObject >	createMDObject (int label, PyObject *pyValue)
void	setMDObjectValue (MDObject *obj, PyObject *pyValue)
PyObject *	getMDObjectValue (const MDObject *obj)

Variables
PyObject *	PyXmippError
PyMethodDef	MDQuery_methods []
PyTypeObject	MDQueryType
PyMethodDef	MetaData_methods []
PyTypeObject	MetaDataType

Macro Definition Documentation

MDQuery_Check

#define MDQuery_Check

(

v

)

(((v)->ob_type == &MDQueryType))

Definition at line 42 of file python_metadata.h.

MDQuery_Value

#define MDQuery_Value

(

v

)

((*((MDQueryObject*)(v))->query))

Definition at line 43 of file python_metadata.h.

MetaData_Check

#define MetaData_Check

(

v

)

(((v)->ob_type == &MetaDataType))

Definition at line 39 of file python_metadata.h.

MetaData_Value

#define MetaData_Value

(

v

)

((*((MetaDataObject*)(v))->metadata))

Definition at line 40 of file python_metadata.h.

RETURN_MDOBJECT

#define RETURN_MDOBJECT

(

value

)

return std::make_unique<MDObject>((MDLabel)label, value)

Definition at line 45 of file python_metadata.h.

Function Documentation

createMDObject()

std::unique_ptr<MDObject> createMDObject	(	int	label,
		PyObject *	pyValue
	)

Definition at line 2246 of file python_metadata.cpp.

{
    try
    {
        if (PyBool_Check(pyValue))
        {
            bool bValue = (pyValue == Py_True);
            RETURN_MDOBJECT(bValue);
        }
        if (PyLong_Check(pyValue) && MDL::isInt((MDLabel)label))
        {
            int iValue = PyLong_AS_LONG(pyValue);
            RETURN_MDOBJECT(iValue);
        }
        if (PyLong_Check(pyValue) && MDL::isLong((MDLabel)label))
        {
            size_t value = PyLong_AsUnsignedLong(pyValue);
            RETURN_MDOBJECT(value);
        }
        if (PyUnicode_Check(pyValue))
        {
            const char * str = PyUnicode_AsUTF8(PyObject_Str(pyValue));
            RETURN_MDOBJECT(std::string(str));
        }
        if (FileName_Check(pyValue))
        {
            RETURN_MDOBJECT(*((FileNameObject*)pyValue)->filename);
        }
        if (PyFloat_Check(pyValue))
        {
            double dValue = PyFloat_AS_DOUBLE(pyValue);
            RETURN_MDOBJECT(double(dValue));
        }
        if (PyList_Check(pyValue))
        {
            size_t size = PyList_Size(pyValue);
            PyObject * item = nullptr;
            double dValue = 0.;
            std::vector<double> vValue(size);
            for (size_t i = 0; i < size; ++i)
            {
                item = PyList_GetItem(pyValue, i);
                if (!PyFloat_Check(item))
                {
                    PyErr_SetString(PyExc_TypeError,
                                    "Vectors are only supported for double");
                    return nullptr;
                }
                dValue = PyFloat_AS_DOUBLE(item);
                vValue[i] = dValue;
            }
            RETURN_MDOBJECT(vValue);
        }
        PyErr_SetString(PyExc_TypeError, "Unrecognized type to create MDObject");
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}

createMDValueRelational()

PyObject* createMDValueRelational	(	PyObject *	args,
		int	op
	)

Definition at line 114 of file python_metadata.cpp.

{
    int label;
    int limit = -1;
    int offset = 0;
    auto orderLabel = (int) MDL_OBJID;
    PyObject *pyValue; //Only used to skip label and value

    if ((op == -1 && PyArg_ParseTuple(args, "iO|iiii", &label, &pyValue, &op,
                                      &limit, &offset, &orderLabel)) || PyArg_ParseTuple(args, "iO|iii",
                                              &label, &pyValue, &limit, &offset, &orderLabel))
    {
        auto object = createMDObject(label, pyValue);
        if (!object)
            return nullptr;
        auto *pyQuery = (MDQueryObject*)PyObject_CallFunction((PyObject*)&MDQueryType, "");
        pyQuery->query = std::make_unique<MDValueRelational>(*object, (RelationalOp) op,
                                               limit, offset, (MDLabel) orderLabel);
        return (PyObject *) pyQuery;
    }
    return nullptr;
}

getMDObjectValue()

PyObject* getMDObjectValue

(

const MDObject *

obj

)

Definition at line 2381 of file python_metadata.cpp.

{
    if (obj->label == MDL_UNDEFINED) //if undefine label, store as a literal string
        return nullptr;
    switch (MDL::labelType(obj->label))
    {
    case LABEL_BOOL: //bools are int in sqlite3
        if (obj->data.boolValue)
            Py_RETURN_TRUE;
        else
            Py_RETURN_FALSE;
    case LABEL_INT:
        return PyLong_FromLong(obj->data.intValue);
    case LABEL_SIZET:
        return PyLong_FromLong(obj->data.longintValue);
    case LABEL_DOUBLE:
        return PyFloat_FromDouble(obj->data.doubleValue);
    case LABEL_STRING:
        return PyUnicode_FromString(obj->data.stringValue->c_str());
    case LABEL_VECTOR_DOUBLE:
        {
            std::vector<double> & vector = *(obj->data.vectorValue);
            int size = vector.size();
            PyObject * list = PyList_New(size);
            for (int i = 0; i < size; ++i)
                PyList_SetItem(list, i, PyFloat_FromDouble(vector[i]));
            return list;
        }
    default:
            return nullptr;
    }//close switch
    return nullptr;
}

MDQuery_dealloc()

void MDQuery_dealloc

(

MDQueryObject *

self

)

Definition at line 81 of file python_metadata.cpp.

{
    self->~MDQueryObject(); // Call the destructor
    Py_TYPE(self)->tp_free((PyObject*)self);
}

MDQuery_new()

PyObject* MDQuery_new	(	PyTypeObject *	type,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 89 of file python_metadata.cpp.

{
    auto *self = (MDQueryObject*)type->tp_alloc(type, 0);
    return (PyObject *)self;
}

MDQuery_repr()

PyObject* MDQuery_repr

(

PyObject *

obj

)

Definition at line 97 of file python_metadata.cpp.

{
    auto *self = (MDQueryObject*) obj;
    if (self->query)
    {
        String s = self->query->whereString() + self->query->limitString()
                   + self->query->orderByString();
        return PyUnicode_FromString(s.c_str());
    }
    else
        return PyUnicode_FromString("");
}

MetaData_addIndex()

PyObject* MetaData_addIndex	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1971 of file python_metadata.cpp.

{
    int label;
    if (PyArg_ParseTuple(args, "i", &label))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->addIndex((MDLabel)label);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_addItemId()

PyObject* MetaData_addItemId	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1343 of file python_metadata.cpp.

{
    try
    {
        const auto *self = reinterpret_cast<MetaDataObject*>(obj);
        self->metadata->addItemId();
        Py_RETURN_NONE;
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}

MetaData_addLabel()

PyObject* MetaData_addLabel	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1321 of file python_metadata.cpp.

{
    int label;
    int pos = -1;
    if (PyArg_ParseTuple(args, "i|i", &label, &pos))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->addLabel((MDLabel) label, pos);
            Py_RETURN_TRUE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_addObject()

PyObject* MetaData_addObject	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 863 of file python_metadata.cpp.

{
    const auto *self = reinterpret_cast<MetaDataObject*>(obj);
    return PyLong_FromUnsignedLong(self->metadata->addObject());
}

MetaData_addPlain()

PyObject* MetaData_addPlain	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 712 of file python_metadata.cpp.

{
    const auto *self = reinterpret_cast<MetaDataObject*>(obj);

    if (self != NULL)
    {
        PyObject *input = NULL;
        PyObject *input2 = NULL;
        PyObject *pyStr = NULL;
        PyObject *pyLabels = NULL;
        PyObject *pySep = NULL;
        const char *str = NULL;
        const char *labels = NULL;

        if (PyArg_ParseTuple(args, "OO|O", &input, &input2, &pySep))
        {
            try
            {
                pyStr = PyObject_Str(input);
                pyLabels = PyObject_Str(input2);
                if ((NULL != pyStr) && (NULL != pyLabels))
                {
                    str = PyUnicode_AsUTF8(pyStr);
                    labels = PyUnicode_AsUTF8(pyLabels);
                    self->metadata->addPlain(str, labels);
                    Py_RETURN_NONE;
                }
                else
                    return NULL;
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
                return NULL;
            }
        }
    }
    return NULL;
}

MetaData_aggregate()

PyObject* MetaData_aggregate	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1790 of file python_metadata.cpp.

{

    AggregateOperation op;
    MDLabel aggregateLabel;
    MDLabel operateLabel;
    MDLabel resultLabel;
    PyObject *pyMd = nullptr;

    if (PyArg_ParseTuple(args, "Oiiii", &pyMd, &op, &aggregateLabel,
                         &operateLabel, &resultLabel))
    {
        try
        {
            if (!MetaData_Check(pyMd))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::aggregate: Expecting MetaData as first argument");
                return nullptr;
            }
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->aggregate(MetaData_Value(pyMd),
                                      op, aggregateLabel,
                                      operateLabel, resultLabel);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_aggregateMdGroupBy()

PyObject* MetaData_aggregateMdGroupBy	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1826 of file python_metadata.cpp.

{

    AggregateOperation op;
    PyObject *aggregateLabel= nullptr;
    MDLabel operateLabel;
    MDLabel resultLabel;
    PyObject *pyMd = nullptr;

    if (PyArg_ParseTuple(args, "OiOii", &pyMd, &op, &aggregateLabel,
                         &operateLabel, &resultLabel))
    {
        try
        {
            if (!MetaData_Check(pyMd))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::aggregateMdGroupBy: Expecting MetaData as first argument");
                return nullptr;
            }
            if (!PyList_Check(aggregateLabel))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::aggregateMdGroupBy: Input must be a mdl List not a mdl label");
                return nullptr;

            }
            size_t size = PyList_Size(aggregateLabel);
            std::vector<MDLabel> vaggregateLabel(size);
            PyObject * item = nullptr;
            int iValue = 0;
            for (size_t i = 0; i < size; ++i)
            {
                item = PyList_GetItem(aggregateLabel, i);
                if (!PyLong_Check(item))
                {
                    PyErr_SetString(PyExc_TypeError,
                                    "MDL labels must be integers (MDLABEL)");
                    return nullptr;
                }
                iValue = PyLong_AsLong(item);
                vaggregateLabel[i] = (MDLabel)iValue;
            }

            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->aggregateGroupBy(MetaData_Value(pyMd),
                                             (AggregateOperation) op, vaggregateLabel,
                                             operateLabel, resultLabel);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_aggregateSingle()

PyObject* MetaData_aggregateSingle	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1738 of file python_metadata.cpp.

{
    AggregateOperation op;
    MDLabel label;
    PyObject *pyValue;

    if (PyArg_ParseTuple(args, "ii", &op, &label))
    {
        try
        {
            auto object = MDObject(label);
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->aggregateSingle(object, op, label);
            pyValue = getMDObjectValue(&object);
            return pyValue;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_aggregateSingleInt()

PyObject* MetaData_aggregateSingleInt	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1764 of file python_metadata.cpp.

{
    AggregateOperation op;
    MDLabel label;
    PyObject *pyValue;

    if (PyArg_ParseTuple(args, "ii", &op, &label))
    {
        try
        {
            auto object = MDObject(label);
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->aggregateSingleInt(object, op, label);
            pyValue = getMDObjectValue(&object);
            return pyValue;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_append()

PyObject* MetaData_append	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 830 of file python_metadata.cpp.

{
    const auto *self = reinterpret_cast<MetaDataObject*>(obj);

    if (self != nullptr)
    {
        PyObject *input = nullptr;
        if (PyArg_ParseTuple(args, "O", &input))
        {
            try
            {
                if (PyUnicode_Check(input))
                   {
                      const char *str = PyUnicode_AsUTF8(input);
                      self->metadata->append(str);
                   }
                else if (FileName_Check(input))
                    self->metadata->append(FileName_Value(input));
                else
                    return nullptr;
                Py_RETURN_NONE;
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
                return nullptr;
            }
        }
    }
    return nullptr;
}

MetaData_clear()

PyObject* MetaData_clear	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1594 of file python_metadata.cpp.

{
    try
    {
        const auto *self = reinterpret_cast<MetaDataObject*>(obj);
        self->metadata->clear();
        Py_RETURN_NONE;
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
        return nullptr;
    }
}

MetaData_containsLabel()

PyObject* MetaData_containsLabel	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1298 of file python_metadata.cpp.

{
    int label;
    if (PyArg_ParseTuple(args, "i", &label))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            if (self->metadata->containsLabel((MDLabel) label))
                Py_RETURN_TRUE;
            else
                Py_RETURN_FALSE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_copyColumn()

PyObject* MetaData_copyColumn	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1448 of file python_metadata.cpp.

{
    int labelDst;
    int labelSrc;
    if (PyArg_ParseTuple(args, "ii", &labelDst, &labelSrc))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->copyColumn((MDLabel)labelDst, (MDLabel)labelSrc);
            Py_RETURN_TRUE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_copyColumnTo()

PyObject* MetaData_copyColumnTo	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 2310 of file python_metadata.cpp.

{
    int labelDst;
    int labelSrc;
    PyObject * pyMd;
    if (PyArg_ParseTuple(args, "Oii", &pyMd, &labelDst, &labelSrc))
    {
        try
        {
            if (MetaData_Check(pyMd))
            {
                MetaData_Value(obj).copyColumnTo(MetaData_Value(pyMd), (MDLabel)labelDst, (MDLabel)labelSrc);
                Py_RETURN_TRUE;
            }
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_dealloc()

void MetaData_dealloc

(

MetaDataObject *

self

)

Definition at line 490 of file python_metadata.cpp.

{
    self->~MetaDataObject(); // Call the destructor
    Py_TYPE(self)->tp_free((PyObject*)self);
}

MetaData_fillConstant()

PyObject* MetaData_fillConstant	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1360 of file python_metadata.cpp.

{
    int label;
    PyObject *pyValue = nullptr;
    PyObject *pyStr = nullptr;
    if (PyArg_ParseTuple(args, "i|O", &label, &pyValue))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            if ((pyStr = PyObject_Str(pyValue)) != nullptr)
            {
                const char * str = PyUnicode_AsUTF8(pyStr);
                if (str != nullptr)
                {
                    self->metadata->fillConstant((MDLabel) label, str);
                    Py_RETURN_TRUE;
                }
            }
            PyErr_SetString(PyXmippError, "MetaData.fillConstant: couldn't convert second argument to string");
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_fillExpand()

PyObject* MetaData_fillExpand	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1391 of file python_metadata.cpp.

{
    int label;

    if (PyArg_ParseTuple(args, "i", &label))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->fillExpand((MDLabel) label);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_fillRandom()

PyObject* MetaData_fillRandom	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1413 of file python_metadata.cpp.

{
    int label;
    double op1 = 0.;
    double op2 = 0.;
    double op3 = 0.;
    PyObject *pyValue = nullptr;
    PyObject *pyStr = nullptr;

    if (PyArg_ParseTuple(args, "iOdd|d", &label, &pyValue, &op1, &op2, &op3))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            if ((pyStr = PyObject_Str(pyValue)) != nullptr)
            {
                const char * str = PyUnicode_AsUTF8(pyStr);
                if (str != nullptr)
                {
                    self->metadata->fillRandom((MDLabel) label, str, op1, op2, op3);
                    Py_RETURN_TRUE;
                }
            }
            PyErr_SetString(PyXmippError, "MetaData.fillRandom: couldn't convert second argument to string");
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_firstObject()

PyObject* MetaData_firstObject	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 870 of file python_metadata.cpp.

{
    const auto *self = reinterpret_cast<MetaDataObject*>(obj);
    return PyLong_FromUnsignedLong(self->metadata->firstRowId());
}

MetaData_getActiveLabels()

PyObject* MetaData_getActiveLabels	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1213 of file python_metadata.cpp.

{
    try
    {
        const auto *self = reinterpret_cast<MetaDataObject*>(obj);
        std::vector<MDLabel> labels = self->metadata->getActiveLabels();
        int size = labels.size();
        PyObject * list = PyList_New(size);

        for (int i = 0; i < size; ++i)
            PyList_SetItem(list, i, PyLong_FromLong(labels.at(i)));

        return list;

    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}

MetaData_getColumnFormat()

PyObject* MetaData_getColumnFormat	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 934 of file python_metadata.cpp.

{
    try
    {
        const auto *self = reinterpret_cast<MetaDataObject*>(obj);
        if (self->metadata->isColumnFormat())
            Py_RETURN_TRUE;
        else
            Py_RETURN_FALSE;
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}

MetaData_getColumnValues()

PyObject* MetaData_getColumnValues	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1139 of file python_metadata.cpp.

{
    int label;
    if (PyArg_ParseTuple(args, "i", &label))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);

            std::vector<MDObject> v;
            self->metadata->getColumnValues((MDLabel) label,v);

            size_t size=v.size();
            PyObject * list = PyList_New(size);

            for (size_t i = 0; i < size; ++i)
                PyList_SetItem(list, i, getMDObjectValue(&(v[i])));

            return list;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_getComment()

PyObject* MetaData_getComment	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1963 of file python_metadata.cpp.

{
    const auto *self = reinterpret_cast<MetaDataObject*>(obj);
    return PyUnicode_FromString(self->metadata->getComment().c_str());
}

MetaData_getMaxStringLength()

PyObject* MetaData_getMaxStringLength	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1276 of file python_metadata.cpp.

{
    int label;
    if (PyArg_ParseTuple(args, "i", &label))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            int length = self->metadata->getMaxStringLength((MDLabel) label);

            return PyLong_FromLong(length);
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_getParsedLines()

PyObject* MetaData_getParsedLines	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 900 of file python_metadata.cpp.

{
    try
    {
        const auto *self = reinterpret_cast<MetaDataObject*>(obj);
        return PyLong_FromUnsignedLong(self->metadata->getParsedLines());
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}

MetaData_getRow()

PyObject* MetaData_getRow	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1114 of file python_metadata.cpp.

{
    if (size_t objectId = BAD_OBJID; PyArg_ParseTuple(args, "k", &objectId))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            const auto row = self->metadata->getRowSql(objectId);
            PyObject *d = PyODict_New();
            for (const auto *o : row) {
                PyODict_SetItem(d, PyLong_FromLong(o->label), getMDObjectValue(o));
            }
            return d;
        }
        catch (const XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_getValue()

PyObject* MetaData_getValue	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1083 of file python_metadata.cpp.

{
    int label;
    size_t objectId = BAD_OBJID;
    PyObject *pyValue;

    if (PyArg_ParseTuple(args, "ik", &label, &objectId))
    {
        try
        {
            auto object = MDObject((MDLabel) label);
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            if (self->metadata->getValue(object, objectId))
            {
                pyValue = getMDObjectValue(&object);
                return pyValue;
            }
            else
            {
                Py_RETURN_NONE;
            }
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_importObjects()

PyObject* MetaData_importObjects	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1702 of file python_metadata.cpp.

{
    PyObject *pyMd = nullptr;
    PyObject *pyQuery = nullptr;

    if (PyArg_ParseTuple(args, "OO", &pyMd, &pyQuery))
    {
        try
        {
            if (!MetaData_Check(pyMd))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::importObjects: Expecting MetaData as first argument");
                return nullptr;
            }
            if (!MDQuery_Check(pyQuery))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::importObjects: Expecting MDQuery as second argument");
                return nullptr;
            }
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->importObjects(MetaData_Value(pyMd),
                                          MDQuery_Value(pyQuery));
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_intersection()

PyObject* MetaData_intersection	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 2108 of file python_metadata.cpp.

{
    int label;
    PyObject *pyMd = nullptr;

    if (PyArg_ParseTuple(args, "Oi", &pyMd, &label))
    {
        try
        {
            if (!MetaData_Check(pyMd))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::intersection: Expecting MetaData as first argument");
                return nullptr;
            }
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->intersection(MetaData_Value(pyMd), (MDLabel) label);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_isEmpty()

PyObject* MetaData_isEmpty	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 916 of file python_metadata.cpp.

{
    try
    {
        const auto *self = reinterpret_cast<MetaDataObject*>(obj);
        if (self->metadata->isEmpty())
            Py_RETURN_TRUE;
        else
            Py_RETURN_FALSE;
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}

MetaData_iter()

PyObject* MetaData_iter

(

PyObject *

obj

)

Iteration functions

Definition at line 1611 of file python_metadata.cpp.

{
    try
    {
        auto *self = reinterpret_cast<MetaDataObject*>(obj);
        self->iter = std::make_unique<MetaDataDb::id_iterator>(self->metadata->ids().begin());
        self->iter_end = std::make_unique<MetaDataDb::id_iterator>(self->metadata->ids().end());
        Py_INCREF(self);
        return (PyObject *) self;
        //return Py_BuildValue("l", self->metadata->iteratorBegin());
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}

MetaData_iternext()

PyObject* MetaData_iternext

(

PyObject *

obj

)

Definition at line 1629 of file python_metadata.cpp.

{
    try
    {
        const auto *self = reinterpret_cast<MetaDataObject*>(obj);
        if (*(self->iter) == *(self->iter_end))
            return nullptr;
        size_t objId = **(self->iter);
        ++(*self->iter);
        //type format should be "n" instead of "i" but I put i since python 2.4 does not support n
        return Py_BuildValue("i", objId);
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}

MetaData_join1()

PyObject* MetaData_join1	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1991 of file python_metadata.cpp.

{
    int labelLeft;
    PyObject *pyMdLeft = nullptr;
    PyObject *pyMdright = nullptr;
    JoinType jt=LEFT;

    if (PyArg_ParseTuple(args, "OOi|i", &pyMdLeft, &pyMdright, &labelLeft, &jt))
    {
        try
        {
            if (!MetaData_Check(pyMdLeft))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::join: Expecting MetaData as first argument");
                return nullptr;
            }
            if (!MetaData_Check(pyMdright))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::join: Expecting MetaData as second argument");
                return nullptr;
            }
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->join1(MetaData_Value(pyMdLeft),
                                      MetaData_Value(pyMdright),
                                      (MDLabel) labelLeft,
                                      (JoinType) jt);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_join2()

PyObject* MetaData_join2	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 2031 of file python_metadata.cpp.

{
    int labelLeft;
    int labelRight;
    PyObject *pyMdLeft = nullptr;
    PyObject *pyMdright = nullptr;
    JoinType jt=LEFT;

    if (PyArg_ParseTuple(args, "OOii|i", &pyMdLeft, &pyMdright, &labelLeft,&labelRight, &jt))
    {
        try
        {
            if (!MetaData_Check(pyMdLeft))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::join: Expecting MetaData as first argument");
                return nullptr;
            }
            if (!MetaData_Check(pyMdright))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::join: Expecting MetaData as second argument");
                return nullptr;
            }
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->join2(MetaData_Value(pyMdLeft),
                                  MetaData_Value(pyMdright),
                                  (MDLabel) labelLeft,
                                  (MDLabel) labelRight, (JoinType) jt);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_joinNatural()

PyObject* MetaData_joinNatural	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 2072 of file python_metadata.cpp.

{
    PyObject *pyMdLeft = nullptr;
    PyObject *pyMdright = nullptr;

    if (PyArg_ParseTuple(args, "OO", &pyMdLeft, &pyMdright))
    {
        try
        {
            if (!MetaData_Check(pyMdLeft))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::joinNatural: Expecting MetaData as first argument");
                return nullptr;
            }
            if (!MetaData_Check(pyMdright))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::joinNatural: Expecting MetaData as second argument");
                return nullptr;
            }
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->joinNatural(MetaData_Value(pyMdLeft),
                                  MetaData_Value(pyMdright));
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_lastObject()

PyObject* MetaData_lastObject	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 877 of file python_metadata.cpp.

{
    const auto *self = reinterpret_cast<MetaDataObject*>(obj);
    return PyLong_FromUnsignedLong(self->metadata->lastRowId());
}

MetaData_makeAbsPath()

PyObject* MetaData_makeAbsPath	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1573 of file python_metadata.cpp.

{
    int label = (MDLabel) MDL_IMAGE;
    if (PyArg_ParseTuple(args, "|i", &label))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->makeAbsPath((MDLabel) label);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_merge()

PyObject* MetaData_merge	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1914 of file python_metadata.cpp.

{
    PyObject *pyMd = nullptr;

    if (PyArg_ParseTuple(args, "O", &pyMd))
    {
        try
        {
            if (!MetaData_Check(pyMd))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::merge: Expecting MetaData as first argument");
                return nullptr;
            }
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->merge(MetaData_Value(pyMd));
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_new()

PyObject* MetaData_new	(	PyTypeObject *	type,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 498 of file python_metadata.cpp.

{
    auto *self = (MetaDataObject*)type->tp_alloc(type, 0);

    if (self != nullptr)
    {
        PyObject *input = nullptr;
        PyObject *pyStr = nullptr;
        PyArg_ParseTuple(args, "|O", &input);
        if (input != nullptr)
        {
            try
            {
                if (MetaData_Check(input))
                    self->metadata = std::make_unique<MetaDataDb>(MetaData_Value(input));
                else if ((pyStr = PyObject_Str(input)) != nullptr)
                {
                    const char *str = PyUnicode_AsUTF8(pyStr);
                    self->metadata = std::make_unique<MetaDataDb>(str);
                }
                else
                {
                    PyErr_SetString(PyExc_TypeError,
                                    "MetaData_new: Bad string value for reading metadata");
                    return nullptr;
                }
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
                return nullptr;
            }
        }
        else
        {
            self->metadata = std::make_unique<MetaDataDb>();
        }
    }
    return (PyObject *)self;
}

MetaData_operate()

PyObject* MetaData_operate	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 2137 of file python_metadata.cpp.

{
    char * str = nullptr;

    if (PyArg_ParseTuple(args, "s", &str))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->operate(str);
            //free(str);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    // free(str);
    return nullptr;
}

MetaData_print()

int MetaData_print	(	PyObject *	obj,
		FILE *	fp,
		int	flags
	)

Definition at line 539 of file python_metadata.cpp.

{
    try
    {
        const auto *self = reinterpret_cast<MetaDataObject*>(obj);
        std::stringstream ss;
        self->metadata->write(ss);
        fprintf(fp, "%s", ss.str().c_str());
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
        return -1;
    }
    return 0;
}

MetaData_randomize()

PyObject* MetaData_randomize	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 2188 of file python_metadata.cpp.

{
    PyObject *pyMd = nullptr;

    if (PyArg_ParseTuple(args, "O", &pyMd))
    {
        try
        {
            if (!MetaData_Check(pyMd))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::randomize: Expecting MetaData as first argument");
                return nullptr;
            }
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->randomize(MetaData_Value(pyMd));
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_read()

PyObject* MetaData_read	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 604 of file python_metadata.cpp.

{
    const auto *self = reinterpret_cast<MetaDataObject*>(obj);

    if (self != nullptr)
    {
        PyObject *list = nullptr; //list can be a list of labels or maxRows
        PyObject *input = nullptr;
        PyObject *pyStr = nullptr;
        const char *str = nullptr;
        if (PyArg_ParseTuple(args, "O|O", &input,  &list))
        {
            try
            {
                if ((pyStr = PyObject_Str(input)) != nullptr)
                {
                    str = PyUnicode_AsUTF8(pyStr);
                    if (list != nullptr)
                    {
                        if (PyList_Check(list))
                        {
                            size_t size = PyList_Size(list);
                            PyObject * item = nullptr;
                            int iValue = 0;
                            MDLabelVector vValue(size);
                            for (size_t i = 0; i < size; ++i)
                            {
                                item = PyList_GetItem(list, i);
                                if (!PyLong_Check(item))
                                {
                                    PyErr_SetString(PyExc_TypeError,
                                                    "MDL labels must be integers (MDLABEL)");
                                    return nullptr;
                                }
                                iValue = PyLong_AsLong(item);
                                vValue[i] = (MDLabel)iValue;
                            }
                            self->metadata->read(str,&vValue);
                        }
                        else if (PyLong_Check(list)){
                          auto maxRows = (size_t) PyLong_AsLong(list);
                          self->metadata->setMaxRows(maxRows);
                          self->metadata->read(str);
                        }
                    }
                    else
                        self->metadata->read(str);
                    Py_RETURN_NONE;
                }
                else
                    return nullptr;
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
                return nullptr;
            }
        }
    }
    return nullptr;
}

MetaData_readBlock()

PyObject* MetaData_readBlock	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 754 of file python_metadata.cpp.

{
    const auto *self = reinterpret_cast<MetaDataObject*>(obj);

    if (self != NULL)
    {
        PyObject *input = NULL;
        PyObject *blockName = NULL;
        PyObject *pyStr = NULL;
        PyObject *pyStrBlock = NULL;
        const char *str = NULL;
        const char *strBlock = NULL;
        if (PyArg_ParseTuple(args, "OO", &input, &blockName))
        {
            try
            {
                pyStr = PyObject_Str(input);
                pyStrBlock = PyObject_Str(blockName);
                if ((NULL != pyStr) && (NULL != pyStrBlock))
                {
                    str = PyUnicode_AsUTF8(pyStr);
                    strBlock = PyUnicode_AsUTF8(pyStrBlock);
                    self->metadata->read((std::string) strBlock + "@" + str,
                                         NULL);
                    Py_RETURN_NONE;
                }
                else
                    return NULL;
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
                return NULL;
            }
        }
    }
    return NULL;
}

MetaData_readPlain()

PyObject* MetaData_readPlain	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 668 of file python_metadata.cpp.

{
    const auto *self = reinterpret_cast<MetaDataObject*>(obj);

    if (self != NULL)
    {
        PyObject *input = NULL;
        PyObject *input2 = NULL;
        PyObject *pyStr = NULL;
        PyObject *pyLabels = NULL;
        PyObject *pySep = NULL;
        const char *str = NULL;
        const char *labels = NULL;

        if (PyArg_ParseTuple(args, "OO|O", &input, &input2, &pySep))
        {
            try
            {
                pyStr = PyObject_Str(input);
                pyLabels = PyObject_Str(input2);

                if ((NULL != pyStr) && (NULL != pyLabels))
                {
                    str = PyUnicode_AsUTF8(pyStr);
                    labels = PyUnicode_AsUTF8(pyLabels);

                    self->metadata->readPlain(str, labels);
                    Py_RETURN_NONE;
                }
                else
                    return NULL;
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
                return NULL;
            }
        }
    }
    return NULL;
}

MetaData_removeDisabled()

PyObject* MetaData_removeDisabled	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1556 of file python_metadata.cpp.

{
    try
    {
        const auto *self = reinterpret_cast<MetaDataObject*>(obj);
        self->metadata->removeDisabled();
        Py_RETURN_NONE;
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}

MetaData_removeDuplicates()

PyObject* MetaData_removeDuplicates	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

remove Duplicate rows Metadata

Definition at line 1678 of file python_metadata.cpp.

{
    int label = MDL_UNDEFINED;

    if (PyArg_ParseTuple(args, "|i", &label))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            MetaDataDb MDaux = *(self->metadata);
            self->metadata->clear();
            self->metadata->removeDuplicates(MDaux, (MDLabel)label);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_removeLabel()

PyObject* MetaData_removeLabel	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1060 of file python_metadata.cpp.

{
    int label;
    if (PyArg_ParseTuple(args, "i", &label))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            if (self->metadata->removeLabel((MDLabel) label))
                Py_RETURN_TRUE;
            else
                Py_RETURN_FALSE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_removeObjects()

PyObject* MetaData_removeObjects	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1528 of file python_metadata.cpp.

{
    PyObject *pyQuery = nullptr;

    if (PyArg_ParseTuple(args, "O", &pyQuery))
    {
        try
        {
            if (!MDQuery_Check(pyQuery))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::removeObjects: Expecting MDQuery as second arguments");
                return nullptr;
            }
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->removeObjects(MDQuery_Value(pyQuery));
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_renameColumn()

PyObject* MetaData_renameColumn	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1470 of file python_metadata.cpp.

{
    PyObject * oldLabel = nullptr;
    PyObject * newLabel = nullptr;
    if (PyArg_ParseTuple(args, "OO", &oldLabel, &newLabel))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            if(PyLong_Check ( oldLabel ) && PyLong_Check ( newLabel ))
            {
                self->metadata->renameColumn((MDLabel) PyLong_AsLong (oldLabel),
                                             (MDLabel) PyLong_AsLong (newLabel));
            }
            else if (PyList_Check(oldLabel)&& PyList_Check ( newLabel ))
            {
                size_t size = PyList_Size(oldLabel);
                PyObject * itemOld = nullptr;
                PyObject * itemNew = nullptr;
                int iOldValue = 0;
                int iNewValue = 0;
                std::vector<MDLabel> vOldValue(size);
                std::vector<MDLabel> vNewValue(size);
                for (size_t i = 0; i < size; ++i)
                {
                    itemOld = PyList_GetItem(oldLabel, i);
                    itemNew = PyList_GetItem(newLabel, i);
                    if (!PyLong_Check(itemOld) || !PyLong_Check(itemNew))
                    {
                        PyErr_SetString(PyExc_TypeError,
                                        "MDL labels must be integers (MDLABEL)");
                        return nullptr;
                    }
                    iOldValue = PyLong_AsLong(itemOld);
                    iNewValue = PyLong_AsLong(itemNew);
                    vOldValue[i] = (MDLabel)iOldValue;
                    vNewValue[i] = (MDLabel)iNewValue;
                }
                //self->metadata->read(str,&vValue);
                self->metadata->renameColumn(vOldValue,vNewValue);
            }

            Py_RETURN_TRUE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_replace()

PyObject* MetaData_replace	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 2161 of file python_metadata.cpp.

{
    int label;
    char * oldStr = nullptr;
    char * newStr = nullptr;
    if (PyArg_ParseTuple(args, "iss", &label, &oldStr, &newStr))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->replace((MDLabel)label, oldStr, newStr);
            //free(oldStr);
            //free(newStr);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    //free(oldStr);
    //free(newStr);
    return nullptr;
}

MetaData_repr()

PyObject* MetaData_repr

(

PyObject *

obj

)

Definition at line 558 of file python_metadata.cpp.

{
    const auto *self = reinterpret_cast<MetaDataObject*>(obj);
    return PyUnicode_FromString(
               (self->metadata->getFilename() + "(MetaData)").c_str());
}

MetaData_RichCompareBool()

PyObject* MetaData_RichCompareBool	(	PyObject *	obj,
		PyObject *	obj2,
		int	opid
	)

Definition at line 567 of file python_metadata.cpp.

{
    const auto *self = reinterpret_cast<MetaDataObject*>(obj);
    auto *md2 = (MetaDataObject*) obj2;
    int result = -1;

    if (self != nullptr && md2 != nullptr)
    {
        try
        {
            if (opid == Py_EQ)
                {
                    if (*(self->metadata) == *(md2->metadata))
                        Py_RETURN_TRUE;
                    else
                       Py_RETURN_FALSE;
                }
            else if  (opid == Py_NE)
                    {
                        if (*(self->metadata) == *(md2->metadata))
                            Py_RETURN_FALSE;
                        else
                            Py_RETURN_TRUE;
                    }
            else
                return Py_NotImplemented;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_selectPart()

PyObject* MetaData_selectPart	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 2216 of file python_metadata.cpp.

{
    auto label=(int)MDL_OBJID;
    size_t start;
    size_t numberOfObjects;
    PyObject *pyMd = nullptr;

    if (PyArg_ParseTuple(args, "Okk|i", &pyMd, &start, &numberOfObjects, &label))
    {
        try
        {
            if (!MetaData_Check(pyMd))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::selectPart: Expecting MetaData as first argument");
                return nullptr;
            }
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->selectPart(MetaData_Value(pyMd), start, numberOfObjects, (MDLabel) label);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_setColumnFormat()

PyObject* MetaData_setColumnFormat	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 952 of file python_metadata.cpp.

{
    PyObject *input = nullptr;
    if (PyArg_ParseTuple(args, "O", &input))
    {
        try
        {
            if (PyBool_Check(input))
            {
                const auto *self = reinterpret_cast<MetaDataObject*>(obj);
                self->metadata->setColumnFormat(input == Py_True);
                Py_RETURN_NONE;
            }
            else
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::setColumnFormat: Expecting boolean value");
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_setColumnValues()

PyObject* MetaData_setColumnValues	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1169 of file python_metadata.cpp.

{
    int label;
    PyObject *list = nullptr;
    if (PyArg_ParseTuple(args, "iO", &label, &list))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            size_t size=PyList_Size(list);
            bool addObjects=(self->metadata->size()==0);
            MDObject object((MDLabel) label);
            if (addObjects)
            {
                for (size_t i=0; i<size; ++i)
                {
                    size_t id=self->metadata->addObject();
                    setMDObjectValue(&object,PyList_GetItem(list,i));
                    self->metadata->setValue(object,id);
                }
            }
            else
            {
                if (self->metadata->size()!=size)
                    PyErr_SetString(PyXmippError, "Metadata size different from list size");
                size_t i=0;
                for (size_t objId : self->metadata->ids())
                {
                    setMDObjectValue(&object,PyList_GetItem(list,i++));
                    self->metadata->setValue(object, objId);
                }
            }
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
            return nullptr;
        }
    }
    Py_RETURN_NONE;
}

MetaData_setComment()

PyObject* MetaData_setComment	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1942 of file python_metadata.cpp.

{
    char * str = nullptr;
    if (PyArg_ParseTuple(args, "s", &str))
    {
        try
        {
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->setComment(str);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_setRow()

PyObject* MetaData_setRow	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1005 of file python_metadata.cpp.

{
    PyObject *dict;
    if (size_t objectId = BAD_OBJID; PyArg_ParseTuple(args, "Ok", &dict, &objectId)) {
        try
        {
            PyObject *key;
            PyObject *value;
            Py_ssize_t pos = 0;
            MDRowVec row;
            while (PyDict_Next(dict, &pos, &key, &value)) {
                auto label = PyLong_AsLong(key);
                auto object = createMDObject(static_cast<int>(label), value);
                row.setValue(*object);
            }
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->setRow(row, objectId);
            Py_RETURN_TRUE;
        }
        catch (const XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_setValue()

PyObject* MetaData_setValue	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 979 of file python_metadata.cpp.

{
    int label;
    size_t objectId = BAD_OBJID;
    PyObject *pyValue; //Only used to skip label and value

    if (PyArg_ParseTuple(args, "iOk", &label, &pyValue, &objectId))
    {
        try
        {
            auto object = createMDObject(label, pyValue);
            if (!object)
                return nullptr;
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->setValue(*object, objectId);
            Py_RETURN_TRUE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_setValueCol()

PyObject* MetaData_setValueCol	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1034 of file python_metadata.cpp.

{
    int label;
    PyObject *pyValue; //Only used to skip label and value

    if (PyArg_ParseTuple(args, "iO", &label, &pyValue))
    {
        try
        {
            auto object = createMDObject(label, pyValue);
            if (!object)
                return nullptr;
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->setValueCol(*object);
            Py_RETURN_TRUE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_size()

PyObject* MetaData_size	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 884 of file python_metadata.cpp.

{
    try
    {
        const auto *self = reinterpret_cast<MetaDataObject*>(obj);
        return PyLong_FromUnsignedLong(self->metadata->size());
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return nullptr;
}

MetaData_sort()

PyObject* MetaData_sort	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Sort Metadata

Definition at line 1649 of file python_metadata.cpp.

{
    int label = MDL_IMAGE;
    auto *ascPy = Py_True;
    bool asc=true;
    int limit   = -1;
    int offset  =  0;
    if (PyArg_ParseTuple(args, "|iOii", &label,&ascPy,&limit,&offset))
    {
        try
        {
            if (PyBool_Check(ascPy))
                asc = (ascPy == Py_True);
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            MetaDataDb MDaux = *(self->metadata);
            self->metadata->clear();
            self->metadata->sort(MDaux, (MDLabel) label,asc,limit,offset);
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_unionAll()

PyObject* MetaData_unionAll	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1886 of file python_metadata.cpp.

{
    PyObject *pyMd = nullptr;

    if (PyArg_ParseTuple(args, "O", &pyMd))
    {
        try
        {
            if (!MetaData_Check(pyMd))
            {
                PyErr_SetString(PyExc_TypeError,
                                "MetaData::unionAll: Expecting MetaData as first argument");
                return nullptr;
            }
            const auto *self = reinterpret_cast<MetaDataObject*>(obj);
            self->metadata->unionAll(MetaData_Value(pyMd));
            Py_RETURN_NONE;
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }
    return nullptr;
}

MetaData_write()

PyObject* MetaData_write	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 795 of file python_metadata.cpp.

{
    const auto *self = reinterpret_cast<MetaDataObject*>(obj);
    WriteModeMetaData wmd;
    wmd = MD_OVERWRITE;
    if (self != NULL)
    {
        PyObject *input = nullptr;
        PyObject *pyStr = nullptr;
        const char *str = NULL;
        if (PyArg_ParseTuple(args, "O|i", &input, &wmd))
        {
            try
            {
                if ((pyStr = PyObject_Str(input)) != NULL)
                {
                    str = PyUnicode_AsUTF8(pyStr);
                    self->metadata->write(str, (WriteModeMetaData) wmd);
                    Py_RETURN_NONE;
                }
                else
                    return NULL;
            }
            catch (XmippError &xe)
            {
                PyErr_SetString(PyXmippError, xe.what());
                return NULL;
            }
        }
    }
    return NULL;
}

setMDObjectValue()

void setMDObjectValue	(	MDObject *	obj,
		PyObject *	pyValue
	)

Definition at line 2333 of file python_metadata.cpp.

{
    try
    {
        if (PyLong_Check(pyValue))
            obj->setValue((int)PyLong_AS_LONG(pyValue));
        else if (PyLong_Check(pyValue))
            obj->setValue((size_t)PyLong_AsUnsignedLong(pyValue));
        else if (PyUnicode_Check(pyValue))
            {
              const char * str = PyUnicode_AsUTF8(PyObject_Str(pyValue));
              obj->setValue(std::string(str));
            }
        else if (FileName_Check(pyValue))
            obj->setValue((*((FileNameObject*)pyValue)->filename));
        else if (PyFloat_Check(pyValue))
            obj->setValue(PyFloat_AS_DOUBLE(pyValue));
        else if (PyBool_Check(pyValue))
            obj->setValue((pyValue == Py_True));
        else if (PyList_Check(pyValue))
        {
            size_t size = PyList_Size(pyValue);
            PyObject * item = nullptr;
            double dValue = 0.;
            std::vector<double> vValue(size);
            for (size_t i = 0; i < size; ++i)
            {
                item = PyList_GetItem(pyValue, i);
                if (!PyFloat_Check(item))
                {
                    PyErr_SetString(PyExc_TypeError,
                                    "Vectors are only supported for double");
                }
                dValue = PyFloat_AS_DOUBLE(item);
                vValue[i] = dValue;
            }
            obj->setValue(vValue);
        }
        else
            PyErr_SetString(PyExc_TypeError, "Unrecognized type to create MDObject");
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
}

xmipp_addLabelAlias()

PyObject* xmipp_addLabelAlias	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 205 of file python_metadata.cpp.

{


    int label;
    int type;
    PyObject *input = nullptr;
    PyObject *pyStr = nullptr;
    PyObject *pyStr1 = nullptr;
    auto *pyReplace = Py_False;
    const char *str =nullptr;
    bool replace = true;


    if (PyArg_ParseTuple(args, "iO|Oi", &label, &input, &pyReplace, &type))
    {
        try
        {
            if ((pyStr = PyObject_Str(input)) != nullptr &&
                (PyBool_Check(pyReplace)))
            {
                replace = pyReplace == Py_True;
                str = PyUnicode_AsUTF8(pyStr);
                MDL::addLabelAlias((MDLabel)label,(String)str, replace, (MDLabelType)type);
                Py_RETURN_NONE;
            }
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }

    return nullptr;
}

xmipp_getBlocksInMetaDataFile()

PyObject* xmipp_getBlocksInMetaDataFile	(	PyObject *	obj,
		PyObject *	args
	)

Definition at line 1236 of file python_metadata.cpp.

{
    PyObject *input;
    const char *fileName = NULL;
    FileName fn;
    StringVector blocks;

    try
    {
        if (PyArg_ParseTuple(args, "O", &input))
        {

            if (PyUnicode_Check(input)){
                 fileName = PyUnicode_AsUTF8(input);
                 fn = fileName;
            }
            else if (FileName_Check(input))
                fn = FileName_Value(input);
            else
                return NULL;
            getBlocksInMetaDataFile(fn, blocks);
            int size = blocks.size();
            PyObject * list = PyList_New(size);

            for (int i = 0; i < size; ++i)
            {
                PyList_SetItem(list, i, PyUnicode_FromString(blocks[i].c_str()));
            }
            return list;
        }
    }
    catch (XmippError &xe)
    {
        PyErr_SetString(PyXmippError, xe.what());
    }
    return NULL;
}

xmipp_getNewAlias()

PyObject* xmipp_getNewAlias	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 243 of file python_metadata.cpp.

{


    int type;
    PyObject *input = nullptr;
    PyObject *pyStr = nullptr;
    PyObject *pyStr1 = nullptr;
    const char *str = nullptr;


    if (PyArg_ParseTuple(args, "Oi", &input, &type))
    {
        try
        {
            if ((pyStr = PyObject_Str(input)) != nullptr )
            {
                str = PyUnicode_AsUTF8(pyStr);
                return PyLong_FromLong(MDL::getNewAlias((String)str, (MDLabelType)type));
                
            }
        }
        catch (XmippError &xe)
        {
            PyErr_SetString(PyXmippError, xe.what());
        }
    }

    return nullptr;
}

xmipp_MDValueEQ()

PyObject* xmipp_MDValueEQ	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 144 of file python_metadata.cpp.

{
    return createMDValueRelational(args, EQ);
}

xmipp_MDValueGE()

PyObject* xmipp_MDValueGE	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 174 of file python_metadata.cpp.

{
    return createMDValueRelational(args, GE);
}

xmipp_MDValueGT()

PyObject* xmipp_MDValueGT	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 168 of file python_metadata.cpp.

{
    return createMDValueRelational(args, GT);
}

xmipp_MDValueLE()

PyObject* xmipp_MDValueLE	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 162 of file python_metadata.cpp.

{
    return createMDValueRelational(args, LE);
}

xmipp_MDValueLT()

PyObject* xmipp_MDValueLT	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 156 of file python_metadata.cpp.

{
    return createMDValueRelational(args, LT);
}

xmipp_MDValueNE()

PyObject* xmipp_MDValueNE	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 150 of file python_metadata.cpp.

{
    return createMDValueRelational(args, NE);
}

xmipp_MDValueRange()

PyObject* xmipp_MDValueRange	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 180 of file python_metadata.cpp.

{
    int label;
    int limit = -1;
    int offset = 0;
    auto orderLabel = (int) MDL_OBJID;
    PyObject *pyValue1;
    PyObject *pyValue2; //Only used to skip label and value

    if (PyArg_ParseTuple(args, "iOO|iii", &label, &pyValue1, &pyValue2, &limit,
                         &offset, &orderLabel))
    {
        auto object1 = createMDObject(label, pyValue1);
        auto object2 = createMDObject(label, pyValue2);
        if (!object1 || !object2)
            return nullptr;
        auto *pyQuery = (MDQueryObject*)PyObject_CallFunction((PyObject*)&MDQueryType, "");
        pyQuery->query = std::make_unique<MDValueRange>(*object1, *object2, limit, offset,
                                          (MDLabel) orderLabel);
        return (PyObject *) pyQuery;
    }
    return nullptr;
}

xmipp_MDValueRelational()

PyObject* xmipp_MDValueRelational	(	PyObject *	obj,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 138 of file python_metadata.cpp.

{
    return createMDValueRelational(args, -1);
}

Variable Documentation

MDQuery_methods

PyMethodDef MDQuery_methods[]

Definition at line 77 of file python_metadata.cpp.

MDQueryType

PyTypeObject MDQueryType

Definition at line 35 of file python_metadata.cpp.

MetaData_methods

PyMethodDef MetaData_methods[]

Definition at line 276 of file python_metadata.cpp.

MetaDataType

PyTypeObject MetaDataType

Definition at line 446 of file python_metadata.cpp.

PyXmippError

PyObject* PyXmippError

Definition at line 47 of file xmippmodule.cpp.