PyObjConvUtils.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <boost/python/object.hpp>
#include <boost/python/list.hpp>
#include <boost/python/tuple.hpp>
#include <boost/python/dict.hpp>
#include <boost/python/extract.hpp>
#include <boost/variant.hpp>
 
#include <map>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
 
namespace Belle2 {
  class Path;
 
  namespace PyObjConvUtils {
 
    /*
     * We need forward declarations here, because otherwise the compiler ends up calling
     * the wrong function!
     */
    bool checkPythonObject(const boost::python::object& pyObject, bool);
    bool checkPythonObject(const boost::python::object& pyObject, float);
    bool checkPythonObject(const boost::python::object& pyObject, double);
    bool checkPythonObject(const boost::python::object& pyObject, int);
    bool checkPythonObject(const boost::python::object& pyObject, unsigned int);
    bool checkPythonObject(const boost::python::object& pyObject, unsigned long int);
    bool checkPythonObject(const boost::python::object& pyObject, const std::string&);
    template<typename Key, typename Value>
    bool checkPythonObject(const boost::python::object& pyObject, const std::map<Key, Value>&);
    template<typename Value>
    bool checkPythonObject(const boost::python::object& pyObject, const std::vector<Value>&);
    template<typename Value>
    bool checkPythonObject(const boost::python::object& pyObject, const std::set<Value>&);
    template<typename... Types>
    bool checkPythonObject(const boost::python::object& pyObject, const std::tuple<Types...>&);
    template<typename... Types>
    bool checkPythonObject(const boost::python::object& pyObject, const boost::variant<Types...>&);
    template<typename Type>
    bool checkPythonObject(const boost::python::object& pyObject, const std::optional<Type>&);
 
    template<typename Scalar>
    Scalar convertPythonObject(const boost::python::object& pyObject, Scalar);
    template<typename Key, typename Value>
    std::map<Key, Value> convertPythonObject(const boost::python::object& pyObject, const std::map<Key, Value>&);
    template<typename Value>
    std::vector<Value> convertPythonObject(const boost::python::object& pyObject, const std::vector<Value>&);
    template<typename Value>
    std::set<Value> convertPythonObject(const boost::python::object& pyObject, const std::set<Value>&);
    template<typename... Types>
    std::tuple<Types...> convertPythonObject(const boost::python::object& pyObject, const std::tuple<Types...>&);
    template<typename... Types>
    boost::variant<Types...> convertPythonObject(const boost::python::object& pyObject, const boost::variant<Types...>&);
    template<typename Type>
    std::optional<Type> convertPythonObject(const boost::python::object& pyObject, const std::optional<Type>&);
 
    template<typename Scalar>
    boost::python::object convertToPythonObject(const Scalar& value);
    template<typename Value>
    boost::python::list convertToPythonObject(const std::vector<Value>& vector);
    template<typename Value>
    boost::python::object convertToPythonObject(const std::set<Value>& set);
    template<typename Key, typename Value>
    boost::python::dict convertToPythonObject(const std::map<Key, Value>& map);
    template<typename... Types>
    boost::python::tuple convertToPythonObject(const std::tuple<Types...>& tuple);
    template<typename... Types>
    boost::python::object convertToPythonObject(const boost::variant<Types...>& tuple);
    template<typename Type>
    boost::python::object convertToPythonObject(const std::optional<Type>& optional);
 
    template<typename T> struct Type;
    template<typename T> struct Type<std::vector<T> >;
    template<typename T> struct Type<std::set<T>>;
    template<typename A, typename B> struct Type<std::map<A, B> >;
    template<typename... Types> struct Type<std::tuple<Types...> >;
    template<typename... Types> struct Type<boost::variant<Types...> >;
    template<> struct Type<int>;
    template<> struct Type<bool>;
    template<> struct Type<float>;
    template<> struct Type<double>;
    template<> struct Type<std::string>;
 
    template< typename T, typename... Types> struct VariadicType;
    template< typename T> struct VariadicType<T> {  static std::string name() { return Type<T>::name(); } };
    template< typename T, typename... Types> struct VariadicType {
      static std::string name()
      {
        return Type<T>::name() + ", " + VariadicType<Types...>::name();
      }
    };
 
    template<typename T> struct Type {  static std::string name() { return "???";} };
    template<typename T> struct Type<std::vector<T> > {  static std::string name() { return std::string("list(") + Type<T>::name() + ")"; } };
    template<typename T> struct Type<std::set<T>> {  static std::string name() { return std::string("set(") + Type<T>::name() + ")"; }};
    template<typename A, typename B> struct Type<std::map<A, B> > {  static std::string name() { return std::string("dict(") + Type<A>::name() + " -> " + Type<B>::name() + ")"; } };
 
    template<> struct Type<unsigned int> {  static std::string name() { return "unsigned int"; } };
    template<> struct Type<unsigned long int> {  static std::string name() { return "unsigned long int"; } };
    template<> struct Type<int> {  static std::string name() { return "int"; } };
    template<> struct Type<bool> {  static std::string name() { return "bool"; } };
    template<> struct Type<float> {  static std::string name() { return "float"; } };
    template<> struct Type<double> {  static std::string name() { return "float"; } };
    template<> struct Type<std::string> {  static std::string name() { return "str"; } };
 
    template<typename T> struct Type<std::optional<T>> {  static std::string name() { return Type<T>::name() + " or None"; } };
 
    template<typename... Types> struct Type<std::tuple<Types...> > {  static std::string name() { return std::string("tuple(") + VariadicType<Types...>::name() + ")"; } };
 
    template<typename... Types> struct Type<boost::variant<Types...> > {  static std::string name() { return std::string("variant(") + VariadicType<Types...>::name() + ")"; } };
 
    template<> struct Type<std::shared_ptr<Path>> {
      static std::string name() { return std::string("Path"); }
    };
 
 
    template < size_t > struct SizeT { };
 
    inline bool checkPythonObject(const boost::python::object& pyObject, bool /*dispatch tag*/)
    {
      return PyBool_Check(pyObject.ptr());
    }
 
    inline bool checkPythonObject(const boost::python::object& pyObject, int /*dispatch tag*/)
    {
      return PyLong_CheckExact(pyObject.ptr());
    }
    inline bool checkPythonObject(const boost::python::object& pyObject, unsigned int /*dispatch tag*/)
    {
      return PyLong_CheckExact(pyObject.ptr());
    }
 
    inline bool checkPythonObject(const boost::python::object& pyObject, unsigned long int /*dispatch tag*/)
    {
      return PyLong_CheckExact(pyObject.ptr());
    }
 
    inline bool checkPythonObject(const boost::python::object& pyObject, float /*dispatch tag*/)
    {
      return PyFloat_CheckExact(pyObject.ptr());
    }
 
    inline bool checkPythonObject(const boost::python::object& pyObject, double /*dispatch tag*/)
    {
      return PyFloat_CheckExact(pyObject.ptr());
    }
 
    inline bool checkPythonObject(const boost::python::object& pyObject, const std::string& /*dispatch tag*/)
    {
      return PyUnicode_Check(pyObject.ptr());
    }
 
    template<typename Key, typename Value>
    bool checkPythonObject(const boost::python::object& pyObject, const std::map<Key, Value>& /*dispatch tag*/)
    {
      if (not PyDict_Check(pyObject.ptr())) return false;
      const boost::python::dict& pyDict = static_cast<const boost::python::dict&>(pyObject);
      boost::python::list keys = pyDict.keys();
      boost::python::list values = pyDict.values();
      for (int i = 0; i < boost::python::len(keys); ++i) {
        if (not checkPythonObject(keys[i], Key())) return false;
        if (not checkPythonObject(values[i], Value())) return false;
      }
      return true;
    }
 
    template<class Functor>
    bool iteratePythonObject(const boost::python::object& pyObject, Functor function)
    {
      boost::python::object iterator(boost::python::handle<>(PyObject_GetIter(pyObject.ptr())));
      PyObject* item{nullptr};
      // ok, loop over the iterator and check all elements
      while ((item = PyIter_Next(iterator.ptr()))) {
        boost::python::object obj{boost::python::handle<>(item)}; // to make sure we properly decref
        if (not function(obj)) return false;
      }
      return true;
    }
 
    template<typename Value>
    bool checkPythonObject(const boost::python::object& pyObject, const std::vector<Value>& /*dispatch tag*/)
    {
      if (not PyList_Check(pyObject.ptr())) return false;
      return iteratePythonObject(pyObject, [](const boost::python::object & element) {
        return checkPythonObject(element, Value());
      });
    }
 
    template<typename Value>
    bool checkPythonObject(const boost::python::object& pyObject, const std::set<Value>&)
    {
      if (not PyAnySet_Check(pyObject.ptr())) return false;
      return iteratePythonObject(pyObject, [](const boost::python::object & element) {
        return checkPythonObject(element, Value());
      });
    }
 
    template<typename... Types, std::size_t ... Is>
    bool CheckTuple(const std::tuple<Types...>& tuple, const boost::python::tuple& pyTuple,
                    std::index_sequence<Is...>)
    {
      return (... && checkPythonObject(pyTuple[Is], std::get<Is>(tuple)));
    }
 
    template<typename... Types>
    bool checkPythonObject(const boost::python::object& pyObject, const std::tuple<Types...>& tuple)
    {
      if (not PyTuple_Check(pyObject.ptr())) return false;
      const boost::python::tuple& pyTuple = static_cast<const boost::python::tuple&>(pyObject);
      return CheckTuple(tuple, pyTuple, std::index_sequence_for<Types ...>());
    }
 
    template<typename VariantType>
    bool CheckVariant(const VariantType&,
                      const boost::python::object&,
                      SizeT<0>)
    {
      return false;
    }
 
    template<typename... Types, size_t N>
    bool CheckVariant(const boost::variant<Types...>& variant,
                      const boost::python::object& pyObject,
                      SizeT<N>)
    {
      using Scalar = typename std::tuple_element < N - 1, std::tuple<Types...> >::type;
      if (checkPythonObject(pyObject, Scalar())) {
        return true;
      }
      return CheckVariant(variant, pyObject, SizeT < N - 1 > ());
    }
 
    template<typename... Types>
    bool checkPythonObject(const boost::python::object& pyObject, const boost::variant<Types...> variant)
    {
      return CheckVariant(variant, pyObject, SizeT<sizeof...(Types)>());
    }
 
    template<typename Type>
    bool checkPythonObject(const boost::python::object& pyObject, const std::optional<Type>&)
    {
      return pyObject.is_none() or checkPythonObject(pyObject, Type());
    }
 
    template<typename Scalar>
    boost::python::object convertToPythonObject(const Scalar& value)
    {
      return boost::python::object(value);
    }
 
    template<typename Value>
    boost::python::list convertToPythonObject(const std::vector<Value>& vector)
    {
      boost::python::list outputList;
      for (const auto& value : vector) {
        outputList.append(convertToPythonObject(value));
      }
      return outputList;
    }
 
    template<typename Value>
    boost::python::object convertToPythonObject(const std::set<Value>& set)
    {
      boost::python::object result(boost::python::handle<>(PySet_New(nullptr)));
      for (const auto& value : set) {
        PySet_Add(result.ptr(), convertToPythonObject(value).ptr());
      }
      return result;
    }
 
    template<typename Key, typename Value>
    boost::python::dict convertToPythonObject(const std::map<Key, Value>& map)
    {
      boost::python::dict outputDict;
      for (auto pair : map) {
        outputDict[convertToPythonObject(pair.first)] = convertToPythonObject(pair.second);
      }
      return outputDict;
    }
 
    template < typename TupleType >
    inline void GetTuple(const TupleType& tuple, boost::python::list& pyList)
    {
      GetTuple(tuple, pyList, SizeT<std::tuple_size<TupleType>::value>());
    }
 
    template < typename TupleType >
    inline void GetTuple(const TupleType&, boost::python::list&, SizeT<0>) { }
 
    template < typename TupleType, size_t N >
    inline void GetTuple(const TupleType& tuple, boost::python::list& pyList, SizeT<N>)
    {
      GetTuple(tuple, pyList, SizeT < N - 1 > ());
      pyList.append(convertToPythonObject(std::get < N - 1 > (tuple)));
    }
    template<typename... Types>
    boost::python::tuple convertToPythonObject(const std::tuple<Types...>& tuple)
    {
      boost::python::list outputList;
      GetTuple(tuple, outputList);
      boost::python::tuple outputTuple(outputList);
      return outputTuple;
    }
 
    class convertToPythonObjectVisitor : public boost::static_visitor<boost::python::object> {
    public:
      template<class T>
      boost::python::object operator()(const T& value) const
      {
        return convertToPythonObject(value);
      }
    };
 
    template<typename... Types>
    boost::python::object convertToPythonObject(const boost::variant<Types...>& variant)
    {
      return boost::apply_visitor(convertToPythonObjectVisitor(), variant);
    }
 
    template<typename Type>
    boost::python::object convertToPythonObject(const std::optional<Type>& optional)
    {
      if (optional) {
        return convertToPythonObject(*optional);
      } else {
        return boost::python::object();
      }
    }
 
    template<typename Scalar>
    Scalar convertPythonObject(const boost::python::object& pyObject, const Scalar)
    {
 
      Scalar tmpValue;
      boost::python::extract<Scalar> valueProxy(pyObject);
      if (valueProxy.check()) {
        tmpValue = static_cast<Scalar>(valueProxy);
      } else {
        throw std::runtime_error(std::string("Could not convert value: Expected type '") + Type<Scalar>::name() + "' instead of '" +
                                 pyObject.ptr()->ob_type->tp_name + "'.");
      }
      return tmpValue;
 
    }
 
    template<typename Value>
    std::vector<Value> convertPythonObject(const boost::python::object& pyObject, const std::vector<Value>&)
    {
 
      std::vector<Value> tmpVector;
      if (PyList_Check(pyObject.ptr()) or PyGen_Check(pyObject.ptr())) {
        iteratePythonObject(pyObject, [&tmpVector](const boost::python::object & element) {
          tmpVector.emplace_back(convertPythonObject(element, Value()));
          return true;
        });
      } else {
        tmpVector.emplace_back(convertPythonObject(pyObject, Value()));
      }
      return tmpVector;
    }
 
    template<typename Value>
    std::set<Value> convertPythonObject(const boost::python::object& pyObject, const std::set<Value>&)
    {
      std::set<Value> result;
      if (PyAnySet_Check(pyObject.ptr())) {
        iteratePythonObject(pyObject, [&result](const boost::python::object & element) {
          result.emplace(convertPythonObject(element, Value()));
          return true;
        });
      } else {
        result.emplace(convertPythonObject(pyObject, Value()));
      }
      return result;
    }
 
 
    template<typename Key, typename Value>
    std::map<Key, Value> convertPythonObject(const boost::python::object& pyObject, const std::map<Key, Value>&)
    {
      std::map<Key, Value> tmpMap;
      const boost::python::dict& pyDict = static_cast<const boost::python::dict&>(pyObject);
      boost::python::list keys = pyDict.keys();
 
      for (int i = 0; i < boost::python::len(keys); ++i) {
        Key key = convertPythonObject(keys[boost::python::object(i)], Key());
        Value value = convertPythonObject(pyDict[key], Value());
        tmpMap.insert(std::pair<Key, Value>(key, value));
      }
      return tmpMap;
    }
 
 
    template < typename TupleType >
    inline void SetTuple(TupleType& tuple, const boost::python::tuple& pyTuple)
    {
      static const unsigned N = std::tuple_size<TupleType>::value;
      if ((unsigned)boost::python::len(pyTuple) != N) {
        throw std::runtime_error(std::string("Given python tuple has length ") +
                                 std::to_string(boost::python::len(pyTuple)) +
                                 ", expected " + std::to_string(N));
      }
      SetTuple(tuple, pyTuple, SizeT<N>());
    }
 
    template < typename TupleType >
    inline void SetTuple(TupleType&, const boost::python::tuple&, SizeT<0>) { }
 
    template < typename TupleType, size_t N >
    inline void SetTuple(TupleType& tuple, const boost::python::tuple& pyTuple, SizeT<N>)
    {
      SetTuple(tuple, pyTuple, SizeT < N - 1 > ());
      std::get < N - 1 > (tuple) = convertPythonObject(pyTuple[N - 1], std::get < N - 1 > (tuple));
    }
    template<typename... Types>
    std::tuple<Types...> convertPythonObject(const boost::python::object& pyObject, const std::tuple<Types...>&)
    {
      std::tuple<Types...> tmpTuple;
      const boost::python::tuple& pyTuple = static_cast<const boost::python::tuple&>(pyObject);
      SetTuple(tmpTuple, pyTuple);
      return tmpTuple;
    }
 
    template <typename... Types>
    inline void SetVariant(boost::variant<Types...>&, const boost::python::object& pyObject, SizeT<0>)
    {
      throw std::runtime_error(std::string("Could not set module parameter: Expected type '") +
                               Type<boost::variant<Types...> >::name() + "' instead of '" +
                               pyObject.ptr()->ob_type->tp_name + "'.");
    }
 
    template < typename... Types, size_t N >
    inline void SetVariant(boost::variant<Types...>& variant, const boost::python::object& pyObject, SizeT<N>)
    {
      using Scalar = typename std::tuple_element < N - 1, std::tuple<Types...> >::type;
      if (checkPythonObject(pyObject, Scalar())) {
        try {
          Scalar value = convertPythonObject(pyObject, Scalar());
          variant = value;
          return;
        } catch (std::runtime_error& e) {
        }
      }
      // Conversion failed - try next type
      SetVariant(variant, pyObject, SizeT < N - 1 > ());
    }
    template<typename... Types>
    boost::variant<Types...> convertPythonObject(const boost::python::object& pyObject, const boost::variant<Types...>&)
    {
      boost::variant<Types...> tmpVariant;
      SetVariant(tmpVariant, pyObject, SizeT<sizeof...(Types)>());
      return tmpVariant;
    }
 
    template<typename Type>
    std::optional<Type> convertPythonObject(const boost::python::object& pyObject, const std::optional<Type>&)
    {
      std::optional<Type> tmpOptional = std::nullopt;
      if (!pyObject.is_none()) {
        tmpOptional = convertPythonObject(pyObject, Type());
      }
      return tmpOptional;
    }
  }
}