Inheritance diagram for betterConfigParser.BetterConfigParser:

Public Member Functions
def	__init__ (self)

def	checkInput (self, section, knownSimpleOptions=[], knownKeywords=[], ignoreOptions=[])

def	exists (self, section, option)

def	getAlignments (self)

def	getCompares (self)

def	getGeneral (self)

def	getResultingSection (self, section, defaultDict={}, demandPars=[])

def	items (self, section, raw=False, vars=None)

def	optionxform (self, optionstr)

def	set (self, section, option, value=None)

def	write (self, fp)

Static Public Attributes
	general = self.getResultingSection( "general", defaultDict = defaults, demandPars = mandatories )

string	internal_section = "internals"

	knownSimpleOptions

list	mandatories

	OPTCRE_VALIDATION

Private Member Functions
def	__updateDict (self, dictionary, section)

Private Attributes
	_optcre

Detailed Description

Definition at line 57 of file betterConfigParser.py.

Constructor & Destructor Documentation

def betterConfigParser.BetterConfigParser.__init__ ( self )

Definition at line 58 of file betterConfigParser.py.

     def __init__(self):
         ConfigParser.ConfigParser.__init__(self,dict_type=AdaptedDict)
         self._optcre = self.OPTCRE_VALIDATION
 

Member Function Documentation

def betterConfigParser.BetterConfigParser.__updateDict	(	self,
		dictionary,
		section
	)

private

Definition at line 75 of file betterConfigParser.py.

Referenced by betterConfigParser.BetterConfigParser.getResultingSection().

     def __updateDict( self, dictionary, section ):
         result = dictionary
         try:
             for option in self.options( section ):
                 result[option] = self.get( section, option )
             if "local"+section.title() in self.sections():
                 for option in self.options( "local"+section.title() ):
                     result[option] = self.get( "local"+section.title(),
                                                    option )
         except ConfigParser.NoSectionError as section:
             msg = ("%s in configuration files. This section is mandatory."
                    %(str(section).replace(":", "", 1)))
             raise AllInOneError(msg)
         return result
 

def betterConfigParser.BetterConfigParser.checkInput	(	self,
		section,
		knownSimpleOptions = `[]`,
		knownKeywords = `[]`,
		ignoreOptions = `[]`
	)

Method which checks, if the given options in `section` are in the
list of `knownSimpleOptions` or match an item of `knownKeywords`.
This is basically a check for typos and wrong parameters.

Arguments:
- `section`: Section of a configuration file
- `knownSimpleOptions`: List of allowed simple options in `section`.
- `knownKeywords`: List of allowed keywords in `section`.

Definition at line 183 of file betterConfigParser.py.

References FileExportPlugin.FileExportPlugin.options, cmsswPreprocessor.CmsswPreprocessor.options, DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, DOTExport.DotProducer.options, TestProcess.TestProcess.options, confdb.HLTProcess.options, production_tasks.Task.options, VisualizationOptions.options(), fireworks::OptionNode.options(), and edmIntegrityCheck.IntegrityCheck.options.

Referenced by betterConfigParser.BetterConfigParser.getCompares().

                    ignoreOptions=[]):
         """
         Method which checks, if the given options in `section` are in the
         list of `knownSimpleOptions` or match an item of `knownKeywords`.
         This is basically a check for typos and wrong parameters.
         
         Arguments:
         - `section`: Section of a configuration file
         - `knownSimpleOptions`: List of allowed simple options in `section`.
         - `knownKeywords`: List of allowed keywords in `section`.
         """
 
         try:
             for option in self.options( section ):
                 if option in knownSimpleOptions:
                     continue
                 elif option.split()[0] in knownKeywords:
                     continue
                 elif option in ignoreOptions:
                     print ("Ignoring option '%s' in section '[%s]'."
                            %(option, section))
                 else:
                     msg = ("Invalid or unknown parameter '%s' in section '%s'!"
                            %(option, section))
                     raise AllInOneError(msg)
         except ConfigParser.NoSectionError:
             pass
 

def betterConfigParser.BetterConfigParser.exists	(	self,
		section,
		option
	)

Definition at line 65 of file betterConfigParser.py.

References PixelDCSObject< T >.items, betterConfigParser.AdaptedDict.items(), tensorflow::NTSession::ExecutorsAndKeys.items, tensorflow::TBBSession::ExecutorsAndKeys.items, betterConfigParser.BetterConfigParser.items(), and svgfig.SVG.items().

     def exists( self, section, option):
         try:
             items = self.items(section) 
         except ConfigParser.NoSectionError:
             return False
         for item in items:
             if item[0] == option:
                 return True
         return False
         

def betterConfigParser.BetterConfigParser.getAlignments ( self )

Definition at line 123 of file betterConfigParser.py.

References betterConfigParser.BetterConfigParser.items(), join(), and DDCutTubsFromPoints.sections.

     def getAlignments( self ):
         alignments = []
         for section in self.sections():
             if "alignment:" in section:
                 alignments.append( Alignment( section.split( "alignment:" )[1],
                                               self ) )
         names_after_cleaning = [alignment.name for alignment in alignments]
         duplicates = [name
                       for name, count
                       in collections.Counter(names_after_cleaning).items()
                       if count > 1]
         if len(duplicates) > 0:
             msg = "Duplicate alignment names after removing invalid characters: "
             msg += ", ".join(duplicates) +"\n"
             msg += "Please rename the alignments to avoid name clashes."
             raise AllInOneError(msg)
         return alignments
 

def betterConfigParser.BetterConfigParser.getCompares ( self )

Definition at line 141 of file betterConfigParser.py.

     def getCompares( self ):
         compares = {}
         for section in self.sections():
             if "compare:" in section:
                 self.checkInput(section,
                                 knownSimpleOptions = ["levels", "dbOutput","moduleList","modulesToPlot","useDefaultRange","plotOnlyGlobal","plotPng","makeProfilePlots",
                                                       "dx_min","dx_max","dy_min","dy_max","dz_min","dz_max","dr_min","dr_max","rdphi_min","rdphi_max",
                                                       "dalpha_min","dalpha_max","dbeta_min","dbeta_max","dgamma_min","dgamma_max",
                                                       "jobmode", "3DSubdetector1", "3Dubdetector2", "3DTranslationalScaleFactor", "jobid"])
                 levels = self.get( section, "levels" )
                 dbOutput = self.get( section, "dbOutput" )
                 compares[section.split(":")[1]] = ( levels, dbOutput )
         return compares
 

def betterConfigParser.BetterConfigParser.getGeneral ( self )

Definition at line 155 of file betterConfigParser.py.

     def getGeneral( self ):
         defaults = {
             "jobmode":"interactive",
             "datadir":os.getcwd(),
             "logdir":os.getcwd(),
             }

def betterConfigParser.BetterConfigParser.getResultingSection	(	self,
		section,
		defaultDict = `{}`,
		demandPars = `[]`
	)

Definition at line 90 of file betterConfigParser.py.

     def getResultingSection( self, section, defaultDict = {}, demandPars = [] ):
         result = copy.deepcopy(defaultDict)
         for option in demandPars:
             try:
                 result[option] = self.get( section, option )
             except ConfigParser.NoOptionError as globalSectionError:
                 globalSection = str( globalSectionError ).split( "'" )[-2]
                 splittedSectionName = section.split( ":" )
                 if len( splittedSectionName ) > 1:
                     localSection = ("local"+section.split( ":" )[0].title()+":"
                                     +section.split(":")[1])
                 else:
                     localSection = ("local"+section.split( ":" )[0].title())
                 if self.has_section( localSection ):
                     try:
                         result[option] = self.get( localSection, option )
                     except ConfigParser.NoOptionError as option:
                         msg = ("%s. This option is mandatory."
                                %(str(option).replace(":", "", 1).replace(
                                     "section",
                                     "section '"+globalSection+"' or", 1)))
                         raise AllInOneError(msg)
                 else:
                     msg = ("%s. This option is mandatory."
                            %(str(globalSectionError).replace(":", "", 1)))
                     raise AllInOneError(msg)
         try:
             result = self.__updateDict( result, section )
         except AllInOneError:   #section doesn't exist
             if demandPars:      #then there's at least one mandatory parameter, which means the section needs to be there
                 raise           #otherwise all the parameters are optional, so it's ok
         return result
 

def betterConfigParser.BetterConfigParser.items	(	self,
		section,
		raw = `False`,
		vars = `None`
	)

Definition at line 218 of file betterConfigParser.py.

References Vispa.Main.SplitterTab.SplitterToolBar._sections, and html.HtmlReport._sections.

Referenced by betterConfigParser.BetterConfigParser.exists(), betterConfigParser.BetterConfigParser.getAlignments(), crabConfigParser.CrabConfigParser.getSectionLines(), python.rootplot.core.Options.kwarg_list(), and betterConfigParser.BetterConfigParser.write().

     def items(self, section, raw=False, vars=None):
         if section == "validation":
             if raw or vars:
                 raise NotImplementedError("'raw' and 'vars' do not work for betterConfigParser.items()!")
             items = self._sections["validation"].items()
             return items
         else:
             return ConfigParser.ConfigParser.items(self, section, raw, vars)
 

def betterConfigParser.BetterConfigParser.optionxform	(	self,
		optionstr
	)

Definition at line 62 of file betterConfigParser.py.

     def optionxform(self, optionstr):
         return optionstr
     

def betterConfigParser.BetterConfigParser.set	(	self,
		section,
		option,
		value = `None`
	)

Definition at line 211 of file betterConfigParser.py.

     def set(self, section, option, value=None):
         try:
             ConfigParser.ConfigParser.set(self, section, option, value)
         except ConfigParser.NoSectionError:
             self.add_section(section)
             ConfigParser.ConfigParser.set(self, section, option, value)
 

def betterConfigParser.BetterConfigParser.write	(	self,
		fp
	)

Write an .ini-format representation of the configuration state.

Definition at line 227 of file betterConfigParser.py.

References Vispa.Main.SplitterTab.SplitterToolBar._sections, html.HtmlReport._sections, betterConfigParser.BetterConfigParser.items(), join(), python.rootplot.root2matplotlib.replace(), and str.

Referenced by pkg.AbstractPkg.generate(), and querying.connection.write_and_commit().

     def write(self, fp):
         """Write an .ini-format representation of the configuration state."""
         for section in self._sections:
             fp.write("[%s]\n" % section)
             for (key, value) in self._sections[section].items():
                 if key == "__name__" or not isinstance(value, (str, unicode)):
                     continue
                 if value is not None:
                     key = " = ".join((key, str(value).replace('\n', '\n\t')))
                 fp.write("%s\n" % (key))
             fp.write("\n")
 
 

Member Data Documentation

betterConfigParser.BetterConfigParser._optcre

private

Definition at line 60 of file betterConfigParser.py.

betterConfigParser.BetterConfigParser.general = self.getResultingSection( "general", defaultDict = defaults, demandPars = mandatories )

static

Definition at line 165 of file betterConfigParser.py.

Referenced by primaryVertexValidation.PrimaryVertexValidation.__init__(), zMuMuValidation.ZMuMuValidation.__init__(), offlineValidation.OfflineValidation.__init__(), preexistingValidation.PreexistingOfflineValidation.__init__(), plottingOptions.PlottingOptionsTrackSplitting.__init__(), plottingOptions.PlottingOptionsZMuMu.__init__(), plottingOptions.PlottingOptionsOffline.__init__(), plottingOptions.PlottingOptionsPrimaryVertex.__init__(), genericValidation.GenericValidationData.__init__(), genericValidation.GenericValidationData_CTSR.cosmics0T(), preexistingValidation.PreexistingValidation.filesToCompare(), monteCarloValidation.MonteCarloValidation.getRepMap(), trackSplittingValidation.TrackSplittingValidation.getRepMap(), preexistingValidation.PreexistingValidation.getRepMap(), primaryVertexValidation.PrimaryVertexValidation.getRepMap(), zMuMuValidation.ZMuMuValidation.getRepMap(), offlineValidation.OfflineValidation.getRepMap(), preexistingValidation.PreexistingOfflineValidation.getRepMap(), plottingOptions.BasePlottingOptions.getRepMap(), preexistingValidation.PreexistingPrimaryVertexValidation.getRepMap(), genericValidation.GenericValidation.getRepMap(), and genericValidation.GenericValidationData_CTSR.use_d0cut().

string betterConfigParser.BetterConfigParser.internal_section = "internals"

static

Definition at line 166 of file betterConfigParser.py.

betterConfigParser.BetterConfigParser.knownSimpleOptions

static

Definition at line 164 of file betterConfigParser.py.

list betterConfigParser.BetterConfigParser.mandatories

static

Initial value:

 = [
             "eosdir",
         ]

Definition at line 161 of file betterConfigParser.py.

betterConfigParser.BetterConfigParser.OPTCRE_VALIDATION

static

Initial value:

 = re.compile(
         r'(?P<option>'
         r'(?P<preexisting>preexisting)?'
         r'[^:=\s][^:=]*)'                     # very permissive!
         r'\s*(?(preexisting)|'                # IF preexisting does not exist:
         r'(?P<vi>[:=])\s*'                    #   any number of space/tab,
                                               #   followed by separator
                                               #   (either : or =), followed
                                               #   by any # space/tab
         r'(?P<value>.*))$'                    #   everything up to eol
         )

Definition at line 243 of file betterConfigParser.py.

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation