Add no_copy dataclass

Author: nickyoung-github

README.md

@@ -67,10 +67,14 @@ You can create an instance of the pybind class from your original using `get_pyb
 ## No Copy
 
 What if you would like a single representation of the data, shared between C++ and python. Then fear not,
-`base.BaseModelNoCopy` is your friend! Deriving from this class will result in the annotations for the pydantic class
-being re-written using `computed_field`, with property getters and setters operating on the generated pybind class.
+`BaseModelNoCopy` and `dataclass` are your friends!
 
-`BaseModelNoCopy.__init__` will create the corresponding pybind class, using the supplied values.
+Deriving from this `BaseModelNoCopy` will give you equivalent functionality of as pydantic's `BaseModel`. The
+annotations are re-written using `computed_field`, with property getters and setters operating on the generated pybind
+class, which is instantiated behind the scenes in `init`
+
+`dataclass` works similarly, adding properties to the dataclass, so that the exisitng get and set functionality works
+seamless in accessing the generated pybind class (also set via a shimmed `init`)
 
 
 ## Supported Types

pydantic_bind/__init__.py

@@ -1,7 +1,8 @@
-from .base import BaseModelNoCopy, get_pybind_type, get_pybind_value
+from .base import BaseModelNoCopy, dataclass, get_pybind_type, get_pybind_value
 
 __all__ = (
     BaseModelNoCopy,
+    dataclass,
     get_pybind_type,
     get_pybind_value
 )

pydantic_bind/base.py

@@ -1,6 +1,6 @@
-from dataclasses import is_dataclass
+from dataclasses import dataclass as orig_dataclass, is_dataclass
 from enum import Enum, EnumType
-from functools import cache
+from functools import cache, wraps
 from importlib import import_module
 from pydantic import BaseModel as BaseModel, ConfigDict, computed_field
 from pydantic.fields import ComputedFieldInfo, FieldInfo
@@ -84,9 +84,10 @@ def _get_pybind_value(obj, default_to_self: bool = True):
         raise UnconvertableValue("Only dataclasses and pydantic classes supported")
 
 
-def from_pybind_value(value, typ:Type):
+def from_pybind_value(value, typ: Type):
     origin = get_origin(typ)
     args = get_args(typ)
+    is_dc = is_dataclass(typ)
 
     if origin is Optional:
         typ = args[0]
@@ -95,9 +96,9 @@ def from_pybind_value(value, typ:Type):
 
     if issubclass(typ, Enum):
         return typ[value.name]
-    elif issubclass(typ, __IBaseModelNoCopy):
+    elif issubclass(typ, __IBaseModelNoCopy) or (is_dc and hasattr(typ, "__no_copy__")):
         return typ(__pybind_impl__=value)
-    elif is_dataclass(typ) or issubclass(typ, BaseModel):
+    elif is_dc or issubclass(typ, BaseModel):
         # This is quite inefficient
         kwargs = {}
         for field_name, field_type, _ in field_info_iter(typ):
@@ -266,3 +267,28 @@ def __init__(self, **kwargs):
 
             pybind_type = get_pybind_type(type(self))
             self.__pybind_impl = pybind_type(**kwargs)
+
+
+def __dc_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)
+
+    return wrapper
+
+
+def dataclass(cls=None, /, *, init=True, repr=True, eq=True, order=False,
+              unsafe_hash=False, frozen=False, match_args=True,
+              kw_only=False, slots=False, weakref_slot=False):
+
+    ret = orig_dataclass(cls, init=init, repr=repr, eq=eq, order=order, unsafe_hash=unsafe_hash, frozen=frozen,
+                         match_args=match_args, kw_only=kw_only, slots=slots, weakref_slot=weakref_slot)
+
+    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.__no_copy__ = True
+
+    return ret

pydantic_bind/cpp_generator.py

@@ -244,6 +244,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})
     {indent}{newline_indent.join(pydantic_attrs)};"""
 

setup.py

@@ -3,7 +3,7 @@
 # ToDo: Add versioneer
 
 setup(name="pydantic_bind",
-      version="1.2.7",
+      version="1.2.8",
       description="C++/pybind generation from Pydantic classes",
       author="Nick Young",
       license=r"https://www.apache.org/licenses/LICENSE-2.0",