Refactor automatic TypeError msg generation

- Move `create_parser` to `parser.py`
- Update `raise_type_error_with_signature`
  to generate more informative error messages
  by discerning the received and expected argument
  types

Author: SyntaxAerror

stat_log_db/src/stat_log_db/__init__.py

@@ -1,2 +1,3 @@
 from . import exceptions
+from . import parser
 from . import cli

stat_log_db/src/stat_log_db/cli.py

@@ -1,44 +1,17 @@
 import os
 import sys
-import argparse
 
-from .exceptions import raise_type_error_with_signature
-
-
-def create_parser(parser_args: dict, version: str | int = "0.0.1") -> argparse.ArgumentParser:
-    """Create the main argument parser."""
-    # Validate parser_args
-    if not isinstance(parser_args, dict):
-        raise_type_error_with_signature()
-    # Default formatter class
-    if "formatter_class" not in parser_args:
-        parser_args["formatter_class"] = argparse.RawDescriptionHelpFormatter
-    try:
-        parser = argparse.ArgumentParser(**parser_args)
-    except Exception as e:
-        raise Exception(f"Failed to create ArgumentParser: {e}")
-
-    # Validate version
-    if not isinstance(version, (str, int)):
-        raise_type_error_with_signature()
-
-    # Add version argument
-    parser.add_argument(
-        "--version",
-        action="version",
-        version=version if isinstance(version, str) else str(version)
-    )
-
-    return parser
+from .parser import create_parser
 
 
 def main():
     """Main CLI entry point."""
 
+    # TODO: Read info from pyproject.toml?
     parser = create_parser({
         "prog": "sldb",
         "description": "My CLI tool",
-    }, "0.0.1") # TODO: Read version from pyproject.toml?
+    }, "0.0.1")
 
     args = parser.parse_args()
 

stat_log_db/src/stat_log_db/exceptions.py

@@ -1,16 +1,42 @@
 
-def raise_type_error_with_signature():
+def raise_type_error_with_signature(argument_name: str | list[str] | tuple[str, ...] | set[str] | None = None):
     """Generate a standard type error message."""
-    # TODO: f"arg must be of type 'argtype', but {inspect.stack()[0][3]} got {type(arg).__name__}"
-    message = ""
+    message = f"TypeError with one or more of argument(s): {argument_name}"
     try:
         import inspect
-        caller_frame = inspect.stack()[1].frame
         import types
+        current_frame = inspect.currentframe()
+        current_function_name = None
+        caller_frame = None
+        if isinstance(current_frame, types.FrameType):
+            current_function_name = inspect.getframeinfo(current_frame).function
+            # caller_frame = inspect.stack()[1].frame
+            caller_frame = current_frame.f_back
         if isinstance(caller_frame, types.FrameType):
-            function_name = inspect.getframeinfo(caller_frame).function
-            signature = inspect.signature(caller_frame.f_globals[function_name])
-            message = f"TypeError in function '{function_name}'. Signature:\n{function_name}{signature}"
+            caller_function_name = inspect.getframeinfo(caller_frame).function
+            message = f"TypeError in function '{caller_function_name}'."
+            signature = inspect.signature(caller_frame.f_globals[caller_function_name])
+            message += f"\nSignature: {caller_function_name}{signature}"
+            arg_names = []
+            if argument_name is None:
+                arg_names = list(signature.parameters.keys())
+            elif isinstance(argument_name, (list, tuple, set)):
+                arg_names = list(argument_name)
+            elif isinstance(argument_name, str):
+                arg_names = [argument_name]
+            else:
+                current_function_name_msg_str = f"in '{current_function_name}'" if current_function_name else ""
+                received_argument_name_type_str = type(argument_name).__name__
+                raise TypeError(f"Invalid argument name type {current_function_name_msg_str} for argument 'argument_name': {received_argument_name_type_str}")
+            for arg_name in arg_names:
+                received_arg_type = type(caller_frame.f_locals[arg_name])
+                received_arg_type_str = received_arg_type.__name__ if isinstance(received_arg_type, type) else received_arg_type
+                received_arg = caller_frame.f_locals[arg_name]
+                expected_arg_type = signature.parameters[arg_name].annotation
+                expected_arg_type_str = expected_arg_type.__name__ if isinstance(expected_arg_type, type) else expected_arg_type
+                if received_arg_type != expected_arg_type:
+                    message += f"\nArgument '{arg_name}' must be of type '{expected_arg_type_str}', but {caller_function_name} got {received_arg_type_str}: {received_arg}"
     except Exception as e:
-        raise Exception(f"Failed to generate type error message: {e}")
+        raise TypeError(message + f"\nAdditional error while generating error message:\n{e}")
+        # raise Exception(f"Failed to generate type error message: {e}")
     raise TypeError(message)

stat_log_db/src/stat_log_db/parser.py

@@ -0,0 +1,30 @@
+import argparse
+
+from .exceptions import raise_type_error_with_signature
+
+
+def create_parser(parser_args: dict, version: str | int = "0.0.1") -> argparse.ArgumentParser:
+    """Create the main argument parser."""
+    # Validate parser_args
+    if not isinstance(parser_args, dict):
+        raise_type_error_with_signature("parser_args")
+    # Default formatter class
+    if "formatter_class" not in parser_args:
+        parser_args["formatter_class"] = argparse.RawDescriptionHelpFormatter
+    try:
+        parser = argparse.ArgumentParser(**parser_args)
+    except Exception as e:
+        raise Exception(f"Failed to create ArgumentParser: {e}")
+
+    # Validate version
+    if not isinstance(version, (str, int)):
+        raise_type_error_with_signature("version")
+
+    # Add version argument
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=version if isinstance(version, str) else str(version)
+    )
+
+    return parser