def test_must_use_valid_url_scheme(self):
try:
GraphDatabase.driver("x://xxx")
except ValueError:
assert True
else:
assert False
class MetaInfoCreator( object ):
def __init__( self, databasePath, datasetDict):
#increment to existing db
self.db = GraphDatabase( databasePath )
self.datasetDict = datasetDict
def start(self):
self._createInfoNodes()
self._finish()
def _createInfoNodes( self ):
print "Creating info nodes"
# do all insertions within one transaction: complete failure or success!
with self.db.transaction:
metaVertex = self.db.node() #self.db.reference_node
print "Meta node created, id %i" %( metaVertex.id )
index = self.db.node.indexes.create('meta')
index['meta']['meta'] = metaVertex
for num, (label, patientFile) in enumerate( self.datasetDict.items() ):
patientFile = open( patientFile, 'r')
patientFile.readline() #header
datasetVertex = self.db.node()
datasetVertex['datalabel'] = label
datasetVertex['barcode'] = patientFile.readline().strip("\n")
metaVertex.relationships.create('DATASET', datasetVertex, label=label)
patientFile.close()
def _finish(self):
self.db.shutdown()
print "Infonodes created"
def showAllDB(): db = GraphDatabase(workingdb) query = """START n=node(*) MATCH (n) - [r] -> (m) RETURN n.name, r, m.name""" print db.query(query) db.shutdown()
def get_rel_info(dbname,relid):
from neo4j import GraphDatabase
from neo4j import OUTGOING, INCOMING, ANY
db = GraphDatabase(dbname)
relid = int(relid) #make sure it is an int
rel = db.relationship[relid]
print rel
for key,value in rel.items():
print "\t"+key,value
db.shutdown()
def get_node_info(dbname,nodeid):
from neo4j import GraphDatabase
from neo4j import OUTGOING, INCOMING, ANY
db = GraphDatabase(dbname)
nodeid = int(nodeid) #make sure it is an int
nd = db.node[nodeid]
print nd
for key,value in nd.items():
print "\t"+key,value
if "uniqname" in str(key):
break
db.shutdown()
def showAllRelations(qname):
db = GraphDatabase(workingdb)
query = """START n=node(*)
MATCH (n) - [r] -> (m)
WHERE HAS(n.name) AND n.name = {name}
RETURN n.name, r, m.name"""
print db.query(query, name=qname)
db.shutdown()
def test_create_configured_db(self):
folder_to_put_db_in = tempfile.mkdtemp()
try:
# START SNIPPET: creatingConfiguredDatabase
from neo4j import GraphDatabase
# Example configuration parameters
db = GraphDatabase(folder_to_put_db_in, string_block_size=200, array_block_size=240)
db.shutdown()
# END SNIPPET: creatingConfiguredDatabase
finally:
if os.path.exists(folder_to_put_db_in):
import shutil
shutil.rmtree(folder_to_put_db_in)
def __init__(self, options, columns):
# Calling super constructor
super(Neo4jForeignDataWrapper, self).__init__(options, columns)
# Managed server option
if 'url' not in options:
log_to_postgres('The Bolt url parameter is required and the default is "bolt://localhost:7687"', WARNING)
self.url = options.get("url", "bolt://localhost:7687")
if 'user' not in options:
log_to_postgres('The user parameter is required and the default is "neo4j"', ERROR)
self.user = options.get("user", "neo4j")
if 'password' not in options:
log_to_postgres('The password parameter is required for Neo4j', ERROR)
self.password = options.get("password", "")
if 'cypher' not in options:
log_to_postgres('The cypher parameter is required', ERROR)
self.cypher = options.get("cypher", "MATCH (n) RETURN n LIMIT 100")
# Setting table columns
self.columns = columns
# Create a neo4j driver instance
self.driver = GraphDatabase.driver( self.url, auth=basic_auth(self.user, self.password))
self.columns_stat = self.compute_columns_stat()
self.table_stat = int(options.get("estimated_rows", -1))
if(self.table_stat < 0):
self.table_stat = self.compute_table_stat()
log_to_postgres('Table estimated rows : ' + unicode(self.table_stat), DEBUG)
def test_can_run_simple_statement(self):
session = GraphDatabase.driver("bolt://localhost").session()
count = 0
for record in session.run("RETURN 1 AS n"):
assert record[0] == 1
assert record["n"] == 1
try:
record["x"]
except AttributeError:
assert True
else:
assert False
assert record.n == 1
try:
record.x
except AttributeError:
assert True
else:
assert False
try:
record[object()]
except TypeError:
assert True
else:
assert False
assert repr(record)
assert len(record) == 1
count += 1
session.close()
assert count == 1
def test_create_db(self):
folder_to_put_db_in = tempfile.mkdtemp()
try:
# START SNIPPET: creatingDatabase
from neo4j import GraphDatabase
# Create db
db = GraphDatabase(folder_to_put_db_in)
# Always shut down your database
db.shutdown()
# END SNIPPET: creatingDatabase
finally:
if os.path.exists(folder_to_put_db_in):
import shutil
shutil.rmtree(folder_to_put_db_in)
def test_fails_on_missing_parameter(self):
session = GraphDatabase.driver("bolt://localhost").session()
try:
session.run("RETURN {x}").consume()
except CypherError:
assert True
else:
assert False
def test_can_run_statement_that_returns_multiple_records(self):
session = GraphDatabase.driver("bolt://localhost").session()
count = 0
for record in session.run("unwind(range(1, 10)) AS z RETURN z"):
assert 1 <= record[0] <= 10
count += 1
session.close()
assert count == 10
def get_nodeinfo_for_name(dbname,name):
from neo4j import GraphDatabase
from neo4j import OUTGOING, INCOMING, ANY
db = GraphDatabase(dbname)
with db.transaction:
node_idx = db.node.indexes.get('graphNamedNodes')
hits = node_idx['name'][name]
for i in hits:
print i
for key,value in i.items():
print "\t"+key,value
#printing after, prints mrcas which are usually too long
#comment to let it go, but don't commit
if "uniqname" in str(key):
break
hits.close()
db.shutdown()
def get_db(self, data_dir=None):
from neo4j import GraphDatabase
if self._db is None:
if data_dir is None:
data_dir = settings.GRAPH_DATABASE_PATH
self._db = GraphDatabase(data_dir)
db = self._db
return self._db
def test_fails_on_bad_syntax(self):
session = GraphDatabase.driver("bolt://localhost").session()
try:
session.run("X").consume()
except CypherError:
assert True
else:
assert False
def showAllNodes(): # open the db db = GraphDatabase(workingdb) number_of_nodes = len(db.nodes) query = "START n=node(*) RETURN n" print "This db has " + str(number_of_nodes) +"nodes" if(number_of_nodes>0): print db.query(query) else: print "no nodes" db.shutdown()
def test_can_handle_cypher_error(self):
with GraphDatabase.driver("bolt://localhost").session() as session:
try:
session.run("X")
except CypherError:
assert True
else:
assert False
def test_can_obtain_summary_info(self):
with GraphDatabase.driver("bolt://localhost").session() as session:
result = session.run("CREATE (n) RETURN n")
summary = result.summarize()
assert summary.statement == "CREATE (n) RETURN n"
assert summary.parameters == {}
assert summary.statement_type == "rw"
assert summary.statistics.nodes_created == 1
def __init__(self, config, graphtype, minoccs=1, maxcoocs=1, maxcables=None, year=None):
self.mongodb = CablegateDatabase(config['general']['mongodb'])["cablegate"]
self.graphdb = GraphDatabase(config['general']['neo4j'])
self.config = config
if graphtype is None or graphtype=="occurrences":
self.update_occurrences_network(minoccs, maxcoocs, maxcables, year, documents=False)
elif graphtype == "cooccurrences":
(nodecache, ngramcache) = self.update_occurrences_network(minoccs, maxcoocs, maxcables, year, documents=False)
self.update_cooccurrences_network(nodecache, ngramcache, minoccs, maxcoocs)
def test_can_return_node(self):
with GraphDatabase.driver("bolt://localhost").session() as session:
result = session.run("MERGE (a:Person {name:'Alice'}) RETURN a")
assert len(result) == 1
for record in result:
alice = record[0]
assert isinstance(alice, Node)
assert alice.labels == {"Person"}
assert alice.properties == {"name": "Alice"}
def test_can_return_relationship(self):
with GraphDatabase.driver("bolt://localhost").session() as session:
result = session.run("MERGE ()-[r:KNOWS {since:1999}]->() RETURN r")
assert len(result) == 1
for record in result:
rel = record[0]
assert isinstance(rel, Relationship)
assert rel.type == "KNOWS"
assert rel.properties == {"since": 1999}
class NeoCreator:
def __init__(self,path):
self.db = GraphDatabase(path)
def shutdown(self):
self.db.shutdown()
def createNewNode(self,_id,nick):
with self.db.transaction:
newNode = self.db.node(uid=_id,Label=nick)
if newNode is None:
raise
return newNode
def createRelationship(self,origin,destiny):
with self.db.transaction:
origin.tweets(destiny,Label="tweets")
def test_can_obtain_plan_info(self):
with GraphDatabase.driver("bolt://localhost").session() as session:
result = session.run("EXPLAIN CREATE (n) RETURN n")
plan = result.summarize().plan
assert plan.operator_type == "ProduceResults"
assert plan.identifiers == ["n"]
assert plan.arguments == {"planner": "COST", "EstimatedRows": 1.0, "version": "CYPHER 3.0",
"KeyNames": "n", "runtime-impl": "INTERPRETED", "planner-impl": "IDP",
"runtime": "INTERPRETED"}
assert len(plan.children) == 1
def addUser(usuario):
# Create a database
db = GraphDatabase('/tmp/')
user_idx = db.node.indexes.get('users')
cafe_idx = db.node.indexes.get('cafes')
# All write operations happen in a transaction
with db.transaction:
firstNode = db.node(name=usuario, type_record='user')
user_idx['name'][usuario] = firstNode
secondNode = cafe_idx['name']['lungo'].single
# Create a relationship with type 'knows'
relationship = firstNode.toma(secondNode, cantidad=3)
# Always shut down your database when your application exits
db.shutdown()
def main():
global db
try:
shutil.rmtree('benchmark_db')
except:
pass
db = GraphDatabase('benchmark_db')
repetitions = 10
count = 1000
transaction_benchmark(repetitions)
node_benchmark(repetitions,count)
relation_benchmark(repetitions,count)
traversal_benchmark(repetitions,count)
indexing_benchmark(repetitions,count)
lookup_benchmark(repetitions,count)
db.shutdown()
def __init__(self,mind,dbpath="data"):
self.mind = mind
self.dbpath = dbpath
self.mind.log("Starting Graph Database at "+dbpath)
self.db = GraphDatabase(dbpath)
self.root = None
memorySize = len(self.db.nodes)
self.log("starting with "+str(memorySize)+" nodes in memory")
self.vars = {}
self.initialGraph(memorySize<=1)
def addtodb(lnode, rnode, relationship): # Create a database db = GraphDatabase(workingdb) # rel['subjsym'], rel['objsym'], rel['filler'] with db.transaction: lnodef = False #lnodef and rnodef store whether the node has been found in the db rnodef = False for node in db.nodes: for key, value in node.items(): if (key == "name"): if(value == lnode): leftnode = node lnodef = True if(value == rnode): rightnode = node rnodef = True if (not lnodef): leftnode = db.node(name=(lnode)) print "Lnode " + lnode + "created" if (not rnodef): rightnode = db.node(name=(rnode)) print "Rnode " + rnode + "created" relf = False for rel in leftnode.relationships.outgoing: for key, value in rel.items(): if (str(rel.type) == relationship and key == 'hits'and rel.end == rightnode): rel[key] = value + 1 relf = True print "rel found. Increasing number of hits " if (not relf): rel = leftnode.relationships.create(relationship, rightnode) print "created relationship " + relationship rel['hits'] = 1 db.shutdown()
def test_can_obtain_profile_info(self):
with GraphDatabase.driver("bolt://localhost").session() as session:
result = session.run("PROFILE CREATE (n) RETURN n")
profile = result.summarize().profile
assert profile.db_hits == 0
assert profile.rows == 1
assert profile.operator_type == "ProduceResults"
assert profile.identifiers == ["n"]
assert profile.arguments == {"planner": "COST", "EstimatedRows": 1.0, "version": "CYPHER 3.0",
"KeyNames": "n", "runtime-impl": "INTERPRETED", "planner-impl": "IDP",
"runtime": "INTERPRETED", "Rows": 1, "DbHits": 0}
assert len(profile.children) == 1
def test_can_return_path(self):
with GraphDatabase.driver("bolt://localhost").session() as session:
result = session.run("MERGE p=({name:'Alice'})-[:KNOWS]->({name:'Bob'}) RETURN p")
assert len(result) == 1
for record in result:
path = record[0]
assert isinstance(path, Path)
assert path.start.properties == {"name": "Alice"}
assert path.end.properties == {"name": "Bob"}
assert path.relationships[0].type == "KNOWS"
assert len(path.nodes) == 2
assert len(path.relationships) == 1
def test_can_run_simple_statement_from_bytes_string(self):
session = GraphDatabase.driver("bolt://localhost").session()
count = 0
for record in session.run(b"RETURN 1 AS n"):
assert record[0] == 1
assert record["n"] == 1
assert record.n == 1
assert repr(record)
assert len(record) == 1
count += 1
session.close()
assert count == 1
def __init__(self, uri, user, password):
self.driver = GraphDatabase.driver(uri,
auth=(user, password),
encrypted=False)
# -*- coding: utf-8 -*-
"""
Created on Fri Nov 27 19:29:30 2020
@author: Owner
"""
import os
import glob
import json
from getpass import getpass
from tqdm import tqdm
from neo4j import GraphDatabase
driver = GraphDatabase.driver("neo4j://localhost:7687",
auth=("neo4j", getpass()))
from neo4j import GraphDatabase
import json
driver = GraphDatabase.driver("bolt://neo4j:7687",
auth=("neo4j", "test"),
encrypted=False)
session = driver.session()
node_id = 1835
query = "MATCH (rn:RootNode)--(cf:ContentField)--(sen:Sentence)--(ent:Entity) "
query += "WHERE (rn.name = '" + str(node_id) + "') "
query += "RETURN DISTINCT rn.name as node_id, ent.ner as ent_ner, ent.text as ent_text "
query += "ORDER BY ent.ner ASC"
result = session.run(query)
res_dict = []
for record in result:
res_dict.append({
'node_id': record['node_id'],
'ent_ner': record['ent_ner'],
'ent_text': record['ent_text']
})
print(res_dict)
from neo4j import GraphDatabase
from Database import Database
from Classes.Career import *
import tkinter as tk
uri = "bolt://localhost:7687"
driver = GraphDatabase.driver(uri, auth=("neo4j", "password"))
db = Database("bolt://localhost:7687", "neo4j", "password")
career_name = "Prueba"
# Prueba para crear a base de datos.
db.deleteCareer(career_name)
nodeType1 = "Clase"
nodeType2 = "Persona"
nodeType3 = "gusto"
nodeType4 = "Carrera"
materias = []
personas = []
hobbies = []
carreras = []
# Prueba para obtener todos de un tipo
result1 = db.getAllType(nodeType1)
for record in result1:
materias.append(record[0]["nombre"])
result2 = db.getAllType(nodeType2)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Nov 29 18:31:17 2018
@author: geoffrey
"""
from neo4j import GraphDatabase
uri = "bolt://localhost:7687"
driver = GraphDatabase.driver(uri, auth=("test", "test"))
###############################################################################
# FONCTION nombre de proteines
###############################################################################
def number_of_protein(tx):
for record in tx.run("match (n:Protein) return count(n)"):
return record["count(n)"]
def number_of_protein_interface():
with driver.session() as session:
a = session.read_transaction(number_of_protein)
return a
###############################################################################
# FONCTION nombre de relation et moyenne du nombre de voisin
###############################################################################
def protocol_version(cls):
with GraphDatabase.driver(cls.bolt_uri, auth=cls.auth_token) as driver:
with driver.session() as session:
return session.run("RETURN 1").summary().protocol_version
def setUp(self):
from neo4j import GraphDatabase
self.driver = GraphDatabase.driver(self.bolt_routing_uri,
auth=self.auth_token)
# language: python
# name: python3
# ---
# # Building a co-author graph
#
# In this notebook we're going to build an inferred graph of co-authors based on people collaborating on the same papers. We're also going to store a property on the relationship indicating the year of their first collaboration.
# tag::imports[]
from neo4j import GraphDatabase
# end::imports[]
# +
# tag::driver[]
bolt_uri = "bolt://link-prediction-neo4j"
driver = GraphDatabase.driver(bolt_uri, auth=("neo4j", "admin"))
# end::driver[]
print(driver.address)
# -
# We can create the co-author graph by running the query below to do this:
# +
# tag::data-import[]
query = """
CALL apoc.periodic.iterate(
"MATCH (a1)<-[:AUTHOR]-(paper)-[:AUTHOR]->(a2:Author)
WITH a1, a2, paper
ORDER BY a1, paper.year
RETURN a1, a2, collect(paper)[0].year AS year, count(*) AS collaborations",
'''
Program to establish connection to database
'''
import json
from neo4j import GraphDatabase
import os
'''
.env file needs to be in current director of the following format
{
"uri":"bolt://ec2-18-220-22-55.us-east-2.compute.amazonaws.com:7687",
"neo4j_user" : "test_user",
"neo4j_passw" : "test123"
}
'''
#load params
env_file_fp = open('./db_conn/.env')
params = json.load(env_file_fp)
uri = params.get('uri')
driver = GraphDatabase.driver(uri,
auth=(params.get('neo4j_user'),
params.get('neo4j_passw')))
from neo4j import GraphDatabase
import time
driver = GraphDatabase.driver('bolt://localhost:7687',
auth=('neo4j', '12345678'))
for tempo in range(0, 31):
tempo_iniziale = time.clock() * 1000
def print_friends_of(tx, name):
for record in tx.run(
"MATCH path=(:Person {name:'DONALD J. TRUMP'})-[:RELATED_TO*1..3]-(other:Person) WHERE ALL(x IN NODES(path) WHERE x.name <> 'IVANKA TRUMP') WITH DISTINCT(other) as other RETURN other, EXISTS( (other)-[:RELATED_TO]-(:Person{ name:'IVANKA TRUMP' }) ) as friendOfTrump ORDER BY other.name",
name=name):
print(record["other"], record["friendOfTrump"])
tempo_finale = time.clock() * 1000
print(tempo_finale - tempo_iniziale)
with driver.session() as session:
session.read_transaction(print_friends_of, "Trump")
def test_bolt_uri_constructs_bolt_driver(self):
with StubCluster("v3/empty.script"):
uri = "bolt://127.0.0.1:9001"
with GraphDatabase.driver(uri, auth=self.auth_token) as driver:
assert isinstance(driver, BoltDriver)
def _get_driver(self):
return GraphDatabase.driver(GRAPH_DATABASE_URI,
auth=basic_auth(GRAPH_DATABASE_USER,
GRAPH_DATABASE_PASSWORD))
from neo4j import GraphDatabase
from tests import api_
from reddit_detective import RedditNetwork, Comments
from reddit_detective.data_models import Redditor
driver_ = GraphDatabase.driver("bolt://localhost:7687",
auth=("neo4j", "testing"))
def test_network():
net = RedditNetwork(driver=driver_,
components=[
Comments(
Redditor(api_, "BloodMooseSquirrel", limit=5)),
Comments(Redditor(api_, "Anub_Rekhan", limit=5))
])
assert net
assert net.cypher_code()
net.run_cypher_code()
def run():
test_network()
if __name__ == '__main__':
run()
def openDatabase(uri: str, username: str, password: str):
driver = GraphDatabase.driver(uri, auth=basic_auth(username, password))
session = driver.session()
return (session, driver)
def __init__(self):
self.__driver = GraphDatabase.driver("bolt://localhost:7687",
auth=("neo4j", "1111"))
# %% init
from pathlib import Path
import datetime
from py2neo import Graph, Node, Relationship
from neo4j import GraphDatabase, basic_auth
import urllib.request
from bs4 import BeautifulSoup
import glob
import random, time
import os
graph = Graph("bolt://localhost:7687", auth=("neo4j", "Password"))
driver = GraphDatabase.driver('bolt://localhost',auth=basic_auth("neo4j", "Password"))
db = driver.session()
import sys
dataPath = 'C:\\Users\\Jo\\Documents\\Tech\\Atom_prj\\MyMedia-FillDB\\data' # <<<<<< hardcoded
if dataPath not in sys.path:
sys.path.insert(0, dataPath)
from FromNotebook import myUrlParse
ytAPI_client_secrets_file_path = "C:\\Users\\Jo\\Documents\\Tech\\Notebooks\\client_secret_1054515006139-e0p34lt262qbh4af24t2po4c5ophspjo.apps.googleusercontent.com.json"
path = "C:\\Users\\Jo\\Documents\\Tech\\ScrapData\\20200709"
def create_YT_API():
import os
import google_auth_oauthlib.flow
import googleapiclient.discovery
import googleapiclient.errors
from faker import Faker
from random import randint
import uuid
from neo4j import GraphDatabase, basic_auth
from helpers import get_connection_details
graphenedb_url = get_connection_details()[0]
graphenedb_user = get_connection_details()[1]
graphenedb_pass = get_connection_details()[2]
# Create graph driver
# This is used to create a session so we can run the code while working on it.
driver = GraphDatabase.driver(graphenedb_url,
auth=basic_auth(graphenedb_user,
graphenedb_pass))
class User:
def __init__(self,
id='',
username='',
name='',
age='',
university='',
password=''):
self.age = age
self.id = id
self.name = name
self.password = password
self.university = university
self.username = username
# %% Import e inicialização da conexão
from neo4j import GraphDatabase
import nxneo4j as nx
import wget, os
import pandas as pd
import numpy as np
driver = GraphDatabase.driver(uri="bolt://localhost:7687",
auth=("neo4j", "test"))
G = nx.Graph(driver)
# %% Primeiros testes
G.delete_all()
G.add_node(1) #single node
G.add_nodes_from([2, 3, 4]) #multiple nodes
G.add_edge(1, 2) #single edge
G.add_edges_from([(2, 3), (3, 4)]) #multiple edges
G.add_node('Mike', gender='M', age=17)
G.add_edge('Mike', 'Jenny', type='friends', weight=3)
nx.draw(G)
# %% Deleta os dados existentes e insere os novos dados
G.delete_all()
colaboracao = pd.read_csv('dados\collaboration.edgelist.txt',
delimiter='\t',
header=None)
lista_df = np.array_split(colaboracao, 20)
# %%
for resultado in lista_df:
def server_version_info(cls):
with GraphDatabase.driver(cls.bolt_uri, auth=cls.auth_token) as driver:
with driver.session() as session:
full_version = session.run("RETURN 1").summary().server.version
return ServerVersion.from_str(full_version)
# -*- coding: utf-8 -*-
"""
Created on Fri Oct 2 15:19:46 2020
@author: sookmyung
"""
import csv, sys, time
import pandas as pd
start_time = time.time()
from neo4j import GraphDatabase
driver = GraphDatabase.driver("bolt://localhost:7687", auth=("neo4j", "wowhi223"), encrypted=False)
'''
name : 이상우
pid : 880514-1520414
'''
def extractCreateProps(p, d, ac):
userNames, userIds = [], []
dataNames, dataFilePaths, dataVals, dataOrigins = [], [], [], []
acNames, acDates, acDetails = [], [], []
for idx, val in enumerate(d):
userNames.append(p[idx]['name'])
userIds.append(p[idx]['pid'])
def __init__(self):
# インストラクタ
driver = GraphDatabase.driver("bolt://neo4j",
auth=basic_auth("neo4j", "neo4jpw"))
self.session = driver.session()
from neo4j import GraphDatabase
from manipulator.private_settings import NEO4J_HOST, NEO4J_USER, NEO4J_PASS
_driver = GraphDatabase.driver(NEO4J_HOST, auth=(NEO4J_USER, NEO4J_PASS))
_session = _driver.session()
def get_driver():
return _driver
parser.add_argument('-a', '--address', help='neo4j address',
type=str, default="bolt://127.0.0.1:7687")
parser.add_argument('-p', '--password',
help='neo4j password', type=str, default="neo4j")
parser.add_argument('-u', '--user', help='neo4j user name',
type=str, default="neo4j")
parser.add_argument('-t', '--thread_num', type=int, default=4)
args = parser.parse_args()
time_report = {"vertex_use_time": [], "edge_use_time": [],
"vertex_batch_size": vertex_batch_size, "edge_batch_size": edge_batch_size}
vertex_use_time = time_report["vertex_use_time"]
edge_use_time = time_report["edge_use_time"]
thread_num = args.thread_num
driver = GraphDatabase.driver(
args.address, auth=(args.user, args.password))
with open(args.file) as f:
data = json.load(f)
print("start write")
sessions = [driver.session() for i in range(thread_num)]
total_start_time = time.time()
time_report["total_start_time"] = total_start_time
thread_vertex = []
tag_count = len(data['vertex'])
thread_tag_count = thread_num // tag_count
if thread_tag_count < 1:
raise Exception("thread_num must great tag_count")
vertices_time = time.time()
session_ids = 0
def __init__(self, uri, user, password):
self.driver = GraphDatabase.driver(uri, auth=(user, password))
if not gene_id in gene_id_to_pubmed_id:
gene_id_to_pubmed_id[gene_id] = {}
gene_id_to_pubmed_id[gene_id][pubmed_id] = None
unique_pubmed_ids[pubmed_id] = None
f.close()
#pp.pprint(gene_id_to_pubmed_id)
#pp.pprint(unique_pubmed_ids)
#
# connect to Neo4j
#
driver = GraphDatabase.driver(uri, auth=(username, password))
#
# clear the way (CRUDE)
#
cmd = 'MATCH (c:NCBI_PUBMED)-[r]-() DELETE r;'
with driver.session() as session:
session.run(cmd)
cmd = 'MATCH (c:NCBI_PUBMED) DELETE c;'
with driver.session() as session:
session.run(cmd)
#
# load pubmed
#
pubmed_list = []
def main():
driver = GraphDatabase.driver("bolt://100.25.45.169:33374",
auth=basic_auth("neo4j",
"age-driver-nomenclatures"))
session = driver.session()
def __init__(self, uri, auth):
self.driver = GraphDatabase.driver(uri, auth=auth)
def setup_class(cls):
cls.creds = [{
"type": "writer",
"creds": {
"host": "localhost",
"port": "7687",
"user": "******",
"password": "******"
}
}, {
"type": "reader",
"creds": {
"host": "localhost",
"port": "7687",
"user": "******",
"password": "******"
}
}]
data = [
{
'tweet_id': 1,
'text': 'Tweet 1',
'hydrated': 'FULL'
},
{
'tweet_id': 2,
'text': 'Tweet 2',
'hydrated': 'FULL'
},
{
'tweet_id': 3,
'text': 'Tweet 3'
},
{
'tweet_id': 4,
'text': 'Tweet 4',
'hydrated': 'PARTIAL'
},
{
'tweet_id': 5,
'text': 'Tweet 5',
'hydrated': 'PARTIAL'
},
]
traversal = '''UNWIND $tweets AS t
MERGE (tweet:Tweet {id:t.tweet_id})
ON CREATE SET
tweet.text = t.text,
tweet.hydrated = t.hydrated
'''
res = list(filter(lambda c: c["type"] == 'writer', cls.creds))
creds = res[0]["creds"]
uri = f'bolt://{creds["host"]}:{creds["port"]}'
graph = GraphDatabase.driver(uri,
auth=basic_auth(creds['user'],
creds['password']),
encrypted=False)
try:
with graph.session() as session:
session.run(traversal, tweets=data)
cls.ids = pd.DataFrame({'id': [1, 2, 3, 4, 5]})
except Exception as err:
print(err)
# Now add some account data
user_data = [
{
'account_id': 1,
'hydrated': 'FULL'
},
{
'account_id': 2,
'hydrated': 'FULL'
},
{
'account_id': 3
},
{
'account_id': 4,
'hydrated': 'PARTIAL'
},
{
'account_id': 5,
'hydrated': 'PARTIAL'
},
]
traversal = '''UNWIND $users AS u
MERGE (account:Account {id:u.account_id})
ON CREATE SET
account.hydrated = u.hydrated
'''
try:
with graph.session() as session:
session.run(traversal, users=user_data)
cls.ids = pd.DataFrame({'id': [1, 2, 3, 4, 5]})
except Exception as err:
print(err)
def __init__(self, uri, user, password, database):
self._driver = GraphDatabase.driver(uri,
auth=(user, password),
encrypted=0)
self.__database = database
from neo4j import GraphDatabase
from graphviz import Digraph
### begin config
# connection to Neo4J database
driver = GraphDatabase.driver("bolt://localhost:7687", auth=("neo4j", "1234"))
##### colors
#c81919 - dark red
#f9cccc - light red
#
#0333a3 - dark blue
#bbd1ff - light blue
#
#feb729 - yellow
#fed47f - light yellow
#
#178544 - dark green
#4ae087 - light green
#
#a034a8 - purple
#e7bdeb - light purple
#
#13857d - dark cyan
#19b1a7 - cyan
#93f0ea - light cyan
c2_cyan = "#318599"
c2_orange = "#ea700d"
c2_light_orange = "#f59d56"
c2_light_yellow = "#ffd965"
