def test_returns_story_of_events_from_a_newest_to_the_last(self) -> None: manager = EventManager() manager.emit(Event('Rat killed')) manager.emit(Event('Quest completed')) assert ( manager.history() == [Event('Quest completed'), Event('Rat killed')] )
def __init__(self, psize=188, pcap=False, interval_s=1, skip_cc_err_for_first_ms=100): self.__pcap = pcap self.__stat = None self.__stat_prev = None self.__stat_program_prev = None self.__interval = interval_s self.__psize = psize * 8 self.first_pk_dt = None self.__last_dt = None self.__current_dt = None self.__skip_cc_err_for_ms = skip_cc_err_for_first_ms self.__start_timer() self.monitoring_start_dt = None self.monitoring_end_dt = None self.pat_received_dt = None self.pmt_received_dt = None self.cat_received_dt = None self.sdt_received_dt = None self.programs = Programs() self.viewer = Viewer() # Events self.onStatReady = Event() # Fired for each stat interval self.onFinalStatReady = Event() # Fired when final start is ready
def record_event(self, event: Event) -> None: """ Record the event async. """ import workers from polyaxon.settings import EventsCeleryTasks if not event.ref_id: event.ref_id = self.get_ref_id() serialized_event = event.serialize(dumps=False, include_actor_name=True, include_instance_info=True) workers.send(EventsCeleryTasks.EVENTS_TRACK, kwargs={'event': serialized_event}, countdown=None) workers.send(EventsCeleryTasks.EVENTS_LOG, kwargs={'event': serialized_event}, countdown=None) workers.send(EventsCeleryTasks.EVENTS_NOTIFY, kwargs={'event': serialized_event}, countdown=None) # We include the instance in the serialized event for executor serialized_event['instance'] = event.instance self.executor.record(event_type=event.event_type, event_data=serialized_event)
def test_only_specified_events_trigger_stage_change(self) -> None: dialog = Dialog() dialog.add_player_line("I'm the player.") dialog.set_next_stage(fired_by=Event('Rat killed')) dialog.add_npc_line("I'm Npc. You have killed a rat") dialog.handle(event=Event('Item found')) lines = dialog.lines() self.assertEqual(next(lines), PlayerLine("I'm the player."))
def test_triggering_events_has_to_happen_in_order(self) -> None: dialog = Dialog() dialog.add_player_line("I'm the player.") dialog.set_next_stage(fired_by=Event('Rat killed')) dialog.add_npc_line("I'm Npc. You have killed a rat") dialog.set_next_stage(fired_by=Event('Item found')) dialog.handle(event=Event('Item found')) lines = dialog.lines() self.assertEqual(next(lines), PlayerLine("I'm the player."))
def setUpClass(self): super(FlankingDecisionRulesTestCase, self).setUpClass() self.bot1 = BotMock("bot1", 10) self.bot2 = BotMock("bot2", 10) self.action1 = { self.bot1: Action(Action.ActionType.PREPARE_FLANKING_LEFT)} self.action2 = { self.bot2: Action(Action.ActionType.PREPARE_FLANKING_RIGHT)} self.event1 = {self.bot1: Event(Event.EventType.STATUS_HAS_CHANGED)} self.event2 = {self.bot2: Event(Event.EventType.STATUS_HAS_CHANGED)}
def test_presents_line_for_next_stage_if_specific_event_happened( self) -> None: dialog = Dialog() dialog.add_player_line("I'm the player.") dialog.set_next_stage(fired_by=Event('Rat killed')) dialog.add_npc_line("I'm Npc. You have killed a rat") dialog.add_player_line("Yes I did!") dialog.handle(event=Event('Rat killed')) lines = dialog.lines() self.assertEqual(next(lines), NpcLine("I'm Npc. You have killed a rat")) self.assertEqual(next(lines), PlayerLine("Yes I did!")) with self.assertRaises(StopIteration): next(lines)
def test_dialogs_are_added_to_previously_defined_stage(self) -> None: dialog = Dialog() dialog.add_player_line("I'm the player.") dialog.set_next_stage(fired_by=Event('Rat killed')) dialog.add_npc_line("I'm Npc. You have killed a rat") dialog.add_player_line("Yes I did!") dialog.set_next_stage(fired_by=Event('Huge Rat killed')) dialog.add_npc_line("Wow you have killed a Huuuge rat") self.assertEqual(dialog.lines_for_stage(0), [PlayerLine("I'm the player.")]) self.assertEqual(dialog.lines_for_stage(1), [ NpcLine("I'm Npc. You have killed a rat"), PlayerLine("Yes I did!"), ]) self.assertEqual(dialog.lines_for_stage(2), [NpcLine("Wow you have killed a Huuuge rat")])
def press_button(self, time: float): if self.current_state == SignalState.GREEN_UNPRESSED: self.current_state = SignalState.GREEN_PRESSED elif self.current_state == SignalState.GREEN_TIMED_OUT: at = time + YELLOW_TIMER_LENGTH self.event_queue.push(Event(EventType.YELLOW_EXPIRES, at, {})) self.current_state = SignalState.YELLOW
def test_constructor(self): """ Should be correctly initialize with paramters.""" value = "value" event = Event(Event.EventType.STATUS_HAS_CHANGED, param="value") self.assertIsNotNone(event) self.assertEqual(event.event_type, Event.EventType.STATUS_HAS_CHANGED) self.assertEqual(event.kwargs['param'], value)
def handle_event(self, event: Event): if event.type == EventType.GREEN_EXPIRES: if self.current_state == SignalState.GREEN_PRESSED: at = event.at + YELLOW_TIMER_LENGTH self.event_queue.push(Event(EventType.YELLOW_EXPIRES, at, {})) self.current_state = SignalState.YELLOW elif self.current_state == SignalState.GREEN_UNPRESSED: self.current_state = SignalState.GREEN_TIMED_OUT elif event.type == EventType.YELLOW_EXPIRES: at = event.at + RED_TIMER_LENGTH self.event_queue.push(Event(EventType.RED_EXPIRES, at, {})) self.current_state = SignalState.RED self.red_expire = event.at + RED_TIMER_LENGTH elif event.type == EventType.RED_EXPIRES: at = event.at + GREEN_TIMER_LENGTH self.event_queue.push(Event(EventType.GREEN_EXPIRES, at, {})) self.current_state = SignalState.GREEN_UNPRESSED
def callback(self, proto, name, args): if self._callback == None: self.logger.info("[%s.%s]" % (proto, name)) for arg in args: self.logger.info("\t%s:" % arg, args[arg]) else: event = Event(proto, name, args) self._callback(event)
def test_launch_request(): with open('tests/testjson/launch_request_payload.json', 'r') as json_file: request = json_file.read() request = json.loads(request) with open('tests/testjson/launch_request_response.json', 'r') as json_file: response = json_file.read() response = json.loads(response) event = Event(request) # The next few lines add in a few bits that amazon add on after the response is sent to them actual = {'body': event.get_my_response()} actual['body']['response']['type'] = '_DEFAULT_RESPONSE' expected = response assert json.dumps(actual, sort_keys=True) == json.dumps(expected, sort_keys=True)
def create_timer(self, duration, timername=None): '''Cr un timer qui va envoyer un vnement Timer_end la fin self.dispatch.add_event se termine immdiatement aprs l'ajout dans la queue donc le thread du Timer s'arrte aprs l'execution du add_event() donc il n'y a pas de problme d'execution concurrente entre le thread du timer et le dispatcher''' t = threading.Timer(duration/1000, self.dispatcher.add_event, \ [Event("internal", "timeout", {'timername':timername})]) t.start()
def handleCarArrival(event: Event): global autos_left if autos_left > 0: at = exponential_1(float(next(autos_generator))) + event.at direction = event.metadata["Direction"] newAuto = Event(EventType.AUTO_ARRIVAL, at, {"Direction": direction}) event_queue.push(newAuto) autos_left -= 1
def test_presents_lines_for_initial_stage(self) -> None: dialog = Dialog() dialog.add_player_line("I'm the player.") dialog.set_next_stage(fired_by=Event('Rat killed')) dialog.add_npc_line("I'm Npc. You have killed a rat") dialog.add_player_line("Yes I did!") lines = dialog.lines() self.assertEqual(next(lines), PlayerLine("I'm the player.")) with self.assertRaises(StopIteration): next(lines)
def mock_data(start=None): if start is None: start = current_day_default_start_time() subjects = [("Matematyka Dyskretna", 212), ("Inżynieria Oprogramowania", 211), ("Analiza Matematyczna", 213), ("Teoria Informacji", 214)] return [ Event(name, start + timedelta(hours=2 * i, minutes=5 * i), start + timedelta(hours=2 * (i + 1), minutes=5 * i), WUTLocation("Mini", str(room)), "Wykład").as_dict() for i, (name, room) in enumerate(subjects) ]
def handlePedArrival(event: Event): global peds_left if peds_left > 0: at = exponential_u(float(next(peds_generator)), 20) + event.at direction = event.metadata["Direction"] meta = { "Index": event.metadata["Index"] + 2, "Direction": direction, "Speed": uniform_ab(next(peds_generator), 2.6, 4.1) } newPed = Event(EventType.PED_ARRIVAL, at, meta) event_queue.push(newPed) peds_left -= 1 ##Pedestrian gets to crosswalk arrivalAtCrosswalk = Event( EventType.PED_AT_BUTTON, event.at + peds.DISTANCE_TO_CROSSWALK / event.metadata["Speed"], event.metadata) event_queue.push(arrivalAtCrosswalk)
def _setup_events(conf): """Setup the events defined in the settings.""" events = {} for name in conf.keys(): events[name] = Event(name=name) for listener in conf[name]: action = 'run' if ':' in listener: listener, action = listener.rsplit(':') events[name].add_listener(listener, action) # Add events to module scope. globals().update(events)
def handlePedAtButton(event: Event): if len(peds.crosswalk_peds) == 0: if float(next(button_generator)) < (15 / 16): traffic_signal.press_button(event.at) elif float(next(button_generator)) < 1 / (len(peds.crosswalk_peds) + 1): traffic_signal.press_button(event.at) peds.crosswalk_peds.append(event) ## PED_IMPATIENT handles whether the ped would actually press the button, so we don't have to here ## If they don't walk immediately, they plan to press the button in a minute. if traffic_signal.current_state != ssm.SignalState.RED: event_queue.push( Event(EventType.PED_IMPATIENT, event.at + 60, event.metadata))
def get_report(self, gemeinfo): new_state = self.get_bot_state(gemeinfo) if self.current_state == new_state: return [] else: if self.current_state == None: result = [] else: result = [ Event(Event.EventType.STATUS_HAS_CHANGED, old_state=self.current_state, new_state=new_state) ] self.current_state = new_state return result
def events_by_visit(visit_id: str): query = """ SELECT id, patient_id, event_type, event_timestamp, event_metadata, edited_at FROM events WHERE visit_id = %s ORDER BY event_timestamp """ with get_connection() as conn: with conn.cursor() as cur: cur.execute(query, [visit_id]) for row in cur: id, patient_id, event_type, event_timestamp, event_metadata, edited_at = row yield Event(id=id, patient_id=patient_id, visit_id=visit_id, event_type=event_type, event_timestamp=event_timestamp, event_metadata=event_metadata, edited_at=edited_at)
def get_today_schedule(): now = datetime.now() start = now - timedelta(days=now.weekday()) first_start = start.strftime("%Y-%m-%d") second_start = (start + timedelta(days=7)).strftime("%Y-%m-%d") usos_events = usos.get( "https://apps.usos.pw.edu.pl/services/tt/student", data={ "start": first_start, "fields": "start_time|end_time|course_name|classtype_name|building_name|room_number" } ).data.copy() + usos.get( "https://apps.usos.pw.edu.pl/services/tt/student", data={ "start": second_start, "fields": "start_time|end_time|course_name|classtype_name|building_name|room_number" }).data.copy() events = [ Event(event['course_name']['pl'], datetime.strptime(event['start_time'], "%Y-%m-%d %H:%M:%S"), datetime.strptime(event['end_time'], "%Y-%m-%d %H:%M:%S"), WUTLocation(event["building_name"]["pl"], event["room_number"]), event['classtype_name']['pl']) for event in usos_events ] def get_formatted_delta(days): return (start + timedelta(days=days)).strftime("%Y-%m-%d") day_events = [{ "date": get_formatted_delta(i), "events": [ event.as_dict() for event in events if event.start.strftime("%Y-%m-%d") == get_formatted_delta(i) ] } for i in range(14)] return jsonify(day_events)
def patient_details(patient_id: str): query = """ SELECT id, visit_id, event_type, event_timestamp, event_metadata, edited_at FROM events WHERE patient_id = %s AND event_type = 'Patient Details' ORDER BY event_timestamp LIMIT 1 """ with get_connection() as conn: with conn.cursor() as cur: cur.execute(query, [patient_id]) row = cur.fetchone() if row is None: return None id, visit_id, event_type, event_timestamp, event_metadata, edited_at = row return Event(id=id, patient_id=patient_id, visit_id=visit_id, event_type=event_type, event_timestamp=event_timestamp, event_metadata=event_metadata, edited_at=edited_at)
def start(N: int, autos_g, pedestrians_g, button_g): global event_queue, autos_left, peds_left global autos_generator, peds_generator, button_generator #Begin end conditons autos_left = N - 1 peds_left = N - 1 #Init all generators autos_generator = autos_g peds_generator = pedestrians_g button_generator = button_g #Initialize all beginning arrival events event_queue.push( Event( EventType.PED_ARRIVAL, exponential_u(float(next(peds_generator)), 20), { "Index": 0, "Direction": "EAST", "Speed": uniform_ab(next(peds_generator), 2.6, 4.1) })) '''event_queue.push( Event(EventType.PED_ARRIVAL, exponential_1(float(next(peds_generator))), { "Index": 1, "Direction": "WEST", "Speed": uniform_ab(next(peds_generator), 2.6, 4.1) } ))''' #event_queue.push(Event(EventType.AUTO_ARRIVAL, exponential_1(float(next(autos_generator))), {"Direction": "EAST"})) #event_queue.push(Event(EventType.AUTO_ARRIVAL, exponential_1(float(next(autos_generator))), {"Direction": "WEST"})) #EVENT LOOP while not event_queue.empty(): nextEvent = next(event_queue) processEvent(nextEvent)
def main(hospital): monitored_area = None for m in hospital.monitored_area_list: if m.id == int(sys.argv[1]): monitored_area = m break log_file = "logs/agents/log_agent_" + str( monitored_area.id) + "_" + datetime.now().strftime( "%Y-%m-%d") + ".json" log.setup_custom_logger(log_file) log.info(monitored_area.to_json_format(), monitored_area.id, c.STATE) agent_mqtt = AgentMQTT(monitored_area) monitored_area.attach_observer( EventObserver(monitored_area, agent_mqtt.client)) Event(monitored_area).start() agent_mqtt.run()
def create_event(self, proto, name, args=dict()): e = Event(proto, name, args) self.dispatcher.add_event(event)
def __init__(self, state): Event.__init__(self, state)
class Statistics: def __init__(self, psize=188, pcap=False, interval_s=1, skip_cc_err_for_first_ms=100): self.__pcap = pcap self.__stat = None self.__stat_prev = None self.__stat_program_prev = None self.__interval = interval_s self.__psize = psize * 8 self.first_pk_dt = None self.__last_dt = None self.__current_dt = None self.__skip_cc_err_for_ms = skip_cc_err_for_first_ms self.__start_timer() self.monitoring_start_dt = None self.monitoring_end_dt = None self.pat_received_dt = None self.pmt_received_dt = None self.cat_received_dt = None self.sdt_received_dt = None self.programs = Programs() self.viewer = Viewer() # Events self.onStatReady = Event() # Fired for each stat interval self.onFinalStatReady = Event() # Fired when final start is ready def __start_timer(self): self.__timer = threading.Timer(self.__interval, self.__generate_stat) self.__timer.start() def update_programs_info(self, dt: datetime, programs: Programs, pat=None, pmt=None, cat=None, sdt=None): self.programs = copy.deepcopy(programs) if pat is not None: self.pat_received_dt = dt if pmt is not None: self.pmt_received_dt = dt if cat is not None: self.cat_received_dt = dt if sdt is not None: self.sdt_received_dt = dt """def show_table_data(self, dt: datetime, programs: Programs, sdt=None, bat=None, nit=None): if sdt is not None: self.viewer.print_sdt(sdt, dt=dt) if bat is not None: self.viewer.print_bat(bat, dt=dt)""" def update_stat(self, dpk: TSPacket, rsync: int, pat=None, pmt=None, cat=None, crc32_ok=None, pcr_pid=False, pes=None): if self.first_pk_dt is None: self.first_pk_dt = dpk.dt pid_stat = None is_new_pid = False index = 0 if self.__stat is None: self.__stat = list() else: # Find stat object for pid for stat in self.__stat: if stat['pid'] == dpk.tsh_pid: pid_stat = stat break index += 1 if pid_stat is None: pid_stat = {'pid': dpk.tsh_pid, 'stat': PidStat()} is_new_pid = True # Packet count pid_stat['stat'].Packet_count += 1 if dpk.tsh_tsc != 0: pid_stat['stat'].Scrambled_count += 1 # Rsync if rsync != 0: pid_stat['stat'].TS_sync_loss += 1 # Sync byte error if dpk.tsh_sync != 71: pid_stat['stat'].Sync_byte_error += 1 # PAT_error # PAT does not occur at least every 0,5 s # a PID 0x0000 does not contain a table_id 0x00 (i.e. a PAT) # Scrambling_control_field is not 00 for PID 0x0000 if pat is not None: if (pid_stat['stat'].x_pam_dt is not None and (pid_stat['stat'].x_pam_dt + datetime.timedelta(milliseconds=500) < dpk.dt or dpk.tsh_tsc != 0 or pat.table_id != 0)): pid_stat['stat'].PAT_error += 1 pid_stat['stat'].x_pam_dt = dpk.dt # CC check # Incorrect packet order # a packet occurs more than twice # lost packet # The continuity_counter shall not be incremented when # the adaptation_field_control of the packet equals '00' or '10' # or PID = 0x1FFF - Null Packet if dpk.tsh_pid != 8191 and dpk.tsh_afc not in [0, 2]: if pid_stat['stat'].cc is not None: if pid_stat['stat'].cc == dpk.tsh_cc: if pid_stat['stat'].x_cc_repeated: pid_stat['stat'].x_cc_repeated = False # Skip CC_error for first self.__skip_cc_err_for_ms if self.__skip_cc_err_for_ms is not None: if(self.first_pk_dt + datetime.timedelta(milliseconds=self.__skip_cc_err_for_ms) < dpk.dt): self.__skip_cc_err_for_ms = None pid_stat['stat'].CC_errors += 1 """else: print('CC_error skipped') """ # Debug else: pid_stat['stat'].CC_errors += 1 #print('{} CC_error PID=0x{:04X} CC={}'.format(dpk.dt, dpk.tsh_pid, dpk.tsh_cc)) # Debug else: pid_stat['stat'].x_cc_repeated = True elif ((dpk.tsh_cc > 15 or (pid_stat['stat'].cc < 15 and pid_stat['stat'].cc + 1 != dpk.tsh_cc) or (pid_stat['stat'].cc == 15 and dpk.tsh_cc != 0))): # Skip CC_error for first self.__skip_cc_err_for_ms if self.__skip_cc_err_for_ms is not None: if (self.first_pk_dt + datetime.timedelta(milliseconds=self.__skip_cc_err_for_ms) < dpk.dt): self.__skip_cc_err_for_ms = None pid_stat['stat'].CC_errors += 1 """else: print('CC_error skipped') """ # Debug else: pid_stat['stat'].CC_errors += 1 #print('{} CC_error PID=0x{:04X} CC={}'.format(dpk.dt, dpk.tsh_pid, dpk.tsh_cc)) # Debug pid_stat['stat'].cc = dpk.tsh_cc # PMT_error # Sections with table_id 0x02, (i.e. a PMT), do not # occur at least every 0,5 s on the PID which is referred to in the PAT # Scrambling_control_field is not 00 for all PIDs containing sections with table_id 0x02 (i.e. a PMT) if pmt is not None: if (pid_stat['stat'].x_pmt_dt is not None and (pid_stat['stat'].x_pmt_dt + datetime.timedelta(milliseconds=500) < dpk.dt or dpk.tsh_tsc != 0 or pmt.table_id != 2)): pid_stat['stat'].PMT_error += 1 pid_stat['stat'].x_pmt_dt = dpk.dt # PID_error # It is checked whether there exists a data stream for each PID that occurs. This error might occur # where TS are multiplexed, or demultiplexed and again remultiplexed. # The user specified period should not exceed 5 s for video or audio PIDs (see note). Data services # and audio services with ISO 639 [i.17] language descriptor with type greater than '0' should be # excluded from this 5 s limit. # NOTE: For PIDs carrying other information such as sub-titles, data services or audio services with # ISO 639 [i.17] language descriptor with type greater than '0', the time between two consecutive # packets of the same PID may be significantly longer. if pid_stat['stat'].x_pid_dt is not None and pid_stat['stat'].x_pid_dt + datetime.timedelta(seconds=5) < dpk.dt: pid_stat['stat'].PID_error += 1 pid_stat['stat'].x_pid_dt = dpk.dt # Transport_error # Transport_error_indicator in the TS-Header is set to "1" if dpk.tsh_tei == 1: pid_stat['stat'].Transport_error += 1 # CRC_error # CRC error occurred in CAT, PAT, PMT, NIT, EIT, BAT, SDT or TOT table if crc32_ok is not None and crc32_ok is False: pid_stat['stat'].CRC_error += 1 # PCR errors if pcr_pid: if pid_stat['stat'].x_pcr_dt is not None: # PCR_discontinuity_indicator_error # The difference between two consecutive PCR values (PCRi+1 – PCRi) is outside the range of # 0...100 ms without the discontinuity_indicator set if pid_stat['stat'].x_pcr_dt + datetime.timedelta(milliseconds=100) < dpk.dt and dpk.af_disc != 1: pid_stat['stat'].PCR_discontinuity_indicator_error += 1 # PCR_repetition_error # Time interval between two consecutive PCR values more than 40 ms elif pid_stat['stat'].x_pcr_dt + datetime.timedelta(milliseconds=40) < dpk.dt: pid_stat['stat'].PCR_repetition_error += 1 pid_stat['stat'].x_pcr_dt = dpk.dt # PTS_error # PTS repetition period more than 700 ms if pes is not None: if (pid_stat['stat'].x_pts_dt is not None and pes.PTS is not None and pid_stat['stat'].x_pts_dt + datetime.timedelta(milliseconds=700) < dpk.dt): pid_stat['stat'].PTS_error += 1 pid_stat['stat'].x_pts_dt = dpk.dt # CAT_error # Packets with transport_scrambling_control not 00 present, but no section with table_id = 0x01 # (i.e. a CAT) present # Section with table_id other than 0x01 (i.e. not a CAT) found on PID 0x0001 if cat is not None and cat.table_id != 1: pid_stat['stat'].CAT_error += 1 # Update stat data if is_new_pid: self.__stat.append(pid_stat) else: self.__stat[index] = pid_stat # Check if need generate stat (in case of parsing pcap file instead of real stream) self.__current_dt = dpk.dt if self.__last_dt is None: self.__last_dt = self.__current_dt elif self.__pcap and self.__last_dt + datetime.timedelta(seconds=self.__interval) < self.__current_dt: self.__timer.cancel() self.__generate_stat() def __generate_stat(self, restart_timer=True, is_final=False): result = None if self.__stat is not None: if self.__stat_prev is None or is_final: self.__stat_program_prev = PidStat() self.__stat_prev = list() # Calculate Program stat stat_program = PidStat() for pid in self.__stat: stat_program.Packet_count += pid['stat'].Packet_count stat_program.Scrambled_count += pid['stat'].Scrambled_count stat_program.TS_sync_loss += pid['stat'].TS_sync_loss stat_program.Sync_byte_error += pid['stat'].Sync_byte_error stat_program.PAT_error += pid['stat'].PAT_error stat_program.CC_errors += pid['stat'].CC_errors stat_program.PMT_error += pid['stat'].PMT_error stat_program.PID_error += pid['stat'].PID_error stat_program.Transport_error += pid['stat'].Transport_error stat_program.CRC_error += pid['stat'].CRC_error stat_program.PCR_repetition_error += pid['stat'].PCR_repetition_error stat_program.PCR_discontinuity_indicator_error += pid['stat'].PCR_discontinuity_indicator_error stat_program.PTS_error += pid['stat'].PTS_error stat_program.CAT_error += pid['stat'].CAT_error # Calculate delta between current and previous Program stat stat_program_delta = self.__calc_delta(stat_program, self.__stat_program_prev) # Check if any error appeared for Program has_errors = 0 if (stat_program_delta.Scrambled_count != 0 or stat_program_delta.TS_sync_loss != 0 or stat_program_delta.Sync_byte_error != 0 or stat_program_delta.PAT_error != 0 or stat_program_delta.CC_errors != 0 or stat_program_delta.PMT_error != 0 or stat_program_delta.PID_error != 0 or stat_program_delta.Transport_error or stat_program_delta.CRC_error != 0 or stat_program_delta.PCR_repetition_error != 0 or stat_program_delta.PCR_discontinuity_indicator_error != 0 or stat_program_delta.PTS_error != 0 or stat_program_delta.CAT_error != 0): has_errors = 1 # Prepare stat results (program and pid bitrates) if is_final: time_delta = (self.__current_dt - self.first_pk_dt).total_seconds() results_list = ['{"monitoring_start_dt":"', str(self.monitoring_start_dt), '","monitoring_end_dt":"', str(self.monitoring_end_dt), '","first_pk_dt":"', str(self.first_pk_dt), '","pat_received_dt":"', str(self.pat_received_dt), '","pmt_received_dt":"', str(self.pmt_received_dt), '"'] else: time_delta = (self.__current_dt - self.__last_dt).total_seconds() if time_delta == 0: time_delta = 1 results_list = ['{"dt":"', str(self.__current_dt), '"'] # Add stat for program results_list.extend([',"has_errors":', str(has_errors), ',"program_bitrate":', self.__calc_bitrate(stat_program_delta.Packet_count, time_delta)]) if has_errors == 1 or is_final: results_list.append(',"program_stat":' + str(stat_program_delta)) # Add stat for program and per pid results_list.append(',"pids":[') pids_stat = '' for pid in self.__stat: pids_stat += ('{'+'"pid":' + str(pid['pid']) + ',"bitrate":' + self.__calc_bitrate(pid['stat'].Packet_count - self.__find_pid_stat_prev(pid['pid']).Packet_count, time_delta)) if has_errors == 1 or is_final: pids_stat += (',"stat":' + str(self.__calc_delta(pid['stat'], self.__find_pid_stat_prev(pid['pid'])))) pids_stat += '},' results_list.append(pids_stat[:-1] + ']') results_list.append('}') result = ''.join(results_list) self.__stat_prev = copy.deepcopy(self.__stat) self.__stat_program_prev = copy.deepcopy(stat_program) self.__last_dt = self.__current_dt else: if is_final: results_list = ['{"monitoring_start_dt":"', str(self.monitoring_start_dt), '","monitoring_end_dt":"', str(self.monitoring_end_dt), '","first_pk_dt":"', str(self.first_pk_dt), '","pat_received_dt":"', str(self.pat_received_dt), '","pmt_received_dt":"', str(self.pmt_received_dt), '","has_errors":-1}'] result = ''.join(results_list) else: result = '{"dt":"' + str(datetime.datetime.now()) + '","has_errors":-1}' if restart_timer: self.__start_timer() if (not is_final) and self.onStatReady.getHandlerCount() > 0: self.onStatReady.fire(stat_result=result) return result def __calc_bitrate(self, packet_count: int, time_delta: float) -> str: return str(round(packet_count*self.__psize/time_delta)) def __calc_delta(self, stat: PidStat, stat_prev: PidStat) -> PidStat: stat_delta = PidStat() stat_delta.Packet_count = stat.Packet_count - stat_prev.Packet_count stat_delta.Scrambled_count = stat.Scrambled_count - stat_prev.Scrambled_count stat_delta.TS_sync_loss = stat.TS_sync_loss - stat_prev.TS_sync_loss stat_delta.Sync_byte_error = stat.Sync_byte_error - stat_prev.Sync_byte_error stat_delta.PAT_error = stat.PAT_error - stat_prev.PAT_error stat_delta.CC_errors = stat.CC_errors - stat_prev.CC_errors stat_delta.PMT_error = stat.PMT_error - stat_prev.PMT_error stat_delta.PID_error = stat.PID_error - stat_prev.PID_error stat_delta.Transport_error = stat.Transport_error - stat_prev.Transport_error stat_delta.CRC_error = stat.CRC_error - stat_prev.CRC_error stat_delta.PCR_repetition_error = (stat.PCR_repetition_error - stat_prev.PCR_repetition_error) stat_delta.PCR_discontinuity_indicator_error = (stat.PCR_discontinuity_indicator_error - stat_prev.PCR_discontinuity_indicator_error) stat_delta.PTS_error = stat.PTS_error - stat_prev.PTS_error stat_delta.CAT_error = stat.CAT_error - stat_prev.CAT_error return stat_delta def __find_pid_stat_prev(self, pid: int) -> PidStat: for pid_prev in self.__stat_prev: if pid == pid_prev['pid']: return pid_prev['stat'] return PidStat() def get_stat(self) -> dict: self.__timer.cancel() self.__generate_stat(restart_timer=False) stat = self.__generate_stat(restart_timer=False, is_final=True) if self.onFinalStatReady.getHandlerCount() > 0: self.onFinalStatReady.fire(stat_result=stat) return json.loads(stat)
def lambda_function(event, session=None): return json.dumps(Event(event).get_my_response())
def test_manager_can_emit_event(self) -> None: manager = EventManager() manager.emit(Event('Rat killed')) assert manager.events == [Event('Rat killed')]