Replace SyftError return values with rising PySyftExceptions

packages/syft/src/syft/exceptions/exception.py

@@ -0,0 +1,27 @@
+# stdlib
+from typing import List
+from typing import Optional
+
+# relative
+from ..service.context import NodeServiceContext
+from ..service.response import SyftError
+from ..service.user.user_roles import ServiceRole
+
+
+class PySyftException(Exception):
+    """Base class for all PySyft exceptions."""
+
+    def __init__(self, message: str, roles: Optional[List[ServiceRole]] = None):
+        super().__init__(message)
+        self.message = message
+        self.roles = roles if roles else [ServiceRole.ADMIN]
+
+    def raise_with_context(self, context: NodeServiceContext):
+        self.context = context
+        return self
+
+    def handle(self) -> SyftError:
+        if self.context and self.context.role in self.roles:
+            return SyftError(message=self.message)
+        else:
+            return SyftError(message="Access denied to exception message.")

packages/syft/src/syft/exceptions/user.py

@@ -0,0 +1,35 @@
+# stdlib
+
+# relative
+from ..service.user.user_roles import ServiceRole
+from .exception import PySyftException
+
+UserAlreadyExistsException = PySyftException(
+    message="User already exists", roles=[ServiceRole.ADMIN]
+)
+
+UserNotFoundException = PySyftException(
+    message="User not found", roles=[ServiceRole.ADMIN]
+)
+AdminVerifyKeyException = PySyftException(
+    message="Failed to get admin verify_key", roles=[ServiceRole.ADMIN]
+)
+RoleNotFoundException = PySyftException(
+    message="Role not found", roles=[ServiceRole.ADMIN]
+)
+
+
+def NoUserWithVerifyKeyException(verify_key: str) -> PySyftException:
+    return PySyftException(
+        message=f"No User with verify_key: {verify_key}", roles=[ServiceRole.ADMIN]
+    )
+
+
+def NoUserWithEmailException(email: str) -> PySyftException:
+    return PySyftException(
+        message=f"No User with email: {email}", roles=[ServiceRole.ADMIN]
+    )
+
+
+def StashRetrievalException(message: str) -> PySyftException:
+    return PySyftException(message=message, roles=[ServiceRole.ADMIN])

packages/syft/src/syft/node/node.py

@@ -41,6 +41,7 @@
 from ..client.api import SyftAPICall
 from ..client.api import SyftAPIData
 from ..client.api import debox_signed_syftapicall_response
+from ..exceptions.exception import PySyftException
 from ..external import OBLV
 from ..serde.deserialize import _deserialize
 from ..serde.serialize import _serialize
@@ -806,6 +807,8 @@ def handle_api_call_with_unsigned_result(
             method = self.get_service_method(_private_api_path)
             try:
                 result = method(context, *api_call.args, **api_call.kwargs)
+            except PySyftException as e:
+                return e.handle()
             except Exception:
                 result = SyftError(
                     message=f"Exception calling {api_call.path}. {traceback.format_exc()}"

packages/syft/src/syft/service/user/user_service.py

@@ -6,6 +6,11 @@
 
 # relative
 from ...abstract_node import NodeType
+from ...exceptions.user import AdminVerifyKeyException
+from ...exceptions.user import NoUserWithEmailException
+from ...exceptions.user import NoUserWithVerifyKeyException
+from ...exceptions.user import StashRetrievalException
+from ...exceptions.user import UserAlreadyExistsException
 from ...node.credentials import SyftSigningKey
 from ...node.credentials import SyftVerifyKey
 from ...node.credentials import UserLoginCredentials
@@ -235,9 +240,7 @@ def update(
                 email=user_update.email
             )
             if user_with_email_exists:
-                return SyftError(
-                    message=f"A user with the email {user_update.email} already exists."
-                )
+                raise UserAlreadyExistsException.raise_with_context(context=context)
 
         if result.is_err():
             error_msg = (
@@ -389,17 +392,6 @@ def exchange_credentials(
             f"{context.login_credentials.email} with error: {result.err()}"
         )
 
-    def admin_verify_key(self) -> Union[SyftVerifyKey, SyftError]:
-        try:
-            result = self.stash.admin_verify_key()
-            if result.is_ok():
-                return result.ok()
-            else:
-                return SyftError(message="failed to get admin verify_key")
-
-        except Exception as e:
-            return SyftError(message=str(e))
-
     def register(
         self, context: NodeServiceContext, new_user: UserCreate
     ) -> Union[Tuple[SyftSuccess, UserPrivateKey], SyftError]:
@@ -449,25 +441,44 @@ def register(
         msg = SyftSuccess(message=success_message)
         return (msg, user.to(UserPrivateKey))
 
-    def user_verify_key(self, email: str) -> Union[SyftVerifyKey, SyftError]:
+    def admin_verify_key(self) -> SyftVerifyKey:
+        try:
+            result = self.stash.admin_verify_key()
+        except Exception as e:
+            raise StashRetrievalException(message=repr(e)) from e
+
+        if result.is_ok() and result.ok() is not None:
+            return result.ok()
+        else:
+            raise AdminVerifyKeyException
+
+    def user_verify_key(self, email: str) -> SyftVerifyKey:
         # we are bypassing permissions here, so dont use to return a result directly to the user
         credentials = self.admin_verify_key()
-        result = self.stash.get_by_email(credentials=credentials, email=email)
-        if result.ok() is not None:
+        try:
+            result = self.stash.get_by_email(credentials=credentials, email=email)
+        except Exception as e:
+            raise StashRetrievalException(message=repr(e)) from e
+
+        if result.is_ok() and result.ok() is not None:
             return result.ok().verify_key
-        return SyftError(message=f"No user with email: {email}")
+        else:
+            raise NoUserWithEmailException(email)
 
-    def get_by_verify_key(
-        self, verify_key: SyftVerifyKey
-    ) -> Union[UserView, SyftError]:
+    def get_by_verify_key(self, verify_key: SyftVerifyKey) -> User:
         # we are bypassing permissions here, so dont use to return a result directly to the user
         credentials = self.admin_verify_key()
-        result = self.stash.get_by_verify_key(
-            credentials=credentials, verify_key=verify_key
-        )
-        if result.is_ok():
+        try:
+            result = self.stash.get_by_verify_key(
+                credentials=credentials, verify_key=verify_key
+            )
+        except Exception as e:
+            raise StashRetrievalException(message=repr(e)) from e
+
+        if result.is_ok() and result.ok() is not None:
             return result.ok()
-        return SyftError(message=f"No User with verify_key: {verify_key}")
+        else:
+            raise NoUserWithVerifyKeyException(verify_key.verify)
 
 
 TYPE_TO_SERVICE[User] = UserService