megadetector 5.0.29__py3-none-any.whl → 10.0.0__py3-none-any.whl

megadetector/utils/ct_utils.py

@@ -206,9 +206,9 @@ def json_serialize_datetime(obj):
 
 
 def write_json(path,
-               content, 
-               indent=1, 
-               force_str=False, 
+               content,
+               indent=1,
+               force_str=False,
                serialize_datetimes=False,
                ensure_ascii=True,
                encoding='utf-8'):
@@ -222,6 +222,7 @@ def write_json(path,
         force_str (bool, optional): whether to force string conversion for non-serializable objects
         serialize_datetimes (bool, optional): whether to serialize datetime objects to ISO format
         ensure_ascii (bool, optional): whether to ensure ASCII characters in the output
+        encoding (str, optional): string encoding to use
     """
 
     default_handler = None
@@ -238,9 +239,13 @@ def write_json(path,
     elif force_str:
         default_handler = str
 
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+
     with open(path, 'w', newline='\n', encoding=encoding) as f:
         json.dump(content, f, indent=indent, default=default_handler, ensure_ascii=ensure_ascii)
 
+# ...def write_json(...)
+
 
 def convert_yolo_to_xywh(yolo_box):
     """
@@ -389,8 +394,8 @@ def point_dist(p1,p2):
     Computes the distance between two points, represented as length-two tuples.
 
     Args:
-        p1: point, formatted as (x,y)
-        p2: point, formatted as (x,y)
+        p1 (list or tuple): point, formatted as (x,y)
+        p2 (list or tuple): point, formatted as (x,y)
 
     Returns:
         float: the Euclidean distance between p1 and p2
@@ -407,8 +412,8 @@ def rect_distance(r1, r2, format='x0y0x1y1'):
     Can also specify "format" as x0y0wh for MD-style bbox formatting (x0,y0,w,h).
 
     Args:
-        r1: rectangle, formatted as (x0,y0,x1,y1) or (x0,y0,xy,y1)
-        r2: rectangle, formatted as (x0,y0,x1,y1) or (x0,y0,xy,y1)
+        r1 (list or tuple): rectangle, formatted as (x0,y0,x1,y1) or (x0,y0,xy,y1)
+        r2 (list or tuple): rectangle, formatted as (x0,y0,x1,y1) or (x0,y0,xy,y1)
         format (str, optional): whether the boxes are formatted as 'x0y0x1y1' (default) or 'x0y0wh'
 
     Returns:
@@ -477,7 +482,7 @@ def split_list_into_n_chunks(L, n, chunk_strategy='greedy'): # noqa
     Args:
         L (list): list to split into chunks
         n (int): number of chunks
-        chunk_strategy (str, optiopnal): "greedy" or "balanced"; see above
+        chunk_strategy (str, optional): "greedy" or "balanced"; see above
 
     Returns:
         list: list of chunks, each of which is a list
@@ -496,7 +501,7 @@ def split_list_into_n_chunks(L, n, chunk_strategy='greedy'): # noqa
         raise ValueError('Invalid chunk strategy: {}'.format(chunk_strategy))
 
 
-def sort_list_of_dicts_by_key(L,k,reverse=False): # noqa
+def sort_list_of_dicts_by_key(L, k, reverse=False, none_handling='smallest'): # noqa ("L" should be lowercase)
     """
     Sorts the list of dictionaries [L] by the key [k].
 
@@ -504,11 +509,25 @@ def sort_list_of_dicts_by_key(L,k,reverse=False): # noqa
         L (list): list of dictionaries to sort
         k (object, typically str): the sort key
         reverse (bool, optional): whether to sort in reverse (descending) order
+        none_handling (str, optional): how to handle None values. Options:
+            "smallest" - treat None as smaller than all other values (default)
+            "largest" - treat None as larger than all other values
+            "error" - raise error when None is compared with non-None
 
     Returns:
-        dict: sorted copy of [d]
+        list: sorted copy of [L]
     """
-    return sorted(L, key=lambda d: d[k], reverse=reverse)
+
+    if none_handling == 'error':
+        return sorted(L, key=lambda d: d[k], reverse=reverse)
+    elif none_handling == 'smallest':
+        # None values treated as smaller than other values: use tuple (is_not_none, value)
+        return sorted(L, key=lambda d: (d[k] is not None, d[k]), reverse=reverse)
+    elif none_handling == "largest":
+        # None values treated as larger than other values: use tuple (is_none, value)
+        return sorted(L, key=lambda d: (d[k] is None, d[k]), reverse=reverse)
+    else:
+        raise ValueError('Invalid none_handling value: {}'.format(none_handling))
 
 
 def sort_dictionary_by_key(d,reverse=False):
@@ -573,7 +592,7 @@ def round_floats_in_nested_dict(obj, decimal_places=5, allow_iterator_conversion
     sets, and other iterables. Modifies mutable objects in place.
 
     Args:
-        obj: The object to process (can be a dict, list, set, tuple, or primitive value)
+        obj (obj): The object to process (can be a dict, list, set, tuple, or primitive value)
         decimal_places (int, optional): Number of decimal places to round to
         allow_iterator_conversion (bool, optional): for iterator types, should we convert
             to lists?  Otherwise we error.
@@ -595,7 +614,7 @@ def round_floats_in_nested_dict(obj, decimal_places=5, allow_iterator_conversion
 
     elif isinstance(obj, tuple):
         # Tuples are immutable, so we create a new one
-        return tuple(round_floats_in_nested_dict(item, decimal_places=decimal_places, 
+        return tuple(round_floats_in_nested_dict(item, decimal_places=decimal_places,
                                                  allow_iterator_conversion=allow_iterator_conversion) for item in obj)
 
     elif isinstance(obj, set):
@@ -606,11 +625,11 @@ def round_floats_in_nested_dict(obj, decimal_places=5, allow_iterator_conversion
 
     elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes, bytearray)):
         # Handle other iterable types: convert to list, process, and convert back
-        processed_list = [round_floats_in_nested_dict(item, 
+        processed_list = [round_floats_in_nested_dict(item,
                                                       decimal_places=decimal_places,
                                                       allow_iterator_conversion=allow_iterator_conversion) \
                                                         for item in obj]
-        
+
         # Try to recreate the original type, but fall back to list for iterators
         try:
             return type(obj)(processed_list)
@@ -682,7 +701,7 @@ def is_float(v):
 
     if v is None:
         return False
-    
+
     try:
         _ = float(v)
         return True
@@ -714,7 +733,7 @@ def is_empty(v):
     data from .csv files.  "empty" includes None, '', and NaN.
 
     Args:
-        v: the object to evaluate for emptiness
+        v (obj): the object to evaluate for emptiness
 
     Returns:
         bool: True if [v] is None, '', or NaN, otherwise False
@@ -731,12 +750,12 @@ def is_empty(v):
 def to_bool(v):
     """
     Convert an object to a bool with specific rules.
-    
+
     Args:
-        obj (object): The object to convert
-        
+        v (object): The object to convert
+
     Returns:
-        bool or None: 
+        bool or None:
         - For strings: True if 'true' (case-insensitive), False if 'false', recursively applied if int-like
         - For int/bytes: False if 0, True otherwise
         - For bool: returns the bool as-is
@@ -745,7 +764,7 @@ def to_bool(v):
 
     if isinstance(v, bool):
         return v
-    
+
     if isinstance(v, str):
 
         try:
@@ -764,7 +783,7 @@ def to_bool(v):
 
     if isinstance(v, (int, bytes)):
         return v != 0
-    
+
     return None
 
 
@@ -817,7 +836,7 @@ def isnan(v):
     Returns True if v is a nan-valued float, otherwise returns False.
 
     Args:
-        v: the object to evaluate for nan-ness
+        v (obj): the object to evaluate for nan-ness
 
     Returns:
         bool: True if v is a nan-valued float, otherwise False
@@ -866,7 +885,7 @@ def is_function_name(s,calling_namespace):
 def parse_kvp(s,kv_separator='='):
     """
     Parse a key/value pair, separated by [kv_separator].  Errors if s is not
-    a valid key/value pair string.  Strips leading/trailing whitespace from 
+    a valid key/value pair string.  Strips leading/trailing whitespace from
     the key and value.
 
     Args:
@@ -1014,6 +1033,10 @@ def make_temp_folder(top_level_folder='megadetector',subfolder=None,append_guid=
 def make_test_folder(subfolder=None):
     """
     Wrapper around make_temp_folder that creates folders within megadetector/tests
+
+    Args:
+        subfolder (str): specific subfolder to create within the default megadetector temp
+            folder.
     """
 
     return make_temp_folder(top_level_folder='megadetector/tests',
@@ -1135,14 +1158,14 @@ def test_geometric_operations():
     r1 = [0.4,0.8,10,22]; r2 = [100, 101, 200, 210.4]; assert abs(rect_distance(r1,r2)-119.753) < 0.001
     r1 = [0.4,0.8,10,22]; r2 = [101, 101, 200, 210.4]; assert abs(rect_distance(r1,r2)-120.507) < 0.001
     r1 = [0.4,0.8,10,22]; r2 = [120, 120, 200, 210.4]; assert abs(rect_distance(r1,r2)-147.323) < 0.001
-    
+
     # Test with 'x0y0wh' format
     r1_wh = [0,0,1,1]; r2_wh = [1,0,1,1]; assert rect_distance(r1_wh, r2_wh, format='x0y0wh') == 0
     r1_wh = [0,0,1,1]; r2_wh = [1.5,0,1,1]; assert abs(rect_distance(r1_wh, r2_wh, format='x0y0wh') - 0.5) < 0.00001
 
 
     ##%% Test point_dist
-	
+
     assert point_dist((0,0), (3,4)) == 5.0
     assert point_dist((1,1), (1,1)) == 0.0
 
@@ -1153,17 +1176,17 @@ def test_dictionary_operations():
     """
 
     ##%% Test sort_list_of_dicts_by_key
-	
-    L = [{'a':5},{'a':0},{'a':10}] 
+
+    x = [{'a':5},{'a':0},{'a':10}]
     k = 'a'
-    sorted_L = sort_list_of_dicts_by_key(L, k)
-    assert sorted_L[0]['a'] == 0; assert sorted_L[1]['a'] == 5; assert sorted_L[2]['a'] == 10
-    sorted_L_rev = sort_list_of_dicts_by_key(L, k, reverse=True)
-    assert sorted_L_rev[0]['a'] == 10; assert sorted_L_rev[1]['a'] == 5; assert sorted_L_rev[2]['a'] == 0
+    sorted_x = sort_list_of_dicts_by_key(x, k)
+    assert sorted_x[0]['a'] == 0; assert sorted_x[1]['a'] == 5; assert sorted_x[2]['a'] == 10
+    sorted_x_rev = sort_list_of_dicts_by_key(x, k, reverse=True)
+    assert sorted_x_rev[0]['a'] == 10; assert sorted_x_rev[1]['a'] == 5; assert sorted_x_rev[2]['a'] == 0
 
 
     ##%% Test sort_dictionary_by_key
-	
+
     d_key = {'b': 2, 'a': 1, 'c': 3}
     sorted_d_key = sort_dictionary_by_key(d_key)
     assert list(sorted_d_key.keys()) == ['a', 'b', 'c']
@@ -1190,7 +1213,7 @@ def test_dictionary_operations():
     d_inv = {'a': 'x', 'b': 'y'}
     inverted_d = invert_dictionary(d_inv)
     assert inverted_d == {'x': 'a', 'y': 'b'}
-	
+
     # Does not check for uniqueness, last one wins
     d_inv_dup = {'a': 'x', 'b': 'x'}
     inverted_d_dup = invert_dictionary(d_inv_dup)
@@ -1203,7 +1226,7 @@ def test_float_rounding_and_truncation():
     """
 
     ##%% Test round_floats_in_nested_dict
-	
+
     data = {
         "name": "Project X",
         "values": [1.23456789, 2.3456789],
@@ -1229,7 +1252,7 @@ def test_float_rounding_and_truncation():
 
 
     ##%% Test truncate_float_array and truncate_float
-	
+
     assert truncate_float_array([0.12345, 0.67890], precision=3) == [0.123, 0.678]
     assert truncate_float_array([1.0, 2.0], precision=2) == [1.0, 2.0]
     assert truncate_float(0.12345, precision=3) == 0.123
@@ -1239,7 +1262,7 @@ def test_float_rounding_and_truncation():
 
 
     ##%% Test round_float_array and round_float
-	
+
     assert round_float_array([0.12345, 0.67890], precision=3) == [0.123, 0.679]
     assert round_float_array([1.0, 2.0], precision=2) == [1.0, 2.0]
     assert round_float(0.12345, precision=3) == 0.123
@@ -1253,7 +1276,7 @@ def test_object_conversion_and_presentation():
     """
 
     ##%% Test args_to_object
-	
+
     class ArgsObject:
         pass
     args_namespace = type('ArgsNameSpace', (), {'a': 1, 'b': 'test', '_c': 'ignored'})
@@ -1265,7 +1288,7 @@ def test_object_conversion_and_presentation():
 
 
     ##%% Test dict_to_object
-	
+
     class DictObject:
         pass
     d = {'a': 1, 'b': 'test', '_c': 'ignored'}
@@ -1277,7 +1300,7 @@ def test_object_conversion_and_presentation():
 
 
     ##%% Test pretty_print_object
-	
+
     class PrettyPrintable:
         def __init__(self):
             self.a = 1
@@ -1289,7 +1312,7 @@ def test_object_conversion_and_presentation():
     parsed_json = json.loads(json_str) # Relies on json.loads
     assert parsed_json['a'] == 1
     assert parsed_json['b'] == "test"
-    
+
 
 def test_list_operations():
     """
@@ -1297,7 +1320,7 @@ def test_list_operations():
     """
 
     ##%% Test is_list_sorted
-	
+
     assert is_list_sorted([1, 2, 3])
     assert not is_list_sorted([1, 3, 2])
     assert is_list_sorted([3, 2, 1], reverse=True)
@@ -1306,10 +1329,10 @@ def test_list_operations():
     assert is_list_sorted([1]) # Single element list is sorted
     assert is_list_sorted([1,1,1])
     assert is_list_sorted([1,1,1], reverse=True)
-    
-	
+
+
     ##%% Test split_list_into_fixed_size_chunks
-	
+
     assert split_list_into_fixed_size_chunks([1,2,3,4,5,6], 2) == [[1,2],[3,4],[5,6]]
     assert split_list_into_fixed_size_chunks([1,2,3,4,5], 2) == [[1,2],[3,4],[5]]
     assert split_list_into_fixed_size_chunks([], 3) == []
@@ -1317,11 +1340,11 @@ def test_list_operations():
 
 
     ##%% Test split_list_into_n_chunks
-	
+
     # Greedy
     assert split_list_into_n_chunks([1,2,3,4,5,6], 3, chunk_strategy='greedy') == [[1,2],[3,4],[5,6]]
-    assert split_list_into_n_chunks([1,2,3,4,5], 3, chunk_strategy='greedy') == [[1,2],[3,4],[5]] 
-    assert split_list_into_n_chunks([1,2,3,4,5,6,7], 3, chunk_strategy='greedy') == [[1,2,3],[4,5],[6,7]] 
+    assert split_list_into_n_chunks([1,2,3,4,5], 3, chunk_strategy='greedy') == [[1,2],[3,4],[5]]
+    assert split_list_into_n_chunks([1,2,3,4,5,6,7], 3, chunk_strategy='greedy') == [[1,2,3],[4,5],[6,7]]
     assert split_list_into_n_chunks([], 3) == [[],[],[]]
 
     # Balanced
@@ -1330,7 +1353,7 @@ def test_list_operations():
     assert split_list_into_n_chunks([], 3, chunk_strategy='balanced') == [[],[],[]]
     try:
         split_list_into_n_chunks([1,2,3], 2, chunk_strategy='invalid')
-        assert False, "ValueError not raised for invalid chunk_strategy"
+        raise AssertionError("ValueError not raised for invalid chunk_strategy")
     except ValueError:
         pass
 
@@ -1341,19 +1364,19 @@ def test_datetime_serialization():
     """
 
     ##%% Test json_serialize_datetime
-	
+
     now = datetime.datetime.now()
     today = datetime.date.today()
     assert json_serialize_datetime(now) == now.isoformat()
     assert json_serialize_datetime(today) == today.isoformat()
     try:
         json_serialize_datetime("not a datetime")
-        assert False, "TypeError not raised for non-datetime object"
+        raise AssertionError("TypeError not raised for non-datetime object")
     except TypeError:
         pass
     try:
         json_serialize_datetime(123)
-        assert False, "TypeError not raised for non-datetime object"
+        raise AssertionError("TypeError not raised for non-datetime object")
     except TypeError:
         pass
 
@@ -1364,7 +1387,7 @@ def test_bounding_box_operations():
     """
 
     ##%% Test convert_yolo_to_xywh
-	
+
     # [x_center, y_center, w, h]
     yolo_box = [0.5, 0.5, 0.2, 0.2]
     # [x_min, y_min, width_of_box, height_of_box]
@@ -1373,7 +1396,7 @@ def test_bounding_box_operations():
 
 
     ##%% Test convert_xywh_to_xyxy
-	
+
     # [x_min, y_min, width_of_box, height_of_box]
     xywh_box = [0.1, 0.1, 0.3, 0.3]
     # [x_min, y_min, x_max, y_max]
@@ -1387,7 +1410,7 @@ def test_bounding_box_operations():
     bb2 = [0.25, 0.25, 0.5, 0.5]
     assert abs(get_iou(bb1, bb2) - 0.142857) < 1e-5
     bb3 = [0, 0, 1, 1]
-    bb4 = [0.5, 0.5, 1, 1] 
+    bb4 = [0.5, 0.5, 1, 1]
     assert abs(get_iou(bb3, bb4) - (0.25 / 1.75)) < 1e-5
     bb5 = [0,0,1,1]
     bb6 = [1,1,1,1] # No overlap
@@ -1410,7 +1433,7 @@ def test_detection_processing():
     """
 
     ##%% Test _get_max_conf_from_detections and get_max_conf
-	
+
     detections1 = [{'conf': 0.8}, {'conf': 0.9}, {'conf': 0.75}]
     assert _get_max_conf_from_detections(detections1) == 0.9
     assert _get_max_conf_from_detections([]) == 0.0
@@ -1424,8 +1447,8 @@ def test_detection_processing():
     assert get_max_conf(im3) == 0.0
     im4 = {'detections': None}
     assert get_max_conf(im4) == 0.0
-    
-	
+
+
     ##%% Test sort_results_for_image
 
     img_data = {
@@ -1436,30 +1459,30 @@ def test_detection_processing():
         ]
     }
     sort_results_for_image(img_data)
-    
-	# Check detections sorted by conf
+
+    # Check detections sorted by conf
     assert img_data['detections'][0]['conf'] == 0.9
     assert img_data['detections'][1]['conf'] == 0.8
     assert img_data['detections'][2]['conf'] == 0.7
-    
-	# Check classifications sorted by conf (only for the first original detection, now at index 0 after sort)
+
+    # Check classifications sorted by conf (only for the first original detection, now at index 0 after sort)
     assert img_data['detections'][0]['classifications'][0] == ('x', 0.95)
     assert img_data['detections'][0]['classifications'][1] == ('y', 0.85)
-    
-	# Check classifications for the second original detection (now at index 2)
+
+    # Check classifications for the second original detection (now at index 2)
     assert img_data['detections'][2]['classifications'][0] == ('a', 0.9)
     assert img_data['detections'][2]['classifications'][1] == ('b', 0.8)
     assert img_data['detections'][2]['classifications'][2] == ('c', 0.6)
-    
+
     # Test with no detections or no classifications field
     img_data_no_det = {'detections': None}
-    sort_results_for_image(img_data_no_det) 
+    sort_results_for_image(img_data_no_det)
     assert img_data_no_det['detections'] is None
-    
+
     img_data_empty_det = {'detections': []}
     sort_results_for_image(img_data_empty_det)
     assert img_data_empty_det['detections'] == []
-    
+
     img_data_no_classifications_field = {'detections': [{'conf': 0.8}]}
     sort_results_for_image(img_data_no_classifications_field)
     assert 'classifications' not in img_data_no_classifications_field['detections'][0]
@@ -1479,7 +1502,7 @@ def test_type_checking_and_validation():
     """
 
     ##%% Test is_float
-	
+
     assert is_float(1.23)
     assert is_float("1.23")
     assert is_float("-1.23")
@@ -1490,7 +1513,7 @@ def test_type_checking_and_validation():
 
 
     ##%% Test is_iterable
-	
+
     assert is_iterable([1,2,3])
     assert is_iterable("hello")
     assert is_iterable({'a':1})
@@ -1501,7 +1524,7 @@ def test_type_checking_and_validation():
 
 
     ##%% Test is_empty
-	
+
     assert is_empty(None)
     assert is_empty("")
     assert is_empty(np.nan)
@@ -1513,7 +1536,7 @@ def test_type_checking_and_validation():
 
 
     ##%% Test min_none and max_none
-	
+
     assert min_none(1, 2) == 1
     assert min_none(None, 2) == 2
     assert min_none(1, None) == 1
@@ -1525,7 +1548,7 @@ def test_type_checking_and_validation():
 
 
     ##%% Test isnan
-	
+
     assert isnan(np.nan)
     assert not isnan(0.0)
     assert not isnan("text")
@@ -1535,7 +1558,7 @@ def test_type_checking_and_validation():
 
 
     ##%% Test sets_overlap
-	
+
     assert sets_overlap({1,2,3}, {3,4,5})
     assert not sets_overlap({1,2}, {3,4})
     assert sets_overlap([1,2,3], [3,4,5]) # Test with lists
@@ -1544,7 +1567,7 @@ def test_type_checking_and_validation():
 
 
     ##%% Test is_function_name
-	
+
     def _test_local_func(): pass
     assert is_function_name("is_float", locals()) # Test a function in ct_utils
     assert is_function_name("_test_local_func", locals()) # Test a local function
@@ -1563,38 +1586,38 @@ def test_string_parsing():
     """
 
     ##%% Test parse_kvp and parse_kvp_list
-	
+
     assert parse_kvp("key=value") == ("key", "value")
     assert parse_kvp("key = value with spaces") == ("key", "value with spaces")
     assert parse_kvp("key=value1=value2", kv_separator='=') == ("key", "value1=value2")
     try:
         parse_kvp("keyvalue")
-        assert False, "AssertionError not raised for invalid KVP"
+        raise AssertionError("AssertionError not raised for invalid KVP")
     except AssertionError:
         pass
-    
+
     kvp_list = ["a=1", "b = 2", "c=foo=bar"]
     parsed_list = parse_kvp_list(kvp_list)
     assert parsed_list == {"a": "1", "b": "2", "c": "foo=bar"}
     assert parse_kvp_list(None) == {}
     assert parse_kvp_list([]) == {}
     d_initial = {'z': '0'}
-    
-	# parse_kvp_list modifies d in place if provided
-    parse_kvp_list(kvp_list, d=d_initial) 
+
+    # parse_kvp_list modifies d in place if provided
+    parse_kvp_list(kvp_list, d=d_initial)
     assert d_initial == {"z": "0", "a": "1", "b": "2", "c": "foo=bar"}
-    
-	# Test with a different separator
+
+    # Test with a different separator
     assert parse_kvp("key:value", kv_separator=":") == ("key", "value")
     assert parse_kvp_list(["a:1","b:2"], kv_separator=":") == {"a":"1", "b":"2"}
 
 
     ##%% Test dict_to_kvp_list
-	
+
     d_kvp = {"a": "1", "b": "dog", "c": "foo=bar"}
     kvp_str = dict_to_kvp_list(d_kvp)
-    
-	# Order isn't guaranteed, so check for presence of all items and length
+
+    # Order isn't guaranteed, so check for presence of all items and length
     assert "a=1" in kvp_str
     assert "b=dog" in kvp_str
     assert "c=foo=bar" in kvp_str
@@ -1605,12 +1628,12 @@ def test_string_parsing():
     d_kvp_int = {"a":1, "b":"text"}
     try:
         dict_to_kvp_list(d_kvp_int, non_string_value_handling='error')
-        assert False, "ValueError not raised for non-string value with 'error' handling"
+        raise AssertionError("ValueError not raised for non-string value with 'error' handling")
     except ValueError:
         pass
     convert_result = dict_to_kvp_list(d_kvp_int, non_string_value_handling='convert')
     assert "a=1" in convert_result and "b=text" in convert_result
-    
+
     omit_result = dict_to_kvp_list({"a":1, "b":"text"}, non_string_value_handling='omit')
     assert "a=1" not in omit_result and "b=text" in omit_result
     assert omit_result == "b=text"
@@ -1619,7 +1642,7 @@ def test_string_parsing():
 
 
     ##%% Test parse_bool_string
-	
+
     assert parse_bool_string("true")
     assert parse_bool_string("True")
     assert parse_bool_string(" TRUE ")
@@ -1630,12 +1653,12 @@ def test_string_parsing():
     assert parse_bool_string(False) is False
     try:
         parse_bool_string("maybe")
-        assert False, "ValueError not raised for invalid bool string"
+        raise AssertionError("ValueError not raised for invalid bool string")
     except ValueError:
         pass
     try:
         parse_bool_string("1") # Should not parse to True
-        assert False, "ValueError not raised for '1'"
+        raise AssertionError("ValueError not raised for '1'")
     except ValueError:
         pass
 
@@ -1647,18 +1670,18 @@ def test_temp_folder_creation():
 
     # Store original tempdir for restoration if modified by tests (though unlikely for make_temp_folder)
     original_tempdir = tempfile.gettempdir()
-    
+
     # Test make_temp_folder
     custom_top_level = "my_custom_temp_app_test" # Unique name for this test run
     custom_subfolder = "specific_test_run"
-    
+
     # Test with default subfolder (UUID)
     temp_folder1_base = os.path.join(tempfile.gettempdir(), custom_top_level)
     temp_folder1 = make_temp_folder(top_level_folder=custom_top_level)
     assert os.path.exists(temp_folder1)
     assert os.path.basename(os.path.dirname(temp_folder1)) == custom_top_level
     assert temp_folder1_base == os.path.dirname(temp_folder1) # Path up to UUID should match
-   
+
     # Cleanup: remove the custom_top_level which contains the UUID folder
     if os.path.exists(temp_folder1_base):
         shutil.rmtree(temp_folder1_base)
@@ -1674,26 +1697,26 @@ def test_temp_folder_creation():
     assert os.path.basename(temp_folder2) == custom_subfolder
     assert os.path.basename(os.path.dirname(temp_folder2)) == custom_top_level
     assert temp_folder2 == os.path.join(tempfile.gettempdir(), custom_top_level, custom_subfolder)
-    
-	# Cleanup
+
+    # Cleanup
     if os.path.exists(temp_folder2_base):
         shutil.rmtree(temp_folder2_base)
     assert not os.path.exists(temp_folder2_base)
 
 
     # Test make_test_folder (which uses 'megadetector/tests' as top_level)
-	#
+    #
     # This will create tempfile.gettempdir()/megadetector/tests/some_uuid or specified_subfolder
     megadetector_temp_base = os.path.join(tempfile.gettempdir(), "megadetector")
     test_subfolder = "my_specific_module_test"
-    
+
     # Test with default subfolder for make_test_folder
     test_folder1 = make_test_folder() # Creates megadetector/tests/uuid_folder
     assert os.path.exists(test_folder1)
     assert os.path.basename(os.path.dirname(test_folder1)) == "tests"
     assert os.path.basename(os.path.dirname(os.path.dirname(test_folder1))) == "megadetector"
-    
-	# Cleanup for make_test_folder default: remove the 'megadetector' base temp dir
+
+    # Cleanup for make_test_folder default: remove the 'megadetector' base temp dir
     if os.path.exists(megadetector_temp_base):
         shutil.rmtree(megadetector_temp_base)
     assert not os.path.exists(megadetector_temp_base)
@@ -1703,21 +1726,21 @@ def test_temp_folder_creation():
     test_folder2 = make_test_folder(subfolder=test_subfolder) # megadetector/tests/my_specific_module_test
     assert os.path.exists(test_folder2)
     assert test_subfolder in test_folder2
-    assert "megadetector" in test_folder2    
-    
-	# Cleanup for make_test_folder specific: remove the 'megadetector' base temp dir
+    assert "megadetector" in test_folder2
+
+    # Cleanup for make_test_folder specific: remove the 'megadetector' base temp dir
     if os.path.exists(megadetector_temp_base):
         shutil.rmtree(megadetector_temp_base)
     assert not os.path.exists(megadetector_temp_base)
-    
+
     # Verify cleanup if top level folder was 'megadetector' (default for make_temp_folder)
-	#
+    #
     # This means it creates tempfile.gettempdir()/megadetector/uuid_folder
-    default_temp_folder = make_temp_folder() 
+    default_temp_folder = make_temp_folder()
     assert os.path.exists(default_temp_folder)
     assert os.path.basename(os.path.dirname(default_temp_folder)) == "megadetector"
-    
-	# Cleanup: remove the 'megadetector' base temp dir created by default make_temp_folder
+
+    # Cleanup: remove the 'megadetector' base temp dir created by default make_temp_folder
     if os.path.exists(megadetector_temp_base):
          shutil.rmtree(megadetector_temp_base)
     assert not os.path.exists(megadetector_temp_base)
@@ -1729,7 +1752,7 @@ def test_temp_folder_creation():
 def run_all_module_tests():
     """
     Run all tests in the ct_utils module.  This is not invoked by pytest; this is
-    just a convenience wrapper for debuggig the tests.
+    just a convenience wrapper for debugging the tests.
     """
 
     test_write_json()
@@ -1745,6 +1768,3 @@ def run_all_module_tests():
     test_type_checking_and_validation()
     test_string_parsing()
     test_temp_folder_creation()
-
-# from IPython import embed; embed()
-# run_all_module_tests()