Validation.v2.py

Go to the documentation of this file.

#!/usr/bin/python

## @package serverportfolio.Validation
# @brief For user validation before updating the data

# todo extend to console, extend to the update of list_csv/divsplit

# ScrollVerticalFrame seems to work, but consums lots of memory, even crash, maybe memory leack ?
# see simple tests in bin..scroll3.py
# not seems to good to mix grid and pack "in the same container"

import logging

import Tkinter as tk
#from Tkinter import *
#from ttk import *

## @class ValidationTkinter
# @brief Small GUI to validate the update of data
class ValidationTkinter(tk.Frame):
    
    def __init__(self, dict_input, master=None):
        tk.Frame.__init__(self, master)
        
        # default cell of the top-level windows can expend
        self.grid(sticky=tk.N+tk.S+tk.E+tk.W)
        
        # dict_interactive in input/output
        self.dict_input = dict_input
        #self.grid()
        self.createWidgets()
        
    def createWidgets(self):
        
        top=self.winfo_toplevel()
        top.columnconfigure(0, weight=1)
        #top.rowconfigure(0, weight=1)

        self.columnconfigure(0, weight=1)
        # TO not forget for each column
        #self.columnconfigure(1, weight=1)
        #self.rowconfigure(0,weight=1)
        
        # will contains the IntVars
        self.dict_choice = {}
        
        #i = 0
        labf = {}
        for key_action, value_action in self.dict_input.iteritems():
            
            # create key for each action
            #self.dict_choice[key_action] = {}
            
            # move all the rest to create_one_input_xml, makes sense
            # create a Label Frame for each action, expand horizontally
            labf[key_action] = tk.LabelFrame(self, text=key_action)
            # always add in the next row, column 0
            labf[key_action].grid( sticky=tk.E+tk.W, pady=8,padx=5 )
            
            # create key for each action
            self.dict_choice[key_action] = {}
            
            # same behaviour, if here, more logic
            i = 0
            
            # list of value
            for key_value, value_value in value_action.iteritems():

                name = key_value
                old_value = value_value['xml_value']
                new_value = value_value['new_value']
                state = value_value['repl_add']
                # can send dict_choice[key_action]
                self.create_one_input_xml(i, labf[key_action], key_action, name, old_value, new_value, state) #, self.lchoice, self.lrb)
                i += 1
        
        # 
        frame_button = tk.Frame(self)
        frame_button.grid() 
        # parent first argument
        self.validButton = tk.Button(frame_button, text='Valid', command=self.valid)          
        self.validButton.grid(column=0, row=0, sticky=tk.E, pady=5)
        
        self.quitButton = tk.Button(frame_button, text='Quit', command=self.quit)
        self.quitButton.grid(column=1, row=0, sticky=tk.W, pady=5)
        
        #for child in self.winfo_children(): child.grid_configure(padx=5, pady=5)
        
    ## @brief Check Validation is valid (all radiobuttons selected)
    def valid(self):
        #print "Validation Button"
        #print 'dict_choice ', self.dict_choice
        
        # check all values have been validated, could be common, never error in HistPrice
        for key_action, value_action in self.dict_choice.iteritems():
            for value in self.dict_choice[key_action].values():
                
                if not ((value.get() == 0) | (value.get() == 2)):
                    # make message, not all selected, continue, cancel...
                    self.popupmsg("All entries must be selected as Accepted or Rejected to continue,\nor press Quit to validate the default")
                    return
        
        # update dict_interactive, specific xml
        for key_action in self.dict_choice.keys():
            
            #while any(self.dict_choice[key_action]):
            for name in self.dict_choice[key_action].keys():
                
                   # only one element
                   value = self.dict_choice[key_action][name]
                   #print "key, value ", value
                   self.dict_input[key_action][name]['repl_add'] = value.get()
                   
        # quit application    
        self.quit()
              
    def create_one_input_xml(self, i, labframe, action, name, old_value, new_value, state): 
        
        var = tk.IntVar()
        var.set( state )
        
        # consider name is unique here, but still tricky to get the data
        self.dict_choice[action][name] = var
        
        # this column, after new value, only can expad, looks ok, radio button always on the right
        # minsize ok for initial, but bad when minimised
        labframe.columnconfigure(2, weight=1,minsize=100 )
        tk.Label( labframe, text=name).grid(column=0, row=i, sticky=tk.W, padx=5, pady=2)
        tk.Label( labframe, text=str(old_value)).grid(column=1, row=i, sticky=tk.W, padx=5, pady=2)
        # option Label width=50 makes text center
        tk.Label( labframe, text=str(new_value)).grid(column=2, row=i, sticky=tk.W, padx=5, pady=2)
        # radio button
        tk.Radiobutton( labframe, text='Rej.', variable=var, value=0).grid(column=3, row=i, sticky=tk.E)
        tk.Radiobutton( labframe, text='Acc.', variable=var, value=2).grid(column=4, row=i, sticky=tk.E)


    def popupmsg(self,msg):
        
        popup = tk.Toplevel(takefocus=True)
        popup.title('Message')
        tk.Label( popup, text=msg).grid( padx=10, pady=10)
        tk.Button(popup, text='Ok', command=popup.quit).grid( pady=10 )
        
# to combine later, maybe base class and derived ones...
# or one class, and in a specific LabelFrame can be deal with both

# http://tkinter.unpythonic.net/wiki/VerticalScrolledFrame

class VerticalScrolledFrame(tk.Frame):
    """A pure Tkinter scrollable frame that actually works!
    * Use the 'interior' attribute to place widgets inside the scrollable frame
    * Construct and pack/place/grid normally
    * This frame only allows vertical scrolling

    """
    def __init__(self, parent, *args, **kw):
        tk.Frame.__init__(self, parent, *args, **kw)            

        # needed if grid is used
        self.columnconfigure(0, weight=1)
        
        # create a canvas object and a vertical scrollbar for scrolling it
        vscrollbar = tk.Scrollbar(self, orient=tk.VERTICAL)
        #vscrollbar.pack(fill=Y, side=RIGHT, expand=FALSE)
        vscrollbar.grid(column=1, row=0, sticky=tk.E+tk.N+tk.S)
        
        canvas = tk.Canvas(self, bd=0, highlightthickness=0, yscrollcommand=vscrollbar.set)
        #canvas.pack(side=LEFT, fill=BOTH, expand=TRUE)
        canvas.grid(column=0, row=0, sticky=tk.W+tk.E)
        
        vscrollbar.config(command=canvas.yview)
        
        # reset the view
        canvas.xview_moveto(0)
        canvas.yview_moveto(0)

        # create a frame inside the canvas which will be scrolled with it
        self.interior = interior = tk.Frame(canvas)
        #self.interior.grid()
        interior_id = canvas.create_window(0, 0, window=interior, anchor=tk.NW)
        #interior_id = canvas.create_window(4, 4, window=interior, anchor=tk.NW)

        # track changes to the canvas and frame width and sync them,
        # also updating the scrollbar
        def _configure_interior(event):
            # update the scrollbars to match the size of the inner frame
            size = (interior.winfo_reqwidth(), interior.winfo_reqheight())
            canvas.config(scrollregion="0 0 %s %s" % size)
            if interior.winfo_reqwidth() != canvas.winfo_width():
                # update the canvas's width to fit the inner frame
                canvas.config(width=interior.winfo_reqwidth())
        interior.bind('<Configure>', _configure_interior)

        def _configure_canvas(event):
            if interior.winfo_reqwidth() != canvas.winfo_width():
                # update the inner frame's width to fill the canvas
                canvas.itemconfigure(interior_id, width=canvas.winfo_width())
        canvas.bind('<Configure>', _configure_canvas)

## @class ValidationTkHP
# @brief Small GUI, specific for dealing with list_csv
class ValidationTkHP(tk.Frame):
    
    def __init__(self, dict_input, master=None):
        tk.Frame.__init__(self, master)
        
        self.logger = logging.getLogger('SP.ValidationtTkHP')
        # default cell of the top-level windows can expend
        self.grid(sticky=tk.N+tk.S+tk.E+tk.W)
        
        # dict_interactive in input/output
        self.dict_input = dict_input
        self.logger.debug("init ValidationTkHP")
        
        self.createWidgets()
        
    def createWidgets(self):
        # to make resizable frame, columnconfigure must be called/ same with rowconfigure
        top=self.winfo_toplevel()
        # make column 0 resizable
        top.columnconfigure(0, weight=1)
        # only colomn 0, here need more
        
        self.columnconfigure(0, weight=1)
        #self.quit.grid( 0,0 sticky=tk.N+tk.S+tk.E+tk.W)
        # will contains the IntVars, common with XML
        self.dict_choice = {}
        
        
        #i = 0
        # a priori only one label with csv, maybe DivSplit can be combined later
        self.labf = {}
        #self.dict_label_frame = {}
        
        for key_action, value_action in self.dict_input.iteritems():
            
            # create key
            self.dict_choice[key_action] = {}
            
            label_frame = tk.LabelFrame(self, text=key_action)
            # allow the scrollbar to stay on the rigth
            label_frame.columnconfigure(0, weight=1)
            label_frame.grid(sticky=tk.E+tk.W, pady=8,padx=5) 
            
            # here common
            # create a Label Frame for each action, parent is self (tk.Frame)
            #labf[key_action] = tk.LabelFrame(self, text=key_action) #.grid()
            # always add in the next row, column 0
            #labf[key_action].grid( sticky=tk.E+tk.W, pady=8,padx=5 )
            
            self.labf[key_action] = VerticalScrolledFrame(label_frame) #self)
            # grid or pack working ? both like said
            self.labf[key_action].grid(sticky=tk.E+tk.W)
            
            #self.label = Label(self, text="Shrink the window to activate the scrollbar.")
            #self.label.grid() #pack()
            
            #buttons = []
            #for i in range(50):
            #    buttons.append(Button(self.labf[key_action].interior, text="Button " + str(i)))
            #    buttons[-1].grid() #pack()
                
#             
            i = 0
            # list of value, integer number, value == [ error: ['error_str',[list_values]], repl_add : intger
            for key_value, value_value in value_action.iteritems():
                 
                print "key_value/ value_value ", key_value, value_value
 
                #name = key_value, only an integer
                #old_value = value_value['xml_value']
                #new_value = value_value['new_value']
                label_values = ' '.join(str(value) for value in value_value['error'][1])
                #print "label_values ", label_values
                label_error = value_value['error'][0]
                 
                # most important
                state = value_value['repl_add']
                                                        # or send self.dict_choice[action][name] ??
                #self.createOneInput(i, labf[key_action], key_action, name, old_value, new_value, state) #, self.lchoice, self.lrb)
                self.create_one_input_csv( i, self.labf[key_action], key_action, label_values, label_error, state )
                i += 1
                # if list long enought it is ok
                #self.create_one_input_csv( i, self.labf[key_action], key_action, label_values, label_error, state )
                #i += 1
                #self.create_one_input_csv( i, self.labf[key_action], key_action, label_values, label_error, state )
                #i += 1
                
            # change nothing, still long to load
            #self.labf[key_action].grid(sticky=tk.E+tk.W)
                
        # this is similar with Valid XML
        # to make a specific Frame to contain these buttons 
        # parent first argument, should combine with .grid()
        frame_button = tk.Frame(self)
        self.validButton = tk.Button(frame_button, text='Valid', command=self.valid)
        # to make it print            
        #self.validButton.grid(column=1, row=i+2, sticky=tk.E+tk.W) #sticky=tk.N+tk.S+tk.E+tk.W)
        self.validButton.grid(column=0, row = 0)
        self.quitButton = tk.Button(frame_button, text='Quit', command=self.quit)
        # to make it print            
        self.quitButton.grid(column=1, row=0, sticky=tk.N+tk.S+tk.E+tk.W )
        
        # strange not call to frame_button.grid( column=0, row =count_action) ??
        frame_button.grid()
        
        
        # need sticky for each ??
        #for child in self.winfo_children(): child.grid_configure(padx=5, pady=5)
        
    ## @brief Check Validation is valid (all radiobuttons selected)
    def valid(self):
        #print "Validation Button"
        print 'dict_choice ', self.dict_choice
        
        # check all values have been correctly selected
        # key is an integer here
        for key_action, value_action in self.dict_choice.iteritems():
            
            for value in self.dict_choice[key_action].values():
                
                if not ((value.get() == 0) | (value.get() == 2)):
                    # make message, not all selected, continue, cancel...
                    return
        
        # modify repl_add, similar to XML
        print "Ok, all selected, Apply the selection"
        for key_action in self.dict_choice.keys():
            
            for name in self.dict_choice[key_action].keys():
                
                   # only one element
                   value = self.dict_choice[key_action][name]
                   print "name, value ", name, value, value.get() 
                   self.dict_input[key_action][name]['repl_add'] = value.get()
                   
        # quit application    
        self.quit()
            
    # label different
    def create_one_input_csv(self, i, labframe, action, label_values, label_error, state): 
        
        var = tk.IntVar()
        var.set( state )
        
        # consider name is unique here, but still tricky to get the data
        #self.dict_choice[action][name] = var
        self.dict_choice[action][i] = var
        
        if state == 0:
            color_lab = 'red'
        else:
            color_lab = 'black'
        
        # need interior here, or assign before ??
        labframe.interior.columnconfigure(1, weight=1,minsize=100 )
        label1 =  tk.Label( labframe.interior, text=label_values, fg=color_lab).grid(column=0, row=i+1, sticky=tk.W )#, sticky=tk.N+tk.S+tk.E+tk.W ) # sticky=tk.N+tk.S+tk.E+tk.W how to strech
        label2 = tk.Label( labframe.interior, text=label_error, fg=color_lab).grid(column=1, row=i+1, sticky=tk.W ) 
        #label1 = tk.Label( labframe, text=str(old_value)).grid(column=2, row=i+1)
        #label2 = tk.Label( labframe, text=str(new_value)).grid(column=3, row=i+1)
        
        # radio button, common to all as well
        rb1 = tk.Radiobutton( labframe.interior, text='Rej.', variable=var, value=0).grid(column=3, row=i+1, sticky=tk.N+tk.S+tk.E+tk.W)
        rb2 = tk.Radiobutton( labframe.interior, text='Acc..', variable=var, value=2).grid(column=4, row=i+1, sticky=tk.N+tk.S+tk.E+tk.W)

        
if  __name__ == "__main__":
    
#     test = {
#         'Info': {'Sector': {'xml_value': None, 'new_value': 'Utilities', 'date': '2015-03-03', 'source': 'YQL', 'repl_add': 0}, 
#                  'StockExchange': {'xml_value': None, 'new_value': 'Paris', 'date': '2015-03-03', 'source': 'YQL', 'repl_add': 2} 
#                 },
#         'Other': {'Industry': {'xml_value': None, 'new_value': 'Diversified Utilities', 'date': '2015-03-03', 'source': 'YQL', 'repl_add': 2}, 
#                    'Name': {'xml_value': None, 'new_value': 'GDF SUEZ', 'date': '2015-03-03', 'source': 'YQL', 'repl_add': 1} 
#                 }
#           }
#     # ValidationTkXML
#     app = ValidationTkinter( test )
    
    test = {
        'HistPrice': {0: {'repl_add': 0, 'error': ['volume 0', [1425510000, 4929.04, 4974.64, 4926.09, 4963.51, 0.0]]}, 1: {'repl_add': 0, 'error': ['volume 0', [1425423600, 4882.94, 4917.35, 4856.14, 4917.35, 0.0]]}, 2: {'repl_add': 2, 'error': ['', [1425337200, 4922.43, 4936.47, 4863.92, 4869.25, 116619800.0]]}, 3: {'repl_add': 2, 'error': ['', [1425250800, 4937.43, 4950.59, 4900.11, 4917.32, 149942900.0]]}, 4: {'repl_add': 2, 'error': ['', [1424991600, 4905.77, 4951.48, 4903.09, 4951.48, 120717900.0]]}, 5: {'repl_add': 2, 'error': ['', [1424905200, 4884.89, 4910.62, 4877.24, 4910.62, 105228900.0]]}, 6: {'repl_add': 2, 'error': ['', [1424818800, 4885.0, 4894.6, 4863.22, 4882.22, 117214700.0]]}, 7: {'repl_add': 2, 'error': ['', [1424732400, 4865.68, 4899.52, 4843.96, 4886.44, 106329800.0]]}, 8: {'repl_add': 2, 'error': ['', [1424646000, 4872.13, 4875.97, 4832.36, 4862.3, 102128000.0]]}, 9: {'repl_add': 2, 'error': ['', [1424386800, 4821.38, 4837.93, 4780.81, 4830.9, 140055500.0]]}, 10: {'repl_add': 0, 'error': ['volume 0', [1424300400, 4788.4, 4841.69, 4770.17, 4833.28, 0.0]]}},
        'Div': {0: {'repl_add': 0, 'error': ['volume 0', [1425510000, 4929.04, 4974.64, 4926.09, 4963.51, 0.0]]}, 1: {'repl_add': 0, 'error': ['volume 0', [1425423600, 4882.94, 4917.35, 4856.14, 4917.35, 0.0]]}, 2: {'repl_add': 2, 'error': ['', [1425337200, 4922.43, 4936.47, 4863.92, 4869.25, 116619800.0]]}, 3: {'repl_add': 2, 'error': ['', [1425250800, 4937.43, 4950.59, 4900.11, 4917.32, 149942900.0]]}, 4: {'repl_add': 2, 'error': ['', [1424991600, 4905.77, 4951.48, 4903.09, 4951.48, 120717900.0]]}, 5: {'repl_add': 2, 'error': ['', [1424905200, 4884.89, 4910.62, 4877.24, 4910.62, 105228900.0]]}, 6: {'repl_add': 2, 'error': ['', [1424818800, 4885.0, 4894.6, 4863.22, 4882.22, 117214700.0]]}, 7: {'repl_add': 2, 'error': ['', [1424732400, 4865.68, 4899.52, 4843.96, 4886.44, 106329800.0]]}, 8: {'repl_add': 2, 'error': ['', [1424646000, 4872.13, 4875.97, 4832.36, 4862.3, 102128000.0]]}, 9: {'repl_add': 2, 'error': ['', [1424386800, 4821.38, 4837.93, 4780.81, 4830.9, 140055500.0]]}, 10: {'repl_add': 0, 'error': ['volume 0', [1424300400, 4788.4, 4841.69, 4770.17, 4833.28, 0.0]]}}
    }
    
    test = {
         'HistPrice': {0: {'first_date': '2015-03-06 00:00:00', 'repl_add': 2, 'first_values': [1425596400, 19.14, 19.16, 18.86, 18.9, 6016200.0], 'last_date': '2015-02-02 00:00:00', 'error': '', 'last_values': [1422831600, 19.72, 19.88, 19.59, 19.83, 4641200.0]}},
         'Div': {0: {'first_date': '2015-03-06 00:00:00', 'repl_add': 2, 'first_values': [1425596400, 19.14, 19.16, 18.86, 18.9, 6016200.0], 'last_date': '2015-02-02 00:00:00', 'error': '', 'last_values': [1422831600, 19.72, 19.88, 19.59, 19.83, 4641200.0]}}
    }
    
    app = ValidationTkHP( test )                       
    app.master.title('Manual Validation')
    app.mainloop()
    
    # test modified with new values of repl_add
    print "\n== Test Output ", test