esp::core::Configuration changed to use unordered_map of variant-like instead of Magnum::ConfigurationGroups

examples/tutorials/colabs/managed_rigid_object_tutorial.ipynb

@@ -222,7 +222,7 @@
     "    for k, _ in user_attributes_dict.items():\n",
     "        print(\n",
     "            \"Sphere Object user attribute : {} : {}\".format(\n",
-    "                k, sphere_obj.user_attributes.get(k)\n",
+    "                k, sphere_obj.user_attributes.get_as_string(k)\n",
     "            )\n",
     "        )\n",
     "\n",

examples/tutorials/nb_python/managed_rigid_object_tutorial.py

@@ -208,7 +208,7 @@ def simulate(sim, dt=1.0, get_frames=True):
     for k, _ in user_attributes_dict.items():
         print(
             "Sphere Object user attribute : {} : {}".format(
-                k, sphere_obj.user_attributes.get(k)
+                k, sphere_obj.user_attributes.get_as_string(k)
             )
         )
 

habitat_sim/bindings/__init__.py

@@ -10,7 +10,7 @@
 from habitat_sim._ext.habitat_sim_bindings import (
     CameraSensor,
     CameraSensorSpec,
-    ConfigurationGroup,
+    Configuration,
     CubeMapSensorBase,
     CubeMapSensorBaseSpec,
     EquirectangularSensor,

src/esp/bindings/AttributesBindings.cpp

@@ -51,7 +51,7 @@ void initAttributesBindings(py::module& m) {
 
   // ==== AbstractAttributes ====
   py::class_<AbstractAttributes, esp::core::AbstractFileBasedManagedObject,
-             esp::core::Configuration, AbstractAttributes::ptr>(
+             esp::core::config::Configuration, AbstractAttributes::ptr>(
       m, "AbstractAttributes")
       .def(py::init(
           &AbstractAttributes::create<const std::string&, const std::string&>))
@@ -65,29 +65,12 @@ void initAttributesBindings(py::module& m) {
           "template_id", &AbstractAttributes::getID,
           R"(System-generated ID for template.  Will be unique among templates
           of same type.)")
-      .def("get_user_config_bool",
-           &AbstractAttributes::getUserConfigValue<bool>)
-      .def("get_user_config_string",
-           &AbstractAttributes::getUserConfigValue<std::string>)
-      .def("get_user_config_int", &AbstractAttributes::getUserConfigValue<int>)
-      .def("get_user_config_double",
-           &AbstractAttributes::getUserConfigValue<double>)
-      .def("get_user_config_vec3",
-           &AbstractAttributes::getUserConfigValue<Magnum::Vector3>)
-      .def("get_user_config_quat",
-           &AbstractAttributes::getUserConfigValue<Magnum::Quaternion>)
-      .def("get_user_config_val",
-           &AbstractAttributes::getUserConfigValue<std::string>)
-      .def("set_user_config_val",
-           &AbstractAttributes::setUserConfigValue<std::string>)
-      .def("set_user_config_val", &AbstractAttributes::setUserConfigValue<int>)
-      .def("set_user_config_val",
-           &AbstractAttributes::setUserConfigValue<double>)
-      .def("set_user_config_val", &AbstractAttributes::setUserConfigValue<bool>)
-      .def("set_user_config_val",
-           &AbstractAttributes::setUserConfigValue<Magnum::Vector3>)
-      .def("set_user_config_val",
-           &AbstractAttributes::setUserConfigValue<Magnum::Quaternion>)
+
+      .def(
+          "get_user_config", &AbstractAttributes::editUserConfiguration,
+          R"(Retrieve the User Config object for this attributes, so that it can be
+          viewed or modified. Any changes to the user_config will require the owning
+          attributes to be re-registered.)")
       .def_property_readonly(
           "num_user_configs",
           &AbstractAttributes::getNumUserDefinedConfigurations,

src/esp/bindings/CMakeLists.txt

@@ -6,6 +6,7 @@ pybind11_add_module(
   bindings.cpp
   AttributesBindings.cpp
   AttributesManagersBindings.cpp
+  ConfigBindings.cpp
   CoreBindings.cpp
   GeoBindings.cpp
   GfxBindings.cpp

src/esp/bindings/ConfigBindings.cpp

@@ -0,0 +1,208 @@
+// Copyright (c) Facebook, Inc. and its affiliates.
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+
+#include "esp/bindings/bindings.h"
+#include "esp/core/Configuration.h"
+namespace py = pybind11;
+using py::literals::operator""_a;
+using esp::logging::LoggingContext;
+
+namespace esp {
+namespace core {
+namespace config {
+
+void initConfigBindings(py::module& m) {
+  py::enum_<ConfigStoredType>(m, "ConfigStoredType")
+      .value("Unknown", ConfigStoredType::Unknown)
+      .value("Boolean", ConfigStoredType::Boolean)
+      .value("Integer", ConfigStoredType::Integer)
+      .value("Double", ConfigStoredType::Double)
+      .value("String", ConfigStoredType::String)
+      .value("MagnumVec3", ConfigStoredType::MagnumVec3)
+      .value("MagnumQuat", ConfigStoredType::MagnumQuat)
+      .value("MagnumRad", ConfigStoredType::MagnumRad);
+
+  py::class_<Configuration, Configuration::ptr>(m, "Configuration")
+      .def(py::init(&Configuration::create<>))
+
+      .def(
+          "get",
+          [](Configuration& self, const std::string& key) {
+            // switch on type
+            switch (self.getType(key)) {
+              case ConfigStoredType::Boolean:
+                return py::cast(self.get<bool>(key));
+              case ConfigStoredType::Integer:
+                return py::cast(self.get<int>(key));
+              case ConfigStoredType::Double:
+                return py::cast(self.get<double>(key));
+              case ConfigStoredType::String:
+                return py::cast(self.get<std::string>(key));
+              case ConfigStoredType::MagnumVec3:
+                return py::cast(self.get<Mn::Vector3>(key));
+              case ConfigStoredType::MagnumQuat:
+                return py::cast(self.get<Mn::Quaternion>(key));
+              case ConfigStoredType::MagnumRad:
+                return py::cast(self.get<Mn::Rad>(key));
+              default:
+                // unknown type or value not found
+                throw py::value_error("No valid value found for key " + key);
+                return py::cast(nullptr);
+            }
+            CORRADE_INTERNAL_ASSERT_UNREACHABLE();
+          },
+          R"(Retrieve the requested value, if it exists)")
+
+      .def("set", [](Configuration& self, const std::string& key,
+                     const std::string& val) { self.set(key, val); })
+      .def("set", [](Configuration& self, const std::string& key,
+                     const char* val) { self.set(key, val); })
+      .def("set", [](Configuration& self, const std::string& key,
+                     const int val) { self.set(key, val); })
+      .def("set", [](Configuration& self, const std::string& key,
+                     const double val) { self.set(key, val); })
+      .def("set", [](Configuration& self, const std::string& key,
+                     const bool val) { self.set(key, val); })
+      .def("set", [](Configuration& self, const std::string& key,
+                     const Magnum::Quaternion& val) { self.set(key, val); })
+      .def("set", [](Configuration& self, const std::string& key,
+                     const Magnum::Vector3& val) { self.set(key, val); })
+
+      .def(
+          "get_type", &Configuration::getType,
+          R"(Retrieves the ConfigStoredType of the value referred to by the passed key.)")
+
+      .def(
+          "get_as_string", &Configuration::getAsString,
+          R"(Retrieves a string representation of the value referred to by the passed key.)")
+
+      .def("get_bool_keys",
+           &Configuration::getStoredKeys<ConfigStoredType::Boolean>)
+      .def("get_string_keys",
+           &Configuration::getStoredKeys<ConfigStoredType::String>)
+      .def("get_int_keys",
+           &Configuration::getStoredKeys<ConfigStoredType::Integer>)
+      .def("get_float_keys",
+           &Configuration::getStoredKeys<ConfigStoredType::Double>)
+      .def("get_vec3_keys",
+           &Configuration::getStoredKeys<ConfigStoredType::MagnumVec3>)
+      .def("get_quat_keys",
+           &Configuration::getStoredKeys<ConfigStoredType::MagnumQuat>)
+      .def("get_rad_keys",
+           &Configuration::getStoredKeys<ConfigStoredType::MagnumRad>)
+
+      .def("get_keys_and_types", &Configuration::getValueTypes,
+           R"(Returns a dictionary where the keys are the names of the values
+           this configuration holds and the values are the types of these values.)")
+      .def(
+          "get_subconfig_keys", &Configuration::getSubconfigKeys,
+          R"(Retrieves a list of the keys of this configuration's subconfigurations)")
+
+      .def("get_subconfig", &Configuration::editSubconfig,
+           pybind11::return_value_policy::reference,
+           R"(Get the subconfiguration with the given name.)", "name"_a)
+      .def("get_subconfig_copy", &Configuration::getSubconfigCopy,
+           pybind11::return_value_policy::reference,
+           R"(Get a copy of the subconfiguration with the given name.)",
+           "name"_a)
+      .def("save_subconfig", &Configuration::setSubconfigPtr,
+           R"(Save a subconfiguration with the given name.)", "name"_a,
+           "subconfig"_a)
+
+      .def(
+          "find_value_location", &Configuration::findValue,
+          R"(Returns a list of keys, in order, for the traversal of the nested subconfigurations in
+          this Configuration to get the requested key's value or subconfig.  Key is not found if list is empty.)",
+          "key"_a)
+
+      .def(
+          "has_value", &Configuration::hasValue,
+          R"(Returns whether or not this Configuration has the passed key. Does not check subconfigurations.)",
+          "key"_a)
+
+      .def(
+          "has_bool",
+          [](Configuration& self, const std::string& key) {
+            return self.checkMapForKeyAndType<bool>(key);
+          },
+          R"(Returns true if specified key references a boolean value in this configuration.)")
+      .def(
+          "has_int",
+          [](Configuration& self, const std::string& key) {
+            return self.checkMapForKeyAndType<int>(key);
+          },
+          R"(Returns true if specified key references a integer value in this configuration.)")
+      .def(
+          "has_string",
+          [](Configuration& self, const std::string& key) {
+            return self.checkMapForKeyAndType<std::string>(key);
+          },
+          R"(Returns true if specified key references a string value in this configuration.)")
+      .def(
+          "has_float",
+          [](Configuration& self, const std::string& key) {
+            return self.checkMapForKeyAndType<double>(key);
+          },
+          R"(Returns true if specified key references a float value in this configuration.)")
+      .def(
+          "has_quat",
+          [](Configuration& self, const std::string& key) {
+            return self.checkMapForKeyAndType<Mn::Quaternion>(key);
+          },
+          R"(Returns true if specified key references a Magnum::Quaternion value in this configuration.)")
+      .def(
+          "has_vec3",
+          [](Configuration& self, const std::string& key) {
+            return self.checkMapForKeyAndType<Mn::Vector3>(key);
+          },
+          R"(Returns true if specified key references a Magnum::Vector3 value in this configuration.)")
+      .def(
+          "has_rad",
+          [](Configuration& self, const std::string& key) {
+            return self.checkMapForKeyAndType<Mn::Rad>(key);
+          },
+          R"(Returns true if specified key references a Magnum::Rad value in this configuration.)")
+
+      .def(
+          "has_subconfig", &Configuration::hasSubconfig,
+          R"(Returns true if specified key references an existing subconfiguration within this configuration.)")
+
+      .def(
+          "remove",
+          [](Configuration& self, const std::string& key) {
+            // switch on type
+            switch (self.getType(key)) {
+              case ConfigStoredType::Boolean:
+                return py::cast(self.removeAndRetrieve<bool>(key));
+              case ConfigStoredType::Integer:
+                return py::cast(self.removeAndRetrieve<int>(key));
+              case ConfigStoredType::Double:
+                return py::cast(self.removeAndRetrieve<double>(key));
+              case ConfigStoredType::String:
+                return py::cast(self.removeAndRetrieve<std::string>(key));
+              case ConfigStoredType::MagnumVec3:
+                return py::cast(self.removeAndRetrieve<Mn::Vector3>(key));
+              case ConfigStoredType::MagnumQuat:
+                return py::cast(self.removeAndRetrieve<Mn::Quaternion>(key));
+              case ConfigStoredType::MagnumRad:
+                return py::cast(self.removeAndRetrieve<Mn::Rad>(key));
+              default:
+                // unknown type or value not found
+                throw py::value_error("No valid value found for key " + key);
+                return py::cast(nullptr);
+            }
+            CORRADE_INTERNAL_ASSERT_UNREACHABLE();
+          },
+          R"(Retrieve and remove the requested value, if it exists)")
+
+      .def(
+          "remove_subconfig", &Configuration::removeSubconfig,
+          R"(Removes and returns subconfiguration corresponding to passed key, if found. Gives warning otherwise.)");
+
+}  // initConfigBindings
+
+}  // namespace config
+}  // namespace core
+
+}  // namespace esp

src/esp/bindings/CoreBindings.cpp

@@ -3,7 +3,6 @@
 // LICENSE file in the root directory of this source tree.
 
 #include "esp/bindings/bindings.h"
-#include "esp/core/Configuration.h"
 #include "esp/core/random.h"
 
 namespace py = pybind11;
@@ -14,26 +13,6 @@ namespace esp {
 namespace core {
 
 void initCoreBindings(py::module& m) {
-  py::class_<Configuration, Configuration::ptr>(m, "ConfigurationGroup")
-      .def(py::init(&Configuration::create<>))
-      .def("get_bool", &Configuration::getBool)
-      .def("get_string", &Configuration::getString)
-      .def("get_int", &Configuration::getInt)
-      .def("get_double", &Configuration::getDouble)
-      .def("get_vec3", &Configuration::getVec3)
-      .def("get_quat", &Configuration::getQuat)
-      .def("get", &Configuration::getString)
-      .def("set", &Configuration::set<std::string>)
-      .def("set", &Configuration::set<int>)
-      .def("set", &Configuration::set<double>)
-      .def("set", &Configuration::set<bool>)
-      .def("set", &Configuration::set<Magnum::Vector3>)
-      .def("set", &Configuration::set<Magnum::Quaternion>)
-      .def("add_string_to_group", &Configuration::addStringToGroup)
-      .def("get_string_group", &Configuration::getStringGroup)
-      .def("has_value", &Configuration::hasValue)
-      .def("remove_value", &Configuration::removeValue);
-
   // ==== struct RigidState ===
   py::class_<RigidState, RigidState::ptr>(m, "RigidState")
       .def(py::init(&RigidState::create<>))
@@ -70,7 +49,6 @@ void initCoreBindings(py::module& m) {
       });
   core.attr("_logging_context") = new LoggingContext{};
 }
-
 }  // namespace core
 
 }  // namespace esp

src/esp/bindings/bindings.cpp

@@ -108,6 +108,7 @@ PYBIND11_MODULE(habitat_sim_bindings, m) {
   // TODO(msb) gfx, scene, and sensor should not cross-depend
   // TODO(msb) sim and sensor should not cross-depend
   esp::initEspBindings(m);
+  esp::core::config::initConfigBindings(m);
   esp::core::initCoreBindings(m);
   esp::geo::initGeoBindings(m);
   esp::scene::initSceneBindings(m);

src/esp/bindings/bindings.h

@@ -13,7 +13,10 @@ namespace esp {
 namespace core {
 
 void initCoreBindings(pybind11::module& m);
+namespace config {
 
+void initConfigBindings(pybind11::module& m);
+}  // namespace config
 }  // namespace core
 
 namespace geo {

src/esp/core/CMakeLists.txt

@@ -38,6 +38,7 @@ add_library(
   Buffer.h
   Check.cpp
   Check.h
+  Configuration.cpp
   Configuration.h
   esp.cpp
   esp.h