Shorten enum names to SessionType, TransactionType (#212)

## What is the goal of this PR?

While aligning Client Python with Client Java, we introduced `GraknTransaction.Type` and `GraknSession.Type`. But in Python these proved cumbersome to type out. So we reverted them to `SessionType` and `TransactionType`.

## What are the changes implemented in this PR?

Shorten enum names to SessionType, TransactionType

Author: Alex Walker

grakn/api/client.py

@@ -20,7 +20,7 @@
 
 from grakn.api.database import DatabaseManager, ClusterDatabaseManager
 from grakn.api.options import GraknOptions
-from grakn.api.session import GraknSession
+from grakn.api.session import GraknSession, SessionType
 
 
 class GraknClient(ABC):
@@ -34,7 +34,7 @@ def databases(self) -> DatabaseManager:
         pass
 
     @abstractmethod
-    def session(self, database: str, session_type: GraknSession.Type, options: GraknOptions = None) -> GraknSession:
+    def session(self, database: str, session_type: SessionType, options: GraknOptions = None) -> GraknSession:
         pass
 
     @abstractmethod

grakn/api/session.py

@@ -23,7 +23,21 @@
 
 from grakn.api.database import Database
 from grakn.api.options import GraknOptions
-from grakn.api.transaction import GraknTransaction
+from grakn.api.transaction import GraknTransaction, TransactionType
+
+
+class SessionType(enum.Enum):
+    DATA = 0
+    SCHEMA = 1
+
+    def is_data(self):
+        return self is SessionType.DATA
+
+    def is_schema(self):
+        return self is SessionType.SCHEMA
+
+    def proto(self):
+        return session_proto.Session.Type.Value(self.name)
 
 
 class GraknSession(ABC):
@@ -33,7 +47,7 @@ def is_open(self) -> bool:
         pass
 
     @abstractmethod
-    def session_type(self) -> "Type":
+    def session_type(self) -> "SessionType":
         pass
 
     @abstractmethod
@@ -45,7 +59,7 @@ def options(self) -> GraknOptions:
         pass
 
     @abstractmethod
-    def transaction(self, transaction_type: GraknTransaction.Type, options: GraknOptions = None) -> GraknTransaction:
+    def transaction(self, transaction_type: TransactionType, options: GraknOptions = None) -> GraknTransaction:
         pass
 
     @abstractmethod
@@ -59,16 +73,3 @@ def __enter__(self):
     @abstractmethod
     def __exit__(self, exc_type, exc_val, exc_tb):
         pass
-
-    class Type(enum.Enum):
-        DATA = 0
-        SCHEMA = 1
-
-        def is_data(self):
-            return self is GraknSession.Type.DATA
-
-        def is_schema(self):
-            return self is GraknSession.Type.SCHEMA
-
-        def proto(self):
-            return session_proto.Session.Type.Value(self.name)

grakn/api/transaction.py

@@ -30,14 +30,28 @@
 from grakn.api.query.query_manager import QueryManager
 
 
+class TransactionType(enum.Enum):
+    READ = 0
+    WRITE = 1
+
+    def is_read(self):
+        return self is TransactionType.READ
+
+    def is_write(self):
+        return self is TransactionType.WRITE
+
+    def proto(self):
+        return transaction_proto.Transaction.Type.Value(self.name)
+
+
 class GraknTransaction(ABC):
 
     @abstractmethod
     def is_open(self) -> bool:
         pass
 
     @abstractmethod
-    def transaction_type(self) -> "Type":
+    def transaction_type(self) -> TransactionType:
         pass
 
     @abstractmethod
@@ -76,19 +90,6 @@ def __enter__(self):
     def __exit__(self, exc_type, exc_val, exc_tb):
         pass
 
-    class Type(enum.Enum):
-        READ = 0
-        WRITE = 1
-
-        def is_read(self):
-            return self is GraknTransaction.Type.READ
-
-        def is_write(self):
-            return self is GraknTransaction.Type.WRITE
-
-        def proto(self):
-            return transaction_proto.Transaction.Type.Value(self.name)
-
 
 class _GraknTransactionExtended(GraknTransaction, ABC):
 

grakn/client.py

@@ -24,8 +24,8 @@
 
 # Repackaging these symbols allows them to be imported from "grakn.client"
 from grakn.api.options import GraknOptions  # noqa # pylint: disable=unused-import
-from grakn.api.session import GraknSession  # noqa # pylint: disable=unused-import
-from grakn.api.transaction import GraknTransaction  # noqa # pylint: disable=unused-import
+from grakn.api.session import GraknSession, SessionType  # noqa # pylint: disable=unused-import
+from grakn.api.transaction import GraknTransaction, TransactionType  # noqa # pylint: disable=unused-import
 
 
 class Grakn:

grakn/cluster/client.py

@@ -20,7 +20,7 @@
 
 from grakn.api.client import GraknClusterClient
 from grakn.api.options import GraknOptions, GraknClusterOptions
-from grakn.api.session import GraknSession
+from grakn.api.session import SessionType
 from grakn.cluster.database import _ClusterDatabase
 from grakn.cluster.database_manager import _ClusterDatabaseManager
 from grakn.cluster.failsafe_task import _FailsafeTask
@@ -64,15 +64,15 @@ def is_open(self) -> bool:
     def databases(self) -> _ClusterDatabaseManager:
         return self._database_managers
 
-    def session(self, database: str, session_type: GraknSession.Type, options=None) -> _ClusterSession:
+    def session(self, database: str, session_type: SessionType, options=None) -> _ClusterSession:
         if not options:
             options = GraknOptions.cluster()
         return self._session_any_replica(database, session_type, options) if options.read_any_replica else self._session_primary_replica(database, session_type, options)
 
-    def _session_primary_replica(self, database: str, session_type: GraknSession.Type, options=None) -> _ClusterSession:
+    def _session_primary_replica(self, database: str, session_type: SessionType, options=None) -> _ClusterSession:
         return _OpenSessionFailsafeTask(database, session_type, options, self).run_primary_replica()
 
-    def _session_any_replica(self, database: str, session_type: GraknSession.Type, options=None) -> _ClusterSession:
+    def _session_any_replica(self, database: str, session_type: SessionType, options=None) -> _ClusterSession:
         return _OpenSessionFailsafeTask(database, session_type, options, self).run_any_replica()
 
     def database_by_name(self) -> Dict[str, _ClusterDatabase]:
@@ -109,7 +109,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 
 class _OpenSessionFailsafeTask(_FailsafeTask):
 
-    def __init__(self, database: str, session_type: GraknSession.Type, options: GraknClusterOptions, client: _ClusterClient):
+    def __init__(self, database: str, session_type: SessionType, options: GraknClusterOptions, client: _ClusterClient):
         super().__init__(client, database)
         self.session_type = session_type
         self.options = options

grakn/cluster/session.py

@@ -19,8 +19,8 @@
 from typing import TYPE_CHECKING
 
 from grakn.api.options import GraknClusterOptions, GraknOptions
-from grakn.api.session import GraknSession
-from grakn.api.transaction import GraknTransaction
+from grakn.api.session import GraknSession, SessionType
+from grakn.api.transaction import TransactionType
 from grakn.cluster.database import _ClusterDatabase
 from grakn.cluster.failsafe_task import _FailsafeTask
 from grakn.core.database import _CoreDatabase
@@ -32,25 +32,25 @@
 
 class _ClusterSession(GraknSession):
 
-    def __init__(self, cluster_client: "_ClusterClient", server_address: str, database: str, session_type: GraknSession.Type, options: GraknClusterOptions):
+    def __init__(self, cluster_client: "_ClusterClient", server_address: str, database: str, session_type: SessionType, options: GraknClusterOptions):
         self.cluster_client = cluster_client
         self.core_client = cluster_client.core_client(server_address)
         print("Opening a session to '%s'" % server_address)
         self.core_session = self.core_client.session(database, session_type, options)
         self._options = options
 
-    def transaction(self, transaction_type: GraknTransaction.Type, options: GraknClusterOptions = None) -> _CoreTransaction:
+    def transaction(self, transaction_type: TransactionType, options: GraknClusterOptions = None) -> _CoreTransaction:
         if not options:
             options = GraknOptions.cluster()
         return self._transaction_any_replica(transaction_type, options) if options.read_any_replica else self._transaction_primary_replica(transaction_type, options)
 
-    def _transaction_primary_replica(self, transaction_type: GraknTransaction.Type, options: GraknClusterOptions) -> _CoreTransaction:
+    def _transaction_primary_replica(self, transaction_type: TransactionType, options: GraknClusterOptions) -> _CoreTransaction:
         return _TransactionFailsafeTask(self, transaction_type, options).run_primary_replica()
 
-    def _transaction_any_replica(self, transaction_type: GraknTransaction.Type, options: GraknClusterOptions) -> _CoreTransaction:
+    def _transaction_any_replica(self, transaction_type: TransactionType, options: GraknClusterOptions) -> _CoreTransaction:
         return _TransactionFailsafeTask(self, transaction_type, options).run_any_replica()
 
-    def session_type(self) -> GraknSession.Type:
+    def session_type(self) -> SessionType:
         return self.core_session.session_type()
 
     def options(self) -> GraknClusterOptions:
@@ -76,7 +76,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 
 class _TransactionFailsafeTask(_FailsafeTask):
 
-    def __init__(self, cluster_session: _ClusterSession, transaction_type: GraknTransaction.Type, options: GraknClusterOptions):
+    def __init__(self, cluster_session: _ClusterSession, transaction_type: TransactionType, options: GraknClusterOptions):
         super().__init__(cluster_session.cluster_client, cluster_session.database().name())
         self.cluster_session = cluster_session
         self.transaction_type = transaction_type

grakn/core/client.py

@@ -22,7 +22,7 @@
 
 from grakn.api.client import GraknClient
 from grakn.api.options import GraknOptions
-from grakn.api.session import GraknSession
+from grakn.api.session import SessionType
 from grakn.common.rpc.stub import GraknCoreStub
 from grakn.core.database_manager import _CoreDatabaseManager
 from grakn.core.session import _CoreSession
@@ -41,7 +41,7 @@ def __init__(self, address: str, parallelisation: int = 2):
         self._sessions: Dict[bytes, _CoreSession] = {}
         self._is_open = True
 
-    def session(self, database: str, session_type: GraknSession.Type, options=None) -> _CoreSession:
+    def session(self, database: str, session_type: SessionType, options=None) -> _CoreSession:
         if not options:
             options = GraknOptions.core()
         session = _CoreSession(self, database, session_type, options)

grakn/core/session.py

@@ -25,8 +25,8 @@
 from grpc import RpcError
 
 from grakn.api.options import GraknOptions
-from grakn.api.session import GraknSession
-from grakn.api.transaction import GraknTransaction
+from grakn.api.session import GraknSession, SessionType
+from grakn.api.transaction import GraknTransaction, TransactionType
 from grakn.common.concurrent.atomic import AtomicBoolean
 from grakn.common.concurrent.lock import ReadWriteLock
 from grakn.common.rpc.request_builder import session_open_req
@@ -41,7 +41,7 @@
 class _CoreSession(GraknSession):
     _PULSE_INTERVAL_SECONDS = 5
 
-    def __init__(self, client: "_CoreClient", database: str, session_type: GraknSession.Type, options: GraknOptions = None):
+    def __init__(self, client: "_CoreClient", database: str, session_type: SessionType, options: GraknOptions = None):
         if not options:
             options = GraknOptions.core()
         self._client = client
@@ -66,7 +66,7 @@ def __init__(self, client: "_CoreClient", database: str, session_type: GraknSess
     def is_open(self) -> bool:
         return self._is_open.get()
 
-    def session_type(self) -> GraknSession.Type:
+    def session_type(self) -> SessionType:
         return self._session_type
 
     def database(self) -> _CoreDatabase:
@@ -75,7 +75,7 @@ def database(self) -> _CoreDatabase:
     def options(self) -> GraknOptions:
         return self._options
 
-    def transaction(self, transaction_type: GraknTransaction.Type, options: GraknOptions = None) -> GraknTransaction:
+    def transaction(self, transaction_type: TransactionType, options: GraknOptions = None) -> GraknTransaction:
         if not options:
             options = GraknOptions.core()
         try:

grakn/core/transaction.py

@@ -24,7 +24,7 @@
 
 from grakn.api.options import GraknOptions
 from grakn.api.query.future import QueryFuture
-from grakn.api.transaction import _GraknTransactionExtended, GraknTransaction
+from grakn.api.transaction import _GraknTransactionExtended, TransactionType
 from grakn.common.exception import GraknClientException, TRANSACTION_CLOSED
 from grakn.common.rpc.request_builder import transaction_commit_req, transaction_rollback_req, transaction_open_req
 from grakn.common.rpc.stub import GraknCoreStub
@@ -39,7 +39,7 @@
 
 class _CoreTransaction(_GraknTransactionExtended):
 
-    def __init__(self, session: "_CoreSession", transaction_type: GraknTransaction.Type, options: GraknOptions = None):
+    def __init__(self, session: "_CoreSession", transaction_type: TransactionType, options: GraknOptions = None):
         if not options:
             options = GraknOptions.core()
         self._transaction_type = transaction_type
@@ -58,7 +58,7 @@ def __init__(self, session: "_CoreSession", transaction_type: GraknTransaction.T
         except RpcError as e:
             raise GraknClientException.of_rpc(e)
 
-    def transaction_type(self) -> GraknTransaction.Type:
+    def transaction_type(self) -> TransactionType:
         return self._transaction_type
 
     def options(self) -> GraknOptions:

tests/behaviour/config/parameters.py

@@ -26,7 +26,7 @@
 
 # TODO: We aren't consistently using typed parameters in step implementations - we should be.
 from grakn.api.concept.type.attribute_type import AttributeType
-from grakn.api.transaction import GraknTransaction
+from grakn.api.transaction import TransactionType
 from grakn.common.label import Label
 
 
@@ -117,8 +117,8 @@ def parse_value_type(value: str) -> AttributeType.ValueType:
 
 
 @parse.with_pattern("read|write")
-def parse_transaction_type(value: str) -> GraknTransaction.Type:
-    return GraknTransaction.Type.READ if value == "read" else GraknTransaction.Type.WRITE
+def parse_transaction_type(value: str) -> TransactionType:
+    return TransactionType.READ if value == "read" else TransactionType.WRITE
 
 
 register_type(TransactionType=parse_transaction_type)