confit 0.11.1__tar.gz → 0.13.0.dev0__tar.gz

{confit-0.11.1 → confit-0.13.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: confit
-Version: 0.11.1
+Version: 0.13.0.dev0
 Summary: Smart configuration framework
 Author-email: Perceval Wajsburt <perceval.wajsburt@aphp.fr>, Thomas Petit-Jean <thomas.petitjean@aphp.fr>, Adam Remaki <adam.remaki@aphp.fr>, Alice Calliger <alice.calliger@aphp.fr>
 License: Copyright 2023 Assistance Publique - Hôpitaux de Paris
@@ -20,7 +20,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: catalogue>=2.0.7
 Requires-Dist: lark>=1.1.5
-Requires-Dist: pydantic>=1.2
+Requires-Dist: pydantic<3,>=2.1.1
 Requires-Dist: pydantic-core>=0.20
 Requires-Dist: PyYAML
 Requires-Dist: griffe
@@ -247,6 +247,29 @@ ConfitValidationError: 2 validation errors for __main__.func()
 
 Visit the [documentation](https://aphp.github.io/confit/) for more information!
 
+### Subcommands
+
+Confit applications can be composed into groups of subcommands:
+
+```python
+app = Cli()
+training = Cli()
+
+
+@training.command(name="run")
+def run(epochs: int = 10):
+    print(f"Training for {epochs} epochs")
+
+
+app.add_subcommands(training, name="training")
+```
+
+Run the nested command with:
+
+```bash
+python script.py training run --config config.yml --epochs 20
+```
+
 ## Acknowledgement
 
 We would like to thank [Assistance Publique – Hôpitaux de Paris](https://www.aphp.fr/)

{confit-0.11.1 → confit-0.13.0.dev0}/README.md

@@ -219,6 +219,29 @@ ConfitValidationError: 2 validation errors for __main__.func()
 
 Visit the [documentation](https://aphp.github.io/confit/) for more information!
 
+### Subcommands
+
+Confit applications can be composed into groups of subcommands:
+
+```python
+app = Cli()
+training = Cli()
+
+
+@training.command(name="run")
+def run(epochs: int = 10):
+    print(f"Training for {epochs} epochs")
+
+
+app.add_subcommands(training, name="training")
+```
+
+Run the nested command with:
+
+```bash
+python script.py training run --config config.yml --epochs 20
+```
+
 ## Acknowledgement
 
 We would like to thank [Assistance Publique – Hôpitaux de Paris](https://www.aphp.fr/)

{confit-0.11.1 → confit-0.13.0.dev0}/confit/_version.py

@@ -4,7 +4,7 @@ import subprocess
 from importlib import metadata
 from pathlib import Path
 
-_BASE_VERSION = "0.11.1"
+_BASE_VERSION = "0.13.0.dev0"
 
 
 def get_version(base_version: str = _BASE_VERSION) -> str:
@@ -36,10 +36,13 @@ def get_version(base_version: str = _BASE_VERSION) -> str:
     except (OSError, subprocess.CalledProcessError):
         tag = None
 
+    development_version = (
+        base_version if ".dev" in base_version else f"{base_version}.dev0"
+    )
     return (
         base_version
         if tag in {base_version, f"v{base_version}"}
-        else f"{base_version}.dev0+g{commit_hash}"
+        else f"{development_version}+g{commit_hash}"
     )
 
 

{confit-0.11.1 → confit-0.13.0.dev0}/confit/cli.py

@@ -2,6 +2,7 @@ import importlib
 import inspect
 import re
 import sys
+import warnings
 from pathlib import Path
 from types import UnionType
 from typing import (
@@ -17,9 +18,11 @@ from typing import (
     get_origin,
 )
 
+from pydantic.fields import FieldInfo
+
 from .config import Config, merge_from_disk
-from .errors import ConfitValidationError, LegacyValidationError, patch_errors
-from .registry import validate_arguments
+from .errors import ConfitValidationError
+from .registry import VisibleDeprecationWarning, validate_arguments
 from .utils.random import set_seed
 from .utils.settings import is_debug
 from .utils.xjson import loads
@@ -75,6 +78,11 @@ class Cli:
 
     def __init__(self, *args: Any, **kwargs: Any):
         self.commands = {}
+        self.subcommands = []
+        self.typer_args = args
+        self.typer_kwargs = kwargs
+        self.typer_cli = None
+        self.typer_warning_emitted = False
 
     # User code calls this as a decorator to register one command.
     # The stored metadata is used by main.
@@ -104,14 +112,188 @@ class Cli:
                 "fn": fn,
                 "validated": validated,
                 "help": help,
+                "typer_options": {
+                    "cls": cls,
+                    "context_settings": context_settings,
+                    "help": help,
+                    "epilog": epilog,
+                    "short_help": short_help,
+                    "options_metavar": options_metavar,
+                    "add_help_option": add_help_option,
+                    "no_args_is_help": no_args_is_help,
+                    "hidden": hidden,
+                    "deprecated": deprecated,
+                    "rich_help_panel": rich_help_panel,
+                },
                 "registry": registry,
                 "default_config": default_config,
                 "merge_with_default_config": merge_with_default_config,
             }
+            self.typer_cli = None
             return validated
 
         return wrapper
 
+    def add_subcommands(
+        self,
+        cli: "Cli",
+        *,
+        name: Optional[str] = None,
+        help: Optional[str] = None,
+        short_help: Optional[str] = None,
+        hidden: bool = False,
+        deprecated: bool = False,
+    ) -> None:
+        """Add another Confit CLI as a group or flattened command entries"""
+        if not isinstance(cli, Cli):
+            raise TypeError("add_subcommands expects a Confit Cli instance")
+        self.subcommands.append(
+            {
+                "cli": cli,
+                "name": name,
+                "help": help,
+                "short_help": short_help,
+                "hidden": hidden,
+                "deprecated": deprecated,
+            }
+        )
+        self.typer_cli = None
+
+    def add_typer(
+        self,
+        cli: "Cli",
+        *,
+        name: Optional[str] = None,
+        help: Optional[str] = None,
+        short_help: Optional[str] = None,
+        hidden: bool = False,
+        deprecated: bool = False,
+    ) -> None:
+        """Add Confit subcommands through the deprecated Typer compatible name"""
+        warnings.warn(
+            "Cli.add_typer() is deprecated, use Cli.add_subcommands() instead.",
+            VisibleDeprecationWarning,
+            stacklevel=2,
+        )
+        self.add_subcommands(
+            cli,
+            name=name,
+            help=help,
+            short_help=short_help,
+            hidden=hidden,
+            deprecated=deprecated,
+        )
+
+    def command_entries(self):
+        """Return the command and group entries used by dispatch and help"""
+        entries = {
+            name: {"kind": "command", "cli": self, "command": command}
+            for name, command in self.commands.items()
+        }
+        for group in self.subcommands:
+            if group["name"] is None:
+                entries.update(group["cli"].command_entries())
+            else:
+                entries[group["name"]] = {
+                    "kind": "group",
+                    "cli": group["cli"],
+                    "group": group,
+                }
+        return entries
+
+    def format_commands_help(self):
+        """Render the visible commands and groups for the current CLI level"""
+        lines = ["Commands:"]
+        for name, entry in self.command_entries().items():
+            if entry["kind"] == "command":
+                options = entry["command"]["typer_options"]
+            else:
+                options = entry["group"]
+            if options["hidden"]:
+                continue
+            description = options.get("short_help") or options.get("help")
+            suffix = " (deprecated)" if options["deprecated"] else ""
+            if description:
+                description = inspect.cleandoc(description).splitlines()[0]
+                lines.append(f"  {name}{suffix}  {description}")
+            else:
+                lines.append(f"  {name}{suffix}")
+        return "\n".join(lines)
+
+    def get_typer_cli(self):
+        """Build and cache the Typer representation read by external Typer apps"""
+        if self.typer_cli is not None:
+            return self.typer_cli
+        try:
+            typer = importlib.import_module("typer")
+        except ImportError as e:
+            raise ImportError(
+                "Typer interoperability requires the application to install "
+                "and declare a dependency on 'typer'."
+            ) from e
+
+        if not self.typer_warning_emitted:
+            warnings.warn(
+                "Adapting a Confit Cli for Typer is deprecated and will be removed "
+                "in the next major Confit release.",
+                VisibleDeprecationWarning,
+                stacklevel=3,
+            )
+            self.typer_warning_emitted = True
+
+        typer_cli = typer.Typer(*self.typer_args, **self.typer_kwargs)
+        for name, command in self.commands.items():
+            options = dict(command["typer_options"])
+            options["context_settings"] = {
+                **(options["context_settings"] or {}),
+                "ignore_unknown_options": True,
+                "allow_extra_args": True,
+            }
+
+            def create_callback(command_name, command_record):
+                def callback(
+                    ctx: typer.Context,
+                    config: Optional[List[Path]] = None,
+                ):
+                    return self.run_command(
+                        command_name,
+                        command_record,
+                        config,
+                        list(ctx.args),
+                    )
+
+                return callback
+
+            typer_cli.command(name=name, **options)(create_callback(name, command))
+
+        for group in self.subcommands:
+            typer_cli.add_typer(
+                group["cli"],
+                name=group["name"],
+                help=group["help"],
+                short_help=group["short_help"],
+                hidden=group["hidden"],
+                deprecated=group["deprecated"],
+            )
+        self.typer_cli = typer_cli
+        return typer_cli
+
+    @property
+    def registered_commands(self):
+        return self.get_typer_cli().registered_commands
+
+    @property
+    def registered_groups(self):
+        return self.get_typer_cli().registered_groups
+
+    @property
+    def registered_callback(self):
+        return self.get_typer_cli().registered_callback
+
+    @property
+    def info(self):
+        return self.get_typer_cli().info
+
     def __call__(self, args: Optional[List[str]] = None):
         return self.main(args=args)
 
@@ -119,27 +301,37 @@ class Cli:
     # It either prints help or executes the selected command.
     def main(self, args: Optional[List[str]] = None):
         args = list(sys.argv[1:] if args is None else args)
-        commands_help = "\n".join(
-            ["Commands:", *(f"  {name}" for name in self.commands)]
-        )
-
-        # The command name is optional for single command apps.
-        # args is left with only config paths and overrides.
-        if args and args[0] in self.commands:
-            name = args.pop(0)
-            command = self.commands[name]
-        elif len(self.commands) == 1:
-            name = next(iter(self.commands))
-            command = self.commands[name]
-        elif args and args[0] in {"--help", "-h"}:
-            print(commands_help)
-            raise SystemExit(0)
-        else:
-            raise Exception("Missing command")
-
-        if not args and len(self.commands) > 1:
-            print(commands_help)
-            raise SystemExit(0)
+        cli = self
+        command = None
+        name = None
+        group_help = None
+        while command is None:
+            entries = cli.command_entries()
+            commands_help = cli.format_commands_help()
+            if group_help:
+                commands_help = f"{inspect.cleandoc(group_help)}\n\n{commands_help}"
+            implicit_command = (
+                cli is self and not self.subcommands and len(entries) == 1
+            )
+            if args and args[0] in {"--help", "-h"} and not implicit_command:
+                print(commands_help)
+                raise SystemExit(0)
+            if args and args[0] in entries:
+                name = args.pop(0)
+                entry = entries[name]
+                if entry["kind"] == "group":
+                    cli = entry["cli"]
+                    group_help = entry["group"]["help"]
+                    continue
+                command = entry["command"]
+            elif implicit_command:
+                name, entry = next(iter(entries.items()))
+                command = entry["command"]
+            else:
+                if not args:
+                    print(commands_help)
+                    raise SystemExit(0)
+                raise Exception("Missing command")
 
         if any(arg in {"--help", "-h"} for arg in args):
             print(add_config_overrides_help(command["help"], command["fn"]))
@@ -180,19 +372,13 @@ class Cli:
         if default_config is not None and merge_with_default_config:
             config = Config(default_config).merge(config)
 
-        # model_fields tells whether dotted overrides start at the command section.
-        # For example model.date becomes script.model.date when model is a parameter.
-        model_fields = (
-            validated.model.model_fields
-            if hasattr(validated.model, "model_fields")
-            else validated.model.__fields__
-        )
+        parameters = inspect.signature(fn).parameters
         for key, value in parse_overrides(overrides).items():
             if "." not in key:
                 parts = (name, key)
             else:
                 parts = key.split(".")
-                if parts[0] in model_fields and parts[0] not in config:
+                if parts[0] in parameters and parts[0] not in config:
                     parts = (name, *parts)
             current = config
             if parts[0] not in current:
@@ -202,9 +388,11 @@ class Cli:
             current[parts[-1]] = value
 
         try:
-            default_seed = model_fields.get("seed")
-            if default_seed is not None:
+            default_seed = parameters["seed"].default if "seed" in parameters else None
+            if isinstance(default_seed, FieldInfo):
                 default_seed = default_seed.get_default()
+            elif default_seed is inspect.Parameter.empty:
+                default_seed = None
             seed = Config.resolve(
                 config.get(name, {}).get("seed", default_seed),
                 registry=registry,
@@ -224,8 +412,8 @@ class Cli:
                 )
                 return validated(**resolved_config, config_meta=config_meta)
             return validated(**resolved_config)
-        except (LegacyValidationError, ConfitValidationError) as e:
-            e.raw_errors = patch_errors(e.raw_errors, (name,))
+        except ConfitValidationError as e:
+            e = e.with_path((name,))
             if is_debug() or e.__cause__ is not None:
                 raise e
             print("Validation error:", str(e))

{confit-0.11.1 → confit-0.13.0.dev0}/confit/config.py

@@ -15,7 +15,6 @@ from confit.errors import (
     ConfitValidationError,
     CyclicReferenceError,
     MissingReference,
-    patch_errors,
     remove_lib_from_traceback,
 )
 from confit.utils.collections import flatten_sections, join_path, split_path
@@ -24,6 +23,7 @@ from confit.utils.settings import is_debug
 from confit.utils.xjson import Reference, dumps, loads
 
 RESOLVED_TO_CONFIG = WeakKeyDictionary()
+RESOLVED_TO_CONFIGS = WeakKeyDictionary()
 
 Loc = Tuple[Union[int, str]]
 T = TypeVar("T")
@@ -117,13 +117,9 @@ class Config(dict):
                     current = current[part]
 
             current.clear()
-            errors = []
             for k, v in parser.items(section):
                 current[loads(k)] = loads(v)
 
-            if errors:
-                raise ConfitValidationError(errors=errors)
-
         if resolve:
             return config.resolve(registry=registry)
 
@@ -207,6 +203,9 @@ class Config(dict):
         Try to convert non-serializable objects using the RESOLVED_TO_CONFIG object
         back to their original catalogue + params form
 
+        Objects can set `__confit_serialization_origin__` to `"first"` to use
+        their first recorded origin instead of the latest origin
+
         We try to preserve referential equalities between non dict/list/tuple
         objects by serializing subsequent references to the same object as references
         to its first occurrence in the tree.
@@ -258,7 +257,13 @@ class Config(dict):
                 return type(o)(rec(v, (*path, i)) for i, v in enumerate(o))
             cfg = None
             try:
-                cfg = (cfg or Config()).merge(RESOLVED_TO_CONFIG[o])
+                try:
+                    origins = RESOLVED_TO_CONFIGS[o]
+                    origin = getattr(o, "__confit_serialization_origin__", "last")
+                    origin_config = origins[0] if origin == "first" else origins[-1]
+                except KeyError:
+                    origin_config = RESOLVED_TO_CONFIG[o]
+                cfg = (cfg or Config()).merge(origin_config)
             except (KeyError, TypeError):
                 pass
             try:
@@ -454,11 +459,9 @@ class Config(dict):
                         # we need to do it here
                         Config._store_resolved(resolved, cfg)
                     except ConfitValidationError as e:
-                        e = ConfitValidationError(
-                            errors=patch_errors(e.raw_errors, loc, params),
-                            model=e.model,
-                            name=getattr(e, "name", None),
-                        ).with_traceback(remove_lib_from_traceback(e.__traceback__))
+                        e = e.with_path(loc).with_traceback(
+                            remove_lib_from_traceback(e.__traceback__)
+                        )
                         if not is_debug():
                             e.__cause__ = None
                             e.__suppress_context__ = True
@@ -598,7 +601,7 @@ class Config(dict):
     @classmethod
     def _store_resolved(cls, resolved: Any, config: Dict[str, Any]):
         """
-        Adds a resolved object to the RESOLVED_TO_CONFIG dict
+        Adds a resolved object and its origin to the serialization mappings
         for later retrieval during serialization
         ([`.serialize`][confit.config.Config.serialize])
 
@@ -609,6 +612,8 @@ class Config(dict):
         """
         try:
             RESOLVED_TO_CONFIG[resolved] = config
+            origins = RESOLVED_TO_CONFIGS.setdefault(resolved, [])
+            origins.append(config)
         except TypeError:
             pass
 

{confit-0.11.1 → confit-0.13.0.dev0}/confit/draft.py

@@ -11,22 +11,12 @@ from typing import (
 )
 
 import pydantic
+from pydantic_core import core_schema
 from typing_extensions import ParamSpec, Protocol
 
-from confit.errors import (
-    ConfitValidationError,
-    ErrorWrapper,
-    patch_errors,
-    to_legacy_error,
-)
+from confit.errors import ConfitValidationError
 from confit.typing import cast
 
-if pydantic.VERSION >= "2":
-    from pydantic_core import core_schema
-
-
-PYDANTIC_V1 = pydantic.VERSION.split(".")[0] == "1"
-
 P = ParamSpec("P")
 R = TypeVar("R", covariant=True)
 
@@ -94,14 +84,9 @@ class MetaDraft(type):
 
     def validate(cls, value, config=None):
         if not isinstance(value, Draft):
-            raise ConfitValidationError(
-                [
-                    ErrorWrapper(
-                        exc=TypeError(f"Expected {cls}, got {value.__class__}"),
-                        loc=(),
-                    ),
-                ],
-                model=cls,
+            raise ConfitValidationError.from_exception(
+                TypeError(f"Expected {cls}, got {value.__class__}"),
+                source=cls,
                 name=cls.__name__,
             )
         actual = value._func
@@ -115,23 +100,13 @@ class MetaDraft(type):
             else:  # pragma: no cover
                 cast(Union[Type[cls.type_], Callable[..., cls.type_]], actual)
         except pydantic.ValidationError as e:
-            e = to_legacy_error(e, None)
-            e = ConfitValidationError(
-                [
-                    ErrorWrapper(
-                        exc=TypeError(f"Expected {cls}, got {Draft[actual]}"),
-                        loc=e.raw_errors[0]._loc,
-                    ),
-                ],
-                model=cls,
+            raise ConfitValidationError.from_exception(
+                TypeError(f"Expected {cls}, got {Draft[actual]}"),
+                source=cls,
                 name=cls.__name__,
-            )
-            raise e
+            ).with_path(e.errors()[0]["loc"])
         return value
 
-    def __get_validators__(cls):
-        yield cls.validate
-
     def __get_pydantic_core_schema__(cls, source, handler):
         return core_schema.no_info_plain_validator_function(cls.validate)
 
@@ -183,11 +158,7 @@ class Draft(Generic[R], metaclass=MetaDraft):
         try:
             res = self._func(**{**kwargs, **self._kwargs})
         except ConfitValidationError as e:
-            raise ConfitValidationError(
-                patch_errors(e.raw_errors, self._loc, self._kwargs),
-                model=e.model,
-                name=getattr(e, "name", None),
-            ).with_traceback(e.__traceback__)
+            raise e.with_path(self._loc).with_traceback(e.__traceback__)
         return res
 
     def _raise_draft_error(self):