add copy dunders to some objects

Author: arashbm

src/common_edge_properties.hpp

@@ -2,6 +2,7 @@
 #include <reticula/network_concepts.hpp>
 
 #include "bind_core.hpp"
+#include "nanobind/operators.h"
 #include "type_str/scalars.hpp"
 #include "type_str/edges.hpp"
 #include "type_utils.hpp"
@@ -46,6 +47,11 @@ nb::class_<EdgeT> define_basic_edge_concept(nb::module_& m) {
         nb::call_guard<nb::gil_scoped_release>())
     .def(nb::hash(nb::self),
         nb::call_guard<nb::gil_scoped_release>())
+    .def("__copy__", [](const EdgeT& self) {
+        return EdgeT(self);
+    }).def("__deepcopy__", [](const EdgeT& self, nb::dict) {
+        return EdgeT(self);
+    }, "memo"_a)
     .def("__repr__", [](const EdgeT& a) {
       return fmt::format("{}", a);
     }).def_static("__class_repr__", []() {

src/components.cpp

@@ -64,6 +64,11 @@ struct declare_component_types {
       .def("__contains__", &Component::contains,
           "vertex"_a,
           nb::call_guard<nb::gil_scoped_release>())
+      .def("__copy__", [](const Component& self) {
+          return Component(self);
+      }).def("__deepcopy__", [](const Component& self, nb::dict) {
+          return Component(self);
+      }, "memo"_a)
       .def("__repr__", [](const Component& c) {
           return fmt::format("{}", c);
       }).def_static("vertex_type", []() {
@@ -84,6 +89,11 @@ struct declare_component_types {
         python_type_str<ComponentSize>().c_str())
       .def("size", &ComponentSize::size,
           nb::call_guard<nb::gil_scoped_release>())
+      .def("__copy__", [](const ComponentSize& self) {
+          return ComponentSize(self);
+      }).def("__deepcopy__", [](const ComponentSize& self, nb::dict) {
+          return ComponentSize(self);
+      }, "memo"_a)
       .def("__repr__", [](const ComponentSize& c) {
           return fmt::format("{}", c);
       }).def_static("vertex_type", []() {
@@ -102,6 +112,11 @@ struct declare_component_types {
       .def("size_estimate",
           &ComponentSizeEstimate::size_estimate,
           nb::call_guard<nb::gil_scoped_release>())
+      .def("__copy__", [](const ComponentSizeEstimate& self) {
+          return ComponentSizeEstimate(self);
+      }).def("__deepcopy__", [](const ComponentSizeEstimate& self, nb::dict) {
+          return ComponentSizeEstimate(self);
+      }, "memo"_a)
       .def("__repr__", [](const ComponentSizeEstimate& c) {
           return fmt::format("{}", c);
       })

src/networks.cpp

@@ -93,6 +93,11 @@ struct declare_network_class {
           nb::call_guard<nb::gil_scoped_release>())
       .def(nb::self != nb::self,
           nb::call_guard<nb::gil_scoped_release>())
+      .def("__copy__", [](const Net& self) {
+          return Net(self);
+      }).def("__deepcopy__", [](const Net& self, nb::dict) {
+          return Net(self);
+      }, "memo"_a)
       .def("__repr__", [](const Net& a) {
         return fmt::format("{}", a);
       }).def_static("__class_repr__", []() {

src/random_state.cpp

@@ -15,6 +15,11 @@ void declare_random_states(nb::module_& m) {
     }, nb::call_guard<nb::gil_scoped_release>())
     .def(nb::init<std::mt19937_64::result_type>(),
          "seed"_a, nb::call_guard<nb::gil_scoped_release>())
+    .def("__copy__", [](const std::mt19937_64& self) {
+        return std::mt19937_64(self);
+    }).def("__deepcopy__", [](const std::mt19937_64& self, nb::dict) {
+        return std::mt19937_64(self);
+    }, "memo"_a)
     .def("__call__", [](std::mt19937_64& self) { return self(); })
     .def_static("__class_repr__", []() {
       return fmt::format("<class '{}'>", type_str<std::mt19937_64>{}());

src/temporal_clusters.cpp

@@ -71,6 +71,11 @@ struct declare_temporal_cluster_types {
           &Cluster::contains,
           "event"_a,
           nb::call_guard<nb::gil_scoped_release>())
+      .def("__copy__", [](const Cluster& self) {
+          return Cluster(self);
+      }).def("__deepcopy__", [](const Cluster& self, nb::dict) {
+          return Cluster(self);
+      }, "memo"_a)
       .def("__repr__", [](const Cluster& c) {
           return fmt::format("{}", c);
       })
@@ -102,6 +107,11 @@ struct declare_temporal_cluster_types {
           nb::call_guard<nb::gil_scoped_release>())
       .def("__len__", &ClusterSize::size,
           nb::call_guard<nb::gil_scoped_release>())
+      .def("__copy__", [](const ClusterSize& self) {
+          return ClusterSize(self);
+      }).def("__deepcopy__", [](const ClusterSize& self, nb::dict) {
+          return ClusterSize(self);
+      }, "memo"_a)
       .def("__repr__", [](const ClusterSize& c) {
           return fmt::format("{}", c);
       })
@@ -130,6 +140,11 @@ struct declare_temporal_cluster_types {
       .def("mass_estimate",
           &ClusterSizeEstimate::mass_estimate,
           nb::call_guard<nb::gil_scoped_release>())
+      .def("__copy__", [](const ClusterSizeEstimate& self) {
+          return ClusterSizeEstimate(self);
+      }).def("__deepcopy__", [](const ClusterSizeEstimate& self, nb::dict) {
+          return ClusterSizeEstimate(self);
+      }, "memo"_a)
       .def("__repr__", [](const ClusterSizeEstimate& c) {
           return fmt::format("{}", c);
       })