docs: def _generateGraphData(data, oldData=nx.Graph()):
      """
      Processing the data from i3visio structures to generate nodes and edges
  
      This function uses the networkx graph library. It will create a new node
      for each and i3visio.<something> entities while it will add properties for
      all the attribute starting with "@".
  
      Args:
      -----
          d: The i3visio structures containing a list of
          oldData: A graph structure representing the previous information.
  
      Returns:
      --------
          A graph structure representing the updated information.
      """
      def _addNewNode(ent, g):
          """
          Wraps the creation of a node
  
          Args:
          -----
              ent:   The hi3visio-like entities to be used as the identifier.
                  ent = {
                      "value":"i3visio",
                      "type":"i3visio.alias,
                  }
              g:   The graph in which the entity will be stored.
  
          Returns:
          -------
              The label used to represent this element.
          """
          try:
              label = unicode(ent["value"])
          except UnicodeEncodeError as e:
              # Printing that an error was found
              label = str(ent["value"])
          g.add_node(label)
          g.node[label]["type"] = ent["type"]
          return label
  
      def _processAttributes(elems, g):
          """
          Function that processes a list of elements to obtain new attributes.
  
          Args:
          -----
              elems: List of i3visio-like entities.
              g: The graph in which the entity will be stored.
  
          Returns:
          --------
              newAtts: Dict of attributes (to be stored as attributes for the
                  given entity).
              newEntities: List of new Entities (to be stored as attributes for
                  the given entity).
          """
          newAtts = {}
          newEntities= []
  
          for att in elems:
              # If it is an attribute
              if att["type"][0] == "@":
                  # Removing the @ and the  _ of the attributes
                  attName = str(att["type"][1:]).replace('_', '')
                  try:
                      newAtts[attName] = int(att["value"])
                  except:
                      newAtts[attName] = att["value"]
              elif att["type"][:8] == "i3visio.":
                  # Creating a dict to represent the pair: type, value entity.
                  ent = {
                      "value":att["value"],
                      "type":att["type"].replace("i3visio.", "i3visio_"),
                  }
                  # Appending the new Entity to the entity list
                  newEntities.append(ent)
  
                  # Appending the new node
                  hashLabel = _addNewNode(ent, g)
  
                  # Make this recursive to link the attributes in each and every att
                  newAttsInAttributes, newEntitiesInAttributes = _processAttributes(att["attributes"], g)
  
                  # Updating the attributes to the current entity
                  g.node[hashLabel].update(newAttsInAttributes)
  
                  # Creating the edges (the new entities have also been created in the _processAttributes
                  for new in newEntitiesInAttributes:
                      graphData.add_edge(hashLabel, json.dumps(new))
                      try:
                          # Here, we would add the properties of the edge
                          #graphData.edge[hashLabel][json.dumps(new)]["@times_seen"] +=1
                          pass
                      except:
                          # If the attribute does not exist, we would initialize it
                          #graphData.edge[hashLabel][json.dumps(new)]["@times_seen"] = 1
                          pass
              else:
                  # An unexpected type
                  pass
  
          return newAtts, newEntities
  
      graphData = oldData
      # Iterating through the results
      for elem in data:
          # Creating a dict to represent the pair: type, value entity.
          ent = {
              "value":elem["value"],
              "type":elem["type"],
          }
  
          # Appending the new node
          new_node = _addNewNode(ent, graphData)
  
          # Processing the attributes to grab the attributes (starting with "@..." and entities)
          newAtts, newEntities = _processAttributes(elem["attributes"], graphData)
  
          # Updating the attributes to the current entity
          graphData.node[new_node].update(newAtts)
  
          # Creating the edges (the new entities have also been created in the _processAttributes
          for other_node in newEntities:
              # Serializing the second entity
              serEnt = json.dumps(new_node)
  
              try:
                  other_node = unicode(other_node["value"])
              except UnicodeEncodeError as e:
                  # Printing that an error was found
                  other_node = str(other_node["value"])
  
              # Adding the edge
              graphData.add_edge(new_node, other_node)
              try:
                  # Here, we would add the properties of the edge
                  #graphData.edge[hashLabel][hashLabelSeconds]["times_seen"] +=1
                  pass
              except:
                  # If the attribute does not exist, we would initialize it
                  #graphData.edge[hashLabel][hashLabelSeconds]["times_seen"] = 1
                  pass
  
      return graphData