Source Code for Module iceprod.modules.ipmodule

  1  #!/bin/env python 
  2  # 
  3  """ 
  4   Interface for configuring pre/post icetray scripts 
  5   
  6   copyright  (c) 2005 the icecube collaboration 
  7   
  8   @version: $Revision: $ 
  9   @date: $Date: $ 
 10   @author: Juan Carlos Diaz Velez <juancarlos@icecube.wisc.edu> 
 11  """ 
 12   
 13  import os 
 14  import re 
 15  import sys 
 16  import math 
 17  import dircache 
 18  import time 
 19  import string 
 20  import shutil 
 21  import cPickle 
 22  import logging 
 23  import iceprod 
 24  from iceprod.core.odict import OrderedDict 
 25  from iceprod.core.lex import ExpParser 
 26   
 27   
 28   
 29 -class IPBaseClass: 
 30      """ 
 31      This class provides an interface for preprocessing files in iceprod 
 32      """ 
 33   
 34 -    def __init__(self): 
 35          if not hasattr(self,'parameters'): 
 36             self.parameters    = OrderedDict() 
 37             self.description   = OrderedDict() 
 38             self.AddParameter("execute","boolean condition to execute", True) 
 39   
 40          self.status        = 0 
 41          self.configured    = False 
 42          self.parser        = None 
 43   
 44          # Aggregate CPU times 
 45          self.realtime        = 0.0 
 46          self.usertime        = 0.0 
 47          self.systime        = 0.0 
 48   
 49          self.logger = logging.getLogger('IPBaseClass') 
 50   
 51 -    def Configure(self,tray): 
 52          self.logger.info("Configuring IceProd module '%s'" % self.__class__.__name__) 
 53          self.configured    = True 
 54   
 55 -    def SetParser(self, parser): 
 56          """ 
 57          Set the ExpParser object 
 58          """ 
 59          self.parser        = parser 
 60   
 61 -    def AddParameter(self, param,description, value): 
 62          """ 
 63          Add parameter value for plugin 
 64          """ 
 65          self.parameters[param.lower()]  = value 
 66          self.description[param.lower()] = description 
 67   
 68 -    def GetParameter(self, param): 
 69          """ 
 70          Get parameter value for plugin 
 71          """ 
 72          if not self.parameters.has_key(param.lower()): 
 73              raise Exception, "Attemting to get parameter %s not added by %s" % (param,self) 
 74          return self.parameters[param.lower()] 
 75   
 76 -    def SetParameter(self, param, value): 
 77          """ 
 78          Set parameter value for plugin 
 79          """ 
 80          if not self.parameters.has_key(param.lower()): 
 81              print self.ShowParameters() 
 82              raise Exception, "param %s was configured but not added by %s" % (param,self) 
 83          self.parameters[param.lower()] = value 
 84          self.logger.info("%s:%s" %(param,value)) 
 85          return self.SetParameter 
 86   
 87 -    def SetParameters(self, *args): 
 88          """ 
 89          Set multiple parameters for plugin 
 90          """ 
 91          for key,value in args: 
 92              self.SetParameter(key,value) 
 93          return self 
 94   
 95   
 96 -    def Execute(self,stats): 
 97          self.logger.info("execute %s: %s" % (self.__class__.__name__,self.GetParameter("execute"))) 
 98          return self.GetParameter("execute") 
 99   
100 -    def ShowParameters(self): 
101          return zip( 
102              self.parameters.keys(), 
103              map(self.parameters.get,self.parameters.keys()), 
104              map(self.description.get,self.parameters.keys()) 
105              ) 
106   
107 -    def Finish(self,stats={}): 
108          self.logger.info("finish %s: %s" % (self.__class__.__name__,self.GetParameter("execute"))) 
109          return 0 
110   
111 -class Hello(IPBaseClass): 
112   
113 -    def __init__(self): 
114          IPBaseClass.__init__(self) 
115          self.AddParameter("greeting","String to write to screen","Hello World") 
116   
117 -    def Execute(self,stats): 
118          if not IPBaseClass.Execute(self,stats): return 0 
119          print self.GetParameter("greeting") 
120          return 0 
121   
122 -class GoodBye(IPBaseClass): 
123   
124 -    def __init__(self): 
125          IPBaseClass.__init__(self) 
126          self.AddParameter("greeting","String to write to screen","Good bye World") 
127   
128 -    def Execute(self,stats): 
129          if not IPBaseClass.Execute(self,stats): return 0 
130          print self.GetParameter("greeting") 
131          return 0 
132   
133 -class GenericModule(IPBaseClass): 
134 -    def __init__(self): 
135          IPBaseClass.__init__(self) 
136          self.AddParameter("Executable","Name of executable to run","") 
137          self.AddParameter("Arguments","string of arguments to pass to executable",[]) 
138   
139 -    def Execute(self,stats): 
140          if not IPBaseClass.Execute(self,stats): return 0 
141          executable = self.GetParameter("Executable") 
142          arguments  = self.GetParameter("Arguments") 
143          cmd = "%s %s" % (executable," ".join(arguments)) 
144          print "executing:", cmd 
145          return os.system(cmd) 
146           
147  try: 
148     from optparse import OptionParser 
149  except: 
150     print "could not import option parser. skipping definitions of class ParsingModule" 
151  else: 
152     import types 
153   
154 -   class ParsingModule(OptionParser,IPBaseClass): 
155 -        def __init__(self): 
156             OptionParser.__init__(self) 
157             IPBaseClass.__init__(self) 
158   
159             self.parser_opts = None 
160             self.parser_args = [] 
161   
162   
163 -        def AddParameter(self, param,description, value): 
164             IPBaseClass.AddParameter(self,param,description,value) 
165             if type(value) == int: 
166                OptionParser.add_option(self, '', '--%s' % param,  
167                                type="int", help=description, default=str(value) ) 
168             elif type(value) == float: 
169                OptionParser.add_option(self, '', '--%s' % param,  
170                                type="float", help=description, default=str(value) ) 
171             elif type(value) == list: 
172                OptionParser.add_option(self, '', '--%s' % param, help=description,  
173                        default=str(value), dest='multi', action='store', nargs=len(value)) 
174             else: 
175                OptionParser.add_option(self, '', '--%s' % param, help=description, default=str(value) ) 
176   
177 -        def Execute(self, stats={}): 
178              if not IPBaseClass.Execute(self,stats): return 0 
179              (self.parser_opts, self.parser_args) = OptionParser.parse_args(self) 
180   
181 -   class FromOptionParser(IPBaseClass): 
182          """Converts an OptionParser object to an IceProd module. 
183             Takes a parser and a main function as input. 
184             Will pass a dict with the name,value pairs to the main function.""" 
185 -        def __init__(self,parser,main): 
186              IPBaseClass.__init__(self) 
187              self.main = main 
188              self.args = parser.defaults 
189              for name in self.args: 
190                  value = self.args[name] 
191                  description = '' 
192                  IPBaseClass.AddParameter(self,name,description,value) 
193           
194 -        def Execute(self, stats={}): 
195              if not IPBaseClass.Execute(self,stats): return 0 
196              options = {} 
197              for name in self.args: 
198                  options[name] = self.GetParameter(name) 
199              ret = self.main(options,stats) 
200              if ret is None: 
201                  return 0 
202              else: 
203                  return ret 
204