Rename Cypher runner classes to match the new naming

Co-Authored-By: Florentin Dörre <florentin.dorre@neotechnology.com>

Author: knutwalker

graphdatascience/query_runner/cypher_graph_constructor.py

@@ -12,7 +12,7 @@
 from graphdatascience.server_version.server_version import ServerVersion
 
 
-class CypherAggregationApi:
+class CypherProjectionApi:
     RELATIONSHIP_TYPE = "relationshipType"
     SOURCE_NODE_LABEL = "sourceNodeLabels"
     TARGET_NODE_LABEL = "targetNodeLabels"
@@ -76,7 +76,7 @@ def run(self, node_dfs: List[DataFrame], relationship_dfs: List[DataFrame]) -> N
 
         # New Cypher propjection supports concurrency since 2.3.0
         if self._server_version >= ServerVersion(2, 3, 0):
-            self.CypherAggregationRunner(
+            self.CypherProjectionRunner(
                 self._query_runner,
                 self._graph_name,
                 self._concurrency,
@@ -98,7 +98,9 @@ def graph_construct_error_multidf(element: str) -> str:
             node_df = node_dfs[0]
             rel_df = relationship_dfs[0]
 
-            self.CyperProjectionRunner(self._query_runner, self._graph_name, self._concurrency).run(node_df, rel_df)
+            self.LegacyCypherProjectionRunner(self._query_runner, self._graph_name, self._concurrency).run(
+                node_df, rel_df
+            )
 
     def _should_warn_about_arrow_missing(self) -> bool:
         try:
@@ -118,7 +120,7 @@ def _should_warn_about_arrow_missing(self) -> bool:
 
         return should_warn
 
-    class CypherAggregationRunner:
+    class CypherProjectionRunner:
         _BIT_COL_SUFFIX = "_is_present" + str(uuid4())
 
         def __init__(
@@ -149,9 +151,9 @@ def run(self, node_dfs: List[DataFrame], relationship_dfs: List[DataFrame]) -> N
             is_cypher_projection_v2 = self._server_version >= ServerVersion(2, 4, 0)
 
             properties_key = (
-                CypherAggregationApi.REL_PROPERTIES_NEW
+                CypherProjectionApi.REL_PROPERTIES_NEW
                 if is_cypher_projection_v2
-                else CypherAggregationApi.REL_PROPERTIES
+                else CypherProjectionApi.REL_PROPERTIES
             )
 
             aligned_node_dfs = self.adjust_node_dfs(node_dfs, graph_schema, properties_key)
@@ -168,12 +170,12 @@ def run(self, node_dfs: List[DataFrame], relationship_dfs: List[DataFrame]) -> N
 
             property_clauses: List[str] = [
                 self.check_value_clause(combined_cols, prop_col)
-                for prop_col in [CypherAggregationApi.SOURCE_NODE_PROPERTIES, properties_key]
+                for prop_col in [CypherProjectionApi.SOURCE_NODE_PROPERTIES, properties_key]
             ]
 
             source_node_labels_clause = (
-                self.check_value_clause(combined_cols, CypherAggregationApi.SOURCE_NODE_LABEL)
-                if CypherAggregationApi.SOURCE_NODE_LABEL in combined_cols
+                self.check_value_clause(combined_cols, CypherProjectionApi.SOURCE_NODE_LABEL)
+                if CypherProjectionApi.SOURCE_NODE_LABEL in combined_cols
                 else ""
             )
             rel_type_clause = (
@@ -255,23 +257,23 @@ def adjust_node_dfs(
                     f"targetNodeId{self._BIT_COL_SUFFIX}": False,
                 }
 
-                if CypherAggregationApi.RELATIONSHIP_TYPE in schema.all_rels.all:
-                    node_dict[CypherAggregationApi.RELATIONSHIP_TYPE] = None
-                    node_dict[CypherAggregationApi.RELATIONSHIP_TYPE + self._BIT_COL_SUFFIX] = False
+                if CypherProjectionApi.RELATIONSHIP_TYPE in schema.all_rels.all:
+                    node_dict[CypherProjectionApi.RELATIONSHIP_TYPE] = None
+                    node_dict[CypherProjectionApi.RELATIONSHIP_TYPE + self._BIT_COL_SUFFIX] = False
 
                 if "labels" in schema.nodes_per_df[i].all:
-                    node_dict[CypherAggregationApi.SOURCE_NODE_LABEL + self._BIT_COL_SUFFIX] = True
-                    node_dict[CypherAggregationApi.SOURCE_NODE_LABEL] = df["labels"]
+                    node_dict[CypherProjectionApi.SOURCE_NODE_LABEL + self._BIT_COL_SUFFIX] = True
+                    node_dict[CypherProjectionApi.SOURCE_NODE_LABEL] = df["labels"]
                 elif "labels" in schema.all_nodes.all:
-                    node_dict[CypherAggregationApi.SOURCE_NODE_LABEL + self._BIT_COL_SUFFIX] = False
-                    node_dict[CypherAggregationApi.SOURCE_NODE_LABEL] = ""
+                    node_dict[CypherProjectionApi.SOURCE_NODE_LABEL + self._BIT_COL_SUFFIX] = False
+                    node_dict[CypherProjectionApi.SOURCE_NODE_LABEL] = ""
 
                 def collect_to_dict(row: Dict[str, Any]) -> Dict[str, Any]:
                     return {column: row[column] for column in schema.nodes_per_df[i].properties}
 
                 node_dict_df = DataFrame(node_dict)
-                node_dict_df[CypherAggregationApi.SOURCE_NODE_PROPERTIES] = df.apply(collect_to_dict, axis=1)
-                node_dict_df[CypherAggregationApi.SOURCE_NODE_PROPERTIES + self._BIT_COL_SUFFIX] = True
+                node_dict_df[CypherProjectionApi.SOURCE_NODE_PROPERTIES] = df.apply(collect_to_dict, axis=1)
+                node_dict_df[CypherProjectionApi.SOURCE_NODE_PROPERTIES + self._BIT_COL_SUFFIX] = True
                 node_dict_df[properties_key] = None
                 node_dict_df[properties_key + self._BIT_COL_SUFFIX] = False
 
@@ -291,25 +293,25 @@ def adjust_rel_dfs(
                     f"targetNodeId{self._BIT_COL_SUFFIX}": True,
                 }
 
-                if CypherAggregationApi.RELATIONSHIP_TYPE in schema.rels_per_df[i].all:
-                    rel_dict[CypherAggregationApi.RELATIONSHIP_TYPE + self._BIT_COL_SUFFIX] = True
-                    rel_dict[CypherAggregationApi.RELATIONSHIP_TYPE] = df[CypherAggregationApi.RELATIONSHIP_TYPE]
-                elif CypherAggregationApi.RELATIONSHIP_TYPE in schema.all_rels.all:
-                    rel_dict[CypherAggregationApi.RELATIONSHIP_TYPE + self._BIT_COL_SUFFIX] = False
-                    rel_dict[CypherAggregationApi.RELATIONSHIP_TYPE] = None
+                if CypherProjectionApi.RELATIONSHIP_TYPE in schema.rels_per_df[i].all:
+                    rel_dict[CypherProjectionApi.RELATIONSHIP_TYPE + self._BIT_COL_SUFFIX] = True
+                    rel_dict[CypherProjectionApi.RELATIONSHIP_TYPE] = df[CypherProjectionApi.RELATIONSHIP_TYPE]
+                elif CypherProjectionApi.RELATIONSHIP_TYPE in schema.all_rels.all:
+                    rel_dict[CypherProjectionApi.RELATIONSHIP_TYPE + self._BIT_COL_SUFFIX] = False
+                    rel_dict[CypherProjectionApi.RELATIONSHIP_TYPE] = None
 
                 if "labels" in schema.all_nodes.all:
-                    rel_dict[CypherAggregationApi.SOURCE_NODE_LABEL] = None
-                    rel_dict[CypherAggregationApi.SOURCE_NODE_LABEL + self._BIT_COL_SUFFIX] = False
+                    rel_dict[CypherProjectionApi.SOURCE_NODE_LABEL] = None
+                    rel_dict[CypherProjectionApi.SOURCE_NODE_LABEL + self._BIT_COL_SUFFIX] = False
 
                 def collect_to_dict(row: Dict[str, Any]) -> Dict[str, Any]:
                     return {column: row[column] for column in schema.rels_per_df[i].properties}
 
                 rel_dict_df = DataFrame(rel_dict)
                 rel_dict_df[properties_key] = df.apply(collect_to_dict, axis=1)
                 rel_dict_df[properties_key + self._BIT_COL_SUFFIX] = True
-                rel_dict_df[CypherAggregationApi.SOURCE_NODE_PROPERTIES] = None
-                rel_dict_df[CypherAggregationApi.SOURCE_NODE_PROPERTIES + self._BIT_COL_SUFFIX] = False
+                rel_dict_df[CypherProjectionApi.SOURCE_NODE_PROPERTIES] = None
+                rel_dict_df[CypherProjectionApi.SOURCE_NODE_PROPERTIES + self._BIT_COL_SUFFIX] = False
 
                 adjusted_dfs.append(rel_dict_df)
 
@@ -321,21 +323,21 @@ def nodes_config_part(self, node_cols: List[EntityColumnSchema], is_cypher_proje
             nodes_config_fields: List[str] = []
             if any(x.has_labels() for x in node_cols):
                 nodes_config_fields.append(
-                    f"{CypherAggregationApi.SOURCE_NODE_LABEL}: {CypherAggregationApi.SOURCE_NODE_LABEL}"
+                    f"{CypherProjectionApi.SOURCE_NODE_LABEL}: {CypherProjectionApi.SOURCE_NODE_LABEL}"
                 )
                 if is_cypher_projection_v2:
                     nodes_config_fields.append(
-                        f"{CypherAggregationApi.TARGET_NODE_LABEL}: NULL",
+                        f"{CypherProjectionApi.TARGET_NODE_LABEL}: NULL",
                     )
 
             # as we first list all nodes at the top of the df, we don't need to lookup properties for the target node
             if any(x.has_properties() for x in node_cols):
                 nodes_config_fields.append(
-                    f"{CypherAggregationApi.SOURCE_NODE_PROPERTIES}: {CypherAggregationApi.SOURCE_NODE_PROPERTIES}"
+                    f"{CypherProjectionApi.SOURCE_NODE_PROPERTIES}: {CypherProjectionApi.SOURCE_NODE_PROPERTIES}"
                 )
                 if is_cypher_projection_v2:
                     nodes_config_fields.append(
-                        f"{CypherAggregationApi.TARGET_NODE_PROPERTIES}: NULL",
+                        f"{CypherProjectionApi.TARGET_NODE_PROPERTIES}: NULL",
                     )
 
             return nodes_config_fields
@@ -345,15 +347,15 @@ def rels_config_part(self, rel_cols: List[EntityColumnSchema], properties_key: s
 
             if any(x.has_rel_type() for x in rel_cols):
                 rels_config_fields.append(
-                    f"{CypherAggregationApi.RELATIONSHIP_TYPE}: {CypherAggregationApi.RELATIONSHIP_TYPE}"
+                    f"{CypherProjectionApi.RELATIONSHIP_TYPE}: {CypherProjectionApi.RELATIONSHIP_TYPE}"
                 )
 
             if any(x.has_properties() for x in rel_cols):
                 rels_config_fields.append(f"{properties_key}: {properties_key}")
 
             return rels_config_fields
 
-    class CyperProjectionRunner:
+    class LegacyCypherProjectionRunner:
         def __init__(self, query_runner: QueryRunner, graph_name: str, concurrency: int):
             self._query_runner = query_runner
             self._concurrency = concurrency