[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.

[xkollar]

Thinking about it more I came up with slightly nicer workaround:

from enum import StrEnum
from typing import Never

import typer
from pydantic import BaseModel, ConfigDict
from typing_extensions import Annotated, override


class Env(StrEnum):
    local = "local"
    dev = "dev"
    research = "research"
    pre = "pre"
    prod = "prod"


class Config(BaseModel):
    environment: Annotated[Env, typer.Option(help="Environment to run the service in")]
    api_key: Annotated[str, typer.Option(help="API key to authenticate with")]
    port: Annotated[int, typer.Option(help="Port to run the service on")] = 8080
    debug: Annotated[bool, typer.Option(help="Enable debug mode")] = False


def function_that_takes_config(config: Config) -> None:
    print(config.model_dump_json(indent=2))


cli = typer.Typer(add_completion=False, help="A CLI tool to demonstrate use of typer with pydantic")


@cli.command()  # type: ignore[no-any-expr]
class Command(Config):
    """Command To Do fun things!"""

    model_config = ConfigDict(extra="forbid")

    @override
    def model_post_init(self, __context: Never) -> None:
        function_that_takes_config(self)


@cli.command()  # type: ignore[no-any-expr]
def other_command() -> None:
    """Command that takes config from some other source"""
    json_data = '{"environment": "dev", "api_key": "1234", "port": 8081}'
    config = Config.model_validate_json(json_data)
    function_that_takes_config(config)


if __name__ == "__main__":
    cli()

And to make mypy happy I added to my pyproject.toml

[tool.mypy]
...
plugins = ["pydantic.mypy"]

[tool.pydantic-mypy]
init_forbid_extra = true
init_typed = true

I'm moderately happy with this as it decouples creation of config from executing code, IDE gives good hints, and it has pretty command-line help.

[odoublewen]

Neat! Thank you. Putting the business logic of the command under the model_post_init method reads a little funny at first, but I will get used to it.

The ability to organize the args in a BaseModel class, and inherit that for related commands, is really nice. I appreciate you sharing this!!

[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]