JSON2Python.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_TOOLBOXES_PYTHON_JSON2PYTHON_H_
#define _MIRA_TOOLBOXES_PYTHON_JSON2PYTHON_H_

#include <python/BoostPythonWrapper.h>

#include <utils/Foreach.h>
#include <utils/Time.h>
#include <json/JSON.h>

namespace mira { namespace python {


json::Value to_json(boost::python::object o)
{
    try
    {
        if ( o.ptr() == Py_None )
            return json::Value();
        else if ( o.ptr() == Py_False )
            return json::Value(false);
        else if ( o.ptr() == Py_True )
            return json::Value(true);
        else if ( boost::python::extract<int64>(o).check() )
            return json::Value(boost::python::extract<int64>(o)());
        else if ( boost::python::extract<double>(o).check() )
            return json::Value(boost::python::extract<double>(o)());
        else if (boost::python::extract<boost::python::list>(o).check()
                    || boost::python::extract< boost::python::tuple >(o).check()
                    || PyAnySet_Check(o.ptr()))
        {
                if ( PyAnySet_Check(o.ptr()) )
                    o = boost::python::list(o);
                std::size_t len = boost::python::len(o);
                json::Array array;
                array.reserve(len);
                for (std::size_t p = 0; p != len; ++p)
                    array.push_back(to_json(o[p]));
                return array;
        } else if (boost::python::extract<boost::python::dict>(o).check())
        {
            json::Object object;
            // in Python 3 dict.keys() returns an iterable/view and not a list
            boost::python::object keys = boost::python::list(o.attr("keys")());
            // TODO: Find out why this is done backwards
            for (std::size_t len = boost::python::len( keys ); len > 0; --len)
            {
                boost::python::object key = keys[len - 1];
                std::string keystr;
                // need to check for keys in unicode format
                if (PyType_IsSubtype((PyTypeObject*)key.ptr()->ob_type, &PyUnicode_Type)) {
                    boost::python::str strFromUnicode(key);
                    strFromUnicode.encode("utf-8");
                    keystr = boost::python::extract<std::string>(strFromUnicode)();
                } else
                    keystr = boost::python::extract<std::string>(key)();

                object[keystr] = boost::python::extract<json::Value>(o[key])();
            }
            return object;
        } else if (boost::python::extract<mira::Time>(o).check()) {
            auto time = boost::python::extract<mira::Time>(o)();
            return json::Value(time.toUnixNS());
        } else if (boost::python::extract<std::string>(o).check())
            return json::Value(boost::python::extract<std::string>(o)());
        else if (boost::python::extract<json::Object>(o).check())
            return boost::python::extract<json::Object>(o)();
        else if (boost::python::extract<json::Array>(o).check())
            return boost::python::extract<json::Array>(o)();
        else {
            // need an explicit type check for PyUnicode here as the str() conversion might work
            // for types we do not actually want to handle in this way
            if (PyType_IsSubtype((PyTypeObject*)o.ptr()->ob_type, &PyUnicode_Type)) {
                boost::python::str strFromUnicode(o);
                strFromUnicode.encode("utf-8");
                if (boost::python::extract<std::string>(strFromUnicode).check())
                    return json::Value(boost::python::extract<std::string>(strFromUnicode)());
            }
        }

        // just throw if we did not return yet
        MIRA_THROW(XNotImplemented, "python::to_json(boost::python::object) got object of unsupported type");

    } catch (Exception& e)
    {
        if (o.ptr() && o.ptr()->ob_type && o.ptr()->ob_type->tp_name)
            MIRA_RETHROW(e, "Whilst converting a Python object of type "
                         << o.ptr()->ob_type->tp_name << " to a json::Value");
        MIRA_RETHROW(e, "Whilst converting a Python object of unknown type to a json::Value");
    }
}

boost::python::object from_json(const json::Value& j)
{
    try
    {
        if ( j.is_null() )
            return boost::python::object();
        else if (j.type() == json_spirit::bool_type)
            return boost::python::object(j.get_bool());
        else if (j.type() == json_spirit::int_type)
            return boost::python::object(j.get_int64());
        else if (j.type() == json_spirit::real_type)
            return boost::python::object(j.get_real());
        else if (j.type() == json_spirit::str_type)
            return boost::python::object(j.get_str());
        else if (j.type() == json_spirit::array_type) {
            boost::python::list l;
            foreach(auto e, j.get_array())
                l.append(from_json(e));
            return l;
        }
        else if (j.type() == json_spirit::obj_type) {
            return boost::python::object(j.get_obj());
        }
        else
            MIRA_THROW(XNotImplemented, "python::from_json(const json::Value&) got json value of unsupported type");
    } catch (Exception& e)
    {
        MIRA_RETHROW(e, "Whilst converting a json:Value to its equivalent Python type\n"
                     << json::write(j));
    }
}


}} // namespace

#endif