source: branch/logging/log.py @ 1497

'Module to provide logging services'
import wx
import GSASIIgrid as G2gd
MenuBindingLookup = {}
G2logList = [None]
'Contains a list of logged actions; first item is ignored'
LogInfo = {'Logging':False, 'Tree':None}
'Contains a dict with values that are needed in the module'

debug = True

# TODO:
### Note: no provinance info for histogram instrument parameters: need to remove insVal etc.

# track histograms and phases with relative indices

#===========================================================================
# objects for logging variables
def _l2s(lst,separator='+'):
    'Combine a list of objects into a string, with a separator'
    s = ''
    for i in lst: 
        if s != '': s += separator
        s += '"'+str(i)+'"'
    return s

class VarLogEntry(object):
    'object that tracks changes to a variable'
    def __init__(self,treeRefs,indexRefs,value):
        self.treeRefs = treeRefs
        self.indexRefs = indexRefs
        self.value = value
        if debug: print 'Logging var change: w/treeRefs',treeRefs,'indexRefs',indexRefs,'new value=',value
    def __str__(self):
        return 'Variable change: Key(s)= '+_l2s(self.indexRefs)+' to value='+str(self.value)

class MenuLogEntry(object):
    'object that tracks when a menu command is executed'
    def __init__(self,menulabellist):
        self.menulabellist = menulabellist
        if debug:
            t = menulabellist[:]
            t.reverse()
            l = ''
            for item in t:
                if l: l += ' -> '
                l += item
        if debug: print 'Logging menu command: '+l
    def __str__(self):
        return 'Menu press: From '+_l2s(self.menulabellist,'/')
            
class TabLogEntry(object):
    'Object to track when tabs are pressed in the DataFrame window'
    def __init__(self,title,tabname):
        self.wintitle = title
        self.tablabel = tabname
        if debug: print 'Logging tab: "'+tabname+'" on window titled '+title
    def __str__(self):
        return 'Tab press: Tab='+_l2s([self.tablabel])+' on window labeled '+str(self.wintitle)

class TreeLogEntry(object):
    'Object to track when tree items are pressed in the main window'
    def __init__(self,itemlist):
        self.treeItemList = itemlist
        if debug: print 'Logging press on tree: "',itemlist
    def __str__(self):
        return 'Tree item pressed: '+_l2s(self.treeItemList)
            
def _wrapper(func):
    def _wrapped(self, *args, **kwargs):
        return getattr(self.obj, func)(*args, **kwargs)
    return _wrapped

class DictMeta(type):
    def __new__(cls, name, bases, dct):
        default_attrs = dir(object) + ['__getitem__', '__str__']
        for attr in dir(dict):
            if attr not in default_attrs:
                dct[attr] = _wrapper(attr)
        return type.__new__(cls, name, bases, dct)

class dictLogged(object):
    '''A version of a dict object that tracks the source of the
    object back to the location on the G2 tree.
    If a list (tuple) or dict are pulled from inside this object
    the source information is appended to the provinance tracking
    lists.

    tuples are converted to lists.
    '''
    __metaclass__ = DictMeta

    def __init__(self, obj, treeRefs, indexRefs=[]):
        self.treeRefs = treeRefs
        self.indexRefs = indexRefs
        self.obj = obj

    def __getitem__(self,key):
        val = self.obj.__getitem__(key)   
        if type(val) is tuple:
            #if debug: print 'Converting to list',key
            val = list(val)
            self.obj[key] = val
        if type(val) is dict:
            #print 'dict'
            return dictLogged(val,self.treeRefs,self.indexRefs+[key])
        elif type(val) is list:
            #print 'list'
            return listLogged(val,self.treeRefs,self.indexRefs+[key])
        else:
            #print type(val)
            return val

    def __str__(self):
        return self.obj.__str__() + " : " + str(self.treeRefs) + ',' + str(self.indexRefs)

class ListMeta(type):
    def __new__(cls, name, bases, dct):
        default_attrs = dir(object) + ['__getitem__', '__str__']
        for attr in dir(list):
            if attr not in default_attrs:
                dct[attr] = _wrapper(attr)
        return type.__new__(cls, name, bases, dct)

class listLogged(object):
    '''A version of a list object that tracks the source of the
    object back to the location on the G2 tree.
    If a list (tuple) or dict are pulled from inside this object
    the source information is appended to the provinance tracking
    lists.
    
    tuples are converted to lists.
    '''
    __metaclass__ = ListMeta

    def __init__(self, obj, treeRefs, indexRefs=[]):
        self.treeRefs = treeRefs
        self.indexRefs = indexRefs
        self.obj = obj

    def __getitem__(self,key):
        val = self.obj.__getitem__(key)   
        if type(val) is tuple:
            #if debug: print 'Converting to list',key
            val = list(val)
            self.obj[key] = val
        if type(val) is dict:
            #print 'dict'
            return dictLogged(val,self.treeRefs,self.indexRefs+[key])
        elif type(val) is list:
            #print 'list'
            return listLogged(val,self.treeRefs,self.indexRefs+[key])
        else:
            #print type(val)
            return val

    def __str__(self):
        return self.obj.__str__() + " : " + str(self.treeRefs) + ',' + str(self.indexRefs)

#===========================================================================
class G2TreeCtrl(wx.TreeCtrl):
    '''Create a wrapper around the standard TreeCtrl so we can "wrap"
    various events.
    
    This logs when a tree item is selected (in :meth:`onSelectionChanged`)

    This also wraps lists and dicts pulled out of the tree to track where
    they were retrieved from.
    '''
    def __init__(self,parent=None,*args,**kwargs):
        super(self.__class__,self).__init__(parent=parent,*args,**kwargs)
        self.G2frame = parent.GetParent()
        self.root = self.AddRoot('Loaded Data: ')
        self.SelectionChanged = None
        self.repaintAction = None
        LogInfo['Tree'] = self

    def _getTreeItemsList(self,item):
        '''Get the full tree hierarchy from a reference to a tree item.
        Note that this effectively hard-codes phase and histogram names in the
        returned list. We may want to make these names relative in the future.
        '''
        textlist = [self.GetItemText(item)]
        parent = self.GetItemParent(item)
        while parent:
            if parent == self.root: break
            textlist.insert(0,self.GetItemText(parent))
            parent = self.GetItemParent(parent)
        return textlist

    def onSelectionChanged(self,event):
        '''Log each press on a tree item here. 
        '''
        if self.SelectionChanged:
            textlist = self._getTreeItemsList(event.GetItem())
            if LogInfo['Logging']: 
                G2logList.append(TreeLogEntry(textlist))
            self.SelectionChanged(event)

    def Bind(self,eventtype,handler,*args,**kwargs):
        '''Override the Bind() function so that page change events can be trapped
        '''
        if eventtype == wx.EVT_TREE_SEL_CHANGED:
            self.SelectionChanged = handler
            wx.TreeCtrl.Bind(self,eventtype,self.onSelectionChanged)
            return
        wx.TreeCtrl.Bind(self,eventtype,handler,*args,**kwargs)

    def GetItemPyData(self,*args,**kwargs):
        '''Override the standard method to wrap the contents
        so that the source can be tracked
        '''
        data = super(self.__class__,self).GetItemPyData(*args,**kwargs)
        textlist = self._getTreeItemsList(args[0])
        if type(data) is dict:
            return dictLogged(data,textlist)
        if type(data) is list:
            return listLogged(data,textlist)
        if type(data) is tuple: #N.B. tuples get converted to lists
            return listLogged(list(data),textlist)
        return data

    def ClearDataRepaint(self):
        self.repaintAction = None

    def RepaintDataWindow(self):
        item = self.repaintAction
        if isinstance(item,TreeLogEntry):
            self.SelectItem(self.root) # need to select something else
            self.ReplayTreePress(item)
        elif isinstance(item,TabLogEntry):
            self.ReplayTabPress(item)
            
    def ReplayLogItem(self,item):
        'Execute an action taken from a log file entry'
        if isinstance(item,MenuLogEntry):
            self.ReplayMenuCommand(item)
        elif isinstance(item,TreeLogEntry):
            self.ReplayTreePress(item)
            self.repaintAction = item
        elif isinstance(item,VarLogEntry):
            self.ReplayVariableChange(item)
        elif isinstance(item,TabLogEntry):
            self.ReplayTabPress(item)
            self.repaintAction = item
        else:
            raise Exception("Unknown object in log: "+str(type(item))+": "
                            +str(item))
        
    def ReplayTreePress(self,logitem):
        'Perform a Tree press action when read from the log'
        parent = self.root
        for txt in logitem.treeItemList:
            item = G2gd.GetPatternTreeItemId(self.G2frame,parent,txt)
            if not item:
                print 'Not found',txt
                return
            else:
                parent = item
        else:
            self.SelectItem(item)
                
    def ReplayTabPress(self,logitem):
        'Perform a Tab press action when read from the log'
        wintitle = logitem.wintitle
        tabname = logitem.tablabel
        if self.G2frame.dataFrame.GetTitle() != wintitle:
            print self.G2frame.dataFrame.GetTitle(),' != ',wintitle
            raise Exception('tab in wrong window')
        for PageNum in range(self.G2frame.dataDisplay.GetPageCount()):
            if tabname == self.G2frame.dataDisplay.GetPageText(PageNum):
                self.G2frame.dataDisplay.SetSelection(PageNum)
                return
        else:
            print tabname,'not in',[
                self.G2frame.dataDisplay.GetPageText(PageNum) for
                PageNum in range(self.G2frame.dataDisplay.GetPageCount())]
            raise Exception('tab not found')
    def ReplayVariableChange(self,logitem):
        'Perform a Variable Change action, when read from the log'
        parentId = self.root
        for treeitem in logitem.treeRefs:
            item, cookie = self.GetFirstChild(parentId)
            while item:
                if self.GetItemText(item) == treeitem:
                    parentId = item
                    break
                else:
                    item, cookie = self.GetNextChild(parentId, cookie)
            else:
                raise Exception("Tree item not found for "+str(logitem))
        # get the inner most data array
        data = super(self.__class__,self).GetItemPyData(item)
        for item in logitem.indexRefs[:-1]:
            data = data[item]
        # set the value
        data[logitem.indexRefs[-1]] = logitem.value
    def ReplayMenuCommand(self,logitem):
        'Perform a Menu item action when read from the log'
        key = ''
        for item in logitem.menulabellist:
            if key: key += '+'
            key += item
        if MenuBindingLookup.get(key):
            MenuBindingLookup[key](None)
        else:
            raise Exception('No binding for menu item '+key)        
        
#===========================================================================
# variable tracking
def LogVarChange(result,key):
    'Called when a variable is changed to log that action'
    if not LogInfo['Logging']: return
    if hasattr(result,'treeRefs'):
        lastLog = G2logList[-1]
        fullrefs = result.indexRefs+[key]
        if type(lastLog) is VarLogEntry:
            if lastLog.treeRefs == result.treeRefs and lastLog.indexRefs == fullrefs:
                lastLog.value = result[key]
                if debug: print 'update last log to ',result[key]
                return
        G2logList.append(VarLogEntry(result.treeRefs,fullrefs,result[key]))
    else:
        print key,'Error: var change has no provenance info'

#===========================================================================
# menu command tracking
def _getmenuinfo(id,G2frame,handler):
    '''Look up the menu/menu-item label tree from a menuitem's Id
    
    Note that menubars contain multiple menus which contain multiple menuitems.
    A menuitem can itself point to a menu and if so that menu can contain 
    multiple menuitems.

    Here we start with the last menuitem and look up the label for that as well
    as all parents, which will be found in parent menuitems (if any) and the menubar.
    
        menuitem    ->  menu ->  menubar
           |                          |
           |->itemlabel               |-> menulabel
           
    or

        menuitem    ->  (submenu -> menuitem)*(n times) -> menu -> menubar
           |                            |                             |
           |->itemlabel                 |-> sublabel(s)               |-> menulabel
           
    :returns: a list containing all the labels (or None)           
    '''
    # don't worry about help menuitems
    if id == wx.ID_ABOUT: return
    # get the menu item object by searching through all menubars and then its label
    for menubar in G2frame.dataMenuBars:
        menuitem = menubar.FindItemById(id)
        if menuitem:
            #print 'getmenuinfo found',id,menuitem
            break
    else:
        print '****** getmenuinfo failed for id=',id,'binding to=',handler
        #raise Exception('debug: getmenuinfo failed')
        return
    menuLabelList = [menuitem.GetItemLabel()]
    
    # get the menu where the current item is located
    menu = menuitem.GetMenu()
    while menu.GetParent(): # is this menu a submenu of a previous menu?
        parentmenu = menu.GetParent()
        # cycle through the parentmenu until we find the menu
        for i in range(parentmenu.GetMenuItemCount()):
            if parentmenu.FindItemByPosition(i).GetSubMenu()==menu:
                menuLabelList += [parentmenu.FindItemByPosition(i).GetItemLabel()]
                break
        else:
            # menu not found in menu, something is wrong
            print 'error tracing menuitem to parent menu',menuLabelList
            #raise Exception('debug1: error tracing menuitem')
            return
        menu = parentmenu

    menubar = menu.MenuBar
    for i in range(menubar.GetMenuCount()):
        if menubar.GetMenu(i) == menu:
            menuLabelList += [menubar.GetMenuLabel(i)]
            break
    else:
        # menu not found in menubar, something is wrong
        print 'error tracing menuitem to menubar',menuLabelList
        #raise Exception('debug2: error tracing menuitem')
        return
    return menuLabelList

def SaveMenuCommand(id,G2frame,handler):
    '''Creates a table of menu items and their pseudo-bindings
    '''
    menuLabelList = _getmenuinfo(id,G2frame,handler)
    if not menuLabelList: return
    key = ''
    for item in menuLabelList:
        if key: key += '+'
        key += item
    MenuBindingLookup[key] = handler
    return menuLabelList

def InvokeMenuCommand(id,G2frame,event):
    '''Called when a menu item is used to log the action as well as call the
    routine "bind"ed to that menu item
    '''
    menuLabelList = _getmenuinfo(id,G2frame,None)
    key = ''
    if menuLabelList: 
        for item in menuLabelList:
            if key: key += '+'
            key += item
    if key in MenuBindingLookup:
        if LogInfo['Logging']: 
            G2logList.append(MenuLogEntry(menuLabelList))
        MenuBindingLookup[key](event)
    else:
        print 'Error no binding for menu command',menuLabelList,'id=',id
        return

#===========================================================================
# Misc externally callable routines
def LogOn():
    'Turn On logging of actions'
    LogInfo['Logging'] = True

def LogOff():
    'Turn Off logging of actions'
    LogInfo['Logging'] = False

def ShowLogStatus():
    'Return the logging status'
    return LogInfo['Logging']

def ReplayLog(event):
    'replay the logged actions (needs to be a wx.widget)'
    LogOff() # TODO: need to update menu item as well
    LogInfo['Tree'].ClearDataRepaint()
    print 70*'='
    print 'Performing logged actions:'
    for item in G2logList:
        if item:
            print item
            LogInfo['Tree'].ReplayLogItem(item)
            wx.Yield()
    # do repaint here
    LogInfo['Tree'].RepaintDataWindow()
    print 70*'='