Is there a way to have a single field be static and immutable with pydantic

[bb-rrogers]

What I currently have is a class like so:

class Test(BaseModel):
   id: str = None
   name: str = None
   system_url: str

What I am trying to do is have it so that system_url is a static value that cannot be changed and shouldn't be a value that is accepted as being passed in.

I have tried to create a subclass also, however it still changes the variable if it's passed in on new instance creation.

I have thought of using a validator that will ignore the value and instead set the system property that I plan on using. However am looking for other ways that may support this. I have tried to search if this has come up before but constantly run into the JSONSchema.const field type that I feel doesn't match with what I am trying to achieve.

Your help here is greatly appreciated!

[wozniakty]

You can do this with Field using const=True

From the docs you can see:

const: this argument must be the same as the field's default value if present.

SYSTEM_URL = 'abcde'

class Test(BaseModel):
   id: str = None
   name: str = None
   system_url: str = Field(SYSTEM_URL, const=True)

Then:

In [5]: Test(id='a', name='b', system_url='c')
ValidationError: 1 validation error for Test
system_url
  unexpected value; permitted: 'abcde' (type=value_error.const; given=c; permitted=['abcde'])

In [6]: Test(id='a', name='b')
Out[6]: Test(id='a', name='b', system_url='abcde')

In [7]: Test(id='a', name='b', system_url='abcde')
Out[7]: Test(id='a', name='b', system_url='abcde')

[skewty]

If I understand your question properly, you want a static field that is validated just like an instance field.

I don't believe this is possible at this time but it is certainly possible given the way fields are currently implemented.
It would be just a boolean check so it wouldn't be much of a performance hit. Perhaps if this is important you, you could write the code and do a MergeRequest / PullRequest.

If you just want a static field that is not validated use typing.ClassVar. Example:

from typing import ClassVar
from pydantic import BaseModel

class FooModel(BaseModel):
    name: ClassVar[str] = 'John'
    age: int

if ClassVar is too much of a pain, you can use "magic" naming. Pydantic ignores them too.

from typing import ClassVar
from pydantic import BaseModel

class FooModel(BaseModel):
    __name__ = 'John'
    age: int

const argument (if I am understanding the feature correctly) makes that field assignable once only. Assign once then it becomes immutable.

[wozniakty]

@skewty I think you're thinking of the immutable meta config, which does indeed prevent mutation (unless you try hard enough).

Const forces all values provided to be set to the default value, per the docs :)

[samuelcolvin]

Thanks for using pydantic. 🙏

As part of a migration to using discussions and cleanup old issues, I'm closing all open issues with the "question" label. 💭 🆘 🚁

I hope you've now found an answer to your question. If you haven't, feel free to start a 👉 question discussion.

[fiendish]

If you just want a static field that is not validated use typing.ClassVar.

This method doesn't automatically work for serialization because .__dict__ won't include it. So you can't then emit the contents of your class including your static value over the wire as json the way you normally would.

[Alexander-Serov]

It seems like the const= flag is no more. I have searched but haven't found what it was replaced with. could anyone point me to how one does it in pydantic 2.0?

[tteguayco]

Same question as @Alexander-Serov here.

[LyleScott]

Use Literal instead. I dig it since it uses a Python native type instead of a library function! Using the example above...

from typing import Literal


SYSTEM_URL = 'abcde'

class Test(BaseModel):
   id: str = None
   name: str = None
   system_url: Literal[SYSTEM_URL]

also, id and name would be Optional[str] since it can also be None here.

[selmison]

Good solution, but it just works with literal types (int, bool, str, or bytes). For mutable types, My solution was computed_field:

@computed_field()
@property
def names(self):
    return ['abc', 'def']

Use Literal instead. I dig it since it uses a Python native type instead of a library function! Using the example above...

from typing import Literal

SYSTEM_URL = 'abcde'

class Test(BaseModel):
id: str = None
name: str = None
system_url: Literal[SYSTEM_URL]
also, id and name would be Optional[str] since it can also be None here.