Merge pull request #19 from neo4j/refactoring

Refactoring

Author: jakewins

neo4j/v1/session.py

@@ -42,7 +42,7 @@ class which can be used to obtain `Driver` instances that are used for
 STATEMENT_TYPE_SCHEMA_WRITE = "sw"
 
 
-Latency = namedtuple("Latency", ["overall", "network", "wait"])
+Latency = namedtuple("Latency", ("overall", "network", "wait"))
 
 
 class BenchTest(object):
@@ -138,10 +138,7 @@ def on_footer(self, metadata):
         """ Called on receipt of the result footer.
         """
         self.complete = True
-        self.summary = ResultSummary(self.statement, self.parameters,
-                                     metadata.get("type"), metadata.get("stats"),
-                                     metadata.get("plan"), metadata.get("profile"),
-                                     metadata.get("notifications", []))
+        self.summary = ResultSummary(self.statement, self.parameters, **metadata)
         if self.bench_test:
             self.bench_test.end_recv = perf_counter()
 
@@ -190,21 +187,28 @@ class ResultSummary(object):
     profile = None
 
     #: Notifications provide extra information for a user executing a statement.
-    #: They can be warnings about problematic queries or other valuable information that can be presented in a client.
+    #: They can be warnings about problematic queries or other valuable information that can be
+    #: presented in a client.
     #: Unlike failures or errors, notifications do not affect the execution of a statement.
     notifications = None
 
-    def __init__(self, statement, parameters, statement_type, statistics, plan, profile, notifications):
+    def __init__(self, statement, parameters, **metadata):
         self.statement = statement
         self.parameters = parameters
-        self.statement_type = statement_type
-        self.statistics = StatementStatistics(statistics or {})
-        if plan is not None:
-            self.plan = Plan(plan)
-        if profile is not None:
-            self.profile = ProfiledPlan(profile)
+        self.statement_type = metadata.get("type")
+        self.statistics = StatementStatistics(metadata.get("stats", {}))
+        if "plan" in metadata:
+            self.plan = make_plan(metadata["plan"])
+        if "profile" in metadata:
+            self.profile = make_plan(metadata["profile"])
             self.plan = self.profile
-        self.notifications = list(map(Notification, notifications))
+        self.notifications = []
+        for notification in metadata.get("notifications", []):
+            position = notification.get("position")
+            if position is not None:
+                position = Position(position["offset"], position["line"], position["column"])
+            self.notifications.append(Notification(notification["code"], notification["title"],
+                                                   notification["description"], position))
 
 
 class StatementStatistics(object):
@@ -256,79 +260,68 @@ def __repr__(self):
         return repr(vars(self))
 
 
-class Plan(object):
-    """ This describes how the database will execute your statement.
+#: A plan describes how the database will execute your statement.
+#:
+#: operator_type:
+#:   the name of the operation performed by the plan
+#: identifiers:
+#:   the list of identifiers used by this plan
+#: arguments:
+#:   a dictionary of arguments used in the specific operation performed by the plan
+#: children:
+#:   a list of sub-plans
+Plan = namedtuple("Plan", ("operator_type", "identifiers", "arguments", "children"))
+
+
+#: A profiled plan describes how the database executed your statement.
+#:
+#: db_hits:
+#:   the number of times this part of the plan touched the underlying data stores
+#: rows:
+#:   the number of records this part of the plan produced
+ProfiledPlan = namedtuple("ProfiledPlan", Plan._fields + ("db_hits", "rows"))
+
+#: Representation for notifications found when executing a statement. A
+#: notification can be visualized in a client pinpointing problems or
+#: other information about the statement.
+#:
+#: code:
+#:   a notification code for the discovered issue.
+#: title:
+#:   a short summary of the notification
+#: description:
+#:   a long description of the notification
+#: position:
+#:   the position in the statement where this notification points to, if relevant.
+Notification = namedtuple("Notification", ("code", "title", "description", "position"))
+
+#: A position within a statement, consisting of offset, line and column.
+#:
+#: offset:
+#:   the character offset referred to by this position; offset numbers start at 0
+#: line:
+#:   the line number referred to by the position; line numbers start at 1
+#: column:
+#:   the column number referred to by the position; column numbers start at 1
+Position = namedtuple("Position", ("offset", "line", "column"))
+
+
+def make_plan(plan_dict):
+    """ Construct a Plan or ProfiledPlan from a dictionary of metadata values.
+
+    :param plan_dict:
+    :return:
     """
-
-    #: The operation name performed by the plan
-    operator_type = None
-
-    #: A list of identifiers used by this plan
-    identifiers = None
-
-    #: A map of arguments used in the specific operation performed by the plan
-    arguments = None
-
-    #: A list of sub plans
-    children = None
-
-    def __init__(self, plan):
-        self.operator_type = plan["operatorType"]
-        self.identifiers = plan.get("identifiers", [])
-        self.arguments = plan.get("args", [])
-        self.children = [Plan(child) for child in plan.get("children", [])]
-
-
-class ProfiledPlan(Plan):
-    """ This describes how the database excuted your statement.
-    """
-
-    #: The number of times this part of the plan touched the underlying data stores
-    db_hits = 0
-
-    #: The number of records this part of the plan produced
-    rows = 0
-
-    def __init__(self, profile):
-        self.db_hits = profile.get("dbHits", 0)
-        self.rows = profile.get("rows", 0)
-        super(ProfiledPlan, self).__init__(profile)
-
-
-class Notification(object):
-    """ Representation for notifications found when executing a statement.
-    A notification can be visualized in a client pinpointing problems or other information about the statement.
-    """
-
-    #: A notification code for the discovered issue.
-    code = None
-
-    #: A short summary of the notification
-    title = None
-
-    #: A long description of the notification
-    description = None
-
-    #: The position in the statement where this notification points to, if relevant. This is a namedtuple
-    #: consisting of offset, line and column:
-    #:
-    #: - offset - the character offset referred to by this position; offset numbers start at 0
-    #:
-    #: - line - the line number referred to by the position; line numbers start at 1
-    #:
-    #: - column - the column number referred to by the position; column numbers start at 1
-    position = None
-
-    def __init__(self, notification):
-        self.code = notification["code"]
-        self.title = notification["title"]
-        self.description = notification["description"]
-        position = notification.get("position")
-        if position is not None:
-            self.position = Position(position["offset"], position["line"], position["column"])
-
-
-Position = namedtuple('Position', ['offset', 'line', 'column'])
+    operator_type = plan_dict["operatorType"]
+    identifiers = plan_dict.get("identifiers", [])
+    arguments = plan_dict.get("args", [])
+    children = [make_plan(child) for child in plan_dict.get("children", [])]
+    if "dbHits" in plan_dict or "rows" in plan_dict:
+        db_hits = plan_dict.get("dbHits", 0)
+        rows = plan_dict.get("rows", 0)
+        return ProfiledPlan(operator_type, identifiers, arguments, children, db_hits, rows)
+    else:
+        return Plan(operator_type, identifiers, arguments, children)
 
 
 class Session(object):