#!/usr/bin/env python3 # -*- coding: utf-8 -*- # ----------------------------------------------------------------------------- # Liblarch - a library to handle directed acyclic graphs # Copyright (c) 2011-2012 - Lionel Dricot & Izidor MatuĊĦov # # This program is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see . # ----------------------------------------------------------------------------- from random import randint, choice, shuffle from time import sleep, time import logging import os import re import sys import threading from liblarch import Tree from liblarch import TreeNode from liblarch_gtk import TreeView from gi.repository import Gtk from gi.repository import GObject # Set up logging logging.basicConfig(level=logging.INFO) # Constants LOAD_MANY_TASKS_COUNT = 1000 ADD_MANY_TASKS_TO_EXISTING_TASKS = True SLEEP_BETWEEN_TASKS = 0 # Useful for experimenting with the tree BACKUP_OPERATIONS = False def random_task_title_on_id(t_id): try: return 'Task %5d' % int(t_id) except ValueError: return 'Task %5s' % t_id # Generate title in different ways random_task_title = random_task_title_on_id MAX_FILE_ID = 0 def save_backup(function): def _save_backup(*args, **kwargs): global MAX_FILE_ID self = args[0] file_name = "operation_%03d.bak" % MAX_FILE_ID while os.path.exists(file_name): MAX_FILE_ID += 1 file_name = "operation_%03d.bak" % MAX_FILE_ID stdout = sys.stdout stderr = sys.stderr output = open(file_name, "w", 0) sys.stdout = output sys.stderr = output print("Tree before operation") self.print_tree() print("\nOperation '%s':" % (function.__name__)) res = function(*args, **kwargs) print("Tree after operation") self.print_tree() sys.stdout = stdout sys.stderr = stderr output.close() # Print the log output = open(file_name, "r") print(output.read()) output.close() return res if BACKUP_OPERATIONS: return _save_backup else: return function MAX_ID = 0 def random_id(): global MAX_ID MAX_ID += 1 return str(MAX_ID) class TaskNode(TreeNode): def __init__(self, tid, label, viewtree): TreeNode.__init__(self, tid) self.label = label self.tid = tid self.vt = viewtree def get_label(self): return "%s (%s children)" % ( self.label, self.vt.node_n_children(self.tid, recursive=True)) class Backend(threading.Thread): def __init__(self, backend_id, finish_event, delay, tree, viewtree): super().__init__() self.backend_id = backend_id self.delay = delay self.tree = tree self.viewtree = viewtree self.finish_event = finish_event def run(self): counter = 0 parent_id = None while not self.finish_event.wait(self.delay): task_id = self.backend_id + "_" + str(counter) title = task_id node = TaskNode(task_id, title, self.viewtree) self.tree.add_node(node, parent_id, self.tree) parent_id = task_id # Delete some tasks for i in range(randint(3, 10)): delete_id = "{}sec_{}".format( choice([1, 3, 5]), randint(0, 2 * counter)) logging.info("%s deleting %s", self.backend_id, delete_id) self.tree.del_node(delete_id) counter += 1 logging.info("%s --- finish", self.backend_id) class LiblarchDemo(object): """ Shows a simple GUI demo of liblarch usage with several functions for adding tasks """ def _build_tree_view(self): self.tree = Tree() self.tree.add_filter("even", self.even_filter) self.tree.add_filter("odd", self.odd_filter) self.tree.add_filter("flat", self.flat_filter, {"flat": True}) self.tree.add_filter("leaf", self.leaf_filter) self.view_tree = self.tree.get_viewtree() self.mod_counter = 0 self.view_tree.register_cllbck( 'node-added-inview', self._update_title) self.view_tree.register_cllbck( 'node-modified-inview', self._modified_count) self.view_tree.register_cllbck( 'node-deleted-inview', self._update_title) desc = {} col_name = 'label' col = {} col['title'] = "Title" col['value'] = [str, self.task_label_column] col['expandable'] = True col['resizable'] = True col['sorting'] = 'label' col['order'] = 0 desc[col_name] = col tree_view = TreeView(self.view_tree, desc) # Polish TreeView def on_row_activate(sender, a, b): logging.info( "Selected nodes are: %s", str(tree_view.get_selected_nodes())) tree_view.set_dnd_name('liblarch-demo/liblarch_widget') tree_view.set_multiple_selection(True) tree_view.set_property("enable-tree-lines", True) tree_view.connect('row-activated', on_row_activate) return tree_view def even_filter(self, node): if node.get_id().isdigit(): return int(node.get_id()) % 2 == 0 else: return False def odd_filter(self, node): return not self.even_filter(node) def flat_filter(self, node, parameters=None): return True def leaf_filter(self, node): return not node.has_child() def _modified_count(self, nid, path): logging.debug("Node %s has been modified", nid) self.mod_counter += 1 def _update_title(self, sender, nid): count = self.view_tree.get_n_nodes() if count == LOAD_MANY_TASKS_COUNT and self.start_time > 0: stop_time = time() - self.start_time logging.info( "Time to load %s tasks: %s", LOAD_MANY_TASKS_COUNT, stop_time) mean = self.mod_counter * 1.0 / count logging.info( "%s modified signals were received (%s per task)", self.mod_counter, mean) self.window.set_title('Liblarch demo: %s nodes' % count) def __init__(self): self.window = Gtk.Window() self.window.set_size_request(640, 480) self.window.set_position(Gtk.WindowPosition.CENTER) self.window.set_border_width(10) self.window.set_title('Liblarch demo') self.window.connect('destroy', self.finish) self.liblarch_widget = self._build_tree_view() scrolled_window = Gtk.ScrolledWindow() scrolled_window.add_with_viewport(self.liblarch_widget) self.start_time = 0 # Buttons action_panel = Gtk.Box() action_panel.set_spacing(5) button_desc = [ ('_Add a Task', self.add_task), ('_Delete a Task', self.delete_task), ('_Print Tree', self.print_tree), ('_Print FT', self.print_ft), ('_Load many Tasks', self.many_tasks), ('_Quit', self.finish), ] for name, callback in button_desc: button = Gtk.Button.new_with_mnemonic(name) button.connect('clicked', callback) action_panel.pack_start(button, True, True, 0) filter_panel = Gtk.Box() filter_panel.set_spacing(5) for name in self.tree.list_filters(): button = Gtk.ToggleButton("%s filter" % name) button.connect('toggled', self.apply_filter, name) filter_panel.pack_start(button, True, True, 0) # Use cases usecases_vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) usecase_box = None usecase_order = 0 usecase_order_max = 3 button_desc = [ ('_Tree high 3', self.tree_high_3), ('Tree high 3 backwards', self.tree_high_3_backwards), ('Load from file', self.load_from_file), ('Delete DFXBCAE', self.delete_magic), ('Delete backwards', self.delete_backwards), ('Delete randomly', self.delete_random), ('Change task', self.change_task), ('_Backend use case', self.backends), ] for name, callback in button_desc: if usecase_order <= 0: if usecase_box is not None: usecases_vbox.pack_start( usecase_box, expand=False, fill=True, padding=0) usecase_box = Gtk.Box() usecase_box.set_spacing(5) button = Gtk.Button.new_with_mnemonic(name) button.connect('clicked', callback) usecase_box.pack_start(button, True, True, 0) usecase_order = (usecase_order + 1) % usecase_order_max usecases_vbox.pack_start( usecase_box, expand=False, fill=True, padding=0) usecase_panel = Gtk.Expander() usecase_panel.set_label('Use cases') usecase_panel.set_expanded(True) usecase_panel.add(usecases_vbox) # Show it vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) vbox.pack_start(action_panel, False, True, 10) vbox.pack_start(filter_panel, False, True, 10) vbox.pack_start(scrolled_window, True, True, 0) vbox.pack_start(usecase_panel, False, True, 10) self.window.add(vbox) self.window.show_all() self.should_finish = threading.Event() def task_label_column(self, node): newlabel = node.get_label() return newlabel def print_tree(self, widget=None): print() print("=" * 20, "Tree", "=" * 20) self.tree.get_main_view().print_tree() print("=" * 46) print() def print_ft(self, widget=None): print() self.view_tree.print_tree() print() @save_backup def add_task(self, widget): """ Add a new task. If a task is selected, the new task is added as its child """ selected = self.liblarch_widget.get_selected_nodes() t_id = random_id() t_title = random_task_title(t_id) task = TaskNode(t_id, t_title, self.view_tree) if len(selected) == 1: # Adding a subchild parent = selected[0] self.tree.add_node(task, parent_id=parent) logging.info( 'Added sub-task "%s" (%s) for %s', t_title, t_id, parent) else: # Adding as a new child self.tree.add_node(task) for parent_id in selected: task.add_parent(parent_id) logging.info('Added task "%s" (%s)', t_title, t_id) def apply_filter(self, widget, param): logging.info("applying filter: %s", param) if param in self.view_tree.list_applied_filters(): self.view_tree.unapply_filter(param) else: self.view_tree.apply_filter(param) @save_backup def tree_high_3(self, widget): ''' We add the leaf nodes before the root, in order to test if it works fine even in this configuration''' logging.info('Adding a tree of height 3') selected = self.liblarch_widget.get_selected_nodes() if len(selected) == 1: parent = selected[0] else: parent = None t_id = random_id() t_title = random_task_title(t_id) roottask = TaskNode(t_id, t_title, self.view_tree) local_parent = t_id for i in range(2): t_id = random_id() t_title = random_task_title(t_id) task = TaskNode(t_id, t_title, self.view_tree) self.tree.add_node(task, parent_id=local_parent) # Task becomes a parent for new task local_parent = t_id self.tree.add_node(roottask, parent_id=parent) @save_backup def tree_high_3_backwards(self, widget): logging.info('Adding a tree of height 3 backwards') selected = self.liblarch_widget.get_selected_nodes() if len(selected) == 1: parent = selected[0] else: parent = None tasks = [] relationships = [] for i in range(3): t_id = random_id() t_title = random_task_title(t_id) task = TaskNode(t_id, t_title, self.view_tree) tasks.append((t_id, task)) if parent is not None: relationships.append((parent, t_id)) parent = t_id # Relationships can come in any order, e.g. reversed relationships = reversed(relationships) for t_id, task in tasks: logging.info("Adding task to tree: %s %s", t_id, task) self.tree.add_node(task) logging.info("=" * 50) for parent, child in relationships: logging.info("New relationship: %s with %s", parent, child) parent_node = self.tree.get_node(parent) parent_node.add_child(child) logging.info("=" * 50) @save_backup def delete_task(self, widget, order='normal'): logging.info('Deleting a task, order: %s', order) selected = self.liblarch_widget.get_selected_nodes() if order == 'normal': ordered_nodes = selected elif order == 'backward': ordered_nodes = reversed(selected) elif order == 'random': ordered_nodes = selected shuffle(ordered_nodes) # Replace iterator for a list => we want to see the order in logs # and the performance is not important ordered_nodes = [node for node in ordered_nodes] elif order == 'magic-combination': # testing a special case from examples/test_suite ordered_nodes = ['D', 'F', 'X', 'B', 'C', 'A', 'E'] else: logging.error('Unknown order, skipping...') return logging.info( "Tasks should be removed in this order: %s", ordered_nodes) for node_id in ordered_nodes: self.tree.del_node(node_id) logging.info('Removed node %s', node_id) self.print_tree(None) def delete_backwards(self, widget): """ Delete task backward """ self.delete_task(widget, order='backward') def delete_random(self, widget): """ Delete tasks in random order """ self.delete_task(widget, order='random') def delete_magic(self, widget): self.delete_task(widget, order='magic-combination') def change_task(self, widget): for node_id in self.liblarch_widget.get_selected_nodes(): node = self.tree.get_node(node_id) node.label = "Hello" node.modified() def backends(self, widget): logging.info("Backends....") Backend( '1sec', self.should_finish, 1, self.tree, self.view_tree).start() Backend( '3sec', self.should_finish, 3, self.tree, self.view_tree).start() Backend( '5sec', self.should_finish, 5, self.tree, self.view_tree).start() widget.set_sensitive(False) def many_tasks(self, widget): self.start_time = time() def _many_tasks(): tasks_ids = [] prefix = randint(1, 1000) * 100000 for i in range(LOAD_MANY_TASKS_COUNT): t_id = str(prefix + i) t_title = t_id task = TaskNode(t_id, t_title, self.view_tree) # There is 25 % chance to adding as a sub_task if tasks_ids != [] and randint(0, 100) < 90: parent = choice(tasks_ids) self.tree.add_node(task, parent_id=parent) else: self.tree.add_node(task) tasks_ids.append(t_id) # Sleep 0.01 second to create illusion of real tasks sleep(SLEEP_BETWEEN_TASKS) logging.info("end of _many_tasks thread") t = threading.Thread(target=_many_tasks) t.start() def load_from_file(self, widget): dialog = Gtk.FileChooserDialog( "Open..", self.window, Gtk.FileChooserAction.OPEN, (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK)) dialog.set_default_response(Gtk.ResponseType.OK) response = dialog.run() if response == Gtk.ResponseType.OK: file_name = dialog.get_filename() else: file_name = None dialog.destroy() if file_name is None: return log = open(file_name, 'r').read() m = re.match( r'\s*Tree before operation\s+=+\s+Tree\s+=+\s+(.*?)=+', log, re.UNICODE | re.DOTALL) if m: treelines = m.group(1) items = [(len(line) - len(line.lstrip()), line.strip()) for line in treelines.splitlines()] # Filter "root" item and decrease level items = [(level, name) for level, name in items[1:]] # The "root" items should be at level 0, adjust level to that min_level = min(level for level, name in items) items = [(level - min_level, name) for level, name in items] nodes = list(set([name for level, name in items])) relationships = [] parent_level = {-1: None} for level, name in items: parent = parent_level[level - 1] relationships.append((parent, name)) for key in list(parent_level.keys()): if key > level: del parent_level[key] parent_level[level] = name logging.info("Nodes to add:", nodes) logging.info("Relationships:", "\n".join(str(r) for r in relationships)) for node_id in nodes: task = TaskNode( node_id, random_task_title(node_id), self.view_tree) self.tree.add_node(task) for parent, child in relationships: parent_node = self.tree.get_node(parent) parent_node.add_child(child) else: logging.info("Not matched") logging.info("Log: %s", log) def finish(self, widget): self.should_finish.set() Gtk.main_quit() def run(self): Gtk.main() if __name__ == "__main__": GObject.threads_init() app = LiblarchDemo() app.run() # vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4