def test_total_seconds_scalar(self):
# see gh-10939
rng = Timedelta('1 days, 10:11:12.100123456')
expt = 1 * 86400 + 10 * 3600 + 11 * 60 + 12 + 100123456. / 1e9
tm.assert_almost_equal(rng.total_seconds(), expt)
rng = Timedelta(np.nan)
assert np.isnan(rng.total_seconds())
def test_total_seconds_scalar(self):
# see gh-10939
rng = Timedelta('1 days, 10:11:12.100123456')
expt = 1 * 86400 + 10 * 3600 + 11 * 60 + 12 + 100123456. / 1e9
tm.assert_almost_equal(rng.total_seconds(), expt)
rng = Timedelta(np.nan)
assert np.isnan(rng.total_seconds())
def segment_to_indices(
signal: np.ndarray,
sampling_rate: int,
start: pd.Timedelta,
end: pd.Timedelta,
) -> typing.Tuple[int, int]:
if pd.isna(end):
end = pd.to_timedelta(signal.shape[-1] / sampling_rate, unit='s')
max_i = signal.shape[-1]
start_i = int(round(start.total_seconds() * sampling_rate))
start_i = min(start_i, max_i)
end_i = int(round(end.total_seconds() * sampling_rate))
end_i = min(end_i, max_i)
return start_i, end_i
def get_shock(self, step: pd.Timedelta):
shock = {}
for instrument_id, instrument in self.universe.items():
if np.random.rand() < self.rate * step.total_seconds():
magnitude = np.random.choice(np.arange(1, self.magnitude+1))
shock[instrument_id] = np.random.choice((1, -1)) * np.random.choice(magnitude)
return shock
def get_shock(self, step: pd.Timedelta):
shock = {}
for instrument_id, instrument in self.universe.items():
if np.random.rand() < self.rate * step.total_seconds():
log_ret = np.random.exponential(self.magnitude) * np.random.choice((1, -1))
shock[instrument_id] = int((np.exp(log_ret)-1) * instrument.get_value())
return shock
def read_audio(
path: str,
start: pd.Timedelta = None,
end: pd.Timedelta = None,
channel: int = None,
) -> typing.Tuple[np.ndarray, int]: # pragma: no cover
"""Reads (segment of an) audio file.
Args:
path: path to audio file
start: read from this position
end: read until this position
channel: channel number
Returns:
signal: array with signal values in shape ``(channels, samples)``
sampling_rate: sampling rate in Hz
"""
if start is None or pd.isna(start):
offset = 0
else:
offset = start.total_seconds()
if end is None or pd.isna(end):
duration = None
else:
duration = end.total_seconds() - offset
# load raw audio
signal, sampling_rate = af.read(
audeer.safe_path(path),
always_2d=True,
offset=offset,
duration=duration,
)
# mix down
if channel is not None:
if channel < 0 or channel >= signal.shape[0]:
raise ValueError(f'We need 0<=channel<{signal.shape[0]}, '
f'but we have channel={channel}.')
signal = signal[channel, :]
return signal, sampling_rate
def format_timedelta(td: pd.Timedelta, use_colons=True):
total_secs = int(td.total_seconds())
hrs = total_secs // 3600
mins = (total_secs % 3600) // 60
secs = (total_secs % 3600) % 60
if use_colons:
return f"{hrs:02}:{mins:02}:{secs:02}"
else:
return f"{hrs:02}{mins:02}{secs:02}"
def read_audio(
file: str,
*,
start: pd.Timedelta = None,
end: pd.Timedelta = None,
root: str = None,
) -> typing.Tuple[np.ndarray, int]:
"""Reads (segment of an) audio file.
Args:
file: path to audio file
start: read from this position
end: read until this position
root: root folder
Returns:
signal: array with signal values in shape ``(channels, samples)``
sampling_rate: sampling rate in Hz
"""
if root is not None and not os.path.isabs(file):
file = os.path.join(root, file)
if start is None or pd.isna(start):
offset = 0
else:
offset = start.total_seconds()
if end is None or pd.isna(end):
duration = None
else:
duration = end.total_seconds() - offset
signal, sampling_rate = af.read(
audeer.safe_path(file),
always_2d=True,
offset=offset,
duration=duration,
)
return signal, sampling_rate
def timedelt_to_float_h(timedeltas: pd.Timedelta) -> float: # type:ignore
"""
Convert timedelta to float.
Parameters
----------
timedeltas : pd.Timedelta
Timedifference.
Returns
-------
float
Timedelta as seconds.
"""
seconds = timedeltas.total_seconds() # type:ignore
return seconds / 3600
def test_as_unit_non_nano(self):
# case where we are going neither to nor from nano
td = Timedelta(days=1)._as_unit("ms")
assert td.days == 1
assert td.value == 86_400_000
assert td.components.days == 1
assert td._d == 1
assert td.total_seconds() == 86400
res = td._as_unit("us")
assert res.value == 86_400_000_000
assert res.components.days == 1
assert res.components.hours == 0
assert res._d == 1
assert res._h == 0
assert res.total_seconds() == 86400
def split_time_range(time_range: tuple, duration: pd.Timedelta, ignore_error=False) -> tuple:
"""
Takes a time range (formatted strings: '%Y-%m-%dT%H:%M:%S.%f'), and selects
a random interval within these boundaries of the specified active_screen_time.
:param time_range: tuple with formatted time strings
:param duration: timedelta specifying the active_screen_time of the new interval
:param ignore_error: (bool) if true, the function ignores durations
that exceed the original length of the time range
:return: new time range
"""
# Convert the time range strings to unix epoch format
start = datetime.strptime(time_range[0], '%Y-%m-%dT%H:%M:%S.%f').timestamp()
stop = datetime.strptime(time_range[1], '%Y-%m-%dT%H:%M:%S.%f').timestamp()
# Calculate total active_screen_time (in seconds) of original
difference = stop - start
# Calculate active_screen_time of new interval (in seconds)
duration = duration.total_seconds()
# Error handling
if difference < duration:
if ignore_error:
log(
"WARNING: New interval length exceeds original time range active_screen_time! Returning original time range.")
return time_range
else:
raise Exception('ERROR: New interval length exceeds original time range active_screen_time!')
# Pick random new start and stop
new_start = rnd.randint(int(start), int(stop - duration))
new_stop = new_start + duration
# Format new time range
new_time_range = (datetime.fromtimestamp(new_start).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3],
datetime.fromtimestamp(new_stop).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3])
return new_time_range
def toSeconds(someTime: Timedelta) -> float:
return someTime.total_seconds()
def __init__(self, value : float = 0, time_interval : pd.Timedelta = pd.Timedelta(1, 's')):
self._value = value / time_interval.total_seconds()