Merge branch 'main' into ahcorde/python/particleemitter

Author: ahcorde

.github/ci/packages.apt

@@ -12,4 +12,5 @@ python3-distutils
 python3-ignition-math7
 python3-psutil
 python3-pybind11
+python3-pytest
 ruby-dev

python/CMakeLists.txt

@@ -78,6 +78,7 @@ pybind11_add_module(sdformat SHARED
   src/sdf/pySurface.cc
   src/sdf/pyVisual.cc
   src/sdf/pyWorld.cc
+  src/sdf/pybind11_helpers.cc
 )
 
 target_link_libraries(sdformat PRIVATE
@@ -138,10 +139,25 @@ if (BUILD_TESTING)
     pyVisual_TEST
     pyWorld_TEST
   )
+  execute_process(COMMAND "${Python3_EXECUTABLE}" -m pytest --version
+    OUTPUT_VARIABLE PYTEST_output
+    ERROR_VARIABLE  PYTEST_error
+    RESULT_VARIABLE PYTEST_result)
+  if(${PYTEST_result} EQUAL 0)
+    set(pytest_FOUND TRUE)
+  else()
+    message("")
+    message(WARNING "Pytest package not available: ${PYTEST_error}")
+  endif()
 
   foreach (test ${python_tests})
-    add_test(NAME ${test}.py COMMAND
-      "${Python3_EXECUTABLE}" "${CMAKE_SOURCE_DIR}/python/test/${test}.py")
+    if (pytest_FOUND)
+      add_test(NAME ${test}.py COMMAND
+        "${Python3_EXECUTABLE}" -m pytest "${CMAKE_SOURCE_DIR}/python/test/${test}.py" --junitxml "${CMAKE_BINARY_DIR}/test_results/${test}.xml")
+    else()
+      add_test(NAME ${test}.py COMMAND
+        "${Python3_EXECUTABLE}" "${CMAKE_SOURCE_DIR}/python/test/${test}.py")
+    endif()
     set(_env_vars)
     list(APPEND _env_vars "PYTHONPATH=${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/python/:${CMAKE_BINARY_DIR}/lib:$ENV{PYTHONPATH}")
     list(APPEND _env_vars "LD_LIBRARY_PATH=${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}:$ENV{LD_LIBRARY_PATH}")

python/src/sdf/pyFrame.cc

@@ -21,6 +21,7 @@
 
 #include "sdf/Frame.hh"
 #include "pyExceptions.hh"
+#include "pybind11_helpers.hh"
 
 using namespace pybind11::literals;
 
@@ -64,11 +65,7 @@ void defineFrame(pybind11::object module)
          [](const sdf::Frame &self)
          {
            std::string body;
-           auto errors = self.ResolveAttachedToBody(body);
-           if (!errors.empty())
-           {
-             throw PySDFErrorsException(errors);
-           }
+           ThrowIfErrors(self.ResolveAttachedToBody(body));
            return body;
          },
          "Resolve the attached-to body of this frame from the "

python/src/sdf/pyJoint.cc

@@ -21,6 +21,7 @@
 
 #include "sdf/Joint.hh"
 #include "sdf/Sensor.hh"
+#include "pybind11_helpers.hh"
 
 using namespace pybind11::literals;
 
@@ -57,17 +58,17 @@ void defineJoint(pybind11::object module)
          [](const sdf::Joint &self)
          {
            std::string link;
-           auto errors = self.ResolveChildLink(link);
-           return std::make_tuple(errors, link);
+           ThrowIfErrors(self.ResolveChildLink(link));
+           return link;
          },
          "Resolve the name of the child link from the "
          "FrameAttachedToGraph.")
     .def("resolve_parent_link",
          [](const sdf::Joint &self)
          {
            std::string link;
-           auto errors = self.ResolveParentLink(link);
-           return std::make_tuple(errors, link);
+           ThrowIfErrors(self.ResolveParentLink(link));
+           return link;
          },
          "Resolve the name of the parent link from the "
          "FrameAttachedToGraph. It will return the name of a link or "

python/src/sdf/pyJointAxis.cc

@@ -20,6 +20,7 @@
 #include <pybind11/stl.h>
 
 #include "sdf/JointAxis.hh"
+#include "pybind11_helpers.hh"
 
 
 using namespace pybind11::literals;
@@ -38,7 +39,10 @@ void defineJointAxis(pybind11::object module)
     .def(pybind11::init<sdf::JointAxis>())
     .def("xyz", &sdf::JointAxis::Xyz,
          "Get the x,y,z components of the axis unit vector.")
-    .def("set_xyz", &sdf::JointAxis::SetXyz,
+    .def("set_xyz", [](JointAxis &self, const gz::math::Vector3d &_xyz)
+         {
+           ThrowIfErrors(self.SetXyz(_xyz));
+         },
          "Set the x,y,z components of the axis unit vector.")
     .def("damping", &sdf::JointAxis::Damping,
          "Get the physical velocity dependent viscous damping coefficient "
@@ -104,8 +108,12 @@ void defineJointAxis(pybind11::object module)
          "Set the name of the coordinate frame in which this joint axis's "
          "unit vector is expressed. An empty value implies the parent (joint) "
          "frame.")
-    .def("resolve_xyz", &sdf::JointAxis::ResolveXyz,
-         pybind11::arg("_xyz"),
+    .def("resolve_xyz", [](const JointAxis &self, const std::string &_resolveTo)
+         {
+           gz::math::Vector3d xyz;
+           ThrowIfErrors(self.ResolveXyz(xyz, _resolveTo));
+           return xyz;
+         },
          pybind11::arg("_resolveTo") = "",
          "Express xyz unit vector of this axis in the coordinates of "
          "another named frame.")

python/src/sdf/pyModel.cc

@@ -24,6 +24,8 @@
 #include "sdf/Link.hh"
 #include "sdf/Model.hh"
 
+#include "pybind11_helpers.hh"
+
 using namespace pybind11::literals;
 
 namespace sdf
@@ -38,7 +40,10 @@ void defineModel(pybind11::object module)
   pybind11::class_<sdf::Model>(module, "Model")
     .def(pybind11::init<>())
     .def(pybind11::init<sdf::Model>())
-    .def("validate_graphs", &sdf::Model::ValidateGraphs,
+    .def("validate_graphs", [](const sdf::Model &self)
+         {
+           ThrowIfErrors(self.ValidateGraphs());
+         },
          "Check that the FrameAttachedToGraph and PoseRelativeToGraph "
          "are valid.")
     .def("name", &sdf::Model::Name,

python/src/sdf/pyRoot.cc

@@ -23,6 +23,7 @@
 #include "sdf/Model.hh"
 #include "sdf/Root.hh"
 #include "sdf/World.hh"
+#include "pybind11_helpers.hh"
 
 using namespace pybind11::literals;
 
@@ -38,23 +39,32 @@ void defineRoot(pybind11::object module)
   pybind11::class_<sdf::Root>(module, "Root")
     .def(pybind11::init<>())
     .def("load",
-         pybind11::overload_cast<const std::string &>(&sdf::Root::Load),
+         [](Root &self, const std::string &_filename)
+         {
+           ThrowIfErrors(self.Load(_filename));
+         },
          "Parse the given SDF file, and generate objects based on types "
          "specified in the SDF file.")
     .def("load",
-          pybind11::overload_cast<
-            const std::string &, const ParserConfig &>(&sdf::Root::Load),
+         [](Root &self, const std::string &_filename, 
+            const ParserConfig &_config)
+         {
+           ThrowIfErrors(self.Load(_filename, _config));
+         },
          "Parse the given SDF file, and generate objects based on types "
          "specified in the SDF file.")
    .def("load_sdf_string",
-         pybind11::overload_cast<const std::string &>(
-           &sdf::Root::LoadSdfString),
+         [](Root &self, const std::string &_sdf)
+         {
+           ThrowIfErrors(self.LoadSdfString(_sdf));
+         },
          "Parse the given SDF string, and generate objects based on types "
          "specified in the SDF file.")
     .def("load_sdf_string",
-          pybind11::overload_cast<
-            const std::string &, const ParserConfig &>(
-              &sdf::Root::LoadSdfString),
+         [](Root &self, const std::string &_sdf, const ParserConfig &_config)
+         {
+           ThrowIfErrors(self.LoadSdfString(_sdf, _config));
+         },
          "Parse the given SDF string, and generate objects based on types "
          "specified in the SDF file.")
     .def("version", &sdf::Root::Version,
@@ -84,11 +94,17 @@ void defineRoot(pybind11::object module)
     .def("set_light", &sdf::Root::SetLight,
          "Set the light object. This will override any existing model, "
          "actor, and light object.")
-    .def("add_world", &sdf::Root::AddWorld,
+    .def("add_world", [](Root &self, const World &_world)
+         {
+           ThrowIfErrors(self.AddWorld(_world));
+         },
          "Add a world to the root.")
     .def("clear_worlds", &sdf::Root::ClearWorlds,
          "Remove all worlds.")
-    .def("update_graphs", &sdf::Root::UpdateGraphs,
+    .def("update_graphs", [](Root &self)
+         {
+           ThrowIfErrors(self.UpdateGraphs());
+         },
          "Recreate the frame and pose graphs for the worlds and model "
          "that are children of this Root object. You can call this function "
          "to build new graphs when the DOM was created programmatically, or "

python/src/sdf/pySemanticPose.cc

@@ -21,6 +21,7 @@
 #include <gz/math/Pose3.hh>
 
 #include "sdf/SemanticPose.hh"
+#include "pybind11_helpers.hh"
 
 using namespace pybind11::literals;
 
@@ -41,8 +42,13 @@ void defineSemanticPose(pybind11::object module)
          "Get the name of the coordinate frame relative to which this "
          "object's pose is expressed. An empty value indicates that the frame "
          "is relative to the default parent object.")
-    .def("resolve", &sdf::SemanticPose::Resolve,
-         pybind11::arg("_pose"),
+    .def("resolve",
+         [](const sdf::SemanticPose &self, const std::string &_resolveTo)
+         {
+           gz::math::Pose3d pose;
+           ThrowIfErrors(self.Resolve(pose, _resolveTo));
+           return pose;
+         },
          pybind11::arg("_resolveTo") = "",
          "Resolve pose of this object with respect to another named frame. "
          "If there are any errors resolving the pose, the output will not be "

python/src/sdf/pybind11_helpers.cc

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2022 Open Source Robotics Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "pybind11_helpers.hh"
+
+namespace sdf
+{
+// Inline bracket to help doxygen filtering.
+inline namespace SDF_VERSION_NAMESPACE
+{
+namespace python
+{
+/////////////////////////////////////////////////
+void ThrowIfErrors(const sdf::Errors &_errors)
+{
+  if (!_errors.empty())
+  {
+    throw PySDFErrorsException(_errors);
+  }
+}
+}  // namespace python
+}  // namespace SDF_VERSION_NAMESPACE
+}  // namespace sdf
+

python/src/sdf/pybind11_helpers.hh

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2022 Open Source Robotics Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <sdf/sdf_config.h>
+
+#include <sdf/Types.hh>
+
+#include "pyExceptions.hh"
+
+namespace sdf
+{
+// Inline bracket to help doxygen filtering.
+inline namespace SDF_VERSION_NAMESPACE
+{
+namespace python
+{
+/// \brief Throw an exception if the `_errors` container is not empty.
+/// \param[in] _errors The list of errors to check.
+/// \throws PySDFErrorsException
+void ThrowIfErrors(const sdf::Errors &_errors);
+}  // namespace python
+}  // namespace SDF_VERSION_NAMESPACE
+}  // namespace sdf

python/test/pyCollision_TEST.py

@@ -15,7 +15,7 @@
 import copy
 from ignition.math import Pose3d
 from sdformat import (Box, Collision, Contact, Cylinder, Error, Geometry,
-                      Plane, Surface, Sphere)
+                      Plane, Surface, Sphere, SDFErrorsException)
 import sdformat as sdf
 import unittest
 import math
@@ -35,10 +35,9 @@ def test_default_construction(self):
         semanticPose = collision.semantic_pose()
         self.assertEqual(collision.raw_pose(), semanticPose.raw_pose())
         self.assertTrue(not semanticPose.relative_to())
-        pose = Pose3d()
         # expect errors when trying to resolve pose
-        semanticPose.resolve(pose)
-        # self.assertFalse()
+        with self.assertRaises(SDFErrorsException):
+            semanticPose.resolve()
 
         collision.set_raw_pose(Pose3d(-10, -20, -30, math.pi, math.pi, math.pi))
         self.assertEqual(Pose3d(-10, -20, -30, math.pi, math.pi, math.pi),
@@ -50,9 +49,9 @@ def test_default_construction(self):
         semanticPose = collision.semantic_pose()
         self.assertEqual(collision.raw_pose(), semanticPose.raw_pose())
         self.assertEqual("link", semanticPose.relative_to())
-        pose = Pose3d()
         # expect errors when trying to resolve pose
-        # self.assertFalse(semanticPose.resolve(pose).empty())
+        with self.assertRaises(SDFErrorsException):
+            semanticPose.resolve()
 
         self.assertNotEqual(None, collision.geometry())
         self.assertEqual(sdf.GeometryType.EMPTY, collision.geometry().type())

python/test/pyFrame_TEST.py

@@ -34,9 +34,9 @@ def test_default_construction(self):
         semanticPose = frame.semantic_pose()
         self.assertEqual(Pose3d.ZERO, semanticPose.raw_pose())
         self.assertFalse(semanticPose.relative_to())
-        pose = Pose3d()
         # expect errors when trying to resolve pose
-        self.assertTrue(semanticPose.resolve(pose))
+        with self.assertRaises(SDFErrorsException):
+            semanticPose.resolve()
 
         frame.set_attached_to("attachment")
         self.assertEqual("attachment", frame.attached_to())
@@ -48,19 +48,19 @@ def test_default_construction(self):
         semanticPose = frame.semantic_pose()
         self.assertEqual(frame.raw_pose(), semanticPose.raw_pose())
         self.assertEqual("attachment", semanticPose.relative_to())
-        pose = Pose3d()
         # expect errors when trying to resolve pose
-        self.assertTrue(semanticPose.resolve(pose))
+        with self.assertRaises(SDFErrorsException):
+            semanticPose.resolve()
 
         frame.set_pose_relative_to("link")
         self.assertEqual("link", frame.pose_relative_to())
 
         semanticPose = frame.semantic_pose()
         self.assertEqual(frame.raw_pose(), semanticPose.raw_pose())
         self.assertEqual("link", semanticPose.relative_to())
-        pose = Pose3d()
         # expect errors when trying to resolve pose
-        self.assertEqual(1, len(semanticPose.resolve(pose)))
+        with self.assertRaises(SDFErrorsException):
+            semanticPose.resolve()
 
         with self.assertRaises(SDFErrorsException) as cm:
             resolveAttachedToBody = frame.resolve_attached_to_body()