megadetector 10.0.7__py3-none-any.whl → 10.0.8__py3-none-any.whl

megadetector/data_management/cct_json_utils.py

@@ -305,6 +305,9 @@ class SequenceOptions:
         #: How to handle invalid datetimes: 'error' or 'none'
         self.datetime_conversion_failure_behavior = 'none'
 
+        #: Enable additional debug output
+        self.verbose = False
+
 
 #%% Functions
 
@@ -331,7 +334,9 @@ def write_object_with_serialized_datetimes(d,json_fn):
         json.dump(d,f,indent=1,default=json_serialize_datetime)
 
 
-def parse_datetimes_from_cct_image_list(images,conversion_failure_behavior='error'):
+def parse_datetimes_from_cct_image_list(images,
+                                        conversion_failure_behavior='error',
+                                        verbose=False):
     """
     Given the "images" field from a COCO camera traps dictionary, converts all
     string-formatted datetime fields to Python datetimes, making reasonable assumptions
@@ -342,6 +347,7 @@ def parse_datetimes_from_cct_image_list(images,conversion_failure_behavior='erro
         conversion_failure_behavior (str, optional): determines what happens on a failed
             conversion; can be "error" (raise an error), "str" (leave as a string), or
             "none" (convert to None)
+        verbose (bool, optional): enable additional debug output
 
     Returns:
         images: the input list, with datetimes converted (after modifying in place)
@@ -359,14 +365,17 @@ def parse_datetimes_from_cct_image_list(images,conversion_failure_behavior='erro
             dt = dateutil.parser.parse(im['datetime'])
             im['datetime'] = dt
         except Exception as e:
-            s = 'could not parse datetime {}: {}'.format(str(im['datetime']),str(e))
+            s = 'could not parse datetime {} from {}: {}'.format(
+                str(im['datetime']),im['file_name'],str(e))
             if conversion_failure_behavior == 'error':
                 raise ValueError(s)
             elif conversion_failure_behavior == 'str':
-                print('Warning: {}'.format(s))
+                if verbose:
+                    print('Warning: {}'.format(s))
                 pass
             elif conversion_failure_behavior == 'none':
-                print('Warning: {}'.format(s))
+                if verbose:
+                    print('Warning: {}'.format(s))
                 im['datetime'] = None
 
     # ...for each image
@@ -450,7 +459,8 @@ def create_sequences(image_info,options=None):
 
     # Modifies the images in place
     _ = parse_datetimes_from_cct_image_list(image_info,
-            conversion_failure_behavior=options.datetime_conversion_failure_behavior)
+            conversion_failure_behavior=options.datetime_conversion_failure_behavior,
+            verbose=options.verbose)
 
     n_invalid_datetimes = 0
     for im in image_info:
@@ -505,7 +515,7 @@ def create_sequences(image_info,options=None):
                 delta = (im['datetime'] - previous_datetime).total_seconds()
 
             # Start a new sequence if necessary, including the case where this datetime is invalid
-            if delta is None or delta > options.episode_interval_seconds or invalid_datetime:
+            if (delta is None) or (delta > options.episode_interval_seconds) or (invalid_datetime):
                 next_frame_number = 0
                 current_sequence_id = 'location_{}_sequence_index_{}'.format(
                     location,str(next_sequence_number).zfill(5))

megadetector/data_management/databases/subset_json_db.py

@@ -18,13 +18,20 @@ import json
 import argparse
 
 from tqdm import tqdm
-from megadetector.utils import ct_utils
 from copy import copy
 
+from megadetector.utils import ct_utils
+from megadetector.utils.ct_utils import sort_list_of_dicts_by_key
+
 
 #%% Functions
 
-def subset_json_db(input_json, query, output_json=None, ignore_case=False, verbose=False):
+def subset_json_db(input_json,
+                   query,
+                   output_json=None,
+                   ignore_case=False,
+                   remap_categories=True,
+                   verbose=False):
     """
     Given a json file (or dictionary already loaded from a json file), produce a new
     database containing only the images whose filenames contain the string 'query',
@@ -36,6 +43,8 @@ def subset_json_db(input_json, query, output_json=None, ignore_case=False, verbo
             contain this string.  If this is a list, test for exact matches.
         output_json (str, optional): file to write the resulting .json file to
         ignore_case (bool, optional): whether to perform a case-insensitive search for [query]
+        remap_categories (bool, optional): trim the category list to only the categores used
+            in the subset
         verbose (bool, optional): enable additional debug output
 
     Returns:
@@ -92,6 +101,52 @@ def subset_json_db(input_json, query, output_json=None, ignore_case=False, verbo
     output_data['images'] = images
     output_data['annotations'] = annotations
 
+    # Remap categories if necessary
+    if remap_categories:
+
+        category_ids_used = set()
+        for ann in annotations:
+            category_ids_used.add(ann['category_id'])
+
+        if verbose:
+            print('Keeping {} of {} categories'.format(
+                len(category_ids_used),len(input_data['categories'])))
+
+        input_category_id_to_output_category_id = {}
+
+        next_category_id = 0
+
+        # Build mappings from old to new category IDs
+        for input_category_id in category_ids_used:
+            assert isinstance(input_category_id,int), \
+                'Illegal category ID {}'.format(input_category_id)
+            output_category_id = next_category_id
+            next_category_id = next_category_id + 1
+            input_category_id_to_output_category_id[input_category_id] = output_category_id
+
+        # Modify the annotations
+        for ann in annotations:
+            assert ann['category_id'] in input_category_id_to_output_category_id
+            ann['category_id'] = input_category_id_to_output_category_id[ann['category_id']]
+
+        output_categories = []
+
+        # Re-write the category table
+        for cat in input_data['categories']:
+
+            if cat['id'] in input_category_id_to_output_category_id:
+
+                # There may be non-required fields, so don't just create an empty dict
+                # and copy the name/id field, keep the original dict other than "id"
+                output_category = copy(cat)
+                output_category['id'] = input_category_id_to_output_category_id[cat['id']]
+                output_categories.append(output_category)
+
+        output_categories = sort_list_of_dicts_by_key(output_categories,'id')
+        output_data['categories'] = output_categories
+
+    # ...if we need to remap categories
+
     # Write the output file if requested
     if output_json is not None:
         if verbose:

megadetector/detection/pytorch_detector.py

@@ -328,7 +328,8 @@ def _initialize_yolo_imports(model_type='yolov5',
     if try_yolov5_import and not utils_imported:
 
         try:
-            from yolov5.utils.general import non_max_suppression, xyxy2xywh # noqa
+            # from yolov5.utils.general import non_max_suppression # type: ignore
+            from yolov5.utils.general import xyxy2xywh # noqa
             from yolov5.utils.augmentations import letterbox # noqa
             try:
                 from yolov5.utils.general import scale_boxes as scale_coords
@@ -348,7 +349,8 @@ def _initialize_yolo_imports(model_type='yolov5',
 
         try:
 
-            from yolov9.utils.general import non_max_suppression, xyxy2xywh # noqa
+            # from yolov9.utils.general import non_max_suppression # noqa
+            from yolov9.utils.general import xyxy2xywh # noqa
             from yolov9.utils.augmentations import letterbox # noqa
             from yolov9.utils.general import scale_boxes as scale_coords # noqa
             utils_imported = True
@@ -378,7 +380,12 @@ def _initialize_yolo_imports(model_type='yolov5',
 
         try:
 
-            from ultralytics.utils.ops import non_max_suppression # type: ignore # noqa
+            # The non_max_suppression() function moved from the ops module to the nms module
+            # in mid-2025
+            try:
+                from ultralytics.utils.ops import non_max_suppression # type: ignore # noqa
+            except Exception:
+                from ultralytics.utils.nms import non_max_suppression # type: ignore # noqa
             from ultralytics.utils.ops import xyxy2xywh # type: ignore # noqa
 
             # In the ultralytics package, scale_boxes and scale_coords both exist;
@@ -444,9 +451,9 @@ def _initialize_yolo_imports(model_type='yolov5',
             if verbose:
                 print('Imported utils from ultralytics package')
 
-        except Exception:
+        except Exception as e:
 
-            # print('Ultralytics module import failed')
+            print('Ultralytics module import failed: {}'.format(str(e)))
             pass
 
     # If we haven't succeeded yet, assume the YOLOv5 repo is on our PYTHONPATH.
@@ -455,7 +462,8 @@ def _initialize_yolo_imports(model_type='yolov5',
         try:
 
             # import pre- and post-processing functions from the YOLOv5 repo
-            from utils.general import non_max_suppression, xyxy2xywh # type: ignore
+            # from utils.general import non_max_suppression # type: ignore
+            from utils.general import xyxy2xywh # type: ignore
             from utils.augmentations import letterbox # type: ignore
 
             # scale_coords() is scale_boxes() in some YOLOv5 versions
@@ -1283,17 +1291,23 @@ class PTDetector:
         else:
             nms_iou_thres = 0.6
 
-        pred = nms(prediction=pred,
-                   conf_thres=detection_threshold,
-                   iou_thres=nms_iou_thres)
+        use_library_nms = False
+
+        # Model output format changed in recent ultralytics packages, and the nms implementation
+        # in this module hasn't been updated to handle that format yet.
+        if (yolo_model_type_imported is not None) and (yolo_model_type_imported == 'ultralytics'):
+            use_library_nms = True
 
-        # For posterity, the ultralytics implementation
-        if False:
+        if use_library_nms:
             pred = non_max_suppression(prediction=pred,
-                                       conf_thres=detection_threshold,
-                                       iou_thres=nms_iou_thres,
-                                       agnostic=False,
-                                       multi_label=False)
+                                    conf_thres=detection_threshold,
+                                    iou_thres=nms_iou_thres,
+                                    agnostic=False,
+                                    multi_label=False)
+        else:
+            pred = nms(prediction=pred,
+                    conf_thres=detection_threshold,
+                    iou_thres=nms_iou_thres)
 
         assert isinstance(pred, list)
         assert len(pred) == len(batch_metadata), \

megadetector/detection/run_inference_with_yolov5_val.py

@@ -159,7 +159,9 @@ class YoloInferenceOptions:
         #: These are deliberately offset from the standard MD categories; YOLOv5
         #: needs categories IDs to start at 0.
         #:
-        #: This can also be a string that points to a YOLO dataset.yaml file.
+        #: This can also be a string that points to any class mapping file supported
+        #: by read_classes_from_yolo_dataset_file(): a YOLO dataset.yaml file, a text
+        #: file with a list of classes, or a .json file with an ID --> name dict
         self.yolo_category_id_to_name = {0:'animal',1:'person',2:'vehicle'}
 
         #: What should we do if the output file already exists?

megadetector/detection/run_tiled_inference.py

@@ -907,7 +907,10 @@ if False:
 
 #%% Command-line driver
 
-def main(): # noqa
+def main():
+    """
+    Command-line driver for run_tiled_inference
+    """
 
     parser = argparse.ArgumentParser(
         description='Chop a folder of images up into tiles, run MD on the tiles, and stitch the results together')
@@ -956,7 +959,7 @@ def main(): # noqa
         '--detector_options',
         type=str,
         default=None,
-        help=('A list of detector options (key-value pairs) to '))
+        help=('A list of detector options (key-value pairs)'))
 
     # detector_options = parse_kvp_list(args.detector_options)
 

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.path_utils import clean_path
 from megadetector.utils.ct_utils import sort_list_of_dicts_by_key
 from megadetector.visualization import visualization_utils as vis_utils
 
@@ -592,7 +593,7 @@ def video_to_frames(input_video_file,
                     quality=None,
                     max_width=None,
                     frames_to_extract=None,
-                    allow_empty_videos=False):
+                    allow_empty_videos=True):
     """
     Renders frames from [input_video_file] to .jpg files in [output_folder].
 
@@ -618,8 +619,8 @@ def video_to_frames(input_video_file,
             a single frame number.  In the special case where frames_to_extract
             is [], this function still reads video frame rates and verifies that videos
             are readable, but no frames are extracted.
-        allow_empty_videos (bool, optional): Just print a warning if a video appears to have no
-            frames (by default, this is an error).
+        allow_empty_videos (bool, optional): Just print a warning if a video appears to have
+            no frames (by default, this is an error).
 
     Returns:
         tuple: length-2 tuple containing (list of frame filenames,frame rate)
@@ -883,7 +884,14 @@ def _video_to_frames_for_folder(relative_fn,input_folder,output_folder_base,
 
     # Create the target output folder
     output_folder_video = os.path.join(output_folder_base,relative_fn)
-    os.makedirs(output_folder_video,exist_ok=True)
+    try:
+        os.makedirs(output_folder_video,exist_ok=True)
+    except Exception:
+        output_folder_clean = clean_path(output_folder_video)
+        print('Warning: failed to create folder {}, trying {}'.format(
+            output_folder_video,output_folder_clean))
+        output_folder_video = output_folder_clean
+        os.makedirs(output_folder_video,exist_ok=True)
 
     # Render frames
     # input_video_file = input_fn_absolute; output_folder = output_folder_video
@@ -1090,6 +1098,9 @@ class FrameToVideoOptions:
         #: Are frame rates required?
         self.frame_rates_are_required = False
 
+        #: Enable additional debug output
+        self.verbose = False
+
 
 def frame_results_to_video_results(input_file,
                                    output_file,
@@ -1176,9 +1187,14 @@ def frame_results_to_video_results(input_file,
 
         if (video_filename_to_frame_rate is not None):
 
-            if options.frame_rates_are_required:
-                assert video_name in video_filename_to_frame_rate, \
-                    'Could not determine frame rate for {}'.format(video_name)
+            if video_name not in video_filename_to_frame_rate:
+
+                s = 'Could not determine frame rate for {}'.format(video_name)
+                if options.frame_rates_are_required:
+                    raise ValueError(s)
+                elif options.verbose:
+                    print('Warning: {}'.format(s))
+
             if video_name in video_filename_to_frame_rate:
                 im_out['frame_rate'] = video_filename_to_frame_rate[video_name]
 

megadetector/postprocessing/classification_postprocessing.py

@@ -130,7 +130,7 @@ class ClassificationSmoothingOptions:
 
         ## Populated internally
 
-        #: #: Only include these categories in the smoothing process (None to use all categories)
+        #: Only include these categories in the smoothing process (None to use all categories)
         self._detection_category_ids_to_smooth = None
 
 
@@ -1015,6 +1015,10 @@ def smooth_classification_results_sequence_level(input_file,
 
         detections_this_sequence = []
         for image_filename in image_filenames_this_sequence:
+            if image_filename not in image_fn_to_classification_results:
+                print('Warning: {} in sequence list but not in results'.format(
+                    image_filename))
+                continue
             im = image_fn_to_classification_results[image_filename]
             if 'detections' not in im or im['detections'] is None:
                 continue

megadetector/postprocessing/convert_output_format.py

@@ -2,12 +2,8 @@
 
 convert_output_format.py
 
-Converts between file formats output by our batch processing API.  Currently
-supports json <--> csv conversion, but this should be the landing place for any
-conversion - including between hypothetical alternative .json versions - that we support
-in the future.
-
-The .csv format is largely obsolete, don't use it unless you're super-duper sure you need it.
+Converts between file .json and .csv representations of MD output.  The .csv format is
+largely obsolete, don't use it unless you're super-duper sure you need it.
 
 """
 
@@ -15,13 +11,16 @@ The .csv format is largely obsolete, don't use it unless you're super-duper sure
 
 import argparse
 import json
-import csv
 import sys
 import os
 
 from tqdm import tqdm
+from collections import defaultdict
+
+import pandas as pd
 
 from megadetector.postprocessing.load_api_results import load_api_results_csv
+from megadetector.utils.wi_taxonomy_utils import load_md_or_speciesnet_file
 from megadetector.data_management.annotations import annotation_constants
 from megadetector.utils import ct_utils
 
@@ -35,16 +34,13 @@ def convert_json_to_csv(input_path,
                         min_confidence=None,
                         omit_bounding_boxes=False,
                         output_encoding=None,
-                        overwrite=True):
+                        overwrite=True,
+                        verbose=False):
     """
     Converts a MD results .json file to a totally non-standard .csv format.
 
     If [output_path] is None, will convert x.json to x.csv.
 
-    TODO: this function should obviously be using Pandas or some other sensible structured
-    representation of tabular data.  Even a list of dicts.  This implementation is quite
-    brittle and depends on adding fields to every row in exactly the right order.
-
     Args:
         input_path (str): the input .json file to convert
         output_path (str, optional): the output .csv file to generate; if this is None, uses
@@ -57,7 +53,7 @@ def convert_json_to_csv(input_path,
         output_encoding (str, optional): encoding to use for the .csv file
         overwrite (bool, optional): whether to overwrite an existing .csv file; if this is False and
             the output file exists, no-ops and returns
-
+        verbose (bool, optional): enable additional debug output
     """
 
     if output_path is None:
@@ -68,36 +64,28 @@ def convert_json_to_csv(input_path,
         return
 
     print('Loading json results from {}...'.format(input_path))
-    json_output = json.load(open(input_path))
-
-    rows = []
+    json_output = load_md_or_speciesnet_file(input_path,
+                                             verbose=verbose)
 
-    fixed_columns = ['image_path', 'max_confidence', 'detections']
+    def clean_category_name(s):
+        return s.replace(',','_').replace(' ','_').lower()
 
-    # We add an output column for each class other than 'empty',
-    # containing the maximum probability of  that class for each image
-    # n_non_empty_detection_categories = len(annotation_constants.annotation_bbox_categories) - 1
-    n_non_empty_detection_categories = annotation_constants.NUM_DETECTOR_CATEGORIES
-    detection_category_column_names = []
-    assert annotation_constants.detector_bbox_category_id_to_name[0] == 'empty'
-    for cat_id in range(1,n_non_empty_detection_categories+1):
-        cat_name = annotation_constants.detector_bbox_category_id_to_name[cat_id]
-        detection_category_column_names.append('max_conf_' + cat_name)
+    # Create column names for max detection confidences
+    detection_category_id_to_max_conf_column_name = {}
+    for category_id in json_output['detection_categories'].keys():
+        category_name = clean_category_name(json_output['detection_categories'][category_id])
+        detection_category_id_to_max_conf_column_name[category_id] = \
+            'max_conf_' + category_name
 
-    n_classification_categories = 0
+    classification_category_id_to_max_conf_column_name = {}
 
+    # Create column names for max classification confidences (if necessary)
     if 'classification_categories' in json_output.keys():
-        classification_category_id_to_name = json_output['classification_categories']
-        classification_category_ids = list(classification_category_id_to_name.keys())
-        classification_category_id_to_column_number = {}
-        classification_category_column_names = []
-        for i_category,category_id in enumerate(classification_category_ids):
-            category_name = classification_category_id_to_name[category_id].\
-                replace(' ','_').replace(',','')
-            classification_category_column_names.append('max_classification_conf_' + category_name)
-            classification_category_id_to_column_number[category_id] = i_category
-
-        n_classification_categories = len(classification_category_ids)
+
+        for category_id in json_output['classification_categories'].keys():
+            category_name = clean_category_name(json_output['classification_categories'][category_id])
+            classification_category_id_to_max_conf_column_name[category_id] = \
+                'max_classification_conf_' + category_name
 
     # There are several .json fields for which we add .csv columns; other random bespoke fields
     # will be ignored.
@@ -117,26 +105,43 @@ def convert_json_to_csv(input_path,
     if len(optional_fields_present) > 0:
         print('Found {} optional fields'.format(len(optional_fields_present)))
 
-    expected_row_length = len(fixed_columns) + len(detection_category_column_names) + \
-        n_classification_categories + len(optional_fields_present)
-
     print('Formatting results...')
 
+    output_records = []
+
     # i_image = 0; im = json_output['images'][i_image]
     for im in tqdm(json_output['images']):
 
-        image_id = im['file']
+        output_record = {}
+        output_records.append(output_record)
+
+        output_record['image_path'] = im['file']
+        output_record['max_confidence'] = ''
+        output_record['detections'] = ''
+
+        for field_name in optional_fields_present:
+            output_record[field_name] = ''
+            if field_name in im:
+                output_record[field_name] = im[field_name]
+
+        for detection_category_id in detection_category_id_to_max_conf_column_name:
+            column_name = detection_category_id_to_max_conf_column_name[detection_category_id]
+            output_record[column_name] = 0
+
+        for classification_category_id in classification_category_id_to_max_conf_column_name:
+            column_name = classification_category_id_to_max_conf_column_name[classification_category_id]
+            output_record[column_name] = 0
 
         if 'failure' in im and im['failure'] is not None:
-            row = [image_id, 'failure', im['failure']]
-            rows.append(row)
+            output_record['max_confidence'] = 'failure'
+            output_record['detections'] = im['failure']
             # print('Skipping failed image {} ({})'.format(im['file'],im['failure']))
             continue
 
         max_conf = ct_utils.get_max_conf(im)
+        detection_category_id_to_max_conf = defaultdict(float)
+        classification_category_id_to_max_conf = defaultdict(float)
         detections = []
-        max_detection_category_probabilities = [None] * n_non_empty_detection_categories
-        max_classification_category_probabilities = [0] * n_classification_categories
 
         # d = im['detections'][0]
         for d in im['detections']:
@@ -155,31 +160,24 @@ def convert_json_to_csv(input_path,
             xmax = input_bbox[0] + input_bbox[2]
             ymax = input_bbox[1] + input_bbox[3]
             output_detection = [ymin, xmin, ymax, xmax]
-
             output_detection.append(d['conf'])
-
-            # Category 0 is empty, for which we don't have a column, so the max
-            # confidence for category N goes in column N-1
-            detection_category_id = int(d['category'])
-            assert detection_category_id > 0 and detection_category_id <= \
-                n_non_empty_detection_categories
-            detection_category_column = detection_category_id - 1
-            detection_category_max = max_detection_category_probabilities[detection_category_column]
-            if detection_category_max is None or d['conf'] > detection_category_max:
-                max_detection_category_probabilities[detection_category_column] = d['conf']
-
-            output_detection.append(detection_category_id)
+            output_detection.append(int(d['category']))
             detections.append(output_detection)
 
+            detection_category_id = d['category']
+            detection_category_max = detection_category_id_to_max_conf[detection_category_id]
+            if d['conf'] > detection_category_max:
+                detection_category_id_to_max_conf[detection_category_id] = d['conf']
+
             if 'classifications' in d:
-                assert n_classification_categories > 0,\
-                    'Oops, I have classification results, but no classification metadata'
+
                 for c in d['classifications']:
-                    category_id = c[0]
-                    p = c[1]
-                    category_index = classification_category_id_to_column_number[category_id]
-                    if (max_classification_category_probabilities[category_index] < p):
-                        max_classification_category_probabilities[category_index] = p
+                    classification_category_id = c[0]
+                    classification_conf = c[1]
+                    classification_category_max = \
+                        classification_category_id_to_max_conf[classification_category_id]
+                    if classification_conf > classification_category_max:
+                        classification_category_id_to_max_conf[classification_category_id] = d['conf']
 
                 # ...for each classification
 
@@ -191,40 +189,36 @@ def convert_json_to_csv(input_path,
         if not omit_bounding_boxes:
             detection_string = json.dumps(detections)
 
-        row = [image_id, max_conf, detection_string]
-        row.extend(max_detection_category_probabilities)
-        row.extend(max_classification_category_probabilities)
+        output_record['detections'] = detection_string
+        output_record['max_confidence'] = max_conf
 
-        for field_name in optional_fields_present:
-            if field_name not in im:
-                row.append('')
-            else:
-                row.append(str(im[field_name]))
+        for detection_category_id in detection_category_id_to_max_conf_column_name:
+            column_name = detection_category_id_to_max_conf_column_name[detection_category_id]
+            output_record[column_name] = \
+                detection_category_id_to_max_conf[detection_category_id]
 
-        assert len(row) == expected_row_length
-        rows.append(row)
+        for classification_category_id in classification_category_id_to_max_conf_column_name:
+            column_name = classification_category_id_to_max_conf_column_name[classification_category_id]
+            output_record[column_name] = \
+                classification_category_id_to_max_conf[classification_category_id]
 
     # ...for each image
 
     print('Writing to csv...')
 
-    with open(output_path, 'w', newline='', encoding=output_encoding) as f:
-        writer = csv.writer(f, delimiter=',')
-        header = fixed_columns
-        header.extend(detection_category_column_names)
-        if n_classification_categories > 0:
-            header.extend(classification_category_column_names)
-        for field_name in optional_fields_present:
-            header.append(field_name)
-        writer.writerow(header)
-        writer.writerows(rows)
+    df = pd.DataFrame(output_records)
+
+    if omit_bounding_boxes:
+        df = df.drop('detections',axis=1)
+    df.to_csv(output_path,index=False,header=True)
 
 # ...def convert_json_to_csv(...)
 
 
 def convert_csv_to_json(input_path,output_path=None,overwrite=True):
     """
-    Convert .csv to .json.  If output_path is None, will convert x.csv to x.json.
+    Convert .csv to .json.  If output_path is None, will convert x.csv to x.json.  This
+    supports a largely obsolete .csv format, there's almost no reason you want to do this.
 
     Args:
         input_path (str): .csv filename to convert to .json

megadetector/postprocessing/subset_json_detector_output.py

@@ -83,6 +83,9 @@ class SubsetJsonDetectorOutputOptions:
     def __init__(self):
 
         #: Only process files containing the token 'query'
+        #:
+        #: Does not support general regexes, but supports ^ as a special case
+        #: regex-like notation for "starts with"
         self.query = None
 
         #: Replace 'query' with 'replacement' if 'replacement' is not None.  If 'query' is None,

megadetector/utils/directory_listing.py

@@ -21,7 +21,7 @@ from megadetector.utils.path_utils import is_image_file
 
 #%% Directory enumeration functions
 
-def create_plain_index(root, dirs, files, dirname=None):
+def _create_plain_index(root, dirs, files, dirname=None):
     """
     Creates the fairly plain HTML folder index including a preview of a single image file,
     if any is present.
@@ -40,6 +40,7 @@ def create_plain_index(root, dirs, files, dirname=None):
 
     if dirname is None:
         dirname = root or '/'
+    dirname = dirname.replace('\\','/')
 
     html = "<!DOCTYPE html>\n"
     html += "<html lang='en'><head>"
@@ -104,13 +105,14 @@ def create_plain_index(root, dirs, files, dirname=None):
     html += "</body></html>\n"
     return html
 
-# ...def create_plain_index(...)
+# ...def _create_plain_index(...)
 
 
-def traverse_and_create_index(dir,
-                              overwrite_files=False,
-                              template_fun=create_plain_index,
-                              basepath=None):
+def create_html_index(dir,
+                      overwrite=False,
+                      template_fun=_create_plain_index,
+                      basepath=None,
+                      recursive=True):
     """
     Recursively traverses the local directory [dir] and generates a index
     file for each folder using [template_fun] to generate the HTML output.
@@ -118,12 +120,13 @@ def traverse_and_create_index(dir,
 
     Args:
         dir (str): directory to process
-        overwrite_files (bool, optional): whether to over-write existing index file
+        overwrite (bool, optional): whether to over-write existing index file
         template_fun (func, optional): function taking three arguments (string,
             list of string, list of string) representing the current root, the list of folders,
             and the list of files.  Should return the HTML source of the index file.
         basepath (str, optional): if not None, the name used for each subfolder in [dir]
             in the output files will be relative to [basepath]
+        recursive (bool, optional): recurse into subfolders
     """
 
     print('Traversing {}'.format(dir))
@@ -141,7 +144,7 @@ def traverse_and_create_index(dir,
         # Output is written to file *root*/index.html
         output_file = os.path.join(root, "index.html")
 
-        if not overwrite_files and os.path.isfile(output_file):
+        if (not overwrite) and os.path.isfile(output_file):
             print('Skipping {}, file exists'.format(output_file))
             continue
 
@@ -157,7 +160,10 @@ def traverse_and_create_index(dir,
         with open(output_file, 'wt') as fi:
             fi.write(html)
 
-# ...def traverse_and_create_index(...)
+        if not recursive:
+            break
+
+# ...def create_html_index(...)
 
 
 #%% Command-line driver
@@ -171,7 +177,7 @@ def main(): # noqa
     parser.add_argument("--basepath", type=str,
                         help='Folder names will be printed relative to basepath, if specified',
                         default=None)
-    parser.add_argument("--enable_overwrite", action='store_true', default=False,
+    parser.add_argument("--overwrite", action='store_true', default=False,
                         help='If set, the script will overwrite existing index.html files.')
 
     if len(sys.argv[1:]) == 0:
@@ -182,9 +188,9 @@ def main(): # noqa
 
     assert os.path.isdir(args.directory), "{} is not a valid directory".format(args.directory)
 
-    traverse_and_create_index(args.directory,
-                              overwrite_files=args.enable_overwrite,
-                              basepath=args.basepath)
+    create_html_index(args.directory,
+                      overwrite=args.overwrite,
+                      basepath=args.basepath)
 
 if __name__ == '__main__':
     main()

megadetector/utils/path_utils.py

@@ -528,7 +528,8 @@ def find_images(dirname,
 def clean_filename(filename,
                    allow_list=VALID_FILENAME_CHARS,
                    char_limit=CHAR_LIMIT,
-                   force_lower= False):
+                   force_lower=False,
+                   remove_trailing_leading_whitespace=True):
     r"""
     Removes non-ASCII and other invalid filename characters (on any
     reasonable OS) from a filename, then optionally trims to a maximum length.
@@ -544,11 +545,27 @@ def clean_filename(filename,
         char_limit (int, optional): maximum allowable filename length, if None will skip this
             step
         force_lower (bool, optional): convert the resulting filename to lowercase
-
+        remove_trailing_leading_whitespace (bool, optional): remove trailing and
+            leading whitespace from each component of a path, e.g. does not allow
+            a/b/c /d.jpg
     Returns:
         str: cleaned version of [filename]
     """
 
+    if remove_trailing_leading_whitespace:
+
+        # Best effort to preserve the original separator
+        separator = '/'
+        if '\\' in filename:
+            separator = '\\'
+
+        filename = filename.replace('\\','/')
+        components = filename.split('/')
+        clean_components = [c.strip() for c in components]
+        filename = separator.join(clean_components)
+        if separator == '\\':
+            filename = filename.replace('/','\\')
+
     # keep only valid ascii chars
     cleaned_filename = (unicodedata.normalize('NFKD', filename)
                         .encode('ASCII', 'ignore').decode())
@@ -565,7 +582,8 @@ def clean_filename(filename,
 def clean_path(pathname,
                allow_list=VALID_PATH_CHARS,
                char_limit=CHAR_LIMIT,
-               force_lower=False):
+               force_lower=False,
+               remove_trailing_leading_whitespace=True):
     """
     Removes non-ASCII and other invalid path characters (on any reasonable
     OS) from a path, then optionally trims to a maximum length.
@@ -576,13 +594,20 @@ def clean_path(pathname,
         char_limit (int, optional): maximum allowable filename length, if None will skip this
             step
         force_lower (bool, optional): convert the resulting filename to lowercase
+        remove_trailing_leading_whitespace (bool, optional): remove trailing and
+            leading whitespace from each component of a path, e.g. does not allow
+            a/b/c /d.jpg
 
     Returns:
         str: cleaned version of [filename]
     """
 
-    return clean_filename(pathname, allow_list=allow_list,
-                          char_limit=char_limit, force_lower=force_lower)
+    return clean_filename(pathname,
+                          allow_list=allow_list,
+                          char_limit=char_limit,
+                          force_lower=force_lower,
+                          remove_trailing_leading_whitespace=\
+                            remove_trailing_leading_whitespace)
 
 
 def flatten_path(pathname,separator_chars=SEPARATOR_CHARS,separator_char_replacement='~'):
@@ -1553,6 +1578,7 @@ class TestPathUtils:
         """
 
         self.test_dir = make_test_folder(subfolder='megadetector/path_utils_tests')
+        print('Using temporary folder {} for path utils testing'.format(self.test_dir))
         os.makedirs(self.test_dir, exist_ok=True)
 
 
@@ -1776,7 +1802,11 @@ class TestPathUtils:
         ])
         folders_non_recursive_abs = folder_list(folder_list_dir, recursive=False,
                                                 return_relative_paths=False)
-        assert sorted(folders_non_recursive_abs) == expected_folders_non_recursive_abs
+        assert sorted(folders_non_recursive_abs) == expected_folders_non_recursive_abs, \
+            'Non-recursive folder list failured, expected:\n\n{}\n\nFound:\n\n{}'.format(
+                str(expected_folders_non_recursive_abs),
+                str(folders_non_recursive_abs)
+            )
 
         # Test non-recursive, relative paths
         expected_folders_non_recursive_rel = sorted(['subdir1', 'subdir2'])
@@ -2114,7 +2144,17 @@ class TestPathUtils:
         assert clean_filename("test*file?.txt", char_limit=10) == "testfile.t"
         assert clean_filename("TestFile.TXT", force_lower=True) == "testfile.txt"
         assert clean_filename("file:with<illegal>chars.txt") == "filewithillegalchars.txt"
-        assert clean_filename(" accented_name_éà.txt") == " accented_name_ea.txt"
+
+        s = " accented_name_éà.txt"
+
+        assert clean_filename(s,
+                              remove_trailing_leading_whitespace=False) == " accented_name_ea.txt", \
+            'clean_filename with remove_trailing_leading_whitespace=False: {}'.format(
+                clean_filename(s, remove_trailing_leading_whitespace=False))
+
+        assert clean_filename(s, remove_trailing_leading_whitespace=True) == "accented_name_ea.txt", \
+            'clean_filename with remove_trailing_leading_whitespace=False: {}'.format(
+                clean_filename(s, remove_trailing_leading_whitespace=True))
 
         # Separators are not allowed by default in clean_filename
         assert clean_filename("path/to/file.txt") == "pathtofile.txt"
@@ -2444,7 +2484,13 @@ class TestPathUtils:
         un_tar_dir = os.path.join(self.test_dir, "un_tar_contents")
         os.makedirs(un_tar_dir, exist_ok=True)
         with tarfile.open(output_tar_path, 'r:gz') as tf:
-            tf.extractall(path=un_tar_dir)
+            # The "filter" option was added as of Python 3.12, and *not* specifying
+            # filter=None will change behavior as of Python 3.14.  We want the unmodified
+            # behavior, but we want to support Python <3.12, so we do a version check.
+            if sys.version_info >= (3, 12):
+                tf.extractall(path=un_tar_dir, filter=None)
+            else:
+                tf.extractall(path=un_tar_dir)
 
         expected_untarred_file1 = os.path.join(un_tar_dir, os.path.relpath(file1_path, self.test_dir))
         expected_untarred_file2 = os.path.join(un_tar_dir, os.path.relpath(file2_path, self.test_dir))
@@ -2618,7 +2664,9 @@ def test_path_utils():
 
     test_instance = TestPathUtils()
     test_instance.set_up()
+
     try:
+
         test_instance.test_is_image_file()
         test_instance.test_find_image_strings()
         test_instance.test_find_images()
@@ -2643,5 +2691,7 @@ def test_path_utils():
         test_instance.test_add_files_to_single_tar_file()
         test_instance.test_parallel_zip_individual_files_and_folders()
         test_instance.test_compute_file_hash()
+
     finally:
+
         test_instance.tear_down()

megadetector/utils/url_utils.py

@@ -2,7 +2,7 @@
 
 url_utils.py
 
-Frequently-used functions for downloading or manipulating URLs
+Frequently-used functions for downloading, manipulating, or serving URLs
 
 """
 
@@ -16,6 +16,9 @@ import urllib.error
 import requests
 import shutil
 import pytest
+import socketserver
+import threading
+import http.server
 
 from functools import partial
 from tqdm import tqdm
@@ -453,6 +456,93 @@ def get_url_sizes(urls,n_workers=1,pool_type='thread',timeout=None,verbose=False
     return url_to_size
 
 
+#%%  Singleton HTTP server
+
+class QuietHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
+    """
+    SimpleHTTPRequestHandler sublcass that suppresses console printouts
+    """
+    def __init__(self, *args, directory=None, **kwargs):
+        super().__init__(*args, directory=directory, **kwargs)
+
+    def log_message(self, format, *args): # noqa
+        pass
+
+
+class SingletonHTTPServer:
+    """
+    HTTP server that runs on a local port, serving a particular local folder.  Runs as a
+    singleton, so starting a server in a new folder closes the previous server.  I use this
+    primarily to serve MD/SpeciesNet previews from manage_local_batch, which can exceed
+    the 260-character filename length limitation imposed by browser on Windows, so really the
+    point here is just to remove characters from the URL.
+    """
+
+    _server = None
+    _thread = None
+
+    @classmethod
+    def start_server(cls, directory, port=8000, host='localhost'):
+        """
+        Start or restart the HTTP server with a specific directory
+
+        Args:
+            directory (str): the root folder served by the server
+            port (int, optional): the port on which to create the server
+            host (str, optional): the host on which to listen, typically
+                either "localhost" (default) or "0.0.0.0"
+
+        Returns:
+            str: URL to the running host
+        """
+
+        # Stop the existing server instance if necessary
+        cls.stop_server()
+
+        # Create new server
+        handler = partial(QuietHTTPRequestHandler, directory=directory)
+        cls._server = socketserver.TCPServer((host, port), handler)
+
+        # Start server in daemon thread (dies when parent process dies)
+        cls._thread = threading.Thread(target=cls._server.serve_forever)
+        cls._thread.daemon = True
+        cls._thread.start()
+
+        print(f"Serving {directory} at http://{host}:{port}")
+        return f"http://{host}:{port}"
+
+
+    @classmethod
+    def stop_server(cls):
+        """
+        Stop the current server (if one is running)
+        """
+
+        if cls._server:
+            cls._server.shutdown()
+            cls._server.server_close()
+            cls._server = None
+        if cls._thread:
+            cls._thread.join(timeout=1)
+            cls._thread = None
+
+
+    @classmethod
+    def is_running(cls):
+        """
+        Check whether the server is currently running.
+
+        Returns:
+            bool: True if the server is running
+        """
+
+        return (cls._server is not None) and \
+            (cls._thread is not None) and \
+            (cls._thread.is_alive())
+
+# ...class SingletonHTTPServer
+
+
 #%% Tests
 
 # Constants for tests

megadetector/utils/wi_taxonomy_utils.py

@@ -10,8 +10,6 @@ Functions related to working with the SpeciesNet / Wildlife Insights taxonomy.
 
 import os
 import json
-import tempfile
-import uuid
 
 import pandas as pd
 
@@ -399,11 +397,12 @@ def generate_whole_image_detections_for_classifications(classifications_json_fil
 
 
 def generate_md_results_from_predictions_json(predictions_json_file,
-                                              md_results_file,
+                                              md_results_file=None,
                                               base_folder=None,
                                               max_decimals=5,
                                               convert_human_to_person=True,
-                                              convert_homo_species_to_human=True):
+                                              convert_homo_species_to_human=True,
+                                              verbose=False):
     """
     Generate an MD-formatted .json file from a predictions.json file, generated by the
     SpeciesNet ensemble.  Typically, MD results files use relative paths, and predictions.json
@@ -424,7 +423,7 @@ def generate_md_results_from_predictions_json(predictions_json_file,
 
     Args:
         predictions_json_file (str): path to a predictions.json file, or a dict
-        md_results_file (str): path to which we should write an MD-formatted .json file
+        md_results_file (str, optional): path to which we should write an MD-formatted .json file
         base_folder (str, optional): leading string to remove from each path in the
             predictions.json file
         max_decimals (int, optional): number of decimal places to which we should round
@@ -435,6 +434,10 @@ def generate_md_results_from_predictions_json(predictions_json_file,
         convert_homo_species_to_human (bool, optional): the ensemble often rolls human predictions
             up to "homo species", which isn't wrong, but looks odd.  This forces these back to
             "homo sapiens".
+        verbose (bool, optional): enable additional debug output
+
+    Returns:
+        dict: results in MD format
     """
 
     # Read predictions file
@@ -558,7 +561,9 @@ def generate_md_results_from_predictions_json(predictions_json_file,
                     # but a non-blank prediction.  For now, create a fake detection to handle this prediction.
                     if len(im_out['detections']) == 0:
 
-                        print('Warning: creating fake detection for non-blank whole-image classification')
+                        if verbose:
+                            print('Warning: creating fake detection for non-blank whole-image classification' + \
+                                  ' in {}'.format(im_in['file']))
                         det_out = {}
                         all_unknown_detections.append(det_out)
 
@@ -640,12 +645,15 @@ def generate_md_results_from_predictions_json(predictions_json_file,
     output_dict['classification_category_descriptions'] = classification_category_descriptions
     output_dict['images'] = images_out
 
-    with open(md_results_file,'w') as f:
-        json.dump(output_dict,f,indent=1)
+    if md_results_file is not None:
+        with open(md_results_file,'w') as f:
+            json.dump(output_dict,f,indent=1)
 
-    validation_options = ValidateBatchResultsOptions()
-    validation_options.raise_errors = True
-    _ = validate_batch_results(md_results_file, options=validation_options)
+        validation_options = ValidateBatchResultsOptions()
+        validation_options.raise_errors = True
+        _ = validate_batch_results(md_results_file, options=validation_options)
+
+    return output_dict
 
 # ...def generate_md_results_from_predictions_json(...)
 
@@ -885,24 +893,16 @@ def load_md_or_speciesnet_file(fn,verbose=True):
     with open(fn,'r') as f:
         detector_output = json.load(f)
 
-    # Convert to MD format if necessary
+    # If this is a SpeicesNet file, convert to MD format
     if 'predictions' in detector_output:
+
         if verbose:
             print('This appears to be a SpeciesNet output file, converting to MD format')
-        md_temp_dir = os.path.join(tempfile.gettempdir(), 'megadetector_temp_files')
-        os.makedirs(md_temp_dir,exist_ok=True)
-        temp_results_file = os.path.join(md_temp_dir,str(uuid.uuid1()) + '.json')
-        print('Writing temporary results to {}'.format(temp_results_file))
-        generate_md_results_from_predictions_json(predictions_json_file=fn,
-                                                  md_results_file=temp_results_file,
-                                                  base_folder=None)
-        with open(temp_results_file,'r') as f:
-            detector_output = json.load(f)
-        try:
-            os.remove(temp_results_file)
-        except Exception:
-            if verbose:
-                print('Warning: error removing temporary .json {}'.format(temp_results_file))
+        detector_output = generate_md_results_from_predictions_json(predictions_json_file=fn,
+                                                                    md_results_file=None,
+                                                                    base_folder=None)
+
+    # ...if this is a SpeciesNet file
 
     assert 'images' in detector_output, \
         'Detector output file should be a json file with an "images" field.'

megadetector/visualization/visualize_video_output.py

@@ -67,6 +67,10 @@ class VideoVisualizationOptions:
         #: Skip frames before first and after last above-threshold detection
         self.trim_to_detections = False
 
+        #: By default, output videos use the same extension as input videos,
+        #: use this to force a particular extension
+        self.output_extension = None
+
 # ...class VideoVisualizationOptions
 
 
@@ -287,10 +291,16 @@ def _process_video(video_entry,
         result['error'] = 'Video not found: {}'.format(input_video_path)
         return result
 
-    # Create output path preserving directory structure
-    rel_path = video_entry['file']
-    output_video_path = os.path.join(out_dir, rel_path)
-    os.makedirs(os.path.dirname(output_video_path), exist_ok=True)
+    output_fn_relative = video_entry['file']
+
+    if options.output_extension is not None:
+        ext = options.output_extension
+        if not ext.startswith('.'):
+            ext = '.' + ext
+        output_fn_relative = os.path.splitext(output_fn_relative)[0] + ext
+
+    output_fn_abs = os.path.join(out_dir, output_fn_relative)
+    os.makedirs(os.path.dirname(output_fn_abs), exist_ok=True)
 
     # Get frames to process
     frames_to_process = _get_frames_to_process(video_entry,
@@ -392,10 +402,10 @@ def _process_video(video_entry,
 
             # Create VideoWriter
             fourcc = cv2.VideoWriter_fourcc(*options.fourcc)
-            video_writer = cv2.VideoWriter(output_video_path, fourcc, output_framerate, (width, height))
+            video_writer = cv2.VideoWriter(output_fn_abs, fourcc, output_framerate, (width, height))
 
             if not video_writer.isOpened():
-                result['error'] = 'Failed to open video writer for {}'.format(output_video_path)
+                result['error'] = 'Failed to open video writer for {}'.format(output_fn_abs)
                 return result
 
             # Write frames

{megadetector-10.0.7.dist-info → megadetector-10.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: megadetector
-Version: 10.0.7
+Version: 10.0.8
 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>

{megadetector-10.0.7.dist-info → megadetector-10.0.8.dist-info}/RECORD

@@ -32,7 +32,7 @@ megadetector/classification/efficientnet/utils.py,sha256=76SQdh0zK7CFcwTW4kiechC
 megadetector/data_management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 megadetector/data_management/animl_to_md.py,sha256=Z6PDJxeM_5dMZJBM3j0mxDPW2_1bNkXx0M3_qq42_Ig,4416
 megadetector/data_management/camtrap_dp_to_coco.py,sha256=HoCGMzZTEvnudnAjbOr-mCizXHmc8mMNSUChy_Q9PkI,9673
-megadetector/data_management/cct_json_utils.py,sha256=B9YawIxs1l62AsWlv0yHaV01XZtbRXQ8NByRwfYGjv0,19536
+megadetector/data_management/cct_json_utils.py,sha256=Azyuwok6-g5YGVAdBzv3-eJIlplXCoTcjGWu6zy9bQ0,19917
 megadetector/data_management/cct_to_md.py,sha256=e1fYevSz0m65n5H16uB6uwzNiXiwxjdB2ka5p68R4d0,5120
 megadetector/data_management/cct_to_wi.py,sha256=wcBOmurXY5I-hiqV6SmRSGUAeYaKHEU1LgCZjqVmCyw,9561
 megadetector/data_management/coco_to_labelme.py,sha256=uYJ60XoZfHUEfLzj-EjLyeNM590skNnMp-IThWwNISo,8683
@@ -59,7 +59,7 @@ megadetector/data_management/databases/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JC
 megadetector/data_management/databases/add_width_and_height_to_db.py,sha256=EYfFGPkXyFz6ZGQfXjCK3pNXLBg0hu73wiACdEEB0E0,2964
 megadetector/data_management/databases/combine_coco_camera_traps_files.py,sha256=Au7akR2KZHm_l8-MGGRGf0CQy1az_JVgZW5Yz1_XQeQ,6609
 megadetector/data_management/databases/integrity_check_json_db.py,sha256=kxGCHpBADXT_LHVLUENGvmby-orvVYIsK6fdgqhABBI,17386
-megadetector/data_management/databases/subset_json_db.py,sha256=mO1eAkrfCSAp2_r5vHVjHvet_utFJcWRm3rNa8WvSx8,4134
+megadetector/data_management/databases/subset_json_db.py,sha256=AQF-12vnZJ73JrWvjUd2ME666MmQDiCOvO0e7zGjPpg,6243
 megadetector/data_management/lila/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 megadetector/data_management/lila/create_lila_blank_set.py,sha256=tApCL4XN1Vzl6YvcdI6SY4TZbHeCyHLzNYweFfX0sy0,19490
 megadetector/data_management/lila/create_lila_test_set.py,sha256=UWJPKrwNW-UVeGrMUrFvmIt2UHVyuFiPzRFKkbEbk5A,5014
@@ -73,21 +73,21 @@ megadetector/data_management/lila/test_lila_metadata_urls.py,sha256=ThU78Ks5V3rF
 megadetector/detection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 megadetector/detection/change_detection.py,sha256=Ne3GajbH_0KPBU8ruHp4Rkr0uKd5oKAMQ3CQTRKRHgQ,28659
 megadetector/detection/process_video.py,sha256=kuQHrpOC3LQo9ecqJPpzkds9fZVnoLmrfJw_yh-oxi8,17890
-megadetector/detection/pytorch_detector.py,sha256=ixU-2_AnCwEP33FaaqTZRoi1WxIUeM4x_ksbNT-tezA,59817
+megadetector/detection/pytorch_detector.py,sha256=4Ix6AOBciMbn5zFHXe4hgb5tXGOup57ju3z8gtsin3s,60567
 megadetector/detection/run_detector.py,sha256=TTX29zxDN_O7ja61sOmMIVewUz3yRvKg1D1AAYhVEkc,46851
 megadetector/detection/run_detector_batch.py,sha256=aZgiywL6arrdQ_l3jzlHctlccqL537lwVStjhi1hIWw,89823
-megadetector/detection/run_inference_with_yolov5_val.py,sha256=A-AQuARVVy7oR9WtenCZwzvd5U3HQwihMr4Jkiv9U0g,53515
+megadetector/detection/run_inference_with_yolov5_val.py,sha256=dJXh3BwKOQQ4OA-Mq_heEb7AfBAk7qKUAagnIGuFtaU,53689
 megadetector/detection/run_md_and_speciesnet.py,sha256=Dp_SpJZp0pX9jzFtxM6zPCyBNq49uyQpMDAdNDLVorM,50280
-megadetector/detection/run_tiled_inference.py,sha256=wrQkKIloHBO9v2i0nZ1_Tt75iFtVrnco3Y4FafoVxdw,39382
+megadetector/detection/run_tiled_inference.py,sha256=hVpR-URC67e6Ht-cy_EgIrJ4GFina29H_lBXOE3bzwM,39435
 megadetector/detection/tf_detector.py,sha256=3b2MiqgMw8KBDzHQliUSDXWrmKpa9iZnfe6EgYpMcYo,8398
-megadetector/detection/video_utils.py,sha256=AlmNJ5n7qmv3Z65HcjI1ALAxXMmyTG3pUiO7oJm-8rs,53363
+megadetector/detection/video_utils.py,sha256=M7yje6XeOnR_QwDyuG1o6bwTKvRysoA2NiOK2MSi98E,53943
 megadetector/postprocessing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 megadetector/postprocessing/add_max_conf.py,sha256=9MYtsH2mwkiaZb7Qcor5J_HskfAj7d9srp8G_Qldpk0,1722
 megadetector/postprocessing/categorize_detections_by_size.py,sha256=DpZpRNFlyeOfWuOc6ICuENgIWDCEtiErJ_frBZp9lYM,5382
-megadetector/postprocessing/classification_postprocessing.py,sha256=TrhzjMWkoLs4ml0ObCKR7rUpprbT7sgS6RtyjPicj9A,68362
+megadetector/postprocessing/classification_postprocessing.py,sha256=OoPVr34vXyLykB42SplcSKo9cj7dgf8Yju_DCDhd6_k,68574
 megadetector/postprocessing/combine_batch_outputs.py,sha256=BEP8cVa0sMIPg7tkWQc_8vOEPnbmWjOsQdVJHe61uz8,8468
 megadetector/postprocessing/compare_batch_results.py,sha256=RDlKLwea76rOWiDneSJUj6P_oMBMnD2BY4inoxLqQiw,84258
-megadetector/postprocessing/convert_output_format.py,sha256=FiwKSiMyEeNVLLfjpQtx3CrMbchwNUaW2TgLmdXGFVo,14892
+megadetector/postprocessing/convert_output_format.py,sha256=3KLO6NqddofgIEYjV8_iZIf0iXaplFN2AroUq5i4R7k,14472
 megadetector/postprocessing/create_crop_folder.py,sha256=T37HnvBEakikXY3n3Bgk5boFo_0-Z5aKnkEWXv-Ki4s,23166
 megadetector/postprocessing/detector_calibration.py,sha256=UFjJ8D6tMghatLRj3CyrtJ7vrPIJkULMNsYMIj98j2M,20495
 megadetector/postprocessing/generate_csv_report.py,sha256=KIGT8zFZev-cl4YOCq2BqnodBWsZG-7CZaWuep_211U,19169
@@ -100,7 +100,7 @@ megadetector/postprocessing/postprocess_batch_results.py,sha256=VJyXx8I6KZgefrLN
 megadetector/postprocessing/remap_detection_categories.py,sha256=BE6Ce-PGBEx1FyG3XwbYp2D5sh5xUlVf6fonaMuPMAg,7927
 megadetector/postprocessing/render_detection_confusion_matrix.py,sha256=oNvDTh5td5ynELNnhz4XaLP2HiwLuojkJlob15TpgcY,26365
 megadetector/postprocessing/separate_detections_into_folders.py,sha256=Yvpkl_MsWbGoo4zvQHrXHkATRJaYdYligItfg9bvuV8,32262
-megadetector/postprocessing/subset_json_detector_output.py,sha256=FiP1sUYfIBqOiSwjkJ6qkj4hvlF7yJsF7-y9tmfSShc,32187
+megadetector/postprocessing/subset_json_detector_output.py,sha256=R6CtSMcriXq50EHawXWC5pHZ-vtJFSKqjeleGKiouDY,32325
 megadetector/postprocessing/top_folders_to_bottom.py,sha256=zYrqMHjUZG8urh2CYphfs91ZQ620uqe-TL8jVYy8KVw,6049
 megadetector/postprocessing/validate_batch_results.py,sha256=9nr7LeKMdki9Y821ag2bZFQCxuq0OqINDH7cPXyVcY8,12059
 megadetector/postprocessing/repeat_detection_elimination/find_repeat_detections.py,sha256=XgVeyga8iSC01MAjXxb2rn-CgJTYHqC_gfxxEoSn4aw,9420
@@ -121,17 +121,17 @@ megadetector/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 megadetector/tests/test_nms_synthetic.py,sha256=oY6xmT1sLSSN7weQJ8TPTaZgAiSiZ6s43EffUhwLWIw,14707
 megadetector/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 megadetector/utils/ct_utils.py,sha256=IiZV8dWtJamveINv_joATMgMPHeDkZ8l82jDEQcLgQg,60502
-megadetector/utils/directory_listing.py,sha256=CZBzwg0Fus1xuRAp3ycEBjViDdwwk4eKdGq06ZERLDg,6414
+megadetector/utils/directory_listing.py,sha256=0-VMuQWo6rETIKERqfX6Zn7pRp_GJ4JiFiWvsw9PQcU,6500
 megadetector/utils/extract_frames_from_video.py,sha256=vjSVgxtb5z2syHCVYWc2KdNUpc-O6yY8nkbj_wqsIvY,12255
 megadetector/utils/gpu_test.py,sha256=5zUfAVeSjH8I08eCqayFmMxL-0mix8SjJJTe5ORABvU,3544
 megadetector/utils/md_tests.py,sha256=Iup4KjyIpLUpZ4TzzwEyGK61rg6aH7NrEQsdQ-ov51I,80300
-megadetector/utils/path_utils.py,sha256=qU1jTBHYy11i5vOMslFEUjc1VBnxQHnDCPYkVzuUXms,98686
+megadetector/utils/path_utils.py,sha256=tV8eh77m_uS8YYpOQZO8GUKR6l5sZrSSIkApqgi_DmY,101030
 megadetector/utils/process_utils.py,sha256=gQcpH9WYvGPUs0FhtJ5_Xvl6JsvoGz8_mnDQk0PbTRM,5673
 megadetector/utils/split_locations_into_train_val.py,sha256=fd_6pj1aWY6hybwaXvBn9kBcOHjI90U-OsTmEAGpeu8,10297
 megadetector/utils/string_utils.py,sha256=r2Maw3zbzk3EyaZcNkdqr96yP_8m4ey6v0WxlemEY9U,6155
-megadetector/utils/url_utils.py,sha256=VWYDHbWctTtw7mvbb_A5DTdF3v9V2mWhBoOP5MGE5S8,25728
+megadetector/utils/url_utils.py,sha256=PzqN-VquAZFBRin2ZaYi5U2WCsMYSwvM0X-NN45Fdh4,28448
 megadetector/utils/wi_platform_utils.py,sha256=8CGpiox_aL6RVZKfJqPVwpW4_6Cjku0HIajJPcmeNpE,32019
-megadetector/utils/wi_taxonomy_utils.py,sha256=vZ_UlRtyLpfF4-ehBt7HHjcj7PsI2dVWFz2tES9cxt4,66641
+megadetector/utils/wi_taxonomy_utils.py,sha256=o4AvY5gZXfk69pPckdGxgIPhqsH2-hJQucavSRsUnoc,66513
 megadetector/utils/write_html_image_list.py,sha256=6Tbe5wyUxoBYJgH9yVrxxKCeWF2BVre_wQMEOQJ-ZIU,9068
 megadetector/visualization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 megadetector/visualization/plot_utils.py,sha256=uDDlOhdaJ3V8sGj2kS9b0cgszKc8WCq2_ofl6TW_XUs,10727
@@ -139,9 +139,9 @@ megadetector/visualization/render_images_with_thumbnails.py,sha256=-XX4PG4wnrFjF
 megadetector/visualization/visualization_utils.py,sha256=E5uvysS3F1S_yiPFxZty3U2f6cjuE8zG6XWggYOu-5o,75921
 megadetector/visualization/visualize_db.py,sha256=8YDWSR0eMehXYdPtak9z8UUw35xV7hu-0eCuzgSLjWc,25558
 megadetector/visualization/visualize_detector_output.py,sha256=HpWh7ugwo51YBHsFi40iAp9G-uRAMMjgsm8H_uBolBs,20295
-megadetector/visualization/visualize_video_output.py,sha256=4A5uit_JVV46kZCsO6j0bZ5-o6ZTAlXKuVvvR_xWpho,20266
-megadetector-10.0.7.dist-info/licenses/LICENSE,sha256=RMa3qq-7Cyk7DdtqRj_bP1oInGFgjyHn9-PZ3PcrqIs,1100
-megadetector-10.0.7.dist-info/METADATA,sha256=TOU1IZ7EWaMp6D_11fpJNaH8_csJvVIXGynIol6flLc,6486
-megadetector-10.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-megadetector-10.0.7.dist-info/top_level.txt,sha256=wf9DXa8EwiOSZ4G5IPjakSxBPxTDjhYYnqWRfR-zS4M,13
-megadetector-10.0.7.dist-info/RECORD,,
+megadetector/visualization/visualize_video_output.py,sha256=ibMGB5ynMwNXmaMlY8h8tURb-Lyvuxs1EB08x_jvev0,20606
+megadetector-10.0.8.dist-info/licenses/LICENSE,sha256=RMa3qq-7Cyk7DdtqRj_bP1oInGFgjyHn9-PZ3PcrqIs,1100
+megadetector-10.0.8.dist-info/METADATA,sha256=eMFedi5m5t_vYsJzAQsf7Q2Z9mHASAqEOuJjiQVWgZE,6486
+megadetector-10.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+megadetector-10.0.8.dist-info/top_level.txt,sha256=wf9DXa8EwiOSZ4G5IPjakSxBPxTDjhYYnqWRfR-zS4M,13
+megadetector-10.0.8.dist-info/RECORD,,