Merge pull request #1605 from Libensemble/refactor/deprecate_from_yaml_toml_json

Refactor / remove ensemble.from_yaml/toml/json

Author: jlnav

docs/examples/calling_scripts.rst

@@ -45,19 +45,6 @@ One worker runs a persistent generator and the other four run the forces simulat
     :caption: tests/scaling_tests/forces/forces_simple/run_libe_forces.py
     :linenos:
 
-Object + yaml Version
-~~~~~~~~~~~~~~~~~~~~~
-
-..  literalinclude:: ../../libensemble/tests/scaling_tests/forces/forces_adv/run_libe_forces_from_yaml.py
-    :language: python
-    :caption: tests/scaling_tests/forces/forces_adv/run_libe_forces_from_yaml.py
-    :linenos:
-
-..  literalinclude:: ../../libensemble/tests/scaling_tests/forces/forces_adv/forces.yaml
-    :language: yaml
-    :caption: tests/scaling_tests/forces/forces_adv/forces.yaml
-    :linenos:
-
 Persistent APOSMM with Gradients
 --------------------------------
 

libensemble/ensemble.py

@@ -1,10 +1,6 @@
-import importlib
-import json
 import logging
 
 import numpy.typing as npt
-import tomli
-import yaml
 
 from libensemble.executors import Executor
 from libensemble.libE import libE
@@ -117,110 +113,6 @@ class Ensemble:
             experiment = Ensemble()
             experiment.sim_specs = sim_specs
 
-    .. dropdown:: Option 3: Loading parameters from files
-
-        .. code-block:: python
-            :linenos:
-
-            from libensemble import Ensemble
-
-            experiment = Ensemble()
-
-            my_experiment.from_yaml("my_parameters.yaml")
-            # or...
-            my_experiment.from_toml("my_parameters.toml")
-            # or...
-            my_experiment.from_json("my_parameters.json")
-
-        .. tab-set::
-
-            .. tab-item:: my_parameters.yaml
-
-                .. code-block:: yaml
-                    :linenos:
-
-                    libE_specs:
-                        save_every_k_gens: 20
-
-                    exit_criteria:
-                        sim_max: 80
-
-                    gen_specs:
-                        gen_f: generator.gen_random_sample
-                        outputs:
-                            x:
-                                type: float
-                                size: 1
-                        user:
-                            gen_batch_size: 5
-
-                    sim_specs:
-                        sim_f: simulator.sim_find_sine
-                        inputs:
-                            - x
-                        outputs:
-                            y:
-                                type: float
-
-            .. tab-item:: my_parameters.toml
-
-                .. code-block:: toml
-                    :linenos:
-
-                    [libE_specs]
-                        save_every_k_gens = 300
-
-                    [exit_criteria]
-                        sim_max = 80
-
-                    [gen_specs]
-                        gen_f = "generator.gen_random_sample"
-                        [gen_specs.outputs]
-                            [gen_specs.outputs.x]
-                                type = "float"
-                                size = 1
-                        [gen_specs.user]
-                            gen_batch_size = 5
-
-                    [sim_specs]
-                        sim_f = "simulator.sim_find_sine"
-                        inputs = ["x"]
-                        [sim_specs.outputs]
-                            [sim_specs.outputs.y]
-                                type = "float"
-
-            .. tab-item:: my_parameters.json
-
-                .. code-block:: json
-                    :linenos:
-
-                    {
-                        "libE_specs": {
-                            "save_every_k_gens": 300,
-                        },
-                        "exit_criteria": {
-                            "sim_max": 80
-                        },
-                        "gen_specs": {
-                            "gen_f": "generator.gen_random_sample",
-                            "outputs": {
-                                "x": {
-                                    "type": "float",
-                                    "size": 1
-                                }
-                            },
-                            "user": {
-                                "gen_batch_size": 5
-                            }
-                        },
-                        "sim_specs": {
-                            "sim_f": "simulator.sim_find_sine",
-                            "inputs": ["x"],
-                            "outputs": {
-                                "f": {"type": "float"}
-                            }
-                        }
-                    }
 
     Parameters
     ----------
@@ -431,111 +323,6 @@ def nworkers(self, value):
         if self._libE_specs:
             self._libE_specs.nworkers = value
 
-    def _get_func(self, loaded):
-        """Extracts user function specified in loaded dict"""
-        func_path_split = loaded.rsplit(".", 1)
-        func_name = func_path_split[-1]
-        try:
-            return getattr(importlib.import_module(func_path_split[0]), func_name)
-        except AttributeError:
-            self._util_logger.manager_warning(ATTR_ERR_MSG.format(func_name))
-            raise
-        except ModuleNotFoundError:
-            self._util_logger.manager_warning(NOTFOUND_ERR_MSG.format(func_name))
-            raise
-
-    @staticmethod
-    def _get_outputs(loaded):
-        """Extracts output parameters from loaded dict"""
-        if not loaded:
-            return []
-        fields = [i for i in loaded]
-        field_params = [i for i in loaded.values()]
-        results = []
-        for i in range(len(fields)):
-            field_type = field_params[i]["type"]
-            built_in_type = __builtins__.get(field_type, field_type)
-            try:
-                if field_params[i]["size"] == 1:
-                    size = (1,)  # formatting how size=1 is typically preferred
-                else:
-                    size = field_params[i]["size"]
-                results.append((fields[i], built_in_type, size))
-            except KeyError:
-                results.append((fields[i], built_in_type))
-        return results
-
-    @staticmethod
-    def _get_normal(loaded):
-        return loaded
-
-    def _get_option(self, specs, name):
-        """Gets a specs value, underlying spec is either a dict or a class"""
-        attr = getattr(self, specs)
-        if isinstance(attr, dict):
-            return attr.get(name)
-        else:
-            return getattr(attr, name)
-
-    def _parse_spec(self, loaded_spec):
-        """Parses and creates traditional libEnsemble dictionary from loaded dict info"""
-
-        field_f = {
-            "sim_f": self._get_func,
-            "gen_f": self._get_func,
-            "alloc_f": self._get_func,
-            "inputs": self._get_normal,
-            "persis_in": self._get_normal,
-            "outputs": self._get_outputs,
-            "globus_compute_endpoint": self._get_normal,
-            "user": self._get_normal,
-        }
-
-        userf_fields = [f for f in loaded_spec if f in field_f.keys()]
-
-        if len(userf_fields):
-            for f in userf_fields:
-                loaded_spec[f] = field_f[f](loaded_spec[f])
-
-        return loaded_spec
-
-    def _parameterize(self, loaded):
-        """Updates and sets attributes from specs loaded from file"""
-        for f in loaded:
-            loaded_spec = self._parse_spec(loaded[f])
-            old_spec = getattr(self, f)
-            ClassType = CORRESPONDING_CLASSES[f]
-            if isinstance(old_spec, dict):
-                old_spec.update(loaded_spec)
-                if old_spec.get("in") and old_spec.get("inputs"):
-                    old_spec.pop("inputs")  # avoid clashes
-                elif old_spec.get("out") and old_spec.get("outputs"):
-                    old_spec.pop("outputs")  # avoid clashes
-                setattr(self, f, ClassType(**old_spec))
-            else:  # None. attribute not set yet
-                setattr(self, f, ClassType(**loaded_spec))
-
-    def from_yaml(self, file_path: str):
-        """Parameterizes libEnsemble from ``yaml`` file"""
-        with open(file_path, "r") as f:
-            loaded = yaml.full_load(f)
-
-        self._parameterize(loaded)
-
-    def from_toml(self, file_path: str):
-        """Parameterizes libEnsemble from ``toml`` file"""
-        with open(file_path, "rb") as f:
-            loaded = tomli.load(f)
-
-        self._parameterize(loaded)
-
-    def from_json(self, file_path: str):
-        """Parameterizes libEnsemble from ``json`` file"""
-        with open(file_path, "rb") as f:
-            loaded = json.load(f)
-
-        self._parameterize(loaded)
-
     def add_random_streams(self, num_streams: int = 0, seed: str = ""):
         """
 
@@ -588,3 +375,11 @@ def save_output(self, basename: str, append_attrs: bool = True):
                 )
             else:
                 save_libE_output(self.H, self.persis_info, basename, self.nworkers, append_attrs=append_attrs)
+
+    def _get_option(self, specs, name):
+        """Gets a specs value, underlying spec is either a dict or a class"""
+        attr = getattr(self, specs)
+        if isinstance(attr, dict):
+            return attr.get(name)
+        else:
+            return getattr(attr, name)