megadetector 5.0.14__py3-none-any.whl → 5.0.16__py3-none-any.whl

megadetector/utils/md_tests.py

@@ -10,6 +10,8 @@ This module should not depend on anything else in this repo outside of the
 tests themselves, even if it means some duplicated code (e.g. for downloading files),
 since much of what it tries to test is, e.g., imports.
 
+"Correctness" is determined by agreement with a file that this script fetches from lila.science.
+
 """
 
 #%% Imports and constants
@@ -27,6 +29,10 @@ import subprocess
 import argparse
 import inspect
 
+#: IoU threshold used to determine whether boxes in two detection files likely correspond
+#: to the same box.
+iou_threshold_for_file_comparison = 0.9
+
 
 #%% Classes
 
@@ -108,7 +114,9 @@ class MDTestOptions:
 
 def get_expected_results_filename(gpu_is_available,
                                   model_string='mdv5a',
-                                  test_type='images'):
+                                  test_type='image',
+                                  augment=False,
+                                  options=None):
     """
     Expected results vary just a little across inference environments, particularly
     between PT 1.x and 2.x, so when making sure things are working acceptably, we 
@@ -150,7 +158,21 @@ def get_expected_results_filename(gpu_is_available,
     except Exception:
         pass
     
-    return '{}-{}-results-{}-{}.json'.format(model_string,test_type,hw_string,pt_string)
+    aug_string = ''
+    if augment:
+        aug_string = 'augment-'
+        
+    fn = '{}-{}{}-{}-{}.json'.format(model_string,aug_string,test_type,hw_string,pt_string)
+    
+    from megadetector.utils.path_utils import insert_before_extension
+    
+    if test_type == 'video':
+        fn = insert_before_extension(fn,'frames')
+    
+    if options is not None and options.scratch_dir is not None:
+        fn = os.path.join(options.scratch_dir,fn)
+        
+    return fn
     
     
 def download_test_data(options=None):
@@ -220,7 +242,12 @@ def download_test_data(options=None):
             
     # ...for each file in the zipfile
     
-    # Warn if file are present that aren't expected
+    try:
+        zipf.close()
+    except Exception as e:
+        print('Warning: error closing zipfile:\n{}'.format(str(e)))
+        
+    # Warn if files are present that aren't expected
     test_files = glob.glob(os.path.join(scratch_dir,'**/*'), recursive=True)
     test_files = [os.path.relpath(fn,scratch_dir).replace('\\','/') for fn in test_files]
     test_files_set = set(test_files)
@@ -336,6 +363,192 @@ def output_files_are_identical(fn1,fn2,verbose=False):
 # ...def output_files_are_identical(...)
    
 
+def compare_detection_lists(detections_a,detections_b,options,bidirectional_comparison=True):
+    """
+    Compare two lists of MD-formatted detections, matching detections across lists using IoU
+    criteria.  Generally used to compare detections for the same image when two sets of results 
+    are expected to be more or less the same.
+    
+    Args:
+        detections_a (list): the first set of detection dicts
+        detections_b (list): the second set of detection dicts
+        options (MDTestOptions): options that determine tolerable differences between files    
+        bidirectional_comparison (bool, optional): reverse the arguments and make a recursive
+            call.
+            
+    Returns:
+        dict: a dictionary with keys 'max_conf_error' and 'max_coord_error'.
+    """
+    from megadetector.utils.ct_utils import get_iou
+    
+    max_conf_error = 0
+    max_coord_error = 0
+        
+    # i_det_a = 0
+    for i_det_a in range(0,len(detections_a)):
+        
+        det_a = detections_a[i_det_a]
+        
+        # Don't process very-low-confidence boxes
+        if det_a['conf'] < options.max_conf_error:
+            continue
+        
+        matching_det_b = None
+        highest_iou = -1
+        
+        # Find the closest match in the detections_b list
+        
+        # i_det_b = 0
+        for i_det_b in range(0,len(detections_b)):
+            
+            b_det = detections_b[i_det_b]
+            
+            if b_det['category'] != det_a['category']:
+                continue
+            
+            iou = get_iou(det_a['bbox'],b_det['bbox'])
+            
+            # Is this likely the same detection as det_a?
+            if iou >= iou_threshold_for_file_comparison and iou > highest_iou:
+                matching_det_b = b_det
+                highest_iou = iou
+                
+        # If there are no detections in this category in detections_b
+        if matching_det_b is None:
+            if det_a['conf'] > max_conf_error:
+                max_conf_error = det_a['conf']
+            # max_coord_error = 1.0
+            continue
+        
+        assert det_a['category'] == matching_det_b['category']
+        conf_err = abs(det_a['conf'] - matching_det_b['conf'])
+        coord_differences = []
+        for i_coord in range(0,4):
+            coord_differences.append(abs(det_a['bbox'][i_coord]-\
+                                         matching_det_b['bbox'][i_coord]))
+        coord_err = max(coord_differences)
+        
+        if conf_err >= max_conf_error:
+            max_conf_error = conf_err
+            
+        if coord_err >= max_coord_error:
+            max_coord_error = coord_err            
+    
+    # ...for each detection in detections_a
+    
+    if bidirectional_comparison:
+        
+        reverse_comparison_results = compare_detection_lists(detections_b,
+                                                             detections_a, 
+                                                             options, 
+                                                             bidirectional_comparison=False)
+        
+        if reverse_comparison_results['max_conf_error'] > max_conf_error:
+            max_conf_error = reverse_comparison_results['max_conf_error']
+        if reverse_comparison_results['max_coord_error'] > max_coord_error:
+            max_coord_error = reverse_comparison_results['max_coord_error']
+    
+    list_comparison_results = {}
+    list_comparison_results['max_coord_error'] = max_coord_error
+    list_comparison_results['max_conf_error'] = max_conf_error
+    
+    return list_comparison_results
+
+# ...def compare_detection_lists(...)
+
+
+def compare_results(inference_output_file,expected_results_file,options):
+    """
+    Compare two MD-formatted output files that should be nearly identical, allowing small
+    changes (e.g. rounding differences).  Generally used to compare a new results file to 
+    an expected results file.
+    
+    Args:
+        inference_output_file (str): the first results file to compare
+        expected_results_file (str): the second results file to compare
+        options (MDTestOptions): options that determine tolerable differences between files
+        
+    Returns:
+        dict: dictionary with keys 'max_coord_error' and 'max_conf_error'
+    """
+    
+    # Read results
+    with open(inference_output_file,'r') as f:
+        results_from_file = json.load(f) # noqa
+    
+    with open(os.path.join(options.scratch_dir,expected_results_file),'r') as f:
+        expected_results = json.load(f)
+            
+    filename_to_results = {im['file'].replace('\\','/'):im for im in results_from_file['images']}
+    filename_to_results_expected = {im['file'].replace('\\','/'):im for im in expected_results['images']}
+    
+    assert len(filename_to_results) == len(filename_to_results_expected), \
+        'Error: expected {} files in results, found {}'.format(
+            len(filename_to_results_expected),
+            len(filename_to_results))
+    
+    max_conf_error = 0
+    max_conf_error_file = None
+    
+    max_coord_error = 0
+    max_coord_error_file = None    
+    
+    # fn = next(iter(filename_to_results.keys()))
+    for fn in filename_to_results.keys():
+                
+        actual_image_results = filename_to_results[fn]
+        expected_image_results = filename_to_results_expected[fn]
+        
+        if 'failure' in actual_image_results:
+            assert 'failure' in expected_image_results and \
+                'detections' not in actual_image_results and \
+                'detections' not in expected_image_results
+            continue
+        assert 'failure' not in expected_image_results
+        
+        actual_detections = actual_image_results['detections']
+        expected_detections = expected_image_results['detections']
+        
+        comparison_results_this_image = compare_detection_lists(
+            detections_a=actual_detections,
+            detections_b=expected_detections,
+            options=options,
+            bidirectional_comparison=True)
+        
+        if comparison_results_this_image['max_conf_error'] > max_conf_error:
+            max_conf_error = comparison_results_this_image['max_conf_error']
+            max_conf_error_file = fn
+            
+        if comparison_results_this_image['max_coord_error'] > max_coord_error:
+            max_coord_error = comparison_results_this_image['max_coord_error']
+            max_coord_error_file = fn
+                
+    # ...for each image
+    
+    if not options.warning_mode:
+        
+        assert max_conf_error <= options.max_conf_error, \
+            'Confidence error {} is greater than allowable ({})'.format(
+                max_conf_error,options.max_conf_error)
+        
+        assert max_coord_error <= options.max_coord_error, \
+            'Coord error {} is greater than allowable ({})'.format(
+                max_coord_error,options.max_coord_error)
+        
+    print('Max conf error: {} (file {})'.format(
+        max_conf_error,max_conf_error_file))
+    print('Max coord error: {} (file {})'.format(
+        max_coord_error,max_coord_error_file))
+    
+    comparison_results = {}
+    comparison_results['max_conf_error'] = max_conf_error
+    comparison_results['max_coord_error'] = max_coord_error
+
+    return comparison_results
+
+# ...def compare_results(...)
+
+
 def _args_to_object(args, obj):
     """
     Copies all fields from a Namespace (typically the output from parse_args) to an
@@ -440,6 +653,8 @@ def run_python_tests(options):
     
     ## Run inference on an image
     
+    print('\n** Running MD on a single image **\n')
+    
     from megadetector.detection import run_detector
     from megadetector.visualization import visualization_utils as vis_utils
     image_fn = os.path.join(options.scratch_dir,options.test_images[0])
@@ -449,6 +664,8 @@ def run_python_tests(options):
 
     
     ## Run inference on a folder
+
+    print('\n** Running MD on a folder of images **\n')
     
     from megadetector.detection.run_detector_batch import load_and_run_detector_batch,write_results_to_file
     from megadetector.utils import path_utils
@@ -458,95 +675,41 @@ def run_python_tests(options):
     inference_output_file = os.path.join(options.scratch_dir,'folder_inference_output.json')
     image_file_names = path_utils.find_images(image_folder,recursive=True)
     results = load_and_run_detector_batch(options.default_model, image_file_names, quiet=True)
-    _ = write_results_to_file(results,inference_output_file,
-                              relative_path_base=image_folder,detector_file=options.default_model)
+    _ = write_results_to_file(results,
+                              inference_output_file,
+                              relative_path_base=image_folder,
+                              detector_file=options.default_model)
 
-    # Read results
-    with open(inference_output_file,'r') as f:
-        results_from_file = json.load(f) # noqa
     
-
     ## Verify results
-
-    # Read expected results
-    expected_results_filename = get_expected_results_filename(is_gpu_available(verbose=False))
     
-    with open(os.path.join(options.scratch_dir,expected_results_filename),'r') as f:
-        expected_results = json.load(f)
-            
-    filename_to_results = {im['file'].replace('\\','/'):im for im in results_from_file['images']}
-    filename_to_results_expected = {im['file'].replace('\\','/'):im for im in expected_results['images']}
+    expected_results_file = get_expected_results_filename(is_gpu_available(verbose=False),
+                                                          options=options)
+    compare_results(inference_output_file,expected_results_file,options)
+        
+    # Make note of this filename, we will use it again later
+    inference_output_file_standard_inference = inference_output_file
     
-    assert len(filename_to_results) == len(filename_to_results_expected), \
-        'Error: expected {} files in results, found {}'.format(
-            len(filename_to_results_expected),
-            len(filename_to_results))
     
-    max_coord_error = 0
-    max_conf_error = 0
+    ## Run and verify again with augmentation enabled
     
-    # fn = next(iter(filename_to_results.keys()))
-    for fn in filename_to_results.keys():
-                
-        actual_image_results = filename_to_results[fn]
-        expected_image_results = filename_to_results_expected[fn]
-        
-        if 'failure' in actual_image_results:
-            assert 'failure' in expected_image_results and \
-                'detections' not in actual_image_results and \
-                'detections' not in expected_image_results
-            continue
-        assert 'failure' not in expected_image_results
-        
-        actual_detections = actual_image_results['detections']
-        expected_detections = expected_image_results['detections']
-        
-        s = 'expected {} detections for file {}, found {}'.format(
-            len(expected_detections),fn,len(actual_detections))
-        s += '\nExpected results file: {}\nActual results file: {}'.format(
-            expected_results_filename,inference_output_file)
-        
-        if options.warning_mode:
-            if len(actual_detections) != len(expected_detections):
-                print('Warning: {}'.format(s))
-            continue
-        assert len(actual_detections) == len(expected_detections), \
-            'Error: {}'.format(s)
-        
-        # i_det = 0
-        for i_det in range(0,len(actual_detections)):
-            actual_det = actual_detections[i_det]
-            expected_det = expected_detections[i_det]
-            assert actual_det['category'] == expected_det['category']
-            conf_err = abs(actual_det['conf'] - expected_det['conf'])
-            coord_differences = []
-            for i_coord in range(0,4):
-                coord_differences.append(abs(actual_det['bbox'][i_coord]-expected_det['bbox'][i_coord]))
-            coord_err = max(coord_differences)
-            
-            if conf_err > max_conf_error:
-                max_conf_error = conf_err
-            if coord_err > max_coord_error:
-                max_coord_error = coord_err
-        
-        # ...for each detection
-        
-    # ...for each image
+    print('\n** Running MD on images with augmentation **\n')
     
-    if not options.warning_mode:
-        
-        assert max_conf_error <= options.max_conf_error, \
-            'Confidence error {} is greater than allowable ({})'.format(
-                max_conf_error,options.max_conf_error)
-        
-        assert max_coord_error <= options.max_coord_error, \
-            'Coord error {} is greater than allowable ({})'.format(
-                max_coord_error,options.max_coord_error)
-        
-    print('Max conf error: {}'.format(max_conf_error))
-    print('Max coord error: {}'.format(max_coord_error))
-
+    from megadetector.utils.path_utils import insert_before_extension
+    
+    inference_output_file_augmented = insert_before_extension(inference_output_file,'augmented')
+    results = load_and_run_detector_batch(options.default_model, image_file_names, quiet=True, augment=True)
+    _ = write_results_to_file(results,
+                              inference_output_file_augmented,
+                              relative_path_base=image_folder,
+                              detector_file=options.default_model)
 
+    expected_results_file_augmented = \
+        get_expected_results_filename(is_gpu_available(verbose=False),
+                                      augment=True,options=options)
+    compare_results(inference_output_file_augmented,expected_results_file_augmented,options)
+        
+    
     ## Postprocess results
     
     from megadetector.postprocessing.postprocess_batch_results import \
@@ -589,6 +752,7 @@ def run_python_tests(options):
             
         from megadetector.detection.run_inference_with_yolov5_val import \
             YoloInferenceOptions, run_inference_with_yolo_val
+        from megadetector.utils.path_utils import insert_before_extension
         
         inference_output_file_yolo_val = os.path.join(options.scratch_dir,'folder_inference_output_yolo_val.json')
         
@@ -599,12 +763,23 @@ def run_python_tests(options):
         yolo_inference_options.model_filename = options.default_model
         yolo_inference_options.augment = False
         yolo_inference_options.overwrite_handling = 'overwrite'
+        from megadetector.detection.run_detector import DEFAULT_OUTPUT_CONFIDENCE_THRESHOLD
+        yolo_inference_options.conf_thres = DEFAULT_OUTPUT_CONFIDENCE_THRESHOLD
         
         run_inference_with_yolo_val(yolo_inference_options)
         
+        ## Confirm this matches the standard inference path
+        
+        if False:
+            # TODO: compare_results() isn't quite ready for this yet
+            compare_results(inference_output_file=inference_output_file_yolo_val, 
+                            expected_results_file=inference_output_file_standard_inference, 
+                            options=options)
+        
+        
+        
         # Run again, without symlinks this time
         
-        from megadetector.utils.path_utils import insert_before_extension
         inference_output_file_yolo_val_no_links = insert_before_extension(inference_output_file_yolo_val,
                                                                           'no-links')
         yolo_inference_options.output_file = inference_output_file_yolo_val_no_links
@@ -647,7 +822,10 @@ def run_python_tests(options):
         
         ## Video test (single video)
        
+        print('\n** Running MD on a single video **\n')
+        
         from megadetector.detection.process_video import ProcessVideoOptions, process_video
+        from megadetector.utils.path_utils import insert_before_extension
         
         video_options = ProcessVideoOptions()
         video_options.model_file = options.default_model
@@ -668,7 +846,7 @@ def run_python_tests(options):
         video_options.fourcc = options.video_fourcc
         # video_options.rendering_confidence_threshold = None
         # video_options.json_confidence_threshold = 0.005
-        video_options.frame_sample = 5    
+        video_options.frame_sample = 10
         video_options.n_cores = 5
         # video_options.debug_max_frames = -1
         # video_options.class_mapping_filename = None
@@ -683,38 +861,83 @@ def run_python_tests(options):
         
         ## Video test (folder)
         
+        print('\n** Running MD on a folder of videos **\n')
+        
         from megadetector.detection.process_video import ProcessVideoOptions, process_video_folder
+        from megadetector.utils.path_utils import insert_before_extension
         
         video_options = ProcessVideoOptions()
         video_options.model_file = options.default_model
         video_options.input_video_file = os.path.join(options.scratch_dir,
                                                       os.path.dirname(options.test_videos[0]))
         video_options.output_json_file = os.path.join(options.scratch_dir,'video_folder_output.json')
-        # video_options.output_video_file = None
+        video_options.output_video_file = None
         video_options.frame_folder = os.path.join(options.scratch_dir,'video_scratch/frame_folder')
         video_options.frame_rendering_folder = os.path.join(options.scratch_dir,'video_scratch/rendered_frame_folder')    
         video_options.render_output_video = False
-        # video_options.keep_rendered_frames = False
-        # video_options.keep_rendered_frames = False
+        video_options.keep_rendered_frames = False
+        video_options.keep_rendered_frames = False
         video_options.force_extracted_frame_folder_deletion = True
         video_options.force_rendered_frame_folder_deletion = True
-        # video_options.reuse_results_if_available = False
-        # video_options.reuse_frames_if_available = False
+        video_options.reuse_results_if_available = False
+        video_options.reuse_frames_if_available = False
         video_options.recursive = True
         video_options.verbose = True
         video_options.fourcc = options.video_fourcc
         # video_options.rendering_confidence_threshold = None
         # video_options.json_confidence_threshold = 0.005
-        video_options.frame_sample = 5    
-        video_options.n_cores = 5
+        video_options.frame_sample = 10  
+        video_options.n_cores = 5        
+        
+        # Force frame extraction to disk, since that's how we generated our expected results file
+        video_options.force_on_disk_frame_extraction = True
         # video_options.debug_max_frames = -1
         # video_options.class_mapping_filename = None
         
+        # Use quality == None, because we can't control whether YOLOv5 has patched cm2.imread,
+        # and therefore can't rely on using the quality parameter
+        video_options.quality = None
+        video_options.max_width = None
+        
         _ = process_video_folder(video_options)
     
         assert os.path.isfile(video_options.output_json_file), \
             'Python video test failed to render output .json file'
+            
+        frame_output_file = insert_before_extension(video_options.output_json_file,'frames')
+        assert os.path.isfile(frame_output_file)
+        
+        
+        ## Verify results
+        
+        expected_results_file = \
+            get_expected_results_filename(is_gpu_available(verbose=False),test_type='video',options=options)
+        assert os.path.isfile(expected_results_file)
+        compare_results(frame_output_file,expected_results_file,options)
+        
+        
+        ## Run again, this time in memory, and make sure the results are *almost* the same
+        
+        # They won't be quite the same, because the on-disk path goes through a jpeg intermediate
+        
+        print('\n** Running MD on a folder of videos (in memory) **\n')
         
+        video_options.output_json_file = insert_before_extension(video_options.output_json_file,'in-memory')
+        video_options.force_on_disk_frame_extraction = False
+        _ = process_video_folder(video_options)
+                
+        frame_output_file_in_memory = insert_before_extension(video_options.output_json_file,'frames')
+        assert os.path.isfile(frame_output_file_in_memory)
+        
+        from copy import deepcopy
+        options_loose = deepcopy(options)
+        options_loose.max_conf_error = 0.05
+        options_loose.max_coord_error = 0.01
+        
+        compare_results(inference_output_file=frame_output_file,
+                        expected_results_file=frame_output_file_in_memory,
+                        options=options_loose)
+                
     # ...if we're not skipping video tests
     
     print('\n*** Finished module tests ***\n')
@@ -804,7 +1027,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 the image queue enabled, make sure the results are the same
@@ -816,7 +1040,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 on multiple cores, make sure the results are the same
@@ -854,7 +1079,8 @@ def run_cli_tests(options):
         del os.environ['CUDA_VISIBLE_DEVICES']
         
     assert output_files_are_identical(fn1=inference_output_file_cpu, 
-                                      fn2=inference_output_file_cpu_multicore,verbose=True)
+                                      fn2=inference_output_file_cpu_multicore,
+                                      verbose=True)
     
     
     ## Postprocessing
@@ -925,7 +1151,7 @@ def run_cli_tests(options):
         results_from_file = json.load(f) # noqa
         
     
-    ## Run inference on a folder (augmented)
+    ## Run inference on a folder (augmented, w/YOLOv5 val script)
     
     if options.yolo_working_dir is None:
         
@@ -960,7 +1186,8 @@ def run_cli_tests(options):
         cmd_results = execute_and_print(cmd)
         
         assert output_files_are_identical(fn1=inference_output_file_yolo_val,
-                                          fn2=inference_output_file_yolo_val_checkpoint)
+                                          fn2=inference_output_file_yolo_val_checkpoint,
+                                          verbose=True)
         
     if not options.skip_video_tests:
             
@@ -1080,19 +1307,21 @@ if False:
     options.cpu_execution_is_error = False
     options.skip_video_tests = False
     options.skip_python_tests = False
-    options.skip_cli_tests = False
+    options.skip_cli_tests = True
     options.scratch_dir = None
     options.test_data_url = 'https://lila.science/public/md-test-package.zip'
     options.force_data_download = False
     options.force_data_unzip = False
-    options.warning_mode = True
+    options.warning_mode = False
     options.max_coord_error = 0.001
     options.max_conf_error = 0.005
     options.cli_working_dir = r'c:\git\MegaDetector'
     options.yolo_working_dir = r'c:\git\yolov5-md'
 
-    import os
     
+    #%%
+    
+    import os
     if 'PYTHONPATH' not in os.environ or options.yolo_working_dir not in os.environ['PYTHONPATH']:
         os.environ['PYTHONPATH'] += ';' + options.yolo_working_dir
 
@@ -1218,3 +1447,36 @@ python md_tests.py --cli_working_dir "/mnt/c/git/MegaDetector" --yolo_working_di
 
 python -c "import md_tests; print(md_tests.get_expected_results_filename(True))"
 """
+
+
+#%% Scrap
+
+if False:
+
+    pass
+
+    #%%
+    
+    import sys; sys.path.append(r'c:\git\yolov5-md')
+    
+    #%%
+    
+    fn1 = r"G:\temp\md-test-package\mdv5a-video-cpu-pt1.10.1.frames.json"
+    fn2 = r"G:\temp\md-test-package\mdv5a-video-gpu-pt1.10.1.frames.json"
+    fn3 = r"G:\temp\md-test-package\mdv5a-video-cpu-pt2.x.frames.json"
+    fn4 = r"G:\temp\md-test-package\mdv5a-video-gpu-pt2.x.frames.json"
+    
+    assert all([os.path.isfile(fn) for fn in [fn1,fn2,fn3,fn4]])
+    print(output_files_are_identical(fn1,fn1,verbose=False))
+    print(output_files_are_identical(fn1,fn2,verbose=False))
+    print(output_files_are_identical(fn1,fn3,verbose=False))
+    
+    #%%
+    
+    fn1 = r"G:\temp\md-test-package\mdv5a-image-gpu-pt1.10.1.json"
+    fn2 = r"G:\temp\md-test-package\mdv5a-augment-image-gpu-pt1.10.1.json"
+    print(output_files_are_identical(fn1,fn2,verbose=True))
+    
+    fn1 = r"G:\temp\md-test-package\mdv5a-image-cpu-pt1.10.1.json"
+    fn2 = r"G:\temp\md-test-package\mdv5a-augment-image-cpu-pt1.10.1.json"
+    print(output_files_are_identical(fn1,fn2,verbose=True))

megadetector/utils/path_utils.py

@@ -924,8 +924,8 @@ def zip_files_into_single_zipfile(input_files, output_fn, arc_name_base,
     
 def zip_folder(input_folder, output_fn=None, overwrite=False, verbose=False, compresslevel=9):
     """
-    Recursively zip everything in [input_folder] into a single zipfile, storing outputs as relative 
-    paths.
+    Recursively zip everything in [input_folder] into a single zipfile, storing files as paths 
+    relative to [input_folder].
     
     Args: 
         input_folder (str): folder to zip