s464967/Inzynierka
2
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
773aea2f05
Inzynierka/Lib/site-packages/pandas/core/arrays/timedeltas.py

1063 lines
34 KiB
Python
Raw Normal View History

first commit
2023-06-02 12:51:02 +02:00
from __future__ import annotations
from datetime import timedelta
import operator
from typing import (
TYPE_CHECKING,
Iterator,
cast,
)
import warnings
import numpy as np
from pandas._libs import (
lib,
tslibs,
)
from pandas._libs.tslibs import (
BaseOffset,
NaT,
NaTType,
Tick,
Timedelta,
astype_overflowsafe,
get_supported_reso,
get_unit_from_dtype,
iNaT,
is_supported_unit,
npy_unit_to_abbrev,
periods_per_second,
to_offset,
)
from pandas._libs.tslibs.conversion import precision_from_unit
from pandas._libs.tslibs.fields import (
get_timedelta_days,
get_timedelta_field,
)
from pandas._libs.tslibs.timedeltas import (
array_to_timedelta64,
floordiv_object_array,
ints_to_pytimedelta,
parse_timedelta_unit,
truediv_object_array,
)
from pandas._typing import (
AxisInt,
DateTimeErrorChoices,
DtypeObj,
NpDtype,
npt,
)
from pandas.compat.numpy import function as nv
from pandas.util._validators import validate_endpoints
from pandas.core.dtypes.common import (
TD64NS_DTYPE,
is_dtype_equal,
is_extension_array_dtype,
is_float_dtype,
is_integer_dtype,
is_object_dtype,
is_scalar,
is_string_dtype,
is_timedelta64_dtype,
pandas_dtype,
)
from pandas.core.dtypes.missing import isna
from pandas.core import nanops
from pandas.core.array_algos import datetimelike_accumulations
from pandas.core.arrays import datetimelike as dtl
from pandas.core.arrays._ranges import generate_regular_range
import pandas.core.common as com
from pandas.core.ops import roperator
from pandas.core.ops.common import unpack_zerodim_and_defer
if TYPE_CHECKING:
from pandas import DataFrame
def _field_accessor(name: str, alias: str, docstring: str):
def f(self) -> np.ndarray:
values = self.asi8
if alias == "days":
result = get_timedelta_days(values, reso=self._creso)
else:
# error: Incompatible types in assignment (
# expression has type "ndarray[Any, dtype[signedinteger[_32Bit]]]",
# variable has type "ndarray[Any, dtype[signedinteger[_64Bit]]]
result = get_timedelta_field(values, alias, reso=self._creso) # type: ignore[assignment] # noqa: E501
if self._hasna:
result = self._maybe_mask_results(
result, fill_value=None, convert="float64"
)
return result
f.__name__ = name
f.__doc__ = f"\n{docstring}\n"
return property(f)
class TimedeltaArray(dtl.TimelikeOps):
"""
Pandas ExtensionArray for timedelta data.
.. warning::
TimedeltaArray is currently experimental, and its API may change
without warning. In particular, :attr:`TimedeltaArray.dtype` is
expected to change to be an instance of an ``ExtensionDtype``
subclass.
Parameters
----------
values : array-like
The timedelta data.
dtype : numpy.dtype
Currently, only ``numpy.dtype("timedelta64[ns]")`` is accepted.
freq : Offset, optional
copy : bool, default False
Whether to copy the underlying array of data.
Attributes
----------
None
Methods
-------
None
"""
_typ = "timedeltaarray"
_internal_fill_value = np.timedelta64("NaT", "ns")
_recognized_scalars = (timedelta, np.timedelta64, Tick)
_is_recognized_dtype = is_timedelta64_dtype
_infer_matches = ("timedelta", "timedelta64")
@property
def _scalar_type(self) -> type[Timedelta]:
return Timedelta
__array_priority__ = 1000
# define my properties & methods for delegation
_other_ops: list[str] = []
_bool_ops: list[str] = []
_object_ops: list[str] = ["freq"]
_field_ops: list[str] = ["days", "seconds", "microseconds", "nanoseconds"]
_datetimelike_ops: list[str] = _field_ops + _object_ops + _bool_ops + ["unit"]
_datetimelike_methods: list[str] = [
"to_pytimedelta",
"total_seconds",
"round",
"floor",
"ceil",
"as_unit",
]
# Note: ndim must be defined to ensure NaT.__richcmp__(TimedeltaArray)
# operates pointwise.
def _box_func(self, x: np.timedelta64) -> Timedelta | NaTType:
y = x.view("i8")
if y == NaT._value:
return NaT
return Timedelta._from_value_and_reso(y, reso=self._creso)
@property
# error: Return type "dtype" of "dtype" incompatible with return type
# "ExtensionDtype" in supertype "ExtensionArray"
def dtype(self) -> np.dtype: # type: ignore[override]
"""
The dtype for the TimedeltaArray.
.. warning::
A future version of pandas will change dtype to be an instance
of a :class:`pandas.api.extensions.ExtensionDtype` subclass,
not a ``numpy.dtype``.
Returns
-------
numpy.dtype
"""
return self._ndarray.dtype
# ----------------------------------------------------------------
# Constructors
_freq = None
_default_dtype = TD64NS_DTYPE # used in TimeLikeOps.__init__
@classmethod
def _validate_dtype(cls, values, dtype):
# used in TimeLikeOps.__init__
_validate_td64_dtype(values.dtype)
dtype = _validate_td64_dtype(dtype)
return dtype
# error: Signature of "_simple_new" incompatible with supertype "NDArrayBacked"
@classmethod
def _simple_new( # type: ignore[override]
cls, values: np.ndarray, freq: BaseOffset | None = None, dtype=TD64NS_DTYPE
) -> TimedeltaArray:
# Require td64 dtype, not unit-less, matching values.dtype
assert isinstance(dtype, np.dtype) and dtype.kind == "m"
assert not tslibs.is_unitless(dtype)
assert isinstance(values, np.ndarray), type(values)
assert dtype == values.dtype
result = super()._simple_new(values=values, dtype=dtype)
result._freq = freq
return result
@classmethod
def _from_sequence(cls, data, *, dtype=None, copy: bool = False) -> TimedeltaArray:
if dtype:
dtype = _validate_td64_dtype(dtype)
data, inferred_freq = sequence_to_td64ns(data, copy=copy, unit=None)
freq, _ = dtl.validate_inferred_freq(None, inferred_freq, False)
if dtype is not None:
data = astype_overflowsafe(data, dtype=dtype, copy=False)
return cls._simple_new(data, dtype=data.dtype, freq=freq)
@classmethod
def _from_sequence_not_strict(
cls,
data,
*,
dtype=None,
copy: bool = False,
freq=lib.no_default,
unit=None,
) -> TimedeltaArray:
"""
A non-strict version of _from_sequence, called from TimedeltaIndex.__new__.
"""
if dtype:
dtype = _validate_td64_dtype(dtype)
assert unit not in ["Y", "y", "M"] # caller is responsible for checking
explicit_none = freq is None
freq = freq if freq is not lib.no_default else None
freq, freq_infer = dtl.maybe_infer_freq(freq)
data, inferred_freq = sequence_to_td64ns(data, copy=copy, unit=unit)
freq, freq_infer = dtl.validate_inferred_freq(freq, inferred_freq, freq_infer)
if explicit_none:
freq = None
if dtype is not None:
data = astype_overflowsafe(data, dtype=dtype, copy=False)
result = cls._simple_new(data, dtype=data.dtype, freq=freq)
if inferred_freq is None and freq is not None:
# this condition precludes `freq_infer`
cls._validate_frequency(result, freq)
elif freq_infer:
# Set _freq directly to bypass duplicative _validate_frequency
# check.
result._freq = to_offset(result.inferred_freq)
return result
# Signature of "_generate_range" incompatible with supertype
# "DatetimeLikeArrayMixin"
@classmethod
def _generate_range( # type: ignore[override]
cls, start, end, periods, freq, closed=None, *, unit: str | None = None
):
periods = dtl.validate_periods(periods)
if freq is None and any(x is None for x in [periods, start, end]):
raise ValueError("Must provide freq argument if no data is supplied")
if com.count_not_none(start, end, periods, freq) != 3:
raise ValueError(
"Of the four parameters: start, end, periods, "
"and freq, exactly three must be specified"
)
if start is not None:
start = Timedelta(start).as_unit("ns")
if end is not None:
end = Timedelta(end).as_unit("ns")
if unit is not None:
if unit not in ["s", "ms", "us", "ns"]:
raise ValueError("'unit' must be one of 's', 'ms', 'us', 'ns'")
else:
unit = "ns"
if start is not None and unit is not None:
start = start.as_unit(unit, round_ok=False)
if end is not None and unit is not None:
end = end.as_unit(unit, round_ok=False)
left_closed, right_closed = validate_endpoints(closed)
if freq is not None:
index = generate_regular_range(start, end, periods, freq, unit=unit)
else:
index = np.linspace(start._value, end._value, periods).astype("i8")
if not left_closed:
index = index[1:]
if not right_closed:
index = index[:-1]
td64values = index.view(f"m8[{unit}]")
return cls._simple_new(td64values, dtype=td64values.dtype, freq=freq)
# ----------------------------------------------------------------
# DatetimeLike Interface
def _unbox_scalar(self, value) -> np.timedelta64:
if not isinstance(value, self._scalar_type) and value is not NaT:
raise ValueError("'value' should be a Timedelta.")
self._check_compatible_with(value)
if value is NaT:
return np.timedelta64(value._value, self.unit)
else:
return value.as_unit(self.unit).asm8
def _scalar_from_string(self, value) -> Timedelta | NaTType:
return Timedelta(value)
def _check_compatible_with(self, other) -> None:
# we don't have anything to validate.
pass
# ----------------------------------------------------------------
# Array-Like / EA-Interface Methods
def astype(self, dtype, copy: bool = True):
# We handle
# --> timedelta64[ns]
# --> timedelta64
# DatetimeLikeArrayMixin super call handles other cases
dtype = pandas_dtype(dtype)
if isinstance(dtype, np.dtype) and dtype.kind == "m":
if dtype == self.dtype:
if copy:
return self.copy()
return self
if is_supported_unit(get_unit_from_dtype(dtype)):
# unit conversion e.g. timedelta64[s]
res_values = astype_overflowsafe(self._ndarray, dtype, copy=False)
return type(self)._simple_new(
res_values, dtype=res_values.dtype, freq=self.freq
)
else:
raise ValueError(
f"Cannot convert from {self.dtype} to {dtype}. "
"Supported resolutions are 's', 'ms', 'us', 'ns'"
)
return dtl.DatetimeLikeArrayMixin.astype(self, dtype, copy=copy)
def __iter__(self) -> Iterator:
if self.ndim > 1:
for i in range(len(self)):
yield self[i]
else:
# convert in chunks of 10k for efficiency
data = self._ndarray
length = len(self)
chunksize = 10000
chunks = (length // chunksize) + 1
for i in range(chunks):
start_i = i * chunksize
end_i = min((i + 1) * chunksize, length)
converted = ints_to_pytimedelta(data[start_i:end_i], box=True)
yield from converted
# ----------------------------------------------------------------
# Reductions
def sum(
self,
*,
axis: AxisInt | None = None,
dtype: NpDtype | None = None,
out=None,
keepdims: bool = False,
initial=None,
skipna: bool = True,
min_count: int = 0,
):
nv.validate_sum(
(), {"dtype": dtype, "out": out, "keepdims": keepdims, "initial": initial}
)
result = nanops.nansum(
self._ndarray, axis=axis, skipna=skipna, min_count=min_count
)
return self._wrap_reduction_result(axis, result)
def std(
self,
*,
axis: AxisInt | None = None,
dtype: NpDtype | None = None,
out=None,
ddof: int = 1,
keepdims: bool = False,
skipna: bool = True,
):
nv.validate_stat_ddof_func(
(), {"dtype": dtype, "out": out, "keepdims": keepdims}, fname="std"
)
result = nanops.nanstd(self._ndarray, axis=axis, skipna=skipna, ddof=ddof)
if axis is None or self.ndim == 1:
return self._box_func(result)
return self._from_backing_data(result)
# ----------------------------------------------------------------
# Accumulations
def _accumulate(self, name: str, *, skipna: bool = True, **kwargs):
if name == "cumsum":
op = getattr(datetimelike_accumulations, name)
result = op(self._ndarray.copy(), skipna=skipna, **kwargs)
return type(self)._simple_new(result, freq=None, dtype=self.dtype)
elif name == "cumprod":
raise TypeError("cumprod not supported for Timedelta.")
else:
return super()._accumulate(name, skipna=skipna, **kwargs)
# ----------------------------------------------------------------
# Rendering Methods
def _formatter(self, boxed: bool = False):
from pandas.io.formats.format import get_format_timedelta64
return get_format_timedelta64(self, box=True)
def _format_native_types(
self, *, na_rep: str | float = "NaT", date_format=None, **kwargs
) -> npt.NDArray[np.object_]:
from pandas.io.formats.format import get_format_timedelta64
# Relies on TimeDelta._repr_base
formatter = get_format_timedelta64(self._ndarray, na_rep)
# equiv: np.array([formatter(x) for x in self._ndarray])
# but independent of dimension
return np.frompyfunc(formatter, 1, 1)(self._ndarray)
# ----------------------------------------------------------------
# Arithmetic Methods
def _add_offset(self, other):
assert not isinstance(other, Tick)
raise TypeError(
f"cannot add the type {type(other).__name__} to a {type(self).__name__}"
)
@unpack_zerodim_and_defer("__mul__")
def __mul__(self, other) -> TimedeltaArray:
if is_scalar(other):
# numpy will accept float and int, raise TypeError for others
result = self._ndarray * other
freq = None
if self.freq is not None and not isna(other):
freq = self.freq * other
return type(self)._simple_new(result, dtype=result.dtype, freq=freq)
if not hasattr(other, "dtype"):
# list, tuple
other = np.array(other)
if len(other) != len(self) and not is_timedelta64_dtype(other.dtype):
# Exclude timedelta64 here so we correctly raise TypeError
# for that instead of ValueError
raise ValueError("Cannot multiply with unequal lengths")
if is_object_dtype(other.dtype):
# this multiplication will succeed only if all elements of other
# are int or float scalars, so we will end up with
# timedelta64[ns]-dtyped result
arr = self._ndarray
result = [arr[n] * other[n] for n in range(len(self))]
result = np.array(result)
return type(self)._simple_new(result, dtype=result.dtype)
# numpy will accept float or int dtype, raise TypeError for others
result = self._ndarray * other
return type(self)._simple_new(result, dtype=result.dtype)
__rmul__ = __mul__
def _scalar_divlike_op(self, other, op):
"""
Shared logic for __truediv__, __rtruediv__, __floordiv__, __rfloordiv__
with scalar 'other'.
"""
if isinstance(other, self._recognized_scalars):
other = Timedelta(other)
# mypy assumes that __new__ returns an instance of the class
# github.com/python/mypy/issues/1020
if cast("Timedelta | NaTType", other) is NaT:
# specifically timedelta64-NaT
result = np.empty(self.shape, dtype=np.float64)
result.fill(np.nan)
return result
# otherwise, dispatch to Timedelta implementation
return op(self._ndarray, other)
else:
# caller is responsible for checking lib.is_scalar(other)
# assume other is numeric, otherwise numpy will raise
if op in [roperator.rtruediv, roperator.rfloordiv]:
raise TypeError(
f"Cannot divide {type(other).__name__} by {type(self).__name__}"
)
result = op(self._ndarray, other)
freq = None
if self.freq is not None:
# Note: freq gets division, not floor-division, even if op
# is floordiv.
freq = self.freq / other
# TODO: 2022-12-24 test_ufunc_coercions, test_tdi_ops_attributes
# get here for truediv, no tests for floordiv
if op is operator.floordiv:
if freq.nanos == 0 and self.freq.nanos != 0:
# e.g. if self.freq is Nano(1) then dividing by 2
# rounds down to zero
# TODO: 2022-12-24 should implement the same check
# for truediv case
freq = None
return type(self)._simple_new(result, dtype=result.dtype, freq=freq)
def _cast_divlike_op(self, other):
if not hasattr(other, "dtype"):
# e.g. list, tuple
other = np.array(other)
if len(other) != len(self):
raise ValueError("Cannot divide vectors with unequal lengths")
return other
def _vector_divlike_op(self, other, op) -> np.ndarray | TimedeltaArray:
"""
Shared logic for __truediv__, __floordiv__, and their reversed versions
with timedelta64-dtype ndarray other.
"""
# Let numpy handle it
result = op(self._ndarray, np.asarray(other))
if (is_integer_dtype(other.dtype) or is_float_dtype(other.dtype)) and op in [
operator.truediv,
operator.floordiv,
]:
return type(self)._simple_new(result, dtype=result.dtype)
if op in [operator.floordiv, roperator.rfloordiv]:
mask = self.isna() | isna(other)
if mask.any():
result = result.astype(np.float64)
np.putmask(result, mask, np.nan)
return result
@unpack_zerodim_and_defer("__truediv__")
def __truediv__(self, other):
# timedelta / X is well-defined for timedelta-like or numeric X
op = operator.truediv
if is_scalar(other):
return self._scalar_divlike_op(other, op)
other = self._cast_divlike_op(other)
if (
is_timedelta64_dtype(other.dtype)
or is_integer_dtype(other.dtype)
or is_float_dtype(other.dtype)
):
return self._vector_divlike_op(other, op)
if is_object_dtype(other.dtype):
other = np.asarray(other)
if self.ndim > 1:
res_cols = [left / right for left, right in zip(self, other)]
res_cols2 = [x.reshape(1, -1) for x in res_cols]
result = np.concatenate(res_cols2, axis=0)
else:
result = truediv_object_array(self._ndarray, other)
return result
else:
return NotImplemented
@unpack_zerodim_and_defer("__rtruediv__")
def __rtruediv__(self, other):
# X / timedelta is defined only for timedelta-like X
op = roperator.rtruediv
if is_scalar(other):
return self._scalar_divlike_op(other, op)
other = self._cast_divlike_op(other)
if is_timedelta64_dtype(other.dtype):
return self._vector_divlike_op(other, op)
elif is_object_dtype(other.dtype):
# Note: unlike in __truediv__, we do not _need_ to do type
# inference on the result. It does not raise, a numeric array
# is returned. GH#23829
result_list = [other[n] / self[n] for n in range(len(self))]
return np.array(result_list)
else:
return NotImplemented
@unpack_zerodim_and_defer("__floordiv__")
def __floordiv__(self, other):
op = operator.floordiv
if is_scalar(other):
return self._scalar_divlike_op(other, op)
other = self._cast_divlike_op(other)
if (
is_timedelta64_dtype(other.dtype)
or is_integer_dtype(other.dtype)
or is_float_dtype(other.dtype)
):
return self._vector_divlike_op(other, op)
elif is_object_dtype(other.dtype):
other = np.asarray(other)
if self.ndim > 1:
res_cols = [left // right for left, right in zip(self, other)]
res_cols2 = [x.reshape(1, -1) for x in res_cols]
result = np.concatenate(res_cols2, axis=0)
else:
result = floordiv_object_array(self._ndarray, other)
assert result.dtype == object
return result
else:
return NotImplemented
@unpack_zerodim_and_defer("__rfloordiv__")
def __rfloordiv__(self, other):
op = roperator.rfloordiv
if is_scalar(other):
return self._scalar_divlike_op(other, op)
other = self._cast_divlike_op(other)
if is_timedelta64_dtype(other.dtype):
return self._vector_divlike_op(other, op)
elif is_object_dtype(other.dtype):
result_list = [other[n] // self[n] for n in range(len(self))]
result = np.array(result_list)
return result
else:
return NotImplemented
@unpack_zerodim_and_defer("__mod__")
def __mod__(self, other):
# Note: This is a naive implementation, can likely be optimized
if isinstance(other, self._recognized_scalars):
other = Timedelta(other)
return self - (self // other) * other
@unpack_zerodim_and_defer("__rmod__")
def __rmod__(self, other):
# Note: This is a naive implementation, can likely be optimized
if isinstance(other, self._recognized_scalars):
other = Timedelta(other)
return other - (other // self) * self
@unpack_zerodim_and_defer("__divmod__")
def __divmod__(self, other):
# Note: This is a naive implementation, can likely be optimized
if isinstance(other, self._recognized_scalars):
other = Timedelta(other)
res1 = self // other
res2 = self - res1 * other
return res1, res2
@unpack_zerodim_and_defer("__rdivmod__")
def __rdivmod__(self, other):
# Note: This is a naive implementation, can likely be optimized
if isinstance(other, self._recognized_scalars):
other = Timedelta(other)
res1 = other // self
res2 = other - res1 * self
return res1, res2
def __neg__(self) -> TimedeltaArray:
freq = None
if self.freq is not None:
freq = -self.freq
return type(self)._simple_new(-self._ndarray, dtype=self.dtype, freq=freq)
def __pos__(self) -> TimedeltaArray:
return type(self)(self._ndarray.copy(), freq=self.freq)
def __abs__(self) -> TimedeltaArray:
# Note: freq is not preserved
return type(self)(np.abs(self._ndarray))
# ----------------------------------------------------------------
# Conversion Methods - Vectorized analogues of Timedelta methods
def total_seconds(self) -> npt.NDArray[np.float64]:
"""
Return total duration of each element expressed in seconds.
This method is available directly on TimedeltaArray, TimedeltaIndex
and on Series containing timedelta values under the ``.dt`` namespace.
Returns
-------
ndarray, Index or Series
When the calling object is a TimedeltaArray, the return type
is ndarray. When the calling object is a TimedeltaIndex,
the return type is an Index with a float64 dtype. When the calling object
is a Series, the return type is Series of type `float64` whose
index is the same as the original.
See Also
--------
datetime.timedelta.total_seconds : Standard library version
of this method.
TimedeltaIndex.components : Return a DataFrame with components of
each Timedelta.
Examples
--------
**Series**
>>> s = pd.Series(pd.to_timedelta(np.arange(5), unit='d'))
>>> s
0 0 days
1 1 days
2 2 days
3 3 days
4 4 days
dtype: timedelta64[ns]
>>> s.dt.total_seconds()
0 0.0
1 86400.0
2 172800.0
3 259200.0
4 345600.0
dtype: float64
**TimedeltaIndex**
>>> idx = pd.to_timedelta(np.arange(5), unit='d')
>>> idx
TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'],
dtype='timedelta64[ns]', freq=None)
>>> idx.total_seconds()
Index([0.0, 86400.0, 172800.0, 259200.0, 345600.0], dtype='float64')
"""
pps = periods_per_second(self._creso)
return self._maybe_mask_results(self.asi8 / pps, fill_value=None)
def to_pytimedelta(self) -> npt.NDArray[np.object_]:
"""
Return an ndarray of datetime.timedelta objects.
Returns
-------
numpy.ndarray
"""
return ints_to_pytimedelta(self._ndarray)
days = _field_accessor("days", "days", "Number of days for each element.")
seconds = _field_accessor(
"seconds",
"seconds",
"Number of seconds (>= 0 and less than 1 day) for each element.",
)
microseconds = _field_accessor(
"microseconds",
"microseconds",
"Number of microseconds (>= 0 and less than 1 second) for each element.",
)
nanoseconds = _field_accessor(
"nanoseconds",
"nanoseconds",
"Number of nanoseconds (>= 0 and less than 1 microsecond) for each element.",
)
@property
def components(self) -> DataFrame:
"""
Return a DataFrame of the individual resolution components of the Timedeltas.
The components (days, hours, minutes seconds, milliseconds, microseconds,
nanoseconds) are returned as columns in a DataFrame.
Returns
-------
DataFrame
"""
from pandas import DataFrame
columns = [
"days",
"hours",
"minutes",
"seconds",
"milliseconds",
"microseconds",
"nanoseconds",
]
hasnans = self._hasna
if hasnans:
def f(x):
if isna(x):
return [np.nan] * len(columns)
return x.components
else:
def f(x):
return x.components
result = DataFrame([f(x) for x in self], columns=columns)
if not hasnans:
result = result.astype("int64")
return result
# ---------------------------------------------------------------------
# Constructor Helpers
def sequence_to_td64ns(
data,
copy: bool = False,
unit=None,
errors: DateTimeErrorChoices = "raise",
) -> tuple[np.ndarray, Tick | None]:
"""
Parameters
----------
data : list-like
copy : bool, default False
unit : str, optional
The timedelta unit to treat integers as multiples of. For numeric
data this defaults to ``'ns'``.
Must be un-specified if the data contains a str and ``errors=="raise"``.
errors : {"raise", "coerce", "ignore"}, default "raise"
How to handle elements that cannot be converted to timedelta64[ns].
See ``pandas.to_timedelta`` for details.
Returns
-------
converted : numpy.ndarray
The sequence converted to a numpy array with dtype ``timedelta64[ns]``.
inferred_freq : Tick or None
The inferred frequency of the sequence.
Raises
------
ValueError : Data cannot be converted to timedelta64[ns].
Notes
-----
Unlike `pandas.to_timedelta`, if setting ``errors=ignore`` will not cause
errors to be ignored; they are caught and subsequently ignored at a
higher level.
"""
assert unit not in ["Y", "y", "M"] # caller is responsible for checking
inferred_freq = None
if unit is not None:
unit = parse_timedelta_unit(unit)
data, copy = dtl.ensure_arraylike_for_datetimelike(
data, copy, cls_name="TimedeltaArray"
)
if isinstance(data, TimedeltaArray):
inferred_freq = data.freq
# Convert whatever we have into timedelta64[ns] dtype
if is_object_dtype(data.dtype) or is_string_dtype(data.dtype):
# no need to make a copy, need to convert if string-dtyped
data = _objects_to_td64ns(data, unit=unit, errors=errors)
copy = False
elif is_integer_dtype(data.dtype):
# treat as multiples of the given unit
data, copy_made = _ints_to_td64ns(data, unit=unit)
copy = copy and not copy_made
elif is_float_dtype(data.dtype):
# cast the unit, multiply base/frac separately
# to avoid precision issues from float -> int
if is_extension_array_dtype(data):
mask = data._mask
data = data._data
else:
mask = np.isnan(data)
# The next few lines are effectively a vectorized 'cast_from_unit'
m, p = precision_from_unit(unit or "ns")
with warnings.catch_warnings():
# Suppress RuntimeWarning about All-NaN slice
warnings.filterwarnings(
"ignore", "invalid value encountered in cast", RuntimeWarning
)
base = data.astype(np.int64)
frac = data - base
if p:
frac = np.round(frac, p)
with warnings.catch_warnings():
warnings.filterwarnings(
"ignore", "invalid value encountered in cast", RuntimeWarning
)
data = (base * m + (frac * m).astype(np.int64)).view("timedelta64[ns]")
data[mask] = iNaT
copy = False
elif is_timedelta64_dtype(data.dtype):
data_unit = get_unit_from_dtype(data.dtype)
if not is_supported_unit(data_unit):
# cast to closest supported unit, i.e. s or ns
new_reso = get_supported_reso(data_unit)
new_unit = npy_unit_to_abbrev(new_reso)
new_dtype = np.dtype(f"m8[{new_unit}]")
data = astype_overflowsafe(data, dtype=new_dtype, copy=False)
copy = False
else:
# This includes datetime64-dtype, see GH#23539, GH#29794
raise TypeError(f"dtype {data.dtype} cannot be converted to timedelta64[ns]")
data = np.array(data, copy=copy)
assert data.dtype.kind == "m"
assert data.dtype != "m8" # i.e. not unit-less
return data, inferred_freq
def _ints_to_td64ns(data, unit: str = "ns"):
"""
Convert an ndarray with integer-dtype to timedelta64[ns] dtype, treating
the integers as multiples of the given timedelta unit.
Parameters
----------
data : numpy.ndarray with integer-dtype
unit : str, default "ns"
The timedelta unit to treat integers as multiples of.
Returns
-------
numpy.ndarray : timedelta64[ns] array converted from data
bool : whether a copy was made
"""
copy_made = False
unit = unit if unit is not None else "ns"
if data.dtype != np.int64:
# converting to int64 makes a copy, so we can avoid
# re-copying later
data = data.astype(np.int64)
copy_made = True
if unit != "ns":
dtype_str = f"timedelta64[{unit}]"
data = data.view(dtype_str)
data = astype_overflowsafe(data, dtype=TD64NS_DTYPE)
# the astype conversion makes a copy, so we can avoid re-copying later
copy_made = True
else:
data = data.view("timedelta64[ns]")
return data, copy_made
def _objects_to_td64ns(data, unit=None, errors: DateTimeErrorChoices = "raise"):
"""
Convert a object-dtyped or string-dtyped array into an
timedelta64[ns]-dtyped array.
Parameters
----------
data : ndarray or Index
unit : str, default "ns"
The timedelta unit to treat integers as multiples of.
Must not be specified if the data contains a str.
errors : {"raise", "coerce", "ignore"}, default "raise"
How to handle elements that cannot be converted to timedelta64[ns].
See ``pandas.to_timedelta`` for details.
Returns
-------
numpy.ndarray : timedelta64[ns] array converted from data
Raises
------
ValueError : Data cannot be converted to timedelta64[ns].
Notes
-----
Unlike `pandas.to_timedelta`, if setting `errors=ignore` will not cause
errors to be ignored; they are caught and subsequently ignored at a
higher level.
"""
# coerce Index to np.ndarray, converting string-dtype if necessary
values = np.array(data, dtype=np.object_, copy=False)
result = array_to_timedelta64(values, unit=unit, errors=errors)
return result.view("timedelta64[ns]")
def _validate_td64_dtype(dtype) -> DtypeObj:
dtype = pandas_dtype(dtype)
if is_dtype_equal(dtype, np.dtype("timedelta64")):
# no precision disallowed GH#24806
msg = (
"Passing in 'timedelta' dtype with no precision is not allowed. "
"Please pass in 'timedelta64[ns]' instead."
)
raise ValueError(msg)
if (
not isinstance(dtype, np.dtype)
or dtype.kind != "m"
or not is_supported_unit(get_unit_from_dtype(dtype))
):
raise ValueError(f"dtype {dtype} cannot be converted to timedelta64[ns]")
return dtype
Reference in New Issue Copy Permalink