# n = batch.create(node)
                    nodes.add(compound_id)
                if compound.id not in compoundDict:
                    compoundDict[compound.id] = compound_id
                currentNodes.add(compound_id)

        importer.done_nodes()

        for reaction in pathway.reactions:
            if reaction.name in reactionToNode:
                gene_ids = reactionToNode[reaction.name]
                for gene_id in gene_ids:
                    for substrate in reaction.substrates:
                        substrate_id = substrate.name[4:]
                        if substrate_id in nodes:
                            importer.add_edge('Edge', substrate_id, gene_id, {'_isNetworkEdge': True})
                            currentEdges[substrate_id + '_' + gene_id] = {'source': substrate_id, 'target': gene_id}

                            # create_pathway_edge(edgeDict, substrateNode, node)
                            if reaction.type == 'reversible':
                                importer.add_edge('Edge', gene_id, substrate_id, {'_isNetworkEdge': True})
                                currentEdges[gene_id + '_' + substrate_id] = {'source': gene_id, 'target': substrate_id}
                                # create_pathway_edge(edgeDict, node, substrateNode)

                    for product in reaction.products:
                        product_id = product.name[4:]
                        if product_id in nodes:
                            importer.add_edge('Edge', gene_id, product_id, {'_isNetworkEdge': True})
                            currentEdges[gene_id + '_' + product_id] = {'source': gene_id, 'target': product_id}

                            # create_pathway_edge(edgeDict, node, productNode)
Esempio n. 2
0
            if node["Label"] in set_ids:
                setId = set_ids[node["Label"]]
            else:
                current_set_id += 1
                setId = str(current_set_id)
                set_ids[node["Label"]] = setId

            importer.add_node(['_Network_Node', 'Structure'],
                              str(node["StructureID"]), {
                                  'name': str(node["StructureID"]),
                                  'labels': [setId]
                              })
            importer.add_node(['_Set_Node', 'Label'], setId,
                              {'name': str(node["Label"])})
            importer.add_edge('ConsistsOf', setId, str(node["StructureID"]),
                              {}, 'Label')
        else:
            importer.add_node(['_Network_Node', 'Structure'],
                              str(node["StructureID"]), {
                                  'name': str(node["StructureID"]),
                                  'labels': []
                              })

    edges = doc["edges"]

    for edge in edges:
        importer.add_edge('Edge', str(edge["SourceStructureID"]),
                          str(edge["TargetStructureID"]), {
                              '_isNetworkEdge': True,
                              'Type': edge["Type"],
                              'Label': edge["Label"]
  for node in nodes:
    if node["Label"] is not None:

      if node["Label"] in set_ids:
        setId = set_ids[node["Label"]]
      else:
        current_set_id += 1
        setId = str(current_set_id)
        set_ids[node["Label"]] = setId

      importer.add_node(['_Network_Node', 'Structure'], str(node["StructureID"]),
                        {'name': str(node["StructureID"]), 'labels': [setId]})
      importer.add_node(['_Set_Node', 'Label'], setId,
                        {'name': str(node["Label"])})
      importer.add_edge('ConsistsOf', setId, str(node["StructureID"]), {}, 'Label')
    else:
      importer.add_node(['_Network_Node', 'Structure'], str(node["StructureID"]),
                        {'name': str(node["StructureID"]), 'labels': []})

  edges = doc["edges"]

  for edge in edges:
    importer.add_edge('Edge', str(edge["SourceStructureID"]), str(edge["TargetStructureID"]), {'_isNetworkEdge': True,
                                                                                               'Type': edge["Type"],
                                                                                               'Label': edge["Label"]})


    # importer.add_node(['_Network_Node', 'Compound'], compound_id,
    #                   {'name': cpdName, 'idType': 'KEGG_COMPOUND',
    #                    'url': 'http://www.kegg.jp/dbget-bin/www_bget?cpd:' + compound_id})
                    # n = batch.create(node)
                    nodes.add(compound_id)
                if compound.id not in compoundDict:
                    compoundDict[compound.id] = compound_id
                currentNodes.add(compound_id)

        importer.done_nodes()

        for reaction in pathway.reactions:
            if reaction.name in reactionToNode:
                gene_ids = reactionToNode[reaction.name]
                for gene_id in gene_ids:
                    for substrate in reaction.substrates:
                        substrate_id = substrate.name[4:]
                        if substrate_id in nodes:
                            importer.add_edge('Edge', substrate_id, gene_id,
                                              {'_isNetworkEdge': True})
                            currentEdges[substrate_id + '_' + gene_id] = {
                                'source': substrate_id,
                                'target': gene_id
                            }

                            # create_pathway_edge(edgeDict, substrateNode, node)
                            if reaction.type == 'reversible':
                                importer.add_edge('Edge', gene_id,
                                                  substrate_id,
                                                  {'_isNetworkEdge': True})
                                currentEdges[gene_id + '_' + substrate_id] = {
                                    'source': gene_id,
                                    'target': substrate_id
                                }
                                # create_pathway_edge(edgeDict, node, substrateNode)