From c237777e843a105fb3c9b7de749a00b91f45f248 Mon Sep 17 00:00:00 2001
From: Akash S <akashsuresh0510@gmail.com>
Date: Tue, 13 May 2025 15:30:22 +0530
Subject: [PATCH 1/7] refactor: enhance evaluation messages with JSON
 formatting for better readability

---
 src/tirith/core/evaluators/contained_in.py    | 30 +++++++------------
 src/tirith/core/evaluators/contains.py        | 30 +++++++------------
 src/tirith/core/evaluators/equals.py          | 11 +++++--
 src/tirith/core/evaluators/greater_than.py    | 15 ++++++++--
 .../core/evaluators/greater_than_equal_to.py  | 12 ++++++--
 src/tirith/core/evaluators/is_empty.py        |  9 ++++--
 src/tirith/core/evaluators/is_not_empty.py    |  6 ++--
 src/tirith/core/evaluators/less_than.py       | 13 ++++++--
 .../core/evaluators/less_than_equal_to.py     | 13 ++++++--
 .../core/evaluators/not_contained_in.py       | 30 ++++++++-----------
 src/tirith/core/evaluators/not_contains.py    | 22 +++++++-------
 src/tirith/core/evaluators/not_equals.py      | 11 +++++--
 src/tirith/core/evaluators/regex_match.py     | 18 ++++++++---
 src/tirith/utils.py                           | 27 ++++++++++++++++-
 tests/core/evaluators/test_equals.py          |  4 +--
 tests/core/evaluators/test_greater_than.py    |  4 +--
 .../evaluators/test_greater_than_equal_to.py  |  4 +--
 tests/core/evaluators/test_is_empty.py        |  6 ++--
 tests/core/evaluators/test_is_not_empty.py    |  6 ++--
 tests/core/evaluators/test_less_than.py       |  4 +--
 .../evaluators/test_less_than_equal_to.py     |  6 ++--
 tests/core/evaluators/test_not_equals.py      |  4 +--
 tests/core/evaluators/test_regex_match.py     |  6 ++--
 23 files changed, 173 insertions(+), 118 deletions(-)

diff --git a/src/tirith/core/evaluators/contained_in.py b/src/tirith/core/evaluators/contained_in.py
index 75e61f87..aab8dc00 100644
--- a/src/tirith/core/evaluators/contained_in.py
+++ b/src/tirith/core/evaluators/contained_in.py
@@ -1,7 +1,7 @@
 import logging
 
 from .base_evaluator import BaseEvaluator
-from tirith.utils import sort_collections
+from tirith.utils import sort_collections,json_format_value
 
 logger = logging.getLogger(__name__)
 
@@ -37,7 +37,7 @@ def evaluate(self, evaluator_input, evaluator_data):
                 result = evaluator_input in evaluator_data
                 evaluation_result["passed"] = result
                 if result:
-                    evaluation_result["message"] = "Found {} inside {}".format(evaluator_input, evaluator_data)
+                    evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
             # if evaluator_input is a list
             elif isinstance(evaluator_data, list):
                 evaluator_data = sort_collections(evaluator_data)
@@ -46,47 +46,39 @@ def evaluate(self, evaluator_input, evaluator_data):
                     result = evaluator_input in evaluator_data
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Found {} inside {}".format(evaluator_input, evaluator_data)
+                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
                     else:
-                        evaluation_result["message"] = "Failed to find {} inside {}".format(
-                            evaluator_input, evaluator_data
-                        )
+                        evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
                 else:
                     result = evaluator_input in evaluator_data
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Found {} inside {}".format(evaluator_input, evaluator_data)
+                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
                     else:
-                        evaluation_result["message"] = "Failed to find {} inside {}".format(
-                            evaluator_input, evaluator_data
-                        )
+                        evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
             elif isinstance(evaluator_data, dict):
                 if isinstance(evaluator_input, dict):
                     evaluation_result["passed"] = True
-                    evaluation_result["message"] = "Found {} inside {}".format(evaluator_input, evaluator_data)
+                    evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
                     for key in evaluator_input:
                         if key in evaluator_data:
                             if evaluator_data[key] != evaluator_input[key]:
                                 evaluation_result["passed"] = False
-                                evaluation_result["message"] = "Failed to find {} inside {}".format(
-                                    evaluator_input, evaluator_data
-                                )
+                                evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
                                 break
                         else:
                             evaluation_result["passed"] = False
-                            evaluation_result["message"] = "Failed to find {} inside {}".format(
-                                evaluator_input, evaluator_data
-                            )
+                            evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
                             break
                 else:
                     result = evaluator_input in evaluator_data
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Found {} inside {}".format(evaluator_input, evaluator_data)
+                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
             else:
                 evaluation_result["message"] = (
                     "{} is an unsupported data type for evaluating against value in 'condition.value'".format(
-                        evaluator_data
+                        json_format_value(evaluator_data)
                     )
                 )
             return evaluation_result
diff --git a/src/tirith/core/evaluators/contains.py b/src/tirith/core/evaluators/contains.py
index ba83f7a6..58d5d521 100644
--- a/src/tirith/core/evaluators/contains.py
+++ b/src/tirith/core/evaluators/contains.py
@@ -1,7 +1,7 @@
 import logging
 
 from .base_evaluator import BaseEvaluator
-from tirith.utils import sort_collections
+from tirith.utils import sort_collections,json_format_value
 
 
 logger = logging.getLogger(__name__)
@@ -38,7 +38,7 @@ def evaluate(self, evaluator_input, evaluator_data):
                 result = evaluator_data in evaluator_input
                 evaluation_result["passed"] = result
                 if result:
-                    evaluation_result["message"] = "Found {} inside {}".format(evaluator_data, evaluator_input)
+                    evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
             # if evaluator_input is a list
             elif isinstance(evaluator_input, list):
                 evaluator_input = sort_collections(evaluator_input)
@@ -47,47 +47,39 @@ def evaluate(self, evaluator_input, evaluator_data):
                     result = evaluator_data in evaluator_input
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Found {} inside {}".format(evaluator_data, evaluator_input)
+                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
                     else:
-                        evaluation_result["message"] = "Failed to find {} inside {}".format(
-                            evaluator_data, evaluator_input
-                        )
+                        evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
                 else:
                     result = evaluator_data in evaluator_input
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Found {} inside {}".format(evaluator_data, evaluator_input)
+                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
                     else:
-                        evaluation_result["message"] = "Failed to find {} inside {}".format(
-                            evaluator_data, evaluator_input
-                        )
+                        evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
             elif isinstance(evaluator_input, dict):
                 if isinstance(evaluator_data, dict):
                     evaluation_result["passed"] = True
-                    evaluation_result["message"] = "Found {} inside {}".format(evaluator_data, evaluator_input)
+                    evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
                     for key in evaluator_data:
                         if key in evaluator_input:
                             if evaluator_input[key] != evaluator_data[key]:
                                 evaluation_result["passed"] = False
-                                evaluation_result["message"] = "Failed to find {} inside {}".format(
-                                    evaluator_data, evaluator_input
-                                )
+                                evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
                                 break
                         else:
                             evaluation_result["passed"] = False
-                            evaluation_result["message"] = "Failed to find {} inside {}".format(
-                                evaluator_data, evaluator_input
-                            )
+                            evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
                             break
                 else:
                     result = evaluator_data in evaluator_input
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Found {} inside {}".format(evaluator_data, evaluator_input)
+                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
             else:
                 evaluation_result["message"] = (
                     "{} is an unsupported data type for evaluating against value in 'condition.value'".format(
-                        evaluator_data
+                        json_format_value(evaluator_data)
                     )
                 )
             return evaluation_result
diff --git a/src/tirith/core/evaluators/equals.py b/src/tirith/core/evaluators/equals.py
index bdd4f1b1..56d08060 100644
--- a/src/tirith/core/evaluators/equals.py
+++ b/src/tirith/core/evaluators/equals.py
@@ -1,7 +1,8 @@
 import logging
+from typing import Dict, Any
 
 from .base_evaluator import BaseEvaluator
-from tirith.utils import sort_collections
+from tirith.utils import sort_collections, json_format_value
 
 logger = logging.getLogger(__name__)
 
@@ -41,9 +42,13 @@ def evaluate(self, evaluator_input, evaluator_data):
             result = value1 == value2
             evaluation_result["passed"] = result
             if result:
-                evaluation_result["message"] = "{} is equal to {}".format(evaluator_input, evaluator_data)
+                evaluation_result["message"] = "{} is equal to {}".format(
+                    json_format_value(evaluator_input), json_format_value(evaluator_data)
+                )
             else:
-                evaluation_result["message"] = "{} is not equal to {}".format(evaluator_input, evaluator_data)
+                evaluation_result["message"] = "{} is not equal to {}".format(
+                    json_format_value(evaluator_input), json_format_value(evaluator_data)
+                )
             return evaluation_result
         except Exception as e:
             evaluation_result["message"] = str(e)
diff --git a/src/tirith/core/evaluators/greater_than.py b/src/tirith/core/evaluators/greater_than.py
index 9baba884..f454c86e 100644
--- a/src/tirith/core/evaluators/greater_than.py
+++ b/src/tirith/core/evaluators/greater_than.py
@@ -1,4 +1,11 @@
+import logging
+from typing import Dict, Any
+
 from .base_evaluator import BaseEvaluator
+from tirith.utils import json_format_value
+
+
+logger = logging.getLogger(__name__)
 
 
 # Checks if :attr:`value` is more then :attr:`other`. Automatically casts values to the same type if possible.
@@ -30,9 +37,13 @@ def evaluate(self, evaluator_input, evaluator_data):
             value2 = evaluator_data
             evaluation_result["passed"] = value1 > value2
             if evaluation_result["passed"]:
-                evaluation_result["message"] = "{} is greater than {}".format(value1, value2)
+                evaluation_result["message"] = "{} is greater than {}".format(
+                    json_format_value(value1), json_format_value(value2)
+                )
             else:
-                evaluation_result["message"] = "{} is not greater than {}".format(value1, value2)
+                evaluation_result["message"] = "{} is not greater than {}".format(
+                    json_format_value(value1), json_format_value(value2)
+                )
             return evaluation_result
         except Exception as e:
             evaluation_result["message"] = str(e)
diff --git a/src/tirith/core/evaluators/greater_than_equal_to.py b/src/tirith/core/evaluators/greater_than_equal_to.py
index f4d1e3d2..e7830325 100644
--- a/src/tirith/core/evaluators/greater_than_equal_to.py
+++ b/src/tirith/core/evaluators/greater_than_equal_to.py
@@ -1,5 +1,7 @@
+import logging
+from typing import Dict, Any
 from .base_evaluator import BaseEvaluator
-
+from tirith.utils import json_format_value
 # Checks if :attr:`value` is more then or equal to :attr:`other`. Automatically casts values to the same type if possible.
 
 # Args:
@@ -31,9 +33,13 @@ def evaluate(self, evaluator_input, evaluator_data):
             value2 = evaluator_data
             evaluation_result["passed"] = value1 >= value2
             if evaluation_result["passed"]:
-                evaluation_result["message"] = "{} is greater than equal to {}".format(value1, value2)
+                evaluation_result["message"] = "{} is greater than equal to {}".format(
+                    json_format_value(value1), json_format_value(value2)
+                )
             else:
-                evaluation_result["message"] = "{} is not greater than or equal to {}".format(value1, value2)
+                evaluation_result["message"] = "{} is not greater than or equal to {}".format(
+                    json_format_value(value1), json_format_value(value2)
+                )
             return evaluation_result
         except Exception as e:
             evaluation_result["message"] = str(e)
diff --git a/src/tirith/core/evaluators/is_empty.py b/src/tirith/core/evaluators/is_empty.py
index df69d07a..e5fa0b73 100644
--- a/src/tirith/core/evaluators/is_empty.py
+++ b/src/tirith/core/evaluators/is_empty.py
@@ -1,5 +1,8 @@
-from .base_evaluator import BaseEvaluator
+import logging
+from typing import Dict, Any
 
+from .base_evaluator import BaseEvaluator
+from tirith.utils import json_format_value
 # Checks if input is empty (null, empty list [], empty dict {}, empty str '')
 
 # Args:
@@ -33,9 +36,9 @@ def evaluate(self, evaluator_input, evaluator_data=None):
                 and not evaluator_input
             ):
                 evaluation_result["passed"] = True
-                evaluation_result["message"] = "{} is empty".format(evaluator_input)
+                evaluation_result["message"] = "{} is empty".format(json_format_value(evaluator_input))
             if not evaluation_result["passed"]:
-                evaluation_result["message"] = "{} is not empty".format(evaluator_input)
+                evaluation_result["message"] = "{} is not empty".format(json_format_value(evaluator_input))
             return evaluation_result
         except Exception as e:
             evaluation_result["message"] = str(e)
diff --git a/src/tirith/core/evaluators/is_not_empty.py b/src/tirith/core/evaluators/is_not_empty.py
index 65539b0f..ee40e831 100644
--- a/src/tirith/core/evaluators/is_not_empty.py
+++ b/src/tirith/core/evaluators/is_not_empty.py
@@ -1,5 +1,5 @@
 from .base_evaluator import BaseEvaluator
-
+from tirith.utils import json_format_value
 # Checks if input is not empty
 
 # Args:
@@ -30,9 +30,9 @@ def evaluate(self, evaluator_input, evaluator_data=None):
                 or isinstance(evaluator_input, dict)
             ) and evaluator_input:
                 evaluation_result["passed"] = True
-                evaluation_result["message"] = "{} is not empty".format(evaluator_input)
+                evaluation_result["message"] = "{} is not empty".format(json_format_value(evaluator_input))
             if not evaluation_result["passed"]:
-                evaluation_result["message"] = "{} is empty".format(evaluator_input)
+                evaluation_result["message"] = "{} is empty".format(json_format_value(evaluator_input))
             return evaluation_result
         except Exception as e:
             evaluation_result["message"] = str(e)
diff --git a/src/tirith/core/evaluators/less_than.py b/src/tirith/core/evaluators/less_than.py
index e20bb8e8..3bf6d5e3 100644
--- a/src/tirith/core/evaluators/less_than.py
+++ b/src/tirith/core/evaluators/less_than.py
@@ -1,5 +1,8 @@
-from .base_evaluator import BaseEvaluator
+import logging
+from typing import Dict, Any
 
+from .base_evaluator import BaseEvaluator
+from tirith.utils import json_format_value
 # Checks if :attr:`value` is less then :attr:`other`. Automatically casts values to the same type if possible.
 
 # Args:
@@ -29,9 +32,13 @@ def evaluate(self, evaluator_input, evaluator_data):
             value2 = evaluator_data
             evaluation_result["passed"] = value1 < value2
             if evaluation_result["passed"]:
-                evaluation_result["message"] = "{} is less than {}".format(value1, value2)
+                evaluation_result["message"] = "{} is less than {}".format(
+                    json_format_value(value1), json_format_value(value2)
+                )
             else:
-                evaluation_result["message"] = "{} is not less than {}".format(value1, value2)
+                evaluation_result["message"] = "{} is not less than {}".format(
+                    json_format_value(value1), json_format_value(value2)
+                )
             return evaluation_result
         except Exception as e:
             evaluation_result["message"] = str(e)
diff --git a/src/tirith/core/evaluators/less_than_equal_to.py b/src/tirith/core/evaluators/less_than_equal_to.py
index 0894b54e..594c64c2 100644
--- a/src/tirith/core/evaluators/less_than_equal_to.py
+++ b/src/tirith/core/evaluators/less_than_equal_to.py
@@ -1,5 +1,8 @@
-from .base_evaluator import BaseEvaluator
+import logging
+from typing import Dict, Any
 
+from .base_evaluator import BaseEvaluator
+from tirith.utils import json_format_value
 # Checks if :attr:`value` is less then or equal to :attr:`other`. Automatically casts values to the same type if possible.
 
 # Args:
@@ -34,9 +37,13 @@ def evaluate(self, evaluator_input, evaluator_data):
             value2 = evaluator_data
             evaluation_result["passed"] = value1 <= value2
             if evaluation_result["passed"]:
-                evaluation_result["message"] = "{} is less than equal to {}".format(value1, value2)
+                evaluation_result["message"] = "{} is less than equal to {}".format(
+                    json_format_value(value1), json_format_value(value2)
+                )
             else:
-                evaluation_result["message"] = "{} is not less than or equal to {}".format(value1, value2)
+                evaluation_result["message"] = "{} is not less than or equal to {}".format(
+                    json_format_value(value1), json_format_value(value2)
+                )
             return evaluation_result
         except Exception as e:
             evaluation_result["message"] = str(e)
diff --git a/src/tirith/core/evaluators/not_contained_in.py b/src/tirith/core/evaluators/not_contained_in.py
index 7261cb87..e4940cba 100644
--- a/src/tirith/core/evaluators/not_contained_in.py
+++ b/src/tirith/core/evaluators/not_contained_in.py
@@ -1,7 +1,7 @@
 import logging
 
 from .base_evaluator import BaseEvaluator
-from tirith.utils import sort_collections
+from tirith.utils import sort_collections, json_format_value
 
 
 logger = logging.getLogger(__name__)
@@ -27,9 +27,9 @@ def evaluate(self, evaluator_input, evaluator_data):
                 result = evaluator_input not in evaluator_data
                 evaluation_result["passed"] = result
                 if result:
-                    evaluation_result["message"] = "Did not find {} inside {}".format(evaluator_input, evaluator_data)
+                    evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
                 else:
-                    evaluation_result["message"] = "Found {} inside {}".format(evaluator_input, evaluator_data)
+                    evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
             # if evaluator_input is a list
             elif isinstance(evaluator_data, list):
                 evaluator_data = sort_collections(evaluator_data)
@@ -38,46 +38,40 @@ def evaluate(self, evaluator_input, evaluator_data):
                     result = evaluator_input not in evaluator_data
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Did not find {} inside {}".format(
-                            evaluator_input, evaluator_data
-                        )
+                        evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
                     else:
-                        evaluation_result["message"] = "Found {} inside {}".format(evaluator_input, evaluator_data)
+                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
                 else:
                     result = evaluator_input not in evaluator_data
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Did not find {} inside {}".format(
-                            evaluator_input, evaluator_data
-                        )
+                        evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
                     else:
-                        evaluation_result["message"] = "Found {} inside {}".format(evaluator_input, evaluator_data)
+                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
             elif isinstance(evaluator_data, dict):
                 if isinstance(evaluator_input, dict):
                     evaluation_result["passed"] = True
-                    evaluation_result["message"] = "Did not find {} inside {}".format(evaluator_input, evaluator_data)
+                    evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
                     for key in evaluator_input:
                         if key not in evaluator_data:
                             continue
 
                         if evaluator_data[key] == evaluator_input[key]:
                             evaluation_result["passed"] = False
-                            evaluation_result["message"] = "Found {} inside {}".format(evaluator_input, evaluator_data)
+                            evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
                             break
                 else:
                     result = evaluator_input not in evaluator_data
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Did not find {} inside {}".format(
-                            evaluator_input, evaluator_data
-                        )
+                        evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
                     else:
-                        evaluation_result["message"] = "Found {} inside {}".format(evaluator_input, evaluator_data)
+                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
             else:
                 evaluation_result["passed"] = False
                 evaluation_result["message"] = (
                     "{} is an unsupported data type for evaluating against value in 'condition.value'".format(
-                        evaluator_data
+                        json_format_value(evaluator_data)
                     )
                 )
             return evaluation_result
diff --git a/src/tirith/core/evaluators/not_contains.py b/src/tirith/core/evaluators/not_contains.py
index 7f336a69..c1678f3f 100644
--- a/src/tirith/core/evaluators/not_contains.py
+++ b/src/tirith/core/evaluators/not_contains.py
@@ -1,7 +1,7 @@
 import logging
 
 from .base_evaluator import BaseEvaluator
-from tirith.utils import sort_collections
+from tirith.utils import sort_collections, json_format_value
 
 
 logger = logging.getLogger(__name__)
@@ -38,9 +38,9 @@ def evaluate(self, evaluator_input, evaluator_data):
                 result = evaluator_data not in evaluator_input
                 evaluation_result["passed"] = result
                 if result:
-                    evaluation_result["message"] = "Did not find {} inside {}".format(evaluator_data, evaluator_input)
+                    evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
                 else:
-                    evaluation_result["message"] = "Found {} inside {}".format(evaluator_data, evaluator_input)
+                    evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
             # if evaluator_input is a list
             elif isinstance(evaluator_input, list):
                 evaluator_input = sort_collections(evaluator_input)
@@ -53,7 +53,7 @@ def evaluate(self, evaluator_input, evaluator_data):
                             evaluator_data, evaluator_input
                         )
                     else:
-                        evaluation_result["message"] = "Found {} inside {}".format(evaluator_data, evaluator_input)
+                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
                 else:
                     result = evaluator_data not in evaluator_input
                     evaluation_result["passed"] = result
@@ -62,34 +62,32 @@ def evaluate(self, evaluator_input, evaluator_data):
                             evaluator_data, evaluator_input
                         )
                     else:
-                        evaluation_result["message"] = "Found {} inside {}".format(evaluator_data, evaluator_input)
+                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
             elif isinstance(evaluator_input, dict):
                 if isinstance(evaluator_data, dict):
                     evaluation_result["passed"] = True
-                    evaluation_result["message"] = "Did not find {} inside {}".format(evaluator_data, evaluator_input)
+                    evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
                     for key in evaluator_data:
                         if key not in evaluator_input:
                             continue
 
                         if evaluator_input[key] == evaluator_data[key]:  # changes for xontains
                             evaluation_result["passed"] = False
-                            evaluation_result["message"] = "Found {} inside {}".format(evaluator_data, evaluator_input)
+                            evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
                             break
                 else:
                     result = evaluator_data not in evaluator_input
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Did not find {} inside {}".format(
-                            evaluator_data, evaluator_input
-                        )
+                        evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
                     else:
-                        evaluation_result["message"] = "Found {} inside {}".format(evaluator_data, evaluator_input)
+                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
 
             else:
                 evaluation_result["passed"] = False
                 evaluation_result["message"] = (
                     "{} is an unsupported data type for evaluating against value in 'condition.value'".format(
-                        evaluator_data
+                        json_format_value(evaluator_data)
                     )
                 )
             return evaluation_result
diff --git a/src/tirith/core/evaluators/not_equals.py b/src/tirith/core/evaluators/not_equals.py
index 516ecb07..806626a4 100644
--- a/src/tirith/core/evaluators/not_equals.py
+++ b/src/tirith/core/evaluators/not_equals.py
@@ -1,7 +1,8 @@
 import logging
+from typing import Dict, Any
 
 from .base_evaluator import BaseEvaluator
-from tirith.utils import sort_collections
+from tirith.utils import sort_collections,json_format_value
 
 logger = logging.getLogger(__name__)
 
@@ -41,9 +42,13 @@ def evaluate(self, evaluator_input, evaluator_data):
             result = value1 != value2
             evaluation_result["passed"] = result
             if result:
-                evaluation_result["message"] = "{} is not equal to {}".format(evaluator_input, evaluator_data)
+                evaluation_result["message"] = "{} is not equal to {}".format(
+                    json_format_value(evaluator_input), json_format_value(evaluator_data)
+                )
             else:
-                evaluation_result["message"] = "{} is equal to {}".format(evaluator_input, evaluator_data)
+                evaluation_result["message"] = "{} is equal to {}".format(
+                    json_format_value(evaluator_input), json_format_value(evaluator_data)
+                )
             return evaluation_result
         except Exception as e:
             evaluation_result["message"] = str(e)
diff --git a/src/tirith/core/evaluators/regex_match.py b/src/tirith/core/evaluators/regex_match.py
index 73de6043..3338ccf9 100644
--- a/src/tirith/core/evaluators/regex_match.py
+++ b/src/tirith/core/evaluators/regex_match.py
@@ -1,5 +1,9 @@
-from .base_evaluator import BaseEvaluator
+import logging
 import re
+from typing import Dict, Any
+
+from .base_evaluator import BaseEvaluator
+from tirith.utils import json_format_value
 
 
 class RegexMatch(BaseEvaluator):
@@ -13,17 +17,23 @@ def evaluate(self, evaluator_input, evaluator_data):
                 if match is None:
                     evaluation_result = {
                         "passed": False,
-                        "message": "{} does not match regex pattern {}".format(evaluator_input, evaluator_data),
+                        "message": "{} does not match regex pattern {}".format(
+                            json_format_value(evaluator_input), json_format_value(evaluator_data)
+                        ),
                     }
                 else:
                     evaluation_result = {
                         "passed": True,
-                        "message": "{} matches regex pattern {}".format(evaluator_input, evaluator_data),
+                        "message": "{} matches regex pattern {}".format(
+                            json_format_value(evaluator_input), json_format_value(evaluator_data)
+                        ),
                     }
             else:
                 evaluation_result = {
                     "passed": False,
-                    "message": "{} does not match regex pattern {}".format(evaluator_input, evaluator_data),
+                    "message": "{} does not match regex pattern {}".format(
+                        json_format_value(evaluator_input), json_format_value(evaluator_data)
+                    ),
                 }
             return evaluation_result
         except Exception as e:
diff --git a/src/tirith/utils.py b/src/tirith/utils.py
index 1666b5b1..9662c8a3 100644
--- a/src/tirith/utils.py
+++ b/src/tirith/utils.py
@@ -1,7 +1,32 @@
 import logging
-
+import json
 logger = logging.getLogger(__name__)
+from typing import Any
+
 
+def json_format_value(value: Any) -> str:
+    """
+    Format a Python value as a JSON string representation.
+    This produces a more language-agnostic representation of values that's
+    suitable for displaying in evaluation messages.
+    
+    Args:
+        value: Any Python value
+        
+    Returns:
+        A JSON-formatted string representation of the value, enclosed in backticks
+    """
+    try:
+        # Special case for None as JSON's null isn't as recognizable
+        if value is None:
+            return "`None`"
+        
+        # For basic types, use JSON representation
+        json_str = json.dumps(value)
+        return f"`{json_str}`"
+    except (TypeError, ValueError):
+        # Fall back to string representation for non-JSON-serializable values
+        return f"`{str(value)}`"
 
 def sort_collections(inputs):
     try:
diff --git a/tests/core/evaluators/test_equals.py b/tests/core/evaluators/test_equals.py
index 57ea9883..b9530372 100644
--- a/tests/core/evaluators/test_equals.py
+++ b/tests/core/evaluators/test_equals.py
@@ -13,7 +13,7 @@
 @mark.parametrize("evaluator_input,evaluator_data", checks_passing)
 def test_evaluate_passing(evaluator_input, evaluator_data):
     result = evaluator.evaluate(evaluator_input, evaluator_data)
-    assert result == {"passed": True, "message": f"{evaluator_input} is equal to {evaluator_data}"}
+    assert result == {"passed": True, "message": f"`{evaluator_input}` is equal to `{evaluator_data}`"}
 
 
 # pytest -v -m failing
@@ -21,4 +21,4 @@ def test_evaluate_passing(evaluator_input, evaluator_data):
 @mark.parametrize("evaluator_input,evaluator_data", checks_failing)
 def test_evaluate_failing(evaluator_input, evaluator_data):
     result = evaluator.evaluate(evaluator_input, evaluator_data)
-    assert result == {"passed": False, "message": f"{evaluator_input} is not equal to {evaluator_data}"}
+    assert result == {"passed": False, "message": f"`{evaluator_input}` is not equal to `{evaluator_data}`"}
diff --git a/tests/core/evaluators/test_greater_than.py b/tests/core/evaluators/test_greater_than.py
index 7c7e27e7..8da0c432 100644
--- a/tests/core/evaluators/test_greater_than.py
+++ b/tests/core/evaluators/test_greater_than.py
@@ -14,11 +14,11 @@
 @mark.passing
 def test_evaluate_passing():
     result = evaluator.evaluate(evaluator_input1, evaluator_data1)
-    assert result == {"passed": True, "message": f"{evaluator_input1} is greater than {evaluator_data1}"}
+    assert result == {"passed": True, "message": f"`{evaluator_input1}` is greater than `{evaluator_data1}`"}
 
 
 # pytest -v -m failing
 @mark.failing
 def test_evaluate_failing():
     result = evaluator.evaluate(evaluator_input2, evaluator_data2)
-    assert result == {"passed": False, "message": f"{evaluator_input2} is not greater than {evaluator_data2}"}
+    assert result == {"passed": False, "message": f"`{evaluator_input2}` is not greater than `{evaluator_data2}`"}
diff --git a/tests/core/evaluators/test_greater_than_equal_to.py b/tests/core/evaluators/test_greater_than_equal_to.py
index 112b347f..20fae9ba 100644
--- a/tests/core/evaluators/test_greater_than_equal_to.py
+++ b/tests/core/evaluators/test_greater_than_equal_to.py
@@ -14,7 +14,7 @@
 @mark.passing
 def test_evaluate_passing():
     result = evaluator.evaluate(evaluator_input1, evaluator_data1)
-    assert result == {"passed": True, "message": f"{evaluator_input1} is greater than equal to {evaluator_data1}"}
+    assert result == {"passed": True, "message": f"`{evaluator_input1}` is greater than equal to `{evaluator_data1}`"}
 
 
 # pytest -v -m failing
@@ -23,5 +23,5 @@ def test_evaluate_failing():
     result = evaluator.evaluate(evaluator_input2, evaluator_data2)
     assert result == {
         "passed": False,
-        "message": f"{evaluator_input2} is not greater than or equal to {evaluator_data2}",
+        "message": f"`{evaluator_input2}` is not greater than or equal to `{evaluator_data2}`",
     }
diff --git a/tests/core/evaluators/test_is_empty.py b/tests/core/evaluators/test_is_empty.py
index b03c5a32..6bf2155f 100644
--- a/tests/core/evaluators/test_is_empty.py
+++ b/tests/core/evaluators/test_is_empty.py
@@ -1,6 +1,6 @@
 from tirith.core.evaluators import IsEmpty
 from pytest import mark
-
+from tirith.utils import json_format_value
 checks_passing = ("", None, [], dict())
 checks_failing = ("stackguardian", 1, [None], dict(a=1))
 
@@ -11,11 +11,11 @@
 @mark.parametrize("evaluator_input", checks_passing)
 def test_evaluate_passing(evaluator_input):
     result = evaluator.evaluate(evaluator_input)
-    assert result == {"message": f"{evaluator_input} is empty", "passed": True}
+    assert result == {"message": f"{json_format_value(evaluator_input)} is empty", "passed": True}
 
 
 @mark.passing
 @mark.parametrize("evaluator_input", checks_failing)
 def test_evaluate_failing(evaluator_input):
     result = evaluator.evaluate(evaluator_input)
-    assert result == {"message": f"{evaluator_input} is not empty", "passed": False}
+    assert result == {"message": f"{json_format_value(evaluator_input)} is not empty", "passed": False}
diff --git a/tests/core/evaluators/test_is_not_empty.py b/tests/core/evaluators/test_is_not_empty.py
index d708e62f..2d5cea26 100644
--- a/tests/core/evaluators/test_is_not_empty.py
+++ b/tests/core/evaluators/test_is_not_empty.py
@@ -1,6 +1,6 @@
 from tirith.core.evaluators import IsNotEmpty
 from pytest import mark
-
+from tirith.utils import json_format_value
 evaluator_input1 = "abc"
 evaluator_input2 = ""
 
@@ -11,11 +11,11 @@
 @mark.passing
 def test_evaluate_passing():
     result = evaluator.evaluate(evaluator_input1)
-    assert result == {"passed": True, "message": f"{evaluator_input1} is not empty"}
+    assert result == {"passed": True, "message": f"{json_format_value(evaluator_input1)} is not empty"}
 
 
 # pytest -v -m passing
 @mark.failing
 def test_evaluate_passing():
     result = evaluator.evaluate(evaluator_input2)
-    assert result == {"passed": False, "message": f"{evaluator_input2} is empty"}
+    assert result == {"passed": False, "message": f"{json_format_value(evaluator_input2)} is empty"}
diff --git a/tests/core/evaluators/test_less_than.py b/tests/core/evaluators/test_less_than.py
index 881b5ca0..e4efff4f 100644
--- a/tests/core/evaluators/test_less_than.py
+++ b/tests/core/evaluators/test_less_than.py
@@ -14,11 +14,11 @@
 @mark.passing
 def test_evaluate_passing():
     result = evaluator.evaluate(evaluator_input1, evaluator_data1)
-    assert result == {"passed": True, "message": f"{evaluator_input1} is less than {evaluator_data1}"}
+    assert result == {"passed": True, "message": f"`{evaluator_input1}` is less than `{evaluator_data1}`"}
 
 
 # pytest -v -m failing
 @mark.failing
 def test_evaluate_failing():
     result = evaluator.evaluate(evaluator_input2, evaluator_data2)
-    assert result == {"passed": False, "message": f"{evaluator_input2} is not less than {evaluator_data2}"}
+    assert result == {"passed": False, "message": f"`{evaluator_input2}` is not less than `{evaluator_data2}`"}
diff --git a/tests/core/evaluators/test_less_than_equal_to.py b/tests/core/evaluators/test_less_than_equal_to.py
index 5d9ff7a8..3a3a9f1b 100644
--- a/tests/core/evaluators/test_less_than_equal_to.py
+++ b/tests/core/evaluators/test_less_than_equal_to.py
@@ -1,6 +1,6 @@
 from tirith.core.evaluators import LessThanEqualTo
 from pytest import mark
-
+from tirith.utils import json_format_value
 evaluator_input1 = 26
 evaluator_data1 = 27
 
@@ -14,11 +14,11 @@
 @mark.passing
 def test_evaluate_passing():
     result = evaluator.evaluate(evaluator_input1, evaluator_data1)
-    assert result == {"passed": True, "message": f"{evaluator_input1} is less than equal to {evaluator_data1}"}
+    assert result == {"passed": True, "message": f"{json_format_value(evaluator_input1)} is less than equal to {json_format_value(evaluator_data1)}"}
 
 
 # pytest -v -m failing
 @mark.failing
 def test_evaluate_failing():
     result = evaluator.evaluate(evaluator_input2, evaluator_data2)
-    assert result == {"passed": False, "message": f"{evaluator_input2} is not less than or equal to {evaluator_data2}"}
+    assert result == {"passed": False, "message": f"{json_format_value(evaluator_input2)} is not less than or equal to {json_format_value(evaluator_data2)}"}
diff --git a/tests/core/evaluators/test_not_equals.py b/tests/core/evaluators/test_not_equals.py
index d76707c3..992734c5 100644
--- a/tests/core/evaluators/test_not_equals.py
+++ b/tests/core/evaluators/test_not_equals.py
@@ -13,7 +13,7 @@
 @mark.parametrize("evaluator_input,evaluator_data", checks_passing)
 def test_evaluate_passing(evaluator_input, evaluator_data):
     result = evaluator.evaluate(evaluator_input, evaluator_data)
-    assert result == {"passed": True, "message": f"{evaluator_input} is not equal to {evaluator_data}"}
+    assert result == {"passed": True, "message": f"`{evaluator_input}` is not equal to `{evaluator_data}`"}
 
 
 # pytest -v -m failing
@@ -21,4 +21,4 @@ def test_evaluate_passing(evaluator_input, evaluator_data):
 @mark.parametrize("evaluator_input,evaluator_data", checks_failing)
 def test_evaluate_failing(evaluator_input, evaluator_data):
     result = evaluator.evaluate(evaluator_input, evaluator_data)
-    assert result == {"passed": False, "message": f"{evaluator_input} is equal to {evaluator_data}"}
+    assert result == {"passed": False, "message": f"`{evaluator_input}` is equal to `{evaluator_data}`"}
diff --git a/tests/core/evaluators/test_regex_match.py b/tests/core/evaluators/test_regex_match.py
index 3b4e1297..7a51e65b 100644
--- a/tests/core/evaluators/test_regex_match.py
+++ b/tests/core/evaluators/test_regex_match.py
@@ -1,6 +1,6 @@
 from tirith.core.evaluators import RegexMatch
 from pytest import mark
-
+from tirith.utils import json_format_value
 evaluator_data1 = "^(?=[a-zA-Z0-9._]{8,20}$)(?!.*[_.]{2})[^_.].*[^_.]$"
 evaluator_input1 = "amitrakshar01"
 
@@ -14,14 +14,14 @@
 @mark.passing
 def test_regex_passing():
     result = evaluator.evaluate(evaluator_input1, evaluator_data1)
-    assert result == {"passed": True, "message": f"{evaluator_input1} matches regex pattern {evaluator_data1}"}
+    assert result == {"passed": True, "message": f"{json_format_value(evaluator_input1)} matches regex pattern {json_format_value(evaluator_data1)}"}
 
 
 # pytest -v -m failing
 @mark.failing
 def test_regex_failing():
     result = evaluator.evaluate(evaluator_input2, evaluator_data2)
-    assert result == {"passed": False, "message": f"{evaluator_input2} does not match regex pattern {evaluator_data2}"}
+    assert result == {"passed": False, "message": f"{json_format_value(evaluator_input2)} does not match regex pattern {json_format_value(evaluator_data2)}"}
 
 
 def test_regex_list():

From bc179a7745921e7b08b585e9472bb31e11adffcf Mon Sep 17 00:00:00 2001
From: Akash S <akashsuresh0510@gmail.com>
Date: Tue, 13 May 2025 15:31:19 +0530
Subject: [PATCH 2/7] black formatting

---
 src/tirith/core/evaluators/contained_in.py    | 38 +++++++++++++-----
 src/tirith/core/evaluators/contains.py        | 38 +++++++++++++-----
 .../core/evaluators/greater_than_equal_to.py  |  1 +
 src/tirith/core/evaluators/is_empty.py        |  1 +
 src/tirith/core/evaluators/is_not_empty.py    |  1 +
 src/tirith/core/evaluators/less_than.py       |  1 +
 .../core/evaluators/less_than_equal_to.py     |  1 +
 .../core/evaluators/not_contained_in.py       | 40 ++++++++++++++-----
 src/tirith/core/evaluators/not_contains.py    | 32 +++++++++++----
 src/tirith/core/evaluators/not_equals.py      |  2 +-
 src/tirith/utils.py                           |  8 ++--
 tests/core/evaluators/test_is_empty.py        |  1 +
 tests/core/evaluators/test_is_not_empty.py    |  1 +
 .../evaluators/test_less_than_equal_to.py     | 11 ++++-
 tests/core/evaluators/test_regex_match.py     | 11 ++++-
 15 files changed, 141 insertions(+), 46 deletions(-)

diff --git a/src/tirith/core/evaluators/contained_in.py b/src/tirith/core/evaluators/contained_in.py
index aab8dc00..316820ce 100644
--- a/src/tirith/core/evaluators/contained_in.py
+++ b/src/tirith/core/evaluators/contained_in.py
@@ -1,7 +1,7 @@
 import logging
 
 from .base_evaluator import BaseEvaluator
-from tirith.utils import sort_collections,json_format_value
+from tirith.utils import sort_collections, json_format_value
 
 logger = logging.getLogger(__name__)
 
@@ -37,7 +37,9 @@ def evaluate(self, evaluator_input, evaluator_data):
                 result = evaluator_input in evaluator_data
                 evaluation_result["passed"] = result
                 if result:
-                    evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                    evaluation_result["message"] = "Found {} inside {}".format(
+                        json_format_value(evaluator_input), json_format_value(evaluator_data)
+                    )
             # if evaluator_input is a list
             elif isinstance(evaluator_data, list):
                 evaluator_data = sort_collections(evaluator_data)
@@ -46,35 +48,51 @@ def evaluate(self, evaluator_input, evaluator_data):
                     result = evaluator_input in evaluator_data
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                        evaluation_result["message"] = "Found {} inside {}".format(
+                            json_format_value(evaluator_input), json_format_value(evaluator_data)
+                        )
                     else:
-                        evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                        evaluation_result["message"] = "Failed to find {} inside {}".format(
+                            json_format_value(evaluator_input), json_format_value(evaluator_data)
+                        )
                 else:
                     result = evaluator_input in evaluator_data
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                        evaluation_result["message"] = "Found {} inside {}".format(
+                            json_format_value(evaluator_input), json_format_value(evaluator_data)
+                        )
                     else:
-                        evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                        evaluation_result["message"] = "Failed to find {} inside {}".format(
+                            json_format_value(evaluator_input), json_format_value(evaluator_data)
+                        )
             elif isinstance(evaluator_data, dict):
                 if isinstance(evaluator_input, dict):
                     evaluation_result["passed"] = True
-                    evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                    evaluation_result["message"] = "Found {} inside {}".format(
+                        json_format_value(evaluator_input), json_format_value(evaluator_data)
+                    )
                     for key in evaluator_input:
                         if key in evaluator_data:
                             if evaluator_data[key] != evaluator_input[key]:
                                 evaluation_result["passed"] = False
-                                evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                                evaluation_result["message"] = "Failed to find {} inside {}".format(
+                                    json_format_value(evaluator_input), json_format_value(evaluator_data)
+                                )
                                 break
                         else:
                             evaluation_result["passed"] = False
-                            evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                            evaluation_result["message"] = "Failed to find {} inside {}".format(
+                                json_format_value(evaluator_input), json_format_value(evaluator_data)
+                            )
                             break
                 else:
                     result = evaluator_input in evaluator_data
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                        evaluation_result["message"] = "Found {} inside {}".format(
+                            json_format_value(evaluator_input), json_format_value(evaluator_data)
+                        )
             else:
                 evaluation_result["message"] = (
                     "{} is an unsupported data type for evaluating against value in 'condition.value'".format(
diff --git a/src/tirith/core/evaluators/contains.py b/src/tirith/core/evaluators/contains.py
index 58d5d521..7b302fb8 100644
--- a/src/tirith/core/evaluators/contains.py
+++ b/src/tirith/core/evaluators/contains.py
@@ -1,7 +1,7 @@
 import logging
 
 from .base_evaluator import BaseEvaluator
-from tirith.utils import sort_collections,json_format_value
+from tirith.utils import sort_collections, json_format_value
 
 
 logger = logging.getLogger(__name__)
@@ -38,7 +38,9 @@ def evaluate(self, evaluator_input, evaluator_data):
                 result = evaluator_data in evaluator_input
                 evaluation_result["passed"] = result
                 if result:
-                    evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                    evaluation_result["message"] = "Found {} inside {}".format(
+                        json_format_value(evaluator_data), json_format_value(evaluator_input)
+                    )
             # if evaluator_input is a list
             elif isinstance(evaluator_input, list):
                 evaluator_input = sort_collections(evaluator_input)
@@ -47,35 +49,51 @@ def evaluate(self, evaluator_input, evaluator_data):
                     result = evaluator_data in evaluator_input
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                        evaluation_result["message"] = "Found {} inside {}".format(
+                            json_format_value(evaluator_data), json_format_value(evaluator_input)
+                        )
                     else:
-                        evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                        evaluation_result["message"] = "Failed to find {} inside {}".format(
+                            json_format_value(evaluator_data), json_format_value(evaluator_input)
+                        )
                 else:
                     result = evaluator_data in evaluator_input
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                        evaluation_result["message"] = "Found {} inside {}".format(
+                            json_format_value(evaluator_data), json_format_value(evaluator_input)
+                        )
                     else:
-                        evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                        evaluation_result["message"] = "Failed to find {} inside {}".format(
+                            json_format_value(evaluator_data), json_format_value(evaluator_input)
+                        )
             elif isinstance(evaluator_input, dict):
                 if isinstance(evaluator_data, dict):
                     evaluation_result["passed"] = True
-                    evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                    evaluation_result["message"] = "Found {} inside {}".format(
+                        json_format_value(evaluator_data), json_format_value(evaluator_input)
+                    )
                     for key in evaluator_data:
                         if key in evaluator_input:
                             if evaluator_input[key] != evaluator_data[key]:
                                 evaluation_result["passed"] = False
-                                evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                                evaluation_result["message"] = "Failed to find {} inside {}".format(
+                                    json_format_value(evaluator_data), json_format_value(evaluator_input)
+                                )
                                 break
                         else:
                             evaluation_result["passed"] = False
-                            evaluation_result["message"] = "Failed to find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                            evaluation_result["message"] = "Failed to find {} inside {}".format(
+                                json_format_value(evaluator_data), json_format_value(evaluator_input)
+                            )
                             break
                 else:
                     result = evaluator_data in evaluator_input
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                        evaluation_result["message"] = "Found {} inside {}".format(
+                            json_format_value(evaluator_data), json_format_value(evaluator_input)
+                        )
             else:
                 evaluation_result["message"] = (
                     "{} is an unsupported data type for evaluating against value in 'condition.value'".format(
diff --git a/src/tirith/core/evaluators/greater_than_equal_to.py b/src/tirith/core/evaluators/greater_than_equal_to.py
index e7830325..078cb5f2 100644
--- a/src/tirith/core/evaluators/greater_than_equal_to.py
+++ b/src/tirith/core/evaluators/greater_than_equal_to.py
@@ -2,6 +2,7 @@
 from typing import Dict, Any
 from .base_evaluator import BaseEvaluator
 from tirith.utils import json_format_value
+
 # Checks if :attr:`value` is more then or equal to :attr:`other`. Automatically casts values to the same type if possible.
 
 # Args:
diff --git a/src/tirith/core/evaluators/is_empty.py b/src/tirith/core/evaluators/is_empty.py
index e5fa0b73..6fbf4d0d 100644
--- a/src/tirith/core/evaluators/is_empty.py
+++ b/src/tirith/core/evaluators/is_empty.py
@@ -3,6 +3,7 @@
 
 from .base_evaluator import BaseEvaluator
 from tirith.utils import json_format_value
+
 # Checks if input is empty (null, empty list [], empty dict {}, empty str '')
 
 # Args:
diff --git a/src/tirith/core/evaluators/is_not_empty.py b/src/tirith/core/evaluators/is_not_empty.py
index ee40e831..02bf59b3 100644
--- a/src/tirith/core/evaluators/is_not_empty.py
+++ b/src/tirith/core/evaluators/is_not_empty.py
@@ -1,5 +1,6 @@
 from .base_evaluator import BaseEvaluator
 from tirith.utils import json_format_value
+
 # Checks if input is not empty
 
 # Args:
diff --git a/src/tirith/core/evaluators/less_than.py b/src/tirith/core/evaluators/less_than.py
index 3bf6d5e3..abe7b195 100644
--- a/src/tirith/core/evaluators/less_than.py
+++ b/src/tirith/core/evaluators/less_than.py
@@ -3,6 +3,7 @@
 
 from .base_evaluator import BaseEvaluator
 from tirith.utils import json_format_value
+
 # Checks if :attr:`value` is less then :attr:`other`. Automatically casts values to the same type if possible.
 
 # Args:
diff --git a/src/tirith/core/evaluators/less_than_equal_to.py b/src/tirith/core/evaluators/less_than_equal_to.py
index 594c64c2..75cc47bc 100644
--- a/src/tirith/core/evaluators/less_than_equal_to.py
+++ b/src/tirith/core/evaluators/less_than_equal_to.py
@@ -3,6 +3,7 @@
 
 from .base_evaluator import BaseEvaluator
 from tirith.utils import json_format_value
+
 # Checks if :attr:`value` is less then or equal to :attr:`other`. Automatically casts values to the same type if possible.
 
 # Args:
diff --git a/src/tirith/core/evaluators/not_contained_in.py b/src/tirith/core/evaluators/not_contained_in.py
index e4940cba..4274a4f6 100644
--- a/src/tirith/core/evaluators/not_contained_in.py
+++ b/src/tirith/core/evaluators/not_contained_in.py
@@ -27,9 +27,13 @@ def evaluate(self, evaluator_input, evaluator_data):
                 result = evaluator_input not in evaluator_data
                 evaluation_result["passed"] = result
                 if result:
-                    evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                    evaluation_result["message"] = "Did not find {} inside {}".format(
+                        json_format_value(evaluator_input), json_format_value(evaluator_data)
+                    )
                 else:
-                    evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                    evaluation_result["message"] = "Found {} inside {}".format(
+                        json_format_value(evaluator_input), json_format_value(evaluator_data)
+                    )
             # if evaluator_input is a list
             elif isinstance(evaluator_data, list):
                 evaluator_data = sort_collections(evaluator_data)
@@ -38,35 +42,51 @@ def evaluate(self, evaluator_input, evaluator_data):
                     result = evaluator_input not in evaluator_data
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                        evaluation_result["message"] = "Did not find {} inside {}".format(
+                            json_format_value(evaluator_input), json_format_value(evaluator_data)
+                        )
                     else:
-                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                        evaluation_result["message"] = "Found {} inside {}".format(
+                            json_format_value(evaluator_input), json_format_value(evaluator_data)
+                        )
                 else:
                     result = evaluator_input not in evaluator_data
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                        evaluation_result["message"] = "Did not find {} inside {}".format(
+                            json_format_value(evaluator_input), json_format_value(evaluator_data)
+                        )
                     else:
-                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                        evaluation_result["message"] = "Found {} inside {}".format(
+                            json_format_value(evaluator_input), json_format_value(evaluator_data)
+                        )
             elif isinstance(evaluator_data, dict):
                 if isinstance(evaluator_input, dict):
                     evaluation_result["passed"] = True
-                    evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                    evaluation_result["message"] = "Did not find {} inside {}".format(
+                        json_format_value(evaluator_input), json_format_value(evaluator_data)
+                    )
                     for key in evaluator_input:
                         if key not in evaluator_data:
                             continue
 
                         if evaluator_data[key] == evaluator_input[key]:
                             evaluation_result["passed"] = False
-                            evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                            evaluation_result["message"] = "Found {} inside {}".format(
+                                json_format_value(evaluator_input), json_format_value(evaluator_data)
+                            )
                             break
                 else:
                     result = evaluator_input not in evaluator_data
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                        evaluation_result["message"] = "Did not find {} inside {}".format(
+                            json_format_value(evaluator_input), json_format_value(evaluator_data)
+                        )
                     else:
-                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_input),json_format_value( evaluator_data))
+                        evaluation_result["message"] = "Found {} inside {}".format(
+                            json_format_value(evaluator_input), json_format_value(evaluator_data)
+                        )
             else:
                 evaluation_result["passed"] = False
                 evaluation_result["message"] = (
diff --git a/src/tirith/core/evaluators/not_contains.py b/src/tirith/core/evaluators/not_contains.py
index c1678f3f..9ed5afab 100644
--- a/src/tirith/core/evaluators/not_contains.py
+++ b/src/tirith/core/evaluators/not_contains.py
@@ -38,9 +38,13 @@ def evaluate(self, evaluator_input, evaluator_data):
                 result = evaluator_data not in evaluator_input
                 evaluation_result["passed"] = result
                 if result:
-                    evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                    evaluation_result["message"] = "Did not find {} inside {}".format(
+                        json_format_value(evaluator_data), json_format_value(evaluator_input)
+                    )
                 else:
-                    evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                    evaluation_result["message"] = "Found {} inside {}".format(
+                        json_format_value(evaluator_data), json_format_value(evaluator_input)
+                    )
             # if evaluator_input is a list
             elif isinstance(evaluator_input, list):
                 evaluator_input = sort_collections(evaluator_input)
@@ -53,7 +57,9 @@ def evaluate(self, evaluator_input, evaluator_data):
                             evaluator_data, evaluator_input
                         )
                     else:
-                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                        evaluation_result["message"] = "Found {} inside {}".format(
+                            json_format_value(evaluator_data), json_format_value(evaluator_input)
+                        )
                 else:
                     result = evaluator_data not in evaluator_input
                     evaluation_result["passed"] = result
@@ -62,26 +68,36 @@ def evaluate(self, evaluator_input, evaluator_data):
                             evaluator_data, evaluator_input
                         )
                     else:
-                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                        evaluation_result["message"] = "Found {} inside {}".format(
+                            json_format_value(evaluator_data), json_format_value(evaluator_input)
+                        )
             elif isinstance(evaluator_input, dict):
                 if isinstance(evaluator_data, dict):
                     evaluation_result["passed"] = True
-                    evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                    evaluation_result["message"] = "Did not find {} inside {}".format(
+                        json_format_value(evaluator_data), json_format_value(evaluator_input)
+                    )
                     for key in evaluator_data:
                         if key not in evaluator_input:
                             continue
 
                         if evaluator_input[key] == evaluator_data[key]:  # changes for xontains
                             evaluation_result["passed"] = False
-                            evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                            evaluation_result["message"] = "Found {} inside {}".format(
+                                json_format_value(evaluator_data), json_format_value(evaluator_input)
+                            )
                             break
                 else:
                     result = evaluator_data not in evaluator_input
                     evaluation_result["passed"] = result
                     if result:
-                        evaluation_result["message"] = "Did not find {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                        evaluation_result["message"] = "Did not find {} inside {}".format(
+                            json_format_value(evaluator_data), json_format_value(evaluator_input)
+                        )
                     else:
-                        evaluation_result["message"] = "Found {} inside {}".format(json_format_value(evaluator_data),json_format_value( evaluator_input))
+                        evaluation_result["message"] = "Found {} inside {}".format(
+                            json_format_value(evaluator_data), json_format_value(evaluator_input)
+                        )
 
             else:
                 evaluation_result["passed"] = False
diff --git a/src/tirith/core/evaluators/not_equals.py b/src/tirith/core/evaluators/not_equals.py
index 806626a4..ebe5cd45 100644
--- a/src/tirith/core/evaluators/not_equals.py
+++ b/src/tirith/core/evaluators/not_equals.py
@@ -2,7 +2,7 @@
 from typing import Dict, Any
 
 from .base_evaluator import BaseEvaluator
-from tirith.utils import sort_collections,json_format_value
+from tirith.utils import sort_collections, json_format_value
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/tirith/utils.py b/src/tirith/utils.py
index 9662c8a3..5d61aef5 100644
--- a/src/tirith/utils.py
+++ b/src/tirith/utils.py
@@ -1,5 +1,6 @@
 import logging
 import json
+
 logger = logging.getLogger(__name__)
 from typing import Any
 
@@ -9,10 +10,10 @@ def json_format_value(value: Any) -> str:
     Format a Python value as a JSON string representation.
     This produces a more language-agnostic representation of values that's
     suitable for displaying in evaluation messages.
-    
+
     Args:
         value: Any Python value
-        
+
     Returns:
         A JSON-formatted string representation of the value, enclosed in backticks
     """
@@ -20,7 +21,7 @@ def json_format_value(value: Any) -> str:
         # Special case for None as JSON's null isn't as recognizable
         if value is None:
             return "`None`"
-        
+
         # For basic types, use JSON representation
         json_str = json.dumps(value)
         return f"`{json_str}`"
@@ -28,6 +29,7 @@ def json_format_value(value: Any) -> str:
         # Fall back to string representation for non-JSON-serializable values
         return f"`{str(value)}`"
 
+
 def sort_collections(inputs):
     try:
         if isinstance(inputs, (str, float, int, bool)):
diff --git a/tests/core/evaluators/test_is_empty.py b/tests/core/evaluators/test_is_empty.py
index 6bf2155f..0cd2149d 100644
--- a/tests/core/evaluators/test_is_empty.py
+++ b/tests/core/evaluators/test_is_empty.py
@@ -1,6 +1,7 @@
 from tirith.core.evaluators import IsEmpty
 from pytest import mark
 from tirith.utils import json_format_value
+
 checks_passing = ("", None, [], dict())
 checks_failing = ("stackguardian", 1, [None], dict(a=1))
 
diff --git a/tests/core/evaluators/test_is_not_empty.py b/tests/core/evaluators/test_is_not_empty.py
index 2d5cea26..c77666f4 100644
--- a/tests/core/evaluators/test_is_not_empty.py
+++ b/tests/core/evaluators/test_is_not_empty.py
@@ -1,6 +1,7 @@
 from tirith.core.evaluators import IsNotEmpty
 from pytest import mark
 from tirith.utils import json_format_value
+
 evaluator_input1 = "abc"
 evaluator_input2 = ""
 
diff --git a/tests/core/evaluators/test_less_than_equal_to.py b/tests/core/evaluators/test_less_than_equal_to.py
index 3a3a9f1b..7aa09005 100644
--- a/tests/core/evaluators/test_less_than_equal_to.py
+++ b/tests/core/evaluators/test_less_than_equal_to.py
@@ -1,6 +1,7 @@
 from tirith.core.evaluators import LessThanEqualTo
 from pytest import mark
 from tirith.utils import json_format_value
+
 evaluator_input1 = 26
 evaluator_data1 = 27
 
@@ -14,11 +15,17 @@
 @mark.passing
 def test_evaluate_passing():
     result = evaluator.evaluate(evaluator_input1, evaluator_data1)
-    assert result == {"passed": True, "message": f"{json_format_value(evaluator_input1)} is less than equal to {json_format_value(evaluator_data1)}"}
+    assert result == {
+        "passed": True,
+        "message": f"{json_format_value(evaluator_input1)} is less than equal to {json_format_value(evaluator_data1)}",
+    }
 
 
 # pytest -v -m failing
 @mark.failing
 def test_evaluate_failing():
     result = evaluator.evaluate(evaluator_input2, evaluator_data2)
-    assert result == {"passed": False, "message": f"{json_format_value(evaluator_input2)} is not less than or equal to {json_format_value(evaluator_data2)}"}
+    assert result == {
+        "passed": False,
+        "message": f"{json_format_value(evaluator_input2)} is not less than or equal to {json_format_value(evaluator_data2)}",
+    }
diff --git a/tests/core/evaluators/test_regex_match.py b/tests/core/evaluators/test_regex_match.py
index 7a51e65b..841b4997 100644
--- a/tests/core/evaluators/test_regex_match.py
+++ b/tests/core/evaluators/test_regex_match.py
@@ -1,6 +1,7 @@
 from tirith.core.evaluators import RegexMatch
 from pytest import mark
 from tirith.utils import json_format_value
+
 evaluator_data1 = "^(?=[a-zA-Z0-9._]{8,20}$)(?!.*[_.]{2})[^_.].*[^_.]$"
 evaluator_input1 = "amitrakshar01"
 
@@ -14,14 +15,20 @@
 @mark.passing
 def test_regex_passing():
     result = evaluator.evaluate(evaluator_input1, evaluator_data1)
-    assert result == {"passed": True, "message": f"{json_format_value(evaluator_input1)} matches regex pattern {json_format_value(evaluator_data1)}"}
+    assert result == {
+        "passed": True,
+        "message": f"{json_format_value(evaluator_input1)} matches regex pattern {json_format_value(evaluator_data1)}",
+    }
 
 
 # pytest -v -m failing
 @mark.failing
 def test_regex_failing():
     result = evaluator.evaluate(evaluator_input2, evaluator_data2)
-    assert result == {"passed": False, "message": f"{json_format_value(evaluator_input2)} does not match regex pattern {json_format_value(evaluator_data2)}"}
+    assert result == {
+        "passed": False,
+        "message": f"{json_format_value(evaluator_input2)} does not match regex pattern {json_format_value(evaluator_data2)}",
+    }
 
 
 def test_regex_list():

From 1958fcb2ee366bd69ad52560e9727242b319a38f Mon Sep 17 00:00:00 2001
From: Akash S <akashsuresh0510@gmail.com>
Date: Tue, 13 May 2025 15:37:58 +0530
Subject: [PATCH 3/7] fix docstring lint

---
 src/tirith/utils.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tirith/utils.py b/src/tirith/utils.py
index 5d61aef5..a46dda6c 100644
--- a/src/tirith/utils.py
+++ b/src/tirith/utils.py
@@ -16,6 +16,7 @@ def json_format_value(value: Any) -> str:
 
     Returns:
         A JSON-formatted string representation of the value, enclosed in backticks
+        
     """
     try:
         # Special case for None as JSON's null isn't as recognizable

From be56ddb640eabf82747d7d2bad2959968d6f030f Mon Sep 17 00:00:00 2001
From: Akash S <akashsuresh0510@gmail.com>
Date: Tue, 13 May 2025 15:38:46 +0530
Subject: [PATCH 4/7] lint fix

---
 src/tirith/utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tirith/utils.py b/src/tirith/utils.py
index a46dda6c..05a105a0 100644
--- a/src/tirith/utils.py
+++ b/src/tirith/utils.py
@@ -16,7 +16,7 @@ def json_format_value(value: Any) -> str:
 
     Returns:
         A JSON-formatted string representation of the value, enclosed in backticks
-        
+
     """
     try:
         # Special case for None as JSON's null isn't as recognizable

From acf7be36ee58faf8d5bc1622df36c4651b8d411c Mon Sep 17 00:00:00 2001
From: Akash S <akashsuresh0510@gmail.com>
Date: Tue, 13 May 2025 15:44:48 +0530
Subject: [PATCH 5/7] refactor: improve docstring formatting and remove
 unnecessary None check in json_format_value

---
 src/tirith/utils.py | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/tirith/utils.py b/src/tirith/utils.py
index 05a105a0..49f9f951 100644
--- a/src/tirith/utils.py
+++ b/src/tirith/utils.py
@@ -8,21 +8,18 @@
 def json_format_value(value: Any) -> str:
     """
     Format a Python value as a JSON string representation.
+
     This produces a more language-agnostic representation of values that's
     suitable for displaying in evaluation messages.
 
-    Args:
-        value: Any Python value
-
-    Returns:
-        A JSON-formatted string representation of the value, enclosed in backticks
+    :param value: Any Python value
+    :type value: Any
 
+    :returns: A JSON-formatted string representation of the value, enclosed in backticks
+    :rtype: str
     """
-    try:
-        # Special case for None as JSON's null isn't as recognizable
-        if value is None:
-            return "`None`"
 
+    try:
         # For basic types, use JSON representation
         json_str = json.dumps(value)
         return f"`{json_str}`"

From 2b3332b4cb22e9a42ff57004fefcf6672bb18cbc Mon Sep 17 00:00:00 2001
From: Akash S <akashsuresh0510@gmail.com>
Date: Tue, 13 May 2025 15:46:20 +0530
Subject: [PATCH 6/7] fix docstrings

---
 src/tirith/utils.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/tirith/utils.py b/src/tirith/utils.py
index 49f9f951..6d325f99 100644
--- a/src/tirith/utils.py
+++ b/src/tirith/utils.py
@@ -18,7 +18,6 @@ def json_format_value(value: Any) -> str:
     :returns: A JSON-formatted string representation of the value, enclosed in backticks
     :rtype: str
     """
-
     try:
         # For basic types, use JSON representation
         json_str = json.dumps(value)

From e631bbdbc0464ab68bd78fa6835151ebaad65ea0 Mon Sep 17 00:00:00 2001
From: Akash S <akashsuresh0510@gmail.com>
Date: Tue, 13 May 2025 16:03:07 +0530
Subject: [PATCH 7/7] refactor: remove unused imports in regex_match.py

---
 src/tirith/core/evaluators/regex_match.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/tirith/core/evaluators/regex_match.py b/src/tirith/core/evaluators/regex_match.py
index 3338ccf9..ec1e105a 100644
--- a/src/tirith/core/evaluators/regex_match.py
+++ b/src/tirith/core/evaluators/regex_match.py
@@ -1,6 +1,4 @@
-import logging
 import re
-from typing import Dict, Any
 
 from .base_evaluator import BaseEvaluator
 from tirith.utils import json_format_value