class EventEmitter2(object):
def __init__(self):
"""
"""
self.events = OrderedMultiDict()
self.on = self.add_listener
self.off = self.remove_listener
# TODO: Add listener to remove
def add_listener(self, event, listener, count=0):
if not (isinstance(listener, FunctionType)) or (isinstance(listener, BuiltinFunctionType)):
raise Exception("Invalid Listener: %s" % (str(listener)))
_event = re.compile(event)
_listener = {"handler": listener, "calls": 0, "calls_left": count}
self.events.add(_event, _listener)
return True
def emit(self, event, kwargs):
for pattern, listener in self.events.iteritems(multi=True):
if pattern.match(event):
if not listener["calls_left"]:
log.debug("Removing Listener: %s on Pattern: %s") % (
listener, pattern)
self.remove_listener(pattern, listener)
listener["calls"] += 1
listener["calls_left"] -= 1
yield listener["handler"](**kwargs)
def remove_listener(self, pattern, listener):
pattern = re.compile(pattern)
listeners = self.events.getlist(pattern)
for pattern, _listener in self.events.iteritems(multi=True):
if _listener['handler'] == listener:
listener = _listener
break
listeners = self.events.getlist(pattern)
listeners.remove(listener)
if len(listeners):
self.events.update({pattern: listeners})
else:
self.events._remove(pattern)
return True
def on_any(self, listener):
raise NotImplementedError
def off_any(self, listener):
raise NotImplementedError
def once(self, event, listener):
self.add_listener(event, listener, left=1)
def many(self, event, listener, left):
self.add_listener(event, listener, left)
class EventEmitter2(object):
def __init__(self):
"""
"""
self.events = OrderedMultiDict()
self.on = self.add_listener
self.off = self.remove_listener
# TODO: Add listener to remove
def add_listener(self, event, listener, count=0):
if (isinstance(listener, BuiltinFunctionType)):
raise Exception("Invalid Listener: %s" % (str(listener)))
_event = re.compile(event)
_listener = {"handler": listener, "calls": 0, "calls_left": count}
self.events.add(_event, _listener)
return True
def emit(self, event, kwargs):
for pattern, listener in self.events.iteritems(multi=True):
if pattern.match(event):
if not listener["calls_left"]:
log.debug("Removing Listener: %s on Pattern: %s") % (
listener, pattern)
self.remove_listener(pattern, listener)
listener["calls"] += 1
listener["calls_left"] -= 1
yield listener["handler"](**kwargs)
def remove_listener(self, pattern, listener):
pattern = re.compile(pattern)
listeners = self.events.getlist(pattern)
for pattern, _listener in self.events.iteritems(multi=True):
if _listener['handler'] == listener:
listener = _listener
break
listeners = self.events.getlist(pattern)
listeners.remove(listener)
if len(listeners):
self.events.update({pattern: listeners})
else:
self.events._remove(pattern)
return True
def on_any(self, listener):
raise NotImplementedError
def off_any(self, listener):
raise NotImplementedError
def once(self, event, listener):
self.add_listener(event, listener, left=1)
def many(self, event, listener, left):
self.add_listener(event, listener, left)
def find_instruction_order(instructions: OrderedMultiDict):
starting_instruction = set(instructions.keys(multi=True)).difference(
set(instructions.values(multi=True)))
worker_manager = WorkerManager(offset=0)
instruction_order = IndexedSet()
current_instructions = list()
for index, value in enumerate(sorted(starting_instruction)):
current_instructions.append(value)
worker_manager.add(value)
current_instructions = sorted(current_instructions)
while current_instructions:
index = -1
for i, current_instruction in enumerate(current_instructions):
if not {
key
for key, value in instructions.items(multi=True)
if value == current_instruction
}.difference(instruction_order):
instruction_order.add(current_instruction)
worker_manager.remove(current_instruction)
for n, value in enumerate(
instructions.getlist(current_instruction)):
if value not in current_instructions:
current_instructions.append(value)
index = i
break
if index != -1:
current_instructions.pop(index)
current_instructions = sorted(current_instructions)
for instruction in current_instructions:
worker_manager.add(instruction)
print("".join(instruction_order))
print(worker_manager.start_time)
def validate(self):
self._call_custom_hook('pre_validate')
dup_id_map = {}
eid_map = OMD([(e.entry_root, e) for e in self.entries])
for eid in eid_map:
elist = eid_map.getlist(eid)
if len(elist) > 1:
dup_id_map[eid] = elist
if dup_id_map:
raise ValueError('duplicate entry IDs detected: %r' % dup_id_map)
self._call_custom_hook('post_validate')
def validate(self):
self._call_custom_hook('pre_validate')
dup_id_map = {}
eid_map = OMD([(e.entry_root, e) for e in self.entries])
for eid in eid_map:
elist = eid_map.getlist(eid)
if len(elist) > 1:
dup_id_map[eid] = elist
if dup_id_map:
raise ValueError('duplicate entry IDs detected: %r' % dup_id_map)
self._call_custom_hook('post_validate')
def analyze_samples():
outcome = OrderedMultiDict()
opcode = Opcode()
methods = [
func
for func in getmembers(Opcode, predicate=isfunction)
if func[0] != "__init__"
]
count = 0
for before, instruction, after in read_inputs():
outcome.clear()
for opcode_method in methods:
if getattr(opcode, opcode_method[0])(before, instruction) == after:
outcome.add(instruction[0], opcode_method[0])
if len(outcome.getlist(instruction[0])) >= 3:
count += 1
#print(outcome)
print(count)
class ArsdkEventContext(object):
def __init__(self, event_list=None, policy=None, marker=None):
if event_list is None:
event_list = []
if policy is not None:
for event in event_list:
event._policy = policy
self._marker = marker
self._by_uuid = OrderedDict(
zip(map(lambda e: e.uuid, event_list), event_list))
self._by_message_id = OrderedMultiDict(
zip(map(lambda e: e.message.id, self._by_uuid.values()), self._by_uuid.values()))
def events(self):
return list(self._by_uuid.values())
def __iter__(self):
return iter(self._by_uuid.values())
def _set_marker(self, marker):
self._marker = marker
return self
def filter(self, message):
if message.id in self._by_message_id:
events = self._by_message_id.getlist(message.id)[:]
return ArsdkEventContext(events, marker=self._marker)
else:
return ArsdkEventContext()
def last(self, message=None):
if message is None:
return next(reversed(self._by_uuid.values()), None)
else:
return self._by_message_id.get(message.id)
def __bool__(self):
return len(self._by_uuid) > 0
__nonzero__ = __bool__
def _marker_prefix_str(self):
return self._marker.begin() if self._marker is not None else ""
def _marker_suffix_str(self):
return self._marker.end() if self._marker is not None else ""
def _to_str(self):
ret = ""
if len(self._by_uuid.values()) > 1:
ret += "["
for i, message_event in enumerate(self._by_uuid.values()):
ret += self._marker_prefix_str()
ret += str(message_event)
ret += self._marker_suffix_str()
if i != (len(self._by_uuid.values()) - 1):
ret += ","
if len(self._by_uuid.values()) > 1:
ret += "]"
return ret
def __str__(self):
return EventMarker.color_string(_format_olympe_dsl(self._to_str()))
class EventContext(object):
def __init__(self, event_list=None, policy=None, marker=None):
if event_list is None:
event_list = []
if policy is not None:
for event in event_list:
event._policy = policy
self._marker = marker
self._by_uuid = OrderedDict(
zip(map(lambda e: e.uuid, event_list), event_list))
self._by_id = OrderedMultiDict(
zip(map(lambda e: e.id, self._by_uuid.values()),
self._by_uuid.values()))
def events(self):
return list(self._by_uuid.values())
def __iter__(self):
return iter(self._by_uuid.values())
def _set_marker(self, marker):
self._marker = marker
return self
def filter(self, payload):
if hasattr(payload, "id") and payload.id in self._by_id:
events = self._by_id.getlist(payload.id)[:]
return EventContext(events, marker=self._marker)
else:
return EventContext()
def last(self, payload=None):
if payload is None:
return next(reversed(self._by_uuid.values()), None)
elif hasattr(payload, "id"):
return self._by_id.get(payload.id)
else:
raise RuntimeError(
"EventContext.last() payload argument doesn't have an 'id' attribute"
)
def __bool__(self):
return len(self._by_uuid) > 0
__nonzero__ = __bool__
def _marker_prefix_str(self):
return self._marker.begin() if self._marker is not None else ""
def _marker_suffix_str(self):
return self._marker.end() if self._marker is not None else ""
def _to_str(self):
ret = ""
if len(self._by_uuid.values()) > 1:
ret += "["
for i, event in enumerate(self._by_uuid.values()):
ret += self._marker_prefix_str()
ret += str(event)
ret += self._marker_suffix_str()
if i != (len(self._by_uuid.values()) - 1):
ret += ","
if len(self._by_uuid.values()) > 1:
ret += "]"
return ret
def __str__(self):
return EventMarker.color_string(_format_olympe_dsl(self._to_str()))
