def setUp(self):
self.arr_tests = []
self.arr_tests.append(Node(5))
self.arr_tests.append(Node(3))
self.arr_tests[1].insert(4)
self.arr_tests[1].insert(5)
self.arr_tests[1].insert(6)
self.arr_tests[1].insert(8)
self.arr_tests[1].insert(9)
self.arr_tests[1].insert(10)
self.arr_tests[1].insert(15)
self.arr_tests.append(Node(5))
self.arr_tests[2].insert(3)
self.arr_tests[2].insert(4)
self.arr_tests[2].insert(8)
self.arr_tests[2].insert(6)
self.arr_tests[2].insert(10)
self.arr_tests[2].insert(9)
self.arr_tests.append(Node(3))
self.arr_tests[3].insert(4)
self.arr_tests[3].insert(5)
self.arr_tests[3].insert(10)
self.arr_tests[3].insert(6)
self.arr_tests[3].insert(8)
self.arr_tests[3].insert(9)
self.arr_tests[3].insert(15)
self.arr_tests.append(Node(8))
self.arr_tests.append(Node(6))
self.arr_tests[5].insert(5)
self.arr_tests[5].insert(4)
self.arr_tests[5].insert(3)
self.arr_tests[5].insert(10)
self.arr_tests[5].insert(9)
self.arr_tests[5].insert(8)
self.arr_tests[5].insert(15)
self.arr_tests.append(Node(5))
self.arr_tests[6].insert(3)
self.arr_tests[6].insert(4)
self.arr_tests[6].insert(8)
self.arr_tests[6].insert(6)
self.arr_tests[6].insert(10)
self.arr_tests[6].insert(9)
def test_preorder_traversal(self):
ordering = []
root = Node(0)
root.left = Node(1)
root.right = Node(2)
root.left.left = Node(3)
root.right.left = Node(4)
root.right.right = Node(5)
btree = tree.BinaryTree(root)
btree.traverse_preorder(store_ordering(ordering))
self.assertEqual(ordering, [0, 1, 3, 2, 4, 5])
def xml_builder(attrs, parent, sizer, sizeritem, pos=None):
"factory to build CustomWidget objects from a XML file"
from xml_parse import XmlParsingError
try:
name = attrs['name']
except KeyError:
raise XmlParsingError(_("'name' attribute missing"))
if not sizer or not sizeritem:
raise XmlParsingError(_("sizer or sizeritem object cannot be None"))
klass = attrs.get("class", "CustomWidget")
win = CustomWidget(name, klass, parent, wx.NewId(), sizer, pos)
#sizer.set_item(win.pos, proportion=sizeritem.proportion, span=sizeritem.span, flag=sizeritem.flag, border=sizeritem.border)
node = Node(win)
win.node = node
if pos is None: common.app_tree.add(node, sizer.node)
else: common.app_tree.insert(node, sizer.node, pos - 1)
return win
def recurse(node: Node, visited: Set) -> [bool, Node]:
if not node:
return True, None
elif node.v in visited:
return False, None
visited.add(node.v)
left_res, left_node = recurse(node.left, visited)
if not left_res:
return False, None
right_res, right_node = recurse(node.right, visited)
if not right_res:
return False, None
return True, Node(node.v, left_node, right_node)
def builder(parent, sizer, pos, number=[1]):
"factory function for EditHyperlinkCtrl objects"
name = u'hyperlink_%d' % number[0]
while common.app_tree.has_name(name):
number[0] += 1
name = u'hyperlink_%d' % number[0]
with parent.frozen():
hyperlink_ctrl = EditHyperlinkCtrl(name, parent, wx.NewId(), name,
sizer, pos)
hyperlink_ctrl.properties["style"].set_to_default()
hyperlink_ctrl.properties["attribute"].set(
True) # allow to modificate it later on...
hyperlink_ctrl.check_defaults()
node = Node(hyperlink_ctrl)
hyperlink_ctrl.node = node
if parent.widget: hyperlink_ctrl.create()
common.app_tree.insert(node, sizer.node, pos - 1)
def generate_game(game_no, model):
# deal cards
l, p1, p2 = deal(model)
landlord = HandCard(l.card_dict, 'dict', is_landlord=True)
peasant1 = HandCard(p1.card_dict, 'dict')
peasant2 = HandCard(p2.card_dict, 'dict')
# construct game tree
node = Node(current=landlord, down=peasant1, up=peasant2)
game_data = pd.DataFrame()
for i in range(100):
# calculate next step
_, node = minimax(node, 3, -inf, +inf)
if node is None or node.is_over():
break
if node.pre1_combo is None:
combo_str = ''
primal_str = ''
primal_type = 0
kicker_len = 0
kicker_type = 0
else:
combo_str = node.pre1_combo.__str__()
primal_str = node.pre1_combo.primal.__str__()
primal_type = node.pre1_combo.get_primal_type()
kicker_len = 0 if node.pre1_combo.kicker is None else node.pre1_combo.kicker.kicker_len
kicker_type = node.pre1_combo.get_kicker_type()
player_no = i % 3 + 1
round_no = (i // 3) + 1
current_str = node.current.__str__()
up_str = node.up.__str__()
down_str = node.down.__str__()
data = pd.DataFrame({
'game_no': [game_no],
'player_no': [player_no],
'round_no': [round_no],
'primal_type': [primal_type],
'kicker_type': [kicker_type],
'kicker_len': [kicker_len],
'combo_str': [combo_str],
'primal_str': [primal_str],
'current_str': [current_str],
'up_str': [up_str],
'down_str': [down_str]
})
game_data = pd.concat([game_data, data])
return game_data
def xml_builder(attrs, parent, sizer, sizeritem, pos=None):
"factory to build EditSpacer objects from a XML file"
from xml_parse import XmlParsingError
if not sizer or not sizeritem:
raise XmlParsingError(_("sizer or sizeritem object cannot be None"))
spacer = EditSpacer('spacer', parent, wx.NewId(), 1, 1, sizer, pos)
sizer.set_item(spacer.pos,
proportion=sizeritem.proportion,
flag=sizeritem.flag,
border=sizeritem.border)
node = Node(spacer)
spacer.node = node
if pos is None:
common.app_tree.add(node, sizer.node)
else:
common.app_tree.insert(node, sizer.node, pos - 1)
return spacer
def builder(parent, sizer, pos, number=[1]):
"factory function for EditPropertyGridManager objects"
label = 'property_grid_%d' % number[0]
while common.app_tree.has_name(label):
number[0] += 1
label = 'property_grid_%d' % number[0]
with parent.frozen():
property_grid_manager = EditPropertyGridManager(
label, parent, wx.NewId(), sizer, pos)
property_grid_manager.properties["style"].set_to_default()
# A grid should be wx.EXPANDed and 'option' should be 1, or you can't see it.
property_grid_manager.properties["proportion"].set(1)
property_grid_manager.properties["flag"].set("wxEXPAND")
node = Node(property_grid_manager)
property_grid_manager.node = node
if parent.widget: property_grid_manager.create()
common.app_tree.insert(node, sizer.node, pos - 1)
def builder(parent, sizer, pos):
"factory function for EditSpacer objects"
dialog = _Dialog(parent)
res = dialog.ShowModal()
width = dialog.width.GetValue()
height = dialog.height.GetValue()
dialog.Destroy()
if res != wx.ID_OK:
return
name = 'spacer'
with parent.frozen():
spacer = EditSpacer( name, parent, wx.NewId(), width, height, sizer, pos )
node = Node(spacer)
spacer.node = node
if parent.widget: spacer.create()
common.app_tree.insert(node, sizer.node, pos-1)
def builder(parent, sizer, pos, number=[0]):
"factory function for EditDialog objects"
import window_dialog
base_classes = ['wxDialog', 'wxPanel']
klass = 'wxDialog' if common.app_tree.app.language.lower(
) == 'xrc' else 'MyDialog'
dialog = window_dialog.WindowDialog(klass, base_classes,
'Select widget type', True)
res = dialog.show()
dialog.Destroy()
if res is None: return
klass, base = res
name = 'dialog' if base == "wxDialog" else "panel"
name = dialog.get_next_name(name)
if base == "wxDialog":
is_panel = False
dialog = EditDialog(name,
parent,
wx.NewId(),
name,
"wxDEFAULT_DIALOG_STYLE",
klass=klass)
else:
is_panel = True
import panel
dialog = panel.EditTopLevelPanel(name, parent, wx.NewId(), klass=klass)
node = Node(dialog)
dialog.node = node
dialog.create()
if base == "wxDialog":
dialog.widget.Show()
else:
dialog.widget.GetParent().Show(
) # the panel is created as child of a Frame
common.app_tree.add(node)
dialog.design.update_label()
if wx.Platform == '__WXMSW__':
if not is_panel:
w = dialog.widget
else:
w = dialog.widget.GetParent()
w.CenterOnScreen()
w.Raise()
def train(agent):
print("Training agent...")
agent.EPOCHS = 1
agent.nbr_simulations = 1
# each epoch represent a game
for epoch in range(agent.EPOCHS):
print("Epoch", str(epoch))
# start from init position
root = Node(Board(), None)
# Simulate a whole game
end = False
c = 0
while not end:
root, end = select_move(root, agent)
print(c)
c += 1
agent.brain.summary()
# Evaluate who won
z = root.state.get_result(white)
print(z)
# Learn from this game
minibatch = random.sample(agent.memory, agent.BS)
training_state = np.array([elem[0][0]
for elem in minibatch]) # 0 for state
training_target = {
'policy_output':
np.array([elem[2] for elem in minibatch]), # 2 for pi
'value_output': np.array([z * elem[1] for elem in minibatch])
} # 1 for player
agent.brain.fit(training_state,
training_target,
epochs=1,
batch_size=agent.BS,
verbose=1,
validation_split=0)
if epoch % 20 == 0:
agent.save_brain()
def inorder_example_tree():
tree = BinaryTree()
n1 = Node('a')
n2 = Node('+')
n3 = Node('*')
n4 = Node('b')
n5 = Node('-')
n6 = Node('/')
n7 = Node('c')
n8 = Node('d')
n9 = Node('e')
n6.left = n7
n6.right = n8
n5.left = n6
n5.right = n9
n3.left = n4
n3.right = n5
n2.left = n1
n2.right = n3
tree.root = n2
return tree
def create_probability_list(f):
letters = {}
counter = 0
for line in f:
if len(line) > 0:
for l in line:
counter += 1
if l in letters:
letters[l] += 1
else:
letters[l] = 1
for k in letters:
letters[k] = letters[k] / counter
nodes = []
for y in letters:
n = Node(value=y, probability=letters[y])
nodes.append(n)
return nodes
def dict_to_tree(tree_dict):
if tree_dict is None:
return None
t = Tree()
if 'node' in tree_dict:
node_dict = tree_dict['node']
node = Node(name=node_dict.get('name', ''), value=node_dict.get('value', None))
if node.name == 'branches' and isinstance(node.value, list):
node.value = [dict_to_tree(branch) for branch in node.value]
t.node = node
if 'left' in tree_dict:
t.left = dict_to_tree(tree_dict['left'])
if 'right' in tree_dict:
t.right = dict_to_tree(tree_dict['right'])
return t
def get_child(self, state, action):
#if node is not in child dictionary...
if self.node_pool[state].children[action] == None:
new_state = self.state_manager.get_state()
new_state_lookup = self.get_lookup_state(new_state)
#...retrieve node from node pool if it exists...
if self.pool_contains(new_state_lookup):
self.node_pool[state].children[action] = self.node_pool[new_state_lookup]
#...if not create the node
else:
possible_actions_from_new_state = self.state_manager.get_possible_actions()
self.add_to_pool(Node(new_state, possible_actions_from_new_state))
self.node_pool[state].children[action] = self.node_pool[new_state_lookup]
return new_state_lookup, False
lookup_state = self.get_lookup_state(self.node_pool[state].children[action].state)
return lookup_state, True
def xml_builder(attrs, parent, sizer, sizeritem, pos=None):
"factory to build EditRadioButton objects from a XML file"
from xml_parse import XmlParsingError
try:
label = attrs['name']
except KeyError:
raise XmlParsingError(_("'name' attribute missing"))
if sizer is None or sizeritem is None:
raise XmlParsingError(_("sizer or sizeritem object cannot be None"))
radio = EditRadioButton(label, parent, wx.NewId(), "", sizer, pos)
sizer.set_item(radio.pos, proportion=sizeritem.proportion, flag=sizeritem.flag, border=sizeritem.border)
node = Node(radio)
radio.node = node
if pos is None:
common.app_tree.add(node, sizer.node)
else:
common.app_tree.insert(node, sizer.node, pos-1)
return radio
def xml_builder(attrs, parent, sizer, sizeritem, pos=None):
"factory function to build EditListCtrl objects from a XML file"
from xml_parse import XmlParsingError
try:
name = attrs['name']
except KeyError:
raise XmlParsingError(_("'name' attribute missing"))
if sizer is None or sizeritem is None:
raise XmlParsingError(_("sizer or sizeritem object cannot be None"))
list_ctrl = EditListCtrl(name, parent, wx.NewId(), sizer, pos, style=0)
#sizer.set_item(list_ctrl.pos, proportion=sizeritem.proportion, span=sizeritem.span, flag=sizeritem.flag, border=sizeritem.border)
node = Node(list_ctrl)
list_ctrl.node = node
if pos is None:
common.app_tree.add(node, sizer.node)
else:
common.app_tree.insert(node, sizer.node, pos - 1)
return list_ctrl
def xml_builder(attrs, parent, sizer, sizeritem, pos=None):
"factory to build EditChoice objects from a XML file"
from xml_parse import XmlParsingError
try:
name = attrs['name']
except KeyError:
raise XmlParsingError(_("'name' attribute missing"))
if sizer is None or sizeritem is None:
raise XmlParsingError(_("sizer or sizeritem object cannot be None"))
choice = EditChoice(name, parent, wx.NewId(), [], sizer, pos)
#sizer.set_item(choice.pos, proportion=sizeritem.proportion, span=sizeritem.span, flag=sizeritem.flag, border=sizeritem.border)
node = Node(choice)
choice.node = node
if pos is None:
common.app_tree.add(node, sizer.node)
else:
common.app_tree.insert(node, sizer.node, pos - 1)
return choice
def __init__(self):
self.base_data = None
self.completions_tree = Node([])
with open('data_dict.obj', 'rb') as f:
self.base_data = pickle.load(f)
root_children = {}
path_base = 'subtrees'
flist_files = glob.glob(os.path.join(path_base, '*.obj'))
for obj_file in flist_files:
with open(obj_file, 'rb') as f:
file_prefix = obj_file.split('.')
letter = file_prefix[0][-1]
new_node = pickle.load(f)
root_children[letter] = new_node
self.completions_tree.children = root_children
def builder(parent, sizer, pos, number=[1]):
"factory function for editor objects from GUI"
dialog = wcodegen.WidgetStyleSelectionDialog(dlg_title, box_title, choices)
res = dialog.ShowModal()
style = dialog.get_selection()
dialog.Destroy()
if res != wx.ID_OK:
return
label = '%s_%d' % (tmpl_label, number[0])
while common.app_tree.has_name(label):
number[0] += 1
label = '%s_%d' % (tmpl_label, number[0])
widget = editor_class(label, parent, wx.ID_ANY, style, sizer, pos)
node = Node(widget)
widget.node = node
if parent.widget: widget.create()
common.app_tree.insert(node, sizer.node, pos - 1)
def xml_builder(attrs, parent, sizer, sizeritem, pos=None):
"Factory to build editor objects from a XML file"
from xml_parse import XmlParsingError
try:
name = attrs['name']
except KeyError:
raise XmlParsingError(_("'name' attribute missing"))
if sizer is None or sizeritem is None:
raise XmlParsingError(_("sizer or sizeritem object cannot be None"))
widget = editor_class(name, parent, wx.ID_ANY, editor_style, sizer, pos)
#sizer.set_item(widget.pos, proportion=sizeritem.proportion, span=sizeritem.span, flag=sizeritem.flag, border=sizeritem.border)
node = Node(widget)
widget.node = node
if pos is None:
common.app_tree.add(node, sizer.node)
else:
common.app_tree.insert(node, sizer.node, pos - 1)
return widget
def parse_ontology_level(lines, lineno, root_spaces, root):
"""
Parse a level of the tree into `root` and return the next `lineno`.
The level is defined by the number of spaces.
"""
prev_categ = None
child_spaces = None
while True:
if lineno == len(lines):
# EOF; end recursion.
break
line = lines[lineno]
if not line.strip() or line.startswith('#'):
# Ignore blank line.
lineno += 1
continue
categ = line.strip()
spaces = 0
for c in line:
if c != ' ':
break
spaces += 1
if spaces < root_spaces:
# Handled by function above us.
break
if spaces == root_spaces:
# Handled by ourselves.
child = Node()
child.label = categ
root.children.append(child)
prev_categ = child
lineno += 1
elif spaces > root_spaces:
# Handled by a child function.
if child_spaces is None:
child_spaces = spaces
if child_spaces != spaces:
raise ValueError("line {}: indent mismatch".format(lineno))
if prev_categ is None:
raise ValueError("line {}: overindented".format(lineno))
lineno = parse_ontology_level(lines, lineno, spaces, prev_categ)
return lineno
def test_find_maximum_value_returns_max_value():
a = Node(4)
b = Node(2)
c = Node(8)
d = Node(42)
e = Node(18)
f = Node(12)
g = Node(25)
h = Node(7)
x = BinaryTree()
x.root = a
x.root.left = b
x.root.right = c
x.root.left.left = d
x.root.left.right = e
x.root.right.left = f
x.root.right.right = h
actual = x.max_value()
expected = 42
assert actual == expected
def IDFS(StartState):
global stepscount, weight, mode
# Update hashtable
Node.h = {}
# Install current depth
depth = 0
# Cycle through depth to the maximum depth
while True:
Node.h = {}
# tree initialisation
current = Node(state=StartState)
# queue initialisation
queue = Queue()
flag = True
# depth cycle
while flag:
# show current condition for step mode
if mode == 1:
print(current.getstate())
input("Press enter to continue...")
# step's counting
stepscount = stepscount + 1
# the decomposition of the node
if current.depth < depth:
current.expand()
# if a solution is found, output the results
if current.goaltest():
weight = sys.getsizeof(Node.h)
result = [current]
while current.depth != 0:
current = current.prev
result.append(current)
return result
# getting child nodes
childs = current.getchild()
# adding child nodes to queue
queue.Queueing_Fn(childs)
# getting the next node from the queue
if not queue.IsQueusEmpty():
current = queue.RemoveFront()
else:
flag = False
# increasing the depth
depth = depth + 1
def test_breadth_first_properly_walks_through_and_collects_values_in_asym_tree(
):
x = BinaryTree()
a = Node(1)
b = Node(2)
c = Node(3)
d = Node(4)
e = Node(5)
f = Node(6)
g = Node(7)
h = Node(8)
i = Node(9)
x.root = a
x.root.left = b
x.root.right = c
x.root.left.left = d
x.root.left.right = e
x.root.left.left.left = f
x.root.left.left.right = g
x.root.right.right = h
x.root.right.right.right = i
actual = x.breadth_first()
expected = [1, 2, 3, 4, 5, 8, 6, 7, 9]
assert actual == expected
def builder(parent, sizer, pos, number=[1]):
"factory function for EditListCtrl objects"
name = 'list_ctrl_%d' % number[0]
while common.app_tree.has_name(name):
number[0] += 1
name = 'list_ctrl_%d' % number[0]
with parent.frozen():
list_ctrl = EditListCtrl(name, parent, wx.NewId(), sizer, pos)
#list_ctrl.properties["style"].set_to_default() # default is wxLC_ICON
list_ctrl.properties["columns"].set([['A', -1], ['B', -1], ['C', -1]])
list_ctrl.properties["rows_number"].set(10)
list_ctrl.properties["style"].set(
["wxLC_REPORT", "wxLC_HRULES", "wxLC_VRULES"])
node = Node(list_ctrl)
list_ctrl.node = node
list_ctrl.properties["proportion"].set(1)
list_ctrl.properties["flag"].set("wxEXPAND")
if parent.widget: list_ctrl.create()
common.app_tree.insert(node, sizer.node, pos - 1)
def xml_builder(attrs, parent, sizer, sizeritem, pos=None):
"factory function to build EditSpinCtrl objects from a XML file"
from xml_parse import XmlParsingError
try:
name = attrs['name']
except KeyError:
raise XmlParsingError(_("'name' attribute missing"))
if sizer is None or sizeritem is None:
raise XmlParsingError(_("sizer or sizeritem object cannot be None"))
spin = EditSpinCtrl(name, parent, wx.NewId(), sizer, pos)
spin.properties["value"].set_active(False)
#sizer.set_item( spin.pos, proportion=sizeritem.proportion, flag=sizeritem.flag, border=sizeritem.border )
node = Node(spin)
spin.node = node
if pos is None:
common.app_tree.add(node, sizer.node)
else:
common.app_tree.insert(node, sizer.node, pos - 1)
return spin
def createTree(list, start = 0, end = None):
if end == None:
end = len(list)
if start == end:
return
mid = (start + end)/2
node = Node(list[mid])
left = createTree(list,start,mid)
right = createTree(list,mid+1,end)
if left:
left.setParent(node)
if right:
right.setParent(node)
node.setLeftChild(left)
node.setRightChild(right)
return node
def test_find_maximum_value_works_with_ALL_negative():
a = Node(-4)
b = Node(-2)
c = Node(-8)
d = Node(-42)
e = Node(-18)
f = Node(-12)
g = Node(-25)
h = Node(-7)
x = BinaryTree()
x.root = a
x.root.left = b
x.root.right = c
x.root.left.left = d
x.root.left.right = e
x.root.right.left = f
x.root.right.right = g
x.root.right.right.right = h
actual = x.max_value()
expected = -2
assert actual == expected
def test_max_value_works_with_unbalanced_tree():
a = Node(4)
b = Node(2)
c = Node(8)
d = Node(42)
e = Node(18)
f = Node(12)
g = Node(68)
h = Node(70)
x = BinaryTree()
x.root = a
x.root.left = b
x.root.left.left = c
x.root.left.left.left = d
x.root.left.left.right = e
x.root.left.left.left.left = f
x.root.left.left.left.right = g
x.root.left.left.left.left.left = h
actual = x.max_value()
expected = 70
assert actual == expected
