Type Support for argparse.Namespace()

[jude253]

Hello,

I hope you are well. I really like Pydantic, and I've found it makes it much easier and also neater to work with classes in python.

Today, I tried to use it to put the arguments parsed from the command line with argparse as an attribute in class to use composition. The exact type name is argparse.Namespace. Because this wasn't able to work, I just converted the arguments to a default dictionary type and used that with pedantic.

This works, but I think it would be much nicer to have the argparse type be able to work work pydantic classes by default, this way I can use the built-in functionality of that, rather than just using dictionary keys to get the arguments.

Would it be possible to add this?

Thanks!

[sydney-runkle]

Reasonable request for pydantic-extra-types!

[Viicos]

I'm not sure I can see how argparse namespaces can be validated: they are just (dynamic) container classes:

class Namespace(_AttributeHolder):
    """Simple object for storing attributes.

    Implements equality by attribute names and values, and provides a simple
    string representation.
    """

    def __init__(self, **kwargs):
        for name in kwargs:
            setattr(self, name, kwargs[name])

Do you have an example of how validation would work?

[jude253]

I'm not sure I can see how argparse namespaces can be validated: they are just (dynamic) container classes:

class Namespace(_AttributeHolder):
    """Simple object for storing attributes.

    Implements equality by attribute names and values, and provides a simple
    string representation.
    """

    def __init__(self, **kwargs):
        for name in kwargs:
            setattr(self, name, kwargs[name])

Do you have an example of how validation would work?

Hi @Viicos, you bring up a good point. I am not very familiar with the internals of pydantic and also the namespace class. I tried to add argparse.Namespace as a type in a pydantic class that inherits from BaseModel, but I got an error message that it couldn't be validated. I found this a little surprising because it's a built in type.

I believe the error message said to try to add a validation of that type to pydantic, but I don't know how to do that. I thought I would raise a ticket instead.

I can maybe look more into this, but it's not my area of expertise.

I do find it interesting though that if you put the dictionary version of the argparse.Namespace, it is able to work fine with pydantic. My understanding is that argparse.Namespace is essentially like dictionary with a few other special features such as being able to call the keys as if they are attributes and I think the .get() doesn't work.

I was thinking having support for cli arguments built into pydantic would be really nice to make making cli applications easier. Especially, making it easier to configure cli input types and commands using like types rather than specifying a lot of strings in dictionaries and stuff.

Do you have an example of how validation would work?

I can try to put together an example for validation as you asked. Do you have a good resource on how to do this though? I am not sure I fully understand what should go into like default validation.

[RedZapdos123]

I reproduced the current behavior. The failure happens because argparse.Namespace does not provide a Pydantic schema hook, so Pydantic treats it as an unknown type.

Minimal reproducible example:

import argparse
from pydantic import BaseModel

print("Reproduction: field typed as argparse.Namespace")

class BrokenModel(BaseModel):
    args: argparse.Namespace

BrokenModel(args=argparse.Namespace(debug=True))

This raises a schema generation error for argparse.Namespace.

argparse.Namespace is a dynamic container, so by itself it does not define a fixed schema (no fixed fields, no fixed types).
So, in this context, 'validation' should mean:

1. Validate input shape (Namespace or dict[str, Any]).
2. Normalize input into one consistent namespace type.
3. Return clear validation errors for unsupported input.
4. Serialize predictably to JSON.
5. Reject dictionaries with non-string keys.

A practical minimal implementation:

import argparse
from copy import deepcopy
from typing import Any

from pydantic import BaseModel
from pydantic_core import PydanticCustomError, core_schema


class ArgparseNamespace(argparse.Namespace):
    @classmethod
    def __get_pydantic_core_schema__(cls, *_):
        dict_schema = core_schema.dict_schema(
            keys_schema=core_schema.str_schema(strict=True),
            values_schema=core_schema.any_schema(),
        )
        return core_schema.json_or_python_schema(
            json_schema=core_schema.chain_schema(
                [dict_schema, core_schema.no_info_plain_validator_function(cls.validate)]
            ),
            python_schema=core_schema.no_info_plain_validator_function(cls.validate),
            serialization=core_schema.plain_serializer_function_ser_schema(
                lambda value: vars(value),
                when_used="json-unless-none",
            ),
        )

    @classmethod
    def validate(cls, value: argparse.Namespace | dict[str, Any]) -> "ArgparseNamespace":
        if isinstance(value, argparse.Namespace):
            return cls(**deepcopy(vars(value)))

        if isinstance(value, dict):
            if not all(isinstance(k, str) for k in value):
                raise PydanticCustomError(
                    "argparse_namespace_key_type",
                    "Input dictionary keys must be strings",
                )
            return cls(**deepcopy(value))

        raise PydanticCustomError(
            "argparse_namespace_type",
            "Input should be a dictionary or an argparse.Namespace instance",
        )


class Model(BaseModel):
    args: ArgparseNamespace


ok_namespace = Model(args=argparse.Namespace(debug=True, retries=3))
ok_dict = Model(args={"debug": False, "retries": 5})
# Model(args=123) -> validation error
# Model(args={1: "x"}) -> validation error

If strict argument level validation is needed, the correct pattern is to validate vars(namespace) with a typed model:

import argparse
from pydantic import BaseModel

class CliArgsSchema(BaseModel):
    debug: bool
    retries: int

ns = argparse.Namespace(debug=True, retries="3")

validated = CliArgsSchema.model_validate(vars(ns))
print(validated)
# debug=True retries=3

So, there can be two levels:

1. Container-level validation (ArgparseNamespace): accepts and normalizes namespace-like input.
2. Field-level validation (typed BaseModel over vars(ns)): enforces exact argument types and constraints.

I feel this approach is correct for current issue: #200 as it resolves the schema generation failure while still allowing stricter validation whenever users need it.