def test_find_breakout_hh50_too_old(self):
events = [
Event(Quote({'date': '2010-09-01'}), 'hh20'),
Event(Quote({'date': '2010-09-20'}), 'hh50'),
Event(Quote({'date': '2010-11-01'}), 'eod'),
]
self.assertFalse(find_recent_breakout(events, '2010-09-25'))
def test_find_breakout_a_stop(self):
events = [
Event(Quote({'date': '2010-09-01'}), 'hh20'),
Event(Quote({'date': '2010-09-20'}), 'hh50'),
Event(Quote({'date': '2010-11-01'}), 'stop'),
]
self.assertFalse(find_recent_breakout(events, '2010-09-15'))
def init():
#int i
#float sum, avg
#struct event *evptr;
global TRACE
TRACE = int(input("Enter TRACE:"))
random.seed(9999) # init random number generator
clocktime = 0.0 # initialize time to 0.0
rtinit0()
rtinit1()
rtinit2()
rtinit3()
# initialize future link changes
if LINKCHANGES == 1:
event = Event(evtime=10000.0,
evtype=LINK_CHANGE,
eventity=-1,
rtpktptr=None)
insertevent(event)
event = Event(evtime=20000.0,
evtype=LINK_CHANGE,
eventity=-1,
rtpktptr=None)
insertevent(event)
def test_find_breakout_hh20_preceeded_by_exit(self):
events = [
Event(Quote({'date': '2010-08-01'}), 'exit'),
Event(Quote({'date': '2010-09-01'}), 'hh20'),
Event(Quote({'date': '2010-11-01'}), 'eod'),
]
self.assertFalse(find_recent_breakout(events, '2010-09-15'))
def test_find_breakout_hh20_preceeded_by_stop(self):
events = [
Event(Quote({'date': '2010-08-01'}), 'stop'),
Event(Quote({'date': '2010-09-20'}), 'hh20'),
Event(Quote({'date': '2010-11-01'}), 'eod'),
]
self.assertEquals(events[1],
find_recent_breakout(events, '2010-09-15'))
def _receive_event(ipc_manager_mailbox, cpu, data, size):
event = Event()
event.setBaseEvent(data)
if event.action is not None:
try:
ipc_manager_mailbox.put_nowait(event)
except QueueEmpty:
# TODO: Increment metric
pass
def find_events(symbol):
events = []
quotes = Quote.get_quotes(symbol)
if len(quotes) < 1:
return events
quote = quotes[0]
stop = None
entry_price = None
hh50 = False
hh20 = False
while quote:
prev = quote
quote = quote.next()
if not quote: # no more data
if entry_price:
#print "Still winning ", entry_price, hh50, hh20
events.append(Event(prev, 'eod', prev.close))
continue
if not hh50 and quote.is_above_50_day_high():
#print "Found a hh50 event %s" % quote
events.append(Event(quote, 'hh50'))
hh50 = True
if entry_price == None:
(entry_price, stop) = get_entry_price_and_stop(quote)
if not hh20 and quote.is_above_20_day_high():
#print "Found a hh20 event %s" % quote
events.append(Event(quote, 'hh20'))
hh20 = True
if entry_price == None:
(entry_price, stop) = get_entry_price_and_stop(quote)
if(hh20 and quote.low < stop): # hit the stop
#print "Found a stop event %s" % quote
events.append(Event(quote, 'stop', stop))
stop = None
entry_price = None
hh50 = None
hh20 = None
continue
if(hh20 and quote.close > entry_price and quote.close < quote.get_indicator().ll_10 ): # exit
#print "Found a exit event %s" % quote
events.append(Event(quote, 'exit', quote.get_indicator().ll_10))
stop = None
entry_price = None
hh50 = None
hh20 = None
continue
#print "Found %s events for ticker %s" %(len(events), symbol)
#print
return events
def read_logs(paths):
"""
Iterates over the given log paths and tries to find events (directories) with the correct name pattern.
:param paths: a list of or just a single path to events
:return: returns a list of the found events
"""
events = []
# we expect a list of paths, make it one if its just a string
if isinstance(paths, str): paths = [paths]
# iterate over the given paths
for p in paths:
if os.path.isdir(p):
logging.info('Reading %s', os.path.abspath(p))
# scan for events
for event in os.listdir(p):
# make sure, the event directory has the correct naming scheme
event_dir = os.path.join(p, event)
# skip files
if not os.path.isdir(event_dir): continue
# check directory name
event_regex = re.match(config['event']['regex'], event)
if event_regex is not None:
events.append(Event(event_dir))
else:
logging.warning('Not a valid event directory: %s',
event_dir)
else:
logging.warning('Not a directory: %s', p)
return events
def _parse_process_exit(self, messages):
pat_serv_exit = re.compile(
r'Port server .* on node .* exited with status [0-9]+\. '
'Restarting')
pat_port_serv = re.compile(r'Port server (.*) on node')
pat_exit_status = re.compile(r'exited with status ([0-9]+)')
for message in messages:
m = pat_serv_exit.search(message)
if m:
m = pat_port_serv.search(message)
if m:
exit_server = m.group(1)
else:
exit_server = 'unknown_port_server'
m = pat_exit_status.search(message)
if m:
exit_status = m.group(1)
else:
exit_status = 'unknown_exit_status'
descr = '{} exited with status {} and restarted'.format(
exit_server, exit_status)
self.timeline.add_event(
Event(message, 'crash', descr,
self.timeline.default_node_name))
def data_received(self, data):
message = data.decode()
print('Data received: {!r}'.format(message))
quartet = self._parse_quartet(message)
if quartet is not None:
event = Event()
event.action = 'flush'
event.quartet = quartet
event.transport = self.transport
try:
self.ipc_manager_mailbox.put_nowait(event)
except QueueEmpty:
# TODO: Increment metric
pass
def interpolate_event(e):
eventNumber = e.get_eventNumber()
frames = e.get_frames()
azis = e.get_azis()
eles = e.get_eles()
new_frames = []
new_azis = []
new_eles = []
frame_dist = frames[1:] - frames[:-1]
for fd_idx, fd in enumerate(frame_dist):
if fd == 1:
# contiguous, set next
new_frames.append(frames[fd_idx])
new_azis.append(azis[fd_idx])
new_eles.append(eles[fd_idx])
else:
start = frames[fd_idx]
end = frames[fd_idx + 1]
new_frames.extend(np.arange(start, end, 1).tolist())
new_azis.extend(
np.linspace(azis[fd_idx], azis[fd_idx + 1], fd).tolist())
new_eles.extend(
np.linspace(eles[fd_idx], eles[fd_idx + 1], fd).tolist())
return Event(-1, eventNumber, np.asarray(new_frames), np.asarray(new_azis),
np.asarray(new_eles))
def ready(self, e):
'''
Finish to load the ship cargo
and wait for it's departure
'''
log.info(f'Ship number {e.details} is already loaded', 'Ready ')
self.time = max(self.time, e.time)
self.events.append(Event(self.time, e.details, self.depart))
return True
def _parse_buckets_not_ready(self, instances):
pat_bucket_not_ready = re.compile(
r"The following buckets became not ready on node "
"'(.*)': \[(.*)\], .*\]$")
pat_bucket_not_ready_mult = re.compile(
r"The following buckets became not ready on node '"
"(.*)': \[\"([^\"]*)\",$")
pat_bucket_not_ready_mult_middle = re.compile(r' *"(.*)",$')
pat_bucket_not_ready_mult_end = re.compile(r' *"(.*)"\]')
for instance in instances:
single = pat_bucket_not_ready.search(instance[0])
multi = pat_bucket_not_ready_mult.search(instance[0])
if single:
on = extract_nodename(single.group(1),
self.timeline.default_node_name)
buckets = single.group(2).replace('"', '')
self.timeline.add_event(
Event(instance[0], 'fail',
'buckets not ready on {}: `{}`'.format(on, buckets),
self.timeline.default_node_name))
elif multi:
on = extract_nodename(multi.group(1),
self.timeline.default_node_name)
buckets = multi.group(2).replace('"', '')
for line in instance[1:]:
m = pat_bucket_not_ready_mult_end.search(line)
if m:
buckets += ', ' + m.group(1)
self.timeline.add_event(
Event(
instance[0], 'fail',
'buckets not ready on {}: `{}`'.format(
on,
buckets), self.timeline.default_node_name))
continue
m = pat_bucket_not_ready_mult_middle.search(line)
if m:
buckets += ', ' + m.group(1)
continue
def test_sparse_csr(m, n, k, nnz, test_count):
start_timer = Event(enable_timing=True)
stop_timer = Event(enable_timing=True)
csr = gen_sparse_csr((m, k), nnz)
mat = torch.randn(k, n, dtype=torch.double)
times = []
for _ in range(test_count):
start_timer.record()
csr.matmul(mat)
stop_timer.record()
times.append(start_timer.elapsed_time(stop_timer))
return sum(times) / len(times)
def __init__(self):
self._address = None
self._name = None
self._device = None
self._subscriber = None
self._writer = None
# Create the message map
self._message_map = {}
for i in range(MessageType.Count):
self._message_map[i] = []
# Setup events
self.face_up_changed = Event()
self.battery_voltage_changed = Event()
self._dtype = None
self._battery_voltage = -1
self._face_up = 0
def arrive(self):
'''
Generate a new arrival
'''
if self.count != self.n:
log.debug(f"Generating the arrival time of ship number {self.count}", "Arrive")
time = self.time + exponential(8) * 60
e = Event(time, self.count, self.enqueue)
self.count += 1
self.events.append(e)
return True
def _parse_flush_start(self, flushes):
pat_bucket_flush_start = re.compile(
r'janitor_agent-(.*)<.*Doing local bucket flush')
for flush in flushes:
m = pat_bucket_flush_start.search(flush)
if m:
bucket = m.group(1)
self.timeline.add_event(
Event(flush, 'flush',
'starting to flush bucket `{}`'.format(bucket),
self.timeline.default_node_name))
def dock(self, e):
'''
Start load the cargo of a ship
'''
log.info(f'Ship number {e.details} is loading its cargo', 'Dock ')
self.time = max(self.time, e.time)
self.docks -= 1
self.bussy = False
time = self.load_time(self.size[e.details])
self.events.append(Event(time, e.details, self.ready))
return True
def _parse_flush_finish(self, flushes):
pat_bucket_flush_end = re.compile(
r'janitor_agent-(.*)<.*Local flush is done')
for flush in flushes:
m = pat_bucket_flush_end.search(flush)
if m:
bucket = m.group(1)
self.timeline.add_event(
Event(flush, 'flush',
'flush complete for bucket `{}`'.format(bucket),
self.timeline.default_node_name))
def __init__(self, timelines=None, input_dict=None):
self.events = []
self.default_node_name = None
if timelines:
self.events.extend(event for timeline in timelines
for event in timeline.events)
elif input_dict:
self.events = [
Event(input_dict=event_dict)
for event_dict in input_dict['events']
]
def _parse_assertions(self, assertions):
extract_assert_regex = re.compile(r'(assertion|asssertion|Assert) '
'failed \[(?P<assert>[^\[]+)\] at')
for assertion in assertions:
m = extract_assert_regex.search(assertion[4])
if m:
self.timeline.add_event(
Event(
assertion[0], 'assert',
'Memcached assertion: `{}`'.format(m.group('assert')),
self.timeline.default_node_name))
def _parse_node_add(self, messages):
pat_node_add = re.compile(r"adding node '(.*)' to nodes_wanted")
for message in messages:
m = pat_node_add.search(message)
if m:
added_node = extract_nodename(m.group(1),
self.timeline.default_node_name)
else:
added_node = 'unknown_node'
self.timeline.add_event(
Event(message, 'topology', 'added node {}'.format(added_node),
self.timeline.default_node_name))
def events():
events_ = [
{'time': e.time,
'type': Event(e.type).name,
'task_id': e.task_id,
'task': e.task,
'flag_submit_id': e.flag_submit_id,
'flag_submit': e.flag_submit,
'extra': e.extra}
for e in EventModel.query.all()
]
return render_template('events.html', events=events_)
def _parse_time_jumps(self, time_jumps):
for time_jump in time_jumps:
m = pat_ms.search(time_jump)
if m:
action_time = m.group(1)
else:
action_time = '?'
self.timeline.add_event(
Event(
time_jump, 'time_jump',
'detected time jump / erlang latency of {}ms'.format(
action_time), self.timeline.default_node_name))
def enqueue(self, e):
'''
Enqueue a new ship that just arrived
'''
size = get_size(self.prob)
self.size[e.details] = size
self.arrivals[e.details] = e.time
self.time = max(self.time, e.time)
log.info(f'Ship number {e.details} arrive to the port', 'Enqueue ')
self.events.append(Event(self.time, e.details, self.move))
bublle_sort_last(self.events)
return self.arrive()
def do_GET(self):
if None != re.search("/set", self.path):
n = urllib.parse.urlparse(self.path)
x = urllib.parse.parse_qs(n.query)
Event.fire(Event.SettingsMessage(x))
self.send_response(200)
self.send_header('Content-Type', 'text/html')
self.end_headers()
output = str(x)
self.wfile.write(output.encode('utf-8'))
return
else:
self.send_response(404)
self.send_header('Content-Type', 'text/html')
self.end_headers()
output = "404 requested endpoint not available"
self.wfile.write(output.encode('utf-8'))
return
def _parse_disk_space(self, messages):
pat_disk_usage = re.compile(
r'Usage of disk "(.*)" on node "(.*)" is around ([0-9]+%)')
for message in messages:
m = pat_disk_usage.search(message)
if m:
disk = m.group(1)
on_node = m.group(2)
perc = m.group(3)
descr = '{} usage on {} is {}'.format(disk, on_node, perc)
self.timeline.add_event(
Event(message, 'fail', descr,
self.timeline.default_node_name))
def move(self, e):
'''
Move a ship to a dock
'''
if (self.docks == 0) or self.bussy:
log.debug("Imposible to move ship number {e.details} at this moment", "Move ")
return False
self.go(1)
log.info(f'Ship number {e.details} is being moved to a dock', 'Move ')
self.bussy = True
time = self.time + exponential(2) * 60
self.events.append(Event(time, e.details, self.dock))
return True
def _parse_data_loss(self, messages):
pat_data_lost = re.compile(
r'Data has been lost for ([0-9]%) of vbuckets in bucket "(.*)"\.')
for message in messages:
m = pat_data_lost.search(message)
if m:
perc = m.group(1)
bucket = m.group(2)
descr = 'bucket {} has lost data for {} of vbuckets'.format(
bucket, perc)
self.timeline.add_event(
Event(message, 'fail', descr,
self.timeline.default_node_name))
def depart(self, e):
'''
Move a ship out of the docks
'''
if self.bussy:
log.debug(f"Tug is bussy, ship number {e.details} stay at dock", "Depart")
return False
log.info(f'Ship number {e.details} is being moved back to the port', 'Depart')
self.go(0)
self.docks += 1
self.bussy = True
time = self.time + exponential(1) * 60
self.events.append(Event(time, e.details, self.done))
return True
