def extractCompartmentStatistics(bioNumber,useID,reactionDefinitions,speciesEquivalence):
    '''
    Iterate over the translated species and check which compartments
    are used together, and how. 
    '''
    reader = libsbml.SBMLReader()
    document = reader.readSBMLFromFile(bioNumber)
    
    
    parser =SBML2BNGL(document.getModel(),useID)
    database = structures.Databases()
    database.pathwaycommons = False
    #call the atomizer (or not)
    #if atomize:
    translator,onlySynDec = mc.transformMolecules(parser,database,reactionDefinitions,speciesEquivalence)
    #else:    
    #    translator={} 


    compartmentPairs = {}
    for element in translator:
        temp = extractCompartmentCoIncidence(translator[element])
        for element in temp:
            if element not in compartmentPairs:
                compartmentPairs[element] = temp[element]
            else:
                compartmentPairs[element].update(temp[element])
    finalCompartmentPairs = {}
    print '-----'
    for element in compartmentPairs:
        if element[0][0] not in finalCompartmentPairs:
            finalCompartmentPairs[element[0][0]] = {}
        finalCompartmentPairs[element[0][0]][tuple([element[0][1],element[1][1]])] = compartmentPairs[element]
    return finalCompartmentPairs
def readFromString(inputString,reactionDefinitions,useID,speciesEquivalence=None,atomize=False):
    '''
    one of the library's main entry methods. Process data from a string
    '''
    try:
        reader = libsbml.SBMLReader()
        document = reader.readSBMLFromString(inputString)
        parser =SBML2BNGL(document.getModel(),useID)
        
        bioGrid = False
        pathwaycommons = False
        if bioGrid:
            loadBioGrid()
        database = structures.Databases()
        database.forceModificationFlag = True
        database.pathwaycommons = False
        if pathwaycommons:
            database.pathwaycommons = True
        namingConventions = resource_path('config/namingConventions.json')
        
        if atomize:
            translator,onlySynDec = mc.transformMolecules(parser,database,reactionDefinitions,namingConventions,speciesEquivalence,bioGrid)
        else:    
            translator={} 
        
        return analyzeHelper(document,reactionDefinitions,
                             useID,'',speciesEquivalence,atomize,translator)[-2]
    except:
        return -5
Example #3
0
def analyzeFile(bioNumber, reactionDefinitions, useID, namingConventions, outputFile,
                speciesEquivalence=None, atomize=False, bioGrid=False, pathwaycommons=False):
    '''
    one of the library's main entry methods. Process data from a file
    '''
    '''
    import cProfile, pstats, StringIO
    pr = cProfile.Profile()
    pr.enable()
    '''
    setupLog(outputFile + '.log', logging.DEBUG)

    logMess.log = []
    logMess.counter = -1
    reader = libsbml.SBMLReader()
    document = reader.readSBMLFromFile(bioNumber)

    if document.getModel() == None:
        print 'File {0} could not be recognized as a valid SBML file'.format(bioNumber)
        return
    parser =SBML2BNGL(document.getModel(),useID)
    database = structures.Databases()
    database.forceModificationFlag = True
    database.pathwaycommons = pathwaycommons

    bioGridDict = {}
    if bioGrid:
        bioGridDict = loadBioGrid()
    
    #call the atomizer (or not). structured molecules are contained in translator
    #onlysyndec is a boolean saying if a model is just synthesis of decay reactions
    if atomize:
        translator, onlySynDec = mc.transformMolecules(parser, database, reactionDefinitions, namingConventions, speciesEquivalence,bioGrid)
    else:    
        translator={}
    #process other sections of the sbml file (functions reactions etc.)
    '''
    pr.disable()
    s = StringIO.StringIO()
    sortby = 'cumulative'
    ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
    ps.print_stats(10)
    print s.getvalue()
    '''
    database.document = document
    database.reactionDefinitions = reactionDefinitions
    database.useID = useID
    database.speciesEquivalence = speciesEquivalence
    database.atomize = atomize

    returnArray = analyzeHelper(document, reactionDefinitions, useID, outputFile, speciesEquivalence, atomize, translator)
    with open(outputFile, 'w') as f:
        f.write(returnArray.finalString)
    #with open('{0}.dict'.format(outputFile),'wb') as f:
    #    pickle.dump(returnArray[-1],f)
    if atomize and onlySynDec:
        returnArray = list(returnArray)
        #returnArray.translator = -1
    returnArray = AnalysisResults(*(list(returnArray[0:-1]) + [database]))
    return returnArray
def readFromString(inputString,reactionDefinitions,useID,speciesEquivalence=None,atomize=False, loggingStream=None):
    '''
    one of the library's main entry methods. Process data from a string
    '''

    console = None
    if loggingStream:
        console = logging.StreamHandler(loggingStream)
        console.setLevel(logging.DEBUG)

        setupStreamLog(console)

    reader = libsbml.SBMLReader()
    document = reader.readSBMLFromString(inputString)
    parser =SBML2BNGL(document.getModel(),useID)
    
    bioGrid = False
    pathwaycommons = True
    if bioGrid:
        loadBioGrid()

    database = structures.Databases()
    database.assumptions = defaultdict(set)
    database.document = document
    database.forceModificationFlag = True
    database.reactionDefinitions = reactionDefinitions
    database.useID = useID
    database.atomize = atomize
    database.speciesEquivalence = speciesEquivalence
    database.pathwaycommons = True
    database.isConversion = True
    #if pathwaycommons:
    #    database.pathwaycommons = True
    namingConventions = resource_path('config/namingConventions.json')
    
    if atomize:
        translator,onlySynDec = mc.transformMolecules(parser,database,reactionDefinitions,namingConventions,speciesEquivalence,bioGrid)
        database.species = translator.keys()
    else:    
        translator={} 
    #logging.getLogger().flush()
    if loggingStream:
        finishStreamLog(console)

    returnArray = analyzeHelper(document, reactionDefinitions,
                         useID,'', speciesEquivalence, atomize, translator, database)

    if atomize and onlySynDec:
        returnArray = list(returnArray)
    returnArray = AnalysisResults(*(list(returnArray[0:-2]) + [database] + [returnArray[-1]]))

    return returnArray
def analyzeFile(bioNumber,reactionDefinitions,useID,namingConventions,outputFile,
                speciesEquivalence=None,atomize=False,bioGrid=False,pathwaycommons=False):
    '''
    one of the library's main entry methods. Process data from a file
    '''
    '''
    import cProfile, pstats, StringIO
    pr = cProfile.Profile()
    pr.enable()
    '''
    logMess.log = []
    logMess.counter = -1
    reader = libsbml.SBMLReader()
    document = reader.readSBMLFromFile(bioNumber)
    
    parser =SBML2BNGL(document.getModel(),useID)
    database = structures.Databases()
    database.forceModificationFlag = True
    database.pathwaycommons = pathwaycommons

    bioGridDict = {}
    if bioGrid:
        bioGridDict = loadBioGrid()
    
    #call the atomizer (or not). structured molecules are contained in translator
    #onlysyndec is a boolean saying if a model is just synthesis of decay reactions
    if atomize:
        translator,onlySynDec = mc.transformMolecules(parser,database,reactionDefinitions,namingConventions,speciesEquivalence,bioGrid)
    else:    
        translator={} 

    #process other sections of the sbml file (functions reactions etc.)    
    '''
    pr.disable()
    s = StringIO.StringIO()
    sortby = 'cumulative'
    ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
    ps.print_stats(10)
    print s.getvalue()
    '''
    returnArray= analyzeHelper(document,reactionDefinitions,useID,outputFile,speciesEquivalence,atomize,translator)
    
    with open(outputFile,'w') as f:
        f.write(returnArray[-2])
    #with open('{0}.dict'.format(outputFile),'wb') as f:
    #    pickle.dump(returnArray[-1],f)
    if atomize and onlySynDec:
        returnArray = list(returnArray)
        returnArray[0] = -1
    return tuple(returnArray[0:-2])
def analyzeFile(bioNumber, reactionDefinitions, useID, namingConventions, outputFile,
                speciesEquivalence=None, atomize=False, bioGrid=False, pathwaycommons=False, ignore=False, noConversion=False):
    '''
    one of the library's main entry methods. Process data from a file
    '''
    '''
    import cProfile, pstats, StringIO
    pr = cProfile.Profile()
    pr.enable()
    '''
    setupLog(outputFile + '.log', logging.DEBUG)

    logMess.log = []
    logMess.counter = -1
    reader = libsbml.SBMLReader()
    document = reader.readSBMLFromFile(bioNumber)

    if document.getModel() == None:
        print 'File {0} could not be recognized as a valid SBML file'.format(bioNumber)
        return
    parser =SBML2BNGL(document.getModel(),useID)
    parser.setConversion(not noConversion)
    database = structures.Databases()
    database.assumptions = defaultdict(set)
    database.forceModificationFlag = True
    database.pathwaycommons = pathwaycommons
    database.ignore = ignore
    database.assumptions = defaultdict(set)


    bioGridDict = {}
    if bioGrid:
        bioGridDict = loadBioGrid()

    translator = {}    
    # call the atomizer (or not). structured molecules are contained in translator
    # onlysyndec is a boolean saying if a model is just synthesis of decay reactions
    try:
        if atomize:
            translator, onlySynDec = mc.transformMolecules(parser, database, reactionDefinitions,
                                                           namingConventions, speciesEquivalence, bioGrid)
    except TranslationException as e:
        print "Found an error in {0}. Check log for more details. Use -I to ignore translation errors".format(e.value)
        if len(logMess.log) > 0:
            with open(outputFile + '.log', 'w') as f:
                for element in logMess.log:
                    f.write(element + '\n')
        return 

    # process other sections of the sbml file (functions reactions etc.)
    '''
    pr.disable()
    s = StringIO.StringIO()
    sortby = 'cumulative'
    ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
    ps.print_stats(10)
    print s.getvalue()
    '''
    database.document = document
    database.reactionDefinitions = reactionDefinitions
    database.useID = useID
    database.speciesEquivalence = speciesEquivalence
    database.atomize = atomize
    database.isConversion = not noConversion

    returnArray = analyzeHelper(document, reactionDefinitions, useID, outputFile, speciesEquivalence, atomize, translator, database)

    with open(outputFile, 'w') as f:
        f.write(returnArray.finalString)
    #with open('{0}.dict'.format(outputFile),'wb') as f:
    #    pickle.dump(returnArray[-1],f)
    if atomize and onlySynDec:
        returnArray = list(returnArray)
        #returnArray.translator = -1
    returnArray = AnalysisResults(*(list(returnArray[0:-2]) + [database] + [returnArray[-1]]))
    return returnArray