def test_invalid_input_eq(): ts_1 = ArrayTimeSeries([1, 2], [3, 4]) ts_2 = ArrayTimeSeries([1, 2, 3], [3, 4, 5]) with raises(TypeError): ts_1 == ([3, 1], [4, 2]) with raises(ValueError): ts_1 == ts_2
def test_setitem(): data = [4, 5, 6] time = [1, 2, 3] ts = ArrayTimeSeries(time, data) index = 0 val = 0 ts[index] = val assert ts == ArrayTimeSeries([1, 2, 3], [0, 5, 6])
def test_invalid_input(): with raises(ValueError): ArrayTimeSeries([1, 2], [3, 4, 5]) with raises(TypeError): ArrayTimeSeries(1, 2) with raises(TypeError): ArrayTimeSeries(1, [1]) with raises(TypeError): ArrayTimeSeries([1, 2], 3) with raises(ValueError): ArrayTimeSeries([1, 2], [2, 2])
def test_invalid_input_add(): ts_1 = ArrayTimeSeries([1, 2], [3, 4]) ts_2 = ArrayTimeSeries([1, 2, 3], [3, 4, 5]) ts_3 = ArrayTimeSeries([2, 3], [5, 6]) arry = [1, 2] with raises(ValueError): ts_sum = ts_1 + ts_2 with raises(TypeError): ts_sum = ts_1 + arry with raises(ValueError): ts_sum = ts_1 + ts_3
def test_valid_input_interpolate(): ts_1 = ArrayTimeSeries([1, 2, 3], [0, 5, 10]) ts_2 = ArrayTimeSeries([100, -100], [2.5, 7.5]) ts_interpolate_test_1 = ts_1.interpolate([1]) assert ts_interpolate_test_1._value == [1.2] assert ts_interpolate_test_1._time == [1] ts_interpolate_test_2 = ts_1.interpolate([-100, 100]) assert ts_interpolate_test_2 == ArrayTimeSeries([1, 3], [-100, 100]) ts_interpolate_test_3 = ts_1.interpolate([2.5, 7.5]) assert ts_interpolate_test_3 == ArrayTimeSeries([1.5, 2.5], [2.5, 7.5]) assert ts_1.interpolate(ts_2.itertimes()) == ArrayTimeSeries([1.5, 2.5], [2.5, 7.5])
def __init__(self, times, values, fsm, id=None): """ Constructor for SMTimeSeries :param fsm: File manager :type fsm: FileStorageManager :param times: a sequence or a numpy array storing time stamps :param values: a sequence or a numpy array storing values :param id: ID of the timeseries """ if not isinstance(values, collections.Sequence) and not \ isinstance(values, np.ndarray): raise TypeError("Input values must be Sequence") if not isinstance(times, collections.Sequence) and not \ isinstance(values, np.ndarray): raise TypeError("Input times must be Sequence") if len(times) != len(values): raise ValueError("Input values and times sequence must have " "the same length") if len(times) != len(set(times)): raise ValueError("Input times sequence must be unique") self._fsm = fsm if id == None: id = self._fsm.gen_id() self._id = id self._fsm.store(self._id, ArrayTimeSeries(values, times))
def test_iteritems(): data = [0, 1, 2, 3, 4] time = [5, 6, 7, 8, 9] ts = ArrayTimeSeries(time, data) l = ts.iteritems() next(l) assert next(l) == (6, 1)
def test_itertimes(): data = [0, 1, 2, 3, 4] #range(0,5) time = [5, 6, 7, 8, 9] #range(5,10) ts = ArrayTimeSeries(time, data) l = ts.itertimes() next(l) assert next(l) == 6
def test_repr_greater_than_five(): data = [4, 5, 6, 7, 8, 9] time = [1, 2, 3, 4, 5, 6] ts = ArrayTimeSeries(time, data) assert repr( ts ) == 'ArrayTimeSeries([(1, 4), (2, 5), (3, 6), (4, 7), (5, 8), (6, 9)])'
def clientThread(conn, sm): while True: # conn.send("Server waiting for input:".encode()) rec = conn.recv(8192) if not rec: break receivedData = pickle.loads(rec) if receivedData['cmd'] == "BYID": # Get ts storage using id received ts = sm.get(receivedData['id']) toSend = { "time": list(ts.times()), "value": list(ts.values()), "id": receivedData['id'] } conn.send(pickle.dumps(toSend)) elif receivedData['cmd'] == 'ADDTS': # Save to storage manager id, time, value = receivedData['id'], receivedData[ 'time'], receivedData['value'] sm.store(id, ArrayTimeSeries(input_time=time, input_value=value)) conn.send(pickle.dumps("Saved to DB!")) conn.close()
def test_empty_ts(): ts = ArrayTimeSeries([], []) for t in ts._value == np.array([]): assert t for t in ts._time == np.array([]): assert t for t in ts._timeseries == np.array([]): assert t
def test_setitem_index_error(): data = [4, 5, 6] time = [1, 2, 3] ts = ArrayTimeSeries(time, data) index = 5 val = 0 with raises(IndexError): ts[index] = val
def __init__(self, input_time, input_value, id=None): """ id is optional and could be None auto generate id is handled by FileStorageManager if id is None """ if id == None: id = StorageManager.generateId() StorageManager.store(str(id), ArrayTimeSeries(input_time, input_value)) self._id = str(id)
def test_valid_init(self): """ All the sized timeseries __init__ constructors should take any sequence-like thing. Unsized should take a generator. """ # NOTE: Depending on intepretation, this might be safe ts = TimeSeries([0], [0]) ats = ArrayTimeSeries([0], [0]) sts = SimulatedTimeSeries(zero_generator) scores.append(('#ts', 'init valid ts, ats, sts', 3))
def process(self, dat, conn): """ process message from flask """ fsm = FileStorageManager() query = dat['type'] #return all metadata if query == "all": result = self._postgres.query_all() #filter by mean range elif query == "mean_in": result = self._postgres.query_mean_range(dat['mean_in']) #filtr by level elif query == "level_in": result = self._postgres.query_level(dat['level_in']) #filter elif query == "ts_data": msg = dat['ts_data'] # add new timeseries given with key in jason format into database result = fsm.store(msg[0], ArrayTimeSeries(msg[1], msg[2])) elif query == "id": msg = dat['id'] result = {} try: result['tsdata'] = fsm.get(msg) result['exist'] = 1 result['metadata'] = self._postgres.query_id(msg) except ValueError: result['exist'] = 0 #return nth closest ts data to ts with sim_id elif query == "ss_id": msg_id = dat['id'] msg_k = dat['k'] result = [] try: ts = fsm.get(msg_id) min_dis, min_db_name, min_ts_file_name = max_similarity_search( ts) result = kth_similarity_search(ts, min_dis, min_db_name, msg_k) except ValueError: pass #return nth closest ts data to ts dataset elif query == "ss_tsdata": ts = dat['tsdata'] msg_k = dat['k'] min_dis, min_db_name, min_ts_file_name = max_similarity_search(ts) result = kth_similarity_search(ts, min_dis, min_db_name, msg_k) else: raise NotImplementedError return result
def get(self, id): """ Get the timeseries using an given ID :param id: ID of timeseries :type id: int or string :return: timeseries of the given ID :rtype: SizedContainerTimeSeriesInterface """ if not os.path.exists('data/ts_data_' + str(id) + '.txt'): raise ValueError( "Timeseries with ID={0} does not exist.".format(id)) ts = np.loadtxt('data/ts_data_' + str(id) + '.txt') return ArrayTimeSeries(ts[:, 1], ts[:, 0])
def test_valid_nonempty_str_and_repr(self): """ All concrete classes should have a __str__() and __repr__(). Repeats are acceptable. """ ts = TimeSeries([0], [0]) ats = ArrayTimeSeries([0], [0]) sts = SimulatedTimeSeries(zero_generator) for ts_class in [ts, ats, sts]: dunder_str = str(ts_class) dunder_repr = repr(ts_class) self.assertNotEqual(dunder_str, '') self.assertNotEqual(dunder_repr, '') scores.append( ('#ts', 'all concrete classes should have non-empty str and repr', 1))
def get(self, id): '''The function to get the TimeSeries Object from the database. Param: id: the id of the TimeSeries object that taken out from database. Return: The TimeSeries object got from the database. ''' filename = self.dir_name + "/ts_" + str(id) + ".dat" try: f = open(filename, "r") except FileNotFoundError: raise Exception("The id is not in the database") else: array = json.loads(f.read())[str(id)] f.close() return ArrayTimeSeries(array[0], array[1])
def test_valid_nondefault_str_and_repr(self): """ All concrete classes should have non-default __str__() and __repr__(). """ ts = TimeSeries([0], [0]) ats = ArrayTimeSeries([0], [0]) sts = SimulatedTimeSeries(zero_generator) self.assertNotRegexpMatches('^<.*.TimeSeries object at .*>$', str(ts)) self.assertNotRegexpMatches('^<.*.TimeSeries object at .*>$', repr(ts)) self.assertNotRegexpMatches('^<.*.ArrayTimeSeries object at .*>$', str(ats)) self.assertNotRegexpMatches('^<.*.ArrayTimeSeries object at .*>$', repr(ats)) self.assertNotRegexpMatches('^<.*.SimulatedTimeSeries object at .*>$', str(sts)) self.assertNotRegexpMatches('^<.*.SimulatedTimeSeries object at .*>$', repr(sts)) scores.append( ('#ts', 'all concrete classes should have non-default str and repr', 1))
def get(self, tid): """ The function gets the stored timeseries value on disk with the given id Args ------ - tid: id for the time series values to be looked up from disk Return ------ values returned in the form of ArrayTimeSeries object. will return non if no file existed with the given tid """ # Returns SizedContainerTimeSeriesInterface object if not isinstance(tid, str): tid = str(tid) if tid in self._id: timeseries = np.load(tid + ".npy") return ArrayTimeSeries(timeseries[0], timeseries[1]) else: return None
def clientThread(conn, storage_manager): while True: rec = conn.recv(1024*4) if not rec: break print("Server has been received:", rec) recv_data = pickle.loads(rec) if recv_data['cmd'] == "GET_BY_ID": ts = storage_manager.get(recv_data['id']) ts_dict = {"time": list(ts.times()), "value": list(ts.values()), "id": recv_data['id']} conn.send(pickle.dumps(toSend)) elif recv_data['cmd'] == 'ADD_TS': id = recv_data['id'] time = recv_data['time'] value = recv_data['value'] storage_manager.store(id, ArrayTimeSeries(list(time.values)), list(value.values())) conn.send(pickle.dumps("Saved to DataBase.")) conn.close()
def test_std(): ts = ArrayTimeSeries([1, 2], [3, 4]) assert ts.std() == sqrt(0.25)
def test_valid_input_sub(): ts_1 = ArrayTimeSeries([1, 2], [3, 4]) ts_2 = ArrayTimeSeries([1, 2], [3, 4]) ts_sub = ts_1 - ts_2 assert ts_sub == ArrayTimeSeries([0, 0], [3, 4])
def test_valid_input_add(): ts_1 = ArrayTimeSeries([1, 2], [3, 4]) ts_2 = ArrayTimeSeries([1, 2], [3, 4]) ts_sum = ts_1 + ts_2 assert ts_sum == ArrayTimeSeries([2, 4], [3, 4])
def test_contains(): ts = ArrayTimeSeries(list(range(10)), list(range(1, 11))) assert (0 in ts) == True assert (11 in ts) == False
def test_invalid_input_setitem(): ts = ArrayTimeSeries([1, 2], [3, 4]) with raises(ValueError): ts[3] = 10 with raises(TypeError): ts[{1}] = 10
def test_valid_input_setitem(): ts = ArrayTimeSeries([1, 2], [3, 4]) ts[0] = 10 assert np.all(ts[0] == (10, 3)) == True
def test_getitem(): ts = ArrayTimeSeries([3, 4], [1, 2]) assert np.all(ts[1] == (4, 2)) == True
def test_len(): ts = ArrayTimeSeries([3, 4], [1, 2]) assert len(ts) == 2
def test_mean(): ts = ArrayTimeSeries([1, 2], [3, 4]) assert ts.mean() == 1.5