Required Optional fields

Question

Currently, adding an Optional field just removes the field from the generated required fields list in the schema/JSON schema. Is there a mechanism for having it instead generate an anyOf field requirement and requiring a field with a null value?

Please complete:

• OS: Mac OS X
• Python version import sys; print(sys.version): 3.7.4 (default, Oct 12 2019, 18:55:28)
• Pydantic version import pydantic; print(pydantic.VERSION): 1.1

I couldn’t find info on this in the help manual, though the general documentation for Union (link) doesn’t specifically call out that it behaves differently with None.

from typing import Optional
import pydantic

class Metadata(pydantic.BaseModel):
    nullable_field = Optional[str]

Would love a way to generate {"anyOf": [{"type": "string"}, {"type": null}]}, though I realize that passing {} and {"nullable_field": None} will generate equivalent Pydantic models.

Thanks for the help and the library!

[yurikhan]

I’m the kind of guy who is known to rant about optionals, nulls, zeros, empty strings, empty arrays and empty objects and how all of them are distinct cases. Would really like if all of the cases here and in various linked issues could be easily expressed in a Pydantic model and mapped to JSON Schema equivalents. I’ll try to summarize the current ways and workarounds to do it:

• A field is required and cannot be null. — Works out of the box

  class Foo(BaseModel):
      foo: int
  
  Foo()
  # ValidationError: field required
  Foo(foo=42)
  # Foo(foo=42)
  Foo(foo=None)
  # ValidationError: none is not an allowed value
  Foo.schema()
  # {'properties': {'foo': {'title': 'Foo', 'type': 'integer'}},
  #  'required': ['foo'],
  #  'title': 'Foo',
  #  'type': 'object'}
  

• A field is required and can be null. — Requires a schema patch

  class Foo(BaseModel):
      foo: Optional[int] = ...
  
      class Config:
          def schema_extra(schema, model):
              schema['properties']['foo'].update({'type': ['null', 'integer']})
  
  Foo()
  # ValidationError: field required
  Foo(foo=42)
  # Foo(foo=42)
  Foo(foo=None)
  # Foo(foo=None)
  Foo.schema()
  # {'properties': {'foo': {'title': 'Foo', 'type': ['null', 'integer']}},
  #  'required': ['foo'],
  #  'title': 'Foo',
  #  'type': 'object'}
  

• A field is optional but if present cannot be null. — Requires a validator

  class Foo(BaseModel):
      foo: Optional[int]
  
      @validator('foo')
      def not_null(cls, v):
          if v is None:
              raise ValueError
          return v
  
  Foo()
  # Foo(foo=None)
  Foo(foo=42)
  # Foo(foo=42)
  Foo(foo=None)
  # ValidationError: type_error
  Foo.schema()
  # {'properties': {'foo': {'title': 'Foo', 'type': 'integer'}},
  #  'title': 'Foo',
  #  'type': 'object'}
  

• A field is optional and may be null. — Requires a schema patch

  class Foo(BaseModel):
      foo: Optional[int]
  
      class Config:
          def schema_extra(schema, model):
              schema['properties']['foo'].update({'type': ['null', 'integer']})
  
  Foo()
  # Foo(foo=None)
  Foo(foo=42)
  # Foo(foo=42)
  Foo(foo=None)
  # Foo(foo=None)
  Foo.schema()
  # {'properties': {'foo': {'title': 'Foo', 'type': ['null', 'integer']}},
  #  'title': 'Foo',
  #  'type': 'object'}
  

Is that right, are those the easiest workarounds, and does the above cover all interesting cases?

(Cue OpenAPI users bickering that arrays in type will only be supported in 3.1+ while 3.0 uses a private extension "nullable": true.)

[spacether]

How about changing the issue name to required nullable fields