[FEATURE] Support Pydantic Models as ParamTypes about typer HOT 15 OPEN

#!/usr/bin/env python3

import click
import pydantic
import typer


class User(pydantic.BaseModel):
    id: int
    name: str = "Jane Doe"


def main(num: int, user: User):
    print(num, type(num))
    print(user, type(user))


if __name__ == "__main__":
    typer.run(main)

#!/usr/bin/env python3
from typing import Any

import click
import pydantic
import typer


_get_click_type = typer.main.get_click_type


def supersede_get_click_type(
    *, annotation: Any, parameter_info: typer.main.ParameterInfo
) -> click.ParamType:
    if hasattr(annotation, "parse_raw"):

        class CustomParamType(click.ParamType):
            def convert(self, value, param, ctx):
                return annotation.parse_raw(value)

        return CustomParamType()
    else:
        return _get_click_type(annotation=annotation, parameter_info=parameter_info)


typer.main.get_click_type = supersede_get_click_type


class User(pydantic.BaseModel):
    id: int
    name = "Jane Doe"


def main(num: int, user: User):
    print(num, type(num))
    print(user, type(user))


if __name__ == "__main__":
    typer.run(main)

import typer

def hello(name: str):
    return f"Hello {name}"

if __name__ == "__main__":
    app = typer.Typer()
    app.command()(hello)

from rich import print
from rich.panel import Panel
from rich.prompt import Confirm, Prompt

class MyBaseModel(BaseModel):
    """Tweaked BaseModel to manage the template settings.

    Adds functionality to prompt user via CLI for values of fields.

    Assumes that all fields have either a default value (None is acceptable,
    even if the field it is not optional) or another nested model.

    This ensures that the object can be constructed without being complete yet.
    """

    model_config = ConfigDict(
        str_strip_whitespace=True, str_min_length=1, validate_assignment=True
    )

    def check(self):
        """Run validation on this object again."""
        self.model_validate(self.model_dump())

    @staticmethod
    def _unpack_annotation(ann):
        """Unpack an annotation from optional, raise exception if it is a non-trivial union."""
        o, ts = get_origin(ann), get_args(ann)
        is_union = o is Union
        fld_types = [ann] if not is_union else [t for t in ts if t is not type(None)]

        ret = []
        for t in fld_types:
            inner_kind = get_origin(t)
            if inner_kind is Literal:
                ret.append([a for a in get_args(t)])
            elif inner_kind is Union:
                raise TypeError("Complex nested types are not supported!")
            else:
                ret.append(t)
        return ret

    def _field_prompt(self, key: str, *, required_only: bool = False):
        """Interactive prompt for one primitive field of the object (one-shot, no retries)."""
        fld = self.model_fields[key]
        val = getattr(self, key, None)

        if required_only and not fld.is_required():
            return val

        defval = val or fld.default

        prompt_msg = f"\n[b]{key}[/b]"
        if fld.description:
            prompt_msg = f"\n[i]{fld.description}[/i]{prompt_msg}"

        ann = self._unpack_annotation(fld.annotation)
        fst, tail = ann[0], ann[1:]

        choices = fst if isinstance(fst, list) else None
        if fst is bool and not tail:
            defval = bool(defval)
            user_val = Confirm.ask(prompt_msg, default=defval)
        else:
            if not isinstance(defval, str) and defval is not None:
                defval = str(defval)
            user_val = Prompt.ask(prompt_msg, default=defval, choices=choices)

        setattr(self, key, user_val)  # assign (triggers validation)
        return getattr(self, key)  # return resulting parsed value

    def prompt_field(
        self,
        key: str,
        *,
        recursive: bool = True,
        missing_only: bool = False,
        required_only: bool = False,
    ) -> Any:
        """Interactive prompt for one field of the object.

        Will show field description to the user and pre-set the current value of the model as the default.

        The resulting value is validated and assigned to the field of the object.
        """
        val = getattr(self, key)
        if isinstance(val, MyBaseModel):
            if recursive:
                val.prompt_fields(
                    missing_only=missing_only,
                    recursive=recursive,
                    required_only=required_only,
                )
            else:  # no recursion -> just skip nested objects
                return

        # primitive case - prompt for value and retry if given invalid input
        while True:
            try:
                # prompt, parse and return resulting value
                return self._field_prompt(key, required_only=required_only)
            except ValidationError as e:
                print()
                print(Panel.fit(str(e)))
                print("[red]The provided value is not valid, please try again.[/red]")

    def prompt_fields(
        self,
        *,
        recursive: bool = True,
        missing_only: bool = False,
        required_only: bool = False,
        exclude: List[str] = None,
    ):
        """Interactive prompt for all fields of the object. See `prompt_field`."""
        excluded = set(exclude or [])
        for key in self.model_fields.keys():
            if missing_only and getattr(self, key, None) is None:
                continue
            if key not in excluded:
                self.prompt_field(
                    key,
                    recursive=recursive,
                    missing_only=True,
                    required_only=required_only,
                )