def test_pickle(self): alias = GenericAlias(list, T) s = pickle.dumps(alias) loaded = pickle.loads(s) self.assertEqual(alias.__origin__, loaded.__origin__) self.assertEqual(alias.__args__, loaded.__args__) self.assertEqual(alias.__parameters__, loaded.__parameters__)
def test_pickle(self): alias = GenericAlias(list, T) for proto in range(pickle.HIGHEST_PROTOCOL + 1): s = pickle.dumps(alias, proto) loaded = pickle.loads(s) self.assertEqual(loaded.__origin__, alias.__origin__) self.assertEqual(loaded.__args__, alias.__args__) self.assertEqual(loaded.__parameters__, alias.__parameters__)
def test_pickle(self): aliases = [GenericAlias(list, T)] + _UNPACKED_TUPLES for alias in aliases: for proto in range(pickle.HIGHEST_PROTOCOL + 1): with self.subTest(alias=alias, proto=proto): s = pickle.dumps(alias, proto) loaded = pickle.loads(s) self.assertEqual(loaded.__origin__, alias.__origin__) self.assertEqual(loaded.__args__, alias.__args__) self.assertEqual(loaded.__parameters__, alias.__parameters__)
def determine_nested_dtype(data: Iterable) -> DataType: if len(data) == 0: return Object sample = next(iter(data)) stype = type(sample) if sample == data: return type(data) elif stype is list or stype is set: nested_type = Column.determine_nested_dtype(sample) else: nested_type = stype return GenericAlias(type(data), nested_type)
def test_copy(self): class X(list): def __copy__(self): return self def __deepcopy__(self, memo): return self aliases = [ GenericAlias(list, T), GenericAlias(deque, T), GenericAlias(X, T) ] + _UNPACKED_TUPLES for alias in aliases: with self.subTest(alias=alias): copied = copy.copy(alias) self.assertEqual(copied.__origin__, alias.__origin__) self.assertEqual(copied.__args__, alias.__args__) self.assertEqual(copied.__parameters__, alias.__parameters__) copied = copy.deepcopy(alias) self.assertEqual(copied.__origin__, alias.__origin__) self.assertEqual(copied.__args__, alias.__args__) self.assertEqual(copied.__parameters__, alias.__parameters__)
def _get_model( DataClass: Type[D], excludes=[]) -> Type[Union[BaseModel, Type[D], Type[T]]]: from dataclasses import is_dataclass annotations = (dict( (name, SCHEMAS.get(type, type)) for name, type in DataClass.__annotations__.items() if not excludes or name not in excludes) if hasattr( DataClass, "__annotations__") else {}) for field_name, field_type in annotations.items(): if type(field_type) == GenericAlias and field_type.__mro__[ 0] in [ # type: ignore list, set, ]: gen_type = field_type.__mro__[0] arg_type = field_type.__args__[0] arg_type = SCHEMAS.get(arg_type, arg_type) field_type.__args__[0] annotations[field_name] = GenericAlias( gen_type, (arg_type, )) # type: ignore if is_dataclass(field_type): field = _get_model(field_type) annotations[field_name] = field namespace = { "__annotations__": annotations, "__module__": TargetClass.__module__, "__qualname__": TargetClass.__qualname__, } model = cast( AnyType, ModelMetaclass(TargetClass.__name__, (ModelSchema, ), namespace), ) for field_name, field_type in annotations.items(): member = members.get(field_name) field = model.__dict__["__fields__"].get(field_name) if not field: continue if isinstance(member, (DataClassField, )): setattr(field, "field_info", Field(..., **member.metadata)) elif isinstance(member, (FieldInfo, )): setattr(field, "field_info", member) return model
def infer_dtype(column_name: str, data_backend: DataBackend) -> DataType: dtype: type = data_backend.dtypes[column_name] if dtype == Object: if len(data_backend) == 0: dtype = Object else: sample = data_backend.iloc[0].values[0] stype = type(sample) if stype is list or stype is set: dtype = DataType( GenericAlias(stype, Column.determine_nested_dtype(sample)) ) else: dtype = stype return DataType(dtype)
def test_copy(self): class X(list): def __copy__(self): return self def __deepcopy__(self, memo): return self for origin in list, deque, X: alias = GenericAlias(origin, T) copied = copy.copy(alias) self.assertEqual(copied.__origin__, alias.__origin__) self.assertEqual(copied.__args__, alias.__args__) self.assertEqual(copied.__parameters__, alias.__parameters__) copied = copy.deepcopy(alias) self.assertEqual(copied.__origin__, alias.__origin__) self.assertEqual(copied.__args__, alias.__args__) self.assertEqual(copied.__parameters__, alias.__parameters__)
def _eval_type(t, globalns, localns, recursive_guard=frozenset()): """Evaluate all forward references in the given type t. For use of globalns and localns see the docstring for get_type_hints(). recursive_guard is used to prevent prevent infinite recursion with recursive ForwardRef. """ if isinstance(t, ForwardRef): return t._evaluate(globalns, localns, recursive_guard) if isinstance(t, (_GenericAlias, GenericAlias)): ev_args = tuple( _eval_type(a, globalns, localns, recursive_guard) for a in t.__args__) if ev_args == t.__args__: return t if isinstance(t, GenericAlias): return GenericAlias(t.__origin__, ev_args) else: return t.copy_with(ev_args) return t
def test_no_kwargs(self): # bpo-42576 with self.assertRaises(TypeError): GenericAlias(bad=float)
import sys from typing import Any, TypeVar import numpy import cupy if numpy.lib.NumpyVersion(numpy.__version__) >= '1.20.0': from numpy.typing import ArrayLike # NOQA from numpy.typing import DTypeLike # NOQA from numpy.typing import NBitBase # NOQA else: ArrayLike = Any # type: ignore DTypeLike = Any # type: ignore NBitBase = Any # type: ignore if sys.version_info >= (3, 9): from types import GenericAlias elif numpy.lib.NumpyVersion(numpy.__version__) >= '1.21.0': from numpy.typing import _GenericAlias as GenericAlias else: def GenericAlias(*args): # type: ignore return Any _ScalarType = TypeVar('_ScalarType', bound=numpy.generic, covariant=True) _DType = GenericAlias(numpy.dtype, (_ScalarType, )) NDArray = GenericAlias(cupy.ndarray, (Any, _DType))
def __class_getitem__(cls, params): return GenericAlias(cls, params)
itemsize: int aligned: bool # A protocol for anything with the dtype attribute class _SupportsDType(Protocol[_DType_co]): @property def dtype(self) -> _DType_co: ... else: _DTypeDict = NotImplemented class _SupportsDType: ... _SupportsDType = GenericAlias(_SupportsDType, _DType_co) # Would create a dtype[np.void] _VoidDTypeLike = Union[ # (flexible_dtype, itemsize) Tuple[_DTypeLikeNested, int], # (fixed_dtype, shape) Tuple[_DTypeLikeNested, _ShapeLike], # [(field_name, field_dtype, field_shape), ...] # # The type here is quite broad because NumPy accepts quite a wide # range of inputs inside the list; see the tests for some # examples. List[Any], # {'names': ..., 'formats': ..., 'offsets': ..., 'titles': ..., # 'itemsize': ...}