fixing mypy

pydantic · samuelcolvin · Nov 2, 2022 · Sep 12, 2022 · Sep 14, 2022 · Sep 14, 2022
commit 246fff2a2b49c2ce17781aba75095d7d382fc4b3
diff --git a/pydantic/_internal/babelfish.py b/pydantic/_internal/babelfish.py
@@ -54,6 +54,7 @@ def generate_config(config: type[BaseConfig]) -> PydanticCoreConfig:
     return {
         'typed_dict_extra_behavior': config.extra.value,
         # 'allow_inf_nan': config.allow_inf_nan,
+        'populate_by_name': config.allow_population_by_field_name,
     }
 
 
@@ -134,12 +135,20 @@ def apply_validators(schema: PydanticCoreSchema, validators: list[Validator]) ->
     """
     for validator in validators:
         assert validator.sub_path is None, 'validator.sub_path is not yet supported'
-        schema = {
-            'type': 'function',
-            'mode': validator.mode,
-            'function': validator.function,
-            'schema': schema,
-        }
+        function = typing.cast(typing.Callable[..., Any], validator.function)
+        if validator.mode == 'plain':
+            schema = {  # type: ignore[misc,assignment]
+                'type': 'function',
+                'mode': 'plain',
+                'function': function,
+            }
+        else:
+            schema = {
+                'type': 'function',
+                'mode': validator.mode,
+                'function': function,
+                'schema': schema,
+            }
     return schema
 
 

diff --git a/pydantic/_internal/model_construction.py b/pydantic/_internal/model_construction.py
@@ -5,7 +5,7 @@
 from types import FunctionType
 from typing import TYPE_CHECKING, Any, Callable, Type, get_type_hints
 
-from pydantic_core import Schema as PydanticCoreSchema, SchemaValidator
+from pydantic_core import SchemaValidator
 
 from ..fields import FieldInfo, ModelPrivateAttr, PrivateAttr
 from ..utils import ClassAttribute, is_valid_identifier
@@ -23,22 +23,9 @@
 
 
 IGNORED_TYPES: tuple[Any, ...] = (FunctionType, property, type, classmethod, staticmethod)
-DUNDER_ATTRIBUTES = {
-    '__annotations__',
-    '__classcell__',
-    '__doc__',
-    '__module__',
-    '__orig_bases__',
-    '__orig_class__',
-    '__qualname__',
-    '__slots__',
-    '__config__',
-}
-# attribute names to ignore off the bat, mostly to save time
-IGNORED_ATTRIBUTES = DUNDER_ATTRIBUTES | {'Config'}
-
-
-def inspect_namespace(namespace) -> None:
+
+
+def inspect_namespace(namespace: dict[str, Any]) -> None:
     """
     iterate over the namespace and:
     * gather private attributes
@@ -48,13 +35,13 @@ def inspect_namespace(namespace) -> None:
     raw_annotations = namespace.get('__annotations__', {})
     for var_name, value in namespace.items():
         if isinstance(value, ModelPrivateAttr):
-            if not var_name.startswith('_') or var_name in DUNDER_ATTRIBUTES:
+            if not single_underscore(var_name):
                 raise NameError(
                     f'Private attributes "{var_name}" must not be a valid field name; '
-                    f'Use sunder or dunder names, e. g. "_{var_name}" or "__{var_name}__"'
+                    f'Use sunder or dunder names, e. g. "_{var_name}"'
                 )
             private_attributes[var_name] = value
-        elif var_name in IGNORED_ATTRIBUTES:
+        elif not single_underscore(var_name):
             continue
         elif var_name.startswith('_'):
             private_attributes[var_name] = PrivateAttr(default=value)
@@ -73,6 +60,10 @@ def inspect_namespace(namespace) -> None:
         namespace['__slots__'] = slots | private_attributes.keys()
 
 
+def single_underscore(name: str) -> bool:
+    return name.startswith('_') and not name.startswith('__')
+
+
 class SelfType:
     """
     This is used to identify a reference to the current model class, e.g. in recursive classes
@@ -83,7 +74,7 @@ class SelfType:
 
 def complete_model_class(
     cls: Type[BaseModel], name: str, validator_functions: ValidationFunctions, bases: tuple[type[Any], ...]
-):
+) -> None:
     """
     Collect bound validator functions, build the model validation schema and set the model signature.
 
@@ -133,7 +124,7 @@ def complete_model_class(
 
     cls.__fields__ = fields
     cls.__pydantic_validator__ = SchemaValidator(inner_schema, core_config)
-    cls.__pydantic_validation_schema__: PydanticCoreSchema = {
+    cls.__pydantic_validation_schema__ = {
         'type': 'new-class',
         'class_type': cls,
         'schema': inner_schema,

diff --git a/pydantic/_internal/typing_extra.py b/pydantic/_internal/typing_extra.py
@@ -16,7 +16,6 @@
     Mapping,
     NewType,
     Optional,
-    Sequence,
     Set,
     Tuple,
     Type,
@@ -46,8 +45,6 @@
     'new_type_supertype',
     'is_classvar',
     'is_finalvar',
-    'update_field_forward_refs',
-    'update_model_forward_refs',
     'TupleGenerator',
     'DictStrAny',
     'DictAny',
@@ -305,8 +302,6 @@ def origin_is_union(tp: Optional[Type[Any]]) -> bool:
 
 
 if TYPE_CHECKING:
-    from ..fields import ModelField
-
     TupleGenerator = Generator[Tuple[str, Any], None, None]
     DictStrAny = Dict[str, Any]
     DictAny = Dict[Any, Any]
@@ -317,7 +312,7 @@ def origin_is_union(tp: Optional[Type[Any]]) -> bool:
     DictIntStrAny = Dict[IntStr, Any]
     MappingIntStrAny = Mapping[IntStr, Any]
     CallableGenerator = Generator[AnyCallable, None, None]
-    ReprArgs = Sequence[Tuple[Optional[str], Any]]
+    ReprArgs = Iterable[Tuple[Optional[str], Any]]
     AnyClassMethod = classmethod[Any]
 
 
@@ -522,67 +517,6 @@ def is_finalvar(ann_type: Type[Any]) -> bool:
     return _check_finalvar(ann_type) or _check_finalvar(get_origin(ann_type))
 
 
-def update_field_forward_refs(field: 'ModelField', globalns: Any, localns: Any) -> None:
-    """
-    Try to update ForwardRefs on fields based on this ModelField, globalns and localns.
-    """
-    prepare = False
-    if field.type_.__class__ == ForwardRef:
-        prepare = True
-        field.type_ = evaluate_forwardref(field.type_, globalns, localns)
-    if field.outer_type_.__class__ == ForwardRef:
-        prepare = True
-        field.outer_type_ = evaluate_forwardref(field.outer_type_, globalns, localns)
-    if prepare:
-        field.prepare()
-
-    if field.sub_fields:
-        for sub_f in field.sub_fields:
-            update_field_forward_refs(sub_f, globalns=globalns, localns=localns)
-
-    if field.discriminator_key is not None:
-        field.prepare_discriminated_union_sub_fields()
-
-
-def update_model_forward_refs(
-    model: Type[Any],
-    fields: Iterable['ModelField'],
-    json_encoders: Dict[Union[Type[Any], str, ForwardRef], AnyCallable],
-    localns: 'DictStrAny',
-    exc_to_suppress: Tuple[Type[BaseException], ...] = (),
-) -> None:
-    """
-    Try to update model fields ForwardRefs based on model and localns.
-    """
-    if model.__module__ in sys.modules:
-        globalns = sys.modules[model.__module__].__dict__.copy()
-    else:
-        globalns = {}
-
-    globalns.setdefault(model.__name__, model)
-
-    for f in fields:
-        try:
-            update_field_forward_refs(f, globalns=globalns, localns=localns)
-        except exc_to_suppress:
-            pass
-
-    for key in set(json_encoders.keys()):
-        if isinstance(key, str):
-            fr: ForwardRef = ForwardRef(key)
-        elif isinstance(key, ForwardRef):
-            fr = key
-        else:
-            continue
-
-        try:
-            new_key = evaluate_forwardref(fr, globalns, localns)
-        except exc_to_suppress:  # pragma: no cover
-            continue
-
-        json_encoders[new_key] = json_encoders.pop(key)
-
-
 def get_class(type_: Type[Any]) -> Union[None, bool, Type[Any]]:
     """
     Tries to get the class of a Type[T] annotation. Returns True if Type is used

diff --git a/pydantic/_internal/valdation_functions.py b/pydantic/_internal/valdation_functions.py
@@ -81,7 +81,7 @@ def extract_validator(self, name: str, value: Any) -> None:
                 self._validators[name] = r_validator
                 self._root_validators.append(name)
 
-    def set_bound_functions(self, cls: type[BaseModel]):
+    def set_bound_functions(self, cls: type[BaseModel]) -> None:
         """
         Set functions in self._validators, now that the class is created and functions are bound.
         """

diff --git a/pydantic/config.py b/pydantic/config.py
@@ -70,40 +70,40 @@ class ConfigDict(TypedDict, total=False):
 
 class BaseConfig:
     title: Optional[str] = None
-    anystr_lower: bool = False
-    anystr_upper: bool = False
-    anystr_strip_whitespace: bool = False
-    min_anystr_length: int = 0
-    max_anystr_length: Optional[int] = None
-    validate_all: bool = False
+    anystr_lower: bool = False  # TODO rename to str_to_lower
+    anystr_upper: bool = False  # TODO rename to str_to_upper
+    anystr_strip_whitespace: bool = False  # TODO rename to str_strip_whitespace
+    min_anystr_length: int = 0  # TODO rename to str_min_length
+    max_anystr_length: Optional[int] = None  # TODO rename to str_max_length
+    validate_all: bool = False  # TODO remove
     extra: Extra = Extra.ignore
-    allow_mutation: bool = True
+    allow_mutation: bool = True  # TODO remove - replaced by frozen
     frozen: bool = False
-    allow_population_by_field_name: bool = False
+    allow_population_by_field_name: bool = False  # TODO rename to populate_by_name
     use_enum_values: bool = False
-    fields: Dict[str, Union[str, Dict[str, str]]] = {}
+    fields: Dict[str, Union[str, Dict[str, str]]] = {}  # TODO remove
     validate_assignment: bool = False
-    error_msg_templates: Dict[str, str] = {}
-    arbitrary_types_allowed: bool = False
-    orm_mode: bool = False
-    getter_dict: Type[GetterDict] = GetterDict
+    error_msg_templates: Dict[str, str] = {}  # TODO remove
+    arbitrary_types_allowed: bool = False  # TODO default True, or remove
+    orm_mode: bool = False  # TODO rename to from_attributes
+    getter_dict: Type[GetterDict] = GetterDict  # TODO remove
     alias_generator: Optional[Callable[[str], str]] = None
-    keep_untouched: Tuple[type, ...] = ()
-    schema_extra: Union[Dict[str, Any], 'SchemaExtraCallable'] = {}
-    json_loads: Callable[[str], Any] = json.loads
-    json_dumps: Callable[..., str] = json.dumps
-    json_encoders: Dict[Union[Type[Any], str, ForwardRef], AnyCallable] = {}
-    underscore_attrs_are_private: bool = False
+    keep_untouched: Tuple[type, ...] = ()  # TODO remove??
+    schema_extra: Union[Dict[str, Any], 'SchemaExtraCallable'] = {}  # TODO remove, new model method
+    json_loads: Callable[[str], Any] = json.loads  # TODO decide
+    json_dumps: Callable[..., str] = json.dumps  # TODO decide
+    json_encoders: Dict[Union[Type[Any], str, ForwardRef], AnyCallable] = {}  # TODO decide
+    underscore_attrs_are_private: bool = False  # TODO remove
     allow_inf_nan: bool = True
 
     # whether inherited models as fields should be reconstructed as base model,
     # and whether such a copy should be shallow or deep
-    copy_on_model_validation: Literal['none', 'deep', 'shallow'] = 'shallow'
+    copy_on_model_validation: Literal['none', 'deep', 'shallow'] = 'shallow'  # TODO remove???
 
     # whether `Union` should check all allowed types before even trying to coerce
-    smart_union: bool = False
+    smart_union: bool = False  # TODO remove
     # whether dataclass `__post_init__` should be run before or after validation
-    post_init_call: Literal['before_validation', 'after_validation'] = 'before_validation'
+    post_init_call: Literal['before_validation', 'after_validation'] = 'before_validation'  # TODO remove
 
     @classmethod
     def get_field_info(cls, name: str) -> Dict[str, Any]:

diff --git a/pydantic/dataclasses.py b/pydantic/dataclasses.py
@@ -53,7 +53,6 @@ class M:
 
 from .class_validators import gather_all_validators
 from .config import BaseConfig, ConfigDict, Extra, get_config
-from .error_wrappers import ValidationError
 from .errors import DataclassTypeError
 from .fields import Field, FieldInfo, Required, Undefined
 from .main import create_model
@@ -222,7 +221,6 @@ def wrap(cls: Type[Any]) -> 'DataclassClassOrWrapper':
 
         should_validate_on_init = default_validate_on_init if validate_on_init is None else validate_on_init
         _add_pydantic_validation_attributes(cls, the_config, should_validate_on_init, dc_cls_doc)
-        dc_cls.__pydantic_model__.__try_update_forward_refs__(**{cls.__name__: cls})
         return dc_cls
 
     if _cls is None:
@@ -423,11 +421,11 @@ def _dataclass_validate_assignment_setattr(self: 'Dataclass', name: str, value:
     if self.__pydantic_initialised__:
         d = dict(self.__dict__)
         d.pop(name, None)
-        known_field = self.__pydantic_model__.__fields__.get(name, None)
-        if known_field:
-            value, error_ = known_field.validate(value, d, loc=name, cls=self.__class__)
-            if error_:
-                raise ValidationError([error_], self.__class__)
+        # known_field = self.__pydantic_model__.__fields__.get(name, None)
+        # if known_field:
+        #     value, error_ = known_field.validate(value, d, loc=name, cls=self.__class__)
+        #     if error_:
+        #         raise ValidationError([error_], self.__class__)
 
     object.__setattr__(self, name, value)
 

diff --git a/pydantic/fields.py b/pydantic/fields.py
@@ -48,7 +48,6 @@ class FieldInfo(Representation):
         'description',
         'exclude',
         'include',
-        'const',
         'gt',
         'ge',
         'lt',
@@ -107,7 +106,6 @@ def __init__(self, **kwargs: Any) -> None:
         self.description = kwargs.pop('description', None)
         self.exclude = kwargs.pop('exclude', None)
         self.include = kwargs.pop('include', None)
-        self.const = kwargs.pop('const', None)
         self.gt = kwargs.pop('gt', None)
         self.ge = kwargs.pop('ge', None)
         self.lt = kwargs.pop('lt', None)
@@ -206,7 +204,6 @@ def Field(
     description: str = None,
     exclude: Union['AbstractSetIntStr', 'MappingIntStrAny', Any] = None,
     include: Union['AbstractSetIntStr', 'MappingIntStrAny', Any] = None,
-    const: bool = None,
     gt: float = None,
     ge: float = None,
     lt: float = None,
@@ -241,7 +238,6 @@ def Field(
       Takes same values as the ``include`` and ``exclude`` arguments on the ``.dict`` method.
     :param include: include this field while dumping.
       Takes same values as the ``include`` and ``exclude`` arguments on the ``.dict`` method.
-    :param const: this field is required and *must* take it's default value
     :param gt: only applies to numbers, requires the field to be "greater than". The schema
       will have an ``exclusiveMinimum`` validation keyword
     :param ge: only applies to numbers, requires the field to be "greater than or equal to". The
@@ -285,7 +281,6 @@ def Field(
         description=description,
         exclude=exclude,
         include=include,
-        const=const,
         gt=gt,
         ge=ge,
         lt=lt,
@@ -338,8 +333,13 @@ def Field(
 MAPPING_LIKE_SHAPES: Set[int] = {SHAPE_DEFAULTDICT, SHAPE_DICT, SHAPE_MAPPING, SHAPE_COUNTER}
 
 
-class ModelField(Representation):
-    pass
+# TODO remove, this is just here to satisfy imports of ModelField
+if TYPE_CHECKING:
+    ModelField = Any
+else:
+
+    class ModelField(Representation):
+        pass
 
 
 class ModelPrivateAttr(Representation):