def __init__(
self,
rules,
leaf_threshold,
refinements={
"node_merging": False,
"rule_overlay": False,
"region_compaction": False,
"rule_pushup": False,
"equi_dense": False
}):
# hyperparameters
self.leaf_threshold = leaf_threshold
self.refinements = refinements
self.rules = RuleSet(rules) if isinstance(rules, list) else rules
self.root = self.create_node(
0, [0, 2**32, 0, 2**32, 0, 2**16, 0, 2**16, 0, 2**8], rules, 1,
None, None)
if (self.refinements["region_compaction"]):
self.refinement_region_compaction(self.root)
self.current_node = self.root
self.nodes_to_cut = [self.root]
self.depth = 1
self.node_count = 1
def test_ruleset(self):
with open('people.json') as f1:
people_data = json.load(f1)
results = list()
for person in people_data['people']:
with open('rules.json') as f2:
rules_data = json.load(f2)
rs = RuleSet(rules_data)
results.append(rs.evaluate(person))
for result in results:
if result['name'] == 'FRED':
self.assertEqual(result['status'], 'COOL')
elif result['name'] == 'GINGER':
self.assertEqual(result['status'], 'OLD')
elif result['name'] == 'SID':
self.assertEqual(result['status'], 'ANCIENT')
elif result['name'] == 'NANCY':
self.assertEqual(result['status'], 'VERY OLD')
elif result['name'] == 'JOE':
self.assertEqual(result['status'], 'YOUNG')
elif result['name'] == 'FLO':
self.assertEqual(result['status'], 'VERY OLD')
elif result['name'] == 'REG':
self.assertEqual(result['status'], 'WEIRD')
elif result['name'] == 'BRIAN':
self.assertEqual(result['status'], 'DEAD')
elif result['name'] == 'ELSIE':
self.assertEqual(result['status'], 'OLD HIPPY')
self.assertEqual(result['nickname'], 'Hippy')
def test_exclusive_ab(self):
rs = RuleSet()
rs.addDep("a", "b")
rs.addConflict("a", "b")
self.assertFalse(rs.isCoherent(), "rs.isCoherent failed")
def test_depends_ab_ba(self):
rs = RuleSet()
rs.addDep("a", "b")
rs.addDep("b", "a")
self.assertTrue(rs.isCoherent(), "rs.isCoherent failed")
def test_deep_deps(self):
rs = RuleSet()
rs.addDep("a", "b")
rs.addDep("b", "c")
rs.addDep("c", "d")
rs.addDep("d", "e")
rs.addDep("a", "f")
rs.addConflict("e", "f")
self.assertFalse(rs.isCoherent(), "rs.isCoherent failed")
def __init__(self, id, ranges, rules, depth, partitions, manual_partition):
self.id = id
self.partitions = list(partitions or [])
self.manual_partition = manual_partition
self.ranges = ranges
self.rules = RuleSet(rules) if isinstance(rules, list) else rules
self.depth = depth
self.children = []
self.action = None
self.pushup_rules = None
self.num_rules = len(self.rules)
def createRuleSet(self, name):
logging.info("Creating RuleSet: " + name)
if (name is None or name == ""):
raise ValueError("RuleSet name cannot be none or empty")
rs = RuleSet(name)
self.ruleSets[name] = rs
logging.info("Created RuleSet: " + name)
return rs
def test_ab_bc_toggle(self):
rs = RuleSet()
rs.addDep("a", "b")
rs.addDep("b", "c")
self.assertTrue(rs.isCoherent(), "rs.isCoherent failed")
opts = Options(rs)
opts.toggle("c")
self.assertSetEqual(
opts.selection(),
set(["c"]),
"toggle expected (c) got %s" % opts.selection(),
)
def test_exclusive_ab_bc_ca_de(self):
rs = RuleSet()
rs.addDep("a", "b")
rs.addDep("b", "c")
rs.addDep("c", "a")
rs.addDep("d", "e")
rs.addConflict("c", "e")
self.assertTrue(rs.isCoherent(), "rs.isCoherent failed")
opts = Options(rs)
opts.toggle("a")
self.assertSetEqual(
opts.selection(),
set(["a", "c", "b"]),
"toggle expected (a, c, b) got %s" % opts.selection(),
)
rs.addDep("f", "f")
opts.toggle("f")
self.assertSetEqual(
opts.selection(),
set(["a", "c", "b", "f"]),
"toggle expected (a, c, b, f) got %s" % opts.selection(),
)
opts.toggle("e")
self.assertSetEqual(
opts.selection(),
set(["e", "f"]),
"toggle expected (e, f) got %s" % opts.selection(),
)
opts.toggle("b")
self.assertSetEqual(
opts.selection(),
set(["a", "c", "b", "f"]),
"toggle expected (a, c, b, f) got %s" % opts.selection(),
)
rs.addDep("b", "g")
opts.toggle("g")
opts.toggle("b")
self.assertSetEqual(
opts.selection(),
set(["g", "f"]),
"toggle expected (g, f) got %s" % opts.selection(),
)
def test_ab_ac(self):
rs = RuleSet()
rs.addDep("a", "b")
rs.addDep("a", "c")
rs.addConflict("b", "d")
rs.addConflict("b", "e")
self.assertTrue(rs.isCoherent(), "rs.isCoherent failed")
opts = Options(rs)
opts.toggle("d")
opts.toggle("e")
opts.toggle("a")
self.assertSetEqual(
opts.selection(),
set(["a", "c", "b"]),
"toggle expected (a, c, b) got %s" % opts.selection(),
)
