confit 0.12.0__tar.gz → 0.13.0.dev0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: confit
-Version: 0.12.0
+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

{confit-0.12.0 → 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.12.0"
+_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.12.0 → confit-0.13.0.dev0}/confit/cli.py

@@ -18,8 +18,10 @@ 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 .errors import ConfitValidationError
 from .registry import VisibleDeprecationWarning, validate_arguments
 from .utils.random import set_seed
 from .utils.settings import is_debug
@@ -370,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:
@@ -392,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,
@@ -414,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.12.0 → 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
@@ -118,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)
 
@@ -464,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

{confit-0.12.0 → 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):

confit-0.13.0.dev0/confit/errors.py

@@ -0,0 +1,265 @@
+import inspect
+import warnings
+from textwrap import indent
+from typing import Callable, Tuple, Union
+
+import pydantic
+
+from confit.utils.collections import join_path
+from confit.utils.settings import is_debug
+from confit.utils.xjson import Reference
+
+Loc = Tuple[Union[int, str]]
+
+
+class MissingReference(Exception):
+    """
+    Raised when one or multiple references cannot be resolved.
+    """
+
+    def __init__(self, ref: Reference):
+        """
+        Parameters
+        ----------
+        ref: Reference
+            The reference that could not be resolved.
+        """
+        self.ref = ref
+        super().__init__()
+
+    def __str__(self):
+        """
+        String representation of the exception
+        """
+        return "Could not interpolate the following reference: {}".format(self.ref)
+
+
+class CyclicReferenceError(Exception):
+    """
+    Raised when a cyclic reference is detected.
+    """
+
+    def __init__(self, path: Loc):
+        """
+        Parameters
+        ----------
+        path: Loc
+            The path of the cyclic reference
+        """
+        self.path = path
+        super().__init__()
+
+    def __str__(self):
+        """
+        String representation of the exception
+        """
+        return "Cyclic reference detected at {}".format(join_path(self.path))
+
+
+def remove_lib_from_traceback(tb):
+    """
+    Remove the lib folder from the traceback
+    """
+    # compare package to module in f_globals
+    if is_debug():
+        return tb
+    if tb is not None and tb.tb_frame.f_globals.get("__package__") == __package__:
+        return remove_lib_from_traceback(tb.tb_next)
+    if tb is None or tb.tb_next is None:
+        return tb
+    tb.tb_next = remove_lib_from_traceback(tb.tb_next)
+    return tb
+
+
+class ConfitValidationError(ValueError):
+    """
+    Structured validation errors with paths added by config and pipeline resolution
+    """
+
+    def __init__(self, errors, *, name=None, source=None, model=None):
+        if model is not None:
+            warnings.warn(
+                "Use source instead of model", DeprecationWarning, stacklevel=2
+            )
+            source = model
+        self.source = source
+        self.name = name or getattr(source, "__qualname__", None)
+        # Old EDS-NLP callers can aggregate lists of errors inside another list
+        self.details = [
+            detail
+            for error in errors
+            for detail in (
+                ConfitValidationError(error).details
+                if isinstance(error, list)
+                else [error]
+            )
+        ]
+        super().__init__(self.details)
+
+    @classmethod
+    def from_exception(cls, error, *, source=None, name=None, signature=None):
+        """
+        Normalize Pydantic errors before config resolution adds its parent path
+        """
+        if isinstance(error, cls):
+            return cls(
+                error.errors(), source=source or error.source, name=name or error.name
+            )
+        if not isinstance(error, pydantic.ValidationError):
+            return cls(
+                [
+                    {
+                        "loc": (),
+                        "msg": str(error),
+                        "type": "value_error",
+                        "ctx": {"error": error},
+                    }
+                ],
+                source=source,
+                name=name,
+            )
+        details = []
+        for detail in error.errors(include_url=False):
+            loc = detail["loc"]
+            if signature is not None and loc and isinstance(loc[0], int):
+                names = [
+                    name
+                    for name, p in signature.parameters.items()
+                    if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
+                ]
+                if loc[0] < len(names):
+                    loc = (names[loc[0]], *loc[1:])
+            nested = detail.get("ctx", {}).get("error")
+            if isinstance(nested, cls):
+                target = source
+                # Only typed construction joins paths, separate calls keep their name
+                try:
+                    for part in loc:
+                        target = (
+                            target.model_fields[part].annotation
+                            if hasattr(target, "model_fields")
+                            else inspect.signature(target).parameters[part].annotation
+                        )
+                except (KeyError, AttributeError, TypeError, ValueError):
+                    target = None
+                if target is not None and target is nested.source:
+                    details.extend(nested.with_path(loc).errors())
+                    continue
+            details.append({**detail, "loc": loc})
+        return cls(details, source=source, name=name)
+
+    def with_path(self, path, *, name=None):
+        """
+        Return an error with a parent path without modifying shared component errors
+        """
+        return type(self)(
+            [{**detail, "loc": (*path, *detail["loc"])} for detail in self.details],
+            source=self.source,
+            name=name or self.name,
+        )
+
+    @classmethod
+    def combine(cls, errors, *, name=None):
+        """
+        Collect failures from sibling components in their original order
+        """
+        return cls([detail for error in errors for detail in error.errors()], name=name)
+
+    def errors(self):
+        return [dict(detail) for detail in self.details]
+
+    def __str__(self):
+        lines = []
+        for detail in self.details:
+            original = detail.get("ctx", {}).get("error")
+            original = original if isinstance(original, BaseException) else None
+            msg = str(original) if original is not None else detail["msg"]
+            if original is None:
+                msg = (
+                    "field required"
+                    if detail["type"].startswith("missing")
+                    else msg[:1].lower() + msg[1:]
+                )
+                if "input" in detail and not detail["type"].startswith("missing"):
+                    value = detail["input"]
+                    try:
+                        preview = repr(value)
+                    except Exception:
+                        preview = object.__repr__(value)
+                    preview = preview[:50] + "..." if len(preview) > 50 else preview
+                    msg += f", got {preview} ({type(value).__name__})"
+            lines.append(
+                "-> " + ".".join(map(str, detail["loc"])) + "\n" + indent(msg, "   ")
+            )
+        count = len(self.details)
+        name = f" for {self.name}()" if self.name is not None else ""
+        return (
+            f"{count} validation error{'s' if count != 1 else ''}{name}\n"
+            + "\n".join(lines)
+        )
+
+    @property
+    def raw_errors(self):
+        warnings.warn(
+            "Use errors() instead of raw_errors", DeprecationWarning, stacklevel=2
+        )
+        return self.errors()
+
+    @raw_errors.setter
+    def raw_errors(self, errors):
+        warnings.warn(
+            "Use with_path or combine instead of assigning raw_errors",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.details = type(self)(errors).details
+
+    @property
+    def model(self):
+        warnings.warn("Use source instead of model", DeprecationWarning, stacklevel=2)
+        return self.source
+
+    @model.setter
+    def model(self, model):
+        warnings.warn("Use source instead of model", DeprecationWarning, stacklevel=2)
+        self.source = model
+
+
+class SignatureError(TypeError):
+    def __init__(self, func: Callable):
+        message = f"{func} must not have positional only args or duplicated kwargs"
+        super().__init__(message)
+
+
+def patch_errors(errors, path=(), values=None, model=None, drop_names=()):
+    """
+    Adapt old EDS-NLP error calls to ConfitValidationError methods
+    """
+    warnings.warn(
+        "Use ConfitValidationError.from_exception and with_path "
+        "instead of patch_errors",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    is_exception = isinstance(errors, (pydantic.ValidationError, ConfitValidationError))
+    error = (
+        ConfitValidationError.from_exception(errors, source=model)
+        if is_exception
+        else ConfitValidationError(errors, source=model)
+    )
+    error = error.with_path(path)
+    if drop_names:
+        error = ConfitValidationError(
+            [
+                {
+                    **detail,
+                    "loc": tuple(
+                        part for part in detail["loc"] if part not in drop_names
+                    ),
+                }
+                for detail in error.errors()
+            ],
+            source=error.source,
+            name=error.name,
+        )
+    return error if is_exception else error.errors()