update pydantic to 1.8.2

Author: d-biehl

robotcode/external/pydantic/pydantic/_hypothesis_plugin.py

@@ -149,7 +149,7 @@ def add_luhn_digit(card_number: str) -> str:
 st.register_type_strategy(pydantic.SecretStr, st.text().map(pydantic.SecretStr))
 
 # IP addresses, networks, and interfaces
-st.register_type_strategy(pydantic.IPvAnyAddress, st.ip_addresses())
+st.register_type_strategy(pydantic.IPvAnyAddress, st.ip_addresses())  # type: ignore[arg-type]
 st.register_type_strategy(
     pydantic.IPvAnyInterface,
     st.from_type(ipaddress.IPv4Interface) | st.from_type(ipaddress.IPv6Interface),  # type: ignore[arg-type]

robotcode/external/pydantic/pydantic/datetime_parse.py

@@ -58,6 +58,8 @@
 # if greater than this, the number is in ms, if less than or equal it's in seconds
 # (in seconds this is 11th October 2603, in ms it's 20th August 1970)
 MS_WATERSHED = int(2e10)
+# slightly more than datetime.max in ns - (datetime.max - EPOCH).total_seconds() * 1e9
+MAX_NUMBER = int(3e20)
 StrBytesIntFloat = Union[str, bytes, int, float]
 
 
@@ -73,6 +75,11 @@ def get_numeric(value: StrBytesIntFloat, native_expected_type: str) -> Union[Non
 
 
 def from_unix_seconds(seconds: Union[int, float]) -> datetime:
+    if seconds > MAX_NUMBER:
+        return datetime.max
+    elif seconds < -MAX_NUMBER:
+        return datetime.min
+
     while abs(seconds) > MS_WATERSHED:
         seconds /= 1000
     dt = EPOCH + timedelta(seconds=seconds)

robotcode/external/pydantic/pydantic/decorator.py

@@ -1,23 +1,10 @@
 from functools import wraps
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    List,
-    Mapping,
-    Optional,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    get_type_hints,
-    overload,
-)
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional, Tuple, Type, TypeVar, Union, overload
 
 from . import validator
 from .errors import ConfigError
 from .main import BaseModel, Extra, create_model
+from .typing import get_all_type_hints
 from .utils import to_camel
 
 __all__ = ('validate_arguments',)
@@ -87,17 +74,17 @@ def __init__(self, function: 'AnyCallableT', config: 'ConfigType'):  # noqa C901
         self.v_args_name = 'args'
         self.v_kwargs_name = 'kwargs'
 
-        type_hints = get_type_hints(function)
+        type_hints = get_all_type_hints(function)
         takes_args = False
         takes_kwargs = False
         fields: Dict[str, Tuple[Any, Any]] = {}
         for i, (name, p) in enumerate(parameters.items()):
-            if p.annotation == p.empty:
+            if p.annotation is p.empty:
                 annotation = Any
             else:
                 annotation = type_hints[name]
 
-            default = ... if p.default == p.empty else p.default
+            default = ... if p.default is p.empty else p.default
             if p.kind == Parameter.POSITIONAL_ONLY:
                 self.arg_mapping[i] = name
                 fields[name] = annotation, default

robotcode/external/pydantic/pydantic/fields.py

@@ -169,7 +169,7 @@ def update_from_config(self, from_config: Dict[str, Any]) -> None:
                     setattr(self, attr_name, value)
 
     def _validate(self) -> None:
-        if self.default not in (Undefined, Ellipsis) and self.default_factory is not None:
+        if self.default is not Undefined and self.default_factory is not None:
             raise ValueError('cannot specify both default and default_factory')
 
 
@@ -370,9 +370,10 @@ def _get_field_info(
             field_info = next(iter(field_infos), None)
             if field_info is not None:
                 field_info.update_from_config(field_info_from_config)
-                if field_info.default not in (Undefined, Ellipsis):
+                if field_info.default is not Undefined:
                     raise ValueError(f'`Field` default cannot be set in `Annotated` for {field_name!r}')
-                if value not in (Undefined, Ellipsis):
+                if value is not Undefined and value is not Required:
+                    # check also `Required` because of `validate_arguments` that sets `...` as default value
                     field_info.default = value
 
         if isinstance(value, FieldInfo):
@@ -450,7 +451,6 @@ def prepare(self) -> None:
         self._type_analysis()
         if self.required is Undefined:
             self.required = True
-            self.field_info.default = Required
         if self.default is Undefined and self.default_factory is None:
             self.default = None
         self.populate_validators()

robotcode/external/pydantic/pydantic/generics.py

@@ -15,13 +15,14 @@
     TypeVar,
     Union,
     cast,
-    get_type_hints,
 )
 
+from typing_extensions import Annotated
+
 from .class_validators import gather_all_validators
 from .fields import DeferredType
 from .main import BaseModel, create_model
-from .typing import display_as_type, get_args, get_origin, typing_base
+from .typing import display_as_type, get_all_type_hints, get_args, get_origin, typing_base
 from .utils import all_identical, lenient_issubclass
 
 _generic_types_cache: Dict[Tuple[Type[Any], Union[Any, Tuple[Any, ...]]], Type[BaseModel]] = {}
@@ -73,7 +74,7 @@ def __class_getitem__(cls: Type[GenericModelT], params: Union[Type[Any], Tuple[T
         model_name = cls.__concrete_name__(params)
         validators = gather_all_validators(cls)
 
-        type_hints = get_type_hints(cls).items()
+        type_hints = get_all_type_hints(cls).items()
         instance_type_hints = {k: v for k, v in type_hints if get_origin(v) is not ClassVar}
 
         fields = {k: (DeferredType(), cls.__fields__[k].field_info) for k in instance_type_hints if k in cls.__fields__}
@@ -159,6 +160,10 @@ def replace_types(type_: Any, type_map: Mapping[Any, Any]) -> Any:
     type_args = get_args(type_)
     origin_type = get_origin(type_)
 
+    if origin_type is Annotated:
+        annotated_type, *annotations = type_args
+        return Annotated[replace_types(annotated_type, type_map), tuple(annotations)]
+
     # Having type args is a good indicator that this is a typing module
     # class instantiation or a generic alias of some sort.
     if type_args:
@@ -167,7 +172,12 @@ def replace_types(type_: Any, type_map: Mapping[Any, Any]) -> Any:
             # If all arguments are the same, there is no need to modify the
             # type or create a new object at all
             return type_
-        if origin_type is not None and isinstance(type_, typing_base) and not isinstance(origin_type, typing_base):
+        if (
+            origin_type is not None
+            and isinstance(type_, typing_base)
+            and not isinstance(origin_type, typing_base)
+            and getattr(type_, '_name', None) is not None
+        ):
             # In python < 3.9 generic aliases don't exist so any of these like `list`,
             # `type` or `collections.abc.Callable` need to be translated.
             # See: https://www.python.org/dev/peps/pep-0585

robotcode/external/pydantic/pydantic/main.py

@@ -184,6 +184,7 @@ def inherit_config(self_config: 'ConfigType', parent_config: 'ConfigType', **nam
     namespace['json_encoders'] = {
         **getattr(parent_config, 'json_encoders', {}),
         **getattr(self_config, 'json_encoders', {}),
+        **namespace.get('json_encoders', {}),
     }
 
     return type('Config', base_classes, namespace)
@@ -248,7 +249,12 @@ def __new__(mcs, name, bases, namespace, **kwargs):  # noqa C901
                 class_vars.update(base.__class_vars__)
                 hash_func = base.__hash__
 
-        config_kwargs = {key: kwargs.pop(key) for key in kwargs.keys() & BaseConfig.__dict__.keys()}
+        allowed_config_kwargs: SetStr = {
+            key
+            for key in dir(config)
+            if not (key.startswith('__') and key.endswith('__'))  # skip dunder methods and attributes
+        }
+        config_kwargs = {key: kwargs.pop(key) for key in kwargs.keys() & allowed_config_kwargs}
         config_from_namespace = namespace.get('Config')
         if config_kwargs and config_from_namespace:
             raise TypeError('Specifying config in two places is ambiguous, use either Config attribute or class kwargs')

robotcode/external/pydantic/pydantic/schema.py

@@ -788,6 +788,7 @@ def field_singleton_schema(  # noqa: C901 (ignore complexity)
     f_schema: Dict[str, Any] = {}
     if field.field_info is not None and field.field_info.const:
         f_schema['const'] = field.default
+
     field_type = field.type_
     if is_literal_type(field_type):
         values = all_literal_values(field_type)
@@ -805,8 +806,8 @@ def field_singleton_schema(  # noqa: C901 (ignore complexity)
         # All values have the same type
         field_type = values[0].__class__
         f_schema['enum'] = list(values)
-
-    if lenient_issubclass(field_type, Enum):
+        add_field_type_to_schema(field_type, f_schema)
+    elif lenient_issubclass(field_type, Enum):
         enum_name = model_name_map[field_type]
         f_schema, schema_overrides = get_field_info_schema(field)
         f_schema.update(get_schema_ref(enum_name, ref_prefix, ref_template, schema_overrides))

robotcode/external/pydantic/pydantic/typing.py

@@ -1,5 +1,4 @@
 import sys
-from enum import Enum
 from typing import (  # type: ignore
     TYPE_CHECKING,
     AbstractSet,
@@ -18,6 +17,7 @@
     Union,
     _eval_type,
     cast,
+    get_type_hints,
 )
 
 from typing_extensions import Annotated, Literal
@@ -70,6 +70,18 @@ def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
         return cast(Any, type_)._evaluate(globalns, localns, set())
 
 
+if sys.version_info < (3, 9):
+    # Ensure we always get all the whole `Annotated` hint, not just the annotated type.
+    # For 3.6 to 3.8, `get_type_hints` doesn't recognize `typing_extensions.Annotated`,
+    # so it already returns the full annotation
+    get_all_type_hints = get_type_hints
+
+else:
+
+    def get_all_type_hints(obj: Any, globalns: Any = None, localns: Any = None) -> Any:
+        return get_type_hints(obj, globalns, localns, include_extras=True)
+
+
 if sys.version_info < (3, 7):
     from typing import Callable as Callable
 
@@ -225,6 +237,7 @@ def get_args(tp: Type[Any]) -> Tuple[Any, ...]:
     'get_args',
     'get_origin',
     'typing_base',
+    'get_all_type_hints',
 )
 
 
@@ -236,14 +249,6 @@ def display_as_type(v: Type[Any]) -> str:
     if not isinstance(v, typing_base) and not isinstance(v, GenericAlias) and not isinstance(v, type):
         v = v.__class__
 
-    if isinstance(v, type) and issubclass(v, Enum):
-        if issubclass(v, int):
-            return 'int'
-        elif issubclass(v, str):
-            return 'str'
-        else:
-            return 'enum'
-
     if isinstance(v, GenericAlias):
         # Generic alias are constructs like `list[int]`
         return str(v).replace('typing.', '')

robotcode/external/pydantic/pydantic/version.py

@@ -1,6 +1,6 @@
 __all__ = 'VERSION', 'version_info'
 
-VERSION = '1.8.1'
+VERSION = '1.8.2'
 
 
 def version_info() -> str: