RemoveMathFromGDML Namespace Reference

Classes
class	ConfigurationError
class	GDMLexpressionRemover
class	GDMLpurifier
class	XMLpurifier
	XML parsing approach. More...

Functions
def	RemoveMathFromGDMLfile (InputFileName, OutputFileName=None, options=None)
def	ApplyToNodes (node, level, func, args, kargs)
def	ApplyToDocument (document, func, args, kargs)
def	RemoveMathFromXMLfile (InputFileName, OutputFileName=None, options=None)
def	LoggingSetup (LoggingLevel=logging.INFO)
def	RunParserOn (parser, InputFileName, options=None)
def	RemoveMathFromGDML ()

Variables
string	__doc__
string	__version__ = "1.6"
bool	hasXML = True

Function Documentation

def RemoveMathFromGDML.ApplyToDocument	(		document,
			func,
			args,
			kargs
	)

Definition at line 298 of file RemoveMathFromGDML.py.

def ApplyToDocument(document, func, *args, **kargs):
   ApplyToNodes(document, 0, func, *args, **kargs)

def RemoveMathFromGDML.ApplyToNodes	(		node,
			level,
			func,
			args,
			kargs
	)

Applies a function to the specified node and all its descendants.

Definition at line 288 of file RemoveMathFromGDML.py.

def ApplyToNodes(node, level, func, *args, **kargs):
   """Applies a function to the specified node and all its descendants."""
   if node.childNodes:
      for child in node.childNodes:
         ApplyToNodes(child, level + 1, func, *args, **kargs)
   func(node, level, *args, **kargs)
   
# ApplyToNodes()

def RemoveMathFromGDML.LoggingSetup

(

LoggingLevel = logging.INFO

)

Definition at line 333 of file RemoveMathFromGDML.py.

def LoggingSetup(LoggingLevel = logging.INFO):

   logging.basicConfig(
     level=LoggingLevel,
     format="%(levelname)s: %(message)s",
     stream=sys.stderr # do not pollute standard output
     )

# def LoggingSetup()

def RemoveMathFromGDML.RemoveMathFromGDML

(

)

Definition at line 387 of file RemoveMathFromGDML.py.

def RemoveMathFromGDML():
   import argparse
   
   LoggingSetup(logging.WARN)
   
   ###
   ### argument parsing
   ###
   # the first parser is the default one
   SupportedParsers = [ 'direct', 'xml', 'list' ]
   if not hasXML:
      logging.warn("XML parser is not supported (cam't find python XML module)")
      SupportedParsers.remove('xml')
   # if
   
   parser = argparse.ArgumentParser(description=__doc__)
   parser.set_defaults(NoROOTformula=False, Parser=SupportedParsers[0])

   parser.add_argument('--stdin', dest="FromSTDIN", action='store_true',
     help="read input from stdin")

   parser.add_argument("InputFiles", nargs="*", default=None,
     help="input GDML files [default: stdin]")

   parser.add_argument("--parser", choices=SupportedParsers, dest="Parser",
     help="choose which parser to use ('list' for a list) [%(default)s]")
   
   parser.add_argument("--direct", action="store_const", const="direct",
     dest="Parser", help="use simple internal parser [%(default)s]")
   
   parser.add_argument("--xml", action="store_const", const="xml",
     dest="Parser", help="use complete XML parser [%(default)s]")

   # mode disabled because it may give wrong answers;
   # the implementation is still available; to enable it, you have to change
   # the hard-coded value of arguments.NoROOTformula.
#   parser.add_argument("--noroot", action="store_true",
#     dest="NoROOTformula",
#     help="use python instead of ROOT TFormula to evaluate expressions [%(default)s]"
#     )

   parser.add_argument("--output", "-o", dest="OutputFile", default=None,
     help="for a single input, use this as output file")
   
   parser.add_argument('--warnzero', '-z', dest="WarnZero", action='store_true',
     help="emit a warning each time an expression evaluates to 0 [%(default)s]")
   parser.add_argument('--dryrun', '--fake', '-n', dest="Fake", action='store_true',
     help="do not write output [%(default)s]")
   parser.add_argument('--verbose', '-v', dest="DoVerbose", action='store_true',
     help="shows all the changes on screen [%(default)s]")
   parser.add_argument('--debug', dest="DoDebug", action='store_true',
     help="enables debug messages on screen")

   parser.add_argument('--version', action='version',
     version='%(prog)s ' + __version__)

   arguments = parser.parse_args()
   
   ###
   ### set up and parameter check
   ###
   # set up the logging system
   logging.getLogger().setLevel \
     (logging.DEBUG if arguments.DoDebug else logging.INFO)

   arguments.LogMsg = logging.info if arguments.DoVerbose else logging.debug

   if arguments.Parser == 'list':
      SupportedParsers.remove('list')
      logging.info("Supported parsers: '%s'.", "', '".join(SupportedParsers)) 
      return 0
   # if list parsers
   
   if arguments.Parser == 'direct':
      Parser = RemoveMathFromGDMLfile
   elif arguments.Parser == 'xml':
      Parser = RemoveMathFromXMLfile
   else:
      raise ConfigurationError("Unexpected parser '%s' requested" % arguments.Parser)
   
   if bool(arguments.FromSTDIN) == bool(arguments.InputFiles):
      raise ConfigurationError \
        ("Please either specify option --stdin OR some input files.")
   #

   ###
   ### run
   ### 
   if arguments.FromSTDIN:
      Parser(None, options=arguments)
   elif arguments.OutputFile is not None:
      if len(arguments.InputFiles) > 1:
         raise ConfigurationError \
           ("Named output is supported only when a single input file is specified.")
      # if
      Parser(arguments.InputFiles[0], arguments.OutputFile, options=arguments)
   else:
      for InputFileName in arguments.InputFiles:
         RunParserOn(Parser, InputFileName, options=arguments)
   # if ... else
   
   ###
   ### done
   ###
   return 0
# RemoveMathFromGDML()

def RemoveMathFromGDML.RemoveMathFromGDMLfile	(		InputFileName,
			OutputFileName = None,
			options = None
	)

Definition at line 223 of file RemoveMathFromGDML.py.

def RemoveMathFromGDMLfile(InputFileName, OutputFileName = None, options = None):
   
   if not options.Fake and OutputFileName and (InputFileName == OutputFileName):
      raise ConfigurationError \
        ("With the direct parser the input and output file must be different.")
   
   # if InputFileName is empty, use standard input
   InputFile = open(InputFileName, 'r') if InputFileName else sys.stdin
   
   if options.Fake:
      logging.info("Output will not be written in dry-run mode.")
      OutputFile = None
   else:
      # if OutputFileName is empty, use standard output; otherwise, overwrite
      OutputFile = open(OutputFileName, 'w') if OutputFileName else sys.stdout
   
   RemoveGDMLexpression = GDMLpurifier(options=options)
   
   for iLine, line in enumerate(InputFile):
      
      # save indentation
      beef = line.lstrip()
      indent = line[:-len(beef)]
      beef = beef.rstrip() # remove stuff at the end of line too (will be lost)
      
      # we keep the words after removal in a new list
      purified = RemoveGDMLexpression.apply(beef, iLine)
      
      if OutputFile:
         # output accumulates the output line
         output = indent + purified
         print >>OutputFile, output
      # if output
   # for
   
   if OutputFileName and OutputFile:
      logging.debug("GDML written to file '%s'", OutputFileName)
   
# RemoveMathFromGDMLfile()

def RemoveMathFromGDML.RemoveMathFromXMLfile	(		InputFileName,
			OutputFileName = None,
			options = None
	)

Definition at line 302 of file RemoveMathFromGDML.py.

def RemoveMathFromXMLfile(InputFileName, OutputFileName = None, options = None):
   
   # if InputFileName is empty, use standard input
   InputFile = open(InputFileName, 'r') if InputFileName else sys.stdin
   
   # parse GDML document using minidom parser
   DOMTree = xml.dom.minidom.parse(InputFile)
   GDML = DOMTree.documentElement
   
   RemoveGDMLexpression = XMLpurifier()
   
   ApplyToDocument(GDML, RemoveGDMLexpression.purifyNode)
   

   if options.Fake:
      logging.info("Output will not be written in dry-run mode.")
   else:
      # if OutputFileName is empty, use standard output; otherwise, overwrite
      OutputFile = open(OutputFileName, 'w') if OutputFileName else sys.stdout
      
      OutputFile.write(GDML.toxml())
      OutputFile.write("\n")
      
      if OutputFileName:
         logging.debug("GDML written to file '%s'", OutputFileName)
   # if output
   
# RemoveMathFromXMLfile()

def RemoveMathFromGDML.RunParserOn	(		parser,
			InputFileName,
			options = None
	)

Renames the input file into '.bak', then runs the parser

Definition at line 344 of file RemoveMathFromGDML.py.

def RunParserOn(parser, InputFileName, options = None):
   """Renames the input file into '.bak', then runs the parser"""
   
   OldInputFileName = InputFileName
   OutputFileName = OldInputFileName
   
   if not options.Fake:
      InputFileName += ".bak"
      
      # rename the input file
      if os.path.exists(InputFileName):
         raise ConfigurationError(
           "Backup file '%s' is on the way. Please remove it first."
           % InputFileName
           )
      # if exists
      logging.debug("Renaming the input file into '%s'", InputFileName)
      os.rename(OldInputFileName, InputFileName)
   # if not dry run
   
   # run the parser
   try:
      parser(InputFileName, OutputFileName, options=options)
   except Exception, e:
      if not options.Fake:
         # if no output file was produced, rename back the input
         if not os.path.exists(OutputFileName):
            logging.debug("Restoring the input file name after a fatal error.")
            os.rename(InputFileName, OldInputFileName) 
      # if
      raise e
   # try ... except
   
   if not options.Fake:
      logging.info("File '%s' rewritten (old file in '%s')",
        OutputFileName, InputFileName
        )
   # if
   
# RunParserOn()

Variable Documentation

string RemoveMathFromGDML.__doc__

private

Initial value:

= """Evaluates and replaces mathematical expressions from a GDML file.

By default, each of the input file is renamed into a .bak file, and the output
replaces the old file. If no input file is specified, the file is read from standard
input and output to standard output, or to the value of the '--output' option.
The output option can also be specified to set the output file name, in which case
the input file is not renamed. If empty, output will be to standard output.

This scripts supports two modes:
- direct parser: a simple parser that looks for patterns '="xxx"' in a line
  and replaces xxx with its value; it preserves the form of the input,
  but it might silently fail to parse good GDML
- XML parser: a python XML parser evaluates the GDML file completely, then it
  writes it anew; it will parse any XML, but it loses comments and can change
  the order of the attributes
The XML parser is easy to extend to include "define" GDML lines, that are not
currently supported.

Expressions are evaluated by ROOT TFormula.
"""

Definition at line 33 of file RemoveMathFromGDML.py.

string RemoveMathFromGDML.__version__ = "1.6"

private

Definition at line 53 of file RemoveMathFromGDML.py.

RemoveMathFromGDML.hasXML = True

Definition at line 61 of file RemoveMathFromGDML.py.