def createRelationshipWithProperties():
print("Start - Creating Relationships")
# Authenticate the user using py2neo.authentication
# Ensure that you change the password 'sumit' as per your database configuration.
py2neo.authenticate("localhost:7474", "neo4j", "sumit")
# Connect to Graph and get the instance of Graph
graph = Graph("http://localhost:7474/db/data/")
# Create Node with Properties
amy = Node("FEMALE", name="Amy")
# Create one more Node with Properties
kristine = Node("FEMALE",name="Kristine")
# Create one more Node with Properties
sheryl = Node("FEMALE",name="Sheryl")
#Define an Object of relationship which depicts the relationship between Amy and Kristine
#We have also defined the properties of the relationship - "since=2005"
#By Default the direction of relationships is left to right, i.e. the -->
kristine_amy = Relationship(kristine,"FRIEND",amy,since=2005)
#This relationship is exactly same as the earlier one but here we are using "Rev"
#"py2neo.Rev = It is used to define the reverse relationship (<--) between given nodes
amy_sheryl=Relationship(amy,Rev("FRIEND"),sheryl,since=2001)
#Finally use graph Object and Create Nodes and Relationship
#When we create Relationship between, then Nodes are also created.
resultNodes = graph.create(kristine_amy,amy_sheryl)
#Print the results (relationships)
print("Relationship Created - ",resultNodes)
class Neo4jConnector:
_graph_connection = None
def __init__(self, connectionString=None):
# set up authentication parameters
authenticate("localhost:7474", "neo4j", "123")
self.connectionString = "http://localhost:7474/db/data/"
self._graph_connection = Graph(connectionString)
self.error_file = open("Dump/log/dberror.txt", "a")
return
def createNodes(self, wikiPage):
print ("creating node %s" %wikiPage.getTitle())
try:
if self._graph_connection is not None:
alice = Node("article2",name = wikiPage.title,content= wikiPage.getContent())
self._graph_connection.create(alice)
else:
self.error_file.write("create node failed: connection not avaialable".encode('utf-8'))
print 'create node failed: connection not avaialable'
return
except Exception, e:
self.error_file.write('Search failed: {%s} { %s } \n' % (wikiPage.getTitle(), e.message))
print 'create node failed: %s %s' % (e.message,e.args)
pass
def computeShortestPathCoherence(node1, node2, w):
"""Connects to graph database, then creates and sends query to graph
database. Returns the shortest path between two nodes.
Format: (67149)-[:'LINKS_TO']->(421)"""
if node1.strip()==node2.strip():
return w
fromCache=rds.get("%s:%s" % (node1, node2))
if fromCache:
return float(fromCache)*w
else:
g = Graph()
q="MATCH path=shortestPath((m:Page {name:\"%s\"})-[LINKS_TO*1..10]-(n:Page {name:\"%s\"})) RETURN LENGTH(path) AS length, path, m, n" % (node1, node2)
cursor=g.run(q)
path=None
for c in cursor:
path=c
#
if path:
rds.set("%s:%s" % (node1, node2), 1/path["length"])
rds.set("%s:%s" % (node2, node1), 1/path["length"])
return w/path["length"]
else:
rds.set("%s:%s" % (node1, node2), 0.0)
rds.set("%s:%s" % (node2, node1), 0.0)
return 0.0
def make_sequence(self):
authenticate(settings.NeoHost, settings.NeoLog, settings.NeoPass)
graph = Graph("{0}/db/data/".format(settings.NeoHost))
query = """MATCH (start:Video)-[:Jaccard*5..10]->(sequence:Video)
WHERE start<>sequence MATCH p=shortestPath((start:Video)-[:Jaccard*]->(sequence:Video))
WHERE NONE (n IN nodes(p) WHERE size(filter(x IN nodes(p) WHERE n = x))> 1)
RETURN EXTRACT(n IN NODES(p)|[n.id, n.rating]) LIMIT 100000"""
r1 = graph.run(query).data()
k = 0
for i in r1:
#print(i.values)
for video in i['EXTRACT(n IN NODES(p)|[n.id, n.rating])']:
#print(video)
self.seq_ids.append(k)
self.video_ids.append(video[0])
self.ratings.append(video[1])
k+=1
data = {'sequence': self.seq_ids, 'video': self.video_ids, 'rating': self.ratings}
df = pd.DataFrame(data)
df = df[pd.notnull(df['video'])]
print(df)
dz = df.groupby('sequence')['rating'].std()
print(dz)
path = '{0}/{1}/'.format(settings.VideosDirPath, self.game)
if not os.path.exists(path):
os.makedirs(path)
file_name = '{0}/sequences.csv'.format(path)
df.to_csv(file_name, encoding='utf-8')
summary_data = '{0}/summary.csv'.format(path)
dz.to_csv(summary_data, encoding='utf-8')
return
class Graph(object):
def __init__(self, neo4j_uri):
self.graph = NeoGraph(neo4j_uri)
def find_node(self, label, node_id):
args = dict(property_key="node_id", property_value=node_id)
return self.graph.find_one(label, **args)
def create_user(self, args):
node = self.find_node("User", args["username"])
if not node:
properties = dict(
node_id=args["username"],
name=args["name"],
city=args["city"]
)
node = Node("User", **properties)
self.graph.create(node)
return node, True
return node, False
def delete_user(self, user):
node = self.find_node("User", user)
if node:
self.graph.delete(node)
return True
return False
class PersonLoader(object):
def __init__(self):
authenticate("localhost:7474", "neo4j", "1111")
self.graph_db = Graph(graph_DB_url)
self.api_url = "http://127.0.0.1:8000/api/v1/person/?format=json"
self.statement = "MERGE (n:Person {Name:{N}, Identification:{I}, id: {ID}, NonResidentForeigner:{NR}," \
"MoreInformation:{MI}}) RETURN n"
def whipUp(self):
objects = json.load(urlopen(self.api_url))["objects"]
for object in objects:
args = {}
args["ID"]=object["id"]
args["I"]=object["Identification"]
args["NR"]=object["NonResidentForeigner"]
args["N"]=object["Name"]
args["MI"]=object["MoreInformation"]
#args["AD"]=object["Address"]["id"]
perCh = getPerson(Name=args["N"])
if perCh!=None:
continue
db = self.graph_db.cypher.begin()
db.append(self.statement, args)
db.commit()
address = getAddress(id=int(object["Address"]["id"]))
person = getPerson(id=int(args["ID"]))
self.graph_db.create(rel(person.one, "LIVED", address.one))
def get_tracks():
track_metadata = {}
graph = Graph()
for track in graph.find("Track"):
track_metadata[track.properties['id']] = inflate(track.properties)
return track_metadata
class SocialFormationLoader(object):
def __init__(self):
authenticate("localhost:7474", "neo4j", "1111")
self.graph_db = Graph(graph_DB_url)
self.api_url = "http://127.0.0.1:9000/api/v1/socialformation/?format=json"
self.statement = "MERGE (n:SocialFormation {id: {ID}, Name:{N}, DateReg:{DR}, RegNumb:{RN}}) RETURN n"
def whipUp(self):
objects = json.load(urlopen(self.api_url))["objects"]
for object in objects:
args = {}
args["ID"]=object["id"]
args["N"]=object["Name"]
args["DR"]=object["DateReg"]
args["RN"]=object["RegNumb"]
#print args
db = self.graph_db.cypher.begin()
db.append(self.statement, args)
db.commit()
sf = getSocialFormation(args["ID"])
adr = getAddress(id = int(object["Address"]["id"]), Street = object["Address"]["Street"])
#per = getPerson(id = int(object["Person"]["id"]), Name = (object["Person"]["Surname"] + " " + object["Person"]["Name"]))
per = getPerson(Name = (object["Person"]["Surname"] + " " + object["Person"]["Name"]))
if adr != None:
self.graph_db.create(rel(sf.one, "HAVE_ADDRESS", adr.one))
if per != None:
self.graph_db.create(rel(sf.one, "SF_HAVE_PERSON", per.one))
class Neo4j():
graph = None
def __init__(self):
print("create neo4j class ...")
def connectDB(self):
self.graph = Graph("http://localhost:7474", username="******", password="******")
print('connect successed')
def matchItembyTitle(self,value):
answer = self.graph.find_one(label="Item",property_key="title",property_value=value)
return answer
# 根据title值返回互动百科item
def matchHudongItembyTitle(self,value):
answer = self.graph.find_one(label="HudongItem",property_key="title",property_value=value)
return answer
# 返回限定个数的互动百科item
def getAllHudongItem(self, limitnum):
List = []
ge = self.graph.find(label="HudongItem", limit=limitnum)
for g in ge:
List.append(HudongItem(g))
print('load AllHudongItem over ...')
return List
#test = Neo4j()
#test.connectDB()
#a = test.getLabeledHudongItem('labels.txt')
#print(a[10].openTypeList)
def get_track_comments():
track_comments = {}
graph = Graph()
for comment in graph.find("Comment"):
track_comments[comment.properties['id']] = inflate(comment.properties)
return track_comments
def createRelationships():
global relationships
graph = Graph('http://localhost:7474/db/data')
for r in relationships:
NodeA = graph.find_one(r["start"]["collection"],property_key = "_id", property_value = str(r["start"]["_id"]))
NodeB = graph.find_one(r["end"]["collection"],property_key = "_id", property_value = str(r["end"]["_id"]))
graph.create(rel(NodeA,r["name"],NodeB))
def sync_meetup_data(group):
graph = Graph(host=config['neo4j']['host'], user=config['neo4j']['user'],
password=config['neo4j']['password'])
location = get_group_location(group)
tx = graph.begin()
location_node = Node('Location', city=location['city'], state=location['state'], country=location['country'])
tx.create(location_node)
tx.commit()
meetup_groups = get_groups_in_location(location, category=34)
logger.info('Finding upcoming meetup events at {} meetup groups'.format(len(meetup_groups)))
for group in meetup_groups:
time.sleep(2)
group, events = get_group_events(group)
tx = graph.begin()
group_node = Node("Group", name=group)
tx.create(group_node)
location_relation = Relationship(location_node, 'HAS MEETUP', group_node)
tx.create(location_relation)
for event in events:
event_node = Node('Event', name=event['name'], time=event['time'])
tx.create(event_node)
rel = Relationship(group_node, "HAS EVENT", event_node)
tx.create(rel)
tx.commit()
logger.info('Transaction ({}) status: {}'.format(group, str(tx.finished())))
class Grapher:
def __init__(self):
self.graph = Graph()
"""Accepts a dict of scanning results and adds the server, its ports and vulerabilities in Neo4jDB"""
def plot_scan_results(self, res):
for host in res.keys():
hostname = res[host][KEY_HOSTNAME]
server = Node(SERVER, id=host, address=host, hostname=hostname)
for attr in res[host].keys():
if attr not in top_keys:
for portno in res[host][attr]:
if res[host][attr][portno].get(KEY_STATE, "closed") == OPEN:
product = res[host][attr][portno][KEY_PRODUCT]
version = res[host][attr][portno][KEY_VERSION]
cpe = res[host][attr][portno][KEY_CPE]
vulnerabilities = res[host][attr][portno][KEY_VULNERABILITIES]
port = Node(PORT, id=portno, number=portno, protocol=attr, product=product, version=version, cpe=cpe, state=OPEN)
server_has_port = Relationship(server, HAS, port)
self.graph.create(server_has_port)
for vulnerability in vulnerabilities:
published = vulnerability[KEY_PUBLISHED]
cve = vulnerability[KEY_CVE]
summary = vulnerability[KEY_SUMMARY]
vuln = Node(VULNERABILITY, id=cve, cve=cve, summary=summary, published=published)
port_has_vuln = Relationship(port, HAS, vuln)
self.graph.create(port_has_vuln)
def handle(self, *args, **options): # pylint: disable=unused-argument
"""
Iterates through each course, serializes them into graphs, and saves
those graphs to neo4j.
"""
# first, make sure that there's a valid neo4j configuration
if settings.NEO4J_CONFIG is None:
raise CommandError(
"No neo4j configuration (NEO4J_CONFIG) defined in lms.auth.json."
)
auth_params = ["{host}:{https_port}", "{user}", "{password}"]
authenticate(*[param.format(**settings.NEO4J_CONFIG) for param in auth_params])
graph = Graph(**settings.NEO4J_CONFIG)
mss = ModuleStoreSerializer()
total_number_of_courses = len(mss.all_courses)
for index, course in enumerate(mss.all_courses):
# first, clear the request cache to prevent memory leaks
RequestCache.clear_request_cache()
log.info(
"Now exporting %s to neo4j: course %d of %d total courses",
course.id,
index + 1,
total_number_of_courses
)
nodes, relationships = mss.serialize_course(course.id)
log.info(
"%d nodes and %d relationships in %s",
len(nodes),
len(relationships),
course.id
)
transaction = graph.begin()
try:
# first, delete existing course
transaction.run(
"MATCH (n:item) WHERE n.course_key='{}' DETACH DELETE n".format(
six.text_type(course.id)
)
)
# now, re-add it
self.add_to_transaction(nodes, transaction)
self.add_to_transaction(relationships, transaction)
transaction.commit()
except Exception: # pylint: disable=broad-except
log.exception(
"Error trying to dump course %s to neo4j, rolling back",
six.text_type(course.id)
)
transaction.rollback()
class GraphImporter(object):
def __init__(self, graphurl, commitEvery=100):
self.graph = Graph(graphurl)
self.commitEvery = commitEvery
self._act = None
self._actC = commitEvery
def delete_all(self):
self.graph.delete_all()
self.graph.cypher.run('CREATE INDEX ON :_Network_Node(id)')
self.graph.cypher.run('CREATE INDEX ON :_Set_Node(id)')
def _tx(self):
if self._act is not None:
return self._act
self._act = self.graph.cypher.begin()
self._actC = self.commitEvery
return self._act
def _done(self):
self._actC -= 1
if self._actC == 0: # commit
self._act.process()
self._act.commit()
sys.stdout.write('.')
self._act = None
def _close(self):
if self._act is not None: # commit last tx
self._actC = 1
self._done()
def add_node(self, labels, node_id, properties):
tx = self._tx()
add_node(tx, labels, node_id, properties)
self._done()
def done_nodes(self):
self._done()
def append(self, query):
tx = self._tx()
tx.append(query)
self._done()
def add_edge(self, label, source_node_id, target_node_id, properties, source_type=u'_Network_Node', update_only=False):
tx = self._tx()
add_edge(tx, label, source_node_id, target_node_id, properties, source_type, update_only)
self._done()
def __call__(self, query):
tx = self._tx()
tx.append(query)
self._done()
def finish(self):
self._close()
def get_graph():
global NEO4J_URL,NEO4J_HOST,NEO4J_PORT,NEO4J_AUTH
# Connect to graph
creds = NEO4J_AUTH.split('/')
graph = Graph(user=creds[0], password=creds[1], host=NEO4J_HOST)
graph.run('match (t:Tweet) return COUNT(t)')
return graph
class Person(object):
def __init__(self):
self.graph = Graph()
#do nothing
def createPerson(self, name, fullname, occupation, homepage, wikipedia_link):
person = Node('Person', name=name, fullname=fullname, occupation=occupation, homepage=homepage, wikipedia_link=wikipedia_link)
self.graph.create(person)
return person
def add2neo(courses):
authenticate("localhost:7474", 'neo4j', 'admin')
graph = Graph()
for course in courses:
name = course.prefix+course.number
for pre in course.prereqs:
print 'adding rel', name, pre
try:
graph.create(Relationship(courseNodes[name]['node'], 'REQUIRES', courseNodes[pre]['node']))
except:
print 'could not add', name, pre
def expot_data(cid, data):
"""
将数据导入到neo4j，给每个导入的实体添加一个标签cid.
:param cid:
:param data:
:return:
"""
title = data[0]
host, http_port, bolt_port, user, password = '******', 7474, 7687, 'neo4j', 'gswewf'
graph = Graph(host=host, http_port=http_port, bolt_port=bolt_port, user=user, password=password)
# title = ["_id", "_labels", "tagline", "title", "released", "name", "born", "_start", "_end", "_type", "roles"]
_start_index = title.index('_start')
node_property = title[2:_start_index]
relation_property = title[_start_index + 3:]
nodes = {}
relationships = []
tx = graph.begin()
for line in data[1:]:
_id, _labels = line[:2]
node_property_value = line[2:_start_index]
_start, _end, _type = line[_start_index:_start_index + 3]
relation_property_value = line[_start_index + 3:]
_labels = [label for label in _labels.strip().split(':') if label]
_labels.append(cid.capitalize())
# print(line)
# nodes = {"a": Node("person", name="weiyudang", age=13), "b": Node("person", name="wangjiaqi")}
if _id and not _start and not _end:
property_dict = {k: v for k, v in zip(node_property, node_property_value) if v}
_cid = "{}_{}".format(cid.lower(), _id)
updatetime = int(time.time() * 1000) # 与 neo4j的timestamp()一致
node = Node(*_labels, _cid=_cid, updatetime=updatetime, **property_dict)
# graph.merge(node)
nodes.setdefault(_cid, node)
tx.create(node)
elif not _id and _start and _end:
property_dict = {k: v for k, v in zip(relation_property, relation_property_value) if v}
start_cid = "{}_{}".format(cid.lower(), _start)
end_cid = "{}_{}".format(cid.lower(), _end)
# a = Node(_cid=start_cid)
# b = Node(_cid=end_cid)
a = nodes.get(start_cid)
b = nodes.get(end_cid)
a_knows_b = Relationship(a, _type, b, **property_dict)
# graph.merge(a_knows_b)
relationships.append(a_knows_b)
tx.create(a_knows_b)
else:
raise ValueError("数据有误： {}".format(line))
print(len(nodes), len(relationships))
# sub_graph = Subgraph(nodes=nodes, relationships=relationships)
# graph.create(sub_graph)
tx.commit()
def import_api_data():
"""
imports data from my register (method and all adjacent) into graph DB
"""
graph = Graph()
# Uncomment on the first run!
# graph.schema.create_uniqueness_constraint("Method", "id")
# graph.schema.create_uniqueness_constraint("Author", "id")
# graph.schema.create_uniqueness_constraint("Category", "id")
methods = get_objects('method')
for api_method in methods:
node_method = graph.merge_one("Method", "id", api_method["id"])
node_method["name"] = api_method["name"]
node_method["creation_date"] = api_method["creation_date"]
node_method["approval_date"] = api_method["approval_date"]
for api_author in api_method["authors"]:
node_author = graph.merge_one("Author", "id", api_author["id"])
node_author["name"] = api_author["name"]
node_author.push()
graph.create_unique(Relationship(node_author, "WROTE", node_method))
api_category = api_method["category"]
node_category = graph.merge_one("Category", "id", api_category["id"])
node_category["name"] = api_category["name"]
node_category.push()
graph.create_unique(Relationship(node_category, "CONTAINS", node_method))
node_method.push()
class Neo4j():
graph = None
def __init__(self):
print("create neo4j class ...")
def connectDB(self):
self.graph = Graph("http://localhost:7474", username="******", password="******")
def matchItembyTitle(self,value):
answer = self.graph.find_one(label="Item",property_key="title",property_value=value)
return answer
# 根据title值返回互动百科item
def matchHudongItembyTitle(self,value):
answer = self.graph.find_one(label="HudongItem",property_key="title",property_value=value)
return answer
# 返回所有已经标注过的互动百科item filename为labels.txt
def getLabeledHudongItem(self, filename):
labels = readCSV2(filename)
List = []
i = 0
for line in labels:
ctx = self.graph.find_one(label="HudongItem",property_key="title",property_value=line[0])
if ctx == None:
continue;
cur = HudongItem(ctx)
cur.label = line[1]
List.append(cur)
print('load LabeledHudongItem over ...')
return List
# 返回限定个数的互动百科item
def getAllHudongItem(self, limitnum):
List = []
ge = self.graph.find(label="HudongItem", limit=limitnum)
for g in ge:
List.append(HudongItem(g))
print('load AllHudongItem over ...')
return List
#test = Neo4j()
#test.connectDB()
#answer = test.graph.find_one(label="HudongItem",property_key="title",property_value='火龙果')
#print(answer)
#a = test.getLabeledHudongItem('labels.txt')
#print(a[10].openTypeList)
def get_graph():
graph = Graph()
nodes = set()
links = []
for rel_type in [REL_FOLLOWS, REL_UPLOADED, REL_FAVORITED]:
for rel in graph.match(rel_type=rel_type):
start = node_to_id(rel.start_node)
end = node_to_id(rel.end_node)
if rel_type == REL_FAVORITED and end not in nodes:
continue
nodes.add(start)
nodes.add(end)
links.append([start, end])
return {'nodes': list(nodes), 'links': links}
def import_api_data2():
authenticate("localhost:7474", "neo4j", "1111")
graph = Graph()
#graph.delete_all()
# Uncomment on the first run!
#graph.schema.create_uniqueness_constraint("Borjnuk", "id")
#graph.schema.create_uniqueness_constraint("Obtaj", "id")
#graph.schema.create_uniqueness_constraint("Property", "id")
obtajenna = get_objects_art('obtaj')
for api_obtaj in obtajenna:
node_obtaj= graph.merge_one("Obtaj", "id", api_obtaj["id"])
node_obtaj["reason_doc"] = api_obtaj["reason_doc"]
node_obtaj["cost_size"] = api_obtaj["cost_size"]
for api_author in api_obtaj["borjnuku"]:
node_borjnuk = graph.merge_one("Borjnuk", "id", api_author["id"])
node_borjnuk["name"] = api_author["name"]
node_borjnuk["tel_number"] = api_author["tel_number"]
node_borjnuk.push()
graph.create_unique(Relationship(node_borjnuk, "obtajuetsa", node_obtaj))
for api_property in api_obtaj["properties"]:
node_property = graph.merge_one("Property", "id", api_property["id"])
node_property["name"] = api_property["name_property"]
node_property["ser_number"] = api_property["ser_number"]
node_property.push()
graph.create_unique(Relationship(node_property, "zakladena", node_obtaj))
node_obtaj.push()
class AgoraOrganization(object):
def __init__(self):
self.name = None
self.unique_id = None
self.mission_statement = None
self.email = None
self.is_open = False
self.is_invite_only = False
self.website = None
self.graph_db = Graph()
@property
def org_node(self):
return self.graph_db.find_one(AgoraLabel.ORGANIZATION,
property_key='name',
property_value=self.name)
@property
def org_members(self):
"""
list of the members of the organization
:return: list of tuple of member name, email
"""
org_members_nodes = self.graph_db.match(start_node=self.org_node,
rel_type=AgoraRelationship.MEMBER_OF,
end_node=None)
org_members_list = []
for item in org_members_nodes:
org_members_list.append((item.end_node["name"], item.end_node["email"]))
return org_members_list
def create_organization(self):
"""
create a new organization
:return: py2neo Node
"""
self.unique_id = str(uuid.uuid4())
new_org_properties = {
"name": self.name,
"mission_statement": self.mission_statement,
"unique_id": self.unique_id,
"email": self.email,
"is_open": self.is_open,
"is_invite_only": self.is_invite_only,
"website": self.website}
new_org_node = Node.cast(AgoraLabel.ORGANIZATION, new_org_properties)
self.graph_db.create(new_org_node)
return new_org_node
def main():
if not has_py2neo:
sys.exit("[!] py2neo must be installed for this script.")
if not has_evtx:
sys.exit("[!] python-evtx must be installed for this script.")
if not has_lxml:
sys.exit("[!] lxml must be installed for this script.")
if not has_lxml:
sys.exit("[!] numpy must be installed for this script.")
if not has_changefinder:
sys.exit("[!] changefinder must be installed for this script.")
try:
graph_http = "http://" + NEO4J_USER + ":" + NEO4J_PASSWORD +"@" + NEO4J_SERVER + ":" + NEO4J_PORT + "/db/data/"
GRAPH = Graph(graph_http)
except:
sys.exit("[!] Can't connect Neo4j Database.")
print("[*] Script start. %s" % datetime.datetime.now().strftime("%Y/%m/%d %H:%M:%S"))
if args.run:
try:
app.run(threaded=True, host="0.0.0.0", port=WEB_PORT)
except:
sys.exit("[!] Can't runnning web application.")
# Delete database data
if args.delete:
GRAPH.delete_all()
print("[*] Delete all nodes and relationships from this Neo4j database.")
if args.evtx:
for evtx_file in args.evtx:
if not os.path.isfile(evtx_file):
sys.exit("[!] Can't open file {0}.".format(evtx_file))
parse_evtx(args.evtx, GRAPH)
if args.xmls:
for xml_file in args.xmls:
if not os.path.isfile(xml_file):
sys.exit("[!] Can't open file {0}.".format(xml_file))
parse_evtx(args.xmls, GRAPH)
print("[*] Script end. %s" % datetime.datetime.now().strftime("%Y/%m/%d %H:%M:%S"))
def test_can_cast_3_tuple():
casted = Graph.cast(("Alice", "KNOWS", "Bob"))
assert isinstance(casted, Relationship)
assert not casted.bound
assert casted.start_node == Node("Alice")
assert casted.type == "KNOWS"
assert casted.end_node == Node("Bob")
class Neo4j():
graph = None
def __init__(self):
print("create neo4j class ...")
def connectDB(self):
self.graph = Graph("http://localhost:7474", username="******", password="******")
def matchItembyTitle(self,value):
answer = self.graph.find_one(label="Item",property_key="title",property_value=value)
return answer
# 根据title值返回互动百科item
def matchHudongItembyTitle(self,value):
answer = self.graph.find_one(label="HudongItem",property_key="title",property_value=value)
return answer
def save_publications_list(publications):
"""
Method to save all the publications to neo4j database
"""
graph = Graph()
for publication in publications:
publication_node = Node("Publication")
for key in publication:
if key not in ['_id', 'authorsSearched', 'identifiers', 'rank', 'work-citation-type']:
publication_node.properties[key] = publication[key]
graph.create(publication_node)
print 'Inserted Publication: ' + publication['doi']
class Achievement(object):
def __init__(self, graph_db):
self.name = None
self.id = None
self.description = None
self.title = None
self.is_visible = True
self.date = None
self._graph_db = Graph(settings.DATABASE_URL)
@property
def achievement_node(self):
return self._graph_db.find_one(GraphLabel.ACHIEVEMENT,
property_key='id',
property_value=self.id)
@property
def achievement_interests(self):
"""
get list of interests linked to this achievement
:return:
"""
# ach_interests = self.graph_db.match(start_node=self.achievement_node,
# rel_type=Relationship.)
return None
def connect(self):
conf = self.get_config()
authenticate(conf['host'] + ":" + conf['port'],conf['username'],conf["password"])
try:
self.neo = Graph("http://" + conf['host'] + ":" + conf["port"] + "/db/data")
except:
print "Failed to connect!"
def __init__(self):
self.g = Graph("http://localhost:7474", username="******", password="******")
self.num_limit = 20
class MedicalGraph:
def __init__(self):
cur_dir = '/'.join(os.path.abspath(__file__).split('/')[:-1])
self.data_path = os.path.join(cur_dir, 'data/disease.csv')
self.graph = Graph("http://localhost:7474",
username="******",
password="******")
def read_file(self):
"""
读取文件，获得实体，实体关系
:return:
"""
# cols = ["name", "alias", "part", "age", "infection", "insurance", "department", "checklist", "symptom",
# "complication", "treatment", "drug", "period", "rate", "money"]
# 实体
diseases = [] # 疾病
aliases = [] # 别名
symptoms = [] # 症状
parts = [] # 部位
departments = [] # 科室
complications = [] # 并发症
drugs = [] # 药品
# 疾病的属性：age, infection, insurance, checklist, treatment, period, rate, money
diseases_infos = []
# 关系
disease_to_symptom = [] # 疾病与症状关系
disease_to_alias = [] # 疾病与别名关系
disease_to_part = [] # 疾病与部位关系
disease_to_department = [] # 疾病与科室关系
disease_to_complication = [] # 疾病与并发症关系
disease_to_drug = [] # 疾病与药品关系
all_data = pd.read_csv(self.data_path,
encoding='gb18030').loc[:, :].values
for data in all_data:
disease_dict = {} # 疾病信息
# 疾病
disease = str(data[0]).replace("...", " ").strip()
disease_dict["name"] = disease
# 别名
line = re.sub("[，、；,.;]", " ", str(data[1])) if str(
data[1]) else "未知"
for alias in line.strip().split():
aliases.append(alias)
if [disease, alias] not in disease_to_alias:
disease_to_alias.append([disease, alias])
# 部位
part_list = str(data[2]).strip().split() if str(data[2]) else "未知"
for part in part_list:
parts.append(part)
if [disease, part] not in disease_to_part:
disease_to_part.append([disease, part])
# 年龄
age = str(data[3]).strip()
disease_dict["age"] = age
# 传染性
infect = str(data[4]).strip()
disease_dict["infection"] = infect
# 医保
insurance = str(data[5]).strip()
disease_dict["insurance"] = insurance
# 科室
department_list = str(data[6]).strip().split()
for department in department_list:
departments.append(department)
if [disease, department] not in disease_to_department:
disease_to_department.append([disease, department])
# 检查项
check = str(data[7]).strip()
disease_dict["checklist"] = check
# 症状
symptom_list = str(data[8]).replace("...",
" ").strip().split()[:-1]
for symptom in symptom_list:
symptoms.append(symptom)
if [disease, symptom] not in disease_to_symptom:
disease_to_symptom.append([disease, symptom])
# 并发症
complication_list = str(data[9]).strip().split()[:-1] if str(
data[9]) else "未知"
for complication in complication_list:
complications.append(complication)
if [disease, complication] not in disease_to_complication:
disease_to_complication.append([disease, complication])
# 治疗方法
treat = str(data[10]).strip()[:-4]
disease_dict["treatment"] = treat
# 药品
drug_string = str(data[11]).replace("...", " ").strip()
for drug in drug_string.split()[:-1]:
drugs.append(drug)
if [disease, drug] not in disease_to_drug:
disease_to_drug.append([disease, drug])
# 治愈周期
period = str(data[12]).strip()
disease_dict["period"] = period
# 治愈率
rate = str(data[13]).strip()
disease_dict["rate"] = rate
# 费用
money = str(data[14]).strip() if str(data[14]) else "未知"
disease_dict["money"] = money
diseases_infos.append(disease_dict)
return set(diseases), set(symptoms), set(aliases), set(parts), set(departments), set(complications), \
set(drugs), disease_to_alias, disease_to_symptom, disease_to_part, disease_to_department, \
disease_to_complication, disease_to_drug, diseases_infos
def create_node(self, label, nodes):
"""
创建节点
:param label: 标签
:param nodes: 节点
:return:
"""
count = 0
for node_name in nodes:
node = Node(label, name=node_name)
self.graph.create(node)
count += 1
print(count, len(nodes))
return
# def create_node(self, label, nodes):
# count = 0
# for node_name in nodes:
# # print(node_name)
# node = Node(label, name=node_name)
# matcher = NodeMatcher(self.graph)
# txt = matcher.match(label, name=node_name).first()
# if txt is None:
# self.graph.create(node)
#
# count += 1
# # print(count, len(nodes))
# return
def create_diseases_nodes(self, disease_info):
"""
创建疾病节点的属性
:param disease_info: list(Dict)
:return:
"""
count = 0
for disease_dict in disease_info:
node = Node("Disease",
name=disease_dict['name'],
age=disease_dict['age'],
infection=disease_dict['infection'],
insurance=disease_dict['insurance'],
treatment=disease_dict['treatment'],
checklist=disease_dict['checklist'],
period=disease_dict['period'],
rate=disease_dict['rate'],
money=disease_dict['money'])
self.graph.create(node)
count += 1
print(count)
return
def create_graphNodes(self):
"""
创建知识图谱实体
:return:
"""
disease, symptom, alias, part, department, complication, drug, rel_alias, rel_symptom, rel_part, \
rel_department, rel_complication, rel_drug, rel_infos = self.read_file()
self.create_diseases_nodes(rel_infos)
self.create_node("Symptom", symptom)
self.create_node("Alias", alias)
self.create_node("Part", part)
self.create_node("Department", department)
self.create_node("Complication", complication)
self.create_node("Drug", drug)
return
def create_graphRels(self):
disease, symptom, alias, part, department, complication, drug, \
rel_alias, rel_symptom, rel_part, rel_department, rel_complication, rel_drug, rel_infos = self.read_file()
self.create_relationship("Disease", "Alias", rel_alias, "ALIAS_IS",
"别名")
self.create_relationship("Disease", "Symptom", rel_symptom,
"HAS_SYMPTOM", "症状")
self.create_relationship("Disease", "Part", rel_part, "PART_IS",
"发病部位")
self.create_relationship("Disease", "Department", rel_department,
"DEPARTMENT_IS", "所属科室")
self.create_relationship("Disease", "Complication", rel_complication,
"HAS_COMPLICATION", "并发症")
self.create_relationship("Disease", "Drug", rel_drug, "HAS_DRUG", "药品")
def create_relationship(self, start_node, end_node, edges, rel_type,
rel_name):
"""
创建实体关系边
:param start_node:
:param end_node:
:param edges:
:param rel_type:
:param rel_name:
:return:
"""
count = 0
# 去重处理
set_edges = []
for edge in edges:
set_edges.append('###'.join(edge))
all = len(set(set_edges))
for edge in set(set_edges):
edge = edge.split('###')
p = edge[0]
q = edge[1]
query = "match(p:%s),(q:%s) where p.name='%s'and q.name='%s' create (p)-[rel:%s{name:'%s'}]->(q)" % (
start_node, end_node, p, q, rel_type, rel_name)
try:
self.graph.run(query)
count += 1
print(rel_type, count, all)
except Exception as e:
print(e)
return
'''导出数据'''
def export_data(self):
disease, symptom, alias, part, department, complication, drug, \
rel_alias, rel_symptom, rel_part, rel_department, rel_complication, rel_drug, rel_infos = self.read_file()
f_disease = open('data1/disease.txt', 'w+', encoding='utf-8')
f_alias = open('data1/alias.txt', 'w+', encoding='utf-8')
f_symptom = open('data1/symptom.txt', 'w+', encoding='utf-8')
f_part = open('data1/part.txt', 'w+', encoding='utf-8')
f_department = open('data1/department.txt', 'w+', encoding='utf-8')
f_complication = open('data1/complication.txt', 'w+', encoding='utf-8')
f_drug = open('data1/drug.txt', 'w+', encoding='utf-8')
f_disease.write('\n'.join(list(disease)))
f_alias.write('\n'.join(list(alias)))
f_symptom.write('\n'.join(list(symptom)))
f_part.write('\n'.join(list(part)))
f_department.write('\n'.join(list(department)))
f_complication.write('\n'.join(list(complication)))
f_drug.write('\n'.join(list(drug)))
f_disease.close()
f_alias.close()
f_symptom.close()
f_part.close()
f_department.close()
f_complication.close()
f_drug.close()
# coding:utf-8
from py2neo import Graph, Node, Relationship
import time
import xlrd
import xlwt
from datetime import date, datetime
# 打开图数据库
graph = Graph('http://localhost:7474', name='neo4j', password='******')
# graph.delete_all()
# 打开 Excel:zzjg
file = "zzjg.xls"
wb = xlrd.open_workbook(filename=file)
sheetn = wb.sheet_by_index(0)
print(sheetn.name, sheetn.nrows, sheetn.ncols)
rowsacount = sheetn.nrows
# rows = sheet1.row_values(0) #获取行内容
# print(rows)
# cols = sheet1.col_values(0) #获取列内容
# print(cols)
rootnode = Node('v组织机构', name='中国石化')
graph.create(rootnode)
amax = 1
for i in range(0, rowsacount):
# print(i)
rn = sheetn.row_values(i)
# print(rn[3].split("/")[0])
import datetime
import calendar
import time
startTime = time.time()
def getUTCStamp(dt):
return calendar.timegm(dt.utctimetuple())
def toMin(timeDiff):
seconds = timeDiff
return str("%.3f" % seconds)
graph = Graph()
# Create the correct UTC stamps for each month.
months = []
for i in range(1, 13):
months.append(getUTCStamp(datetime.datetime(2008, i, 1)))
'''
###
### Check Total number of Obama menntions in 2008
###
query = '\
MATCH (c:Comment) \
WHERE c.body =~ ".*[Oo]bama.*" \
RETURN count(c) as obamas\
'
tick = time.time()
def __init__(self):
cur_dir = '/'.join(os.path.abspath(__file__).split('/')[:-1])
self.data_path = os.path.join(cur_dir, 'data/disease.csv')
self.graph = Graph("http://localhost:7474",
username="******",
password="******")
#coding: utf-8
from py2neo import Graph, Node, Relationship
from py2neo.matching import NodeMatcher, RelationshipMatcher
from py2neo.ogm import Label
import re
import xlrd
import time
from com.wdk.stock.knowledgegraph.py2neo_advanced_tools import copy_all_incoming_relationship,\
copy_all_outgoing_relationship
# 连接neo4j数据库
graph = Graph("http://127.0.0.1:7474", username="******", password="******")
file_name_resume = '上市公司高管简历.xlsx'
file_name_manager_profile = '上市公司高管.xls'
# 把管理层的基本信息输入到图数据库中
def add_manager_profile_to_graph(file_name_manager_profile):
workbook = xlrd.open_workbook(file_name_manager_profile)
sheet_names = workbook.sheet_names()
for sheet_name in sheet_names:
sheet = workbook.sheet_by_name(sheet_name)
row_count = 0
current_year = int(time.strftime('%Y', time.localtime()))
for rowx in range(1, sheet.nrows):
row_count += 1
manager_name = sheet.row_values(rowx)[0]
stock_name = sheet.row_values(rowx)[1]
manager_sex = sheet.row_values(rowx)[2]
def connect_graph():
graph = Graph("http://localhost:7474/db/data/", user='******', password='******')
return graph
def __init__(self):
self.graph = Graph("http://localhost:7474",
username="******",
password="******")
__author__ = 'Andrei'
from py2neo import Graph
from py2neo import Node, Relationship
graph = Graph('http://*****:*****@localhost:7474/db/data')
alice = Node("Person", name="Alice")
bob = Node("Person", name="Bob")
alice_knows_bob = Relationship(alice, "KNOWS", "bob")
graph.create(alice_knows_bob)
alice.properties["age"] = 33
bob.properties["age"] = 44
graph.push(alice, bob)
from py2neo.cypher import cypher_escape
import re
# s = os.path.dirname(os.getcwd())
# print(s)
# with open(s+r"\GetData\orginfoFormat.pkl","rb") as fp:
# ngoData = pickle.load(fp)
orgType = ["全部","国内机构","境外机构","基金会","企业","政府部门"]
provinceNameMap = {"西藏省":"西藏自治区","内蒙省":"内蒙古自治区","广西省":"广西壮族自治区",
"新疆省":"新疆维吾尔自治区","宁夏省":"宁夏回族自治区"}
fp = open("orginfoFinalNew.pkl", "rb")
ngo = pickle.load(fp)
print(len(ngo))
authenticate("localhost:7474", "neo4j", "liyi193328")
graph = Graph()
# graph.delete_all()
def getAllNgoName():
fp = open("orginfoFinalNew.pkl", "rb")
ngo = pickle.load(fp)
names = list()
for per in ngo:
names.append(per.name)
fp = open("AllNgoName.pkl","wb")
pickle.dump(names,fp)
fp.close()
return names
def findNode(pat,names):
if len(pat) < 2:
from py2neo import Graph, Path
graph = Graph()
#a. Add movie = "John Wick"
#b. Add directors by Chad Stahelski, David Leitch
#c. Add actors William Dafoe and Michael Nyquist
#d. Add DIRECTED_BY and ACTS_IN relationships for all
# - include role property on ACTS_IN
wick = graph.cypher.execute(
'CREATE (m:Movie {title: {title}, year: {year}}) RETURN m',
title='John Wick',
year='2014-10-24')[0][0]
tx2 = graph.cypher.begin()
for actor_name in ['William Dafoe', 'Michael Nyquist']:
tx2.append('CREATE (a:Actor {name: {name}}) RETURN a', name=actor_name)
will, mike = [result.one for result in tx2.commit()]
will_path = Path(will, ('ACTS_IN', {'role': 'Marcus'}), wick)
graph.create(will_path)
mike_path = Path(mike, ('ACTS_IN', {'role': 'Viggo Tarasov'}), wick)
graph.create(mike_path)
tx3 = graph.cypher.begin()
for director_name in ['Chad Stahelski', 'David Leitch']:
tx3.append('CREATE (d:Director {name: {name}}) RETURN d',
name=director_name)
chad, david = [result.one for result in tx3.commit()]
from py2neo import Graph, Node, Relationship, watch
from py2neo.ogm import GraphObject, Property
from uuid import uuid4
from datetime import datetime
from passlib.hash import bcrypt
from flask_login import UserMixin, current_user
#URL = 'http://hobby-ehpkpbgfojekgbkepcgcceol.dbs.graphenedb.com:24789'
URL = os.environ.get('NEO4J_URL') or 'http://localhost:7474'
username = os.environ.get('NEO4J_USER') or 'neo4j'
password = os.environ.get('NEO4J_PASS') or 'arfat78692'
#username = '******'
#password = '******'
graph = Graph(URL + '/db/data/', username=username, password=password, bolt=False)
# OGM of User Label
class User(GraphObject, UserMixin):
__primarykey__ = 'email'
email = Property()
username = Property()
password = Property()
def __init__(self, email=''):
return User.select(graph, email).first()
@classmethod
def get_user(cls, email):
return cls.select(graph, email).first()
from py2neo import Graph, Database, Node, Relationship
import os
graph=Graph("http://*****:*****@123"))
def scope(data_file):
import json
json = json.load(data_file)
query = """
WITH {json} AS data
UNWIND KEYS($json) AS k
CREATE(label:author{name:$json[k].author,hashtag:$json[k].hashtags,tweetdate:$json[k].date,date_time:$json[k].datetime,tid:$json[k].tid,tweettext:$json[k].tweet_text,authorid:$json[k].author_id,location:$json[k].location,language:$json[k].lang,like_count:$json[k].like_count})
"""
graph.run(query,json=json)
def problem1():
for record in graph.run("MATCH (n) WHERE n.name='selfresqingprncess' RETURN n ORDER BY n.date_time DESC"):
print(record["n"]["tid"])
print(record["n"]["tweettext"])
print(record["n"]["authorid"])
print(record["n"]["location"])
print(record["n"]["language"])
def problem2():
for record in graph.run("MATCH (n) WHERE n.tweettext CONTAINS 'Senate' RETURN n ORDER BY n.like_count DESC"):
print(record["n"]["tweettext"])
def problem3():
for record in graph.run("MATCH (n) WHERE n.hashtag='pqr' RETURN n ORDER BY n.date_time DESC"):
print(record["n"]["tweettext"])
def problem4():
import re
from datetime import datetime, timedelta
import requests
from py2neo import Graph
import constants
from helpers import post_message
graph = Graph(constants.neo_url)
# pat = re.compile(r'(?i)\b((?:https?://|www\d{0,3}[]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:\'".,<>?\xab\xbb\u201c\u201d\u2018\u2019]))')
pat = re.compile(r'(https?.\/\/+)([^ ]+)')
r = re.compile(pat)
def onMessage(message):
m = r.search(message['text'])
if m is None:
return
url = m.group()
print(url)
# check if it exists
check_statement = """
MATCH (u:User)--(m:Message)--(l:Link {id: {url}})
return u.name as name, m.date as date
"""
good = False
# This simply checks to see if you have a connection string in your repo.
# I use `strip` to remove whitespace/newlines.
for line in gi:
if line.strip() == "connect_remote.json":
good = True
break
if good is False:
print("The connect_remote.json file is not in your .gitignore file. \
Please add it!")
with open('../connect_remote.json') as f:
data = json.load(f)
graph = Graph(**data[1])
tx = graph.begin()
re3api_short = "https://www.re3data.org/api/beta/repository/"
kws = set()
for repo in repositories:
print("Working on " + str(repo['name']))
uri = "https://www.re3data.org/api/beta/repository/" + repo['id']
repodata = parsere3(uri)['r3d:re3data']['r3d:repository']
node = {'id': repo.get('id'),
'name': repodata.get('r3d:repositoryName').get('#text'),
'url': repodata.get('r3d:repositoryURL'),
'keywords': repodata.get('r3d:keyword'),
'description': repodata.get('r3d:description').get('#text'),
import json
import uuid
import os
import googlemaps
# === DB Connections ===
"""
For Connecting to NEO4j PROD DB on Heroku
"""
graphenedb_url = os.environ.get("GRAPHENEDB_BOLT_URL", 'blah')
graphenedb_user = os.environ.get("GRAPHENEDB_BOLT_USER", 'blah')
graphenedb_pass = os.environ.get("GRAPHENEDB_BOLT_PASSWORD", 'blah')
authenticate(graphenedb_url.strip("bolt://").replace("24787", "24780"), graphenedb_user, graphenedb_pass)
graph = Graph(graphenedb_url, user=graphenedb_user, password=graphenedb_pass, bolt = True, secure = True, http_port = 24789, https_port = 24780)
"""
For Connecting to local host instance
"""
# graph = Graph(bolt=True, host=os.environ.get("NEO4J_PYTHON_HOST", 'n/a'), user=os.environ.get("NEO4J_PYTHON_USER", 'n/a'), password=os.environ.get("NEO4J_PYTHON_PASS", 'n/a'))
"""
Google Maps Object for querying New Restaurants
"""
gmaps = googlemaps.Client(key=os.environ["GOOGLE_MAPS_API_KEY"])
# === User Model for UserService API ===
class User:
from py2neo import Graph, Database
db = Database()
graph = Graph(user="******")
def confCommuntity():
query = """
MATCH (c:conference)-[r:edition]->(p:paper)<--(a:author)
WITH c.name as confName, a.authorName as authorName, count(distinct r.year) as nYear
WHERE nYear>=4
RETURN confName, collect(authorName) as authorNames
"""
return graph.run(query).data()
if __name__ == '__main__':
list_confComm = confCommuntity()
print(
"List of conference name and their community authors with papers in 4 different editions."
)
for val in list_confComm:
print(val)
from py2neo import Graph, Node, Relationship, authenticate
from passlib.hash import bcrypt
from datetime import datetime
import queryService
import loadOntologyEntities, readOntology
import os
import uuid
#url = os.environ.get('http://*****:*****@emborectest.sb04.stations.graphenedb.com:24789/db/data/")
class User:
def __init__(self, username):
self.username = username
def find(self):
user = graph.find_one("OnlineMusicAccount", "username", self.username)
return user
def register(self, password, group, age):
if not self.find():
user = Node("OnlineMusicAccount",
username=self.username,
parser.add_option('--user',
dest='user',
default='neo4j',
help='neo4j user',
metavar='str')
parser.add_option('--password',
dest='password',
default='neo4j',
help='neo4j user password',
metavar='str')
(options, args) = parser.parse_args()
if options.input is None:
print('input is required')
parser.print_help()
exit(1)
graph = Graph(host=options.host,
http_port=options.port,
user=options.user,
password=options.password)
delete_all_data(graph)
prepare_graph(graph)
with open(options.input) as f:
dump = json.load(f)
create_nodes_and_rels(graph, dump)
def __init__(self):
self.g = Graph('bolt://localhost:7687', username='******', password='******')
# -*- coding: utf-8 -*-
'''
将csv文件导入neo4j数据库
import文件夹是neo4j默认的数据导入文件夹
所以首先要将data文件夹下所有csv文件拷贝到neo4j数据库的根目录import文件夹下，没有则先创建import文件夹
然后运行此程序
'''
from py2neo import Graph
graph = Graph("http://localhost:7474", username="******", password="******")
"""
#测试
cql='''
MATCH (p:Person)
where p.name="张柏芝"
return p
'''
#清空数据库
#data = graph.run('MATCH (n) OPTIONAL MATCH (n)-[r]-() DELETE n,r')
data = graph.run(cql)
print(list(data)[0]['p']["biography"])
"""
# 导入节点 电影类型 == 注意类型转换
cql = '''
LOAD CSV WITH HEADERS FROM "file:///genre.csv" AS line
MERGE (p:Genre{gid:toInteger(line.gid),name:line.gname})
'''
result = graph.run(cql)
print(result, "电影类型 存储成功")
import time
from py2neo.ogm import *
from py2neo import Node, Relationship, Graph
import os, json
# NODES Author Hashtag tweet
# RELATIONSHIPS: Reply(user , tweet) Retweet(user , tweet) Post(user, tweet) Mention(tweet,user Hashtag(tweet,hashtag)
graph = ''
try:
graph = Graph(host="localhost", password="******")
except:
print("coudn't connect to neo4j")
exit()
count = 0
count2 = 0
count3 = 0
count4 = 0
flag = 0
a = graph.run("MATCH (n) DETACH DELETE n")
pres = []
newpres = []
file_data = open('ds.json').read()
read_data = json.loads(file_data)
tx = graph.begin(autocommit=False)
for key in read_data.keys():
read = read_data[key]
hashtags = read['hashtags']
mentions = read['mentions']
from py2neo import Graph, Schema
graph = Graph(auth=("neo4j", "137137137"))
graph.delete_all()
# Create Indexes for primary keys of entites
tx = graph.begin()
tx.run('''CREATE INDEX ON :Member(ID)''')
tx.run('''CREATE INDEX ON :Organization(ID)''')
tx.run('''CREATE INDEX ON :User(ID)''')
tx.commit()
# Create Entities
tx = graph.begin()
tx.run('''
LOAD CSV WITH HEADERS FROM "file:///data/organization.csv" AS row
CREATE (o:Organization)
SET o = row,
o.ID = toInteger(row.ID)
RETURN o
''')
tx.run('''
LOAD CSV WITH HEADERS FROM "file:///data/user.csv" AS row
CREATE (u:User)
SET u = row,
u.ID = toInteger(row.ID)
RETURN u
''')
tx.commit()
# Create Relationships
def ad(request):
user_id = None
if request.user.is_authenticated():
user_id = request.user.id
if request.method == 'POST':
form = AdForm(request.POST)
if form.is_valid():
ad = Anuncio.objects.create(
categoria=form.cleaned_data['categoria'],
produto=form.cleaned_data['produto'],
marca=form.cleaned_data['marca'],
modelo=form.cleaned_data['modelo'],
descricao=form.cleaned_data['descricao'],
numserie=form.cleaned_data['numserie'],
peso=form.cleaned_data['peso'],
c_prof=form.cleaned_data['c_prof'],
c_altura=form.cleaned_data['c_altura'],
c_largura=form.cleaned_data['c_largura'],
diaria=form.cleaned_data['diaria'],
usuario_id=user_id)
categoria = form.cleaned_data['categoria']
produto = form.cleaned_data['produto']
categorias = categoria.split('/')
# Autentica no BD neo4j
authenticate("localhost:7474", "neo4j", "secret")
# Recupera o BD para uma variável
stuffgraph = Graph()
# Cria um node para o produto
produto_node = Node("Produto", id=ad.id, nome=produto)
# Monta a query Cypher para buscar a categoria
cypher_str = 'MATCH '
for i in range(len(categorias) - 1):
cypher_str = cypher_str + '''(%s: Categoria {nome: "%s"})
-[:TEM_SUBCATEGORIA]->''' % (
"a" + str(i), categorias[i])
cypher_str = cypher_str + '''(%s: Categoria {nome: "%s"})
RETURN %s''' % ("a" + str(len(categorias)), categorias[
len(categorias) - 1], "a" + str(len(categorias)))
# Captura em uma variável o node de categoria retornado pela query
categoria_node = stuffgraph.cypher.execute_one(cypher_str)
# Cria a relação ESTA_EM entre produto e categoria
rel_produto_categoria = Relationship(produto_node, "ESTA_EM",
categoria_node)
# Persiste no BD neo4j
stuffgraph.create(rel_produto_categoria)
return HttpResponseRedirect('/')
else:
form = AdForm()
variables = RequestContext(request, {'form': form})
return render_to_response(
'rentstuff/ad.html',
variables,
)
from py2neo import authenticate, Graph
import pandas as pd
from pandas.util.testing import assert_frame_equal
from final_main_test import *
# IN CASE YOU HAVEN'T USED PYTEST BEFORE
# install pytest - "pip install pytest" should work
# from the command line, navigate to the folder
# run "py.test neo4j_test.py" from command line
# once all 3 tests pass, you're good
authenticate("54.85.112.231:7474", "neo4j", "LEbKqX3q")
graph = Graph("bolt://54.85.112.231/db/data/")
def test_one():
"""Return all of the associations of Ariel Sharon """
# this is the query that your wrapper should parse and return from
datalog_query = """
q(organization) :-
actor(id, _, pname, _),
affiliation(id, organization, _, _),
pname = 'Ariel Sharon'
"""
# i am using your execute function to run the query above
datalog_result = final_query(datalog_query)
# this is what i would expect your parser to ask the database
neo_query = """
class AnswerSearcher:
def __init__(self):
self.g = Graph("http://localhost:7474", username="******", password="******")
self.num_limit = 20
'''执行cypher查询，并返回相应结果'''
def search_main(self, sqls):
final_answers = []
for sql_ in sqls:
question_type = sql_['question_type']
queries = sql_['sql']
answers = []
for query in queries:
ress = self.g.run(query).data()
answers += ress
final_answer = self.answer_prettify(question_type, answers)
if final_answer:
final_answers.append(final_answer)
return final_answers
'''根据对应的qustion_type，调用相应的回复模板'''
def answer_prettify(self, question_type, answers):
final_answer = []
if not answers:
return ''
if question_type == 'disease_symptom':
desc = [i['n.name'] for i in answers]
subject = answers[0]['m.name']
final_answer = '{0}的症状包括：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'symptom_disease':
desc = [i['m.name'] for i in answers]
subject = answers[0]['n.name']
final_answer = '症状{0}可能染上的疾病有：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'disease_cause':
desc = [i['m.cause'] for i in answers]
subject = answers[0]['m.name']
final_answer = '{0}可能的成因有：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'disease_prevent':
desc = [i['m.prevent'] for i in answers]
subject = answers[0]['m.name']
final_answer = '{0}的预防措施包括：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'disease_lasttime':
desc = [i['m.cure_lasttime'] for i in answers]
subject = answers[0]['m.name']
final_answer = '{0}治疗可能持续的周期为：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'disease_cureway':
desc = [';'.join(i['m.cure_way']) for i in answers]
subject = answers[0]['m.name']
final_answer = '{0}可以尝试如下治疗：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'disease_cureprob':
desc = [i['m.cured_prob'] for i in answers]
subject = answers[0]['m.name']
final_answer = '{0}治愈的概率为（仅供参考）：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'disease_easyget':
desc = [i['m.easy_get'] for i in answers]
subject = answers[0]['m.name']
final_answer = '{0}的易感人群包括：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'disease_desc':
desc = [i['m.desc'] for i in answers]
subject = answers[0]['m.name']
final_answer = '{0},熟悉一下：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'disease_acompany':
desc1 = [i['n.name'] for i in answers]
desc2 = [i['m.name'] for i in answers]
subject = answers[0]['m.name']
desc = [i for i in desc1 + desc2 if i != subject]
final_answer = '{0}的症状包括：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'disease_not_food':
desc = [i['n.name'] for i in answers]
subject = answers[0]['m.name']
final_answer = '{0}忌食的食物包括有：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'disease_do_food':
do_desc = [i['n.name'] for i in answers if i['r.name'] == '宜吃']
recommand_desc = [i['n.name'] for i in answers if i['r.name'] == '推荐食谱']
subject = answers[0]['m.name']
final_answer = '{0}宜食的食物包括有：{1}\n推荐食谱包括有：{2}'.format(subject, ';'.join(list(set(do_desc))[:self.num_limit]), ';'.join(list(set(recommand_desc))[:self.num_limit]))
elif question_type == 'food_not_disease':
desc = [i['m.name'] for i in answers]
subject = answers[0]['n.name']
final_answer = '患有{0}的人最好不要吃{1}'.format('；'.join(list(set(desc))[:self.num_limit]), subject)
elif question_type == 'food_do_disease':
desc = [i['m.name'] for i in answers]
subject = answers[0]['n.name']
final_answer = '患有{0}的人建议多试试{1}'.format('；'.join(list(set(desc))[:self.num_limit]), subject)
elif question_type == 'disease_drug':
desc = [i['n.name'] for i in answers]
subject = answers[0]['m.name']
final_answer = '{0}通常的使用的药品包括：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'drug_disease':
desc = [i['m.name'] for i in answers]
subject = answers[0]['n.name']
final_answer = '{0}主治的疾病有{1},可以试试'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'disease_check':
desc = [i['n.name'] for i in answers]
subject = answers[0]['m.name']
final_answer = '{0}通常可以通过以下方式检查出来：{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
elif question_type == 'check_disease':
desc = [i['m.name'] for i in answers]
subject = answers[0]['n.name']
final_answer = '通常可以通过{0}检查出来的疾病有{1}'.format(subject, '；'.join(list(set(desc))[:self.num_limit]))
return final_answer
def graph(uri):
return Graph(uri)
from py2neo import Graph
graph = Graph("http://localhost:7474/db/data/")
# remove self loop
graph.data("match (n)-[r]->(n) delete r")
# return graph
graph.data("MATCH p = ()-[r:UnderProgram]->(n {name: program_name}) RETURN p")
# match (n)-[r:HasDuplicate]->(n) delete r
# MATCH (n {name: 'Alice'})->(m)
# "Accounting (BS)"
MATCH p = ()-[r: UnderProgram]->(n {name: "Accounting (BS)"}) RETURN p
MATCH (m)-[r:UnderProgram]->(n {name: 'Accounting (BS)'})
where (m)-[r:HasPreparation]->()
graph_3.data("MATCH (m)-[r:UnderProgram]->(n {name: 'Accounting (BS)'})\
where not (m)-[r:HasPreparation]->() and not (m)-[r:HasPrerequisite]->()\
return m")
MATCH (k)-[r*]->(n:ABC)
with k, r, n, count(k)
import pandas as pd
courses = list()
courselist = graph_3.data("MATCH p = (m)-[r:UnderProgram]->(n {name: 'Accounting (BS)'}) return p")
for course in courselist:
graph_3.data("Match ")
def create_connection_with_neo4j_mysql():
# create connection with neo4j
global graph_database
graph_database = Graph("http://localhost:7474/db/data/",
auth=("neo4j", "test"))
from pandas import DataFrame
from newBookInfor import *
'''
host:服务器ip地址，默认为'localhost'
http_port:http协议——服务器监听端口，默认为7474
https_port:https协议——服务器监听端口，默认为7473
bolt_port:bolt协议——服务器监听端口，默认为7687
user:登录用户名，默认为'neo4j'
password:登录密码，无默认值，故若数据库其他参数都为默认值，则可直接通过密码登录
'''
result = readBookField().fetchall()
#cow_result = readBookField().description()
#graph1 = Graph(host='localhost', http_port=7978, user='******', password='******')
graph1 = Graph(host='http://112.74.160.185',
http_port=7474,
user='******',
password='******')
graph2 = Graph('http://112.74.160.185:7474/browser/',
user='******',
password='******')
graph3 = Graph('https://localhost:7473/browser/',
user='******',
password='******')
graph4 = Graph(password='******')
graph = graph2.begin() # 打开图数据库，未打开时不能进行操作
matcher = NodeMatcher(graph) #使用NodeMatcher来查找数据
def createNode(label_name):
node = Node('base_node', name=label_name
