Fix stuff

Author: nickyoung-github

README.md

@@ -119,6 +119,8 @@ Headers are installed to `<top level>/include`
 
 Compiled pybind modules are installed into `<original module path>/__pybind__`
 
+For C++ usage, you need only the headers, the compiled code is for pybind/python usage only
+
 For the example below, `common_object_model/common_object_model/v1/common/__pybind__/foo.cpython-311-darwin.so` will
 be installed (obviously with corresponding qualifiers for Linux/Windows). `get_pybind_value()` searches this
 directory
@@ -286,6 +288,7 @@ will generate the following files:
             .value("SUNDAY", Weekday::SUNDAY);
 
         py::class_<DCFoo>(m, "DCFoo")
+            .def(py::init<>())
             .def(py::init<std::optional<std::string>, int>(), py::arg("my_string"), py::arg("my_int"))
             .def_readwrite("my_string", &DCFoo::my_string)
             .def_readwrite("my_int", &DCFoo::my_int);
@@ -296,13 +299,15 @@ will generate the following files:
             .def_readwrite("my_day", &Foo::my_day);
 
         py::class_<Bar>(m, "Bar")
+            .def(py::init<>())
             .def(py::init<std::string, bool, Weekday, int, std::optional<std::string>>(), py::arg("my_string"), py::arg("my_bool")=true,
                 py::arg("my_day")=SUNDAY, py::arg("my_int")=123, py::arg("my_optional_string")=std::nullopt)
             .def_readwrite("my_string", &Bar::my_string)
             .def_readwrite("my_int", &Bar::my_int)
             .def_readwrite("my_optional_string", &Bar::my_optional_string);
 
         py::class_<Baz>(m, "Baz")
+            .def(py::init<>())
             .def(py::init<DCFoo, Foo, std::chrono::system_clock::time_point, std::variant<std::string, double>>(), py::arg("my_dc_foo"),
                 py::arg("my_foo"), py::arg("my_date"), py::arg("my_variant")=123.0)
             .def_readwrite("my_dc_foo", &Baz::my_dc_foo)

pydantic_bind/base.py

@@ -269,11 +269,12 @@ def __init__(self, **kwargs):
             self.__pybind_impl = pybind_type(**kwargs)
 
 
-def __dc_init(init):
+def __dataclass_init(init):
     @wraps(init)
     def wrapper(self, *args, __pybind_impl__=None, **kwargs):
-        self.__pybind_impl = __pybind_impl__ or get_pybind_type(type(self))()
-        return init(self, *args, **kwargs)
+        self.pybind_impl = __pybind_impl__ or get_pybind_type(type(self))()
+        init(self, *args, **kwargs)
+        arse = True
 
     return wrapper
 
@@ -288,7 +289,7 @@ def dataclass(cls=None, /, *, init=True, repr=True, eq=True, order=False,
     for name, field in ret.__dataclass_fields__.items():
         setattr(cls, name, property(fget=_getter(name, field.type), fset=_setter(name, field.type)))
 
-    ret.__init__ = __dc_init(ret.__init__)
+    ret.__init__ = __dataclass_init(ret.__init__)
     ret.__no_copy__ = True
 
     return ret

pydantic_bind/cpp_generator.py

@@ -198,6 +198,7 @@ def generate_class(model_class: ModelMetaclass, indent_size: int = 0, max_width:
     cls_name = model_class.__name__
     bases = f" : public {', '.join(b.__name__ for b in base_init.keys())}" if base_init else ""
     default_constructor = ""
+    default_pydantic_init = ""
     indent = " " * indent_size
     newline = "\n"
     newline_indent = f"{newline}    {indent}"
@@ -209,6 +210,7 @@ def generate_class(model_class: ModelMetaclass, indent_size: int = 0, max_width:
 
     if default_init_args:
         default_constructor = f"{indent}{cls_name}() :\n"
+        default_pydantic_init = f"{indent}.def(py::init<>())\n"
 
         if base_init:
             default_constructor += \
@@ -244,8 +246,7 @@ def generate_class(model_class: ModelMetaclass, indent_size: int = 0, max_width:
     pydantic_bases = ", " + ", ".join(base.__name__ for base in base_init.keys()) if base_init else ""
     pydantic_init = "\n".join(args_wrapper.wrap(f"{', '.join(types)}>(), {', '.join(kwargs)}"))
     pydantic_def = f"""{indent}py::class_<{cls_name}{pydantic_bases}>(m, "{cls_name}")
-    {indent}.def(py::init<>())
-    {indent}.def(py::init<{pydantic_init})
+    {default_pydantic_init}{indent}.def(py::init<{pydantic_init})
     {indent}{newline_indent.join(pydantic_attrs)};"""
 
     return struct_def, pydantic_def, tuple(f"#include {i}" for i in sorted(all_includes))
@@ -271,8 +272,9 @@ def generate_enum(enum_typ: EnumType, indent_size: int = 0, max_width: int = 110
 def generate_module(module_name: str, output_dir: str, indent_size: int = 4, max_width: int = 110):
     single_newline = "\n"
     double_newline = "\n\n"
-    dot = r'.'
-    slash = r'/'
+    dot = r"."
+    slash = r"/"
+    indent = " " * indent_size
 
     module = import_module(module_name)
     generated_root = Path(output_dir)
@@ -304,9 +306,17 @@ def generate_module(module_name: str, output_dir: str, indent_size: int = 4, max
                 if self_include in includes:
                     includes.remove(self_include)
 
+    imports = []
+    for include in (i for i in includes if namespace in i):
+        import_parts = include.split(slash)
+        import_parts.insert(-2, "__pybind__")
+        imprt = '.'.join(import_parts).replace('#include ', '').replace('.h', '')
+        imports.append(f"{indent}py::module_::import({imprt});")
+
     enum_contents = f"\n{double_newline.join(enum_defs)}{single_newline if struct_defs else ''}" if enum_defs else ""
     struct_contents = f"\n{double_newline.join(struct_defs)}" if struct_defs else ""
     include_contents = f"\n{single_newline.join(includes)}\n" if includes else ""
+    import_contents = f"\n{single_newline.join(imports)}\n" if imports else ""
 
     header_contents = f"""
 #ifndef {guard}
@@ -331,7 +341,7 @@ def generate_module(module_name: str, output_dir: str, indent_size: int = 4, max
 
 
 PYBIND11_MODULE({module_base_name}, m)
-{{
+{{{import_contents}
 {double_newline.join(pydantic_defs)}
 }}
 """

pydantic_bind/include/msgpack/msgpack.h

@@ -199,6 +199,14 @@ namespace msgpack {
             pack_type(value.time_since_epoch().count());
         }
 
+        template<class T>
+        void pack_type(const std::optional<T> &value) {
+            if (!value)
+                serialized_object.emplace_back(nil);
+            else
+                pack_type(*value);
+        }
+
         template<class T>
         void pack_array(const T &array) {
             if (array.size() < 16) {
@@ -514,15 +522,6 @@ namespace msgpack {
         }
     }
 
-    template<>
-    inline
-    void Packer::pack_type(const std::optional<T> &value) {
-        if (!value)
-            serialized_object.emplace_back(nil);
-        else
-            pack_type(*value);
-    }
-
     class Unpacker {
     public:
         Unpacker() : data_pointer(nullptr), data_end(nullptr) {};