Merge 1.0

Author: RagnarW

README.rst

@@ -28,10 +28,10 @@ Example Usage
     driver = GraphDatabase.driver("bolt://localhost")
     session = driver.session()
     session.run("CREATE (a:Person {name:'Bob'})")
-    cursor = session.run("MATCH (a:Person) RETURN a.name AS name")
-    while cursor.next()
-        print(cursor["name"])
-    cursor.close()
+    result = session.run("MATCH (a:Person) RETURN a.name AS name")
+    for record in result:
+        print(record["name"])
+    result.close()
     session.close()
 
 

docs/source/index.rst

@@ -24,15 +24,13 @@ Session API
 .. autoclass:: neo4j.v1.Record
    :members:
 
-.. autofunction:: neo4j.v1.record
-
-.. autoclass:: neo4j.v1.ResultCursor
+.. autoclass:: neo4j.v1.StatementResult
    :members:
 
 .. autoclass:: neo4j.v1.ResultSummary
    :members:
 
-.. autoclass:: neo4j.v1.StatementStatistics
+.. autoclass:: neo4j.v1.Counters
    :members:
 
 

example.py

@@ -18,9 +18,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from neo4j.v1.session import GraphDatabase
+from neo4j.v1.session import GraphDatabase, basic_auth
 
-driver = GraphDatabase.driver("bolt://localhost")
+
+driver = GraphDatabase.driver("bolt://localhost", auth=basic_auth("neo4j", "neo4j"))
 session = driver.session()
 
 session.run("MERGE (a:Person {name:'Alice'})")

examples/test_examples.py

@@ -19,17 +19,26 @@
 # limitations under the License.
 
 
-from unittest import TestCase
+from unittest import skip
 
+from neo4j.v1 import TRUST_ON_FIRST_USE, TRUST_SIGNED_CERTIFICATES
+from test.util import ServerTestCase
+
+# Do not change the contents of this tagged section without good reason*
 # tag::minimal-example-import[]
-from neo4j.v1 import GraphDatabase
+from neo4j.v1 import GraphDatabase, basic_auth
 # end::minimal-example-import[]
+# (* "good reason" is defined as knowing what you are doing)
+
+
+auth_token = basic_auth("neo4j", "password")
 
 
-class FreshDatabaseTestCase(TestCase):
+class FreshDatabaseTestCase(ServerTestCase):
 
     def setUp(self):
-        session = GraphDatabase.driver("bolt://localhost").session()
+        ServerTestCase.setUp(self)
+        session = GraphDatabase.driver("bolt://localhost", auth=auth_token).session()
         session.run("MATCH (n) DETACH DELETE n")
         session.close()
 
@@ -38,14 +47,14 @@ class MinimalWorkingExampleTestCase(FreshDatabaseTestCase):
 
     def test_minimal_working_example(self):
         # tag::minimal-example[]
-        driver = GraphDatabase.driver("bolt://localhost")
+        driver = GraphDatabase.driver("bolt://localhost", auth=basic_auth("neo4j", "password"))
         session = driver.session()
 
-        session.run("CREATE (neo:Person {name:'Neo', age:23})")
+        session.run("CREATE (a:Person {name:'Arthur', title:'King'})", )
 
-        cursor = session.run("MATCH (p:Person) WHERE p.name = 'Neo' RETURN p.age")
-        while cursor.next():
-            print("Neo is %d years old." % cursor["p.age"])
+        result = session.run("MATCH (a:Person) WHERE a.name = 'Arthur' RETURN a.name AS name, a.title AS title")
+        for record in result:
+            print("%s %s" % (record["title"], record["name"]))
 
         session.close()
         # end::minimal-example[]
@@ -55,7 +64,7 @@ class ExamplesTestCase(FreshDatabaseTestCase):
 
     def test_construct_driver(self):
         # tag::construct-driver[]
-        driver = GraphDatabase.driver("bolt://localhost")
+        driver = GraphDatabase.driver("bolt://localhost", auth=basic_auth("neo4j", "password"))
         # end::construct-driver[]
         return driver
 
@@ -67,124 +76,123 @@ def test_configuration(self):
 
     def test_tls_require_encryption(self):
         # tag::tls-require-encryption[]
-        # TODO: Unfortunately, this feature is not yet implemented for Python
-        pass
+        driver = GraphDatabase.driver("bolt://localhost", auth=basic_auth("neo4j", "password"), encrypted=True)
         # end::tls-require-encryption[]
 
     def test_tls_trust_on_first_use(self):
         # tag::tls-trust-on-first-use[]
-        # TODO: Unfortunately, this feature is not yet implemented for Python
-        pass
+        driver = GraphDatabase.driver("bolt://localhost", auth=basic_auth("neo4j", "password"), encrypted=True, trust=TRUST_ON_FIRST_USE)
         # end::tls-trust-on-first-use[]
+        assert driver
 
+    @skip("testing verified certificates not yet supported ")
     def test_tls_signed(self):
         # tag::tls-signed[]
-        # TODO: Unfortunately, this feature is not yet implemented for Python
-        pass
+        driver = GraphDatabase.driver("bolt://localhost", auth=basic_auth("neo4j", "password"), encrypted=True, trust=TRUST_SIGNED_CERTIFICATES)
         # end::tls-signed[]
+        assert driver
 
     def test_statement(self):
-        driver = GraphDatabase.driver("bolt://localhost")
+        driver = GraphDatabase.driver("bolt://localhost", auth=auth_token)
         session = driver.session()
         # tag::statement[]
-        session.run("CREATE (person:Person {name: {name}})", {"name": "Neo"}).close()
+        result = session.run("CREATE (person:Person {name: {name}})", {"name": "Arthur"})
         # end::statement[]
+        result.consume()
         session.close()
 
     def test_statement_without_parameters(self):
-        driver = GraphDatabase.driver("bolt://localhost")
+        driver = GraphDatabase.driver("bolt://localhost", auth=auth_token)
         session = driver.session()
         # tag::statement-without-parameters[]
-        session.run("CREATE (person:Person {name: 'Neo'})").close()
+        result = session.run("CREATE (person:Person {name: 'Arthur'})")
         # end::statement-without-parameters[]
+        result.consume()
         session.close()
 
-    def test_result_cursor(self):
-        driver = GraphDatabase.driver("bolt://localhost")
+    def test_result_traversal(self):
+        driver = GraphDatabase.driver("bolt://localhost", auth=auth_token)
         session = driver.session()
-        # tag::result-cursor[]
-        search_term = "hammer"
-        cursor = session.run("MATCH (tool:Tool) WHERE tool.name CONTAINS {term} "
-                             "RETURN tool.name", {"term": search_term})
-        print("List of tools called %r:" % search_term)
-        while cursor.next():
-            print(cursor["tool.name"])
-        # end::result-cursor[]
+        # tag::result-traversal[]
+        search_term = "sword"
+        result = session.run("MATCH (weapon:Weapon) WHERE weapon.name CONTAINS {term} "
+                             "RETURN weapon.name", {"term": search_term})
+        print("List of weapons called %r:" % search_term)
+        for record in result:
+            print(record["weapon.name"])
+        # end::result-traversal[]
         session.close()
 
-    def test_cursor_nesting(self):
-        driver = GraphDatabase.driver("bolt://localhost")
+    def test_result_retention(self):
+        driver = GraphDatabase.driver("bolt://localhost", auth=auth_token)
+        # tag::retain-result[]
         session = driver.session()
-        # tag::retain-result-query[]
-        cursor = session.run("MATCH (person:Person) WHERE person.dept = {dept} "
-                             "RETURN id(person) AS minion", {"dept": "IT"})
-        while cursor.next():
-            session.run("MATCH (person) WHERE id(person) = {id} "
-                        "MATCH (boss:Person) WHERE boss.name = {boss} "
-                        "CREATE (person)-[:REPORTS_TO]->(boss)", {"id": cursor["minion"], "boss": "Bob"})
-        # end::retain-result-query[]
+        result = session.run("MATCH (knight:Person:Knight) WHERE knight.castle = {castle} "
+                             "RETURN knight.name AS name", {"castle": "Camelot"})
+        retained_result = list(result)
         session.close()
+        for record in retained_result:
+            print("%s is a knight of Camelot" % record["name"])
+        # end::retain-result[]
+        assert isinstance(retained_result, list)
 
-    def test_result_retention(self):
-        driver = GraphDatabase.driver("bolt://localhost")
+    def test_nested_statements(self):
+        driver = GraphDatabase.driver("bolt://localhost", auth=auth_token)
         session = driver.session()
-        # tag::retain-result-process[]
-        cursor = session.run("MATCH (person:Person) WHERE person.dept = {dept} "
-                             "RETURN id(person) AS minion", {"dept": "IT"})
-        minion_records = list(cursor.stream())
-
-        for record in minion_records:
-            session.run("MATCH (person) WHERE id(person) = {id} "
-                        "MATCH (boss:Person) WHERE boss.name = {boss} "
-                        "CREATE (person)-[:REPORTS_TO]->(boss)", {"id": record["minion"], "boss": "Bob"})
-        # end::retain-result-process[]
+        # tag::nested-statements[]
+        result = session.run("MATCH (knight:Person:Knight) WHERE knight.castle = {castle} "
+                             "RETURN id(knight) AS knight_id", {"castle": "Camelot"})
+        for record in result:
+            session.run("MATCH (knight) WHERE id(knight) = {id} "
+                        "MATCH (king:Person) WHERE king.name = {king} "
+                        "CREATE (knight)-[:DEFENDS]->(king)", {"id": record["knight_id"], "king": "Arthur"})
+        # end::nested-statements[]
         session.close()
 
     def test_transaction_commit(self):
-        driver = GraphDatabase.driver("bolt://localhost")
+        driver = GraphDatabase.driver("bolt://localhost", auth=auth_token)
         session = driver.session()
         # tag::transaction-commit[]
         tx = session.begin_transaction()
-        tx.run("CREATE (p:Person {name: 'The One'})")
+        tx.run("CREATE (:Person {name: 'Guinevere'})")
         tx.commit()
         # end::transaction-commit[]
-        cursor = session.run("MATCH (p:Person {name: 'The One'}) RETURN count(p)")
-        assert cursor.next()
-        assert cursor["count(p)"] == 1
-        assert cursor.at_end()
+        result = session.run("MATCH (p:Person {name: 'Guinevere'}) RETURN count(p)")
+        record = next(result)
+        assert record["count(p)"] == 1
         session.close()
 
     def test_transaction_rollback(self):
-        driver = GraphDatabase.driver("bolt://localhost")
+        driver = GraphDatabase.driver("bolt://localhost", auth=auth_token)
         session = driver.session()
         # tag::transaction-rollback[]
         tx = session.begin_transaction()
-        tx.run("CREATE (p:Person {name: 'The One'})")
+        tx.run("CREATE (:Person {name: 'Merlin'})")
         tx.rollback()
         # end::transaction-rollback[]
-        cursor = session.run("MATCH (p:Person {name: 'The One'}) RETURN count(p)")
-        assert cursor.next()
-        assert cursor["count(p)"] == 0
-        assert cursor.at_end()
+        result = session.run("MATCH (p:Person {name: 'Merlin'}) RETURN count(p)")
+        record = next(result)
+        assert record["count(p)"] == 0
         session.close()
 
     def test_result_summary_query_profile(self):
-        driver = GraphDatabase.driver("bolt://localhost")
+        driver = GraphDatabase.driver("bolt://localhost", auth=auth_token)
         session = driver.session()
         # tag::result-summary-query-profile[]
-        cursor = session.run("PROFILE MATCH (p:Person {name: {name}}) "
-                             "RETURN id(p)", {"name": "The One"})
-        summary = cursor.summarize()
+        result = session.run("PROFILE MATCH (p:Person {name: {name}}) "
+                             "RETURN id(p)", {"name": "Arthur"})
+        summary = result.consume()
         print(summary.statement_type)
         print(summary.profile)
         # end::result-summary-query-profile[]
         session.close()
 
     def test_result_summary_notifications(self):
-        driver = GraphDatabase.driver("bolt://localhost")
+        driver = GraphDatabase.driver("bolt://localhost", auth=auth_token)
         session = driver.session()
         # tag::result-summary-notifications[]
-        summary = session.run("EXPLAIN MATCH (a), (b) RETURN a,b").summarize()
+        result = session.run("EXPLAIN MATCH (king), (queen) RETURN king, queen")
+        summary = result.consume()
         for notification in summary.notifications:
             print(notification)
         # end::result-summary-notifications[]

neo4j/__main__.py

@@ -27,19 +27,21 @@
 from sys import stdout, stderr
 
 from .util import Watcher
-from .v1.session import GraphDatabase, CypherError
+from .v1.session import GraphDatabase, CypherError, basic_auth
 
 
 def main():
     parser = ArgumentParser(description="Execute one or more Cypher statements using Bolt.")
     parser.add_argument("statement", nargs="+")
-    parser.add_argument("-u", "--url", default="bolt://localhost", metavar="CONNECTION_URL")
+    parser.add_argument("-k", "--keys", action="store_true")
+    parser.add_argument("-P", "--password")
     parser.add_argument("-p", "--parameter", action="append", metavar="NAME=VALUE")
     parser.add_argument("-q", "--quiet", action="store_true")
-    parser.add_argument("-s", "--secure", action="store_true")
+    parser.add_argument("-U", "--user", default="neo4j")
+    parser.add_argument("-u", "--url", default="bolt://localhost", metavar="CONNECTION_URL")
     parser.add_argument("-v", "--verbose", action="count")
     parser.add_argument("-x", "--times", type=int, default=1)
-    parser.add_argument("-z", "--summarize", action="store_true")
+    parser.add_argument("-z", "--summary", action="store_true")
     args = parser.parse_args()
 
     if args.verbose:
@@ -57,30 +59,26 @@ def main():
             except ValueError:
                 parameters[name] = value
 
-    driver = GraphDatabase.driver(args.url, secure=args.secure)
+    driver = GraphDatabase.driver(args.url, auth=basic_auth(args.user, args.password))
     session = driver.session()
     for _ in range(args.times):
         for statement in args.statement:
             try:
-                cursor = session.run(statement, parameters)
+                result = session.run(statement, parameters)
             except CypherError as error:
                 stderr.write("%s: %s\r\n" % (error.code, error.message))
             else:
                 if not args.quiet:
-                    has_results = False
-                    for i, record in enumerate(cursor.stream()):
-                        has_results = True
-                        if i == 0:
-                            stdout.write("%s\r\n" % "\t".join(record.keys()))
-                        stdout.write("%s\r\n" % "\t".join(map(repr, record)))
-                    if has_results:
-                        stdout.write("\r\n")
-                    if args.summarize:
-                        summary = cursor.summarize()
+                    if args.keys:
+                        stdout.write("%s\r\n" % "\t".join(result.keys()))
+                    for i, record in enumerate(result):
+                        stdout.write("%s\r\n" % "\t".join(map(repr, record.values())))
+                    if args.summary:
+                        summary = result.summary
                         stdout.write("Statement      : %r\r\n" % summary.statement)
                         stdout.write("Parameters     : %r\r\n" % summary.parameters)
                         stdout.write("Statement Type : %r\r\n" % summary.statement_type)
-                        stdout.write("Statistics     : %r\r\n" % summary.statistics)
+                        stdout.write("Counters       : %r\r\n" % summary.counters)
                         stdout.write("\r\n")
     session.close()
 

neo4j/meta.py

@@ -19,4 +19,4 @@
 # limitations under the License.
 
 
-version = "1.0.0b2"
+version = "1.0.0b3"

neo4j/v1/__init__.py

@@ -18,5 +18,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from .constants import *
 from .session import *
-from .typesystem import *
+from .types import *