megadetector 10.0.10__py3-none-any.whl → 10.0.11__py3-none-any.whl

megadetector/postprocessing/render_detection_confusion_matrix.py

@@ -252,9 +252,10 @@ def render_detection_confusion_matrix(ground_truth_file,
                                     md_formatted_results['images']),
                                     total=len(md_formatted_results['images'])))
         finally:
-            pool.close()
-            pool.join()
-            print("Pool closed and joined for confusion matrix rendering")
+            if pool is not None:
+                pool.close()
+                pool.join()
+                print("Pool closed and joined for confusion matrix rendering")
 
     else:
 
@@ -369,11 +370,15 @@ def render_detection_confusion_matrix(ground_truth_file,
 
         # If there were no detections at all, call this image empty
         if len(results_im['detections']) == 0:
+
             predicted_category_name = empty_category_name
+
         # Otherwise look for above-threshold detections
         else:
+
             results_category_name_to_confidence = defaultdict(int)
             for det in results_im['detections']:
+
                 category_name = results_category_id_to_name[det['category']]
                 detection_threshold = confidence_thresholds['default']
                 if category_name in confidence_thresholds:
@@ -381,12 +386,15 @@ def render_detection_confusion_matrix(ground_truth_file,
                 if det['conf'] > detection_threshold:
                     results_category_name_to_confidence[category_name] = max(
                         results_category_name_to_confidence[category_name],det['conf'])
-                # If there were no detections above threshold
-                if len(results_category_name_to_confidence) == 0:
-                    predicted_category_name = empty_category_name
-                else:
-                    predicted_category_name = max(results_category_name_to_confidence,
-                        key=results_category_name_to_confidence.get)
+
+            # ...for each detection
+
+            # If there were no detections above threshold
+            if len(results_category_name_to_confidence) == 0:
+                predicted_category_name = empty_category_name
+            else:
+                predicted_category_name = max(results_category_name_to_confidence,
+                    key=results_category_name_to_confidence.get)
 
         ground_truth_category_index = gt_category_name_to_category_index[ground_truth_category_name]
         predicted_category_index = gt_category_name_to_category_index[predicted_category_name]
@@ -396,7 +404,7 @@ def render_detection_confusion_matrix(ground_truth_file,
 
         confusion_matrix[ground_truth_category_index,predicted_category_index] += 1
 
-    # ...for each file
+    # ...for each ground truth file
 
     plt.ioff()
 

megadetector/postprocessing/repeat_detection_elimination/remove_repeat_detections.py

@@ -37,7 +37,7 @@ def remove_repeat_detections(input_file,output_file,filtering_dir):
     """
 
     assert os.path.isfile(input_file), "Can't find file {}".format(input_file)
-    assert os.path.isdir(filtering_dir), "Can't find folder {}".format(filtering_dir)
+    assert os.path.exists(filtering_dir), "Can't find input file/folder {}".format(filtering_dir)
     options = repeat_detections_core.RepeatDetectionOptions()
     if os.path.isfile(filtering_dir):
         options.filterFileToLoad = filtering_dir

megadetector/postprocessing/repeat_detection_elimination/repeat_detections_core.py

@@ -869,7 +869,7 @@ def _update_detection_table(repeat_detection_results, options, output_file_name=
                 detection_to_modify = row_detections[instance.i_detection]
 
                 # Make sure the bounding box matches
-                assert (instance_bbox[0:3] == detection_to_modify['bbox'][0:3])
+                assert (instance_bbox[0:4] == detection_to_modify['bbox'][0:4])
 
                 # Make the probability negative, if it hasn't been switched by
                 # another bounding box
@@ -1149,7 +1149,8 @@ def find_repeat_detections(input_filename, output_file_name=None, options=None):
 
         # Load the filtering file
         detection_index_file_name = options.filterFileToLoad
-        s_in = open(detection_index_file_name, 'r').read()
+        with open(detection_index_file_name, 'r') as f:
+            s_in = f.read()
         detection_info = jsonpickle.decode(s_in)
         filtering_base_dir = os.path.dirname(options.filterFileToLoad)
         suspicious_detections = detection_info['suspicious_detections']
@@ -1382,7 +1383,8 @@ def find_repeat_detections(input_filename, output_file_name=None, options=None):
 
                 # candidate_detection_file = all_candidate_detection_files[0]
                 for candidate_detection_file in all_candidate_detection_files:
-                    s = open(candidate_detection_file, 'r').read()
+                    with open(candidate_detection_file, 'r') as f:
+                        s = f.read()
                     candidate_detections_this_file = jsonpickle.decode(s)
                     all_candidate_detections.append(candidate_detections_this_file)
 

megadetector/postprocessing/separate_detections_into_folders.py

@@ -494,7 +494,8 @@ def separate_detections_into_folders(options):
 
     # Load detection results
     print('Loading detection results')
-    results = json.load(open(options.results_file))
+    with open(options.results_file,'r') as f:
+        results = json.load(f)
     images = results['images']
 
     for im in images:
@@ -618,8 +619,13 @@ def separate_detections_into_folders(options):
 
         print('Starting a pool with {} threads'.format(options.n_threads))
         pool = ThreadPool(options.n_threads)
-        process_detections_with_options = partial(_process_detections, options=options)
-        _ = list(tqdm(pool.imap(process_detections_with_options, images), total=len(images)))
+        try:
+            process_detections_with_options = partial(_process_detections, options=options)
+            _ = list(tqdm(pool.imap(process_detections_with_options, images), total=len(images)))
+        finally:
+            pool.close()
+            pool.join()
+            print('Pool closed and joined for folder separation')
 
     if options.remove_empty_folders:
         print('Removing empty folders from {}'.format(options.base_output_folder))
@@ -736,7 +742,7 @@ def main(): # noqa
                         help='Line thickness (in pixels) for rendering, only meaningful if ' + \
                              'using render_boxes (defaults to {})'.format(
                              default_line_thickness))
-    parser.add_argument('--box_expansion', type=int, default=default_line_thickness,
+    parser.add_argument('--box_expansion', type=int, default=default_box_expansion,
                         help='Box expansion (in pixels) for rendering, only meaningful if ' + \
                              'using render_boxes (defaults to {})'.format(
                              default_box_expansion))

megadetector/postprocessing/subset_json_detector_output.py

@@ -433,7 +433,7 @@ def subset_json_detector_output_by_list(data, options):
     """
 
     if options.keep_files_in_list is None:
-        return
+        return data
 
     files_to_keep = None
 

megadetector/postprocessing/top_folders_to_bottom.py

@@ -45,7 +45,12 @@ class TopFoldersToBottomOptions:
     Options used to parameterize top_folders_to_bottom()
     """
 
-    def __init__(self,input_folder,output_folder,copy=True,n_threads=1):
+    def __init__(self,
+                 input_folder,
+                 output_folder,
+                 copy=True,
+                 n_threads=1,
+                 overwrite=False):
 
         #: Whether to copy (True) vs. move (False) false when re-organizing
         self.copy = copy
@@ -60,7 +65,7 @@ class TopFoldersToBottomOptions:
         self.output_folder = output_folder
 
         #: If this is False and an output file exists, throw an error
-        self.overwrite = False
+        self.overwrite = overwrite
 
 
 #%% Main functions
@@ -130,6 +135,7 @@ def top_folders_to_bottom(options):
         options (TopFoldersToBottomOptions): See TopFoldersToBottomOptions for parameter details.
 
     """
+
     os.makedirs(options.output_folder,exist_ok=True)
 
     # Enumerate input folder
@@ -167,10 +173,15 @@ def top_folders_to_bottom(options):
 
         print('Starting a pool with {} threads'.format(options.n_threads))
         pool = ThreadPool(options.n_threads)
-        process_file_with_options = partial(_process_file, options=options)
-        _ = list(tqdm(pool.imap(process_file_with_options, relative_files), total=len(relative_files)))
+        try:
+            process_file_with_options = partial(_process_file, options=options)
+            _ = list(tqdm(pool.imap(process_file_with_options, relative_files), total=len(relative_files)))
+        finally:
+            pool.close()
+            pool.join()
+            print('Pool closed and join for folder inversion')
 
-# ...def top_folders_to_bottom()
+# ...def top_folders_to_bottom(...)
 
 
 #%% Interactive driver
@@ -192,7 +203,7 @@ if False:
 
 #%% Command-line driver
 
-# python top_folders_to_bottom.py "g:\temp\separated_images" "g:\temp\separated_images_inverted" --n_threads 100
+# python top_folders_to_bottom.py "g:\temp\separated_images" "g:\temp\separated_images_inverted" --n_threads 10
 
 def main(): # noqa
 
@@ -215,7 +226,11 @@ def main(): # noqa
 
     # Convert to an options object
     options = TopFoldersToBottomOptions(
-        args.input_folder,args.output_folder,copy=args.copy,n_threads=args.n_threads)
+        args.input_folder,
+        args.output_folder,
+        copy=args.copy,
+        n_threads=args.n_threads,
+        overwrite=args.overwrite)
 
     top_folders_to_bottom(options)
 

megadetector/postprocessing/validate_batch_results.py

@@ -39,7 +39,7 @@ typical_keys = ['classification_categories',
 
 class ValidateBatchResultsOptions:
     """
-    Options controlling the behavior of validate_bach_results()
+    Options controlling the behavior of validate_batch_results()
     """
 
     def __init__(self):

megadetector/taxonomy_mapping/map_new_lila_datasets.py

@@ -15,10 +15,10 @@ import json
 # Created by get_lila_category_list.py
 input_lila_category_list_file = os.path.expanduser('~/lila/lila_categories_list/lila_dataset_to_categories.json')
 
-output_file = os.path.expanduser('~/lila/lila_additions_2025.06.23.csv')
+output_file = os.path.expanduser('~/lila/lila_additions_2025.10.07.csv')
 
 datasets_to_map = [
-    'Nkhotakota Camera Traps'
+    'California Small Animals'
     ]
 
 
@@ -128,6 +128,52 @@ output_df.to_csv(output_file, index=None, header=True)
 # from megadetector.utils.path_utils import open_file; open_file(output_file)
 
 
+#%% Remap missing entries in the .csv file
+
+# ...typically because I made a change to the mapping code.
+
+from megadetector.utils.path_utils import insert_before_extension
+from megadetector.utils.ct_utils import is_empty
+
+remapped_file = insert_before_extension(output_file,'remapped')
+
+df = pd.read_csv(output_file)
+
+for i_row,row in df.iterrows():
+
+    # Do we need to map this row?
+    if is_empty(row['source']):
+
+        query = row['query']
+        print('Mapping {}'.format(query))
+
+        taxonomic_match = get_preferred_taxonomic_match(query,taxonomy_preference=taxonomy_preference)
+
+        if (taxonomic_match.source == taxonomy_preference):
+
+            source = taxonomic_match.source
+            taxonomy_level = taxonomic_match.taxonomic_level
+            scientific_name = taxonomic_match.scientific_name
+            common_name  = taxonomic_match.common_name
+            taxonomy_string = taxonomic_match.taxonomy_string
+
+            # Write source, taxonomy_level, scientific_name, common_name, and taxonomy_string
+            # to the corresponding columns in the current row in df
+            df.loc[i_row, 'source'] = source
+            df.loc[i_row, 'taxonomy_level'] = taxonomy_level
+            df.loc[i_row, 'scientific_name'] = scientific_name
+            df.loc[i_row, 'common_name'] = common_name
+            df.loc[i_row, 'taxonomy_string'] = taxonomy_string
+
+        # ...if we found a match
+
+    # ...do we need to map this row?
+
+# ...for each row
+
+df.to_csv(remapped_file, index=None, header=True)
+
+
 #%% Manual lookup
 
 if False:
@@ -140,11 +186,19 @@ if False:
 
     #%%
 
-    q = 'animalia'
+    from megadetector.taxonomy_mapping.species_lookup import pop_levels
+
+    # Use this when an iNat match includes an empty subgenus with the same name as the genus
+    n_levels_to_pop = 0
+    q = 'sus scrofa'
 
     taxonomy_preference = 'inat'
     m = get_preferred_taxonomic_match(q,taxonomy_preference)
+    if n_levels_to_pop > 0:
+        m = pop_levels(m,n_levels_to_pop)
+
     # print(m.scientific_name); import clipboard; clipboard.copy(m.scientific_name)
+    # common_name = eval(m.__dict__['taxonomy_string'])[0][-1][0]; print(common_name); clipboard.copy(common_name)
 
     if (m is None) or (len(m.taxonomy_string) == 0):
         print('No match')
@@ -155,3 +209,5 @@ if False:
         print(m.source)
         print(m.taxonomy_string)
         import clipboard; clipboard.copy(m.taxonomy_string)
+
+

megadetector/taxonomy_mapping/prepare_lila_taxonomy_release.py

@@ -162,4 +162,4 @@ if False:
 
     print('Wrote final output to {}'.format(release_taxonomy_file))
 
-# ...if False
+

megadetector/taxonomy_mapping/preview_lila_taxonomy.py

@@ -16,7 +16,7 @@ import os
 import pandas as pd
 
 # lila_taxonomy_file = r"c:\git\agentmorrisprivate\lila-taxonomy\lila-taxonomy-mapping.csv"
-lila_taxonomy_file = os.path.expanduser('~/lila/lila_additions_2025.06.23.csv')
+lila_taxonomy_file = os.path.expanduser('~/lila/lila_additions_2025.10.07.csv')
 
 preview_base = os.path.expanduser('~/lila/lila_taxonomy_preview')
 os.makedirs(preview_base,exist_ok=True)
@@ -56,11 +56,6 @@ def taxonomy_string_to_level(taxonomy_string):
     return level
 
 
-#%% Read the taxonomy mapping file
-
-df = pd.read_csv(lila_taxonomy_file)
-
-
 #%% Prepare taxonomy lookup
 
 from megadetector.taxonomy_mapping.species_lookup import \
@@ -95,20 +90,29 @@ taxonomy_preference = 'inat'
 # i_row = 0; row = df.iloc[i_row]
 for i_row,row in tqdm(df.iterrows(),total=len(df)):
 
-    sn = row['scientific_name']
-    if not isinstance(sn,str):
-        continue
+    try:
+
+        sn = row['scientific_name']
+        if not isinstance(sn,str):
+            continue
 
-    m = get_preferred_taxonomic_match(sn,taxonomy_preference)
-    assert m.scientific_name == sn
+        m = get_preferred_taxonomic_match(sn,taxonomy_preference)
+        assert m.scientific_name == sn
 
-    ts = row['taxonomy_string']
-    assert m.taxonomy_string[0:50] == ts[0:50], 'Mismatch for {}:\n\n{}\n\n{}\n'.format(
-        row['dataset_name'],ts,m.taxonomy_string)
+        ts = row['taxonomy_string']
+        assert m.taxonomy_string[0:50] == ts[0:50], 'Mismatch for {}:\n\n{}\n\n{}\n'.format(
+            row['dataset_name'],ts,m.taxonomy_string)
+
+        if ts != m.taxonomy_string:
+            n_taxonomy_changes += 1
+            df.loc[i_row,'taxonomy_string'] = m.taxonomy_string
+
+    except Exception as e:
 
-    if ts != m.taxonomy_string:
-        n_taxonomy_changes += 1
-        df.loc[i_row,'taxonomy_string'] = m.taxonomy_string
+        print('Error at row {}: {}'.format(i_row,str(e)))
+        raise
+
+# ...for each row
 
 print('\nMade {} taxonomy changes'.format(n_taxonomy_changes))
 
@@ -325,6 +329,11 @@ for i_row,row in df.iterrows():
 
 #%% Download sample images for all scientific names
 
+# You might have to do this:
+#
+# pip install python-magic
+# pip install python-magic-bin
+
 # Takes ~1 minute per 10 rows
 
 remapped_queries = {'papio':'papio+baboon',

megadetector/taxonomy_mapping/species_lookup.py

@@ -560,6 +560,7 @@ def get_taxonomic_info(query: str) -> List[Dict[str, Any]]:
     Main entry point: get taxonomic matches from both taxonomies for [query],
     which may be a scientific or common name.
     """
+
     query = query.strip().lower()
     # print("Finding taxonomy information for: {0}".format(query))
 
@@ -682,6 +683,35 @@ hyphenated_terms = ['crowned', 'backed', 'throated', 'tailed', 'headed', 'cheeke
                     'fronted', 'bellied', 'spotted', 'eared', 'collared', 'breasted',
                     'necked']
 
+def pop_levels(m, n_levels=1):
+    """
+    Remove [n_levels] levels from the bottom of the TaxonomicMatch object m, typically used to remove
+    silly subgenera.
+    """
+
+    v = eval(m.taxonomy_string)
+    assert v[0][1] == m.taxonomic_level
+    assert v[0][2] == m.scientific_name
+    popped_v = v[n_levels:]
+    taxonomic_level = popped_v[0][1]
+    scientific_name = popped_v[0][2]
+    common_name = popped_v[0][3]
+    if len(common_name) == 0:
+        common_name = ''
+    else:
+        common_name = common_name[0]
+    taxonomy_string = str(popped_v)
+    source = m.source
+    return TaxonomicMatch(scientific_name=scientific_name,
+                          common_name=common_name,
+                          taxonomic_level=taxonomic_level,
+                          source=source,
+                          taxonomy_string=taxonomy_string,
+                          match=None)
+
+# ...def pop_levels(...)
+
+
 def get_preferred_taxonomic_match(query: str, taxonomy_preference = 'inat', retry=True) -> TaxonomicMatch:
     """
     Wrapper for _get_preferred_taxonomic_match, but expressing a variety of heuristics
@@ -704,6 +734,17 @@ def get_preferred_taxonomic_match(query: str, taxonomy_preference = 'inat', retr
     for s in hyphenated_terms:
         query = query.replace(' ' + s,'-' + s)
     m,query = _get_preferred_taxonomic_match(query=query,taxonomy_preference=taxonomy_preference)
+
+    if (len(m.scientific_name) > 0) or (not retry):
+        return m
+
+    query = query.replace(' species','')
+    query = query.replace(' order','')
+    query = query.replace(' genus','')
+    query = query.replace(' family','')
+    query = query.replace(' subfamily','')
+    m,query = _get_preferred_taxonomic_match(query=query,taxonomy_preference=taxonomy_preference)
+
     return m
 
 
@@ -887,8 +928,16 @@ def _get_preferred_taxonomic_match(query: str, taxonomy_preference = 'inat') ->
 
     taxonomy_string = str(match)
 
-    return TaxonomicMatch(scientific_name, common_name, taxonomic_level, source,
-                          taxonomy_string, match),query
+    m = TaxonomicMatch(scientific_name, common_name, taxonomic_level, source,
+                        taxonomy_string, match)
+
+    if (m.taxonomic_level == 'subgenus' and \
+        match[1][1] == 'genus' and \
+        match[1][2] == m.scientific_name):
+        print('Removing redundant subgenus {}'.format(scientific_name))
+        m = pop_levels(m,1)
+
+    return m,query
 
 # ...def _get_preferred_taxonomic_match()
 

megadetector/utils/ct_utils.py

@@ -241,7 +241,10 @@ def write_json(path,
     elif force_str:
         default_handler = str
 
-    os.makedirs(os.path.dirname(path), exist_ok=True)
+    # Create the parent directory if necessary
+    parent_dir = os.path.dirname(path)
+    if len(parent_dir) > 0:
+        os.makedirs(parent_dir, 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)
@@ -562,7 +565,7 @@ def sort_dictionary_by_value(d,sort_values=None,reverse=False):
         reverse (bool, optional): whether to sort in reverse (descending) order
 
     Returns:
-        dict: sorted copy of [d
+        dict: sorted copy of [d]
     """
 
     if sort_values is None:
@@ -1022,8 +1025,10 @@ def parse_bool_string(s, strict=False):
     s = str(s).lower().strip()
 
     if strict:
-        false_strings = ('false')
-        true_strings = ('true')
+        # Fun fact: ('false') (rather than ('false,')) creates a string,
+        # not a tuple.
+        false_strings = ('false',)
+        true_strings = ('true',)
     else:
         false_strings = ('no', 'false', 'f', 'n', '0')
         true_strings = ('yes', 'true', 't', 'y', '1')

megadetector/utils/extract_frames_from_video.py

@@ -55,6 +55,10 @@ class FrameExtractionOptions:
         #: must be a folder when this is specified.
         self.detector_output_file = None
 
+    # ...def __init__(...)
+
+# ...class FrameExtractionOptions
+
 
 #%% Core functions
 

megadetector/utils/gpu_test.py

@@ -34,7 +34,7 @@ def torch_test():
     except Exception as e: #noqa
         print('PyTorch unavailable, not running PyTorch tests.  PyTorch import error was:\n{}'.format(
             str(e)))
-        return
+        return 0
 
     print('Torch version: {}'.format(str(torch.__version__)))
     print('CUDA available (according to PyTorch): {}'.format(torch.cuda.is_available()))
@@ -71,17 +71,17 @@ def tf_test():
     Print diagnostic information about TF/CUDA status.
 
     Returns:
-        int: The number of CUDA devices reported by PyTorch.
+        int: The number of CUDA devices reported by TensorFlow.
     """
 
     try:
-        import tensorflow as tf
+        import tensorflow as tf # type: ignore
     except Exception as e: #noqa
         print('TensorFlow unavailable, not running TF tests.  TF import error was:\n{}'.format(
             str(e)))
-        return
+        return 0
 
-    from tensorflow.python.platform import build_info as build
+    from tensorflow.python.platform import build_info as build # type: ignore
     print(f"TF version: {tf.__version__}")
 
     if 'cuda_version' not in build.build_info:
@@ -94,7 +94,7 @@ def tf_test():
         print(f"CuDNN build version reported by TensorFlow: {build.build_info['cudnn_version']}")
 
     try:
-        from tensorflow.python.compiler.tensorrt import trt_convert as trt
+        from tensorflow.python.compiler.tensorrt import trt_convert as trt # type: ignore
         print("Linked TensorRT version: {}".format(trt.trt_utils._pywrap_py_utils.get_linked_tensorrt_version()))
     except Exception:
         print('Could not probe TensorRT version')

megadetector/utils/md_tests.py

@@ -386,7 +386,7 @@ def output_files_are_identical(fn1,fn2,verbose=False):
     fn2_results['images'] = \
          sorted(fn2_results['images'], key=lambda d: d['file'])
 
-    if len(fn1_results['images']) != len(fn1_results['images']):
+    if len(fn1_results['images']) != len(fn2_results['images']):
         if verbose:
             print('{} images in {}, {} images in {}'.format(
                 len(fn1_results['images']),fn1,
@@ -1249,8 +1249,8 @@ def run_cli_tests(options):
         cmd_results = execute_and_print(cmd)
 
         assert output_files_are_identical(fn1=inference_output_file,
-                                        fn2=inference_output_file_queue,
-                                        verbose=True)
+                                          fn2=inference_output_file_queue,
+                                          verbose=True)
 
 
         ## Run again with the image queue and worker-side preprocessing enabled
@@ -1265,24 +1265,24 @@ def run_cli_tests(options):
         cmd_results = execute_and_print(cmd)
 
         assert output_files_are_identical(fn1=inference_output_file,
-                                        fn2=inference_output_file_preprocess_queue,
-                                        verbose=True)
+                                          fn2=inference_output_file_preprocess_queue,
+                                          verbose=True)
 
 
-        ## Run again with the image queue and worker-side preprocessing
+        ## Run again with the image queue but no worker-side preprocessing
 
-        print('\n** Running MD on a folder (with image queue and preprocessing) (CLI) **\n')
+        print('\n** Running MD on a folder (with image queue but no worker-side preprocessing) (CLI) **\n')
 
-        cmd = base_cmd + ' --use_image_queue --preprocess_on_image_queue'
-        inference_output_file_preprocess_queue = \
-            insert_before_extension(inference_output_file,'preprocess_queue')
-        cmd = cmd.replace(inference_output_file,inference_output_file_preprocess_queue)
+        cmd = base_cmd + ' --use_image_queue'
+        inference_output_file_no_preprocess_queue = \
+            insert_before_extension(inference_output_file,'no_preprocess_queue')
+        cmd = cmd.replace(inference_output_file,inference_output_file_no_preprocess_queue)
         cmd += ' --detector_options {}'.format(dict_to_kvp_list(options.detector_options))
         cmd_results = execute_and_print(cmd)
 
         assert output_files_are_identical(fn1=inference_output_file,
-                                        fn2=inference_output_file_preprocess_queue,
-                                        verbose=True)
+                                          fn2=inference_output_file_no_preprocess_queue,
+                                          verbose=True)
 
 
         ## Run again with the worker-side preprocessing and an alternative batch size
@@ -1316,8 +1316,8 @@ def run_cli_tests(options):
         cmd_results = execute_and_print(cmd)
 
         assert output_files_are_identical(fn1=inference_output_file,
-                                        fn2=inference_output_file_checkpoint,
-                                        verbose=True)
+                                          fn2=inference_output_file_checkpoint,
+                                          verbose=True)
 
 
         ## Run again with "modern" postprocessing, make sure the results are *not* the same as classic
@@ -1331,8 +1331,8 @@ def run_cli_tests(options):
         cmd_results = execute_and_print(cmd)
 
         assert not output_files_are_identical(fn1=inference_output_file,
-                                            fn2=inference_output_file_modern,
-                                            verbose=True)
+                                              fn2=inference_output_file_modern,
+                                              verbose=True)
 
 
         ## Run again with "modern" postprocessing and worker-side preprocessing,
@@ -1348,13 +1348,13 @@ def run_cli_tests(options):
 
         # This should not be the same as the "classic" results
         assert not output_files_are_identical(fn1=inference_output_file,
-                                            fn2=inference_output_file_modern_worker_preprocessing,
-                                            verbose=True)
+                                              fn2=inference_output_file_modern_worker_preprocessing,
+                                              verbose=True)
 
         # ...but it should be the same as the single-threaded "modern" results
         assert output_files_are_identical(fn1=inference_output_file_modern,
-                                        fn2=inference_output_file_modern_worker_preprocessing,
-                                        verbose=True)
+                                          fn2=inference_output_file_modern_worker_preprocessing,
+                                          verbose=True)
 
 
         if not options.skip_cpu_tests: