Class variables?

[dsully]

Is it possible to have class variables that are not part of the schema that is parsed by pydantic?

ie:

class MyModel(BaseModel):

     # This is part of pydantic
     group: str = None

     # This is not.
     ACTIONS = ['a', 'b', 'c']```

[samuelcolvin]

https://github.com/samuelcolvin/pydantic/blob/0698384788e78b3353877bc44340a00089ea1d3f/pydantic/main.py#L121

Start the name with _ or use a function with the @property decorator.

[dsully]

Thanks. Would you accept a PR that also ignored all uppercase class variable names?

I didn't see this in the documentation, perhaps I missed it?

[samuelcolvin]

Probably not excluding all uppercase variables, but I would accept a PR which either:

• exclude_uppercase: bool which when True caused uppercase variables to be excluded from validation
• exclude_vars: Set[str] where you could provide a bunch of variables names which you wished to exclude

[jaheba]

Being able to define attributes which are not being part of the schema being part is also something I'm looking for.

However, I have the suspicion that doing so based on the case of the variable name could be too inflexible. Thus, I would prefer the exclude_vars approach much more.

But how about we add a new type, which marks variables as internal?

class MyModel(BaseModel):
     # This is part of pydantic
     group: str = None

     # This is not.
     ACTIONS: Internal[List[str] = ['a', 'b', 'c']```

[samuelcolvin]

Internal makes a lot of sense to me.

I guess it might upset mypy, but that doesn't both me much.

[jaheba]

I think I've found a way to trick mypy. We can abuse a Union, where one case is an internal field. That way, we can check whether that var is internal and still have the mypy guarantees.

class _internal:
    pass

T = TypeVar('T')

Internal = Union[_internal, T]

# accepted by mypy
x: Internal[int] = 42

[samuelcolvin]

Makes sense to me, I neither know nor care whether it's an abuse of typing.

[samuelcolvin]

Humm, maybe we need to think harder about using types to indicate things that don't relate to type. Could be very confusing.

[jaheba]

Humm, maybe we need to think harder about using types to indicate things that don't relate to type. Could be very confusing.

I agree.

I think what we are looking for is a way to annotate settings for each field. The problem is that we are limited in ways to do so:

a) variable name (e.g. variables starting with an `_` are currently ignored)
b) type annotation
c) default value the field is set to
d) using external annotations, such as the `Config` class

In Rust for example, one can also annotate things using the #[...] syntax. But we don't have that option in Python.

Out of the ones listed, I would currently prefer c) :

class MyModel(BaseModel):
    x: int = Internal(42)

What I am currently worried about, if there are other annotations we would like to add which would make this approach unfeasable. Maybe something like this would be better than:

class MyModel(BaseModel):
    x: int = Field(42, internal=True, allow_mutation=False)

[samuelcolvin]

That's already work going on. See #190, #129.

Problem is that internal, as it works now couldn't be used with anything else, eg. allow_mutaion=False. Because the variables are just ignored by pydantic.

Also, internal is a confusing name as it indicates they can only be used inside the class. Maybe it should be called "ignored". And I'd rather just keep it in config for cleanness.

[jaheba]

That's already work going on. See #190, #129.

Oh, that looks nice. I think that would probably be the right place to add the feature then.

Also, internal is a confusing name as it indicates they can only be used inside the class. Maybe it should be called "ignored". And I'd rather just keep it in config for cleanness.

Agreed internal is just what first came to mind. Although I'm not sure if ignored is unambigious either. But I guess that's a discussion for another time.

[koliyo]

First of all, I would also like this feature.

As a workaround I am trying to use the _foo declaration syntax. But with this I am not allowed to explicitly set the value of the object.

o = Foo(**data)
o._bar = 3

Then I get

ValueError: "Foo" object has no field "_bar"

I just want to exclude it from the external data parameterization.