[FEATURE] support Pydantic BaseModel to "collect" all kwargs, like FastAPI

[odoublewen]

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the Typer documentation, with the integrated search.
• I already searched in Google "How to X in Typer" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to Typer but to Click.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from typer import Typer
from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None

app = Typer()

@app.command("create")
def create_item(item: Item):
    return item

Description

I might be missing something, but wouldn't it be cool if Typer could work like this FastAPI docs example.

This feature request superficially resembles #111 but notice I'm seeking to use a Pydantic BaseModel as THE input for the function, not just as a custom type for one of many args.

I struggled to write a descriptive title that would differentiate it from this other request (which is also well reasoned I think). I think the example code makes it clear what I'm thinking of.

Operating System

Linux, macOS

Operating System Details

No response

Typer Version

0.9.0

Python Version

Python 3.10.11

Additional Context

I love Typer, thanks!

[alex-janss]

This works for me:

@app.command()
class foo_cmd(BaseModel):
    """foo cmd"""
    x: int
    y: bool = False

    def model_post_init(self, _):
        print(f"{self.x=}, {self.y=}")

[shomeax]

@alex-janss while provided example supports docstring of model as an app description, it totally ignores either docstrings or Field(description='...') or Field(title='...') annotations in the app --help output

[xkollar]

This is a great proof of concept, but I think there’s still room for improvement. When working with a function like def fun(conf: Config): ..., I’d love to have the flexibility to both expose it via a command-line interface and run it as part of a service. For example, the service could receive a config (via Kafka, FastAPI, etc.) and then execute fun with that.

I’d prefer not to tie this to model_post_init, as I think decoupling the message reception from the code execution is important—there might be an internal queue, additional validation, or other intermediate steps involved.

Perhaps there’s an opportunity for a separate package to address this? A solution that allows defining a single model for function arguments, while supporting multiple ingestion methods without code duplication, would be incredibly useful. 😇

It feels like typer and pydantic could be an amazing match, and I think this could be a good step in that direction.

[shomeax]

also, name argument to @app.command() seems to have no effect

[shomeax]

Ahh, that's what I'm got about parameter names.

from typer import Typer, Argument, Option
from pydantic import BaseModel, Field
from enum import StrEnum

class SomeProfile(StrEnum):
    low = 'low'
    medium = 'medium'
    high = 'high'

app = Typer()

@app.command()
class SomeParams(BaseModel):
    """
    Do something
    """

    name: str
    profile: Annotated[SomeProfile, Option(help='Size profile'), Field(default='low')]

and now we get a nice help:

$ typer main.py --help

Usage: main.py [OPTIONS] NAME                                                                                                                                                                              
                                                                                                                                                                                                                        
 Do something

  Arguments
   *  name  TEXT [default: None] [required]
  Options
   --profile  [low|medium|high]    Size profile [default: low]