comparison PyTypeInterface.cpp @ 51:c1e4f706ca9a

Fix numpy version incompatibility issues and updated some example plugins.

 	(EXCEPT FOR TEMPORARY PYTHON OBJECTS)!  						 */
 
 PyTypeInterface::PyTypeInterface() : 
 	m_strict(false),
 	m_error(false),
+	m_numpyInstalled(false),
 	error(m_error) // const public reference for easy access
 {
 }
 
 PyTypeInterface::~PyTypeInterface()

 		//TODO: check for limits here (same on most systems)
 		return (float) PyFloat_AS_DOUBLE(pyValue);
 	
 	if (pyValue == NULL)
 	{
-		setValueError("Error while converting float object.",m_strict);
+		setValueError("Error while converting object " + PyValue_Get_TypeName(pyValue) + " to float. ",m_strict);
 		return 0.0;		
 	}
 		
 	// in strict mode we will not try harder
 	if (m_strict) {
-		setValueError("Strict conversion error: object is not float.",m_strict);
+		setValueError("Strict conversion error: object" + PyValue_Get_TypeName(pyValue) +" is not float.",m_strict);
 		return 0.0;
 	}
 
 	// convert other objects supporting the number protocol
 	if (PyNumber_Check(pyValue))

 			ListElement = (string) PyString_AsString(PyObject_Str(pyString));
 			Output.push_back(ListElement);
 		}
 		return Output;
 	}
-#ifdef _DEBUG
-	cerr << "PyTypeInterface::PyValue_To_StringVector: Warning: Value is not list of strings." << endl;
-#endif
+
+// #ifdef _DEBUG
+// 	cerr << "PyTypeInterface::PyValue_To_StringVector: Warning: Value is not list of strings." << endl;
+// #endif
 
 	/// Assume a single value that can be casted as string 
 	/// this allows to write e.g. Feature.label = 5.2 instead of ['5.2']
 	Output.push_back(PyValue_To_String(pyList));
 	if (m_error) {

 std::vector<float> 
 PyTypeInterface::PyValue_To_FloatVector (PyObject *pyValue) const 
 {
 
 #ifdef HAVE_NUMPY
+if (m_numpyInstalled) 
+{
 	// there are four types of values we may receive from a numpy process:
 	// * a python scalar, 
 	// * an array scalar, (e.g. numpy.float32)
 	// * an array with nd = 0  (0D array)
 	// * an array with nd > 0

 	}
 
 	/// numpy array
 	if (PyArray_CheckExact(pyValue)) 
 		return PyArray_To_FloatVector(pyValue);
-
+}
 #endif
 
 	/// python list of floats (backward compatible)
 	if (PyList_Check(pyValue)) {
 		return PyList_To_FloatVector(pyValue);

 	Output.push_back(PyValue_To_Float(pyValue));
 	if (m_error) {
 		std::string msg = "Value is not list or array of floats nor can be casted as float. ";
 		setValueError(msg,m_strict);
 #ifdef _DEBUG
-	cerr << "PyTypeInterface::PyValue_To_FloatVector failed." << msg << endl;
+	cerr << "PyTypeInterface::PyValue_To_FloatVector failed. " << msg << endl;
 #endif
 	}
 	return Output;
 }
 

 		Output.push_back(ListElement);
 	}
 	return Output;
 }
 
-#ifdef HAVE_NUMPY
+// if numpy is not installed this will not be called, 
+// therefor we do not check again
+#ifdef HAVE_NUMPY 
 std::vector<float> 
 PyTypeInterface::PyArray_To_FloatVector (PyObject *pyValue) const 
 {
 	std::vector<float> Output;
 	

 	}
 }
 #endif
 
 
-/// FeatureSet (an integer map of OutputLists)
+/// FeatureSet (an integer map of FeatureLists)
 Vamp::Plugin::FeatureSet
 PyTypeInterface::PyValue_To_FeatureSet(PyObject* pyValue) const
 {
 	Vamp::Plugin::FeatureSet rFeatureSet;
 

 		}
 		if (!m_errorQueue.empty()) m_error = true; 
 		return rFeatureSet;
 	}
 
-	/// accept no return values
+	/// accept None return values
 	if (pyValue == Py_None) return rFeatureSet;
 
 	/// give up
 	std::string msg = "Unsupported return type. Expected list or vampy.FeatureSet(). ";
 	setValueError(msg,m_strict);