graphdatascience 1.15a1__tar.gz → 1.15a2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphdatascience
-Version: 1.15a1
+Version: 1.15a2
 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.15a2}/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.15a2}/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.15a2/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.15a2}/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,

{graphdatascience-1.15a1 → graphdatascience-1.15a2}/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()
@@ -884,7 +890,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 +924,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.15a2}/graphdatascience/query_runner/neo4j_query_runner.py

@@ -57,19 +57,9 @@ class Neo4jQueryRunner(QueryRunner):
             query_runner = Neo4jQueryRunner(
                 endpoint, 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
@@ -90,19 +80,12 @@ class Neo4jQueryRunner(QueryRunner):
             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
@@ -167,12 +150,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 +159,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 +235,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
 
@@ -373,6 +342,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.15a2/graphdatascience/query_runner/standalone_session_query_runner.py

@@ -0,0 +1,76 @@
+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(_)

{graphdatascience-1.15a1 → graphdatascience-1.15a2}/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",
 ]

{graphdatascience-1.15a1 → graphdatascience-1.15a2}/graphdatascience/session/aura_api.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import logging
 import math
 import time
-import uuid
 import warnings
 from collections import defaultdict
 from datetime import timedelta
@@ -22,8 +21,10 @@ from graphdatascience.session.aura_api_responses import (
     InstanceCreateDetails,
     InstanceDetails,
     InstanceSpecificDetails,
+    ProjectDetails,
     SessionDetails,
-    TenantDetails,
+    SessionDetailsWithErrors,
+    SessionErrorData,
     WaitResult,
 )
 from graphdatascience.session.cloud_location import CloudLocation
@@ -32,33 +33,51 @@ from graphdatascience.version import __version__
 
 
 class AuraApiError(Exception):
+    """
+    Raised when an API call to the AuraAPI fails (after retries).
+    """
+
     def __init__(self, message: str, status_code: int):
         super().__init__(self, message)
         self.status_code = status_code
         self.message = message
 
 
+class SessionStatusError(Exception):
+    """
+    Raised when a session is in a non-healthy state. Such as after a session failed or got expired.
+    """
+
+    def __init__(self, errors: list[SessionErrorData]):
+        message = f"Session is in an unhealthy state. Details: {[str(e) for e in errors]}"
+
+        super().__init__(self, message)
+
+
 class AuraApi:
-    API_VERSION = "v1beta5"
+    API_VERSION = "v1"
 
     def __init__(
-        self, client_id: str, client_secret: str, tenant_id: Optional[str] = None, aura_env: Optional[str] = None
+        self, client_id: str, client_secret: str, project_id: Optional[str] = None, aura_env: Optional[str] = None
     ) -> None:
         self._base_uri = AuraApi.base_uri(aura_env)
         self._credentials = (client_id, client_secret)
 
-        self._request_session = self._init_request_session(self._credentials)
+        self._auth = AuraApi.Auth(
+            oauth_url=f"{self._base_uri}/oauth/token",
+            credentials=self._credentials,
+            headers={"User-agent": f"neo4j-graphdatascience-v{__version__}"},
+        )
+        self._request_session = self._init_request_session()
         self._logger = logging.getLogger()
 
-        self._tenant_id = tenant_id if tenant_id else self._get_tenant_id()
-        self._tenant_details: Optional[TenantDetails] = None
+        self._project_id = project_id if project_id else self._get_project_id()
+        self._project_details: Optional[ProjectDetails] = None
 
-    def _init_request_session(self, credentials: tuple[str, str]) -> requests.Session:
+    def _init_request_session(self) -> requests.Session:
         request_session = requests.Session()
         request_session.headers = {"User-agent": f"neo4j-graphdatascience-v{__version__}"}
-        request_session.auth = AuraApi.Auth(
-            oauth_url=f"{self._base_uri}/oauth/token", credentials=credentials, headers=request_session.headers
-        )
+        request_session.auth = self._auth
         # dont retry on POST as its not idempotent
         request_session.mount(
             "https://",
@@ -106,8 +125,7 @@ class AuraApi:
         ttl: Optional[timedelta] = None,
         cloud_location: Optional[CloudLocation] = None,
     ) -> SessionDetails:
-        pwd = str(uuid.uuid4())  # password wont be used and will go away in v1 endpoints
-        json = {"name": name, "password": pwd, "memory": memory.value, "tenant_id": self._tenant_id}
+        json = {"name": name, "memory": memory.value, "project_id": self._project_id}
 
         if dbid:
             json["instance_id"] = dbid
@@ -120,17 +138,19 @@ class AuraApi:
             json["region"] = cloud_location.region
 
         response = self._request_session.post(
-            f"{self._base_uri}/{AuraApi.API_VERSION}/data-science/sessions", json=json
+            f"{self._base_uri}/{AuraApi.API_VERSION}/graph-analytics/sessions", json=json
         )
 
         self._check_resp(response)
 
         raw_json: dict[str, Any] = response.json()
-        return SessionDetails.from_json(raw_json["data"], raw_json.get("errors", []))
+        self._check_errors(raw_json)
+
+        return SessionDetails.from_json(raw_json["data"])
 
     def get_session(self, session_id: str) -> Optional[SessionDetails]:
         response = self._request_session.get(
-            f"{self._base_uri}/{AuraApi.API_VERSION}/data-science/sessions/{session_id}"
+            f"{self._base_uri}/{AuraApi.API_VERSION}/graph-analytics/sessions/{session_id}"
         )
 
         if response.status_code == HTTPStatus.NOT_FOUND.value:
@@ -139,17 +159,19 @@ class AuraApi:
         self._check_resp(response)
 
         raw_json: dict[str, Any] = response.json()
-        return SessionDetails.from_json(raw_json["data"], raw_json.get("errors", []))
+        self._check_errors(raw_json)
 
-    def list_sessions(self, dbid: Optional[str] = None) -> list[SessionDetails]:
+        return SessionDetails.from_json(raw_json["data"])
+
+    def list_sessions(self, dbid: Optional[str] = None) -> list[SessionDetailsWithErrors]:
         # these are query parameters (not passed in the body)
         params = {
-            "tenantId": self._tenant_id,
+            "projectId": self._project_id,
             "instanceId": dbid,
         }
 
         response = self._request_session.get(
-            f"{self._base_uri}/{AuraApi.API_VERSION}/data-science/sessions", params=params
+            f"{self._base_uri}/{AuraApi.API_VERSION}/graph-analytics/sessions", params=params
         )
 
         self._check_resp(response)
@@ -161,7 +183,7 @@ class AuraApi:
         for error in raw_json.get("errors", []):
             errors_per_session[error["id"]].append(error)
 
-        return [SessionDetails.from_json(s, errors_per_session[s["id"]]) for s in data]
+        return [SessionDetailsWithErrors.from_json_with_error(s, errors_per_session[s["id"]]) for s in data]  # noqa: F821
 
     def wait_for_session_running(
         self,
@@ -177,14 +199,6 @@ class AuraApi:
                 return WaitResult.from_error(f"Session `{session_id}` not found -- please retry")
             elif session.status == "Ready":
                 return WaitResult.from_connection_url(session.bolt_connection_url())
-            elif session.status == "Failed":
-                return WaitResult.from_error(
-                    f"Session `{session_id}` with name `{session.name}` failed due to: {session.errors}"
-                )
-            elif session.is_expired():
-                return WaitResult.from_error(
-                    f"Session `{session_id}` with name `{session.name}` is expired. Expired due to: {session.errors}"
-                )
             else:
                 self._logger.debug(
                     f"Session `{session_id}` is not yet running. "
@@ -204,7 +218,7 @@ class AuraApi:
 
     def delete_session(self, session_id: str) -> bool:
         response = self._request_session.delete(
-            f"{self._base_uri}/{AuraApi.API_VERSION}/data-science/sessions/{session_id}",
+            f"{self._base_uri}/{AuraApi.API_VERSION}/graph-analytics/sessions/{session_id}",
         )
         self._check_endpoint_deprecation(response)
 
@@ -223,7 +237,7 @@ class AuraApi:
             "version": "5",
             "region": region,
             "type": type,
-            "tenant_id": self._tenant_id,
+            "tenant_id": self._project_id,
             "cloud_provider": cloud_provider,
         }
 
@@ -244,7 +258,7 @@ class AuraApi:
         return InstanceSpecificDetails.fromJson(response.json()["data"])
 
     def list_instances(self) -> list[InstanceDetails]:
-        response = self._request_session.get(f"{self._base_uri}/v1/instances", params={"tenantId": self._tenant_id})
+        response = self._request_session.get(f"{self._base_uri}/v1/instances", params={"tenantId": self._project_id})
 
         self._check_resp(response)
 
@@ -303,26 +317,33 @@ class AuraApi:
 
         return EstimationDetails.from_json(response.json()["data"])
 
-    def _get_tenant_id(self) -> str:
+    def _get_project_id(self) -> str:
         response = self._request_session.get(f"{self._base_uri}/v1/tenants")
         self._check_resp(response)
 
         raw_data = response.json()["data"]
 
         if len(raw_data) != 1:
-            tenants_dict = {d["id"]: d["name"] for d in raw_data}
+            projects_dict = {d["id"]: d["name"] for d in raw_data}
             raise RuntimeError(
-                f"This account has access to multiple tenants: `{tenants_dict}`. Please specify which one to use."
+                f"This account has access to multiple projects: `{projects_dict}`. Please specify which one to use."
             )
 
         return raw_data[0]["id"]  # type: ignore
 
-    def tenant_details(self) -> TenantDetails:
-        if not self._tenant_details:
-            response = self._request_session.get(f"{self._base_uri}/v1/tenants/{self._tenant_id}")
+    def project_details(self) -> ProjectDetails:
+        if not self._project_details:
+            response = self._request_session.get(f"{self._base_uri}/v1/tenants/{self._project_id}")
             self._check_resp(response)
-            self._tenant_details = TenantDetails.from_json(response.json()["data"])
-        return self._tenant_details
+            self._project_details = ProjectDetails.from_json(response.json()["data"])
+        return self._project_details
+
+    def _check_errors(self, raw_json: dict[str, Any]) -> None:
+        errors = raw_json.get("errors", [])
+        typed_errors = [SessionErrorData.from_json(error) for error in errors] if errors else None
+
+        if typed_errors:
+            raise SessionStatusError(typed_errors)
 
     def _check_resp(self, resp: requests.Response) -> None:
         self._check_status_code(resp)