def stat(self, attribute=""):
stat = {}
stat['name'] = str(self)
stat['used'] = db.getNodeIdByAttribute("archive_type", str(self))
stat['state1'] = len(intersection([stat['used'], db.getNodeIdByAttribute("archive_state", "1")]))
stat['state2'] = len(intersection([stat['used'], db.getNodeIdByAttribute("archive_state", "3")]))
stat['state3'] = len(intersection([stat['used'], db.getNodeIdByAttribute("archive_state", "3")]))
stat['used'] = len(stat['used'])
if attribute == "":
return stat
elif attribute in stat.keys():
return stat[attribute]
def logs_divergence(baseline_logs, updated_logs):
log_intersection = len(intersection(baseline_logs, updated_logs))
log_union = len(union(baseline_logs, updated_logs))
IOU = 1.0
if log_union > 0:
IOU = log_intersection / float(log_union)
return 1 - IOU
def archive_thread(self):
if not time:
return
while True:
time.sleep(int(config.get("archive.interval", 60)))
archive_nodes_3 = db.getNodeIdByAttribute("archive_state", "3")
archive_nodes_2 = []
date_now = format_date(now(), "yyymmddhhmmss")
for manager in self.manager:
# search for nodes to archive after access over period (state 2)
for n in db.getNodeIdByAttribute("archive_state", "2"):
try:
node = tree.getNode(n)
if node.get("archive_date"):
date_archive = format_date(parse_date(node.get("archive_date"), "%Y-%m-%dT%H:%M:%S"), "yyymmddhhmmss")
if date_now >= date_archive:
archive_nodes_2.append(long(node.id))
except:
pass
# union to get all nodes with state 3 and 2 with over period
archive_nodes = union((archive_nodes_3, archive_nodes_2))
nodes = intersection((db.getNodeIdByAttribute("archive_type", str(manager)), archive_nodes))
# run action defined in manager
try:
self.manager[manager].actionArchive(nodes)
except:
pass
def load(self, parts: List[str]):
with open(self.filepath_json_live) as f:
json_read = json.load(f)
for part in utils.intersection(parts, list(json_read.keys())):
self.score[part] = {}
self.score[part]['notes'] = json_read[part]['notes']
def search(self, q):
global searcher, subnodes
log.info('search: %s for node %s %s' % (q, str(self.id), str(self.name)))
self._makePersistent()
if q.startswith('searchcontent='):
return searcher.query(q)
items = subnodes(self)
if not isinstance(items, list):
items = items.getIDs()
return NodeList(intersection([items, searcher.query(q)]))
def search(self, q):
global searcher, subnodes
log.info('search: %s for node %s %s' %
(q, str(self.id), str(self.name)))
self._makePersistent()
if q.startswith('searchcontent='):
return searcher.query(q)
items = subnodes(self)
if not isinstance(items, list):
items = items.getIDs()
return NodeList(intersection([items, searcher.query(q)]))
def run(self):
js_logs = {
'in_baseline':
len(self.baseline_js_logs.js_messages),
'in_upgraded':
len(self.updated_js_logs.js_messages),
'in_both':
len(
intersection(self.baseline_js_logs.js_messages,
self.updated_js_logs.js_messages))
}
network_logs = {
'in_baseline':
len(self.baseline_network_logs.network_messages),
'in_upgraded':
len(self.updated_network_logs.network_messages),
'in_both':
len(
intersection(self.baseline_network_logs.network_messages,
self.updated_network_logs.network_messages))
}
risk_score_js = Scores.logs_divergence(
self.baseline_js_logs.js_messages,
self.updated_js_logs.js_messages)
risk_score_network = Scores.logs_divergence(
self.baseline_network_logs.network_messages,
self.updated_network_logs.network_messages)
risk_score = max(risk_score_js, risk_score_network)
self.result = {
'javascript': js_logs,
'network': network_logs,
'risk_score': risk_score
}
return self.result
def from_json(filepath, parts=['melody', 'chord', 'root']) -> music21.stream.Score:
with open(filepath) as f:
json_read = json.load(f)
partmap = {}
for name_part in utils.intersection(parts, list(json_read.keys())):
part = music21.stream.Part()
notes = nl.NoteLive.parse_list(
json_read[name_part]['notes']
)
for note_live in notes:
note = music21.note.Note(
pitch=note_live.pitch
)
note.duration = music21.duration.Duration(
note_live.beats_duration
)
part.insert(
note_live.beat_start,
note
)
if name_part == 'chord':
part.makeVoices()
part.makeRests(fillGaps=True)
part.makeMeasures()
part.id = name_part
part.partName = name_part
partmap[name_part] = part
score = music21.stream.Score()
for _, part in partmap.items():
score.append(part)
return score
def get_covering_tests(coverage, dict_of_modified_coverable_lines,
covering_type):
list_of_covering_tests = []
for key, covering_lines in dict_of_modified_coverable_lines.items():
for test_method, i_covering_lines in coverage[key].items():
covering_test_with_score = {}
lines_covered = utils.intersection(
list(map(int, i_covering_lines)),
covering_lines[covering_type])
detailed_lines_covered = {}
if len(lines_covered) > 0:
covering_test_with_score['test'] = test_method
detailed_lines_covered['class'] = key
detailed_lines_covered['lines_covered'] = lines_covered
detailed_lines_covered['bug_fix_code_covered'] = \
(len(lines_covered) / len(covering_lines[covering_type])) * 100
covering_test_with_score[
'detailed_lines_covered'] = detailed_lines_covered
list_of_covering_tests.append(covering_test_with_score)
return list_of_covering_tests
# ----------------------------------------------------------------------------------------------------------------------
# Test intersection, jaccard, and bboxes_intersection function
# gt [ymin, xmin, ymax, xmax]
test_gt_bbox = tf.constant([[[2, 1, 5, 4]],
[[2, 2, 7, 5]],
[[4, 1, 6, 3]]], dtype=tf.float32)
# pred [ymin, xmin, ymax, xmax]
test_pred_bbox = tf.constant([[[1, 3, 3, 6]],
[[3, 3, 5, 5]],
[[1, 4, 3, 6]]], dtype=tf.float32)
tf.print(f"test gt", tf.shape(test_gt_bbox))
tf.print(f"test pred", tf.shape(test_pred_bbox))
inter = intersection(test_pred_bbox, test_gt_bbox)
tf.print(f"test intersection shape", tf.shape(inter))
tf.print(f"test intersection", inter)
jac = jaccard(test_pred_bbox, test_gt_bbox)
tf.print(f"test jaccard shape", tf.shape(jac))
tf.print(f"test jaccard", jac)
# ----------------------------------------------------------------------------------------------------------------------
# test bbox interaction for random crop
# Todo make it clear
test_ref_bbox = tf.constant([[0, 0, 1, 1]], dtype=tf.float32)
test_pred_bbox = tf.constant([[0.1, 0.3, 0.3, 0.6],
[0.3, 0.3, 0.5, 0.5],
[0.1, 0.4, 0.3, 0.6]], dtype=tf.float32)
bbox_iter = bboxes_intersection(test_ref_bbox, test_pred_bbox)
tf.print(f"test bbox inter shape", tf.shape(bbox_iter))
def execute(self):
ids1 = self.a.execute()
if not len(ids1):
return ids1
ids2 = self.b.execute()
return intersection([ids1, ids2])
def execute(self):
ids = self.a.execute()
if not len(ids):
return ids
return intersection([ids, self.b.execute()])
def execute(self):
ids = self.a.execute()
if not len(ids):
return ids
return intersection([ids, self.b.execute()])
def execute(self):
ids1 = self.a.execute()
if not len(ids1):
return ids1
ids2 = self.b.execute()
return intersection([ids1, ids2])
