userAppBrowser.py

__version__  = "$Revision: 2.10 $"

import os
import sys
import imp
import fnmatch
import logging
import traceback
from types import ModuleType

from qt import QScrollView, QVBox, QApplication, QString, SIGNAL, SLOT, QObject

from userAppBrowserGui import userAppBrowserGui
from userAppTree import userAppTree

class userModule(object):
  Param = ('.py', 'r', imp.PY_SOURCE)
  SysModules = sys.modules.keys()

  def __init__(self, root, packagename, groupname, appname):
    self.module = None
    self.__deps = []
    self.__root = root
    self.__packagename = packagename
    self.__groupname = groupname
    self.__appname  = appname
    self.__import()

  def __import(self):
    root = self.__root
    packagename = self.__packagename
    groupname = self.__groupname
    appname = self.__appname
    appfile = os.path.join(root, packagename, groupname, appname+'.py')
    fp = file(appfile, 'r')
    try:
      previous = sys.modules.keys()
      module = imp.load_module(appname, fp, appfile, userModule.Param)
      fp.close()
      s = dir(module)
      if 'userModuleName' in s and 'userGui' in s:
        self.module = module
        self.__deps = []
        if 'userApplication' in s:
          for (dep, module) in sys.modules.items():
            if (dep not in previous) and type(module) == ModuleType:
              dep_path = dep.split('.')
              if len(dep_path) == 4:
                if dep_path[0] == packagename and dep_path[1] == groupname:
                  self.__deps.append(dep)
      else:
        self.module = None
        del module
    except Exception, msg:
      fp.close()
      traceback.print_exc()

  def reload(self):
    del self.module
    for dep in self.__deps:
      if dep in sys.modules:
        del sys.modules[dep]
    self.__import()


def import_initfile(root, packagename, groupname):
  initfile = os.path.join(root, packagename, groupname, '__init__.py')
  fp = file(initfile, 'r')
  modname = packagename+groupname+'__init'
  userapps = []
  try:
    module = imp.load_module(modname, fp, initfile, userModule.Param)
    fp.close()
    if 'UserApps' in dir(module):
      for app in module.UserApps:
        userapps.append(app)
    del module
  except Exception, msg:
    fp.close()
    traceback.print_exc()
  return userapps

class userAppBrowser(userAppBrowserGui):
  Debug = 0
  Info  = 1
  Warn  = 2
  Error = 3
  Fatal = 4

  LevelNames = {
    Debug: 'DEBUG',
    Info:  'INFO',
    Warn:  'WARN',
    Error: 'ERROR',
    Fatal: 'FATAL'
    }

  Color = {Debug : 'green',
           Info :  'black',
           Warn :  'blue',
           Error : 'red',
           Fatal : 'red'
           }

  MaxLines = 500
  SaveLines = 250

  def __init__(self, rc, appdir):
    userAppBrowserGui.__init__(self)
    self.setCaption("User Applications Browser")
    self.__rc = rc
    self.__appdir = appdir
    self.guis = {}
    self.guisOrder = []
    self.__tab_frames = []
    for (verlevel, vername) in userAppBrowser.LevelNames.items():
      self.VerbosityBox.insertItem(QString(vername), verlevel)
    self.VerbosityBox.setCurrentItem(1)
    self.__playButtons = [self.ResetButton,
                          self.StopButton,
                          self.PauseButton,
                          self.RunButton]
    self.__setPlayButtons(enabled=False)
    self.__tree = userAppTree(self.userAppTreeGui)
    self.__loaddir()
    self.__logtext = []
    self.userAppTextBrowser.setTextFormat(QObject.LogText)
    
  def __setPlayButtons(self, enabled):
    for button in self.__playButtons:
      button.setEnabled(enabled)

  def verbosity(self):
    return userAppBrowser.LevelNames[self.VerbosityBox.currentItem()]

  def updateSchema(self):
    self.__tree.loadNodes(self.__rc.common().getLAT())
    for usergui in self.guis.values():
      usergui.updateSchema()

  def updateSuites(self):
    for usergui in self.guis.values():
      if 'updateSuite' in dir(usergui):
        usergui.updateSuite()

  def getGui(self, appname):
    return self.guis[appname]

  def getTree(self):
    return self.__tree

  def loaded(self, appgui):
    if not self.RunButton.isEnabled():
      self.__setPlayButtons(enabled=True)
    for usergui in self.guis.values():
      if usergui == appgui:
        self.userAppLabel.setText(appgui.usrmodule.module.userModuleName)
        usergui.loaded()
      else:
        usergui.unloaded()

  def __loadApps(self, root, packagename, groupname):
    usrmodules = []
    appnames = import_initfile(root, packagename, groupname)
    for appname in appnames:
      usrmodule = userModule(root, packagename, groupname, appname)
      if usrmodule.module is not None:
        usrmodules.append(usrmodule)
        logging.debug('userAppBrowser: loading %s.%s' %(groupname, appname))
      else:
        logging.debug('userAppBrowser: skipping %s.%s'%(groupname, appname))
    return usrmodules

  def __loaddir(self):
    (root, packagename) = os.path.split(self.__appdir)
    if packagename == '': (root, packagename) = os.path.split(root)
    sys.path.insert(0, root)
    groupnames = import_initfile(root, packagename, '')
    self.guisOrder = []
    for groupname in groupnames:
      usrmodules = self.__loadApps(root, packagename, groupname)
      if len(usrmodules):
        self.guisOrder.append([groupname, []])
        newtab = QScrollView(self.userAppTabs)
        frame = QVBox(newtab.viewport())
        newtab.addChild(frame)
        self.userAppTabs.addTab(newtab, groupname)
        self.__tab_frames.append(newtab)
        for usrmodule in usrmodules:
          module = usrmodule.module
          usergui = module.userGui(frame, self.__rc, usrmodule)
          self.guis[module.userModuleName] = usergui
          self.guisOrder[-1][1].append(module.userModuleName)
        
    sys.path.remove(root)

  def ResetClicked(self):
    self.__rc.ResetClicked()

  def StopClicked(self):
    self.__rc.StopClicked()

  def PauseClicked(self):
    self.__rc.PauseClicked()

  def RunClicked(self):
    self.__rc.RunClicked()

  def purge(self):
    self.__rc.execGUImethod(self.__purge)

  def __purge(self):
    lines = len(self.__logtext)
    if lines > userAppBrowser.MaxLines:
      self.__logtext = self.__logtext[lines-userAppBrowser.SaveLines:]
      self.userAppTextBrowser.clear()
      for line in self.__logtext:
        self.userAppTextBrowser.append(line)

  def append(self, message, level):
    self.__rc.execGUImethodNR(self.__append, message, level)

  def __append(self, message, level):
    color = userAppBrowser.Color[level]
    message = '<font color=%s>%s</font>'%(color, message)
    self.__logtext.append(message)
    self.userAppTextBrowser.append(message)


if __name__ == '__main__':
  from LATTE.client.gOptions import Options

  class panelsTest(object):
    def __init__(self, browser):
      self.__browser = browser

    def getUserApp(self):
      return self.__browser

  class rcTest(object):
    def __init__(self):
      self.__panels = {}
      self.__prefs = {'logdir': '/tmp'}

    def addPanel(self, name, browser):
      panel = panelsTest(browser)
      self.__panels[name] = panel

    def panels(self):
      return self.__panels

    def preferences(self):
      return self.__prefs

  options = Options(['appdir'])
  try:
    options.parse()
  except Exception, msg:
    options.usage()
    raise Exception, msg

  app = QApplication(sys.argv)
  app.connect(app, SIGNAL("lastWindowClosed()"),app, SLOT("quit()"))
  rc = rcTest()
  win = userAppBrowser(rc, appdir=options.appdir)
  rc.addPanel('Global', win)
  win.updateSuites()
  win.show()
  app.exec_loop()

---