py_object.hpp

Go to the documentation of this file.

//
// Created by Aman LaChapelle on 11/14/16.
//
// pytorch-inference
// Copyright (c) 2016 Aman LaChapelle
// Full license at pytorch-inference/LICENSE.txt
//

#ifndef PY_CPP_PYMODULE_HPP
#define PY_CPP_PYMODULE_HPP

#include <Python.h>
#include <stdexcept>
#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <type_traits>

#ifndef PYCPP_WHICH_PYTHON
  #define PYCPP_WHICH_PYTHON "/usr/local/bin/ipython"
#endif

#ifndef PYCPP_PY_HOME
  #define PYCPP_PY_HOME "../.."
#endif

namespace pycpp {

  class py_object;

  static std::string which_python = PYCPP_WHICH_PYTHON;

  static std::string python_home = PYCPP_PY_HOME;

  inline PyObject *to_python(const std::vector<int> &vec) {
    long n = vec.size();
    PyObject *pyvec = PyList_New(n);
    for (int i = 0; i < n; i++) {
      PyList_SetItem(pyvec, i, PyLong_FromLong((long) vec[i]));
    }
    return pyvec;
  }

  inline PyObject *to_python(std::vector<int> &&vec) {
    long n = vec.size();
    PyObject *pyvec = PyList_New(n);
    for (int i = 0; i < n; i++) {
      PyList_SetItem(pyvec, i, PyLong_FromLong((long) vec[i]));
    }
    return pyvec;
  }

  inline PyObject *to_python(const std::vector<long> &vec) {
    long n = vec.size();
    PyObject *pyvec = PyList_New(n);
    for (int i = 0; i < n; i++) {
      PyList_SetItem(pyvec, i, PyLong_FromLong((long) vec[i]));
    }
    return pyvec;
  }

  inline PyObject *to_python(std::vector<long> &&vec) {
    long n = vec.size();
    PyObject *pyvec = PyList_New(n);
    for (int i = 0; i < n; i++) {
      PyList_SetItem(pyvec, i, PyLong_FromLong((long) vec[i]));
    }
    return pyvec;
  }

  inline PyObject *to_python(const std::vector<double> &vec) {
    long n = vec.size();
    PyObject *pyvec = PyList_New(n);
    for (int i = 0; i < n; i++) {
      PyList_SetItem(pyvec, i, PyFloat_FromDouble((double) vec[i]));
    }
    return pyvec;
  }

  inline PyObject *to_python(std::vector<double> &&vec) {
    long n = vec.size();
    PyObject *pyvec = PyList_New(n);
    for (int i = 0; i < n; i++) {
      PyList_SetItem(pyvec, i, PyFloat_FromDouble((double) vec[i]));
    }
    return pyvec;
  }

  inline PyObject *to_python(const std::vector<float> &vec) {
    long n = vec.size();
    PyObject *pyvec = PyList_New(n);
    for (int i = 0; i < n; i++) {
      PyList_SetItem(pyvec, i, PyFloat_FromDouble((double) vec[i]));
    }
    return pyvec;
  }

  inline PyObject *to_python(std::vector<float> &&vec) {
    long n = vec.size();
    PyObject *pyvec = PyList_New(n);
    for (int i = 0; i < n; i++) {
      PyList_SetItem(pyvec, i, PyFloat_FromDouble((double) vec[i]));
    }
    return pyvec;
  }

  inline PyObject *to_python(const std::vector<std::string> &vec) {
    long n = vec.size();
    PyObject *pyvec = PyList_New(n);
    for (int i = 0; i < n; i++) {
      PyList_SetItem(pyvec, i, PyUnicode_FromString(vec[i].c_str()));
    }
    return pyvec;
  }

  inline PyObject *to_python(std::vector<std::string> &&vec) {
    long n = vec.size();
    PyObject *pyvec = PyList_New(n);
    for (int i = 0; i < n; i++) {
      PyList_SetItem(pyvec, i, PyUnicode_FromString(vec[i].c_str()));
    }
    return pyvec;
  }

  inline PyObject *to_python(const int &num){
    return PyLong_FromLong((long)num);
  }

  inline PyObject *to_python(int &&num){
    return PyLong_FromLong((long)num);
  }

  inline PyObject *to_python(const long &num){
    return PyLong_FromLong(num);
  }

  inline PyObject *to_python(long &&num){
    return PyLong_FromLong(num);
  }

  inline PyObject *to_python(const float &num){
    return PyFloat_FromDouble((double)num);
  }

  inline PyObject *to_python(float &&num){
    return PyFloat_FromDouble((double)num);
  }

  inline PyObject *to_python(const double &num){
    return PyFloat_FromDouble(num);
  }

  inline PyObject *to_python(double &&num){
    return PyFloat_FromDouble(num);
  }

  inline PyObject *to_python(const std::string &str){
    return PyUnicode_FromString(str.c_str());
  }

  inline PyObject *to_python(std::string &&str){
    return PyUnicode_FromString(str.c_str());
  }

  inline PyObject *to_python(const char *str){
    return PyUnicode_FromString(str);
  }

  inline PyObject *to_python(char *str){
    return PyUnicode_FromString(str);
  }

  inline void from_python(PyObject *pyobj, std::string &cppobj) {
    cppobj = std::string(PyBytes_AsString(pyobj));
  };

  inline void from_python(PyObject *pyobj, int &cppobj) {
    cppobj = (int) PyLong_AsLong(pyobj);
  };

  inline void from_python(PyObject *pyobj, long &cppobj) {
    cppobj = PyLong_AsLong(pyobj);
  };

  inline void from_python(PyObject *pyobj, float &cppobj) {
    cppobj = (float) PyFloat_AsDouble(pyobj);
  };

  inline void from_python(PyObject *pyobj, double &cppobj) {
    cppobj = PyFloat_AsDouble(pyobj);
  };

  inline void from_python(PyObject *pyobj, std::vector<std::string> &cppobj) {
    PyList_Check(pyobj);
    size_t len = PyList_Size(pyobj);
    PyObject *item;
    for (size_t i = 0; i < len; i++){
      PyList_GetItem(item, i);
      cppobj.push_back(PyBytes_AsString(item));
    }
  };

  inline void from_python(PyObject *pyobj, std::vector<int> &cppobj) {
    PyList_Check(pyobj);
    size_t len = PyList_Size(pyobj);
    PyObject *item;
    for (size_t i = 0; i < len; i++){
      PyList_GetItem(item, i);
      cppobj.push_back((int)PyLong_AsLong(item));
    }
  };

  inline void from_python(PyObject *pyobj, std::vector<long> &cppobj) {
    PyList_Check(pyobj);
    size_t len = PyList_Size(pyobj);
    PyObject *item;
    for (size_t i = 0; i < len; i++){
      PyList_GetItem(item, i);
      cppobj.push_back(PyLong_AsLong(item));
    }
  };

  inline void from_python(PyObject *pyobj, std::vector<float> &cppobj) {
    PyList_Check(pyobj);
    size_t len = PyList_Size(pyobj);
    PyObject *item;
    for (size_t i = 0; i < len; i++){
      PyList_GetItem(item, i);
      cppobj.push_back((float)PyFloat_AsDouble(item));
    }
  };

  inline void from_python(PyObject *pyobj, std::vector<double> &cppobj) {
    PyList_Check(pyobj);
    size_t len = PyList_Size(pyobj);
    PyObject *item;
    for (size_t i = 0; i < len; i++){
      PyList_GetItem(item, i);
      cppobj.push_back(PyFloat_AsDouble(item));
    }
  };

  inline PyObject *make_tuple(std::initializer_list<PyObject *> l){

    int num = l.size();

    if (num == 0){
      return PyTuple_Pack(0);
    }

    PyObject *out = PyTuple_New(num);

    for (int i = 0; i < num; i++){
      PyTuple_SetItem(out, i, *(l.begin()+i));
    }

    return out;
  }

  inline PyObject *make_tuple(std::vector<PyObject *> l){

    int num = l.size();

    if (num == 0){
      return PyTuple_Pack(0);
    }

    PyObject *out = PyTuple_New(num);

    for (int i = 0; i < num; i++){
      PyTuple_SetItem(out, i, *(l.begin()+i));
    }

    return out;
  }

  inline PyObject *make_dict(std::initializer_list<PyObject *> l){
    assert(l.size()%2 == 0);

    int num = l.size();

    if (num == 0){
      return nullptr;
    }

    PyObject *out = PyDict_New();

    for (int i = 0; i < num; i+=2){
      PyDict_SetItem(out, *(l.begin()+i), *(l.begin()+i+1));
    }

    return out;
  }

  class py_object {
    PyObject *me;

  private:

    inline void check_callable(PyObject *obj) {
      if (PyCallable_Check(obj)) {
        return;
      } else {
        std::string object(PyBytes_AsString(PyObject_Repr(obj)));
        throw std::runtime_error("Object " + object + " not callable");
      }
    }

  public:

    py_object(){};

    py_object(PyObject *obj){
      me = std::move(obj);
      Py_XDECREF(obj);
    }

    py_object(const std::string &package,
              const std::string &py_home = ""){

      if (!py_home.empty()){
        setenv("PYTHONPATH", py_home.c_str(), 1);
      }
      else {
        setenv("PYTHONPATH", pycpp::python_home.c_str(), 1);
      }

      std::wstring wp = std::wstring(pycpp::which_python.begin(), pycpp::which_python.end());
      Py_SetProgramName((wchar_t *) wp.c_str());

      if (!Py_IsInitialized()){
        Py_Initialize();
      }

      me = PyImport_ImportModule(package.c_str());
      if (PyErr_Occurred()){
        PyErr_Print();
        throw std::runtime_error("Unable to import package");
      }

    }

    ~py_object(){
      Py_Finalize();
    }

    inline PyObject *operator()(const std::string &attr){
      return this->operator()(attr, {});
    }

    inline PyObject *operator()(const std::string &attr,
                                PyObject *args,
                                PyObject *kwargs = NULL){
      assert(PyTuple_Check(args));
      assert(kwargs == NULL || kwargs == nullptr || PyDict_Check(kwargs));

      PyObject *callable = PyObject_GetAttrString(me, attr.c_str());

      check_callable(callable);

      PyObject *retval = PyObject_Call(callable, args, kwargs);
      if (PyErr_Occurred()){
        PyErr_Print();
      }

      Py_CLEAR(args);
      Py_CLEAR(callable);

      if (kwargs)
        PyDict_Clear(kwargs);

      Py_CLEAR(kwargs);

      return retval;
    }

    inline PyObject *operator()(const std::string &attr,
                                std::initializer_list<PyObject *> arg) {

      PyObject *args = pycpp::make_tuple(arg);

      PyObject *callable = PyObject_GetAttrString(me, attr.c_str());

      check_callable(callable);

      PyObject *retval = PyObject_Call(callable, args, NULL);
      if (PyErr_Occurred()){
        PyErr_Print();
      }

      Py_CLEAR(args);
      Py_CLEAR(callable);

      return retval;
    }

    inline PyObject *operator()(const std::string &attr,
                                std::initializer_list<PyObject *> arg,
                                std::initializer_list<PyObject *> kwarg) {

      PyObject *args = pycpp::make_tuple(arg);
      PyObject *kwargs = pycpp::make_dict(kwarg);

      PyObject *callable = PyObject_GetAttrString(me, attr.c_str());

      check_callable(callable);

      PyObject *retval = PyObject_Call(callable, args, kwargs);
      if (PyErr_Occurred()){
        PyErr_Print();
      }

      Py_CLEAR(args);
      Py_CLEAR(kwargs);
      Py_CLEAR(callable);

      return retval;
    }

    template<typename T>
    inline void operator()(const std::string &attr,
                           T &cpp_retval){
      (*this)(attr, cpp_retval, {});

      return;
    }

    template<typename T>
    inline void operator()(const std::string &attr,
                           T &cpp_retval,
                           PyObject *args,
                           PyObject *kwargs = NULL){
      assert(PyTuple_Check(args));
      assert(kwargs == NULL || kwargs == nullptr || PyDict_Check(kwargs));

      PyObject *callable = PyObject_GetAttrString(me, attr.c_str());

      check_callable(callable);

      PyObject *retval = PyObject_Call(callable, args, kwargs);
      if (PyErr_Occurred()){
        PyErr_Print();
      }

      Py_CLEAR(args);
      Py_CLEAR(callable);
      PyDict_Clear(kwargs);
      Py_CLEAR(kwargs);

      from_python(retval, cpp_retval);

      return;
    }
    
    template<typename T>
    inline void operator()(const std::string &attr,
                           T &cpp_retval,
                           std::initializer_list<PyObject *> arg){
      
      PyObject *args = pycpp::make_tuple(arg);

      PyObject *callable = PyObject_GetAttrString(me, attr.c_str());

      check_callable(callable);

      PyObject *retval = PyObject_Call(callable, args, NULL);
      if (PyErr_Occurred()){
        PyErr_Print();
      }

      Py_CLEAR(args);
      Py_CLEAR(callable);

      from_python(retval, cpp_retval);

      return;
      
    }

    template<typename T>
    inline void operator()(const std::string &attr,
                           T &cpp_retval,
                           std::initializer_list<PyObject *> arg,
                           std::initializer_list<PyObject *> kwarg){

      PyObject *args = pycpp::make_tuple(arg);
      PyObject *kwargs = pycpp::make_dict(kwarg);

      PyObject *callable = PyObject_GetAttrString(me, attr.c_str());

      check_callable(callable);

      PyObject *retval = PyObject_Call(callable, args, kwargs);
      if (PyErr_Occurred()){
        PyErr_Print();
      }

      Py_CLEAR(args);
      Py_CLEAR(kwargs);
      Py_CLEAR(callable);

      from_python(retval, cpp_retval);

      return;

    }

    py_object py_class(const std::string &klass, PyObject *args = NULL, PyObject *kwargs = NULL){

      assert(args == NULL || args == nullptr || PyTuple_Check(args));
      assert(kwargs == NULL || kwargs == nullptr || PyDict_Check(kwargs));

      py_object out;

      PyObject *pyclassname = PyObject_GetAttrString(me, klass.c_str());

      if (pyclassname){
        check_callable(pyclassname);
        out.me = PyObject_Call(pyclassname, args, kwargs);
      }

      if (PyErr_Occurred()){
        PyErr_Print();
      }

      if (out.me){ //if the class imported and it's not NULL
        return out;
      }
      else{ //else throw an error
        throw std::runtime_error("Class not imported!");
      }
    }

  };

} //pycpp


#endif //PY_CPP_PYMODULE_HPP