After looking through the source code, I don't see any way that this would be easily possible with the specialized kwarg supplied. The dict function is recursive and doesn't support arbitrary arguments.

Now, I was able to hack something together but... it is awful. This was performed using pydantic==1.10.7.

I was thinking we could apply a special flag value in the exclude arguments to provide something to trigger the exclusion logic off of. This became trickier than I expected, because it requires knowing the full structure of the object and exactly how to index the excluded fields. There is also some odd normalization happening on lists, which is causing the value provided to be mutated as it makes its way down the function call.

This is the best I could get (WARNING not tested thoroughly). We create a dictionary that returns itself on every lookup, that exposed __all__ as an exclude field. This will allow our key to be passed to each and every model, and be passed on to child objects to evaluate as well.

EXCLUDED_SPECIAL_FIELDS = "exclude_special_fields"

class _ExclusionDict(dict):
    def __init__(self):
        super().__init__({"__all__": {EXCLUDED_SPECIAL_FIELDS: True}})

    def get(self, key):
        return self


ExcludeSpecial = _ExclusionDict()


class SpecialExclusionBaseModel(BaseModel):
    _special_exclusions: set[str]

    def dict(self, **kwargs):
        exclusions = getattr(self.__class__, "_special_exclusions", None)
        exclude = kwargs.get("exclude")
        if exclusions and exclude and EXCLUDED_SPECIAL_FIELDS in exclude:
            return {
                k: v
                for k, v in super().dict(**kwargs).items()
                if k not in exclusions
            }
        return super().dict(**kwargs)

With this base class, we can provide a class field called _special_exclusions to indicate which fields we want excluded when the ExcludeSpecial instance is provided as the exclude kw argument.

On some initial testing, this seems to work with nested hierarchies including dicts and lists. There are probably bugs here that need to be worked out, but hopefully this is a good jumping off point for others.

class MyModel(SpecialExclusionBaseModel):
    _special_exclusions = {"field"}
    field: str

class AnotherModel(BaseModel):
    models: list[MyModel]

class AnotherAnotherModel(BaseModel):
    models: dict[str, AnotherModel]


model = MyModel(field=1)
another = AnotherAnotherModel(models={"test": AnotherModel(models=[model])})
print(another.dict(exclude=ExcludeSpecial))

{'models': {'test': {'models': [{}]}}}

Hi @SDAravind,
the following should do the trick:

bar.model_dump(include={"c": True, "d": {"b"}, "e": {"__all__": {"a"}}})

Quoting the docs

Special care must be taken when including or excluding fields from a list or tuple of submodels or dictionaries. In this scenario, model_dump and related methods expect integer keys for element-wise inclusion or exclusion. To exclude (ed. or include) a field from every member of a list or tuple, the dictionary key '__all__' can be used, as shown here

Pydantic will exclude the class variables which begin with an underscore. so if it fits your use case, you can rename your attribues.

class User(UserBase):
    _user_id=str
    some_other_field=str
    ....

Create a pydantic model with only those fields and return it

bro you didn't even put exclude_none anywhere in the code; if you actually do exclude_none=True, your code would work recursively:

dumped = outer.model_dump_json(exclude_none=True)
print(dumped)
# {"inner":{"required_field":"test"}}

You could exclude only optional model fields that unset by making of union of model fields that are set and those that are not None.

Pydantic provides the following arguments for exporting method model.dict(...):

exclude_unset: whether fields which were not explicitly set when creating the model should be excluded from the returned dictionary; default False.

exclude_none: whether fields which are equal to None should be excluded from the returned dictionary; default False

To make union of two dicts we can use the expression a = {**b, **c} (values from c overwrites values from b). Note that since Python 3.9 it could be done just as a = b | c.

from pydantic import BaseModel
from typing import Optional
from pydantic.json import pydantic_encoder
import json


class Foo(BaseModel):
    x: int
    y: int = 42
    z: Optional[int]

def exclude_optional_dict(model: BaseModel):
    return {**model.dict(exclude_unset=True), **model.dict(exclude_none=True)}

def exclude_optional_json(model: BaseModel):
    return json.dumps(exclude_optional_dict(model), default=pydantic_encoder)
    


print(exclude_optional_json(Foo(x=3)))  # {"x": 3, "y": 42}
print(exclude_optional_json(Foo(x=3, z=None)))  # {"x": 3, "z": null, "y": 42}
print(exclude_optional_json(Foo(x=3, z=77)))  # {"x": 3, "z": 77, "y": 42}

Update

In order for the approach to work with nested models, we need to do a deep union( or merge) of two dictionaries, like so:

def union(source, destination):
    for key, value in source.items():
        if isinstance(value, dict):
            node = destination.setdefault(key, {})
            union(value, node)
        else:
            destination[key] = value

    return destination

def exclude_optional_dict(model: BaseModel):
    return union(model.dict(exclude_unset=True), model.dict(exclude_none=True))

class Foo(BaseModel):
    x: int
    y: int = 42
    z: Optional[int]

class Bar(BaseModel):
    a: int
    b: int = 52
    c: Optional[int]
    d: Foo


print(exclude_optional_json(Bar(a=4, d=Foo(x=3))))
print(exclude_optional_json(Bar(a=4, c=None, d=Foo(x=3, z=None))))
print(exclude_optional_json(Bar(a=4, c=78, d=Foo(x=3, z=77))))

{"a": 4, "b": 52, "d": {"x": 3, "y": 42}}
{"a": 4, "b": 52, "d": {"x": 3, "y": 42, "z": null}, "c": null}
{"a": 4, "b": 52, "c": 78, "d": {"x": 3, "y": 42, "z": 77}}