Dayof/test_tree_data_source.py

## test_tree_data_source.py
import toga
from collections import namedtuple

# Structure of the main data source of the tree
GRADES = namedtuple('Grades', 'cl grade')

class TreeStructure:
    def __init__(self):
        # Data source of the tree
        self.data = (
            GRADES('A', () ),
            GRADES('B', ('7.5', '6.1', '8.5') ),
            GRADES('C', ('1.4', '6.1', '2.5') ),
            GRADES('D', ('5.5', ) ),
            GRADES('E', ('2.1', '5.5') )
        )
        # Data visualization of the tree
        self._visualization = self.tree_visualization_show_grades()

    @property
    def data(self):
        """
        :returns: The data source of the tree
        :rtype:   ``tuple``
        """
        return self._data

    @data.setter
    def data(self, data):
        '''
        Set the data of the tree

        :param data: Data source of the tree
        :type  data: ``tuple``
        '''
        self._data = data
        self.update_visualization()

    def update_visualization(self, condition=False):
        '''
        Update the data visualization

        :param condition: Condition to expand a branch on the tree.
                            True to show classes that contains students who
                            passed, False to show classes that contains
                            students who failed.
        :type  condition: ``bool``
        '''
        self._visualization = self.tree_visualization_show_grades(condition)

    def tree_visualization_show_grades(self, condition=False):
        '''
        Tree visualization

        :param condition: Condition to expand a branch on the tree.
                            True to show classes that contains students who
                            passed, False to show classes that contains
                            students who failed.
        :type  condition: ``bool``

        :return: Return the data visualization of the Tree.
                    The dictionary contains items identified with the id of the
                    node and values that informs its icon's url and a bool that
                    indicates if the node is collapsed or expanded.
                    (default is True)

                    E.g. {node_id : (None, True)}
        :rtype: ``dict```
        '''
        # Icons url and nodes that will be returned
        icons, nodes = {'check': 'check.png', 'fail': 'icon.png'}, {}

        for item in self.data:
            passed, failed = False, False
            for grade in item.grade:
                # Condition to a student pass in this class
                if float(grade) >= 5.0:
                    icon, passed = icons['check'], True
                else:
                    icon, failed = icons['fail'], True

                nodes[id(item)+id(grade)] = (icon, True)

            # If the condition to expand the branch is True when there are
            #   students that has passed in the class (>=5.0) or the condition
            #   is to expand the tree when there are student that has failed
            #   (<5.0).
            if condition and passed or not condition and failed:
                nodes[id(item)] = (None, False)

        return nodes

    def roots(self):
        '''
        Top level of the tree

        :return: Return the nodes of the top level of the tree.
                    Each node information is represent with a dictionary that
                    contains the text of the node, icon's url and a bool that
                    indicates if the node is collapsed or expanded.
        :rtype:  ``list`` of ``dict``
        '''
        final_data = []

        for item in self.data:
            # Joins the node data according with the current visualization of
            #   the tree. A root node in this application doesn't have an icon.
            if id(item) in self._visualization.keys():
                data = {'text': item[0],
                        'icon': None,
                        'collapsed': self._visualization[id(item)][1]}
            else:
                data = item[0]
            final_data.append(data)
        return final_data

    # list of tuples
    def search_node(self, text, branch=None):
        for item in self.data:
            if item[0] == text:
                return self._make_data(id(item), item[1])
        return []

    def _make_data(self, node_id, children):
        '''
        Joins tha data of a node

        :param node_id: Id of the node's parent
        :type  node_id: ``int``

        :param children: Texts of the children of the node's parent
        :type  children: ``tuple``

        :return: Return the information about each child of a node's parent.
                    Each node information is represent with a tuple that
                    contains the text of the node, icon's url and a bool that
                    indicates if the node is collapsed or expanded.
        :rtype:  ``list`` of ``tuple``
        '''
        children_data = []

        for child in children:
            # Adds the node id of the node's parent with the id of the current
            #   child node, key will be the path of the child
            key = node_id+id(child)
            # Joins the child node data according with the current
            #   visualization of the tree
            if key in self._visualization.keys():
                new_data = (child, self._visualization[key][0],
                                    self._visualization[key][1])
            else:
                new_data = (child, None, True)
            children_data.append(new_data)
        return children_data

class TogaDataSource:
    '''
    Toga Data Source
    '''
    def __init__(self, data):
        '''
        Instantiate a new instance of the Toga data source

        :param data: Data source and data visualization of the tree
        :type  data: :class:`TreeStructure`
        '''
        self._source = data

    def roots(self):
        '''
        Top level of the tree

        :return: Return the nodes of the top level of the tree.
                    Each node information is represent with a dictionary that
                    contains the text of the node, icon's url and a bool that
                    indicates if the node is collapsed or expanded
                    (default is True).

                    It's possible to pass just a string data instead of the
                    dictionary if the user don't want to bother with icons
                    or if a branch of the tree is expanded.

                    E.g. [{'text': None, 'icon': None, 'collapsed': True}] or
                            ['text']
        :rtype:  ``list`` of ``dict`` or ``list`` of ``str``
        '''
        return self._source.roots()

    def children(self, node):
        '''
        Children of the node

        :param node: Parent node
        :type  node: :class:`tree.Node`

        :return: Return the information about each child of the node's parent.
                    Each node information is represent with a dictionary that
                    contains the text of the node, icon's url and a bool that
                    indicates if the node is collapsed or expanded
                    (default is True).

                    It's possible to pass just a string data instead of the
                    dictionary if the user don't want to bother with icons
                    or if a branch of the tree is expanded.

                    E.g. [{'text': None, 'icon': None, 'collapsed': True}] or
                            ['text']
        :rtype:  ``list`` of ``dict`` or ``list`` of ``str``
        '''
        # default data of a node
        data = {'text': None,
                'icon': None,
                'collapsed': True}

        # children is a list of tuples that contains text, icon and a bool that
        #   indicates if the child is collapsed
        children = self._source.search_node(node.data['text'])
        return [{k : value for (k,v), value in zip(data.items(), child)} for
        child in children]

class StartApp(toga.App):
    '''
    Main Application
    '''
    def startup(self):
        '''
        Initial method to start a Toga application inside of a class
        '''
        # Main window
        self.main_window = toga.MainWindow(self.name)
        self.main_window.app = self

        # Tree structure of this application
        self.tree_data = TreeStructure()
        # Tree widget from Toga
        self.tree = toga.Tree(['Classes and Grades'],
                            data=TogaDataSource(self.tree_data))

        # Button to add a node on the tree
        update_tree_node_button = toga.Button('Add F grades',
                                        on_press=self.callbackUpdateNode)
        # Button to update the data visualization of the tree and show who has
        #   passed
        update_tree_display_button_pass = toga.Button('Show who passed',
                                        on_press=self.callbackUpdateDisplayPass)
        # Button to update the data visualization of the tree and show who has
        #   failed
        update_tree_display_button_fail = toga.Button('Show who failed',
                                        on_press=self.callbackUpdateDisplayFail)

        # Widget to control the application using buttons
        self.control_box = toga.Box(children=[update_tree_node_button,
                                            update_tree_display_button_pass,
                                            update_tree_display_button_fail])

        # Main widget of the application, show both the Ttee data and the
        #   buttons to control thee application
        frame = toga.SplitContainer()
        frame.content = [self.tree, self.control_box]

        # Add the main widget inside of the main application
        self.main_window.content = frame
        # Show the application
        self.main_window.show()

    def callbackUpdateNode(self, event):
        # New node to be add on the data source
        self.tree_data.data += (GRADES('F', ('0.1', ) ),)
        # Update the tree
        self.tree.update()

    def callbackUpdateDisplayPass(self, event):
        # Update the data source visualization
        self.tree_data.update_visualization(True)
        # Update the tree
        self.tree.update()

    def callbackUpdateDisplayFail(self, event):
        # Update the data source visualization, default is False
        self.tree_data.update_visualization()
        # Update the tree
        self.tree.update()

def main():
    # Start the application with the title and the name of the organization
    app = StartApp('Test Tree using data source construction',
                    'org.pybee.test')
    app.main_loop()

if __name__ == '__main__':
    main()
	import toga
	from collections import namedtuple

	# Structure of the main data source of the tree
	GRADES = namedtuple('Grades', 'cl grade')

	class TreeStructure:
	def __init__(self):
	# Data source of the tree
	self.data = (
	GRADES('A', () ),
	GRADES('B', ('7.5', '6.1', '8.5') ),
	GRADES('C', ('1.4', '6.1', '2.5') ),
	GRADES('D', ('5.5', ) ),
	GRADES('E', ('2.1', '5.5') )
	)
	# Data visualization of the tree
	self._visualization = self.tree_visualization_show_grades()

	@property
	def data(self):
	"""
	:returns: The data source of the tree
	:rtype: ``tuple``
	"""
	return self._data

	@data.setter
	def data(self, data):
	'''
	Set the data of the tree

	:param data: Data source of the tree
	:type data: ``tuple``
	'''
	self._data = data
	self.update_visualization()

	def update_visualization(self, condition=False):
	'''
	Update the data visualization

	:param condition: Condition to expand a branch on the tree.
	True to show classes that contains students who
	passed, False to show classes that contains
	students who failed.
	:type condition: ``bool``
	'''
	self._visualization = self.tree_visualization_show_grades(condition)

	def tree_visualization_show_grades(self, condition=False):
	'''
	Tree visualization

	:param condition: Condition to expand a branch on the tree.
	True to show classes that contains students who
	passed, False to show classes that contains
	students who failed.
	:type condition: ``bool``

	:return: Return the data visualization of the Tree.
	The dictionary contains items identified with the id of the
	node and values that informs its icon's url and a bool that
	indicates if the node is collapsed or expanded.
	(default is True)

	E.g. {node_id : (None, True)}
	:rtype: ``dict```
	'''
	# Icons url and nodes that will be returned
	icons, nodes = {'check': 'check.png', 'fail': 'icon.png'}, {}

	for item in self.data:
	passed, failed = False, False
	for grade in item.grade:
	# Condition to a student pass in this class
	if float(grade) >= 5.0:
	icon, passed = icons['check'], True
	else:
	icon, failed = icons['fail'], True

	nodes[id(item)+id(grade)] = (icon, True)

	# If the condition to expand the branch is True when there are
	# students that has passed in the class (>=5.0) or the condition
	# is to expand the tree when there are student that has failed
	# (<5.0).
	if condition and passed or not condition and failed:
	nodes[id(item)] = (None, False)

	return nodes

	def roots(self):
	'''
	Top level of the tree

	:return: Return the nodes of the top level of the tree.
	Each node information is represent with a dictionary that
	contains the text of the node, icon's url and a bool that
	indicates if the node is collapsed or expanded.
	:rtype: ``list`` of ``dict``
	'''
	final_data = []

	for item in self.data:
	# Joins the node data according with the current visualization of
	# the tree. A root node in this application doesn't have an icon.
	if id(item) in self._visualization.keys():
	data = {'text': item[0],
	'icon': None,
	'collapsed': self._visualization[id(item)][1]}
	else:
	data = item[0]
	final_data.append(data)
	return final_data

	# list of tuples
	def search_node(self, text, branch=None):
	for item in self.data:
	if item[0] == text:
	return self._make_data(id(item), item[1])
	return []

	def _make_data(self, node_id, children):
	'''
	Joins tha data of a node

	:param node_id: Id of the node's parent
	:type node_id: ``int``

	:param children: Texts of the children of the node's parent
	:type children: ``tuple``

	:return: Return the information about each child of a node's parent.
	Each node information is represent with a tuple that
	contains the text of the node, icon's url and a bool that
	indicates if the node is collapsed or expanded.
	:rtype: ``list`` of ``tuple``
	'''
	children_data = []

	for child in children:
	# Adds the node id of the node's parent with the id of the current
	# child node, key will be the path of the child
	key = node_id+id(child)
	# Joins the child node data according with the current
	# visualization of the tree
	if key in self._visualization.keys():
	new_data = (child, self._visualization[key][0],
	self._visualization[key][1])
	else:
	new_data = (child, None, True)
	children_data.append(new_data)
	return children_data

	class TogaDataSource:
	'''
	Toga Data Source
	'''
	def __init__(self, data):
	'''
	Instantiate a new instance of the Toga data source

	:param data: Data source and data visualization of the tree
	:type data: :class:`TreeStructure`
	'''
	self._source = data

	def roots(self):
	'''
	Top level of the tree

	:return: Return the nodes of the top level of the tree.
	Each node information is represent with a dictionary that
	contains the text of the node, icon's url and a bool that
	indicates if the node is collapsed or expanded
	(default is True).

	It's possible to pass just a string data instead of the
	dictionary if the user don't want to bother with icons
	or if a branch of the tree is expanded.

	E.g. [{'text': None, 'icon': None, 'collapsed': True}] or
	['text']
	:rtype: ``list`` of ``dict`` or ``list`` of ``str``
	'''
	return self._source.roots()

	def children(self, node):
	'''
	Children of the node

	:param node: Parent node
	:type node: :class:`tree.Node`

	:return: Return the information about each child of the node's parent.
	Each node information is represent with a dictionary that
	contains the text of the node, icon's url and a bool that
	indicates if the node is collapsed or expanded
	(default is True).

	It's possible to pass just a string data instead of the
	dictionary if the user don't want to bother with icons
	or if a branch of the tree is expanded.

	E.g. [{'text': None, 'icon': None, 'collapsed': True}] or
	['text']
	:rtype: ``list`` of ``dict`` or ``list`` of ``str``
	'''
	# default data of a node
	data = {'text': None,
	'icon': None,
	'collapsed': True}

	# children is a list of tuples that contains text, icon and a bool that
	# indicates if the child is collapsed
	children = self._source.search_node(node.data['text'])
	return [{k : value for (k,v), value in zip(data.items(), child)} for
	child in children]

	class StartApp(toga.App):
	'''
	Main Application
	'''
	def startup(self):
	'''
	Initial method to start a Toga application inside of a class
	'''
	# Main window
	self.main_window = toga.MainWindow(self.name)
	self.main_window.app = self

	# Tree structure of this application
	self.tree_data = TreeStructure()
	# Tree widget from Toga
	self.tree = toga.Tree(['Classes and Grades'],
	data=TogaDataSource(self.tree_data))

	# Button to add a node on the tree
	update_tree_node_button = toga.Button('Add F grades',
	on_press=self.callbackUpdateNode)
	# Button to update the data visualization of the tree and show who has
	# passed
	update_tree_display_button_pass = toga.Button('Show who passed',
	on_press=self.callbackUpdateDisplayPass)
	# Button to update the data visualization of the tree and show who has
	# failed
	update_tree_display_button_fail = toga.Button('Show who failed',
	on_press=self.callbackUpdateDisplayFail)

	# Widget to control the application using buttons
	self.control_box = toga.Box(children=[update_tree_node_button,
	update_tree_display_button_pass,
	update_tree_display_button_fail])

	# Main widget of the application, show both the Ttee data and the
	# buttons to control thee application
	frame = toga.SplitContainer()
	frame.content = [self.tree, self.control_box]

	# Add the main widget inside of the main application
	self.main_window.content = frame
	# Show the application
	self.main_window.show()

	def callbackUpdateNode(self, event):
	# New node to be add on the data source
	self.tree_data.data += (GRADES('F', ('0.1', ) ),)
	# Update the tree
	self.tree.update()

	def callbackUpdateDisplayPass(self, event):
	# Update the data source visualization
	self.tree_data.update_visualization(True)
	# Update the tree
	self.tree.update()

	def callbackUpdateDisplayFail(self, event):
	# Update the data source visualization, default is False
	self.tree_data.update_visualization()
	# Update the tree
	self.tree.update()

	def main():
	# Start the application with the title and the name of the organization
	app = StartApp('Test Tree using data source construction',
	'org.pybee.test')
	app.main_loop()

	if __name__ == '__main__':
	main()