the1conf 1.0.0__py3-none-any.whl → 1.2.3__py3-none-any.whl

the1conf/app_config.py

@@ -1,108 +1,31 @@
 from __future__ import annotations
 
-import dataclasses
-import importlib
+import copy
+
 import json
 import logging
-import copy
 import os
-import ast
-import inspect
-import textwrap
-from collections.abc import Iterable, Mapping, MutableMapping, Sequence
-from dataclasses import dataclass
-from enum import Enum, auto
+
+from collections import OrderedDict
+from collections.abc import Iterable, Mapping, Sequence
 from pathlib import Path
-from typing import (
-    Annotated,
-    Any,
-    Callable,
-    cast,
-    Generic,
-    Optional,
-    TypeAlias,
-    TypeVar,
-    Union,
-    get_args,
-    get_origin,
-    get_type_hints,
-    dataclass_transform,
-)
+from typing import Any, Callable, Optional, Union, cast
 
+from .auto_prolog import AutoProlog
+import toml
 import yaml
-
-from .attr_dict import AttrDict, is_sequence
 from pydantic import TypeAdapter, ValidationError
-from .config_var import ConfigVarDef, Flags, PathType, Undefined, _UndefinedSentinel, _undef, configvar
-
-
-def _get_attribute_docstrings(cls: type) -> dict[str, str]:
-    """
-    Extracts docstrings for class attributes by parsing the source code.
-    This allows using docstrings to populate ConfigVarDef.Help.
-    """
-    docstrings = {}
-    try:
-        source = inspect.getsource(cls)
-        # Deduct to handle nested classes indentation
-        source = textwrap.dedent(source)
-    except (OSError, TypeError):
-        # Source code not available (e.g. dynamic class, REPL, compiled files)
-        return {}
-
-    try:
-        tree = ast.parse(source)
-    except SyntaxError:
-        return {}
-
-    # We look for the ClassDef in the parsed source.
-    # Since inspect.getsource(cls) returns the class definition itself,
-    # the first node in body should be the ClassDef.
-    for node in tree.body:
-        if isinstance(node, ast.ClassDef):
-            for i, item in enumerate(node.body):
-                if isinstance(item, (ast.Assign, ast.AnnAssign)):
-                    # Check if the next node is an expression containing a string (docstring)
-                    if i + 1 < len(node.body):
-                        next_node = node.body[i + 1]
-                        if (
-                            isinstance(next_node, ast.Expr)
-                            and isinstance(next_node.value, ast.Constant)
-                            and isinstance(next_node.value.value, str)
-                        ):
-                            docstring = next_node.value.value.strip()
-
-                            targets = []
-                            if isinstance(item, ast.Assign):
-                                targets = item.targets
-                            elif isinstance(item, ast.AnnAssign):
-                                targets = [item.target]
-
-                            for target in targets:
-                                if isinstance(target, ast.Name):
-                                    docstrings[target.id] = docstring
-            # We found the class def, no need to continue in top level
-            break
-            
-    return docstrings
-
-
-class AppConfigException(Exception):
-    def __init__(self, message: str) -> None:
-        super().__init__(message)
-        self.message = message
-
-
-class NameSpace:
-    """Marker class for configuration namespaces.
-    Used to group configuration variables into nested namespaces within an AppConfig subclass.
-    See AppConfig documentation for more information.
-    """
 
-    pass
+from .attr_dict import AttrDict
+from .utils import is_sequence, Undefined
+from .config_var import ConfigVarDef, Flags
+from .solver import Solver
+from .var_substitution import resolve_candidate_list
+from .utils import _undef
+from .app_config_meta import AppConfigMeta, ConfigVarCollector
 
 
-class AppConfig(AttrDict):
+class AppConfig(AttrDict, AutoProlog, metaclass=AppConfigMeta):
     """ "
     A class to manage application configuration. It can be passed from callable to callable.
     It can search for variable values in command line arguments, environment variables, a yaml or json configuration file
@@ -153,8 +76,8 @@ class AppConfig(AttrDict):
     Configuration is best defined declaratively by subclassing AppConfig:
 
         class MyConfig(AppConfig):
-            host: str = configvar(Default="localhost")
-            port: int = configvar(Default=8080)
+            host: str = configvar(default="localhost")
+            port: int = configvar(default=8080)
 
     Nested Namespaces:
     ------------------
@@ -163,16 +86,16 @@ class AppConfig(AttrDict):
 
         class MyConfig(AppConfig):
             # Root level variable
-            debug: bool = configvar(Default=False)
+            debug: bool = configvar(default=False)
 
             # Nested namespace 'db'
             class db(NameSpace):
-                host: str = configvar(Default="db.local")
-                port: int = configvar(Default=5432)
+                host: str = configvar(default="db.local")
+                port: int = configvar(default=5432)
 
             # Nested namespace 'api'
             class api(NameSpace):
-                key: str = configvar(EnvName="API_KEY")
+                key: str = configvar(env_name="API_KEY")
 
     inst = MyConfig()
     inst.resolve_vars()
@@ -185,11 +108,11 @@ class AppConfig(AttrDict):
 
         class DatabaseConfig(AppConfig):
             class db(NameSpace):
-                host: str = configvar(Default="localhost")
+                host: str = configvar(default="localhost")
 
         class ApiConfig(AppConfig):
             class api(NameSpace):
-                timeout: int = configvar(Default=30)
+                timeout: int = configvar(default=30)
 
         # Combine into the final application config
         class App(DatabaseConfig, ApiConfig):
@@ -198,11 +121,16 @@ class AppConfig(AttrDict):
     If multiple mixins define the same namespace (e.g. `class db(NameSpace)`), their variables are merged.
     """
 
-    #: The logger for this class
     _logger = logging.getLogger(__name__)
-    _solver_logger = logging.getLogger(f"{__name__}.solver")
     _global_flags: Flags
-    _config_var_defs: list[ConfigVarDef]
+    _config_var_defs: OrderedDict[str, ConfigVarDef]
+    """ The list of ConfigVarDef defined in this AppConfig class and its parent classes as an ordered dictionary. 
+        This attribute is created at class creation time by the __init_subclass__ method.
+    """
+    _autoprolog_var_names: list[str]
+    """ The list of the names of ConfigVarDef defined in AutoProlog.
+        This attribute is created at class creation time by the __init_subclass__ method.
+    """
 
     def __init_subclass__(cls, **kwargs: Any) -> None:
         """
@@ -210,74 +138,38 @@ class AppConfig(AttrDict):
 
         Create the _config_var_defs attribute that contains the list of ConfigVarDef
         defined in this subclass as well as the ones defined in parent classes.
+
+        This method also handle namespaces defined with nested classes inheriting from NameSpace.
+        1. It first collects the _config_var_defs from parent classes to handle mixins, when a variable is found in a parent class with the same name as a variable in a child class,
+            the child class variable takes precedence, thus we remove the parent class variable from the collected list before adding the child class variable.
+        2. Then it inspects the class __dict__ to find ConfigVarDef defined in this class (and nested classes) and add them to the collected list.
+            Collecting ConfigVarDef in this class is done by the collect_vars() class method which is called recursively on nested NameSpace classes
+            and which is also search for docstrings to attach them as help to the ConfigVarDef if help is not already defined.
+        3. Finally it sets the _config_var_defs attribute on the class.
+
         """
+        # First call super to handle any parent class logic
         super().__init_subclass__(**kwargs)
 
-        # First try to look if there is already a _config_var_defs attribute in one of the parent classes.
-        collected: list[ConfigVarDef] = []
-        seen_attr_names: set[str] = set()
-        for base in reversed(cls.__mro__[1:]):
-            # from the deepest parent class to the nearest parent class: search if there
-            # is a _config_var_defs attribute in the inspected class.
-            base_defs = getattr(base, "_config_var_defs", None)
-            if not base_defs:
-                continue
-            for var_def in base_defs:
-                # base_defs is the _config_var_defs list. Loops on each of its elements and store them in the collected list
-                # For each one read its name. If the variable name is already in the collected list, it means that it has been
-                # defined in a parent class of the current inspected base class. So we remove the old definition and add the new one.
-                attr_name = getattr(var_def, "_name", None)
-                if attr_name:
-                    if attr_name in seen_attr_names:
-                        collected = [
-                            v for v in collected if getattr(v, "_name", None) != attr_name
-                        ]
-                    collected.append(var_def)
-                    seen_attr_names.add(attr_name)
-
-        # Helper method for recursive collection
-        def collect_vars(owner: type, prefix: str = "") -> Iterable[ConfigVarDef]:
-            # extract docstrings from the class source code
-            docstrings = _get_attribute_docstrings(owner)
-
-            # Inspect the class __dict__ to find ConfigVarDef defined in this class
-            for attr_name, value in owner.__dict__.items():
-                if isinstance(value, ConfigVarDef):
-                    # Clone to update name with prefix
-                    # We use copy.copy because ConfigVarDef is mutable but generic.
-                    new_var = copy.copy(value)
-                    
-                    # If Help is missing, try to use the docstring
-                    if not new_var.Help and attr_name in docstrings:
-                        new_var._help = docstrings[attr_name]
-
-                    if prefix:
-                        # We need to access _name directly
-                        original_name = getattr(value, "_name", attr_name)
-                        new_var._name = f"{prefix}{original_name}"
-
-                    yield new_var
-
-                elif (
-                    isinstance(value, type)
-                    and issubclass(value, NameSpace)
-                    and value is not NameSpace
-                ):
-                    # Recurse
-                    yield from collect_vars(value, prefix=f"{prefix}{attr_name}.")
-
-        # Now inspect the class __dict__ to find ConfigVarDef defined in this class (and nested classes) and add them to the collected list.
-        for value in collect_vars(cls):
-            attr_name = getattr(value, "_name", None)
-            if attr_name:
-                if attr_name in seen_attr_names:
-                    collected = [
-                        v for v in collected if getattr(v, "_name", None) != attr_name
-                    ]
-                collected.append(value)
-                seen_attr_names.add(attr_name)
-
-        cls._config_var_defs = collected
+        with ConfigVarCollector() as collector:
+            # try to look if there is already a _config_var_defs attribute in one of the parent classes.
+
+            for base in reversed(cls.__mro__[1:-1]):
+                # __mro__ contain:
+                #    1. The class of the object (class of cls here, which is this class)
+                #    2. The hierarchy of the parent classes in the MRO order which goes from left to right at each level and from the level
+                #       closest to the object to one deeper in the tree.
+                #    3. The Object class which is the latest class in the inheritance tree.
+                # Here we skip the first element which is the class of the object itself (cls) and the last which is Object class and we traverse
+                # it in reverse order.
+
+                collector.collect_in_config_var_defs(base)
+
+            # Now inspect the class __dict__ to find ConfigVarDef defined in this class (and nested classes) and add them to the collected list.
+            # note that collect_config_vars is defined in the metaclass.
+            collector.collect_on_class(cls)
+            cls._config_var_defs = collector.get_collected_vars()
+            cls._autoprolog_var_names = collector.get_auto_prolog_var_names()
 
     def __init__(
         self,
@@ -286,7 +178,6 @@ class AppConfig(AttrDict):
         no_key_search: Optional[bool] = None,
         no_conffile_search: Optional[bool] = None,
         no_search: Optional[bool] = None,
-        conffile_path: Optional[Path] = None,
         allow_override: Optional[bool] = None,
         click_key_conversion: Optional[bool] = None,
     ):
@@ -301,7 +192,6 @@ class AppConfig(AttrDict):
             no_key_search (bool, optional): don't search values in the value dictionary. Defaults to False.
             no_conffile_search (bool, optional): don't search values in the configuration file. Defaults to False.
             no_search (bool, optional): don't search values in any location. Defaults to False.
-            conffile_path (Path, optional): the configuration file path. Defaults to None.
             allow_override (bool, optional): allow overriding variable in the configuration when calling resolve_vars.
                 it happens either when resolve_vars() is call several times or the variable was set before its call.
             click_key_conversion (bool, optional): use the variable name converted to lower case and with dashes converted to underscores as
@@ -315,14 +205,8 @@ class AppConfig(AttrDict):
             click_key_conversion=click_key_conversion,
             allow_override=allow_override,
         )
-        self.conffile_path = conffile_path
-        # Configuration variable definitions used by resolve_vars().
-        # This is intentionally an instance attribute so callers can set/replace it
-        # dynamically (major-version breaking change: resolve_vars no longer accepts
-        # a var_specs parameter).
-        # Default to the declarative definitions collected on the class.
-        self._config_var_defs = list(getattr(self.__class__, "_config_var_defs", []))
-        self._logger.debug("init AppCtx")
+
+        self._logger.debug("init AppConfig")
 
     def clone(self) -> AppConfig:
         """cloning the AppConfig object"""
@@ -330,61 +214,73 @@ class AppConfig(AttrDict):
         clone.__dict__ = self.__dict__.copy()
         return clone
 
-    @classmethod
-    def _find_var_in_dict(cls, where: Mapping[Any, Any], var_name: str) -> Any | Undefined:
-        """
-        Search for var_name in a dictionary.
-        var_name contains dict keys separated by a dot (.) ie key1.key2.key3
-        The left side key key1 is search in the where directory, if it is found
-        and it is a dictionary then key2 is search in it and
-        all key are searched in sequence.
-        Returns _undef if not found, allowing to distinguish between None (explicit null) and missing.
-        """
-        cur_dic: Mapping[Any, Any] = where
-        for key in var_name.split("."):
-            # logger = logging.getLogger(f"{cls.__module__}.{cls.__name__}")
-            # logger.debug(f"searching for key: {key} in dict : {cur_val}")
-            if key in cur_dic:
-                cur_dic = cur_dic[key]
-                # logger.debug(f"Found key: {key} = {cur_val}")
-            else:
-                return _undef
+    def _set_value(self, name: str, value: Any) -> None:
+        """Set a value.
 
-        return cur_dic
+        Use an AttrDict implementation to handle dotted keys and not trigger recursion loops
+        if called from a descriptor.
+        """
+        self[name] = value
 
-    def _run_eval(
+    def _get_eval_runner(
         self,
-        callable: Callable[[str, Any, Any], Any],
-        var_val: Any = None,
-        var_name: str = "",
-    ) -> Any:
+    ) -> Callable[[Callable[[str, Any, Any], Any], str, Any], Any]:
         """
         Call a Callable found in a Eval Form.
         """
-        return callable(var_name, self, var_val)
+        this = self
+
+        def runner(
+            callable: Callable[[str, Any, Any], Any], var_name: str, var_val: Any
+        ) -> Any:
+            return callable(var_name, this, var_val)
+
+        return runner
+
+    def _resolve_conffile_path(
+        self, candidates: Optional[str | Path | Iterable[str | Path]]
+    ) -> Path | None:
+        if candidates is None:
+            return None
+
+        # Normalize candidates to list of str for resolve_candidate_list
+        candidates_str_list: list[str] = []
+        if isinstance(candidates, (str, Path)):
+            candidates_str_list = [str(candidates)]
+        elif is_sequence(candidates):
+            candidates_str_list = [str(c) for c in cast(Sequence[Any], candidates)]
+
+        # Define existence check
+        def file_exists(p: str) -> Any:
+            path_obj = Path(p)
+            if path_obj.is_file():
+                return path_obj
+            else:
+                return _undef
 
-    def _set_value(self, name: str, value: Any) -> None:
-        """Set a value.
+        # Build context for Jinja with current values resolved
+        context = self.to_dict()
 
-        Depending on AttrDict implementation to handle dotted keys and not trigger recursion loops
-        if called from a descriptor.
-        """
-        self[name] = value
+        # Resolve using current self as context (for jinja variables)
+        resolved_path = resolve_candidate_list(
+            candidates=candidates_str_list, context=context, check_exists=file_exists
+        )
+
+        return resolved_path
 
     def resolve_vars(
         self,
         *,
-        contexts: Optional[str | Iterable[str]] = None,
+        scopes: Optional[str | Iterable[str]] = None,
         values: Mapping[str, Any] = {},
-        no_exception: Optional[bool] = None,
         no_env_search: Optional[bool] = None,
         no_value_search: Optional[bool] = None,
         no_conffile_search: Optional[bool] = None,
         no_search: Optional[bool] = None,
-        conffile_path: Optional[Path] = None,
+        conffile_path: Optional[Path | str | Sequence[str | Path]] = None,
         allow_override: Optional[bool] = None,
         click_key_conversion: Optional[bool] = None,
-    ) -> Any:
+    ) -> None:
         """
         Resolve the configuration variables defined in this AppConfig object.
         The variable values are searched in these locations in the following order:
@@ -411,233 +307,205 @@ class AppConfig(AttrDict):
             no_search=no_search,
             click_key_conversion=click_key_conversion,
             allow_override=allow_override,
-            no_exception=no_exception,
         )
         local_flags = self._global_flags.merge(inplace=False, other=resolve_flags)
         assert local_flags is not None
 
+        # building the Solver who is in charge of resolving configuration variables
+        solver = Solver(
+            eval_runner=self._get_eval_runner(),
+            flags=local_flags,
+            values_map=values,
+            var_solved=self,
+        )
+
+        # Special case for auto_prolog variable: we need to try to solve them
+        # before any other variable and before resolving the configuration file path because
+        # it can depends on one of them, the one that can be ovveriden are resolved at each run
+        for var_name in self._autoprolog_var_names:
+            vardef = self._config_var_defs.get(var_name)
+            if vardef is None:
+                continue
+            if self.has_value(var_name) and not (
+                local_flags.allow_override or vardef.flags.allow_override
+            ):
+                continue
+            # call solver to try to find a value for the configuration variable
+            value_found = solver.resolve_confvar(var_to_solve=vardef, scopes=scopes)
+            if value_found != _undef:
+                self._set_value(var_name, value_found)
+
         # Read configuration file if requiered
         conf_file_vars = None
-        cur_conffile_path = conffile_path if conffile_path else self.conffile_path
-        if not local_flags.no_conffile_search and cur_conffile_path is not None:
-            if cur_conffile_path.is_file():
+        if not local_flags.no_conffile_search and conffile_path is not None:
+            # Resolve conffile_path if it's dynamic
+            cur_conffile_path = self._resolve_conffile_path(conffile_path)
+
+            if cur_conffile_path is not None and cur_conffile_path.is_file():
                 with cur_conffile_path.open("r") as f:
                     if cur_conffile_path.suffix.lower() == ".json":
                         self._logger.debug(f"Parsing json file {cur_conffile_path}")
                         conf_file_vars = json.load(f)
+                    elif cur_conffile_path.suffix.lower() == ".toml":
+                        self._logger.debug(f"Parsing toml file {cur_conffile_path}")
+                        conf_file_vars = toml.load(f)
                     else:
                         self._logger.debug(
                             f"Parsing file {cur_conffile_path} with suffix {cur_conffile_path.suffix.lower()}"
                         )
                         conf_file_vars = yaml.safe_load(f)
+                    # updating the solver with the values found in the configuration file
+                    solver.set_conffile_values_map(conf_file_vars)
             else:
                 self._logger.info(f"configuration file {cur_conffile_path} not found.")
 
         # Read the var definitions one by one in their definition order
-        for var in self._config_var_defs:
+        for var_name, var_def in self._config_var_defs.items():
+
+            # Check if variable is manually set on the instance or resolved in a previous pass
+            has_value = self.has_value(var_name)
+
             # compute the current flags for this variable by merging local flags with variable flags
-            cur_flags = local_flags.merge(inplace=False, other=var.flags)
+            cur_flags = local_flags.merge(inplace=False, other=var_def.flags)
             assert cur_flags is not None
-            # self.logger.debug(f"looking for a value for variable: {var.Name}")
-
-            self._solver_logger.debug(f"Searching for var name {var.Name}:\n{str(var)}")
 
-            # if we are resolving the variables in some specific contexts (ie parameter context has value)
-            # we check if the variable belongs to one of these contexts and if not we skip it.
-            if contexts is None and var.Contexts is not None:
+            # if the variable is already defined and override is not allowed then
+            # we skip it (First valid scope wins).
+            if not cur_flags.allow_override and has_value:
                 continue
-            if contexts is not None and var.Contexts is not None:
-                test_ctx = []
-                # put True in test_ctx for each context that matches, False otherwise
-                if is_sequence(contexts):
-                    test_ctx = [c in var.Contexts for c in contexts]
-                else:
-                    test_ctx = [contexts in var.Contexts]
 
-                # test if there is any True in test_ctx which means that at least one context matches
-                if not any(test_ctx):
-                    continue
-
-            if var.Contexts is None and contexts is not None:
-                # variable without context are common to all contexts so we process them but only once.
-                if var.Name in self.__dict__:
-                    continue
+            # call solver to try to find a value for the configuration variable
+            value_found = solver.resolve_confvar(var_to_solve=var_def, scopes=scopes)
+            if value_found != _undef:
+                self._logger.info(
+                    f"Variable '{var_name}' resolved to: {str(value_found)}"
+                )
+                # add the found value to the AppConfig object through the AttrDict implementation.
+                self._set_value(var_name, value_found)
+            else:
+                self._logger.debug(f"Variable '{var_def.name}' could not be resolved.")
 
-            # if the variable is already defined and override is not allowed then
-            # we skip it (First valid context wins).
-            if not cur_flags.allow_override and var.Name in self.__dict__:
+    def _serialize_var_defs(
+        self, vardef_to_serialize: Iterable[ConfigVarDef], for_file: bool = False
+    ) -> dict[str, Any]:
+        """
+        Serialize the given variable definitions to a dictionary.
+        We know that values came from strings and that they are either alone or in a list.
+        Thus we can just use str() to serialize them.
+        To detect list we need to look at the split_to_list attribute of the ConfigVarDef and call str() on
+        each element of the list, then join them with the separator used to create the list.
+        If for_file is True we serialize only variables that have no_conffile_search set to False and
+        used file_key as the key in the dict, otherwise the key is the variable name.
+        """
+        # we are going to take advantage of the AttrDict to accept dotted keys in order to create nested dicts.
+        dumper = AttrDict()
+        for var in vardef_to_serialize:
+            if for_file and not var.flags.no_conffile_search:
+                key = var.file_key
+            elif not for_file:
+                key = var.name
+            else:
                 continue
 
-            val_found: str | None | list[Any] | Undefined = _undef
-            found = False
+            sep = var.split_to_list if isinstance(var.split_to_list, str) else ","
+            if var.split_to_list:
+                val_list = [str(v) for v in self[var.name]]
+                val = sep.join(val_list)
+            else:
+                val = str(self[var.name])
 
-            #  Searching variable value in the values mapping
-            if (
-                values is not None
-                and not cur_flags.no_value_search
-                and var.ValueKey is not None
-            ):
-                # searching var key
-                if var.ValueKey in values and values[var.ValueKey] is not None:
-                    val_found = values[var.ValueKey]
-                    found = True
-                    self._solver_logger.debug(
-                        f"{var.Name} -> Found in Values = {val_found}"
-                    )
-                if not found and cur_flags.click_key_conversion:
-                    # try with click key conversion
-                    click_key = var.ValueKey.lower().replace("-", "_")
-                    if click_key in values and values[click_key] is not None:
-                        val_found = values[click_key]
-                        found = True
-                        self._solver_logger.debug(
-                            f"{var.Name} -> Found in Values with Click Key Conversion = {val_found}"
-                        )
-            # Searching variable value in the environment variables
-            if not found and not cur_flags.no_env_search and var.EnvName is not None:
-                env_val = os.getenv(var.EnvName)
-                if env_val is not None:
-                    val_found = env_val
-                    found = True
-                    self._solver_logger.debug(f"{var.Name} -> Found in Env = {val_found}")
-            #  Searching variable value in the configuration file
-            if (
-                not found
-                and not cur_flags.no_conffile_search
-                and conf_file_vars is not None
-                and var.FileKey is not None
-            ):
-                file_val = self._find_var_in_dict(conf_file_vars, var.FileKey)
-                if file_val is not _undef:
-                    val_found = file_val
-                    found = True
-                    self._solver_logger.debug(
-                        f"{var.Name} -> Found in Configuration File = {val_found}"
-                    )
-            #  Setting variable value to the default value if defined.
-            if not found and var.Default is not _undef:
-                if var.Default is not None and callable(var.Default):
-                    val_found = self._run_eval(callable=var.Default, var_name=var.Name)
-                else:
-                    val_found = var.Default
-                found = True
-                self._solver_logger.debug(
-                    f"{var.Name} -> Found in Default Value = {val_found}"
-                )
+            dumper[key] = val
 
-            # Raise exception if no value was found and no_exception is True
-            if not found and not cur_flags.no_exception:
-                raise AppConfigException(
-                    f"No value for var {var.Name} in context {contexts}"
-                )
+        return cast(dict[str, Any], dumper.to_dict())
 
-            if found:
-                if isinstance(val_found, _UndefinedSentinel):
-                    raise AssertionError(
-                        "Internal error: val_found is _undef while found=True"
-                    )
-                # spliting lists
-                if (
-                    var.SplitToList
-                    and val_found is not None
-                    and isinstance(val_found, str)
-                ):
-                    sep: str = (
-                        "," if isinstance(var.SplitToList, bool) else var.SplitToList
-                    )
-                    val_found = val_found.split(sep)
-
-                # Transform the variable value if specified.
-                if var.Transform is not None:
-                    val_transfo = self._run_eval(
-                        callable=var.Transform,
-                        var_val=val_found,
-                        var_name=var.Name,
-                    )
-                    self._solver_logger.debug(
-                        f"{var.Name} -> Value Transformed: {val_found} => {val_transfo}"
-                    )
-                    val_found = val_transfo
-
-                # Validate and cast the variable value using pydantic TypeAdapter
-                if var.TypeInfo is not None and val_found is not None:
-                    try:
-                        ta = TypeAdapter(var.TypeInfo)
-                        val_found = ta.validate_python(val_found)
-                    except ValidationError as e:
-                        raise AppConfigException(f"Validation failed for var {var.Name}: {e}")
-
-                self._set_value(var.Name, val_found)
-            elif var.Name not in self.__dict__:
-                # in case of overiding and when on subsenquent call no value were found we don't want to erase a value
-                # found on a previous run. This can happen when some global flags are overriden or for variable without
-                # context.
-                self._set_value(var.Name, None)
-
-            # Make special treatment for paths
-            if (
-                not var.NoDirProcessing
-                and var.TypeInfo == Path
-                and self[var.Name] != None
-            ):
-                var_value = self[var.Name]
-                new_val: list[Path] | Path | None = None
-                try:
-                    if iter(var_value):
-                        # we need to consider the case where the variable is a list of Path
-                        new_val = []
-                        for val in var_value:
-                            res = self._process_paths(value=val, var=var)
-                            new_val.append(res)
-                except Exception:
-                    res = self._process_paths(value=var_value, var=var)
-                    new_val = res
-                self._set_value(var.Name, new_val)
-
-    def _process_paths(self, *, value: Any, var: ConfigVarDef) -> Path:
+    def store_conf_infile(
+        self,
+        file: Union[Path, str],
+        *,
+        namespaces: Sequence[str] = [],
+        scopes: Sequence[str] = [],
+        type: str = "yaml",
+    ) -> None:
+        """
+        Store the current configuration in a file by merging the variables in the file with the one in this Appconfig object.
+        The method writes the variables in a file.
+        The variables to write must be in one of the specified namespaces and have one of the specified scopes.
+
+        Args:
+            file (Path | str ): The path to the file where to write the configuration.
+            namespaces (Sequence[str], optional): A list of namespaces dotted names to filter the variables to write. Defaults to [].
+            scopes (Sequence[str], optional): A list of scopes to filter the variables to write. Defaults to [].
+            type (str, optional): The type of the file to write. Can be "yaml", "json" or "toml". Defaults to "yaml".
         """
-        Run the path processing for a single Path variable.
-        
-        """ 
-
-        var_value: Path
-        if isinstance(value, str):
-            var_value = Path(value)
-        elif isinstance(value, Path):
-            var_value = value
-        else:
-            raise Exception("not a path")
-
-        res: Path = var_value
-        # First process the CanBeRelative case.
-        if var.CanBeRelativeTo is not None:
-
-            if var_value.is_absolute():
-                res = var_value
-            else:
-                # resolving the root directory from which to be relative to.
-                can_be_relative = var.CanBeRelativeTo
-                root_dir: Path
-                if isinstance(can_be_relative, str) and can_be_relative in self.__dict__:
-                    root_dir = Path(self[can_be_relative])
-                else:
-                    root_dir = Path(can_be_relative)
-                res = root_dir.joinpath(var_value)
 
-        # Expanding user home and resolving dots in path
-        res = res.expanduser().resolve()
+        def get_vars_to_dump() -> Iterable[ConfigVarDef]:
+            """
+            loop over variable definitions to select the variables to dump. we use a separate function
+            in ordre to return a generator to avoid double list traversal
+            """
+            for var in self._config_var_defs.values():
+
+                # check namespaces filter if any
+                if namespaces:
+                    # if the variable is not in one of the requested namespaces skip it
+                    if not any(var.name.startswith(prefix) for prefix in namespaces):
+                        continue
+
+                # check scope filter if any
+                if scopes:
+                    # if the variable is specific to some scopes check if one of them is in the requested scopes
+                    if var.scopes is not None:
+                        if not any(ctx in var.scopes for ctx in scopes):
+                            continue
+
+                # check if the variable should be in the file
+                # redondant because file_key is None only if no_conffile_search is True, but useful for type checker that knwos that file_key is not None.
+                if var.flags.no_conffile_search or var.file_key is None:
+                    continue
 
-        # create directory if MakeDir is not None
-        if var.MakeDirs:
-            if var.MakeDirs == PathType.Dir:
-                res.mkdir(parents=True, exist_ok=True)
+                yield var
+
+        if type not in ["json", "yaml", "toml"]:
+            raise ValueError(
+                f"Unknown type {type}. Supported types are 'json', 'toml' and 'yaml'."
+            )
+        data: dict[str, Any] = {}
+
+        data = self._serialize_var_defs(get_vars_to_dump())
+        if isinstance(file, str):
+            file = Path(file)
+
+        # if possible we need to read the file in order to inject our data into it and
+        # not remove data in the file that we don't have in configuration.
+        if file.exists() and os.access(file, os.R_OK):
+            # file exists and is readable, we open it in read mode to load existing data
+            with file.open("r", encoding="utf-8") as f:
+                if type == "json":
+                    existing_data = json.load(f)
+                elif type == "yaml":
+                    existing_data = yaml.safe_load(f)
+                else:
+                    existing_data = toml.load(f)
+            # merge existing data with new data
+            existing_data.update(data)
+            data = existing_data
+        if not file.parent.exists():
+            file.parent.mkdir(parents=True, exist_ok=True)
+
+        with file.open("w", encoding="utf-8") as f:
+            if type == "json":
+                json.dump(data, f, indent=4)
+            elif type == "yaml":
+                yaml.safe_dump(data, f)
             else:
-                res.parent.mkdir(parents=True, exist_ok=True)
-        return res
+                toml.dump(data, f)
+
+    def serialize(self) -> dict[str, Any]:
+        """Serialize the AppConfig to a dictionary."""
+        return self._serialize_var_defs(self._config_var_defs.values())
 
     def __repr__(self) -> str:
-        mess = ["App Context:"]
-        for cur_var, cur_val in self.__dict__.items():
-            mess.append(f"\t{cur_var}:\t{cur_val}")
+        return str(self.to_dict())
 
-        return "\n".join(mess)
+    def __str__(self) -> str:
+        return json.dumps(self.serialize(), indent=2, sort_keys=True, default=str)