Merge pull request #86 from lsst/tickets/DM-38772

mwittgen · web-flow · commit ffca2db377e8 · 2025-08-07T11:43:21.000-07:00
DM-38772: Use pybind11 v3 holder classes
diff --git a/python/lsst/sphgeom/_angle.cc b/python/lsst/sphgeom/_angle.cc
@@ -40,7 +40,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<Angle> &cls) {
+void defineClass(py::classh<Angle> &cls) {
     cls.def_static("nan", &Angle::nan);
     cls.def_static("fromDegrees", &Angle::fromDegrees);
     cls.def_static("fromRadians", &Angle::fromRadians);
diff --git a/python/lsst/sphgeom/_angleInterval.cc b/python/lsst/sphgeom/_angleInterval.cc
@@ -41,7 +41,7 @@ namespace sphgeom {
 
 template <>
 void defineClass(
-        py::class_<AngleInterval, std::shared_ptr<AngleInterval>> &cls) {
+        py::classh<AngleInterval> &cls) {
     python::defineInterval<decltype(cls), AngleInterval, Angle>(cls);
 
     cls.def_static("fromDegrees", &AngleInterval::fromDegrees, "x"_a, "y"_a);
diff --git a/python/lsst/sphgeom/_box.cc b/python/lsst/sphgeom/_box.cc
@@ -52,7 +52,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<Box, std::unique_ptr<Box>, Region> &cls) {
+void defineClass(py::classh<Box, Region> &cls) {
     cls.attr("TYPE_CODE") = py::int_(Box::TYPE_CODE);
 
     cls.def_static("fromDegrees", &Box::fromDegrees, "lon1"_a, "lat1"_a,
diff --git a/python/lsst/sphgeom/_box3d.cc b/python/lsst/sphgeom/_box3d.cc
@@ -42,7 +42,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<Box3d, std::shared_ptr<Box3d>> &cls) {
+void defineClass(py::classh<Box3d> &cls) {
     cls.def_static("empty", &Box3d::empty);
     cls.def_static("full", &Box3d::full);
     cls.def_static("aroundUnitSphere", &Box3d::aroundUnitSphere);
diff --git a/python/lsst/sphgeom/_chunker.cc b/python/lsst/sphgeom/_chunker.cc
@@ -47,7 +47,7 @@ py::str toString(Chunker const &self) {
 }
 
 template <>
-void defineClass(py::class_<Chunker, std::shared_ptr<Chunker>> &cls) {
+void defineClass(py::classh<Chunker> &cls) {
     cls.def(py::init<int32_t, int32_t>(), "numStripes"_a,
             "numSubStripesPerStripe"_a);
 
diff --git a/python/lsst/sphgeom/_circle.cc b/python/lsst/sphgeom/_circle.cc
@@ -48,7 +48,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<Circle, std::unique_ptr<Circle>, Region> &cls) {
+void defineClass(py::classh<Circle, Region> &cls) {
     cls.attr("TYPE_CODE") = py::int_(Circle::TYPE_CODE);
 
     cls.def_static("empty", &Circle::empty);
diff --git a/python/lsst/sphgeom/_compoundRegion.cc b/python/lsst/sphgeom/_compoundRegion.cc
@@ -91,7 +91,7 @@ class CompoundIterator {
 }  // namespace
 
 template <>
-void defineClass(py::class_<CompoundRegion, std::unique_ptr<CompoundRegion>, Region> &cls) {
+void defineClass(py::classh<CompoundRegion, Region> &cls) {
     cls.def("nOperands", &CompoundRegion::nOperands);
     cls.def("__len__", &CompoundRegion::nOperands);
     cls.def(
@@ -113,15 +113,15 @@ void defineClass(py::class_<CompoundRegion, std::unique_ptr<CompoundRegion>, Reg
 }
 
 template <>
-void defineClass(py::class_<UnionRegion, std::unique_ptr<UnionRegion>, CompoundRegion> &cls) {
+void defineClass(py::classh<UnionRegion, CompoundRegion> &cls) {
     cls.attr("TYPE_CODE") = py::int_(UnionRegion::TYPE_CODE);
     cls.def(py::init(&_args_factory<UnionRegion>));
     cls.def(py::pickle(&python::encode, &python::decode<UnionRegion>));
     cls.def("__repr__", [](CompoundRegion const &self) { return _repr("UnionRegion", self); });
 }
 
 template <>
-void defineClass(py::class_<IntersectionRegion, std::unique_ptr<IntersectionRegion>, CompoundRegion> &cls) {
+void defineClass(py::classh<IntersectionRegion, CompoundRegion> &cls) {
     cls.attr("TYPE_CODE") = py::int_(IntersectionRegion::TYPE_CODE);
     cls.def(py::init(&_args_factory<IntersectionRegion>));
     cls.def(py::pickle(&python::encode, &python::decode<IntersectionRegion>));
diff --git a/python/lsst/sphgeom/_convexPolygon.cc b/python/lsst/sphgeom/_convexPolygon.cc
@@ -49,8 +49,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<ConvexPolygon, std::unique_ptr<ConvexPolygon>,
-                            Region> &cls) {
+void defineClass(py::classh<ConvexPolygon, Region> &cls) {
     cls.attr("TYPE_CODE") = py::int_(ConvexPolygon::TYPE_CODE);
 
     cls.def_static("convexHull", &ConvexPolygon::convexHull, "points"_a);
diff --git a/python/lsst/sphgeom/_ellipse.cc b/python/lsst/sphgeom/_ellipse.cc
@@ -48,7 +48,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<Ellipse, std::unique_ptr<Ellipse>, Region> &cls) {
+void defineClass(py::classh<Ellipse, Region> &cls) {
     cls.attr("TYPE_CODE") = py::int_(Ellipse::TYPE_CODE);
 
     cls.def_static("empty", &Ellipse::empty);
diff --git a/python/lsst/sphgeom/_htmPixelization.cc b/python/lsst/sphgeom/_htmPixelization.cc
@@ -39,7 +39,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<HtmPixelization, Pixelization> &cls) {
+void defineClass(py::classh<HtmPixelization, Pixelization> &cls) {
     cls.attr("MAX_LEVEL") = py::int_(HtmPixelization::MAX_LEVEL);
 
     cls.def_static("level", &HtmPixelization::level, "i"_a);
diff --git a/python/lsst/sphgeom/_interval1d.cc b/python/lsst/sphgeom/_interval1d.cc
@@ -40,7 +40,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<Interval1d, std::shared_ptr<Interval1d>> &cls) {
+void defineClass(py::classh<Interval1d> &cls) {
     python::defineInterval<decltype(cls), Interval1d, double>(cls);
 
     cls.def_static("empty", &Interval1d::empty);
diff --git a/python/lsst/sphgeom/_lonLat.cc b/python/lsst/sphgeom/_lonLat.cc
@@ -40,7 +40,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<LonLat, std::shared_ptr<LonLat>> &cls) {
+void defineClass(py::classh<LonLat> &cls) {
     cls.def_static("fromDegrees", &LonLat::fromDegrees);
     cls.def_static("fromRadians", &LonLat::fromRadians);
     cls.def_static("latitudeOf", &LonLat::latitudeOf);
diff --git a/python/lsst/sphgeom/_matrix3d.cc b/python/lsst/sphgeom/_matrix3d.cc
@@ -46,7 +46,7 @@ Vector3d getRow(Matrix3d const &self, py::int_ row) {
 }
 
 template <>
-void defineClass(py::class_<Matrix3d, std::shared_ptr<Matrix3d>> &cls) {
+void defineClass(py::classh<Matrix3d> &cls) {
     cls.def(py::init<>());
     cls.def(py::init<double, double, double, double, double, double, double,
                      double, double>(),
diff --git a/python/lsst/sphgeom/_mq3cPixelization.cc b/python/lsst/sphgeom/_mq3cPixelization.cc
@@ -39,7 +39,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<Mq3cPixelization, Pixelization> &cls) {
+void defineClass(py::classh<Mq3cPixelization, Pixelization> &cls) {
     cls.attr("MAX_LEVEL") = py::int_(Mq3cPixelization::MAX_LEVEL);
 
     cls.def_static("level", &Mq3cPixelization::level);
diff --git a/python/lsst/sphgeom/_normalizedAngle.cc b/python/lsst/sphgeom/_normalizedAngle.cc
@@ -41,7 +41,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<NormalizedAngle> &cls) {
+void defineClass(py::classh<NormalizedAngle> &cls) {
     // Provide the equivalent of the NormalizedAngle to Angle C++ cast
     // operator in Python
     py::implicitly_convertible<NormalizedAngle, Angle>();
diff --git a/python/lsst/sphgeom/_normalizedAngleInterval.cc b/python/lsst/sphgeom/_normalizedAngleInterval.cc
@@ -40,8 +40,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<NormalizedAngleInterval,
-                            std::shared_ptr<NormalizedAngleInterval>> &cls) {
+void defineClass(py::classh<NormalizedAngleInterval> &cls) {
     python::defineInterval<decltype(cls), NormalizedAngleInterval,
                            NormalizedAngle>(cls);
 
diff --git a/python/lsst/sphgeom/_pixelization.cc b/python/lsst/sphgeom/_pixelization.cc
@@ -41,7 +41,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<Pixelization> &cls) {
+void defineClass(py::classh<Pixelization> &cls) {
     cls.def("universe", &Pixelization::universe);
     cls.def("pixel", &Pixelization::pixel, "i"_a);
     cls.def("index", &Pixelization::index, "i"_a);
diff --git a/python/lsst/sphgeom/_q3cPixelization.cc b/python/lsst/sphgeom/_q3cPixelization.cc
@@ -39,7 +39,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<Q3cPixelization, Pixelization> &cls) {
+void defineClass(py::classh<Q3cPixelization, Pixelization> &cls) {
     cls.attr("MAX_LEVEL") = py::int_(Q3cPixelization::MAX_LEVEL);
 
     cls.def(py::init<int>(), "level"_a);
diff --git a/python/lsst/sphgeom/_rangeSet.cc b/python/lsst/sphgeom/_rangeSet.cc
@@ -91,7 +91,7 @@ py::list ranges(RangeSet const &self) {
 }  // <anonymous>
 
 template <>
-void defineClass(py::class_<RangeSet, std::shared_ptr<RangeSet>> &cls) {
+void defineClass(py::classh<RangeSet> &cls) {
     cls.def(py::init<>());
     cls.def(py::init<uint64_t>(), "integer"_a);
     cls.def(py::init([](uint64_t a, uint64_t b) {
diff --git a/python/lsst/sphgeom/_region.cc b/python/lsst/sphgeom/_region.cc
@@ -51,7 +51,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<Region, std::unique_ptr<Region>> &cls) {
+void defineClass(py::classh<Region> &cls) {
     cls.def("clone", &Region::clone);
     cls.def("isEmpty", &Region::isEmpty);
     cls.def("getBoundingBox", &Region::getBoundingBox);
diff --git a/python/lsst/sphgeom/_sphgeom.cc b/python/lsst/sphgeom/_sphgeom.cc
@@ -71,47 +71,37 @@ PYBIND11_MODULE(_sphgeom, mod) {
     // This results in docstrings containing only Python type names, even
     // when there are circular dependencies in C++.
 
-    py::class_<Angle> angle(mod, "Angle");
-    py::class_<NormalizedAngle> normalizedAngle(mod, "NormalizedAngle");
-    py::class_<LonLat, std::shared_ptr<LonLat>> lonLat(mod, "LonLat");
-    py::class_<Vector3d, std::shared_ptr<Vector3d>> vector3d(mod, "Vector3d");
-    py::class_<UnitVector3d, std::shared_ptr<UnitVector3d>> unitVector3d(
-            mod, "UnitVector3d");
-    py::class_<Matrix3d, std::shared_ptr<Matrix3d>> matrix3d(mod, "Matrix3d");
-
-    py::class_<AngleInterval, std::shared_ptr<AngleInterval>> angleInterval(
-            mod, "AngleInterval");
-    py::class_<NormalizedAngleInterval,
-               std::shared_ptr<NormalizedAngleInterval>>
-            normalizedAngleInterval(mod, "NormalizedAngleInterval");
-    py::class_<Interval1d, std::shared_ptr<Interval1d>> interval1d(
-            mod, "Interval1d");
-
-    py::class_<Box3d, std::shared_ptr<Box3d>> box3d(mod, "Box3d");
-
-    py::class_<Region, std::unique_ptr<Region>> region(mod, "Region");
-    py::class_<Box, std::unique_ptr<Box>, Region> box(mod, "Box");
-    py::class_<Circle, std::unique_ptr<Circle>, Region> circle(mod, "Circle");
-    py::class_<ConvexPolygon, std::unique_ptr<ConvexPolygon>, Region>
-            convexPolygon(mod, "ConvexPolygon");
-    py::class_<Ellipse, std::unique_ptr<Ellipse>, Region> ellipse(mod,
+    py::classh<Angle> angle(mod, "Angle");
+    py::classh<NormalizedAngle> normalizedAngle(mod, "NormalizedAngle");
+    py::classh<LonLat> lonLat(mod, "LonLat");
+    py::classh<Vector3d> vector3d(mod, "Vector3d");
+    py::classh<UnitVector3d> unitVector3d(mod, "UnitVector3d");
+    py::classh<Matrix3d> matrix3d(mod, "Matrix3d");
+
+    py::classh<AngleInterval> angleInterval(mod, "AngleInterval");
+    py::classh<NormalizedAngleInterval> normalizedAngleInterval(mod, "NormalizedAngleInterval");
+    py::classh<Interval1d> interval1d(mod, "Interval1d");
+
+    py::classh<Box3d> box3d(mod, "Box3d");
+
+    py::classh<Region> region(mod, "Region");
+    py::classh<Box, Region> box(mod, "Box");
+    py::classh<Circle, Region> circle(mod, "Circle");
+    py::classh<ConvexPolygon, Region> convexPolygon(mod, "ConvexPolygon");
+    py::classh<Ellipse, Region> ellipse(mod,
                                                                   "Ellipse");
-    py::class_<CompoundRegion, std::unique_ptr<CompoundRegion>, Region> compoundRegion(mod, "CompoundRegion");
-    py::class_<UnionRegion, std::unique_ptr<UnionRegion>, CompoundRegion> unionRegion(mod, "UnionRegion");
-    py::class_<IntersectionRegion, std::unique_ptr<IntersectionRegion>, CompoundRegion>
-            intersectionRegion(mod, "IntersectionRegion");
-
-    py::class_<RangeSet, std::shared_ptr<RangeSet>> rangeSet(mod, "RangeSet");
-
-    py::class_<Pixelization> pixelization(mod, "Pixelization");
-    py::class_<HtmPixelization, Pixelization> htmPixelization(
-            mod, "HtmPixelization");
-    py::class_<Mq3cPixelization, Pixelization> mq3cPixelization(
-            mod, "Mq3cPixelization");
-    py::class_<Q3cPixelization, Pixelization> q3cPixelization(
-            mod, "Q3cPixelization");
-
-    py::class_<Chunker, std::shared_ptr<Chunker>> chunker(mod, "Chunker");
+    py::classh<CompoundRegion, Region> compoundRegion(mod, "CompoundRegion");
+    py::classh<UnionRegion, CompoundRegion> unionRegion(mod, "UnionRegion");
+    py::classh<IntersectionRegion, CompoundRegion> intersectionRegion(mod, "IntersectionRegion");
+
+    py::classh<RangeSet> rangeSet(mod, "RangeSet");
+
+    py::classh<Pixelization> pixelization(mod, "Pixelization");
+    py::classh<HtmPixelization, Pixelization> htmPixelization(mod, "HtmPixelization");
+    py::classh<Mq3cPixelization, Pixelization> mq3cPixelization(mod, "Mq3cPixelization");
+    py::classh<Q3cPixelization, Pixelization> q3cPixelization(mod, "Q3cPixelization");
+
+    py::classh<Chunker> chunker(mod, "Chunker");
 
     defineClass(angle);
     defineClass(normalizedAngle);
diff --git a/python/lsst/sphgeom/_unitVector3d.cc b/python/lsst/sphgeom/_unitVector3d.cc
@@ -43,7 +43,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<UnitVector3d, std::shared_ptr<UnitVector3d>> &cls) {
+void defineClass(py::classh<UnitVector3d> &cls) {
     // Provide the equivalent of the UnitVector3d to Vector3d C++ cast
     // operator in Python
     py::implicitly_convertible<UnitVector3d, Vector3d>();
diff --git a/python/lsst/sphgeom/_vector3d.cc b/python/lsst/sphgeom/_vector3d.cc
@@ -42,7 +42,7 @@ namespace lsst {
 namespace sphgeom {
 
 template <>
-void defineClass(py::class_<Vector3d, std::shared_ptr<Vector3d>> &cls) {
+void defineClass(py::classh<Vector3d> &cls) {
     cls.def(py::init<>());
     cls.def(py::init<double, double, double>(), "x"_a, "y"_a, "z"_a);
     cls.def(py::init<Vector3d const &>(), "vector"_a);

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ py::str toString(Chunker const &self) {`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`template <>`
`50`		`-void defineClass(py::class_<Chunker, std::shared_ptr<Chunker>> &cls) {`
	`50`	`+void defineClass(py::classh<Chunker> &cls) {`
`51`	`51`	`cls.def(py::init<int32_t, int32_t>(), "numStripes"_a,`
`52`	`52`	`"numSubStripesPerStripe"_a);`
`53`	`53`