pipelime-python 2.2.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

pipelime/cli/tui/utils.py

@@ -1,12 +1,13 @@
+import inspect
 from enum import Enum
 from typing import List, Mapping, Tuple, Type, cast
 
-from pydantic.v1 import BaseModel
-from pydantic.v1.fields import ModelField
+from pydantic import BaseModel
 
 from pipelime.cli.utils import PipelimeSymbolsHelper
 from pipelime.piper import PipelimeCommand
 from pipelime.stages import SampleStage, StageInput
+from pipelime.utils.pydantic_compat import FieldView, iter_fields, strip_annotated
 
 
 class TuiField(BaseModel):
@@ -31,9 +32,9 @@ def is_tui_needed(cmd_cls: Type[PipelimeCommand], cmd_args: Mapping) -> bool:
     Returns:
         True if the TUI is needed, False otherwise.
     """
-    for field in cmd_cls.__fields__.values():
+    for field in iter_fields(cmd_cls):
         name = field.name
-        alias = field.alias
+        alias = field.effective_alias
         required = field.required
 
         if (name not in cmd_args) and (alias not in cmd_args) and required:
@@ -41,7 +42,7 @@ def is_tui_needed(cmd_cls: Type[PipelimeCommand], cmd_args: Mapping) -> bool:
             return True
 
         # if present, check if it's a StageInput
-        if field.type_ == StageInput:
+        if field.inner_type is StageInput:
             if name in cmd_args:
                 stage_input_args = cmd_args.get(name)
             else:
@@ -81,9 +82,9 @@ def are_stageinput_args_present(
     Returns:
         True if the StageInput required args are present, False otherwise.
     """
-    for field in stage_cls.__fields__.values():
+    for field in iter_fields(stage_cls):
         name = field.name
-        alias = field.alias
+        alias = field.effective_alias
         required = field.required
 
         if (name not in stage_args) and (alias not in stage_args) and required:
@@ -93,7 +94,7 @@ def are_stageinput_args_present(
     return True
 
 
-def init_tui_field(field: ModelField, args: Mapping) -> TuiField:
+def init_tui_field(field: FieldView, args: Mapping) -> TuiField:
     """Initialize a TuiField.
 
     Args:
@@ -108,10 +109,10 @@ def init_tui_field(field: ModelField, args: Mapping) -> TuiField:
 
     if field.name in args:
         default = str(args[field.name])
-    elif field.alias in args:
-        default = str(args[field.alias])
+    elif field.effective_alias in args:
+        default = str(args[field.effective_alias])
     else:
-        field_default = field.get_default()
+        field_default = None if field.required else field.default
 
         if field_default is not None:
             if isinstance(field_default, BaseModel):
@@ -124,7 +125,7 @@ def init_tui_field(field: ModelField, args: Mapping) -> TuiField:
     tui_field = TuiField(
         simple=True,
         name=field.name,
-        description=str(field.field_info.description),
+        description=str(field.description),
         hint=hint,
         type_=get_field_type(field),
         value=default,
@@ -132,7 +133,7 @@ def init_tui_field(field: ModelField, args: Mapping) -> TuiField:
     return tui_field
 
 
-def init_stageinput_tui_field(field: ModelField, cmd_args: Mapping) -> TuiField:
+def init_stageinput_tui_field(field: FieldView, cmd_args: Mapping) -> TuiField:
     """Initialize a TuiField for a StageInput.
 
     Args:
@@ -142,11 +143,11 @@ def init_stageinput_tui_field(field: ModelField, cmd_args: Mapping) -> TuiField:
     Returns:
         The initialized TuiField.
     """
-    if (field.name not in cmd_args) and (field.alias not in cmd_args):
+    if (field.name not in cmd_args) and (field.effective_alias not in cmd_args):
         tui_field = TuiField(
             simple=True,
             name=field.name,
-            description=str(field.field_info.description),
+            description=str(field.description),
             type_=get_field_type(field),
         )
         return tui_field
@@ -154,7 +155,7 @@ def init_stageinput_tui_field(field: ModelField, cmd_args: Mapping) -> TuiField:
     if field.name in cmd_args:
         stage_input_args = cmd_args.get(field.name)
     else:
-        stage_input_args = cmd_args.get(field.alias)
+        stage_input_args = cmd_args.get(field.effective_alias)
 
     stage_name = ""
     stage_args = {}
@@ -170,8 +171,8 @@ def init_stageinput_tui_field(field: ModelField, cmd_args: Mapping) -> TuiField:
     stage_cls = stage_info[-1]
 
     tui_fields = []
-    for field in stage_cls.__fields__.values():
-        tui_fields.append(init_tui_field(field, stage_args))
+    for f in iter_fields(stage_cls):
+        tui_fields.append(init_tui_field(f, stage_args))
 
     tui_field = TuiField(
         simple=False,
@@ -182,7 +183,7 @@ def init_stageinput_tui_field(field: ModelField, cmd_args: Mapping) -> TuiField:
     return tui_field
 
 
-def get_field_type(field: ModelField) -> str:
+def get_field_type(field: FieldView) -> str:
     """Get the type of a field.
 
     Args:
@@ -191,12 +192,14 @@ def get_field_type(field: ModelField) -> str:
     Returns:
         The type of the field.
     """
-    type_ = field.annotation
-
-    if "typing." in str(type_):
-        type_ = str(type_).replace("typing.", "")
+    # constrained types (`Annotated[int, Gt(gt=0)]`) are shown as their base type
+    type_ = strip_annotated(field.annotation)
+    if inspect.isclass(type_) and not getattr(type_, "__args__", None):
+        type_ = type_.__name__
     else:
-        type_ = field.annotation.__name__
+        # `typing` aliases print as `typing.List[int]`, modern hints as written
+        # (`list[int]`, `int | None`); never rely on `__name__` (UnionType has none)
+        type_ = str(type_).replace("typing.", "")
 
     # replace common pipelime types
     common_pipelime_types = {

pipelime/cli/utils.py

@@ -9,7 +9,7 @@ from types import ModuleType
 
 import yaml
 from loguru import logger
-from pydantic.v1 import BaseModel, ValidationError
+from pydantic import BaseModel, ValidationError
 from rich import get_console
 from rich.prompt import Prompt
 from yaml.error import YAMLError
@@ -108,13 +108,15 @@ class PipelimeSymbolsHelper:
 
     @classmethod
     def _symbol_name(cls, symbol):
-        from pydantic.v1 import BaseModel
+        import inspect
 
-        return (
-            symbol.__config__.title
-            if issubclass(symbol, BaseModel) and symbol.__config__.title
-            else symbol.__name__
-        )
+        from pydantic import BaseModel
+
+        from pipelime.utils.pydantic_compat import model_title
+
+        if inspect.isclass(symbol) and issubclass(symbol, BaseModel):
+            return model_title(symbol)
+        return symbol.__name__
 
     @classmethod
     def _warn_double_def(cls, type_, name, first, second):
@@ -148,22 +150,28 @@ class PipelimeSymbolsHelper:
             )
 
             # set module path when loading from file
+            # NB: only for the classes defined there, a class the file imports
+            # (eg, `from pipelime.stages import StageEntity`) keeps its own path
             if module_name.endswith(".py"):
                 for _, sym_cls in module_symbols:
-                    sym_cls._classpath = f"{module_name}:{sym_cls.__name__}"
+                    if sym_cls.__module__ == module_.__name__:
+                        sym_cls._classpath = f"{module_name}:{sym_cls.__name__}"
 
             # check for double symbols in the same module
+            # NB: the same class re-exported under another name is not a duplicate
             for idx, (sym_name, sym_cls) in enumerate(module_symbols):
                 for other_sym_name, other_sym_cls in module_symbols[idx + 1 :]:  # noqa
-                    if sym_name == other_sym_name:
+                    if sym_name == other_sym_name and sym_cls is not other_sym_cls:
                         cls._warn_double_def(
                             symbol_type, sym_name, sym_cls, other_sym_cls
                         )
 
             # check for double commands across modules
+            # NB: a module importing a symbol from another one (eg, a user file
+            # with `from pipelime.stages import StageEntity`) is not a duplicate
             module_symbols = dict(module_symbols)
             for sym_name, sym_cls in module_symbols.items():
-                if sym_name in all_syms:
+                if sym_name in all_syms and all_syms[sym_name] is not sym_cls:
                     cls._warn_double_def(
                         symbol_type, sym_name, sym_cls, all_syms[sym_name]
                     )
@@ -631,7 +639,7 @@ def pl_print(
     """
     import inspect
 
-    from pydantic.v1 import BaseModel
+    from pydantic import BaseModel
     from rich import print as rprint
 
     from pipelime.cli.pretty_print import print_model_info
@@ -720,9 +728,11 @@ def get_pipelime_command_cls(
     return cmd_cls[1]
 
 
-def get_pipelime_command(
+def resolve_pipelime_command(
     cmd: "T_DAG_NODE", checkpoint: t.Optional["CheckpointNamespace"] = None
-) -> "PipelimeCommand":
+):
+    """Splits a DAG node definition into the command class (None when `cmd` is
+    already an instance) and a zero-arg builder returning the command."""
     from pipelime.piper.model import LazyCommand, PipelimeCommand
 
     cmd_cls, cmd_args = None, {}
@@ -734,19 +744,28 @@ def get_pipelime_command(
     elif isinstance(cmd, LazyCommand):
         cmd_cls = cmd
 
-    if cmd_cls is not None:
-        cmd = (
-            cmd_cls(**cmd_args)
-            if checkpoint is None
-            else cmd_cls.init_from_checkpoint(checkpoint, **cmd_args)
-        )
+    def _build() -> "PipelimeCommand":
+        obj = cmd
+        if cmd_cls is not None:
+            obj = (
+                cmd_cls(**cmd_args)
+                if checkpoint is None
+                else cmd_cls.init_from_checkpoint(checkpoint, **cmd_args)
+            )
+        if not isinstance(obj, PipelimeCommand):
+            raise ValueError(f"{obj} is not a pipelime command.")
+        if checkpoint is not None:
+            obj._checkpoint = checkpoint
+        return obj
+
+    real_cls = cmd_cls.command_class if isinstance(cmd_cls, LazyCommand) else cmd_cls
+    return real_cls, _build
 
-    if not isinstance(cmd, PipelimeCommand):
-        raise ValueError(f"{cmd} is not a pipelime command.")
 
-    if checkpoint is not None:
-        cmd._checkpoint = checkpoint
-    return cmd
+def get_pipelime_command(
+    cmd: "T_DAG_NODE", checkpoint: t.Optional["CheckpointNamespace"] = None
+) -> "PipelimeCommand":
+    return resolve_pipelime_command(cmd, checkpoint)[1]()
 
 
 def time_to_str(nanosec: int) -> str:
@@ -761,21 +780,29 @@ def time_to_str(nanosec: int) -> str:
     return str(timedelta(microseconds=nanosec / 1000))
 
 
-def show_field_alias_valerr(e: ValidationError):
-    def _replace_alias(val):
-        if isinstance(val, str):
-            for field in e.model.__fields__.values():  # type: ignore
-                if (
-                    field.model_config.allow_population_by_field_name
-                    and field.has_alias
-                    and field.alias == val
-                ):
-                    return f"{field.name} / {field.alias}"
-        return val
+def format_validation_error(e: ValidationError, model_cls=None) -> str:
+    """The error text with `name / alias` locations, as pipelime 2.x printed them.
+    `model_cls` is the class that raised (v2 errors do not carry it)."""
+    from pipelime.utils.pydantic_compat import iter_fields
+
+    alias_to_name = {}
+    if model_cls is not None and model_cls.model_config.get("populate_by_name"):
+        alias_to_name = {
+            f.alias: f"{f.name} / {f.alias}"
+            for f in iter_fields(model_cls)
+            if f.has_alias
+        }
 
+    lines = [f"{e.error_count()} validation error(s) for {e.title}"]
     for err in e.errors():
-        if "loc" in err:
-            err["loc"] = tuple(_replace_alias(pos) for pos in err["loc"])
+        loc = " -> ".join(str(alias_to_name.get(p, p)) for p in err.get("loc", ()))
+        lines.append(f"{loc or '(root)'}\n  {err['msg']} [type={err['type']}]")
+    return "\n".join(lines)
+
+
+def show_field_alias_valerr(e: ValidationError, model_cls=None) -> str:
+    """The pipelime 2.x name of `format_validation_error`."""
+    return format_validation_error(e, model_cls)
 
 
 def parse_user_input(s: str) -> t.Any: