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': ...}