add updates libs

server/libs/cattrs/cols.py

@@ -5,25 +5,20 @@ from __future__ import annotations
 from collections import defaultdict
 from collections.abc import Callable, Iterable
 from functools import partial
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    DefaultDict,
-    Literal,
-    NamedTuple,
-    TypeVar,
-    get_type_hints,
-)
+from typing import TYPE_CHECKING, Any, DefaultDict, Literal, NamedTuple, TypeVar
 
 from attrs import NOTHING, Attribute, NothingType
 
 from ._compat import (
     ANIES,
+    AbcSet,
     get_args,
+    get_full_type_hints,
     get_origin,
     is_bare,
     is_frozenset,
     is_mapping,
+    is_mutable_sequence,
     is_sequence,
     is_subclass,
 )
@@ -47,10 +42,13 @@ if TYPE_CHECKING:
 
 __all__ = [
     "defaultdict_structure_factory",
+    "homogenous_tuple_structure_factory",
+    "is_abstract_set",
     "is_any_set",
     "is_defaultdict",
     "is_frozenset",
     "is_mapping",
+    "is_mutable_sequence",
     "is_namedtuple",
     "is_sequence",
     "is_set",
@@ -70,6 +68,11 @@ def is_any_set(type) -> bool:
     return is_set(type) or is_frozenset(type)
 
 
+def is_abstract_set(type) -> bool:
+    """A predicate function for abstract (collection.abc) sets."""
+    return type is AbcSet or (getattr(type, "__origin__", None) is AbcSet)
+
+
 def is_namedtuple(type: Any) -> bool:
     """A predicate function for named tuples."""
 
@@ -151,6 +154,47 @@ def list_structure_factory(type: type, converter: BaseConverter) -> StructureHoo
     return structure_list
 
 
+def homogenous_tuple_structure_factory(
+    type: type, converter: BaseConverter
+) -> StructureHook:
+    """A hook factory for homogenous (all elements the same, indeterminate length) tuples.
+
+    Converts any given iterable into a tuple.
+    """
+
+    if is_bare(type) or type.__args__[0] in ANIES:
+
+        def structure_tuple(obj: Iterable[T], _: type = type) -> tuple[T, ...]:
+            return tuple(obj)
+
+        return structure_tuple
+
+    elem_type = type.__args__[0]
+
+    try:
+        handler = converter.get_structure_hook(elem_type)
+    except RecursionError:
+        # Break the cycle by using late binding.
+        handler = converter.structure
+
+    if converter.detailed_validation:
+
+        # We have to structure into a list first anyway.
+        list_structure = list_structure_factory(type, converter)
+
+        def structure_tuple(obj: Iterable[T], _: type = type) -> tuple[T, ...]:
+            return tuple(list_structure(obj, _))
+
+    else:
+
+        def structure_tuple(
+            obj: Iterable[T], _: type = type, _handler=handler, _elem_type=elem_type
+        ) -> tuple[T, ...]:
+            return tuple([_handler(e, _elem_type) for e in obj])
+
+    return structure_tuple
+
+
 def namedtuple_unstructure_factory(
     cl: type[tuple], converter: BaseConverter, unstructure_to: Any = None
 ) -> UnstructureHook:
@@ -195,7 +239,7 @@ def _namedtuple_to_attrs(cl: type[tuple]) -> list[Attribute]:
             type=a,
             alias=name,
         )
-        for name, a in get_type_hints(cl).items()
+        for name, a in get_full_type_hints(cl).items()
     ]