@adriangb,

I think it's doable, just not super high priority at the moment.

@adriangb @sydney-runkle I know this is probably a pretty minor feature. It's good to know that it might happen someday, so I can just look forward to it. For now I'll work around it the best I can. Thank you both for your time!

Would be amazing to have the PydanticOmit working @adriangb @sydney-runkle

Hey folks! This should help: pydantic/pydantic-core#1535

Thank you so much! I look forward to trying it out when it's released 😃

For my use case, I need to be able to evaluate this on every field. I suppose I could add the option to every field of the model. And then if a field already had a exclude_if configured on it, I could call their function first and check its return result to see if it's already being excluded before running my own logic.

I did something similar, though I also needed exclusions based on some more complex criteria. I made an ExcludeIf annotation that lets you pass in a predicate (like ExludeIf(lambda v: v < 5) (it also supports a when_used argument that works like Pydantic's), then a few subclasses of it where the predicates are predefined on the class (ExcludeIfNone(), ExcludeIfFalsy(), ExcludeIfEqual("a_value"), ExcludeIfIn(["some", "list"])).

This approach works for the serialization, but has the unfortunate side effect that the schema the the returned type is empty now.

I've been experimenting with something like this as well. But there is a bit of a complication when you have multiple model serializers involved.

I wanted to create a very basic, library-style class model that would have this behavior generalized across all sorts of different kinds of models. This means some of these subclasses might want to further customize their model serialization behavior.

But if you set a model serializer on a subclass, the parent serializer does not get called automatically. You can call it via super().{parent-serializer-method-name}(...) but you have to ensure you configure your subclass model serializer the same way, and pass the same arguments and so on (like the 'wrap' argument for wrap mode). If the model changes how it wants to serialize things, the subclasses all have to be changed.

It would be nice if when calling the default serialization via mode='wrap' that it would call the superclasses model serializer for you, and then the subclass does not have to worry about how/if it should call the super classes serializer. The doc says it serializes it the same way it normally would when using 'wrap' mode, but it does skip the superclasses model serializer function unfortunately.

Thanks for this, it worked for me though I had to tweak it to take into account Field aliases and to run PlainSerializer(s):

from dataclasses import dataclass

from pydantic import BaseModel, PlainSerializer, model_serializer

@dataclass
class OmitIfNone:
    pass

class AppResponseModel(BaseModel):
    @model_serializer
    def _serialize(self):
        skip_if_none = set()
        serialize_aliases = dict()

        # Gather fields that should omit if None
        for name, field_info in self.model_fields.items():
            if any(
                isinstance(metadata, OmitIfNone) for metadata in field_info.metadata
            ):
                skip_if_none.add(name)
            elif field_info.serialization_alias:
                serialize_aliases[name] = field_info.serialization_alias

        serialized = dict()

        for name, value in self:
            # Skip serializing None if it was marked with "OmitIfNone"
            if value is None and name in skip_if_none:
                continue
            serialize_key = serialize_aliases.get(name, name)

            # Run Annotated PlainSerializer
            for metadata in self.model_fields[name].metadata:
                if isinstance(metadata, PlainSerializer):
                    value = metadata.func(value)

            serialized[serialize_key] = value

        return serialized