def remove_from_index(self, cls, index, key=None, value=None, entity=None):
""" Remove any nodes or relationships from an index that match a
particular set of criteria. Allowed parameter combinations are:
`key`, `value`, `entity`
remove a specific node or relationship indexed under a given
key-value pair
`key`, `entity`
remove a specific node or relationship indexed against a given key
and with any value
`entity`
remove all occurrences of a specific node or relationship
regardless of key or value
:param cls: the type of indexed entity
:param index: index or index name
:param key: index entry key
:param value: index entry value
:param entity: node or relationship to remove from the index
:return: :class:`.Job`
"""
index = self._index(cls, index)
if key and value and entity:
uri = self._uri_for(index, key, value, remote(entity)._id)
elif key and entity:
uri = self._uri_for(index, key, remote(entity)._id)
elif entity:
uri = self._uri_for(index, remote(entity)._id)
else:
raise TypeError("Illegal parameter combination for index removal")
return self.append_delete(uri)
def test_can_pull_path(self):
alice = Node(name="Alice")
bob = Node(name="Bob")
carol = Node(name="Carol")
dave = Node(name="Dave")
path = Path(alice, "LOVES", bob, Relationship(carol, "HATES", bob),
carol, "KNOWS", dave)
self.graph.create(path)
assert path[0]["amount"] is None
assert path[1]["amount"] is None
assert path[2]["since"] is None
statement = (
"MATCH ()-[ab]->() WHERE id(ab)={ab} "
"MATCH ()-[bc]->() WHERE id(bc)={bc} "
"MATCH ()-[cd]->() WHERE id(cd)={cd} "
"SET ab.amount = 'lots', bc.amount = 'some', cd.since = 1999")
id_0 = remote(path[0])._id
id_1 = remote(path[1])._id
id_2 = remote(path[2])._id
parameters = {"ab": id_0, "bc": id_1, "cd": id_2}
self.graph.run(statement, parameters)
self.graph.pull(path)
assert path[0]["amount"] == "lots"
assert path[1]["amount"] == "some"
assert path[2]["since"] == 1999
def test_can_push_path(self):
alice = Node(name="Alice")
bob = Node(name="Bob")
carol = Node(name="Carol")
dave = Node(name="Dave")
path = Path(alice, "LOVES", bob, Relationship(carol, "HATES", bob),
carol, "KNOWS", dave)
self.graph.create(path)
statement = ("MATCH ()-[ab]->() WHERE id(ab)={ab} "
"MATCH ()-[bc]->() WHERE id(bc)={bc} "
"MATCH ()-[cd]->() WHERE id(cd)={cd} "
"RETURN ab.amount, bc.amount, cd.since")
parameters = {
"ab": remote(path[0])._id,
"bc": remote(path[1])._id,
"cd": remote(path[2])._id
}
path[0]["amount"] = "lots"
path[1]["amount"] = "some"
path[2]["since"] = 1999
ab_amount, bc_amount, cd_since = self.graph.run(statement,
parameters).next()
assert ab_amount is None
assert bc_amount is None
assert cd_since is None
self.graph.push(path)
ab_amount, bc_amount, cd_since = self.graph.run(statement,
parameters).next()
assert ab_amount == "lots"
assert bc_amount == "some"
assert cd_since == 1999
def remove_from_index(self, cls, index, key=None, value=None, entity=None):
""" Remove any nodes or relationships from an index that match a
particular set of criteria. Allowed parameter combinations are:
`key`, `value`, `entity`
remove a specific node or relationship indexed under a given
key-value pair
`key`, `entity`
remove a specific node or relationship indexed against a given key
and with any value
`entity`
remove all occurrences of a specific node or relationship
regardless of key or value
:param cls: the type of indexed entity
:param index: index or index name
:param key: index entry key
:param value: index entry value
:param entity: node or relationship to remove from the index
:return: :class:`.Job`
"""
index = self._index(cls, index)
if key and value and entity:
uri = self._uri_for(index, key, value, remote(entity)._id)
elif key and entity:
uri = self._uri_for(index, key, remote(entity)._id)
elif entity:
uri = self._uri_for(index, remote(entity)._id)
else:
raise TypeError("Illegal parameter combination for index removal")
return self.append_delete(uri)
def __init__(self, graph, path):
self.graph = graph
self.remote = Resource(remote(self.graph.dbms).uri.resolve(path))
try:
self.remote.get()
except GraphError:
raise NotImplementedError("No extension found at path %r on "
"graph <%s>" % (path, remote(self.graph).uri))
def __init__(self, graph, path):
self.graph = graph
self.remote = Resource(remote(self.graph.dbms).uri.resolve(path))
try:
self.remote.get()
except GraphError:
raise NotImplementedError("No extension found at path %r on "
"graph <%s>" %
(path, remote(self.graph).uri))
def test_can_create_relationship(self):
a = Node("Person", name="Alice")
b = Node("Person", name="Bob")
r = Relationship(a, "KNOWS", b, since=1999)
self.graph.create(r)
assert remote(a)
assert remote(b)
assert remote(r)
assert r.start_node() == a
assert r.end_node() == b
def __eq__(self, other):
if not isinstance(other, GraphObject):
return False
remote_self = remote(self.__ogm__.node)
remote_other = remote(other.__ogm__.node)
if remote_self and remote_other:
return remote_self == remote_other
else:
return self.__primarylabel__ == other.__primarylabel__ and \
self.__primarykey__ == other.__primarykey__ and \
self.__primaryvalue__ == other.__primaryvalue__
def __eq__(self, other):
if not isinstance(other, GraphObject):
return False
remote_self = remote(self.__ogm__.node)
remote_other = remote(other.__ogm__.node)
if remote_self and remote_other:
return remote_self == remote_other
else:
return self.__primarylabel__ == other.__primarylabel__ and \
self.__primarykey__ == other.__primarykey__ and \
self.__primaryvalue__ == other.__primaryvalue__
def _index_manager(self, content_type):
""" Fetch the index management resource for the given `content_type`.
:param content_type:
:return:
"""
if content_type is Node:
uri = remote(self.graph).metadata["node_index"]
elif content_type is Relationship:
uri = remote(self.graph).metadata["relationship_index"]
else:
raise TypeError("Indexes can manage either Nodes or Relationships")
return Resource(uri)
def _index_manager(self, content_type):
""" Fetch the index management resource for the given `content_type`.
:param content_type:
:return:
"""
if content_type is Node:
uri = remote(self.graph).metadata["node_index"]
elif content_type is Relationship:
uri = remote(self.graph).metadata["relationship_index"]
else:
raise TypeError("Indexes can manage either Nodes or Relationships")
return Resource(uri)
def test_unique_path_not_unique_raises_cypher_error(self):
graph = self.graph
record = graph.run("CREATE (a), (b) RETURN a, b").next()
parameters = {
"A": remote(record["a"])._id,
"B": remote(record["b"])._id
}
statement = ("MATCH (a) WHERE id(a)={A} MATCH (b) WHERE id(b)={B}"
"CREATE (a)-[:KNOWS]->(b)")
graph.run(statement, parameters)
graph.run(statement, parameters)
statement = ("MATCH (a) WHERE id(a)={A} MATCH (b) WHERE id(b)={B}"
"CREATE UNIQUE (a)-[:KNOWS]->(b)")
with self.assertRaises(ConstraintError):
graph.run(statement, parameters)
def delete_index(self, content_type, index_name):
""" Delete the entire index identified by the type and name supplied.
:param content_type: either :class:`.Node` or
:class:`.Relationship`
:param index_name: the name of the index to delete
:raise LookupError: if the specified index does not exist
"""
if index_name not in self._indexes[content_type]:
self.get_indexes(content_type)
if index_name in self._indexes[content_type]:
index = self._indexes[content_type][index_name]
remote(index).delete()
del self._indexes[content_type][index_name]
else:
raise LookupError("Index not found")
def _related_objects(self):
if self.__related_objects is None:
self.__related_objects = []
remote_node = remote(self.node)
if remote_node:
self.__db_pull__(remote_node.graph)
return self.__related_objects
def __db_delete__(self, tx):
ogm = self.__ogm__
remote_node = remote(ogm.node)
if remote_node:
tx.run("MATCH (a) WHERE id(a) = {x} OPTIONAL MATCH (a)-[r]->() DELETE r DELETE a", x=remote_node._id)
for related_objects in ogm.related.values():
related_objects.clear()
def _related_objects(self):
if self.__related_objects is None:
self.__related_objects = []
remote_node = remote(self.node)
if remote_node:
self.__db_pull__(remote_node.graph)
return self.__related_objects
def __db_delete__(self, tx):
ogm = self.__ogm__
remote_node = remote(ogm.node)
if remote_node:
tx.run("MATCH (a) WHERE id(a) = {x} OPTIONAL MATCH (a)-[r]->() DELETE r DELETE a", x=remote_node._id)
for related_objects in ogm.related.values():
related_objects.clear()
def delete_index(self, content_type, index_name):
""" Delete the entire index identified by the type and name supplied.
:param content_type: either :class:`.Node` or
:class:`.Relationship`
:param index_name: the name of the index to delete
:raise LookupError: if the specified index does not exist
"""
if index_name not in self._indexes[content_type]:
self.get_indexes(content_type)
if index_name in self._indexes[content_type]:
index = self._indexes[content_type][index_name]
remote(index).delete()
del self._indexes[content_type][index_name]
else:
raise LookupError("Index not found")
def __db_push__(self, graph):
related_objects = self._related_objects
tx = graph.begin()
# 1. merge all nodes (create ones that don't)
for related_object, _ in related_objects:
tx.merge(related_object)
tx.process()
# 2a. remove any relationships not in list of nodes
subject_id = remote(self.node)._id
tx.run("MATCH %s WHERE id(a) = {x} AND NOT id(b) IN {y} DELETE _" % self.__relationship_pattern,
x=subject_id, y=[remote(obj.__ogm__.node)._id for obj, _ in related_objects])
# 2b. merge all relationships
for related_object, properties in related_objects:
tx.run("MATCH (a) WHERE id(a) = {x} MATCH (b) WHERE id(b) = {y} "
"MERGE %s SET _ = {z}" % self.__relationship_pattern,
x=subject_id, y=remote(related_object.__ogm__.node)._id, z=properties)
tx.commit()
def test_query_can_return_collection(self):
node = Node()
self.graph.create(node)
statement = "MATCH (a) WHERE id(a)={N} RETURN collect(a) AS a_collection"
params = {"N": remote(node)._id}
cursor = self.graph.run(statement, params)
record = cursor.next()
assert record["a_collection"] == [node]
def test_param_used_once(self):
node = Node()
self.graph.create(node)
statement = "MATCH (a) WHERE id(a)={X} RETURN a"
params = {"X": remote(node)._id}
cursor = self.graph.run(statement, params)
record = cursor.next()
assert record["a"] == node
def test_can_push_relationship(self):
a = Node()
b = Node()
ab = Relationship(a, "KNOWS", b)
self.graph.create(ab)
value = self.graph.evaluate(
"MATCH ()-[ab:KNOWS]->() WHERE id(ab)={i} "
"RETURN ab.since",
i=remote(ab)._id)
assert value is None
ab["since"] = 1999
self.graph.push(ab)
value = self.graph.evaluate(
"MATCH ()-[ab:KNOWS]->() WHERE id(ab)={i} "
"RETURN ab.since",
i=remote(ab)._id)
assert value == 1999
def add(self, key, value, entity):
""" Add an entity to this index under the `key`:`value` pair supplied.
Note that while Neo4j indexes allow multiple entities to be added under
a particular key:value, the same entity may only be represented once;
this method is therefore idempotent.
:param key:
:param value:
:param entity:
"""
remote(self).post({
"key": key,
"value": value,
"uri": remote(entity).uri.string,
})
return entity
def add(self, key, value, entity):
""" Add an entity to this index under the `key`:`value` pair supplied.
Note that while Neo4j indexes allow multiple entities to be added under
a particular key:value, the same entity may only be represented once;
this method is therefore idempotent.
:param key:
:param value:
:param entity:
"""
remote(self).post({
"key": key,
"value": value,
"uri": remote(entity).uri.string,
})
return entity
def test_param_used_twice(self):
node = Node()
self.graph.create(node)
statement = "MATCH (a) WHERE id(a)={X} MATCH (b) WHERE id(b)={X} RETURN a, b"
params = {"X": remote(node)._id}
record = self.graph.run(statement, params).next()
assert record["a"] == node
assert record["b"] == node
def __db_push__(self, graph):
related_objects = self._related_objects
tx = graph.begin()
# 1. merge all nodes (create ones that don't)
for related_object, _ in related_objects:
tx.merge(related_object)
tx.process()
# 2a. remove any relationships not in list of nodes
subject_id = remote(self.node)._id
tx.run("MATCH %s WHERE id(a) = {x} AND NOT id(b) IN {y} DELETE _" % self.__relationship_pattern,
x=subject_id, y=[remote(obj.__ogm__.node)._id for obj, _ in related_objects])
# 2b. merge all relationships
for related_object, properties in related_objects:
tx.run("MATCH (a) WHERE id(a) = {x} MATCH (b) WHERE id(b) = {y} "
"MERGE %s SET _ = {z}" % self.__relationship_pattern,
x=subject_id, y=remote(related_object.__ogm__.node)._id, z=properties)
tx.commit()
def __primaryvalue__(self):
node = self.__ogm__.node
primary_key = self.__primarykey__
if primary_key == "__id__":
remote_node = remote(node)
return remote_node._id if remote_node else None
else:
return node[primary_key]
def __primaryvalue__(self):
node = self.__ogm__.node
primary_key = self.__primarykey__
if primary_key == "__id__":
remote_node = remote(node)
return remote_node._id if remote_node else None
else:
return node[primary_key]
def __init__(self, graph, name):
self.graph = graph
self.name = name
remote_graph = remote(self.graph)
extensions = remote_graph.metadata["extensions"]
try:
self.resources = {key: Resource(value) for key, value in extensions[self.name].items()}
except KeyError:
raise LookupError("No plugin named %r found on graph <%s>" % (self.name, remote_graph.uri))
def __db_pull__(self, graph):
ogm = self.__ogm__
if not remote(ogm.node):
selector = GraphObjectSelector(self.__class__, graph)
selector._selection_class = NodeSelection
ogm.node = selector.select(self.__primaryvalue__).first()
graph.pull(ogm.node)
for related_objects in ogm.related.values():
related_objects.__db_pull__(graph)
def test_query(self):
a, b, ab = self.alice_and_bob
statement = ("MATCH (a) WHERE id(a)={A} "
"MATCH (b) WHERE id(b)={B} "
"MATCH (a)-[ab:KNOWS]->(b) "
"RETURN a, b, ab, a.name AS a_name, b.name AS b_name")
records = list(
self.graph.run(statement, {
"A": remote(a)._id,
"B": remote(b)._id
}))
assert len(records) == 1
for record in records:
assert isinstance(record["a"], Node)
assert isinstance(record["b"], Node)
assert isinstance(record["ab"], Relationship)
assert record["a_name"] == "Alice"
assert record["b_name"] == "Bob"
def __db_pull__(self, graph):
ogm = self.__ogm__
if not remote(ogm.node):
selector = GraphObjectSelector(self.__class__, graph)
selector._selection_class = NodeSelection
ogm.node = selector.select(self.__primaryvalue__).first()
graph.pull(ogm.node)
for related_objects in ogm.related.values():
related_objects.__db_pull__(graph)
def test_query_can_return_path(self):
a, b, ab = self.alice_and_bob
statement = ("MATCH (a) WHERE id(a)={A} "
"MATCH (b) WHERE id(b)={B} "
"MATCH p=((a)-[ab:KNOWS]->(b)) "
"RETURN p")
records = list(
self.graph.run(statement, {
"A": remote(a)._id,
"B": remote(b)._id
}))
assert len(records) == 1
for record in records:
assert isinstance(record["p"], Path)
nodes = record["p"].nodes()
assert len(nodes) == 2
assert nodes[0] == a
assert nodes[1] == b
assert record["p"][0].type() == "KNOWS"
def test_can_graph_pull_node(self):
alice_1 = Node()
alice_2 = Node("Person", name="Alice")
self.graph.create(alice_2)
assert set(alice_1.labels()) == set()
assert dict(alice_1) == {}
alice_1.__remote__ = RemoteEntity(remote(alice_2).uri)
self.graph.pull(alice_1)
assert set(alice_1.labels()) == set(alice_2.labels())
assert dict(alice_1) == dict(alice_2)
def test_param_reused_once_after_with_statement(self):
a, b, ab = self.alice_and_bob
query = ("MATCH (a) WHERE id(a)={A} "
"MATCH (a)-[:KNOWS]->(b) "
"WHERE a.age > {min_age} "
"WITH a "
"MATCH (a)-[:KNOWS]->(b) "
"WHERE b.age > {min_age} "
"RETURN b")
params = {"A": remote(a)._id, "min_age": 50}
record = self.graph.run(query, params).next()
assert record["b"] == b
def __init__(self, graph, name):
self.graph = graph
self.name = name
remote_graph = remote(self.graph)
extensions = remote_graph.metadata["extensions"]
try:
self.resources = {
key: Resource(value)
for key, value in extensions[self.name].items()
}
except KeyError:
raise LookupError("No plugin named %r found on graph <%s>" %
(self.name, remote_graph.uri))
def test_param_used_thrice(self):
node = Node()
self.graph.create(node)
statement = "MATCH (a) WHERE id(a)={X} " \
"MATCH (b) WHERE id(b)={X} " \
"MATCH (c) WHERE id(c)={X} " \
"RETURN a, b, c"
params = {"X": remote(node)._id}
cursor = self.graph.run(statement, params)
record = cursor.next()
assert record["a"] == node
assert record["b"] == node
assert record["c"] == node
def __db_push__(self, graph):
ogm = self.__ogm__
node = ogm.node
if remote(node):
graph.push(node)
else:
primary_key = getattr(node, "__primarykey__", "__id__")
if primary_key == "__id__":
graph.create(node)
else:
graph.merge(node)
for related_objects in ogm.related.values():
related_objects.__db_push__(graph)
def correct_name(graph):
tmps1 = time.time()
statement = 'MATCH (labels:Label) '\
'RETURN labels'
tx = graph.begin()
cursor = tx.run(statement)
for record in cursor:
name = str(dict(record[0])["name"])
(user_defined_name, modified) = correctPersonName(name)
if modified is True:
statement = 'MATCH (clus_lab:Label) '\
'WHERE ID(clus_lab)=' + str(remote(record[0])._id) + \
' MATCH (algo:Algo {name:"' + 'user_defined' + '"}) '\
'MATCH (clus:Cluster)-[:LABEL]->(clus_lab) '\
'MERGE (user_lab:Label {name:"' + user_defined_name + '"}) '\
'MERGE (user_lab)-[:IDENTIFY_BY]->(algo) '\
'CREATE (user_clus:User_Defined_Cluster) '\
'CREATE (user_clus)-[:LABEL]->(user_lab) '\
'CREATE (user_clus)-[:CLUSTERED]->(clus) '\
'CREATE (user_clus)-[:GENERATED_BY]->(algo) '\
'RETURN user_clus,clus '
cursor2 = tx.run(statement)
for record2 in cursor2:
statement = 'MATCH (clus:Cluster) '\
'WHERE ID(clus)=' + str(remote(record2[1])._id) + \
' MATCH (clus)-[:CLUSTERED]->(tracks:Track) '\
'RETURN tracks'
cursor3 = tx.run(statement)
for track in cursor3:
statement = 'MATCH (user_clus:User_Defined_Cluster) '\
'WHERE ID(user_clus)=' + str(remote(record2[0])._id) + \
' MATCH (track:Track) '\
'WHERE ID(track) =' + str(remote(track[0])._id) + \
' CREATE (user_clus)-[:CLUSTERED]->(track)'
tx.run(statement)
tx.commit()
tmps2 = time.time() - tmps1
print "Done in " + str(int(tmps2)) + " second(s)."
def __db_push__(self, graph):
ogm = self.__ogm__
node = ogm.node
if remote(node):
graph.push(node)
else:
primary_key = getattr(node, "__primarykey__", "__id__")
if primary_key == "__id__":
graph.create(node)
else:
graph.merge(node)
for related_objects in ogm.related.values():
related_objects.__db_push__(graph)
def load_texture(graph,cluster): tx = graph.begin() image_str = "" statement = 'MATCH (n:Cluster) '\ 'WHERE Not (n)-[:CLUSTERED]-() '\ 'MATCH (n)-[r]->() '\ 'DELETE r ' graph.run(statement) statement = 'MATCH (n:Cluster) '\ 'WHERE Not (n)-[:CLUSTERED]-() '\ 'DELETE n ' graph.run(statement) if type(cluster) is str : sentence = cluster else: print cluster sentence = str(remote(cluster)._id) print sentence statement = 'MATCH (clus) '\ 'WHERE ID(clus)=' + sentence + \ ' MATCH (clus)-[:CLUSTERED]->(track:Track) '\ 'WITH track LIMIT 1 '\ 'MATCH (track)<-[:TRACK]-()<-[:COMPOSED_OF]-(:Jt)-[:BROADCAST_ON]->(day:Day)<-[:DAY]-(month:Month)<-[:MONTH]-(year:Year) '\ 'RETURN track.num_shot,track.num_track,day.name,month.name,year.name LIMIT 1' cursor = tx.run(statement) for record in cursor: print record year = str(record[4]) month = str(record[3]) day = str(record[2]) num_shot = str(record[0]) num_track = str(record[1]) if len(day) == 1: day = "0" + day if len(month) == 1: month = "0" + month f = open(texture_path_local + "image_track_" + str(year) +".json") json_texture_year = json.load(f) f.close() image_str = str(json_texture_year[month + "_" + day][num_shot + "_" + num_track]) statement = 'MATCH (clus) '\ 'WHERE ID(clus)=' + sentence +\ ' SET clus.texture ="' + image_str + '" '\ 'RETURN clus.texture ' record = graph.run(statement) tx.commit return image_str
def append_node(i, node):
remote_node = remote(node)
if node is None:
path.append("(n{0})".format(i))
values.append("n{0}".format(i))
elif remote_node:
path.append("(n{0})".format(i))
initial_match_clause.append("MATCH (n{0}) WHERE id(n{0})={{i{0}}}".format(i))
params["i{0}".format(i)] = remote_node._id
values.append("n{0}".format(i))
else:
path.append("(n{0} {{p{0}}})".format(i))
params["p{0}".format(i)] = dict(node)
values.append("n{0}".format(i))
def cursor2json(cursor):
# Same pseudo-random sequence for each exec: allows stable layout on the UI
random.seed(0)
g = {"nodes": [], "edges": []}
done = set()
for res in cursor:
for node in res.nodes():
ref = remote(node).ref
if ref not in done:
labels = list(node.labels())
g["nodes"].append(node2json(ref, labels, dict(node)))
done.add(ref)
for edge in res.relationships():
ref = remote(edge).ref
if ref not in done:
from_ref = remote(edge.start_node()).ref
to_ref = remote(edge.end_node()).ref
g["edges"].append(edge2json(ref, from_ref, to_ref,
[edge.type()], dict(edge)))
done.add(ref)
return g
def _uri_for(self, resource, *segments, **kwargs):
""" Return a relative URI in string format for the entity specified
plus extra path segments.
"""
if isinstance(resource, int):
uri = "{{{0}}}".format(resource)
elif isinstance(resource, NodePointer):
uri = "{{{0}}}".format(resource.address)
elif isinstance(resource, Job):
uri = "{{{0}}}".format(self.find(resource))
else:
remote_resource = remote(resource)
remote_graph = remote(remote_resource.graph)
graph_uri = remote_graph.uri.string
entity_uri = remote_resource.uri.string
uri = entity_uri[len(graph_uri):]
if segments:
if not uri.endswith("/"):
uri += "/"
uri += "/".join(map(percent_encode, segments))
query = kwargs.get("query")
if query is not None:
uri += "?" + query
return uri
def _uri_for(self, resource, *segments, **kwargs):
""" Return a relative URI in string format for the entity specified
plus extra path segments.
"""
if isinstance(resource, int):
uri = "{{{0}}}".format(resource)
elif isinstance(resource, NodePointer):
uri = "{{{0}}}".format(resource.address)
elif isinstance(resource, Job):
uri = "{{{0}}}".format(self.find(resource))
else:
remote_resource = remote(resource)
remote_graph = remote(remote_resource.graph)
graph_uri = remote_graph.uri.string
entity_uri = remote_resource.uri.string
uri = entity_uri[len(graph_uri):]
if segments:
if not uri.endswith("/"):
uri += "/"
uri += "/".join(map(percent_encode, segments))
query = kwargs.get("query")
if query is not None:
uri += "?" + query
return uri
def add_if_none(self, key, value, entity):
""" Add an entity to this index under the `key`:`value` pair
supplied if no entry already exists at that point.
If added, this method returns the entity, otherwise :py:const:`None`
is returned.
"""
rs = self._get_or_create.post({
"key": key,
"value": value,
"uri": remote(entity).uri.string,
})
if rs.status_code == CREATED:
return entity
else:
return None
def __init__(self, content_type, uri, name=None):
self._content_type = content_type
key_value_pos = uri.find("/{key}/{value}")
if key_value_pos >= 0:
self._searcher = ResourceTemplate(uri)
self.__remote__ = Resource(uri[:key_value_pos])
else:
self.__remote__ = Resource(uri)
self._searcher = ResourceTemplate(uri.string + "/{key}/{value}")
uri = remote(self).uri
self._create_or_fail = Resource(uri.resolve("?uniqueness=create_or_fail"))
self._get_or_create = Resource(uri.resolve("?uniqueness=get_or_create"))
self._query_template = ResourceTemplate(uri.string + "{?query,order}")
self._name = name or uri.path.segments[-1]
self.__searcher_stem_cache = {}
self.graph = Graph(uri.resolve("/db/data/").string)
def __db_merge__(self, tx, primary_label=None, primary_key=None):
# TODO make atomic
graph = tx.graph
ogm = self.__ogm__
node = ogm.node
if primary_label is None:
primary_label = getattr(node, "__primarylabel__", None)
if primary_key is None:
primary_key = getattr(node, "__primarykey__", "__id__")
if not remote(node):
if primary_key == "__id__":
node.add_label(primary_label)
graph.create(node)
else:
graph.merge(node, primary_label, primary_key)
for related_objects in ogm.related.values():
related_objects.__db_push__(graph)
def uri_string(self):
""" The fully resolved URI string for this target.
:rtype: string
"""
if isinstance(self.entity, int):
uri_string = "{%d}" % self.entity
elif isinstance(self.entity, NodePointer):
uri_string = "{%d}" % self.entity.address
else:
remote_entity = remote(self.entity)
if remote_entity:
uri_string = remote_entity.ref
else:
uri_string = ustr(self.entity)
if self.segments:
if not uri_string.endswith("/"):
uri_string += "/"
uri_string += "/".join(map(percent_encode, self.segments))
return uri_string
def remove(self, key=None, value=None, entity=None):
""" Remove any entries from the index which match the parameters
supplied. The allowed parameter combinations are:
`key`, `value`, `entity`
remove a specific entity indexed under a given key-value pair
`key`, `value`
remove all entities indexed under a given key-value pair
`key`, `entity`
remove a specific entity indexed against a given key but with
any value
`entity`
remove all occurrences of a specific entity regardless of
key and value
"""
if key and value and entity:
t = ResourceTemplate(remote(self).uri.string + "/{key}/{value}/{entity}")
t.expand(key=key, value=value, entity=remote(entity)._id).delete()
elif key and value:
uris = [
URI(remote(entity).metadata["indexed"])
for entity in self.get(key, value)
]
batch = ManualIndexWriteBatch(self.graph)
for uri in uris:
batch.append_delete(uri)
batch.run()
elif key and entity:
t = ResourceTemplate(remote(self).uri.string + "/{key}/{entity}")
t.expand(key=key, entity=remote(entity)._id).delete()
elif entity:
t = ResourceTemplate(remote(self).uri.string + "/{entity}")
t.expand(entity=remote(entity)._id).delete()
else:
raise TypeError("Illegal parameter combination for index removal")
def __init__(self, graph):
self.graph = graph
self.runner = BatchRunner(remote(self.graph).metadata["batch"])
self.jobs = []
def _get_ref(elt, cls, props):
return remote(elt).ref if isinstance(elt, cls) else props.pop("_ref")
def _get_ref(elt, props):
if isinstance(elt, Node):
return int(remote(elt).ref.split('/', 1)[-1])
else:
return elt["metadata"]["id"]
def __repr__(self):
return "{0}({1}, {2})".format(
self.__class__.__name__,
self._content_type.__name__,
repr(remote(self).uri.string)
)
