def mobile_app_availability_marker(raw_stream_id: uuid, stream_name: str, owner_id, dd_stream_name, CC: CerebralCortex, config: dict): """ This algorithm uses phone battery percentages to decide whether mobile app was available or unavailable. Theoretically, phone battery data shall be collected 24/7. :param raw_stream_id: :param CC: :param config: """ try: # using stream_id, data-diagnostic-stream-id, and owner id to generate a unique stream ID for battery-marker app_availability_marker_stream_id = uuid.uuid3(uuid.NAMESPACE_DNS, str( raw_stream_id + dd_stream_name + owner_id + "MOBILE APP AVAILABILITY MARKER")) stream_days = get_stream_days(raw_stream_id, app_availability_marker_stream_id, CC) for day in stream_days: stream = CC.get_stream(raw_stream_id, day=day, data_type=DataSet.COMPLETE) if len(stream.data) > 0: windowed_data = window(stream.data, config['general']['window_size'], True) results = process_windows(windowed_data, config) merged_windows = merge_consective_windows(results) if len(merged_windows) > 0: input_streams = [{"owner_id": owner_id, "id": str(raw_stream_id), "name": stream_name}] output_stream = {"id": app_availability_marker_stream_id, "name": dd_stream_name, "algo_type": config["algo_type"]["app_availability_marker"]} metadata = get_metadata(dd_stream_name, input_streams, config) store(merged_windows, input_streams, output_stream, metadata, CC, config) except Exception as e: print(e)
def analyze_quality(streams, owner_id, led_right_wrist_quality_stream_name, wrist, CC): led_stream_quality_id = uuid.uuid3(uuid.NAMESPACE_DNS, str(led_right_wrist_quality_stream_name + owner_id+"LED quality computed on CerebralCortex")) window_size = 3 # in seconds if wrist=="right": if "LED--org.md2k.motionsense--MOTION_SENSE_HRV--RIGHT_WRIST" in streams: led_wrist_stream_id = streams["LED--org.md2k.motionsense--MOTION_SENSE_HRV--RIGHT_WRIST"][ "identifier"] led_wrist_stream_name = streams["LED--org.md2k.motionsense--MOTION_SENSE_HRV--RIGHT_WRIST"]["name"] else: led_wrist_stream_id = None else: if "LED--org.md2k.motionsense--MOTION_SENSE_HRV--LEFT_WRIST" in streams: led_wrist_stream_id = streams["LED--org.md2k.motionsense--MOTION_SENSE_HRV--LEFT_WRIST"][ "identifier"] led_wrist_stream_name = streams["LED--org.md2k.motionsense--MOTION_SENSE_HRV--LEFT_WRIST"]["name"] else: led_wrist_stream_id = None #cassandra - cerebralcortex.data #mysql - stream if led_wrist_stream_id: stream_end_days = CC.get_stream_duration(led_wrist_stream_id) if stream_end_days["start_time"] and stream_end_days["end_time"]: days = stream_end_days["end_time"] - stream_end_days["start_time"] for day in range(days.days + 1): day = (stream_end_days["start_time"]+timedelta(days=day)).strftime('%Y%m%d') stream = CC.get_stream(led_wrist_stream_id, day=day, data_type=DataSet.COMPLETE) if len(stream.data) > 0: windowed_data = window(stream.data, window_size, False) led_quality_windows = data_quality_led(windowed_data) input_streams = [{"owner_id": str(owner_id), "id": str(led_wrist_stream_id), "name": led_wrist_stream_name}] output_stream = {"id": str(led_stream_quality_id), "name": led_right_wrist_quality_stream_name, "algo_type": ""} store(led_quality_windows, input_streams, output_stream, CC)
def calc_voiced_segments_hourly(self, audio_data: list) -> List[DataPoint]: """ calculates amout of voice_segments present every hour of a day. returns start_time, end_time and amount of voiced segments present every hour Algorithm: window(input audio_data) per hour Calculate voiced_segments_for_each_hour return voiced_segments_for_each hour :param audio_data:list of input data after thresholding :return:Datapoint with start_time,end_time and amount of voiced segments in minute :rtype:List(DataPoint) """ windowed_per_hour = window(audio_data, 3600, False) voiced_per_hour = [] for key in windowed_per_hour: no_voiced_segments_hr = 0 for values in windowed_per_hour[key]: if (values.sample == 1): no_voiced_segments_hr += 1 voiced_per_hour.append((DataPoint(start_time=key[0], end_time=key[1], offset=audio_data[0].offset, sample=no_voiced_segments_hr))) return voiced_per_hour
def work_beacon_context(self, beaconworkstream, input_streams, user_id): """ produces datapoint sample as 1 or 2 if around work beacons else 0 :param beaconworkstream: :param input_streams: :param user_id: :return: stream with (start_time,end_time,offset,sample= 0 or 1] based on context of work_beacon 1 or work_beacon 2 """ if (len(beaconworkstream) > 0): beaconstream = beaconworkstream windowed_data = window(beaconstream, self.window_size, True) new_data = [] for i, j in windowed_data: if (len(windowed_data[i, j]) > 0): values = [] for items in windowed_data[i, j]: values.append(items.sample) if ('1' in items.sample) & ('2' in items.sample): windowed_data[i, j] = "1" else: windowed_data[i, j] = values[0] else: windowed_data[i, j] = "0" data = merge_consective_windows(windowed_data) for items in data: if items.sample is not None and items.sample != "": new_data.append( DataPoint(start_time=items.start_time, end_time=items.end_time, offset=beaconworkstream[0].offset, sample=items.sample)) try: self.store_stream(filepath="work_beacon_context.json", input_streams=input_streams, user_id=user_id, data=new_data, localtime=False) self.CC.logging.log( '%s %s work_beacon_context stored %d ' 'DataPoints for user %s ' % (str(datetime.datetime.now()), self.__class__.__name__, len(new_data), str(new_data))) except Exception as e: self.CC.logging.log("Exception:", str(e)) self.CC.logging.log(str(traceback.format_exc())) else: self.CC.logging.log("No work beacon streams found for user %s" % str(user_id))
def phone_screen_touch_marker(raw_stream_id: uuid, raw_stream_name: str, owner_id, dd_stream_name, CC: CerebralCortex, config: dict, start_time=None, end_time=None): """ This is not part of core data diagnostic suite. It only calculates how many screen touches are there. :param raw_stream_id: :param CC: :param config: """ try: # using stream_id, data-diagnostic-stream-id, and owner id to generate a unique stream ID for battery-marker screen_touch_stream_id = uuid.uuid3( uuid.NAMESPACE_DNS, str(raw_stream_id + dd_stream_name + owner_id + "mobile phone screen touch marker")) stream_days = get_stream_days(raw_stream_id, screen_touch_stream_id, CC) for day in stream_days: stream = CC.get_datastream(raw_stream_id, data_type=DataSet.COMPLETE, day=day, start_time=start_time, end_time=end_time) if len(stream.data) > 0: windowed_data = window(stream.data, config['general']['window_size'], True) results = process_windows(windowed_data) merged_windows = merge_consective_windows(results) if len(merged_windows) > 0: input_streams = [{ "owner_id": owner_id, "id": str(raw_stream_id), "name": raw_stream_name }] output_stream = { "id": screen_touch_stream_id, "name": dd_stream_name, "algo_type": config["algo_type"]["app_availability_marker"] } metadata = get_metadata(dd_stream_name, input_streams, config) store(merged_windows, input_streams, output_stream, metadata, CC, config) except Exception as e: print(e)
def home_beacon_context(self, beaconhomestream, beacon_stream_id, beacon_stream_name, user_id): """ produces datapoint sample as 1 if around home beacon else 0 :param beaconhomestream: :param beacon_stream_id: :param beacon_stream_name: :param user_id: :return: new stream (start_time,end_time,offset,sample=[0 or 1] """ input_streams = [] input_streams.append({ "identifier": beacon_stream_id, "name": beacon_stream_name }) if (len(beaconhomestream) > 0): beaconstream = beaconhomestream windowed_data = window(beaconstream, self.window_size, True) new_data = [] for i, j in windowed_data: if (len(windowed_data[i, j]) > 0): windowed_data[i, j] = "1" else: windowed_data[i, j] = "0" data = merge_consective_windows(windowed_data) for items in data: if items.sample is not None and items.sample != "": new_data.append( DataPoint(start_time=items.start_time, end_time=items.end_time, offset=beaconhomestream[0].offset, sample=items.sample)) try: self.store_stream(filepath="home_beacon_context.json", input_streams=input_streams, user_id=user_id, data=new_data, localtime=False) self.CC.logging.log( '%s %s home_beacon_context stored %d ' 'DataPoints for user %s ' % (str(datetime.datetime.now()), self.__class__.__name__, len(new_data), str(new_data))) except Exception as e: self.CC.logging.log("Exception:", str(e)) self.CC.logging.log(str(traceback.format_exc())) else: self.CC.logging.log("No home beacon streams found for user %s" % str(user_id))
def ecg_data_quality(datastream: DataStream, window_size: float = 2.0, acceptable_outlier_percent: float = .34, outlier_threshold_high: float = .9769, outlier_threshold_low: float = .004884, ecg_threshold_band_loose: float = .01148, ecg_threshold_slope: float = .02443, buffer_length: int = 3) -> DataStream: """ :param datastream: Input ECG datastream :param window_size: Window size specifying the number of seconds the datastream is divided to check for data quality :param acceptable_outlier_percent: The acceptable outlier percentage in a window default is 34 percent :param outlier_threshold_high: The percentage of ADC range above which any value is considered an outlier :param outlier_threshold_low: The percentage of ADC range below which any value is considered an outlier :param ecg_threshold_band_loose: The Band Loose Threshold for ECG signal expressed in the percentage of ADC range :param ecg_threshold_slope: The Slope threshold of ECG signal- No consecutive DataPoints can have this difference in values(expressed as percentage of ADC range) :param buffer_length: This specifies the memory of the data quality computation. Meaning this number of past windows will also have a role to decide the quality of the current window :return: An Annotated Datastream of ECG Data quality specifying the time ranges when data quality was acceptable/non-acceptable """ ecg_quality_stream = DataStream.from_datastream(input_streams=[datastream]) window_data = window(datastream.data, window_size=window_size) ecg_quality = [] ecg_range = [] for key, data in window_data.items(): if len(data) > 0: result = compute_data_quality(data, ecg_range, True, ecg_threshold_band_loose, ecg_threshold_slope, acceptable_outlier_percent, outlier_threshold_high, outlier_threshold_low, buffer_length) if not ecg_quality: ecg_quality.append( DataPoint.from_tuple(data[0].start_time, result, data[-1].start_time)) else: if ecg_quality[-1].sample == result: new_point = DataPoint.from_tuple( ecg_quality[-1].start_time, result, data[-1].start_time) ecg_quality[-1] = new_point else: ecg_quality.append( DataPoint.from_tuple(data[0].start_time, result, data[-1].start_time)) ecg_quality_stream.data = ecg_quality return ecg_quality_stream
def battery_marker(raw_stream_id: uuid, stream_name: str, user_id, dd_stream_name, CC: CerebralCortex, config: dict): """ This algorithm uses battery percentages to decide whether device was powered-off or battery was low. All the labeled data (st, et, label) with its metadata are then stored in a datastore. :param raw_stream_id: :param CC: :param config: """ try: # using stream_id, data-diagnostic-stream-id, and owner id to generate a unique stream ID for battery-marker battery_marker_stream_id = uuid.uuid3( uuid.NAMESPACE_DNS, str(raw_stream_id + dd_stream_name + user_id + "BATTERY MARKER")) stream_days = get_stream_days(raw_stream_id, battery_marker_stream_id, CC) for day in stream_days: stream = CC.get_stream(raw_stream_id, day=day, data_type=DataSet.COMPLETE) if len(stream.data) > 0: windowed_data = window(stream.data, config['general']['window_size'], True) results = process_windows(windowed_data, stream_name, config) merged_windows = merge_consective_windows(results) if len(merged_windows) > 0: input_streams = [{ "owner_id": user_id, "id": str(raw_stream_id), "name": stream_name }] output_stream = { "id": battery_marker_stream_id, "name": dd_stream_name, "algo_type": config["algo_type"]["battery_marker"] } labelled_windows = mark_windows(battery_marker_stream_id, merged_windows, CC, config) metadata = get_metadata(dd_stream_name, input_streams, config) store(labelled_windows, input_streams, output_stream, metadata, CC, config) except Exception as e: print(e)
def sensor_availability(raw_stream_id: uuid, stream_name: str, owner_id: uuid, dd_stream_name, phone_physical_activity, CC: CerebralCortex, config: dict): """ Mark missing data as wireless disconnection if a participate walks away from phone or sensor :param raw_stream_id: :param stream_name: :param owner_id: :param dd_stream_name: :param phone_physical_activity: :param CC: :param config: """ # using stream_id, data-diagnostic-stream-id, and owner id to generate a unique stream ID for battery-marker wireless_marker_stream_id = uuid.uuid3( uuid.NAMESPACE_DNS, str(raw_stream_id + dd_stream_name + owner_id)) stream_days = get_stream_days(raw_stream_id, wireless_marker_stream_id, CC) for day in stream_days: # load stream data to be diagnosed raw_stream = CC.get_stream(raw_stream_id, day=day, data_type=DataSet.COMPLETE) if len(raw_stream.data) > 0: windowed_data = window(raw_stream.data, config['general']['window_size'], True) results = process_windows(windowed_data, day, CC, phone_physical_activity, config) merged_windows = merge_consective_windows(results) if len(merged_windows) > 0: input_streams = [{ "owner_id": owner_id, "id": str(raw_stream_id), "name": stream_name }] output_stream = { "id": wireless_marker_stream_id, "name": dd_stream_name, "algo_type": config["algo_type"]["sensor_unavailable_marker"] } metadata = get_metadata(dd_stream_name, input_streams, config) store(merged_windows, input_streams, output_stream, metadata, CC, config)
def accelerometer_features( accel: DataStream, window_length: float = 10.0, activity_threshold: float = 0.21, percentile_low: int = 1, percentile_high: int = 99 ) -> Tuple[DataStream, DataStream, DataStream]: """ References: Figure 3: http://www.cs.memphis.edu/~santosh/Papers/Timing-JIT-UbiComp-2014.pdf :param percentile_high: :param percentile_low: :param accel: :param window_length: :param activity_threshold: :return: """ accelerometer_magnitude = magnitude(normalize(accel)) accelerometer_win_mag_deviations_data = [] for key, data in window(accelerometer_magnitude.data, window_length).items(): accelerometer_win_mag_deviations_data.append( window_std_dev(data, key[0])) accelerometer_win_mag_deviations = DataStream.from_datastream([accel]) accelerometer_win_mag_deviations.data = accelerometer_win_mag_deviations_data am_values = np.array([dp.sample for dp in accelerometer_magnitude.data]) low_limit = np.percentile(am_values, percentile_low) high_limit = np.percentile(am_values, percentile_high) range = high_limit - low_limit accel_activity_data = [] for dp in accelerometer_win_mag_deviations_data: comparison = dp.sample > (low_limit + activity_threshold * range) accel_activity_data.append( DataPoint.from_tuple(dp.start_time, comparison)) accel_activity = DataStream.from_datastream([accel]) accel_activity.data = accel_activity_data return accelerometer_magnitude, accelerometer_win_mag_deviations, accel_activity
def attachment_marker(raw_stream_id: uuid, stream_name: str, owner_id: uuid, dd_stream_name, CC: CerebralCortex, config: dict): """ Label sensor data as sensor-on-body, sensor-off-body, or improper-attachment. All the labeled data (st, et, label) with its metadata are then stored in a datastore """ # TODO: quality streams could be multiple so find the one computed with CC # using stream_id, data-diagnostic-stream-id, and owner id to generate a unique stream ID for battery-marker attachment_marker_stream_id = uuid.uuid3( uuid.NAMESPACE_DNS, str(raw_stream_id + dd_stream_name + owner_id + "ATTACHMENT MARKER")) stream_days = get_stream_days(raw_stream_id, attachment_marker_stream_id, CC) for day in stream_days: # load stream data to be diagnosed raw_stream = CC.get_stream(raw_stream_id, day=day, data_type=DataSet.COMPLETE) if len(raw_stream.data) > 0: windowed_data = window(raw_stream.data, config['general']['window_size'], True) results = process_windows(windowed_data, config) merged_windows = merge_consective_windows(results) input_streams = [{ "owner_id": owner_id, "id": str(raw_stream_id), "name": stream_name }] output_stream = { "id": attachment_marker_stream_id, "name": dd_stream_name, "algo_type": config["algo_type"]["attachment_marker"] } metadata = get_metadata(dd_stream_name, input_streams, config) store(merged_windows, input_streams, output_stream, metadata, CC, config)
def audio_context(self, user_id: str, input_streams_audio: dict, stream1_data: list, input_streams_audio_work: dict = None, stream2_data: list = None): """ redirects appropirate streams for appropriate calculations. takes raw input stream and labels every minute window as voiced or noise based on threshold of 20 secs. Algorithm: window(input_audio inference stream) on 1 minute if voiced segments >= 20 secs label minute window as 'voiced' else: label minute window as 'noise' :param str user_id:id of user :param dict input_streams_audio: input stream for audio for whole day :param list stream1_data: list of Datapoints :param dict input_streams_audio_work:input stream for audio for office only :param list stream2_data: list of DataPoints """ if (len(stream1_data) > 0): audio_stream = stream1_data timestamp = [] for items in audio_stream: timestamp_in_unix = mktime(items.start_time.timetuple()) timestamp.append(items.start_time) windowed_data = window(audio_stream, 60, False) no_voiced_segments = 0 for key in windowed_data: temp_voice = 0 temp_noise = 0 for idx, val in enumerate(windowed_data[key]): if (idx + 1) < len(windowed_data[key]): if val.sample[0] == "noise": temp_noise += ( windowed_data[key][idx + 1].start_time - val.start_time).total_seconds() else: temp_voice += ( windowed_data[key][idx + 1].start_time - val.start_time).total_seconds() if (temp_voice >= 20): windowed_data[key] = "voice" no_voiced_segments += 1 else: windowed_data[key] = "noise" audio_data = [] for keys in windowed_data.keys(): if windowed_data[keys] == "voice": audio_data.append( DataPoint(start_time=keys[0], end_time=keys[1], offset=audio_stream[0].offset, sample=1)) else: audio_data.append( DataPoint(start_time=keys[0], end_time=keys[1], offset=audio_stream[0].offset, sample=0)) file_path_voiced_minute = "voice_segments_context_per_minute.json" self.store_data(file_path_voiced_minute, input_streams_audio, user_id, audio_data) voiced_hourly = self.calc_voiced_segments_hourly(audio_data) file_path_voiced_hourly = "average_voiced_segments_hourly.json" self.store_data(file_path_voiced_hourly, input_streams_audio, user_id, voiced_hourly) voiced_daily = \ self.calc_voiced_segments_daily_average(audio_data, no_voiced_segments) file_path_voiced_daily = "average_voiced_segments_daily.json" self.store_data(file_path_voiced_daily, input_streams_audio, user_id, voiced_daily) if stream2_data: data_at_office = [] office_start_time = stream2_data[0].start_time office_end_time = stream2_data[0].end_time for items in audio_data: if (items.start_time>= office_start_time)and \ (items.end_time<= office_end_time): data_at_office.append(items) voiced_hourly_at_work = \ self.calc_voiced_segments_hourly(data_at_office) file_path_hourly_at_work =\ "average_voiced_segments_office_hourly.json" self.store_data(file_path_hourly_at_work, input_streams_audio_work, user_id, voiced_hourly_at_work) voiced_daily_at_work = \ self.calc_voiced_segments_daily_average(data_at_office, no_voiced_segments) file_path_daily_at_work =\ "average_voiced_segments_office_daily.json" self.store_data(file_path_daily_at_work, input_streams_audio_work, user_id, voiced_daily_at_work)
def packet_loss_marker(raw_stream_id: uuid, stream_name: str, owner_id: uuid, dd_stream_name, CC: CerebralCortex, config: dict): """ Label a window as packet-loss if received packets are less than the expected packets. All the labeled data (st, et, label) with its metadata are then stored in a datastore. :param raw_stream_id: :param CC_obj: :param config: """ # using stream_id, data-diagnostic-stream-id, and owner id to generate a unique stream ID for battery-marker packetloss_marker_stream_id = uuid.uuid3( uuid.NAMESPACE_DNS, str(raw_stream_id + dd_stream_name + owner_id + "PACKET LOSS MARKER")) stream_days = get_stream_days(raw_stream_id, packetloss_marker_stream_id, CC) if stream_name == config["stream_names"]["autosense_ecg"]: sampling_rate = config["sampling_rate"]["ecg"] threshold_val = config["packet_loss_marker"][ "ecg_acceptable_packet_loss"] label = config["labels"]["ecg_packet_loss"] elif stream_name == config["stream_names"]["autosense_rip"]: sampling_rate = config["sampling_rate"]["rip"] threshold_val = config["packet_loss_marker"][ "rip_acceptable_packet_loss"] label = config["labels"]["rip_packet_loss"] elif stream_name == config["stream_names"][ "motionsense_hrv_accel_right"] or stream_name == config[ "stream_names"]["motionsense_hrv_accel_left"]: sampling_rate = config["sampling_rate"]["motionsense_accel"] threshold_val = config["packet_loss_marker"][ "motionsense_accel_acceptable_packet_loss"] label = config["labels"]["motionsense_gyro_packet_loss"] elif stream_name == config["stream_names"][ "motionsense_hrv_gyro_right"] or stream_name == config[ "stream_names"]["motionsense_hrv_gyro_left"]: sampling_rate = config["sampling_rate"]["motionsense_gyro"] threshold_val = config["packet_loss_marker"][ "motionsense_gyro_acceptable_packet_loss"] label = config["labels"]["motionsense_gyro_packet_loss"] for day in stream_days: # load stream data to be diagnosed stream = CC.get_stream(raw_stream_id, day=day, data_type=DataSet.COMPLETE) if len(stream.data) > 0: windowed_data = window(stream.data, config['general']['window_size'], True) results = process_windows(windowed_data, sampling_rate, threshold_val, label, config) merged_windows = merge_consective_windows(results) if len(merged_windows) > 0: input_streams = [{ "owner_id": owner_id, "id": str(raw_stream_id), "name": stream_name }] output_stream = { "id": packetloss_marker_stream_id, "name": dd_stream_name, "algo_type": config["algo_type"]["packet_loss_marker"] } metadata = get_metadata(dd_stream_name, input_streams, config) store(merged_windows, input_streams, output_stream, metadata, CC, config)
def work_beacon_context(self, beaconworkstream: list, input_streams: dict, user_id: str): """ produces datapoint sample as 1 if around work beacon 1, 2 if around workbeacon2 and 0 if not around work beacon Algorithm:: data = window beaconstream if [values] in a minute window in data if 1 in values and 2 in values: around work_beacon1 (1) else around work_beacon(values[0]):could be either 1 or 2 else not around beacon:0 :param List(Datapoint) beaconworkstream : Input list :param dict input_streams: Dict to store stream id and name for storing :param string user_id: id of user """ if (len(beaconworkstream) > 0): beaconstream = beaconworkstream windowed_data = window(beaconstream, self.window_size, True) new_data = [] for i, j in windowed_data: if (len(windowed_data[i, j]) > 0): values = [] for items in windowed_data[i, j]: values.append(items.sample) if ('1' in items.sample) & ('2' in items.sample): windowed_data[i, j] = 1 else: windowed_data[i, j] = int(values[0]) else: windowed_data[i, j] = 0 data = merge_consective_windows(windowed_data) print(data) for items in data: if items.sample is not None and items.sample != "": new_data.append( DataPoint(start_time=items.start_time, end_time=items.end_time, offset=beaconworkstream[0].offset, sample=items.sample)) try: self.store_stream(filepath="work_beacon_context.json", input_streams=input_streams, user_id=user_id, data=new_data, localtime=True) self.CC.logging.log( '%s %s work_beacon_context stored %d ' 'DataPoints for user %s ' % (str(datetime.datetime.now()), self.__class__.__name__, len(new_data), str(new_data))) except Exception as e: self.CC.logging.log("Exception:", str(e)) self.CC.logging.log(str(traceback.format_exc())) else: self.CC.logging.log("No work beacon streams found for user %s" % str(user_id))
def home_beacon_context(self, beaconhomestream: list, beacon_stream_id: str, beacon_stream_name: str, user_id: str): """ produces datapoint sample as 1 if around home beacon else 0 Algorithm:: data = window beaconstream if values in a minute window in data around beacon:1 else not around beacon:0 :param List(Datapoint) beaconhomestream : Input list :param str beacon_stream_id: stream name representing workbeacon1 :param str beacon_stream_name: stream name representing workbeacon2 :param str user_id: id of user """ input_streams = [] input_streams.append({ "identifier": beacon_stream_id, "name": beacon_stream_name }) if (len(beaconhomestream) > 0): beaconstream = beaconhomestream windowed_data = window(beaconstream, self.window_size, True) new_data = [] for i, j in windowed_data: if (len(windowed_data[i, j]) > 0): windowed_data[i, j] = 1 else: windowed_data[i, j] = 0 data = merge_consective_windows(windowed_data) print(data) for items in data: if items.sample is not None and items.sample != "": new_data.append( DataPoint(start_time=items.start_time, end_time=items.end_time, offset=beaconhomestream[0].offset, sample=items.sample)) try: self.store_stream(filepath="home_beacon_context.json", input_streams=input_streams, user_id=user_id, data=new_data, localtime=True) self.CC.logging.log( '%s %s home_beacon_context stored %d ' 'DataPoints for user %s ' % (str(datetime.datetime.now()), self.__class__.__name__, len(new_data), str(new_data))) except Exception as e: self.CC.logging.log("Exception:", str(e)) self.CC.logging.log(str(traceback.format_exc())) else: self.CC.logging.log("No home beacon streams found for user %s" % str(user_id))