Esempio n. 1
0
def build_gexf(edges, out_name, p_sample = 1):
  if not Gexf_loaded:
    print 'Could not load Gexf from module gexf.'
    return
  gexf = Gexf("snikolov", out_name)
  graph = gexf.addGraph('directed', 'dynamic', out_name)
  end = str(max([edge[2] for edge in edges]))
  for (src, dst, time) in edges:
    if np.random.rand() > p_sample:
      continue
    # Assumes time is in epoch seconds
    #d = datetime.datetime.fromtimestamp(int(time))    
    #date = d.isoformat()
    start = str(time)
    if src != -1:
      if not graph.nodeExists(src) or start < graph._nodes[src].start:
        graph.addNode(id = src, label = '', start = start, end = end)
      if not graph.nodeExists(dst) or start < graph._nodes[dst].start:
        graph.addNode(id = dst, label = '', start = start, end = end)
      graph.addEdge(id = str(src) + ',' + str(dst), source = src,
                    target = dst, start = start, end = end)
    else:
      if not graph.nodeExists(dst):
        graph.addNode(id = dst, label = '', start = start, end = end)
      
  out = open('/Users/snikolov/projects/twesearch/data/graphs/' + out_name + '.gexf', 'w')
  gexf.write(out)
  out.close()
Esempio n. 2
0
def build_gexf(path, out_name, p_sample = 1):
  if not Gexf_loaded:
    print 'Could not import Gexf from gexf module.'
    return
  graphs = {}
  gexfs = {}
  call(['mkdir', 'data/graphs/' + out_name])
  files = os.listdir(path)
  for (fi, file) in enumerate(files):
    print file
    if not re.match('part-.-[0-9]{5}',file):
      print 'Filename', file, 'not valid data. Skipping...'
      continue
    if os.path.isdir(file):
      print 'File', file, 'is directory. Skipping...'
      continue
    f = open(os.path.join(path,file), 'r')
    line = f.readline()
    while line:
      if np.random.rand() > p_sample:
        line = f.readline()
        continue
      if np.random.rand() < 0.0001:
        print sorted([ (len(graphs[t]._nodes), len(graphs[t]._edges), t) for t in graphs ])
      fields = line_to_fields(line)
      if len(fields) != 12:
        # print 'Bad line', line, '. Skipping...'
        line = f.readline()
        continue
      dst_status_id = fields[0]
      src_status_id = fields[4]
      time = fields[5]
      topic = fields[8]

      # Clean non ASCII chars from topic name, since XML complains.
      topic = ''.join(c for c in topic if ord(c) < 128)

      if topic not in gexfs:
        gexfs[topic] = Gexf("Stanislav Nikolov", topic)
        graphs[topic] = gexfs[topic].addGraph("directed", "dynamic", topic)
      if not graphs[topic].nodeExists(src_status_id):
        graphs[topic].addNode(id = str(src_status_id), label = "",
                              start = time, end = "Infinity")
      if not graphs[topic].nodeExists(dst_status_id):
        graphs[topic].addNode(id = str(dst_status_id), label = "",
                              start = time, end = "Infinity")
      graphs[topic].addEdge(id = "(" + str(src_status_id) + "," + str(dst_status_id) + ")",
                            source = src_status_id,
                            target = dst_status_id,
                            start = time,
                            end = "Infinity")
      line = f.readline()

    for topic in gexfs.keys():
      clean_topic = ''.join([ c for c in topic if (c != '#' and c != ' ') ])
      out = open("data/graphs/" + out_name + "/" + clean_topic + ".gexf", "w")
      gexfs[topic].write(out)
      out.close()
Esempio n. 3
0
def generateXml(G, layers):
    gexf = Gexf("lzu.edu", "network based on IPv6")
    graph = gexf.addGraph("undirected", "static", "network based on IPv6")

    # atr1 = graph.addNodeAttribute('ip address',type='string',defaultValue='true')
    atr1 = graph.addNodeAttribute(force_id='modularity_class',
                                  title='Modularity Class',
                                  type='integer')

    f = faker.Faker(locale='zh-CN')
    print('ipv6:{}'.format(f.ipv6()))

    nodes = list(G.nodes)
    edges = list(G.edges)
    print('nodes:{}'.format(nodes))
    print('edges:{}'.format(edges))

    activate_nodes = []
    for i in range(len(layers)):
        for j in range(len(layers[i])):
            activate_nodes.append(layers[i][j])

    for i in range(len(nodes)):
        tmp = graph.addNode(nodes[i], f.ipv6())
        attribute_flag = 0
        for j in range(len(layers)):
            if nodes[i] in layers[j]:
                attribute_flag = j + 1
                break
        tmp.addAttribute(atr1, str(attribute_flag))
    for i in range(len(edges)):
        graph.addEdge(str(i), str(edges[i][0]), str(edges[i][1]))
    # tmp = graph.addNode("0","Gephi")
    # tmp.addAttribute(atr1,"http://gephi.org")
    # tmp = graph.addNode("1","Webatlas")
    # tmp.addAttribute(atr1,"http://webatlas.fr")
    # tmp = graph.addNode("2","RTGI")
    # tmp.addAttribute(atr1,"http://rtgi.fr")
    # tmp = graph.addNode("3","BarabasiLab")
    # tmp.addAttribute(atr1,"http://barabasilab.com")

    # graph.addEdge("0","0","1",weight='1')
    # graph.addEdge("1","0","2",weight='1')
    # graph.addEdge("2","1","0",weight='1')
    # graph.addEdge("3","2","1",weight='1')
    # graph.addEdge("4","0","3",weight='1')

    xml_file = os.getcwd(
    ) + os.sep + 'app' + os.sep + 'static' + os.sep + 'data' + os.sep + 'xml' + os.sep + 'data.xml'
    output_file = open(xml_file, "wb")
    gexf.write(output_file)
Esempio n. 4
0
def generate_graph():
    gexf = Gexf("sna - meetup.com", "A meetup.com social network analysis")
    graph = gexf.addGraph("undirected", "static", "Meetup groups graph")

    # attributes
    organizer_attr = graph.addNodeAttribute('organizer', 'None', 'string')
    type_attr = graph.addNodeAttribute('type', 'None', 'string')
    category_attr = graph.addNodeAttribute('category', 'None', 'integer')

    groups = get_data('data/groups.json')
    members = get_data('data/members.json')

    # print groups[0]
    # print members[0]

    groups = list(filter(lambda x: int(x['members']) <= 200, groups))

    print "Total number of groups: %s" % len(groups)

    for index, group in enumerate(groups):
        node = graph.addNode("G-%s" % group.get('id'), group.get('urlname'))
        if group.get('organizer'):
            node.addAttribute(organizer_attr,
                              str(group.get('organizer').get('member_id')))
        if group.get('category'):
            node.addAttribute(category_attr,
                              str(group.get('category').get('id')))
        node.addAttribute(type_attr, 'Group')

    members = list(
        filter(
            lambda x: (x['group_id']) in list(map(lambda x: x['id'], groups)),
            members))

    print "Total number of members: %s" % len(members)

    for index, member in enumerate(members):
        # print index + 1

        node = graph.addNode("M-%s" % member.get('member_id'),
                             get_member_name(member.get('name')))
        node.addAttribute(type_attr, 'Member')

        graph.addEdge(
            index,
            "G-%s" % member.get('group_id'),
            "M-%s" % member.get('member_id'),
        )

    return gexf
Esempio n. 5
0
def getgexf(g):
    gexf = Gexf('hxq', 'test graph')
    graph = gexf.addGraph('undirected graph')

    node_counter = 0
    for node in g.nodes():
        graph.addNode(node_counter, node)
        node_couter += 1

    edge_counter = 0
    for edge in g.edges():
        start, end = edge
        graph.addEdge(edge_counter, start, end)

    output_file = open('graph.gexf', 'w')
    gexf.write(output_file)
def tree2graph(tree_nodes):
    tree_xml = ''
    dt, max_depth, max_width = buchheim_weibospread.buchheim(tree_nodes[0])

    gexf = Gexf('tree', 'simple')
    graph = gexf.addGraph('directed', 'static', 'weibo graph')
    graph.addNodeAttribute('photo_url', type='URI', force_id='photo_url')
    graph.addNodeAttribute('name', type='string', force_id='name')
    graph.addNodeAttribute('location', type='string', force_id='location')
    graph.addNodeAttribute('datetime', type='string', force_id='datetime')
    graph.addNodeAttribute('repost_num', type='string', force_id='repost_num')
    graph.addNodeAttribute('weibo_url', type='URI', force_id='weibo_url')
    
    add_node_and_edge(dt, graph, Count(), max_width=max_width)

    return etree.tostring(gexf.getXML(), pretty_print=False, encoding='utf-8', xml_declaration=True), max_depth, max_width
Esempio n. 7
0
  def convert(self,nodes,ties):

    gexf = Gexf(config.CREATOR, config.DESCRIPTION)
    graph = gexf.addGraph(config.DEFAULTEDGETYPE, config.MODE, config.LABEL)

    # Percorre todos os nós
    for node in nodes.keys():
      for item in nodes[node]:
        graph.addNode(nodes[node][item]['id'], item)

    for i in xrange(len(ties)):
      graph.addEdge(i, ties[i][0], ties[i][1])

    output = open(config.OUTPUT_FILE,'w')
    gexf.write(output)

    output.close()
Esempio n. 8
0
def derived_x_to_y():
    txt = open('./dot/derived_x_to_y.gv', 'w')
    txt.write('//%s\n' % (str(datetime.now())))
    txt.write('digraph graphname {\n')
    gexf = Gexf('Jianhua Shao', 'Thingiver derivation mapping')
    graph = gexf.addGraph('directed', 'static', 'derivation_x_y')
    #attr_node = graph.addNodeAttribute('url', '', 'string')
    attr_edge = graph.addEdgeAttribute('c_days', '', 'string')
    #sql = sql_derived_x_to_y
    sql = sql_derived_x_to_y_created_time
    param = ()
    c = conn.cursor()
    c.execute(sql, param)
    for r in c.fetchall():
        print r
        x = r[1]
        y = r[2]
        x_ctime = r[3]
        y_ctime = r[4]
        x = x.strip('\n\t/thing:')
        #x = int(x)
        y = y.strip('\n\t/thing:')
        #y = int(y)
        #print type(x), type(y)
        #print x, y
        x_ctime = datetime.strptime(x_ctime, '%b %d, %Y')
        y_ctime = datetime.strptime(y_ctime, '%b %d, %Y')
        duration = (y_ctime - x_ctime).days
        #print duration
        dot_line = '\t{%s} -> {%s} [label=%s];\n' % (x, y, str(duration))
        print dot_line
        txt.write(dot_line)
        n_x = graph.addNode(str(x), str(x))
        n_y = graph.addNode(str(y), str(y))
        #n_x.addAttribute(attr_node, 'string')
        #n_y.addAttribute(attr_node, 'string')
        e = graph.addEdge('%s_%s' % (str(x), str(y)), x, y)
        e.addAttribute(attr_edge, str(duration))
        #print e
    c.close()
    txt.write('}')
    txt.close()
    gexf_file = open('./dot/derived_x_to_y.gexf', 'w')
    gexf.write(gexf_file)
    print "finish"
Esempio n. 9
0
def gen_gexf(ofile='./../gexf/test2.gexf'):
    import sys, pprint
    from gexf import Gexf

    # test helloworld.gexf
    gexf = Gexf("Gephi.org", "A Web network")
    graph = gexf.addGraph("directed", "static", "A Web network")

    atr2 = graph.addNodeAttribute('modularity_class', 'Modularity Class',
                                  'integer')

    tmp = graph.addNode("0", "A")
    tmp.addAttribute(atr2, "0")

    tmp = graph.addNode("1", "B")
    tmp.addAttribute(atr2, "0")

    graph.addEdge("0", "0", "1", weight='1')

    output_file = open(ofile, "w")
    gexf.write(output_file)
Esempio n. 10
0
def make_gexf(gexf_name_1, gexf_name_2, G, node_degree, key_users, all_uid_pr, pr_data, partition, new_attribute_dict):
    gexf = Gexf(gexf_name_1, gexf_name_2)

    node_id = {}
    graph = gexf.addGraph("directed", "static", "demp graph")
    graph.addNodeAttribute('name', type='string', force_id='name')
    graph.addNodeAttribute('location', type='string', force_id='location') # 添加地理位置属性
    graph.addNodeAttribute('timestamp', type='int', force_id='timestamp')
    graph.addNodeAttribute('pagerank', type='string', force_id='pagerank')
    graph.addNodeAttribute('acategory', type='string', force_id='acategory')
    graph.addNodeAttribute('text', type='string', force_id='text')
    graph.addNodeAttribute('reposts_count', type='string', force_id='reposts_count') # 新添加的属性
    graph.addNodeAttribute('comments_count', type='string', force_id='comments_count')
    graph.addNodeAttribute('attitude_count', type='string', force_id='attitude_count')
    graph.addNodeAttribute('rank_pr', type='string', force_id='rank_pr') # 用户的pagerank值对应的排名
    pos = nx.spring_layout(G) # 定义一个布局 pos={node:[v...]/(v...)}

    node_counter = 0
    edge_counter = 0

    for node in G.nodes():
        x, y = pos[node] # 返回位置(x,y)
        degree = node_degree[node]
        if node not in node_id: # {node:排名}
            node_id[node] = node_counter
            node_counter += 1
        uid = node # 节点就是用户名
        if uid in key_users: # 根据是否为关键用户添加不同的节点 
            _node = graph.addNode(node_id[node], str(node), x=str(x), y=str(y), z='0', r='255', g='51', b='51', size=str(degree))
        else:
            _node = graph.addNode(node_id[node], str(node), x=str(x), y=str(y), z='0', r='0', g='204', b='204', size=str(degree))
        cluster_id = str(partition[node])
        _node.addAttribute('acategory', cluster_id)
        #print 'al_uid_pr:', all_uid_pr
        pr = str(all_uid_pr[str(uid)])
        _node.addAttribute('pagerank', pr)
        rank = pr_data[uid]
        _node.addAttribute('rank_pr', str(rank))
        #print 'pagarank_uid:', uid
        try:
            text_add = new_attribute_dict[uid][0][0] # 添加节点属性--text
            _node.addAttribute('text', json.dumps(text_add))
            reposts_count_add = i2u(new_attribute_dict[uid][0][1])
            _node.addAttribute('reposts_count', reposts_count_add) # 添加节点属性--reposts_count
            comment_count_add = i2u(new_attribute_dict[uid][0][2])
            _node.addAttribute('comments_count', comment_count_add) # 添加节点属性--comment_count
            attitude_count_add = i2u(new_attribute_dict[uid][0][3])
            if attitude_count_add == None:
                attitude_count_add = u'未知'
            _node.addAttribute('attitude_count', i2u(attitude_count_add)) # 添加节点属性--attitude_count
        except KeyError:
            _node.addAttribute('text', u'未知')
            _node.addAttribute('reposts_count', u'未知')
            _node.addAttribute('comments_count', u'未知')
            _node.addAttribute('attitude_count', u'未知')
        user_info = acquire_user_by_id(uid) # 获取对应的用户信息,添加属性
        if user_info:
            _node.addAttribute('name', user_info['name'])
            _node.addAttribute('location', user_info['location'])
        else:
            _node.addAttribute('name', u'未知')
            _node.addAttribute('location', u'未知')
            #_node.addAttribute('timestamp', str(uid_ts[uid]))

    for edge in G.edges():
        start, end = edge # (repost_uid, source_uid)
        start_id = node_id[start]
        end_id = node_id[end]
        graph.addEdge(str(edge_counter), str(start_id), str(end_id))
        edge_counter += 1

    return gexf
Esempio n. 11
0
def make_ds_gexf(gexf_name_1, gexf_name_2, G, node_degree, pr_key_users, all_uid_pr, ds_pr_data, partition, ds_new_attribute_dict):
    gexf = Gexf(gexf_name_1, gexf_name_2)

    node_id = {}
    graph = gexf.addGraph('directed', 'static', 'demp graph')
    graph.addNodeAttribute('name', type='string', force_id='name')
    graph.addNodeAttribute('location', type='string', force_id='location')
    graph.addNodeAttribute('timestamp', type='string', force_id='timestamp')
    graph.addNodeAttribute('pagerank', type='float', force_id='pagerank')
    #graph.addNodeAttribute('trendsetter_rank', type='float', force_id='trendsetter_rank')
    graph.addNodeAttribute('acategory', type='string', force_id='acategory')
    graph.addNodeAttribute('text', type='string', force_id='text')
    graph.addNodeAttribute('reposts_count', type='string', force_id='reposts_count')
    graph.addNodeAttribute('comments_count', type='string', force_id='comments_count')
    graph.addNodeAttribute('attitude_count', type='string', force_id='attitude_count')
    graph.addNodeAttribute('rank_pr', type='string', force_id='rank_pr')
    #graph.addNodeAttribute('rank_tr', type='string', force_id='rank_tr')

    pos = nx.spring_layout(G)

    node_counter = 0
    edge_counter = 0

    for node in G.nodes():
        x, y = pos[node]
        degree = node_degree[node]
        if node not in node_id: # 判断该节点是否已经加入到图中
            node_id[node] = node_counter
            node_counter += 1
        uid = node # 节点就是用户名
        if uid in pr_key_users:
            _node = graph.addNode(node_id[node], str(node), x=str(x), y=str(y), z='0', r='255', g='51', b='51', size=str(degree))
        else:
            _node = graph.addNode(node_id[node], str(node), x=str(x), y=str(y), z='0', r='0', g='204', b='204', size=str(degree))
        cluster_id = str(partition[node])
        _node.addAttribute('acategory', cluster_id)
        pr = str(all_uid_pr[str(uid)])
        _node.addAttribute('pagerank', pr)
        #print 'all_uid_tr:', all_uid_tr
        #print 'all_uid_pr:', all_uid_pr
        #tr = str(all_uid_tr[str(uid)])
        #_node.addAttribute('trendsetter_rank', tr)
        rank_pr = ds_pr_data[uid]
        _node.addAttribute('rank_pr', str(rank_pr))
        #rank_tr = ds_tr_data[uid]
        #_node.addAttribute('rank_tr', str(rank_tr))
        try:
            text_add = ds_new_attribute_dict[uid][0][0]
            _node.addAttribute('text', json.dumps(text_add))
            reposts_count_add = i2u(ds_new_attribute_dict[uid][0][1])
            _node.addAttribute('reposts_count', reposts_count_add)
            comment_count_add = i2u(ds_new_attribute_dict[uid][0][2])
            _node.addAttribute('comments_count', comment_count_add)
            attitude_count_add = i2u(ds_new_attribute_dict[uid][0][3])
            if attitude_count_add == None:
                attitude_count_add = u'未知'
            _node.addAttribute('attitude_count', i2u(attitude_count_add))
            timestamp_add = i2u(ds_new_attribute_dict[uid][0][4])
            _node.addAttribute('timestamp', timestamp_add)
        except KeyError:
            _node.addAttribute('text', u'未知')
            _node.addAttribute('reposts_count', u'未知')
            _node.addAttribute('comments_count', u'未知')
            _node.addAttribute('attitude_count', u'未知')
            _node.addAttribute('timestamp', u'未知')
        user_info = acquire_user_by_id(uid) # 获取对应的用户信息,添加属性
        if user_info:
            _node.addAttribute('name', user_info['name'])
            _node.addAttribute('location', user_info['location'])
        else:
            _node.addAttribute('name', u'未知')
            _node.addAttribute('location', u'未知')


    for edge in G.edges():
        start, end = edge # (repost_uid, source_uid)
        start_id = node_id[start]
        end_id = node_id[end]
        graph.addEdge(str(edge_counter), str(start_id), str(end_id))
        edge_counter += 1

    return gexf
Esempio n. 12
0
    if 'e+' in time:
        calctime = time.split('e+')
        time = str(float(calctime[0]) * pow(10, int(calctime[1])))
    elif 'e-' in time:
        calctime = time.split('e-')
        time = str(float(calctime[0]) * pow(10, int(calctime[1]) * (-1)))
    return time


lsArgs = sys.argv

trace_file = open(lsArgs[1], 'r')
trace_lines = trace_file.readlines()
trace_file.close()

gexf = Gexf("Pedro and David", "Dynamic graph")
graph = gexf.addGraph("directed", "dynamic", "Graph")
idTotalNodeDuration = graph.addNodeAttribute("Total Duration", "0.0",
                                             "float")  #name, default, type
idTotalEdgeDuration = graph.addEdgeAttribute("Total Duration", "0.0", "float")
idLinkType = graph.addEdgeAttribute("Type", "None", "string")
idNumMsgs = graph.addEdgeAttribute("Number of messages", "0", "integer")

dicEvents = {}

i = 0
while (trace_lines[i].startswith('%') == True):

    if ('%EventDef' in trace_lines[i]):

        lsLine = trace_lines[i].split(' ')
Content-Type: text/html\n
<html>
  <head>
  <meta charset="utf-8" />
  <link rel="stylesheet" href="http://tools.christopherkullenberg.se/style.css">
    <title>Results</title>
  </head>
<body>
   <p>Processing...</p>
""" + message)

thefile = open("upload/" + fn, 'r', encoding="utf-8")
tsv = csv.reader(thefile, delimiter='\t')
next(tsv)  #remove headers

gexf = Gexf("Citation Network", "File:" + fn + ".")
graph = gexf.addGraph("directed", "static", "Web of Science Citation network")

citationnetworkdict = {}

for t in tsv:
    AU = t[1]
    CR = t[29]
    citationnetworkdict.update({AU: CR.split('; ')})

numberofedges = 0
for key, value in citationnetworkdict.items():
    graph.addNode(key, key)

    for v in value:
        graph.addNode(v, v)
from gexf import Gexf, GexfImport


#gephx is xml, which does not support accents, so we need to remove them
def remove_accents(word):
    return ''.join(x for x in unicodedata.normalize('NFKD', word)
                   if x in string.ascii_letters)


df = pd.read_csv('authors_counts.csv', delimiter=',', index_col=0)

rows = list(df.index)
cols = list(df.columns.values)
num = len(rows)

gexf = Gexf("emCOMP", "Authors")
G = gexf.addGraph("directed", "static", "Authors")

unreadable_names = {}
#add nodes
for r in rows:
    #gephx needs unicode, make sure the string is unicode
    if isinstance(unicode(r, "utf-8"), str):
        print "ordinary string"
    elif isinstance(unicode(r, "utf-8"), unicode):
        print "unicode string"
    #Checking myself
    print(r)
    print(remove_accents(unicode(r, "utf-8")))
    new_string = remove_accents(unicode(r, "utf-8"))
    count = 0
Esempio n. 15
0
import sys, pprint
from gexf import Gexf
import codecs

input_file = codecs.open("pr-lpa2.txt", encoding="utf-8")
gexf = Gexf("2018st27", "LPA")
graph = gexf.addGraph("undirected", "static", "LPA")

class_attr = graph.addNodeAttribute("Class",
                                    defaultValue=0,
                                    type="integer",
                                    force_id="class")
pr_attr = graph.addNodeAttribute('PageRank',
                                 defaultValue=0.0,
                                 type="double",
                                 force_id="pageranks")

i = 0
library = {}
for line in input_file:
    strs = line.split("\t")
    label_name = strs[0].split("#")
    library[label_name[1]] = i
    node = graph.addNode(i, label_name[1])
    node.addAttribute(class_attr, label_name[0])
    node.addAttribute(pr_attr, label_name[2])
    i += 1

i = 0
input_file.seek(0)
Esempio n. 16
0
import sys

sys.path.append('../gexf')
from gexf import Gexf, GexfImport

df = pd.read_csv('article_similarity_filtered.csv', delimiter=',', index_col=0)
dates = pd.read_csv('master_articles-scraped_filtered_aritcles.csv',
                    delimiter=',')

rows = list(df.index)
rows.remove('Article URL')
cols = list(df.columns.values)
num = len(rows)
cols.remove('Article URL.1')

gexf = Gexf("emCOMP", "Article Similarity")
graph = gexf.addGraph("undirected", "static", "Article Similarity")

#add nodes
for r in rows:
    graph.addNode(r, dates.loc[r, "updated_domain"])

#add edges
count = 0
count_r = 0
for r in rows:
    print("r" + str(count_r))
    for c in cols:
        #can be adapted for directed graph
        if (df.loc[r, c] > .85):
            r_date = datetime.datetime.strptime(str(dates.loc[r, "first_ts"]),
Esempio n. 17
0
DB_NAME = "picbrother"

try:
    conn = MySQLdb.connect(host=DB_HOST,
                           user=DB_USER,
                           passwd=DB_PSWD,
                           db=DB_NAME,
                           use_unicode=True)
except MySQLdb.Error, e:
    print "Error %d: %s" % (e.args[0], e.args[1])
    sys.exit(1)

cursor = conn.cursor()

if __name__ == '__main__':
    gexf = Gexf("PIC BROTHER", "Le graph du pic !")
    graph = gexf.addGraph("undirected", "static", "Picbrother graph")
    cursor.execute("SELECT id, fb_id, first_name, last_name FROM  `T_USER` ")
    rows = cursor.fetchall()
    for row in rows:
        print "%s, %s, %s, %s" % (row[0], row[1], row[2], row[3])
        #graph.addNode(row[0],u"#%s => %s %s" % (row[1],row[2],row[3])) #  ==>  Probléme d'accent... Comment faire ?
        graph.addNode(str(row[0]),
                      unac.unac_string("%s %s" % (row[2], row[3]), "utf-8"))
    print "Nombre de user ajoute : %d" % cursor.rowcount
    cursor.execute(
        "SELECT U1.user_id, U2.user_id, COUNT( * ) weight FROM  `J_PHOTO_USER` U1,  `J_PHOTO_USER` U2 WHERE U1.photo_id = U2.photo_id AND U1.user_id != U2.user_id GROUP BY U1.user_id, U2.user_id"
    )
    rows = cursor.fetchall()
    edge_id = 0
    for row in rows:
Esempio n. 18
0
#!/usr/bin/python2.7

import pygeoip as geoip
from gexf import Gexf

db = geoip.Database('GeoIP.dat')
gexf = Gexf("Alexander Konovalov", "The internet map")
graph = gexf.addGraph("directed", "static", "The internet map")

attrid = graph.addNodeAttribute("country", "??", type="string")


def addIP(ip):
    if not graph.nodeExists(ip):
        info = db.lookup(ip)
        country = "??"
        if info.country:
            country = info.country
        n = graph.addNode(ip, ip)
        n.addAttribute(attrid, country)


n = 0
with open("out.csv") as f:
    for line in f:
        ips = tuple(line.strip().replace("-", ".").split('\t'))
        if len(ips) < 2:
            continue
        ip1, ip2 = ips
        addIP(ip1)
        addIP(ip2)
Esempio n. 19
0
from gexf import Gexf
from py2neo import cypher, neo4j

__author__ = 'Trevor Grant'


# test helloworld.gexf
gexf = Gexf(__author__,__title__)
graph=gexf.addGraph("directed","static",__desc__)
graph_db = neo4j.GraphDatabaseService()


query = neo4j.CypherQuery(graph_db, "MATCH (n) WHERE n.on_path=1 RETURN n" ) 
results = query.execute()
# Query for relationships where both nodes have .on_path
for r in results:
	quite =graph.addNode(str(r[0]._id),r[0]['KEYWORD_TEXT'])
#	if r[0]._id == 2418: print 'yup'


RESULTS_PER_PAGE= 1000
# Query for nodes with .on_path

paging = False
skip=0
query = neo4j.CypherQuery(graph_db, "MATCH (m {on_path:1})-[r]->(n {on_path:1}) RETURN r ORDER BY ID(r) SKIP %i LIMIT %i" % (skip,RESULTS_PER_PAGE ))
results = query.execute()
if len(results)==1000: 
	paging=True
	skip += RESULTS_PER_PAGE
# Query for relationships where both nodes have .on_path
Esempio n. 20
0

# Main
if __name__ == "__main__":
	# MongoDB connection
	client 		= MongoClient('localhost', 27017)
	db 			= client.ccl
	mails 		= db.mails
	threads 	= db.threads
	authors		= db.authors

	# Create a graph
	g = nx.Graph()

	# Create a graph
	gexf 		= Gexf("Anne L'Hote","A bipartite graph of threads vs. authors")
	graph 		= gexf.addGraph("directed","static","ccl")

	output_file	= open("data/ccl.gexf","w")

	for author in authors.find():
		# Add a node by author
		g.add_node(str(author['_id']), {
			'viz': {
				'color': {'r': authorColor['r'], 'g': authorColor['g'], 'b': authorColor['b']},
				'position': {'y': random.random(), 'x': random.random(), 'z': 0.0},
				'size': author['count']},
			'label': author['email']
		})

	for thread in threads.find({'count':{'$gte':3}}):
Esempio n. 21
0
#!/usr/bin/python

from gexf import Gexf, GexfImport

# test helloworld.gexf
gexf = Gexf("Paul Girard", "A hello world! file")
graph = gexf.addGraph("directed", "static", "a hello world graph")

graph.addNode("0", "hello")
graph.addNode("1", "World")
graph.addEdge("0", "0", "1")

output_file = open("hellowrld.gexf", "w")
gexf.write(output_file)

# test GexfImport
f = open("exp.gexf")
o = open("exp_bootstrap_bootstrap.gexf", "w+")

gexf_import = GexfImport(f).gexf()
gexf_import.write(o)
Esempio n. 22
0
from gexf import Gexf
from lxml import etree
from model.school_chanye import search_school, search_chanye, search_school_chanye, search_school_id

import faker
f = faker.Faker(locale='zh-CN')

school = search_school()
chanye = search_chanye()
school_chanye = search_school_chanye()
school_id = search_school_id()

gexf = Gexf("school", "chanye")
graph = gexf.addGraph("school", "jiaoyu", "chanye")

atr1 = graph.addNodeAttribute(force_id='modularity_class',
                              title='schoolce',
                              defaultValue='true',
                              type='integer')
atr2 = graph.addNodeAttribute(force_id='chanye',
                              title='chan_ye',
                              defaultValue='true',
                              type='string')

for node in school:
    node_type = 'school'
    tmp_node = graph.addNode(str(node[0]), str(node[1]))
    tmp_node.addAttribute(atr1, str(node[0] - 1))

for node in chanye:
    node_type = 'chanye'
Esempio n. 23
0
def convert(team_name, channels_list, graph='mention_based_graph_info', user='******', pwd='FluoBySusTech',
            port=3306, host='10.20.13.209', dbname='rowdata'):
    from gexf import Gexf
    from textblob import TextBlob
    import random
    import pymysql
    import pandas as pd

    try:
        con = pymysql.Connect(
            host=host,  # 远程登录主机的ip地址
            port=port,  # mysql服务器的端口
            user=user,  # mysql的用户
            passwd=pwd,  # 密码
            db=dbname,  # 需要的数据库名称
        )
        # 获取本次的游标
        cur = con.cursor()
    except pymysql.Error as e:
        print("Error %d: %s" % (e.args[0], e.args[1]))

    cur.execute('select * from team_channel_relation ')
    team_to_channel = cur.fetchall()
    team_to_channel = list(map(list, zip(*team_to_channel)))
    team = team_to_channel[0][:]
    channel = team_to_channel[1][:]
    team_to_channel = {'team': team, 'channel': channel}
    team_to_channel = pd.DataFrame(team_to_channel)
    del team
    del channel

    for channel_file in channels_list:

        gexf = Gexf("Gephi.org", "A Web network")

        output = gexf.addGraph("directed", "static", "A Web network")

        cur.execute('select * from people_channel_relation where channel_id = \'' + channel_file + '\' ')
        person_and_channel = cur.fetchall()

        if len(person_and_channel) == 0:
            output_file = open(".\graphdata_of_" + channel_file + ".gexf", "wb")
            gexf.write(output_file)
            output_file.close()

        else:

            person_and_channel = list(map(list, zip(*person_and_channel)))
            person = person_and_channel[0][:]
            channel = person_and_channel[1][:]
            person_and_channel = {'person': person, 'channel': channel}
            person_and_channel = pd.DataFrame(person_and_channel)
            del person
            del channel

            person_list = person_and_channel['person']

            # print(person_and_channel)

            channel_node = output.addNodeAttribute(force_id="Channel", title="channel", type="String")
            team_node = output.addNodeAttribute(force_id="Team", title="team", type="String")
            weight_node = output.addNodeAttribute(force_id="Weight", title="weight", type="float")

            people_id = dict()
            #            id_list = ['people']
            #            for id in id_list:
            #                cur.execute('select * from ' + id)
            #                data = cur.fetchall()
            #                for i in data:
            #                    exec(id + '_id[\'' + i[0] + '\']=i[1]')
            #                    print('id', id)

            person_set = set(person_list)
            person_to_channel = []
            for tem_person in person_set:
                cur.execute('select * from people_channel_relation where people_id = \'' + tem_person + '\' ')

                person_to_channel = person_to_channel + list(cur.fetchall())

            person_to_channel = list(map(list, zip(*person_to_channel)))
            person = person_to_channel[0][:]
            channel = person_to_channel[1][:]
            person_to_channel = {'person': person, 'channel': channel}
            person_to_channel = pd.DataFrame(person_to_channel)

            # print(person_to_channel)

            cc = 0
            num2333 = len(person_set)
            for tem_id in person_set:
                #                print(cc / num2333)
                try:
                    tem_name = people_id[tem_id]
                except KeyError:
                    tem_name = "Null"

                tem_channel_list = set(person_to_channel[person_to_channel['person'] == tem_id]['channel'])

                tmp_node = output.addNode(tem_id, tem_name)
                tmp_node.addAttribute(weight_node, str(int(100 * random.random())))
                tem_team_list = set()
                for tem_channel in tem_channel_list:
                    # cur.execute('select team_id from team_channel_relation where channel_id = \'' + tem_channel + '\'')
                    # tem_team_list = cur.fetchall()
                    tem_team_list = tem_team_list | set(
                        team_to_channel[team_to_channel['channel'] == tem_channel]['team'])
                for tem_team in tem_team_list:
                    tmp_node.addAttribute(team_node, tem_team)

                for tem_channel in tem_channel_list:
                    tmp_node.addAttribute(channel_node, tem_channel)

                cc = cc + 1

            m = 'mention_based_graph_info'
            cur.execute('select * from ' + m + ' where channel_id = \'' + channel_file + '\' ')
            data = cur.fetchall()

            msg_att = output.addEdgeAttribute(force_id="Message", title="message", type='String', defaultValue='None')
            weight_att = output.addEdgeAttribute(force_id="Weight", title="weight", type='float', defaultValue='0')
            date_att = output.addEdgeAttribute(force_id="Date", title="date", type='float', defaultValue='None')
            channel_att = output.addEdgeAttribute(force_id="Channel", title="channel", type='String',
                                                  defaultValue='None')
            team_att = output.addEdgeAttribute(force_id="Team", title="team", type='String', defaultValue='None')
            cc = 0
            numhehe = len(data)
            for tem_m in data:
                #                print(cc / numhehe)
                sender, receiver, text, channel_id, team_id, ts = tem_m
                blob = TextBlob(text)
                weight = str(blob.sentiment.polarity)
                try:
                    tem_edge = output.addEdge(sender + receiver + str(cc), sender, receiver, weight=weight)
                except Exception:
                    try:
                        tmp_node = output.addNode(receiver, 'Null')
                        tem_edge = output.addEdge(sender + receiver + str(cc), sender, receiver, weight=weight)
                    except Exception:
                        tmp_node = output.addNode(sender, 'Null')
                        tem_edge = output.addEdge(sender + receiver + str(cc), sender, receiver, weight=weight)

                cc = cc + 1
                tem_edge.addAttribute(msg_att, text)
                tem_edge.addAttribute(weight_att, weight)
                tem_edge.addAttribute(date_att, str(ts))
                tem_edge.addAttribute(team_att, team_id)
                tem_edge.addAttribute(channel_att, channel_id)


            output_file = open(dir_path + "/mention_based/{}_{}.gexf".format(team_name, channel_file), "wb")
            gexf.write(output_file)
            output_file.close()
Esempio n. 24
0
from gexf import Gexf
try:
    gexf = Gexf ("Jianhua Shao", "hello world description")
    graph = gexf.addGraph ("directed", "static", "hello world hints")
    attribute_node = graph.addNodeAttribute("name", "default_value", "type like string")
    attribute_edge = graph.addEdgeAttribute("name", "default_value", "type like boolean")
    n = graph.addNode("0", "node_name")
    n1=graph.addNode("1", "node_name1")
    n1=graph.addNode("2", "node_name2")
    n1=graph.addNode("3", "node_name3")
    #n.addAttribute(attribute_node, "mashup")
    e = graph.addEdge("name", "0", "1")
    
    e.addAttribute(attribute_edge, "true")
    e1 = graph.addEdge("name", "0", "2")
    e2 = graph.addEdge("name", "1", "2")
    e3 = graph.addEdge("name", "2", "3")
    output_file = open("D://programableweb.gexf", "w")
    gexf.write(output_file)
    #outputfile.close()
except:
    print "error"
    pass
"""import networkx as nx
import enchant
import matplotlib.pyplot as plt
g=nx.Graph()
g.add_node(1)
g.add_node(2)
g.add_edge(1,2)
#nx.draw(g)
Esempio n. 25
0
    nodeSet = set()
    edgeSet = {}
    newNode = set(['color'])


    for i in range(3):
        edges = findBSiblings(newNode)
        currentSiblingSet = set()

        for edge in edges:
            currentSiblingSet.add(edge[0])
            currentSiblingSet.add(edge[1])
            if edgeSet.has_key(edge[0]+"_"+edge[1]) == False and edgeSet.has_key(edge[1]+"_"+edge[0]) == False:
                edgeSet[edge[0]+"_"+edge[1]] = edge

        newNode = currentSiblingSet - nodeSet
        nodeSet = nodeSet | newNode

    gexf = Gexf("Husonchen", "A hello world! file")
    graph = gexf.addGraph("undirected", "static", "categories")

    for node in nodeSet:
        graph.addNode(node, node)

    i = 0
    for edge in edgeSet.values():
        graph.addEdge(str(i),edge[0] , edge[1])
        i += 1

    output_file = open("helloworld.gexf", "w")
    gexf.write(output_file)
Esempio n. 26
0
from gexf import Gexf
from lxml import etree
from model.school_xuke import search_school, search_xueke, search_school_xuke, search_school_id

import faker
f = faker.Faker(locale='zh-CN')

school = search_school()
xuke = search_xueke()
school_xuke = search_school_xuke()
school_id = search_school_id()

gexf = Gexf("school", "xueke")
graph = gexf.addGraph("school", "jiaoyu", "xueke")

atr1 = graph.addNodeAttribute(force_id='modularity_class',
                              title='schoolce',
                              defaultValue='true',
                              type='integer')
atr2 = graph.addNodeAttribute(force_id='xueke',
                              title='xu_ke',
                              defaultValue='true',
                              type='string')

for node in school:
    node_type = 'school'
    tmp_node = graph.addNode(str(node[0]), str(node[1]))
    tmp_node.addAttribute(atr1, str(node[0] - 1))

for node in xuke:
    node_type = 'xuke'
Esempio n. 27
0
from gexf import Gexf
import cjdnsmap
import sys

if len(sys.argv) != 2:
	print "usage: " + sys.argv[0] + " output.gexf"
	sys.exit()

output_filename = sys.argv[1]


nodes, edges = cjdnsmap.get_map()

gexf = Gexf("cjdns mapper", "A map of cjdns network")
graph = gexf.addGraph("undirected", "static", "cjdns network graph")

attr_ip                 = graph.addNodeAttribute("IP",                 type="string")
attr_version            = graph.addNodeAttribute("Version",            type="integer")
attr_connections        = graph.addNodeAttribute("Connections",        type="integer")
attr_active_connections = graph.addNodeAttribute("Active connections", type="integer")

attr_quality            = graph.addEdgeAttribute("Quality", 0,         type="float")


for node in nodes:
	n = graph.addNode(node.ip, node.name)
	n.addAttribute(attr_ip, node.ip)
	n.addAttribute(attr_version, str(node.version))
	n.addAttribute(attr_connections, str(node.connections))
	n.addAttribute(attr_active_connections, str(node.active_connections))
Esempio n. 28
0
import sys, pprint
from gexf import Gexf

# test helloworld.gexf
gexf = Gexf("course system", "neo4j graph")
graph = gexf.addGraph("directed", "static", "A Web network")

atr1 = graph.addNodeAttribute('url',
                              type='string',
                              defaultValue='123',
                              force_id='testid')
atr2 = graph.addNodeAttribute('indegree',
                              type='float',
                              defaultValue='true',
                              force_id='modularity_class')
atr3 = graph.addNodeAttribute('frog', type='boolean', defaultValue='true')

tmp = graph.addNode("0", "Gephi")
tmp.addAttribute(atr1, "http://gephi.org")
tmp.addAttribute(atr2, '1')

tmp = graph.addNode("1", "Webatlas")
tmp.addAttribute(atr1, "http://webatlas.fr")
tmp.addAttribute(atr2, '2')

tmp = graph.addNode("2", "RTGI")
tmp.addAttribute(atr1, "http://rtgi.fr")
tmp.addAttribute(atr2, '3')

tmp = graph.addNode("3", "BarabasiLab")
tmp.addAttribute(atr1, "http://barabasilab.com")
Esempio n. 29
0
import sys
import pprint
from gexf import Gexf

# test helloworld.gexf
gexf = Gexf("Home With Kids", "A Demo Graph")
graph = gexf.addGraph("directed", "static", "A Demo Graph")

atr1 = graph.addNodeAttribute('ID', type='string')
atr2 = graph.addNodeAttribute('adult', type='boolean', defaultValue='true')

tmp = graph.addNode("0", "刘梅")
tmp.addAttribute(atr1, "123456")
tmp.addAttribute(atr2, 'true')

tmp = graph.addNode("1", "夏东海")
tmp.addAttribute(atr1, "534523")
tmp.addAttribute(atr2, 'true')

tmp = graph.addNode("2", "夏雪")
tmp.addAttribute(atr1, "2312311")
tmp.addAttribute(atr2, 'false')

tmp = graph.addNode("3", "刘星")
tmp.addAttribute(atr1, "1231231")
tmp.addAttribute(atr2, 'false')

tmp = graph.addNode("4", "夏雨")
tmp.addAttribute(atr1, "2314889")
tmp.addAttribute(atr2, 'false')
# # 根据输入文件构建国家交互网络
# def graphBuild(nodeList, edgeList):
#     # for indexs in nodeList.index:
#     # graphCon.add_node(nodeList.node[indexs].strip())
#     # 上面注释了的代码是添加节点,不过也可以不需要,因为下面添加边的时候,边两端的节点会自动添加到网络中
#     for indexs in edgeList.index:
#         countryGraph.add_edge(edgeList.edgeNode1[indexs].strip(), edgeList.edgeNode2[indexs].strip(),
#                               weight=edgeList.numCount[indexs])  # 添加边与权重

# graphBuild(nodeList, edgeList)  # 运行网络构建函数

# # 输出网络
# nx.write_gexf(countryGraph, gexfPath + 'graph_' + dataTime + 'c1.gexf')  # 输出为Gephi格式
# print("ss")
# print(gexf)
gexf = Gexf("Gephi.org", "A Web network")
graph = gexf.addGraph("undirected", "static", "A Web network")
atr1 = graph.addNodeAttribute('Modularity_class',
                              force_id='modularity_class',
                              type='integer')
atr2 = graph.addNodeAttribute('country', force_id='country', type='string')
atr3 = graph.addNodeAttribute('nodenumber',
                              force_id='nodenumber',
                              type='integer')
# atr3 = graph.addNodeAttribute('frog',type='boolean',defaultValue='true')
eatr1 = graph.addEdgeAttribute('country1',
                               force_id='country1',
                               type='string',
                               defaultValue='country1')
eatr2 = graph.addEdgeAttribute('country2',
                               force_id='country2',