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

megadetector/detection/process_video.py

@@ -81,8 +81,8 @@ class ProcessVideoOptions:
         self.augment = False
 
         #: By default, a video with no frames (or no frames retrievable with the current parameters)
-        #: is treated as a failure; this causes it to be treated as a video with no detections.
-        self.allow_empty_videos = False
+        #: is silently stored as a failure; this causes it to halt execution.
+        self.exit_on_empty_video = False
 
         #: Detector-specific options
         self.detector_options = None
@@ -134,6 +134,14 @@ def process_videos(options):
     # Check for incompatible options
     _validate_video_options(options)
 
+    if options.output_json_file is None:
+        video_file = options.input_video_file.replace('\\','/')
+        if video_file.endswith('/'):
+            video_file = video_file[:-1]
+        options.output_json_file = video_file + '.json'
+        print('Output file not specified, defaulting to {}'.format(
+            options.output_json_file))
+
     assert options.output_json_file.endswith('.json'), \
         'Illegal output file {}'.format(options.output_json_file)
 
@@ -173,7 +181,7 @@ def process_videos(options):
                                                        every_n_frames=every_n_frames_param,
                                                        verbose=options.verbose,
                                                        files_to_process_relative=[video_bn],
-                                                       allow_empty_videos=options.allow_empty_videos)
+                                                       error_on_empty_video=options.exit_on_empty_video)
 
     else:
 
@@ -187,7 +195,7 @@ def process_videos(options):
                                                        every_n_frames=every_n_frames_param,
                                                        verbose=options.verbose,
                                                        recursive=options.recursive,
-                                                       allow_empty_videos=options.allow_empty_videos)
+                                                       error_on_empty_video=options.exit_on_empty_video)
 
     # ...whether we're processing a file or a folder
 
@@ -414,9 +422,10 @@ def main(): # noqa
                         action='store_true',
                         help='Enable image augmentation')
 
-    parser.add_argument('--allow_empty_videos',
+    parser.add_argument('--exit_on_empty_video',
                         action='store_true',
-                        help='By default, videos with no retrievable frames cause an error, this makes it a warning')
+                        help=('By default, videos with no retrievable frames are stored as failures; this' \
+                              'causes them to halt execution'))
 
     parser.add_argument(
         '--detector_options',

megadetector/detection/video_utils.py

@@ -101,6 +101,99 @@ def find_videos(dirname,
     return find_video_strings(files)
 
 
+#%% Shared function for opening videos
+
+DEFAULT_BACKEND = -1
+
+# This is the order in which we'll try to open backends.
+#
+# In general, the defaults are as follows, though they vary depending
+# on what's installed:
+#
+# Windows: CAP_DSHOW or CAP_MSMF
+# Linux: CAP_FFMPEG
+# macOS: CAP_AVFOUNDATION
+#
+# Technically if the default fails, we may try the same backend again, but this
+# is rare, and it's not worth the complexity of figuring out what the system
+# default is.
+backend_id_to_name = {
+    DEFAULT_BACKEND:'default',
+    cv2.CAP_FFMPEG: 'CAP_FFMPEG',
+    cv2.CAP_DSHOW: 'CAP_DSHOW',
+    cv2.CAP_MSMF: 'CAP_MSMF',
+    cv2.CAP_AVFOUNDATION: 'CAP_AVFOUNDATION',
+    cv2.CAP_GSTREAMER: 'CAP_GSTREAMER'
+}
+
+def open_video(video_path,verbose=False):
+    """
+    Open the video at [video_path], trying multiple OpenCV backends if necessary.
+
+    Args:
+        video_path (str): the file to open
+        verbose (bool, optional): enable additional debug output
+
+    Returns:
+        (cv2.VideoCapture,image): a tuple containing (a) the open video capture device
+        (or None if no backends succeeded) and (b) the first frame of the video (or None)
+    """
+
+    if not os.path.isfile(video_path):
+        print('Video file {} not found'.format(video_path))
+        return None,None
+
+    backend_ids = backend_id_to_name.keys()
+
+    for backend_id in backend_ids:
+
+        backend_name = backend_id_to_name[backend_id]
+        if verbose:
+            print('Trying backend {}'.format(backend_name))
+
+        try:
+            if backend_id == DEFAULT_BACKEND:
+                vidcap = cv2.VideoCapture(video_path)
+            else:
+                vidcap = cv2.VideoCapture(video_path, backend_id)
+        except Exception as e:
+            if verbose:
+                print('Warning: error opening {} with backend {}: {}'.format(
+                    video_path,backend_name,str(e)))
+            continue
+
+        if not vidcap.isOpened():
+            if verbose:
+                print('Warning: isOpened() is False for {} with backend {}'.format(
+                    video_path,backend_name))
+            try:
+                vidcap.release()
+            except Exception:
+                pass
+            continue
+
+        success, image = vidcap.read()
+        if success and (image is not None):
+            if verbose:
+                print('Successfully opened {} with backend: {}'.format(
+                    video_path,backend_name))
+            return vidcap,image
+
+        print('Warning: failed to open {} with backend {}'.format(
+            video_path,backend_name))
+        try:
+            vidcap.release()
+        except Exception:
+            pass
+
+    # ...for each backend
+
+    print('Error: failed to open {} with any backend'.format(video_path))
+    return None,None
+
+# ...def open_video(...)
+
+
 #%% Functions for rendering frames to video and vice-versa
 
 # http://tsaith.github.io/combine-images-into-a-video-with-python-3-and-opencv-3.html
@@ -146,21 +239,32 @@ def frames_to_video(images, fs, output_file_name, codec_spec=default_fourcc):
     cv2.destroyAllWindows()
 
 
-def get_video_fs(input_video_file):
+def get_video_fs(input_video_file,verbose=False):
     """
     Retrieves the frame rate of [input_video_file].
 
     Args:
         input_video_file (str): video file for which we want the frame rate
+        verbose (bool, optional): enable additional debug output
 
     Returns:
-        float: the frame rate of [input_video_file]
+        float: the frame rate of [input_video_file], or None if no frame
+            rate could be extracted
     """
 
-    assert os.path.isfile(input_video_file), 'File {} not found'.format(input_video_file)
-    vidcap = cv2.VideoCapture(input_video_file)
+    assert os.path.isfile(input_video_file), \
+        'File {} not found'.format(input_video_file)
+    vidcap,_ = open_video(input_video_file,verbose=verbose)
+    if vidcap is None:
+        if verbose:
+            print('Failed to get frame rate for {}'.format(input_video_file))
+        return None
     fs = vidcap.get(cv2.CAP_PROP_FPS)
-    vidcap.release()
+    try:
+        vidcap.release()
+    except Exception as e:
+        print('Warning: error closing video handle for {}: {}'.format(
+            input_video_file,str(e)))
     return fs
 
 
@@ -249,7 +353,7 @@ def run_callback_on_frames(input_video_file,
             of the video, no frames are extracted.  Can also be a single int, specifying
             a single frame number.
         allow_empty_videos (bool, optional): Just print a warning if a video appears to have no
-            frames (by default, this is an error).
+            frames (by default, this raises an Exception).
 
     Returns:
         dict: dict with keys 'frame_filenames' (list), 'frame_rate' (float), 'results' (list).
@@ -271,7 +375,7 @@ def run_callback_on_frames(input_video_file,
 
     try:
 
-        vidcap = cv2.VideoCapture(input_video_file)
+        vidcap,image = open_video(input_video_file,verbose=verbose)
         n_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
         frame_rate = vidcap.get(cv2.CAP_PROP_FPS)
 
@@ -300,7 +404,11 @@ def run_callback_on_frames(input_video_file,
         # frame_number = 0
         for frame_number in range(0,n_frames):
 
-            success,image = vidcap.read()
+            # We've already read the first frame, when we opened the video
+            if frame_number != 0:
+                success,image = vidcap.read()
+            else:
+                success = True
 
             if not success:
                 assert image is None
@@ -363,9 +471,9 @@ def run_callback_on_frames_for_folder(input_video_folder,
                                       frame_callback,
                                       every_n_frames=None,
                                       verbose=False,
-                                      allow_empty_videos=False,
                                       recursive=True,
-                                      files_to_process_relative=None):
+                                      files_to_process_relative=None,
+                                      error_on_empty_video=False):
     """
     Calls the function frame_callback(np.array,image_id) on all (or selected) frames in
     all videos in [input_video_folder].
@@ -382,10 +490,10 @@ def run_callback_on_frames_for_folder(input_video_folder,
             interpreted as a sampling rate in seconds, which is rounded to the nearest frame
             sampling rate.
         verbose (bool, optional): enable additional debug console output
-        allow_empty_videos (bool, optional): Just print a warning if a video appears to have no
-            frames (by default, this is an error).
         recursive (bool, optional): recurse into [input_video_folder]
         files_to_process_relative (list, optional): only process specific relative paths
+        error_on_empty_video (bool, optional): by default, videos with errors or no valid frames
+            are silently stored as failures; this turns them into exceptions
 
     Returns:
         dict: dict with keys 'video_filenames' (list of str), 'frame_rates' (list of floats),
@@ -440,18 +548,21 @@ def run_callback_on_frames_for_folder(input_video_folder,
                                                    every_n_frames=every_n_frames,
                                                    verbose=verbose,
                                                    frames_to_process=None,
-                                                   allow_empty_videos=allow_empty_videos)
+                                                   allow_empty_videos=False)
 
         except Exception as e:
 
-            print('Warning: error processing video {}: {}'.format(
-                video_fn_abs,str(e)
-            ))
-            to_return['frame_rates'].append(-1.0)
-            failure_result = {}
-            failure_result['failure'] = 'Failure processing video: {}'.format(str(e))
-            to_return['results'].append(failure_result)
-            continue
+            if (not error_on_empty_video):
+                print('Warning: error processing video {}: {}'.format(
+                    video_fn_abs,str(e)
+                ))
+                to_return['frame_rates'].append(-1.0)
+                failure_result = {}
+                failure_result['failure'] = 'Failure processing video: {}'.format(str(e))
+                to_return['results'].append(failure_result)
+                continue
+            else:
+                raise
 
         # ...try/except
 

megadetector/postprocessing/classification_postprocessing.py

@@ -13,14 +13,15 @@ Functions for postprocessing species classification results, particularly:
 
 #%% Constants and imports
 
-import os
 import json
 import copy
+import pandas as pd
 
 from collections import defaultdict
 from tqdm import tqdm
 
 from megadetector.utils.ct_utils import is_list_sorted
+from megadetector.utils.ct_utils import is_empty
 from megadetector.utils.ct_utils import sort_dictionary_by_value
 from megadetector.utils.ct_utils import sort_dictionary_by_key
 from megadetector.utils.ct_utils import invert_dictionary
@@ -29,9 +30,9 @@ from megadetector.utils.wi_taxonomy_utils import clean_taxonomy_string
 from megadetector.utils.wi_taxonomy_utils import taxonomy_level_index
 from megadetector.utils.wi_taxonomy_utils import taxonomy_level_string_to_index
 
-from megadetector.utils.wi_taxonomy_utils import non_taxonomic_prediction_strings
 from megadetector.utils.wi_taxonomy_utils import human_prediction_string
 from megadetector.utils.wi_taxonomy_utils import animal_prediction_string
+from megadetector.utils.wi_taxonomy_utils import is_taxonomic_prediction_string
 from megadetector.utils.wi_taxonomy_utils import blank_prediction_string # noqa
 
 
@@ -1101,16 +1102,16 @@ def restrict_to_taxa_list(taxa_list,
                           output_file,
                           allow_walk_down=False,
                           add_pre_filtering_description=True,
-                          allow_redundant_latin_names=False):
+                          allow_redundant_latin_names=True,
+                          protected_common_names=None,
+                          use_original_common_names_if_available=True,
+                          verbose=True):
     """
     Given a prediction file in MD .json format, likely without having had
     a geofence applied, apply a custom taxa list.
 
     Args:
-        taxa_list (str or list): list of latin names, or a text file containing
-            a list of latin names.  Optionally may contain a second (comma-delimited)
-            column containing common names, used only for debugging.  Latin names
-            must exist in the SpeciesNet taxonomy.
+        taxa_list (str): .csv file with at least the columns "latin" and "common".
         speciesnet_taxonomy_file (str): taxonomy filename, in the same format used for
             model release (with 7-token taxonomy entries)
         input_file (str): .json file to read, in MD format.  This can be None, in which
@@ -1128,45 +1129,73 @@ def restrict_to_taxa_list(taxa_list,
             if the same latin name appears twice in the taxonomy list; if True, we'll
             just print a warning and ignore all entries other than the first for this
             latin name
+        protected_common_names (list, optional): these categories should be
+            unmodified, even if they aren't used, or have the same taxonomic
+            description as other categories
+        use_original_common_names_if_available (bool, optional): if an "original_common"
+            column is present in [taxa_list], use those common names instead of the ones
+            in the taxonomy file
+        verbose (bool, optional): enable additional debug output
     """
 
     ##%% Read target taxa list
 
-    if isinstance(taxa_list,str):
-        assert os.path.isfile(taxa_list), \
-            'Could not find taxa list file {}'.format(taxa_list)
-        with open(taxa_list,'r') as f:
-            taxa_list = f.readlines()
+    taxa_list_df = pd.read_csv(taxa_list)
 
-    taxa_list = [s.strip().lower() for s in taxa_list]
-    taxa_list = [s for s in taxa_list if len(s) > 0]
+    required_columns = ('latin','common')
+    for s in required_columns:
+        assert s in taxa_list_df.columns, \
+            'Required column {} missing from taxonomy list file {}'.format(
+                s,taxa_list)
 
+    # Convert the "latin" and "common" columns in taxa_list_df to lowercase
+    taxa_list_df['latin'] = taxa_list_df['latin'].str.lower()
+    taxa_list_df['common'] = taxa_list_df['common'].str.lower()
+
+    # Remove rows from taxa_list_df where the "latin" column is nan,
+    # printing a warning for each row (with a string representation of the whole row)
+    for i_row,row in taxa_list_df.iterrows():
+        if pd.isna(row['latin']):
+            if verbose:
+                print('Warning: Skipping row with empty "latin" column in {}:\n{}\n'.format(
+                    taxa_list,str(row.to_dict())))
+            taxa_list_df.drop(index=i_row, inplace=True)
+
+    # Convert all NaN values in the "common" column to empty strings
+    taxa_list_df['common'] = taxa_list_df['common'].fillna('')
+
+    # Create a dictionary mapping latin names to common names
     target_latin_to_common = {}
 
-    for s in taxa_list:
+    for i_row,row in taxa_list_df.iterrows():
 
-        if s.strip().startswith('#'):
-            continue
-        tokens = s.split(',')
-        # We allow additional columns now
-        # assert len(tokens) <= 2
-        binomial_name = tokens[0]
-        assert len(binomial_name.split(' ')) in (1,2,3), \
-            'Illegal binomial name in species list: {}'.format(binomial_name)
-        if len(tokens) > 0:
-            common_name = tokens[1].strip().lower()
-        else:
-            common_name = None
-        if binomial_name in target_latin_to_common:
-            error_string = 'scientific name {} appears multiple times in the taxonomy list'.format(
-                    binomial_name)
+        latin = row['latin']
+        common = row['common']
+
+        if use_original_common_names_if_available and \
+            ('original_common' in row) and \
+            (not is_empty(row['original_common'])):
+                common = row['original_common'].strip().lower()
+
+        # Valid latin names have either one token (e.g. "canidae"),
+        # two tokens (e.g. "bos taurus"), or three tokens (e.g. "canis lupus familiaris")
+        assert len(latin.split(' ')) in (1,2,3), \
+            'Illegal binomial name {} in taxaonomy list {}'.format(
+                latin,taxa_list)
+
+        if latin in target_latin_to_common:
+            error_string = \
+                'scientific name {} appears multiple times in the taxonomy list'.format(
+                latin)
             if allow_redundant_latin_names:
-                print('Warning: {}'.format(error_string))
+                if verbose:
+                    print('Warning: {}'.format(error_string))
             else:
                 raise ValueError(error_string)
-        target_latin_to_common[binomial_name] = common_name
 
-    # ...for each line in the taxonomy file
+        target_latin_to_common[latin] = common
+
+    # ...for each row in the custom taxonomy list
 
 
     ##%% Read taxonomy file
@@ -1185,7 +1214,7 @@ def restrict_to_taxa_list(taxa_list,
     def _insert_taxonomy_string(s):
 
         tokens = s.split(';')
-        assert len(tokens) == 7
+        assert len(tokens) == 7, 'Illegal taxonomy string {}'.format(s)
 
         guid = tokens[0] # noqa
         class_name = tokens[1]
@@ -1196,20 +1225,24 @@ def restrict_to_taxa_list(taxa_list,
         common_name = tokens[6]
 
         if len(class_name) == 0:
-            assert common_name in ('animal','vehicle','blank')
+            assert common_name in ('animal','vehicle','blank'), \
+                'Illegal common name {}'.format(common_name)
             return
 
         if len(species) > 0:
-            assert all([len(s) > 0 for s in [genus,family,order]])
+            assert all([len(s) > 0 for s in [genus,family,order]]), \
+                'Higher-level taxa missing for {}: {},{},{}'.format(s,genus,family,order)
             binomial_name = genus + ' ' + species
             if binomial_name not in speciesnet_latin_name_to_taxon_string:
                 speciesnet_latin_name_to_taxon_string[binomial_name] = s
         elif len(genus) > 0:
-            assert all([len(s) > 0 for s in [family,order]])
+            assert all([len(s) > 0 for s in [family,order]]), \
+                'Higher-level taxa missing for {}: {},{}'.format(s,family,order)
             if genus not in speciesnet_latin_name_to_taxon_string:
                 speciesnet_latin_name_to_taxon_string[genus] = s
         elif len(family) > 0:
-            assert len(order) > 0
+            assert len(order) > 0, \
+                'Higher-level taxa missing for {}: {}'.format(s,order)
             if family not in speciesnet_latin_name_to_taxon_string:
                 speciesnet_latin_name_to_taxon_string[family] = s
         elif len(order) > 0:
@@ -1232,12 +1265,19 @@ def restrict_to_taxa_list(taxa_list,
 
     # In theory any taxon that appears as the parent of another taxon should
     # also be in the taxonomy, but this isn't always true, so we fix it here.
-
     new_taxon_string_to_missing_tokens = defaultdict(list)
 
+    # While we're making this loop, also see whether we need to store any custom
+    # common name mappings based on the taxonomy list.
+    speciesnet_latin_name_to_output_common_name = {}
+
     # latin_name = next(iter(speciesnet_latin_name_to_taxon_string.keys()))
     for latin_name in speciesnet_latin_name_to_taxon_string.keys():
 
+        if latin_name in target_latin_to_common:
+            speciesnet_latin_name_to_output_common_name[latin_name] = \
+                target_latin_to_common[latin_name]
+
         if 'no cv result' in latin_name:
             continue
 
@@ -1260,7 +1300,8 @@ def restrict_to_taxa_list(taxa_list,
                 for i_copy_token in range(1,i_token+1):
                     new_tokens[i_copy_token] = tokens[i_copy_token]
                 new_tokens[-1] = test_token + ' species'
-                assert new_tokens[-2] == ''
+                assert new_tokens[-2] == '', \
+                    'Illegal taxonomy string {}'.format(taxon_string)
                 new_taxon_string = ';'.join(new_tokens)
                 # assert new_taxon_string not in new_taxon_strings
                 new_taxon_string_to_missing_tokens[new_taxon_string].append(test_token)
@@ -1269,14 +1310,19 @@ def restrict_to_taxa_list(taxa_list,
 
     # ...for each taxon
 
-    print('Found {} taxa that need to be inserted to make the taxonomy valid:\n'.format(
-        len(new_taxon_string_to_missing_tokens)))
-
     new_taxon_string_to_missing_tokens = \
         sort_dictionary_by_key(new_taxon_string_to_missing_tokens)
-    for taxon_string in new_taxon_string_to_missing_tokens:
-        missing_taxa = ','.join(new_taxon_string_to_missing_tokens[taxon_string])
-        print('{} ({})'.format(taxon_string,missing_taxa))
+
+    if verbose:
+
+        print(f'Found {len(new_taxon_string_to_missing_tokens)} taxa that need to be inserted to ' + \
+              'make the taxonomy valid, showing only mammals and birds here:\n')
+
+        for taxon_string in new_taxon_string_to_missing_tokens:
+            if 'mammalia' not in taxon_string and 'aves' not in taxon_string:
+                continue
+            missing_taxa = ','.join(new_taxon_string_to_missing_tokens[taxon_string])
+            print('{} ({})'.format(taxon_string,missing_taxa))
 
     for new_taxon_string in new_taxon_string_to_missing_tokens:
         _insert_taxonomy_string(new_taxon_string)
@@ -1298,7 +1344,7 @@ def restrict_to_taxa_list(taxa_list,
             n_failed_mappings += 1
 
     if n_failed_mappings > 0:
-        raise ValueError('Cannot continue with geofence generation')
+        raise ValueError('Cannot continue with taxonomic restriction')
 
 
     ##%% For the allow-list, map each parent taxon to a set of allowable child taxa
@@ -1312,7 +1358,8 @@ def restrict_to_taxa_list(taxa_list,
 
         taxon_string = speciesnet_latin_name_to_taxon_string[latin_name]
         tokens = taxon_string.split(';')
-        assert len(tokens) == 7
+        assert len(tokens) == 7, \
+            'Illegal taxonomy string {}'.format(taxon_string)
 
         # Remove GUID and common mame
         #
@@ -1324,25 +1371,85 @@ def restrict_to_taxa_list(taxa_list,
         # If this is a species
         if len(tokens[-1]) > 0:
             binomial_name = tokens[-2] + ' ' + tokens[-1]
-            assert binomial_name == latin_name
+            assert binomial_name == latin_name, \
+                'Binomial/latin mismatch: {} vs {}'.format(binomial_name,latin_name)
+            # If this already exists, it should only allow "None"
+            if binomial_name in allowed_parent_taxon_to_child_taxa:
+                assert len(allowed_parent_taxon_to_child_taxa[binomial_name]) == 1, \
+                    'Species-level entry {} has multiple children'.format(binomial_name)
+                assert None in allowed_parent_taxon_to_child_taxa[binomial_name], \
+                    'Species-level entry {} has non-None children'.format(binomial_name)
             allowed_parent_taxon_to_child_taxa[binomial_name].add(None)
             child_taxon = binomial_name
 
-        # The first candidate parent is the genus
+        # The first level that can ever be a parent taxon is the genus level
         parent_token_index = len(tokens) - 2
 
+        # Walk up from genus to family
         while(parent_token_index >= 0):
 
+            # "None" is our leaf node marker, we should never have ''
+            if child_taxon is not None:
+                assert len(child_taxon) > 0
+
             parent_taxon = tokens[parent_token_index]
-            allowed_parent_taxon_to_child_taxa[parent_taxon].add(child_taxon)
-            child_taxon = parent_taxon
+
+            # Don't create entries for blank taxa
+            if (len(parent_taxon) > 0):
+
+                create_child = True
+
+                # This is the lowest-level taxon in this entry
+                if (child_taxon is None):
+
+                    # ...but we don't want to remove existing children from any parents
+                    if (parent_taxon in allowed_parent_taxon_to_child_taxa) and \
+                       (len(allowed_parent_taxon_to_child_taxa[parent_taxon]) > 0):
+                        if verbose:
+                            existing_children_string = str(allowed_parent_taxon_to_child_taxa[parent_taxon])
+                            print('Not creating empty child for parent {} (already has children {})'.format(
+                                parent_taxon,existing_children_string))
+                        create_child = False
+
+                # If we're adding a new child entry, clear out any leaf node markers
+                else:
+
+                    if (parent_taxon in allowed_parent_taxon_to_child_taxa) and \
+                       (None in allowed_parent_taxon_to_child_taxa[parent_taxon]):
+
+                        assert len(allowed_parent_taxon_to_child_taxa[parent_taxon]) == 1, \
+                            'Illlegal parent/child configuration'
+
+                        if verbose:
+                            print('Un-marking parent {} as a leaf node because of child {}'.format(
+                                parent_taxon,child_taxon))
+
+                        allowed_parent_taxon_to_child_taxa[parent_taxon] = set()
+
+                if create_child:
+                    allowed_parent_taxon_to_child_taxa[parent_taxon].add(child_taxon)
+
+                # If we haven't hit a non-empty taxon yet, don't update "child_taxon"
+                assert len(parent_taxon) > 0
+                child_taxon = parent_taxon
+
+            # ...if we have a non-empty taxon
+
             parent_token_index -= 1
 
+        # ...for each taxonomic level
+
     # ...for each allowed latin name
 
     allowed_parent_taxon_to_child_taxa = \
         sort_dictionary_by_key(allowed_parent_taxon_to_child_taxa)
 
+    for parent_taxon in allowed_parent_taxon_to_child_taxa:
+        # "None" should only ever appear alone; this marks a leaf node with no children
+        if None in allowed_parent_taxon_to_child_taxa[parent_taxon]:
+            assert len(allowed_parent_taxon_to_child_taxa[parent_taxon]) == 1, \
+                '"None" should only appear alone in a child taxon list'
+
 
     ##%% If we were just validating the custom taxa file, we're done
 
@@ -1369,11 +1476,25 @@ def restrict_to_taxa_list(taxa_list,
 
         input_taxon_string = input_category_id_to_taxonomy_string[input_category_id]
         input_taxon_tokens = input_taxon_string.split(';')
-        assert len(input_taxon_tokens) == 7
+        assert len(input_taxon_tokens) == 7, \
+            'Illegal taxonomy string: {}'.format(input_taxon_string)
 
-        # Don't mess with blank/no-cv-result/animal/human
-        if (input_taxon_string in non_taxonomic_prediction_strings) or \
+        # Don't mess with blank/no-cv-result/human (or "animal", which is really "unknown")
+        if (not is_taxonomic_prediction_string(input_taxon_string)) or \
            (input_taxon_string == human_prediction_string):
+            if verbose:
+                print('Not messing with non-taxonomic category {}'.format(input_taxon_string))
+            input_category_id_to_output_taxon_string[input_category_id] = \
+                input_taxon_string
+            continue
+
+        # Don't mess with protected categories
+        common_name = input_taxon_tokens[-1]
+
+        if (protected_common_names is not None) and \
+            (common_name in protected_common_names):
+            if verbose:
+                print('Not messing with protected category {}'.format(common_name))
             input_category_id_to_output_taxon_string[input_category_id] = \
                 input_taxon_string
             continue
@@ -1403,19 +1524,23 @@ def restrict_to_taxa_list(taxa_list,
                 test_index -= 1
                 continue
 
-            assert test_taxon_name in speciesnet_latin_name_to_taxon_string
+            assert test_taxon_name in speciesnet_latin_name_to_taxon_string, \
+                '{} should be a substring of {}'.format(test_taxon_name,
+                                                        speciesnet_latin_name_to_taxon_string)
 
             # Is this taxon allowed according to the custom species list?
             if test_taxon_name in allowed_parent_taxon_to_child_taxa:
 
                 allowed_child_taxa = allowed_parent_taxon_to_child_taxa[test_taxon_name]
-                assert allowed_child_taxa is not None
+                assert allowed_child_taxa is not None, \
+                    'allowed_child_taxa should not be None: {}'.format(test_taxon_name)
 
                 # If this is the lowest-level allowable token or there is not a
                 # unique child, don't walk any further, even if walking down
                 # is enabled.
-                if (None in allowed_child_taxa):
-                    assert len(allowed_child_taxa) == 1
+                if None in allowed_child_taxa:
+                    assert len(allowed_child_taxa) == 1, \
+                        '"None" should not be listed as a child taxa with other child taxa'
 
                 if (None in allowed_child_taxa) or (len(allowed_child_taxa) > 1):
                     target_taxon = test_taxon_name
@@ -1427,8 +1552,12 @@ def restrict_to_taxa_list(taxa_list,
                     while ((next(iter(allowed_child_taxa)) is not None) and \
                           (len(allowed_child_taxa) == 1)):
                         candidate_taxon = next(iter(allowed_child_taxa))
-                        assert candidate_taxon in allowed_parent_taxon_to_child_taxa
-                        assert candidate_taxon in speciesnet_latin_name_to_taxon_string
+                        assert candidate_taxon in allowed_parent_taxon_to_child_taxa, \
+                            '{} should be a subset of {}'.format(
+                                candidate_taxon,allowed_parent_taxon_to_child_taxa)
+                        assert candidate_taxon in speciesnet_latin_name_to_taxon_string, \
+                            '{} should be a subset of {}'.format(
+                                candidate_taxon,speciesnet_latin_name_to_taxon_string)
                         allowed_child_taxa = \
                             allowed_parent_taxon_to_child_taxa[candidate_taxon]
                     target_taxon = candidate_taxon
@@ -1450,21 +1579,30 @@ def restrict_to_taxa_list(taxa_list,
 
     ##%% Build the new tables
 
+    speciesnet_taxon_string_to_latin_name = invert_dictionary(speciesnet_latin_name_to_taxon_string)
+
     input_category_id_to_output_category_id = {}
     output_taxon_string_to_category_id = {}
     output_category_id_to_common_name = {}
 
     for input_category_id in input_category_id_to_output_taxon_string:
 
-        original_common_name = \
-            input_category_id_to_common_name[input_category_id]
-        original_taxon_string = \
-            input_category_id_to_taxonomy_string[input_category_id]
         output_taxon_string = \
             input_category_id_to_output_taxon_string[input_category_id]
 
         output_common_name = output_taxon_string.split(';')[-1]
 
+        # Possibly substitute a custom common name
+        if output_taxon_string in speciesnet_taxon_string_to_latin_name:
+
+            speciesnet_latin_name = speciesnet_taxon_string_to_latin_name[output_taxon_string]
+
+            if speciesnet_latin_name in speciesnet_latin_name_to_output_common_name:
+                custom_common_name = speciesnet_latin_name_to_output_common_name[speciesnet_latin_name]
+                if custom_common_name != output_common_name:
+                    print('Substituting common name {} for {}'.format(custom_common_name,output_common_name))
+                    output_common_name = custom_common_name
+
         # Do we need to create a new output category?
         if output_taxon_string not in output_taxon_string_to_category_id:
             output_category_id = str(len(output_taxon_string_to_category_id))
@@ -1479,21 +1617,28 @@ def restrict_to_taxa_list(taxa_list,
         input_category_id_to_output_category_id[input_category_id] = \
             output_category_id
 
+        # Sometimes-useful debug printouts
         if False:
+            original_common_name = \
+              input_category_id_to_common_name[input_category_id]
+
+            original_taxon_string = \
+                input_category_id_to_taxonomy_string[input_category_id]
+
             print('Mapping {} ({}) to:\n{} ({})\n'.format(
                 original_common_name,original_taxon_string,
                 output_common_name,output_taxon_string))
-        if False:
             print('Mapping {} to {}'.format(
                 original_common_name,output_common_name,))
 
     # ...for each category
 
 
-    ##%% Remap all category labels
+    #%% Remap all category labels
 
     assert len(set(output_taxon_string_to_category_id.keys())) == \
-           len(set(output_taxon_string_to_category_id.values()))
+           len(set(output_taxon_string_to_category_id.values())), \
+           'Category ID/value non-uniqueness error'
 
     output_category_id_to_taxon_string = \
         invert_dictionary(output_taxon_string_to_category_id)

megadetector/utils/wi_taxonomy_utils.py

@@ -180,8 +180,10 @@ def taxonomy_level_index(s):
     if len(tokens) == 7:
         tokens = tokens[1:-1]
 
+    # Anything without a class is considered non-taxonomic
     if len(tokens[0]) == 0:
         return 0
+
     # WI taxonomy strings start at class, so we'll never return 1 (kingdom) or 2 (phylum)
     elif len(tokens[1]) == 0:
         return 3
@@ -198,6 +200,22 @@ def taxonomy_level_index(s):
         return 8
 
 
+def is_taxonomic_prediction_string(s):
+    """
+    Determines whether [s] is a classification string that has taxonomic properties; this
+    does not include, e.g., blanks/vehicles/no cv result.  It also excludes "animal".
+
+    Args:
+        s (str): a five- or seven-token taxonomic string
+
+    Returns:
+        bool: whether [s] is a taxonomic category
+    """
+
+    return (taxonomy_level_index(s) > 0)
+
+
+
 def get_kingdom(prediction_string):
     """
     Return the kingdom field from a WI prediction string

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

@@ -1,134 +1,134 @@
-Metadata-Version: 2.4
-Name: megadetector
-Version: 10.0.5
-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>
-License:     MIT License
-        
-            Permission is hereby granted, free of charge, to any person obtaining a copy
-            of this software and associated documentation files (the "Software"), to deal
-            in the Software without restriction, including without limitation the rights
-            to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-            copies of the Software, and to permit persons to whom the Software is
-            furnished to do so, subject to the following conditions:
-        
-            The above copyright notice and this permission notice shall be included in all
-            copies or substantial portions of the Software.
-        
-            THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-            IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-            FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-            AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-            LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-            OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-            SOFTWARE.
-        
-Project-URL: Homepage, https://github.com/agentmorris/MegaDetector
-Project-URL: Documentation, https://megadetector.readthedocs.io
-Project-URL: Bug Reports, https://github.com/agentmorris/MegaDetector/issues
-Project-URL: Source, https://github.com/agentmorris/MegaDetector
-Keywords: camera traps,conservation,wildlife,ai,megadetector
-Classifier: Programming Language :: Python :: 3
-Requires-Python: <3.14,>=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: mkl==2024.0; sys_platform != "darwin"
-Requires-Dist: numpy>=1.26.4
-Requires-Dist: Pillow>=9.5
-Requires-Dist: tqdm>=4.64.0
-Requires-Dist: jsonpickle>=3.0.2
-Requires-Dist: humanfriendly>=2.1
-Requires-Dist: matplotlib>=3.8.0
-Requires-Dist: opencv-python>=4.8.0
-Requires-Dist: requests>=2.31.0
-Requires-Dist: pyqtree>=1.0.0
-Requires-Dist: scikit-learn>=1.3.1
-Requires-Dist: pandas>=2.1.1
-Requires-Dist: python-dateutil
-Requires-Dist: send2trash
-Requires-Dist: clipboard
-Requires-Dist: dill
-Requires-Dist: ruff
-Requires-Dist: pytest
-Requires-Dist: ultralytics-yolov5==0.1.1
-Requires-Dist: yolov9pip==0.0.4
-Dynamic: license-file
-
-# MegaDetector
-
-This package is a pip-installable version of the support/inference code for [MegaDetector](https://github.com/agentmorris/MegaDetector/?tab=readme-ov-file#megadetector), an object detection model that helps conservation biologists spend less time doing boring things with camera trap images.  Complete documentation for this Python package is available at [megadetector.readthedocs.io](https://megadetector.readthedocs.io).
-
-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).
-
-If you don't want to run MegaDetector, and you just want to use the utilities in this package - postprocessing, manipulating large volumes of camera trap images, etc. - you may want to check out the [megadetector-utils](https://pypi.org/project/megadetector-utils/) package, which is identical to this one, but excludes all of the PyTorch/YOLO dependencies, and is thus approximately one zillion times smaller.
-
-## Installation
-
-Install with:
-
-`pip install megadetector`
-
-MegaDetector model weights aren't downloaded at the time you install the package, but they will be (optionally) automatically downloaded the first time you run the model.
-
-## Package reference
-
-See [megadetector.readthedocs.io](https://megadetector.readthedocs.io).
-
-
-## Examples of things you can do with this package
-
-### Run MegaDetector on one image and count the number of detections
-
-```
-from megadetector.utils import url_utils
-from megadetector.visualization import visualization_utils as vis_utils
-from megadetector.detection import run_detector
-
-# This is the image at the bottom of this page, it has one animal in it
-image_url = 'https://github.com/agentmorris/MegaDetector/raw/main/images/orinoquia-thumb-web.jpg'
-temporary_filename = url_utils.download_url(image_url)
-
-image = vis_utils.load_image(temporary_filename)
-
-# This will automatically download MDv5a; you can also specify a filename.
-model = run_detector.load_detector('MDV5A')
-
-result = model.generate_detections_one_image(image)
-
-detections_above_threshold = [d for d in result['detections'] if d['conf'] > 0.2]
-print('Found {} detections above threshold'.format(len(detections_above_threshold)))
-```
-
-### Run MegaDetector on a folder of images
-
-```
-from megadetector.detection.run_detector_batch import \
-    load_and_run_detector_batch, write_results_to_file
-from megadetector.utils import path_utils
-import os
-
-# Pick a folder to run MD on recursively, and an output file
-image_folder = os.path.expanduser('~/megadetector_test_images')
-output_file = os.path.expanduser('~/megadetector_output_test.json')
-
-# Recursively find images
-image_file_names = path_utils.find_images(image_folder,recursive=True)
-
-# This will automatically download MDv5a; you can also specify a filename.
-results = load_and_run_detector_batch('MDV5A', image_file_names)
-
-# Write results to a format that Timelapse and other downstream tools like.
-write_results_to_file(results,
-                      output_file,
-                      relative_path_base=image_folder,
-                      detector_file=detector_filename)
-```
-
-## Contact
-
-Contact <a href="cameratraps@lila.science">cameratraps@lila.science</a> with questions.
-
-## Gratuitous animal picture
-
-<img src="https://github.com/agentmorris/MegaDetector/raw/main/images/orinoquia-thumb-web_detections.jpg"><br/>Image credit University of Minnesota, from the [Orinoquía Camera Traps](http://lila.science/datasets/orinoquia-camera-traps/) data set.
+Metadata-Version: 2.4
+Name: megadetector
+Version: 10.0.7
+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>
+License:     MIT License
+        
+            Permission is hereby granted, free of charge, to any person obtaining a copy
+            of this software and associated documentation files (the "Software"), to deal
+            in the Software without restriction, including without limitation the rights
+            to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+            copies of the Software, and to permit persons to whom the Software is
+            furnished to do so, subject to the following conditions:
+        
+            The above copyright notice and this permission notice shall be included in all
+            copies or substantial portions of the Software.
+        
+            THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+            IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+            FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+            AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+            LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+            OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+            SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/agentmorris/MegaDetector
+Project-URL: Documentation, https://megadetector.readthedocs.io
+Project-URL: Bug Reports, https://github.com/agentmorris/MegaDetector/issues
+Project-URL: Source, https://github.com/agentmorris/MegaDetector
+Keywords: camera traps,conservation,wildlife,ai,megadetector
+Classifier: Programming Language :: Python :: 3
+Requires-Python: <3.14,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mkl==2024.0; sys_platform != "darwin"
+Requires-Dist: numpy>=1.26.4
+Requires-Dist: Pillow>=9.5
+Requires-Dist: tqdm>=4.64.0
+Requires-Dist: jsonpickle>=3.0.2
+Requires-Dist: humanfriendly>=2.1
+Requires-Dist: matplotlib>=3.8.0
+Requires-Dist: opencv-python>=4.8.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: pyqtree>=1.0.0
+Requires-Dist: scikit-learn>=1.3.1
+Requires-Dist: pandas>=2.1.1
+Requires-Dist: python-dateutil
+Requires-Dist: send2trash
+Requires-Dist: clipboard
+Requires-Dist: dill
+Requires-Dist: ruff
+Requires-Dist: pytest
+Requires-Dist: ultralytics-yolov5==0.1.1
+Requires-Dist: yolov9pip==0.0.4
+Dynamic: license-file
+
+# MegaDetector
+
+This package is a pip-installable version of the support/inference code for [MegaDetector](https://github.com/agentmorris/MegaDetector/?tab=readme-ov-file#megadetector), an object detection model that helps conservation biologists spend less time doing boring things with camera trap images.  Complete documentation for this Python package is available at [megadetector.readthedocs.io](https://megadetector.readthedocs.io).
+
+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).
+
+If you don't want to run MegaDetector, and you just want to use the utilities in this package - postprocessing, manipulating large volumes of camera trap images, etc. - you may want to check out the [megadetector-utils](https://pypi.org/project/megadetector-utils/) package, which is identical to this one, but excludes all of the PyTorch/YOLO dependencies, and is thus approximately one zillion times smaller.
+
+## Installation
+
+Install with:
+
+`pip install megadetector`
+
+MegaDetector model weights aren't downloaded at the time you install the package, but they will be (optionally) automatically downloaded the first time you run the model.
+
+## Package reference
+
+See [megadetector.readthedocs.io](https://megadetector.readthedocs.io).
+
+
+## Examples of things you can do with this package
+
+### Run MegaDetector on one image and count the number of detections
+
+```
+from megadetector.utils import url_utils
+from megadetector.visualization import visualization_utils as vis_utils
+from megadetector.detection import run_detector
+
+# This is the image at the bottom of this page, it has one animal in it
+image_url = 'https://github.com/agentmorris/MegaDetector/raw/main/images/orinoquia-thumb-web.jpg'
+temporary_filename = url_utils.download_url(image_url)
+
+image = vis_utils.load_image(temporary_filename)
+
+# This will automatically download MDv5a; you can also specify a filename.
+model = run_detector.load_detector('MDV5A')
+
+result = model.generate_detections_one_image(image)
+
+detections_above_threshold = [d for d in result['detections'] if d['conf'] > 0.2]
+print('Found {} detections above threshold'.format(len(detections_above_threshold)))
+```
+
+### Run MegaDetector on a folder of images
+
+```
+from megadetector.detection.run_detector_batch import \
+    load_and_run_detector_batch, write_results_to_file
+from megadetector.utils import path_utils
+import os
+
+# Pick a folder to run MD on recursively, and an output file
+image_folder = os.path.expanduser('~/megadetector_test_images')
+output_file = os.path.expanduser('~/megadetector_output_test.json')
+
+# Recursively find images
+image_file_names = path_utils.find_images(image_folder,recursive=True)
+
+# This will automatically download MDv5a; you can also specify a filename.
+results = load_and_run_detector_batch('MDV5A', image_file_names)
+
+# Write results to a format that Timelapse and other downstream tools like.
+write_results_to_file(results,
+                      output_file,
+                      relative_path_base=image_folder,
+                      detector_file=detector_filename)
+```
+
+## Contact
+
+Contact <a href="cameratraps@lila.science">cameratraps@lila.science</a> with questions.
+
+## Gratuitous animal picture
+
+<img src="https://github.com/agentmorris/MegaDetector/raw/main/images/orinoquia-thumb-web_detections.jpg"><br/>Image credit University of Minnesota, from the [Orinoquía Camera Traps](http://lila.science/datasets/orinoquia-camera-traps/) data set.

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

@@ -72,7 +72,7 @@ megadetector/data_management/lila/lila_common.py,sha256=IRWs46TrxcjckLidDwXPmb5O
 megadetector/data_management/lila/test_lila_metadata_urls.py,sha256=ThU78Ks5V3rFyJSKStFcM5M2yTlhR_pgMTa6_KuF5Hs,5256
 megadetector/detection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 megadetector/detection/change_detection.py,sha256=Ne3GajbH_0KPBU8ruHp4Rkr0uKd5oKAMQ3CQTRKRHgQ,28659
-megadetector/detection/process_video.py,sha256=iE-TA42IhrVwl3ftZ12mgaWv5CuttsI5SsivxSzpRiY,17498
+megadetector/detection/process_video.py,sha256=kuQHrpOC3LQo9ecqJPpzkds9fZVnoLmrfJw_yh-oxi8,17890
 megadetector/detection/pytorch_detector.py,sha256=ixU-2_AnCwEP33FaaqTZRoi1WxIUeM4x_ksbNT-tezA,59817
 megadetector/detection/run_detector.py,sha256=TTX29zxDN_O7ja61sOmMIVewUz3yRvKg1D1AAYhVEkc,46851
 megadetector/detection/run_detector_batch.py,sha256=aZgiywL6arrdQ_l3jzlHctlccqL537lwVStjhi1hIWw,89823
@@ -80,11 +80,11 @@ megadetector/detection/run_inference_with_yolov5_val.py,sha256=A-AQuARVVy7oR9Wte
 megadetector/detection/run_md_and_speciesnet.py,sha256=Dp_SpJZp0pX9jzFtxM6zPCyBNq49uyQpMDAdNDLVorM,50280
 megadetector/detection/run_tiled_inference.py,sha256=wrQkKIloHBO9v2i0nZ1_Tt75iFtVrnco3Y4FafoVxdw,39382
 megadetector/detection/tf_detector.py,sha256=3b2MiqgMw8KBDzHQliUSDXWrmKpa9iZnfe6EgYpMcYo,8398
-megadetector/detection/video_utils.py,sha256=JkCTK1-aNmLDHOEvlI1w5KS2ZssSdgzerLIUE8iX2_I,49785
+megadetector/detection/video_utils.py,sha256=AlmNJ5n7qmv3Z65HcjI1ALAxXMmyTG3pUiO7oJm-8rs,53363
 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=klHi5OFQx0LTQntg384llZeSmrxUWEm2HJQmEU-sG8U,60710
+megadetector/postprocessing/classification_postprocessing.py,sha256=TrhzjMWkoLs4ml0ObCKR7rUpprbT7sgS6RtyjPicj9A,68362
 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
@@ -131,7 +131,7 @@ megadetector/utils/split_locations_into_train_val.py,sha256=fd_6pj1aWY6hybwaXvBn
 megadetector/utils/string_utils.py,sha256=r2Maw3zbzk3EyaZcNkdqr96yP_8m4ey6v0WxlemEY9U,6155
 megadetector/utils/url_utils.py,sha256=VWYDHbWctTtw7mvbb_A5DTdF3v9V2mWhBoOP5MGE5S8,25728
 megadetector/utils/wi_platform_utils.py,sha256=8CGpiox_aL6RVZKfJqPVwpW4_6Cjku0HIajJPcmeNpE,32019
-megadetector/utils/wi_taxonomy_utils.py,sha256=VTlWqZqNBplpvTvg7E_tCh88RdG_wf-6jE6ahU7GOuI,66173
+megadetector/utils/wi_taxonomy_utils.py,sha256=vZ_UlRtyLpfF4-ehBt7HHjcj7PsI2dVWFz2tES9cxt4,66641
 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
@@ -140,8 +140,8 @@ megadetector/visualization/visualization_utils.py,sha256=E5uvysS3F1S_yiPFxZty3U2
 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.5.dist-info/licenses/LICENSE,sha256=RMa3qq-7Cyk7DdtqRj_bP1oInGFgjyHn9-PZ3PcrqIs,1100
-megadetector-10.0.5.dist-info/METADATA,sha256=i5TpLpLfLxIXO5brvz7yqqKlZ3K5mnvHfoeXExTJCXI,6352
-megadetector-10.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-megadetector-10.0.5.dist-info/top_level.txt,sha256=wf9DXa8EwiOSZ4G5IPjakSxBPxTDjhYYnqWRfR-zS4M,13
-megadetector-10.0.5.dist-info/RECORD,,
+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,,