def load_node(node_id):
""" Return a SqNode subclass for the given id.
Wrap a call to a Graph API that returns a GraphNode and call on
sqfactory to parse it into a SqNode subclass.
Required:
id node_id id of node to fetch
Returns:
SqNode single instance of concrete SqNode subclass
"""
node = None
try:
graph_node = reader.get_node(node_id)
if graph_node:
factory = sqfactory.get_factory()
node = factory.construct_node_and_edges(graph_node)
except GraphOutputError as e:
#logger.debug(e.reason)
print e.reason
return node
def load_edges(node_id):
""" Return a dict of SqEdge subclasses for the given SqNode ID.
Wrap a call to a Graph API that returns a GraphEdge and call on
sqfactory to parse it into a SqEdge subclass.
Required:
id node_id id of edge to fetch
Returns:
dict concrete SqEdge subclasses keyed on ID
"""
edges = None
try:
graph_node = reader.get_node(node_id)
edges = {}
factory = sqfactory.get_factory()
for id, graph_edge in graph_node.edges().items():
edges[id] = factory.construct_edge(graph_edge)
except GraphOutputError as e:
#logger.debug(e.reason)
print e.reason
return edges
def load_edge(edge_id):
""" Return a SqEdge subclass for the given id.
Wrap a call to a Graph API that returns a GraphEdge and call on
sqfactory to parse it into a SqEdge subclass.
Required:
id edge_id id of edge to fetch
Returns:
SqEdge single instance of concrete SqEdge subclass
"""
edge = None
try:
factory = sqfactory.get_factory()
edge = factory.construct_edge(reader.get_edge(edge_id))
except GraphOutputError as e:
#logger.debug(e.reason)
print e.reason
return edge
def load_neighbors(
node_id,
edge_type_pruner=None,
node_type_return_filter=None):
""" Load a SqNode and its specified SqEdges and neighbor SqNodes.
Required:
id node_id SqNode id
Optional:
list edge_type_pruner list of SqEdge types to traverse
list node_type_return_filter list of SqNode types to return
Returns:
tuple (SqNode, dict) => (start, neighbors)
"""
node = None
neighbor_nodes = None
try:
# get node, outgoing edges, neighbor nodes
graph_path = reader.get_path_to_neighbor_nodes(
node_id,
edge_type_pruner,
node_type_return_filter)
# load nodes and edges into SqNodes and SqEdges
factory = sqfactory.get_factory()
node = factory.construct_node_and_edges(graph_path.get_start_node())
neighbor_nodes = {}
for id, graph_node in graph_path.get_neighbor_nodes().items():
neighbor_nodes[id] = factory.construct_node_and_edges(graph_node)
except GraphOutputError as e:
#logger.debug(e.reason)
print e.reason
# TODO: this only works for depth-1 queries because of graph fan-out, so
# we need something different for queries of depth-2 and up.
return (node, neighbor_nodes)
def create_node_and_edges(prototype_node, prototype_edges):
""" Create a new SqNode and its SqEdges in the database.
Required:
GraphProtoNode prototype_node unwritten version of GraphNode
list prototype_edges unwritten GraphEdges as GraphProtoEdges
Return:
SqNode SqNode created or None on failure
"""
node = None
try:
# create and store a new GraphNode
new_node = create_node(prototype_node)
# point to/from id in GraphEdges-to-be at the new GraphNode
for prototype_edge in prototype_edges:
prototype_edge.set_node_id(new_node.id())
# TODO: raise an error when incomplete Edge prototypes [meaning, ones
# missing a to/from node] are passed to create_edge(). this may already
# be happening, but it certainly isn't a specific enough error.
# create and store new GraphEdges to/from the new GraphNode
new_edges = create_edges(prototype_edges)
# the new GraphNode should contain the new GraphEdges
new_node.set_edges(new_edges)
# load the new GraphNode and GraphEdges into SqObjects
factory = sqfactory.get_factory()
node = factory.construct_node_and_edges(new_node)
except GraphInputError as e:
# logger.debug(e.reason)
print e.reason
return node
def load_nodes_by_property(key, value, node_type_return_filter=None):
""" Return a list of SqNodes for a given property and node type.
Wrap a call to a Graph API that returns a GraphNode and call on
sqfactory to parse it into a SqNode subclass.
Ideally, this property would be indexed in the database. In fact,
the underlying graph or data layer may impose this restriction on
queries and throw an error if no index exists for this property.
Required:
str key property key to look up
mixed value property value to look up
Optional:
list node_type_return_filter list of SqNode types to return
Returns:
dict SqNodes keyed on ID (or None)
"""
nodes = None
try:
graph_nodes = reader.get_nodes_by_index(
key,
value,
node_type_return_filter)
nodes = {}
factory = sqfactory.get_factory()
for id, graph_node in graph_nodes.items():
nodes[id] = factory.construct_node_and_edges(graph_node)
except GraphOutputError as e:
#logger.debug(e.reason)
print e.reason
return nodes
