def test_new_tree_add_2_nodes_and_print_it(self):
t = Tree()
n = Node(title='test', id='1', parent_id='root')
t.add(n)
n = Node(title='test2', id='2', parent_id='1')
t.add(n)
print(t)
def test_new_tree_add_2_nodes_and_search_it(self):
t = Tree()
n = Node(title='test', id='1', parent_id='root')
t.add(n)
n = Node(title='test2', id='2', parent_id='1')
t.add(n)
#print(t)
result = t.search('2')
self.assertEqual(result.get_id(), '2')
def grow_trees(stream):
tree = Tree()
node_added = signal('node_added')
for parent, child, created_at in stream:
candidate = Edge(parent, child, created_at)
if tree.should_add(candidate):
tree.add(candidate)
if tree.is_root(candidate):
node_added.send('grow_trees', tree_name=tree.name, edge=candidate)
node_added.send('grow_trees', tree_name=tree.name, edge=candidate)
return tree
def _accept(self):
lhs, rhs = self.productions[0]
parse_tree = Tree()
parse_tree.data = lhs
for tree in self.trees:
parse_tree.add(tree)
self._is_accepted = True
self.trees = [parse_tree]
return self.stack.raw_stack()
def _reduce(self, look_up):
lhs, rhs = self.productions[look_up]
new_tree = Tree(lhs)
for tree in self.trees[-len(rhs):]:
new_tree.add(tree)
self.trees = self.trees[:-len(rhs)] + [new_tree]
reduced_stack = self.stack.raw_stack()[:-len(rhs) * 2]
temp_state = reduced_stack[-1]
new_state = self.gotos[temp_state][lhs]
return reduced_stack + [lhs, new_state]
class GDriveMgrHelper:
"""
Takes care of actually building a local structure that matches Google
Drive's online and downloading all the files and folders into their
correct places in the hierarchy.
It uses gdrivefunctions.py to handle the gdrive API calls and auth
"""
def __init__(self, root_dir):
""":param: root_dir = a node to build tree off of"""
# initialize directory Tree structure
self.dir_tree = Tree()
# this will be initialized in main where we get credentials and stuff
self._service = None
# where we will store all dl'd files
self.root_dir = root_dir
def set_service(self, service):
self._service = service
def get_service(self):
return self._service
def _get_files_in_folder(self, folder_id):
"""
Gets the metadata for all the children inside a Google Drive folder
:param: folder_id = the Google Drive id of a folder
:return: list of dicts that have all the file metadata
"""
children_ids = gdrive.get_children(self.get_service(), folder_id)
total = 0
files_list = []
for child_id in children_ids:
metadata = gdrive.get_file_metadata(self.get_service(), child_id)
if metadata["labels"]["trashed"]:
continue # the file was marked as trash, don't download
# add file's info as tuple to the returned list
title = metadata["title"]
mime = metadata["mimeType"]
if len(metadata["parents"]) != 0:
# parent id is in a dict inside a list
parents = metadata["parents"][0]
if parents["isRoot"]:
parent_id = "root"
else:
parent_id = parents["id"]
else:
# some files have an empty parents list
parent_id = None
files_list.append(
{"id": child_id, "mime": mime, "title": title, "parent_id": parent_id, "metadata": metadata}
)
# logging to stdout
total += 1
print("Retrieved file " + str(total) + ". " + title + " (" + mime + ")")
return files_list
def create_tree(self):
"""
Generate a Tree object using file metadata from all of the files in
Google Drive. then save it as a pickled object inside the data directory.
"""
self._rec_create_tree("root") # Google API uses "root" as id of root folder
# pickle the object to a file so we can reuse it as a template to download files
dir_tree_path = os.path.join(gdrive.DATA_DIR, "dir_tree.pickle")
with open(dir_tree_path, "wb") as f:
pickle.dump(self.dir_tree, f)
def _rec_create_tree(self, folder_id):
"""
Helper to create directory tree object
:param: folder_id = Google Drive id of a folder
"""
if folder_id is None:
return
if folder_id == "root":
print("")
print("----------------------------------------")
print(" Starting to create tree from Root")
print("----------------------------------------")
print("")
files_list = self._get_files_in_folder(folder_id) # tuple
for f in files_list:
# add the file to the folder with id 'folder_id'
new_node = Node(id=f["id"], title=f["title"], parent_id=f["parent_id"], metadata=f["metadata"])
result = self.dir_tree.add(new_node)
if result == 0:
# parent_id was None, so it shouldn't be added
continue
elif result == -1:
# parent node doesn't exist yet, so go get it
self._rec_create_tree(f["parent_id"])
# file is a folder that could have files in it...
if f["mime"] == "application/vnd.google-apps.folder":
print("")
print("----------------------------------------")
print(" New folder: " + f["title"])
print("----------------------------------------")
print("")
self._rec_create_tree(f["id"])
return
def _rec_download_files(self, node):
"""Helper function to download_files()"""
for child in node.get_children():
if child.get_mime() == "application/vnd.google-apps.folder":
try:
os.mkdir(child.get_title())
except OSError as e:
print("Error:", e)
print("Tried to create '%s'" % child.get_title())
try:
os.chdir(child.get_title())
except OSError as e:
print("Error:", e)
print("Couldn't chdir to '%s'. Skipping download of this directory." % child.get_title())
continue
self._rec_download_files(child)
elif "vnd.google-apps" in child.get_mime():
# file is a "google doc" file and can't be downloaded. Http error 400
continue
else:
try:
gdrive.download_file(self.get_service(), child.get_id(), child.get_title())
except OSError as e:
print("Error:", e)
print("Failed downloading '%s'" % child.get_title())
os.chdir("../")
def download_files(self):
"""
Uses dir_tree to create folders and download all files except Google Docs.
:return: 1 if encountered an OSError, 0 if no errors
"""
with open("dir_tree.pickle", "rb") as f:
print("loading tree...")
tree = pickle.load(f)
os.chdir(gdrive.GDRIVE_ROOT_DIR)
try:
self._rec_download_files(tree.get_root())
return 0
except OSError as e:
return 1
def update_gdrive_dir_tree(self):
pass
def push_local_file_changes_to_drive(self):
pass
class TestTreeMethods(unittest.TestCase):
def setUp(self):
self.n1 = Node(title='node1', id='1', parent_id='root')
self.n2 = Node(title='node2', id='2', parent_id='1')
self.n3 = Node(title='node3', id='3', parent_id='1')
self.n4 = Node(title='node4', id='4', parent_id='2')
self.n5 = Node(title='node5', id='5', parent_id='4')
# set up tree with multiple nodes
self.t1 = Tree()
self.t1.add(self.n1) # node1 has many children
self.t1.add(self.n2)
self.t1.add(self.n3)
self.t1.add(self.n4)
self.t1.add(self.n5)
#print("Tree before the test:")
#print(self.t1)
# set up tree with only one node besides root
self.n6 = Node('node6', '6', parent_id='root')
self.one_node_tree = Tree()
self.one_node_tree.add(self.n6)
def tearDown(self):
self.n1 = None
self.n2 = None
self.n3 = None
self.n4 = None
self.n5 = None
self.n6 = None
self.t1 = None
self.t2 = None
def test_get_root(self):
self.assertEqual(self.t1.get_root().get_id(), 'root')
def test_init_node_not_have_id_root(self):
""" test init using a node who's id is not 'root'"""
n = Node(title='foo', id=0)
t = Tree(n)
self.assertEqual(t.get_root().get_id(), 'root')
def test_init_node_has_id_of_root(self):
n = Node(title='foo', id='root')
t = Tree(n)
self.assertEqual(t.get_root().get_id(), 'root')
def test_string_empty_tree(self):
t2 = Tree(None)
self.assertEqual(t2.__str__(), '|---Google_Drive\n')
def test_string_non_empty_tree(self):
print("You can't really test this...automatically")
print(self.t1)
def test_search_for_root(self):
result = self.t1.search('root')
self.assertTrue(result.get_id() == 'root')
def test_search_for_first_node_added(self):
result = self.t1.search('1')
self.assertTrue(result.get_id() == '1')
def test_search_for_nonexisting_node_in_one_node_tree(self):
result = self.one_node_tree.search(self.n2.get_id())
self.assertTrue(result == None)
def test_new_tree_add_2_nodes_and_print_it(self):
t = Tree()
n = Node(title='test', id='1', parent_id='root')
t.add(n)
n = Node(title='test2', id='2', parent_id='1')
t.add(n)
print(t)
def test_new_tree_add_2_nodes_and_search_it(self):
t = Tree()
n = Node(title='test', id='1', parent_id='root')
t.add(n)
n = Node(title='test2', id='2', parent_id='1')
t.add(n)
#print(t)
result = t.search('2')
self.assertEqual(result.get_id(), '2')
# From here down, tests are failing
def test_search_for_nested_leaf_node(self):
result = self.t1.search(self.n5.get_id())
self.assertTrue('5' == result.get_id())
def test_search_for_node1(self):
result = self.t1.search(self.n1.get_id())
self.assertTrue(result.get_id(), '1')
def test_search_for_node2(self):
result = self.t1.search(self.n2.get_id())
self.assertTrue(result.get_id(), '2')
def test_search_for_node3(self):
result = self.t1.search(self.n3.get_id())
self.assertTrue(result.get_id(), '3')
def test_search_for_node4(self):
result = self.t1.search(self.n4.get_id())
self.assertTrue(result.get_id(), '4')
def test_search_for_node5(self):
result = self.t1.search(self.n5.get_id())
self.assertTrue(result.get_id(), '5')
def test_search_empty_tree(self):
root = None
empty_tree = Tree(root)
result = empty_tree.search(self.n1.get_id())
self.assertEqual(result, None)
def test_check_that_node_was_added(self):
n = Node('test_node', id='7', parent_id='4')
was_added = self.t1.add(n)
#print(self.t1)
self.assertEqual(was_added, 1)
def test_add_node_whose_parent_is_in_tree(self):
""" test adding node whose parent is node4 """
n = Node('test_node2', id='8', parent_id='4')
was_added = self.t1.add(n) # should be 1
#print(self.t1)
self.assertEqual(was_added, 1)
def test_add_node_whose_parent_is_not_in_tree(self):
n = Node('test_node3', id='9', parent_id='0')
was_added = self.t1.add(n) # should be -1
self.assertEqual(was_added, -1)
def test_add_node_whose_parent_is_none(self):
n = Node('test_node', id='8')
was_added = self.t1.add(n) # should be 0
self.assertEqual(was_added, 0)
def parse(input, grammar, actions, gotos):
# TODO #1: create a list of trees
trees = [] # List containing "trees", that is, the parent node of each tree
stack = []
stack.append(0)
while True:
print("stack: ", end = "")
print(stack, end = " ")
print("input: ", end = "")
print(input, end = " ")
state = stack[-1]
token = input[0]
action = actions[(state, token)]
print("action: ", end = "")
print(action)
if action is None:
return None # tree building update
# shift operation
if action[0] == 's':
input.pop(0) # Get the symbol out of the input, removing it
stack.append(token) # Add the removed symbol that was already processed in the previous loop into the stack
state = int(action[1]) # Loads the appropriate action to taken from the actions dictionary generated from the .csv table
stack.append(state)
# TODO #2: create a new tree, set data to token, and append it to the list of trees
tree = Tree() # Create new tree
tree.data = token # Parent node will be the token
trees.append(tree) # Add the tree to the list of trees we have
# reduce operation
elif action[0] == 'r':
production = grammar[int(action[1])]
lhs = getLHS(production)
rhs = getRHS(production)
for i in range(len(rhs) * 2):
stack.pop()
state = stack[-1] # State for the goto value
stack.append(lhs)
stack.append(int(gotos[(state, lhs)]))
# TODO #3: create a new tree and set data to lhs
newTree = Tree() # Create a new tree because both trees will unify under the new parent when reducing
newTree.data = lhs # Start with the tree on the left hand side
# TODO #4: get "len(rhs)" trees from the right of the list of trees and add each of them as child of the new tree you created, preserving the left-right order
for tree in trees[-len(rhs):]: # Get each tree from the list of trees and add them as a child of our tree for reduction
newTree.add(tree) # Add the tree as a child
# TODO #5: remove "len(rhs)" trees from the right of the list of trees
# Because we do not want to keep the trees that were moved to the new tree (don't want duplicates)
trees = trees[:-len(rhs)] # Remove all the trees aside from the ones moved
# TODO #6: append the new tree to the list of trees
trees.append(newTree) # Add the newly created tree to the list of trees
# not a shift or reduce operation, must be an "accept" operation
else:
production = grammar[0]
lhs = getLHS(production)
rhs = getRHS(production)
# TODO #7: same as reduce but using the 1st rule of the grammar
# Merge all of the trees from the list and put them under the start symbol
root = Tree()
root.data = lhs
for tree in trees:
root.add(tree)
# TODO #8: return the new tree
return root
class Commands:
"""Helper class, contains command for bind events, menu and buttons."""
def __init__(self, drawer):
"""Initialization commands class."""
self.drawer = drawer
self.phrases = self.drawer.phrases
self.message = Message(self.drawer)
self.notes = Notes(self.message, self.phrases)
self.config = self.drawer.config
self.config.checker(self.message, self.phrases)
self.tree = Tree()
self.actions = Actions(self.tree, self.notes)
self.set_window()
def set_window(self):
"""Set size and position window from saving data."""
self.drawer.SetPosition(self.config.get_pos())
self.drawer.SetSize(self.config.get_size())
self.drawer.Layout()
def donate(self, event):
"""Run donate hyperlink in browser."""
webbrowser.open(self.config.donate_url)
def home(self, event):
"""Run home page hyperlink in browser."""
webbrowser.open(self.phrases.about.url)
def about(self, event):
"""Run about dialog."""
About(
self.drawer,
self.phrases.about.title,
self.phrases.about.name,
version.VERSION,
self.phrases.about.author
).ShowModal()
def close(self, event):
"""Close event for button close."""
self.drawer.Close(True)
def close_window(self, event):
"""Close window event."""
if self.config.general_expand == 'true':
self.expand_tree_save()
self.notes.close()
self.config.set_pos(self.drawer.GetScreenPosition())
self.config.set_size(self.drawer.GetSize())
self.config.close()
self.drawer.Destroy()
def __sort(self, titles, parents):
"""Sort titles and parents dictionaries by order_sort field."""
sort_notes = OrderedDict()
parents_list = [0]
childs = []
while parents:
for parent in parents_list:
order_dict = self.notes.get_order(parent)
if order_dict:
order_id = [item[0] for item in sorted(list(order_dict.items()), key=lambda i: i[1])]
for index in order_id:
sort_notes[index] = (parent, titles[index])
parents.pop(index)
childs.append(copy.copy(order_id))
parents_list = childs.pop(0)
return sort_notes
def init_tree(self):
"""Initialization tree widget."""
titles = self.notes.get_titles()
parents = self.notes.get_parents()
sort_notes = self.__sort(titles, parents)
wx_tree_id = self.drawer.tree.AddRoot(self.phrases.widgets.tree.root)
self.tree.add(0, -1, wx_tree_id)
for index, note in sort_notes.items():
parent_wx_tree_id = self.tree.id2wx_tree_id(note[0])
wx_tree_id = self.drawer.tree.AppendItem(parent_wx_tree_id, note[1])
self.tree.add(index, note[0], wx_tree_id)
if self.config.general_expand == 'true':
self.expand_tree_init()
def expand_tree_init(self):
"""Init expand tree if set config settings."""
expands = self.notes.get_expands()
wx_tree_id = self.tree.id2wx_tree_id(0)
self.drawer.tree.Expand(wx_tree_id)
for index in range(1, self.tree.get_count()):
wx_tree_id = self.tree.id2wx_tree_id(index)
if expands.get(index, 0) == 1:
self.drawer.tree.Expand(wx_tree_id)
else:
self.drawer.tree.Collapse(wx_tree_id)
def expand_tree_save(self):
"""Save expand tree if set config settings."""
expands = {}
for index in range(1, self.tree.get_count()):
wx_tree_id = self.tree.id2wx_tree_id(index)
if self.drawer.tree.IsExpanded(wx_tree_id):
expands[index] = 1
else:
expands[index] = 0
self.notes.set_expands(expands)
def __set_state_order_menuitem(self, state):
"""Set state menu items order."""
self.drawer.order_up.Enable(state)
self.drawer.order_down.Enable(state)
self.drawer.order_parent_up.Enable(state)
self.drawer.order_parent_down.Enable(state)
def __set_state_sort_menuitem(self, state):
"""Set state menu items sort."""
self.drawer.sort_titles.Enable(state)
self.drawer.sort_childcount_up.Enable(state)
self.drawer.sort_childcount_down.Enable(state)
self.drawer.sort_state_up.Enable(state)
self.drawer.sort_state_down.Enable(state)
def __set_state_undo_menuitem(self):
"""Set menu items undo and redo."""
if self.actions.isUndo():
self.drawer.undo.Enable(True)
else:
self.drawer.undo.Enable(False)
if self.actions.isRedo():
self.drawer.redo.Enable(True)
else:
self.drawer.redo.Enable(False)
def __set_state_del(self, state):
"""Set state to delete button and delete menu item."""
self.drawer.but_del.Enable(state)
self.drawer.del_note.Enable(state)
def __disable_widgets(self):
"""Disable state for all widgets."""
self.__set_state_del(False)
self.drawer.data.SetValue('')
self.drawer.data.Disable()
self.drawer.readonly.Enable(False)
self.drawer.state_check.Enable(False)
self.drawer.states.Enable(False)
def __tree_select(self):
"""Change select item in tree with program select."""
index = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
if index is None:
self.__set_state_order_menuitem(False)
self.__set_state_sort_menuitem(False)
self.__disable_widgets()
self.drawer.but_create.Disable()
self.drawer.create_child.Enable(False)
self.drawer.info_date.Enable(False)
elif index == 0:
self.__set_state_order_menuitem(False)
self.__set_state_sort_menuitem(True)
self.__disable_widgets()
self.drawer.but_create.Enable(True)
self.drawer.create_child.Enable(True)
self.drawer.info_date.Enable(False)
else:
self.__set_state_order_menuitem(True)
self.__set_state_sort_menuitem(True)
self.drawer.info_date.Enable(True)
self.drawer.data.Enable()
data = self.notes.get_note(index)
self.drawer.data.SetValue(data)
self.drawer.readonly.Enable(True)
readonly = self.notes.get_readonly(index)
self.drawer.readonly.SetValue(readonly)
self.__set_state_text_note(not readonly)
self.__set_state_del(not readonly)
self.drawer.state_check.Enable(True)
state_check = self.notes.get_state_check(index)
self.drawer.state_check.SetValue(state_check)
self.drawer.states.Enable(state_check)
self.__set_state(index)
self.drawer.but_create.Enable(True)
self.drawer.create_child.Enable(True)
self.drawer.but_save.Disable()
self.drawer.save_note.Enable(False)
def tree_select(self, event):
"""Change select item in tree."""
self.__tree_select()
def tree_activated(self, event):
"""Activated edit label on tree item."""
index = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
readonly = self.drawer.readonly.GetValue()
if readonly:
if (self.config.readonly_password_check == "true") and self.__check_password():
readonly = False
if (index != 0) and (not readonly):
self.drawer.tree.EditLabel(event.GetItem())
def tree_end_edit(self, event):
"""Finish edit label item tree."""
wx_tree_id = self.drawer.tree.GetSelection()
index = self.tree.wx_tree_id2id(wx_tree_id)
title = event.GetLabel()
if title != '':
self.actions.run(SaveTitle(index, title))
self.__set_state_undo_menuitem()
def text_change(self, event):
"""Change text controls note."""
index = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
if index != 0:
self.drawer.but_save.Enable()
self.drawer.save_note.Enable(True)
def __set_state_text_note(self, state):
"""Set data text control note readonly state."""
self.drawer.data.SetEditable(state)
def __check_password(self):
"""Check state readonly password."""
result = False
dlg = PasswordEntryDialog(self.drawer, self.drawer.phrases.titles.password)
if RetCode.OK == dlg.ShowModal():
hashpass= hashlib.sha1(dlg.GetValue().encode("utf-8"))
if hashpass.hexdigest() == self.config.readonly_password:
result = True
dlg.Destroy()
return result
def __change_readonly(self, index, readonly):
"""Change readonly attribute for widgets."""
self.actions.run(SetReadonly(index, readonly))
self.__set_state_text_note(not readonly)
self.__set_state_del(not readonly)
def change_readonly(self, event):
"""Change readonly attribute for note."""
index = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
readonly = self.drawer.readonly.GetValue()
if readonly:
self.__change_readonly(index, readonly)
elif self.config.readonly_password_check != "true":
self.__change_readonly(index, readonly)
elif self.__check_password():
self.__change_readonly(index, readonly)
else:
self.drawer.readonly.SetValue(True)
self.__set_state_undo_menuitem()
def change_state(self, event):
"""Change state attribute for note."""
index = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
state_check = self.drawer.state_check.GetValue()
self.actions.run(SetStateCheck(index, state_check))
self.drawer.states.Enable(state_check)
self.__set_state_undo_menuitem()
def choice_state(self, event):
"""Set state for note."""
index = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
state = self.drawer.states.GetString(self.drawer.states.GetSelection())
self.actions.run(SetState(index, state))
self.__set_state_undo_menuitem()
def __set_state(self, index):
"""Set string in choice states."""
state = self.notes.get_state(index)
select = self.drawer.states.FindString(state)
if select == self.drawer.get_not_found():
select = 0
self.drawer.states.SetSelection(select)
def save(self, event):
"""Save data note in database."""
wx_tree_id = self.drawer.tree.GetSelection()
index = self.tree.wx_tree_id2id(wx_tree_id)
data = self.drawer.data.GetValue()
self.actions.run(SaveNote(index, data))
self.__set_state_undo_menuitem()
self.drawer.but_save.Disable()
self.drawer.save_note.Enable(False)
def delete(self, event):
"""Delete note from database."""
if self.message.question(self.phrases.titles.warning, self.phrases.questions.del_note):
index = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
parent_id = self.tree.get_parent_id(index)
self.drawer.tree.DeleteAllItems()
self.actions.run(DelNote(index))
self.__set_state_undo_menuitem()
self.tree.clear()
self.init_tree()
self.drawer.tree.SelectItem(self.tree.id2wx_tree_id(parent_id))
self.__tree_select()
def create(self, event):
"""Create new note."""
if event.GetId() == self.drawer.create_root.GetId():
parent_id = 0
else:
parent_id = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
index = self.tree.get_count()
parent_wx_tree_id = self.tree.id2wx_tree_id(parent_id)
wx_tree_id = self.drawer.tree.AppendItem(parent_wx_tree_id, self.phrases.widgets.tree.new_note)
self.drawer.tree.Expand(parent_wx_tree_id)
self.drawer.tree.SelectItem(wx_tree_id)
self.tree.add(index, parent_id, wx_tree_id)
self.actions.run(CreateNote(index, self.drawer.tree.GetItemText(wx_tree_id)))
self.__set_state_undo_menuitem()
self.__tree_select()
def insert(self, event):
"""Insert new note."""
before_item = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
if before_item != 0:
parent_id = self.tree.get_parent_id(before_item)
index = self.tree.get_count()
parent_wx_tree_id = self.tree.id2wx_tree_id(parent_id)
wx_tree_id = self.drawer.tree.AppendItem(parent_wx_tree_id, self.phrases.widgets.tree.new_note)
self.actions.run(InsertNote(index, before_item, self.drawer.tree.GetItemText(wx_tree_id)))
self.__set_state_undo_menuitem()
self.expand_tree_save()
self.tree.clear()
self.drawer.tree.DeleteAllItems()
self.init_tree()
parent_wx_tree_id = self.tree.id2wx_tree_id(parent_id)
self.drawer.tree.Expand(parent_wx_tree_id)
self.drawer.tree.SelectItem(self.tree.id2wx_tree_id(index))
self.__tree_select()
def rollback(self, event):
"""Process menu commands undo and redo."""
index = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
parent = self.tree.get_parent_id(index)
if event.GetId() == self.drawer.undo.GetId():
self.actions.undo()
elif event.GetId() == self.drawer.redo.GetId():
self.actions.redo()
self.__set_state_undo_menuitem()
self.expand_tree_save()
self.tree.clear()
self.drawer.tree.DeleteAllItems()
self.init_tree()
select = self.tree.id2wx_tree_id(index)
if select is None:
select = self.tree.id2wx_tree_id(parent)
self.drawer.tree.SelectItem(select)
self.__tree_select()
def order(self, event):
"""Order items."""
index = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
if event.GetId() == self.drawer.order_up.GetId():
self.actions.run(OrderUp(index))
elif event.GetId() == self.drawer.order_down.GetId():
self.actions.run(OrderDown(index))
elif event.GetId() == self.drawer.order_parent_up.GetId():
self.actions.run(OrderParentUp(index))
elif event.GetId() == self.drawer.order_parent_down.GetId():
self.actions.run(OrderParentDown(index))
self.__set_state_undo_menuitem()
self.expand_tree_save()
self.tree.clear()
self.drawer.tree.DeleteAllItems()
self.init_tree()
self.drawer.tree.SelectItem(self.tree.id2wx_tree_id(index))
self.__tree_select()
def sort(self, event):
"""Sort items."""
index = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
if event.GetId() == self.drawer.sort_titles.GetId():
self.actions.run(SortTitle(index))
elif event.GetId() == self.drawer.sort_childcount_up.GetId():
self.actions.run(SortChildCountUp(index))
elif event.GetId() == self.drawer.sort_childcount_down.GetId():
self.actions.run(SortChildCountDown(index))
elif event.GetId() == self.drawer.sort_state_up.GetId():
self.actions.run(SortStateUp(index))
elif event.GetId() == self.drawer.sort_state_down.GetId():
self.actions.run(SortStateDown(index))
self.__set_state_undo_menuitem()
self.expand_tree_save()
self.tree.clear()
self.drawer.tree.DeleteAllItems()
self.init_tree()
self.drawer.tree.SelectItem(self.tree.id2wx_tree_id(index))
self.__tree_select()
def count(self, event):
"""Show information of count notes."""
if event.GetId() == self.drawer.count_root.GetId():
self.message.information(self.phrases.titles.info, self.phrases.info.count.root % self.tree.get_count_childs(0))
elif event.GetId() == self.drawer.count_child.GetId():
index = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
self.message.information(self.phrases.titles.info, self.phrases.info.count.child % self.tree.get_count_childs(index))
else:
self.message.information(self.phrases.titles.info, self.phrases.info.count.total % (self.tree.get_count() - 1))
def info_date(self, event):
"""Show info of date create and date update note."""
index = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
date_create, date_update = self.notes.get_date(index)
create = self.phrases.info.date.create.format(date_create)
update = self.phrases.info.date.update.format(date_update)
self.message.information(self.phrases.titles.info, '\n'.join([create, update]))
def options(self, event):
"""Run settings dialog."""
if self.config.open_settings(self.drawer):
self.drawer.states.Set(self.config.get_states(self.phrases.widgets.states))
index = self.tree.wx_tree_id2id(self.drawer.tree.GetSelection())
self.drawer.Layout()
state = self.notes.get_state(index)
self.drawer.states.SetSelection(self.drawer.states.FindString(state))
self.message.information(self.phrases.titles.info, self.phrases.info.need_restart)
def parse(input, grammar, actions, gotos):
# create a list of trees
trees = []
stack = []
stack.append(0)
while True:
print("stack: ", end="")
print(stack, end=" ")
print("input: ", end="")
print("stack: ", end="")
print(stack, end=" ")
print("input: ", end="")
print(input, end=" ")
state = stack[-1]
token = input[0]
action = actions[(state, token)]
print("action: ", end="")
print(action)
if action is None:
if state == 1 and input[0] != "program":
print(errorMessage(7))
if state == 2 and input[0] != "var":
print(errorMessage(8))
if state == 24 and input[0] != ":=":
print(errorMessage(9))
if state == 44 and input[0] != ("+" or "-"):
print(errorMessage(9))
if state == 30 and input[0] != ("integer" or "boolean"):
print(errorMessage(10))
if state == 34 and input[0] != ("identifier" or "integer_literal"
or "true" or "false"):
print(errorMessage(11))
if state == 8 and input[0] != "$":
print(errorMessage(6))
return None
# shift operation
if action[0] == 's':
input.pop(0)
stack.append(token)
if len(action) == 3:
state = int(action[1] + action[2])
else:
state = int(action[1])
stack.append(state)
# create a new tree, set data to token, and append it to the list of trees
tree = Tree()
tree.data = token
trees.append(tree)
# reduce operation
elif action[0] == 'r':
if len(action) == 3:
production = grammar[int(action[1] + action[2])]
else:
production = grammar[int(action[1])]
lhs = getLHS(production)
rhs = getRHS(production)
for i in range(len(rhs) * 2):
stack.pop()
state = stack[-1]
stack.append(lhs)
stack.append(int(gotos[(state, lhs)]))
# create a new tree and set data to lhs
newTree = Tree()
newTree.data = lhs
# get "len(rhs)" trees from the right of the list of trees and add each of them as child of the new tree you created, preserving the left-right order
for tree in trees[-len(rhs):]:
newTree.add(tree)
# remove "len(rhs)" trees from the right of the list of trees
trees = trees[:-len(rhs)]
# append the new tree to the list of trees
trees.append(newTree)
# not a shift or reduce operation, must be an "accept" operation
else:
production = grammar[0]
lhs = getLHS(production)
rhs = getRHS(production)
# same as reduce but using the 1st rule of the grammar
root = Tree()
root.data = lhs
for tree in trees:
root.add(tree)
# return the new tree
return root
