dataformats Namespace Reference

Functions
def	help
def	importDF
def	indent
def	search
def	wrap_always
def	wrap_onspace
def	wrap_onspace_strict
Variables
list	imported_modules = []

---

Function Documentation

def dataformats::help

(

)

Definition at line 125 of file dataformats.py.

          :
    print "usage: dataformats pattern_to_search"
    print "example: dataformats muon"
    print "Note! multiple patterns separated by space are not supported"

def dataformats::importDF

(

path

)

Definition at line 84 of file dataformats.py.

                  :

    modules_to_import = "RecoTracker RecoLocalTracker RecoLocalCalo RecoEcal RecoEgamma RecoLocalMuon RecoMuon RecoJets RecoMET RecoBTag RecoTauTag RecoVertex RecoPixelVertexing HLTrigger RecoParticleFlow".split()
    modules_to_import = "RecoLocalTracker RecoLocalMuon RecoLocalCalo RecoEcal TrackingTools RecoTracker RecoJets RecoMET RecoMuon RecoBTau RecoBTag RecoTauTag RecoVertex RecoPixelVertexing RecoEgamma RecoParticleFlow L1Trigger".split()
  

    for m in modules_to_import:
        m = m + "_dataformats"
        try:
            sys.path.append(path+"/src/Documentation/DataFormats/python/")
            globals()[m] = __import__(m)
            imported_modules.append(m)
            print m
        except ImportError:
            print "skipping", m
        
# END of import            
        

def dataformats::indent	(		rows,
			hasHeader = False,
			headerChar = '-',
			delim = ' | ',
			justify = 'left',
			separateRows = False,
			prefix = '',
			postfix = '',
			wrapfunc = lambda x:x
	)

Indents a table by column.
   - rows: A sequence of sequences of items, one sequence per row.
   - hasHeader: True if the first row consists of the columns' names.
   - headerChar: Character to be used for the row separator line
     (if hasHeader==True or separateRows==True).
   - delim: The column delimiter.
   - justify: Determines how are data justified in their column. 
     Valid values are 'left','right' and 'center'.
   - separateRows: True if rows are to be separated by a line
     of 'headerChar's.
   - prefix: A string prepended to each printed row.
   - postfix: A string appended to each printed row.
   - wrapfunc: A function f(text) for wrapping text; each element in
     the table is first wrapped by this function.

Definition at line 4 of file dataformats.py.

Referenced by CalibrationXML::addChild(), FWPSetTableManager::cellRenderer(), node_filter(), operator<<(), and edm::ParameterDescription< std::vector< ParameterSet > >::writeOneElementToCfi().

                                                                       :x):
    """Indents a table by column.
       - rows: A sequence of sequences of items, one sequence per row.
       - hasHeader: True if the first row consists of the columns' names.
       - headerChar: Character to be used for the row separator line
         (if hasHeader==True or separateRows==True).
       - delim: The column delimiter.
       - justify: Determines how are data justified in their column. 
         Valid values are 'left','right' and 'center'.
       - separateRows: True if rows are to be separated by a line
         of 'headerChar's.
       - prefix: A string prepended to each printed row.
       - postfix: A string appended to each printed row.
       - wrapfunc: A function f(text) for wrapping text; each element in
         the table is first wrapped by this function."""
    # closure for breaking logical rows to physical, using wrapfunc
    def rowWrapper(row):
        newRows = [wrapfunc(item).split('\n') for item in row]
        return [[substr or '' for substr in item] for item in map(None,*newRows)]
    # break each logical row into one or more physical ones
    logicalRows = [rowWrapper(row) for row in rows]
    # columns of physical rows
    columns = map(None,*reduce(operator.add,logicalRows))
    # get the maximum of each column by the string length of its items
    maxWidths = [max([len(str(item)) for item in column]) for column in columns]
    rowSeparator = headerChar * (len(prefix) + len(postfix) + sum(maxWidths) + \
                                 len(delim)*(len(maxWidths)-1))
    # select the appropriate justify method
    justify = {'center':str.center, 'right':str.rjust, 'left':str.ljust}[justify.lower()]
    output=cStringIO.StringIO()
    if separateRows: print >> output, rowSeparator
    for physicalRows in logicalRows:
        for row in physicalRows:
            print >> output, \
                prefix \
                + delim.join([justify(str(item),width) for (item,width) in zip(row,maxWidths)]) \
                + postfix
        if separateRows or hasHeader: print >> output, rowSeparator; hasHeader=False
    return output.getvalue()

# written by Mike Brown
# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/148061

def dataformats::search

(

query

)

Definition at line 102 of file dataformats.py.

Referenced by AlignmentMonitorTemplate::event().

                 :
    labels = ('Where(Package)', 'Instance', 'Container', 'Description')
    width = 20
    
    data = ""
    for module in imported_modules:
        for dict_name in ["full", "reco", "aod"]:         # going through all dictionaries
            #print module
            dict = vars(globals()[module])[dict_name] 
              
            for key in sorted(dict.keys()):                        # going though all elements in dictionary
                # TODO: IMPROVE
                element = dict[key]
                if query.lower() in element.__str__().lower():    # searching for query
                    if not (("No documentation".lower()) in element.__str__().lower()):
                        data+= module.replace("_dataformats", "")+" ("+ dict_name.replace("full", "FEVT") + ")||" + "||".join(element)+"\n"
                    
    if (data != ""):
        rows = [row.strip().split('||')  for row in data.splitlines()]
        print indent([labels]+rows, hasHeader=True, separateRows=True, prefix='| ', postfix=' |',  wrapfunc=lambda x: wrap_always(x,width))
    else:
        print "No documentation found"   

def dataformats::wrap_always	(		text,
			width
	)

A simple word-wrap function that wraps text on exactly width characters.
   It doesn't split the text in words.

Definition at line 70 of file dataformats.py.

                            :
    """A simple word-wrap function that wraps text on exactly width characters.
       It doesn't split the text in words."""
    return '\n'.join([ text[width*i:width*(i+1)] \
                       for i in xrange(int(math.ceil(1.*len(text)/width))) ])



# END OF TABLE FORMATING

# START of import

def dataformats::wrap_onspace	(		text,
			width
	)

A word-wrap function that preserves existing line breaks
and most spaces in the text. Expects that existing line
breaks are posix newlines (\n).

Definition at line 47 of file dataformats.py.

                             :
    """
    A word-wrap function that preserves existing line breaks
    and most spaces in the text. Expects that existing line
    breaks are posix newlines (\n).
    """
    return reduce(lambda line, word, width=width: '%s%s%s' %
                  (line,
                   ' \n'[(len(line[line.rfind('\n')+1:])
                         + len(word.split('\n',1)[0]
                              ) >= width)],
                   word),
                  text.split(' ')
                 )

def dataformats::wrap_onspace_strict	(		text,
			width
	)

Similar to wrap_onspace, but enforces the width constraint:
   words longer than width are split.

Definition at line 63 of file dataformats.py.

                                    :
    """Similar to wrap_onspace, but enforces the width constraint:
       words longer than width are split."""
    wordRegex = re.compile(r'\S{'+str(width)+r',}')
    return wrap_onspace(wordRegex.sub(lambda m: wrap_always(m.group(),width),text),width)

---

Variable Documentation

list dataformats::imported_modules = []

Definition at line 82 of file dataformats.py.