v0.47.0: fingerprint update with fallback for str/int index overlaps

Create a fallback hash function to handle mixed key types in dictionaries
and lists, ensuring consistent hashing across different data structures.

Fallback called is prefixed with "HO_" to indicate its usage.

pyproject.toml

@@ -1,7 +1,7 @@
 # MARK: Project info
 [project]
 name = "corelibs"
-version = "0.45.0"
+version = "0.47.0"
 description = "Collection of utils for Python scripts"
 readme = "README.md"
 requires-python = ">=3.13"

src/corelibs/config_handling/settings_loader.py

@@ -577,7 +577,7 @@ class SettingsLoader:
             self.log.logger.log(Log.get_log_level_int(level), msg, stacklevel=2)
         if self.log is None or self.always_print:
             if print_error:
-                print(msg)
+                print(f"[SettingsLoader] {msg}")
         if level == 'ERROR':
             # remove any prefix [!] for error message list
             self.__error_msg.append(msg.replace('[!] ', '').strip())

src/corelibs/iterator_handling/fingerprint.py

@@ -4,11 +4,38 @@ Various dictionary, object and list hashers
 
 import json
 import hashlib
-from typing import Any
+from typing import Any, cast, Sequence
+
+
+def hash_object(obj: Any) -> str:
+    """
+    RECOMMENDED for new use
+    Create a hash for any dict or list with mixed key types
+
+    Arguments:
+        obj {Any} -- _description_
+
+    Returns:
+        str -- _description_
+    """
+    def normalize(o: Any) -> Any:
+        if isinstance(o, dict):
+            # Sort by repr of keys to handle mixed types (str, int, etc.)
+            o = cast(dict[Any, Any], o)
+            return tuple(sorted((repr(k), normalize(v)) for k, v in o.items()))
+        if isinstance(o, (list, tuple)):
+            o = cast(Sequence[Any], o)
+            return tuple(normalize(item) for item in o)
+        return repr(o)
+
+    normalized = normalize(obj)
+    return hashlib.sha256(str(normalized).encode()).hexdigest()
 
 
 def dict_hash_frozen(data: dict[Any, Any]) -> int:
     """
+    NOT RECOMMENDED, use dict_hash_crc or hash_object instead
+    If used, DO NOT CHANGE
     hash a dict via freeze
 
     Args:
@@ -22,18 +49,25 @@ def dict_hash_frozen(data: dict[Any, Any]) -> int:
 
 def dict_hash_crc(data: dict[Any, Any] | list[Any]) -> str:
     """
-    Create a sha256 hash over dict
+    LEGACY METHOD, must be kept for fallback, if used by other code, DO NOT CHANGE
+    Create a sha256 hash over dict or list
     alternative for
     dict_hash_frozen
 
     Args:
-        data (dict | list): _description_
+        data (dict[Any, Any] | list[Any]): _description_
 
     Returns:
-        str: _description_
+        str: sha256 hash, prefiex with HO_ if fallback used
     """
-    return hashlib.sha256(
-        json.dumps(data, sort_keys=True, ensure_ascii=True).encode('utf-8')
-    ).hexdigest()
+    try:
+        return hashlib.sha256(
+            # IT IS IMPORTANT THAT THE BELOW CALL STAYS THE SAME AND DOES NOT CHANGE OR WE WILL GET DIFFERENT HASHES
+            # separators=(',', ':') to get rid of spaces, but if this is used the hash will be different, DO NOT ADD
+            json.dumps(data, sort_keys=True, ensure_ascii=True, default=str).encode('utf-8')
+        ).hexdigest()
+    except TypeError:
+        # Fallback tod different hasher, will return DIFFERENT hash than above, so only usable in int/str key mixes
+        return "HO_" + hash_object(data)
 
 # __END__

src/corelibs/iterator_handling/list_helpers.py

@@ -2,6 +2,7 @@
 List type helpers
 """
 
+import json
 from typing import Any, Sequence
 
 
@@ -44,4 +45,31 @@ def is_list_in_list(
     # Get the difference and extract just the values
     return [item for item, _ in set_a - set_b]
 
+
+def make_unique_list_of_dicts(dict_list: list[Any]) -> list[Any]:
+    """
+    Create a list of unique dictionary entries
+
+    Arguments:
+        dict_list {list[Any]} -- _description_
+
+    Returns:
+        list[Any] -- _description_
+    """
+    try:
+        # try json dumps, can fail with int and str index types
+        return list(
+            {
+                json.dumps(d, sort_keys=True, ensure_ascii=True, separators=(',', ':')): d
+                for d in dict_list
+            }.values()
+        )
+    except TypeError:
+        # Fallback for non-serializable entries, slow but works
+        unique: list[Any] = []
+        for d in dict_list:
+            if d not in unique:
+                unique.append(d)
+        return unique
+
 # __END__

src/corelibs/logging_handling/log.py

@@ -602,9 +602,9 @@ class Log(LogParent):
                 __setting = self.DEFAULT_LOG_SETTINGS.get(__log_entry, True)
             default_log_settings[__log_entry] = __setting
         # check console log type
-        default_log_settings['console_format_type'] = cast('ConsoleFormat', log_settings.get(
-            'console_format_type', self.DEFAULT_LOG_SETTINGS['console_format_type']
-        ))
+        if (console_format_type := log_settings.get('console_format_type')) is None:
+            console_format_type = self.DEFAULT_LOG_SETTINGS['console_format_type']
+        default_log_settings['console_format_type'] = cast('ConsoleFormat', console_format_type)
         # check log queue
         __setting = log_settings.get('log_queue', self.DEFAULT_LOG_SETTINGS['log_queue'])
         if __setting is not None:

test-run/config_handling/config/settings.ini

@@ -17,6 +17,7 @@ str_length=foobar
 int_range=20
 int_range_not_set=
 int_range_not_set_empty_set=5
+bool_var=True
 #
 match_target=foo
 match_target_list=foo,bar,baz

test-run/config_handling/settings_loader.py

@@ -84,6 +84,7 @@ def main():
                 "int_range_not_set_empty_set": [
                     "empty:"
                 ],
+                "bool_var": ["convert:bool"],
                 "match_target": ["matching:foo"],
                 "match_target_list": ["split:,", "matching:foo|bar|baz",],
                 "match_source_a": ["in:match_target"],

test-run/iterator_handling/list_helpers.py

@@ -2,7 +2,10 @@
 test list helpers
 """
 
-from corelibs.iterator_handling.list_helpers import is_list_in_list, convert_to_list
+from typing import Any
+from corelibs.debug_handling.dump_data import dump_data
+from corelibs.iterator_handling.list_helpers import is_list_in_list, convert_to_list, make_unique_list_of_dicts
+from corelibs.iterator_handling.fingerprint import dict_hash_crc
 
 
 def __test_is_list_in_list_a():
@@ -18,9 +21,66 @@ def __convert_list():
     print(f"IN: {source} -> {result}")
 
 
+def __make_unique_list_of_dicts():
+    dict_list = [
+        {"a": 1, "b": 2, "nested": {"x": 10, "y": 20}},
+        {"a": 1, "b": 2, "nested": {"x": 10, "y": 20}},
+        {"b": 2, "a": 1, "nested": {"y": 20, "x": 10}},
+        {"b": 2, "a": 1, "nested": {"y": 20, "x": 30}},
+        {"a": 3, "b": 4, "nested": {"x": 30, "y": 40}}
+    ]
+    unique_dicts = make_unique_list_of_dicts(dict_list)
+    dhf = dict_hash_crc(unique_dicts)
+    print(f"Unique dicts: {dump_data(unique_dicts)} [{dhf}]")
+
+    dict_list = [
+        {"a": 1, 1: "one"},
+        {1: "one", "a": 1},
+        {"a": 2, 1: "one"}
+    ]
+    unique_dicts = make_unique_list_of_dicts(dict_list)
+    dhf = dict_hash_crc(unique_dicts)
+    print(f"Unique dicts: {dump_data(unique_dicts)} [{dhf}]")
+
+    dict_list = [
+        {"a": 1, "b": [1, 2, 3]},
+        {"b": [1, 2, 3], "a": 1},
+        {"a": 1, "b": [1, 2, 4]},
+        1, 2, "String", 1, "Foobar"
+    ]
+    unique_dicts = make_unique_list_of_dicts(dict_list)
+    dhf = dict_hash_crc(unique_dicts)
+    print(f"Unique dicts: {dump_data(unique_dicts)} [{dhf}]")
+
+    dict_list: list[Any] = [
+        [],
+        {},
+        [],
+        {},
+        {"a": []},
+        {"a": []},
+        {"a": {}},
+        {"a": {}},
+    ]
+    unique_dicts = make_unique_list_of_dicts(dict_list)
+    dhf = dict_hash_crc(unique_dicts)
+    print(f"Unique dicts: {dump_data(unique_dicts)} [{dhf}]")
+
+    dict_list: list[Any] = [
+        (1, 2),
+        (1, 2),
+        (2, 3),
+    ]
+    unique_dicts = make_unique_list_of_dicts(dict_list)
+    dhf = dict_hash_crc(unique_dicts)
+    print(f"Unique dicts: {dump_data(unique_dicts)} [{dhf}]")
+
+
 def main():
+    """List helpers test runner"""
     __test_is_list_in_list_a()
     __convert_list()
+    __make_unique_list_of_dicts()
 
 
 if __name__ == "__main__":

test-run/logging_handling/log.py

@@ -27,7 +27,8 @@ def main():
             "per_run_log": True,
             # "console_format_type": ConsoleFormatSettings.NONE,
             # "console_format_type": ConsoleFormatSettings.MINIMAL,
-            "console_format_type": ConsoleFormat.TIME_MICROSECONDS | ConsoleFormat.NAME | ConsoleFormat.LEVEL,
+            # "console_format_type": ConsoleFormat.TIME_MICROSECONDS | ConsoleFormat.NAME | ConsoleFormat.LEVEL,
+            "console_format_type": None,
             # "console_format_type": ConsoleFormat.NAME,
             # "console_format_type": (
             #     ConsoleFormat.TIME | ConsoleFormat.TIMEZONE | ConsoleFormat.LINENO | ConsoleFormat.LEVEL

tests/unit/iterator_handling/test_fingerprint.py

@@ -4,7 +4,101 @@ tests for corelibs.iterator_handling.fingerprint
 
 from typing import Any
 import pytest
-from corelibs.iterator_handling.fingerprint import dict_hash_frozen, dict_hash_crc
+from corelibs.iterator_handling.fingerprint import dict_hash_frozen, dict_hash_crc, hash_object
+
+
+class TestHashObject:
+    """Tests for hash_object function"""
+
+    def test_hash_object_simple_dict(self):
+        """Test hashing a simple dictionary with hash_object"""
+        data = {"key1": "value1", "key2": "value2"}
+        result = hash_object(data)
+
+        assert isinstance(result, str)
+        assert len(result) == 64  # SHA256 produces 64 hex characters
+
+    def test_hash_object_mixed_keys(self):
+        """Test hash_object with mixed int and string keys"""
+        data = {"key1": "value1", 1: "value2", 2: "value3"}
+        result = hash_object(data)
+
+        assert isinstance(result, str)
+        assert len(result) == 64
+
+    def test_hash_object_consistency(self):
+        """Test that hash_object produces consistent results"""
+        data = {"str_key": "value", 123: "number_key"}
+        hash1 = hash_object(data)
+        hash2 = hash_object(data)
+
+        assert hash1 == hash2
+
+    def test_hash_object_order_independence(self):
+        """Test that hash_object is order-independent"""
+        data1 = {"a": 1, 1: "one", "b": 2, 2: "two"}
+        data2 = {2: "two", "b": 2, 1: "one", "a": 1}
+        hash1 = hash_object(data1)
+        hash2 = hash_object(data2)
+
+        assert hash1 == hash2
+
+    def test_hash_object_list_of_dicts_mixed_keys(self):
+        """Test hash_object with list of dicts containing mixed keys"""
+        data = [
+            {"name": "item1", 1: "value1"},
+            {"name": "item2", 2: "value2"}
+        ]
+        result = hash_object(data)
+
+        assert isinstance(result, str)
+        assert len(result) == 64
+
+    def test_hash_object_nested_mixed_keys(self):
+        """Test hash_object with nested structures containing mixed keys"""
+        data = {
+            "outer": {
+                "inner": "value",
+                1: "mixed_key"
+            },
+            2: "another_mixed"
+        }
+        result = hash_object(data)
+
+        assert isinstance(result, str)
+        assert len(result) == 64
+
+    def test_hash_object_different_data(self):
+        """Test that different data produces different hashes"""
+        data1 = {"key": "value", 1: "one"}
+        data2 = {"key": "value", 2: "two"}
+        hash1 = hash_object(data1)
+        hash2 = hash_object(data2)
+
+        assert hash1 != hash2
+
+    def test_hash_object_complex_nested(self):
+        """Test hash_object with complex nested structures"""
+        data = {
+            "level1": {
+                "level2": {
+                    1: "value",
+                    "key": [1, 2, {"nested": "deep", 3: "int_key"}]
+                }
+            }
+        }
+        result = hash_object(data)
+
+        assert isinstance(result, str)
+        assert len(result) == 64
+
+    def test_hash_object_list_with_tuples(self):
+        """Test hash_object with lists containing tuples"""
+        data = [("a", 1), ("b", 2), {1: "mixed", "key": "value"}]
+        result = hash_object(data)
+
+        assert isinstance(result, str)
+        assert len(result) == 64
 
 
 class TestDictHashFrozen:
@@ -279,6 +373,116 @@ class TestDictHashCrc:
         assert isinstance(result, str)
         assert len(result) == 64
 
+    def test_dict_hash_crc_fallback_mixed_keys(self):
+        """Test dict_hash_crc fallback with mixed int and string keys"""
+        data = {"key1": "value1", 1: "value2", 2: "value3"}
+        result = dict_hash_crc(data)
+
+        assert isinstance(result, str)
+        # Fallback prefixes with "HO_"
+        assert result.startswith("HO_")
+        # Hash should be 64 chars + 3 char prefix = 67 total
+        assert len(result) == 67
+
+    def test_dict_hash_crc_fallback_consistency(self):
+        """Test that fallback produces consistent hashes"""
+        data = {"str_key": "value", 123: "number_key", 456: "another"}
+        hash1 = dict_hash_crc(data)
+        hash2 = dict_hash_crc(data)
+
+        assert hash1 == hash2
+        assert hash1.startswith("HO_")
+
+    def test_dict_hash_crc_fallback_order_independence(self):
+        """Test that fallback is order-independent for mixed-key dicts"""
+        data1 = {"a": 1, 1: "one", "b": 2, 2: "two"}
+        data2 = {2: "two", "b": 2, 1: "one", "a": 1}
+        hash1 = dict_hash_crc(data1)
+        hash2 = dict_hash_crc(data2)
+
+        assert hash1 == hash2
+        assert hash1.startswith("HO_")
+
+    def test_dict_hash_crc_fallback_list_of_dicts_mixed_keys(self):
+        """Test fallback with list of dicts containing mixed keys"""
+        data = [
+            {"name": "item1", 1: "value1"},
+            {"name": "item2", 2: "value2"},
+            {3: "value3", "type": "mixed"}
+        ]
+        result = dict_hash_crc(data)
+
+        assert isinstance(result, str)
+        assert result.startswith("HO_")
+        assert len(result) == 67
+
+    def test_dict_hash_crc_fallback_nested_mixed_keys(self):
+        """Test fallback with nested dicts containing mixed keys"""
+        data = {
+            "outer": {
+                "inner": "value",
+                1: "mixed_key"
+            },
+            2: "another_mixed"
+        }
+        result = dict_hash_crc(data)
+
+        assert isinstance(result, str)
+        assert result.startswith("HO_")
+        assert len(result) == 67
+
+    def test_dict_hash_crc_fallback_different_data(self):
+        """Test that different mixed-key data produces different hashes"""
+        data1 = {"key": "value", 1: "one"}
+        data2 = {"key": "value", 2: "two"}
+        hash1 = dict_hash_crc(data1)
+        hash2 = dict_hash_crc(data2)
+
+        assert hash1 != hash2
+        assert hash1.startswith("HO_")
+        assert hash2.startswith("HO_")
+
+    def test_dict_hash_crc_fallback_complex_structure(self):
+        """Test fallback with complex nested structure with mixed keys"""
+        data = [
+            {
+                "id": 1,
+                1: "first",
+                "data": {
+                    "nested": "value",
+                    100: "nested_int_key"
+                }
+            },
+            {
+                "id": 2,
+                2: "second",
+                "items": [1, 2, 3]
+            }
+        ]
+        result = dict_hash_crc(data)
+
+        assert isinstance(result, str)
+        assert result.startswith("HO_")
+        assert len(result) == 67
+
+    def test_dict_hash_crc_no_fallback_string_keys_only(self):
+        """Test that string-only keys don't trigger fallback"""
+        data = {"key1": "value1", "key2": "value2", "key3": "value3"}
+        result = dict_hash_crc(data)
+
+        assert isinstance(result, str)
+        assert not result.startswith("HO_")
+        assert len(result) == 64
+
+    def test_dict_hash_crc_no_fallback_int_keys_only(self):
+        """Test that int-only keys don't trigger fallback"""
+        data = {1: "one", 2: "two", 3: "three"}
+        result = dict_hash_crc(data)
+
+        assert isinstance(result, str)
+        assert not result.startswith("HO_")
+        assert len(result) == 64
+
 
 class TestComparisonBetweenHashFunctions:
     """Tests comparing dict_hash_frozen and dict_hash_crc"""

tests/unit/iterator_handling/test_list_helpers.py

@@ -4,7 +4,7 @@ iterator_handling.list_helepr tests
 
 from typing import Any
 import pytest
-from corelibs.iterator_handling.list_helpers import convert_to_list, is_list_in_list
+from corelibs.iterator_handling.list_helpers import convert_to_list, is_list_in_list, make_unique_list_of_dicts
 
 
 class TestConvertToList:
@@ -298,3 +298,225 @@ class TestPerformance:
         # Should still work correctly despite duplicates
         assert set(result) == {1, 3}
         assert isinstance(result, list)
+
+
+class TestMakeUniqueListOfDicts:
+    """Test cases for make_unique_list_of_dicts function"""
+
+    def test_basic_duplicate_removal(self):
+        """Test basic removal of duplicate dictionaries"""
+        dict_list = [
+            {"a": 1, "b": 2},
+            {"a": 1, "b": 2},
+            {"a": 3, "b": 4}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 2
+        assert {"a": 1, "b": 2} in result
+        assert {"a": 3, "b": 4} in result
+
+    def test_order_independent_duplicates(self):
+        """Test that dictionaries with different key orders are treated as duplicates"""
+        dict_list = [
+            {"a": 1, "b": 2},
+            {"b": 2, "a": 1},  # Same content, different order
+            {"a": 3, "b": 4}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 2
+        assert {"a": 1, "b": 2} in result
+        assert {"a": 3, "b": 4} in result
+
+    def test_empty_list(self):
+        """Test with empty list"""
+        result = make_unique_list_of_dicts([])
+        assert result == []
+        assert isinstance(result, list)
+
+    def test_single_dict(self):
+        """Test with single dictionary"""
+        dict_list = [{"a": 1, "b": 2}]
+        result = make_unique_list_of_dicts(dict_list)
+        assert result == [{"a": 1, "b": 2}]
+
+    def test_all_unique(self):
+        """Test when all dictionaries are unique"""
+        dict_list = [
+            {"a": 1},
+            {"b": 2},
+            {"c": 3},
+            {"d": 4}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 4
+        for d in dict_list:
+            assert d in result
+
+    def test_all_duplicates(self):
+        """Test when all dictionaries are duplicates"""
+        dict_list = [
+            {"a": 1, "b": 2},
+            {"a": 1, "b": 2},
+            {"a": 1, "b": 2},
+            {"b": 2, "a": 1}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 1
+        assert result[0] == {"a": 1, "b": 2}
+
+    def test_nested_values(self):
+        """Test with nested structures as values"""
+        dict_list = [
+            {"a": [1, 2], "b": 3},
+            {"a": [1, 2], "b": 3},
+            {"a": [1, 3], "b": 3}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 2
+        assert {"a": [1, 2], "b": 3} in result
+        assert {"a": [1, 3], "b": 3} in result
+
+    def test_different_value_types(self):
+        """Test with different value types"""
+        dict_list = [
+            {"str": "hello", "int": 42, "float": 3.14, "bool": True},
+            {"str": "hello", "int": 42, "float": 3.14, "bool": True},
+            {"str": "world", "int": 99, "float": 2.71, "bool": False}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 2
+
+    def test_empty_dicts(self):
+        """Test with empty dictionaries"""
+        dict_list: list[Any] = [
+            {},
+            {},
+            {"a": 1}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 2
+        assert {} in result
+        assert {"a": 1} in result
+
+    def test_single_key_dicts(self):
+        """Test with single key dictionaries"""
+        dict_list = [
+            {"a": 1},
+            {"a": 1},
+            {"a": 2},
+            {"b": 1}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 3
+        assert {"a": 1} in result
+        assert {"a": 2} in result
+        assert {"b": 1} in result
+
+    def test_many_keys(self):
+        """Test with dictionaries containing many keys"""
+        dict1 = {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}
+        dict2 = {"e": 5, "d": 4, "c": 3, "b": 2, "a": 1}  # Same, different order
+        dict3 = {"a": 1, "b": 2, "c": 3, "d": 4, "e": 6}  # Different value
+        dict_list = [dict1, dict2, dict3]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 2
+
+    def test_numeric_keys(self):
+        """Test with numeric keys"""
+        dict_list = [
+            {1: "one", 2: "two"},
+            {2: "two", 1: "one"},
+            {1: "one", 2: "three"}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 2
+
+    def test_none_values(self):
+        """Test with None values"""
+        dict_list = [
+            {"a": None, "b": 2},
+            {"a": None, "b": 2},
+            {"a": 1, "b": None}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 2
+        assert {"a": None, "b": 2} in result
+        assert {"a": 1, "b": None} in result
+
+    def test_mixed_key_types(self):
+        """Test with mixed key types (string and numeric)"""
+        dict_list = [
+            {"a": 1, 1: "one"},
+            {1: "one", "a": 1},
+            {"a": 2, 1: "one"}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 2
+
+    @pytest.mark.parametrize("dict_list,expected_length", [
+        ([{"a": 1}, {"a": 1}, {"a": 1}], 1),
+        ([{"a": 1}, {"a": 2}, {"a": 3}], 3),
+        ([{"a": 1, "b": 2}, {"b": 2, "a": 1}], 1),
+        ([{}, {}], 1),
+        ([{"x": [1, 2]}, {"x": [1, 2]}], 1),
+        ([{"a": 1}, {"b": 2}, {"c": 3}], 3),
+    ])  # pyright: ignore[reportUnknownArgumentType]
+    def test_parametrized_unique_dicts(self, dict_list: list[Any], expected_length: int):
+        """Test make_unique_list_of_dicts with various input combinations"""
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == expected_length
+        assert isinstance(result, list)
+
+    def test_large_list(self):
+        """Test with a large list of dictionaries"""
+        dict_list = [{"id": i % 100, "value": f"val_{i % 100}"} for i in range(1000)]
+        result = make_unique_list_of_dicts(dict_list)
+        # Should have 100 unique dicts (0-99)
+        assert len(result) == 100
+
+    def test_preserves_last_occurrence(self):
+        """Test behavior with duplicate entries"""
+        # The function uses dict comprehension, which keeps last occurrence
+        dict_list = [
+            {"a": 1, "b": 2},
+            {"a": 3, "b": 4},
+            {"a": 1, "b": 2}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 2
+        # Just verify correct unique count, order may vary
+
+    def test_nested_dicts(self):
+        """Test with nested dictionaries"""
+        dict_list = [
+            {"outer": {"inner": 1}},
+            {"outer": {"inner": 1}},
+            {"outer": {"inner": 2}}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 2
+
+    def test_string_values_case_sensitive(self):
+        """Test that string values are case-sensitive"""
+        dict_list = [
+            {"name": "John"},
+            {"name": "john"},
+            {"name": "JOHN"},
+            {"name": "John"}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 3
+
+    def test_boolean_values(self):
+        """Test with boolean values"""
+        dict_list = [
+            {"flag": True, "count": 1},
+            {"count": 1, "flag": True},
+            {"flag": False, "count": 1}
+        ]
+        result = make_unique_list_of_dicts(dict_list)
+        assert len(result) == 2
+        assert {"flag": True, "count": 1} in result
+        assert {"flag": False, "count": 1} in result
+
+# __END__

tests/unit/logging_handling/log_testing/test_log_3_custom_console_formatter.py

@@ -28,6 +28,7 @@ def tmp_log_path(tmp_path: Path) -> Path:
 @pytest.fixture
 def basic_log_settings() -> LogSettings:
     """Basic log settings for testing"""
+    # Return a new dict each time to avoid state pollution
     return {
         "log_level_console": LoggingLevel.WARNING,
         "log_level_file": LoggingLevel.DEBUG,
@@ -308,4 +309,54 @@ class TestUpdateConsoleFormatter:
         # Verify message was logged
         assert "Test warning message" in caplog.text
 
+    def test_log_console_format_option_set_to_none(
+        self, tmp_log_path: Path
+    ):
+        """Test that when log_console_format option is set to None, it uses ConsoleFormatSettings.ALL"""
+        # Save the original DEFAULT_LOG_SETTINGS to restore it after test
+        original_default = Log.DEFAULT_LOG_SETTINGS.copy()
+
+        try:
+            # Reset DEFAULT_LOG_SETTINGS to ensure clean state
+            Log.DEFAULT_LOG_SETTINGS = {
+                "log_level_console": Log.DEFAULT_LOG_LEVEL_CONSOLE,
+                "log_level_file": Log.DEFAULT_LOG_LEVEL_FILE,
+                "per_run_log": False,
+                "console_enabled": True,
+                "console_color_output_enabled": True,
+                "console_format_type": ConsoleFormatSettings.ALL,
+                "add_start_info": True,
+                "add_end_info": False,
+                "log_queue": None,
+            }
+
+            # Create a fresh settings dict with console_format_type explicitly set to None
+            settings: LogSettings = {
+                "log_level_console": LoggingLevel.WARNING,
+                "log_level_file": LoggingLevel.DEBUG,
+                "per_run_log": False,
+                "console_enabled": True,
+                "console_color_output_enabled": False,
+                "console_format_type": None,  # type: ignore
+                "add_start_info": False,
+                "add_end_info": False,
+                "log_queue": None,
+            }
+
+            # Verify that None is explicitly set in the input
+            assert settings['console_format_type'] is None
+
+            log = Log(
+                log_path=tmp_log_path,
+                log_name="test_log",
+                log_settings=settings
+            )
+
+            # Verify that None was replaced with ConsoleFormatSettings.ALL
+            # The Log class should replace None with the default value (ALL)
+            assert log.log_settings['console_format_type'] == ConsoleFormatSettings.ALL
+        finally:
+            # Restore original DEFAULT_LOG_SETTINGS
+            Log.DEFAULT_LOG_SETTINGS = original_default
+
 # __END__