cfg-viewer.py

Go to the documentation of this file.

#!/usr/bin/env python
# -*- coding: latin-1 -*-
from __future__ import print_function
import re
import collections
import FWCore.ParameterSet.Config as cms
import FWCore.ParameterSet.SequenceTypes as seq
import six

class unscheduled:
    def __init__(self,cfgFile,html,quiet,helperDir,fullDir):
        self._html = html
        #self._serverName = os.path.join(os.path.split(html)[0],"EditingServer.py")
        self._quiet = quiet
        self._theDir= fullDir
        self._helperDir = helperDir
        self._mother,self._daughter ={},{}
        self._reg = re.compile("['>]")
        self._data,self._types,self._genericTypes={},{},{}
        self._dictP ="DictParent"
        self._modSeqP = "ModuleSeqParent"
        self._prodConsP=  "ProdConsumParent"
        self._parents = {
        "DictParent":{"creator":"dictCreate","simple": True},
        "ModuleSeqParent":{"creator":"modSeqCreate","simple": False},
        "ProdConsumParent":{"creator":"prodConCreate","simple": False}
        }
        for name,x in six.iteritems(self._parents):
            x["pfile"] = self._filenames(name)
            x["cfile"] = self._filenames(x["creator"])
        self._type = "%stypes.js"%(fullDir)
        self._allJSFiles =["types.js"]
        self._config = ConfigDataAccessor.ConfigDataAccessor()
        self._config.open(cfgFile)
        self._computed = self._proceed(cfgFile)

    def _proceed(self, fileName):
        #self._filename= ""
        topObjs = self._config.topLevelObjects()
        if(len(topObjs)):
            self._getData(topObjs)
            ty = "genericTypes"
            with open(self._type, 'w') as f:
                f.write("var %s=%s"%(ty,genericTypes))
            self._createObjects()
            self._writeDictParent(ty)
            self._writeModSeqParent()
            self._writeProdConsum()
            fN = fileName.split("./")[-1].split(".")[0]
            JS = ["%s%s"%(self._helperDir,x)for x in self._allJSFiles]
            html(self._html,JS,self._data, self._theDir, self._helperDir,
            self._config.process().name_(), fN)

            return True
        else:
            print("---Nothing found for file %s."\
                 " No computation done.---"%(fileName))
            return False

    def _getData(self,objs):
        # i will loop around objs and keep adding things which are configFolders
        calc =[]
        for each in objs:
            name = self._config.label(each)
            kids = self._config.children(each)
            if(not kids):
                if(not self._quiet):print(name, "is empty.")
                continue
            # Taking liberty of assuming all are of same type.
            ty = type(kids[0])
            if(ty is ConfigDataAccessor.ConfigFolder):
                objs.extend(kids)
            else:
                if(not self._quiet):print("computing %s.."%(name))
                if(isinstance(kids[0], seq._ModuleSequenceType)):
                    # e.g.it's a path, sequence or endpath
                    self._doSequenceTypes(kids,name)
                else:
                    # e.g. it's a pset etc.
                    self._doNonSequenceType(kids,name)
                calc.append(name)
        # now i will print out producers/consumers.
        if(self._quiet):print("calculated: %s."%(", ".join(calc)))
        self._producersConsumers()

    # Get the data for items which are SequenceTypes
    def _doSequenceTypes(self,paths,namep):
        theDataFile,fullDataFile = self._calcFilenames(namep)
        topLevel,fullTopLevel = self._calcFilenames("top-"+namep)
        json = [topLevel,theDataFile]
        cap = namep.capitalize()
        bl={}
        types = False
        with open(fullDataFile,'w') as data:
            data.write("{")
            v = visitor(data, self._config)  
            for item in paths:
                if(not types):
                    spec = self._checkType(item)
                    self._saveData(spec,self._parents[self._modSeqP]["creator"],json) 
                    types = True
                name = self._config.label(item)
                # Dont think we need to check for this here. 
                self._mothersDaughters(name,item)
                key = self._config.label(item)
                item.visit(v)
                bl[key]= getParamSeqDict(v._finalExit(),
                            self._config.fullFilename(item), self._config.type(item), "")
            data.write("}")
            with open(fullTopLevel, 'w') as other:
                other.write(JSONFormat(bl))

    # Check type of item and return the specofic type
    def _checkType(self,item):
        gen, spec = re.sub(self._reg, "", 
                                 str(item.__class__)).split(".")[-2:]
        doTypes(spec,gen)
        return spec

    # find the mothers and daughters, storing them
    def _mothersDaughters(self,name, item):
        mo =self._config.motherRelations(item)
        dau = self._config.daughterRelations(item)
        if(mo):
            self._mother[name] = [self._config.label(i) for i in mo]
        if(dau):
            self._daughter[name] = [self._config.label(i) for i in dau]

    # Find data for objs which are not SequenceTypes
    def _doNonSequenceType(self,objs, globalType):
        everything={}
        always= types = False
        theDataFile, fullDataFile = self._calcFilenames(globalType)
        # For modules types can be diff 
        # so we always want to call the doTypes method
        if(globalType =="modules"):
            self._saveData(globalType.capitalize(),
                           self._parents[self._dictP]["creator"],
                           [theDataFile]) 
            always = types = True
        for item in objs:
            if(always or not types):
                spec = self._checkType(item)
                if(not types):
                    self._saveData(spec,self._parents[self._dictP]["creator"],
                                   [theDataFile]) 
                    types = True
            name = self._config.label(item)
            self._mothersDaughters(name, item)
            if(isinstance(item,cms._Parameterizable)):
                out = getParameters(item.parameters_())
            elif(isinstance(item,cms._ValidatingListBase)):
                out = listBase(item)
            if(isinstance(item,cms._TypedParameterizable)):
                oType = item.type_()
            else:
                oType =""
            everything[name] = getParamSeqDict(out,
                                 self._config.fullFilename(item),
                                 self._config.type(item), oType)
        with open(fullDataFile,'w') as dataFile:
            dataFile.write(JSONFormat(everything))

    # Return json data file names
    def _calcFilenames(self,name):
        return self._filenames(name,"data-%s.json")

    # Return filenames
    def _filenames(self,name,option=""):
        if(option): basicName = option%(name)
        else: basicName = "%s.js"%(name)
        return (basicName, "%s%s"%(self._theDir,basicName))

    # write out mothers and daughters (producers/consumers).
    def _producersConsumers(self):
        if(not self._mother and not self._daughter):
            return  
        for name,theDict in six.iteritems({"producer":self._mother, 
                                           "consumer":self._daughter}):
            thedataFile , fulldataFile = self._calcFilenames(name)
            self._saveData(name.capitalize(),
                            self._parents[self._prodConsP]["creator"],
                            [thedataFile,self._calcFilenames("modules")[0]]) 
            with open(fulldataFile,'w') as moth:
                moth.write(JSONFormat(theDict))
    def _saveData(self,name,base,jsonfiles):
        jsonfiles = " ".join(["%s%s"%(self._helperDir,x)for x in jsonfiles])
        temp={}
        temp["data-base"] = base
        temp["data-files"] = jsonfiles
        self._data[name] = temp

    # Create objs and print out .js files for
    # each type of items we have.
    def _createObjects(self):
        base = "obj= Object.create(new %s(%s));"
        format="""
    function %s(%s){
      var obj;
      %s
      return obj;
    }
    """
        name = "data"
        for pname,x in six.iteritems(self._parents):
            simple = base%(pname,name)
            filename,fullfilename= x["cfile"]
            self._allJSFiles.append(filename)
            if(x["simple"]):
                paramName="modules"
                with open(fullfilename, 'w') as setUp:
                    setUp.write(format%(x["creator"],paramName,self._load(
                                                       name,paramName,simple)))
                continue
            secName = "topL"
            paramName=["modules","topLevel"]
            complexOne = base%(pname,"%s,%s"%(name, secName))
            with open(fullfilename, 'w') as setUp:
                setUp.write(format%(x["creator"],", ".join(paramName),
                              self._load(name,paramName[0],
                              self._load(secName, paramName[1],complexOne))))

    # return the .js code for loading json files in a string
    def _load(self,name,param,inner):
        return"""
      loadJSON(%s).done(function(%s){\n%s\n});
    """%(param,name,inner)

    # The parent class for non SequenceTypes
    def _writeDictParent(self, typeName):
        exVar ='this.%(key)sKey= "%(key)s";'
        exFunc ="""
/**
 * Gives the %(key)s 
 * @param {String} the key to the dictionary.
 * @returns {String || Integer} result from dictionary if found else 0.
 */
%(name)s.prototype.get%(key)s = function(key){
  return this.getFeature(key,this.%(key)sKey);
}
    """
        search = """%(name)s.prototype.search%(key)s = function(reg,term,replce){
  return this.generalSearch(reg,term,replce,this.%(key)sKey);
}  """
        extra= """
    /**
    /**
* Uses the list of parents names to go further into
* the lists in the dictionry, and give the last parents children.
* @param {Array} the names of parents to look through.
*                 First parent should be a key to the dictionary. 
* @param {Integer} the index where the elusive parameter is. Needed incase 
*         we have a list with muultiple parameters of the same name.
*                 
* @returns {Array} the resulting children from the last parent.
*/
DictParent.prototype.getInnerParams = function(parents, index){
  var currentList = this.data[parents[0]][this.%(key)sKey];
  var targetList=[]
  var siblingsOfTarget=[]
  for(var i=1; i < parents.length;i++){
    for(var p=0; p < currentList.length;p++){
      if(currentList[p][0]==parents[i]){
        targetList = currentList[p]
        siblingsOfTarget=currentList
        var found = targetList[1];
        break;
      }
    }
    currentList = found;
  }
  if(p != index)targetList=siblingsOfTarget[index]
  return targetList;
}
    """
        functs=""
        variables =""
        name = self._dictP
        data = self._parents[name]
        fileName, fullfileName= data["pfile"]
        for feature in dictFeatures:
            d = {"key": feature, "name": name}
            variables +=exVar%d
            functs +=exFunc%d
            if(feature == "Parameters"):
                functs +=extra%d
            else:
                functs += search%d
        self._allJSFiles.append(fileName)
        with open(fullfileName, 'w') as parent:
            parent.write("""
/*
  Base Object for dictionaries.
  To use, create a dictParent obj,
  then use Object.create to create a new obj
  then you can change some variables/add functions
  and have the inherited functions.
*/
function %(name)s(data){
  this.data=data;
  %(theVars)s
}
/**
 * Finds the desired feature from a dictionary.
* @param {String} the key to the dictionary.
* @param {String} the feature we want from the dictionary.
* @returns {String || Integer} result from dictionary if found else 0.
*/
%(name)s.prototype.getFeature = function(key, feature){
  var temp = this.data[key];
  if(temp) return temp[feature];
  else return 0;
}
DictParent.prototype.getData = function(){
  return [this.data];
}
%(getterFunctions)s

/**
 * Gives the keys from desired dictionary.
* @returns {Array} all keys from the dictionary.
*/
%(name)s.prototype.getKeys = function(){
  return Object.keys(this.data);
}
%(name)s.prototype.generalSearch = function(reg,term,repl,feature, d){
  d = d || this.data;
  var matches ={}
  for (var key in d){
    var x= d[key][feature]
    if(x.indexOf(term)>-1){
      matches[key] = x.replace(reg,repl)
    }
  }
  return matches;
}

/**
 * Gives the generic type for a given type.
 * @param {String} type 
 * @returns {String} the generic type
 */
function getGenericType(type){
    return %(gen)s[type];
}
   """%{"theVars":variables,"getterFunctions":functs, 
              "gen": typeName, "name":name})

    # Write out the class for SequenceTypes
    def _writeModSeqParent(self):
        f = """
/**
 * Gives the direct children
 * @param {String} a path name
 * @returns {Array} list of names of the the children.
 */
%(name)s.prototype.getModules = function(name){ 
  return this.topLevelData[name][this.ParametersKey];
}
%(name)s.prototype.getTopFile = function(key){
  return this.topLevelData[key][this.FileKey];
}
%(name)s.prototype.getData = function(){
  return [this.topLevelData, this.data];
}
%(name)s.prototype.searchType = function(reg,term,replce){
  return this.generalSearch(reg,term,replce,this.TypeKey, this.topLevelData);
}
%(name)s.prototype.searchFile = function(reg,term,replce){
  return this.generalSearch(reg,term,replce,this.FileKey, this.topLevelData);
}
"""
        self._complexBase(self._modSeqP, f)

    # Write out the class for producers and consumers.
    def _writeProdConsum(self):
        f= """
/**
 * Gives the direct children
 * @param {String} a path name
 * @returns {Array} list of names of the the children.
 */
%(name)s.prototype.getModules = function(name){ 
  return this.topLevelData[name];
}
%(name)s.prototype.getTopFile = function(key){
  return this.getFile(key);
}
%(name)s.prototype.getData = function(){
  return [this.topLevelData, this.data];
}
// Producer and consumer have different structure to rest.
// Dont have file and type with them..
// to get file and type we need to take each name, 
//look up the moduledata and find matches.
%(name)s.prototype.generalSearch = function(reg,term,repl, feature){
  var matches ={}
  for (var key in this.topLevelData){
    var x = this.data[key][feature]
    if(x.indexOf(term)>-1){
      matches[key] = x.replace(reg,repl)
    }
  }
  return matches;
}
%(name)s.prototype.typeSearch = function(reg,term,replce){
  return this.generalSearch(reg,term,replce,this.TypeKey);
}
%(name)s.prototype.fileSearch = function(reg,term,replce){
  return this.generalSearch(reg,term,replce,this.FileKey);
}
  """
        self._complexBase(self._prodConsP, f)

    def _complexBase(self,parentName, extra):
        name = parentName
        data = self._parents[name]  
        fileName, fullfilename= data["pfile"]
        self._allJSFiles.append(fileName)
        all = """
/* 
 Base object for thing of the type: 
 It also inherits from DictParent.           
*/                                          
function %(name)s(data,topLevel, nameList,indexList){ 
  this.data = data; 
  this.topLevelData=topLevel;// e.g. pathNames to module names 
  this.fixedNameList = nameList; // e.g.names of paths 
}
%(name)s.prototype = new %(dict)s(this.data);

%(name)s.prototype.getKeys = function(){
  return Object.keys(this.topLevelData)
}
      """+ extra
        with open(fullfilename, 'w') as parent:
            parent.write(all%{"name": name, "dict": self._dictP})

# Helper function which gets parameter details.
def getParameters(parameters):
    all =[]
    if(not parameters):
        return []
    for (name,valType) in six.iteritems(parameters):
        theT= (valType.configTypeName() if(
               hasattr(valType,"configTypeName")) else "").split(" ",1)[-1]
        temp = re.sub("<|>|'", "", str(type(valType)))
        generic, spec = temp.split(".")[-2:]
        doTypes(spec,generic)
        theList=[name]
        if(isinstance(valType,cms._Parameterizable)):
            theList.append(getParameters(valType.parameters_()))
        elif(isinstance(valType,cms._ValidatingListBase)):
            theList.append(listBase(valType))
        else:
            if(isinstance(valType,cms._SimpleParameterTypeBase)):
                value = valType.configValue()
            else:
                try:
                    value = valType.pythonValue()
                except:
                    value = valType
            theList.append(value) 
            if(theT != "double" and theT !="int" and not isinstance(valType, str)):
                if(not valType.isTracked()):
                    theList.append("untracked")
        theList.append(theT)
        all.append(theList)
    return all

def listBase(VList):
    # we have a list of things.. 
    #loop around the list get parameters of inners.
    #Since ValidatingListBases "*usually* have the same types 
    #throughout, just test first --is this a rule?
    # Find out and if needed move these ifs to the loop.
    if(not VList):return ""
    first = VList[0]
    if(isinstance(first,cms._Parameterizable)or 
       isinstance(first,cms._ValidatingListBase)):
        anotherVList=False
        if(isinstance(first,cms._ValidatingListBase)):
            anotherVList=True
        outerList=[]
        for member in VList:
            if(member.hasLabel_()):
                name = member.label()
            else:
                name = member.configTypeName()
            innerList=[name]
            if(not anotherVList):
                innerList.append(getParameters(member.parameters_()))
            else:
                innerList.append(listBase(member))
            temp = re.sub("<|>|'", "", str(type(member)))
            generic, spec = temp.split(".")[-2:]
            doTypes(spec,generic)
            innerList.append(spec)
            outerList.append(innerList)
        return outerList
    elif(isinstance(first,cms._SimpleParameterTypeBase)):
        return ",".join(i.configValue() for i in VList)
    elif(isinstance(first,cms._ParameterTypeBase)):
        return ",".join(i.pythonValue() for i in VList)
    else:
        #Most things should at least be _ParameterTypeBase, adding this jic
        try:
            outcome = ",".join(str(i) for i in VList)
            return outcome
        except:
            return "Unknown types"


dictFeatures=["Parameters", "Type", "File", "oType"]
# Used to enforce dictionary in datafiles.
def getParamSeqDict(params, fil, typ, oType):
    d={}
    d[dictFeatures[0]] = params
    d[dictFeatures[1]] = typ
    d[dictFeatures[2]] = fil
    d[dictFeatures[3]] = oType
    return d

class visitor:
    def __init__(self, df, cfg):
        self._df = df
        self._underPath = [] # direct children of paths 
                             #(includes children of modules)
        self._modulesToPaths={} # map from modules to index of path -
        self._seq = 0
        self._pathLength=0
        self._currentName =""
        self._oldNames =[]
        self._done =[]
        self._seqs={}
        self._typeNumbers = {}
        self._innerSeq = False
        self._reg= re.compile("<|>|'")
        self.config = cfg

    def _finalExit(self):
        self._pathLength+=1
        temp = self._underPath
        self._underPath =[]
        return temp

    # Only keep in if we manage to move doModules into this class
    def _getType(self,val):
        return re.sub(self._reg, "", str(type(val))).split(".")[-2:]

    """
    Do Module Objects e.g. producers etc
  """
    def _doModules(self,modObj, dataFile, seq, seqs, currentName, innerSeq):
        #name = modObj.label_()
        name = self.config.label(modObj)
        # If this is not an inner sequence then we add so it can go to paths
        if(seq==0):
            self._underPath.append(name)
        else:
            seqs[currentName].append([name])
        # If we've seen this name before, no need to compute values again.
        # we need to put this mod/seq name under the path name in the dict
        if(name not in self._modulesToPaths.keys()):
            self._modulesToPaths[name] =[self._pathLength]
            filename = modObj._filename.split("/")[-1]
            generic,specific = self._getType(modObj)
            doTypes(specific,generic)
            d = getParamSeqDict(getParameters(modObj.parameters_()),
                                filename, specific, modObj.type_())
            theS='"%s":%s'
            if(len(self._modulesToPaths) > 1): theS=","+theS
            dataFile.write(theS%(name, JSONFormat(d))) 
        else:
            #oldMods.append(name) 
            self._modulesToPaths[name].append(self._pathLength)

    def enter(self, value):
        if(isinstance(value,cms._Module)):
            self._doModules(value, self._df, self._seq,
                      self._seqs, self._currentName, self._innerSeq)
        elif(isinstance(value,cms._Sequenceable)):
            generic,specific = self._getType(value)
            doTypes(specific, generic)
            if(isinstance(value, cms._ModuleSequenceType)):
                if(len(self._currentName) >0):
                    self._oldNames.insert(0, self._currentName)
                name = self.config.label(value)
                #name = value.label_()
                if(self._seq >0):
                    # this is an inner sequence
                    self._innerSeq = True;
                    self._seqs[self._currentName].append([name])
                else:
                    self._underPath.append(name)
                self._seqs[name] = []
                self._currentName = name
                self._seq +=1
            else:
                # just sequenceable.. 
                name = value.__str__()
                if(self._currentName):
                    self._seqs[self._currentName].append([name, specific])
                else:
                    self._underPath.append(value.__str__())
                    if(name not in self._done):
                        d = getParamSeqDict([], "", specific, "")
                        self._df.write(',"%s":%s'%(name,JSONFormat(d))) 
                        self._done.append(name) 

    def leave(self, value):
        if(isinstance(value,cms._Module)):
            return
        elif(isinstance(value,cms._Sequenceable)):
            # now need to determine difference between 
            #ones which have lists and ones which dont
            if(isinstance(value, cms._ModuleSequenceType)):
                #name = value.label()
                name = self.config.label(value)
                if(name in self._oldNames):self._oldNames.remove(name)
                if(self._currentName == name):
                    if(self._oldNames):
                        self._currentName = self._oldNames.pop(0)
                    else:
                        self._currentName=""
                if(name not in self._done):
                    generic,specific = self._getType(value)
                    d = getParamSeqDict(self._seqs.pop(name), "", specific, "")
                    self._df.write(',"%s":%s'%(name,JSONFormat(d)))
                    self._done.append(name)  
                self._seq -=1
                if(self._seq==0): self._innerSeq = False;

class html:
    def __init__(self,name,js,items,theDir, helperDir, pN,pFN):
        jqName = "%scfgJS.js"%(theDir)
        jqLocal = "%scfgJS.js"%(helperDir)
        css = "%sstyle.css"%(theDir)
        cssL = "%sstyle.css"%(helperDir)
        js.insert(0,jqLocal)
        self._jqueryFile(jqName, pN,pFN)
        self._printHtml(name,self._scripts(js),self._css(css, cssL),
                        self._items(items), self._searchitems(items))

    def _scripts(self, js):
        x = """
<script type="text/javascript" src="%s"></script>"""
        return "\n".join([x%(i) for i in js])

    def _items(self, items):
        l= """
<option value=%(n)s data-base="%(d)s" data-files="%(f)s"> %(n)s</option>"""
        s= [l%({"n":x,"f":y["data-files"],"d":y["data-base"]})
            for x,y in six.iteritems(items)]
        return " ".join(s)

    def _searchitems(self,items):
        b = """<option value="%(name)s" data-base="%(d)s">%(name)s</option> """
        return "\n ".join([b%({"name": x, "d":y["data-base"]})
               for x,y in six.iteritems(items)])

    def _printHtml(self,name,scrip,css,items, search):
        with open(name,'w') as htmlFile:
            htmlFile.write("""<!DOCTYPE html>\n<html>\n  <head>
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" >
    <title>cfg-browser</title>\n    <script type="text/javascript" 
       src="http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js">
    </script>\n    %(s)s\n    %(css)s\n  </head>\n  <body>
      <div class="topBox topSpec">
      <input type="submit" value="Edit" id="editMode" autocomplete="off"
        disabled/>\n      <div class="helpLinks">
        <a href="#" class="nowhere" id="helpMouse" data-help="#help">help
        </a></br/>
        <a href="mailto:susie.murphy@cern.ch?Subject=CfgBrowserhelp" 
         target="_top">Contact</a>\n      </div>\n      <div id="help"> </div>
      <span id="mode">Normal Mode</span>
      <div class="topBox hideTopBox">hide</div>\n    </div>
    <a id="topOfPage"></a>\n    <br/><br/><br/>\n    <div class="outerBox">
      <div class="boxTitle"> Pick\n        <div class="dottedBorder">
          <form onsubmit="return false;">\n            <select id="showType">
             %(items)s\n            </select>\n            <br/><br/>
            <input type="submit" id="docSubmit" value="submit">
          </form>\n        </div>\n      </div>
      <div class="boxTitle"> Pick\n        <div class="dottedBorder">
          <form onsubmit="return false;">
            <input type="text" id="searchWord"/>
            <select id="searchType">\n              %(search)s
           </select> \n            <span id="addSearch"> </span>
            <br/><br/>
            <input type="submit" value="Search" id="search"/>
            <input type="checkbox" id="rmHilight" value="File"/>
            <span>Don't show highlights</span>\n          </form> 
        </div>\n      </div>\n    </div> \n    <br/>
    <input type="checkbox" id="ShowFiles" value="File"/>
    <span>Show file names</span>\n    <br/><br/>\n    <script>
      document.getElementById("searchType").selectedIndex = -1;\n    </script>
    <div id="posty"> </div>\n    <br/>\n    <div id="current"></div>
    <br/>\n    <div id="searchCount"></div>\n    <div id="attachParams"></div>
    <div class="rightScroll">\n      <a href="#topOfPage">Back to Top</a>
      <p>\n        <a id="hide" href="javascript:;" >Hide All</a>\n      </p>
    </div>\n  </body>\n</html>\n"""%{
            "s":scrip,"css":css,"items":items, "search":search})

    def _css(self, css, cssLocal):
        with open(css, 'w') as cssfile:
            cssfile.write("""
*{\n   font-family:"Lucida Grande", Tahoma, Arial, Verdana, sans-serif;\n}
.topBox{\n  opacity:0.9;\n  background-color:#dfdfdf;\n}\n.topSpec{
    position:fixed;\n  top:0;\n  left:0;\n  width:100%;\n  height:2.5em;
  border-radius:.9em;\n}\n.hideTopBox, .showTopBox{\n  position:absolute;
  top:2.5em;\n  right:2%;\n  width:auto;\n  height:auto;\n  padding: 0.2em;
  font-weight:bold;\n  cursor:pointer;\n  border-radius:.3em;\n}\n.negative{
    position:absolute;\n    right:0;\n    text-decoration:none;
    font-weight:bold;\n    color:#565656;\n}\n#mode{\n  position:absolute;
  right:50%; \n  color:#808080;\n  font-size:12pt;\n}\n#editMode,#normalMode{
  position:absolute;\n  left:.3em;\n  top:.5em;\n}\n#save{
  position:absolute;\n  top:.5em;\n}\n.helpLinks{\n  position:absolute;
  right:1.3em;\n  width:6.2em;\n  text-align:right;\n}
/* divs for the Pick and Search boxes.*/\n.outerBox{\n  width:100%;
  overflow:hidden;\n}\n.boxTitle{\n  float:left;\n  margin-left:.6em;
  color:#A9A9A9;\n}\n.dottedBorder{\n  width:25em;\n  height:4em;
  border:.1em dashed #A9A9A9;\n  padding:.6em;\n}\n/* -- */
/* Right scroll box. */\n.rightScroll{\n  position:fixed;\n  bottom:50%;
  right:0; \n  width:6.2em;\n  text-align:right;\n  border:.1em solid #A9A9A9;
  opacity:0.4;\n  background-color:#F0FFF0;\n}\n#hide{\n  cursor:default;
  opacity:0.2;\n}\nli{\n  padding-left:.8em;\n}\nul{\n  list-style-type:none;
  padding-left:.1em;\n}\n/* Icons before list items. */\n.expand:before{
  content:'›';\n}\n.expanded:before{\n  content:'ˇ';\n}
.expand:before,.expanded:before{\n  float:left;\n  margin-right:.6em;\n}
.expand,.expanded{\n  cursor:pointer;\n}\n/* colours of each. */
.Path,.EndPath{\n  color:#192B33;\n}\n.Modules{ \n  color:#800080;\n}
.SequenceTypes{\n  color:#0191C8\n}\n.paramInner,.Types{\n  color:#4B4B81;\n}
.param{\n  color:#9999CC;\n  margin-left:.8em;\n  cursor:default; \n}\n.value{
  color:#0000FF;\n}\n.type{\n  color:#00CCFF;\n}
/* Header for what's showing */\n#current{\n  color:#808080;\n  font-size:12pt;
  text-decoration:underline; \n}\n/* help settings */\n#help{
  position:absolute;\n  display:none;\n  background:#ccc;\n  border:.1em solid;
  width:19em;\n  right:15em;\n  top:1.2em;\n}\nh5{\n  font-style:normal;
  text-decoration:underline; \n  margin:0;\n  font-size:9pt;\n}\nh6{
  margin:0;\n  color:#666666;\n}\n#attachParams{\n  color:#192B33;\n}\nem{
  color:#FFA500;\n}\n.cellEdit{\n  border:.1em dotted #A9A9A9;\n  cursor: text;
}\n""")
        return """<link href="%s" rel="stylesheet" \
           type="text/css"/>"""%(cssLocal)

    def _jqueryFile(self,name, pN,pFN):
        with open(name, 'w')as jq:
            jq.write("""
\n$(document).ready(function(){ \n//Object used to get all details
var processName="%s";\nvar processFileName ="%s";
var CURRENT_OBJ;\nvar searchShowing= false;\nvar showParams = false
var alreadyShowing = false\nvar topClass = "Top"\nvar searching = false
var expandDisable = false;\nvar hideVisible=false //nothing is expanded.
// ---\n/*\n Functions used to abstract away name of function calls
  on the object (CURRENT_OBJ).
  (i.e. so function names can easily be changed.)\n*/
function baseParams(inputs){\n  return CURRENT_OBJ.getParameters(inputs);\n}
function baseInnerParams(inputs, index){
  return CURRENT_OBJ.getInnerParams(inputs, index);\n}
function baseType(inputs){\n  return CURRENT_OBJ.getType(inputs);\n}
function baseFile(inputs){\n  return CURRENT_OBJ.getFile(inputs);\n}
function baseTopFile(inputs){\n  return CURRENT_OBJ.getTopFile(inputs);\n}
// --- Show some inital data operations ---\n/*\n  Show something new!\n*/
$(document).on('click', '#docSubmit', function(e){
  var $elem =  $('#showType :selected')
  //get the function we want and the lists\n  setCURRENT_OBJ($elem)\n     
  addData($elem.attr("value"), CURRENT_OBJ.getKeys());\n  searchShowing= false;
});\n/*\n  Add data to the html.\n*/
function addData(docType, data, dataNames){
  $("#editMode").removeAttr("disabled"); \n var dataNames = dataNames || data;
  if(alreadyShowing){\n    //need to click cancel if its active.
    goNormal($("#normalMode"));\n    if(!searching)$("#searchCount").html("")
    invisibleHide()\n    paramOptions(false)
    $(document.getElementsByTagName('body')).children('ul').remove();\n  }
  $("#current").html(docType)\n  var gen = getGenericType(docType)
  var ty = docType\n  if(gen != undefined){\n    var gL =  gen.toLowerCase()
    if(gL=="modules"||gL=="types") var ty= gen;\n  }
  var $LI = $(document.createElement('li')
   ).addClass("expand").addClass(ty).addClass(topClass);
  docType= docType.toLowerCase()\n  var showTypes = false\n  showParams = true
  switch(docType){\n    case "producer":\n    case "consumer":
      showParams = false\n      paramOptions(true)
      $LI.addClass("Modules")\n      showTypes = true\n      break;
    case "modules":\n      $LI.addClass("Modules")\n      showTypes = true
      //showParams = true\n      break;\n  }
  var $UL = addTopData(data,$LI,showTypes,dataNames)\n  alreadyShowing = true;
  $UL.appendTo('#attachParams');\n}\n/*
 Used to add the top level data to html.\n*/
function addTopData(data,$LI,types,dataName){
  var dataName = dataName || data;
  var $UL = $(document.createElement('ul'));\n  var doNormalFile = false;
  var files = document.getElementById("ShowFiles").checked\n  if(files){
    try{\n      baseTopFile(dataName[0])\n    }\n    catch(e){
      doNormalFile = true;\n    }\n  }\n  for(var i=0; i < data.length;i++){
    var n = dataName[i]\n    var t = data[i];
    if(types)t += " ("+baseType(n)+")"\n    if(files){ 
      if(doNormalFile)var file = baseFile(n)
      else var file = baseTopFile(n)\n      t += " ("+file+")"}
    $UL.append($LI.clone().attr("data-name",n).html(t));\n  }\n return $UL;\n}
// --- end of inital showing data operations ---\n
// --- search operations ---\n
//$(document).on('click', "[name='searchTerm1']", function(e){
//$(document).on('click', "#searchType option", function(e){
$(document).on('click', '#searchType', function(e){\n  $("#addSearch").empty()
  var tname= $(this).text().toLowerCase();\n  var sel= jQuery('<select/>', {
      id:"searchType2"\n  })
  var li = (tname =="modules"|| tname == "producer"|| tname == "consumer")?
           ["Name", "Type", "File"]: ["Name", "File"]\n  for(var i in li){
    var x = li[i]\n  jQuery('<option/>',{\n      value:x,\n      text:x
    }).appendTo(sel)\n   }\n  sel.appendTo("#addSearch");\n});\n/*
  Current search only searches for top level things.\n*/
$(document).on('click','#search', function(e){\n   searching = true
   var first = $('#searchType :selected')\n   if(first.length ==0){ 
     window.alert("Please chose a search type."); \n     return;\n   }
   var doc = first.text()\n   var searchTerm = $('#searchWord').val()
   var $elem = $('option[value="'+doc+'"]')\n   setCURRENT_OBJ($elem)
   var reg = new RegExp(searchTerm, 'g')
   if($('#rmHilight').prop('checked'))\n     var fin = searchTerm\n   else
     var fin = "<em>"+searchTerm+"</em>"
   switch($('#searchType2 :selected').text()){\n   case "File":
     $("#ShowFiles").prop('checked', true);
     var items = CURRENT_OBJ.searchFile(reg,searchTerm,fin)
     var matchCount = fileTypeSearch(doc,items,true)\n     break;
   case "Type":\n     var items = CURRENT_OBJ.searchType(reg,searchTerm,fin)
     var matchCount = fileTypeSearch(doc,items,false)\n     break
   case "Name":\n     var matchCount = easySearch(searchTerm,reg, doc, fin)
   }\n   $("#searchCount").html(matchCount+ " found.")\n  searching = false;
  searchShowing= true;\n});\n/*\n  Used when searching top level elements.
  i.e. Module names, path names etc.
  We dont need to delve into any dictionaries, we just use the keys.\n*/
function easySearch(term,reg, doc, fin){\n  var keys = CURRENT_OBJ.getKeys()
  var matches = keys.filter(function(e, i, a){return (e.indexOf(term)>-1)})
  var highlights = matches.map(function(e,i,a){
                               return e.replace(reg, fin)})
  addData(doc, highlights,matches)\n  return matches.length\n}\n/*
  When searching type or file names of top level elements.\n*/
function fileTypeSearch(doc,items,file){
  var newFunct = function(name){return items[name]}\n  if(file){
    var backup = baseFile\n    var backup2 = baseTopFile
    baseFile = newFunct  \n    baseTopFile = newFunct\n  }\n  else {
    var backup = baseType\n    baseType = newFunct\n  }
  var matches = Object.keys(items)\n  addData(doc, matches)\n  if(file){
    baseFile = backup\n   baseTopFile = backup2\n  }\n  else baseType = backup
  return matches.length\n}\n// --- end of search operations ---\n
// --- edit operations ---\n// variables needed:
// will contain the highest parents, where something *might*
// be changed in its children.\nvar $potential=[]
// dict, keys are parentNames and values are lists of children changed
// under that parent\nvar parChildNames={}\n
$(document).on('click', '#editMode', function(e){\n  if(searchShowing)
    var dataType = $('#searchType :selected').attr("data-base")
  else var dataType = $('#showType :selected').attr("data-base")
  // Temp restriction of editing SequenceTypes e.g. Paths,EndPaths etc.
  if(dataType=="modSeqCreate"){
    window.alert("At the moment editing for SequenceTypes"+
                 " has been disabled.");\n    return;\n  }
  else if (dataType == "prodConCreate"){
    window.alert("Sorry, it is currently not possible to "+
                "edit producers and consumers.");\n    return;\n  }
  if(CURRENT_OBJ == undefined)return;
  // this is editing mode, turn off expansion\n  expandDisable = true;
  $("#mode")[0].textContent = "Edit Mode"\n  $(this).attr("value", "Cancel");
    var l = ($(this).width()/ parseFloat($("body").css("font-size"))+2.5)+"em"
    $(this).after(jQuery('<input>', {\n      type:"submit",
      value:"Save",\n      id:"save"\n    }).css({\n       left:l\n}));
  $(this).attr("id", "normalMode")\n  makeEditable(searchShowing);
  searchShowing = false;\n});\n/*
  Adds in div elements to make cells editable.\n*/
function makeEditable(rmSearch){\n  // add editable div to everything showing.
  var todo = jQuery.makeArray($(".Top"));\n  while(todo.length){
    var e = $(todo.pop())\n    if(rmSearch)
     e.html(e.html().replace(/(<em>|<\/em>)/g, ""))
    // we have the item.. lets get children
    var kids = jQuery.makeArray(e.children());
    // add divs to all children.\n    while(kids.length){
      var k = $(kids.pop())\n      var tag = k.prop("tagName")\n
      if(tag == "SPAN"){\n        if(k.prop("class")!="type")
          k.html('<div class="cellEdit" contenteditable>'+k.html()+'</div>')
        continue\n      }\n      if(tag =="LI"){
        // add the div but dont get children
        $(k.contents()[0]).wrap('<div class="cellEdit" contenteditable />');
      }\n      // check if have any children
      var moreKids = jQuery.makeArray(k.children());
      if(moreKids.length){\n        kids = kids.concat(moreKids)\n      }
    }\n    // now do current one
    $(e.contents()[0]).wrap('<div class="cellEdit" contenteditable />');\n  }
}\n/*\n  A cell which is editable has been clicked.\n*/
$(document).on('click', '.cellEdit', function(e){
  // we're in edit so things have a div parent over the text.
  // so get parent to get the thing we want.
  var $itemChanged = $(this).parent()
  // now go up until we find greatest parent(item with class==topClass)
  var classes = $itemChanged.attr("class")\n  var $parent = $itemChanged 
  while(classes.indexOf(topClass)==-1){\n    $parent = $parent.parent();
    classes = $parent.attr("class") || "";\n  }
  var parentName = $parent.attr("data-name");
  // doesnt matter if parent and child are the same.
  var parents = Object.keys(parChildNames)
  if(parents.indexOf(parentName)>-1){\n    // already been edited.
    var kids = parChildNames[parentName] 
    if(kids.indexOf($itemChanged.attr("data-name"))==-1){
      kids.push($itemChanged)\n    }\n  }\n  else{
    parChildNames[parentName]=[$itemChanged]\n  }\n  $potential.push($parent)
});\n//--- end of edit operations ---\n// --- start of save operations ---\n/*
 Save any changes.\n*/\n$(document).on('click', '#save', function(e){
  var allData = CURRENT_OBJ.getData();\n  var oldData = allData[0]
  goNormal($("#normalMode"));\n  if(allData.length >1){
    var top = allData[0];\n    var rest = allData[1];
    var changed = save(deepCopy(top),deepCopy(rest))\n  }\n  else{
    var changed = save(deepCopy(allData[0]));\n  }
  if(Object.keys(changed).length ==0){
    window.alert("Nothing was changed.");\n    $potential=[]
    parChildNames={}\n    return \n  }
  //$('#svg_export_form > input[name=svg]').val("jhgjhg");
  changed["processName"]= processName
  changed["processFileName"]= processFileName\n  $("#posty").empty()
  var form = jQuery('<form/>', {\n    id:"edited_write",\n    method:"POST",
    async: "false",\n    enctype: "multipart/form-data",
    style:"display:none;visibility:hidden",\n  })\n  jQuery('<input/>', {
    type:"hidden",\n    name:"changed",\n    value:JSON.stringify(changed),
  }).appendTo(form)\n  form.appendTo("#posty")\n  $('#edited_write').submit();
  $potential=[]\n  parChildNames={}\n});\n/*
  Go to normal viewing mode. Discard any changes.\n*/
$(document).on('click', '#normalMode', function(e){
  //remove all cell edit Divs\n  goNormal($(this));\n  //$potential =[]
  //parChildNames={}\n});\n/*\n Couldn't find built-in deep clone or copy.\n*/
function deepCopy(obj){\n  if(obj instanceof Array){\n    var copy=[]
    obj.forEach(function(x,i,a){copy[i]= deepCopy(x)})\n    return copy\n  }
  else if(obj instanceof Object){\n    var copy ={}\n    for (key in obj){
      copy[key] = deepCopy(obj[key])\n    }\n    return copy\n  }\n return obj
}\n\n/*\n Returns a dict of everything that has changed.\n*/
function save(data, restData){\n  var allChanged={}\n  var done=[]
  for(var i in $potential){\n    var parent = $potential[i];
    // we have the parent.
    var oldParentName = $(parent).attr("data-name");
    //bit iffy, can have same parent name multiple times? todo
    if(done.indexOf(oldParentName)>-1) continue\n    done.push(oldParentName)
    if(typeof restData =='undefined'){
      var allDict = deepCopy(data[oldParentName])
      var allOldData = allDict["Parameters"]
      var childChanged = parChildNames[oldParentName]
      var oldToNew= chil(childChanged,parent, true)
      if(oldToNew.length ==0) continue
      var newpar = blah(oldToNew, oldParentName, allOldData, parent, false)
      tempDict = allDict\n      tempDict["Parameters"] =  allOldData
      allChanged[newpar] = tempDict\n      if(oldToNew.length>0){
        window.alert("Something went wrong, I did not find all changes.");
      }\n    }\n    else{
      // we have one data for the parents and one for rest
      var allDict = deepCopy(data[oldParentName])
      var allKids = allDict["Parameters"]\n      var tem ={}
      var childChanged = parChildNames[oldParentName];
      var oldToNew = chil(childChanged,parent, false);
      //if(Object.keys(oldToNew).length ==0) continue
      if(oldToNew.length ==0) continue\n      for (var y in allKids){
        var n = allKids[y]\n        var allOld2 = deepCopy(restData[n])
        var allOldData = allOld2["Parameters"]
        // blah chanhes allOldData
        var newpar = blah(oldToNew, n, allOldData, parent, true)
        allOld2["Parameters"]= allOldData\n        tem[newpar] = allOld2
      }\n      var newParentName = $(parent).contents()[0].nodeValue
      //allChanged[newParentName]= tem\n      tempDict = allDict
      tempDict["Parameters"] =  tem\n     allChanged[newParentName] = tempDict
      continue\n    }\n  }\n  return allChanged\n}\n/*
 These three functions are used for getting data from
 a structure such as [{},{},{}]\n*/\nfunction getValue(list, key){\n var re=[]
  for(x in list){\n    di = list[x]\n    k = Object.keys(di)[0]
    if(k==key)re.push(di[k])\n  }\n  return re\n}\nfunction getKeys(list){
  var keys = []\n  for (x in list)\n    keys.push(Object.keys(list[x])[0])
  return keys\n}\nfunction deleteValue(list, k,d){\n  var inde =-1
  var found = false\n  for(var x in list){\n    var di = list[x]
    var key = Object.keys(di)[0]\n    if(key==k && di[key]==d){
      found = true\n      inde = x\n      break\n    }\n  }
  if(found)list.splice(inde,1)\n}\n/*
  allOldData will be changed with the new data.\n*/
function blah(oldToNew, oldParentName, allOldData, parent){
    var newpar = oldParentName\n    var keys = getKeys(oldToNew)
    if(keys.indexOf(oldParentName)>-1){\n      // parent is in
      var tDatas = getValue(oldToNew,oldParentName);
      for (var x in tDatas){\n        var tData = tDatas[x]
        if(tData["i"]==0 && tData["p"].length ==0){
          var newpar = tData["new"];\n          // this isnt finding tData
          deleteValue(oldToNew, oldParentName,tData);\n      }\n     }\n    }
    // okay so here we have everything for this parent.
    // now need to loop through the old data and changed for new.
    if(oldToNew.length >0){
      loopData(allOldData,oldToNew,[oldParentName], [0]);\n    }
  return newpar\n}\n//need to remember that current format is 
//[name, parameters,type,optionalType]\n/*\n  Loop around the data, \n*/
function loopData(thelist, items, parents, pIndex){\n  for(var x in thelist){
    var y = thelist[x]\n    if(y instanceof Array){
      // okay if array, we have full line
      if(typeof y[0] == "string" && y[1] instanceof Array){
        // this is what we want.\n       var theName = y[0]
       var rest = y[1]\n       var types = [y[2]]\n       if(y.length == 4)
         types.push(y[3])\n       // okay, name of this is theName == parent
       // the index of this is x\n       parents.unshift(theName)  
       pIndex.unshift(x)\n       loopData(rest, items, parents, pIndex);
       parents.shift()\n       pIndex.shift()
       rightOne(thelist,x,theName,items,parents,pIndex)
       for(var index in types){\n         var item = types[index]
         rightOne(thelist,x,item,items,parents,pIndex)\n       }
       continue\n      }
      if(y[0] instanceof Array && y[1] instanceof Array){
        // y1 is a parameter\n        // y2 is a parameter
        for(var e in y){\n          loopData(y[e],items,parents,pIndex);
        }\n       continue;\n      }\n      // we are here,
      //so we have something that does not have parameters in a list
      var theName = y[0]\n      for(var index in y){\n        if(index >0){
          parents.unshift(theName)  \n          pIndex.unshift(x)\n        }
        var item = y[index]
        rightOne(thelist,x,item,items,parents,pIndex)\n        if(index >0){
          parents.shift()\n          pIndex.shift()\n        }\n      }
      continue;\n    }\n    else {
      rightOne(thelist,x,y,items,parents,pIndex)\n    }\n  }\n}\n/*
  Helper function. We have a match, now change old values for new values.\n*/
function rightOne(thelist,x,y,items,parents,pIndex){
  if(getKeys(items).indexOf(y)>-1){
    // we know that we have a match, but are indexes the same?
    // index will be in the same list so we can use x
    var dis = getValue(items, y)\n    for (inde in dis){
      var di= dis[inde]\n      if(x == di["i"]){
        if(arrayCompare(parents, pIndex,di["p"],di["pIndex"] )){
          //okay we can be sure we are changing the right thing.
          if(thelist[x] instanceof Array){
            for(var ind in thelist[x]){\n              var z = thelist[x][ind]
              if(y == z){\n                thelist[x][ind] = di["new"]
                break;\n              } \n            }\n          }
          else{\n            thelist[x] = di["new"]\n          }
          deleteValue(items,y,di)\n        }\n      }\n    }\n  }\n}\n/*
  Returns true if arrays a1 is identical to a2 and
  a1Index is identical to a2Index.\n*/
function arrayCompare(a1, a1Index, a2, a2Index) {
    if (a1.length != a2.length)return false;
    for (var i = 0; i < a1.length; i++) {
        if (a1[i] != a2[i] || a1Index[i] != a2Index[i]) {
            return false;\n        }\n    }\n    return true;\n}\n/*
  Take in the children that might have been changed.
  If something has been changed, adds to a dictionary
  dictionary format is  [data-name]={
  "new": newvalue, "i":data-index, "p":[parentNames],
  "pIndex": [indicies of parents]}
  TODO, need a new format, what if children have 
  the same data-name and both are changed?\n*/
function chil (childChanged, parent, addParent){\n  var oldToNew=[]
  for (var x in childChanged){\n      var child = childChanged[x]
      // we need to check if the child has been changed.
      var oldval = child.attr("data-name");
      var isSpan = child.prop("tagName") == "SPAN"\n     var newval = isSpan ?
       child.contents().text(): child.contents()[0].nodeValue;
      //remove any enclosing brackets
      newval = newval.trim().replace(/\(.*\)$/, "");
      oldval = oldval.trim().replace(/\(.*\)$/, "");
      if(oldval==newval)continue\n      else{
        //child has been changed.\n        //we want to keep 4 pieces of data.
        //1. old name, new name\n        //2. data-index
        //3. list of direct parents.\n        //4. indexes of all parents.
        var inner ={}\n        inner["new"] = newval;
        //depends if it was a span or not. Span means we use parents.
        inner["i"]= (isSpan? child.parent().attr("data-index"): 
          child.attr("data-index")) || 0\n        var allP = child.parents()
        var pNames =[]\n        var pIndex =[]
        for(var y=0; y < allP.length; y++){\n          var p = $(allP[y])
          var tag = p.prop("tagName")
          if(p.attr("data-name") == parent.attr("data-name")){
            if(addParent){\n             pNames.push(parent.attr("data-name"))
              pIndex.push(parent.attr("data-index") || 0);\n            }
            break;\n          }\n          else if(tag == "LI"){
            pNames.push(p.attr("data-name"));
            pIndex.push(p.attr("data-index") || 0);\n          }\n        }
        inner["p"] = pNames\n        inner["pIndex"] = pIndex\n       var t={}
        t[oldval]= inner\n        oldToNew.push(t)\n      }
    } // end of childchanged loop\n return oldToNew\n}
// --- end of save operations ---
// --- Expand and show more data operations ---\n/*
  Used when in edit mode to stop any items being added to the webpage.
  More items added after edit mode- they wont be editable, and when you
  click to edit something it loads its children.\n*/
$(document).on('click','.expand, .expanded', function(event){
    if(expandDisable){\n     event.stopImmediatePropagation();\n    }\n});\n/*
  Retrieves and expands elements whose objects have multiple lists
  (i.e. onese who's data-base !=simpleData)\n*/
$(document).on('click', '.Consumer.expand,.Producer.expand,'
+'.Path.expand,.EndPath.expand ',function(event){
    var allModules = CURRENT_OBJ.getModules($(this).attr('data-name'));
    var UL = addParams(this,allModules)\n    $(this).append(UL); 
  event.stopPropagation();\n});\n/*\n  Adds parameters onto objects.\n*/
$(document).on('click','.Modules.expand,.SequenceTypes,.Types.expand'
, function(event){\n  if(showParams){\n    addParams(this);\n  }
  event.stopPropagation();\n});\n/*\n  Hides/Shows children from class param.
*/  \n$(document).on('click', '.paramInner.expand, .paramInner.expanded',
   function(event){\n   if($(this).children('ul').length ==0){
     // find parents\n     var parents = findParents(this)
     var result = baseInnerParams(parents,parseInt(
                   $(this).attr("data-index")) )[1]
     addParams(this, result);\n    }\n    else{
      //children already added, so just hide/show.
      $(this).children('ul').toggle();\n    }\n    event.stopPropagation();
  });\n/*\n  Find the parents of a child.\n*/\nfunction findParents(child){
  var parents =[$(child).attr("data-name")]
  var theParent = $(child).attr("data-parent")
  while(theParent !=undefined){  \n    var child = $(child).parent();
    if(child.prop("tagName")=="UL") continue;
    parents.unshift(child.attr("data-name"));
    theParent = child.attr("data-parent");\n  }\n  return parents\n}\n/*
  Helper function: returns filename appended onto val.\n*/
function getFile(theName){\n  var f = baseFile(theName)
  if(f)return theName+=type(f)\n  return theName\n}\n/*
  Add params to the object. Object can be of any type
  (normally module or param).
  Will be used by modules adding parameters, psets adding parameters.\n*/
  var $LIBasic = $(document.createElement('li')).attr("class","param");
  var $LIExpand = $LIBasic.clone().attr("class","expand");\n
function addParams(obj, params){
  var fileChecked = document.getElementById("ShowFiles").checked
  var $span = $(document.createElement("span"));
  var $typeSpan = $span.clone().addClass("type");
  var $valSpan = $span.clone().addClass("value");
  var $UL = $(document.createElement("ul"));
  var $objName = $(obj).attr('data-name');\n\n  if(!params)
    params = baseParams($objName)\n  for(var i =0; i < params.length; i++){
    var all = params[i].slice() // make copy of it
    var isList= typeof(all)=="object"
    var theName = isList ? all.shift(): all
    var typ= !isList || !all.length ? baseType(theName): all.pop()
    var gen = getGenericType(typ) 
    var spt = $typeSpan.clone().attr("data-name",typ).text(type(typ))
    if(fileChecked) text = getFile(theName)
    if(isList && typeof(all[0]) == "object"){\n      // PSets
      var cloLI = doLI(false,theName,i,"paramInner",spt)
      cloLI.attr("data-parent", $objName)\n    }
    else if(baseParams(theName)){\n      // Modules or sequences
      var cloLI = doLI(false,theName,i,gen,spt)\n    }\n    else{
      // Basic type, has no children\n      var cloLI= doLI(true,theName,i)
      var value =""\n      if(all.length)\n        var value = all.shift()
      // formating so lots of strings look nicer\n     var valDataName = value
      if(value.indexOf(",")>-1){
         value = "<ul><li>"+value.replace(/,/g, ",</li><li>")+"</li></ul>"
      }\n      var add = type(typ)
      cloLI.append($valSpan.clone().attr("data-name",valDataName).html(value))  
      cloLI.append($typeSpan.clone().attr("data-name",add).text(add))
      for(var p=0; p < all.length; p++){\n        var n = type(all[p])       
        cloLI.append($typeSpan.clone().attr("data-name",n).text(n))\n      } 
    } \n    $UL.append(cloLI);\n  }\n  $(obj).append($UL);\n}\n
function type(theName){\n  return " ("+theName+")"\n}\n/*
  Helper function: Adds data to a LI.\n*/
function doLI(basic,dataN,dataI,classes,html){
   if(basic) var $LI = $LIBasic.clone()\n   else var $LI = $LIExpand.clone()
   $LI.attr("data-name", dataN).attr("data-index", dataI).text(dataN);
   if(classes)$LI.addClass(classes)\n   if(html)$LI.append(html)\n  return $LI
}\n/*\n  Box to show params has been clicked.\n*/
$(document).on('click', '#ShowParams', function(e){
  if($(this).is (':checked')){\n    showParams = true\n  }\n  else{
    $(this).next().hide()\n    showParams = false\n  }\n});\n/*
  Removes children from top level list elements.\n*/
$(document).on('click', '#hide', function(e){
  //make sure not called when not needed.
  if($(this).css('cursor')!='default'){  
    var selec = $(".expanded."+topClass).children("ul").hide()
    toggleExpand($(".expanded."+topClass ),e)\n    invisibleHide()\n  }\n});
// --- end of expand and show more data operations ---
// --- general helper operations and functions ---\n\n/*
  Return to normal viewing mode.\n*/\nfunction goNormal(it){
  expandDisable = false;
  $(".cellEdit").replaceWith(function() { return $(this).contents();});
  $("#save").remove()\n  $("#mode")[0].textContent = "Normal Mode"
  it.attr("value", "Edit");\n  it.attr("id", "editMode")\n}\n/*
  Set what the CURRENT_OBJ is.\n*/\nfunction setCURRENT_OBJ($element){
  var thefunction = $element.attr("data-base");
  var list = $element.attr("data-files").split(" ");\n  if(list.length >1){
    CURRENT_OBJ = window[thefunction](list[1], list[0])\n   } \n  else{
    CURRENT_OBJ = window[thefunction](list[0])\n  }\n}\n/*
  Add option in html to show/hide parameters.\n*/\nfunction paramOptions(bool){
  if(!bool){\n   $("#attachParams").empty()\n   return\n  }
  var lb= jQuery('<label/>', {\n      for:"ShowParams"\n  })
  jQuery('<input/>', {\n      type:"checkbox",\n      id:"ShowParams",
      name:"ShowParams",\n      value:"ShowParams",\n      autocomplete:"off"
    }).appendTo(lb)\n  lb.append("Show Parameters")
lb.appendTo("#attachParams")\n}\n/*\n Small info about each option.\n*/
$('#showType option').mouseover(function(){
  var docType = $(this).attr("value").toLowerCase();\n  var info;
  switch(docType){\n    case "producer":
      info="What's produced by each module."\n      break;
    case "consumer":\n      info="What's consumed by each module."
      break;\n    default:\n      info ="List of "+ docType+"s."\n  }
  $(this).attr("title", info);\n});\n/*\n Small info about each option.\n*/
$('span[name="Info"]').mouseover(function(){
  var docType = $(this).attr("value").toLowerCase();\n  var info;
  switch(docType){\n    case "producer":
      info="What's produced by each module."\n      break;
    case "consumer":\n      info="What's consumed by each module."
      break;\n    default:\n      info ="List of "+ docType+"s."\n  }
  $(this).attr("title", info);\n});\n/*\n  More info about what's shown.\n*/
$("#helpMouse").hover(function(e) {
    $($(this).data("help")).stop().show(100);
    var title = "<h6>(Read the README file!)</h6><h4>Info:</h4> "
    var expl = "<h5>Colour codes:</h5> <h6><ul><li class='Path'>pathName"+
               "     </li></ul><ul><li class='Modules'>Modules (e.g. "+
               "EDProducer, EDFilter etc)</li></ul><ul><li class='Types'>"+
               "Types (e.g. PSet)</li></ul><ul><li class='param'>"+
               "ParameterName:<span class='value'> value</span><span"+
               " class='type'>(type)</span></li></ul></h6>"
   var info ="<h5>The data</h5><h6>The headings you can choose from are"+
             " what was collected from the config file.<br/><br/> Any "+
             "change to the config file means having to run the script "+
             "again and then refresh this page (if same output file was "+
             "used).</h6><br/>"
   var tSearch="<h5>Search</h5><h6>Currently can only search by listing "+
               "what items you would like to be searched, and then what part"+
               " of each item.<br/><br/> I.e. search the producers for "+
               "certain names.</h6><br/>"
   var problems = "<h5>HTML/JSON/JS issues</h5><h6>If content isn't "+
                  "loading,or json files cannot be loaded due to browser"+
                  " security issues, try runing the local server created"+
                  " by the script. This will be in the same place as "+
                  "index.html.<br/><span class='Types'>'python cfgServer.py'"+
                  "   </span></h6><br/>"
   var editing = "<h5>Editing</h5><h6>In order to use the edit mode, you "+
                 "need to run the cfgServer.py file, this will be in the "+
                 "same directory as the index.html.<br/>Then go to <span"+
                 " class='Types'> 'http://localhost:8000/index.html.'"+
                 "</span><br/><strong>Please note that the editing of "+
                 "SequenceTypes (i.e. Paths, EndPaths etc) and of producers"+
                 " and consumers has been "
   $($(this).data("help")).html(title+expl+info+problems+editing);
                 "disabled.</strong></h6><br/>"\n}, function() {
    $($(this).data("help")).hide();\n});\n/*
  These two functions hide/show the top box in browser.\n*/
$(document).on('click', '.hideTopBox', function(e){
   $(".topSpec").animate({top: "-2.5em"}, 500);\n   $(this).text("show");
   $(this).toggleClass("hideTopBox "+"showTopBox");\n});
$(document).on('click', '.showTopBox', function(e){
   $(".topSpec").animate({top: "0em"}, 500);\n   $(this).text("hide");
   $(this).toggleClass("showTopBox "+ "hideTopBox");\n});\n/*
  Stop some links from firing.\n*/\n$('a.nowhere').click(function(e)\n{
    e.preventDefault();\n});\n\n// Turn off any action for clicking help.
$('a#help').bind('click', function() {\n   return false;\n});\n/*
  If parameter value is a list, hide/show the list on click.\n*/
$(document).on('click', '.param',function(event){\n    if(!expandDisable){
  if($(this).find('ul').length >0){\n    $(this).find('ul').toggle();\n    }}
  event.stopPropagation();\n});\n/*
  Removes children from expanded paths or modules.\n*/
$(document).on('click', '.expanded',function(event){
  var c = $(this).children('ul');\n  if(c.length >0){\n    $(c).remove();  
  }\n  event.stopPropagation();\n});\nfunction visibleHide(){
  $('#hide').css('opacity',1);\n  $('#hide').css('cursor','pointer');
  hideVisible = true;\n}\nfunction invisibleHide(){
  $('#hide').css('opacity','');\n  $('#hide').css('cursor','');
  hideVisible = false;\n}\n\n// Toggles class names.
$(document).on('click','.expand, .expanded', function(event){
  if(!hideVisible && $(this).is('.expand')){\n  visibleHide();\n  }
  toggleExpand(this, event);\n});\n/*\n  Helper function toggles class type.
*/\nfunction toggleExpand(me,event){\n    $(me).toggleClass("expanded expand");
  event.stopPropagation();\n}\n});\n// end of jquery\n/*
Function to load the JSON files.\n*/\nfunction loadJSON(theName){
 return $.ajax({\n    type: "GET",\n    url: theName,
     beforeSend: function(xhr){\n    if (xhr.overrideMimeType)\n    {
      xhr.overrideMimeType("application/json");\n    }\n  },
    contentType: "application/json",\n    async: false,\n    dataType: "json"
  });\n} \n"""%(pN,pFN))
genericTypes={}

def doTypes(spec, generic):
    genericTypes[spec] = generic

def JSONFormat(d):
    import json
    return json.dumps(d)

class server:
    def __init__(self, name):
        self.printServer(name)

    def printServer(self, name):
        with open(name, 'w') as f:
            f.write("""
#!/usr/bin/env python\nimport SimpleHTTPServer\nimport SocketServer
import shutil\nimport os\nimport cgi\nimport socket\nimport errno\n
#Right now cannot deal with SequenceTypes\nclass CfgConvert:
  def __init__(self, obj):\n    self._pName = obj["processName"]
    self._pFileN = obj["processFileName"]\n    obj.__delitem__("processName")
    obj.__delitem__("processFileName")\n    self._obj = obj
    self._func="cms.%s"
    self.header=\"""import FWCore.ParameterSet.Config as cms
process = cms.Process('%(n)s')\nfrom %(fileN)s import *\n%(changes)s\n\n\"""
  def _doConversion(self):\n    return self.header%(
    {"changes":self._doWork(self._obj),
     "n":self._pName,"fileN":self._pFileN})\n\n  def _doWork(self, obj):
    result =""\n    for key, value in six.iteritems(obj):
      _type = value["Type"]\n      _file = value["File"]
      _params = value["Parameters"]\n      _oType = value["oType"]
      if(_oType):\n        _oType= "'%s',"%(value["oType"])
      #f = eval(func%(_type))\n      if(type(_params)== list):
        if(len(_params)==0):
          result +="process.%s= cms.%s(%s)\\n"%(key,_type,_oType[:-1])
        else:\n          params = self._convert(_params)
          result+="process.%s= cms.%s(%s%s)\\n"%(key,_type,_oType, params)
      #elif(type(_params)== dict):
      #  return "Sorry path and endpaths can not currently be translated."
        #params = self._doWork(_params)\n      
      #obj = f("actualType", *parameters)\n    return result\n      
  def _convert(self,params):
    # NOTE: params do not take names inside functions
    # It is: name = cms.type(value)\n    # okay we have a list like 
    #[name,params, untracked,type]||[name,params,type]
    # 2 format options in the params\n    # 1. [["name", "value", "type"]]
    # 2. [["PsetName",[[as above or this]], "Pset"]]\n
    # At position 0 is name. list[0]==name or list[0]==list 
    # then that will be all
    # At position 1 is value or list. list[1]==value||list.
    # At position 2 is type. list[2] == type || untracked.
    # If there is a position 3 its type. list[3]== type.
    if(all(type(x) == list for x in params)):
      return ",".join([self._convert(x) for x in params])
    length = len(params)\n    if(length==1):
      if(type(params[0]) == list):\n        # wont have params[1]etc  
        # do inners\n        return  self._convert(params[0])
      #wrong format\n      print "Error 01 %s"%(str(params))\n      return ""
    if(length !=3 and length !=4):\n      #wrong format
      print "Error 02 len is %s"%(str(params))\n      return ""
    # okay get on with it.\n    name = params[0]
    if(type(params[1])==list):\n      # do listy things
      value = self._convert(params[1])\n    else:\n      value=params[1]
    ty = params[2]\n    if(name==ty):\n      name=""\n    if(length==4):
      ty+="."+params[3]\n      if(name== params[3]):\n        name=""
    if("vstring" in ty):\n      # split the value up by commas
      value = ",".join(["'%s'"%x for x in value.split(",")])
    elif("string" in ty):\n      #surround string with quotation marks
      value = "%s"%(value)\n    # okay now done with everything
    call= self._func%(ty)\n    if(name):
      return"%s=%s(%s)"%(name,call,value)\n    return"%s(%s)"%(call,value)\n
class ServerHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):\n
  def do_GET(self):\n    if(self.path == "/index.html"):
      # find out what cfg html folders we have below
      # and add each main html page to the index\n      li = os.listdir(".")
      dEnd = "-cfghtml"
      dirs = [x for x in li if os.path.isdir(x) and x.endswith(dEnd)]
      name = "main.html"
      names = [os.path.join(x,name) for x in dirs if name in os.listdir(x)]
      tmpte = '<li><a href ="%(n)s">%(s)s</a></li>'
      lis = [tmpte%{"n":x,"s":os.path.split(x)[0].replace(dEnd, "")}
               for x in names]\n      with open("index.html", 'w') as f:
        f.write(\"""\n<!DOCTYPE html>\n<html>\n  <head>
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8">
    <title>cfg-browser</title>\n  </head>\n  <body>
    <h4>Configuration files:</h4>\n    <ul>\n      %s\n    </ul>\n  </body>
</html>\n        \"""%("".join(lis)))\n      
    return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)\n  
  def do_POST(self):
    ctype,pdict= cgi.parse_header(self.headers.getheader('content-type'))
    bdy = cgi.parse_multipart(self.rfile,pdict)
    ch= " ".join(bdy[bdy.keys()[0]])\n    self.conversion(eval(ch))
    self.writeFile()\n    print "finished writing"\n    
  def conversion(self, json):\n    # Need to convert my json into config
    result = CfgConvert(json)._doConversion()
    with open("changed_cfg.py", 'w')as f:\n      f.write(result)\n
  def writeFile(self):\n    with open("changed_cfg.py", 'rb') as f:
      self.send_response(200)
      self.send_header("Content-Type", 'text/html')
      self.send_header("Content-Disposition", 
                       'attachment; filename="changed_cfg.py"')
      fs = os.fstat(f.fileno())
      self.send_header("Content-Length", str(fs.st_size))
      self.end_headers()\n      shutil.copyfileobj(f, self.wfile)\n
def main(port=8000, reattempts=5):\n  if(port <1024):
    print \"""This port number may be refused permission.
It is better to use a port number > 1023.\"""\n  try:
    Handler = ServerHandler
    httpd = SocketServer.TCPServer(("", port), Handler)
    print "using port", port
    print "Open http://localhost:%s/index.html in your browser."%(port)
    httpd.serve_forever()\n  except socket.error as e:
    if(reattempts >0 and e[0] == errno.EACCES):
      print "Permission was denied."
    elif(reattempts >0 and e[0]== errno.EADDRINUSE):
      print "Address %s is in use."%(port)\n    else:\n      raise
    print "Trying again with a new port number."\n    if(port < 1024):
      port = 1024\n    else:\n      port = port +1
    main(port, reattempts-1)\n\nif __name__ == "__main__":\n  import sys
  if(len(sys.argv)>1):\n    try:\n      port = int(sys.argv[1])
      main(port)\n      sys.exit() \n    except ValueError:
      print "Integer not valid, using default port number."\n  main()
""")

def computeConfigs(args):
    pyList=[]
    for x in args:
        if(os.path.isdir(x)):
            # get all .py files.
            allItems = os.listdir(x)
            py = [os.path.join(x,y) for y in allItems if y.endswith(".py")]
            pyList.extend(computeConfigs(py))
            if(recurse):
             # print "recurse"
                # if we want to recurse, we look for everything
                dirs = []
                for y in os.listdir(x):
                    path = os.path.join(x,y)
                    if(os.path.isdir(path)):
                        pyList.extend(computeConfigs([os.path.join(path,z)
                                                      for z in os.listdir(path)]))
        elif(x.endswith(".py")):
            pyList.append(x)
    return pyList

recurse=False

def main(args,helperDir,htmlFile,quiet, noServer):
    dirName = "%s-cfghtml"
    # new dir format
    #  cfgViewer.html
    #  patTuple-html/
    #    lower.html
    #    cfgViewerHelper/
    #      -json files
    pyconfigs = computeConfigs(args) 
    tmpte = '<li><a href ="%(n)s">%(s)s</a></li>'
    lis=""
    found =0
    for x in pyconfigs:
        print("-----")
        # for every config file
        name = os.path.split(x)[1].replace(".py", "")
        dirN =  dirName%(name)
        # we have the dir name now we only need
        # now we have thedir for everything to be stored in
        #htmlF = opts._htmlfile
        #htmldir= os.path.split(htmlFile)[0]
        #baseDir = os.path.join(htmldir,dirN)
        baseDir = dirN
        dirCreated = False
        if not os.path.exists(baseDir):
            os.makedirs(baseDir)
            dirCreated = True
        # base Dir under where the htmlFile will be.
        lowerHTML = os.path.join(baseDir, htmlFile)
        helper = os.path.join(helperDir, "")
        helperdir = os.path.join(baseDir, helper, "")
        if not os.path.exists(helperdir):
            os.makedirs(helperdir)
        print("Calculating", x)
        try:
            u = unscheduled(x, lowerHTML, quiet, helper,helperdir)
        except Exception as e:
            print("File %s is a config file but something went wrong"%(x))
            print("%s"%(e))
            continue
        print("Finished with", x)
        if(not u._computed and dirCreated):
            # remove any directories created
            shutil.rmtree(baseDir)
            continue
        found +=1
        lis += tmpte%{"n":os.path.join(dirN,htmlFile),"s":name}
    with open("index.html", 'w')as f:
        f.write("""
<!DOCTYPE html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8">
    <title>cfg-browser</title>
  </head>
  <body>
    <h4>Configuration files:</h4>
    <ul>
      %s
    </ul>
  </body>
</html>
    """%("".join(lis)))
    if(found == 0):
        print("Sorry, no configuration files were found.")
        return
    print("Finished dealing with configuration files.")
    server("cfgServer.py")
    if(not noServer):
        print("-----")
        print("Starting the python server..")
        import  cfgServer
        cfgServer.main()


if __name__ == "__main__":
    import sys, os, imp, shutil
    from optparse import OptionParser
    parser = OptionParser(usage="%prog <cfg-file> ")
    parser.add_option("-q", "--quiet",
                    action="store_true", dest="_quiet", default=False,
                    help="Print minimal messages to stdout")
    #parser.add_option("-o", "--html_file", dest="_htmlfile",
    #                  help="The output html file.", default="cfg-viewer.html")
    parser.add_option("-s", "--no_server",
                    action="store_true", dest="_server", default=False,
                    help="Disable starting a python server to view "\
                    "the html after finishing with config files.")
    parser.add_option("-r", "--recurse", dest="_recurse",action="store_true",
                       default=False,
                       help="Search directories recursively for .py files.")
    # store in another dir down
    #additonalDir = "first"
    helper_dir = "cfgViewerJS"
    opts, args = parser.parse_args()
    #cfg = args
    try:
        distBaseDirectory=os.path.abspath(
                          os.path.join(os.path.dirname(__file__),".."))
        if (not os.path.exists(distBaseDirectory) or 
           not "Vispa" in os.listdir(distBaseDirectory)):
            distBaseDirectory=os.path.abspath(
                              os.path.join(os.path.dirname(__file__),"../python"))
        if (not os.path.exists(distBaseDirectory) or 
           not "Vispa" in os.listdir(distBaseDirectory)):
            distBaseDirectory=os.path.abspath(os.path.expandvars(
                                 "$CMSSW_BASE/python/FWCore/GuiBrowsers"))
        if (not os.path.exists(distBaseDirectory) or 
           not "Vispa" in os.listdir(distBaseDirectory)):
            distBaseDirectory=os.path.abspath(os.path.expandvars(
                                "$CMSSW_RELEASE_BASE/python/FWCore/GuiBrowsers"))
    except Exception:
        distBaseDirectory=os.path.abspath(
                           os.path.join(os.path.dirname(sys.argv[0]),".."))
    sys.path.insert(0,distBaseDirectory)
    from Vispa.Main.Directories import *
    distBinaryBaseDirectory=os.path.join(baseDirectory,"dist")
    sys.path.append(distBinaryBaseDirectory)
    from FWCore.GuiBrowsers.Vispa.Plugins.ConfigEditor import ConfigDataAccessor
    print("starting..")
    recurse = opts._recurse
    doesNotExist = [x for x in args if not os.path.exists(x)]
    if(len(doesNotExist)):
        s =""
        for x in doesNotExist:
            args.remove(x)
            s += "%s does not exist.\n"%(x)
        print(s)

    if(len(args)==0 or len(doesNotExist)== len(args)):
        print("""
    Either you provided no arguments, or the arguments provided do not exist.
    Please try again.
    If you need help finding files, provide arguments "." -r and I will search
    recursively through the directories in the current directory.
    """)
    else:
        main(args,"cfgViewerJS","main.html",opts._quiet, opts._server)