graphdatascience 1.15a1__tar.gz → 1.15.1__tar.gz

{graphdatascience-1.15a1/graphdatascience.egg-info → graphdatascience-1.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphdatascience
-Version: 1.15a1
+Version: 1.15.1
 Summary: A Python client for the Neo4j Graph Data Science (GDS) library
 Home-page: https://neo4j.com/product/graph-data-science/
 Author: Neo4j

{graphdatascience-1.15a1 → graphdatascience-1.15.1}/graphdatascience/error/cypher_warning_handler.py

@@ -24,6 +24,12 @@ def filter_id_func_deprecation_warning() -> Callable[[F], F]:
                 message=r"^The query used a deprecated function. \('id' is no longer supported\)",
             )
 
+            # since 2025.04.0
+            warnings.filterwarnings(
+                "ignore",
+                message=r"^The query used a deprecated function. \('id' has been replaced by 'elementId or an application-generated id'\)",
+            )
+
             return func(self, *args, **kwargs)
 
         return cast(F, wrapper)

{graphdatascience-1.15a1 → graphdatascience-1.15.1}/graphdatascience/graph_data_science.py

@@ -7,6 +7,8 @@ from typing import Any, Optional, Type, Union
 from neo4j import Driver
 from pandas import DataFrame
 
+from graphdatascience.query_runner.arrow_authentication import UsernamePasswordAuthentication
+
 from .call_builder import IndirectCallBuilder
 from .endpoints import AlphaEndpoints, BetaEndpoints, DirectEndpoints
 from .error.uncallable_namespace import UncallableNamespace
@@ -93,10 +95,15 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
 
         arrow_info = ArrowInfo.create(self._query_runner)
         if arrow and arrow_info.enabled and self._server_version >= ServerVersion(2, 1, 0):
+            arrow_auth = None
+            if auth is not None:
+                username, password = auth
+                arrow_auth = UsernamePasswordAuthentication(username, password)
+
             self._query_runner = ArrowQueryRunner.create(
                 self._query_runner,
                 arrow_info,
-                auth,
+                arrow_auth,
                 self._query_runner.encrypted(),
                 arrow_disable_server_verification,
                 arrow_tls_root_certs,

graphdatascience-1.15.1/graphdatascience/query_runner/arrow_authentication.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+class ArrowAuthentication(ABC):
+    @abstractmethod
+    def auth_pair(self) -> tuple[str, str]:
+        """Returns the auth pair used for authentication."""
+        pass
+
+
+@dataclass
+class UsernamePasswordAuthentication(ArrowAuthentication):
+    username: str
+    password: str
+
+    def auth_pair(self) -> tuple[str, str]:
+        return self.username, self.password

{graphdatascience-1.15a1 → graphdatascience-1.15.1}/graphdatascience/query_runner/arrow_graph_constructor.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import concurrent
+import logging
 import math
 import warnings
 from concurrent.futures import ThreadPoolExecutor
@@ -33,6 +34,7 @@ class ArrowGraphConstructor(GraphConstructor):
         )
         self._chunk_size = chunk_size
         self._min_batch_size = chunk_size * 10
+        self._logger = logging.getLogger()
 
     def run(self, node_dfs: list[DataFrame], relationship_dfs: list[DataFrame]) -> None:
         try:
@@ -60,8 +62,11 @@ class ArrowGraphConstructor(GraphConstructor):
 
             self._client.relationship_load_done(self._graph_name)
         except (Exception, KeyboardInterrupt) as e:
-            self._client.abort(self._graph_name)
-
+            try:
+                self._client.abort(self._graph_name)
+            except Exception as abort_exception:
+                if "No arrow process" not in str(abort_exception):
+                    self._logger.warning(f"error aborting graph creation: {abort_exception}")
             raise e
 
     def _partition_dfs(self, dfs: list[DataFrame]) -> list[DataFrame]:

{graphdatascience-1.15a1 → graphdatascience-1.15.1}/graphdatascience/query_runner/arrow_query_runner.py

@@ -5,6 +5,7 @@ from typing import Any, Optional
 
 from pandas import DataFrame
 
+from graphdatascience.query_runner.arrow_authentication import ArrowAuthentication
 from graphdatascience.retry_utils.retry_config import RetryConfig
 
 from ..call_parameters import CallParameters
@@ -21,7 +22,7 @@ class ArrowQueryRunner(QueryRunner):
     def create(
         fallback_query_runner: QueryRunner,
         arrow_info: ArrowInfo,
-        auth: Optional[tuple[str, str]] = None,
+        arrow_authentication: Optional[ArrowAuthentication] = None,
         encrypted: bool = False,
         disable_server_verification: bool = False,
         tls_root_certs: Optional[bytes] = None,
@@ -33,7 +34,7 @@ class ArrowQueryRunner(QueryRunner):
 
         gds_arrow_client = GdsArrowClient.create(
             arrow_info,
-            auth,
+            arrow_authentication,
             encrypted,
             disable_server_verification,
             tls_root_certs,
@@ -210,6 +211,13 @@ class ArrowQueryRunner(QueryRunner):
         self._fallback_query_runner.close()
         self._gds_arrow_client.close()
 
+    def clone(self, host: str, port: int) -> "QueryRunner":
+        return ArrowQueryRunner(
+            self._gds_arrow_client,
+            self._fallback_query_runner.clone(host, port),
+            self._server_version,
+        )
+
     def fallback_query_runner(self) -> QueryRunner:
         return self._fallback_query_runner
 

{graphdatascience-1.15a1 → graphdatascience-1.15.1}/graphdatascience/query_runner/gds_arrow_client.py

@@ -35,6 +35,7 @@ from tenacity import (
     wait_exponential,
 )
 
+from graphdatascience.query_runner.arrow_authentication import ArrowAuthentication, UsernamePasswordAuthentication
 from graphdatascience.retry_utils.retry_config import RetryConfig
 from graphdatascience.retry_utils.retry_utils import before_log
 
@@ -48,7 +49,7 @@ class GdsArrowClient:
     @staticmethod
     def create(
         arrow_info: ArrowInfo,
-        auth: Optional[tuple[str, str]] = None,
+        auth: Optional[Union[ArrowAuthentication, tuple[str, str]]] = None,
         encrypted: bool = False,
         disable_server_verification: bool = False,
         tls_root_certs: Optional[bytes] = None,
@@ -92,7 +93,7 @@ class GdsArrowClient:
         host: str,
         retry_config: RetryConfig,
         port: int = 8491,
-        auth: Optional[tuple[str, str]] = None,
+        auth: Optional[Union[ArrowAuthentication, tuple[str, str]]] = None,
         encrypted: bool = False,
         disable_server_verification: bool = False,
         tls_root_certs: Optional[bytes] = None,
@@ -107,8 +108,8 @@ class GdsArrowClient:
             The host address of the GDS Arrow server
         port: int
             The host port of the GDS Arrow server (default is 8491)
-        auth: Optional[tuple[str, str]]
-            A tuple containing the username and password for authentication
+        auth: Optional[Union[ArrowAuthentication, tuple[str, str]]]
+            Either an implementation of ArrowAuthentication providing a pair to be used for basic authentication, or a username, password tuple
         encrypted: bool
             A flag that indicates whether the connection should be encrypted (default is False)
         disable_server_verification: bool
@@ -125,7 +126,7 @@ class GdsArrowClient:
         self._arrow_endpoint_version = arrow_endpoint_version
         self._host = host
         self._port = port
-        self._auth = auth
+        self._auth = None
         self._encrypted = encrypted
         self._disable_server_verification = disable_server_verification
         self._tls_root_certs = tls_root_certs
@@ -134,6 +135,10 @@ class GdsArrowClient:
         self._logger = logging.getLogger("gds_arrow_client")
 
         if auth:
+            if not isinstance(auth, ArrowAuthentication):
+                username, password = auth
+                auth = UsernamePasswordAuthentication(username, password)
+            self._auth = auth
             self._auth_middleware = AuthMiddleware(auth)
 
         self._flight_client = self._instantiate_flight_client()
@@ -189,7 +194,8 @@ class GdsArrowClient:
         def auth_with_retry() -> None:
             client = self._client()
             if self._auth:
-                client.authenticate_basic_token(self._auth[0], self._auth[1])
+                auth_pair = self._auth.auth_pair()
+                client.authenticate_basic_token(auth_pair[0], auth_pair[1])
 
         if self._auth:
             auth_with_retry()
@@ -634,7 +640,10 @@ class GdsArrowClient:
         )
         def send_with_retry() -> dict[str, Any]:
             try:
-                result = client.do_action(flight.Action(action_type, json.dumps(meta_data).encode("utf-8")))
+                result = client.do_action(
+                    action=flight.Action(action_type, json.dumps(meta_data).encode("utf-8")),
+                    options=flight.FlightCallOptions(timeout=20.0),
+                )
 
                 # Consume result fully to sanity check and avoid cancelled streams
                 collected_result = list(result)
@@ -884,7 +893,7 @@ class AuthFactory(ClientMiddlewareFactory):  # type: ignore
 
 
 class AuthMiddleware(ClientMiddleware):  # type: ignore
-    def __init__(self, auth: tuple[str, str], *args: Any, **kwargs: Any) -> None:
+    def __init__(self, auth: ArrowAuthentication, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self._auth = auth
         self._token: Optional[str] = None
@@ -918,15 +927,15 @@ class AuthMiddleware(ClientMiddleware):  # type: ignore
 
     def sending_headers(self) -> dict[str, str]:
         token = self.token()
-        if not token:
-            username, password = self._auth
-            auth_token = f"{username}:{password}"
-            auth_token = "Basic " + base64.b64encode(auth_token.encode("utf-8")).decode("ASCII")
-            # There seems to be a bug, `authorization` must be lower key
-            return {"authorization": auth_token}
-        else:
+        if token is not None:
             return {"authorization": "Bearer " + token}
 
+        auth_pair = self._auth.auth_pair()
+        auth_token = f"{auth_pair[0]}:{auth_pair[1]}"
+        auth_token = "Basic " + base64.b64encode(auth_token.encode("utf-8")).decode("ASCII")
+        # There seems to be a bug, `authorization` must be lower key
+        return {"authorization": auth_token}
+
 
 @dataclass(repr=True, frozen=True)
 class NodeLoadDoneResult:

{graphdatascience-1.15a1 → graphdatascience-1.15.1}/graphdatascience/query_runner/neo4j_query_runner.py

@@ -46,6 +46,8 @@ class Neo4jQueryRunner(QueryRunner):
 
             query_runner = Neo4jQueryRunner(
                 driver,
+                Neo4jQueryRunner.parse_protocol(endpoint),
+                auth,
                 auto_close=True,
                 bookmarks=bookmarks,
                 config=config,
@@ -54,22 +56,18 @@ class Neo4jQueryRunner(QueryRunner):
             )
 
         elif isinstance(endpoint, neo4j.Driver):
+            protocol = "neo4j+s" if endpoint.encrypted else "bolt"
             query_runner = Neo4jQueryRunner(
-                endpoint, auto_close=False, bookmarks=bookmarks, database=database, show_progress=show_progress
+                endpoint,
+                protocol,
+                auto_close=False,
+                bookmarks=bookmarks,
+                database=database,
+                show_progress=show_progress,
             )
-
         else:
             raise ValueError(f"Invalid endpoint type: {type(endpoint)}")
 
-        if Neo4jQueryRunner._NEO4J_DRIVER_VERSION >= SemanticVersion(5, 21, 0):
-            notifications_logger = logging.getLogger("neo4j.notifications")
-            # the client does not expose YIELD fields so we just skip these warnings for now
-            notifications_logger.addFilter(
-                lambda record: (
-                    "The query used a deprecated field from a procedure" in record.msg and "by 'gds." in record.msg
-                )
-            )
-
         return query_runner
 
     @staticmethod
@@ -86,23 +84,18 @@ class Neo4jQueryRunner(QueryRunner):
 
         query_runner = Neo4jQueryRunner(
             driver,
+            Neo4jQueryRunner.parse_protocol(endpoint),
+            auth,
             auto_close=True,
             show_progress=show_progress,
             bookmarks=None,
             config=driver_config,
+            # we need to explicitly set this as the default value is None
+            # database in the session is always neo4j
             database="neo4j",
             instance_description="GDS Session",
         )
 
-        if Neo4jQueryRunner._NEO4J_DRIVER_VERSION >= SemanticVersion(5, 21, 0):
-            notifications_logger = logging.getLogger("neo4j.notifications")
-            # the client does not expose YIELD fields so we just skip these warnings for now
-            notifications_logger.addFilter(
-                lambda record: (
-                    "The query used a deprecated field from a procedure" in record.msg and "by 'gds." in record.msg
-                )
-            )
-
         return query_runner
 
     @staticmethod
@@ -111,9 +104,18 @@ class Neo4jQueryRunner(QueryRunner):
         config["keep_alive"] = True
         config["max_connection_pool_size"] = 50
 
+    @staticmethod
+    def parse_protocol(endpoint: str) -> str:
+        protocol_match = re.match(r"^([^:]+)://", endpoint)
+        if not protocol_match:
+            raise ValueError(f"Invalid endpoint URI format: {endpoint}")
+        return protocol_match.group(1)
+
     def __init__(
         self,
         driver: neo4j.Driver,
+        protocol: str,
+        auth: Optional[tuple[str, str]] = None,
         config: dict[str, Any] = {},
         database: Optional[str] = neo4j.DEFAULT_DATABASE,
         auto_close: bool = False,
@@ -122,6 +124,8 @@ class Neo4jQueryRunner(QueryRunner):
         instance_description: str = "Neo4j DBMS",
     ):
         self._driver = driver
+        self._protocol = protocol
+        self._auth = auth
         self._config = config
         self._auto_close = auto_close
         self._database = database
@@ -167,12 +171,7 @@ class Neo4jQueryRunner(QueryRunner):
                 else:
                     raise e
 
-            # Though pandas support may be experimental in the `neo4j` package, it should always
-            # be supported in the `graphdatascience` package.
-            warnings.filterwarnings(
-                "ignore",
-                message=r"^pandas support is experimental and might be changed or removed in future versions$",
-            )
+            self.__configure_warnings_filter()
 
             df = result.to_df()
 
@@ -181,19 +180,10 @@ class Neo4jQueryRunner(QueryRunner):
             else:
                 self._last_bookmarks = session.last_bookmarks()
 
-            if (
-                Neo4jQueryRunner._NEO4J_DRIVER_VERSION >= SemanticVersion(5, 21, 0)
-                and result._warn_notification_severity == "WARNING"
-            ):
-                # the client does not expose YIELD fields so we just skip these warnings for now
-                warnings.filterwarnings(
-                    "ignore", message=r".*The query used a deprecated field from a procedure\. .* by 'gds.* "
-                )
-            else:
-                notifications = result.consume().notifications
-                if notifications:
-                    for notification in notifications:
-                        self._forward_cypher_warnings(notification)
+            notifications = result.consume().notifications
+            if notifications:
+                for notification in notifications:
+                    self._forward_cypher_warnings(notification)
 
             return df
 
@@ -266,7 +256,7 @@ class Neo4jQueryRunner(QueryRunner):
         # (see https://neo4j.com/docs/status-codes/current/notifications/ for more details)
         severity = notification["severity"]
         if severity == "WARNING":
-            if "query used a deprecated field from a procedure" in notification["description"]:
+            if "deprecated field" in notification["description"] and "procedure" in notification["description"]:
                 # the client does not expose YIELD fields so we just skip these warnings for now
                 return
 
@@ -310,6 +300,22 @@ class Neo4jQueryRunner(QueryRunner):
     def set_show_progress(self, show_progress: bool) -> None:
         self._show_progress = show_progress
 
+    def clone(self, host: str, port: int) -> QueryRunner:
+        endpoint = "{}://{}:{}".format(self._protocol, host, port)
+        driver = neo4j.GraphDatabase.driver(endpoint, auth=self._auth, **self.driver_config())
+
+        return Neo4jQueryRunner(
+            driver,
+            self._protocol,
+            self._auth,
+            self._config,
+            self._database,
+            self._auto_close,
+            self._bookmarks,
+            self._show_progress,
+            self._instance_description,
+        )
+
     @staticmethod
     def handle_driver_exception(session: neo4j.Session, e: Exception) -> None:
         reg_gds_hit = re.search(
@@ -373,6 +379,27 @@ class Neo4jQueryRunner(QueryRunner):
         if retrys == retry_config.max_retries:
             raise UnableToConnectError(f"Unable to connect to the {self._instance_description}") from exception
 
+    def __configure_warnings_filter(self) -> None:
+        if Neo4jQueryRunner._NEO4J_DRIVER_VERSION >= SemanticVersion(5, 21, 0):
+            notifications_logger = logging.getLogger("neo4j.notifications")
+            # the client does not expose YIELD fields so we just skip these warnings for now
+            notifications_logger.addFilter(
+                lambda record: (
+                    "The query used a deprecated field from a procedure" in record.msg and "by 'gds." in record.msg
+                )
+            )
+            notifications_logger.addFilter(
+                lambda record: "The procedure has a deprecated field" in record.msg and "gds." in record.msg
+            )
+        warnings.filterwarnings(
+            "ignore",
+            message=r"^pandas support is experimental and might be changed or removed in future versions$",
+        )
+        # neo4j 2025.04
+        warnings.filterwarnings("ignore", message=r".*The procedure has a deprecated field.*by 'gds.*")
+        # neo4j driver 4.4
+        warnings.filterwarnings("ignore", message=r".*The query used a deprecated field from a procedure.*by 'gds.*")
+
     class ConnectivityRetriesConfig(NamedTuple):
         max_retries: int = 600
         wait_time: int = 1

{graphdatascience-1.15a1 → graphdatascience-1.15.1}/graphdatascience/query_runner/protocol/project_protocols.py

@@ -121,7 +121,7 @@ class ProjectProtocolV3(ProjectProtocol):
         query_runner: QueryRunner,
         endpoint: str,
         params: CallParameters,
-        terminationFlag: TerminationFlag,
+        termination_flag: TerminationFlag,
         yields: Optional[list[str]] = None,
         database: Optional[str] = None,
         logging: bool = False,
@@ -132,6 +132,14 @@ class ProjectProtocolV3(ProjectProtocol):
 
         logger = getLogger()
 
+        # We need to pin the driver to a specific cluster member
+        response = query_runner.call_procedure(
+            ProtocolVersion.V3.versioned_procedure_name(endpoint), params, yields, database, logging, False
+        ).squeeze()
+        member_host = response["host"]
+        member_port = response["port"] if ("port" in response.index) else 7687
+        projection_query_runner = query_runner.clone(member_host, member_port)
+
         @retry(
             reraise=True,
             before=before_log(f"Projection (graph: `{params['graph_name']}`)", logger, DEBUG),
@@ -139,9 +147,13 @@ class ProjectProtocolV3(ProjectProtocol):
             wait=wait_incrementing(start=0.2, increment=0.2, max=2),
         )
         def project_fn() -> DataFrame:
-            terminationFlag.assert_running()
-            return query_runner.call_procedure(
+            termination_flag.assert_running()
+            return projection_query_runner.call_procedure(
                 ProtocolVersion.V3.versioned_procedure_name(endpoint), params, yields, database, logging, False
             )
 
-        return project_fn()
+        projection_result = project_fn()
+
+        projection_query_runner.close()
+
+        return projection_result

{graphdatascience-1.15a1 → graphdatascience-1.15.1}/graphdatascience/query_runner/query_runner.py

@@ -80,5 +80,9 @@ class QueryRunner(ABC):
     def set_show_progress(self, show_progress: bool) -> None:
         pass
 
+    @abstractmethod
+    def clone(self, host: str, port: int) -> "QueryRunner":
+        pass
+
     def set_server_version(self, _: ServerVersion) -> None:
         pass

{graphdatascience-1.15a1 → graphdatascience-1.15.1}/graphdatascience/query_runner/session_query_runner.py

@@ -120,6 +120,14 @@ class SessionQueryRunner(QueryRunner):
         self._show_progress = show_progress
         self._gds_query_runner.set_show_progress(show_progress)
 
+    def clone(self, host: str, port: int) -> QueryRunner:
+        return SessionQueryRunner(
+            self._gds_query_runner,
+            self._db_query_runner.clone(host, port),
+            self._gds_arrow_client,
+            self._show_progress,
+        )
+
     def close(self) -> None:
         self._gds_arrow_client.close()
         self._gds_query_runner.close()
@@ -202,12 +210,13 @@ class SessionQueryRunner(QueryRunner):
             return write_protocol.run_write_back(self._db_query_runner, write_back_params, yields, terminationFlag)
 
         try:
-            if self._resolve_show_progress(logging):
-                database_write_result = self._progress_logger.run_with_progress_logging(
-                    run_write_back, job_id, database
-                )
-            else:
-                database_write_result = run_write_back()
+            # Skipping progress for now as export has a different jobId
+            # if self._resolve_show_progress(logging):
+            #     database_write_result = self._progress_logger.run_with_progress_logging(
+            #         run_write_back, job_id, database
+            #     )
+            # else:
+            database_write_result = run_write_back()
         except Exception as e:
             # catch the case nothing was needed to write-back (empty graph)
             # once we have the Arrow Endpoints V2, we could catch by first checking the jobs summary

graphdatascience-1.15.1/graphdatascience/query_runner/standalone_session_query_runner.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pandas import DataFrame
+
+from graphdatascience import QueryRunner, ServerVersion
+from graphdatascience.call_parameters import CallParameters
+from graphdatascience.query_runner.graph_constructor import GraphConstructor
+
+
+class StandaloneSessionQueryRunner(QueryRunner):
+    def __init__(self, session_query_runner: QueryRunner):
+        self._query_runner = session_query_runner
+
+    def call_procedure(
+        self,
+        endpoint: str,
+        params: Optional[CallParameters] = None,
+        yields: Optional[list[str]] = None,
+        database: Optional[str] = None,
+        logging: bool = False,
+        custom_error: bool = True,
+    ) -> DataFrame:
+        if endpoint.endswith(".write"):
+            raise NotImplementedError("write procedures are not supported on standalone sessions")
+
+        return self._query_runner.call_procedure(endpoint, params, yields, database, logging, custom_error)
+
+    def call_function(self, endpoint: str, params: Optional[CallParameters] = None) -> Any:
+        return self._query_runner.call_function(endpoint, params)
+
+    def server_version(self) -> ServerVersion:
+        return self._query_runner.server_version()
+
+    def create_graph_constructor(
+        self, graph_name: str, concurrency: int, undirected_relationship_types: Optional[list[str]]
+    ) -> GraphConstructor:
+        return self._query_runner.create_graph_constructor(graph_name, concurrency, undirected_relationship_types)
+
+    def set_show_progress(self, show_progress: bool) -> None:
+        self._query_runner.set_show_progress(show_progress)
+
+    def encrypted(self) -> bool:
+        return self._query_runner.encrypted()
+
+    def close(self) -> None:
+        self._query_runner.close()
+
+    def database(self) -> Optional[str]:
+        return "neo4j"
+
+    def run_cypher(
+        self,
+        query: str,
+        params: Optional[dict[str, Any]] = None,
+        database: Optional[str] = None,
+        custom_error: bool = True,
+    ) -> DataFrame:
+        raise NotImplementedError
+
+    def driver_config(self) -> dict[str, Any]:
+        raise NotImplementedError
+
+    def set_database(self, database: str) -> None:
+        raise NotImplementedError
+
+    def set_bookmarks(self, bookmarks: Optional[Any]) -> None:
+        raise NotImplementedError
+
+    def bookmarks(self) -> Optional[Any]:
+        raise NotImplementedError
+
+    def last_bookmarks(self) -> Optional[Any]:
+        raise NotImplementedError
+
+    def set_server_version(self, _: ServerVersion) -> None:
+        super().set_server_version(_)
+
+    def clone(self, host: str, port: int) -> QueryRunner:
+        return self

{graphdatascience-1.15a1 → graphdatascience-1.15.1}/graphdatascience/session/__init__.py

@@ -1,4 +1,5 @@
 from .algorithm_category import AlgorithmCategory
+from .aura_api import AuraApiError, SessionStatusError
 from .cloud_location import CloudLocation
 from .dbms_connection_info import DbmsConnectionInfo
 from .gds_sessions import AuraAPICredentials, GdsSessions
@@ -14,4 +15,6 @@ __all__ = [
     "SessionMemory",
     "SessionMemoryValue",
     "AlgorithmCategory",
+    "SessionStatusError",
+    "AuraApiError",
 ]