SmootLight.util.Config

+ 1 from xml.etree.ElementTree import * + 2 import re + 3 import sys + 4 import xml + 5 import pdb + 6 import util.Strings as Strings + 7 import util.Search as Search + 8 from logger import main_log, exception_log + 9 classArgsMem = {} + 10 CONFIG_PATH = 'config/' + 11 DEFAULT_OVERRIDE_MODE = 'Merge' + 12 +

13 -def loadParamRequirementDict(className): +

14 if not className in classArgsMem: #WOO CACHING + 15 classArgsMem[className] = fileToDict(CONFIG_PATH + className) + 16 return classArgsMem[className] +

17 +

18 -def loadConfigFile(fileName): #TODO: error handling etc. +

19 """Loads a config file. If its an xml file, inheritances are automatically resolved.""" + 20 try: + 21 if '.params' in fileName: + 22 return fileToDict(fileName) + 23 if '.xml' in fileName: + 24 config = ElementTree() + 25 config.parse(fileName) + 26 resolveDocumentInheritances(config.getroot()) + 27 return config + 28 except Exception as inst: + 29 main_log.info('Error loading config file ' + fileName)#, inst) TODO: log exception too + 30 main_log.info(str(inst)) + 31 return None +

32 -def getElement(el): +

33 """Takes an Element or an ElementTree. If it is a tree, it returns its root. Otherwise, just returns + 34 it""" + 35 if xml.etree.ElementTree.iselement(el): + 36 return el + 37 elif el.__class__ == ElementTree: + 38 return el.getroot() +

39 -def compositeXMLTrees(parentTree, overridingTree): +

40 """XML tree composition. Returns the resulting tree, but happens in-place in the overriding + 41 tree.""" + 42 #TODO: break up into sub-methods, change it to use .find() + 43 if parentTree == None: + 44 return overridingTree + 45 if overridingTree == None: + 46 return parentTree #TODO: this will probably cause a bug since it isn't in-place on + 47 #overridingTree + 48 parentTree = getElement(parentTree) + 49 overridingTree = getElement(overridingTree) + 50 parentItems = parentTree.getchildren() + 51 overrideItems = overridingTree.getchildren() + 52 #first, lets figure out what tags we have in the override tree: + 53 tagCollection = [el.tag for el in overrideItems] #we can speed this up with a dict if necessary + 54 for item in parentItems: + 55 if not item.tag in tagCollection: #no override + 56 overridingTree.insert(-1, item) #insert the new item at the end + 57 else: + 58 #do we merge or replace? + 59 intersectingElements = findElementsByTag(item.tag, overrideItems) + 60 if len(intersectingElements) > 1: + 61 main_log.warn('ABUSE! Override of multiple items isn\'t well defined. Don\'t do\ + 62 it!') + 63 interEl = intersectingElements[0] + 64 mode = DEFAULT_OVERRIDE_MODE + 65 if Strings.OVERRIDE_BEHAVIOR in interEl.attrib: + 66 mode = interEl.attrib[Strings.OVERRIDE_BEHAVIOR] + 67 if mode != 'Replace' and mode != 'Merge': + 68 main_log.warn('Bad Override Mode. Choosing to replace.') + 69 mode = 'Replace' + 70 if mode == 'Replace': + 71 pass #we don't need to do anything + 72 if mode == 'Merge': + 73 interEl = compositeXMLTrees(item, interEl) + 74 for item in overrideItems: #resolve appendages + 75 if item.tag == 'APPEND': + 76 children = item.getchildren() + 77 for child in children: + 78 overrideItems.insert(-1, child) + 79 overrideItems.remove(item) + 80 return overridingTree + 81 +

82 -def findElementsByTag(tag, eList): +

83 return [el for el in eList if el.tag == tag] +

84 +

85 -def fileToDict(fileName): +

86 fileText = '' + 87 try: + 88 with open(fileName) as f: + 89 for line in f: + 90 fileText += line.rstrip('\n').lstrip('\t') + ' ' + 91 except IOError: + 92 main_log.info('Failure reading ' + fileName) + 93 return {} + 94 if fileText == '': + 95 return {} + 96 try: + 97 resultDict = eval(fileText) + 98 main_log.info(fileName + ' read and parsed') + 99 return resultDict +100 except: +101 main_log.exception(fileName + ' is not a well formed python dict. Parsing failed') +102 return eval(fileText) +

103 +

104 -def pullArgsFromItem(parentNode): +

105 """Parses arguments into python objects if possible, otherwise leaves as strings""" +106 attribArgs = {} +107 for arg in parentNode.attrib: #automatically pull attributes into the argdict +108 attribArgs[arg] = attemptEval(parentNode.attrib[arg]) +109 argNode = parentNode.find('Args') +110 args = generateArgDict(argNode) +111 for key in attribArgs: +112 args[key] = attribArgs[key] +113 return args +

114 +

115 -def attemptEval(val): +

116 """Runs an eval if possible, or converts into a lambda expression if indicated. Otherwise, +117 leaves as a string.""" +118 try: +119 if '${' in val and '}$' in val: #TODO: this could be a little cleaner +120 dictVal = re.sub("'\$\{(.+?)\}\$'", "b['\\1']", val) #replace expressions '${blah}$' with b['blah'] +121 dictVal = re.sub("\$\{(.+?)\}\$", "a['\\1']", dictVal) #replace all expressions like {blah} with a['blah'] +122 if "'${" and "}$'" in val: #nested lambda madness +123 lambdaVal = eval('lambda a: lambda b: ' + dictVal) +124 else: +125 lambdaVal = eval('lambda a:'+dictVal) #TODO: nested lambdas +126 return lambdaVal #convert referential objects to lambda expressions which can be +127 #resolved dynamically. +128 else: +129 val = eval(val) +130 except (NameError, SyntaxError): +131 val = str(val) +132 return val +

133 +

134 -def generateArgDict(parentNode, recurse=False): +

135 args = {} +136 for arg in parentNode.getchildren(): +137 key = arg.tag +138 if arg.getchildren() != []: +139 value = generateArgDict(arg, True) +140 else: +141 #convert into python if possible, otherwise don't +142 value = attemptEval(arg.text) +143 if key in args: #build of lists of like-elements +144 if type(args[key]) != type([]): +145 args[key] = [args[key]] +146 args[key].append(value) +147 else: +148 args[key]=value +149 #if we should be a list but we aren't: +150 if len(args.keys()) == 1 and recurse: +151 return args[args.keys()[0]] +152 return args +

153 -def resolveDocumentInheritances(el): +

154 """In place resolution of document inheritances. Doesn't return anything.""" +155 abstractMembers = Search.parental_tree_search(el, '.getchildren()', '.tag==\'InheritsFrom\'') +156 for subel in abstractMembers: +157 subel = resolveInheritance(subel) +

158 -def resolveInheritance(el): +

159 """In place resolution of inheritence. Doesn't return anything.""" +160 parentClass = el.find('InheritsFrom') +161 if parentClass != None: +162 parentTree = loadConfigFile(parentClass.text) +163 if parentTree == None: +164 main_log.warn('Inheritance Failed. ' + parentClass.text + 'does not exist') +165 main_log.error('Inheritance Failed. ' + parentClass.text + 'does not exist') +166 return el +167 el = compositeXMLTrees(parentTree, el) +168 el.remove(parentClass) #get rid of the inheritance flag +

169 +

Source Code for Module SmootLight.util.Config