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

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

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

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

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

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

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

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

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

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