in HowTo/gRPC/Linux/OpenAI/LangChain/PyServer/venv/Lib/pydantic/_internal/_generate_schema.py [0:0]
def match_type(self, obj: Any) -> core_schema.CoreSchema: # noqa: C901
"""Main mapping of types to schemas.
The general structure is a series of if statements starting with the simple cases
(non-generic primitive types) and then handling generics and other more complex cases.
Each case either generates a schema directly, calls into a public user-overridable method
(like `GenerateSchema.tuple_variable_schema`) or calls into a private method that handles some
boilerplate before calling into the user-facing method (e.g. `GenerateSchema._tuple_schema`).
The idea is that we'll evolve this into adding more and more user facing methods over time
as they get requested and we figure out what the right API for them is.
"""
if obj is str:
return self.str_schema()
elif obj is bytes:
return core_schema.bytes_schema()
elif obj is int:
return core_schema.int_schema()
elif obj is float:
return core_schema.float_schema()
elif obj is bool:
return core_schema.bool_schema()
elif obj is Any or obj is object:
return core_schema.any_schema()
elif obj is None or obj is _typing_extra.NoneType:
return core_schema.none_schema()
elif obj in TUPLE_TYPES:
return self._tuple_schema(obj)
elif obj in LIST_TYPES:
return self._list_schema(obj, self._get_first_arg_or_any(obj))
elif obj in SET_TYPES:
return self._set_schema(obj, self._get_first_arg_or_any(obj))
elif obj in FROZEN_SET_TYPES:
return self._frozenset_schema(obj, self._get_first_arg_or_any(obj))
elif obj in DICT_TYPES:
return self._dict_schema(obj, *self._get_first_two_args_or_any(obj))
elif isinstance(obj, TypeAliasType):
return self._type_alias_type_schema(obj)
elif obj == type:
return self._type_schema()
elif _typing_extra.is_callable_type(obj):
return core_schema.callable_schema()
elif _typing_extra.is_literal_type(obj):
return self._literal_schema(obj)
elif is_typeddict(obj):
return self._typed_dict_schema(obj, None)
elif _typing_extra.is_namedtuple(obj):
return self._namedtuple_schema(obj, None)
elif _typing_extra.is_new_type(obj):
# NewType, can't use isinstance because it fails <3.7
return self.generate_schema(obj.__supertype__)
elif obj == re.Pattern:
return self._pattern_schema(obj)
elif obj is collections.abc.Hashable or obj is typing.Hashable:
return self._hashable_schema()
elif isinstance(obj, typing.TypeVar):
return self._unsubstituted_typevar_schema(obj)
elif is_finalvar(obj):
if obj is Final:
return core_schema.any_schema()
return self.generate_schema(
self._get_first_arg_or_any(obj),
)
elif isinstance(obj, (FunctionType, LambdaType, MethodType, partial)):
return self._callable_schema(obj)
elif inspect.isclass(obj) and issubclass(obj, Enum):
from ._std_types_schema import get_enum_core_schema
return get_enum_core_schema(obj, self._config_wrapper.config_dict)
if _typing_extra.is_dataclass(obj):
return self._dataclass_schema(obj, None)
res = self._get_prepare_pydantic_annotations_for_known_type(obj, ())
if res is not None:
source_type, annotations = res
return self._apply_annotations(source_type, annotations)
origin = get_origin(obj)
if origin is not None:
return self._match_generic_type(obj, origin)
if self._arbitrary_types:
return self._arbitrary_type_schema(obj)
return self._unknown_type_schema(obj)