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

Is this what you need?

from pydantic import BaseModel, model_serializer

class A(BaseModel):
    a: str | None
    b: str | None

    @model_serializer(mode="wrap")
    def _serialize(self, handler):
        d = handler(self)
        d['a'] = self.a
        return d


a1 = A(a=None, b=None)

a2 = A(a="strrrr", b=None)


print(a1.model_dump(exclude_none=True))

print(a2.model_dump(exclude_none=True))

Output:

{'a': None}
{'a': 'strrrr'}

Or you can modify it to have the list of mandatory fields as a parameter of model:

from pydantic import BaseModel, model_serializer

class A(BaseModel):
    a: str | None
    b: str | None
    c: int | None

    _always_serialize_fields: list["str"] = ["a", "c"]

    @model_serializer(mode="wrap")
    def _serialize(self, handler):
        d = handler(self)
        for f in self._always_serialize_fields:
            d[f] = getattr(self, f)
        return d


a1 = A(a=None, b = None, c=None)

a2 = A(a="strrrr", b=None, c=None)


print(a1.model_dump(exclude_none=True))

print(a2.model_dump(exclude_none=True))

Output:

{'a': None, 'c': None}
{'a': 'strrrr', 'c': None}

According to the documentation on computed_field:

computed_field

Decorator to include property and cached_property when serializing models or dataclasses.

This is useful for fields that are computed from other fields, or for fields that are expensive to compute and should be cached.

In other words, if don't want to include (= exclude) a field we shouldn't use computed_field decorator:

from __future__ import annotations
import pydantic
from pprint import pprint

class System(pydantic.BaseModel):
    id: int
    name: str
    subsystems: list[System] | None = None

    # comment or remove it
    # @pydantic.computed_field()
    @property
    def computed(self) -> str:
        return self.name.upper()


systems = System(
    id=1,
    name="Main system",
    subsystems=[
        System(id=2, name="Subsystem A"),
        System(id=3, name="Subsystem B"),
    ],
)
pprint(systems.model_dump(), indent=2)
print(systems.computed)  # but it is still there

Output is:

{ 'id': 1,
  'name': 'Main system',
  'subsystems': [ {'id': 2, 'name': 'Subsystem A', 'subsystems': None},
                  {'id': 3, 'name': 'Subsystem B', 'subsystems': None}]}
MAIN SYSTEM

You can create your MyBaseModel class from BaseModel, where you can add model serializer (with mode="wrap").

In this model serializer just exclude from result dict all fields which are not present in the self.model_fields.

Now inherit all your models from MyBaseModel and enjoy!

from typing import Any
from pydantic import BaseModel, ConfigDict, model_serializer, SerializerFunctionWrapHandler, FieldSerializationInfo


class MyBaseModel(BaseModel):
    @model_serializer(mode="wrap")
    def _serialize(self, handler):
        d = handler(self)
        d = {k:v for k, v in d.items() if k in self.model_fields}
        return d


class Nested(MyBaseModel):

    model_config = ConfigDict(extra="allow")

    baz: str


class Root(MyBaseModel):

    foo: int = 10
    bar: int
    nested: Nested


if __name__ == "__main__":

    model = Root(foo=10, bar=20, nested={"baz": "boing", "extra": "so special"})

    dumped_data = model.model_dump()

    assert "extra" not in dumped_data["nested"]