def test_this_and_that(self):
self.assert_(2 == len(self.fake_dict.keys()))
cat_hits = self.fake_dict[Bag("cat")]
self.assert_(2 == len(cat_hits))
self.assert_(cat_hits == set(["cat", "tac"]))
self.assert_(1 == len(self.fake_dict[Bag("fred")]))
self.assert_(self.fake_dict[Bag("fred")] == set(["fred"]))
def test_equal(self):
to_bag = [random.randrange(1, 11) for i in range(1000)]
bag1 = Bag(to_bag)
bag2 = Bag(to_bag)
self.assertEqual(bag1, bag2, "Bags are not equal.")
bag1.remove(to_bag[0])
self.assertNotEqual(bag1, bag2, "Bags should not be equal.")
def test_equals(self):
vals = [random.randint(1, 10) for i in range(1000)]
bag1 = Bag(vals)
random.shuffle(vals)
bag2 = Bag(vals)
self.assertTrue(bag1 == bag2, 'bags are not equal')
bag1.remove(vals[0])
self.assertFalse(bag1 == bag2, 'bags are not supposed to be equal')
def testadd(self):
l = [random.randint(1, 10) for i in range(1000)]
first = Bag(l)
second = Bag([])
random.shuffle(l)
for i in l:
second.add(i)
assert first == second
def test_add(self):
vals = [random.randint(1, 10) for i in range(1000)]
bag1 = Bag(vals)
random.shuffle(vals)
bag2 = Bag()
for item in vals:
bag2.add(item)
self.assertEqual(bag1, bag2, 'bags are not equal')
def test_add(self):
test = [random.randint(1, 10) for _ in range(1000)]
bag1 = Bag(test)
bag2 = Bag()
random.shuffle(test)
for v in test:
bag2.add(v)
self.assertEqual(bag1, bag2)
def test_this_and_that(self):
self.assert_(2 == len(self.fake_dict.keys()))
cat_hits = self.fake_dict[Bag("cat")]
self.assert_(2 == len(cat_hits))
self.assert_(cat_hits[0] == "cat")
self.assert_(cat_hits[1] == "tac")
self.assert_(1 == len(self.fake_dict[Bag("fred")]))
self.assert_(self.fake_dict[Bag("fred")][0] == "fred")
def test_equal(self):
test = [random.randint(1, 10) for _ in range(1000)]
bag1 = Bag(test)
random.shuffle(test)
bag2 = Bag(test)
self.assertEqual(bag1, bag2)
bag1.remove(test[0])
self.assertNotEqual(bag1, bag2)
def test__eq__(self):
l = [random.randint(1, 10) for i in range(1000)]
first = Bag(l)
random.shuffle(l)
second = Bag(l)
assert first == second
first.remove(l[0])
assert first != second
def test_this_and_that(fake_dict):
assert (2 == len(fake_dict.keys()))
key = Bag("cat")
cat_hits = sorted(fake_dict[key])
assert (cat_hits == ["cat", "tac"])
assert (1 == len(fake_dict[Bag("fred")]))
assert (list(fake_dict[Bag("fred")])[0] == "fred")
def test_add(self):
to_bag = [random.randrange(1, 11) for i in range(1000)]
bag1 = Bag(to_bag)
random.shuffle(to_bag)
bag2 = Bag()
for i in to_bag:
bag2.add(i)
self.assertEqual(bag1, bag2, "Bags are not equal.")
def initialize_bags(gift_weight_init_method, gift_type_amounts,
warm_start_path):
bags = []
if warm_start_path is None:
gift_type_amounts_remaining = copy.deepcopy(gift_type_amounts)
gifts = []
# Initialize bags
for _ in range(utils.N_BAGS):
bags.append(Bag(is_trash_bag=False))
# Initialize gifts
for _, row in utils.GIFTS_DF.iterrows():
gift = Gift(id_label=row['GiftId'],
gift_type=row['GiftId'].split('_')[0].title())
if gift_type_amounts_remaining is not None:
gift_type_amounts_remaining[gift.gift_type] -= 1
if (gift_type_amounts_remaining is None
or gift_type_amounts_remaining[gift.gift_type] >= 0):
# Add only if gift's type hasn't been added enough already
gift.initialize_weight(gift_weight_init_method)
gifts.append(gift)
# Randomize the order of gifts
np.random.shuffle(gifts)
# Put gifts in the bags
all_bags_full = False
while not all_bags_full:
n_bags_filled = 0
# For each bag, add first occurring gift that fits in the bag
for bag in bags:
gift_to_add = None
for gift in gifts:
if bag.weight + gift.weight <= utils.MAX_BAG_WEIGHT:
gift_to_add = gift
bag.add_gift(gift_to_add)
break
if gift_to_add is not None:
# Remove added gift from list of gifts
gifts.remove(gift_to_add)
n_bags_filled += 1
if n_bags_filled == 0:
all_bags_full = True
if len(gifts) > 0:
# Add the remaining gifts to a trash bag
trash_bag = Bag(is_trash_bag=True)
for gift in gifts:
trash_bag.add_gift(gift)
bags.append(trash_bag)
else:
with open(warm_start_path) as f:
f.readline() # Throw away first line (header)
for l in f.readlines():
bag = Bag(is_trash_bag=False)
for gift_label in l.replace('\n', '').split(' '):
gift = Gift(id_label=gift_label,
gift_type=gift_label.split('_')[0].title())
gift.initialize_weight(gift_weight_init_method)
bag.add_gift(gift)
bags.append(bag)
return bags
def test_add(self):
rand_list = [random.randint(1, 10)
for i in range(0, 1000)] #Make 1000-value random list
bag1 = Bag(rand_list) #Create bag from random list
bag2 = Bag() #Create another bag from shuffled random list
random.shuffle(rand_list) #Shuffle random list
for x in rand_list:
bag2.add(x)
self.assertEqual(bag1, bag2)
def test_equals(self):
rand_list = [random.randint(1, 10)
for i in range(0, 1000)] #Make 1000-value random list
bag1 = Bag(rand_list) #Create bag from random list
random.shuffle(rand_list) #Shuffle random list
bag2 = Bag(rand_list) #Create another bag from shuffled random list
self.assertTrue(bag1.__eq__(bag2)) #They should be equal
bag1.remove(rand_list[0]) #Remove 1 value from one bag
self.assertFalse(bag1.__eq__(bag2)) #They should NOT be equal
def testadd(self):
rand_list = []
for i in range(1000):
rand_list.append(random.randint(1, 10))
bag = Bag(rand_list)
bag2 = Bag()
random.shuffle(rand_list)
for value in rand_list:
bag2.add(value)
assert bag == bag2
def testequals(self):
rand_list = []
for i in range(1000):
rand_list.append(random.randint(1, 10))
bag = Bag(rand_list)
random.shuffle(rand_list)
bag2 = Bag(rand_list)
assert bag == bag2
bag.remove(rand_list[0])
assert bag != bag2
def filter_cmd(argv):
def expr_eval(expr):
def eval_fn(topic, m, t):
return eval(expr)
return eval_fn
parser = optparse.OptionParser(
usage="""rosbag filter [options] INBAG OUTBAG EXPRESSION
EXPRESSION can be any Python-legal expression.
The following variables are available:
* topic: name of topic
* m: message
* t: time of message (t.secs, t.nsecs)""",
description='Filter the contents of the bag.')
parser.add_option(
'-p',
'--print',
action='store',
dest='verbose_pattern',
default=None,
metavar='PRINT-EXPRESSION',
help=
'Python expression to print for verbose debugging. Uses same variables as filter-expression'
)
options, args = parser.parse_args(argv)
if len(args) == 0:
parser.error(
'You must specify an in bag, an out bag, and an expression.')
if len(args) == 1:
parser.error('You must specify an out bag and an expression.')
if len(args) == 2:
parser.error("You must specify an expression.")
if len(args) > 3:
parser.error("Too many arguments.")
inbag_filename, outbag_filename, expr = args
if not os.path.isfile(inbag_filename):
print >> sys.stderr, 'Cannot locate input bag file [%s]' % inbag_filename
sys.exit(2)
filter_fn = expr_eval(expr)
outbag = Bag(outbag_filename, 'w')
try:
inbag = Bag(inbag_filename)
except ROSBagUnindexedException, ex:
print >> sys.stderr, 'ERROR bag unindexed: %s. Run rosbag reindex.' % arg
return
def test_remove(self):
vals = [random.randint(1, 10) for i in range(1000)]
bag1 = Bag(vals)
self.assertRaises(ValueError, lambda: bag1.remove(35))
bag2 = Bag(vals)
random.shuffle(vals)
for item in vals:
bag2.add(item)
for item in vals:
bag2.remove(item)
self.assertEqual(bag1, bag2, 'bags are not equal')
def evaluate_pathway(list_of_paths):
scores = []
# create a set of all participating enzymes, and count the number of enzymes that are not trivial
total_path_length = 0
enzyme_bag = Bag()
enzyme_type_bag = Bag()
for path in list_of_paths:
for enzyme in path_to_enzyme_list(path):
if (not enzyme in pp_enzymes):
total_path_length += 1
enzyme_bag[enzyme] += 1
enzyme_type_bag[enzyme_types[enzyme]] += 1
scores.append((params['TL'], total_path_length))
scores.append((params['NE'], enzyme_type_bag['EPI']))
scores.append((params['NI'], enzyme_type_bag['ISO']))
scores.append((params['NK'], enzyme_type_bag['KIN']))
scores.append((params['ND'], enzyme_type_bag['DHG']))
num_isoenzymes = 0
for (enzyme, count) in enzyme_bag.itercounts():
if (count > 1):
num_isoenzymes += 1
scores.append((params['MIE'], num_isoenzymes))
total_phosphorilation_distance = 0
for path in list_of_paths:
for enzyme in path_to_enzyme_list(path):
if (enzyme_types[enzyme] == "KIN"):
break
else:
total_phosphorilation_distance += 1
scores.append((params['TPD'], total_phosphorilation_distance))
# NTE - Number maximum number of same-product epimerases
G = pathway_to_graph(list_of_paths)
max_epimerase_count = 0
max_split = 0
for v in G.itervertices():
epimerase_count = 0
for child in G[v]:
if (enzyme_types[(v, child)] == "EPI"):
epimerase_count += 1
max_epimerase_count = max(max_epimerase_count, epimerase_count)
max_split = max(max_split, len(G[v]))
scores.append((params['NTE'], max_epimerase_count))
# copy on the scores that have a parameter which is not None.
chosen_scores = []
for (p, s) in scores:
if (p != None):
chosen_scores.append((p, s))
chosen_scores.sort()
return tuple([s[1] for s in chosen_scores])
def test_equals(self):
listone = []
listtwo = []
for x in range(1000):
c = random.randint(1, 10)
listone.append(c)
listtwo.append(c)
random.shuffle(listone)
b1 = Bag(listone)
b2 = Bag(listtwo)
self.assertTrue(b1 == b2)
def test_add(self):
alist = []
for i in range(1000):
alist.append(random.randint(1, 10))
b1 = Bag(alist)
random.shuffle(alist)
b2 = Bag()
for a in alist:
b2.add(a)
if b1 != b2:
raise
def test_remove(self):
to_bag = [random.randrange(1, 11) for i in range(1000)]
bag1 = Bag(to_bag)
self.assertRaises(ValueError, Bag.remove, bag1, 32)
bag2 = Bag(to_bag)
for i in to_bag:
bag2.add(i)
for i in to_bag:
bag2.remove(i)
self.assertEqual(bag1, bag2, "Bags are not equal.")
def test_equals(self):
alist = []
for i in range(1000):
alist.append(random.randint(1, 10))
b1 = Bag(alist)
random.shuffle(alist)
b2 = Bag(alist)
if b1 != b2:
raise
b1.remove(alist[0])
if b1 == b2:
raise
def test_add(self):
listone = []
listtwo = []
for x in range(1000):
c = random.randint(1, 10)
listone.append(c)
listtwo.append(c)
random.shuffle(listone)
b1 = Bag(listone)
b2 = Bag()
for item in listtwo:
b2.add(item)
self.assertTrue(b1 == b2)
def bfs_com_bags(g, vertice_ini):
for vertex in g:
vertex.dist = float('inf')
vertice_ini.dist = 0
d = 0
bag_size = math.ceil(math.log2(g.qtd_vertices))
V = Bag(bag_size)
V.insert(vertice_ini)
while len(V) is not 0:
V2 = Bag(bag_size)
processLayer(g, V, V2, d)
V = V2
d += 1
def test_remove(self):
test = [random.randint(1, 10) for _ in range(1000)]
bag1 = Bag(test)
self.assertRaises(ValueError, bag1.remove, 86)
bag2 = Bag(test)
random.shuffle(test)
test1 = [random.randint(1, 10) for _ in range(1000)]
for v in test1:
bag2.add(v)
for v in test1:
bag2.remove(v)
self.assertEqual(bag1, bag2)
def testremove(self):
l = [random.randint(1, 10) for i in range(1000)]
first = Bag(l)
try:
first.remove(42)
except Exception as e:
assert type(e) == ValueError
second = Bag(l)
random.shuffle(l)
for i in l:
second.add(i)
for i in l:
second.remove(i)
assert first == second
def test_remove(self):
rand_list = [random.randint(1, 10)
for i in range(0, 1000)] #Make 1000-value random list
bag1 = Bag(rand_list) #Create bag from random list
with self.assertRaises(ValueError):
bag1.remove(43)
bag2 = Bag(rand_list)
random.shuffle(rand_list) #Shuffle random list
for x in rand_list:
bag2.add(x)
for x in rand_list:
bag2.remove(x)
self.assertEqual(bag1, bag2)
def test_remove(self):
alist = []
for i in range(1000):
alist.append(random.randint(1, 10))
b1 = Bag(alist)
self.assertRaises(ValueError, b1.remove, 11)
b2 = Bag(alist)
random.shuffle(alist)
for v in alist:
b2.add(v)
for v in alist:
b2.remove(v)
if b1 != b2:
raise
def recognizes(self, txt: str) -> bool:
dfs = DirectedDFS(self._G, [0])
pc = Bag([v for v in range(self._G.V) if dfs.marked(v)])
for i in range(len(txt)):
match = Bag([
v + 1 for v in pc
if v < self._M and self._re[v] in '.' + txt[i]
])
print(match._items, "match")
dfs = DirectedDFS(self._G, match)
print(dfs._marked)
pc = Bag([v for v in range(self._G.V) if dfs.marked(v)])
print(pc._items)
return self._M in pc
