Use static types for LIBRARY_ERRORS

Author: tomuben

exasol/error/_error.py

@@ -3,17 +3,22 @@
 from inspect import cleandoc
 from pathlib import Path
 from typing import (
+    Any,
     Dict,
     Iterable,
     List,
     Mapping,
+    Optional,
     Union,
 )
 
 with warnings.catch_warnings():
     warnings.simplefilter("ignore")
     from exasol_error_reporting_python import exa_error
-    from exasol_error_reporting_python.error_message_builder import InvalidErrorCode
+    from exasol_error_reporting_python.error_message_builder import (
+        ErrorMessageBuilder,
+        InvalidErrorCode,
+    )
 
 
 @dataclass(frozen=True)
@@ -29,17 +34,19 @@ def __init__(
         message: str,
         mitigations: Union[str, Iterable[str]],
         parameters: Dict[str, Union[str, Parameter]],
-    ):
+    ) -> None:
         # This function maybe flattened into or moved out of the constructor in the future.
-        def build_error(code, msg, mitigations, params):
+        def build_error(code, msg, mitigations, params) -> ErrorMessageBuilder:
             builder = exa_error.ExaError.message_builder(code)
             builder.message(msg)
 
             for mitigation in mitigations:
                 builder.mitigation(mitigation)
 
             for k, v in params.items():
-                name, value, description = k, v, ""
+                name = k
+                value = v
+                description: Optional[str] = ""
                 if isinstance(v, Parameter):
                     value = v.value
                     description = v.description
@@ -93,35 +100,58 @@ def _long(error: Error):
         return output[:-1]
 
 
+@dataclass(frozen=True)
+class StaticError:
+    identifier: str
+    message: str
+    messagePlaceholders: List[Dict[str, str]]
+    description: Optional[str]
+    mitigations: List[str]
+    sourceFile: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        ret_val = {
+            "identifier": self.identifier,
+            "message": self.message,
+            "messagePlaceholders": self.messagePlaceholders,
+            "mitigations": self.mitigations,
+            "sourceFile": self.sourceFile,
+        }
+        if self.description is not None:
+            ret_val["description"] = self.description
+        return ret_val
+
+
 # ATTENTION: In the event of an exception while creating an error, we encounter a chicken-and-egg problem regarding error definitions.
 # Therefore, errors created by this library must be defined "statically" within this file.
 # Details should then be used to create a low-level error. The information should also be used to create/update the error-codes.json
 # as part of the release preparation. This is only necessary for this library, as it is the root, other libraries should use
 # the `ec` command-line tool to update and create their project specifc error-codes.json file.
 LIBRARY_ERRORS = {
-    "E-ERP-1": {
-        "identifier": "E-ERP-1",
-        "message": "Invalid error code {{code}}.",
-        "messagePlaceholders": [
+    "E-ERP-1": StaticError(
+        identifier="E-ERP-1",
+        message="Invalid error code {{code}}.",
+        messagePlaceholders=[
             {
                 "placeholder": "code",
                 "description": "Error code which was causing the error.",
             }
         ],
-        "mitigations": ["Ensure you follow the standard error code format."],
-        "sourceFile": Path(__file__).name,
-    },
-    "E-ERP-2": {
-        "identifier": "E-ERP-2",
-        "message": "Unknown error/exception occurred.",
-        "messagePlaceholders": [
+        description=None,
+        mitigations=["Ensure you follow the standard error code format."],
+        sourceFile=Path(__file__).name,
+    ),
+    "E-ERP-2": StaticError(
+        identifier="E-ERP-2",
+        message="Unknown error/exception occurred.",
+        messagePlaceholders=[
             {
                 "placeholder": "traceback",
                 "description": "Exception traceback which lead to the generation of this error.",
             }
         ],
-        "description": "An unexpected error occurred during the creation of the error",
-        "mitigations": [
+        description="An unexpected error occurred during the creation of the error",
+        mitigations=[
             cleandoc(
                 """
                     A good starting point would be to investigate the cause of the attached exception.
@@ -131,8 +161,8 @@ def _long(error: Error):
                     """
             )
         ],
-        "sourceFile": Path(__file__).name,
-    },
+        sourceFile=Path(__file__).name,
+    ),
 }
 
 
@@ -161,16 +191,10 @@ def ExaError(
     except InvalidErrorCode:
         error_code = "E-ERP-1"
         error_details = LIBRARY_ERRORS[error_code]
-        identifier = error_details["identifier"]
-        assert isinstance(identifier, str)
-        _message = error_details["message"]
-        assert isinstance(_message, str)
-        _mitigations = error_details["mitigations"]
-        assert isinstance(_mitigations, list)
         return Error(
-            code=identifier,
-            message=_message,
-            mitigations=_mitigations,
+            code=error_details.identifier,
+            message=error_details.message,
+            mitigations=error_details.mitigations,
             parameters={"code": code},
         )
     except Exception as ex:
@@ -180,29 +204,23 @@ def ExaError(
         parameters = {"traceback": tb}
         error_code = "E-ERP-2"
         error_details = LIBRARY_ERRORS[error_code]
-        identifier = error_details["identifier"]
-        assert isinstance(identifier, str)
-        _message = error_details["message"]
-        assert isinstance(_message, str)
-        _mitigations = error_details["mitigations"]
-        assert isinstance(_mitigations, list)
         return Error(
-            code=identifier,
-            message=_message,
-            mitigations=_mitigations,
+            code=error_details.identifier,
+            message=error_details.message,
+            mitigations=error_details.mitigations,
             parameters=parameters,
         )
 
 
-def _create_error_code_definitions(version=None):
+def _create_error_code_definitions(version=None) -> Dict[str, Any]:
     from exasol.error.version import VERSION
 
     version = version or VERSION
     return {
         "$schema": "https://schemas.exasol.com/error_code_report-1.0.0.json",
         "projectName": "exasol-error-reporting",
         "projectVersion": version,
-        "errorCodes": [code for code in LIBRARY_ERRORS.values()],
+        "errorCodes": [code.to_dict() for code in LIBRARY_ERRORS.values()],
     }
 
 

exasol_error_reporting_python/error_message_builder.py

@@ -30,7 +30,7 @@ def __init__(self, error_code: str) -> None:
         self._error_code = error_code
         self._message_builder: List[str] = []
         self._mitigations: List[str] = []
-        self._parameter_dict: Dict[str, str] = {}
+        self._parameter_dict: Dict[str, Optional[str]] = {}
 
     def message(self, message: str, *arguments) -> "ErrorMessageBuilder":
         """

exasol_error_reporting_python/parameters_mapper.py

@@ -18,10 +18,12 @@ def __init__(self, text: str, arguments: List[str]) -> None:
         self._text = text
         self._parameters = arguments
         self._parameter_idx = 0
-        self._parameter_dict: Dict[str, str] = {}
+        self._parameter_dict: Dict[str, Optional[str]] = {}
 
     @classmethod
-    def get_params_dict(cls, text: str, arguments: List[str]) -> Dict[str, str]:
+    def get_params_dict(
+        cls, text: str, arguments: List[str]
+    ) -> Dict[str, Optional[str]]:
         """
         Create ParametersMapper object and return the generated dictionary
         that maps the placeholders and parameters.
@@ -45,7 +47,6 @@ def _map_parameters(self) -> None:
         for placeholder in PlaceholderHandler.get_placeholders(self._text):
             if self._is_parameter_present():
                 current_parameter = self._get_current_parameter()
-                assert current_parameter is not None
                 self._parameter_dict[placeholder.name] = current_parameter
             self._next_parameters()