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

megadetector/data_management/importers/snapshot_safari_importer_reprise.py

@@ -24,7 +24,7 @@ from collections import defaultdict
 
 from megadetector.utils import path_utils
 
-input_base = '/media/user/Elements'
+input_base = 'e:/'
 output_base = os.path.expanduser('~/data/snapshot-safari-metadata')
 file_list_cache_file = os.path.join(output_base,'file_list.json')
 
@@ -76,23 +76,16 @@ print('Found a total of {} files, {} of which are images'.format(
     len(all_files_relative),len(all_image_files)))
 
 
-#%% Copy all csv files to the annotation cache folder
+#%% Copy all .csv files to the annotation cache folder
 
 # fn = csv_files[0]
-for fn in csv_files:
+for fn in tqdm(csv_files):
+    
     target_file = os.path.join(annotation_cache_dir,os.path.basename(fn))
     source_file = os.path.join(input_base,fn)
     shutil.copyfile(source_file,target_file)    
 
-def read_cached_csv_file(fn):
-    """
-    Later cells will ask to read a .csv file from the original hard drive;
-    read from the annotation cache instead.
-    """
-    
-    cached_csv_file = os.path.join(annotation_cache_dir,os.path.basename(fn))
-    df = pd.read_csv(cached_csv_file)
-    return df
+print('Copied {} .csv files to cache folder'.format(len(csv_files)))
 
 
 #%% List project folders
@@ -123,6 +116,21 @@ project_folder_to_project_code = {v: k for k, v in project_code_to_project_folde
 project_codes = sorted(list(project_code_to_project_folder.keys()))
 project_folders = sorted(list(project_code_to_project_folder.values()))
 
+print('Eumerated {} project folders'.format(len(project_folders)))
+
+
+#%% Support functions
+
+def read_cached_csv_file(fn):
+    """
+    Later cells will ask to read a .csv file from the original hard drive;
+    read from the annotation cache instead.
+    """
+    
+    cached_csv_file = os.path.join(annotation_cache_dir,os.path.basename(fn))
+    df = pd.read_csv(cached_csv_file)
+    return df
+
 def file_to_project_folder(fn):
     """
     For a given filename relative to the drive root, return the corresponding
@@ -138,7 +146,6 @@ def file_to_project_folder(fn):
     assert project_folder in project_folders
     return project_folder
 
-
 def file_to_project_code(fn):
     """
     For a given filename relative to the drive root, return the corresponding
@@ -147,6 +154,9 @@ def file_to_project_code(fn):
     
     return project_folder_to_project_code[file_to_project_folder(fn)]
 
+
+#%% Consistency checking
+
 assert file_to_project_folder(
     'APN/APN_S2/DW/DW_R5/APN_S2_DW_R5_IMAG0003.JPG') == 'APN'
 assert file_to_project_folder(
@@ -163,9 +173,11 @@ assert file_to_project_code(
 #
 # E.g.:
 #
-# 'DHP': ['Snapshot South Africa/DHP/LILA_Reports/DHP_S1_report_lila.csv',
-# 'Snapshot South Africa/DHP/LILA_Reports/DHP_S2_report_lila.csv',
-# 'Snapshot South Africa/DHP/LILA_Reports/DHP_S3_report_lila.csv']
+# 'DHP': [
+#        'Snapshot South Africa/DHP/LILA_Reports/DHP_S1_report_lila.csv',
+#        'Snapshot South Africa/DHP/LILA_Reports/DHP_S2_report_lila.csv',
+#        'Snapshot South Africa/DHP/LILA_Reports/DHP_S3_report_lila.csv'
+#       ]
 #
 project_code_to_report_files = defaultdict(list)
 

megadetector/detection/process_video.py

@@ -345,7 +345,8 @@ def process_video(options):
     caller_provided_rendering_output_folder = (options.frame_rendering_folder is not None)
     
     frame_output_folder = None
-        
+    frame_filenames = None
+    
     # If we should re-use existing results, and the output file exists, don't bother running MD
     if (options.reuse_results_if_available and os.path.isfile(options.output_json_file)):
             
@@ -383,7 +384,7 @@ def process_video(options):
                                                verbose=options.verbose, 
                                                frames_to_process=options.frames_to_extract)
         
-        _add_frame_numbers_to_results(frame_results['results'])
+        frame_results['results'] = _add_frame_numbers_to_results(frame_results['results'])
         
         run_detector_batch.write_results_to_file(
             frame_results['results'], 
@@ -444,7 +445,7 @@ def process_video(options):
                 augment=options.augment,
                 image_size=options.image_size)
         
-            _add_frame_numbers_to_results(results)
+            results = _add_frame_numbers_to_results(results)
         
             run_detector_batch.write_results_to_file(
                 results, 
@@ -545,6 +546,7 @@ def process_video_folder(options):
     
     frame_output_folder = None
     image_file_names = None
+    video_filename_to_fs = {}
     
     # Run MD in memory if we don't need to generate frames
     #
@@ -575,6 +577,10 @@ def process_video_folder(options):
         
         video_results = md_results['results']
         
+        for i_video,video_filename in enumerate(md_results['video_filenames']):
+            assert video_filename not in video_filename_to_fs
+            video_filename_to_fs[video_filename] = md_results['frame_rates'][i_video]
+        
         all_frame_results = []
         
         # r = video_results[0]
@@ -586,13 +592,15 @@ def process_video_folder(options):
             all_frame_results, 
             frames_json,
             relative_path_base=None,
-            detector_file=options.model_file,
-            custom_metadata={'video_frame_rate':md_results['frame_rates']})
+            detector_file=options.model_file)
     
     else:
         
         ## Split every video into frames
         
+        if options.verbose:
+            print('Extracting frames for folder {}'.format(options.input_video_file))
+            
         if caller_provided_frame_output_folder:
             frame_output_folder = options.frame_folder
         else:
@@ -600,8 +608,6 @@ def process_video_folder(options):
             
         os.makedirs(frame_output_folder, exist_ok=True)
     
-        print('Extracting frames')
-        
         frame_filenames, Fs, video_filenames = \
             video_folder_to_frames(input_folder=options.input_video_file,
                                    output_folder_base=frame_output_folder, 
@@ -615,6 +621,10 @@ def process_video_folder(options):
                                    frames_to_extract=options.frames_to_extract,
                                    allow_empty_videos=options.allow_empty_videos)
         
+        for i_video,video_filename in enumerate(video_filenames):
+            assert video_filename not in video_filename_to_fs
+            video_filename_to_fs[video_filename] = Fs[i_video]
+                
         print('Extracted frames for {} videos'.format(len(set(video_filenames))))
         image_file_names = list(itertools.chain.from_iterable(frame_filenames))
         
@@ -660,15 +670,15 @@ def process_video_folder(options):
                 results, 
                 frames_json,
                 relative_path_base=frame_output_folder,
-                detector_file=options.model_file,
-                custom_metadata={'video_frame_rate':Fs})
+                detector_file=options.model_file)
         
     # ...if we're running MD on in-memory frames vs. extracting frames to disk
     
     ## Convert frame-level results to video-level results
 
     print('Converting frame-level results to video-level results')
-    frame_results_to_video_results(frames_json,video_json)
+    frame_results_to_video_results(frames_json,video_json,
+                                   video_filename_to_frame_rate=video_filename_to_fs)
 
 
     ## (Optionally) render output videos

megadetector/detection/run_detector_batch.py

@@ -846,7 +846,7 @@ def write_results_to_file(results,
     https://github.com/agentmorris/MegaDetector/tree/main/megadetector/api/batch_processing#batch-processing-api-output-format
 
     Args:
-        results (list):  list of dict, each dict represents detections on one image
+        results (list): list of dict, each dict represents detections on one image
         output_file (str): path to JSON output file, should end in '.json'
         relative_path_base (str, optional): path to a directory as the base for relative paths, can
             be None if the paths in [results] are absolute

megadetector/detection/video_utils.py

@@ -22,6 +22,7 @@ from functools import partial
 from inspect import signature
 
 from megadetector.utils import path_utils    
+from megadetector.utils.ct_utils import sort_list_of_dicts_by_key
 from megadetector.visualization import visualization_utils as vis_utils
 
 default_fourcc = 'h264'
@@ -197,7 +198,7 @@ def _filename_to_frame_number(filename):
 def _add_frame_numbers_to_results(results):
     """
     Given the 'images' list from a set of MD results that was generated on video frames,
-    add a 'frame_number' field to each image.
+    add a 'frame_number' field to each image, and return the list, sorted by frame number.
     
     Args:
         results (list): list of image dicts        
@@ -208,6 +209,9 @@ def _add_frame_numbers_to_results(results):
         fn = im['file']
         frame_number = _filename_to_frame_number(fn)
         im['frame_number'] = frame_number
+        
+    results = sort_list_of_dicts_by_key(results,'frame_number')
+    return results
     
 
 def run_callback_on_frames(input_video_file, 
@@ -332,8 +336,8 @@ def run_callback_on_frames_for_folder(input_video_folder,
         recursive (bool, optional): recurse into [input_video_folder]
     
     Returns:
-        dict: dict with keys 'video_filenames' (list), 'frame_rates' (list of floats), 'results' (list).
-        video_filenames will be *relative* filenames.
+        dict: dict with keys 'video_filenames' (list of str), 'frame_rates' (list of floats),
+        'results' (list of list of dicts). 'video_filenames' will contain *relative* filenames.
     """
     
     to_return = {'video_filenames':[],'frame_rates':[],'results':[]}
@@ -777,7 +781,8 @@ class FrameToVideoOptions:
         self.non_video_behavior = 'error'
     
 
-def frame_results_to_video_results(input_file,output_file,options=None):
+def frame_results_to_video_results(input_file,output_file,options=None,
+                                   video_filename_to_frame_rate=None):
     """
     Given an MD results file produced at the *frame* level, corresponding to a directory 
     created with video_folder_to_frames, maps those frame-level results back to the 
@@ -790,6 +795,8 @@ def frame_results_to_video_results(input_file,output_file,options=None):
         output_file (str): the .json file to which we should write video-level results
         options (FrameToVideoOptions, optional): parameters for converting frame-level results
             to video-level results, see FrameToVideoOptions for details            
+        video_filename_to_frame_rate (dict): maps (relative) video path names to frame rates,
+            used only to populate the output file
     """
 
     if options is None:
@@ -878,6 +885,10 @@ def frame_results_to_video_results(input_file,output_file,options=None):
         im_out['file'] = video_name
         im_out['detections'] = canonical_detections
         
+        if (video_filename_to_frame_rate is not None) and \
+            (video_name in video_filename_to_frame_rate):
+            im_out['frame_rate'] = video_filename_to_frame_rate[video_name]
+        
         # 'max_detection_conf' is no longer included in output files by default
         if False:
             im_out['max_detection_conf'] = 0

megadetector/postprocessing/postprocess_batch_results.py

@@ -770,7 +770,7 @@ def _render_image_no_gt(file_info,detection_categories_to_results_name,
             if det['conf'] > max_conf:
                 max_conf = det['conf']
 
-            if ('classifications' in det):
+            if ('classifications' in det) and (len(det['classifications']) > 0):
 
                 # This is a list of [class,confidence] pairs, sorted by confidence
                 classifications = det['classifications']
@@ -1203,13 +1203,13 @@ def process_batch_results(options):
         # Rows / first index is ground truth, columns / second index is predicted category
         classifier_cm = collections.defaultdict(lambda: collections.defaultdict(lambda: 0))
 
-        # iDetection = 0; fn = detector_files[iDetection]; print(fn)
+        # i_detection = 0; fn = detector_files[i_detection]; print(fn)
         assert len(detector_files) == len(detections_df)
-        for iDetection, fn in enumerate(detector_files):
+        for i_detection, fn in enumerate(detector_files):
 
             image_id = ground_truth_indexed_db.filename_to_id[fn]
             image = ground_truth_indexed_db.image_id_to_image[image_id]
-            detections = detections_df['detections'].iloc[iDetection]
+            detections = detections_df['detections'].iloc[i_detection]
             pred_class_ids = [det['classifications'][0][0] \
                 for det in detections if 'classifications' in det.keys()]
             pred_classnames = [classification_categories[pd] for pd in pred_class_ids]

megadetector/postprocessing/repeat_detection_elimination/repeat_detections_core.py

@@ -210,9 +210,12 @@ class RepeatDetectionOptions:
         #: a/b/c/RECONYX100 and a/b/c/RECONYX101 may really be the same camera).
         #:
         #: See ct_utils for a common replacement function that handles most common
-        #: manufacturer folder names.
+        #: manufacturer folder names:
+        #:
+        #: from megadetector.utils import ct_utils
+        #: self.customDirNameFunction = ct_utils.image_file_to_camera_folder
         self.customDirNameFunction = None
-        
+                
         #: Include only specific folders, mutually exclusive with [excludeFolders]
         self.includeFolders = None
         

megadetector/utils/ct_utils.py

@@ -16,6 +16,8 @@ import os
 import jsonpickle
 import numpy as np
 
+from operator import itemgetter
+
 # List of file extensions we'll consider images; comparisons will be case-insensitive
 # (i.e., no need to include both .jpg and .JPG on this list).
 image_extensions = ['.jpg', '.jpeg', '.gif', '.png']
@@ -294,6 +296,29 @@ def get_max_conf(im):
     return max_conf
 
 
+def sort_results_for_image(im):
+    """
+    Sort classification and detection results in descending order by confidence (in place).
+    
+    Args:
+        im (dict): image dictionary in the MD output format (with a 'detections' field)
+    """
+    if 'detections' not in im or im['detections'] is None:
+        return
+
+    # Sort detections in descending order by confidence
+    im['detections'] = sort_list_of_dicts_by_key(im['detections'],k='conf',reverse=True)
+    
+    for det in im['detections']:
+        
+        # Sort classifications (which are (class,conf) tuples) in descending order by confidence
+        if 'classifications' in det and \
+            (det['classifications'] is not None) and \
+            (len(det['classifications']) > 0):
+            L = det['classifications']
+            det['classifications'] = sorted(L,key=itemgetter(1),reverse=True)
+
+
 def point_dist(p1,p2):
     """
     Computes the distance between two points, represented as length-two tuples.
@@ -406,6 +431,21 @@ def split_list_into_n_chunks(L, n, chunk_strategy='greedy'):
         raise ValueError('Invalid chunk strategy: {}'.format(chunk_strategy))
 
 
+def sort_list_of_dicts_by_key(L,k,reverse=False):
+    """
+    Sorts the list of dictionaries [L] by the key [k].
+    
+    Args:
+        L (list): list of dictionaries to sort
+        k (object, typically str): the sort key
+        reverse (bool, optional): whether to sort in reverse (descending) order
+        
+    Returns:
+        dict: sorted copy of [d]
+    """
+    return sorted(L, key=lambda d: d[k], reverse=reverse)
+    
+    
 def sort_dictionary_by_key(d,reverse=False):
     """
     Sorts the dictionary [d] by key.
@@ -611,3 +651,11 @@ if False:
     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 dictionary sorting
+    
+    L = [{'a':5},{'a':0},{'a':10}]
+    k = 'a'
+    sort_list_of_dicts_by_key(L, k, reverse=True)
+    

megadetector/utils/md_tests.py

@@ -528,12 +528,12 @@ def compare_results(inference_output_file,expected_results_file,options):
     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)
+            'Confidence error {} is greater than allowable ({}), on file:\n{}'.format(
+                max_conf_error,options.max_conf_error,max_conf_error_file)
         
         assert max_coord_error <= options.max_coord_error, \
-            'Coord error {} is greater than allowable ({})'.format(
-                max_coord_error,options.max_coord_error)
+            'Coord error {} is greater than allowable ({}), on file:\n{}'.format(
+                max_coord_error,options.max_coord_error,max_coord_error_file)
         
     print('Max conf error: {} (file {})'.format(
         max_conf_error,max_conf_error_file))
@@ -653,7 +653,7 @@ def run_python_tests(options):
     
     ## Run inference on an image
     
-    print('\n** Running MD on a single image **\n')
+    print('\n** Running MD on a single image (module) **\n')
     
     from megadetector.detection import run_detector
     from megadetector.visualization import visualization_utils as vis_utils
@@ -665,7 +665,7 @@ def run_python_tests(options):
     
     ## Run inference on a folder
 
-    print('\n** Running MD on a folder of images **\n')
+    print('\n** Running MD on a folder of images (module) **\n')
     
     from megadetector.detection.run_detector_batch import load_and_run_detector_batch,write_results_to_file
     from megadetector.utils import path_utils
@@ -693,7 +693,7 @@ def run_python_tests(options):
     
     ## Run and verify again with augmentation enabled
     
-    print('\n** Running MD on images with augmentation **\n')
+    print('\n** Running MD on images with augmentation (module) **\n')
     
     from megadetector.utils.path_utils import insert_before_extension
     
@@ -712,6 +712,8 @@ def run_python_tests(options):
     
     ## Postprocess results
     
+    print('\n** Post-processing results (module) **\n')
+    
     from megadetector.postprocessing.postprocess_batch_results import \
         PostProcessingOptions,process_batch_results
     postprocessing_options = PostProcessingOptions()
@@ -727,6 +729,8 @@ def run_python_tests(options):
         
     ## Partial RDE test
     
+    print('\n** Testing RDE (module) **\n')
+    
     from megadetector.postprocessing.repeat_detection_elimination.repeat_detections_core import \
         RepeatDetectionOptions, find_repeat_detections
     
@@ -749,7 +753,9 @@ def run_python_tests(options):
         print('Skipping YOLO val inference tests, no YOLO folder supplied')
         
     else:
-            
+        
+        print('\n** Running YOLO val inference test (module) **\n')
+        
         from megadetector.detection.run_inference_with_yolov5_val import \
             YoloInferenceOptions, run_inference_with_yolo_val
         from megadetector.utils.path_utils import insert_before_extension
@@ -775,9 +781,7 @@ def run_python_tests(options):
             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
         
         inference_output_file_yolo_val_no_links = insert_before_extension(inference_output_file_yolo_val,
@@ -822,7 +826,7 @@ def run_python_tests(options):
         
         ## Video test (single video)
        
-        print('\n** Running MD on a single video **\n')
+        print('\n** Running MD on a single video (module) **\n')
         
         from megadetector.detection.process_video import ProcessVideoOptions, process_video
         from megadetector.utils.path_utils import insert_before_extension
@@ -861,7 +865,7 @@ def run_python_tests(options):
         
         ## Video test (folder)
         
-        print('\n** Running MD on a folder of videos **\n')
+        print('\n** Running MD on a folder of videos (module) **\n')
         
         from megadetector.detection.process_video import ProcessVideoOptions, process_video_folder
         from megadetector.utils.path_utils import insert_before_extension
@@ -920,7 +924,7 @@ def run_python_tests(options):
         
         # 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')
+        print('\n** Running MD on a folder of videos (in memory) (module) **\n')
         
         video_options.output_json_file = insert_before_extension(video_options.output_json_file,'in-memory')
         video_options.force_on_disk_frame_extraction = False
@@ -977,6 +981,8 @@ def run_cli_tests(options):
     
     ## Run inference on an image
     
+    print('\n** Running MD on a single image (CLI) **\n')
+    
     image_fn = os.path.join(options.scratch_dir,options.test_images[0])
     output_dir = os.path.join(options.scratch_dir,'single_image_test')
     if options.cli_working_dir is None:
@@ -999,6 +1005,7 @@ def run_cli_tests(options):
     
     ## Run inference on a folder
     
+    print('\n** Running MD on a folder (CLI) **\n')
     
     image_folder = os.path.join(options.scratch_dir,'md-test-images')
     assert os.path.isdir(image_folder), 'Test image folder {} is not available'.format(image_folder)
@@ -1018,6 +1025,8 @@ def run_cli_tests(options):
     
     ## Run again with checkpointing enabled, make sure the results are the same
     
+    print('\n** Running MD on a folder (with checkpoints) (CLI) **\n')
+    
     from megadetector.utils.path_utils import insert_before_extension
         
     checkpoint_string = ' --checkpoint_frequency 5'
@@ -1033,6 +1042,8 @@ def run_cli_tests(options):
     
     ## Run again with the image queue enabled, make sure the results are the same
     
+    print('\n** Running MD on a folder (with image queue) (CLI) **\n')
+    
     cmd = base_cmd + ' --use_image_queue'
     from megadetector.utils.path_utils import insert_before_extension
     inference_output_file_queue = insert_before_extension(inference_output_file,'_queue')
@@ -1060,11 +1071,16 @@ def run_cli_tests(options):
     if not gpu_available:
         inference_output_file_cpu = inference_output_file
     else:
+        
+        print('\n** Running MD on a folder (single CPU) (CLI) **\n')
+                
         inference_output_file_cpu = insert_before_extension(inference_output_file,'cpu')    
         cmd = base_cmd
         cmd = cmd.replace(inference_output_file,inference_output_file_cpu)    
         cmd_results = execute_and_print(cmd)
         
+    print('\n** Running MD on a folder (multiple CPUs) (CLI) **\n')
+    
     cpu_string = ' --ncores 4'
     cmd = base_cmd + cpu_string
     from megadetector.utils.path_utils import insert_before_extension
@@ -1085,6 +1101,8 @@ def run_cli_tests(options):
     
     ## Postprocessing
     
+    print('\n** Testing post-processing (CLI) **\n')
+    
     postprocessing_output_dir = os.path.join(options.scratch_dir,'postprocessing_output_cli')
     
     if options.cli_working_dir is None:
@@ -1099,6 +1117,8 @@ def run_cli_tests(options):
     
     ## RDE
     
+    print('\n** Running RDE (CLI) **\n')
+    
     rde_output_dir = os.path.join(options.scratch_dir,'rde_output_cli')
     
     if options.cli_working_dir is None:
@@ -1135,6 +1155,8 @@ def run_cli_tests(options):
     
     ## Run inference on a folder (tiled)
     
+    print('\n** Running tiled inference (CLI) **\n')
+    
     image_folder = os.path.join(options.scratch_dir,'md-test-images')
     tiling_folder = os.path.join(options.scratch_dir,'tiling-folder')
     inference_output_file_tiled = os.path.join(options.scratch_dir,'folder_inference_output_tiled.json')
@@ -1159,6 +1181,8 @@ def run_cli_tests(options):
         
     else:
     
+        print('\n** Running YOLOv5 val tests (CLI) **\n')
+        
         image_folder = os.path.join(options.scratch_dir,'md-test-images')
         yolo_results_folder = os.path.join(options.scratch_dir,'yolo-output-folder')
         yolo_symlink_folder = os.path.join(options.scratch_dir,'yolo-symlink_folder')
@@ -1193,6 +1217,8 @@ def run_cli_tests(options):
             
         ## Video test
         
+        print('\n** Testing video rendering (CLI) **\n')
+        
         video_inference_output_file = os.path.join(options.scratch_dir,'video_inference_output.json')
         output_video_file = os.path.join(options.scratch_dir,'video_scratch/cli_rendered_video.mp4')
         frame_folder = os.path.join(options.scratch_dir,'video_scratch/frame_folder_cli')
@@ -1219,6 +1245,8 @@ def run_cli_tests(options):
     
     ## Run inference on a folder (with MDV5B, so we can do a comparison)
     
+    print('\n** Running MDv5b (CLI) **\n')
+    
     image_folder = os.path.join(options.scratch_dir,'md-test-images')
     inference_output_file_alt = os.path.join(options.scratch_dir,'folder_inference_output_alt.json')
     if options.cli_working_dir is None:
@@ -1307,7 +1335,7 @@ if False:
     options.cpu_execution_is_error = False
     options.skip_video_tests = False
     options.skip_python_tests = False
-    options.skip_cli_tests = True
+    options.skip_cli_tests = False
     options.scratch_dir = None
     options.test_data_url = 'https://lila.science/public/md-test-package.zip'
     options.force_data_download = False

megadetector/utils/torch_test.py

@@ -0,0 +1,32 @@
+"""
+
+ torch_test.py
+
+ Simple script to verify CUDA availability, used to verify a CUDA/PyTorch
+ environment.
+
+"""
+
+def torch_test():
+    """
+    Print diagnostic information about Torch/CUDA status, including Torch/CUDA versions
+    and all available CUDA device names.
+    """
+    
+    import torch
+
+    print('Torch version: {}'.format(str(torch.__version__)))
+    print('CUDA available: {}'.format(torch.cuda.is_available()))
+
+    device_ids = list(range(torch.cuda.device_count()))
+    print('Found {} CUDA devices:'.format(len(device_ids)))
+    for device_id in device_ids:
+        device_name = 'unknown'
+        try:
+            device_name = torch.cuda.get_device_name(device=device_id)
+        except Exception as e:
+            pass
+        print('{}: {}'.format(device_id,device_name))
+       
+if __name__ == '__main__':    
+    torch_test()

megadetector/utils/url_utils.py

@@ -141,6 +141,8 @@ def download_url(url,
         
     return destination_filename
 
+# ...def download_url(...)
+
 
 def download_relative_filename(url, output_base, verbose=False):
     """
@@ -168,6 +170,8 @@ def download_relative_filename(url, output_base, verbose=False):
     destination_filename = os.path.join(output_base,relative_filename)
     return download_url(url, destination_filename, verbose=verbose)
 
+# ...def download_relative_filename(...)
+
 
 def _do_parallelized_download(download_info,overwrite=False,verbose=False):
     """
@@ -197,6 +201,8 @@ def _do_parallelized_download(download_info,overwrite=False,verbose=False):
     result['status'] = 'success'
     return result
 
+# ...def _do_parallelized_download(...)
+
 
 def parallel_download_urls(url_to_target_file,verbose=False,overwrite=False,
                            n_workers=20,pool_type='thread'):
@@ -257,8 +263,10 @@ def parallel_download_urls(url_to_target_file,verbose=False,overwrite=False,
                 
     return results
 
-    
-def test_url(url, error_on_failure=True, timeout=None):
+# ...def parallel_download_urls(...)
+
+
+def test_url(url,error_on_failure=True,timeout=None):
     """
     Tests the availability of [url], returning an http status code.
     
@@ -281,7 +289,7 @@ def test_url(url, error_on_failure=True, timeout=None):
     return r.status_code
     
 
-def test_urls(urls, error_on_failure=True, n_workers=1, pool_type='thread', timeout=None):
+def test_urls(urls,error_on_failure=True,n_workers=1,pool_type='thread',timeout=None):
     """
     Verify that URLs are available (i.e., returns status 200).  By default,
     errors if any URL is unavailable.  
@@ -327,3 +335,86 @@ def test_urls(urls, error_on_failure=True, n_workers=1, pool_type='thread', time
             urls), total=len(urls)))
                 
     return status_codes
+
+# ...def test_urls(...)
+
+
+def get_url_size(url,verbose=False,timeout=None):
+    """
+    Get the size of the file pointed to by a URL, based on the Content-Length property.  If the 
+    URL is not available, or the Content-Length property is not available, or the content-Length 
+    property is not an integer, returns None.  
+    
+    Args:
+        url (str): the url to test
+        verbose (bool, optional): enable additional debug output
+        timeout (int, optional): timeout in seconds to wait before considering this 
+            access attempt to be a failure; see requests.head() for precise documentation
+        
+    Returns:
+        int: the file size in bytes, or None if it can't be retrieved
+    """
+
+    try:
+        r = urllib.request.Request(url,method='HEAD')
+        f = urllib.request.urlopen(r, timeout=timeout)
+        if f.status != 200:
+            if verbose:
+                print('Status {} retrieving file size for {}'.format(f.status,url))
+            return None
+        size_bytes = int(f.headers['Content-Length'])
+        return size_bytes
+    except Exception as e:
+        if verbose:
+            print('Error retrieving file size for {}:\n{}'.format(url,str(e)))
+        return None
+    
+# ...def get_url_size(...)
+
+
+def get_url_sizes(urls,n_workers=1,pool_type='thread',timeout=None,verbose=False):
+    """
+    Retrieve file sizes for the URLs specified by [urls].  Returns None for any URLs
+    that we can't access, or URLs for which the Content-Length property is not set.
+    
+    Args:
+        urls (list): list of URLs for which we should retrieve sizes
+        n_workers (int, optional): number of concurrent workers, set to <=1 to disable
+            parallelization
+        pool_type (str, optional): worker type to use; should be 'thread' or 'process'
+        timeout (int, optional): timeout in seconds to wait before considering this 
+            access attempt to be a failure; see requests.head() for precise documentation
+        verbose (bool, optional): print additional debug information
+    
+    Returns:
+        dict: maps urls to file sizes, which will be None for URLs for which we were unable
+        to retrieve a valid size.        
+    """
+        
+    url_to_size = {}
+    
+    if n_workers <= 1:        
+        
+        for url in tqdm(urls):
+            url_to_size[url] = get_url_size(url,verbose=verbose,timeout=timeout)
+                
+    else:
+
+        if pool_type == 'thread':
+            pool = ThreadPool(n_workers)
+        else:
+            assert pool_type == 'process', 'Unsupported pool type {}'.format(pool_type)
+            pool = Pool(n_workers)
+        
+        print('Starting a {} pool with {} workers'.format(pool_type,n_workers))
+        
+        file_sizes = list(tqdm(pool.imap(
+            partial(get_url_size,verbose=verbose,timeout=timeout),
+            urls), total=len(urls)))
+        
+        for i_url,url in enumerate(urls):
+            url_to_size[url] = file_sizes[i_url]
+                
+    return url_to_size
+
+# ...get_url_sizes(...)

megadetector/visualization/visualization_utils.py

@@ -536,6 +536,9 @@ def render_detection_bounding_boxes(detections,
             
             x1, y1, w_box, h_box = detection['bbox']
             display_boxes.append([y1, x1, y1 + h_box, x1 + w_box])
+            
+            # The class index to use for coloring this box, which may be based on the detection
+            # category or on the most confident classification category.
             clss = detection['category']
             
             # {} is the default, which means "show labels with no mapping", so don't use "if label_map" here
@@ -558,22 +561,30 @@ def render_detection_bounding_boxes(detections,
                         assert len(displayed_label) == 1
                         displayed_label[0] += ' ' + custom_string
                                     
-            if 'classifications' in detection:
+            if ('classifications' in detection) and len(detection['classifications']) > 0:
 
-                # To avoid duplicate colors with detection-only visualization, offset
-                # the classification class index by the number of detection classes
-                clss = annotation_constants.NUM_DETECTOR_CATEGORIES + int(detection['classifications'][0][0])
                 classifications = detection['classifications']
+                
                 if len(classifications) > max_classifications:
                     classifications = classifications[0:max_classifications]
                     
+                max_classification_category = 0
+                max_classification_conf = -100
+                
                 for classification in classifications:
                     
                     classification_conf = classification[1]
-                    if classification_conf is not None and \
-                        classification_conf < classification_confidence_threshold:
+                    if classification_conf is None or \
+                       classification_conf < classification_confidence_threshold:
                         continue
+                    
                     class_key = classification[0]
+                    
+                    # Is this the most confident classification for this detection?
+                    if classification_conf > max_classification_conf:
+                        max_classification_conf = classification_conf
+                        max_classification_category = int(class_key)
+                        
                     if (classification_label_map is not None) and (class_key in classification_label_map):
                         class_name = classification_label_map[class_key]
                     else:
@@ -585,6 +596,10 @@ def render_detection_bounding_boxes(detections,
                     
                 # ...for each classification
 
+                # To avoid duplicate colors with detection-only visualization, offset
+                # the classification class index by the number of detection classes
+                clss = annotation_constants.NUM_DETECTOR_CATEGORIES + max_classification_category
+                
             # ...if we have classification results
                         
             display_strs.append(displayed_label)

{megadetector-5.0.16.dist-info → megadetector-5.0.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: megadetector
-Version: 5.0.16
+Version: 5.0.18
 Summary: MegaDetector is an AI model that helps conservation folks spend less time doing boring things with camera trap images.
 Author-email: Your friendly neighborhood MegaDetector team <cameratraps@lila.science>
 Maintainer-email: Your friendly neighborhood MegaDetector team <cameratraps@lila.science>
@@ -57,22 +57,20 @@ This package is a pip-installable version of the support/inference code for [Meg
 If you aren't looking for the Python package specifically, and you just want to learn more about what MegaDetector is all about, head over to the [MegaDetector repo](https://github.com/agentmorris/MegaDetector/?tab=readme-ov-file#megadetector).
 
 
-## Reasons you probably aren't looking for this package
+## Reasons you might not be looking for this package
 
 ### If you are an ecologist...
 
-If you are an ecologist looking to use MegaDetector to help you get through your camera trap images, you probably don't want this package.  We recommend starting with our "[Getting started with MegaDetector](https://github.com/agentmorris/MegaDetector/blob/main/getting-started.md)" page, then digging in to the [MegaDetector User Guide](https://github.com/agentmorris/MegaDetector/blob/main/megadetector.md), which will walk you through the process of using MegaDetector.  That journey will <i>not</i> involve this Python package.
+If you are an ecologist looking to use MegaDetector to help you get through your camera trap images, you probably don't want this package, or at least you probably don't want to start at this page.  We recommend starting with our "[Getting started with MegaDetector](https://github.com/agentmorris/MegaDetector/blob/main/getting-started.md)" page, then digging in to the [MegaDetector User Guide](https://github.com/agentmorris/MegaDetector/blob/main/megadetector.md), which will walk you through the process of using MegaDetector.
 
 ### If you are a computer-vision-y type...
 
-If you are a computer-vision-y person looking to run or fine-tune MegaDetector programmatically, you still probably don't want this package.  MegaDetector is just a fine-tuned version of [YOLOv5](https://github.com/ultralytics/yolov5), and the [ultralytics](https://github.com/ultralytics/ultralytics/) package (from the developers of YOLOv5) has a zillion bells and whistles for both inference and fine-tuning that this package doesn't.
+If you are a computer-vision-y person looking to run or fine-tune MegaDetector programmatically, you probably don't want this package.  MegaDetector is just a fine-tuned version of [YOLOv5](https://github.com/ultralytics/yolov5), and the [ultralytics](https://github.com/ultralytics/ultralytics/) package (from the developers of YOLOv5) has a zillion bells and whistles for both inference and fine-tuning that this package doesn't.
 
 ## Reasons you might want to use this package
 
 If you want to programmatically interact with the postprocessing tools from the MegaDetector repo, or programmatically run MegaDetector in a way that produces [Timelapse](https://saul.cpsc.ucalgary.ca/timelapse)-friendly output (i.e., output in the standard [MegaDetector output format](https://github.com/agentmorris/MegaDetector/tree/main/megadetector/api/batch_processing#megadetector-batch-output-format)), this package might be for you.
 
-Although even if that describes you, you <i>still</i> might be better off cloning the MegaDetector repo.  Pip-installability requires that some dependencies be newer than what was available at the time MDv5 was trained, so results are <i>very slightly</i> different than results produced in the "official" environment.  These differences <i>probably</i> don't matter much, but they have not been formally characterized.
-
 ## If I haven't talked you out of using this package...
 
 To install:

{megadetector-5.0.16.dist-info → megadetector-5.0.18.dist-info}/RECORD

@@ -109,7 +109,7 @@ megadetector/data_management/importers/rspb_to_json.py,sha256=y03v1d1un9mI3HZRCZ
 megadetector/data_management/importers/save_the_elephants_survey_A.py,sha256=lugw8m5Nh2Fhs-FYo9L0mDL3_29nAweLxEul6GekdkI,10669
 megadetector/data_management/importers/save_the_elephants_survey_B.py,sha256=SWClXENsIePwifP8eJeRsj3kh3Bztl6Kzc_BdqNZvFw,11172
 megadetector/data_management/importers/snapshot_safari_importer.py,sha256=dQ1GmpHcrQCQF9YZ0UaLTvc_3aOZEDqWGcxzYQeq4ho,23605
-megadetector/data_management/importers/snapshot_safari_importer_reprise.py,sha256=cv2zOWmhvXPRM-ZFrzmYFjq0Y2fwo7PUN_UJ_T2aryo,22333
+megadetector/data_management/importers/snapshot_safari_importer_reprise.py,sha256=f2WXC22fzbKaQl2888bfUlzap4oDhRG3ysZOUMBrcw0,22549
 megadetector/data_management/importers/snapshot_serengeti_lila.py,sha256=-aYq_5IxhpcR6oxFYYVv98WVnGAr0mnVkbX-oJCPd8M,33865
 megadetector/data_management/importers/sulross_get_exif.py,sha256=Bt1tGYtr5CllxCe2BL8uI3SfPu3e1SSqijnOz--iRqQ,2071
 megadetector/data_management/importers/timelapse_csv_set_to_json.py,sha256=B9VbBltf3IdPBI2O1Cmg8wODhlIML4MQpjdhTFD4GP4,15916
@@ -136,14 +136,14 @@ megadetector/data_management/lila/get_lila_image_counts.py,sha256=UxXS5RDnSA_Wbx
 megadetector/data_management/lila/lila_common.py,sha256=IEnGoyRgcqbek1qJ1gFE83p1Pg_5kaMS-nQI25lRWIs,10132
 megadetector/data_management/lila/test_lila_metadata_urls.py,sha256=jqN7UID16fu78BK_2sygb4s9BBeVCpSZT3_oL2GYxxY,4438
 megadetector/detection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-megadetector/detection/process_video.py,sha256=UAwBGTez5t1m0zmOlz9WmnQh-yfFLcpWkBbfKkDcsA4,49448
+megadetector/detection/process_video.py,sha256=yVjkm5SxHH-R5SazMQmF-XXRhrhPdE2z4X4bGkfeN-k,50019
 megadetector/detection/pytorch_detector.py,sha256=StOnaspDBkMeePiTyq5ZEcFUDBEddq36nigHXbF-zAQ,14029
 megadetector/detection/run_detector.py,sha256=vEfq3jJTseD0sIM9MaIhbeEVqP6JoLXOC2cl8Dhehxs,30553
-megadetector/detection/run_detector_batch.py,sha256=Yvtp_d5RJQ70TiSEpLyast5p1ar06gM-BeYL3EkaPZ8,57305
+megadetector/detection/run_detector_batch.py,sha256=d0fayCVXzKxa1tCiw6D8kmDqcwOAIuvrgw_Zfw0eRjE,57304
 megadetector/detection/run_inference_with_yolov5_val.py,sha256=yjNm130qntOyJ4jbetdt5xDHWnSmBXRydyxB2I56XjM,49099
 megadetector/detection/run_tiled_inference.py,sha256=vw0713eNuMiEOjHfweQl58zPHNxPOMdFWZ8bTDLhlMY,37883
 megadetector/detection/tf_detector.py,sha256=5V94a0gR6WmGPacKm59hl1eYEZI8cG04frF4EvHrmzU,8285
-megadetector/detection/video_utils.py,sha256=c5IWyVfHcXXEdDo_JRNgtrpe5bfl1QjAgFHsLwnfczE,40748
+megadetector/detection/video_utils.py,sha256=MzD8aUgdyAD9xK9w2fK0lvZtDhjpeHDkftvRXk3YJVA,41399
 megadetector/detection/detector_training/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 megadetector/detection/detector_training/model_main_tf2.py,sha256=YwNsZ7hkIFaEuwKU0rHG_VyqiR_0E01BbdlD0Yx4Smo,4936
 megadetector/postprocessing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -157,7 +157,7 @@ megadetector/postprocessing/load_api_results.py,sha256=FqcaiPMuqTojZOV3Jn14pJESp
 megadetector/postprocessing/md_to_coco.py,sha256=x3sUnOLd2lVfdG2zRN7k-oUvx6rvRD7DWmWJymPc108,12359
 megadetector/postprocessing/md_to_labelme.py,sha256=hejMKVxaz_xdtsGDPTQkeWuis7gzT-VOrL2Qf8ym1x0,11703
 megadetector/postprocessing/merge_detections.py,sha256=AEMgMivhph1vph_t_Qv85d9iHynT2nvq7otN4KGrDLU,17776
-megadetector/postprocessing/postprocess_batch_results.py,sha256=8mrq39C09Ea5mW5x1t3MptSrrKzqqck1NE2h8-hYYSc,78936
+megadetector/postprocessing/postprocess_batch_results.py,sha256=xa1FCQnzo1B6Inq8EWqS_In5xDu3qNzES_YdZ0INKr0,78978
 megadetector/postprocessing/remap_detection_categories.py,sha256=d9IYTa0i_KbbrarJc_mczABmdwypscl5-KpK8Hx_z8o,6640
 megadetector/postprocessing/render_detection_confusion_matrix.py,sha256=_wsk4W0PbNiqmFuHy-EA0Z07B1tQLMsdCTPatnHAdZw,27382
 megadetector/postprocessing/separate_detections_into_folders.py,sha256=k42gxnL8hbBiV0e2T-jmFrhxzIxnhi57Nx9cDSSL5s0,31218
@@ -165,7 +165,7 @@ megadetector/postprocessing/subset_json_detector_output.py,sha256=PDgb6cnsFm9d4E
 megadetector/postprocessing/top_folders_to_bottom.py,sha256=Dqk-KZXiRlIYlmLZmk6aUapmaaLJUKOf8wK1kxt9W6A,6283
 megadetector/postprocessing/repeat_detection_elimination/find_repeat_detections.py,sha256=e4Y9CyMyd-bLN3il8tu76vI0nVYHZlhZr6vcL0J4zQ0,9832
 megadetector/postprocessing/repeat_detection_elimination/remove_repeat_detections.py,sha256=tARPxuY0OyQgpKU2XqiQPko3f-hHnWuISB8ZlZgXwxI,2819
-megadetector/postprocessing/repeat_detection_elimination/repeat_detections_core.py,sha256=_RX0Gtb8YQPYdfQDGIvg1RvyqsdyanmEg1pqVmheHlg,67776
+megadetector/postprocessing/repeat_detection_elimination/repeat_detections_core.py,sha256=vEmWLSSv0_rxDwhjz_S9YaKZ_LM2tADTz2JYb_zUCnc,67923
 megadetector/taxonomy_mapping/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 megadetector/taxonomy_mapping/map_lila_taxonomy_to_wi_taxonomy.py,sha256=6D_YHTeWTs6O8S9ABog2t9-wfQSh9dW2k9XTqXUZKfo,17927
 megadetector/taxonomy_mapping/map_new_lila_datasets.py,sha256=FSJ6ygpADtlYLf5Bhp9kMb5km2-MH0mmM_ccyStxo34,4054
@@ -179,24 +179,25 @@ megadetector/taxonomy_mapping/taxonomy_graph.py,sha256=ayrTFseVaIMbtMXhnjWCkZdxI
 megadetector/taxonomy_mapping/validate_lila_category_mappings.py,sha256=1qyZr23bvZSVUYLQnO1XAtIZ4jdpARA5dxt8euKVyOA,2527
 megadetector/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 megadetector/utils/azure_utils.py,sha256=0BdnkG2hW-X0yFpsJqmBhOd2wysz_LvhuyImPJMVPJs,6271
-megadetector/utils/ct_utils.py,sha256=RTMc0UszYuW9QpMo-qetaWder1mFWIzkMLL2UM6PYdY,17960
+megadetector/utils/ct_utils.py,sha256=1LXAjnzeeFeQqp59cWn3Nxt5OQk3t2DfO5wQ30flA5E,19441
 megadetector/utils/directory_listing.py,sha256=r4rg2xA4O9ZVxVtzPZzXIXa0DOEukAJMTTNcNSiQcuM,9668
-megadetector/utils/md_tests.py,sha256=fIfm2pzdZL-eJkD3OEJwUJZmTM6ShBiJhugWkNGlZU4,57142
+megadetector/utils/md_tests.py,sha256=n_5PkeUComn8pbvN-sLS4XdNsNPnvz8jk6DhrCcm9PU,58225
 megadetector/utils/path_utils.py,sha256=o68jfPDaLj3NizipVCQEnmB5GfPHpMOLUmQWamYM4w0,37165
 megadetector/utils/process_utils.py,sha256=2SdFVxqob-YUW2BTjUEavNuRH3jA4V05fbKMtrVSd3c,5635
 megadetector/utils/sas_blob_utils.py,sha256=k76EcMmJc_otrEHcfV2fxAC6fNhxU88FxM3ddSYrsKU,16917
 megadetector/utils/split_locations_into_train_val.py,sha256=jvaDu1xKB51L3Xq2nXQo0XtXRjNRf8RglBApl1g6gHo,10101
 megadetector/utils/string_utils.py,sha256=ZQapJodzvTDyQhjZgMoMl3-9bqnKAUlORpws8Db9AkA,2050
-megadetector/utils/url_utils.py,sha256=-ZuFFH1AhTYSaVRjphMu7Kle5WJeDp0_ExAVevlGyvk,11653
+megadetector/utils/torch_test.py,sha256=aEYE-1vGt5PujD0bHAVRTJiLrKFlGWpS8zeYhqEYZLY,853
+megadetector/utils/url_utils.py,sha256=yybWwJ-vl2A6Fci66i-xt_dl3Uqh72Ylnb8XOT2Grog,14835
 megadetector/utils/write_html_image_list.py,sha256=apzoWkgZWG-ybCT4k92PlS4-guN_sNBSMMMbj7Cfm1k,8638
 megadetector/visualization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 megadetector/visualization/plot_utils.py,sha256=lOfU3uPrcuHZagV_1SN8erT8PujIepocgw6KZ17Ej6c,10671
 megadetector/visualization/render_images_with_thumbnails.py,sha256=kgJYW8BsqRO4C7T3sqItdBuSkZ64I1vOtIWAsVG4XBI,10589
-megadetector/visualization/visualization_utils.py,sha256=jWiXlLpmWh_CH2vApZURclOC7fdip1aKWQ66wuNabyA,62369
+megadetector/visualization/visualization_utils.py,sha256=J53VsI8aQmzzBBeu-msm8c-qC6pm_HCMkMKYvnylqjo,63083
 megadetector/visualization/visualize_db.py,sha256=x9jScwG-3V-mZGy5cB1s85KWbiAIfvgVUcLqUplHxGA,22110
 megadetector/visualization/visualize_detector_output.py,sha256=LY8QgDWpWlXVLZJUskvT29CdkNvIlEsFTk4DC_lS6pk,17052
-megadetector-5.0.16.dist-info/LICENSE,sha256=RMa3qq-7Cyk7DdtqRj_bP1oInGFgjyHn9-PZ3PcrqIs,1100
-megadetector-5.0.16.dist-info/METADATA,sha256=D61Nms1U_SFJmGp4br2HZQZ2kwopqEuDfVq4dcdGWD8,7894
-megadetector-5.0.16.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-megadetector-5.0.16.dist-info/top_level.txt,sha256=wf9DXa8EwiOSZ4G5IPjakSxBPxTDjhYYnqWRfR-zS4M,13
-megadetector-5.0.16.dist-info/RECORD,,
+megadetector-5.0.18.dist-info/LICENSE,sha256=RMa3qq-7Cyk7DdtqRj_bP1oInGFgjyHn9-PZ3PcrqIs,1100
+megadetector-5.0.18.dist-info/METADATA,sha256=utglc5y0-WOnPflCpNPA36mrZMtTN6KTLboBU3LvTaw,7464
+megadetector-5.0.18.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+megadetector-5.0.18.dist-info/top_level.txt,sha256=wf9DXa8EwiOSZ4G5IPjakSxBPxTDjhYYnqWRfR-zS4M,13
+megadetector-5.0.18.dist-info/RECORD,,

{megadetector-5.0.16.dist-info → megadetector-5.0.18.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (74.1.2)
 Root-Is-Purelib: true
 Tag: py3-none-any