@wjakob would you mind activating TravisCI for this project?

@wjakob or @SylvainCorlay would you mind activating AppVeyor CI for this repo?

I have a class function that returns a nlohmann::json object that I would like to call directly in python.

Is there any way to use this function without having to explicitly do the conversion myself?

What I am currently doing is:

py::class_<myClass> (m, "myClass")
    .def (py::init<const char*> ())  
    .def ("getJSON", [] (const myClass& my_class) -> py::object {
        nl::json json_obj = my_class.getJSON ();
        py::object py_obj = json_obj; // convert to type already bound
        return py_obj;
    })
    ;

I am trying to achieve something like:

py::class_<myClass> (m, "myClass")
    .def (py::init<const char*> ())
    .def ("getJSON", &myClass::getJSON)
        ;

I tried to register a py::implicitly_convertible<py::object, nl::json> (); but it just works from python to C++, not the other way around.

I also tried defining a json binding class with:

py::class_<nl::json> (m, "json")
    .def (py::init<> ())
    .def (py::init<py::object> ())
     ;
py::implicitly_convertible<py::object, nl::json> ();

I also know that what would probably work is to return a py::object from myClass::getJSON as mentioned in #18. However, I would like to avoid myClass having to depend on a pybind11 implementation.

Hi,

sorry for being lame but I can't put together a complete working example with pybind11_json.
Here is what I need to do:

1.) I have a native C++ class like
class Foo {
public:
int member1;
int member2;
};

2.) I have the corresponding pybind11 class_ mapping which defines a "Foo" class and does ".def_readwrite" on "member1" and "member2"

3.) Now I need to have to create something which automatically makes it possible that from Python I could:

foo = Foo()
foo.member1 = 1
foo.member2 = 2
jsonFoo = json(foo)
print(jsonFoo) // This would print '{ member1 : 1, member2 : 2 }'

// ???
foo2 = json('{ member1: 4, member2 : 5}')
print(foo2.member1) // this would print 4
print(foo2.member2) // this would print 5

Is it possible at all? Or do I have to create Nlohmann boilerplate code to be able to "Jsonify" my "Foo" class?
What is the full workflow here to be able to serialize back and forther PyBind11 classes in Python?
Thanks,

p.s. I have tried using the "implicitly_convertible" trick

pythonbind::class_nl::json(mod, "Json")
.def(py::init<>())
.def(py::initpy::object());
py::implicitly_convertible<py::object, nl::json>();

and then from Python:

foo = Foo()
jsonFoo = Json(foo)
json.dumps(jsonFoo)

but that gives me "to_json not implemented for this type of object: xxxx_pybind11.Foo object at XXXXX"
(which I suppose is not a surprise, as the C++ PyBind classes are not iterable objects, hence you need to write
for each and every Pybind class its own Json converter, I suppose?)

When BUILD_TESTS=ON it builds the executable test_pybind11_json but 'make test' doesn't run it.

Adding support for the ordered_json type in addition to currently used json would be beneficial for users intending to preserve order of elements in the JSON structures.

For further discussion, see:
https://github.com/nlohmann/json#order-of-object-keys
nlohmann/json#2179
nlohmann/json#2258

P.S. Thank you for a great piece of software (we use it in https://github.com/open-atmos/PyPartMC/)

In some paths within py::object from_json(const nl::json& j) the returned object is returned via std::move(obj);. This triggers a redundant-move warning in GCC 12.1, as the move prevents copy elision.

During my app compilation, I got a multiple repetition of 2 warnings:

/Users/studio/maialib/core/external/pybind11_json/pybind11_json.hpp:57:20: note: 
      call 'std::move' explicitly to avoid copying
            return obj;
                   ^~~
                   std::move(obj)
/Users/studio/maialib/core/external/pybind11_json/pybind11_json.hpp:66:20: warning: 
      local variable 'obj' will be copied despite being returned by name
      [-Wreturn-std-move]
            return obj;
                   ^~~

Please, could you fix it to clean the terminal output compilation?

My System:

• Apple OS X Catalina 10.15.7
• Xcode Command Tools 11.5
• Pybind11 2.9.0
• Using CMake with C++17 flags enable

Obs.: This 2 warnings appear on OS X system only. I got no warnings on Windows and Linux.

When converting a nl::json object that contains the infinity to Python, infinity gets interpreted as an integer instead of a float. If I bind the following function

#include <cmath>

nl::json test() {
    return nl::json(INFINITY);
}

it returns -9223372036854775808 on the Python side instead of math.inf.

Hi Martin,

several projects that integrate pybind11 with other dependencies (abseil, basel, protobuf) are slated to move into the pybind organization (https://github.com/pybind/). I thought that this would also make sense for this project, which is both useful and popular. It's completely up to you, of course. If you would like to move, please let me know and I'll invite you to the organization.

Best,
Wenzel

As you can see in this topic #18, I can return a nlohmann::json from a Python function as a pybind11::object type.

Now, I'm trying to send a JSON as a input argument to my_func(), modify it and return it back in my Python script.

Example: C++ side

pybind11::object my_func(nlohmann::json& a)
{
    a["new"] = "new string";

    return a;
}

It compiles Ok, but when I tried to call this function inside my Python module, I got this error below:

Error: Python side

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: test(): incompatible function arguments. The following argument types are supported:
    1. (self: my_lib.MusicXML, arg0: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>) -> object

What I have to do to fix it?

Thank you,

Is possible to "register" support for serialize other kind of non trivial python object like pathlib.Path --> serialized as str?

Hi,

I must say I really like the idea of this utility to ease my parameters structures usage in Python. I encountered an issue with bound enumerations. I use enumerations quite a lot in C++ mainly in factories. I can easily have a nlohmann converters for them, I can easily bind them, but I'm lost when trying to have the two functionalities working together.

It's quite logic since the nlohmann json bindings expect classic types and I guess enumerations fall into a special structures. I tried to get how I could handle those errors but I struggle finding how I could do that.

#include 
#include "nlohmann/json.hpp"

// This is where I copied pybind11_json.hpp

#include "converters/json.h"
#define MODULE_NAME footest
namespace testing_pybind11_json {
enum class Foo : uint32_t { ZERO, ONE, TWO, THREE };

NLOHMANN_JSON_SERIALIZE_ENUM(Foo,

{{Foo::ZERO, "ZERO"},

{Foo::ONE, "ONE"},

{Foo::TWO, "TWO"},

{Foo::THREE, "THREE"}})
void print_json(const nlohmann::json &j) {

std::cout << std::endl << std::setw(4) << j.dump() << std::endl;

}
void print_dict(const py::dict &d) {

nlohmann::json j;

j = d;

std::cout << std::endl << std::setw(4) << j.dump() << std::endl;

}
} // namespace testing_pybind11_json
PYBIND11_MODULE(MODULE_NAME, m) {

Py_Initialize();

PyEval_InitThreads();
py::enum_<testing_pybind11_json::Foo>(m, "Foo")
    .value("ZERO", testing_pybind11_json::Foo::ZERO)
    .value("ONE", testing_pybind11_json::Foo::ONE)
    .value("TWO", testing_pybind11_json::Foo::TWO)
    .value("THREE", testing_pybind11_json::Foo::THREE);
m.def("print_json", &testing_pybind11_json::print_json);
m.def("print_dict", &testing_pybind11_json::print_dict);

}

import footest
import pytest
@pytest.mark.module("binding.utils")

def pytestcase_testing_pybind11_print_json():

footest.print_json({'a': 1, 'b': 2})

footest.print_json({'a': 1, 'b': 2, 'c': footest.Foo.ONE})
@pytest.mark.module("binding.utils")

def pytestcase_testing_pybind11_print_dict():

footest.print_dict({'a': 1, 'b': 2})

footest.print_dict({'a': 1, 'b': 2, 'c': footest.Foo.ONE})

    @pytest.mark.module("binding.utils")
    def pytestcase_testing_pybind11_print_json():
        mci.print_json({'a': 1, 'b': 2})
>       mci.print_json({'a': 1, 'b': 2, 'c': mci.Foo.ONE})
E       TypeError: print_json(): incompatible function arguments. The following argument types are supported:
E           1. (arg0: json) -> None
E       
E       Invoked with: {'a': 1, 'b': 2, 'c': <Foo.ONE: 1>}

sdk/modules/computational_imaging/python/tests/bindings/calibration_pytest.py:148: TypeError

    @pytest.mark.module("binding.utils")
    def pytestcase_testing_pybind11_print_dict():
        mci.print_dict({'a': 1, 'b': 2})
>       mci.print_dict({'a': 1, 'b': 2, 'c': mci.Foo.ONE})
E       RuntimeError: to_json not implemented for this type of object: <Foo.ONE: 1>

sdk/modules/computational_imaging/python/tests/bindings/calibration_pytest.py:154: RuntimeError