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()