graphdatascience 1.8__tar.gz → 1.10a1__tar.gz

{graphdatascience-1.8/graphdatascience.egg-info → graphdatascience-1.10a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphdatascience
-Version: 1.8
+Version: 1.10a1
 Summary: A Python client for the Neo4j Graph Data Science (GDS) library
 Home-page: https://neo4j.com/product/graph-data-science/
 Author: Neo4j
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Database
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
@@ -30,10 +31,11 @@ License-File: LICENSE
 Requires-Dist: multimethod<2.0,>=1.0
 Requires-Dist: neo4j<6.0,>=4.4.2
 Requires-Dist: pandas<3.0,>=1.0
-Requires-Dist: pyarrow<14.0,>=4.0
+Requires-Dist: pyarrow<15.0,>=10.0
 Requires-Dist: textdistance<5.0,>=4.0
 Requires-Dist: tqdm<5.0,>=4.0
 Requires-Dist: typing-extensions<5.0,>=4.0
+Requires-Dist: requests
 Provides-Extra: ogb
 Requires-Dist: ogb<2.0,>=1.0; extra == "ogb"
 Provides-Extra: networkx
@@ -125,6 +127,7 @@ Full end-to-end examples in Jupyter ready-to-run notebooks can be found in the [
 * [Sampling, Export and Integration with PyG example](examples/import-sample-export-gnn.ipynb)
 * [Load data to a projected graph via graph construction](examples/load-data-via-graph-construction.ipynb)
 * [Heterogeneous Node Classification with HashGNN and Autotuning](https://github.com/neo4j/graph-data-science-client/tree/main/examples/heterogeneous-node-classification-with-hashgnn.ipynb)
+* [Perform inference using pre-trained KGE models](examples/kge-predict-transe-pyg-train.ipynb)
 
 
 ## Documentation

{graphdatascience-1.8 → graphdatascience-1.10a1}/README.md

@@ -84,6 +84,7 @@ Full end-to-end examples in Jupyter ready-to-run notebooks can be found in the [
 * [Sampling, Export and Integration with PyG example](examples/import-sample-export-gnn.ipynb)
 * [Load data to a projected graph via graph construction](examples/load-data-via-graph-construction.ipynb)
 * [Heterogeneous Node Classification with HashGNN and Autotuning](https://github.com/neo4j/graph-data-science-client/tree/main/examples/heterogeneous-node-classification-with-hashgnn.ipynb)
+* [Perform inference using pre-trained KGE models](examples/kge-predict-transe-pyg-train.ipynb)
 
 
 ## Documentation

graphdatascience-1.10a1/graphdatascience/__init__.py

@@ -0,0 +1,36 @@
+from .graph.graph_create_result import GraphCreateResult
+from .graph.graph_object import Graph
+from .graph_data_science import GraphDataScience
+from .model.graphsage_model import GraphSageModel
+from .model.link_prediction_model import LinkFeature, LPModel
+from .model.node_classification_model import NCModel
+from .model.node_regression_model import NRModel
+from .model.pipeline_model import NodePropertyStep
+from .model.simple_rel_embedding_model import SimpleRelEmbeddingModel
+from .pipeline.lp_training_pipeline import LPTrainingPipeline
+from .pipeline.nc_training_pipeline import NCTrainingPipeline
+from .pipeline.nr_training_pipeline import NRTrainingPipeline
+from .query_runner.query_runner import QueryRunner
+from .server_version.server_version import ServerVersion
+from .session.gds_sessions import GdsSessions
+from .version import __version__
+
+__all__ = [
+    "GraphDataScience",
+    "GdsSessions",
+    "QueryRunner",
+    "__version__",
+    "ServerVersion",
+    "Graph",
+    "GraphCreateResult",
+    "LPTrainingPipeline",
+    "NCTrainingPipeline",
+    "NRTrainingPipeline",
+    "NodePropertyStep",
+    "LinkFeature",
+    "LPModel",
+    "NCModel",
+    "NRModel",
+    "GraphSageModel",
+    "SimpleRelEmbeddingModel",
+]

{graphdatascience-1.8 → graphdatascience-1.10a1}/graphdatascience/algo/algo_proc_runner.py

@@ -7,21 +7,15 @@ from ..error.illegal_attr_checker import IllegalAttrChecker
 from ..graph.graph_object import Graph
 from ..graph.graph_type_check import graph_type_check
 from ..model.graphsage_model import GraphSageModel
+from graphdatascience.call_parameters import CallParameters
 
 
 class AlgoProcRunner(IllegalAttrChecker, ABC):
     @graph_type_check
     def _run_procedure(self, G: Graph, config: Dict[str, Any], with_logging: bool = True) -> DataFrame:
-        query = f"CALL {self._namespace}($graph_name, $config)"
+        params = CallParameters(graph_name=G.name(), config=config)
 
-        params: Dict[str, Any] = {}
-        params["graph_name"] = G.name()
-        params["config"] = config
-
-        if with_logging:
-            return self._query_runner.run_query_with_logging(query, params)
-        else:
-            return self._query_runner.run_query(query, params)
+        return self._query_runner.call_procedure(endpoint=self._namespace, params=params, logging=with_logging)
 
     @graph_type_check
     def estimate(self, G: Graph, **config: Any) -> "Series[Any]":

graphdatascience-1.10a1/graphdatascience/call_parameters.py

@@ -0,0 +1,8 @@
+from typing import Any, OrderedDict
+
+
+class CallParameters(OrderedDict[str, Any]):
+    # since Python 3.6 also initializing through CallParameters(**kwargs) is order preserving
+
+    def placeholder_str(self) -> str:
+        return ", ".join([f"${k}" for k in self.keys()])

{graphdatascience-1.8 → graphdatascience-1.10a1}/graphdatascience/caller_base.py

@@ -13,7 +13,11 @@ class CallerBase(ABC):
         self._server_version = server_version
 
     def _raise_suggestive_error_message(self, requested_endpoint: str) -> NoReturn:
-        list_result = self._query_runner.run_query("CALL gds.list() YIELD name", custom_error=False)
+        list_result = self._query_runner.call_procedure(
+            endpoint="gds.list",
+            yields=["name"],
+            custom_error=False,
+        )
         all_endpoints = list_result["name"].tolist()
 
         raise SyntaxError(generate_suggestive_error_message(requested_endpoint, all_endpoints))

{graphdatascience-1.8 → graphdatascience-1.10a1}/graphdatascience/endpoints.py

@@ -3,11 +3,7 @@ from .algo.single_mode_algo_endpoints import (
     SingleModeAlphaAlgoEndpoints,
 )
 from .call_builder import IndirectAlphaCallBuilder, IndirectBetaCallBuilder
-from .graph.graph_endpoints import (
-    GraphAlphaEndpoints,
-    GraphBetaEndpoints,
-    GraphEndpoints,
-)
+from .graph.graph_endpoints import GraphAlphaEndpoints, GraphBetaEndpoints
 from .model.model_endpoints import (
     ModelAlphaEndpoints,
     ModelBetaEndpoints,
@@ -39,7 +35,6 @@ class DirectEndpoints(
     SingleModeAlgoEndpoints,
     DirectSystemEndpoints,
     DirectUtilEndpoints,
-    GraphEndpoints,
     PipelineEndpoints,
     ModelEndpoints,
     ConfigEndpoints,

{graphdatascience-1.8 → graphdatascience-1.10a1}/graphdatascience/error/endpoint_suggester.py

@@ -9,7 +9,7 @@ def generate_suggestive_error_message(requested_endpoint: str, all_endpoints: Li
     MIN_SIMILARITY_FOR_SUGGESTION = 0.9
 
     closest_endpoint = None
-    curr_max_similarity = 0
+    curr_max_similarity = 0.0
     for ep in all_endpoints:
         similarity = textdistance.jaro_winkler(requested_endpoint, ep)
         if similarity >= MIN_SIMILARITY_FOR_SUGGESTION:

graphdatascience-1.8/graphdatascience/graph/graph_proc_runner.py → graphdatascience-1.10a1/graphdatascience/graph/base_graph_proc_runner.py

@@ -1,6 +1,7 @@
 import os
 import pathlib
 import sys
+import warnings
 from typing import Any, Dict, List, Optional, Union
 
 import pandas as pd
@@ -24,7 +25,6 @@ from .graph_entity_ops_runner import (
 )
 from .graph_export_runner import GraphExportRunner
 from .graph_object import Graph
-from .graph_project_runner import GraphProjectRunner
 from .graph_sample_runner import GraphSampleRunner
 from .graph_type_check import (
     from_graph_type_check,
@@ -32,15 +32,24 @@ from .graph_type_check import (
     graph_type_check_optional,
 )
 from .ogb_loader import OGBLLoader, OGBNLoader
+from graphdatascience.call_parameters import CallParameters
 from graphdatascience.graph.graph_create_result import GraphCreateResult
-from graphdatascience.graph.graph_cypher_runner import GraphCypherRunner
 
 Strings = Union[str, List[str]]
 
 is_neo4j_4_driver = ServerVersion.from_string(neo4j_driver_version) < ServerVersion(5, 0, 0)
 
 
-class GraphProcRunner(UncallableNamespace, IllegalAttrChecker):
+class BaseGraphProcRunner(UncallableNamespace, IllegalAttrChecker):
+    def __init__(self, query_runner: Any, namespace: str, server_version: ServerVersion):
+        super().__init__(query_runner, namespace, server_version)
+        # Pandas 2.2.0 deprecated an API used by ArrowTable.to_pandas() (< pyarrow 14.0)
+        warnings.filterwarnings(
+            "ignore",
+            category=DeprecationWarning,
+            message=r"Passing a BlockManager to DataFrame is deprecated",
+        )
+
     @staticmethod
     def _path(package: str, resource: str) -> pathlib.Path:
         if sys.version_info >= (3, 9):
@@ -77,8 +86,11 @@ class GraphProcRunner(UncallableNamespace, IllegalAttrChecker):
 
         errors = []
 
-        exists = self._query_runner.run_query(
-            f"CALL gds.graph.exists('{graph_name}') YIELD exists", custom_error=False
+        exists = self._query_runner.call_procedure(
+            endpoint="gds.graph.exists",
+            params=CallParameters(graph_name=graph_name),
+            yields=["exists"],
+            custom_error=False,
         ).squeeze()
 
         # compare against True as (1) unit tests return None here and (2) numpys True does not work with `is True`.
@@ -213,11 +225,6 @@ class GraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         self._namespace += ".networkx"
         return NXLoader(self._query_runner, self._namespace, self._server_version)
 
-    @property
-    def project(self) -> GraphProjectRunner:
-        self._namespace += ".project"
-        return GraphProjectRunner(self._query_runner, self._namespace, self._server_version)
-
     @property
     @compatible_with("graphProperty", min_inclusive=ServerVersion(2, 5, 0))
     def graphProperty(self) -> GraphPropertyRunner:
@@ -230,24 +237,17 @@ class GraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         self._namespace += ".nodeLabel"
         return GraphLabelRunner(self._query_runner, self._namespace, self._server_version)
 
-    @property
-    def cypher(self) -> GraphCypherRunner:
-        self._namespace += ".project"
-        return GraphCypherRunner(self._query_runner, self._namespace, self._server_version)
-
     @compatible_with("generate", min_inclusive=ServerVersion(2, 5, 0))
     def generate(self, graph_name: str, node_count: int, average_degree: int, **config: Any) -> GraphCreateResult:
         self._namespace += ".generate"
+        params = CallParameters(
+            graph_name=graph_name, node_count=node_count, average_degree=average_degree, config=config
+        )
 
-        query = f"CALL {self._namespace}($graph_name, $node_count, $average_degree, $config)"
-        params = {
-            "graph_name": graph_name,
-            "node_count": node_count,
-            "average_degree": average_degree,
-            "config": config,
-        }
-
-        result = self._query_runner.run_query(query, params).squeeze()
+        result = self._query_runner.call_procedure(
+            endpoint=self._namespace,
+            params=params,
+        ).squeeze()
 
         return GraphCreateResult(Graph(graph_name, self._query_runner, self._server_version), result)
 
@@ -262,15 +262,17 @@ class GraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         **config: Any,
     ) -> GraphCreateResult:
         self._namespace += ".filter"
-        result = self._query_runner.run_query_with_logging(
-            f"CALL {self._namespace}($graph_name, $from_graph_name, $node_filter, $relationship_filter, $config)",
-            {
-                "graph_name": graph_name,
-                "from_graph_name": from_G.name(),
-                "node_filter": node_filter,
-                "relationship_filter": relationship_filter,
-                "config": config,
-            },
+        params = CallParameters(
+            graph_name=graph_name,
+            from_graph_name=from_G.name(),
+            node_filter=node_filter,
+            relationship_filter=relationship_filter,
+            config=config,
+        )
+        result = self._query_runner.call_procedure(
+            endpoint=self._namespace,
+            logging=True,
+            params=params,
         ).squeeze()
 
         return GraphCreateResult(Graph(graph_name, self._query_runner, self._server_version), result)
@@ -290,28 +292,30 @@ class GraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         self._namespace += ".ogbl"
         return OGBLLoader(self._query_runner, self._namespace, self._server_version)
 
-    @graph_type_check
     def drop(
         self,
-        G: Graph,
+        graph: Union[Graph, str],
         failIfMissing: bool = False,
         dbName: str = "",
         username: Optional[str] = None,
     ) -> Optional["Series[Any]"]:
         self._namespace += ".drop"
 
-        params = {
-            "graph_name": G.name(),
-            "fail_if_missing": failIfMissing,
-            "db_name": dbName,
-        }
+        if isinstance(graph, Graph):
+            graph = graph.name()
+
+        params = CallParameters(
+            graph_name=graph,
+            fail_if_missing=failIfMissing,
+            db_name=dbName,
+        )
         if username:
-            query = f"CALL {self._namespace}($graph_name, $fail_if_missing, $db_name, $username)"
             params["username"] = username
-        else:
-            query = f"CALL {self._namespace}($graph_name, $fail_if_missing, $db_name)"
 
-        result = self._query_runner.run_query(query, params)
+        result = self._query_runner.call_procedure(
+            endpoint=self._namespace,
+            params=params,
+        )
         if not result.empty:
             return result.squeeze()  # type: ignore
 
@@ -319,7 +323,10 @@ class GraphProcRunner(UncallableNamespace, IllegalAttrChecker):
 
     def exists(self, graph_name: str) -> "Series[Any]":
         self._namespace += ".exists"
-        result = self._query_runner.run_query(f"CALL {self._namespace}($graph_name)", {"graph_name": graph_name})
+        result = self._query_runner.call_procedure(
+            endpoint=self._namespace,
+            params=CallParameters(graph_name=graph_name),
+        )
 
         return result.squeeze()  # type: ignore
 
@@ -327,19 +334,22 @@ class GraphProcRunner(UncallableNamespace, IllegalAttrChecker):
     def list(self, G: Optional[Graph] = None) -> DataFrame:
         self._namespace += ".list"
 
+        params = CallParameters()
         if G:
-            query = f"CALL {self._namespace}($graph_name)"
-            params = {"graph_name": G.name()}
-        else:
-            query = "CALL gds.graph.list()"
-            params = {}
+            params["graph_name"] = G.name()
 
-        return self._query_runner.run_query(query, params)
+        return self._query_runner.call_procedure(
+            endpoint=self._namespace,
+            params=params,
+        )
 
     @client_only_endpoint("gds.graph")
     def get(self, graph_name: str) -> Graph:
-        result = self._query_runner.run_query(
-            f"CALL gds.graph.list('{graph_name}') YIELD graphName", custom_error=False
+        result = self._query_runner.call_procedure(
+            endpoint="gds.graph.list",
+            params=CallParameters(graph_name=graph_name),
+            yields=["graphName"],
+            custom_error=False,
         )
         if len(result["graphName"]) == 0:
             raise ValueError(
@@ -356,15 +366,17 @@ class GraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         entities: Strings,
         config: Dict[str, Any],
     ) -> DataFrame:
-        query = f"CALL {self._namespace}($graph_name, $properties, $entities, $config)"
-        params = {
-            "graph_name": G.name(),
-            "properties": properties,
-            "entities": entities,
-            "config": config,
-        }
+        params = CallParameters(
+            graph_name=G.name(),
+            properties=properties,
+            entities=entities,
+            config=config,
+        )
 
-        return self._query_runner.run_query(query, params)
+        return self._query_runner.call_procedure(
+            endpoint=self._namespace,
+            params=params,
+        )
 
     @property
     def nodeProperty(self) -> GraphElementPropertyRunner:
@@ -491,16 +503,17 @@ class GraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         **config: Any,
     ) -> "Series[Any]":
         self._namespace += ".writeRelationship"
+        params = CallParameters(
+            graph_name=G.name(),
+            relationship_type=relationship_type,
+            relationship_property=relationship_property,
+            config=config,
+        )
 
-        query = f"CALL {self._namespace}($graph_name, $relationship_type, $relationship_property, $config)"
-        params = {
-            "graph_name": G.name(),
-            "relationship_type": relationship_type,
-            "relationship_property": relationship_property,
-            "config": config,
-        }
-
-        return self._query_runner.run_query(query, params).squeeze()  # type: ignore
+        return self._query_runner.call_procedure(  # type: ignore
+            endpoint=self._namespace,
+            params=params,
+        ).squeeze()
 
     @multimethod
     def removeNodeProperties(self) -> None:
@@ -515,15 +528,16 @@ class GraphProcRunner(UncallableNamespace, IllegalAttrChecker):
         **config: Any,
     ) -> Series:  # type: ignore
         self._namespace += ".removeNodeProperties"
+        params = CallParameters(
+            graph_name=G.name(),
+            properties=node_properties,
+            config=config,
+        )
 
-        query = f"CALL {self._namespace}($graph_name, $properties, $config)"
-        params = {
-            "graph_name": G.name(),
-            "properties": node_properties,
-            "config": config,
-        }
-
-        return self._query_runner.run_query(query, params).squeeze()  # type: ignore
+        return self._query_runner.call_procedure(  # type: ignore
+            endpoint=self._namespace,
+            params=params,
+        ).squeeze()
 
     @removeNodeProperties.register
     @compatible_with("removeNodeProperties", max_exclusive=ServerVersion(2, 1, 0))
@@ -543,10 +557,12 @@ class GraphProcRunner(UncallableNamespace, IllegalAttrChecker):
     def deleteRelationships(self, G: Graph, relationship_type: str) -> "Series[Any]":
         self._namespace += ".deleteRelationships"
 
-        query = f"CALL {self._namespace}($graph_name, $relationship_type)"
-        params = {
-            "graph_name": G.name(),
-            "relationship_type": relationship_type,
-        }
+        params = CallParameters(
+            graph_name=G.name(),
+            relationship_type=relationship_type,
+        )
 
-        return self._query_runner.run_query(query, params).squeeze()  # type: ignore
+        return self._query_runner.call_procedure(  # type: ignore
+            endpoint=self._namespace,
+            params=params,
+        ).squeeze()

{graphdatascience-1.8 → graphdatascience-1.10a1}/graphdatascience/graph/graph_alpha_proc_runner.py

@@ -3,12 +3,12 @@ from typing import List, Optional, Union
 
 from pandas import DataFrame
 
+from ..call_parameters import CallParameters
 from ..error.client_only_endpoint import client_deprecated, client_only_endpoint
 from ..error.illegal_attr_checker import IllegalAttrChecker
 from ..error.uncallable_namespace import UncallableNamespace
 from ..server_version.compatible_with import compatible_with
 from ..server_version.server_version import ServerVersion
-from .graph_alpha_project_runner import GraphAlphaProjectRunner
 from .graph_entity_ops_runner import GraphLabelRunner, GraphPropertyRunner
 from .graph_object import Graph
 from .graph_sample_runner import GraphAlphaSampleRunner
@@ -30,11 +30,6 @@ class GraphAlphaProcRunner(UncallableNamespace, IllegalAttrChecker):
         self._namespace += ".nodeLabel"
         return GraphLabelRunner(self._query_runner, self._namespace, self._server_version)
 
-    @property
-    def project(self) -> GraphAlphaProjectRunner:
-        self._namespace += ".project"
-        return GraphAlphaProjectRunner(self._query_runner, self._namespace, self._server_version)
-
     @client_only_endpoint("gds.alpha.graph")
     @client_deprecated(old_endpoint="gds.alpha.graph.construct", new_endpoint="gds.graph.construct")
     @compatible_with("construct", min_inclusive=ServerVersion(2, 1, 0))
@@ -51,8 +46,11 @@ class GraphAlphaProcRunner(UncallableNamespace, IllegalAttrChecker):
 
         errors = []
 
-        exists = self._query_runner.run_query(
-            f"CALL gds.graph.exists('{graph_name}') YIELD exists", custom_error=False
+        exists = self._query_runner.call_procedure(
+            endpoint="gds.graph.exists",
+            yields=["exists"],
+            params=CallParameters(graph_name=graph_name),
+            custom_error=False,
         ).squeeze()
 
         # compare against True as (1) unit tests return None here and (2) numpys True does not work with `is True`.

{graphdatascience-1.8 → graphdatascience-1.10a1}/graphdatascience/graph/graph_beta_proc_runner.py

@@ -5,6 +5,7 @@ from ..error.uncallable_namespace import UncallableNamespace
 from .graph_export_runner import GraphExportCsvEndpoints
 from .graph_object import Graph
 from .graph_project_runner import GraphProjectBetaRunner
+from graphdatascience.call_parameters import CallParameters
 from graphdatascience.graph.graph_create_result import GraphCreateResult
 from graphdatascience.graph.graph_entity_ops_runner import GraphRelationshipsBetaRunner
 
@@ -30,14 +31,13 @@ class GraphBetaProcRunner(UncallableNamespace, IllegalAttrChecker):
     def generate(self, graph_name: str, node_count: int, average_degree: int, **config: Any) -> GraphCreateResult:
         self._namespace += ".generate"
 
-        query = f"CALL {self._namespace}($graph_name, $node_count, $average_degree, $config)"
-        params = {
-            "graph_name": graph_name,
-            "node_count": node_count,
-            "average_degree": average_degree,
-            "config": config,
-        }
+        params = CallParameters(
+            graph_name=graph_name,
+            node_count=node_count,
+            average_degree=average_degree,
+            config=config,
+        )
 
-        result = self._query_runner.run_query(query, params).squeeze()
+        result = self._query_runner.call_procedure(endpoint=self._namespace, params=params).squeeze()
 
         return GraphCreateResult(Graph(graph_name, self._query_runner, self._server_version), result)

{graphdatascience-1.8 → graphdatascience-1.10a1}/graphdatascience/graph/graph_create_result.py

@@ -1,12 +1,12 @@
+from __future__ import annotations
+
 from types import TracebackType
-from typing import Any, NamedTuple, Optional, Type, TypeVar
+from typing import Any, NamedTuple, Optional, Type
 
 from pandas import Series
 
 from .graph_object import Graph
 
-TGraphCreateResult = TypeVar("TGraphCreateResult", bound="GraphCreateResult")
-
 
 class GraphCreateResult(NamedTuple):
     """
@@ -16,7 +16,7 @@ class GraphCreateResult(NamedTuple):
     graph: Graph
     result: "Series[Any]"
 
-    def __enter__(self: TGraphCreateResult) -> Graph:
+    def __enter__(self: GraphCreateResult) -> Graph:
         return self.graph
 
     def __exit__(

{graphdatascience-1.8 → graphdatascience-1.10a1}/graphdatascience/graph/graph_cypher_runner.py

@@ -41,7 +41,7 @@ class GraphCypherRunner(CallerBase):
 
         GraphCypherRunner._verify_query_ends_with_return_clause(self._namespace, query)
 
-        result = self._query_runner.run_query(query, params, database, False).squeeze()
+        result = self._query_runner.run_cypher(query, params, database, False).squeeze()
 
         try:
             graph_name = str(result["graphName"])

{graphdatascience-1.8 → graphdatascience-1.10a1}/graphdatascience/graph/graph_endpoints.py

@@ -1,13 +1,6 @@
 from ..caller_base import CallerBase
 from .graph_alpha_proc_runner import GraphAlphaProcRunner
 from .graph_beta_proc_runner import GraphBetaProcRunner
-from .graph_proc_runner import GraphProcRunner
-
-
-class GraphEndpoints(CallerBase):
-    @property
-    def graph(self) -> GraphProcRunner:
-        return GraphProcRunner(self._query_runner, f"{self._namespace}.graph", self._server_version)
 
 
 class GraphAlphaEndpoints(CallerBase):