Add configuration reading support to CMOOSApp wrapper

Co-authored-by: msis <577139+msis@users.noreply.github.com>

Author: Copilot

Documentation/examples/simpleapp.moos

@@ -0,0 +1,26 @@
+// Example mission file for simpleapp.py
+// To run: python simpleapp.py --mission_file=simpleapp.moos
+
+ServerHost = localhost
+ServerPort = 9000
+Community  = pymoos_example
+
+// Start MOOSDB with: MOOSDB simpleapp.moos
+
+ProcessConfig = MOOSDB
+{
+  ServerHost = localhost
+  ServerPort = 9000
+}
+
+ProcessConfig = pymoos_simple_app
+{
+  AppTick   = 1.0
+  CommsTick = 5.0
+  
+  // Custom configuration parameters
+  app_freq = 2.0
+  comms_freq = 10.0
+  variable_name = simple_app_var
+  max_iterations = 10
+}

Documentation/examples/simpleapp.py

@@ -12,8 +12,30 @@
 # OnStartUp is called when the app first starts
 def on_startup():
     print("App starting up...")
-    app.set_app_freq(1.0)  # Set how often Iterate is called (Hz)
-    app.set_comms_freq(5.0)  # Set how often comms happen (Hz)
+    
+    # Read configuration from the mission file
+    # The mission file should have a ProcessConfig block for this app
+    success, freq = app.get_configuration_double('app_freq')
+    if success:
+        print(f"Setting app frequency from config: {freq} Hz")
+        app.set_app_freq(freq)
+    else:
+        print("Using default app frequency: 1.0 Hz")
+        app.set_app_freq(1.0)
+    
+    success, comms_freq = app.get_configuration_double('comms_freq')
+    if success:
+        print(f"Setting comms frequency from config: {comms_freq} Hz")
+        app.set_comms_freq(comms_freq)
+    else:
+        print("Using default comms frequency: 5.0 Hz")
+        app.set_comms_freq(5.0)
+    
+    # Read other configuration parameters
+    success, var_name = app.get_configuration_string('variable_name')
+    if success:
+        print(f"Will publish to variable: {var_name}")
+    
     return True
 
 # OnConnectToServer is called when connection to MOOSDB is established
@@ -52,6 +74,9 @@ def main():
     app.set_iterate_callback(iterate)
 
     # Run the application (this blocks until iterate returns False)
+    # You can optionally provide a mission file path for configuration:
+    # app.run('localhost', 9000, 'pymoos_simple_app', 'simpleapp.moos')
+    # Or run without a mission file (using defaults in on_startup):
     app.run('localhost', 9000, 'pymoos_simple_app')
 
 if __name__ == "__main__":

README.md

@@ -55,7 +55,12 @@ import pymoos
 app = pymoos.app()
 
 def on_startup():
-    app.set_app_freq(10.0)  # Hz
+    # Read configuration from mission file
+    success, freq = app.get_configuration_double('app_freq')
+    if success:
+        app.set_app_freq(freq)
+    else:
+        app.set_app_freq(10.0)  # Default Hz
     return True
 
 def on_connect_to_server():
@@ -69,8 +74,17 @@ app.set_on_start_up_callback(on_startup)
 app.set_on_connect_to_server_callback(on_connect_to_server)
 app.set_iterate_callback(iterate)
 
-app.run('localhost', 9000, 'my_app')
+# Optionally provide a mission file for configuration
+app.run('localhost', 9000, 'my_app', 'my_mission.moos')
 ```
 
+The `app` class supports reading configuration from MOOS mission files using:
+- `get_configuration_string(param)` - Read string parameters
+- `get_configuration_double(param)` - Read numeric parameters
+- `get_configuration_int(param)` - Read integer parameters
+- `get_configuration_bool(param)` - Read boolean parameters
+
+All methods return a tuple `(success, value)`.
+
 See `Documentation/examples/simpleapp.py` for a complete example.
 

src/pyMOOS.cpp

@@ -361,6 +361,48 @@ class AppWrapper : public CMOOSApp {
         return true;
     }
 
+    // Configuration reading methods
+    bool GetConfigurationParam(const std::string& sParam, std::string& sVal) {
+        return m_MissionReader.GetConfigurationParam(sParam, sVal);
+    }
+
+    bool GetConfigurationParam(const std::string& sParam, double& dVal) {
+        return m_MissionReader.GetConfigurationParam(sParam, dVal);
+    }
+
+    bool GetConfigurationParam(const std::string& sParam, int& nVal) {
+        return m_MissionReader.GetConfigurationParam(sParam, nVal);
+    }
+
+    bool GetConfigurationParam(const std::string& sParam, bool& bVal) {
+        return m_MissionReader.GetConfigurationParam(sParam, bVal);
+    }
+
+    // Python-friendly wrappers that return tuples (success, value)
+    py::tuple GetConfigurationString(const std::string& sParam) {
+        std::string sVal;
+        bool bSuccess = m_MissionReader.GetConfigurationParam(sParam, sVal);
+        return py::make_tuple(bSuccess, sVal);
+    }
+
+    py::tuple GetConfigurationDouble(const std::string& sParam) {
+        double dVal = 0.0;
+        bool bSuccess = m_MissionReader.GetConfigurationParam(sParam, dVal);
+        return py::make_tuple(bSuccess, dVal);
+    }
+
+    py::tuple GetConfigurationInt(const std::string& sParam) {
+        int nVal = 0;
+        bool bSuccess = m_MissionReader.GetConfigurationParam(sParam, nVal);
+        return py::make_tuple(bSuccess, nVal);
+    }
+
+    py::tuple GetConfigurationBool(const std::string& sParam) {
+        bool bVal = false;
+        bool bSuccess = m_MissionReader.GetConfigurationParam(sParam, bVal);
+        return py::make_tuple(bSuccess, bVal);
+    }
+
 private:
     /** callback functions (stored) */
     py::object on_new_mail_object_;
@@ -741,6 +783,34 @@ PYBIND11_MODULE(pymoos, m) {
                     "This is the main work loop of the application.",
                     py::arg("func"))
 
+        .def("get_configuration_string",
+                    &MOOS::AppWrapper::GetConfigurationString,
+                    "Read a string parameter from the mission file configuration block. "
+                    "Returns a tuple (success, value) where success is True if the "
+                    "parameter was found.",
+                    py::arg("param"))
+        
+        .def("get_configuration_double",
+                    &MOOS::AppWrapper::GetConfigurationDouble,
+                    "Read a double parameter from the mission file configuration block. "
+                    "Returns a tuple (success, value) where success is True if the "
+                    "parameter was found.",
+                    py::arg("param"))
+        
+        .def("get_configuration_int",
+                    &MOOS::AppWrapper::GetConfigurationInt,
+                    "Read an integer parameter from the mission file configuration block. "
+                    "Returns a tuple (success, value) where success is True if the "
+                    "parameter was found.",
+                    py::arg("param"))
+        
+        .def("get_configuration_bool",
+                    &MOOS::AppWrapper::GetConfigurationBool,
+                    "Read a boolean parameter from the mission file configuration block. "
+                    "Returns a tuple (success, value) where success is True if the "
+                    "parameter was found.",
+                    py::arg("param"))
+        
         ;
 
 

tests/test.py

@@ -440,6 +440,87 @@ def iterate():
         # Verify we received our message
         self.assertTrue(self.received_mail)
 
+    def test_42_app_configuration(self):
+        """Test app configuration reading"""
+        logger.debug(' on ')
+        
+        # Create a temporary mission file
+        import tempfile
+        import os
+        
+        mission_content = """
+ServerHost = localhost
+ServerPort = 9000
+Community  = pymoos_test_db
+
+ProcessConfig = test_app_config
+{
+    test_string = hello_world
+    test_double = 3.14
+    test_int = 42
+    test_bool = true
+}
+"""
+        
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.moos', delete=False) as f:
+            f.write(mission_content)
+            mission_file = f.name
+        
+        try:
+            a = pymoos.app()
+            
+            self.config_read = False
+            self.test_values = {}
+            
+            def on_startup():
+                logger.debug('on_startup called')
+                
+                # Read configuration parameters
+                success, val = a.get_configuration_string('test_string')
+                if success:
+                    self.test_values['test_string'] = val
+                
+                success, val = a.get_configuration_double('test_double')
+                if success:
+                    self.test_values['test_double'] = val
+                
+                success, val = a.get_configuration_int('test_int')
+                if success:
+                    self.test_values['test_int'] = val
+                
+                success, val = a.get_configuration_bool('test_bool')
+                if success:
+                    self.test_values['test_bool'] = val
+                
+                self.config_read = True
+                a.set_app_freq(10.0)
+                return True
+            
+            self.iteration_count = 0
+            def iterate():
+                self.iteration_count += 1
+                if self.iteration_count >= 2:
+                    return False
+                return True
+            
+            a.set_on_start_up_callback(on_startup)
+            a.set_iterate_callback(iterate)
+            
+            # Run the app with mission file
+            a.run('localhost', 9000, 'test_app_config', mission_file)
+            
+            # Verify configuration was read
+            self.assertTrue(self.config_read)
+            self.assertEqual(self.test_values.get('test_string'), 'hello_world')
+            self.assertEqual(self.test_values.get('test_double'), 3.14)
+            self.assertEqual(self.test_values.get('test_int'), 42)
+            self.assertEqual(self.test_values.get('test_bool'), True)
+            
+        finally:
+            # Clean up temporary file
+            if os.path.exists(mission_file):
+                os.unlink(mission_file)
+
 
 if __name__ == '__main__':
     unittest.main()