def test_Microsecond():
assert_offset_equal(Micro(), datetime(2010, 1, 1),
datetime(2010, 1, 1, 0, 0, 0, 1))
assert_offset_equal(Micro(-1), datetime(2010, 1, 1, 0, 0, 0, 1),
datetime(2010, 1, 1))
assert_offset_equal(2 * Micro(), datetime(2010, 1, 1),
datetime(2010, 1, 1, 0, 0, 0, 2))
assert_offset_equal(-1 * Micro(), datetime(2010, 1, 1, 0, 0, 0, 1),
datetime(2010, 1, 1))
assert Micro(3) + Micro(2) == Micro(5)
assert Micro(3) - Micro(2) == Micro()
def test_tick_mul_float():
off = Micro(2)
# Case where we retain type
result = off * 1.5
expected = Micro(3)
assert result == expected
assert isinstance(result, Micro)
# Case where we bump up to the next type
result = off * 1.25
expected = Nano(2500)
assert result == expected
assert isinstance(result, Nano)
def test_Nanosecond():
timestamp = Timestamp(datetime(2010, 1, 1))
assert_offset_equal(Nano(), timestamp, timestamp + np.timedelta64(1, "ns"))
assert_offset_equal(Nano(-1), timestamp + np.timedelta64(1, "ns"), timestamp)
assert_offset_equal(2 * Nano(), timestamp, timestamp + np.timedelta64(2, "ns"))
assert_offset_equal(-1 * Nano(), timestamp + np.timedelta64(1, "ns"), timestamp)
assert Nano(3) + Nano(2) == Nano(5)
assert Nano(3) - Nano(2) == Nano()
# GH9284
assert Nano(1) + Nano(10) == Nano(11)
assert Nano(5) + Micro(1) == Nano(1005)
assert Micro(5) + Nano(1) == Nano(5001)
def test_resolution(self):
def _assert_less(ts1, ts2):
val1 = self.dtc.convert(ts1, None, None)
val2 = self.dtc.convert(ts2, None, None)
if not val1 < val2:
raise AssertionError(f"{val1} is not less than {val2}.")
# Matplotlib's time representation using floats cannot distinguish
# intervals smaller than ~10 microsecond in the common range of years.
ts = Timestamp("2012-1-1")
_assert_less(ts, ts + Second())
_assert_less(ts, ts + Milli())
_assert_less(ts, ts + Micro(50))
def get_ts(_file, _s):
_df = pd.read_csv(_file,
names=['date', 'EURUSD', 'EURJPY', 'EURAUD',
'USDJPY']).dropna()
del _df['EURJPY'], _df['EURAUD'], _df['USDJPY']
_df['EURUSD'] = _df['EURUSD'].apply(lambda x: x.split(':')[1])
# delete row with ''
_df = _df.drop(_df.ix[_df.EURUSD == ''].index)
_df['EURUSD'] = _df['EURUSD'].astype(float)
_df['time'] = pd.DatetimeIndex(
_df['date'].apply(lambda x: x.split('.')[0]))
_df['micros'] = _df['date'].apply(lambda x: x.split('.')[1]).astype(
int) + 1
_df['micros'] = _df['micros'].apply(lambda _x: Micro(_x))
_df.index = _df['time'] + _df['micros'] # index as Datetime
del _df['date']
del _df['time']
del _df['micros']
# pandas.core.frame.DataFrame
_ts = pd.DataFrame(_df['EURUSD'].resample(_s).bfill())
_ts['change'] = _ts['EURUSD'] - _ts['EURUSD'].shift()
_ts['A'] = 1
_ts.loc[_ts.change == 0, 'A'] = 0
_ts['D'] = 0
_ts.loc[_ts.change > 0, 'D'] = 1
_ts.loc[_ts.change < 0, 'D'] = -1
_ts['A_lag1'] = _ts['A'].shift(1) # 'A': Ai; 'A_lag1': Aim1
_ts['D_lag1'] = _ts['D'].shift(1) # 'D': Di; 'D_lag1': Dim1
return _ts.dropna()
def resample(df, sampling_period=1):
"""Resample the data
Warning: does not handle missing values
Parameters
----------
df: pandas.DataFrame,
index: pandas.DatetimeIndex
values: power measured
sampling_period: float of int, optional
Elapsed time between two measures in second
Returns
-------
df: pandas.DataFrame,
index: pandas.DatetimeIndex with sampling_period seconds between
two timestapms
values: power measured
"""
assert isinstance(df, pd.DataFrame)
assert isinstance(df.index, pd.DatetimeIndex)
if isinstance(sampling_period, int):
df = df.resample(Second(sampling_period),
how='last',
label='right',
closed='right')
else:
period = sampling_period * (10**6)
df = df.resample(Micro(period),
how='last',
label='right',
closed='right')
return df
from pandas.tseries.offsets import (Day, BDay, Hour, Minute, Second, Milli,
Week, Micro, MonthEnd, MonthBegin,
BMonthBegin, BMonthEnd, YearBegin, YearEnd,
BYearBegin, BYearEnd, QuarterBegin,
QuarterEnd, BQuarterBegin, BQuarterEnd)
_offset_map = {
'D' : Day(),
'B' : BDay(),
'H' : Hour(),
'T' : Minute(),
'S' : Second(),
'L' : Milli(),
'U' : Micro(),
None : None,
# Monthly - Calendar
'M' : MonthEnd(),
'MS' : MonthBegin(),
# Monthly - Business
'BM' : BMonthEnd(),
'BMS' : BMonthBegin(),
# Annual - Calendar
'A-JAN' : YearEnd(month=1),
'A-FEB' : YearEnd(month=2),
'A-MAR' : YearEnd(month=3),
'A-APR' : YearEnd(month=4),
'BA': 'BA-DEC', # BYearEnd(month=12),
'BAS': 'BAS-JAN', # BYearBegin(month=1),
'Min': 'T',
'min': 'T',
'ms': 'L',
'us': 'U',
'ns': 'N'
}
_name_to_offset_map = {
'days': Day(1),
'hours': Hour(1),
'minutes': Minute(1),
'seconds': Second(1),
'milliseconds': Milli(1),
'microseconds': Micro(1),
'nanoseconds': Nano(1)
}
_INVALID_FREQ_ERROR = "Invalid frequency: {0}"
def to_offset(freqstr):
"""
Return DateOffset object from string representation or
Timedelta object
Examples
--------
>>> to_offset('5Min')
Minute(5)
def get_period_alias(offset_str: str) -> Optional[str]:
"""
Alias to closest period strings BQ->Q etc.
"""
return _offset_to_period_map.get(offset_str, None)
_name_to_offset_map = {
"days": Day(1),
"hours": Hour(1),
"minutes": Minute(1),
"seconds": Second(1),
"milliseconds": Milli(1),
"microseconds": Micro(1),
"nanoseconds": Nano(1),
}
def to_offset(freq) -> Optional[DateOffset]:
"""
Return DateOffset object from string or tuple representation
or datetime.timedelta object.
Parameters
----------
freq : str, tuple, datetime.timedelta, DateOffset or None
Returns
-------
class TestDateTimeConverter:
@pytest.fixture
def dtc(self):
return converter.DatetimeConverter()
def test_convert_accepts_unicode(self, dtc):
r1 = dtc.convert("12:22", None, None)
r2 = dtc.convert("12:22", None, None)
assert r1 == r2, "DatetimeConverter.convert should accept unicode"
def test_conversion(self, dtc):
rs = dtc.convert(["2012-1-1"], None, None)[0]
xp = dates.date2num(datetime(2012, 1, 1))
assert rs == xp
rs = dtc.convert("2012-1-1", None, None)
assert rs == xp
rs = dtc.convert(date(2012, 1, 1), None, None)
assert rs == xp
rs = dtc.convert("2012-1-1", None, None)
assert rs == xp
rs = dtc.convert(Timestamp("2012-1-1"), None, None)
assert rs == xp
# also testing datetime64 dtype (GH8614)
rs = dtc.convert("2012-01-01", None, None)
assert rs == xp
rs = dtc.convert("2012-01-01 00:00:00+0000", None, None)
assert rs == xp
rs = dtc.convert(
np.array(["2012-01-01 00:00:00+0000", "2012-01-02 00:00:00+0000"]),
None,
None,
)
assert rs[0] == xp
# we have a tz-aware date (constructed to that when we turn to utc it
# is the same as our sample)
ts = Timestamp("2012-01-01").tz_localize("UTC").tz_convert(
"US/Eastern")
rs = dtc.convert(ts, None, None)
assert rs == xp
rs = dtc.convert(ts.to_pydatetime(), None, None)
assert rs == xp
rs = dtc.convert(Index([ts - Day(1), ts]), None, None)
assert rs[1] == xp
rs = dtc.convert(Index([ts - Day(1), ts]).to_pydatetime(), None, None)
assert rs[1] == xp
def test_conversion_float(self, dtc):
rtol = 0.5 * 10**-9
rs = dtc.convert(Timestamp("2012-1-1 01:02:03", tz="UTC"), None, None)
xp = converter.dates.date2num(Timestamp("2012-1-1 01:02:03", tz="UTC"))
tm.assert_almost_equal(rs, xp, rtol=rtol)
rs = dtc.convert(Timestamp("2012-1-1 09:02:03", tz="Asia/Hong_Kong"),
None, None)
tm.assert_almost_equal(rs, xp, rtol=rtol)
rs = dtc.convert(datetime(2012, 1, 1, 1, 2, 3), None, None)
tm.assert_almost_equal(rs, xp, rtol=rtol)
def test_conversion_outofbounds_datetime(self, dtc):
# 2579
values = [date(1677, 1, 1), date(1677, 1, 2)]
rs = dtc.convert(values, None, None)
xp = converter.dates.date2num(values)
tm.assert_numpy_array_equal(rs, xp)
rs = dtc.convert(values[0], None, None)
xp = converter.dates.date2num(values[0])
assert rs == xp
values = [datetime(1677, 1, 1, 12), datetime(1677, 1, 2, 12)]
rs = dtc.convert(values, None, None)
xp = converter.dates.date2num(values)
tm.assert_numpy_array_equal(rs, xp)
rs = dtc.convert(values[0], None, None)
xp = converter.dates.date2num(values[0])
assert rs == xp
@pytest.mark.parametrize(
"time,format_expected",
[
(0, "00:00"), # time2num(datetime.time.min)
(86399.999999, "23:59:59.999999"), # time2num(datetime.time.max)
(90000, "01:00"),
(3723, "01:02:03"),
(39723.2, "11:02:03.200"),
],
)
def test_time_formatter(self, time, format_expected):
# issue 18478
result = converter.TimeFormatter(None)(time)
assert result == format_expected
@pytest.mark.parametrize("freq", ("B", "L", "S"))
def test_dateindex_conversion(self, freq, dtc):
rtol = 10**-9
dateindex = tm.makeDateIndex(k=10, freq=freq)
rs = dtc.convert(dateindex, None, None)
xp = converter.dates.date2num(dateindex._mpl_repr())
tm.assert_almost_equal(rs, xp, rtol=rtol)
@pytest.mark.parametrize("offset", [Second(), Milli(), Micro(50)])
def test_resolution(self, offset, dtc):
# Matplotlib's time representation using floats cannot distinguish
# intervals smaller than ~10 microsecond in the common range of years.
ts1 = Timestamp("2012-1-1")
ts2 = ts1 + offset
val1 = dtc.convert(ts1, None, None)
val2 = dtc.convert(ts2, None, None)
if not val1 < val2:
raise AssertionError(f"{val1} is not less than {val2}.")
def test_convert_nested(self, dtc):
inner = [Timestamp("2017-01-01"), Timestamp("2017-01-02")]
data = [inner, inner]
result = dtc.convert(data, None, None)
expected = [dtc.convert(x, None, None) for x in data]
assert (np.array(result) == expected).all()
def test_rule_aliases(self):
rule = to_offset('10us')
self.assertEqual(rule, Micro(10))
def parse_file(filepath):
trace = Ftrace(filepath, ['tsens_threshold_hit', 'tsens_read', 'tsens_threshold_clear', 'clock_set_rate'])
return (filepath, trace)
if __name__ == '__main__':
fp, trace = parse_file(FILEPATH)
# duration
total_duration = trace.duration if not INTERVAL else INTERVAL.duration
# Thermal
NAMES = [TSENS_ALIAS[tsens] for tsens in trace.thermal.names if tsens in TSENS_ALIAS] + CLKS
df_therm = DataFrame(columns=NAMES)
for tsens in trace.thermal.names:
for therm in trace.thermal.temp_intervals(tsens=tsens, interval=INTERVAL):
df_therm.loc[start + Micro(therm.interval.start*1e6), TSENS_ALIAS[tsens]] = therm.temp
# lets look at clocks.
for clk in CLKS:
for freq_event in trace.clock.frequency_intervals(clock=clk, interval=INTERVAL):
i_start=start + Micro(freq_event.interval.start*1e6)
i_end=start + Micro(freq_event.interval.end*1e6)
try:
df_therm.loc[i_start:i_end, clk] = freq_event.frequency
except KeyError:
print "Error logging " + str(freq_event)
df_therm[start + Micro(freq_event.interval.start*1e6):start + Micro(freq_event.interval.end*1e6), clk] = freq_event.frequency
for clk_event in trace.clock.clock_intervals(clock=clk, state=ftrace.clock.ClockState.DISABLED, interval=INTERVAL):
df_therm.loc[start + Micro(clk_event.interval.start*1e6): start + Micro(clk_event.interval.end*1e6), clk] = 0
df_therm.sort(inplace=True)
}
CLKS =['a57_clk', 'a53_clk', 'oxili_gfx3d_clk']
trace = Ftrace(r'C:\Users\c00759961\Documents\temp\nina-MDA35B-camera-UHD-recording-after.html',
['tsens_read', 'tsens_threshold_clear', 'tsens_threshold_hit',
'clock_set_rate', 'clock_enable', 'clock_disable'])
start = Timestamp('1/1/1970')
#end = start + Second(trace.duration)
NAMES = [TSENS_ALIAS[tsens] for tsens in trace.thermal.names if tsens in TSENS_ALIAS] + CLKS
df_therm = DataFrame(columns=NAMES)
#index=period_range(start=start, end=end, freq='1U')
for tsens in trace.thermal.names:
for therm in trace.thermal.temp_intervals(tsens=tsens):
df_therm.loc[start + Micro(therm.interval.end*1e6), TSENS_ALIAS[tsens]] = therm.temp
# lets look at clocks.
for clk in CLKS:
for freq_event in trace.clock.frequency_intervals(clock=clk):
df_therm.loc[start + Micro(freq_event.interval.end*1e6), clk] = freq_event.frequency
for clk_event in trace.clock.clock_intervals(clock=clk,
state=ftrace.clock.ClockState.DISABLED):
df_therm.loc[start + Micro(clk_event.interval.end*1e6), clk] = 0
df_therm.sort(inplace=True)
# Resample to every 100milliseconds
df_therm = df_therm.asfreq('100L', method='ffill').fillna(method='ffill').fillna(-1)
df_therm.to_csv(r'C:\Users\c00759961\Documents\temp\nina-MDA35B-camera-UHD-recording-after-thermal-timeline.csv')
'tsens_threshold_hit', 'tsens_read', 'tsens_threshold_clear',
'clock_set_rate'
])
# duration
total_duration = trace.duration
# Thermal
NAMES = [
TSENS_ALIAS[tsens]
for tsens in trace.thermal.names if tsens in TSENS_ALIAS
] + CLKS
df_therm = DataFrame(columns=NAMES)
for tsens in trace.thermal.names:
for therm in trace.thermal.temp_intervals(tsens=tsens, interval=None):
df_therm.loc[start + Micro(therm.interval.start * 1e6),
TSENS_ALIAS[tsens]] = therm.temp
# lets look at clocks.
for clk in CLKS:
for freq_event in trace.clock.frequency_intervals(clock=clk,
interval=None):
i_start = start + Micro(freq_event.interval.start * 1e6)
i_end = start + Micro(freq_event.interval.end * 1e6)
try:
df_therm.loc[i_start:i_end, clk] = freq_event.frequency
except KeyError:
print "Error logging " + str(freq_event)
df_therm[start + Micro(freq_event.interval.start * 1e6):start +
Micro(freq_event.interval.end * 1e6),
clk] = freq_event.frequency
