class TestTree(unittest.TestCase):
def setUp(self):
self.tree = Tree(5)
def test_init(self):
self.assertEqual(self.tree.root.value, 5)
def test_add_child(self):
self.assertTrue(self.tree.add_child(5, 4))
self.assertFalse(self.tree.add_child(6, 3))
def test_find(self):
self.tree.add_child(5, 4)
self.tree.add_child(4, 3)
self.assertTrue(self.tree.find(4))
self.assertFalse(self.tree.find(6))
def test_height(self):
self.tree.add_child(5, 4)
self.tree.add_child(4, 3)
self.assertEqual(self.tree.height(), 2)
def test_tree_levels(self):
self.tree.add_child(5, 4)
self.tree.add_child(4, 3)
self.assertEqual(self.tree.tree_levels(), [[5], [4], [3]])
def test_DFS(self):
self.tree.add_child(5, 4)
self.tree.add_child(5, 7)
self.tree.add_child(7, 8)
self.tree.add_child(4, 3)
self.tree.add_child(4, 6)
self.assertEqual(self.tree.DFS(self.tree.root), [5, 7, 8, 4, 6, 3])
def test_exceptions(self):
with self.assertRaises(ValueError):
t = Tree("t", "T")
t.insert('t', "T")
with self.assertRaises(KeyError):
t = Tree('t', "T")
t.find('z')
def test_tree_find(self):
'Verify find method, with data and without'
t = Tree('D')
for c, i in (('F', [6,7,8]),('C', 3), ('G', dict(one=1, two=2)), ('A', 1), ('E', 5), ('B', 2)):
t.insert(c, i)
self.assertEqual(t.find('D'), None)
self.assertEqual(t.find('A'), 1)
self.assertEqual(t.find('F'), [6,7,8])
self.assertEqual(t.find('G'), {'one':1, 'two':2})
self.assertRaises(KeyError, t.find, 'Z')
def arvoreminima(self):
"""
Opera apenas em grafos não-direcionados e conectados
{"arvoreminima":{"arestas":[(1,2),(2,0),(1,0)], "custo":21}}
"""
copy = self.matriz
edges = []
menor = [-1,-1,-1]
teste = False
out = []
weight = ''
for k in range (self.edge/2):
for i in range (self.size):
for j in range (i):
if (copy[i][j] > -1):
if (int(menor[2]) > int(-1)):
if (int(copy[i][j]) < int(menor[2])):
menor = [j,i,copy[i][j]]
teste = True
else:
menor = [j,i,copy[i][j]]
teste = True
copy[menor[1]][menor[0]] = -1
edges += [menor]
menor = [-1,-1,-1]
if teste:
connected = Tree(self.size)
aux = edges.pop(0)
weight = aux[2]
tree = [[aux[0],aux[1]]]
while (len(tree) < self.size - 1):
aux = edges.pop(0)
if (connected.find(aux[0]) != connected.find(aux[1])):
weight += aux[2]
tree += [[aux[0],aux[1]]]
connected.merge(aux[0],aux[1])
out = "["
for i in range(len(tree)):
out += str("(")+str(tree[i][0])+","+str(tree[i][1])+")"
if (i < (len(tree) - 1)):
out += str(',')
out += "]"
return "{\"arvoreminima\":{\"arestas\":"+str(out)+", \"custo\":"+str(weight)+"}}"
def test_find2():
tree = Tree()
l = [38, 13, 51, 10, 25, 40, 84, 12, 37, 66, 89, 95]
length = len(l)
while len(l) > 0:
key = l.pop(0)
value = chr(key)
tree.insert(key, value)
assert tree.find(100) == None
assert tree.find(50) == None
assert tree.find(15) == None
assert tree.find(39) == None
def dfs(board_state):
'Uses Depth First Search to search for solution'
startTime = time.time()
tree = Tree()
tree.add(Node(board_state, None, None))
tree.frontier.append(tree.find(board_state))
result = None
while tree.has_frontier():
current_node = tree.frontier.pop(0)
if current_node.reached_goal():
tree.result = current_node
break
children = current_node.children()
for child in children[::-1]:
if tree.already_added(child) == False:
tree.add(child)
tree.frontier.insert(0, child)
tree.expanded.append(current_node)
elapsed_time = time.time() - startTime
tree.total_time = elapsed_time
build_file(tree)
def test_remove():
tree = Tree()
l = [38, 13, 51, 10, 25, 40, 84, 12, 37, 66, 89, 95]
length = len(l)
while len(l) > 0:
key = l.pop(0)
value = chr(key)
tree.insert(key, value)
tree.remove(38)
assert tree.root.key == 37
assert tree.find(38) == None
tree.remove(89)
print(tree.in_order())
p, c = tree.find_parent_croot(95)
assert p.key == 84
assert c.key == 95
tree.remove(13)
print(tree.in_order())
p, c = tree.find_parent_croot(10)
assert p.key == 12
assert c.key == 10
tree.remove(10)
print(tree.in_order())
tree.remove(15)
print(tree.in_order())
p, c = tree.find_parent_croot(25)
assert p.key == 12
assert c.key == 25
def ast(board_state):
'Uses A* to search for solution'
startTime = time.time()
tree = Tree()
tree.add(NodeHeuristic(board_state, None, None))
tree.frontier = Queue.PriorityQueue()
tree.frontier.put(tree.find(board_state))
result = None
while tree.frontier.empty() == False:
current_node = tree.frontier.get()
if current_node.reached_goal():
tree.result = current_node
break
children = current_node.children()
for child in children:
if tree.already_added(child) == False:
tree.add(child)
tree.frontier.put(child)
tree.expanded.append(current_node)
elapsed_time = time.time() - startTime
tree.total_time = elapsed_time
build_file(tree)
def test_find_returns_node_with_the_specified_value_when_such_exists():
t = Tree("a")
t.add_child("b")
t.add_child("c").add_child("d").add_child("e")
node = t.find("d")
assert_that(node.children[0].value, is_("e"))
def test_does_not_find_key_in_the_tree_with_depth_two(self):
root_node = Node([1, 3, 8])
target_node = Node([5])
root_node.add_right_middle_child(target_node)
tree = Tree(root_node)
result = tree.find(6)
self.assertEqual(result, None)
def test_find():
dict_depth = 7
rnd_tree = Tree(get_random_dict(dict_depth))
rnd_path = (get_random_path(rnd_tree.root))
request = get_mixed_request(rnd_path)
result = rnd_tree.find(request)
# ToDo Fix error with depth level (at now: -1 level)
pass
def test_finds_key_in_the_tree_with_depth_two_with_two_keys_at_leaf(self):
root_node = Node([1, 3, 8])
target_node = Node([9])
other_node = Node([5])
root_node.add_right_middle_child(other_node)
root_node.add_right_child(target_node)
tree = Tree(root_node)
result = tree.find(9)
self.assertEqual(result, 9)
class Test(unittest.TestCase):
def setUp(self):
self.test = Tree("D", ord("D"))
for c in "BJQKFAC":
self.test.insert(c, ord(c))
def testTree(self):
self.assertEqual(self.test.answer(70), 'F')
self.assertEqual(self.test.answer(81), 'Q')
def testExceptions(self):
self.assertRaises(KeyError, self.test.find(99))
def test_find():
l = list()
for i in range(97, 107):
l.append(i)
tree = Tree()
random.shuffle(l)
while len(l) > 0:
key = l.pop()
value = chr(key)
tree.insert(key, value)
for i in range(97, 107):
key = i
value = chr(key)
croot = tree.find(key)
assert croot.value == value
def test_cannot_find_a_key_in_the_tree(self):
root_node = Node([1, 3, 8])
tree = Tree(root_node)
result = tree.find(5)
self.assertEqual(result, None)
def test_find(self):
t = Tree('t', "T")
observed = t.find('t')
expected = 'T'
self.assertEqual(observed, expected)
def test_finds_key_in_the_tree_with_depth_one_and_one_key_root(self):
root_node = Node([1])
tree = Tree(root_node)
result = tree.find(1)
self.assertEqual(result, 1)
class Tasks:
ROOT_TASK_ID = 0
def __init__(self, fileName=None, task_dir=None):
try:
if fileName is not None:
task_dir = task_dir if task_dir is not None else ''
self.fileName = task_dir + fileName
self.fileDB = FileDB(self.fileName)
self.taskObj = self.read()
else:
self.taskObj = Tree(Tasks.ROOT_TASK_ID)
self.fileName = None
except:
self.taskObj = Tree(Tasks.ROOT_TASK_ID)
def createId(self):
return str(random.randint(1, 20000))
# create a tree obj based on the input prop and val and insert
def addTask(self, taskId=None, parentTaskId=None, prop=None):
if taskId is None:
taskId = self.createId()
elif taskId <= Tasks.ROOT_TASK_ID:
raise Exception('Cannot create task with taskId ' + str(taskId))
if parentTaskId is None:
parentTaskId = Tasks.ROOT_TASK_ID
elif parentTaskId < Tasks.ROOT_TASK_ID:
raise Exception('Cannot create task with parentTaskId ' +
str(parentTaskId))
if prop is None:
prop = {}
deb('Tasks: addTask- creating new task with id =' + str(taskId) +
', parent task id =' + str(parentTaskId))
prop['completed'] = 0
task = Tree(id=taskId, prop=prop)
deb('Tasks: addTask- created task object. ' +
'Now inserting it into the tree')
self.taskObj.insert(task, parentTaskId)
# update the file
self.write()
# create a tasks object from a dictionary
# we expect the dictionary to be in a certain way.
# Need some checks in place to make sure that is obeyed
def dictToTask(self, inputDict):
if inputDict == {}:
raise Exception('could not read Json file, or the file was empty!')
resDict = {}
parentId = ''
for key, value in inputDict.items():
deb('dictToTask: key is = ' + str(key))
deb('dictToTask: value is = ' + str(value))
t = Tree(id=key)
# if resDict has the object already use that
if key in resDict:
t = resDict[key]
# set the other properties
t.prop = value['prop']
if str(value['parentId']) != str(key):
deb('dictToTask: ParentId = ' + str(value['parentId']) +
', key:' + str(key))
if value['parentId'] in resDict:
deb('dictToTask: key=' + str(key) +
', parentId in resDict. ParentId:' +
str(value['parentId']))
parent = resDict[value['parentId']]
t.parent = parent
parent.children.append(t)
else:
deb('dictToTask: key=' + str(key) +
', parentId not in resDict. ParentId:' +
str(value['parentId']))
pTree = Tree(value['parentId'])
t.parent = pTree
pTree.children.append(t)
resDict[value['parentId']] = pTree
else:
deb('dictToTask: found root. ParentId = ' +
str(value['parentId']) + ', key:' + str(key))
t.parent = t
parentId = value['parentId']
resDict[key] = t
if parentId == '':
raise Exception('no top level task present in the json file')
return resDict[parentId]
# read from json file.
def read(self):
if self.fileName is None:
return
data = self.fileDB.readAll()
return self.dictToTask(data)
# create an object dictionary
# similar to a serialization operation
def taskToDict(self, tasks):
if tasks is None:
return {}
deb('Tasks: createDict for taskId= ' + str(tasks.id))
resDict = {}
tasksDict = {}
tasksDict['children'] = [cObj.id for cObj in tasks.children] \
if tasks.children is not None else []
tasksDict['parentId'] = tasks.parent.id if tasks.parent is not None \
else Tasks.ROOT_TASK_ID
tasksDict['prop'] = tasks.prop
if 'completed' not in tasksDict['prop']:
tasksDict['prop']['completed'] = 0
resDict[tasks.id] = tasksDict
if tasks.children is not None:
for childObj in tasks.children:
cDict = self.taskToDict(childObj)
resDict.update(cDict)
deb('Tasks: createDict- taskId' + str(tasks.id) +
', final dictionary is:' + str(resDict))
return resDict
def write(self):
if self.fileName is None:
return
taskDict = self.taskToDict(self.taskObj)
self.fileDB.writeAll(taskDict)
#update a task
def updateTask(self,
taskId,
parentId=None,
prop=None,
updateSubtasks=False):
if taskId == Tasks.ROOT_TASK_ID:
raise Exception('Cannot update task with taskId: ' + taskId)
# raise an exception if not found
currTask = self.taskObj.find(taskId)
if currTask is None:
raise Exception('Cannot find task with task id = ' + taskId)
if self.__isArchived(currTask):
raise Exception('Cannot update archived task')
# nothing to update
if prop is None and parentId is None:
return
if parentId is not None:
deb('Tasks: updateTask- new parent id is: ' + str(parentId))
currParent = currTask.parent
deb('updateTask: current parent is:' + str(currParent.id))
if parentId != currParent.id:
if parentId == currTask.id:
newParentId = Tasks.ROOT_TASK_ID
newParent = self.taskObj.find(parentId)
if newParent is not None:
currParent.children.remove(currTask)
# we don't append in children list if the new parent is
# the current task but that condition is checked before
# we reach here so don't need an if condition
newParent.children.append(currTask)
currTask.parent = newParent
if prop is not None:
deb('Tasks - updateTask: before updating currTask prop ' +
str(currTask.prop))
if updateSubtasks:
self.__updateSubtasks(currTask, prop)
else:
currTask.prop.update(prop)
deb('Tasks - updateTask: after updating currTask prop' +
str(currTask.prop))
# update the file
self.write()
# this routine updates the task and all associated subtasks
# with the provided properties
def __updateSubtasks(self, currTask, prop):
currTask.prop.update(prop)
for ch in currTask.children:
self.__updateSubtasks(ch.id, prop)
def archiveTask(self, taskId):
task = self.taskObj.find(taskId)
if task is None:
raise Exception('Could not find task with task id :' + taskId)
if self.__isArchived(task):
return
completionDict = {
'completed': 1,
'completion_time': str(datetime.datetime.now())
}
self.__updateSubtasks(task, completionDict)
# update the file
self.write()
# is completed
def __isArchived(self, task):
if 'completed' not in task.prop:
return false
return task.prop['completed'] == 1
class TicTacToe(object):
def __init__(self):
self.tree = None
self.xplayer = False #True if human player
self.oplayer = False #True if human player
self.gameover = False
self.xturn = True #False if oturn
self.template = StateTemplate([0, 1, 2, 3, 4, 5, 6, 7, 8])
self.startState = [-1, -1, -1, -1, -1, -1, -1, -1, -1]
def setupTree(self):
'''Set up the full tree which shows all of the game states'''
self.tree = Tree()
self.tree.root.data = GameState(self.startState)
node = self.tree.root
while node is not None:
if -1 in node.data.state:
nodestate = deepcopy(node.data.state)
index = nodestate.index(-1)
node.data.state[index] = -2
node = self.tree.addNode(node)
#node = self.tree.findNode(nodeid)
if len([k for k in nodestate if k == -1 or k == -2]) % 2:
#if len(node.id) % 2 == 0:
nodestate[index] = 'X'
else:
nodestate[index] = 'O'
for i in range(len(nodestate)):
if nodestate[i] == -2:
nodestate[i] = -1
node.data = GameState(nodestate)
#node.depth = len(node.id)-1 #depth is 0-based
else:
node = node.parent
self.tree.prune(self.tree.root,
filters()) #prune the tree with the filters
def checkEndGame(self):
'''Return true if the current node has no children'''
if len(self.tree.root.children) == 0:
return True
return False
def humanFirstTurn(self):
return int(raw_input("Enter an 'X' at location: (0-8) "))
def humanTurn(self, symbol):
'''Gets called when it is a humans turn. symbol is either "X" or "O"'''
i = int(raw_input("Enter an '" + symbol + "' at location: (0-8) "))
data = self.tree.root.data.copy()
if not data.setData(symbol, i):
print("Cannot place '" + symbol + "' there. Try again")
self.humanTurn(symbol)
else:
node = self.tree.find(data)
self.tree.setRoot(node.id)
#def aiTurn(self, symbol, index):
# '''The ai at this point has chosen the best path as given by the index'''
# data = self.tree.root.data.copy() #get a copy of root GameState
# #data.setData(symbol, index)
# node = self.tree.find(data)
# self.tree.setRoot(node.id)
def makeMoveAI(self, index):
node = self.tree.root.children[index]
self.tree.setRoot(node.id)
