mas_multiplayer_chat
/
.venv
/lib
/python3.12
/site-packages
/pydantic
/deprecated
/copy_internals.py
from __future__ import annotations as _annotations | |
import typing | |
from copy import deepcopy | |
from enum import Enum | |
from typing import Any, Tuple | |
import typing_extensions | |
from .._internal import ( | |
_model_construction, | |
_typing_extra, | |
_utils, | |
) | |
if typing.TYPE_CHECKING: | |
from .. import BaseModel | |
from .._internal._utils import AbstractSetIntStr, MappingIntStrAny | |
AnyClassMethod = classmethod[Any, Any, Any] | |
TupleGenerator = typing.Generator[Tuple[str, Any], None, None] | |
Model = typing.TypeVar('Model', bound='BaseModel') | |
# should be `set[int] | set[str] | dict[int, IncEx] | dict[str, IncEx] | None`, but mypy can't cope | |
IncEx: typing_extensions.TypeAlias = 'set[int] | set[str] | dict[int, Any] | dict[str, Any] | None' | |
_object_setattr = _model_construction.object_setattr | |
def _iter( | |
self: BaseModel, | |
to_dict: bool = False, | |
by_alias: bool = False, | |
include: AbstractSetIntStr | MappingIntStrAny | None = None, | |
exclude: AbstractSetIntStr | MappingIntStrAny | None = None, | |
exclude_unset: bool = False, | |
exclude_defaults: bool = False, | |
exclude_none: bool = False, | |
) -> TupleGenerator: | |
# Merge field set excludes with explicit exclude parameter with explicit overriding field set options. | |
# The extra "is not None" guards are not logically necessary but optimizes performance for the simple case. | |
if exclude is not None: | |
exclude = _utils.ValueItems.merge( | |
{k: v.exclude for k, v in self.model_fields.items() if v.exclude is not None}, exclude | |
) | |
if include is not None: | |
include = _utils.ValueItems.merge({k: True for k in self.model_fields}, include, intersect=True) | |
allowed_keys = _calculate_keys(self, include=include, exclude=exclude, exclude_unset=exclude_unset) # type: ignore | |
if allowed_keys is None and not (to_dict or by_alias or exclude_unset or exclude_defaults or exclude_none): | |
# huge boost for plain _iter() | |
yield from self.__dict__.items() | |
if self.__pydantic_extra__: | |
yield from self.__pydantic_extra__.items() | |
return | |
value_exclude = _utils.ValueItems(self, exclude) if exclude is not None else None | |
value_include = _utils.ValueItems(self, include) if include is not None else None | |
if self.__pydantic_extra__ is None: | |
items = self.__dict__.items() | |
else: | |
items = list(self.__dict__.items()) + list(self.__pydantic_extra__.items()) | |
for field_key, v in items: | |
if (allowed_keys is not None and field_key not in allowed_keys) or (exclude_none and v is None): | |
continue | |
if exclude_defaults: | |
try: | |
field = self.model_fields[field_key] | |
except KeyError: | |
pass | |
else: | |
if not field.is_required() and field.default == v: | |
continue | |
if by_alias and field_key in self.model_fields: | |
dict_key = self.model_fields[field_key].alias or field_key | |
else: | |
dict_key = field_key | |
if to_dict or value_include or value_exclude: | |
v = _get_value( | |
type(self), | |
v, | |
to_dict=to_dict, | |
by_alias=by_alias, | |
include=value_include and value_include.for_element(field_key), | |
exclude=value_exclude and value_exclude.for_element(field_key), | |
exclude_unset=exclude_unset, | |
exclude_defaults=exclude_defaults, | |
exclude_none=exclude_none, | |
) | |
yield dict_key, v | |
def _copy_and_set_values( | |
self: Model, | |
values: dict[str, Any], | |
fields_set: set[str], | |
extra: dict[str, Any] | None = None, | |
private: dict[str, Any] | None = None, | |
*, | |
deep: bool, # UP006 | |
) -> Model: | |
if deep: | |
# chances of having empty dict here are quite low for using smart_deepcopy | |
values = deepcopy(values) | |
extra = deepcopy(extra) | |
private = deepcopy(private) | |
cls = self.__class__ | |
m = cls.__new__(cls) | |
_object_setattr(m, '__dict__', values) | |
_object_setattr(m, '__pydantic_extra__', extra) | |
_object_setattr(m, '__pydantic_fields_set__', fields_set) | |
_object_setattr(m, '__pydantic_private__', private) | |
return m | |
def _get_value( | |
cls: type[BaseModel], | |
v: Any, | |
to_dict: bool, | |
by_alias: bool, | |
include: AbstractSetIntStr | MappingIntStrAny | None, | |
exclude: AbstractSetIntStr | MappingIntStrAny | None, | |
exclude_unset: bool, | |
exclude_defaults: bool, | |
exclude_none: bool, | |
) -> Any: | |
from .. import BaseModel | |
if isinstance(v, BaseModel): | |
if to_dict: | |
return v.model_dump( | |
by_alias=by_alias, | |
exclude_unset=exclude_unset, | |
exclude_defaults=exclude_defaults, | |
include=include, # type: ignore | |
exclude=exclude, # type: ignore | |
exclude_none=exclude_none, | |
) | |
else: | |
return v.copy(include=include, exclude=exclude) | |
value_exclude = _utils.ValueItems(v, exclude) if exclude else None | |
value_include = _utils.ValueItems(v, include) if include else None | |
if isinstance(v, dict): | |
return { | |
k_: _get_value( | |
cls, | |
v_, | |
to_dict=to_dict, | |
by_alias=by_alias, | |
exclude_unset=exclude_unset, | |
exclude_defaults=exclude_defaults, | |
include=value_include and value_include.for_element(k_), | |
exclude=value_exclude and value_exclude.for_element(k_), | |
exclude_none=exclude_none, | |
) | |
for k_, v_ in v.items() | |
if (not value_exclude or not value_exclude.is_excluded(k_)) | |
and (not value_include or value_include.is_included(k_)) | |
} | |
elif _utils.sequence_like(v): | |
seq_args = ( | |
_get_value( | |
cls, | |
v_, | |
to_dict=to_dict, | |
by_alias=by_alias, | |
exclude_unset=exclude_unset, | |
exclude_defaults=exclude_defaults, | |
include=value_include and value_include.for_element(i), | |
exclude=value_exclude and value_exclude.for_element(i), | |
exclude_none=exclude_none, | |
) | |
for i, v_ in enumerate(v) | |
if (not value_exclude or not value_exclude.is_excluded(i)) | |
and (not value_include or value_include.is_included(i)) | |
) | |
return v.__class__(*seq_args) if _typing_extra.is_namedtuple(v.__class__) else v.__class__(seq_args) | |
elif isinstance(v, Enum) and getattr(cls.model_config, 'use_enum_values', False): | |
return v.value | |
else: | |
return v | |
def _calculate_keys( | |
self: BaseModel, | |
include: MappingIntStrAny | None, | |
exclude: MappingIntStrAny | None, | |
exclude_unset: bool, | |
update: typing.Dict[str, Any] | None = None, # noqa UP006 | |
) -> typing.AbstractSet[str] | None: | |
if include is None and exclude is None and exclude_unset is False: | |
return None | |
keys: typing.AbstractSet[str] | |
if exclude_unset: | |
keys = self.__pydantic_fields_set__.copy() | |
else: | |
keys = set(self.__dict__.keys()) | |
keys = keys | (self.__pydantic_extra__ or {}).keys() | |
if include is not None: | |
keys &= include.keys() | |
if update: | |
keys -= update.keys() | |
if exclude: | |
keys -= {k for k, v in exclude.items() if _utils.ValueItems.is_true(v)} | |
return keys | |