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')]
