11class Config:
 12    """Class for configuration.
 13
 14    Config object contains the config dict and the processing list
 15    and no methods except `__init__`, `__repr__`, `__eq__`,
 16    `__getattribute__`, `__setattr__` and `__delattr__`.
 17    The Config objects are mutable and not hashable.
 18
 19    Parameters
 20    ----------
 21    config_dict : Dict[str, Any]
 22        The config dict.
 23    process_list : Optional[List[Processing]], optional
 24        The list of Processing objects. If None, an empty list is used.
 25        The default is None.
 26
 27    Examples
 28    --------
 29    >>> config = Config({"a": 1, "b": {"c": 2}})
 30    >>> config.dict
 31    {"a": 1, "b": {"c": 2}}
 32    >>> config.process_list
 33    []
 34    >>> config.b
 35    Config({"c": 2}, [])
 36    >>> config.b.c
 37    2
 38    """
 39
 40    def __init__(
 41        self,
 42        config_dict: Dict[str, Any],
 43        process_list: Optional[List["Processing"]] = None,
 44    ) -> None:
 45        self.dict = config_dict
 46        self.process_list = process_list if process_list else []
 47
 48    def __dir__(self) -> List[str]:
 49        """List of attributes, sub-configurations and parameters."""
 50        return ["dict", "process_list"] + list(self.dict.keys())
 51
 52    def __repr__(self) -> str:
 53        """Representation of Config object."""
 54        process_classes = [process.__class__.__name__ for process in self.process_list]
 55        return f"Config({self.dict}, {process_classes})"
 56
 57    def __eq__(self, other: Any) -> bool:
 58        """Equality operator.
 59
 60        Two Config objects are equal if their dicts are equal and their
 61        lists of Processing objects are equal (order doesn't matter).
 62        """
 63        if (
 64            isinstance(other, Config)
 65            and self.dict == other.dict
 66            and len(self.process_list) == len(other.process_list)
 67        ):
 68            equal = True
 69            for processing in self.process_list:
 70                equal = equal and processing in other.process_list
 71            for processing in other.process_list:
 72                equal = equal and processing in self.process_list
 73            return equal
 74        return False
 75
 76    def __getattribute__(self, __name: str) -> Any:
 77        """Get attribute, sub-configuration or parameter.
 78
 79        The dict should be nested (unflattened). If it is not the case,
 80        you can apply `cliconfig.dict_routines.flatten` on `config.dict`
 81        to unflatten it.
 82        """
 83        if __name in ["dict", "process_list"]:
 84            return super().__getattribute__(__name)
 85        if __name not in self.dict:
 86            keys = ", ".join(self.dict.keys())
 87            raise AttributeError(  # pylint: disable=raise-missing-from
 88                f"Config has no attribute '{__name}'. Available keys are: {keys}."
 89            )
 90        if isinstance(self.dict[__name], dict):
 91            # If the attribute is a dict, return a Config object
 92            # so that we can access the nested keys with multiple dots
 93            return Config(self.dict[__name], process_list=self.process_list)
 94        return self.dict[__name]
 95
 96    def __setattr__(self, __name: str, value: Any) -> None:
 97        """Set attribute, sub-configuration or parameter.
 98
 99        The dict should be nested (unflattened). If it is not the case,
100        you can apply `cliconfig.dict_routines.flatten` on `config.dict`
101        to unflatten it.
102        """
103        if __name in ["dict", "process_list"]:
104            super().__setattr__(__name, value)
105        else:
106            self.dict[__name] = value
107
108    def __delattr__(self, __name: str) -> None:
109        """Delete attribute, sub-configuration or parameter.
110
111        The dict should be nested (unflattened). If it is not the case,
112        you can apply `cliconfig.dict_routines.flatten` on `config.dict`
113        to unflatten it.
114        """
115        if __name in ["dict", "process_list"]:
116            super().__delattr__(__name)
117        else:
118            del self.dict[__name]

945class DefaultProcessings:
946    """Default list of built-in processings.
947
948    To add these processings to a Config instance, use:
949    ```python
950    config.process_list += DefaultProcessings().list
951    ```
952
953    The current default processing list contains:
954     * ProcessCheckTags: protect against '@' in keys at the end of pre-merge)
955     * ProcessMerge (@merge_all, @merge_before, @merge_after): merge multiple
956       files into one.
957     * ProcessCopy (@copy): persistently copy a value from one key to an other
958       and protect it
959     * ProcessTyping (@type:X): force the type of parameter to any type X.
960     * ProcessSelect (@select): select sub-config(s) to keep and delete the
961       other sub-configs in the same parent config.
962     * ProcessDelete (@delete): delete the parameter tagged with @delete on
963       pre-merge.
964    """
965
966    def __init__(self) -> None:
967        self.list: List[Processing] = [
968            ProcessCheckTags(),
969            ProcessMerge(),
970            ProcessCopy(),
971            ProcessDef(),
972            ProcessTyping(),
973            ProcessSelect(),
974            ProcessDelete(),
975            ProcessDict(),
976            ProcessNew(),
977        ]

11class Processing:
12    """Processing base class.
13
14    Each processing classes contains pre-merge, post-merge, pre-save
15    and post-load processing. They are used with routines that apply
16    processing in `cliconfig.process_routines` and
17    `cliconfig.config_routines`.
18
19    That are applied in the order defined
20    by the order attribute in case of multiple processing.
21    """
22
23    def __init__(self) -> None:
24        self.premerge_order = 0.0
25        self.postmerge_order = 0.0
26        self.endbuild_order = 0.0
27        self.presave_order = 0.0
28        self.postload_order = 0.0
29
30    def premerge(self, flat_config: Config) -> Config:
31        """Pre-merge processing.
32
33        Function applied to the flat config to modify it
34        before merging. It takes a flat config and returns a flat config.
35        """
36        return flat_config
37
38    def postmerge(self, flat_config: Config) -> Config:
39        """Post-merge processing.
40
41        Function applied to the flat config to modify it
42        after merging . It takes a flat config and returns a flat config.
43        """
44        return flat_config
45
46    def endbuild(self, flat_config: Config) -> Config:
47        """End-build processing.
48
49        Function applied to the flat config to modify it at the end of
50        a building process (typically `cliconfig.config_routines.make_config`
51        or `cliconfig.config_routines.load_config`).
52        It takes a flat config and returns a flat config.
53        """
54        return flat_config
55
56    def presave(self, flat_config: Config) -> Config:
57        """Pre-save processing.
58
59        Function applied to the flat config to modify it before
60        saving. It takes a flat config and returns a flat config.
61        """
62        return flat_config
63
64    def postload(self, flat_config: Config) -> Config:
65        """Post-load processing.
66
67        Function applied to the flat config to modify it after
68        loading. It takes a flat config and returns a flat config.
69        """
70        return flat_config
71
72    def __repr__(self) -> str:
73        """Representation of Processing object."""
74        return f"{self.__class__.__name__}"
75
76    def __eq__(self, __value: object) -> bool:
77        """Equality operator.
78
79        Two processing are equal if they are the same class and add the same
80        attributes (accessed with `__dict__`).
81        """
82        equal = (
83            isinstance(__value, self.__class__) and self.__dict__ == __value.__dict__
84        )
85        return equal

141def create_processing_keep_property(
142    func: Callable,
143    regex: Optional[str] = None,
144    tag_name: Optional[str] = None,
145    premerge_order: float = 0.0,
146    postmerge_order: float = 0.0,
147    endbuild_order: float = 0.0,
148) -> Processing:
149    """Create a processing object that keep a property from a value using tag or regex.
150
151    The pre-merge processing looks for keys that match the tag or the regex, apply
152    the function func on the value and store the result (= the "property"):
153    `property = func(flat_dict[key])`.
154    The post-merge processing will check that the property is the same as the one
155    stored during pre-merge. If not, it will raise a ValueError.
156
157    It also possible to pass the flat config as a second argument of the function
158    `func`. In this case, the function apply
159    `property = func(flat_dict[key], flat_config)`.
160
161    Parameters
162    ----------
163    func : Callable
164        The function to apply to the value (and eventually the flat config)
165        to define the property to keep.
166        property = func(flat_dict[key]) or func(flat_dict[key], flat_config)
167    regex : Optional[str]
168        The regex to match the key.
169    tag_name : Optional[str]
170        The tag (without "@") to match the key. The values are modified when
171        triggering the pattern ".*@<tag_name>.*" and the tag is removed from the key.
172    premerge_order : float, optional
173        The pre-merge order, by default 0.0
174    postmerge_order : float, optional
175        The post-merge order, by default 0.0
176    endbuild_order : float, optional
177        The end-build order, by default 0.0
178
179    Raises
180    ------
181    ValueError
182        If both tag and regex are provided or if none of them are provided.
183
184    Returns
185    -------
186    Processing
187        The processing object with the pre-merge and post-merge methods.
188
189    Examples
190    --------
191    A processing that enforce the types of all the parameters to be constant
192    (equal to the type of the first value encountered):
193
194    ```python
195    create_processing_keep_property(
196        type,
197        regex=".*",
198        premerge_order=15.0,
199        postmerge_order=15.0,
200        endbuild_order=15.0
201    )
202    ```
203
204    A processing that protect parameters tagged with @protect from being changed:
205
206    ```python
207    create_processing_keep_property(
208        lambda x: x,
209        tag_name="protect",
210        premerge_order=15.0,
211        postmerge_order=15.0
212    )
213    ```
214    """
215    if tag_name is not None:
216        if regex is not None:
217            raise ValueError("You must provide a tag or a regex but not both.")
218    else:
219        if regex is None:
220            raise ValueError(
221                "You must provide a tag or a regex (to trigger the value update)."
222            )
223    processing = _ProcessingKeepProperty(
224        func,
225        regex=regex,
226        tag_name=tag_name,
227        premerge_order=premerge_order,
228        postmerge_order=postmerge_order,
229        endbuild_order=endbuild_order,
230    )
231    return processing

 14def create_processing_value(
 15    func: Union[Callable[[Any], Any], Callable[[Any, Config], Any]],
 16    processing_type: str = "premerge",
 17    *,
 18    regex: Optional[str] = None,
 19    tag_name: Optional[str] = None,
 20    order: float = 0.0,
 21    persistent: bool = False,
 22) -> Processing:
 23    r"""Create a processing object that modifies a value in config using tag or regex.
 24
 25    The processing is applied on pre-merge. It triggers when the key matches
 26    the tag or the regex. The function apply `flat_dict[key] = func(flat_dict[key])`.
 27    You must only provide one of tag or regex. If tag is provided, the tag will be
 28    removed from the key during pre-merge.
 29
 30    It also possible to pass the flat config as a second argument of the function
 31    `func`. In this case, the function apply
 32    `flat_dict[key] = func(flat_dict[key], flat_config)`.
 33
 34    Parameters
 35    ----------
 36    func : Callable
 37        The function to apply to the value (and eventually the flat config)
 38        to make the new value so that:
 39        flat_dict[key] = func(flat_dict[key]) or func(flat_dict[key], flat_config)
 40    processing_type : str, optional
 41        One of "premerge", "postmerge", "presave", "postload" or "endbuild".
 42        Timing to apply the value update. In all cases the tag is removed on pre-merge.
 43        By default "premerge".
 44    regex : Optional[str]
 45        The regex to match the key.
 46    tag_name : Optional[str]
 47        The tag (without "@") to match the key. The tag is removed on pre-merge.
 48    order : int, optional
 49        The pre-merge order. By default 0.0.
 50    persistent : bool, optional
 51        If True, the processing will be applied on all keys that have already
 52        matched the tag before. By nature, using regex make the processing
 53        always persistent. By default, False.
 54
 55    Raises
 56    ------
 57    ValueError
 58        If both tag and regex are provided or if none of them are provided.
 59    ValueError
 60        If the processing type is not one of "premerge", "postmerge", "presave",
 61        "postload" or "endbuild".
 62
 63    Returns
 64    -------
 65    processing : Processing
 66        The processing object with the pre-merge method.
 67
 68
 69    Examples
 70    --------
 71    With the following config and 2 processings:
 72
 73    ```yaml
 74    # config.yaml
 75    neg_number1: 1
 76    neg_number2: 1
 77    neg_number3@add1: 1
 78    ```
 79
 80    ```python
 81    # main.py
 82    proc2 = create_processing_value(
 83        lambda val: -val,
 84        regex="neg_number.*",
 85        order=0.0
 86    )
 87    proc1 = create_processing_value(
 88        lambda val: val + 1,
 89        tag_name="add1",
 90        order=1.0
 91    )
 92    ```
 93
 94    When config.yaml is merged with an other config, it will be considered
 95    before merging as:
 96
 97    ```python
 98    {'number1': -1, 'number2': -1, 'number3': 0}
 99    ```
100
101    Using the config as a second argument of the function:
102
103    ```yaml
104    # config.yaml
105    param1: 1
106    param2@eval: "config.param1 + 1"
107    ```
108
109    ```python
110    # main.py
111    proc = create_processing_value(
112        lambda val, config: eval(val, {'config': config}),
113        processing_type='postmerge',
114        tag_name='eval',
115        persistent=False
116    )
117    ```
118
119    After config.yaml is merged with another config, param2 will be evaluated
120    as 2 (except if config.param1 has changed with a processing before).
121    """
122    if tag_name is not None:
123        if regex is not None:
124            raise ValueError("You must provide a tag or a regex but not both.")
125    else:
126        if regex is None:
127            raise ValueError(
128                "You must provide a tag or a regex (to trigger the value update)."
129            )
130    proc = _ProcessingValue(
131        func,
132        processing_type,
133        regex=regex,
134        tag_name=tag_name,
135        order=order,
136        persistent=persistent,
137    )
138    return proc

250def flatten_config(config: Config) -> Config:
251    """Flatten a config.
252
253    Parameters
254    ----------
255    config : Config
256        The config to flatten.
257
258    Returns
259    -------
260    confg : Config
261        The config containing a flattened dict.
262    """
263    config.dict = flatten(config.dict)
264    return config

158def flatten(in_dict: Dict[str, Any]) -> Dict[str, Any]:
159    """Flatten dict then return it (flat keys are built with dots).
160
161    Work even if in_dict is a mix of nested and flat dictionaries.
162    For instance like this:
163
164    >>> flatten({'a.b': {'c': 1}, 'a': {'b.d': 2}, 'a.e': {'f.g': 3}})
165    {'a.b.c': 1, 'a.b.d': 2, 'a.e.f.g': 3}
166
167    Parameters
168    ----------
169    in_dict : Dict[str, Any]
170        The dict to flatten. It can be nested, already flat or a mix of both.
171
172    Raises
173    ------
174    ValueError
175        If dict has some conflicting keys (like `{'a.b': <x>, 'a': {'b': <y>}}`).
176
177    Returns
178    -------
179    flat_dict : Dict[str, Any]
180        The flattened dict.
181
182    Examples
183    --------
184    ```python
185    >>> flatten({'a.b': 1, 'a': {'c': 2}, 'd': 3})
186    {'a.b': 1, 'a.c': 2, 'd': 3}
187    >>> flatten({'a.b': {'c': 1}, 'a': {'b.d': 2}, 'a.e': {'f.g': 3}})
188    {'a.b.c': 1, 'a.b.d': 2, 'a.e.f.g': 3}
189    >>> flatten({'a.b': 1, 'a': {'b': 1}})
190    ValueError: duplicated key 'a.b'
191    >>> flatten({'a.b': 1, 'a': {'c': {}}, 'a.c': 3})
192    {'a.b': 1, 'a.c': 3}
193    ```
194    .. note::
195        Nested empty dict are ignored even if they are conflicting (see last example).
196    """
197    flat_dict = _flatten(in_dict, reducer="dot")
198    return flat_dict

 24def make_config(
 25    *default_config_paths: str,
 26    process_list: Optional[List[Processing]] = None,
 27    add_default_processing: bool = True,
 28    fallback: str = "",
 29    no_cli: bool = False,
 30) -> Config:
 31    r"""Make a config from default config(s) and CLI argument(s) with processing.
 32
 33    The function uses the CLI Config routines `cliconfig.cli_parser.parse_cli`
 34    to parse the CLI arguments and merge them with
 35    `cliconfig.process_routines.merge_flat_paths_processing`, applying
 36    the pre-merge and post-merge processing functions on each merge.
 37
 38    Parameters
 39    ----------
 40    default_config_paths : Tuple[str]
 41        Paths to default configs. They are merged in order and new keys
 42        are allowed.
 43    process_list: Optional[List[Processing]], optional
 44        The list of processing to apply during each merge. None for empty list.
 45        By default None.
 46    add_default_processing : bool, optional
 47        If add_default_processing is True, the default processings
 48        (found on `cliconfig.processing.builtin.DefaultProcessings`) are added to
 49        the list of processings. By default True.
 50    fallback : str, optional
 51        Path of the configuration to use if no additional config is provided
 52        with `--config`. No fallback config if empty string (default),
 53        in that case, the config is the default configs plus the CLI arguments.
 54    no_cli : bool, optional
 55        If True, the CLI arguments are not parsed and the config is only
 56        built from the default_config_paths in input and the
 57        fallback argument is ignored. By default False.
 58
 59    Raises
 60    ------
 61    ValueError
 62        If additional configs have new keys that are not in default configs.
 63
 64    Returns
 65    -------
 66    config : Config
 67        The nested built config. Contains the config dict (config.dict) and
 68        the processing list (config.process_list) which can be used to apply
 69        further processing routines.
 70
 71    Examples
 72    --------
 73    ```python
 74    # main.py
 75    config = make_config('data.yaml', 'model.yaml', 'train.yaml')
 76    ```
 77
 78    ```script
 79    python main.py -- config [bestmodel.yaml,mydata.yaml] \
 80        --architecture.layers.hidden_dim=64
 81    ```
 82
 83    .. note::
 84        Setting additional arguments from CLI that are not in default configs
 85        does NOT raise an error but only a warning. This ensures the compatibility
 86        with other CLI usage (e.g notebook, argparse, etc.)
 87    """
 88    logger = cliconfig._CLICONFIG_LOGGER  # pylint: disable=W0212
 89    # Create the processing list
 90    process_list_: List[Processing] = [] if process_list is None else process_list
 91    if add_default_processing:
 92        process_list_ += DefaultProcessings().list
 93    config = Config({}, process_list_)
 94    if no_cli:
 95        additional_config_paths: List[str] = []
 96        cli_params_dict: Dict[str, Any] = {}
 97    else:
 98        additional_config_paths, cli_params_dict = parse_cli(sys.argv)
 99        if not additional_config_paths and fallback:
100            # Add fallback config
101            additional_config_paths = [fallback]
102    # Merge default configs and additional configs
103    for i, paths in enumerate([default_config_paths, additional_config_paths]):
104        # Allow new keys for default configs only
105        allow_new_keys = i == 0
106        for path in paths:
107            config = merge_flat_paths_processing(
108                config,
109                path,
110                allow_new_keys=allow_new_keys,
111                preprocess_first=False,  # Already processed
112            )
113
114    # Allow new keys for CLI parameters but do not merge them and raise
115    # warning.
116    cli_params_dict = flatten(cli_params_dict)
117    new_keys, keys = [], list(cli_params_dict.keys())
118    for key in keys:
119        if (
120            not is_tag_in(key, "new", full_key=True)
121            and clean_all_tags(key) not in config.dict
122        ):
123            # New key: delete it
124            new_keys.append(clean_all_tags(key))
125            del cli_params_dict[key]
126    if new_keys:
127        new_keys_message = "  - " + "\n  - ".join(new_keys)
128        message = (
129            "[CONFIG] New keys found in CLI parameters "
130            f"that will not be merged:\n{new_keys_message}"
131        )
132        logger.warning(message)
133    # Merge CLI parameters
134    cli_params_config = Config(cli_params_dict, [])
135    config = merge_flat_processing(
136        config, cli_params_config, allow_new_keys=False, preprocess_first=False
137    )
138    message = (
139        f"[CONFIG] Merged {len(default_config_paths)} default config(s), "
140        f"{len(additional_config_paths)} additional config(s) and "
141        f"{len(cli_params_dict)} CLI parameter(s)."
142    )
143    logger.info(message)
144    config = end_build_processing(config)
145    config.dict = unflatten(config.dict)
146    return config

149def load_config(
150    path: str,
151    default_config_paths: Optional[List[str]] = None,
152    process_list: Optional[List[Processing]] = None,
153    *,
154    add_default_processing: bool = True,
155) -> Config:
156    """Load config from a file and merge into optional default configs.
157
158    First merge the default configs together (if any), then load the config
159    from path, apply the post-load processing, and finally merge the loaded
160    config.
161
162    Parameters
163    ----------
164    path : str
165        The path to the file to load the configuration.
166    default_config_paths : Optional[List[str]], optional
167        Paths to default configs. They are merged in order, new keys are allowed.
168        Then, the loaded config is merged into the result. None for no default configs.
169        By default None.
170    process_list: Optional[List[Processing]]
171        The list of processing to apply after loading and for the merges.
172        If None, no processing is applied. By default None.
173    add_default_processing : bool, optional
174        If add_default_processing is True, the default processings
175        (found on `cliconfig.processing.builtin.DefaultProcessings`)
176        are added to the list of processings. By default True.
177
178    Returns
179    -------
180    config: Dict[str, Any]
181        The nested loaded config. Contains the config dict (config.dict) and
182        the processing list (config.process_list) which can be used to apply
183        further processing routines.
184
185    .. note::
186        If default configs are provided, the function does not allow new keys
187        for the loaded config. This is for helping the user to see how to
188        adapt the config file if the default configs have changed.
189    """
190    # Crate process_list
191    process_list_: List[Processing] = [] if process_list is None else process_list
192    if add_default_processing:
193        process_list_ += DefaultProcessings().list
194
195    config = Config({}, process_list_)
196    if default_config_paths:
197        for config_path in default_config_paths:
198            config = merge_flat_paths_processing(
199                config,
200                config_path,
201                allow_new_keys=True,
202                preprocess_first=False,  # Already processed
203            )
204    loaded_config = load_processing(path, config.process_list)
205    # Update the config list from loaded_config in config
206    config.process_list = loaded_config.process_list
207    # Merge the loaded config into the config and
208    # disallow new keys for loaded config
209    # if default configs are provided
210    config = merge_flat_processing(
211        config,
212        loaded_config,
213        allow_new_keys=default_config_paths is None,
214        preprocess_first=False,
215    )
216    config = end_build_processing(config)
217    config.dict = unflatten(config.dict)
218    return config

 99def merge_flat_paths_processing(
100    config_or_path1: Union[str, Config],
101    config_or_path2: Union[str, Config],
102    *,
103    additional_process: Optional[List[Processing]] = None,
104    allow_new_keys: bool = True,
105    preprocess_first: bool = True,
106    preprocess_second: bool = True,
107    postprocess: bool = True,
108) -> Config:
109    """Flatten, merge and apply processing to two configs or their yaml paths.
110
111    Similar to `merge_flat_processing` but allows to pass configs
112    or their yaml paths. Work even if the configs have a mix of nested and flat dicts.
113    If both arguments are configs, the process lists are merged before applying
114    the processing. The duplicate processings (with same internal variables)
115    are removed.
116
117    Parameters
118    ----------
119    config_or_path1 : Union[str, Config]
120        The first config or its path.
121    config_or_path2 : Union[str, Config]
122        The second config or its path, to merge into first config.
123    additional_process : Optional[List[Processing]], optional
124        Additional processings to apply to the merged config. It can
125        be useful to merge a config from its path while it has some specific
126        processings.
127    allow_new_keys : bool, optional
128        If True, new keys (that are not in config1) are allowed in config2.
129        Otherwise, it raises an error. By default True.
130    preprocess_first : bool, optional
131        If True, apply pre-merge processing to config1. By default True.
132    preprocess_second : bool, optional
133        If True, apply pre-merge processing to config2. By default True.
134    postprocess : bool, optional
135        If True, apply post-merge processing to the merged config. By default True.
136
137    Raises
138    ------
139    ValueError
140        If allow_new_keys is False and config2 has new keys that are not in config1.
141    ValueError
142        If there are conflicting keys when flatten one of the dicts.
143
144    Returns
145    -------
146    flat_config : Config
147        The merged flat config.
148    """
149    configs = []
150    for config_or_path in [config_or_path1, config_or_path2]:
151        if isinstance(config_or_path, str):
152            config_dict = load_dict(config_or_path)
153            config = Config(config_dict, [])
154        elif isinstance(config_or_path, Config):
155            config = config_or_path
156        elif isinstance(config_or_path, dict):
157            raise ValueError(
158                "config_or_path must be a Config instance or a path to a yaml file "
159                "but you passed a dict. If you want to use it as a valid input, "
160                "you should use Config(<input dict>, []) instead."
161            )
162        else:
163            raise ValueError(
164                "config_or_path must be a Config instance or a path to a yaml file."
165            )
166        configs.append(config)
167    config1, config2 = configs[0], configs[1]
168    if additional_process is not None:
169        config1.process_list.extend(additional_process)
170        config2.process_list.extend(additional_process)
171    flat_config = merge_flat_processing(
172        config1,
173        config2,
174        allow_new_keys=allow_new_keys,
175        preprocess_first=preprocess_first,
176        preprocess_second=preprocess_second,
177        postprocess=postprocess,
178    )
179    return flat_config

21def merge_flat_processing(
22    config1: Config,
23    config2: Config,
24    *,
25    allow_new_keys: bool = True,
26    preprocess_first: bool = True,
27    preprocess_second: bool = True,
28    postprocess: bool = True,
29) -> Config:
30    """Flatten and merge config2 into config1 and apply pre and post processing.
31
32    Work even if the config dicts have a mix of nested and flat dictionaries.
33    If both arguments are configs, the process lists are merged before applying
34    the processing. The duplicate processings (with same internal variables)
35    are removed.
36
37    Parameters
38    ----------
39    config1 : Config
40        The first config.
41    config2 : Config
42        The second dict to merge into config1.
43    allow_new_keys : bool, optional
44        If True, new keys (that are not in config1) are allowed in config2.
45        Otherwise, it raises an error. By default True.
46    preprocess_first : bool, optional
47        If True, apply pre-merge processing to config1. By default True.
48    preprocess_second : bool, optional
49        If True, apply pre-merge processing to config2. By default True.
50    postprocess : bool, optional
51        If True, apply post-merge processing to the merged config. By default True.
52
53    Raises
54    ------
55    ValueError
56        If allow_new_keys is False and config2 has new keys that are not in config1.
57    ValueError
58        If there are conflicting keys when flatten one of the dicts.
59
60    Returns
61    -------
62    flat_config : Config
63        The merged flat config.
64    """
65    # Flatten the dictionaries
66    config1.dict, config2.dict = _flat_before_merge(config1.dict, config2.dict)
67    # Get the process list of the merge
68    process_list = config1.process_list
69    for process in config2.process_list:
70        # NOTE 2 processings are equal if they are the same class and add the same
71        # attributes.
72        if process not in process_list:
73            process_list.append(process)
74    # Apply the pre-merge processing
75    if preprocess_first:
76        config1.process_list = process_list
77        pre_order_list = sorted(process_list, key=lambda x: x.premerge_order)
78        for processing in pre_order_list:
79            config1 = processing.premerge(config1)
80        process_list = config1.process_list
81    if preprocess_second:
82        config2.process_list = process_list
83        pre_order_list = sorted(process_list, key=lambda x: x.premerge_order)
84        for processing in pre_order_list:
85            config2 = processing.premerge(config2)
86        process_list = config2.process_list
87    # Merge the dictionaries
88    flat_dict = merge_flat(config1.dict, config2.dict, allow_new_keys=allow_new_keys)
89    # Create the new config
90    flat_config = Config(flat_dict, process_list)
91    # Apply the postmerge processing
92    if postprocess:
93        post_order_list = sorted(process_list, key=lambda x: x.postmerge_order)
94        for processing in post_order_list:
95            flat_config = processing.postmerge(flat_config)
96    return flat_config