shell.py

Go to the documentation of this file.

# -*- coding: utf-8 -*-

import os
import sys
import time
import code
import platform
import progressbar

from libCatKernel import *

from arguments import *
from wrapper import *

#----------------------------------------------------------------------------
# options


def opts():
  return cat.options()

#----------------------------------------------------------------------------
# tree/object navigation


def obj():
  return cat.current()


def get(path):
  return cat.current().child(path)


def cd(path=''):
  cat.cd(path)
  prompt()


def load(filename):
  if (os.path.exists(filename) == False):
    filename = filename + ".py"
  if (os.path.exists(filename)):
    execfile(filename)
    prompt()
    cat.options().setDefFile(filename)
  else:
    cat.warning("File " + filename + " does not exist.", "CAT")


def reload():
  filename = cat.options().defFile()
  cat.computer().clear()
  load(filename)


def ls(path=''):
  if path == '':
    element = cat.current()
  else:
    element = cat.current().child(path)
  if type(element) != None:
    l = element.children()
    for iter in range(len(l)):
      cat.info("    " + l[iter].name() +
               " [" + l[iter].type() + "]", "CAT")
    cat.info(element.name() + " :  " + str(len(l)) +
             " child(ren) found.", "CAT")


def ll(path=''):
  if path == '':
    element = cat.current()
  else:
    element = cat.current().child(path)
  if type(element) != None:
    lproc = cat.procDb().list(element)
    nproc = len(lproc)
    if (nproc) > 0:
      cat.info("- Processus: ", "CAT")
    for p in range(nproc):
      cat.info("    " + lproc[p].name() +
               " : " + lproc[p].title(), "CAT")
    l = element.children()
    if (len(l)) > 0:
      cat.info("- Element(s): ", "CAT")
    for iter in range(len(l)):
      cat.info("    " + l[iter].name() +
               " [" + l[iter].type() + "]", "CAT")
      lproc = cat.procDb().list(l[iter])
      for p in range(len(lproc)):
        cat.info("       . " + lproc[p].name() +
                 " : " + lproc[p].title(), "CAT")
      cat.info(element.name() + " :  " + str(len(l)) + " child(ren) found [" +
               str(nproc) + " processus].", "CAT")


def pwd():
  cat.info(cat.current().name() + " [" + cat.current().type() + "]", "CAT")


def tree(path=''):
  if path == '':
    element = cat.current()
  else:
    element = cat.current().child(path)
  if type(element) != None:
    element.tree()


def view(path='', indent='  '):
  if path == '':
    element = cat.current()
  else:
    element = cat.current().child(path)
  line = indent + ' -> ' + \
      element.name() + '[' + element.type() + \
      ' - ' + element.attributs() + ']'
  print line
  l = element.children()
  for iter in range(len(l)):
    lproc = cat.procDb().list(l[iter])
    for p in range(len(lproc)):
      print indent + "   ." + lproc[p].name() + "(" + lproc[p].title() + ") - " + lproc[p].attributs()
    view(l[iter].path(''), indent + '  ')

 # def com(objecgt):
 #   while connection!=None:
 #   print connection()


def create(object, type):
  if cat.create(object, type).isFailure():
    cat.fatal("Could not make object " +
              object + " of type " + type, "CAT")

#----------------------------------------------------------------------------


def process(object):
  ok = False
  list = cat.procDb().list()
  for p in range(len(list)):
    if (list[p].name() == object):
      return list[p]
  if (ok == False):
    cat.warning("Could not find processus " + object + ".", "CAT")
    return None


def data(object, stream=None):
  ok = False
  list = cat.procDb().list()
  for p in range(len(list)):
    if (list[p].name() == object):
      ok = True
      if (stream == None):
        list[p].data().info()
      else:
        return list[p].data().vector(stream)
  if (ok == False):
    cat.warning("Could not find processus " + object + ".", "CAT")
    return

#----------------------------------------------------------------------------
# application settings


def app():
  return cat


def clear(path=''):
  if path == '':
    element = cat.current()
  else:
    element = cat.current().child(path)
  if type(element) != None:
    element.clear()


def delete(path=''):
  if path == '*':
    cat.current().clear()
  else:
    cat.current().delChild(path)


def outputLevel(level='INFO'):
  levels = {'VERBOSE': MsgLevel.VERBOSE,
            'DEBUG': MsgLevel.DEBUG,
            'INFO': MsgLevel.INFO,
            'WARNING': MsgLevel.WARNING,
            'FATAL': MsgLevel.FATAL}
  outLevel = levels.get(level)
  if outLevel != None:
    cat.options().setLogOutputLevel(outLevel)
  else:
    cat.warning("Output Level should be 'VERBOSE', 'DEBUG', 'INFO', 'WARNING' or 'FATAL'",
                "CAT")
    cat.warning("'" + level + "' level output not understood.", "CAT")


def init():
  cat.computer().recursiveInitCommunications()
  cat.computer().recursiveInitElement()


def network():
  cat.fatal("Not implemented.", "CAT")


def reset(path=''):
  if path == '':
    element = cat.current()
  else:
    element = cat.current().child(path)
  if type(element) != None:
    element.reset()


def prompt():
  current = cat.current()
  if current != None:
    sys.ps1 = "\033[92m" + current.name() + "\033[0m[\033[93m" + \
        current.type() + "\033[0m] > "
  else:
    sys.ps1 = "\033[91mInvalid\033[0m[\033[95mNone\033[0m] > "


def loadDll(name):
  cat.dllMgr().load(name)

#----------------------------------------------------------------------------
# processing


def run(processus, element, nevt):
  if (type(element) == str):
    element = get(element)
    if (element == None):
      return Code.FAILURE
  ok = False
  proc = None
  list = cat.procDb().list(element)
  for p in range(len(list)):
    if (list[p].name() == processus):
      proc = list[p]
      ok = True
  if (ok == False):
    cat.warning("Could not find processus " + processus + ".", "CAT")
    return Code.FAILURE
  nrun = opts().runNumber()
  if (cat.prepare(processus, element, nevt).isFailure()):
    cat.warning("Could not prepare the processus " +
                processus + ".", "CAT")
    return Code.FAILURE
  evt = nevt
  width = 50

  plts   = None
  module = None
  wrap = wrapper(cat, proc, "proc")
  online  = cat.options().plotFreq()
  if (wrap.ok):
    module = wrap.GetActive()
    proc.setElement(element)
    if module and (online != 0):
      plts = module.createPlots(cat, proc, nrun)        
    
  p = progressbar.AnimatedProgressBar(
      processus, end=abs(evt), width=width, fill='▣', blank='-')
  timing  = -1.
  ievt    = 0
  if (evt<0): timing = time.time()
  evt    = abs(evt)
  stop    = False

  try:
    while ( not stop ):
      ievt+=1
      if timing>=0:
        elapsed = time.time() - timing
        p.set(elapsed)
        if elapsed > evt : stop = True
      else :
        p + 1
        if ievt>=evt : stop = True
      p.show_progress()
      if (cat.loop().isFailure()):
        cat.warning("Error detected during processing.", "CAT")
      if online>0 and plt:
        if ievt%online==0:
          if module :
            module.updatePlots(plts, proc)
  except KeyboardInterrupt:
    pass

  cat.terminate()
  if module and online==0:
    plts = module.createPlots(cat, proc, nrun) 
    module.updatePlots(plts, proc)

  #  Plot(processus, nrun)

# def plot(processus, nrun):
#   p = proc(processus)
#   if (p != None):
#     wrap = wrapper(cat, p, "proc")
#     if (wrap.ok):
#       module = wrap.GetActive()
#       plot = module.Plot(cat, p, None, nrun)
#       if plot:
#         plot.current().show()
#   return Code.SUCCESS

# def finalplot(processus, nrun):
#   p = proc(processus)
#   if (p != None):
#     wrap = wrapper(cat, p, "proc")
#     if (wrap.ok):
#       module = wrap.GetActive()
#       plot = module.FinalPlot(cat, p, None, nrun)
#       if plot:
#         plot.current().show()
#   return Code.SUCCESS


def shell(app, args):
  import version
  global cat
  global figid
  figid = 0
  if (app == None):
    cat = Application()
  else:
    cat = app
  outputLevel(args.output)
  vers = version.version()
  vers.info()
  cat.initialize()
  if ("" <> args.file):
    if (os.path.exists(args.file)):
      execfile(args.file)
      cat.options().setDefFile(args.file)
    else:
      cat.fatal("Cannot execute init file " +
                args.file + ". Abort.", "CAT")
      return -1
  prompt()

# main

if __name__ == "__main__":
  args = arguments()
  args.shellMode = True
  shell(Application(), args)