+001: # cython: language_level=3, embedsignature=True, initializedcheck=False

  __pyx_t_6 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_6) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 002: # Copyright (C) 2018-present Jesus Lara

 003: #

+004: from typing import get_args, get_origin, Union, Optional, Literal

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_get_args,__pyx_mstate_global->__pyx_n_u_get_origin,__pyx_mstate_global->__pyx_n_u_Union,__pyx_mstate_global->__pyx_n_u_Optional,__pyx_mstate_global->__pyx_n_u_Literal};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_typing, __pyx_imported_names, 5, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_get_args,__pyx_mstate_global->__pyx_n_u_get_origin,__pyx_mstate_global->__pyx_n_u_Union,__pyx_mstate_global->__pyx_n_u_Optional,__pyx_mstate_global->__pyx_n_u_Literal};
    for (__pyx_t_3=0; __pyx_t_3 < 5; __pyx_t_3++) {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 4, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+005: from collections.abc import Callable, Awaitable

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Callable,__pyx_mstate_global->__pyx_n_u_Awaitable};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_collections_abc, __pyx_imported_names, 2, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Callable,__pyx_mstate_global->__pyx_n_u_Awaitable};
    for (__pyx_t_3=0; __pyx_t_3 < 2; __pyx_t_3++) {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 5, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+006: import typing

  __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_typing, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_typing, __pyx_t_2) < (0)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+007: from types import UnionType

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_UnionType};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_types, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_UnionType};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 7, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 7, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+008: import asyncio

  __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_asyncio, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error)
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_asyncio, __pyx_t_2) < (0)) __PYX_ERR(0, 8, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+009: import inspect

  __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_inspect, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_inspect, __pyx_t_2) < (0)) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 010: from cpython.object cimport PyObject_IsInstance, PyObject_IsSubclass

 011: from cpython.type cimport PyType_Check

+012: from enum import Enum

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Enum};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_enum, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Enum};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 12, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+013: from decimal import Decimal

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Decimal};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_decimal, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Decimal};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 13, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 13, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+014: import datetime

  __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_datetime, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error)
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_datetime, __pyx_t_2) < (0)) __PYX_ERR(0, 14, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+015: from uuid import UUID

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_UUID};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_uuid, __pyx_imported_names, 1, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_UUID};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 15, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+016: import asyncpg.pgproto.pgproto as pgproto

  __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_asyncpg_pgproto_pgproto, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error)
  __pyx_t_5 = __Pyx_ImportFrom(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_pgproto);
  Py_DECREF(__pyx_t_1);
  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 16, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_5;
  __pyx_t_5 = __Pyx_ImportFrom(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_pgproto);
  Py_DECREF(__pyx_t_1);
  if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 16, __pyx_L1_error)
  __pyx_t_1 = __pyx_t_5;
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pgproto, __pyx_t_2) < (0)) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+017: from .types import uint64_min, uint64_max, Text

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_uint64_min,__pyx_mstate_global->__pyx_n_u_uint64_max,__pyx_mstate_global->__pyx_n_u_Text};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_types, __pyx_imported_names, 3, __pyx_mstate_global->__pyx_kp_u_datamodel_types, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_uint64_min,__pyx_mstate_global->__pyx_n_u_uint64_max,__pyx_mstate_global->__pyx_n_u_Text};
    for (__pyx_t_3=0; __pyx_t_3 < 3; __pyx_t_3++) {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 17, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 17, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+018: from .fields import Field

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Field_2};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_fields, __pyx_imported_names, 1, __pyx_mstate_global->__pyx_kp_u_datamodel_fields, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_Field_2};
    __pyx_t_3 = 0; {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 18, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 18, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

+019: from .functions import (

  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_is_iterable,__pyx_mstate_global->__pyx_n_u_is_primitive,__pyx_mstate_global->__pyx_n_u_is_dataclass,__pyx_mstate_global->__pyx_n_u_is_function,__pyx_mstate_global->__pyx_n_u_is_callable,__pyx_mstate_global->__pyx_n_u_is_empty};
    __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_functions, __pyx_imported_names, 6, __pyx_mstate_global->__pyx_kp_u_datamodel_functions, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error)
  }
  __pyx_t_2 = __pyx_t_1;
  __Pyx_GOTREF(__pyx_t_2);
  {
    PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_is_iterable,__pyx_mstate_global->__pyx_n_u_is_primitive,__pyx_mstate_global->__pyx_n_u_is_dataclass,__pyx_mstate_global->__pyx_n_u_is_function,__pyx_mstate_global->__pyx_n_u_is_callable,__pyx_mstate_global->__pyx_n_u_is_empty};
    for (__pyx_t_3=0; __pyx_t_3 < 6; __pyx_t_3++) {
      __pyx_t_4 = __Pyx_ImportFrom(__pyx_t_2, __pyx_imported_names[__pyx_t_3]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 19, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_3], __pyx_t_4) < (0)) __PYX_ERR(0, 19, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    }
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 020:     is_iterable,

 021:     is_primitive,

 022:     is_dataclass,

 023:     is_function,

 024:     is_callable,

 025:     is_empty

 026: )

 027: 

 028: 

+029: cdef bint _is_union(object origin):

static int __pyx_f_9datamodel_10validation__is_union(PyObject *__pyx_v_origin) {
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("datamodel.validation._is_union", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;

  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+030:     return origin is Union or origin is UnionType

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Union); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = (__pyx_v_origin == __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!__pyx_t_3) {

  } else {

    __pyx_t_1 = __pyx_t_3;

    goto __pyx_L3_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_UnionType); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = (__pyx_v_origin == __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  __pyx_t_1 = __pyx_t_3;

  __pyx_L3_bool_binop_done:;
  {
    __pyx_r = __pyx_t_1;
  }
  goto __pyx_L0;

 031: 

+032: cdef str valid_int(object field, str name, object value, object _type):

static PyObject *__pyx_f_9datamodel_10validation_valid_int(CYTHON_UNUSED PyObject *__pyx_v_field, PyObject *__pyx_v_name, PyObject *__pyx_v_value, CYTHON_UNUSED PyObject *__pyx_v__type) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("datamodel.validation.valid_int", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 033:     # Basic check for integer type.

+034:     if not isinstance(value, int):

  __pyx_t_1 = PyLong_Check(__pyx_v_value); 
  __pyx_t_2 = (!__pyx_t_1);


  if (__pyx_t_2) {
/* … */
  }

+035:         return f"Field {name} expected an integer, got {value!r} of type {type(value).__name__}"

    __pyx_t_3 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 35, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 35, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 35, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 35, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Field;
    __pyx_t_7[1] = __pyx_t_3;
    __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_expected_an_integer_got;
    __pyx_t_7[3] = __pyx_t_4;
    __pyx_t_7[4] = __pyx_mstate_global->__pyx_kp_u_of_type;
    __pyx_t_7[5] = __pyx_t_6;
    __pyx_t_8 = 41;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_8 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[5]);
    #endif
    __pyx_t_9 = 0;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_7[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[5]);
    #endif
    __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_7, 6, __pyx_t_8, __pyx_t_9);
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 35, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_5);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_5 = 0;
    goto __pyx_L0;

+036:     return None

  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)Py_None); __Pyx_INCREF(Py_None);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  goto __pyx_L0;

 037: 

+038: cdef str valid_float(object field, str name, object value, object _type):

static PyObject *__pyx_f_9datamodel_10validation_valid_float(CYTHON_UNUSED PyObject *__pyx_v_field, PyObject *__pyx_v_name, PyObject *__pyx_v_value, CYTHON_UNUSED PyObject *__pyx_v__type) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("datamodel.validation.valid_float", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+039:     if not isinstance(value, (float, int)):  # sometimes ints are allowed

  __pyx_t_2 = PyFloat_Check(__pyx_v_value); 
  if (!__pyx_t_2) {

  } else {

    __pyx_t_1 = __pyx_t_2;

    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_2 = PyLong_Check(__pyx_v_value); 

  __pyx_t_1 = __pyx_t_2;

  __pyx_L4_bool_binop_done:;
  __pyx_t_2 = (!__pyx_t_1);


  if (__pyx_t_2) {
/* … */
  }

+040:         return f"Field {name} expected a float, got {value!r} of type {type(value).__name__}"

    __pyx_t_3 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 40, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 40, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 40, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 40, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Field;
    __pyx_t_7[1] = __pyx_t_3;
    __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_expected_a_float_got;
    __pyx_t_7[3] = __pyx_t_4;
    __pyx_t_7[4] = __pyx_mstate_global->__pyx_kp_u_of_type;
    __pyx_t_7[5] = __pyx_t_6;
    __pyx_t_8 = 38;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_8 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[5]);
    #endif
    __pyx_t_9 = 0;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_7[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[5]);
    #endif
    __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_7, 6, __pyx_t_8, __pyx_t_9);
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 40, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_5);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_5 = 0;
    goto __pyx_L0;

+041:     return None

  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)Py_None); __Pyx_INCREF(Py_None);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  goto __pyx_L0;

 042: 

+043: cdef str valid_str(object field, str name, object value, object _type):

static PyObject *__pyx_f_9datamodel_10validation_valid_str(CYTHON_UNUSED PyObject *__pyx_v_field, PyObject *__pyx_v_name, PyObject *__pyx_v_value, CYTHON_UNUSED PyObject *__pyx_v__type) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("datamodel.validation.valid_str", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+044:     if not isinstance(value, str):

  __pyx_t_1 = PyUnicode_Check(__pyx_v_value); 
  __pyx_t_2 = (!__pyx_t_1);


  if (__pyx_t_2) {
/* … */
  }

+045:         return f"Field {name} expected a string, got {value!r} of type {type(value).__name__}"

    __pyx_t_3 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 45, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 45, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Field;
    __pyx_t_7[1] = __pyx_t_3;
    __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_expected_a_string_got;
    __pyx_t_7[3] = __pyx_t_4;
    __pyx_t_7[4] = __pyx_mstate_global->__pyx_kp_u_of_type;
    __pyx_t_7[5] = __pyx_t_6;
    __pyx_t_8 = 39;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_8 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[5]);
    #endif
    __pyx_t_9 = 0;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_7[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[5]);
    #endif
    __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_7, 6, __pyx_t_8, __pyx_t_9);
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 45, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_5);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_5 = 0;
    goto __pyx_L0;

+046:     return None

  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)Py_None); __Pyx_INCREF(Py_None);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  goto __pyx_L0;

 047: 

+048: cdef str valid_uuid(object field, str name, object value, object _type):

static PyObject *__pyx_f_9datamodel_10validation_valid_uuid(CYTHON_UNUSED PyObject *__pyx_v_field, PyObject *__pyx_v_name, PyObject *__pyx_v_value, CYTHON_UNUSED PyObject *__pyx_v__type) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("datamodel.validation.valid_uuid", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+049:     if not isinstance(value, (UUID, pgproto.UUID)):

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_UUID); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_pgproto); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_UUID); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_5 = PyObject_IsInstance(__pyx_v_value, __pyx_t_1); 
  if (!__pyx_t_5) {

  } else {

    __pyx_t_4 = __pyx_t_5;

    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_5 = PyObject_IsInstance(__pyx_v_value, __pyx_t_3); 

  __pyx_t_4 = __pyx_t_5;

  __pyx_L4_bool_binop_done:;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_5 = (!__pyx_t_4);


  if (__pyx_t_5) {
/* … */
  }

+050:         return f"Field {name} expected a UUID, got {value!r} of type {type(value).__name__}"

    __pyx_t_1 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 50, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Field;
    __pyx_t_7[1] = __pyx_t_1;
    __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_expected_a_UUID_got;
    __pyx_t_7[3] = __pyx_t_3;
    __pyx_t_7[4] = __pyx_mstate_global->__pyx_kp_u_of_type;
    __pyx_t_7[5] = __pyx_t_6;
    __pyx_t_8 = 37;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_8 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[5]);
    #endif
    __pyx_t_9 = 0;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_7[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[5]);
    #endif
    __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 6, __pyx_t_8, __pyx_t_9);
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_2);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_2 = 0;
    goto __pyx_L0;

+051:     return None

  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)Py_None); __Pyx_INCREF(Py_None);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  goto __pyx_L0;

 052: 

+053: cdef str valid_boolean(object field, str name, object value, object _type):

static PyObject *__pyx_f_9datamodel_10validation_valid_boolean(CYTHON_UNUSED PyObject *__pyx_v_field, PyObject *__pyx_v_name, PyObject *__pyx_v_value, CYTHON_UNUSED PyObject *__pyx_v__type) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("datamodel.validation.valid_boolean", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+054:     if not isinstance(value, bool):

  __pyx_t_1 = PyBool_Check(__pyx_v_value); 
  __pyx_t_2 = (!__pyx_t_1);


  if (__pyx_t_2) {
/* … */
  }

+055:         return f"Field {name} expected a boolean, got {value!r} of type {type(value).__name__}"

    __pyx_t_3 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 55, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 55, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 55, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Field;
    __pyx_t_7[1] = __pyx_t_3;
    __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_expected_a_boolean_got;
    __pyx_t_7[3] = __pyx_t_4;
    __pyx_t_7[4] = __pyx_mstate_global->__pyx_kp_u_of_type;
    __pyx_t_7[5] = __pyx_t_6;
    __pyx_t_8 = 40;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_8 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[5]);
    #endif
    __pyx_t_9 = 0;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_7[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[5]);
    #endif
    __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_7, 6, __pyx_t_8, __pyx_t_9);
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 55, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_5);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_5 = 0;
    goto __pyx_L0;

+056:     return None

  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)Py_None); __Pyx_INCREF(Py_None);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  goto __pyx_L0;

 057: 

+058: cdef str valid_date(object field, str name, object value, object _type):

static PyObject *__pyx_f_9datamodel_10validation_valid_date(CYTHON_UNUSED PyObject *__pyx_v_field, PyObject *__pyx_v_name, PyObject *__pyx_v_value, CYTHON_UNUSED PyObject *__pyx_v__type) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("datamodel.validation.valid_date", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+059:     if not isinstance(value, datetime.date):

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 59, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_date); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 59, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = PyObject_IsInstance(__pyx_v_value, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 59, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = (!__pyx_t_3);


  if (__pyx_t_4) {
/* … */
  }

+060:         return f"Field {name} expected a date, got {value!r} of type {type(value).__name__}"

    __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 60, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 60, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 60, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Field;
    __pyx_t_7[1] = __pyx_t_2;
    __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_expected_a_date_got;
    __pyx_t_7[3] = __pyx_t_1;
    __pyx_t_7[4] = __pyx_mstate_global->__pyx_kp_u_of_type;
    __pyx_t_7[5] = __pyx_t_6;
    __pyx_t_8 = 37;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_8 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[5]);
    #endif
    __pyx_t_9 = 0;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_7[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[5]);
    #endif
    __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_7, 6, __pyx_t_8, __pyx_t_9);
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 60, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_5);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_5 = 0;
    goto __pyx_L0;

+061:     return None

  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)Py_None); __Pyx_INCREF(Py_None);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  goto __pyx_L0;

 062: 

+063: cdef str valid_datetime(object field, str name, object value, object _type):

static PyObject *__pyx_f_9datamodel_10validation_valid_datetime(CYTHON_UNUSED PyObject *__pyx_v_field, PyObject *__pyx_v_name, PyObject *__pyx_v_value, CYTHON_UNUSED PyObject *__pyx_v__type) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_AddTraceback("datamodel.validation.valid_datetime", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+064:     if isinstance(value, datetime.datetime):

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = PyObject_IsInstance(__pyx_v_value, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 64, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (__pyx_t_3) {
/* … */
  }

+065:         return None

    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)Py_None); __Pyx_INCREF(Py_None);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    goto __pyx_L0;

+066:     if isinstance(value, datetime.date):

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_date); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 66, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_3 = PyObject_IsInstance(__pyx_v_value, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 66, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_3) {
/* … */
  }

+067:         return None

    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)Py_None); __Pyx_INCREF(Py_None);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    goto __pyx_L0;

+068:     return f"Field {name} expected a datetime, got {value!r} of type {type(value).__name__}"

  __pyx_t_1 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 68, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 68, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_t_4, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 68, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_6[0] = __pyx_mstate_global->__pyx_kp_u_Field;
  __pyx_t_6[1] = __pyx_t_1;
  __pyx_t_6[2] = __pyx_mstate_global->__pyx_kp_u_expected_a_datetime_got;
  __pyx_t_6[3] = __pyx_t_2;
  __pyx_t_6[4] = __pyx_mstate_global->__pyx_kp_u_of_type;
  __pyx_t_6[5] = __pyx_t_5;
  __pyx_t_7 = 41;
  #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
  __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6[5]);
  #endif
  __pyx_t_8 = 0;
  #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
  __pyx_t_8 |= __Pyx_PyUnicode_KIND_04(__pyx_t_6[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_6[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_6[5]);
  #endif
  __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_6, 6, __pyx_t_7, __pyx_t_8);
  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 68, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)__pyx_t_4);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  __pyx_t_4 = 0;
  goto __pyx_L0;

 069: 

+070: cdef str valid_timedelta(object field, str name, object value, object _type):

static PyObject *__pyx_f_9datamodel_10validation_valid_timedelta(CYTHON_UNUSED PyObject *__pyx_v_field, PyObject *__pyx_v_name, PyObject *__pyx_v_value, CYTHON_UNUSED PyObject *__pyx_v__type) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("datamodel.validation.valid_timedelta", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+071:     if not isinstance(value, datetime.timedelta):

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_timedelta); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 71, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = PyObject_IsInstance(__pyx_v_value, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 71, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = (!__pyx_t_3);


  if (__pyx_t_4) {
/* … */
  }

+072:         return f"Field {name} expected a timedelta, got {value!r} of type {type(value).__name__}"

    __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 72, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 72, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Field;
    __pyx_t_7[1] = __pyx_t_2;
    __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_expected_a_timedelta_got;
    __pyx_t_7[3] = __pyx_t_1;
    __pyx_t_7[4] = __pyx_mstate_global->__pyx_kp_u_of_type;
    __pyx_t_7[5] = __pyx_t_6;
    __pyx_t_8 = 42;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_8 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[5]);
    #endif
    __pyx_t_9 = 0;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_7[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[5]);
    #endif
    __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_7, 6, __pyx_t_8, __pyx_t_9);
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 72, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_5);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_5 = 0;
    goto __pyx_L0;

+073:     return None

  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)Py_None); __Pyx_INCREF(Py_None);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  goto __pyx_L0;

 074: 

+075: cdef str valid_time(object field, str name, object value, object _type):

static PyObject *__pyx_f_9datamodel_10validation_valid_time(CYTHON_UNUSED PyObject *__pyx_v_field, PyObject *__pyx_v_name, PyObject *__pyx_v_value, CYTHON_UNUSED PyObject *__pyx_v__type) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("datamodel.validation.valid_time", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+076:     if not isinstance(value, datetime.time):

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = PyObject_IsInstance(__pyx_v_value, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 76, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_4 = (!__pyx_t_3);


  if (__pyx_t_4) {
/* … */
  }

+077:         return f"Field {name} expected a time, got {value!r} of type {type(value).__name__}"

    __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 77, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 77, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Field;
    __pyx_t_7[1] = __pyx_t_2;
    __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_expected_a_time_got;
    __pyx_t_7[3] = __pyx_t_1;
    __pyx_t_7[4] = __pyx_mstate_global->__pyx_kp_u_of_type;
    __pyx_t_7[5] = __pyx_t_6;
    __pyx_t_8 = 37;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_8 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[5]);
    #endif
    __pyx_t_9 = 0;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_7[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[5]);
    #endif
    __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_7, 6, __pyx_t_8, __pyx_t_9);
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 77, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_5);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_5 = 0;
    goto __pyx_L0;

+078:     return None

  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)Py_None); __Pyx_INCREF(Py_None);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  goto __pyx_L0;

 079: 

+080: cdef str valid_decimal(object field, str name, object value, object _type):

static PyObject *__pyx_f_9datamodel_10validation_valid_decimal(CYTHON_UNUSED PyObject *__pyx_v_field, PyObject *__pyx_v_name, PyObject *__pyx_v_value, CYTHON_UNUSED PyObject *__pyx_v__type) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("datamodel.validation.valid_decimal", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+081:     if not isinstance(value, Decimal):

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_Decimal); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = PyObject_IsInstance(__pyx_v_value, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 81, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = (!__pyx_t_2);


  if (__pyx_t_3) {
/* … */
  }

+082:         return f"Field {name} expected a Decimal, got {value!r} of type {type(value).__name__}"

    __pyx_t_1 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 82, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 82, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 82, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7[0] = __pyx_mstate_global->__pyx_kp_u_Field;
    __pyx_t_7[1] = __pyx_t_1;
    __pyx_t_7[2] = __pyx_mstate_global->__pyx_kp_u_expected_a_Decimal_got;
    __pyx_t_7[3] = __pyx_t_4;
    __pyx_t_7[4] = __pyx_mstate_global->__pyx_kp_u_of_type;
    __pyx_t_7[5] = __pyx_t_6;
    __pyx_t_8 = 40;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_8 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7[5]);
    #endif
    __pyx_t_9 = 0;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_7[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_7[5]);
    #endif
    __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_7, 6, __pyx_t_8, __pyx_t_9);
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 82, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_5);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_5 = 0;
    goto __pyx_L0;

+083:     return None

  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)Py_None); __Pyx_INCREF(Py_None);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  goto __pyx_L0;

 084: 

 085: 

 086: # List of Validators (primitive types):

 087: validators = {

+088:     str: valid_str,

  __pyx_t_2 = __Pyx_PyDict_NewPresized(12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_CFunc_c18e52__9datamodel_10validation_str__lParenobject__com__etc_to_py_5field_4name_5value_5_type(__pyx_f_9datamodel_10validation_valid_str); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_2, ((PyObject *)(&PyUnicode_Type)), __pyx_t_4) < (0)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+089:     int: valid_int,

  __pyx_t_4 = __Pyx_CFunc_c18e52__9datamodel_10validation_str__lParenobject__com__etc_to_py_5field_4name_5value_5_type(__pyx_f_9datamodel_10validation_valid_int); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_2, ((PyObject *)(&PyLong_Type)), __pyx_t_4) < (0)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+090:     float: valid_float,

  __pyx_t_4 = __Pyx_CFunc_c18e52__9datamodel_10validation_str__lParenobject__com__etc_to_py_5field_4name_5value_5_type(__pyx_f_9datamodel_10validation_valid_float); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 90, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_2, ((PyObject *)(&PyFloat_Type)), __pyx_t_4) < (0)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+091:     UUID: valid_uuid,

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_UUID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 91, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_CFunc_c18e52__9datamodel_10validation_str__lParenobject__com__etc_to_py_5field_4name_5value_5_type(__pyx_f_9datamodel_10validation_valid_uuid); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 91, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_t_2, __pyx_t_4, __pyx_t_6) < (0)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+092:     pgproto.UUID: valid_uuid,

  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_pgproto); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 92, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_UUID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 92, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_CFunc_c18e52__9datamodel_10validation_str__lParenobject__com__etc_to_py_5field_4name_5value_5_type(__pyx_f_9datamodel_10validation_valid_uuid); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 92, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_t_2, __pyx_t_4, __pyx_t_6) < (0)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+093:     bool: valid_boolean,

  __pyx_t_6 = __Pyx_CFunc_c18e52__9datamodel_10validation_str__lParenobject__com__etc_to_py_5field_4name_5value_5_type(__pyx_f_9datamodel_10validation_valid_boolean); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 93, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_t_2, ((PyObject *)(&PyBool_Type)), __pyx_t_6) < (0)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+094:     datetime.date: valid_date,

  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 94, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_date); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 94, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_CFunc_c18e52__9datamodel_10validation_str__lParenobject__com__etc_to_py_5field_4name_5value_5_type(__pyx_f_9datamodel_10validation_valid_date); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 94, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_t_2, __pyx_t_4, __pyx_t_6) < (0)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+095:     datetime.datetime: valid_datetime,

  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 95, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_CFunc_c18e52__9datamodel_10validation_str__lParenobject__com__etc_to_py_5field_4name_5value_5_type(__pyx_f_9datamodel_10validation_valid_datetime); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_t_2, __pyx_t_4, __pyx_t_6) < (0)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+096:     datetime.timedelta: valid_timedelta,

  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 96, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_timedelta); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_CFunc_c18e52__9datamodel_10validation_str__lParenobject__com__etc_to_py_5field_4name_5value_5_type(__pyx_f_9datamodel_10validation_valid_timedelta); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 96, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_t_2, __pyx_t_4, __pyx_t_6) < (0)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+097:     datetime.time: valid_time,

  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_time); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_CFunc_c18e52__9datamodel_10validation_str__lParenobject__com__etc_to_py_5field_4name_5value_5_type(__pyx_f_9datamodel_10validation_valid_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_t_2, __pyx_t_4, __pyx_t_6) < (0)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

+098:     Decimal: valid_decimal,

  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Decimal); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_CFunc_c18e52__9datamodel_10validation_str__lParenobject__com__etc_to_py_5field_4name_5value_5_type(__pyx_f_9datamodel_10validation_valid_decimal); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  if (PyDict_SetItem(__pyx_t_2, __pyx_t_6, __pyx_t_4) < (0)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

+099:     Text: valid_str

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Text); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 99, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = __Pyx_CFunc_c18e52__9datamodel_10validation_str__lParenobject__com__etc_to_py_5field_4name_5value_5_type(__pyx_f_9datamodel_10validation_valid_str); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 99, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  if (PyDict_SetItem(__pyx_t_2, __pyx_t_4, __pyx_t_6) < (0)) __PYX_ERR(0, 88, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_validators, __pyx_t_2) < (0)) __PYX_ERR(0, 87, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 100: }

 101: 

+102: cdef dict _create_error(str name, object value, object error, object val_type, object annotated_type, object exception = None):

static PyObject *__pyx_f_9datamodel_10validation__create_error(PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_error, PyObject *__pyx_v_val_type, PyObject *__pyx_v_annotated_type, struct __pyx_opt_args_9datamodel_10validation__create_error *__pyx_optional_args) {
  PyObject *__pyx_v_exception = ((PyObject *)Py_None);
  PyObject *__pyx_r = NULL;
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_exception = __pyx_optional_args->exception;
    }
  }
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("datamodel.validation._create_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
struct __pyx_opt_args_9datamodel_10validation__create_error {
  int __pyx_n;
  PyObject *exception;
};

 103:     return {

+104:         "field": name,

  __pyx_t_1 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_field, __pyx_v_name) < (0)) __PYX_ERR(0, 104, __pyx_L1_error)

+105:         "value": value,

  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_value, __pyx_v_value) < (0)) __PYX_ERR(0, 104, __pyx_L1_error)

+106:         "error": error,

  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_error, __pyx_v_error) < (0)) __PYX_ERR(0, 104, __pyx_L1_error)

+107:         "value_type": val_type,

  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_value_type, __pyx_v_val_type) < (0)) __PYX_ERR(0, 104, __pyx_L1_error)

+108:         "annotation": annotated_type,

  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_annotation, __pyx_v_annotated_type) < (0)) __PYX_ERR(0, 104, __pyx_L1_error)

+109:         "exception": exception

  if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_exception, __pyx_v_exception) < (0)) __PYX_ERR(0, 104, __pyx_L1_error)
  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)__pyx_t_1);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  __pyx_t_1 = 0;
  goto __pyx_L0;

 110:     }

 111: 

 112: 

+113: cdef inline bint is_enum_class(object annotated_type):

static CYTHON_INLINE int __pyx_f_9datamodel_10validation_is_enum_class(PyObject *__pyx_v_annotated_type) {
  int __pyx_v_res;
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("datamodel.validation.is_enum_class", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;


  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_9datamodel_10validation_13is_instanceof_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */

 114:     cdef int res

 115:     # First, check if annotated_type is a type

+116:     if not PyType_Check(annotated_type):

  __pyx_t_1 = (!PyType_Check(__pyx_v_annotated_type));

  if (__pyx_t_1) {
/* … */
  }

+117:         return False

    {

      __pyx_r = 0;
    }
    goto __pyx_L0;

 118:     # Then check if it is a subclass of Enum.

+119:     res = PyObject_IsSubclass(annotated_type, <object>Enum)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Enum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = PyObject_IsSubclass(__pyx_v_annotated_type, __pyx_t_2); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 119, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_res = __pyx_t_1;

+120:     if res < 0:

  __pyx_t_1 = (__pyx_v_res < 0);

  if (unlikely(__pyx_t_1)) {
/* … */
  }

 121:         # If an error occurred, you might want to raise an exception.

+122:         raise RuntimeError("Error in PyObject_IsSubclass")

    __pyx_t_3 = NULL;
    __pyx_t_4 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Error_in_PyObject_IsSubclass};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_RuntimeError)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(0, 122, __pyx_L1_error)

+123:     return res != 0

  {

    __pyx_r = (__pyx_v_res != 0);
  }
  goto __pyx_L0;

 124: 

+125: cdef bint is_instanceof(object value, object annotated_type):

static int __pyx_f_9datamodel_10validation_is_instanceof(PyObject *__pyx_v_value, PyObject *__pyx_v_annotated_type) {
  struct __pyx_obj_9datamodel_10validation___pyx_scope_struct____pyx_f_9datamodel_10validation_is_instanceof *__pyx_cur_scope;
  PyObject *__pyx_v_origin = NULL;
  PyObject *__pyx_v_args = NULL;
  PyObject *__pyx_v_container_map = NULL;
  PyObject *__pyx_v_e = NULL;
  PyObject *__pyx_gb_9datamodel_10validation_13is_instanceof_2generator = 0;
  PyObject *__pyx_gb_9datamodel_10validation_13is_instanceof_5generator1 = 0;
  int __pyx_r;
  __pyx_cur_scope = (struct __pyx_obj_9datamodel_10validation___pyx_scope_struct____pyx_f_9datamodel_10validation_is_instanceof *)__pyx_tp_new_9datamodel_10validation___pyx_scope_struct____pyx_f_9datamodel_10validation_is_instanceof(__pyx_mstate_global->__pyx_ptype_9datamodel_10validation___pyx_scope_struct____pyx_f_9datamodel_10validation_is_instanceof, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_9datamodel_10validation___pyx_scope_struct____pyx_f_9datamodel_10validation_is_instanceof *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 125, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_v_value = __pyx_v_value;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_value);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_value);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_AddTraceback("datamodel.validation.is_instanceof", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_origin);
  __Pyx_XDECREF(__pyx_v_args);
  __Pyx_XDECREF(__pyx_v_container_map);
  __Pyx_XDECREF(__pyx_v_e);
  __Pyx_XDECREF(__pyx_gb_9datamodel_10validation_13is_instanceof_2generator);
  __Pyx_XDECREF(__pyx_gb_9datamodel_10validation_13is_instanceof_5generator1);
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);

  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
struct __pyx_obj_9datamodel_10validation___pyx_scope_struct____pyx_f_9datamodel_10validation_is_instanceof {
  PyObject_HEAD
  PyObject *__pyx_v_value;
};

 126:     """

 127:     Check if value is an instance of annotated_type, handling typing objects properly.

 128:     For generic types (List[int], etc.), just check against the base container type.

 129:     """

 130:     # Get origin type for generics

+131:     origin = get_origin(annotated_type)

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_origin); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_annotated_type};
    __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_origin = __pyx_t_1;
  __pyx_t_1 = 0;

 132: 

 133:     # PEP 604 union types (int | str)

+134:     if isinstance(annotated_type, UnionType):

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_UnionType); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = PyObject_IsInstance(__pyx_v_annotated_type, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 134, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_5) {
/* … */
  }

+135:         args = get_args(annotated_type)

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
      __pyx_t_4 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_annotated_type};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_args = __pyx_t_1;
    __pyx_t_1 = 0;

+136:         return any(is_instanceof(value, arg) for arg in args if arg is not type(None)) or value is None and type(None) in args

static PyObject *__pyx_pf_9datamodel_10validation_13is_instanceof_genexpr(PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) {
  struct __pyx_obj_9datamodel_10validation___pyx_scope_struct_1_genexpr *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_9datamodel_10validation___pyx_scope_struct_1_genexpr *)__pyx_tp_new_9datamodel_10validation___pyx_scope_struct_1_genexpr(__pyx_mstate_global->__pyx_ptype_9datamodel_10validation___pyx_scope_struct_1_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_9datamodel_10validation___pyx_scope_struct_1_genexpr *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 136, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_9datamodel_10validation___pyx_scope_struct____pyx_f_9datamodel_10validation_is_instanceof *) __pyx_self;
  __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_9datamodel_10validation_13is_instanceof_2generator, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_is_instanceof_locals_genexpr, __pyx_mstate_global->__pyx_n_u_datamodel_validation); if (unlikely(!gen)) __PYX_ERR(0, 136, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("datamodel.validation.is_instanceof.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_9datamodel_10validation_13is_instanceof_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("genexpr", 0);
  __pyx_L3_first_run:;
  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 136, __pyx_L1_error)
  if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 136, __pyx_L1_error) }
  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) {
    __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1);
    __pyx_t_2 = 0;
    __pyx_t_3 = NULL;
  } else {
    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_3)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 136, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference);
        ++__pyx_t_2;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 136, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2));
        #else
        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2);
        #endif
        ++__pyx_t_2;
      }
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 136, __pyx_L1_error)
    } else {
      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 136, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_arg);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_arg, __pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_4);
    __pyx_t_4 = 0;
    __pyx_t_5 = (__pyx_cur_scope->__pyx_v_arg != ((PyObject *)Py_TYPE(Py_None)));
    if (__pyx_t_5) {

      if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_value)) { __Pyx_RaiseClosureNameError("value"); __PYX_ERR(0, 136, __pyx_L1_error) }
      __pyx_t_4 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_value;
      __Pyx_INCREF(__pyx_t_4);
      __pyx_t_5 = __pyx_f_9datamodel_10validation_is_instanceof(__pyx_t_4, __pyx_cur_scope->__pyx_v_arg); if (unlikely(__pyx_t_5 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 136, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_5) {

        {
          PyObject *__pyx_temp;
          {
            __pyx_temp = __pyx_r;
            __Pyx_INCREF(Py_True);
            __pyx_r = Py_True;
          }
          __Pyx_XDECREF(__pyx_temp);
        }
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        goto __pyx_L0;
      }
    }
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  /*else*/ {
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __Pyx_INCREF(Py_False);
        __pyx_r = Py_False;
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    goto __pyx_L0;
  }
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
static PyObject *__pyx_gb_9datamodel_10validation_13is_instanceof_5generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
/* … */
    __pyx_t_1 = __pyx_pf_9datamodel_10validation_13is_instanceof_genexpr(((PyObject*)__pyx_cur_scope), __pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_Generator_GetInlinedResult(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 136, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (!__pyx_t_6) {

    } else {

      __pyx_t_5 = __pyx_t_6;

      goto __pyx_L4_bool_binop_done;
    }
    __pyx_t_6 = (__pyx_cur_scope->__pyx_v_value == Py_None);
    if (__pyx_t_6) {

    } else {

      __pyx_t_5 = __pyx_t_6;

      goto __pyx_L4_bool_binop_done;
    }
    __pyx_t_6 = (__Pyx_PySequence_ContainsTF(((PyObject *)Py_TYPE(Py_None)), __pyx_v_args, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 136, __pyx_L1_error)

    __pyx_t_5 = __pyx_t_6;

    __pyx_L4_bool_binop_done:;
    {
      __pyx_r = __pyx_t_5;
    }
    goto __pyx_L0;
/* … */
struct __pyx_obj_9datamodel_10validation___pyx_scope_struct_1_genexpr {
  PyObject_HEAD
  struct __pyx_obj_9datamodel_10validation___pyx_scope_struct____pyx_f_9datamodel_10validation_is_instanceof *__pyx_outer_scope;
  PyObject *__pyx_genexpr_arg_0;
  PyObject *__pyx_v_arg;
};

 137: 

 138:     # If it's a typing module type like List[int], Dict[str, int], etc.

+139:     if hasattr(annotated_type, '__module__') and annotated_type.__module__ == 'typing':

  __pyx_t_6 = __Pyx_HasAttr(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_n_u_module); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 139, __pyx_L1_error)
  if (__pyx_t_6) {

  } else {

    __pyx_t_5 = __pyx_t_6;

    goto __pyx_L8_bool_binop_done;
  }
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_n_u_module); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 139, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = __Pyx_PyObject_CompareBoolEq_object_str(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_typing, Py_EQ); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 139, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  __pyx_t_5 = __pyx_t_6;

  __pyx_L8_bool_binop_done:;
  if (__pyx_t_5) {
/* … */
  }

 140:         # For Union, check each option

+141:         if origin is Union:

    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Union); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_5 = (__pyx_v_origin == __pyx_t_2);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (__pyx_t_5) {
/* … */
    }

+142:             args = get_args(annotated_type)

      __pyx_t_1 = NULL;
      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 142, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = 1;
      #if CYTHON_UNPACK_METHODS
      if (unlikely(PyMethod_Check(__pyx_t_3))) {
        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
        assert(__pyx_t_1);
        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_1);
        __Pyx_INCREF(__pyx__function);
        __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
        __pyx_t_4 = 0;
      }
      #endif
      {
        PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_annotated_type};
        __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 142, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
      }
      __pyx_v_args = __pyx_t_2;
      __pyx_t_2 = 0;

+143:             return any(is_instanceof(value, arg) for arg in args if arg is not type(None)) or value is None and type(None) in args

static PyObject *__pyx_pf_9datamodel_10validation_13is_instanceof_3genexpr(PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) {
  struct __pyx_obj_9datamodel_10validation___pyx_scope_struct_2_genexpr *__pyx_cur_scope;
  PyObject *__pyx_r = NULL;
  __pyx_cur_scope = (struct __pyx_obj_9datamodel_10validation___pyx_scope_struct_2_genexpr *)__pyx_tp_new_9datamodel_10validation___pyx_scope_struct_2_genexpr(__pyx_mstate_global->__pyx_ptype_9datamodel_10validation___pyx_scope_struct_2_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL);
  if (unlikely(!__pyx_cur_scope)) {
    __pyx_cur_scope = ((struct __pyx_obj_9datamodel_10validation___pyx_scope_struct_2_genexpr *)Py_None);
    __Pyx_INCREF(Py_None);
    __PYX_ERR(0, 143, __pyx_L1_error)
  } else {
    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
  }
  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_9datamodel_10validation___pyx_scope_struct____pyx_f_9datamodel_10validation_is_instanceof *) __pyx_self;
  __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
  __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0;
  __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
  {
    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_9datamodel_10validation_13is_instanceof_5generator1, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_is_instanceof_locals_genexpr, __pyx_mstate_global->__pyx_n_u_datamodel_validation); if (unlikely(!gen)) __PYX_ERR(0, 143, __pyx_L1_error)
    __Pyx_DECREF(__pyx_cur_scope);
    __Pyx_RefNannyFinishContext();
    return (PyObject *) gen;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_AddTraceback("datamodel.validation.is_instanceof.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_gb_9datamodel_10validation_13is_instanceof_5generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
{
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("genexpr", 0);
  __pyx_L3_first_run:;
  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 143, __pyx_L1_error)
  if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 143, __pyx_L1_error) }
  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) {
    __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1);
    __pyx_t_2 = 0;
    __pyx_t_3 = NULL;
  } else {
    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 143, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_3)) {
      if (likely(PyList_CheckExact(__pyx_t_1))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 143, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference);
        ++__pyx_t_2;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 143, __pyx_L1_error)
          #endif
          if (__pyx_t_2 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2));
        #else
        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2);
        #endif
        ++__pyx_t_2;
      }
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 143, __pyx_L1_error)
    } else {
      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
      if (unlikely(!__pyx_t_4)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 143, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_arg);
    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_arg, __pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_4);
    __pyx_t_4 = 0;
    __pyx_t_5 = (__pyx_cur_scope->__pyx_v_arg != ((PyObject *)Py_TYPE(Py_None)));
    if (__pyx_t_5) {

      if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_value)) { __Pyx_RaiseClosureNameError("value"); __PYX_ERR(0, 143, __pyx_L1_error) }
      __pyx_t_4 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_value;
      __Pyx_INCREF(__pyx_t_4);
      __pyx_t_5 = __pyx_f_9datamodel_10validation_is_instanceof(__pyx_t_4, __pyx_cur_scope->__pyx_v_arg); if (unlikely(__pyx_t_5 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 143, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_5) {

        {
          PyObject *__pyx_temp;
          {
            __pyx_temp = __pyx_r;
            __Pyx_INCREF(Py_True);
            __pyx_r = Py_True;
          }
          __Pyx_XDECREF(__pyx_temp);
        }
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        goto __pyx_L0;
      }
    }
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  /*else*/ {
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __Pyx_INCREF(Py_False);
        __pyx_r = Py_False;
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    goto __pyx_L0;
  }
  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  if (__Pyx_PyErr_Occurred()) {
    __Pyx_Generator_Replace_StopIteration(0);
    __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
  }
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  #if !CYTHON_USE_EXC_INFO_STACK
  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
  #endif
  __pyx_generator->resume_label = -1;
  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
      __pyx_t_2 = __pyx_pf_9datamodel_10validation_13is_instanceof_3genexpr(((PyObject*)__pyx_cur_scope), __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_3 = __Pyx_Generator_GetInlinedResult(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 143, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 143, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (!__pyx_t_6) {

      } else {

        __pyx_t_5 = __pyx_t_6;

        goto __pyx_L11_bool_binop_done;
      }
      __pyx_t_6 = (__pyx_cur_scope->__pyx_v_value == Py_None);
      if (__pyx_t_6) {

      } else {

        __pyx_t_5 = __pyx_t_6;

        goto __pyx_L11_bool_binop_done;
      }
      __pyx_t_6 = (__Pyx_PySequence_ContainsTF(((PyObject *)Py_TYPE(Py_None)), __pyx_v_args, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 143, __pyx_L1_error)

      __pyx_t_5 = __pyx_t_6;

      __pyx_L11_bool_binop_done:;
      {
        __pyx_r = __pyx_t_5;
      }
      goto __pyx_L0;
/* … */
struct __pyx_obj_9datamodel_10validation___pyx_scope_struct_2_genexpr {
  PyObject_HEAD
  struct __pyx_obj_9datamodel_10validation___pyx_scope_struct____pyx_f_9datamodel_10validation_is_instanceof *__pyx_outer_scope;
  PyObject *__pyx_genexpr_arg_0;
  PyObject *__pyx_v_arg;
};

 144: 

 145:         # For container types, check against base type

+146:         elif origin in (list, tuple, set, frozenset, dict):

    __Pyx_INCREF(__pyx_v_origin);
    __pyx_t_3 = __pyx_v_origin;
    __pyx_t_6 = __Pyx_PyObject_RichCompareBool(__pyx_t_3, ((PyObject *)(&PyList_Type)), Py_EQ); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 146, __pyx_L1_error)
    if (!__pyx_t_6) {

    } else {

      __pyx_t_5 = __pyx_t_6;

      goto __pyx_L14_bool_binop_done;
    }
    __pyx_t_6 = __Pyx_PyObject_RichCompareBool(__pyx_t_3, ((PyObject *)(&PyTuple_Type)), Py_EQ); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 146, __pyx_L1_error)
    if (!__pyx_t_6) {

    } else {

      __pyx_t_5 = __pyx_t_6;

      goto __pyx_L14_bool_binop_done;
    }
    __pyx_t_6 = __Pyx_PyObject_RichCompareBool(__pyx_t_3, ((PyObject *)(&PySet_Type)), Py_EQ); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 146, __pyx_L1_error)
    if (!__pyx_t_6) {

    } else {

      __pyx_t_5 = __pyx_t_6;

      goto __pyx_L14_bool_binop_done;
    }
    __pyx_t_6 = __Pyx_PyObject_RichCompareBool(__pyx_t_3, ((PyObject *)(&PyFrozenSet_Type)), Py_EQ); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 146, __pyx_L1_error)
    if (!__pyx_t_6) {

    } else {

      __pyx_t_5 = __pyx_t_6;

      goto __pyx_L14_bool_binop_done;
    }
    __pyx_t_6 = __Pyx_PyObject_RichCompareBool(__pyx_t_3, ((PyObject *)(&PyDict_Type)), Py_EQ); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 146, __pyx_L1_error)

    __pyx_t_5 = __pyx_t_6;

    __pyx_L14_bool_binop_done:;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_6 = __pyx_t_5;


    if (__pyx_t_6) {
/* … */
    }

 147:             container_map = {

+148:                 list: list,

      __pyx_t_3 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 148, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      if (PyDict_SetItem(__pyx_t_3, ((PyObject *)(&PyList_Type)), ((PyObject *)(&PyList_Type))) < (0)) __PYX_ERR(0, 148, __pyx_L1_error)

+149:                 tuple: tuple,

      if (PyDict_SetItem(__pyx_t_3, ((PyObject *)(&PyTuple_Type)), ((PyObject *)(&PyTuple_Type))) < (0)) __PYX_ERR(0, 148, __pyx_L1_error)

+150:                 set: set,

      if (PyDict_SetItem(__pyx_t_3, ((PyObject *)(&PySet_Type)), ((PyObject *)(&PySet_Type))) < (0)) __PYX_ERR(0, 148, __pyx_L1_error)

+151:                 frozenset: frozenset,

      if (PyDict_SetItem(__pyx_t_3, ((PyObject *)(&PyFrozenSet_Type)), ((PyObject *)(&PyFrozenSet_Type))) < (0)) __PYX_ERR(0, 148, __pyx_L1_error)

+152:                 dict: dict

      if (PyDict_SetItem(__pyx_t_3, ((PyObject *)(&PyDict_Type)), ((PyObject *)(&PyDict_Type))) < (0)) __PYX_ERR(0, 148, __pyx_L1_error)
      __pyx_v_container_map = ((PyObject*)__pyx_t_3);
      __pyx_t_3 = 0;

 153:             }

+154:             return isinstance(value, container_map.get(origin, object))

      __pyx_t_3 = __pyx_cur_scope->__pyx_v_value;
      __Pyx_INCREF(__pyx_t_3);
      __pyx_t_2 = __Pyx_PyDict_GetItemDefault(__pyx_v_container_map, __pyx_v_origin, __pyx_builtin_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_6 = PyObject_IsInstance(__pyx_t_3, __pyx_t_2); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 154, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      {
        __pyx_r = __pyx_t_6;
      }
      goto __pyx_L0;

 155: 

 156:         # For other typing constructs, consider it valid (can be refined further)

+157:         return True

    {

      __pyx_r = 1;
    }
    goto __pyx_L0;

 158: 

 159:     # For datetime types, use issubclass check

+160:     elif value in (datetime.date, datetime.time, datetime.datetime):

  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_value);
  __pyx_t_2 = __pyx_cur_scope->__pyx_v_value;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_date); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = __Pyx_PyObject_CompareBoolEq_object_object(__pyx_t_2, __pyx_t_1, Py_EQ); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (!__pyx_t_5) {

  } else {

    __pyx_t_6 = __pyx_t_5;

    goto __pyx_L19_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_5 = __Pyx_PyObject_CompareBoolEq_object_object(__pyx_t_2, __pyx_t_3, Py_EQ); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!__pyx_t_5) {

  } else {

    __pyx_t_6 = __pyx_t_5;

    goto __pyx_L19_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = __Pyx_PyObject_CompareBoolEq_object_object(__pyx_t_2, __pyx_t_1, Py_EQ); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  __pyx_t_6 = __pyx_t_5;

  __pyx_L19_bool_binop_done:;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_5 = __pyx_t_6;


  if (__pyx_t_5) {
/* … */
  }

 161:         # Check if is a pendulum instance:

+162:         return issubclass(value, (datetime.date, datetime.time, datetime.datetime))

    __pyx_t_2 = __pyx_cur_scope->__pyx_v_value;
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_date); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 162, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_time); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 162, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_datetime); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 162, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GIVEREF(__pyx_t_3);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 162, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_7);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 162, __pyx_L1_error);
    __Pyx_GIVEREF(__pyx_t_8);
    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_8) != (0)) __PYX_ERR(0, 162, __pyx_L1_error);
    __pyx_t_3 = 0;
    __pyx_t_7 = 0;
    __pyx_t_8 = 0;
    __pyx_t_5 = PyObject_IsSubclass(__pyx_t_2, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 162, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    {
      __pyx_r = __pyx_t_5;
    }
    goto __pyx_L0;

 163: 

 164:     # For normal types, use isinstance

 165:     else:

+166:         try:

  /*else*/ {
    {
      /*try:*/ {
/* … */
      }
      __pyx_L22_error:;
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
/* … */
      __pyx_L24_except_error:;
      __Pyx_XGIVEREF(__pyx_t_9);
      __Pyx_XGIVEREF(__pyx_t_10);
      __Pyx_XGIVEREF(__pyx_t_11);
      __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
      goto __pyx_L1_error;
      __pyx_L26_try_return:;
      __Pyx_XGIVEREF(__pyx_t_9);
      __Pyx_XGIVEREF(__pyx_t_10);
      __Pyx_XGIVEREF(__pyx_t_11);
      __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
      goto __pyx_L0;
      __pyx_L25_except_return:;
      __Pyx_XGIVEREF(__pyx_t_9);
      __Pyx_XGIVEREF(__pyx_t_10);
      __Pyx_XGIVEREF(__pyx_t_11);
      __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
      goto __pyx_L0;
    }
  }

+167:             return isinstance(value, annotated_type)

        __pyx_t_1 = __pyx_cur_scope->__pyx_v_value;
        __Pyx_INCREF(__pyx_t_1);
        __pyx_t_5 = PyObject_IsInstance(__pyx_t_1, __pyx_v_annotated_type); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 167, __pyx_L22_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        {
          __pyx_r = __pyx_t_5;
        }
        goto __pyx_L26_try_return;

+168:         except (AttributeError, TypeError, ValueError) as e:

      __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_AttributeError)))) || __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_TypeError)))) || __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_ValueError))));
      if (__pyx_t_12) {
        __Pyx_AddTraceback("datamodel.validation.is_instanceof", __pyx_clineno, __pyx_lineno, __pyx_filename);
        if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_8) < 0) __PYX_ERR(0, 168, __pyx_L24_except_error)
        __Pyx_XGOTREF(__pyx_t_1);
        __Pyx_XGOTREF(__pyx_t_2);
        __Pyx_XGOTREF(__pyx_t_8);
        __Pyx_INCREF(__pyx_t_2);
        __pyx_v_e = __pyx_t_2;
        /*try:*/ {
/* … */
        /*finally:*/ {
          __pyx_L33_error:;
          /*exception exit:*/{
            __Pyx_PyThreadState_declare
            __Pyx_PyThreadState_assign
            __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
            __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
             __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
            if ( unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
            __Pyx_XGOTREF(__pyx_t_16);
            __Pyx_XGOTREF(__pyx_t_17);
            __Pyx_XGOTREF(__pyx_t_18);
            __Pyx_XGOTREF(__pyx_t_19);
            __Pyx_XGOTREF(__pyx_t_20);
            __Pyx_XGOTREF(__pyx_t_21);
            __pyx_t_12 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename;
            {
              __Pyx_DECREF(__pyx_v_e); __pyx_v_e = 0;
            }
            __Pyx_XGIVEREF(__pyx_t_19);
            __Pyx_XGIVEREF(__pyx_t_20);
            __Pyx_XGIVEREF(__pyx_t_21);
            __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21);
            __Pyx_XGIVEREF(__pyx_t_16);
            __Pyx_XGIVEREF(__pyx_t_17);
            __Pyx_XGIVEREF(__pyx_t_18);
            __Pyx_ErrRestore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
            __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
            __pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15;
            goto __pyx_L24_except_error;
          }
          __pyx_L32_return: {
            __pyx_t_5 = __pyx_r;
            __Pyx_DECREF(__pyx_v_e); __pyx_v_e = 0;
            __pyx_r = __pyx_t_5;
            goto __pyx_L25_except_return;
          }
        }
      }
      goto __pyx_L24_except_error;

 169:             # For errors with subscripted generics, just return True

+170:             if "subscripted generics" in str(e):

          __pyx_t_7 = __Pyx_PyObject_Unicode(__pyx_v_e); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 170, __pyx_L33_error)
          __Pyx_GOTREF(__pyx_t_7);
          __pyx_t_5 = (__Pyx_PyUnicode_ContainsTF(__pyx_mstate_global->__pyx_kp_u_subscripted_generics, __pyx_t_7, Py_EQ)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 170, __pyx_L33_error)
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          if (__pyx_t_5) {
/* … */
          }

+171:                 return True

            {

              __pyx_r = 1;
            }
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            goto __pyx_L32_return;

+172:             raise TypeError(f"{e}")

          __pyx_t_3 = NULL;
          __pyx_t_13 = __Pyx_PyObject_FormatSimple(__pyx_v_e, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 172, __pyx_L33_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_4 = 1;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_13};
            __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_TypeError)), __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 172, __pyx_L33_error)
            __Pyx_GOTREF(__pyx_t_7);
          }
          __Pyx_Raise(__pyx_t_7, 0, 0, 0);
          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
          __PYX_ERR(0, 172, __pyx_L33_error)
        }

 173: 

+174: cpdef bint is_optional_type(object annotated_type):

static PyObject *__pyx_pw_9datamodel_10validation_1is_optional_type(PyObject *__pyx_self, 
#if CYTHON_VECTORCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static int __pyx_f_9datamodel_10validation_is_optional_type(PyObject *__pyx_v_annotated_type, CYTHON_UNUSED int __pyx_skip_dispatch) {
  PyObject *__pyx_v_origin = NULL;
  PyObject *__pyx_v_args = NULL;
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("datamodel.validation.is_optional_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_origin);
  __Pyx_XDECREF(__pyx_v_args);

  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_9datamodel_10validation_1is_optional_type(PyObject *__pyx_self, 
#if CYTHON_VECTORCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_9datamodel_10validation_is_optional_type, "is_optional_type(annotated_type) -> bool\n\nCheck if annotated_type is an Optional type (Union[T, None]).");
static PyMethodDef __pyx_mdef_9datamodel_10validation_1is_optional_type = {"is_optional_type", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9datamodel_10validation_1is_optional_type, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9datamodel_10validation_is_optional_type};
static PyObject *__pyx_pw_9datamodel_10validation_1is_optional_type(PyObject *__pyx_self, 
#if CYTHON_VECTORCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_annotated_type = 0;
  #if !CYTHON_VECTORCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("is_optional_type (wrapper)", 0);
  #if !CYTHON_VECTORCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_annotated_type,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 174, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 174, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "is_optional_type", 0) < (0)) __PYX_ERR(0, 174, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("is_optional_type", 1, 1, 1, i); __PYX_ERR(0, 174, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 174, __pyx_L3_error)
    }
    __pyx_v_annotated_type = values[0];
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("is_optional_type", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 174, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("datamodel.validation.is_optional_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_9datamodel_10validation_is_optional_type(__pyx_self, __pyx_v_annotated_type);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9datamodel_10validation_is_optional_type(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_annotated_type) {
  PyObject *__pyx_r = NULL;
  __pyx_t_1 = __pyx_f_9datamodel_10validation_is_optional_type(__pyx_v_annotated_type, 1); if (unlikely(__pyx_t_1 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 174, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 174, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);

  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = __pyx_t_2;
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  __pyx_t_2 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_AddTraceback("datamodel.validation.is_optional_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9datamodel_10validation_1is_optional_type, 0, __pyx_mstate_global->__pyx_n_u_is_optional_type, NULL, __pyx_mstate_global->__pyx_n_u_datamodel_validation, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 174, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
  #endif
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_is_optional_type, __pyx_t_2) < (0)) __PYX_ERR(0, 174, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 175:     """

 176:     Check if annotated_type is an Optional type (Union[T, None]).

 177:     """

+178:     origin = get_origin(annotated_type)

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_origin); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_annotated_type};
    __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_origin = __pyx_t_1;
  __pyx_t_1 = 0;

 179: 

 180:     # If it's a Union (typing.Union or PEP 604), check if None is one of the options

+181:     if _is_union(origin):

  __pyx_t_5 = __pyx_f_9datamodel_10validation__is_union(__pyx_v_origin); if (unlikely(__pyx_t_5 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 181, __pyx_L1_error)
  if (__pyx_t_5) {
/* … */
  }

+182:         args = get_args(annotated_type)

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 182, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
      __pyx_t_4 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_annotated_type};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_v_args = __pyx_t_1;
    __pyx_t_1 = 0;

+183:         return type(None) in args

    __pyx_t_5 = (__Pyx_PySequence_ContainsTF(((PyObject *)Py_TYPE(Py_None)), __pyx_v_args, Py_EQ)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 183, __pyx_L1_error)
    {
      __pyx_r = __pyx_t_5;
    }
    goto __pyx_L0;

 184: 

 185:     # For backward compatibility with Python 3.8

 186:     # Check old-style Optional typing

+187:     if hasattr(annotated_type, "__origin__") and annotated_type.__origin__ is Union:

  __pyx_t_6 = __Pyx_HasAttr(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_n_u_origin); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 187, __pyx_L1_error)
  if (__pyx_t_6) {

  } else {

    __pyx_t_5 = __pyx_t_6;

    goto __pyx_L5_bool_binop_done;
  }
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_n_u_origin); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 187, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Union); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 187, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = (__pyx_t_1 == __pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  __pyx_t_5 = __pyx_t_6;

  __pyx_L5_bool_binop_done:;
  if (__pyx_t_5) {
/* … */
  }

+188:         args = annotated_type.__args__

    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_n_u_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_v_args = __pyx_t_2;
    __pyx_t_2 = 0;

+189:         return type(None) in args

    __pyx_t_5 = (__Pyx_PySequence_ContainsTF(((PyObject *)Py_TYPE(Py_None)), __pyx_v_args, Py_EQ)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 189, __pyx_L1_error)
    {
      __pyx_r = __pyx_t_5;
    }
    goto __pyx_L0;

 190: 

+191:     return False

  {

    __pyx_r = 0;
  }
  goto __pyx_L0;

 192: 

+193: cdef object get_primary_key_field(object annotated_type, str name, object field_meta):

static PyObject *__pyx_f_9datamodel_10validation_get_primary_key_field(PyObject *__pyx_v_annotated_type, PyObject *__pyx_v_name, PyObject *__pyx_v_field_meta) {
  PyObject *__pyx_v_f = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("datamodel.validation.get_primary_key_field", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_f);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+194:     for f in annotated_type.__dataclass_fields__.values():

  __pyx_t_2 = 0;
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_n_u_dataclass_fields); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 194, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (unlikely(__pyx_t_5 == Py_None)) {
    PyErr_Format(PyExc_AttributeError, "\047NoneType\047 object has no attribute \047%.30s\047", "values");
    __PYX_ERR(0, 194, __pyx_L1_error)
  }
  __pyx_t_6 = __Pyx_dict_iterator(__pyx_t_5, 0, __pyx_mstate_global->__pyx_n_u_values, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 194, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_XDECREF(__pyx_t_1);
  __pyx_t_1 = __pyx_t_6;
  __pyx_t_6 = 0;
  while (1) {
    __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, NULL, &__pyx_t_6, NULL, __pyx_t_4);
    if (unlikely(__pyx_t_7 == 0)) break;
    if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 194, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_XDECREF_SET(__pyx_v_f, __pyx_t_6);
    __pyx_t_6 = 0;

+195:         if name == f.name:

    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 195, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_8 = __Pyx_PyObject_CompareBoolEq_str_object(__pyx_v_name, __pyx_t_6, Py_EQ); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 195, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (__pyx_t_8) {
/* … */
    }

+196:             return f

      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __Pyx_INCREF(__pyx_v_f);
          __pyx_r = __pyx_v_f;
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      goto __pyx_L0;

+197:         if field_meta.get('alias') == f.name:

    __pyx_t_5 = __pyx_v_field_meta;
    __Pyx_INCREF(__pyx_t_5);
    __pyx_t_9 = 0;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_alias};
      __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 197, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
    }
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 197, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_8 = __Pyx_PyObject_CompareBoolEq_object_object(__pyx_t_6, __pyx_t_5, Py_EQ); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 197, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_8) {
/* … */
    }

+198:             return f

      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __Pyx_INCREF(__pyx_v_f);
          __pyx_r = __pyx_v_f;
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      goto __pyx_L0;

+199:         if f.metadata.get('primary_key', False):

    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_mstate_global->__pyx_n_u_metadata); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_get); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 199, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_mstate_global->__pyx_tuple[0], NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 199, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (__pyx_t_8) {
/* … */
    }
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  {
    PyObject* __pyx_temp[2] = {__pyx_mstate_global->__pyx_n_u_primary_key, Py_False};
    __pyx_mstate_global->__pyx_tuple[0] = __Pyx_PyTuple_FromArray(__pyx_temp, 2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(0, 199, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]);
  }
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]);

+200:             return f

      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __Pyx_INCREF(__pyx_v_f);
          __pyx_r = __pyx_v_f;
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      goto __pyx_L0;

+201:     return None

  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  goto __pyx_L0;

 202: 

+203: cdef dict _validate_union_field(

static PyObject *__pyx_f_9datamodel_10validation__validate_union_field(PyObject *__pyx_v_F, PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_annotated_type) {
  CYTHON_UNUSED PyObject *__pyx_v_origin = 0;
  PyObject *__pyx_v_targs = 0;
  PyObject *__pyx_v_subtype_origin = 0;
  PyObject *__pyx_v_errors = 0;
  PyObject *__pyx_v_sub_error = 0;
  PyObject *__pyx_v_list_args = 0;
  PyObject *__pyx_v_inner_type = 0;
  PyObject *__pyx_v_item_errors = 0;
  PyObject *__pyx_v_dict_args = 0;
  PyObject *__pyx_v_key_type = 0;
  PyObject *__pyx_v_val_type = 0;
  PyObject *__pyx_v_subtype = NULL;
  PyObject *__pyx_v_idx = NULL;
  PyObject *__pyx_v_item = NULL;
  PyObject *__pyx_v_dict_errors = NULL;
  PyObject *__pyx_v_k = NULL;
  PyObject *__pyx_v_v = NULL;
  PyObject *__pyx_v_exc = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_18);
  __Pyx_XDECREF(__pyx_t_21);
  __Pyx_AddTraceback("datamodel.validation._validate_union_field", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_origin);
  __Pyx_XDECREF(__pyx_v_targs);
  __Pyx_XDECREF(__pyx_v_subtype_origin);
  __Pyx_XDECREF(__pyx_v_errors);
  __Pyx_XDECREF(__pyx_v_sub_error);
  __Pyx_XDECREF(__pyx_v_list_args);
  __Pyx_XDECREF(__pyx_v_inner_type);
  __Pyx_XDECREF(__pyx_v_item_errors);
  __Pyx_XDECREF(__pyx_v_dict_args);
  __Pyx_XDECREF(__pyx_v_key_type);
  __Pyx_XDECREF(__pyx_v_val_type);
  __Pyx_XDECREF(__pyx_v_subtype);
  __Pyx_XDECREF(__pyx_v_idx);
  __Pyx_XDECREF(__pyx_v_item);
  __Pyx_XDECREF(__pyx_v_dict_errors);
  __Pyx_XDECREF(__pyx_v_k);
  __Pyx_XDECREF(__pyx_v_v);
  __Pyx_XDECREF(__pyx_v_exc);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 204:     object F,           # Field object (your internal representation)

 205:     str name,           # Field name

 206:     object value,       # Actual runtime value

 207:     object annotated_type  # The declared type (e.g. Union[str, List[str]], etc.)

 208: ):

 209:     """

 210:     Validates a complex or nested Union (including Optional and nested structures)

 211:     Returns {} if validation passes, or a dict describing the error.

 212:     """

+213:     cdef object origin = get_origin(annotated_type)

  __pyx_t_2 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_origin); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 213, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_2);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_2);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_annotated_type};
    __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 213, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  __pyx_v_origin = __pyx_t_1;
  __pyx_t_1 = 0;

+214:     cdef tuple targs = get_args(annotated_type)

  __pyx_t_3 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 214, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    assert(__pyx_t_3);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
    __Pyx_INCREF(__pyx_t_3);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
    __pyx_t_4 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_annotated_type};
    __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 214, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  }
  if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(0, 214, __pyx_L1_error)
  __pyx_v_targs = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+215:     cdef object subtype_origin = None

  __Pyx_INCREF(Py_None);
  __pyx_v_subtype_origin = Py_None;

+216:     cdef list errors = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_errors = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

 217:     cdef dict sub_error

+218:     cdef tuple list_args = ()

  __Pyx_INCREF(__pyx_mstate_global->__pyx_empty_tuple);
  __pyx_v_list_args = __pyx_mstate_global->__pyx_empty_tuple;

+219:     cdef object inner_type = None

  __Pyx_INCREF(Py_None);
  __pyx_v_inner_type = Py_None;

+220:     cdef list item_errors = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_item_errors = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+221:     cdef tuple dict_args = ()

  __Pyx_INCREF(__pyx_mstate_global->__pyx_empty_tuple);
  __pyx_v_dict_args = __pyx_mstate_global->__pyx_empty_tuple;

+222:     cdef object key_type = None

  __Pyx_INCREF(Py_None);
  __pyx_v_key_type = Py_None;

+223:     cdef object val_type = None

  __Pyx_INCREF(Py_None);
  __pyx_v_val_type = Py_None;

 224: 

 225:     # 1) Handle Optional (Union[..., None]) if present

+226:     if type(None) in targs and value is None:

  __pyx_t_6 = (__Pyx_PySequence_ContainsTF(((PyObject *)Py_TYPE(Py_None)), __pyx_v_targs, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 226, __pyx_L1_error)
  if (__pyx_t_6) {

  } else {

    __pyx_t_5 = __pyx_t_6;

    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_6 = (__pyx_v_value == Py_None);

  __pyx_t_5 = __pyx_t_6;

  __pyx_L4_bool_binop_done:;
  if (__pyx_t_5) {
/* … */
  }

+227:         return {}  # Valid because it's None

    __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 227, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_1);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_1 = 0;
    goto __pyx_L0;

 228: 

 229:     # 2) Try each subtype in the Union

+230:     for subtype in targs:

  if (unlikely(__pyx_v_targs == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "\047NoneType\047 object is not iterable");
    __PYX_ERR(0, 230, __pyx_L1_error)
  }
  __pyx_t_1 = __pyx_v_targs; __Pyx_INCREF(__pyx_t_1);
  __pyx_t_7 = 0;
  for (;;) {
    {
      Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
      #if !CYTHON_ASSUME_SAFE_SIZE
      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 230, __pyx_L1_error)
      #endif
      if (__pyx_t_7 >= __pyx_temp) break;
    }
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7));
    #else
    __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7);
    #endif
    ++__pyx_t_7;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_XDECREF_SET(__pyx_v_subtype, __pyx_t_2);
    __pyx_t_2 = 0;
/* … */
    __pyx_L6_continue:;
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 231:         # Skip NoneType if it isn't our value

+232:         if subtype is type(None):

    __pyx_t_5 = (__pyx_v_subtype == ((PyObject *)Py_TYPE(Py_None)));
    if (__pyx_t_5) {
/* … */
    }

+233:             continue

      goto __pyx_L6_continue;

 234: 

+235:         subtype_origin = get_origin(subtype)

    __pyx_t_3 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_get_origin); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 235, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_4 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_8))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_8);
      assert(__pyx_t_3);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
      __pyx_t_4 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_subtype};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_DECREF_SET(__pyx_v_subtype_origin, __pyx_t_2);
    __pyx_t_2 = 0;

 236: 

+237:         try:

    {
      /*try:*/ {
/* … */
      }
      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
      goto __pyx_L16_try_end;
      __pyx_L9_error:;
      __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
      __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
/* … */
      __pyx_L11_except_error:;
      __Pyx_XGIVEREF(__pyx_t_9);
      __Pyx_XGIVEREF(__pyx_t_10);
      __Pyx_XGIVEREF(__pyx_t_11);
      __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
      goto __pyx_L1_error;
      __pyx_L13_try_return:;
      __Pyx_XGIVEREF(__pyx_t_9);
      __Pyx_XGIVEREF(__pyx_t_10);
      __Pyx_XGIVEREF(__pyx_t_11);
      __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
      goto __pyx_L0;
      __pyx_L10_exception_handled:;
      __Pyx_XGIVEREF(__pyx_t_9);
      __Pyx_XGIVEREF(__pyx_t_10);
      __Pyx_XGIVEREF(__pyx_t_11);
      __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
      __pyx_L16_try_end:;
    }

 238:             # 2a) If there's no origin, it's a simple or direct type (str, int, custom class, etc.)

+239:             if subtype_origin is None:

        __pyx_t_5 = (__pyx_v_subtype_origin == Py_None);
        if (__pyx_t_5) {
/* … */
          goto __pyx_L17;
        }

 240:                 # If it's just a normal type, check with isinstance

+241:                 if isinstance(value, subtype):

          __pyx_t_5 = PyObject_IsInstance(__pyx_v_value, __pyx_v_subtype); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 241, __pyx_L9_error)
          if (__pyx_t_5) {
/* … */
          }

 242:                     # PASS: we found a valid subtype

+243:                     return {}

            __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 243, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_2);
            {
              PyObject *__pyx_temp;
              {
                __pyx_temp = __pyx_r;
                __pyx_r = ((PyObject*)__pyx_t_2);
              }
              __Pyx_XDECREF(__pyx_temp);
            }
            __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            goto __pyx_L13_try_return;

 244:                 # Not matching? We'll record an error & continue

+245:                 errors.append(f"Value is not instance of {subtype}")

          __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_subtype, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 245, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_2);
          __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Value_is_not_instance_of, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 245, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_errors, __pyx_t_8); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 245, __pyx_L9_error)
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

 246: 

 247:             # 2b) If it's a nested Union, validate recursively

+248:             elif _is_union(subtype_origin):

        __pyx_t_5 = __pyx_f_9datamodel_10validation__is_union(__pyx_v_subtype_origin); if (unlikely(__pyx_t_5 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 248, __pyx_L9_error)
        if (__pyx_t_5) {
/* … */
          goto __pyx_L17;
        }

+249:                 sub_error = _validate_union_field(F, name, value, subtype)

          __pyx_t_8 = __pyx_f_9datamodel_10validation__validate_union_field(__pyx_v_F, __pyx_v_name, __pyx_v_value, __pyx_v_subtype); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 249, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_XDECREF_SET(__pyx_v_sub_error, ((PyObject*)__pyx_t_8));
          __pyx_t_8 = 0;

+250:                 if not sub_error:

          if (__pyx_v_sub_error == Py_None) __pyx_t_5 = 0;
          else
          {
            Py_ssize_t __pyx_temp = __Pyx_PyDict_GET_SIZE(__pyx_v_sub_error);
            if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 250, __pyx_L9_error)
            __pyx_t_5 = (__pyx_temp != 0);
          }

          __pyx_t_6 = (!__pyx_t_5);


          if (__pyx_t_6) {
/* … */
          }

+251:                     return {}  # success

            __pyx_t_8 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 251, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_8);
            {
              PyObject *__pyx_temp;
              {
                __pyx_temp = __pyx_r;
                __pyx_r = ((PyObject*)__pyx_t_8);
              }
              __Pyx_XDECREF(__pyx_temp);
            }
            __pyx_t_8 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            goto __pyx_L13_try_return;

+252:                 errors.append(f"Nested union check failed for {subtype}: {sub_error}")

          __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_subtype, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 252, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_sub_error, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 252, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_2);
          __pyx_t_13[0] = __pyx_mstate_global->__pyx_kp_u_Nested_union_check_failed_for;
          __pyx_t_13[1] = __pyx_t_8;
          __pyx_t_13[2] = __pyx_mstate_global->__pyx_kp_u__2;
          __pyx_t_13[3] = __pyx_t_2;
          __pyx_t_14 = 32;
          #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
          __pyx_t_14 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[3]);
          #endif
          __pyx_t_15 = 0;
          #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
          __pyx_t_15 |= __Pyx_PyUnicode_KIND_04(__pyx_t_13[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_13[3]);
          #endif
          __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_13, 4, __pyx_t_14, __pyx_t_15);
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
          __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_errors, __pyx_t_3); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 252, __pyx_L9_error)
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 253: 

 254:             # 2c) If it's a list origin, e.g. List[str]

+255:             elif subtype_origin is list:

        __pyx_t_6 = (__pyx_v_subtype_origin == ((PyObject *)(&PyList_Type)));
        if (__pyx_t_6) {
/* … */
          goto __pyx_L17;
        }

+256:                 list_args = get_args(subtype)

          __pyx_t_2 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_get_args); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 256, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_4 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_8))) {
            __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_8);
            assert(__pyx_t_2);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
            __Pyx_INCREF(__pyx_t_2);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
            __pyx_t_4 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_subtype};
            __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 256, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_3);
          }
          if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_3))) __PYX_ERR(0, 256, __pyx_L9_error)
          __Pyx_DECREF_SET(__pyx_v_list_args, ((PyObject*)__pyx_t_3));
          __pyx_t_3 = 0;

+257:                 if not isinstance(value, list):

          __pyx_t_6 = PyList_Check(__pyx_v_value); 
          __pyx_t_5 = (!__pyx_t_6);


          if (__pyx_t_5) {
/* … */
            goto __pyx_L20;
          }

+258:                     errors.append(f"Expected list, got {type(value).__name__}")

            __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 258, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_8);
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Expected_list_got, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_3);
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_errors, __pyx_t_3); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 258, __pyx_L9_error)
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 259:                 else:

 260:                     # Validate each item if you like (e.g. ensure each item is str)

+261:                     inner_type = list_args[0]

          /*else*/ {
            if (unlikely(__pyx_v_list_args == Py_None)) {
              PyErr_SetString(PyExc_TypeError, "\047NoneType\047 object is not subscriptable");
              __PYX_ERR(0, 261, __pyx_L9_error)
            }
            __pyx_t_3 = __Pyx_GetItemInt_Tuple(__pyx_v_list_args, 0, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 261, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_3);
            __Pyx_DECREF_SET(__pyx_v_inner_type, __pyx_t_3);
            __pyx_t_3 = 0;

+262:                     item_errors = []

            __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 262, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_3);
            __Pyx_DECREF_SET(__pyx_v_item_errors, ((PyObject*)__pyx_t_3));
            __pyx_t_3 = 0;

+263:                     for idx, item in enumerate(value):

            __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
            __pyx_t_3 = __pyx_mstate_global->__pyx_int_0;
            if (likely(PyList_CheckExact(__pyx_v_value)) || PyTuple_CheckExact(__pyx_v_value)) {
              __pyx_t_8 = __pyx_v_value; __Pyx_INCREF(__pyx_t_8);
              __pyx_t_14 = 0;
              __pyx_t_16 = NULL;
            } else {
              __pyx_t_14 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_v_value); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 263, __pyx_L9_error)
              __Pyx_GOTREF(__pyx_t_8);
              __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 263, __pyx_L9_error)
            }
            for (;;) {
              if (likely(!__pyx_t_16)) {
                if (likely(PyList_CheckExact(__pyx_t_8))) {
                  {
                    Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_8);
                    #if !CYTHON_ASSUME_SAFE_SIZE
                    if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 263, __pyx_L9_error)
                    #endif
                    if (__pyx_t_14 >= __pyx_temp) break;
                  }
                  __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_8, __pyx_t_14, __Pyx_ReferenceSharing_OwnStrongReference);
                  ++__pyx_t_14;
                } else {
                  {
                    Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_8);
                    #if !CYTHON_ASSUME_SAFE_SIZE
                    if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 263, __pyx_L9_error)
                    #endif
                    if (__pyx_t_14 >= __pyx_temp) break;
                  }
                  #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                  __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_14));
                  #else
                  __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_8, __pyx_t_14);
                  #endif
                  ++__pyx_t_14;
                }
                if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 263, __pyx_L9_error)
              } else {
                __pyx_t_2 = __pyx_t_16(__pyx_t_8);
                if (unlikely(!__pyx_t_2)) {
                  PyObject* exc_type = PyErr_Occurred();
                  if (exc_type) {
                    if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 263, __pyx_L9_error)
                    PyErr_Clear();
                  }
                  break;
                }
              }
              __Pyx_GOTREF(__pyx_t_2);
              __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_2);
              __pyx_t_2 = 0;
              __Pyx_INCREF(__pyx_t_3);
              __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3);
              __pyx_t_2 = __Pyx_PyLong_AddObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 263, __pyx_L9_error)
              __Pyx_GOTREF(__pyx_t_2);
              __Pyx_DECREF(__pyx_t_3);
              __pyx_t_3 = __pyx_t_2;
              __pyx_t_2 = 0;
/* … */
            }
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 264:                         # For simple inner type

+265:                         if get_origin(inner_type) is None:

              __pyx_t_17 = NULL;
              __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_get_origin); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 265, __pyx_L9_error)
              __Pyx_GOTREF(__pyx_t_18);
              __pyx_t_4 = 1;
              #if CYTHON_UNPACK_METHODS
              if (unlikely(PyMethod_Check(__pyx_t_18))) {
                __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_18);
                assert(__pyx_t_17);
                PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_18);
                __Pyx_INCREF(__pyx_t_17);
                __Pyx_INCREF(__pyx__function);
                __Pyx_DECREF_SET(__pyx_t_18, __pyx__function);
                __pyx_t_4 = 0;
              }
              #endif
              {
                PyObject *__pyx_callargs[2] = {__pyx_t_17, __pyx_v_inner_type};
                __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_18, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
                __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 265, __pyx_L9_error)
                __Pyx_GOTREF(__pyx_t_2);
              }
              __pyx_t_5 = (__pyx_t_2 == Py_None);
              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
              if (__pyx_t_5) {
/* … */
                goto __pyx_L23;
              }

+266:                             if not isinstance(item, inner_type):

                __pyx_t_5 = PyObject_IsInstance(__pyx_v_item, __pyx_v_inner_type); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 266, __pyx_L9_error)
                __pyx_t_6 = (!__pyx_t_5);


                if (__pyx_t_6) {
/* … */
                }

+267:                                 item_errors.append(f"Index {idx}: {type(item).__name__} != {inner_type}")

                  __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_idx, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 267, __pyx_L9_error)
                  __Pyx_GOTREF(__pyx_t_2);
                  __pyx_t_18 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_item)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 267, __pyx_L9_error)
                  __Pyx_GOTREF(__pyx_t_18);
                  __pyx_t_17 = __Pyx_PyObject_FormatSimple(__pyx_t_18, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 267, __pyx_L9_error)
                  __Pyx_GOTREF(__pyx_t_17);
                  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                  __pyx_t_18 = __Pyx_PyObject_FormatSimple(__pyx_v_inner_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 267, __pyx_L9_error)
                  __Pyx_GOTREF(__pyx_t_18);
                  __pyx_t_19[0] = __pyx_mstate_global->__pyx_kp_u_Index;
                  __pyx_t_19[1] = __pyx_t_2;
                  __pyx_t_19[2] = __pyx_mstate_global->__pyx_kp_u__2;
                  __pyx_t_19[3] = __pyx_t_17;
                  __pyx_t_19[4] = __pyx_mstate_global->__pyx_kp_u__3;
                  __pyx_t_19[5] = __pyx_t_18;
                  __pyx_t_20 = 12;
                  #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
                  __pyx_t_20 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_19[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_19[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_19[5]);
                  #endif
                  __pyx_t_15 = 0;
                  #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
                  __pyx_t_15 |= __Pyx_PyUnicode_KIND_04(__pyx_t_19[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_19[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_19[5]);
                  #endif
                  __pyx_t_21 = __Pyx_PyUnicode_Join(__pyx_t_19, 6, __pyx_t_20, __pyx_t_15);
                  if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 267, __pyx_L9_error)
                  __Pyx_GOTREF(__pyx_t_21);
                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
                  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
                  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                  __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_item_errors, __pyx_t_21); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 267, __pyx_L9_error)
                  __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;

 268:                         else:

 269:                             # Possibly nested structure again

+270:                             sub_error = _validate_union_field(F, f"{name}[{idx}]", item, inner_type)

              /*else*/ {
                __pyx_t_21 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 270, __pyx_L9_error)
                __Pyx_GOTREF(__pyx_t_21);
                __pyx_t_18 = __Pyx_PyObject_FormatSimple(__pyx_v_idx, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 270, __pyx_L9_error)
                __Pyx_GOTREF(__pyx_t_18);
                __pyx_t_13[0] = __pyx_t_21;
                __pyx_t_13[1] = __pyx_mstate_global->__pyx_kp_u__4;
                __pyx_t_13[2] = __pyx_t_18;
                __pyx_t_13[3] = __pyx_mstate_global->__pyx_kp_u__5;
                __pyx_t_20 = 2;
                #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
                __pyx_t_20 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[0]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[2]);
                #endif
                __pyx_t_15 = 0;
                #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
                __pyx_t_15 |= __Pyx_PyUnicode_KIND_04(__pyx_t_13[0]) | __Pyx_PyUnicode_KIND_04(__pyx_t_13[2]);
                #endif
                __pyx_t_17 = __Pyx_PyUnicode_Join(__pyx_t_13, 4, __pyx_t_20, __pyx_t_15);
                if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 270, __pyx_L9_error)
                __Pyx_GOTREF(__pyx_t_17);
                __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                __pyx_t_18 = __pyx_f_9datamodel_10validation__validate_union_field(__pyx_v_F, ((PyObject*)__pyx_t_17), __pyx_v_item, __pyx_v_inner_type); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 270, __pyx_L9_error)
                __Pyx_GOTREF(__pyx_t_18);
                __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
                __Pyx_XDECREF_SET(__pyx_v_sub_error, ((PyObject*)__pyx_t_18));
                __pyx_t_18 = 0;

+271:                             if sub_error:

                if (__pyx_v_sub_error == Py_None) __pyx_t_6 = 0;
                else
                {
                  Py_ssize_t __pyx_temp = __Pyx_PyDict_GET_SIZE(__pyx_v_sub_error);
                  if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 271, __pyx_L9_error)
                  __pyx_t_6 = (__pyx_temp != 0);
                }

                if (__pyx_t_6) {
/* … */
                }
              }
              __pyx_L23:;

+272:                                 item_errors.append(str(sub_error))

                  __pyx_t_18 = __Pyx_PyObject_Unicode(__pyx_v_sub_error); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 272, __pyx_L9_error)
                  __Pyx_GOTREF(__pyx_t_18);
                  __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_item_errors, __pyx_t_18); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 272, __pyx_L9_error)
                  __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;

+273:                     if not item_errors:

            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_v_item_errors);
              if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 273, __pyx_L9_error)
              __pyx_t_6 = (__pyx_temp != 0);
            }

            __pyx_t_5 = (!__pyx_t_6);


            if (__pyx_t_5) {
/* … */
            }

+274:                         return {}  # All items validated

              __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L9_error)
              __Pyx_GOTREF(__pyx_t_3);
              {
                PyObject *__pyx_temp;
                {
                  __pyx_temp = __pyx_r;
                  __pyx_r = ((PyObject*)__pyx_t_3);
                }
                __Pyx_XDECREF(__pyx_temp);
              }
              __pyx_t_3 = 0;
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
              goto __pyx_L13_try_return;

+275:                     errors.append(f"List item errors: {item_errors}")

            __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_item_errors, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 275, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_List_item_errors, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 275, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_8);
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_errors, __pyx_t_8); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 275, __pyx_L9_error)
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

          }
          __pyx_L20:;

 276: 

 277:             # 2d) If it's a dict origin, e.g. Dict[str, int] or Dict[str, Union[int, ...]]

+278:             elif subtype_origin is dict:

        __pyx_t_5 = (__pyx_v_subtype_origin == ((PyObject *)(&PyDict_Type)));
        if (__pyx_t_5) {
/* … */
          goto __pyx_L17;
        }

+279:                 dict_args = get_args(subtype)  # (key_type, value_type)

          __pyx_t_3 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_get_args); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 279, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_18);
          __pyx_t_4 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_18))) {
            __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_18);
            assert(__pyx_t_3);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_18);
            __Pyx_INCREF(__pyx_t_3);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_18, __pyx__function);
            __pyx_t_4 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_subtype};
            __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_18, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 279, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_8);
          }
          if (!(likely(PyTuple_CheckExact(__pyx_t_8))||((__pyx_t_8) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_8))) __PYX_ERR(0, 279, __pyx_L9_error)
          __Pyx_DECREF_SET(__pyx_v_dict_args, ((PyObject*)__pyx_t_8));
          __pyx_t_8 = 0;

+280:                 key_type = dict_args[0]

          if (unlikely(__pyx_v_dict_args == Py_None)) {
            PyErr_SetString(PyExc_TypeError, "\047NoneType\047 object is not subscriptable");
            __PYX_ERR(0, 280, __pyx_L9_error)
          }
          __pyx_t_8 = __Pyx_GetItemInt_Tuple(__pyx_v_dict_args, 0, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 280, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF_SET(__pyx_v_key_type, __pyx_t_8);
          __pyx_t_8 = 0;

+281:                 val_type = dict_args[1]

          if (unlikely(__pyx_v_dict_args == Py_None)) {
            PyErr_SetString(PyExc_TypeError, "\047NoneType\047 object is not subscriptable");
            __PYX_ERR(0, 281, __pyx_L9_error)
          }
          __pyx_t_8 = __Pyx_GetItemInt_Tuple(__pyx_v_dict_args, 1, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 281, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF_SET(__pyx_v_val_type, __pyx_t_8);
          __pyx_t_8 = 0;

+282:                 if not isinstance(value, dict):

          __pyx_t_5 = PyDict_Check(__pyx_v_value); 
          __pyx_t_6 = (!__pyx_t_5);


          if (__pyx_t_6) {
/* … */
            goto __pyx_L28;
          }

+283:                     errors.append(f"Expected dict, got {type(value).__name__}")

            __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 283, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_8);
            __pyx_t_18 = __Pyx_PyObject_FormatSimple(__pyx_t_8, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 283, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_18);
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Expected_dict_got, __pyx_t_18); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 283, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_8);
            __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
            __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_errors, __pyx_t_8); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 283, __pyx_L9_error)
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

 284:                 else:

+285:                     dict_errors = []

          /*else*/ {
            __pyx_t_8 = PyList_New(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 285, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_8);
            __Pyx_XDECREF_SET(__pyx_v_dict_errors, ((PyObject*)__pyx_t_8));
            __pyx_t_8 = 0;

 286:                     # Validate each key, value

+287:                     for k, v in value.items():

            __pyx_t_14 = 0;
            if (unlikely(__pyx_v_value == Py_None)) {
              PyErr_Format(PyExc_AttributeError, "\047NoneType\047 object has no attribute \047%.30s\047", "items");
              __PYX_ERR(0, 287, __pyx_L9_error)
            }
            __pyx_t_18 = __Pyx_dict_iterator(__pyx_v_value, 0, __pyx_mstate_global->__pyx_n_u_items, (&__pyx_t_20), (&__pyx_t_15)); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 287, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_18);
            __Pyx_XDECREF(__pyx_t_8);
            __pyx_t_8 = __pyx_t_18;
            __pyx_t_18 = 0;
            while (1) {
              __pyx_t_22 = __Pyx_dict_iter_next(__pyx_t_8, __pyx_t_20, &__pyx_t_14, &__pyx_t_18, &__pyx_t_3, NULL, __pyx_t_15);
              if (unlikely(__pyx_t_22 == 0)) break;
              if (unlikely(__pyx_t_22 == -1)) __PYX_ERR(0, 287, __pyx_L9_error)
              __Pyx_GOTREF(__pyx_t_18);
              __Pyx_GOTREF(__pyx_t_3);
              __Pyx_XDECREF_SET(__pyx_v_k, __pyx_t_18);
              __pyx_t_18 = 0;
              __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_3);
              __pyx_t_3 = 0;

 288:                         # Check key

+289:                         if not isinstance(k, key_type):

              __pyx_t_6 = PyObject_IsInstance(__pyx_v_k, __pyx_v_key_type); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 289, __pyx_L9_error)
              __pyx_t_5 = (!__pyx_t_6);


              if (__pyx_t_5) {
/* … */
              }

+290:                             dict_errors.append(f"Key {k!r} type mismatch; expected {key_type}")

                __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_k), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 290, __pyx_L9_error)
                __Pyx_GOTREF(__pyx_t_3);
                __pyx_t_18 = __Pyx_PyObject_FormatSimple(__pyx_v_key_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 290, __pyx_L9_error)
                __Pyx_GOTREF(__pyx_t_18);
                __pyx_t_13[0] = __pyx_mstate_global->__pyx_kp_u_Key;
                __pyx_t_13[1] = __pyx_t_3;
                __pyx_t_13[2] = __pyx_mstate_global->__pyx_kp_u_type_mismatch_expected;
                __pyx_t_13[3] = __pyx_t_18;
                __pyx_t_23 = 29;
                #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
                __pyx_t_23 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[3]);
                #endif
                __pyx_t_22 = 0;
                #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
                __pyx_t_22 |= __Pyx_PyUnicode_KIND_04(__pyx_t_13[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_13[3]);
                #endif
                __pyx_t_17 = __Pyx_PyUnicode_Join(__pyx_t_13, 4, __pyx_t_23, __pyx_t_22);
                if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 290, __pyx_L9_error)
                __Pyx_GOTREF(__pyx_t_17);
                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_dict_errors, __pyx_t_17); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 290, __pyx_L9_error)
                __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

 291:                         # Then check value

+292:                         sub_error = _validate_union_field(F, f'{name}[\"{k}\"]', v, val_type)

              __pyx_t_17 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 292, __pyx_L9_error)
              __Pyx_GOTREF(__pyx_t_17);
              __pyx_t_18 = __Pyx_PyObject_FormatSimple(__pyx_v_k, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 292, __pyx_L9_error)
              __Pyx_GOTREF(__pyx_t_18);
              __pyx_t_13[0] = __pyx_t_17;
              __pyx_t_13[1] = __pyx_mstate_global->__pyx_kp_u__6;
              __pyx_t_13[2] = __pyx_t_18;
              __pyx_t_13[3] = __pyx_mstate_global->__pyx_kp_u__7;
              __pyx_t_23 = 4;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_23 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[0]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[2]);
              #endif
              __pyx_t_22 = 0;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_22 |= __Pyx_PyUnicode_KIND_04(__pyx_t_13[0]) | __Pyx_PyUnicode_KIND_04(__pyx_t_13[2]);
              #endif
              __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_13, 4, __pyx_t_23, __pyx_t_22);
              if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 292, __pyx_L9_error)
              __Pyx_GOTREF(__pyx_t_3);
              __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
              __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
              __pyx_t_18 = __pyx_f_9datamodel_10validation__validate_union_field(__pyx_v_F, ((PyObject*)__pyx_t_3), __pyx_v_v, __pyx_v_val_type); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 292, __pyx_L9_error)
              __Pyx_GOTREF(__pyx_t_18);
              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
              __Pyx_XDECREF_SET(__pyx_v_sub_error, ((PyObject*)__pyx_t_18));
              __pyx_t_18 = 0;

+293:                         if sub_error:

              if (__pyx_v_sub_error == Py_None) __pyx_t_5 = 0;
              else
              {
                Py_ssize_t __pyx_temp = __Pyx_PyDict_GET_SIZE(__pyx_v_sub_error);
                if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 293, __pyx_L9_error)
                __pyx_t_5 = (__pyx_temp != 0);
              }

              if (__pyx_t_5) {
/* … */
              }
            }
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

+294:                             dict_errors.append(f"For key={k}: {sub_error}")

                __pyx_t_18 = __Pyx_PyObject_FormatSimple(__pyx_v_k, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 294, __pyx_L9_error)
                __Pyx_GOTREF(__pyx_t_18);
                __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_sub_error, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L9_error)
                __Pyx_GOTREF(__pyx_t_3);
                __pyx_t_13[0] = __pyx_mstate_global->__pyx_kp_u_For_key;
                __pyx_t_13[1] = __pyx_t_18;
                __pyx_t_13[2] = __pyx_mstate_global->__pyx_kp_u__2;
                __pyx_t_13[3] = __pyx_t_3;
                __pyx_t_23 = 10;
                #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
                __pyx_t_23 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[3]);
                #endif
                __pyx_t_22 = 0;
                #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
                __pyx_t_22 |= __Pyx_PyUnicode_KIND_04(__pyx_t_13[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_13[3]);
                #endif
                __pyx_t_17 = __Pyx_PyUnicode_Join(__pyx_t_13, 4, __pyx_t_23, __pyx_t_22);
                if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 294, __pyx_L9_error)
                __Pyx_GOTREF(__pyx_t_17);
                __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
                __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_dict_errors, __pyx_t_17); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 294, __pyx_L9_error)
                __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

+295:                     if not dict_errors:

            {
              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_v_dict_errors);
              if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 295, __pyx_L9_error)
              __pyx_t_5 = (__pyx_temp != 0);
            }

            __pyx_t_6 = (!__pyx_t_5);


            if (__pyx_t_6) {
/* … */
            }

+296:                         return {}  # success

              __pyx_t_8 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 296, __pyx_L9_error)
              __Pyx_GOTREF(__pyx_t_8);
              {
                PyObject *__pyx_temp;
                {
                  __pyx_temp = __pyx_r;
                  __pyx_r = ((PyObject*)__pyx_t_8);
                }
                __Pyx_XDECREF(__pyx_temp);
              }
              __pyx_t_8 = 0;
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
              goto __pyx_L13_try_return;

+297:                     errors.append(f"Dict item errors: {dict_errors}")

            __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_dict_errors, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 297, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_8);
            __pyx_t_17 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Dict_item_errors, __pyx_t_8); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 297, __pyx_L9_error)
            __Pyx_GOTREF(__pyx_t_17);
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_errors, __pyx_t_17); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 297, __pyx_L9_error)
            __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

          }
          __pyx_L28:;

 298: 

 299:             else:

 300:                 # If you have other complex type origins (tuple, etc.), handle them similarly

+301:                 errors.append(f"Unhandled type origin: {subtype_origin} for subtype={subtype}")

        /*else*/ {
          __pyx_t_17 = __Pyx_PyObject_FormatSimple(__pyx_v_subtype_origin, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 301, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_17);
          __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_subtype, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 301, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_13[0] = __pyx_mstate_global->__pyx_kp_u_Unhandled_type_origin;
          __pyx_t_13[1] = __pyx_t_17;
          __pyx_t_13[2] = __pyx_mstate_global->__pyx_kp_u_for_subtype;
          __pyx_t_13[3] = __pyx_t_8;
          __pyx_t_20 = 36;
          #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
          __pyx_t_20 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[3]);
          #endif
          __pyx_t_15 = 0;
          #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
          __pyx_t_15 |= __Pyx_PyUnicode_KIND_04(__pyx_t_13[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_13[3]);
          #endif
          __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_13, 4, __pyx_t_20, __pyx_t_15);
          if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L9_error)
          __Pyx_GOTREF(__pyx_t_3);
          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_errors, __pyx_t_3); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 301, __pyx_L9_error)
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

        }
        __pyx_L17:;

 302: 

+303:         except Exception as exc:

      __pyx_t_15 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception))));
      if (__pyx_t_15) {
        __Pyx_AddTraceback("datamodel.validation._validate_union_field", __pyx_clineno, __pyx_lineno, __pyx_filename);
        if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_8, &__pyx_t_17) < 0) __PYX_ERR(0, 303, __pyx_L11_except_error)
        __Pyx_XGOTREF(__pyx_t_3);
        __Pyx_XGOTREF(__pyx_t_8);
        __Pyx_XGOTREF(__pyx_t_17);
        __Pyx_INCREF(__pyx_t_8);
        __pyx_v_exc = __pyx_t_8;
        /*try:*/ {
/* … */
        /*finally:*/ {
          /*normal exit:*/{
            __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0;
            goto __pyx_L40;
          }
          __pyx_L39_error:;
          /*exception exit:*/{
            __Pyx_PyThreadState_declare
            __Pyx_PyThreadState_assign
            __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0; __pyx_t_29 = 0; __pyx_t_30 = 0;
            __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
            __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
             __Pyx_ExceptionSwap(&__pyx_t_28, &__pyx_t_29, &__pyx_t_30);
            if ( unlikely(__Pyx_GetException(&__pyx_t_25, &__pyx_t_26, &__pyx_t_27) < 0)) __Pyx_ErrFetch(&__pyx_t_25, &__pyx_t_26, &__pyx_t_27);
            __Pyx_XGOTREF(__pyx_t_25);
            __Pyx_XGOTREF(__pyx_t_26);
            __Pyx_XGOTREF(__pyx_t_27);
            __Pyx_XGOTREF(__pyx_t_28);
            __Pyx_XGOTREF(__pyx_t_29);
            __Pyx_XGOTREF(__pyx_t_30);
            __pyx_t_15 = __pyx_lineno; __pyx_t_22 = __pyx_clineno; __pyx_t_24 = __pyx_filename;
            {
              __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = 0;
            }
            __Pyx_XGIVEREF(__pyx_t_28);
            __Pyx_XGIVEREF(__pyx_t_29);
            __Pyx_XGIVEREF(__pyx_t_30);
            __Pyx_ExceptionReset(__pyx_t_28, __pyx_t_29, __pyx_t_30);
            __Pyx_XGIVEREF(__pyx_t_25);
            __Pyx_XGIVEREF(__pyx_t_26);
            __Pyx_XGIVEREF(__pyx_t_27);
            __Pyx_ErrRestore(__pyx_t_25, __pyx_t_26, __pyx_t_27);
            __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0; __pyx_t_29 = 0; __pyx_t_30 = 0;
            __pyx_lineno = __pyx_t_15; __pyx_clineno = __pyx_t_22; __pyx_filename = __pyx_t_24;
            goto __pyx_L11_except_error;
          }
          __pyx_L40:;
        }
        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
        goto __pyx_L10_exception_handled;
      }
      goto __pyx_L11_except_error;

+304:             errors.append(f"Exception in subtype {subtype}: {exc}")

          __pyx_t_18 = __Pyx_PyObject_FormatSimple(__pyx_v_subtype, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 304, __pyx_L39_error)
          __Pyx_GOTREF(__pyx_t_18);
          __pyx_t_21 = __Pyx_PyObject_FormatSimple(__pyx_v_exc, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 304, __pyx_L39_error)
          __Pyx_GOTREF(__pyx_t_21);
          __pyx_t_13[0] = __pyx_mstate_global->__pyx_kp_u_Exception_in_subtype;
          __pyx_t_13[1] = __pyx_t_18;
          __pyx_t_13[2] = __pyx_mstate_global->__pyx_kp_u__2;
          __pyx_t_13[3] = __pyx_t_21;
          __pyx_t_20 = 23;
          #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
          __pyx_t_20 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[3]);
          #endif
          __pyx_t_15 = 0;
          #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
          __pyx_t_15 |= __Pyx_PyUnicode_KIND_04(__pyx_t_13[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_13[3]);
          #endif
          __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_13, 4, __pyx_t_20, __pyx_t_15);
          if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 304, __pyx_L39_error)
          __Pyx_GOTREF(__pyx_t_2);
          __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
          __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
          __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_errors, __pyx_t_2); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 304, __pyx_L39_error)
          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

        }

 305: 

 306:     # 3) If no subtype matched, create an error record

+307:     return _create_error(

  __pyx_t_31.__pyx_n = 1;
  __pyx_t_31.exception = __pyx_v_errors;
  __pyx_t_8 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_3, ((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_v_annotated_type, &__pyx_t_31); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 307, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)__pyx_t_8);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  __pyx_t_8 = 0;
  goto __pyx_L0;

 308:         name,

 309:         value,

+310:         f"Invalid type for {annotated_type}.{name}, expected one of {targs}",

  __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 310, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_17 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 310, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_17);
  __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_targs, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 310, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_19[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_for;
  __pyx_t_19[1] = __pyx_t_1;
  __pyx_t_19[2] = __pyx_mstate_global->__pyx_kp_u__8;
  __pyx_t_19[3] = __pyx_t_17;
  __pyx_t_19[4] = __pyx_mstate_global->__pyx_kp_u_expected_one_of;
  __pyx_t_19[5] = __pyx_t_8;
  __pyx_t_7 = 36;
  #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
  __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_19[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_19[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_19[5]);
  #endif
  __pyx_t_22 = 0;
  #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
  __pyx_t_22 |= __Pyx_PyUnicode_KIND_04(__pyx_t_19[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_19[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_19[5]);
  #endif
  __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_19, 6, __pyx_t_7, __pyx_t_22);
  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 310, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

 311:         type(value),

 312:         annotated_type,

 313:         errors

 314:     )

 315: 

+316: cdef dict _validate_constraints(

static PyObject *__pyx_f_9datamodel_10validation__validate_constraints(PyObject *__pyx_v_field, PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_annotated_type, PyObject *__pyx_v_val_type) {
  PyObject *__pyx_v_length = 0;
  PyObject *__pyx_v_min_length = 0;
  PyObject *__pyx_v_max_length = 0;
  PyObject *__pyx_v_min_val = 0;
  PyObject *__pyx_v_max_val = 0;
  PyObject *__pyx_v_ge_val = 0;
  PyObject *__pyx_v_le_val = 0;
  PyObject *__pyx_v_eq_val = 0;
  PyObject *__pyx_v_ne_val = 0;
  PyObject *__pyx_v_pattern = 0;
  PyObject *__pyx_v_metadata = NULL;
  CYTHON_UNUSED PyObject *__pyx_v_error = NULL;
  PyObject *__pyx_v_re = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("datamodel.validation._validate_constraints", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_length);
  __Pyx_XDECREF(__pyx_v_min_length);
  __Pyx_XDECREF(__pyx_v_max_length);
  __Pyx_XDECREF(__pyx_v_min_val);
  __Pyx_XDECREF(__pyx_v_max_val);
  __Pyx_XDECREF(__pyx_v_ge_val);
  __Pyx_XDECREF(__pyx_v_le_val);
  __Pyx_XDECREF(__pyx_v_eq_val);
  __Pyx_XDECREF(__pyx_v_ne_val);
  __Pyx_XDECREF(__pyx_v_pattern);
  __Pyx_XDECREF(__pyx_v_metadata);
  __Pyx_XDECREF(__pyx_v_error);
  __Pyx_XDECREF(__pyx_v_re);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 317:     object field,

 318:     str name,

 319:     object value,

 320:     object annotated_type,

 321:     object val_type

 322: ):

 323:     """

 324:     Validates primitive field constraints based on field metadata.

 325: 

 326:     Handles the following validations:

 327:     - For strings: length, min_length, max_length

 328:     - For numbers: min, max, gt, lt, ge, le, eq

 329: 

 330:     Args:

 331:         field: The Field object

 332:         name: Field name

 333:         value: The value to validate

 334:         annotated_type: The annotated type

 335:         val_type: The actual value type

 336: 

 337:     Returns:

 338:         Empty dict if validation passes, error dict otherwise

 339:     """

 340:     # string comparisons

+341:     cdef object length = None

  __Pyx_INCREF(Py_None);
  __pyx_v_length = Py_None;

+342:     cdef object min_length = None

  __Pyx_INCREF(Py_None);
  __pyx_v_min_length = Py_None;

+343:     cdef object max_length = None

  __Pyx_INCREF(Py_None);
  __pyx_v_max_length = Py_None;

 344:     # integer/float comparisons

+345:     cdef object min_val = None

  __Pyx_INCREF(Py_None);
  __pyx_v_min_val = Py_None;

+346:     cdef object max_val = None

  __Pyx_INCREF(Py_None);
  __pyx_v_max_val = Py_None;

+347:     cdef object ge_val = None

  __Pyx_INCREF(Py_None);
  __pyx_v_ge_val = Py_None;

+348:     cdef object le_val = None

  __Pyx_INCREF(Py_None);
  __pyx_v_le_val = Py_None;

+349:     cdef object eq_val = None

  __Pyx_INCREF(Py_None);
  __pyx_v_eq_val = Py_None;

+350:     cdef object ne_val = None

  __Pyx_INCREF(Py_None);
  __pyx_v_ne_val = Py_None;

+351:     cdef object pattern = None

  __Pyx_INCREF(Py_None);
  __pyx_v_pattern = Py_None;

 352:     # Skip validation if value is None

+353:     if value is None:

  __pyx_t_1 = (__pyx_v_value == Py_None);
  if (__pyx_t_1) {
/* … */
  }

+354:         return {}

    __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 354, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_2);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_2 = 0;
    goto __pyx_L0;

 355: 

+356:     metadata = field.metadata

  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_field, __pyx_mstate_global->__pyx_n_u_metadata); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 356, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_metadata = __pyx_t_2;
  __pyx_t_2 = 0;

+357:     error = {}

  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 357, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_v_error = ((PyObject*)__pyx_t_2);
  __pyx_t_2 = 0;

 358: 

 359:     # String validations

+360:     if annotated_type is str:

  __pyx_t_1 = (__pyx_v_annotated_type == ((PyObject *)(&PyUnicode_Type)));
  if (__pyx_t_1) {
/* … */
    goto __pyx_L4;
  }

+361:         length = metadata.get('length', None)

    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_metadata, __pyx_mstate_global->__pyx_n_u_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 361, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[1], NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 361, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF_SET(__pyx_v_length, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  {
    PyObject* __pyx_temp[2] = {__pyx_mstate_global->__pyx_n_u_length, Py_None};
    __pyx_mstate_global->__pyx_tuple[1] = __Pyx_PyTuple_FromArray(__pyx_temp, 2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[1])) __PYX_ERR(0, 361, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[1]);
  }
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[1]);

+362:         min_length = metadata.get('min_length', None)

    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_metadata, __pyx_mstate_global->__pyx_n_u_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 362, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[2], NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 362, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF_SET(__pyx_v_min_length, __pyx_t_2);
    __pyx_t_2 = 0;
/* … */
  {
    PyObject* __pyx_temp[2] = {__pyx_mstate_global->__pyx_n_u_min_length, Py_None};
    __pyx_mstate_global->__pyx_tuple[2] = __Pyx_PyTuple_FromArray(__pyx_temp, 2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(0, 362, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]);
  }
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]);

+363:         max_length = metadata.get('max_length', None)

    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_metadata, __pyx_mstate_global->__pyx_n_u_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 363, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[3], NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 363, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF_SET(__pyx_v_max_length, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  {
    PyObject* __pyx_temp[2] = {__pyx_mstate_global->__pyx_n_u_max_length, Py_None};
    __pyx_mstate_global->__pyx_tuple[3] = __Pyx_PyTuple_FromArray(__pyx_temp, 2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[3])) __PYX_ERR(0, 363, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[3]);
  }
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[3]);

+364:         pattern = metadata.get('pattern', getattr(field, '_pattern', None))

    __pyx_t_2 = __pyx_v_metadata;
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_4 = __Pyx_GetAttr3(__pyx_v_field, __pyx_mstate_global->__pyx_n_u_pattern_2, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 364, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_mstate_global->__pyx_n_u_pattern, __pyx_t_4};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 364, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_DECREF_SET(__pyx_v_pattern, __pyx_t_3);
    __pyx_t_3 = 0;

 365:         # Length validation

+366:         if length is not None and len(value) != length:

    __pyx_t_6 = (__pyx_v_length != Py_None);
    if (__pyx_t_6) {

    } else {

      __pyx_t_1 = __pyx_t_6;

      goto __pyx_L6_bool_binop_done;
    }
    __pyx_t_7 = PyObject_Length(__pyx_v_value); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 366, __pyx_L1_error)
    __pyx_t_3 = PyLong_FromSsize_t(__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 366, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);

    __pyx_t_6 = __Pyx_PyObject_CompareBoolNe_int_object(__pyx_t_3, __pyx_v_length, Py_NE); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 366, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

    __pyx_t_1 = __pyx_t_6;

    __pyx_L6_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+367:             return _create_error(

      __pyx_t_4 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_2, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 367, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_4);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_4 = 0;
      goto __pyx_L0;

 368:                 name,

 369:                 value,

+370:                 f"String length must be exactly {length} characters, got {len(value)}",

      __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_length, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 370, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_7 = PyObject_Length(__pyx_v_value); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 370, __pyx_L1_error)
      __pyx_t_4 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_7, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 370, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);

      __pyx_t_8[0] = __pyx_mstate_global->__pyx_kp_u_String_length_must_be_exactly;
      __pyx_t_8[1] = __pyx_t_3;
      __pyx_t_8[2] = __pyx_mstate_global->__pyx_kp_u_characters_got;
      __pyx_t_8[3] = __pyx_t_4;
      __pyx_t_7 = 47;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8[3]);
      #endif
      __pyx_t_9 = 0;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_8[1]);
      #endif
      __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_8, 4, __pyx_t_7, __pyx_t_9);
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 370, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 371:                 val_type,

 372:                 annotated_type

 373:             )

 374: 

 375:         # Min length validation

+376:         if min_length is not None and len(value) < min_length:

    __pyx_t_6 = (__pyx_v_min_length != Py_None);
    if (__pyx_t_6) {

    } else {

      __pyx_t_1 = __pyx_t_6;

      goto __pyx_L9_bool_binop_done;
    }
    __pyx_t_7 = PyObject_Length(__pyx_v_value); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 376, __pyx_L1_error)
    __pyx_t_4 = PyLong_FromSsize_t(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 376, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);

    __pyx_t_6 = __Pyx_PyObject_CompareBoolLt_int_object(__pyx_t_4, __pyx_v_min_length, Py_LT); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 376, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

    __pyx_t_1 = __pyx_t_6;

    __pyx_L9_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+377:             return _create_error(

      __pyx_t_2 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_3, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 377, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_2);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_2 = 0;
      goto __pyx_L0;

 378:                 name,

 379:                 value,

+380:                 f"String length must be at least {min_length} characters, got {len(value)}",

      __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_min_length, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 380, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_7 = PyObject_Length(__pyx_v_value); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 380, __pyx_L1_error)
      __pyx_t_2 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_7, 0, ' ', 'd'); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 380, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);

      __pyx_t_8[0] = __pyx_mstate_global->__pyx_kp_u_String_length_must_be_at_least;
      __pyx_t_8[1] = __pyx_t_4;
      __pyx_t_8[2] = __pyx_mstate_global->__pyx_kp_u_characters_got;
      __pyx_t_8[3] = __pyx_t_2;
      __pyx_t_7 = 48;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8[3]);
      #endif
      __pyx_t_9 = 0;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_8[1]);
      #endif
      __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 4, __pyx_t_7, __pyx_t_9);
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 380, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

 381:                 val_type,

 382:                 annotated_type

 383:             )

 384: 

 385:         # Max length validation

+386:         if max_length is not None and len(value) > max_length:

    __pyx_t_6 = (__pyx_v_max_length != Py_None);
    if (__pyx_t_6) {

    } else {

      __pyx_t_1 = __pyx_t_6;

      goto __pyx_L12_bool_binop_done;
    }
    __pyx_t_7 = PyObject_Length(__pyx_v_value); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 386, __pyx_L1_error)
    __pyx_t_2 = PyLong_FromSsize_t(__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 386, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);

    __pyx_t_6 = __Pyx_PyObject_CompareBoolGt_int_object(__pyx_t_2, __pyx_v_max_length, Py_GT); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 386, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

    __pyx_t_1 = __pyx_t_6;

    __pyx_L12_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+387:             return _create_error(

      __pyx_t_3 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_4, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 387, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_3);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_3 = 0;
      goto __pyx_L0;

 388:                 name,

 389:                 value,

+390:                 f"String length must be at most {max_length} characters, got {len(value)}",

      __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_length, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 390, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      __pyx_t_7 = PyObject_Length(__pyx_v_value); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 390, __pyx_L1_error)
      __pyx_t_3 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_7, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 390, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);

      __pyx_t_8[0] = __pyx_mstate_global->__pyx_kp_u_String_length_must_be_at_most;
      __pyx_t_8[1] = __pyx_t_2;
      __pyx_t_8[2] = __pyx_mstate_global->__pyx_kp_u_characters_got;
      __pyx_t_8[3] = __pyx_t_3;
      __pyx_t_7 = 47;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8[3]);
      #endif
      __pyx_t_9 = 0;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_8[1]);
      #endif
      __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_8, 4, __pyx_t_7, __pyx_t_9);
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 390, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 391:                 val_type,

 392:                 annotated_type

 393:             )

 394: 

 395:         # Pattern validation

+396:         if pattern is not None:

    __pyx_t_1 = (__pyx_v_pattern != Py_None);
    if (__pyx_t_1) {
/* … */
    }

+397:             import re

      __pyx_t_10 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_re, 0, 0, NULL, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 397, __pyx_L1_error)
      __pyx_t_3 = __pyx_t_10;
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_v_re = __pyx_t_3;
      __pyx_t_3 = 0;

+398:             if not re.match(pattern, value):

      __pyx_t_4 = __pyx_v_re;
      __Pyx_INCREF(__pyx_t_4);
      __pyx_t_5 = 0;
      {
        PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_pattern, __pyx_v_value};
        __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_match, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 398, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
      }
      __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 398, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = (!__pyx_t_1);


      if (__pyx_t_6) {
/* … */
      }

+399:                 return _create_error(

        __pyx_t_3 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_4, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 399, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        {
          PyObject *__pyx_temp;
          {
            __pyx_temp = __pyx_r;
            __pyx_r = ((PyObject*)__pyx_t_3);
          }
          __Pyx_XDECREF(__pyx_temp);
        }
        __pyx_t_3 = 0;
        goto __pyx_L0;

 400:                     name,

 401:                     value,

+402:                     f"String does not match pattern {pattern}",

        __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_pattern, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 402, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_String_does_not_match_pattern, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 402, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 403:                     val_type,

 404:                     annotated_type

 405:                 )

 406: 

 407:     # Numeric validations (int, float, Decimal)

+408:     elif annotated_type in (int, float, Decimal):

  __Pyx_INCREF(__pyx_v_annotated_type);
  __pyx_t_3 = __pyx_v_annotated_type;
  __pyx_t_1 = __Pyx_PyObject_RichCompareBool(__pyx_t_3, ((PyObject *)(&PyLong_Type)), Py_EQ); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 408, __pyx_L1_error)
  if (!__pyx_t_1) {

  } else {

    __pyx_t_6 = __pyx_t_1;

    goto __pyx_L16_bool_binop_done;
  }
  __pyx_t_1 = __Pyx_PyObject_RichCompareBool(__pyx_t_3, ((PyObject *)(&PyFloat_Type)), Py_EQ); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 408, __pyx_L1_error)
  if (!__pyx_t_1) {

  } else {

    __pyx_t_6 = __pyx_t_1;

    goto __pyx_L16_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Decimal); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyObject_CompareBoolEq_object_object(__pyx_t_3, __pyx_t_4, Py_EQ); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 408, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

  __pyx_t_6 = __pyx_t_1;

  __pyx_L16_bool_binop_done:;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_1 = __pyx_t_6;


  if (__pyx_t_1) {
/* … */
  }
  __pyx_L4:;

+409:         min_val = metadata.get('min', getattr(field, 'gt', None))

    __pyx_t_4 = __pyx_v_metadata;
    __Pyx_INCREF(__pyx_t_4);
    __pyx_t_2 = __Pyx_GetAttr3(__pyx_v_field, __pyx_mstate_global->__pyx_n_u_gt, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 409, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_mstate_global->__pyx_n_u_min, __pyx_t_2};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 409, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_DECREF_SET(__pyx_v_min_val, __pyx_t_3);
    __pyx_t_3 = 0;

+410:         max_val = metadata.get('max', getattr(field, 'lt', None))

    __pyx_t_2 = __pyx_v_metadata;
    __Pyx_INCREF(__pyx_t_2);
    __pyx_t_4 = __Pyx_GetAttr3(__pyx_v_field, __pyx_mstate_global->__pyx_n_u_lt, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 410, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = 0;
    {
      PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_mstate_global->__pyx_n_u_max, __pyx_t_4};
      __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 410, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_DECREF_SET(__pyx_v_max_val, __pyx_t_3);
    __pyx_t_3 = 0;

+411:         ge_val = getattr(field, 'ge', None)

    __pyx_t_3 = __Pyx_GetAttr3(__pyx_v_field, __pyx_mstate_global->__pyx_n_u_ge, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 411, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_ge_val, __pyx_t_3);
    __pyx_t_3 = 0;

+412:         le_val = getattr(field, 'le', None)

    __pyx_t_3 = __Pyx_GetAttr3(__pyx_v_field, __pyx_mstate_global->__pyx_n_u_le, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 412, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_le_val, __pyx_t_3);
    __pyx_t_3 = 0;

+413:         eq_val = getattr(field, 'eq', None)

    __pyx_t_3 = __Pyx_GetAttr3(__pyx_v_field, __pyx_mstate_global->__pyx_n_u_eq, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 413, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_eq_val, __pyx_t_3);
    __pyx_t_3 = 0;

+414:         ne_val = getattr(field, 'ne', None)

    __pyx_t_3 = __Pyx_GetAttr3(__pyx_v_field, __pyx_mstate_global->__pyx_n_u_ne, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 414, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF_SET(__pyx_v_ne_val, __pyx_t_3);
    __pyx_t_3 = 0;

 415:         # Equal validation

+416:         if eq_val is not None and value != eq_val:

    __pyx_t_6 = (__pyx_v_eq_val != Py_None);
    if (__pyx_t_6) {

    } else {

      __pyx_t_1 = __pyx_t_6;

      goto __pyx_L20_bool_binop_done;
    }
    __pyx_t_6 = __Pyx_PyObject_CompareBoolNe_object_object(__pyx_v_value, __pyx_v_eq_val, Py_NE); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 416, __pyx_L1_error)

    __pyx_t_1 = __pyx_t_6;

    __pyx_L20_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+417:             return _create_error(

      __pyx_t_3 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_4, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 417, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_3);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_3 = 0;
      goto __pyx_L0;

 418:                 name,

 419:                 value,

+420:                 f"Value must be equal to {eq_val}",

      __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_eq_val, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 420, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Value_must_be_equal_to, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 420, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 421:                 val_type,

 422:                 annotated_type

 423:             )

 424: 

 425:         # Not equal validation

+426:         if ne_val is not None and value == ne_val:

    __pyx_t_6 = (__pyx_v_ne_val != Py_None);
    if (__pyx_t_6) {

    } else {

      __pyx_t_1 = __pyx_t_6;

      goto __pyx_L23_bool_binop_done;
    }
    __pyx_t_6 = __Pyx_PyObject_CompareBoolEq_object_object(__pyx_v_value, __pyx_v_ne_val, Py_EQ); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 426, __pyx_L1_error)

    __pyx_t_1 = __pyx_t_6;

    __pyx_L23_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+427:             return _create_error(

      __pyx_t_3 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_4, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 427, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_3);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_3 = 0;
      goto __pyx_L0;

 428:                 name,

 429:                 value,

+430:                 f"Value must not be equal to {ne_val}",

      __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_ne_val, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 430, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Value_must_not_be_equal_to, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 430, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 431:                 val_type,

 432:                 annotated_type

 433:             )

 434: 

 435:         # Minimum value validation (greater than)

+436:         if min_val is not None and value < min_val:  # inclusive

    __pyx_t_6 = (__pyx_v_min_val != Py_None);
    if (__pyx_t_6) {

    } else {

      __pyx_t_1 = __pyx_t_6;

      goto __pyx_L26_bool_binop_done;
    }
    __pyx_t_6 = __Pyx_PyObject_CompareBoolLt_object_object(__pyx_v_value, __pyx_v_min_val, Py_LT); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 436, __pyx_L1_error)

    __pyx_t_1 = __pyx_t_6;

    __pyx_L26_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+437:             return _create_error(

      __pyx_t_3 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_4, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 437, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_3);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_3 = 0;
      goto __pyx_L0;

 438:                 name,

 439:                 value,

+440:                 f"Value must be greater than {min_val}",

      __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_min_val, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 440, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Value_must_be_greater_than, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 440, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 441:                 val_type,

 442:                 annotated_type

 443:             )

 444: 

 445:         # Maximum value validation (less than)

+446:         if max_val is not None and value > max_val:  # inclusive

    __pyx_t_6 = (__pyx_v_max_val != Py_None);
    if (__pyx_t_6) {

    } else {

      __pyx_t_1 = __pyx_t_6;

      goto __pyx_L29_bool_binop_done;
    }
    __pyx_t_6 = __Pyx_PyObject_CompareBoolGt_object_object(__pyx_v_value, __pyx_v_max_val, Py_GT); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 446, __pyx_L1_error)

    __pyx_t_1 = __pyx_t_6;

    __pyx_L29_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+447:             return _create_error(

      __pyx_t_3 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_4, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 447, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_3);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_3 = 0;
      goto __pyx_L0;

 448:                 name,

 449:                 value,

+450:                 f"Value must be less than {max_val}",

      __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_max_val, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 450, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Value_must_be_less_than, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 450, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 451:                 val_type,

 452:                 annotated_type

 453:             )

 454: 

 455:         # Greater than or equal validation

+456:         if ge_val is not None and value < ge_val:

    __pyx_t_6 = (__pyx_v_ge_val != Py_None);
    if (__pyx_t_6) {

    } else {

      __pyx_t_1 = __pyx_t_6;

      goto __pyx_L32_bool_binop_done;
    }
    __pyx_t_6 = __Pyx_PyObject_CompareBoolLt_object_object(__pyx_v_value, __pyx_v_ge_val, Py_LT); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 456, __pyx_L1_error)

    __pyx_t_1 = __pyx_t_6;

    __pyx_L32_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+457:             return _create_error(

      __pyx_t_3 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_4, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 457, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_3);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_3 = 0;
      goto __pyx_L0;

 458:                 name,

 459:                 value,

+460:                 f"Value must be greater than or equal to {ge_val}",

      __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_ge_val, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 460, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Value_must_be_greater_than_or_eq, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 460, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 461:                 val_type,

 462:                 annotated_type

 463:             )

 464: 

 465:         # Less than or equal validation

+466:         if le_val is not None and value > le_val:

    __pyx_t_6 = (__pyx_v_le_val != Py_None);
    if (__pyx_t_6) {

    } else {

      __pyx_t_1 = __pyx_t_6;

      goto __pyx_L35_bool_binop_done;
    }
    __pyx_t_6 = __Pyx_PyObject_CompareBoolGt_object_object(__pyx_v_value, __pyx_v_le_val, Py_GT); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 466, __pyx_L1_error)

    __pyx_t_1 = __pyx_t_6;

    __pyx_L35_bool_binop_done:;
    if (__pyx_t_1) {
/* … */
    }

+467:             return _create_error(

      __pyx_t_3 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_4, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 467, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_3);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_3 = 0;
      goto __pyx_L0;

 468:                 name,

 469:                 value,

+470:                 f"Value must be less than or equal to {le_val}",

      __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_le_val, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 470, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Value_must_be_less_than_or_equal, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 470, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 471:                 val_type,

 472:                 annotated_type

 473:             )

 474: 

 475:     # If we've made it here, all validations passed

+476:     return {}

  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 476, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)__pyx_t_3);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  __pyx_t_3 = 0;
  goto __pyx_L0;

 477: 

+478: cpdef dict _validation(

static PyObject *__pyx_pw_9datamodel_10validation_3_validation(PyObject *__pyx_self, 
#if CYTHON_VECTORCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
static PyObject *__pyx_f_9datamodel_10validation__validation(PyObject *__pyx_v_F, PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_annotated_type, PyObject *__pyx_v_val_type, PyObject *__pyx_v_field_type, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9datamodel_10validation__validation *__pyx_optional_args) {
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_17);
  __Pyx_XDECREF(__pyx_t_20);
  __Pyx_AddTraceback("datamodel.validation._validation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;

  __Pyx_XDECREF(__pyx_v_field_meta);
  __Pyx_XDECREF(__pyx_v_error);
  __Pyx_XDECREF(__pyx_v_allowed_values);
  __Pyx_XDECREF(__pyx_v_result);
  __Pyx_XDECREF(__pyx_v_msg);
  __Pyx_XDECREF(__pyx_v_errors);
  __Pyx_XDECREF(__pyx_v_tuple_args);
  __Pyx_XDECREF(__pyx_v_element_type);
  __Pyx_XDECREF(__pyx_v_i);
  __Pyx_XDECREF(__pyx_v_elem);
  __Pyx_XDECREF(__pyx_v_elem_origin);
  __Pyx_XDECREF(__pyx_v_elem_type);
  __Pyx_XDECREF(__pyx_v_inner_types);
  __Pyx_XDECREF(__pyx_v_t);
  __Pyx_XDECREF(__pyx_v_base_type);
  __Pyx_XDECREF(__pyx_v_field);
  __Pyx_XDECREF(__pyx_v_e);
  __Pyx_XDECREF(__pyx_v_ftype);
  __Pyx_XDECREF(__pyx_v_pk_field);
  __Pyx_XDECREF(__pyx_v_pk_type);

  __Pyx_XDECREF(__pyx_v_fn);
  __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_t);
  __Pyx_XDECREF(__pyx_v_annotated_type);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_9datamodel_10validation_3_validation(PyObject *__pyx_self, 
#if CYTHON_VECTORCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_9datamodel_10validation_2_validation, "_validation(F, str name, value, annotated_type, val_type, str field_type, bool as_objects=False) -> dict");
static PyMethodDef __pyx_mdef_9datamodel_10validation_3_validation = {"_validation", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9datamodel_10validation_3_validation, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9datamodel_10validation_2_validation};
static PyObject *__pyx_pw_9datamodel_10validation_3_validation(PyObject *__pyx_self, 
#if CYTHON_VECTORCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_F = 0;
  PyObject *__pyx_v_name = 0;
  PyObject *__pyx_v_value = 0;
  PyObject *__pyx_v_annotated_type = 0;
  PyObject *__pyx_v_val_type = 0;
  PyObject *__pyx_v_field_type = 0;
  int __pyx_v_as_objects;
  #if !CYTHON_VECTORCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_validation (wrapper)", 0);
  #if !CYTHON_VECTORCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_F,&__pyx_mstate_global->__pyx_n_u_name,&__pyx_mstate_global->__pyx_n_u_value,&__pyx_mstate_global->__pyx_n_u_annotated_type,&__pyx_mstate_global->__pyx_n_u_val_type,&__pyx_mstate_global->__pyx_n_u_field_type,&__pyx_mstate_global->__pyx_n_u_as_objects,0};
  PyObject* values[7] = {0,0,0,0,0,0,0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 478, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 478, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 478, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  5:
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 478, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  4:
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 478, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  3:
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 478, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  2:
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 478, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 478, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_validation", 0) < (0)) __PYX_ERR(0, 478, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 6; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_validation", 0, 6, 7, i); __PYX_ERR(0, 478, __pyx_L3_error) }
      }
    } else {
      switch (__pyx_nargs) {
        case  7:
        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 478, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  6:
        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 478, __pyx_L3_error)
        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 478, __pyx_L3_error)
        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 478, __pyx_L3_error)
        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 478, __pyx_L3_error)
        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 478, __pyx_L3_error)
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 478, __pyx_L3_error)
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_F = values[0];
    __pyx_v_name = ((PyObject*)values[1]);
    __pyx_v_value = values[2];
    __pyx_v_annotated_type = values[3];
    __pyx_v_val_type = values[4];
    __pyx_v_field_type = ((PyObject*)values[5]);
    if (values[6]) {
      __pyx_v_as_objects = __Pyx_PyObject_IsTrue(values[6]); if (unlikely((__pyx_v_as_objects == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 485, __pyx_L3_error)
    } else {
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;

  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9datamodel_10validation_2_validation(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_F, PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_annotated_type, PyObject *__pyx_v_val_type, PyObject *__pyx_v_field_type, int __pyx_v_as_objects) {
  PyObject *__pyx_r = NULL;
  __pyx_t_2.__pyx_n = 1;
  __pyx_t_2.as_objects = __pyx_v_as_objects;
  __pyx_t_1 = __pyx_f_9datamodel_10validation__validation(__pyx_v_F, __pyx_v_name, __pyx_v_value, __pyx_v_annotated_type, __pyx_v_val_type, __pyx_v_field_type, 1, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 478, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = __pyx_t_1;
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("datamodel.validation._validation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9datamodel_10validation_3_validation, 0, __pyx_mstate_global->__pyx_n_u_validation, NULL, __pyx_mstate_global->__pyx_n_u_datamodel_validation, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 478, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
  #endif
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[5]);
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_validation, __pyx_t_2) < (0)) __PYX_ERR(0, 478, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* … */
struct __pyx_opt_args_9datamodel_10validation__validation {
  int __pyx_n;
  int as_objects;
};

 479:     object F,

 480:     str name,

 481:     object value,

 482:     object annotated_type,

 483:     object val_type,

 484:     str field_type,

+485:     bint as_objects=False

  int __pyx_v_as_objects = ((int)0);
  int __pyx_v__valid;
  PyObject *__pyx_v_field_meta = 0;
  PyObject *__pyx_v_error = 0;
  PyObject *__pyx_v_allowed_values = 0;
  PyObject *__pyx_v_result = NULL;
  PyObject *__pyx_v_msg = NULL;
  PyObject *__pyx_v_errors = NULL;
  PyObject *__pyx_v_tuple_args = NULL;
  PyObject *__pyx_v_element_type = NULL;
  PyObject *__pyx_v_i = NULL;
  PyObject *__pyx_v_elem = NULL;
  PyObject *__pyx_v_elem_origin = NULL;
  PyObject *__pyx_v_elem_type = NULL;
  PyObject *__pyx_v_inner_types = NULL;
  PyObject *__pyx_v_t = NULL;
  PyObject *__pyx_v_base_type = NULL;
  PyObject *__pyx_v_field = NULL;
  PyObject *__pyx_v_e = NULL;
  PyObject *__pyx_v_ftype = NULL;
  PyObject *__pyx_v_pk_field = NULL;
  PyObject *__pyx_v_pk_type = NULL;
  int __pyx_v_instance;
  PyObject *__pyx_v_fn = NULL;
  PyObject *__pyx_8genexpr2__pyx_v_t = NULL;
  PyObject *__pyx_r = NULL;
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_as_objects = __pyx_optional_args->as_objects;
    }
  }
  __Pyx_INCREF(__pyx_v_annotated_type);
/* … */
      __pyx_v_as_objects = ((int)0);
    }
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_validation", 0, 6, 7, __pyx_nargs); __PYX_ERR(0, 478, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("datamodel.validation._validation", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyUnicode_Type), 1, "name", 1))) __PYX_ERR(0, 480, __pyx_L1_error)
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_field_type), (&PyUnicode_Type), 1, "field_type", 1))) __PYX_ERR(0, 484, __pyx_L1_error)
  __pyx_r = __pyx_pf_9datamodel_10validation_2_validation(__pyx_self, __pyx_v_F, __pyx_v_name, __pyx_v_value, __pyx_v_annotated_type, __pyx_v_val_type, __pyx_v_field_type, __pyx_v_as_objects);

 486: ):

+487:     cdef bint _valid = False

  __pyx_v__valid = 0;

+488:     cdef object field_meta = F.metadata

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_metadata); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 488, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_field_meta = __pyx_t_1;
  __pyx_t_1 = 0;

+489:     cdef dict error = {}

  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 489, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_error = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

+490:     cdef list allowed_values = []

  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 490, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_allowed_values = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

 491: 

+492:     if not annotated_type:

  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_annotated_type); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 492, __pyx_L1_error)
  __pyx_t_3 = (!__pyx_t_2);


  if (__pyx_t_3) {
/* … */
    goto __pyx_L3;
  }

+493:         annotated_type = F.type

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_type_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 493, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF_SET(__pyx_v_annotated_type, __pyx_t_1);
    __pyx_t_1 = 0;

+494:     elif isinstance(annotated_type, Field):

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_Field_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 494, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = PyObject_IsInstance(__pyx_v_annotated_type, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 494, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_3) {
/* … */
  }
  __pyx_L3:;

+495:         annotated_type = annotated_type.type

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_n_u_type_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 495, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF_SET(__pyx_v_annotated_type, __pyx_t_1);
    __pyx_t_1 = 0;

 496:     # print('VAL > ', name, ' F ', F, ' VALUE > ', value)

+497:     if fn := F.metadata.get('validator', None):

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_metadata); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 497, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_get); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 497, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_mstate_global->__pyx_tuple[4], NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 497, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_INCREF(__pyx_t_1);
  __pyx_v_fn = __pyx_t_1;
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 497, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_3) {
/* … */
  }
/* … */
  {
    PyObject* __pyx_temp[2] = {__pyx_mstate_global->__pyx_n_u_validator, Py_None};
    __pyx_mstate_global->__pyx_tuple[4] = __Pyx_PyTuple_FromArray(__pyx_temp, 2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[4])) __PYX_ERR(0, 497, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[4]);
  }
  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[4]);

+498:         try:

    {
      /*try:*/ {
/* … */
      }
      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
      goto __pyx_L10_try_end;
      __pyx_L5_error:;
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
/* … */
      __pyx_L7_except_error:;
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_XGIVEREF(__pyx_t_7);
      __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
      goto __pyx_L1_error;
      __pyx_L9_try_return:;
      __Pyx_XGIVEREF(__pyx_t_5);
      __Pyx_XGIVEREF(__pyx_t_6);
      __Pyx_XGIVEREF(__pyx_t_7);
      __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
      goto __pyx_L0;
      __pyx_L10_try_end:;
    }

+499:             result = fn(F, value, annotated_type, val_type)

        __pyx_t_4 = NULL;
        __Pyx_INCREF(__pyx_v_fn);
        __pyx_t_8 = __pyx_v_fn; 
        __pyx_t_9 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_8))) {
          __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8);
          assert(__pyx_t_4);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
          __Pyx_INCREF(__pyx_t_4);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
          __pyx_t_9 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[5] = {__pyx_t_4, __pyx_v_F, __pyx_v_value, __pyx_v_annotated_type, __pyx_v_val_type};
          __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (5-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 499, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_1);
        }
        __pyx_v_result = __pyx_t_1;
        __pyx_t_1 = 0;

+500:             if result is False:

        __pyx_t_3 = (__pyx_v_result == Py_False);
        if (__pyx_t_3) {
/* … */
        }

+501:                 msg = f"Validation failed for *{name}*: {value} with result: {result}"

          __pyx_t_1 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 501, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_value, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 501, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_result, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 501, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_4);
          __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Validation_failed_for;
          __pyx_t_10[1] = __pyx_t_1;
          __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u__9;
          __pyx_t_10[3] = __pyx_t_8;
          __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_with_result;
          __pyx_t_10[5] = __pyx_t_4;
          __pyx_t_11 = 40;
          #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
          __pyx_t_11 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[5]);
          #endif
          __pyx_t_12 = 0;
          #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
          __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_10[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[5]);
          #endif
          __pyx_t_13 = __Pyx_PyUnicode_Join(__pyx_t_10, 6, __pyx_t_11, __pyx_t_12);
          if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 501, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __pyx_v_msg = ((PyObject*)__pyx_t_13);
          __pyx_t_13 = 0;

+502:                 return _create_error(name, value, msg, val_type, annotated_type)

          __pyx_t_13 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_v_msg, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 502, __pyx_L5_error)
          __Pyx_GOTREF(__pyx_t_13);
          {
            PyObject *__pyx_temp;
            {
              __pyx_temp = __pyx_r;
              __pyx_r = ((PyObject*)__pyx_t_13);
            }
            __Pyx_XDECREF(__pyx_temp);
          }
          __pyx_t_13 = 0;
          goto __pyx_L9_try_return;

+503:         except ValueError:

      __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_ValueError))));
      if (__pyx_t_12) {
        __Pyx_AddTraceback("datamodel.validation._validation", __pyx_clineno, __pyx_lineno, __pyx_filename);
        if (__Pyx_GetException(&__pyx_t_13, &__pyx_t_4, &__pyx_t_8) < 0) __PYX_ERR(0, 503, __pyx_L7_except_error)
        __Pyx_XGOTREF(__pyx_t_13);
        __Pyx_XGOTREF(__pyx_t_4);
        __Pyx_XGOTREF(__pyx_t_8);

+504:             raise

        __Pyx_GIVEREF(__pyx_t_13);
        __Pyx_GIVEREF(__pyx_t_4);
        __Pyx_XGIVEREF(__pyx_t_8);
        __Pyx_ErrRestoreWithState(__pyx_t_13, __pyx_t_4, __pyx_t_8);
        __pyx_t_13 = 0;  __pyx_t_4 = 0;  __pyx_t_8 = 0; 
        __PYX_ERR(0, 504, __pyx_L7_except_error)
      }
      goto __pyx_L7_except_error;

 505:     # Check for primitive type constraints if the value is not None

+506:     if F._type_category == 'primitive':

  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_type_category); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 506, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_3 = __Pyx_PyObject_CompareBoolEq_object_str(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_primitive, Py_EQ); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 506, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if (__pyx_t_3) {
/* … */
  }

+507:         errors = _validate_constraints(F, name, value, annotated_type, val_type)

    __pyx_t_8 = __pyx_f_9datamodel_10validation__validate_constraints(__pyx_v_F, __pyx_v_name, __pyx_v_value, __pyx_v_annotated_type, __pyx_v_val_type); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 507, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_v_errors = ((PyObject*)__pyx_t_8);
    __pyx_t_8 = 0;

+508:         if errors:

    if (__pyx_v_errors == Py_None) __pyx_t_3 = 0;
    else
    {
      Py_ssize_t __pyx_temp = __Pyx_PyDict_GET_SIZE(__pyx_v_errors);
      if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 508, __pyx_L1_error)
      __pyx_t_3 = (__pyx_temp != 0);
    }

    if (__pyx_t_3) {
/* … */
    }

+509:             return errors

      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __Pyx_INCREF(__pyx_v_errors);
          __pyx_r = __pyx_v_errors;
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      goto __pyx_L0;

 510:     # check: data type hint

 511:     # If field_type is known, short-circuit certain checks

+512:     if F.type == Text:

  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_type_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 512, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Text); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 512, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_CompareBoolEq_object_object(__pyx_t_8, __pyx_t_4, Py_EQ); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 512, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (__pyx_t_3) {
/* … */
  }

+513:         if val_type != str:

    __pyx_t_3 = __Pyx_PyObject_RichCompareBool(__pyx_v_val_type, ((PyObject *)(&PyUnicode_Type)), Py_NE); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 513, __pyx_L1_error)
    if (__pyx_t_3) {
/* … */
    }

+514:             return _create_error(

      __pyx_t_13 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_1, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 514, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_13);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_13 = 0;
      goto __pyx_L0;

 515:                 name,

 516:                 value,

+517:                 f'invalid type for {annotated_type}.{name}, expected {annotated_type}',

      __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 517, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_8 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 517, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_13 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 517, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_invalid_type_for;
      __pyx_t_10[1] = __pyx_t_4;
      __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u__8;
      __pyx_t_10[3] = __pyx_t_8;
      __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_expected;
      __pyx_t_10[5] = __pyx_t_13;
      __pyx_t_11 = 29;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_11 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[5]);
      #endif
      __pyx_t_12 = 0;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_10[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[5]);
      #endif
      __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_10, 6, __pyx_t_11, __pyx_t_12);
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 517, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

 518:                 val_type,

 519:                 annotated_type

 520:             )

+521:         return {}

    __pyx_t_13 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 521, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_13);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_13 = 0;
    goto __pyx_L0;

 522: 

+523:     if is_enum_class(annotated_type):

  __pyx_t_3 = __pyx_f_9datamodel_10validation_is_enum_class(__pyx_v_annotated_type); if (unlikely(__pyx_t_3 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 523, __pyx_L1_error)
  if (__pyx_t_3) {
/* … */
  }

+524:         return validate_enum(name, value, annotated_type, val_type)

    __pyx_t_13 = __pyx_f_9datamodel_10validation_validate_enum(__pyx_v_name, __pyx_v_value, __pyx_v_annotated_type, __pyx_v_val_type); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 524, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_13);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_13 = 0;
    goto __pyx_L0;

 525: 

+526:     if F.origin is Callable:

  __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_origin_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 526, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_13);
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_Callable); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 526, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = (__pyx_t_13 == __pyx_t_1);
  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_3) {
/* … */
  }

+527:         if not is_callable(value):

    __pyx_t_13 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_is_callable); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 527, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_8))) {
      __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_8);
      assert(__pyx_t_13);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_13);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_8, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_v_value};
      __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 527, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
    }
    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 527, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_2 = (!__pyx_t_3);


    if (__pyx_t_2) {
/* … */
    }

+528:             return _create_error(

      __pyx_t_1 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_8, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 528, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_1);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_1 = 0;
      goto __pyx_L0;

+529:                 name, value, f'Invalid function type, expected {annotated_type}', val_type, annotated_type

      __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 529, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Invalid_function_type_expected, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 529, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 530:             )

+531:         return {}

    __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 531, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_1);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_1 = 0;
    goto __pyx_L0;

+532:     elif F.origin is Awaitable:

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_origin_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 532, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_Awaitable); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 532, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_2 = (__pyx_t_1 == __pyx_t_8);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if (__pyx_t_2) {
/* … */
  }

+533:         if asyncio.iscoroutinefunction(value):

    __pyx_t_1 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_asyncio); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 533, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_iscoroutinefunction); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 533, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_1);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_value};
      __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 533, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
    }
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 533, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (__pyx_t_2) {
/* … */
    }

+534:             return  _create_error(name, value, f"Field '{name}': provided coroutine function is not awaitable; call it to obtain a coroutine object.", val_type, annotated_type)

      __pyx_t_8 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 534, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_14[0] = __pyx_mstate_global->__pyx_kp_u_Field_3;
      __pyx_t_14[1] = __pyx_t_8;
      __pyx_t_14[2] = __pyx_mstate_global->__pyx_kp_u_provided_coroutine_function_is;
      __pyx_t_11 = 93;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_11 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_14[1]);
      #endif
      __pyx_t_12 = 0;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_14[1]);
      #endif
      __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_14, 3, __pyx_t_11, __pyx_t_12);
      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 534, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_8 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_4, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 534, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_8);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_8 = 0;
      goto __pyx_L0;

 535:         # Otherwise, check if it is awaitable

+536:         elif not hasattr(value, '__await__'):

    __pyx_t_2 = __Pyx_HasAttr(__pyx_v_value, __pyx_mstate_global->__pyx_n_u_await); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 536, __pyx_L1_error)
    __pyx_t_3 = (!__pyx_t_2);


    if (__pyx_t_3) {
/* … */
    }

+537:             return _create_error(name, value, f"Field '{name}': provided object is not awaitable; it does not have an '__await__' method. but got {type(value)}.", val_type, annotated_type)

      __pyx_t_8 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 537, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_4 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 537, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_15[0] = __pyx_mstate_global->__pyx_kp_u_Field_3;
      __pyx_t_15[1] = __pyx_t_8;
      __pyx_t_15[2] = __pyx_mstate_global->__pyx_kp_u_provided_object_is_not_awaitabl;
      __pyx_t_15[3] = __pyx_t_4;
      __pyx_t_15[4] = __pyx_mstate_global->__pyx_kp_u__8;
      __pyx_t_11 = 93;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_11 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15[3]);
      #endif
      __pyx_t_12 = 0;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_15[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_15[3]);
      #endif
      __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_15, 5, __pyx_t_11, __pyx_t_12);
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 537, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_4 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_1, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 537, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_4);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_4 = 0;
      goto __pyx_L0;

+538:         return {}

    __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 538, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_4);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_4 = 0;
    goto __pyx_L0;

+539:     elif field_type == 'type':

  __pyx_t_3 = __Pyx_PyObject_CompareBoolEq_str_str(__pyx_v_field_type, __pyx_mstate_global->__pyx_n_u_type_2, Py_EQ); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 539, __pyx_L1_error)
  if (__pyx_t_3) {
/* … */
  }

+540:         return validate_type(F, name, value, annotated_type, val_type)

    __pyx_t_4 = __pyx_f_9datamodel_10validation_validate_type(__pyx_v_F, __pyx_v_name, __pyx_v_value, __pyx_v_annotated_type, __pyx_v_val_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 540, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_4);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_4 = 0;
    goto __pyx_L0;

 541: 

+542:     elif F.origin is Literal:

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_origin_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 542, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_Literal); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 542, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = (__pyx_t_4 == __pyx_t_1);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_3) {
/* … */
  }

+543:         allowed_values = list(F.args)

    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __Pyx_PySequence_ListKeepNew(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 543, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF_SET(__pyx_v_allowed_values, ((PyObject*)__pyx_t_4));
    __pyx_t_4 = 0;

+544:         if value not in allowed_values:

    __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_v_value, __pyx_v_allowed_values, Py_NE)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 544, __pyx_L1_error)
    if (__pyx_t_3) {
/* … */
    }

+545:             return _create_error(

      __pyx_t_8 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_13, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 545, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_8);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_8 = 0;
      goto __pyx_L0;

 546:                 name,

 547:                 value,

+548:                 f"Invalid value for {annotated_type}.{name}, expected one of {allowed_values}",

      __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 548, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_1 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 548, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_allowed_values, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 548, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_value_for;
      __pyx_t_10[1] = __pyx_t_4;
      __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u__8;
      __pyx_t_10[3] = __pyx_t_1;
      __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_expected_one_of;
      __pyx_t_10[5] = __pyx_t_8;
      __pyx_t_11 = 37;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_11 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[5]);
      #endif
      __pyx_t_12 = 0;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_10[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[5]);
      #endif
      __pyx_t_13 = __Pyx_PyUnicode_Join(__pyx_t_10, 6, __pyx_t_11, __pyx_t_12);
      if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 548, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

 549:                 val_type,

 550:                 annotated_type

 551:             )

+552:         return {}

    __pyx_t_8 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 552, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_8);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_8 = 0;
    goto __pyx_L0;

 553: 

 554:     # Handle Union (including Optional)

+555:     elif _is_union(F.origin):

  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_origin_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 555, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_3 = __pyx_f_9datamodel_10validation__is_union(__pyx_t_8); if (unlikely(__pyx_t_3 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 555, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if (__pyx_t_3) {
/* … */
    goto __pyx_L19;
  }

 556:         # If None is allowed and value is None, it's valid

+557:         if type(None) in F.args and value is None:

    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 557, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_2 = (__Pyx_PySequence_ContainsTF(((PyObject *)Py_TYPE(Py_None)), __pyx_t_8, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 557, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (__pyx_t_2) {

    } else {

      __pyx_t_3 = __pyx_t_2;

      goto __pyx_L24_bool_binop_done;
    }
    __pyx_t_2 = (__pyx_v_value == Py_None);

    __pyx_t_3 = __pyx_t_2;

    __pyx_L24_bool_binop_done:;
    if (__pyx_t_3) {
/* … */
    }

+558:             return {}

      __pyx_t_8 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 558, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_8);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_8 = 0;
      goto __pyx_L0;

 559:         # return _validate_union_field(F, name, value, annotated_type)

+560:     elif field_type == 'typing' or hasattr(annotated_type, '__module__') and annotated_type.__module__ == 'typing':

  __pyx_t_2 = __Pyx_PyObject_CompareBoolEq_str_str(__pyx_v_field_type, __pyx_mstate_global->__pyx_n_u_typing, Py_EQ); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 560, __pyx_L1_error)
  if (!__pyx_t_2) {

  } else {

    __pyx_t_3 = __pyx_t_2;

    goto __pyx_L26_bool_binop_done;
  }
  __pyx_t_2 = __Pyx_HasAttr(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_n_u_module); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 560, __pyx_L1_error)
  if (__pyx_t_2) {

  } else {

    __pyx_t_3 = __pyx_t_2;

    goto __pyx_L26_bool_binop_done;
  }
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_n_u_module); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 560, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_2 = __Pyx_PyObject_CompareBoolEq_object_str(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_typing, Py_EQ); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 560, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

  __pyx_t_3 = __pyx_t_2;

  __pyx_L26_bool_binop_done:;
  if (__pyx_t_3) {
/* … */
    goto __pyx_L19;
  }

+561:         if F.origin is tuple:

    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_origin_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 561, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_3 = (__pyx_t_8 == ((PyObject *)(&PyTuple_Type)));
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (__pyx_t_3) {
/* … */
    }

+562:             tuple_args = F.args

      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 562, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_v_tuple_args = __pyx_t_8;
      __pyx_t_8 = 0;

 563:             # Check if we are in the homogeneous case: Tuple[T, ...]

+564:             if len(tuple_args) == 2 and tuple_args[1] is Ellipsis:

      __pyx_t_11 = PyObject_Length(__pyx_v_tuple_args); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 564, __pyx_L1_error)
      __pyx_t_2 = (__pyx_t_11 == 2);


      if (__pyx_t_2) {

      } else {

        __pyx_t_3 = __pyx_t_2;

        goto __pyx_L31_bool_binop_done;
      }
      __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_tuple_args, 1, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 564, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_2 = (__pyx_t_8 == __pyx_builtin_Ellipsis);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

      __pyx_t_3 = __pyx_t_2;

      __pyx_L31_bool_binop_done:;
      if (__pyx_t_3) {
/* … */
      }

+565:                 element_type = tuple_args[0]

        __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_tuple_args, 0, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 565, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_v_element_type = __pyx_t_8;
        __pyx_t_8 = 0;

+566:                 for i, elem in enumerate(value):

        __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
        __pyx_t_8 = __pyx_mstate_global->__pyx_int_0;
        if (likely(PyList_CheckExact(__pyx_v_value)) || PyTuple_CheckExact(__pyx_v_value)) {
          __pyx_t_13 = __pyx_v_value; __Pyx_INCREF(__pyx_t_13);
          __pyx_t_11 = 0;
          __pyx_t_16 = NULL;
        } else {
          __pyx_t_11 = -1; __pyx_t_13 = PyObject_GetIter(__pyx_v_value); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 566, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_13); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 566, __pyx_L1_error)
        }
        for (;;) {
          if (likely(!__pyx_t_16)) {
            if (likely(PyList_CheckExact(__pyx_t_13))) {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_13);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 566, __pyx_L1_error)
                #endif
                if (__pyx_t_11 >= __pyx_temp) break;
              }
              __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_13, __pyx_t_11, __Pyx_ReferenceSharing_OwnStrongReference);
              ++__pyx_t_11;
            } else {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_13);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 566, __pyx_L1_error)
                #endif
                if (__pyx_t_11 >= __pyx_temp) break;
              }
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_13, __pyx_t_11));
              #else
              __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_13, __pyx_t_11);
              #endif
              ++__pyx_t_11;
            }
            if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 566, __pyx_L1_error)
          } else {
            __pyx_t_1 = __pyx_t_16(__pyx_t_13);
            if (unlikely(!__pyx_t_1)) {
              PyObject* exc_type = PyErr_Occurred();
              if (exc_type) {
                if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 566, __pyx_L1_error)
                PyErr_Clear();
              }
              break;
            }
          }
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_XDECREF_SET(__pyx_v_elem, __pyx_t_1);
          __pyx_t_1 = 0;
          __Pyx_INCREF(__pyx_t_8);
          __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_8);
          __pyx_t_1 = __Pyx_PyLong_AddObjC(__pyx_t_8, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 566, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_DECREF(__pyx_t_8);
          __pyx_t_8 = __pyx_t_1;
          __pyx_t_1 = 0;
/* … */
        }
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

 567:                     # Can't use isinstance with generic types

+568:                     elem_origin = get_origin(element_type)

          __pyx_t_4 = NULL;
          __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_mstate_global->__pyx_n_u_get_origin); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 568, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_17);
          __pyx_t_9 = 1;
          #if CYTHON_UNPACK_METHODS
          if (unlikely(PyMethod_Check(__pyx_t_17))) {
            __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_17);
            assert(__pyx_t_4);
            PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_17);
            __Pyx_INCREF(__pyx_t_4);
            __Pyx_INCREF(__pyx__function);
            __Pyx_DECREF_SET(__pyx_t_17, __pyx__function);
            __pyx_t_9 = 0;
          }
          #endif
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_element_type};
            __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_17, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
            if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 568, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
          }
          __Pyx_XDECREF_SET(__pyx_v_elem_origin, __pyx_t_1);
          __pyx_t_1 = 0;

+569:                     if elem_origin is None:

          __pyx_t_3 = (__pyx_v_elem_origin == Py_None);
          if (__pyx_t_3) {
/* … */
            goto __pyx_L35;
          }

+570:                         if not isinstance(elem, element_type):

            __pyx_t_3 = PyObject_IsInstance(__pyx_v_elem, __pyx_v_element_type); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 570, __pyx_L1_error)
            __pyx_t_2 = (!__pyx_t_3);


            if (__pyx_t_2) {
/* … */
            }

+571:                             return _create_error(

              __pyx_t_1 = __pyx_f_9datamodel_10validation__create_error(((PyObject*)__pyx_t_4), __pyx_v_elem, __pyx_t_20, ((PyObject *)Py_TYPE(__pyx_v_elem)), __pyx_v_element_type, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 571, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
              __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
              {
                PyObject *__pyx_temp;
                {
                  __pyx_temp = __pyx_r;
                  __pyx_r = ((PyObject*)__pyx_t_1);
                }
                __Pyx_XDECREF(__pyx_temp);
              }
              __pyx_t_1 = 0;
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
              goto __pyx_L0;

+572:                                 f"{name}[{i}]",

              __pyx_t_1 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 572, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __pyx_t_17 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 572, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_17);
              __pyx_t_18[0] = __pyx_t_1;
              __pyx_t_18[1] = __pyx_mstate_global->__pyx_kp_u__4;
              __pyx_t_18[2] = __pyx_t_17;
              __pyx_t_18[3] = __pyx_mstate_global->__pyx_kp_u__5;
              __pyx_t_19 = 2;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[0]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[2]);
              #endif
              __pyx_t_12 = 0;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_18[0]) | __Pyx_PyUnicode_KIND_04(__pyx_t_18[2]);
              #endif
              __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_18, 4, __pyx_t_19, __pyx_t_12);
              if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 572, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_4);
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
              __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

 573:                                 elem,

+574:                                 f"Invalid type at index {i}: expected {element_type}",

              __pyx_t_17 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 574, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_17);
              __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_element_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 574, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __pyx_t_18[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_at_index;
              __pyx_t_18[1] = __pyx_t_17;
              __pyx_t_18[2] = __pyx_mstate_global->__pyx_kp_u_expected_2;
              __pyx_t_18[3] = __pyx_t_1;
              __pyx_t_19 = 33;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[3]);
              #endif
              __pyx_t_12 = 0;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_18[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_18[3]);
              #endif
              __pyx_t_20 = __Pyx_PyUnicode_Join(__pyx_t_18, 4, __pyx_t_19, __pyx_t_12);
              if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 574, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_20);
              __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 575:                                 type(elem), element_type

 576:                             )

 577:                     else:

+578:                         if not is_instanceof(elem, element_type):

          /*else*/ {
            __pyx_t_2 = __pyx_f_9datamodel_10validation_is_instanceof(__pyx_v_elem, __pyx_v_element_type); if (unlikely(__pyx_t_2 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 578, __pyx_L1_error)
            __pyx_t_3 = (!__pyx_t_2);


            if (__pyx_t_3) {
/* … */
            }
          }
          __pyx_L35:;

+579:                             return _create_error(

              __pyx_t_1 = __pyx_f_9datamodel_10validation__create_error(((PyObject*)__pyx_t_4), __pyx_v_elem, __pyx_t_17, ((PyObject *)Py_TYPE(__pyx_v_elem)), __pyx_v_element_type, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 579, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
              __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
              {
                PyObject *__pyx_temp;
                {
                  __pyx_temp = __pyx_r;
                  __pyx_r = ((PyObject*)__pyx_t_1);
                }
                __Pyx_XDECREF(__pyx_temp);
              }
              __pyx_t_1 = 0;
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
              goto __pyx_L0;

+580:                                 f"{name}[{i}]",

              __pyx_t_1 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 580, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __pyx_t_20 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 580, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_20);
              __pyx_t_18[0] = __pyx_t_1;
              __pyx_t_18[1] = __pyx_mstate_global->__pyx_kp_u__4;
              __pyx_t_18[2] = __pyx_t_20;
              __pyx_t_18[3] = __pyx_mstate_global->__pyx_kp_u__5;
              __pyx_t_19 = 2;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[0]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[2]);
              #endif
              __pyx_t_12 = 0;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_18[0]) | __Pyx_PyUnicode_KIND_04(__pyx_t_18[2]);
              #endif
              __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_18, 4, __pyx_t_19, __pyx_t_12);
              if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 580, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_4);
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
              __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;

 581:                                 elem,

+582:                                 f"Invalid type at index {i}: expected {element_type}",

              __pyx_t_20 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 582, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_20);
              __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_element_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 582, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __pyx_t_18[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_at_index;
              __pyx_t_18[1] = __pyx_t_20;
              __pyx_t_18[2] = __pyx_mstate_global->__pyx_kp_u_expected_2;
              __pyx_t_18[3] = __pyx_t_1;
              __pyx_t_19 = 33;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[3]);
              #endif
              __pyx_t_12 = 0;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_18[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_18[3]);
              #endif
              __pyx_t_17 = __Pyx_PyUnicode_Join(__pyx_t_18, 4, __pyx_t_19, __pyx_t_12);
              if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 582, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_17);
              __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 583:                                 type(elem), element_type

 584:                             )

+585:                     if not isinstance(elem, F.args[0]):

          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 585, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_17 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 585, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_17);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __pyx_t_3 = PyObject_IsInstance(__pyx_v_elem, __pyx_t_17); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 585, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
          __pyx_t_2 = (!__pyx_t_3);


          if (__pyx_t_2) {
/* … */
          }

+586:                         return _create_error(

            __pyx_t_17 = __pyx_f_9datamodel_10validation__create_error(((PyObject*)__pyx_t_4), __pyx_v_elem, __pyx_t_20, ((PyObject *)Py_TYPE(__pyx_v_elem)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 586, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_17);
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            {
              PyObject *__pyx_temp;
              {
                __pyx_temp = __pyx_r;
                __pyx_r = ((PyObject*)__pyx_t_17);
              }
              __Pyx_XDECREF(__pyx_temp);
            }
            __pyx_t_17 = 0;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            goto __pyx_L0;

+587:                             f"{name}[{i}]",

            __pyx_t_17 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 587, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_17);
            __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 587, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __pyx_t_18[0] = __pyx_t_17;
            __pyx_t_18[1] = __pyx_mstate_global->__pyx_kp_u__4;
            __pyx_t_18[2] = __pyx_t_1;
            __pyx_t_18[3] = __pyx_mstate_global->__pyx_kp_u__5;
            __pyx_t_19 = 2;
            #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
            __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[0]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[2]);
            #endif
            __pyx_t_12 = 0;
            #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
            __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_18[0]) | __Pyx_PyUnicode_KIND_04(__pyx_t_18[2]);
            #endif
            __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_18, 4, __pyx_t_19, __pyx_t_12);
            if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 587, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 588:                             elem,

+589:                             f"Invalid type at index {i}: expected {F.args[0]}",

            __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 589, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 589, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_17);
            __pyx_t_20 = __Pyx_GetItemInt(__pyx_t_17, 0, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 589, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_20);
            __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
            __pyx_t_17 = __Pyx_PyObject_FormatSimple(__pyx_t_20, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 589, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_17);
            __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
            __pyx_t_18[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_at_index;
            __pyx_t_18[1] = __pyx_t_1;
            __pyx_t_18[2] = __pyx_mstate_global->__pyx_kp_u_expected_2;
            __pyx_t_18[3] = __pyx_t_17;
            __pyx_t_19 = 33;
            #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
            __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[3]);
            #endif
            __pyx_t_12 = 0;
            #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
            __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_18[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_18[3]);
            #endif
            __pyx_t_20 = __Pyx_PyUnicode_Join(__pyx_t_18, 4, __pyx_t_19, __pyx_t_12);
            if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 589, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_20);
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

+590:                             type(elem), F.args[0]

            __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 590, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_17);
            __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_17, 0, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 590, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

 591:                         )

+592:                 return {}

        __pyx_t_8 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 592, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        {
          PyObject *__pyx_temp;
          {
            __pyx_temp = __pyx_r;
            __pyx_r = ((PyObject*)__pyx_t_8);
          }
          __Pyx_XDECREF(__pyx_temp);
        }
        __pyx_t_8 = 0;
        goto __pyx_L0;

 593:             else:

+594:                 if len(value) != len(F.args):

      /*else*/ {
        __pyx_t_11 = PyObject_Length(__pyx_v_value); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 594, __pyx_L1_error)
        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 594, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_19 = PyObject_Length(__pyx_t_8); if (unlikely(__pyx_t_19 == ((Py_ssize_t)-1))) __PYX_ERR(0, 594, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_2 = (__pyx_t_11 != __pyx_t_19);



        if (__pyx_t_2) {
/* … */
        }

+595:                     return _create_error(name, value, f"Invalid length for {annotated_type}.{name}, expected {len(F.args)} elements", val_type, annotated_type)

          __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 595, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_13 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 595, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 595, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_17);
          __pyx_t_19 = PyObject_Length(__pyx_t_17); if (unlikely(__pyx_t_19 == ((Py_ssize_t)-1))) __PYX_ERR(0, 595, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
          __pyx_t_17 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_19, 0, ' ', 'd'); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 595, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_17);

          __pyx_t_21[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_length_for;
          __pyx_t_21[1] = __pyx_t_8;
          __pyx_t_21[2] = __pyx_mstate_global->__pyx_kp_u__8;
          __pyx_t_21[3] = __pyx_t_13;
          __pyx_t_21[4] = __pyx_mstate_global->__pyx_kp_u_expected;
          __pyx_t_21[5] = __pyx_t_17;
          __pyx_t_21[6] = __pyx_mstate_global->__pyx_kp_u_elements;
          __pyx_t_19 = 40;
          #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
          __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_21[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_21[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_21[5]);
          #endif
          __pyx_t_12 = 0;
          #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
          __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_21[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_21[3]);
          #endif
          __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_21, 7, __pyx_t_19, __pyx_t_12);
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 595, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
          __pyx_t_17 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_1, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 595, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_17);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          {
            PyObject *__pyx_temp;
            {
              __pyx_temp = __pyx_r;
              __pyx_r = ((PyObject*)__pyx_t_17);
            }
            __Pyx_XDECREF(__pyx_temp);
          }
          __pyx_t_17 = 0;
          goto __pyx_L0;

 596:                 else:

+597:                     for i, (elem, elem_type) in enumerate(zip(value, F.args)):

        /*else*/ {
          __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
          __pyx_t_17 = __pyx_mstate_global->__pyx_int_0;
          __pyx_t_13 = NULL;
          __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 597, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_9 = 1;
          {
            PyObject *__pyx_callargs[3] = {__pyx_t_13, __pyx_v_value, __pyx_t_8};
            __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_zip, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 597, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
          }
          if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
            __pyx_t_8 = __pyx_t_1; __Pyx_INCREF(__pyx_t_8);
            __pyx_t_19 = 0;
            __pyx_t_16 = NULL;
          } else {
            __pyx_t_19 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 597, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_8);
            __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 597, __pyx_L1_error)
          }
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          for (;;) {
            if (likely(!__pyx_t_16)) {
              if (likely(PyList_CheckExact(__pyx_t_8))) {
                {
                  Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_8);
                  #if !CYTHON_ASSUME_SAFE_SIZE
                  if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 597, __pyx_L1_error)
                  #endif
                  if (__pyx_t_19 >= __pyx_temp) break;
                }
                __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_8, __pyx_t_19, __Pyx_ReferenceSharing_OwnStrongReference);
                ++__pyx_t_19;
              } else {
                {
                  Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_8);
                  #if !CYTHON_ASSUME_SAFE_SIZE
                  if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 597, __pyx_L1_error)
                  #endif
                  if (__pyx_t_19 >= __pyx_temp) break;
                }
                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_19));
                #else
                __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_8, __pyx_t_19);
                #endif
                ++__pyx_t_19;
              }
              if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 597, __pyx_L1_error)
            } else {
              __pyx_t_1 = __pyx_t_16(__pyx_t_8);
              if (unlikely(!__pyx_t_1)) {
                PyObject* exc_type = PyErr_Occurred();
                if (exc_type) {
                  if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 597, __pyx_L1_error)
                  PyErr_Clear();
                }
                break;
              }
            }
            __Pyx_GOTREF(__pyx_t_1);
            if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
              PyObject* sequence = __pyx_t_1;
              Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
              if (unlikely(size != 2)) {
                if (size > 2) __Pyx_RaiseTooManyValuesError(2);
                else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
                __PYX_ERR(0, 597, __pyx_L1_error)
              }
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              if (likely(PyTuple_CheckExact(sequence))) {
                __pyx_t_13 = PyTuple_GET_ITEM(sequence, 0);
                __Pyx_INCREF(__pyx_t_13);
                __pyx_t_20 = PyTuple_GET_ITEM(sequence, 1);
                __Pyx_INCREF(__pyx_t_20);
              } else {
                __pyx_t_13 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference);
                if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 597, __pyx_L1_error)
                __Pyx_XGOTREF(__pyx_t_13);
                __pyx_t_20 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference);
                if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 597, __pyx_L1_error)
                __Pyx_XGOTREF(__pyx_t_20);
              }
              #else
              __pyx_t_13 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 597, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_13);
              __pyx_t_20 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 597, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_20);
              #endif
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            } else {
              Py_ssize_t index = -1;
              __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 597, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_4);
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
              __pyx_t_22 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4);
              index = 0; __pyx_t_13 = __pyx_t_22(__pyx_t_4); if (unlikely(!__pyx_t_13)) goto __pyx_L43_unpacking_failed;
              __Pyx_GOTREF(__pyx_t_13);
              index = 1; __pyx_t_20 = __pyx_t_22(__pyx_t_4); if (unlikely(!__pyx_t_20)) goto __pyx_L43_unpacking_failed;
              __Pyx_GOTREF(__pyx_t_20);
              if (__Pyx_IternextUnpackEndCheck(__pyx_t_22(__pyx_t_4), 2) < (0)) __PYX_ERR(0, 597, __pyx_L1_error)
              __pyx_t_22 = NULL;
              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
              goto __pyx_L44_unpacking_done;
              __pyx_L43_unpacking_failed:;
              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
              __pyx_t_22 = NULL;
              if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
              __PYX_ERR(0, 597, __pyx_L1_error)
              __pyx_L44_unpacking_done:;
            }
            __Pyx_XDECREF_SET(__pyx_v_elem, __pyx_t_13);
            __pyx_t_13 = 0;
            __Pyx_XDECREF_SET(__pyx_v_elem_type, __pyx_t_20);
            __pyx_t_20 = 0;
            __Pyx_INCREF(__pyx_t_17);
            __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_17);
            __pyx_t_1 = __Pyx_PyLong_AddObjC(__pyx_t_17, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 597, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_1);
            __Pyx_DECREF(__pyx_t_17);
            __pyx_t_17 = __pyx_t_1;
            __pyx_t_1 = 0;
/* … */
          }
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        }

+598:                         elem_origin = get_origin(elem_type)

            __pyx_t_20 = NULL;
            __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_get_origin); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 598, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_13);
            __pyx_t_9 = 1;
            #if CYTHON_UNPACK_METHODS
            if (unlikely(PyMethod_Check(__pyx_t_13))) {
              __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_13);
              assert(__pyx_t_20);
              PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_13);
              __Pyx_INCREF(__pyx_t_20);
              __Pyx_INCREF(__pyx__function);
              __Pyx_DECREF_SET(__pyx_t_13, __pyx__function);
              __pyx_t_9 = 0;
            }
            #endif
            {
              PyObject *__pyx_callargs[2] = {__pyx_t_20, __pyx_v_elem_type};
              __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_13, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
              __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
              if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 598, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
            }
            __Pyx_XDECREF_SET(__pyx_v_elem_origin, __pyx_t_1);
            __pyx_t_1 = 0;

+599:                         if elem_origin is None and not isinstance(elem, elem_type):

            __pyx_t_3 = (__pyx_v_elem_origin == Py_None);
            if (__pyx_t_3) {

            } else {

              __pyx_t_2 = __pyx_t_3;

              goto __pyx_L46_bool_binop_done;
            }
            __pyx_t_3 = PyObject_IsInstance(__pyx_v_elem, __pyx_v_elem_type); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 599, __pyx_L1_error)
            __pyx_t_23 = (!__pyx_t_3);



            __pyx_t_2 = __pyx_t_23;

            __pyx_L46_bool_binop_done:;
            if (__pyx_t_2) {
/* … */
            }

+600:                             return _create_error(

              __pyx_t_1 = __pyx_f_9datamodel_10validation__create_error(((PyObject*)__pyx_t_20), __pyx_v_elem, __pyx_t_4, ((PyObject *)Py_TYPE(__pyx_v_elem)), __pyx_t_13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 600, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
              {
                PyObject *__pyx_temp;
                {
                  __pyx_temp = __pyx_r;
                  __pyx_r = ((PyObject*)__pyx_t_1);
                }
                __Pyx_XDECREF(__pyx_temp);
              }
              __pyx_t_1 = 0;
              __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
              __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
              goto __pyx_L0;

+601:                                 f"{name}[{i}]",

              __pyx_t_1 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 601, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __pyx_t_13 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 601, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_13);
              __pyx_t_18[0] = __pyx_t_1;
              __pyx_t_18[1] = __pyx_mstate_global->__pyx_kp_u__4;
              __pyx_t_18[2] = __pyx_t_13;
              __pyx_t_18[3] = __pyx_mstate_global->__pyx_kp_u__5;
              __pyx_t_11 = 2;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_11 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[0]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[2]);
              #endif
              __pyx_t_12 = 0;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_18[0]) | __Pyx_PyUnicode_KIND_04(__pyx_t_18[2]);
              #endif
              __pyx_t_20 = __Pyx_PyUnicode_Join(__pyx_t_18, 4, __pyx_t_11, __pyx_t_12);
              if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 601, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_20);
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

 602:                                 elem,

+603:                                 f"Invalid type at index {i}: expected {F.args[i]}",

              __pyx_t_13 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 603, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_13);
              __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 603, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 603, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_4);
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
              __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_4, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 603, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
              __pyx_t_18[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_at_index;
              __pyx_t_18[1] = __pyx_t_13;
              __pyx_t_18[2] = __pyx_mstate_global->__pyx_kp_u_expected_2;
              __pyx_t_18[3] = __pyx_t_1;
              __pyx_t_11 = 33;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_11 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18[3]);
              #endif
              __pyx_t_12 = 0;
              #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
              __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_18[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_18[3]);
              #endif
              __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_18, 4, __pyx_t_11, __pyx_t_12);
              if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 603, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_4);
              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

+604:                                 type(elem), F.args[i]

              __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 604, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_1);
              __pyx_t_13 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_i); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 604, __pyx_L1_error)
              __Pyx_GOTREF(__pyx_t_13);
              __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 605:                             )

+606:                 return {}

        __pyx_t_17 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 606, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        {
          PyObject *__pyx_temp;
          {
            __pyx_temp = __pyx_r;
            __pyx_r = ((PyObject*)__pyx_t_17);
          }
          __Pyx_XDECREF(__pyx_temp);
        }
        __pyx_t_17 = 0;
        goto __pyx_L0;
      }

+607:         elif F.origin is list:

    __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_origin_2); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 607, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_17);
    __pyx_t_2 = (__pyx_t_17 == ((PyObject *)(&PyList_Type)));
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    if (__pyx_t_2) {
/* … */
    }

+608:             if not isinstance(value, list):

      __pyx_t_2 = PyList_Check(__pyx_v_value); 
      __pyx_t_23 = (!__pyx_t_2);


      if (__pyx_t_23) {
/* … */
      }

+609:                 return _create_error(

        __pyx_t_8 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_1, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 609, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        {
          PyObject *__pyx_temp;
          {
            __pyx_temp = __pyx_r;
            __pyx_r = ((PyObject*)__pyx_t_8);
          }
          __Pyx_XDECREF(__pyx_temp);
        }
        __pyx_t_8 = 0;
        goto __pyx_L0;

 610:                     name,

 611:                     value,

+612:                     f"Invalid type for {annotated_type}.{name}, expected list",

        __pyx_t_17 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 612, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        __pyx_t_8 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 612, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_15[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_for;
        __pyx_t_15[1] = __pyx_t_17;
        __pyx_t_15[2] = __pyx_mstate_global->__pyx_kp_u__8;
        __pyx_t_15[3] = __pyx_t_8;
        __pyx_t_15[4] = __pyx_mstate_global->__pyx_kp_u_expected_list;
        __pyx_t_19 = 33;
        #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
        __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15[3]);
        #endif
        __pyx_t_12 = 0;
        #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
        __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_15[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_15[3]);
        #endif
        __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_15, 5, __pyx_t_19, __pyx_t_12);
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 612, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

 613:                     val_type,

 614:                     annotated_type

 615:                 )

 616:             # List content validation is more complex and should be done in parsing

+617:             return {}

      __pyx_t_8 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 617, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_8);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_8 = 0;
      goto __pyx_L0;

 618:         # For sets

+619:         elif F.origin in (set, frozenset):

    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_origin_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 619, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_2 = __Pyx_PyObject_RichCompareBool(__pyx_t_8, ((PyObject *)(&PySet_Type)), Py_EQ); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 619, __pyx_L1_error)
    if (!__pyx_t_2) {

    } else {

      __pyx_t_23 = __pyx_t_2;

      goto __pyx_L50_bool_binop_done;
    }
    __pyx_t_2 = __Pyx_PyObject_RichCompareBool(__pyx_t_8, ((PyObject *)(&PyFrozenSet_Type)), Py_EQ); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 619, __pyx_L1_error)

    __pyx_t_23 = __pyx_t_2;

    __pyx_L50_bool_binop_done:;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_2 = __pyx_t_23;


    if (__pyx_t_2) {
/* … */
    }

+620:             if not isinstance(value, F.origin):

      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_origin_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 620, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_2 = PyObject_IsInstance(__pyx_v_value, __pyx_t_8); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 620, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_23 = (!__pyx_t_2);


      if (__pyx_t_23) {
/* … */
      }

+621:                 return _create_error(

        __pyx_t_13 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_17, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 621, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        {
          PyObject *__pyx_temp;
          {
            __pyx_temp = __pyx_r;
            __pyx_r = ((PyObject*)__pyx_t_13);
          }
          __Pyx_XDECREF(__pyx_temp);
        }
        __pyx_t_13 = 0;
        goto __pyx_L0;

 622:                     name,

 623:                     value,

+624:                     f"Invalid type for {annotated_type}.{name}, expected {F.origin}",

        __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 624, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_1 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 624, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_origin_2); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 624, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        __pyx_t_13 = __Pyx_PyObject_FormatSimple(__pyx_t_17, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 624, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_for;
        __pyx_t_10[1] = __pyx_t_8;
        __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u__8;
        __pyx_t_10[3] = __pyx_t_1;
        __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_expected;
        __pyx_t_10[5] = __pyx_t_13;
        __pyx_t_19 = 29;
        #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
        __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[5]);
        #endif
        __pyx_t_12 = 0;
        #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
        __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_10[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[5]);
        #endif
        __pyx_t_17 = __Pyx_PyUnicode_Join(__pyx_t_10, 6, __pyx_t_19, __pyx_t_12);
        if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 624, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

 625:                     val_type,

 626:                     annotated_type

 627:                 )

+628:             return {}

      __pyx_t_13 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 628, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_13);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_13 = 0;
      goto __pyx_L0;

 629:         # For dictionaries

+630:         elif F.origin is dict:

    __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_origin_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 630, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    __pyx_t_23 = (__pyx_t_13 == ((PyObject *)(&PyDict_Type)));
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    if (__pyx_t_23) {
/* … */
    }

+631:             if not isinstance(value, dict):

      __pyx_t_23 = PyDict_Check(__pyx_v_value); 
      __pyx_t_2 = (!__pyx_t_23);


      if (__pyx_t_2) {
/* … */
      }

+632:                 return _create_error(

        __pyx_t_17 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_1, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 632, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        {
          PyObject *__pyx_temp;
          {
            __pyx_temp = __pyx_r;
            __pyx_r = ((PyObject*)__pyx_t_17);
          }
          __Pyx_XDECREF(__pyx_temp);
        }
        __pyx_t_17 = 0;
        goto __pyx_L0;

 633:                     name,

 634:                     value,

+635:                     f"Invalid type for {annotated_type}.{name}, expected dict",

        __pyx_t_13 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 635, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_17 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 635, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        __pyx_t_15[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_for;
        __pyx_t_15[1] = __pyx_t_13;
        __pyx_t_15[2] = __pyx_mstate_global->__pyx_kp_u__8;
        __pyx_t_15[3] = __pyx_t_17;
        __pyx_t_15[4] = __pyx_mstate_global->__pyx_kp_u_expected_dict;
        __pyx_t_19 = 33;
        #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
        __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15[3]);
        #endif
        __pyx_t_12 = 0;
        #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
        __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_15[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_15[3]);
        #endif
        __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_15, 5, __pyx_t_19, __pyx_t_12);
        if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 635, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

 636:                     val_type,

 637:                     annotated_type

 638:                 )

+639:             return {}

      __pyx_t_17 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 639, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_17);
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_17);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_17 = 0;
      goto __pyx_L0;

 640:         # Handle Optional Types:

+641:         elif _is_union(F.origin) and type(None) in F.args:

    __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_origin_2); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 641, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_17);
    __pyx_t_23 = __pyx_f_9datamodel_10validation__is_union(__pyx_t_17); if (unlikely(__pyx_t_23 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
    if (__pyx_t_23) {

    } else {

      __pyx_t_2 = __pyx_t_23;

      goto __pyx_L54_bool_binop_done;
    }
    __pyx_t_17 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 641, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_17);
    __pyx_t_23 = (__Pyx_PySequence_ContainsTF(((PyObject *)Py_TYPE(Py_None)), __pyx_t_17, Py_EQ)); if (unlikely((__pyx_t_23 < 0))) __PYX_ERR(0, 641, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;

    __pyx_t_2 = __pyx_t_23;

    __pyx_L54_bool_binop_done:;
    if (__pyx_t_2) {
/* … */
    }

+642:             inner_types = [t for t in F.args if t is not type(None)]

      { /* enter inner scope */
        __pyx_t_17 = PyList_New(0); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 642, __pyx_L58_error)
        __Pyx_GOTREF(__pyx_t_17);
        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 642, __pyx_L58_error)
        __Pyx_GOTREF(__pyx_t_1);
        if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
          __pyx_t_13 = __pyx_t_1; __Pyx_INCREF(__pyx_t_13);
          __pyx_t_19 = 0;
          __pyx_t_16 = NULL;
        } else {
          __pyx_t_19 = -1; __pyx_t_13 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 642, __pyx_L58_error)
          __Pyx_GOTREF(__pyx_t_13);
          __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_13); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 642, __pyx_L58_error)
        }
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        for (;;) {
          if (likely(!__pyx_t_16)) {
            if (likely(PyList_CheckExact(__pyx_t_13))) {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_13);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 642, __pyx_L58_error)
                #endif
                if (__pyx_t_19 >= __pyx_temp) break;
              }
              __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_13, __pyx_t_19, __Pyx_ReferenceSharing_OwnStrongReference);
              ++__pyx_t_19;
            } else {
              {
                Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_13);
                #if !CYTHON_ASSUME_SAFE_SIZE
                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 642, __pyx_L58_error)
                #endif
                if (__pyx_t_19 >= __pyx_temp) break;
              }
              #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
              __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_13, __pyx_t_19));
              #else
              __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_13, __pyx_t_19);
              #endif
              ++__pyx_t_19;
            }
            if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 642, __pyx_L58_error)
          } else {
            __pyx_t_1 = __pyx_t_16(__pyx_t_13);
            if (unlikely(!__pyx_t_1)) {
              PyObject* exc_type = PyErr_Occurred();
              if (exc_type) {
                if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 642, __pyx_L58_error)
                PyErr_Clear();
              }
              break;
            }
          }
          __Pyx_GOTREF(__pyx_t_1);
          __Pyx_XDECREF_SET(__pyx_8genexpr2__pyx_v_t, __pyx_t_1);
          __pyx_t_1 = 0;
          __pyx_t_2 = (__pyx_8genexpr2__pyx_v_t != ((PyObject *)Py_TYPE(Py_None)));
          if (__pyx_t_2) {

            if (unlikely(__Pyx_ListComp_Append(__pyx_t_17, __pyx_8genexpr2__pyx_v_t))) __PYX_ERR(0, 642, __pyx_L58_error)
          }
        }
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_t); __pyx_8genexpr2__pyx_v_t = 0;
        goto __pyx_L63_exit_scope;
        __pyx_L58_error:;
        __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_t); __pyx_8genexpr2__pyx_v_t = 0;
        goto __pyx_L1_error;
        __pyx_L63_exit_scope:;
      } /* exit inner scope */
      __pyx_v_inner_types = __pyx_t_17;
      __pyx_t_17 = 0;

 643:             # If value is None then that is valid:

+644:             if value is None:

      __pyx_t_2 = (__pyx_v_value == Py_None);
      if (__pyx_t_2) {
/* … */
      }

+645:                 return {}

        __pyx_t_17 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 645, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        {
          PyObject *__pyx_temp;
          {
            __pyx_temp = __pyx_r;
            __pyx_r = ((PyObject*)__pyx_t_17);
          }
          __Pyx_XDECREF(__pyx_temp);
        }
        __pyx_t_17 = 0;
        goto __pyx_L0;

 646:             # Otherwise check that value is an instance of at least one inner type:

+647:             for t in inner_types:

      __pyx_t_17 = __pyx_v_inner_types; __Pyx_INCREF(__pyx_t_17);
      __pyx_t_19 = 0;
      for (;;) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_17);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 647, __pyx_L1_error)
          #endif
          if (__pyx_t_19 >= __pyx_temp) break;
        }
        __pyx_t_13 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_17, __pyx_t_19, __Pyx_ReferenceSharing_OwnStrongReference);
        ++__pyx_t_19;
        if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 647, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_13);
        __pyx_t_13 = 0;
/* … */
      }
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      goto __pyx_L70_for_end;
      __pyx_L66_break:;
      __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
      goto __pyx_L70_for_end;
      __pyx_L70_for_end:;

+648:                 base_type = get_origin(t) or t

        __pyx_t_8 = NULL;
        __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_origin); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 648, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_9 = 1;
        #if CYTHON_UNPACK_METHODS
        if (unlikely(PyMethod_Check(__pyx_t_4))) {
          __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4);
          assert(__pyx_t_8);
          PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
          __Pyx_INCREF(__pyx_t_8);
          __Pyx_INCREF(__pyx__function);
          __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
          __pyx_t_9 = 0;
        }
        #endif
        {
          PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_t};
          __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
          __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 648, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
        }
        __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 648, __pyx_L1_error)
        if (!__pyx_t_2) {
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        } else {
          __Pyx_INCREF(__pyx_t_1);
          __pyx_t_13 = __pyx_t_1;
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          goto __pyx_L67_bool_binop_done;
        }
        __Pyx_INCREF(__pyx_v_t);
        __pyx_t_13 = __pyx_v_t;
        __pyx_L67_bool_binop_done:;
        __Pyx_XDECREF_SET(__pyx_v_base_type, __pyx_t_13);
        __pyx_t_13 = 0;

+649:                 if isinstance(value, base_type):

        __pyx_t_2 = PyObject_IsInstance(__pyx_v_value, __pyx_v_base_type); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 649, __pyx_L1_error)
        if (__pyx_t_2) {
/* … */
        }

+650:                     _valid = True

          __pyx_v__valid = 1;

+651:                     break

          goto __pyx_L66_break;

+652:             if not _valid:

      __pyx_t_2 = (!__pyx_v__valid);

      if (__pyx_t_2) {
/* … */
      }

+653:                 return _create_error(

        __pyx_t_1 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_4, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 653, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        {
          PyObject *__pyx_temp;
          {
            __pyx_temp = __pyx_r;
            __pyx_r = ((PyObject*)__pyx_t_1);
          }
          __Pyx_XDECREF(__pyx_temp);
        }
        __pyx_t_1 = 0;
        goto __pyx_L0;

 654:                     name,

 655:                     value,

+656:                     f"Invalid type for {annotated_type}.{name}, expected one of {inner_types}",

        __pyx_t_17 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 656, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_17);
        __pyx_t_13 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 656, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_inner_types, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 656, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_for;
        __pyx_t_10[1] = __pyx_t_17;
        __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u__8;
        __pyx_t_10[3] = __pyx_t_13;
        __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_expected_one_of;
        __pyx_t_10[5] = __pyx_t_1;
        __pyx_t_19 = 36;
        #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
        __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[5]);
        #endif
        __pyx_t_12 = 0;
        #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
        __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_10[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[5]);
        #endif
        __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_10, 6, __pyx_t_19, __pyx_t_12);
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 656, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 657:                     val_type,

 658:                     annotated_type

 659:                 )

+660:     elif type(annotated_type).__name__ == "ModelMeta":

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_annotated_type)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 660, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_CompareBoolEq_object_str(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ModelMeta, Py_EQ); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 660, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_2) {
/* … */
    goto __pyx_L19;
  }

 661:         # If value is already an instance of the expected type, it's valid

+662:         if isinstance(value, annotated_type):

    __pyx_t_2 = PyObject_IsInstance(__pyx_v_value, __pyx_v_annotated_type); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 662, __pyx_L1_error)
    if (__pyx_t_2) {
/* … */
    }

+663:             return {}

      __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 663, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_1);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_1 = 0;
      goto __pyx_L0;

 664:         # Check if there's a field in the annotated type that matches the name and type

+665:         if as_objects:

    if (__pyx_v_as_objects) {
/* … */
      goto __pyx_L73;
    }

+666:             try:

      {
        /*try:*/ {
/* … */
        }
        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
        goto __pyx_L79_try_end;
        __pyx_L74_error:;
        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
        __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
/* … */
        __pyx_L76_except_error:;
        __Pyx_XGIVEREF(__pyx_t_7);
        __Pyx_XGIVEREF(__pyx_t_6);
        __Pyx_XGIVEREF(__pyx_t_5);
        __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_6, __pyx_t_5);
        goto __pyx_L1_error;
        __pyx_L77_except_return:;
        __Pyx_XGIVEREF(__pyx_t_7);
        __Pyx_XGIVEREF(__pyx_t_6);
        __Pyx_XGIVEREF(__pyx_t_5);
        __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_6, __pyx_t_5);
        goto __pyx_L0;
        __pyx_L79_try_end:;
      }

+667:                 field = annotated_type.get_column(name)

          __pyx_t_4 = __pyx_v_annotated_type;
          __Pyx_INCREF(__pyx_t_4);
          __pyx_t_9 = 0;
          {
            PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_name};
            __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_column, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
            __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
            if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 667, __pyx_L74_error)
            __Pyx_GOTREF(__pyx_t_1);
          }
          __pyx_v_field = __pyx_t_1;
          __pyx_t_1 = 0;

+668:             except AttributeError as e:

        __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_AttributeError))));
        if (__pyx_t_12) {
          __Pyx_AddTraceback("datamodel.validation._validation", __pyx_clineno, __pyx_lineno, __pyx_filename);
          if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_4, &__pyx_t_13) < 0) __PYX_ERR(0, 668, __pyx_L76_except_error)
          __Pyx_XGOTREF(__pyx_t_1);
          __Pyx_XGOTREF(__pyx_t_4);
          __Pyx_XGOTREF(__pyx_t_13);
          __Pyx_INCREF(__pyx_t_4);
          __pyx_v_e = __pyx_t_4;
          /*try:*/ {
/* … */
          /*finally:*/ {
            __pyx_L85_error:;
            /*exception exit:*/{
              __Pyx_PyThreadState_declare
              __Pyx_PyThreadState_assign
              __pyx_t_27 = 0; __pyx_t_28 = 0; __pyx_t_29 = 0; __pyx_t_30 = 0; __pyx_t_31 = 0; __pyx_t_32 = 0;
              __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
              __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
              __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
               __Pyx_ExceptionSwap(&__pyx_t_30, &__pyx_t_31, &__pyx_t_32);
              if ( unlikely(__Pyx_GetException(&__pyx_t_27, &__pyx_t_28, &__pyx_t_29) < 0)) __Pyx_ErrFetch(&__pyx_t_27, &__pyx_t_28, &__pyx_t_29);
              __Pyx_XGOTREF(__pyx_t_27);
              __Pyx_XGOTREF(__pyx_t_28);
              __Pyx_XGOTREF(__pyx_t_29);
              __Pyx_XGOTREF(__pyx_t_30);
              __Pyx_XGOTREF(__pyx_t_31);
              __Pyx_XGOTREF(__pyx_t_32);
              __pyx_t_12 = __pyx_lineno; __pyx_t_25 = __pyx_clineno; __pyx_t_26 = __pyx_filename;
              {
                __Pyx_DECREF(__pyx_v_e); __pyx_v_e = 0;
              }
              __Pyx_XGIVEREF(__pyx_t_30);
              __Pyx_XGIVEREF(__pyx_t_31);
              __Pyx_XGIVEREF(__pyx_t_32);
              __Pyx_ExceptionReset(__pyx_t_30, __pyx_t_31, __pyx_t_32);
              __Pyx_XGIVEREF(__pyx_t_27);
              __Pyx_XGIVEREF(__pyx_t_28);
              __Pyx_XGIVEREF(__pyx_t_29);
              __Pyx_ErrRestore(__pyx_t_27, __pyx_t_28, __pyx_t_29);
              __pyx_t_27 = 0; __pyx_t_28 = 0; __pyx_t_29 = 0; __pyx_t_30 = 0; __pyx_t_31 = 0; __pyx_t_32 = 0;
              __pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_25; __pyx_filename = __pyx_t_26;
              goto __pyx_L76_except_error;
            }
            __pyx_L84_return: {
              __pyx_t_33 = __pyx_r;
              __pyx_r = 0;
              __Pyx_DECREF(__pyx_v_e); __pyx_v_e = 0;
              __pyx_r = __pyx_t_33;
              __pyx_t_33 = 0;
              goto __pyx_L77_except_return;
            }
          }
        }
        goto __pyx_L76_except_error;

+669:                 return _create_error(name, value, f'{annotated_type} has no column {name}', val_type, annotated_type, e)

            __pyx_t_17 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 669, __pyx_L85_error)
            __Pyx_GOTREF(__pyx_t_17);
            __pyx_t_8 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 669, __pyx_L85_error)
            __Pyx_GOTREF(__pyx_t_8);
            __pyx_t_14[0] = __pyx_t_17;
            __pyx_t_14[1] = __pyx_mstate_global->__pyx_kp_u_has_no_column;
            __pyx_t_14[2] = __pyx_t_8;
            __pyx_t_19 = 15;
            #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
            __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_14[0]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_14[2]);
            #endif
            __pyx_t_12 = 0;
            #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
            __pyx_t_12 |= __Pyx_PyUnicode_KIND_04(__pyx_t_14[0]) | __Pyx_PyUnicode_KIND_04(__pyx_t_14[2]);
            #endif
            __pyx_t_20 = __Pyx_PyUnicode_Join(__pyx_t_14, 3, __pyx_t_19, __pyx_t_12);
            if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 669, __pyx_L85_error)
            __Pyx_GOTREF(__pyx_t_20);
            __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
            __pyx_t_24.__pyx_n = 1;
            __pyx_t_24.exception = __pyx_v_e;
            __pyx_t_8 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_20, __pyx_v_val_type, __pyx_v_annotated_type, &__pyx_t_24); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 669, __pyx_L85_error)
            __Pyx_GOTREF(__pyx_t_8);
            __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
            {
              PyObject *__pyx_temp;
              {
                __pyx_temp = __pyx_r;
                __pyx_r = ((PyObject*)__pyx_t_8);
              }
              __Pyx_XDECREF(__pyx_temp);
            }
            __pyx_t_8 = 0;
            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
            goto __pyx_L84_return;
          }

+670:             ftype = field.type

      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_field, __pyx_mstate_global->__pyx_n_u_type_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 670, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_v_ftype = __pyx_t_13;
      __pyx_t_13 = 0;

+671:             if ftype <> val_type:

      __pyx_t_2 = __Pyx_PyObject_CompareBoolNe_object_object(__pyx_v_ftype, __pyx_v_val_type, Py_NE); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 671, __pyx_L1_error)
      if (__pyx_t_2) {
/* … */
      }

+672:                 return _create_error(

        __pyx_t_1 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_8, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 672, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        {
          PyObject *__pyx_temp;
          {
            __pyx_temp = __pyx_r;
            __pyx_r = ((PyObject*)__pyx_t_1);
          }
          __Pyx_XDECREF(__pyx_temp);
        }
        __pyx_t_1 = 0;
        goto __pyx_L0;

 673:                     name,

 674:                     value,

+675:                     f"Invalid type for {annotated_type}.{name}, expected {ftype}",

        __pyx_t_13 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 675, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_13);
        __pyx_t_4 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 675, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_ftype, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 675, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_for;
        __pyx_t_10[1] = __pyx_t_13;
        __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u__8;
        __pyx_t_10[3] = __pyx_t_4;
        __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_expected;
        __pyx_t_10[5] = __pyx_t_1;
        __pyx_t_19 = 29;
        #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
        __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[5]);
        #endif
        __pyx_t_25 = 0;
        #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
        __pyx_t_25 |= __Pyx_PyUnicode_KIND_04(__pyx_t_10[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[5]);
        #endif
        __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_10, 6, __pyx_t_19, __pyx_t_25);
        if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 675, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 676:                     val_type,

 677:                     annotated_type

 678:                 )

 679:         else:

 680:             # Validate primary key

+681:             pk_field = get_primary_key_field(annotated_type, name, field_meta)

    /*else*/ {
      __pyx_t_1 = __pyx_f_9datamodel_10validation_get_primary_key_field(__pyx_v_annotated_type, __pyx_v_name, __pyx_v_field_meta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 681, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_v_pk_field = __pyx_t_1;
      __pyx_t_1 = 0;

+682:             if pk_field:

      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_pk_field); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 682, __pyx_L1_error)
      if (__pyx_t_2) {
/* … */
      }
    }
    __pyx_L73:;

+683:                 pk_type = pk_field.type

        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_pk_field, __pyx_mstate_global->__pyx_n_u_type_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 683, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_1);
        __pyx_v_pk_type = __pyx_t_1;
        __pyx_t_1 = 0;

+684:                 if not isinstance(value, pk_type):

        __pyx_t_2 = PyObject_IsInstance(__pyx_v_value, __pyx_v_pk_type); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 684, __pyx_L1_error)
        __pyx_t_23 = (!__pyx_t_2);


        if (__pyx_t_23) {
/* … */
        }

+685:                     return _create_error(

          __pyx_t_8 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_13, __pyx_v_val_type, __pyx_v_pk_type, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 685, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
          {
            PyObject *__pyx_temp;
            {
              __pyx_temp = __pyx_r;
              __pyx_r = ((PyObject*)__pyx_t_8);
            }
            __Pyx_XDECREF(__pyx_temp);
          }
          __pyx_t_8 = 0;
          goto __pyx_L0;

 686:                         name,

 687:                         value,

+688:                         f"Invalid type for {annotated_type}.{pk_field.name}, expected {pk_type}",

          __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 688, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_1);
          __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_pk_field, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 688, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_8, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 688, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_pk_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 688, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_for;
          __pyx_t_10[1] = __pyx_t_1;
          __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u__8;
          __pyx_t_10[3] = __pyx_t_4;
          __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_expected;
          __pyx_t_10[5] = __pyx_t_8;
          __pyx_t_19 = 29;
          #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
          __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[5]);
          #endif
          __pyx_t_25 = 0;
          #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
          __pyx_t_25 |= __Pyx_PyUnicode_KIND_04(__pyx_t_10[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[5]);
          #endif
          __pyx_t_13 = __Pyx_PyUnicode_Join(__pyx_t_10, 6, __pyx_t_19, __pyx_t_25);
          if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 688, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_13);
          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;

 689:                         val_type,

 690:                         pk_type

 691:                     )

+692:     elif is_optional_type(annotated_type):

  __pyx_t_23 = __pyx_f_9datamodel_10validation_is_optional_type(__pyx_v_annotated_type, 0); if (unlikely(__pyx_t_23 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 692, __pyx_L1_error)
  if (__pyx_t_23) {
/* … */
    goto __pyx_L19;
  }

+693:         inner_types = get_args(annotated_type)

    __pyx_t_13 = NULL;
    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_get_args); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 693, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_9 = 1;
    #if CYTHON_UNPACK_METHODS
    if (unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4);
      assert(__pyx_t_13);
      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_13);
      __Pyx_INCREF(__pyx__function);
      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
      __pyx_t_9 = 0;
    }
    #endif
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_v_annotated_type};
      __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 693, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
    }
    __pyx_v_inner_types = __pyx_t_8;
    __pyx_t_8 = 0;

+694:         for t in inner_types:

    if (likely(PyList_CheckExact(__pyx_v_inner_types)) || PyTuple_CheckExact(__pyx_v_inner_types)) {
      __pyx_t_8 = __pyx_v_inner_types; __Pyx_INCREF(__pyx_t_8);
      __pyx_t_19 = 0;
      __pyx_t_16 = NULL;
    } else {
      __pyx_t_19 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_v_inner_types); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 694, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_16 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 694, __pyx_L1_error)
    }
    for (;;) {
      if (likely(!__pyx_t_16)) {
        if (likely(PyList_CheckExact(__pyx_t_8))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_8);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 694, __pyx_L1_error)
            #endif
            if (__pyx_t_19 >= __pyx_temp) break;
          }
          __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_8, __pyx_t_19, __Pyx_ReferenceSharing_OwnStrongReference);
          ++__pyx_t_19;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_8);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 694, __pyx_L1_error)
            #endif
            if (__pyx_t_19 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_19));
          #else
          __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_8, __pyx_t_19);
          #endif
          ++__pyx_t_19;
        }
        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 694, __pyx_L1_error)
      } else {
        __pyx_t_4 = __pyx_t_16(__pyx_t_8);
        if (unlikely(!__pyx_t_4)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 694, __pyx_L1_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);
      __pyx_t_4 = 0;
/* … */
    }
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    goto __pyx_L99_for_else;
    __pyx_L95_break:;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    goto __pyx_L100_for_end;
    /*else*/ {
      __pyx_L99_for_else:;

+695:             if t is type(None) and value is None:

      __pyx_t_2 = (__pyx_v_t == ((PyObject *)Py_TYPE(Py_None)));
      if (__pyx_t_2) {

      } else {

        __pyx_t_23 = __pyx_t_2;

        goto __pyx_L97_bool_binop_done;
      }
      __pyx_t_2 = (__pyx_v_value == Py_None);

      __pyx_t_23 = __pyx_t_2;

      __pyx_L97_bool_binop_done:;
      if (__pyx_t_23) {
/* … */
      }

+696:                 break

        goto __pyx_L95_break;

+697:             elif is_instanceof(val_type, t):

      __pyx_t_23 = __pyx_f_9datamodel_10validation_is_instanceof(__pyx_v_val_type, __pyx_v_t); if (unlikely(__pyx_t_23 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 697, __pyx_L1_error)
      if (__pyx_t_23) {
/* … */
      }

+698:                 break

        goto __pyx_L95_break;

+699:             elif val_type == t:

      __pyx_t_23 = __Pyx_PyObject_CompareBoolEq_object_object(__pyx_v_val_type, __pyx_v_t, Py_EQ); if (unlikely((__pyx_t_23 < 0))) __PYX_ERR(0, 699, __pyx_L1_error)
      if (__pyx_t_23) {
/* … */
      }

+700:                 break

        goto __pyx_L95_break;

 701:         else:

+702:             return _create_error(

      __pyx_t_13 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_1, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 702, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_13);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_13 = 0;
      goto __pyx_L0;
    }
    __pyx_L100_for_end:;

 703:                 name,

 704:                 value,

+705:                 f"Invalid type for {annotated_type}.{name}, expected one of {inner_types}",

      __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 705, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_4 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 705, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_13 = __Pyx_PyObject_FormatSimple(__pyx_v_inner_types, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 705, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_for;
      __pyx_t_10[1] = __pyx_t_8;
      __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u__8;
      __pyx_t_10[3] = __pyx_t_4;
      __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_expected_one_of;
      __pyx_t_10[5] = __pyx_t_13;
      __pyx_t_19 = 36;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[5]);
      #endif
      __pyx_t_25 = 0;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_25 |= __Pyx_PyUnicode_KIND_04(__pyx_t_10[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[5]);
      #endif
      __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_10, 6, __pyx_t_19, __pyx_t_25);
      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 705, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;

 706:                 val_type,

 707:                 annotated_type

 708:             )

+709:     elif val_type != annotated_type:

  __pyx_t_23 = __Pyx_PyObject_CompareBoolNe_object_object(__pyx_v_val_type, __pyx_v_annotated_type, Py_NE); if (unlikely((__pyx_t_23 < 0))) __PYX_ERR(0, 709, __pyx_L1_error)
  if (__pyx_t_23) {
/* … */
  }
  __pyx_L19:;

+710:         instance = is_instanceof(value, annotated_type)

    __pyx_t_23 = __pyx_f_9datamodel_10validation_is_instanceof(__pyx_v_value, __pyx_v_annotated_type); if (unlikely(__pyx_t_23 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 710, __pyx_L1_error)
    __pyx_v_instance = __pyx_t_23;

+711:         if not instance:

    __pyx_t_23 = (!__pyx_v_instance);

    if (__pyx_t_23) {
/* … */
    }

+712:             return _create_error(

      __pyx_t_4 = __pyx_f_9datamodel_10validation__create_error(__pyx_v_name, __pyx_v_value, __pyx_t_8, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 712, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_4);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_4 = 0;
      goto __pyx_L0;

 713:                 name,

 714:                 value,

+715:                 f"Invalid Instance for {annotated_type}.{name}, expected {annotated_type}",

      __pyx_t_13 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 715, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __pyx_t_1 = __Pyx_PyUnicode_Unicode(__pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 715, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 715, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_Instance_for;
      __pyx_t_10[1] = __pyx_t_13;
      __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u__8;
      __pyx_t_10[3] = __pyx_t_1;
      __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_expected;
      __pyx_t_10[5] = __pyx_t_4;
      __pyx_t_19 = 33;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_19 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10[5]);
      #endif
      __pyx_t_25 = 0;
      #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
      __pyx_t_25 |= __Pyx_PyUnicode_KIND_04(__pyx_t_10[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_10[5]);
      #endif
      __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_10, 6, __pyx_t_19, __pyx_t_25);
      if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 715, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

 716:                 val_type,

 717:                 annotated_type

 718:             )

+719:     return error

  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __Pyx_INCREF(__pyx_v_error);
      __pyx_r = __pyx_v_error;
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  goto __pyx_L0;

 720: 

 721: # Define a validator function for uint64

+722: def validate_uint64(value: int) -> None:

/* Python wrapper */
static PyObject *__pyx_pw_9datamodel_10validation_5validate_uint64(PyObject *__pyx_self, 
#if CYTHON_VECTORCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
); /*proto*/
PyDoc_STRVAR(__pyx_doc_9datamodel_10validation_4validate_uint64, "validate_uint64(int value: int) -> None\n\nValidate uint64 values.\n    ");
static PyMethodDef __pyx_mdef_9datamodel_10validation_5validate_uint64 = {"validate_uint64", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9datamodel_10validation_5validate_uint64, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9datamodel_10validation_4validate_uint64};
static PyObject *__pyx_pw_9datamodel_10validation_5validate_uint64(PyObject *__pyx_self, 
#if CYTHON_VECTORCALL
PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
#else
PyObject *__pyx_args, PyObject *__pyx_kwds
#endif
) {
  PyObject *__pyx_v_value = 0;
  #if !CYTHON_VECTORCALL
  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
  #endif
  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("validate_uint64 (wrapper)", 0);
  #if !CYTHON_VECTORCALL
  #if CYTHON_ASSUME_SAFE_SIZE
  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
  #else
  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
  #endif
  #endif
  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
  {
    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_value,0};
  PyObject* values[1] = {0};
    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
    if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 722, __pyx_L3_error)
    if (__pyx_kwds_len > 0) {
      switch (__pyx_nargs) {
        case  1:
        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 722, __pyx_L3_error)
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      const Py_ssize_t kwd_pos_args = __pyx_nargs;
      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "validate_uint64", 0) < (0)) __PYX_ERR(0, 722, __pyx_L3_error)
      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("validate_uint64", 1, 1, 1, i); __PYX_ERR(0, 722, __pyx_L3_error) }
      }
    } else if (unlikely(__pyx_nargs != 1)) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 722, __pyx_L3_error)
    }
    if (__Pyx_PyInt_FromNumber(&values[0], "value", 0) < (0)) __PYX_ERR(0, 722, __pyx_L3_error)
    __pyx_v_value = ((PyObject*)values[0]);
  }
  goto __pyx_L6_skip;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("validate_uint64", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 722, __pyx_L3_error)
  __pyx_L6_skip:;
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __Pyx_AddTraceback("datamodel.validation.validate_uint64", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_value), (&PyLong_Type), 0, "value", 2))) __PYX_ERR(0, 722, __pyx_L1_error)
  __pyx_r = __pyx_pf_9datamodel_10validation_4validate_uint64(__pyx_self, __pyx_v_value);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  goto __pyx_L7_cleaned_up;
  __pyx_L0:;
  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
    Py_XDECREF(values[__pyx_temp]);
  }
  __pyx_L7_cleaned_up:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_9datamodel_10validation_4validate_uint64(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_value) {
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("datamodel.validation.validate_uint64", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_value, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 722, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < (0)) __PYX_ERR(0, 722, __pyx_L1_error)
  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_9datamodel_10validation_5validate_uint64, 0, __pyx_mstate_global->__pyx_n_u_validate_uint64, NULL, __pyx_mstate_global->__pyx_n_u_datamodel_validation, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 722, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6);
  #endif
  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_6, __pyx_t_2);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_validate_uint64, __pyx_t_6) < (0)) __PYX_ERR(0, 722, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;

 723:     """Validate uint64 values.

 724:     """

+725:     if value < uint64_min or value > uint64_max:

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_uint64_min); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 725, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_CompareBoolLt_int_object(__pyx_v_value, __pyx_t_2, Py_LT); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 725, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!__pyx_t_3) {

  } else {

    __pyx_t_1 = __pyx_t_3;

    goto __pyx_L4_bool_binop_done;
  }
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_uint64_max); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 725, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_CompareBoolGt_int_object(__pyx_v_value, __pyx_t_2, Py_GT); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 725, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  __pyx_t_1 = __pyx_t_3;

  __pyx_L4_bool_binop_done:;
  if (unlikely(__pyx_t_1)) {
/* … */
  }

+726:         raise ValueError(f"{value} is not a valid uint64")

    __pyx_t_4 = NULL;
    __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_value, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 726, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyUnicode_Concat__Pyx_ReferenceSharing_OwnStrongReferenceInPlace(__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_is_not_a_valid_uint64); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 726, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_7 = 1;
    {
      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6};
      __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 726, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
    }
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(0, 726, __pyx_L1_error)

 727: 

+728: cdef dict validate_type(object F, object name, object value, object annotated_type, object val_type):

static PyObject *__pyx_f_9datamodel_10validation_validate_type(PyObject *__pyx_v_F, PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_annotated_type, PyObject *__pyx_v_val_type) {
  PyObject *__pyx_v_inner_types = NULL;
  PyObject *__pyx_v_allowed = NULL;
  PyObject *__pyx_v_expected = NULL;
  PyObject *__pyx_8genexpr3__pyx_v_t = NULL;
  PyObject *__pyx_r = NULL;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("datamodel.validation.validate_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_inner_types);
  __Pyx_XDECREF(__pyx_v_allowed);
  __Pyx_XDECREF(__pyx_v_expected);
  __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_t);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 729:     """

 730:     Validate that 'value' is of type 'annotated_type'.

 731:     If 'annotated_type' is a Union, checks if 'value' is an instance of any of the union types.

 732:     Returns None if valid; otherwise, returns an error object via _create_error.

 733:     """

+734:     if not isinstance(value, type):

  __pyx_t_1 = PyType_Check(__pyx_v_value); 
  __pyx_t_2 = (!__pyx_t_1);


  if (__pyx_t_2) {
/* … */
  }

+735:         return _create_error(name, value, f'Invalid type for {annotated_type}.{name}, expected a type', val_type, annotated_type)

    __pyx_t_3 = __pyx_v_name;
    __Pyx_INCREF(__pyx_t_3);
    if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_t_3))) __PYX_ERR(0, 735, __pyx_L1_error)
    __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 735, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_name, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 735, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_for;
    __pyx_t_6[1] = __pyx_t_4;
    __pyx_t_6[2] = __pyx_mstate_global->__pyx_kp_u__8;
    __pyx_t_6[3] = __pyx_t_5;
    __pyx_t_6[4] = __pyx_mstate_global->__pyx_kp_u_expected_a_type;
    __pyx_t_7 = 35;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6[3]);
    #endif
    __pyx_t_8 = 0;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_8 |= __Pyx_PyUnicode_KIND_04(__pyx_t_6[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_6[3]);
    #endif
    __pyx_t_9 = __Pyx_PyUnicode_Join(__pyx_t_6, 5, __pyx_t_7, __pyx_t_8);
    if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 735, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __pyx_f_9datamodel_10validation__create_error(((PyObject*)__pyx_t_3), __pyx_v_value, __pyx_t_9, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 735, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_5);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_5 = 0;
    goto __pyx_L0;

+736:     inner_types = get_args(F.args[0])

  __pyx_t_9 = NULL;
  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 736, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 736, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyLong_From_long, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 736, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_11 = 1;
  #if CYTHON_UNPACK_METHODS
  if (unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3);
    assert(__pyx_t_9);
    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
    __Pyx_INCREF(__pyx_t_9);
    __Pyx_INCREF(__pyx__function);
    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
    __pyx_t_11 = 0;
  }
  #endif
  {
    PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_10};
    __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 736, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
  }
  __pyx_v_inner_types = __pyx_t_5;
  __pyx_t_5 = 0;

+737:     for allowed in inner_types:

  if (likely(PyList_CheckExact(__pyx_v_inner_types)) || PyTuple_CheckExact(__pyx_v_inner_types)) {
    __pyx_t_5 = __pyx_v_inner_types; __Pyx_INCREF(__pyx_t_5);
    __pyx_t_7 = 0;
    __pyx_t_12 = NULL;
  } else {
    __pyx_t_7 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_v_inner_types); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 737, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 737, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_12)) {
      if (likely(PyList_CheckExact(__pyx_t_5))) {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 737, __pyx_L1_error)
          #endif
          if (__pyx_t_7 >= __pyx_temp) break;
        }
        __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_5, __pyx_t_7, __Pyx_ReferenceSharing_OwnStrongReference);
        ++__pyx_t_7;
      } else {
        {
          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5);
          #if !CYTHON_ASSUME_SAFE_SIZE
          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 737, __pyx_L1_error)
          #endif
          if (__pyx_t_7 >= __pyx_temp) break;
        }
        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
        __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_7));
        #else
        __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_7);
        #endif
        ++__pyx_t_7;
      }
      if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 737, __pyx_L1_error)
    } else {
      __pyx_t_3 = __pyx_t_12(__pyx_t_5);
      if (unlikely(!__pyx_t_3)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 737, __pyx_L1_error)
          PyErr_Clear();
        }
        break;
      }
    }
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_XDECREF_SET(__pyx_v_allowed, __pyx_t_3);
    __pyx_t_3 = 0;
/* … */
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

+738:         if value is allowed:

    __pyx_t_2 = (__pyx_v_value == __pyx_v_allowed);
    if (__pyx_t_2) {
/* … */
    }

+739:             return {}

      __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 739, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      {
        PyObject *__pyx_temp;
        {
          __pyx_temp = __pyx_r;
          __pyx_r = ((PyObject*)__pyx_t_3);
        }
        __Pyx_XDECREF(__pyx_temp);
      }
      __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      goto __pyx_L0;

+740:     expected = ', '.join([str(t) for t in F.args])

  { /* enter inner scope */
    __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 740, __pyx_L10_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_F, __pyx_mstate_global->__pyx_n_u_args_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 740, __pyx_L10_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
      __pyx_t_10 = __pyx_t_3; __Pyx_INCREF(__pyx_t_10);
      __pyx_t_7 = 0;
      __pyx_t_12 = NULL;
    } else {
      __pyx_t_7 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 740, __pyx_L10_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_12 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_10); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 740, __pyx_L10_error)
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    for (;;) {
      if (likely(!__pyx_t_12)) {
        if (likely(PyList_CheckExact(__pyx_t_10))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_10);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 740, __pyx_L10_error)
            #endif
            if (__pyx_t_7 >= __pyx_temp) break;
          }
          __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_10, __pyx_t_7, __Pyx_ReferenceSharing_OwnStrongReference);
          ++__pyx_t_7;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_10);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 740, __pyx_L10_error)
            #endif
            if (__pyx_t_7 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_7));
          #else
          __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_10, __pyx_t_7);
          #endif
          ++__pyx_t_7;
        }
        if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 740, __pyx_L10_error)
      } else {
        __pyx_t_3 = __pyx_t_12(__pyx_t_10);
        if (unlikely(!__pyx_t_3)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 740, __pyx_L10_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_XDECREF_SET(__pyx_8genexpr3__pyx_v_t, __pyx_t_3);
      __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_Unicode(__pyx_8genexpr3__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 740, __pyx_L10_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_GIVEREF(__pyx_t_3);
      if (unlikely(__Pyx_ListComp_AppendAndDecref(__pyx_t_5, __pyx_t_3))) __PYX_ERR(0, 740, __pyx_L10_error)
      __pyx_t_3 = 0;
    }
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_t); __pyx_8genexpr3__pyx_v_t = 0;
    goto __pyx_L14_exit_scope;
    __pyx_L10_error:;
    __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_t); __pyx_8genexpr3__pyx_v_t = 0;
    goto __pyx_L1_error;
    __pyx_L14_exit_scope:;
  } /* exit inner scope */
  __pyx_t_10 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__10, __pyx_t_5); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 740, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_expected = ((PyObject*)__pyx_t_10);
  __pyx_t_10 = 0;

+741:     return _create_error(name, value, f'Invalid type for {annotated_type}.{name}, expected a type of {expected}', val_type, annotated_type)

  __pyx_t_10 = __pyx_v_name;
  __Pyx_INCREF(__pyx_t_10);
  if (!(likely(PyUnicode_CheckExact(__pyx_t_10))||((__pyx_t_10) == Py_None) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_t_10))) __PYX_ERR(0, 741, __pyx_L1_error)
  __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 741, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_name, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 741, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_9 = __Pyx_PyUnicode_Unicode(__pyx_v_expected); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 741, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_13[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_type_for;
  __pyx_t_13[1] = __pyx_t_5;
  __pyx_t_13[2] = __pyx_mstate_global->__pyx_kp_u__8;
  __pyx_t_13[3] = __pyx_t_3;
  __pyx_t_13[4] = __pyx_mstate_global->__pyx_kp_u_expected_a_type_of;
  __pyx_t_13[5] = __pyx_t_9;
  __pyx_t_7 = 39;
  #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
  __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_13[5]);
  #endif
  __pyx_t_8 = 0;
  #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
  __pyx_t_8 |= __Pyx_PyUnicode_KIND_04(__pyx_t_13[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_13[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_13[5]);
  #endif
  __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_13, 6, __pyx_t_7, __pyx_t_8);
  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 741, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_9 = __pyx_f_9datamodel_10validation__create_error(((PyObject*)__pyx_t_10), __pyx_v_value, __pyx_t_4, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 741, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)__pyx_t_9);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  __pyx_t_9 = 0;
  goto __pyx_L0;

 742: 

+743: cdef dict validate_enum(object name, object value, object annotated_type, object val_type):

static PyObject *__pyx_f_9datamodel_10validation_validate_enum(PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_annotated_type, PyObject *__pyx_v_val_type) {
  PyObject *__pyx_v_val = 0;
  PyObject *__pyx_v_enum_values = 0;
  PyObject *__pyx_8genexpr4__pyx_v_e = NULL;
  PyObject *__pyx_r = NULL;

 744:     """

 745:     Validate that 'value' is a valid member of the enum 'annotated_type'.

 746:     If 'value' is an instance of 'annotated_type', use its .value.

 747:     Cache the allowed enum values on the enum type to avoid repeated introspection.

 748:     Returns None if valid; otherwise, returns an error object via _create_error.

 749:     """

+750:     cdef object val = value.value if PyObject_IsInstance(value, annotated_type) else value

  __pyx_t_2 = PyObject_IsInstance(__pyx_v_value, __pyx_v_annotated_type); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 750, __pyx_L1_error)
  if (__pyx_t_2) {
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 750, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = __pyx_t_3;
    __pyx_t_3 = 0;
  } else {
    __Pyx_INCREF(__pyx_v_value);
    __pyx_t_1 = __pyx_v_value;
  }

  __pyx_v_val = __pyx_t_1;
  __pyx_t_1 = 0;

+751:     cdef object enum_values = [e.value for e in annotated_type]

  { /* enter inner scope */
    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 751, __pyx_L5_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (likely(PyList_CheckExact(__pyx_v_annotated_type)) || PyTuple_CheckExact(__pyx_v_annotated_type)) {
      __pyx_t_3 = __pyx_v_annotated_type; __Pyx_INCREF(__pyx_t_3);
      __pyx_t_4 = 0;
      __pyx_t_5 = NULL;
    } else {
      __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_annotated_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 751, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 751, __pyx_L5_error)
    }
    for (;;) {
      if (likely(!__pyx_t_5)) {
        if (likely(PyList_CheckExact(__pyx_t_3))) {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 751, __pyx_L5_error)
            #endif
            if (__pyx_t_4 >= __pyx_temp) break;
          }
          __pyx_t_6 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_3, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference);
          ++__pyx_t_4;
        } else {
          {
            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
            #if !CYTHON_ASSUME_SAFE_SIZE
            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 751, __pyx_L5_error)
            #endif
            if (__pyx_t_4 >= __pyx_temp) break;
          }
          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
          __pyx_t_6 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4));
          #else
          __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_4);
          #endif
          ++__pyx_t_4;
        }
        if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 751, __pyx_L5_error)
      } else {
        __pyx_t_6 = __pyx_t_5(__pyx_t_3);
        if (unlikely(!__pyx_t_6)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 751, __pyx_L5_error)
            PyErr_Clear();
          }
          break;
        }
      }
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_XDECREF_SET(__pyx_8genexpr4__pyx_v_e, __pyx_t_6);
      __pyx_t_6 = 0;
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_8genexpr4__pyx_v_e, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 751, __pyx_L5_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_GIVEREF(__pyx_t_6);
      if (unlikely(__Pyx_ListComp_AppendAndDecref(__pyx_t_1, __pyx_t_6))) __PYX_ERR(0, 751, __pyx_L5_error)
      __pyx_t_6 = 0;
    }
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_e); __pyx_8genexpr4__pyx_v_e = 0;
    goto __pyx_L9_exit_scope;
    __pyx_L5_error:;
    __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_e); __pyx_8genexpr4__pyx_v_e = 0;
    goto __pyx_L1_error;
    __pyx_L9_exit_scope:;
  } /* exit inner scope */
  __pyx_v_enum_values = __pyx_t_1;
  __pyx_t_1 = 0;

+752:     if val not in enum_values:

  __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_val, __pyx_v_enum_values, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 752, __pyx_L1_error)
  if (__pyx_t_2) {
/* … */
  }

+753:         return _create_error(

    __pyx_t_7 = __pyx_f_9datamodel_10validation__create_error(((PyObject*)__pyx_t_1), __pyx_v_value, __pyx_t_10, __pyx_v_val_type, __pyx_v_annotated_type, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 753, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    {
      PyObject *__pyx_temp;
      {
        __pyx_temp = __pyx_r;
        __pyx_r = ((PyObject*)__pyx_t_7);
      }
      __Pyx_XDECREF(__pyx_temp);
    }
    __pyx_t_7 = 0;
    goto __pyx_L0;

+754:             name, value, f"Invalid value for {annotated_type}.{name}, expected one of {enum_values}", val_type, annotated_type

    __pyx_t_1 = __pyx_v_name;
    __Pyx_INCREF(__pyx_t_1);
    if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_t_1))) __PYX_ERR(0, 754, __pyx_L1_error)
    __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_annotated_type, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 754, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_name, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 754, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_enum_values, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 754, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_value_for;
    __pyx_t_8[1] = __pyx_t_3;
    __pyx_t_8[2] = __pyx_mstate_global->__pyx_kp_u__8;
    __pyx_t_8[3] = __pyx_t_6;
    __pyx_t_8[4] = __pyx_mstate_global->__pyx_kp_u_expected_one_of;
    __pyx_t_8[5] = __pyx_t_7;
    __pyx_t_4 = 37;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_4 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8[1]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8[3]) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8[5]);
    #endif
    __pyx_t_9 = 0;
    #if __Pyx_PyUnicode_Join_CAN_USE_KIND_AND_LENGTH
    __pyx_t_9 |= __Pyx_PyUnicode_KIND_04(__pyx_t_8[1]) | __Pyx_PyUnicode_KIND_04(__pyx_t_8[3]) | __Pyx_PyUnicode_KIND_04(__pyx_t_8[5]);
    #endif
    __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_8, 6, __pyx_t_4, __pyx_t_9);
    if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 754, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;

 755:         )

+756:     return {}

  __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 756, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  {
    PyObject *__pyx_temp;
    {
      __pyx_temp = __pyx_r;
      __pyx_r = ((PyObject*)__pyx_t_7);
    }
    __Pyx_XDECREF(__pyx_temp);
  }
  __pyx_t_7 = 0;
  goto __pyx_L0;