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