Getting started

svn export https://svn.neo4j.org/components/neo4j.py/trunk neo4j-python

sudo python setup.py install

svn export https://svn.neo4j.org/components/neo4j.py/trunk neo4j-python
cd neo4j-python
sudo jython setup.py install

running install_egg_info
Creating X:\<PATH_TO>\jython\Lib\site-packages\
error: X:\<PATH_TO>\jython\Lib\site-packages\: couldn't make directories

graphdb = neo4j.GraphDatabase("/neo/db/path",
                              classpath=["/a/newer/kernel.jar"],
                              jvm="/usr/lib/jvm.so")

Package content

Some of the content of this package is loaded lazily. When the package is first imported The guaranteed content is GraphDatabase and the API required for defining Traversals, the Exceptions might not be available. When the first GraphDatabase has been initialized the rest of the package is loaded.

The content of this module is:

GraphDatabase

factory for creating a Neo4j Graph Database.

Traversal

Base for defining traversals over the node space.

NotFoundError

Exception that is raised when a node, relationship or property could not be found.

NotInTransactionError

Exception that is raised when the node space is manipulated outside of a transaction.

The rest of the content is used for defining Traversals

Incoming

Defines a relationship type traversable in the incoming direction.

Outgoing

Defines a relationship type traversable in the outgoing direction.

Undirected

Defines a relationship type traversable in any direction.

BREADTH_FIRST

Defines a traversal in breadth first order.

DEPTH_FIRST

Defines a traversal in depth first order.

RETURN_ALL_NODES

Defines a traversal to return all nodes.

RETURN_ALL_BUT_START_NODE

Defines traversal to return all but first node.

StopAtDepth(x)

Defines a traversal to only traverse to depth=x.

STOP_AT_END_OF_GRAPH

Defines a traversal to traverse the entire subgraph.

Nodes, Relationships and Properties

Creating a node:

n = graphdb.node()

Specify properties for new node:

n = graphdb.node(color="Red", widht=16, height=32)

Accessing node by id:

n17 = graphdb.node[14]

Accessing properties:

value = e['key'] # get property value
e['key'] = value # set property value
del e['key']     # remove property value

Create relationship:

n1.Knows(n2)

Any name that does not mean anything for the node class can be used as relationship type:

n1.some_reltionship_type(n2)
n1.CASE_MATTERS(n2)

Specify properties for new relationships:

n1.Knows(n2, since=123456789,
             introduced_at="Christmas party")

Indexes

Get index:

index = graphdb.index("index name")

Create index:

index = graphdb.index("some index", create=True)

If an index is created that already exists, the existing index will not be replaced, and the existing index will be returned. The create flag is a measure to help finding spelling errors in index names.

Using indexes:

index['value'] = node
node = index['value']
del index['value']

Keep in mind that when updating the index with a new value (f.ex. when a property value on a node changes) remember to remove the old value from the index as well, else both values will be indexed.

Using indexes as multi value indexes:

multiIndex.add('value', node)
for node in multiIndex.nodes('value'):
    doStuffWith(node)

Traversals

Traversals are defined by creating a class that extends neo4j.Traversal, and possibly previously defined traversals as well. (Note that neo4j.Traversal always needs to be a direct parent of a traversal class.) A traversal class needs to define the following members:

types

A list of relationship types to be traversed in the traversal. These are created using Incoming, Outgoing and Undirected.

order

The order in which the nodes of the graph are to be traversed. Valid values are BREADTH_FIRST and DEPTH_FIRST

stop

Definition of when the traversal should stop. Valid values are STOP_AT_DEPTH_ONE and STOP_AT_END_OF_GRAPH Alternatively the traversal class may define a more advanced stop predicate in the form of a method called 'isStopNode'.

returnable

Definition of which nodes the traversal should yield. Valid values are RETURN_ALL_NODES and RETURN_ALL_BUT_START_NODE. Alternatively the traversal class may define a more advanced returnable predicate in the form of a method called 'isReturnable'.

To define more advanced stop and returnable predicates the traversal class can define the methods 'isStopNode' and 'isReturnable' respectively. These methods should accept one argument (in addition to self), a traversal position. The position is essentially a node, but with the following extra properties:

last_relationship

The relationship that was traversed to reach this node. This is None for the start node.

is_start

True if this is the start node, False otherwise.

previous_node

The node from which this node was reached. This is None for the start node.

depth

The depth at which this node was found in the traversal. This is 0 for the start node.

returned_count

The number of returned nodes so far.

Nodes yielded by a traversal has an additional 'depth' attribute with the same semantics as above.

class Hackers(neo4j.Traversal):
    types = [
        neo4j.Outgoing.knows,
        neo4j.Outgoing.coded_by,
        ]
    order = neo4j.DEPTH_FIRST
    stop = neo4j.STOP_AT_END_OF_GRAPH

    def isReturnable(self, position):
        return (not position.is_start
                and position.last_relationship.type == 'coded_by')

# Usage:
for hacker_node in Hackers(traversal_start_node):
    # do stuff with hacker_node

Further information

For more information about Neo4j, please visit http://neo4j.org/

Please direct questions and discussions about Neo4j.py to the Neo4j mailing list: https://lists.neo4j.org/mailman/listinfo/user

Copyright (c) 2008-2010 "Neo Technology," Network Engine for Objects in Lund AB http://neotechnology.com