def test_is_list_like():
passes = ([], [1], (1, ), (1, 2), {'a': 1}, set([1, 'a']), Series([1]),
Series([]), Series(['a']).str)
fails = (1, '2', object(), str)
for p in passes:
assert inference.is_list_like(p)
for f in fails:
assert not inference.is_list_like(f)
def __setitem__(self, key, value):
from pandas.core.internals.arrays import extract_array
value = extract_array(value, extract_numpy=True)
if not lib.is_scalar(key) and is_list_like(key):
key = np.asarray(key)
if not lib.is_scalar(value):
value = np.asarray(value)
values = self._ndarray
t = np.result_type(value, values)
if t != self._ndarray.dtype:
values = values.astype(t, casting='safe')
values[key] = value
self._dtype = PandasDtype(t)
self._ndarray = values
else:
self._ndarray[key] = value
def test_is_nested_list_like_passes(inner, outer):
result = outer([inner for _ in range(5)])
assert inference.is_list_like(result)
def test_is_list_like(maybe_list_like):
obj, expected = maybe_list_like
expected = True if expected == 'set' else expected
assert inference.is_list_like(obj) == expected
def test_is_list_like_fails(ll):
assert not inference.is_list_like(ll)
def test_is_list_like_disallow_sets(maybe_list_like):
obj, expected = maybe_list_like
expected = False if expected == 'set' else expected
assert inference.is_list_like(obj, allow_sets=False) == expected
def test_is_list_like_passes(ll):
assert inference.is_list_like(ll)
def test_is_list_like_passes(ll):
assert inference.is_list_like(ll)
def test_is_nested_list_like_passes(inner, outer):
result = outer([inner for _ in range(5)])
assert inference.is_list_like(result)
def maybe_infer_to_datetimelike(value, convert_dates: bool = False):
"""
we might have a array (or single object) that is datetime like,
and no dtype is passed don't change the value unless we find a
datetime/timedelta set
this is pretty strict in that a datetime/timedelta is REQUIRED
in addition to possible nulls/string likes
Parameters
----------
value : np.array / Series / Index / list-like
convert_dates : bool, default False
if True try really hard to convert dates (such as datetime.date), other
leave inferred dtype 'date' alone
"""
# TODO: why not timedelta?
if isinstance(
value,
(ABCDatetimeIndex, ABCPeriodIndex, ABCDatetimeArray, ABCPeriodArray)):
return value
elif isinstance(value, ABCSeries):
if isinstance(value._values, ABCDatetimeIndex):
return value._values
v = value
if not is_list_like(v):
v = [v]
v = np.array(v, copy=False)
# we only care about object dtypes
if not is_object_dtype(v):
return value
shape = v.shape
if not v.ndim == 1:
v = v.ravel()
if not len(v):
return value
def try_datetime(v):
# safe coerce to datetime64
try:
# GH19671
v = tslib.array_to_datetime(v,
require_iso8601=True,
errors="raise")[0]
except ValueError:
# we might have a sequence of the same-datetimes with tz's
# if so coerce to a DatetimeIndex; if they are not the same,
# then these stay as object dtype, xref GH19671
from pandas._libs.tslibs import conversion
from pandas import DatetimeIndex
try:
values, tz = conversion.datetime_to_datetime64(v)
return DatetimeIndex(values).tz_localize("UTC").tz_convert(
tz=tz)
except (ValueError, TypeError):
pass
except Exception:
pass
return v.reshape(shape)
def try_timedelta(v):
# safe coerce to timedelta64
# will try first with a string & object conversion
from pandas import to_timedelta
try:
return to_timedelta(v)._ndarray_values.reshape(shape)
except ValueError:
return v.reshape(shape)
inferred_type = lib.infer_datetimelike_array(ensure_object(v))
if inferred_type == "date" and convert_dates:
value = try_datetime(v)
elif inferred_type == "datetime":
value = try_datetime(v)
elif inferred_type == "timedelta":
value = try_timedelta(v)
elif inferred_type == "nat":
# if all NaT, return as datetime
if isna(v).all():
value = try_datetime(v)
else:
# We have at least a NaT and a string
# try timedelta first to avoid spurious datetime conversions
# e.g. '00:00:01' is a timedelta but technically is also a datetime
value = try_timedelta(v)
if lib.infer_dtype(value, skipna=False) in ["mixed"]:
# cannot skip missing values, as NaT implies that the string
# is actually a datetime
value = try_datetime(v)
return value
def test_is_list_like_fails(ll):
assert not inference.is_list_like(ll)
def test_is_list_like_disallow_sets(maybe_list_like):
obj, expected = maybe_list_like
expected = False if expected == 'set' else expected
assert inference.is_list_like(obj, allow_sets=False) == expected
def test_is_list_like(maybe_list_like):
obj, expected = maybe_list_like
expected = True if expected == 'set' else expected
assert inference.is_list_like(obj) == expected
def _args_adjust(self):
if is_list_like(self.bottom):
self.bottom = np.array(self.bottom)
def __init__(
self,
values: Union[List[Genotype], "GenotypeArray", np.ndarray],
dtype: Optional[GenotypeDtype] = None,
copy: bool = False,
):
"""Initialize assuming values is a GenotypeArray or a numpy array with the correct underlying shape"""
# If the dtype is passed, ensure it is the correct type
if GenotypeDtype.is_dtype(dtype):
self._dtype = dtype
elif dtype is None:
self._dtype = None
else:
raise ValueError(
f"The passed dtype '{dtype}' is not a GenotypeDtype")
# Load the values
# ---------------
if not is_list_like(values):
values = [values]
if isinstance(values, np.ndarray) and (values.dtype
== self._dtype._record_type):
# Stored data format
self._data = values
elif self.is_genotype_array(values):
# values is a GenotypeArray, simply check the dtype and return
if self.dtype is not None:
if self.dtype != values.dtype:
raise ValueError(
f"The provided dtype {dtype} doesn't match"
f" the dtype of the provided values {values.dtype}")
else:
# Take dtype from the values
self._dtype = values.dtype
# Get the data
if copy:
values = values.copy()
self._data = values._data
elif len(values) == 0:
# Return an empty Genotype Array with the given GenotypeDtype
self._data = np.array(values, dtype=self._dtype._record_type)
elif all([type(i) == Genotype for i in values]):
# Sequence of Genotype objects
genotype_array = self._from_sequence(scalars=values,
dtype=dtype,
copy=copy)
# Replace self with the created array
self._data = genotype_array._data
self._dtype = genotype_array._dtype
elif all([type(i) == str for i in values]):
# List of Strings
genotype_array = self._from_sequence_of_strings(strings=values,
dtype=dtype,
copy=copy)
# Replace self with the created array
self._data = genotype_array._data
self._dtype = genotype_array._dtype
else:
raise ValueError(
f"Unsupported `values` type passed to __init__: {type(values)}"
)
# Set an anonymous dtype if one was not set
if self.dtype is None:
self._dtype = GenotypeDtype()
