Merge pull request #1020 from vsbogd/no-config-dir-by-default

Make MeTTa runner not read config dir by default

Author: vsbogd

c/src/metta.rs

@@ -1525,8 +1525,7 @@ pub extern "C" fn env_builder_set_working_dir(builder: *mut env_builder_t, path:
     *builder_arg_ref = builder.into();
 }
 
-/// @brief Sets the config directory for the environment.  A directory at the specified path
-/// will be created, and its contents populated with default values, if one does not already exist
+/// @brief Sets the config directory for the environment.
 /// @ingroup environment_group
 /// @param[in]  builder  A pointer to the in-process environment builder state
 /// @param[in]  path  A C-style string specifying a path to the config directory
@@ -1556,15 +1555,15 @@ pub extern "C" fn env_builder_create_config_dir(builder: *mut env_builder_t, sho
     *builder_arg_ref = builder.into();
 }
 
-/// @brief Configures the environment so that no config directory will be read nor created
+/// @brief Sets the default config directory for the environment.
 /// @ingroup environment_group
 /// @param[in]  builder  A pointer to the in-process environment builder state
 ///
 #[no_mangle]
-pub extern "C" fn env_builder_disable_config_dir(builder: *mut env_builder_t) {
+pub extern "C" fn env_builder_set_default_config_dir(builder: *mut env_builder_t) {
     let builder_arg_ref = unsafe{ &mut *builder };
     let builder = core::mem::replace(builder_arg_ref, env_builder_t::null()).into_inner();
-    let builder = builder.set_no_config_dir();
+    let builder = builder.set_default_config_dir();
     *builder_arg_ref = builder.into();
 }
 

lib/src/metta/runner/environment.rs

@@ -111,7 +111,6 @@ impl Environment {
 /// NOTE: It is not necessary to use the EnvBuilder if the default environment is acceptable
 pub struct EnvBuilder {
     env: Environment,
-    no_cfg_dir: bool,
     create_cfg_dir: bool,
     caches_dir: Option<PathBuf>,
     #[cfg(feature = "pkg_mgmt")]
@@ -135,8 +134,8 @@ impl EnvBuilder {
     /// NOTE: Unless otherwise specified, the default working directory will be the current process
     /// working dir (`cwd`)
     ///
-    /// NOTE: Unless otherwise specified by calling either [Self::set_no_config_dir] or [Self::set_config_dir], the
-    ///   [Environment] will be configured using files in the OS-Specific configuration file locations.
+    /// NOTE: Unless otherwise specified by calling either [Self::set_default_config_dir] or [Self::set_config_dir], the
+    ///   [Environment] will be configured using no configuration directory.
     ///
     /// Depending on the host OS, the config directory locations will be:
     /// * Linux: ~/.config/metta/
@@ -147,9 +146,8 @@ impl EnvBuilder {
     pub fn new() -> Self {
         Self {
             env: Environment::new(),
-            no_cfg_dir: false,
             caches_dir: None,
-            create_cfg_dir: true,
+            create_cfg_dir: false,
             #[cfg(feature = "pkg_mgmt")]
             proto_catalogs: vec![],
             #[cfg(feature = "pkg_mgmt")]
@@ -162,7 +160,7 @@ impl EnvBuilder {
     /// The `test_env` Environment will not load or create any files.  Additionally
     /// this method will initialize the logger for the test environment
     pub fn test_env() -> Self {
-        EnvBuilder::new().set_working_dir(None).set_is_test(true).set_no_config_dir()
+        EnvBuilder::new().set_working_dir(None).set_is_test(true)
     }
 
     /// Sets (or unsets) the working_dir for the environment
@@ -174,10 +172,7 @@ impl EnvBuilder {
     /// Sets the `config_dir` that the environment will load
     pub fn set_config_dir(mut self, config_dir: &Path) -> Self {
         self.env.config_dir = Some(config_dir.into());
-        if self.no_cfg_dir {
-            panic!("Fatal Error: set_config_dir is incompatible with set_no_config_dir");
-        }
-        self
+        self.set_create_config_dir(true)
     }
 
     /// Sets the directory used for caching files, such as those fetched from remote catalogs
@@ -193,20 +188,21 @@ impl EnvBuilder {
     /// NOTE: If the config directory exists but some config files are missing, default files will *not* be created.
     pub fn set_create_config_dir(mut self, should_create: bool) -> Self {
         self.create_cfg_dir = should_create;
-        if self.no_cfg_dir && should_create {
-            panic!("Fatal Error: set_create_config_dir(true) is incompatible with set_no_config_dir");
+        if self.env.config_dir.is_none() && should_create {
+            panic!("Fatal Error: call set_default_config_dir() or set_config_dir(<path>) before calling set_create_config_dir(true)");
         }
         self
     }
 
-    /// Configures the Environment not to load nor create any config files
-    pub fn set_no_config_dir(mut self) -> Self {
-        self.no_cfg_dir = true;
-        self.create_cfg_dir = false;
-        if self.env.config_dir.is_some() {
-            panic!("Fatal Error: set_config_dir is incompatible with set_no_config_dir");
+    /// Sets the `config_dir` to the default configuration directory path
+    pub fn set_default_config_dir(self) -> Self {
+        match ProjectDirs::from("io", "TrueAGI",  "metta") {
+            Some(proj_dirs) => self.set_config_dir(proj_dirs.config_dir()),
+            None => {
+                eprint!("Failed to initialize config with OS config directory!");
+                self
+            }
         }
-        self
     }
 
     /// Sets the `is_test` flag for the environment, to specify whether the environment is a unit-test
@@ -283,21 +279,6 @@ impl EnvBuilder {
             proto_catalogs.insert(0, ProtoCatalog::Path(working_dir.into()));
         }
 
-        //Construct the platform-specific config dir location, if an explicit location wasn't provided
-        if !self.no_cfg_dir {
-            if env.config_dir.is_none() {
-                match ProjectDirs::from("io", "TrueAGI",  "metta") {
-                    Some(proj_dirs) => {
-                        let cfg_dir: PathBuf = proj_dirs.config_dir().into();
-                        env.config_dir = Some(cfg_dir);
-                    },
-                    None => {
-                        eprint!("Failed to initialize config with OS config directory!");
-                    }
-                }
-            }
-        }
-
         if let Some(config_dir) = &env.config_dir {
 
             let init_metta_path = config_dir.join("init.metta");

lib/src/metta/runner/mod.rs

@@ -1426,4 +1426,9 @@ mod tests {
         assert_eq!(result, Ok(vec![vec![]]));
     }
 
+    #[test]
+    fn metta_no_config_dir_by_default() {
+        let metta = Metta::new(None);
+        assert_eq!(metta.environment().config_dir(), None);
+    }
 }

python/hyperon/exts/agents/agent_base.py

@@ -144,7 +144,7 @@ def _init_metta(self):
         # the caller space is not directly accessible as a context,
         # except the case when _metta is set via get_agent_atom with parent MeTTa
         if self._include_paths is not None:
-            env_builder = Environment.custom_env(include_paths=self._include_paths)
+            env_builder = Environment.custom_env(include_paths=self._include_paths, config_dir="")
             metta = MeTTa(env_builder=env_builder)
         else:
             metta = MeTTa()

python/hyperon/metta.py

@@ -31,7 +31,7 @@ def main():
     elif args.file:
         parent_dir = os.path.dirname(args.file)
         with open(args.file) as f: program = f.read()
-        metta = hyperon.MeTTa(env_builder=hyperon.Environment.custom_env(working_dir=parent_dir))
+        metta = hyperon.MeTTa(env_builder=hyperon.Environment.custom_env(working_dir=parent_dir, config_dir=""))
         for result in metta.run(program):
             print(result)
     else:

python/hyperon/runner.py

@@ -116,6 +116,7 @@ def __init__(self, cmetta = None, space = None, env_builder = None):
                 space = GroundingSpaceRef()
             if env_builder is None:
                 env_builder = hp.env_builder_start()
+                hp.env_builder_set_default_config_dir(env_builder)
             hp.env_builder_push_fs_module_format(env_builder, _PyFileMeTTaModFmt)
             #LP-TODO-Next, add an fs_module_fmt arg to the standardized way to init environments, so that
             # the Python user can define additional formats without tweaking any hyperon files.  To make
@@ -233,28 +234,53 @@ def config_dir():
         else:
             return None
 
-    def init_common_env(working_dir = None, config_dir = None, create_config = True, disable_config = False, is_test = False, include_paths = []):
-        """Initialize the common environment with the supplied args"""
-        builder = Environment.custom_env(working_dir, config_dir, create_config, disable_config, is_test, include_paths)
+    def init_common_env(working_dir = None, config_dir = None, create_config = None, is_test = None, include_paths = []):
+        """Initialize the common environment with the supplied args
+
+        Keyword arguments:
+            working_dir -- working directory for the environment (default None)
+            config_dir -- path to the configuration directory, None - no
+            configuration directory, "" - default configuration directory
+            (default None)
+            create_config -- create configuration directory if it doesn't exist
+            (default None)
+            is_test -- is environment used in unit-test flag (default None)
+            include_paths -- additional search paths to search for MeTTa
+            modules in the file system (default [])
+        """
+        builder = Environment.custom_env(working_dir, config_dir, create_config, is_test, include_paths)
         return hp.env_builder_init_common_env(builder)
 
     def test_env():
         """Returns an EnvBuilder object specifying a unit-test environment, that can be used to init a MeTTa runner"""
         return hp.env_builder_use_test_env()
 
-    def custom_env(working_dir = None, config_dir = None, create_config = True, disable_config = False, is_test = False, include_paths = []):
-        """Returns an EnvBuilder object that can be used to init a MeTTa runner, if you need multiple environments to coexist in the same process"""
+    def custom_env(working_dir = None, config_dir = None, create_config = None, is_test = None, include_paths = []):
+        """Returns an EnvBuilder object that can be used to init a MeTTa runner, if you need multiple environments to coexist in the same process
+
+        Keyword arguments:
+            working_dir -- working directory for the environment (default None)
+            config_dir -- path to the configuration directory, None - no
+            configuration directory, "" - default configuration directory
+            (default None)
+            create_config -- create configuration directory if not found
+            (default None)
+            is_test -- is environment used in unit-test flag (default None)
+            include_paths -- additional search paths to search for MeTTa
+            modules in the file system (default [])
+        """
         builder = hp.env_builder_start()
-        if (working_dir is not None):
+        if working_dir is not None:
             hp.env_builder_set_working_dir(builder, working_dir)
-        if (config_dir is not None):
-            hp.env_builder_set_config_dir(builder, config_dir)
-        if (create_config is False):
-            hp.env_builder_create_config_dir(builder, False) #Pass False to disable "create if missing" behavior
-        if (disable_config):
-            hp.env_builder_disable_config_dir(builder)
-        if (is_test):
-            hp.env_builder_set_is_test(builder, True)
+        if config_dir is not None:
+            if config_dir == "":
+                hp.env_builder_set_default_config_dir(builder)
+            else:
+                hp.env_builder_set_config_dir(builder, config_dir)
+        if create_config is not None:
+            hp.env_builder_create_config_dir(builder, create_config)
+        if is_test is not None:
+            hp.env_builder_set_is_test(builder, is_test)
         for path in include_paths:
             hp.env_builder_push_include_path(builder, path)
         return builder

python/hyperonpy.cpp

@@ -1159,8 +1159,8 @@ PYBIND11_MODULE(hyperonpy, m) {
     m.def("env_builder_set_working_dir", [](EnvBuilder& builder, std::string path) { env_builder_set_working_dir(builder.ptr(), path.c_str()); }, "Sets the working dir in the environment");
     m.def("env_builder_set_config_dir", [](EnvBuilder& builder, std::string path) { env_builder_set_config_dir(builder.ptr(), path.c_str()); }, "Sets the config dir in the environment");
     m.def("env_builder_create_config_dir", [](EnvBuilder& builder, bool should_create) { env_builder_create_config_dir(builder.ptr(), should_create); }, "Creates the config dir if it doesn't exist");
-    m.def("env_builder_disable_config_dir", [](EnvBuilder& builder) { env_builder_disable_config_dir(builder.ptr()); }, "Disables the config dir in the environment");
-    m.def("env_builder_set_is_test", [](EnvBuilder& builder, bool is_test) { env_builder_set_is_test(builder.ptr(), is_test); }, "Disables the config dir in the environment");
+    m.def("env_builder_set_default_config_dir", [](EnvBuilder& builder) { env_builder_set_default_config_dir(builder.ptr()); }, "Sets default config directory location");
+    m.def("env_builder_set_is_test", [](EnvBuilder& builder, bool is_test) { env_builder_set_is_test(builder.ptr(), is_test); }, "Set true if this environment is used in unit test");
     m.def("env_builder_push_include_path", [](EnvBuilder& builder, std::string path) { env_builder_push_include_path(builder.ptr(), path.c_str()); }, "Adds an include path to the environment");
     m.def("env_builder_push_fs_module_format", [](EnvBuilder& builder, py::object interface) {
         //TODO. We end up leaking this object, but it's a non-issue in practice because environments usually live the life of the program.

python/tests/test_environment.py

@@ -11,4 +11,4 @@ def testEnvironment(self):
         self.assertTrue(Environment.init_common_env(config_dir = "/tmp/hyperon-test", create_config = True))
         self.assertEqual(Environment.config_dir(), "/tmp/hyperon-test")
 
-        self.assertFalse(Environment.init_common_env(disable_config = True))
+        self.assertFalse(Environment.init_common_env())

python/tests/test_extend.py

@@ -13,7 +13,7 @@ def test_extend(self):
         '''
         This test verifies that importing from a python-implemnted module along with @register_atoms and @register_tokens works
         '''
-        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), disable_config=True, is_test=True))
+        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), is_test=True))
         self.assertEqual(
             metta.run('''
               !(import! &self extension)
@@ -30,7 +30,7 @@ def test_extend(self):
             [[ValueAtom(12)]])
 
     def test_grounded_noext(self):
-        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), disable_config=True, is_test=True))
+        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), is_test=True))
 
         @grounded(metta)
         def abs_dif(x, y):
@@ -47,7 +47,7 @@ def test_extend_dir_pymod(self):
         '''
         This test verifies that importing from a python module directory also works
         '''
-        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), disable_config=True, is_test=True))
+        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), is_test=True))
         self.assertEqual(
             metta.run('''
               !(import! &self ext_dir)
@@ -67,7 +67,7 @@ def test_extend_dir_pymod(self):
     #     '''
     #     This test verifies that importing from a module that imports its own sub-module also works
     #     '''
-    #     metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), disable_config=True, is_test=True))
+    #     metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), is_test=True))
     #     self.assertEqual(
     #         metta.run('''
     #           !(import! &self ext_sub)
@@ -84,7 +84,7 @@ def test_extend_recursive_pymod(self):
         '''
         This test verifies that importing from a sub-module will cause the necessary parents to be imported as well
         '''
-        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), disable_config=True, is_test=True))
+        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), is_test=True))
         self.assertEqual(
             metta.run('''
               !(import! &self ext_recursive:level-2:ext_nested)
@@ -107,7 +107,7 @@ def test_extend_global(self):
         from extension import g_object
         # Sanity check
         self.assertEqual(g_object, None)
-        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), disable_config=True, is_test=True))
+        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), is_test=True))
         metta.run('''
           !(import! &self extension)
           !(set-global! 42)
@@ -127,7 +127,7 @@ def test_error_pyext(self):
         '''
         This test verifies that an error from a Python extension is properly propagated
         '''
-        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), disable_config=True, is_test=True))
+        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), is_test=True))
         result = metta.run("!(import! &self error_pyext)")
         self.assertEqual(S('Error'), result[0][0].get_children()[0])
 

python/tests/test_modules.py

@@ -10,7 +10,7 @@ def test_python_file_mod_format(self):
         Tests that a MeTTa module, implemented as a '.py', file will be correctly identified when the
         module system searches in the include directory, and then that it will be sucessfully loaded
         """
-        runner = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), disable_config=True, is_test=True))
+        runner = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), is_test=True))
 
         #Make sure the `import!` operation finds the pyfile_test_mod.py file, recognizes it as a
         # MeTTa module using the PythonFileModuleFormat, and loads the MeTTa module it sucessfully
@@ -24,7 +24,7 @@ def test_python_file_mod_format(self):
         self.assertEqual(result[0].get_object().content, 3.14159)
 
     def test_include(self):
-        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), disable_config=True, is_test=True))
+        metta = MeTTa(env_builder=Environment.custom_env(working_dir=os.getcwd(), is_test=True))
         result = metta.run("""
             (three isprime)
             !(match &self ($x isprime) $x)
@@ -43,7 +43,7 @@ def test_py_ops(self):
         """
         Tests that a MeTTa module from exts can be imported
         """
-        runner = MeTTa(env_builder=Environment.custom_env())
+        runner = MeTTa(env_builder=Environment.custom_env(config_dir=""))
         runner.run("!(import! &self py_ops)")
         result = runner.run('!(* "a" 4)')
         self.assertEqual(result[0][0], ValueAtom('aaaa'))