comparison native/PyPluginObject.cpp @ 102:216ed5a72c36

Some preliminary changes toward py2/3 compatibility (but the module load stuff remains quite a big deal)

 #define PY_ARRAY_UNIQUE_SYMBOL VAMPYHOST_ARRAY_API
 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
 #define NO_IMPORT_ARRAY
 #include "numpy/arrayobject.h"
 
+#if PY_MAJOR_VERSION < 3
+#include "intobject.h"
+#endif
+
 #include "structmember.h"
 
 #include "FloatConversion.h"
 #include "VectorConversion.h"
 #include "PyRealTime.h"

 
 static
 PyObject *
 pystr(const string &s)
 {
+#if PY_MAJOR_VERSION < 3
     return PyString_FromString(s.c_str());
+#else
+    return PyUnicode_FromString(s.c_str());
+#endif
+}
+
+static
+string
+py2str(PyObject *obj)
+{
+#if PY_MAJOR_VERSION < 3
+    return PyString_AsString(obj);
+#else
+    return PyBytes_AsString(PyUnicode_AsUTF8String(obj));
+#endif
 }
 
 PyObject *
 PyPluginObject_From_Plugin(Plugin *plugin)
 {

     pd->blockSize = 0;
     pd->stepSize = 0;
 
     PyObject *infodict = PyDict_New();
     PyDict_SetItemString
-        (infodict, "api_version", PyInt_FromLong(plugin->getVampApiVersion()));
-    PyDict_SetItemString
-        (infodict, "plugin_version", PyInt_FromLong(plugin->getPluginVersion()));
+        (infodict, "api_version", PyLong_FromLong(plugin->getVampApiVersion()));
+    PyDict_SetItemString
+        (infodict, "plugin_version", PyLong_FromLong(plugin->getPluginVersion()));
     PyDict_SetItemString
         (infodict, "identifier", pystr(plugin->getIdentifier()));
     PyDict_SetItemString
         (infodict, "name", pystr(plugin->getName()));
     PyDict_SetItemString

     PyDict_SetItemString
         (outdict, "description", pystr(desc.description));
     PyDict_SetItemString
         (outdict, "unit", pystr(desc.unit));
     PyDict_SetItemString
-        (outdict, "has_fixed_bin_count", PyInt_FromLong(desc.hasFixedBinCount));
+        (outdict, "has_fixed_bin_count", PyLong_FromLong(desc.hasFixedBinCount));
     if (desc.hasFixedBinCount) {
         PyDict_SetItemString
-            (outdict, "bin_count", PyInt_FromLong(desc.binCount));
+            (outdict, "bin_count", PyLong_FromLong(desc.binCount));
         if (!desc.binNames.empty()) {
             PyDict_SetItemString
                 (outdict, "bin_names", conv.PyValue_From_StringVector(desc.binNames));
         }
     }

             PyDict_SetItemString
                 (outdict, "is_quantized", Py_False);
         }
     }
     PyDict_SetItemString
-        (outdict, "sample_type", PyInt_FromLong((int)desc.sampleType));
+        (outdict, "sample_type", PyLong_FromLong((int)desc.sampleType));
     PyDict_SetItemString
         (outdict, "sample_rate", PyFloat_FromDouble(desc.sampleRate));
     PyDict_SetItemString
         (outdict, "has_duration", desc.hasDuration ? Py_True : Py_False);
     PyDict_SetItemString
-        (outdict, "output_index", PyInt_FromLong(ix));
+        (outdict, "output_index", PyLong_FromLong(ix));
     return outdict;
 }
 
 static PyObject *
 get_output(PyObject *self, PyObject *args)

     PyErr_Clear();
     
     Plugin::OutputList ol = pd->plugin->getOutputDescriptors();
 
     if (pyId) {
-        string id = PyString_AS_STRING(pyId);
+        string id = py2str(pyId);
         for (int i = 0; i < int(ol.size()); ++i) {
             if (ol[i].identifier == id) {
                 return convertOutput(ol[i], i);
             }
         }

         if (n >= 0 && n < int(ol.size())) {
             return convertOutput(ol[n], n);
         }
     }
 
-    PyErr_SetString(PyExc_StandardError,
+    PyErr_SetString(PyExc_Exception,
                     "unknown output id or output index out of range");
     return 0;
 }
 
 static PyObject *

 {
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
 
     if (!pd->isInitialised) {
-        PyErr_SetString(PyExc_StandardError,
+        PyErr_SetString(PyExc_Exception,
                         "Plugin has not been initialised");
         return 0;
     }
         
     pd->plugin->reset();

         return 0; }
 
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
 
-    string param = PyString_AS_STRING(pyParam);
+    string param = py2str(pyParam);
     
     if (!hasParameter(pd, param)) {
-        PyErr_SetString(PyExc_StandardError,
+        PyErr_SetString(PyExc_Exception,
                         (string("Unknown parameter id \"") + param + "\"").c_str());
         return 0;
     }
     
     float value = pd->plugin->getParameter(param);

         return 0; }
 
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
 
-    string param = PyString_AS_STRING(pyParam);
+    string param = py2str(pyParam);
     
     if (!hasParameter(pd, param)) {
-        PyErr_SetString(PyExc_StandardError,
+        PyErr_SetString(PyExc_Exception,
                         (string("Unknown parameter id \"") + param + "\"").c_str());
         return 0;
     }
 
     pd->plugin->setParameter(param, value);

     }
 
     Py_ssize_t pos = 0;
     PyObject *key, *value;
     while (PyDict_Next(dict, &pos, &key, &value)) {
+#if PY_MAJOR_VERSION >= 3
+        if (!key || !PyUnicode_CheckExact(key)) {
+#else
         if (!key || !PyString_CheckExact(key)) {
+#endif
             PyErr_SetString(PyExc_TypeError,
                             "Parameter dict keys must all have string type");
             return 0;
         }
         if (!value || !FloatConversion::check(value)) {
             PyErr_SetString(PyExc_TypeError,
                             "Parameter dict values must be convertible to float");
             return 0;
         }
-        string param = PyString_AS_STRING(key);
+        string param = py2str(key);
         if (paramIds.find(param) == paramIds.end()) {
-            PyErr_SetString(PyExc_StandardError,
+            PyErr_SetString(PyExc_Exception,
                             (string("Unknown parameter id \"") + param + "\"").c_str());
             return 0;
         }
         pd->plugin->setParameter(param, FloatConversion::convert(value));
     }

         return 0; }
 
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
 
-    pd->plugin->selectProgram(PyString_AS_STRING(pyParam));
+    pd->plugin->selectProgram(py2str(pyParam));
     return Py_True;
 }
 
 static
 PyObject *

                 }
 
                 PyList_SET_ITEM(pyFl, fli, pyF);
             }
 
-            PyObject *pyN = PyInt_FromLong(fno);
+            PyObject *pyN = PyLong_FromLong(fno);
             PyDict_SetItem(pyFs, pyN, pyFl);
         }
     }
     
     return pyFs;

 
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
 
     if (!pd->isInitialised) {
-        PyErr_SetString(PyExc_StandardError,
+        PyErr_SetString(PyExc_Exception,
                         "Plugin has not been initialised.");
         return 0;
     }
 
     int channels = pd->channels;

 {
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
 
     if (!pd->isInitialised) {
-        PyErr_SetString(PyExc_StandardError,
+        PyErr_SetString(PyExc_Exception,
                         "Plugin has not been initialised.");
         return 0;
     }
 
     Plugin::FeatureSet fs = pd->plugin->getRemainingFeatures();

 static PyObject *
 get_preferred_block_size(PyObject *self, PyObject *)
 {
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
-    return PyInt_FromLong(pd->plugin->getPreferredBlockSize());
+    return PyLong_FromLong(pd->plugin->getPreferredBlockSize());
 }
 
 static PyObject *
 get_preferred_step_size(PyObject *self, PyObject *)
 {
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
-    return PyInt_FromLong(pd->plugin->getPreferredStepSize());
+    return PyLong_FromLong(pd->plugin->getPreferredStepSize());
 }
 
 static PyObject *
 get_min_channel_count(PyObject *self, PyObject *)
 {
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
-    return PyInt_FromLong(pd->plugin->getMinChannelCount());
+    return PyLong_FromLong(pd->plugin->getMinChannelCount());
 }
 
 static PyObject *
 get_max_channel_count(PyObject *self, PyObject *)
 {
     PyPluginObject *pd = getPluginObject(self);
     if (!pd) return 0;
-    return PyInt_FromLong(pd->plugin->getMaxChannelCount());
+    return PyLong_FromLong(pd->plugin->getMaxChannelCount());
 }
     
 static PyObject *
 unload(PyObject *self, PyObject *)
 {