feat: generalize error_code

* error_code in ResponseError
* raise ... from
* modernize typing

Signed-off-by: Yves Bastide <yves@botify.com>

Author: ybastide

simpleflow/swf/mapper/actors/decider.py

@@ -61,8 +61,8 @@ def complete(
                 raise DoesNotExistError(
                     f"Unable to complete decision task with token={task_token}",
                     message,
-                )
-            raise ResponseError(message)
+                ) from e
+            raise ResponseError(message, error_code=error_code) from e
         finally:
             logging_context.reset()
 
@@ -117,9 +117,9 @@ def poll(self, task_list: str | None = None, identity: str | None = None, **kwar
                     raise DoesNotExistError(
                         "Unable to poll decision task",
                         message,
-                    )
+                    ) from e
 
-                raise ResponseError(message)
+                raise ResponseError(message, error_code=error_code) from e
 
             token = task.get("taskToken")
             if not token:

simpleflow/swf/mapper/actors/worker.py

@@ -64,8 +64,8 @@ def cancel(self, task_token: str, details: str | None = None) -> dict[str, Any]
                 raise DoesNotExistError(
                     f"Unable to cancel activity task with token={task_token}",
                     message,
-                )
-            raise ResponseError(message)
+                ) from e
+            raise ResponseError(message, error_code=error_code) from e
         finally:
             logging_context.reset()
 
@@ -87,9 +87,9 @@ def complete(self, task_token: str, result: Any = None) -> dict[str, Any] | None
                 raise DoesNotExistError(
                     f"Unable to complete activity task with token={task_token}",
                     message,
-                )
+                ) from e
 
-            raise ResponseError(message)
+            raise ResponseError(message, error_code=error_code) from e
         except JumboTooLargeError as e:
             return self.respond_activity_task_failed(task_token, reason=format_exc(e))
 
@@ -113,9 +113,9 @@ def fail(self, task_token: str, details: str | None = None, reason: str | None =
                 raise DoesNotExistError(
                     f"Unable to fail activity task with token={task_token}",
                     message,
-                )
+                ) from e
 
-            raise ResponseError(message)
+            raise ResponseError(message, error_code=error_code) from e
         except JumboTooLargeError as e:
             return self.respond_activity_task_failed(task_token, reason=format_exc(e))
 
@@ -137,15 +137,15 @@ def heartbeat(self, task_token: str, details: str | None = None) -> dict[str, An
                 raise DoesNotExistError(
                     f"Unable to send heartbeat with token={task_token}",
                     message,
-                )
+                ) from e
 
             if error_code == "ThrottlingException":
                 raise RateLimitExceededError(
                     f"Rate exceeded when sending heartbeat with token={task_token}",
                     message,
-                )
+                ) from e
 
-            raise ResponseError(message)
+            raise ResponseError(message, error_code=error_code) from e
 
     def poll(self, task_list: str | None = None, identity: str | None = None) -> Response:
         """Polls for an activity task to process from current
@@ -184,9 +184,9 @@ def poll(self, task_list: str | None = None, identity: str | None = None) -> Res
                 raise DoesNotExistError(
                     "Unable to poll activity task",
                     message,
-                )
+                ) from e
 
-            raise ResponseError(message)
+            raise ResponseError(message, error_code=error_code) from e
 
         if not task.get("taskToken"):
             raise PollTimeout("Activity Worker poll timed out")

simpleflow/swf/mapper/exceptions.py

@@ -3,7 +3,7 @@
 import re
 from collections.abc import Sequence
 from functools import partial, wraps
-from typing import Any, Callable
+from typing import Any, Callable, Pattern
 
 from botocore.exceptions import ClientError
 
@@ -46,9 +46,16 @@ def __init__(self, message: str = "", raw_error: str = "", error_code: str = "",
         'kind'
         >>> error.details
         'details'
+        >>> error = SWFError('message', error_code='FooFault')
+        >>> error.message
+        'message'
+        >>> error.error_code
+        'FooFault'
+        >>> error.details
+        ''
 
         """
-        Exception.__init__(self, message, *args)
+        super().__init__(message, *args)
 
         values = raw_error.split(":", 1)
 
@@ -118,18 +125,15 @@ def ignore(*args, **kwargs):
 REGEX_NESTED_RESOURCE = re.compile(r"Unknown (?:type|execution)[:,]\s*([^ =]+)\s*=")
 
 
-def match_equals(regex, string, values):
+def match_equals(regex: Pattern, string: str | None, values: str | Sequence[str]) -> bool:
     """
     Extract a value from a string with a regex and compare it.
 
     :param regex: to extract the value to check.
-    :type  regex: _sre.SRE_Pattern (compiled regex)
 
     :param string: that contains the value to extract.
-    :type  string: str
 
     :param values: to compare with.
-    :type  values: [str]
 
     """
     if string is None:
@@ -144,12 +148,11 @@ def match_equals(regex, string, values):
     return matched[0] in values
 
 
-def is_unknown_resource_raised(error, *args, **kwargs):
+def is_unknown_resource_raised(error: Exception, *args, **kwargs) -> bool:
     """
     Handler that checks if *error* is an unknown resource fault.
 
     :param error: is the exception to check.
-    :type  error: Exception
 
     """
     if not isinstance(error, ClientError):
@@ -158,7 +161,7 @@ def is_unknown_resource_raised(error, *args, **kwargs):
     return extract_error_code(error) == "UnknownResourceFault"
 
 
-def is_unknown(resource: str | Sequence[str]):
+def is_unknown(resource: str | Sequence[str]) -> Callable:
     """
     Return a function that checks if *error* is an unknown *resource* fault.
 
@@ -190,7 +193,7 @@ def wrapped(error, *args, **kwargs):
     return wrapped
 
 
-def always(value):
+def always(value: Any) -> Callable:
     """
     Always return *value* whatever arguments it got.
 
@@ -217,7 +220,7 @@ def wrapped(*args, **kwargs):
     return wrapped
 
 
-def generate_resource_not_found_message(error):
+def generate_resource_not_found_message(error: Exception) -> str:
     error_code = extract_error_code(error)
     if error_code != "UnknownResourceFault":
         raise ValueError(f"cannot extract resource from {error}")
@@ -227,37 +230,43 @@ def generate_resource_not_found_message(error):
     return f"Resource {resource[0] if resource else 'unknown'} does not exist"
 
 
-def raises(exception, when, extract: Callable[[Any], str] = str):
+def raises(
+    exception: type[Exception] | type[SWFError],
+    when: Callable[[Exception, tuple, dict], bool],
+    extract: Callable[[Any], str] = str,
+):
     """
     :param exception: to raise when the predicate is True.
-    :type  exception: type(Exception)
-
     :param when: predicate to apply.
-    :type  when: (error, *args, **kwargs) -> bool
+    :param extract: function to extract the value from the exception.
     """
 
     @wraps(raises)
     def raises_closure(error, *args, **kwargs):
         if when(error, *args, **kwargs) is True:
-            raise exception(extract(error)) from None
-        raise error
+            if isinstance(getattr(error, "response", None), dict) and issubclass(exception, SWFError):
+                raise exception(extract_message(error), error_code=extract_error_code(error)) from error
+
+            raise exception(extract(error)) from error
+        raise error from None
 
     return raises_closure
 
 
-def catch(exceptions, handle_with=None, log=False):
+def catch(
+    exceptions: type[Exception] | Sequence[type[Exception]] | tuple[type[Exception]],
+    handle_with: Callable[[Exception, tuple, dict], Any] | None = None,
+    log: bool = False,
+):
     """
     Catch *exceptions*, then eventually handle and log them.
 
     :param exceptions: sequence of exceptions to catch.
-    :type  exceptions: Exception | (Exception, )
 
     :param handle_with: handle the exceptions (if handle_with is not None) or
                         raise them again.
-    :type  handle_with: function(err, *args, **kwargs)
 
     :param log: the exception with default logger.
-    :type  log: bool
 
     Examples:
 
@@ -312,10 +321,10 @@ def translate(exceptions, to):
 
     """
 
-    def throw(err, *args, **kwargs):
+    def throw(err: Exception, *args, **kwargs):
         if isinstance(getattr(err, "response", None), dict) and issubclass(to, SWFError):
-            raise to(extract_message(err), error_code=extract_error_code(err)) from None
-        raise to(extract_message(err))
+            raise to(extract_message(err), error_code=extract_error_code(err)) from err
+        raise to(extract_message(err)) from err
 
     return catch(exceptions, handle_with=throw)
 

simpleflow/swf/mapper/models/activity.py

@@ -121,9 +121,9 @@ def _diff(self, ignore_fields: list[str] | None = None) -> ModelDiff:
             error_code = extract_error_code(e)
             message = extract_message(e)
             if error_code == "UnknownResourceFault":
-                raise DoesNotExistError("Remote ActivityType does not exist")
+                raise DoesNotExistError("Remote ActivityType does not exist") from e
 
-            raise ResponseError(message)
+            raise ResponseError(message, error_code=error_code) from e
 
         info = description["typeInfo"]
         config = description["configuration"]
@@ -192,9 +192,9 @@ def save(self):
             error_code = extract_error_code(e)
             message = extract_message(e)
             if error_code == "TypeAlreadyExistsFault":
-                raise AlreadyExistsError(f"{self} already exists")
+                raise AlreadyExistsError(f"{self} already exists") from e
             if error_code in ("UnknownResourceFault", "TypeDeprecatedFault"):
-                raise DoesNotExistError(f"{error_code}: {message}")
+                raise DoesNotExistError(f"{error_code}: {message}") from e
             raise
 
     @exceptions.catch(

simpleflow/swf/mapper/models/domain.py

@@ -86,9 +86,9 @@ def _diff(self, ignore_fields: list[str] | None = None) -> ModelDiff:
         except ClientError as e:
             error_code = e.response["Error"]["Code"]
             if error_code == "UnknownResourceFault":
-                raise DoesNotExistError("Remote Domain does not exist")
+                raise DoesNotExistError("Remote Domain does not exist") from e
 
-            raise ResponseError(e.args[0])
+            raise ResponseError(e.args[0], error_code=error_code) from e
 
         domain_info = description["domainInfo"]
         domain_config = description["configuration"]
@@ -137,8 +137,8 @@ def save(self) -> None:
             error_code = extract_error_code(e)
             message = extract_message(e)
             if error_code == "DomainAlreadyExistsFault":
-                raise AlreadyExistsError(f"Domain {self.name} already exists amazon-side")
-            raise ResponseError(message)
+                raise AlreadyExistsError(f"Domain {self.name} already exists amazon-side") from e
+            raise ResponseError(message, error_code=error_code) from e
 
     @exceptions.translate(ClientError, to=ResponseError)
     @exceptions.catch(

simpleflow/swf/mapper/models/workflow.py

@@ -133,9 +133,9 @@ def _diff(self, ignore_fields: list[str] | None = None) -> ModelDiff:
             error_code = extract_error_code(e)
             message = extract_message(e)
             if error_code == "UnknownResourceFault":
-                raise DoesNotExistError("Remote Domain does not exist")
+                raise DoesNotExistError("Remote Domain does not exist") from e
 
-            raise ResponseError(message)
+            raise ResponseError(message, error_code=error_code) from e
 
         workflow_info = description["typeInfo"]
         workflow_config = description["configuration"]
@@ -199,9 +199,9 @@ def save(self) -> None:
             error_code = extract_error_code(e)
             message = extract_message(e)
             if error_code == "TypeAlreadyExistsFault":
-                raise AlreadyExistsError(f"Workflow type {self.name} already exists amazon-side")
+                raise AlreadyExistsError(f"Workflow type {self.name} already exists amazon-side") from e
             if error_code == "UnknownResourceFault":
-                raise DoesNotExistError(message)
+                raise DoesNotExistError(message) from e
             raise
 
     def delete(self) -> None:
@@ -212,7 +212,7 @@ def delete(self) -> None:
             error_code = extract_error_code(e)
             message = extract_message(e)
             if error_code in ["UnknownResourceFault", "TypeDeprecatedFault"]:
-                raise DoesNotExistError(message)
+                raise DoesNotExistError(message) from e
 
     def upstream(self) -> WorkflowType:
         from simpleflow.swf.mapper.querysets.workflow import WorkflowTypeQuerySet
@@ -400,9 +400,9 @@ def _diff(self, ignore_fields: list[str] | None = None) -> ModelDiff:
             error_code = extract_error_code(e)
             message = extract_message(e)
             if error_code == "UnknownResourceFault":
-                raise DoesNotExistError("Remote Domain does not exist")
+                raise DoesNotExistError("Remote Domain does not exist") from e
 
-            raise ResponseError(message)
+            raise ResponseError(message, error_code=error_code) from e
 
         execution_info = description["executionInfo"]
         execution_config = description["executionConfiguration"]

simpleflow/swf/mapper/querysets/activity.py

@@ -101,9 +101,9 @@ def get(self, name: str, version: str, *args, **kwargs) -> ActivityType:
             error_code = extract_error_code(e)
             message = extract_message(e)
             if error_code == "UnknownResourceFault":
-                raise DoesNotExistError(message)
+                raise DoesNotExistError(message) from e
 
-            raise ResponseError(message)
+            raise ResponseError(message, error_code=error_code) from e
 
         activity_info = response[self._infos]
         activity_config = response["configuration"]

simpleflow/swf/mapper/querysets/domain.py

@@ -39,9 +39,9 @@ def get(self, name: str, *args, **kwargs) -> Domain:
         except ClientError as e:
             error_code = e.response["Error"]["Code"]
             if error_code == "UnknownResourceFault":
-                raise DoesNotExistError(f"No such domain: {name}")
+                raise DoesNotExistError(f"No such domain: {name}") from e
             # Any other errors should raise
-            raise ResponseError(e.args[0])
+            raise ResponseError(e.args[0], error_code=error_code) from e
 
         domain_info = response["domainInfo"]
         domain_config = response["configuration"]

simpleflow/swf/mapper/querysets/workflow.py

@@ -120,9 +120,9 @@ def get(self, name, version, *args, **kwargs):
             error_code = extract_error_code(e)
             message = extract_message(e)
             if error_code == "UnknownResourceFault":
-                raise DoesNotExistError(message)
+                raise DoesNotExistError(message) from e
 
-            raise ResponseError(message)
+            raise ResponseError(message, error_code=error_code) from e
 
         wt_info = response[self._infos]
         wt_config = response["configuration"]
@@ -475,9 +475,9 @@ def get(self, workflow_id, run_id, *args, **kwargs):
             error_code = extract_error_code(e)
             message = extract_message(e)
             if error_code == "UnknownResourceFault":
-                raise DoesNotExistError(message)
+                raise DoesNotExistError(message) from e
 
-            raise ResponseError(message)
+            raise ResponseError(message, error_code=error_code) from e
 
         execution_info = response[self._infos]
         execution_config = response["executionConfiguration"]