Simplify error handling and add a common error base class

ariespython/crypto.py

@@ -1,49 +1,38 @@
-from typing import Dict, Optional
 import json
+from typing import Optional
 
-from indy import crypto, error
-from .error import errorcode_to_exception
-
-async def pack_message(wallet_handle: int,
-                       message: str,
-                       recipient_verkeys: list,
-                       sender_verkey: Optional[str] = None) -> bytes:
-    try:
-        return await crypto.pack_message(
-            wallet_handle,
-            message,
-            recipient_verkeys,
-            sender_verkey
-        )
-    except error.IndyError as err:
-        raise errorcode_to_exception(err.error_code) from err
-
-
-async def unpack_message(wallet_handle: int,
-                         jwe: bytes) -> (str, str, str):
-    try:
-        unpacked = json.loads(await crypto.unpack_message(wallet_handle, jwe))
-        return (
-            unpacked['message'],
-            unpacked['recipient_verkey'],
-            unpacked.get('sender_verkey', None)
-        )
-    except error.IndyError as err:
-        raise errorcode_to_exception(err.error_code) from err
-
-
-async def crypto_sign(wallet_handle: int,
-                      signer_vk: str,
-                      msg: bytes) -> bytes:
-    try:
-        return await crypto.crypto_sign(wallet_handle, signer_vk, msg)
-    except error.IndyError as err:
-        raise errorcode_to_exception(err.errorcode_to_exception) from err
-
-async def crypto_verify(signer_vk: str,
-                        msg: bytes,
-                        signature: bytes) -> bool:
-    try:
-        return await crypto.crypto_verify(signer_vk, msg, signature)
-    except error.IndyError as err:
-        raise errorcode_to_exception(err.errorcode_to_exception) from err
+from indy import crypto
+
+from .error import IndyErrorHandler
+
+
+@IndyErrorHandler()
+async def pack_message(
+    wallet_handle: int,
+    message: str,
+    recipient_verkeys: list,
+    sender_verkey: Optional[str] = None,
+) -> bytes:
+    return await crypto.pack_message(
+        wallet_handle, message, recipient_verkeys, sender_verkey
+    )
+
+
+@IndyErrorHandler()
+async def unpack_message(wallet_handle: int, jwe: bytes) -> (str, str, str):
+    unpacked = json.loads(await crypto.unpack_message(wallet_handle, jwe))
+    return (
+        unpacked["message"],
+        unpacked["recipient_verkey"],
+        unpacked.get("sender_verkey", None),
+    )
+
+
+@IndyErrorHandler()
+async def crypto_sign(wallet_handle: int, signer_vk: str, msg: bytes) -> bytes:
+    return await crypto.crypto_sign(wallet_handle, signer_vk, msg)
+
+
+@IndyErrorHandler()
+async def crypto_verify(signer_vk: str, msg: bytes, signature: bytes) -> bool:
+    return await crypto.crypto_verify(signer_vk, msg, signature)

ariespython/did.py

@@ -1,130 +1,87 @@
-from typing import Dict, Optional, Any, Union
 import json
+from typing import Any, Dict, Union
 
-from indy import did, non_secrets, error
-from .error import errorcode_to_exception
+from indy import did
 
+from .error import IndyErrorHandler, WalletItemNotFound
 
-async def create_and_store_my_did(wallet_handle: int,
-                                  did_dict: Dict[str, Any] = {}) -> (str, str):
-    try:
-        return await did.create_and_store_my_did(
-            wallet_handle,
-            json.dumps(did_dict)
-        )
-    except error.IndyError as err:
-        raise errorcode_to_exception(err.error_code) from err
 
+@IndyErrorHandler()
+async def create_and_store_my_did(
+    wallet_handle: int, did_dict: Dict[str, Any] = {}
+) -> (str, str):
+    return await did.create_and_store_my_did(wallet_handle, json.dumps(did_dict))
 
-async def create_key(wallet_handle: int,
-                     key_dict: Dict[str, Any]) -> str:
-    try:
-        return await did.create_key(
-            wallet_handle,
-            json.dumps(key_dict)
-        )
-    except error.IndyError as err:
-        raise errorcode_to_exception(err.error_code) from err
 
+@IndyErrorHandler()
+async def create_key(wallet_handle: int, key_dict: Dict[str, Any]) -> str:
+    return await did.create_key(wallet_handle, json.dumps(key_dict))
 
 
-async def store_their_did(wallet_handle: int,
-                          identity_dict: Dict[str, Any]) -> None:
-    try:
-        await did.store_their_did(
-            wallet_handle,
-            json.dumps(identity_dict)
-        )
-    except error.IndyError as err:
-        raise errorcode_to_exception(err.error_code) from err
+@IndyErrorHandler()
+async def store_their_did(wallet_handle: int, identity_dict: Dict[str, Any]) -> None:
+    await did.store_their_did(wallet_handle, json.dumps(identity_dict))
 
 
-async def set_key_metadata(wallet_handle: int,
-                           verkey: str,
-                           metadata: Union[Dict, str]) -> None:
+@IndyErrorHandler()
+async def set_key_metadata(
+    wallet_handle: int, verkey: str, metadata: Union[Dict, str]
+) -> None:
     if isinstance(metadata, dict):
         metadata = json.dumps(metadata)
+    await did.set_key_metadata(wallet_handle, verkey, metadata)
 
-    try:
-        await did.set_key_metadata(wallet_handle, verkey, metadata)
-    except error.IndyError as err:
-        raise errorcode_to_exception(err.error_code) from err
 
+@IndyErrorHandler()
+async def get_key_metadata(wallet_handle: int, verkey: str) -> str:
+    metadata = await did.get_key_metadata(wallet_handle, verkey)
 
-
-async def get_key_metadata(wallet_handle: int,
-                           verkey: str) -> str:
     try:
-        metadata = await did.get_key_metadata(wallet_handle, verkey)
+        metadata = json.loads(metadata)
+    except json.decoder.JSONDecodeError:
+        pass
 
-        try:
-            metadata = json.loads(metadata)
-        except json.decoder.JSONDecodeError:
-            pass
+    return metadata
 
-        return metadata
-    except error.IndyError as err:
-        raise errorcode_to_exception(err.error_code) from err
 
+@IndyErrorHandler()
+async def get_did_metadata(wallet_handle: int, did_subject: str) -> str:
+    metadata = await did.get_did_metadata(wallet_handle, did_subject)
 
-async def get_did_metadata(wallet_handle: int,
-                           did_subject: str) -> str:
     try:
-        metadata = await did.get_did_metadata(wallet_handle, did_subject)
-
-        try:
-            metadata = json.loads(metadata)
-        except json.decoder.JSONDecodeError:
-            pass
+        metadata = json.loads(metadata)
+    except json.decoder.JSONDecodeError:
+        pass
 
-        return metadata
-    except error.IndyError as err:
-        raise errorcode_to_exception(err.error_code) from err
+    return metadata
 
 
-async def set_did_metadata(wallet_handle: int,
-                           did_subject: str,
-                           metadata: Union[Dict, str]) -> None:
+@IndyErrorHandler()
+async def set_did_metadata(
+    wallet_handle: int, did_subject: str, metadata: Union[Dict, str]
+) -> None:
     if isinstance(metadata, dict):
         metadata = json.dumps(metadata)
 
-    try:
-        await did.set_did_metadata(wallet_handle, did_subject, metadata)
-    except error.IndyError as err:
-        raise errorcode_to_exception(err.error_code) from err
+    return await did.set_did_metadata(wallet_handle, did_subject, metadata)
 
 
-
-async def key_for_local_did(wallet_handle: int,
-                            did: str) -> str:
-    try:
-        return await did.key_for_local_did(wallet_handle, did)
-    except error.IndyError as err:
-        raise errorcode_to_exception(err.error_code) from err
-
-
-async def did_for_key(wallet_handle: int,
-                      verkey: str) -> str:
-    try:
-        key_meta = await get_key_metadata(wallet_handle, verkey)
-        if 'did' not in key_meta:
-            return None
-        return key_meta['did']
-    except error.IndyError as err:
-        if err.error_code == error.ErrorCode.WalletItemNotFound:
-            return None
-
-        raise errorcode_to_exception(err.error_code) from err
+@IndyErrorHandler()
+async def key_for_local_did(wallet_handle: int, did: str) -> str:
+    return await did.key_for_local_did(wallet_handle, did)
 
 
-async def map_key_to_did(wallet_handle: int,
-                         verkey: str,
-                         did:str):
+async def did_for_key(wallet_handle: int, verkey: str) -> str:
     try:
-        await set_key_metadata(
-            wallet_handle,
-            verkey,
-            {'did': did}
-        )
-    except error.IndyError as err:
-        raise errorcode_to_exception(err.error_code) from err
+        with IndyErrorHandler():
+            key_meta = await get_key_metadata(wallet_handle, verkey)
+            if "did" not in key_meta:
+                return None
+            return key_meta["did"]
+    except WalletItemNotFound:
+        return None
+
+
+@IndyErrorHandler()
+async def map_key_to_did(wallet_handle: int, verkey: str, did: str):
+    await set_key_metadata(wallet_handle, verkey, {"did": did})