from dataclasses import dataclass
from typing import Tuple

@dataclass
class Waffle:
    style: str
    toppings: Tuple[str, ...]

>>> Waffle("Swedish", ("chocolate sauce", "ham"))
Waffle(style='Swedish', 
       toppings=('chocolate sauce', 'ham'))

from typing import Union
from enum import Enum

class Cream(str, Enum):
    whipped_cream = "whipped cream"
    ice_cream = "icecream"

class DessertSauce(str, Enum):
    cloudberry_jam = "cloudberry jam"
    raspberry_jam = "raspberry jam"
    choclate_sauce = "chocolate sauce"

Topping = Union[DessertSauce, Cream]

class WaffleStyle(str, Enum):
    swedish = "Swedish"
    belgian = "Belgian"


@dataclass
class Waffle:
    style: WaffleStyle
    toppings: Tuple[Topping, ...]

>>> Waffle("Swedish", ("chocolate sauce", "ham"))
Waffle(style='Swedish',
       toppings=('chocolate sauce', 'ham'))

from pydantic.dataclasses import dataclass
    
@dataclass
class Waffle:
    style: WaffleStyle
    toppings: Tuple[Topping, ...]

from pydantic import ValidationError
try:
    Waffle("Swedish", ("chocolate sauce", "ham"))
except ValidationError as err:
    print(err)

2 validation errors for Waffle

toppings -> 1
  value is not a valid enumeration member; permitted: 'cloudberry jam', 'raspberry jam', 'chocolate sauce' (type=type_error.enum; enum_values=[<DessertSauce.cloudberry_jam: 'cloudberry jam'>, <DessertSauce.raspberry_jam: 'raspberry jam'>, <DessertSauce.choclate_sauce: 'chocolate sauce'>])

toppings -> 1
  value is not a valid enumeration member; permitted: 'whipped cream', 'icecream' (type=type_error.enum; enum_values=[<Cream.whipped_cream: 'whipped cream'>, <Cream.ice_cream: 'icecream'>])

Waffle(
  "Swedish", 
  (Cream.whipped_cream, "cloudberry jam")
)

Waffle(
  style=<WaffleStyle.swedish: 'Swedish'>, 
  toppings=(
    <Cream.whipped_cream: 'whipped cream'>,
    <DessertSauce.cloudberry_jam: 'cloudberry jam'>
  )
)

from pydantic import BaseModel


class Waffle(BaseModel):
    style: WaffleStyle
    toppings: Tuple[Topping, ...]

Waffle(
  style="Swedish", 
  toppings=(Cream.whipped_cream, "cloudberry jam")
)

Waffle(
  style=<WaffleStyle.swedish: 'Swedish'>, 
  toppings=(
    <Cream.whipped_cream: 'whipped cream'>,
    <DessertSauce.cloudberry_jam: 'cloudberry jam'>
  )
)

>>> _.json()
'{"style": "Swedish", "toppings": ["whipped cream", "cloudberry jam"]}'

>>> Waffle.parse_raw('{"style": "Swedish", "toppings": ["whipped cream", "cloudberry jam"]}')

Waffle(
  style=<WaffleStyle.swedish: 'Swedish'>, 
  toppings=(
    <Cream.whipped_cream: 'whipped cream'>,
    <DessertSauce.cloudberry_jam: 'cloudberry jam'>
  )
)

try:
    Waffle(
      style=42, 
      toppings=(
        Cream.whipped_cream, "cloudberry jam"
      )
    )
except ValidationError as err:
    print(err.json())

[
  {
    "loc": [
      "style"
    ],
    "msg": "value is not a valid enumeration member; permitted: 'Swedish', 'Belgian'",
    "type": "type_error.enum",
    "ctx": {
      "enum_values": [
        "Swedish",
        "Belgian"
      ]
    }
  }
]

>>> Waffle.schema()
{'title': 'Waffle',
 'type': 'object',
 'properties': {'style': {'$ref': '#/definitions/WaffleStyle'},
  'toppings': {'title': 'Toppings',
   'type': 'array',
   'items': {'anyOf': [{'$ref': '#/definitions/DessertSauce'},
     {'$ref': '#/definitions/Cream'}]}}},
 'required': ['style', 'toppings'],
 'definitions': {'WaffleStyle': {'title': 'WaffleStyle',
   'description': 'An enumeration.',
   'enum': ['Swedish', 'Belgian'],
   'type': 'string'},
  'DessertSauce': {'title': 'DessertSauce',
   'description': 'An enumeration.',
   'enum': ['cloudberry jam', 'raspberry jam', 'chocolate sauce'],
   'type': 'string'},
  'Cream': {'title': 'Cream',
   'description': 'An enumeration.',
   'enum': ['whipped cream', 'icecream'],
   'type': 'string'}}}

from pydantic import validator, root_validator
swedish_toppings = (
    DessertSauce.raspberry_jam, DessertSauce.cloudberry_jam,
)
belgian_toppings = (DessertSauce.choclate_sauce,)

class WaffleOrder(Waffle):

  # Root validators check the entire model
  @root_validator(pre=False)
  def check_style_topping(cls, values):
    style, toppings = values.get("style"), values.get("toppings")
    # Check swedish style
    if (style == WaffleStyle.swedish and 
      all(t in swedish_toppings for t in toppings if type(t) is DessertSauce)
    ): return values
      
    # Check belgian style
    if (style == WaffleStyle.belgian and 
      all(t in belgian_toppings for t in toppings if type(t) is DessertSauce)
    ): return values
    
    # Doesn't match any of our allowed styles
    raise ValueError(f"The Waffle Bistro doesn't sell this waffle.")
    
        
  # A validator looking at a single property
  @validator('toppings')
  def check_cream(cls, toppings):
    creams = [t for t in toppings if type(t) is Cream]
    if len(creams) > 1:
      raise ValueError(f"One cream allowed, given: {creams}")
    return toppings

try: 
  WaffleOrder(
    style="Swedish",
    toppings=["icecream", "whipped cream", "cloudberry jam"]
  )
except ValidationError as err:
  print(err)

2 validation errors for WaffleOrder
toppings
  We only allow for one cream topping, given: [<Cream.ice_cream: 'icecream'>, <Cream.whipped_cream: 'whipped cream'>] (type=value_error)
__root__
  'NoneType' object is not iterable (type=type_error)

try: 
  WaffleOrder(
   style="Swedish", 
   toppings=["icecream", "cloudberry jam", "chocolate sauce"]
  )
except ValidationError as err:
  print(err)

1 validation error for WaffleOrder
__root__
  The Waffle Bistro doesn't sell this waffle. (type=value_error)

from pydantic import validate_arguments

# Validator on function
# Ensure valid waffles when making orders
@validate_arguments
def make_order(waffle: WaffleOrder):
    ...

try:
    make_order({
        "style":"Breakfast",
        "toppings":("whipped cream", "raspberry jam")
    })
except ValidationError as err:
    print(err)

2 validation errors for MakeOrder
waffle -> style
  value is not a valid enumeration member; permitted: 
  'Swedish', 'Belgian'
  (type=type_error.enum; enum_values=[
  	<WaffleStyle.swedish: 'Swedish'>, 
  	<WaffleStyle.belgian: 'Belgian'>])

waffle -> __root__
  The Waffle Bistro doesn't sell this waffle.
  (type=value_error)

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

def make_order(waffle: WaffleOrder):
    # Business logic for making an order
    pass

def dispatch_order(waffle: WaffleOrder):
    # Hand over waffle to customer
    pass

# Deliver a waffle
@app.post("/delivery/waffle")
async def deliver_waffle_order(waffle: WaffleOrder):
    dispatch = dispatch_order(waffle)
    return dispatch

@app.post("/order/waffle")
async def order_waffle(waffle: WaffleOrder):
    order = make_order(waffle)
    return order