megadetector 5.0.29__py3-none-any.whl → 10.0.0__py3-none-any.whl

megadetector/utils/split_locations_into_train_val.py

@@ -64,8 +64,8 @@ def split_locations_into_train_val(location_to_category_counts,
         default_max_allowable_error (float, optional): the maximum allowable error for categories not
             present in [category_to_max_allowable_error].  Set to None (or >= 1.0) to disable hard
             constraints for categories not present in [category_to_max_allowable_error]
-        require_complete_coverage (bool, optional): require that every category appear in both train and
-            val
+        require_complete_coverage (bool, optional): require that every category appear in both train
+            and val
 
     Returns:
         tuple: A two-element tuple:

megadetector/utils/string_utils.py

@@ -26,7 +26,7 @@ def is_float(s):
 
     if s is None:
         return False
-    
+
     try:
         _ = float(s)
     except ValueError:
@@ -53,7 +53,7 @@ def human_readable_to_bytes(size):
 
     if not size: # Handle empty string case after stripping spaces
         return 0
-        
+
     if (size[-1] == 'B'):
         size = size[:-1]
 
@@ -70,7 +70,7 @@ def human_readable_to_bytes(size):
         # Need to separate numeric part from unit more carefully.
         numeric_part = ''
         unit_part = ''
-        
+
         # Iterate from the end to find the unit (K, M, G, T)
         # This handles cases like "10KB" or "2.5GB"
         for i in range(len(size) -1, -1, -1):
@@ -79,7 +79,7 @@ def human_readable_to_bytes(size):
             else:
                 numeric_part = size[:i+1]
                 break
-        
+
         # If no unit found, or numeric part is empty after stripping unit
         if not unit_part or not numeric_part:
             return 0
@@ -97,8 +97,8 @@ def human_readable_to_bytes(size):
                 bytes_val *= 1024
             else:
                 # If it's a known unit (like 'B' already stripped) but not T/G/M/K,
-                # and it was floatable, it's just bytes.  If it's an unknown unit, it's 
-				# an error.
+                # and it was floatable, it's just bytes.  If it's an unknown unit, it's
+                # an error.
                 if unit not in ['B', '']: # 'B' was stripped, '' means just a number
                      bytes_val = 0
         except ValueError:
@@ -165,7 +165,7 @@ class TestStringUtils:
         assert human_readable_to_bytes("1GB") == 1024*1024*1024
         assert human_readable_to_bytes("1T") == 1024*1024*1024*1024
         assert human_readable_to_bytes("1TB") == 1024*1024*1024*1024
-        
+
         assert human_readable_to_bytes("2.5K") == 2.5 * 1024
         assert human_readable_to_bytes("0.5MB") == 0.5 * 1024 * 1024
 

megadetector/utils/url_utils.py

@@ -13,9 +13,8 @@ import re
 import urllib
 import urllib.request
 import urllib.error
-import tempfile
-import requests 
-import shutil 
+import requests
+import shutil
 import pytest
 
 from functools import partial
@@ -53,7 +52,7 @@ class DownloadProgressBar:
                 self.pbar = progressbar.ProgressBar(max_value=total_size)
                 self.pbar.start()
             except ImportError:
-                self.pbar = None 
+                self.pbar = None
                 # print("ProgressBar not available, install 'progressbar2' for visual progress.")
 
         if self.pbar:
@@ -108,9 +107,9 @@ def download_url(url,
 
         # This does not guarantee uniqueness, hence "semi-best-effort"
         url_as_filename = re.sub(r'\W+', '', url_without_sas)
-        
+
         n_folder_chars = len(target_folder)
-        
+
         if (len(url_as_filename) + n_folder_chars) >= max_path_len:
             print('Warning: truncating filename target to {} characters'.format(max_path_len))
             max_fn_len = max_path_len - (n_folder_chars + 1)
@@ -202,15 +201,18 @@ def _do_parallelized_download(download_info,overwrite=False,verbose=False):
 # ...def _do_parallelized_download(...)
 
 
-def parallel_download_urls(url_to_target_file, verbose=False, overwrite=False,
-                           n_workers=20, pool_type='thread'):
+def parallel_download_urls(url_to_target_file,
+                           verbose=False,
+                           overwrite=False,
+                           n_workers=20,
+                           pool_type='thread'):
     """
     Downloads a list of URLs to local files.
 
     Catches exceptions and reports them in the returned "results" array.
 
     Args:
-        url_to_target_file: a dict mapping URLs to local filenames.
+        url_to_target_file (dict): a dict mapping URLs to local filenames.
         verbose (bool, optional): enable additional debug console output
         overwrite (bool, optional): whether to overwrite existing local files
         n_workers (int, optional): number of concurrent workers, set to <=1 to disable
@@ -229,7 +231,7 @@ def parallel_download_urls(url_to_target_file, verbose=False, overwrite=False,
 
     if verbose:
         print('Preparing download list')
-    for url in tqdm(url_to_target_file, disable=(not verbose)): 
+    for url in tqdm(url_to_target_file, disable=(not verbose)):
         download_info = {}
         download_info['url'] = url
         download_info['target_file'] = url_to_target_file[url]
@@ -341,7 +343,7 @@ def test_urls(urls,error_on_failure=True,n_workers=1,pool_type='thread',timeout=
             else:
                 assert pool_type == 'process', 'Unsupported pool type {}'.format(pool_type)
                 pool = Pool(n_workers)
-            
+
             if verbose:
                 print('Starting a {} pool with {} workers'.format(pool_type,n_workers))
 
@@ -439,7 +441,7 @@ def get_url_sizes(urls,n_workers=1,pool_type='thread',timeout=None,verbose=False
             file_sizes = list(tqdm(pool.imap(
                 partial(get_url_size,verbose=verbose,timeout=timeout),
                 urls), total=len(urls), disable=(not verbose)))
-            
+
             for i_url,url in enumerate(urls):
                 url_to_size[url] = file_sizes[i_url]
         finally:
@@ -456,8 +458,8 @@ def get_url_sizes(urls,n_workers=1,pool_type='thread',timeout=None,verbose=False
 # Constants for tests
 
 SMALL_FILE_URL = "https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png"
-REDIRECT_SRC_URL = "http://google.com" 
-REDIRECT_DEST_URL = "https://www.google.com/" 
+REDIRECT_SRC_URL = "http://google.com"
+REDIRECT_DEST_URL = "https://www.google.com/"
 NON_EXISTENT_URL = "https://example.com/non_existent_page_404.html"
 DEFINITELY_NON_EXISTENT_DOMAIN_URL = "https://thisshouldnotexist1234567890.com/file.txt"
 RELATIVE_DOWNLOAD_URL = "https://raw.githubusercontent.com/agentmorris/MegaDetector/main/README.md"
@@ -470,13 +472,12 @@ class TestUrlUtils:
     Tests for url_utils.py
     """
 
-
     def set_up(self):
         """
         Create a temporary directory for testing.
         """
 
-        self.test_dir = make_test_folder(subfolder='url_utils_tests')        
+        self.test_dir = make_test_folder(subfolder='url_utils_tests')
         self.download_target_dir = os.path.join(self.test_dir, 'downloads')
         os.makedirs(self.download_target_dir, exist_ok=True)
 
@@ -488,7 +489,7 @@ class TestUrlUtils:
 
         if os.path.exists(self.test_dir):
             shutil.rmtree(self.test_dir)
-        
+
 
     def test_download_url_to_specified_file(self):
         """
@@ -496,7 +497,9 @@ class TestUrlUtils:
         """
 
         dest_filename = os.path.join(self.download_target_dir, "downloaded_google_logo.png")
-        returned_filename = download_url(SMALL_FILE_URL, destination_filename=dest_filename, verbose=False)
+        returned_filename = download_url(SMALL_FILE_URL,
+                                         destination_filename=dest_filename,
+                                         verbose=False)
         assert returned_filename == dest_filename
         assert os.path.exists(dest_filename)
         assert os.path.getsize(dest_filename) > 1000
@@ -507,10 +510,12 @@ class TestUrlUtils:
         Test download_url when destination_filename is None.
         """
 
-        returned_filename = download_url(SMALL_FILE_URL, destination_filename=None, verbose=False)
+        returned_filename = download_url(SMALL_FILE_URL,
+                                         destination_filename=None,
+                                         verbose=False)
         assert os.path.exists(returned_filename)
         assert os.path.getsize(returned_filename) > 1000
-        
+
 
     def test_download_url_non_existent(self):
         """
@@ -520,17 +525,19 @@ class TestUrlUtils:
         dest_filename = os.path.join(self.download_target_dir, "non_existent.html")
         try:
             download_url(NON_EXISTENT_URL, destination_filename=dest_filename, verbose=False)
-            assert False, "urllib.error.HTTPError not raised for 404"
+            raise AssertionError("urllib.error.HTTPError not raised for 404")
         except urllib.error.HTTPError:
             pass
-        
+
         try:
-            download_url(DEFINITELY_NON_EXISTENT_DOMAIN_URL, destination_filename=dest_filename, verbose=False)
-            assert False, \
-                "urllib.error.URLError or requests.exceptions.ConnectionError not raised for DNS failure"
-        except urllib.error.URLError: 
+            download_url(DEFINITELY_NON_EXISTENT_DOMAIN_URL,
+                         destination_filename=dest_filename,
+                         verbose=False)
+            raise AssertionError(
+                "urllib.error.URLError or requests.exceptions.ConnectionError not raised for DNS failure")
+        except urllib.error.URLError:
             pass
-        except requests.exceptions.ConnectionError: 
+        except requests.exceptions.ConnectionError:
             pass
 
 
@@ -540,15 +547,18 @@ class TestUrlUtils:
         """
 
         dest_filename = os.path.join(self.download_target_dir, "force_test.png")
-        
+
         download_url(SMALL_FILE_URL, destination_filename=dest_filename, verbose=False)
         assert os.path.exists(dest_filename)
         initial_mtime = os.path.getmtime(dest_filename)
 
-        download_url(SMALL_FILE_URL, destination_filename=dest_filename, verbose=True) 
+        download_url(SMALL_FILE_URL, destination_filename=dest_filename, verbose=True)
         assert os.path.getmtime(dest_filename) == initial_mtime
 
-        download_url(SMALL_FILE_URL, destination_filename=dest_filename, force_download=True, verbose=False)
+        download_url(SMALL_FILE_URL,
+                     destination_filename=dest_filename,
+                     force_download=True,
+                     verbose=False)
         assert os.path.exists(dest_filename)
 
 
@@ -558,7 +568,10 @@ class TestUrlUtils:
         """
 
         dest_filename = os.path.join(self.download_target_dir, "escape_test.png")
-        download_url(SMALL_FILE_URL, destination_filename=dest_filename, escape_spaces=True, verbose=False)
+        download_url(SMALL_FILE_URL,
+                     destination_filename=dest_filename,
+                     escape_spaces=True,
+                     verbose=False)
         assert os.path.exists(dest_filename)
 
 
@@ -567,7 +580,7 @@ class TestUrlUtils:
         Test download_relative_filename.
         """
 
-        output_base = os.path.join(self.download_target_dir, "relative_dl")        
+        output_base = os.path.join(self.download_target_dir, "relative_dl")
         returned_filename = download_relative_filename(RELATIVE_DOWNLOAD_URL, output_base, verbose=False)
         assert RELATIVE_DOWNLOAD_CONTAIN_TOKEN in returned_filename
         assert RELATIVE_DOWNLOAD_NOT_CONTAIN_TOKEN not in returned_filename
@@ -582,32 +595,38 @@ class TestUrlUtils:
 
         url1_target = os.path.join(self.download_target_dir, "parallel_dl_1.png")
         url2_target = os.path.join(self.download_target_dir, "parallel_dl_2_nonexistent.html")
-        
+
         url_to_target_file = {
             SMALL_FILE_URL: url1_target,
             NON_EXISTENT_URL: url2_target
         }
-        
+
         results = parallel_download_urls(url_to_target_file, n_workers=1, verbose=False)
-        
+
         assert len(results) == 2
-        
+
         status_map = {res['url']: res for res in results}
-        
+
         assert status_map[SMALL_FILE_URL]['status'] == 'success'
         assert status_map[SMALL_FILE_URL]['target_file'] == url1_target
         assert os.path.exists(url1_target)
-        
+
         assert status_map[NON_EXISTENT_URL]['status'].startswith('error: HTTP Error 404')
         assert status_map[NON_EXISTENT_URL]['target_file'] == url2_target
         assert not os.path.exists(url2_target)
 
         if not os.path.exists(url1_target):
              download_url(SMALL_FILE_URL, url1_target, verbose=False)
-        results_skip = parallel_download_urls({SMALL_FILE_URL: url1_target}, n_workers=1, overwrite=False, verbose=True)
+        results_skip = parallel_download_urls({SMALL_FILE_URL: url1_target},
+                                              n_workers=1,
+                                              overwrite=False,
+                                              verbose=True)
         assert results_skip[0]['status'] == 'skipped'
 
-        results_overwrite = parallel_download_urls({SMALL_FILE_URL: url1_target}, n_workers=1, overwrite=True, verbose=False)
+        results_overwrite = parallel_download_urls({SMALL_FILE_URL: url1_target},
+                                                   n_workers=1,
+                                                   overwrite=True,
+                                                   verbose=False)
         assert results_overwrite[0]['status'] == 'success'
 
 
@@ -620,20 +639,22 @@ class TestUrlUtils:
         assert test_url(REDIRECT_SRC_URL, error_on_failure=False, timeout=10) in (200,301)
 
         status_non_existent = test_url(NON_EXISTENT_URL, error_on_failure=False, timeout=5)
-        assert status_non_existent == 404 
-        
+        assert status_non_existent == 404
+
         try:
             test_url(NON_EXISTENT_URL, error_on_failure=True, timeout=5)
-            assert False, "ValueError not raised for NON_EXISTENT_URL"
+            raise AssertionError("ValueError not raised for NON_EXISTENT_URL")
         except ValueError:
             pass
 
         try:
-            test_url(DEFINITELY_NON_EXISTENT_DOMAIN_URL, error_on_failure=True, timeout=5)
-            assert False, "requests.exceptions.ConnectionError or urllib.error.URLError not raised"
-        except requests.exceptions.ConnectionError: 
+            test_url(DEFINITELY_NON_EXISTENT_DOMAIN_URL,
+                     error_on_failure=True,
+                     timeout=5)
+            raise AssertionError("requests.exceptions.ConnectionError or urllib.error.URLError not raised")
+        except requests.exceptions.ConnectionError:
             pass
-        except urllib.error.URLError: 
+        except urllib.error.URLError:
             pass
 
 
@@ -645,10 +666,10 @@ class TestUrlUtils:
 
         try:
             test_urls(urls_to_test, error_on_failure=True, n_workers=1, timeout=5)
-            assert False, "ValueError not raised for urls_to_test"
+            raise AssertionError("ValueError not raised for urls_to_test")
         except ValueError:
             pass
-            
+
         good_urls = [SMALL_FILE_URL, REDIRECT_SRC_URL]
         good_status_codes = test_urls(good_urls, error_on_failure=True, n_workers=1, timeout=10)
         assert good_status_codes == [200, 200]
@@ -661,34 +682,36 @@ class TestUrlUtils:
 
         size = get_url_size(SMALL_FILE_URL, timeout=10)
         assert size is not None
-        assert size > 1000 
+        assert size > 1000
 
         size_dynamic = get_url_size(REDIRECT_DEST_URL, timeout=10, verbose=True)
         if size_dynamic is not None:
             assert isinstance(size_dynamic, int)
-        
+
         size_non_existent = get_url_size(NON_EXISTENT_URL, timeout=5)
         assert size_non_existent is None
-        
+
         size_bad_domain = get_url_size(DEFINITELY_NON_EXISTENT_DOMAIN_URL, timeout=5)
         assert size_bad_domain is None
 
         urls_for_size = [SMALL_FILE_URL, NON_EXISTENT_URL, REDIRECT_DEST_URL]
         sizes_map = get_url_sizes(urls_for_size, n_workers=1, timeout=10)
-        
+
         assert SMALL_FILE_URL in sizes_map
-        assert sizes_map[SMALL_FILE_URL] == size 
-        
+        assert sizes_map[SMALL_FILE_URL] == size
+
         assert NON_EXISTENT_URL in sizes_map
         assert sizes_map[NON_EXISTENT_URL] is None
-        
+
         assert REDIRECT_DEST_URL in sizes_map
         assert sizes_map[REDIRECT_DEST_URL] == size_dynamic
 
 
-def test_url_utils():
+def _test_url_utils():
     """
-    Runs all tests in the TestUrlUtils class.
+    Runs all tests in the TestUrlUtils class.  I generally disable this during testing
+    because it creates irritating nondeterminism, and this is neither a core module nor
+    a module that changes often.
     """
 
     test_instance = TestUrlUtils()

megadetector/utils/wi_utils.py

@@ -465,8 +465,9 @@ def write_download_commands(image_records_to_download,
         force_download (bool, optional): include gs commands even if the target file exists
         n_download_workers (int, optional): number of scripts to write (that's our hacky way
             of controlling parallelization)
-        download_command_file (str, optional): path of the .sh script we should write, defaults
-            to "download_wi_images.sh" in the destination folder
+        download_command_file_base (str, optional): path of the .sh script we should write, defaults
+            to "download_wi_images.sh" in the destination folder.  Individual worker scripts will
+            have a number added, e.g. download_wi_images_00.sh.
     """
 
     if isinstance(image_records_to_download,dict):
@@ -1069,7 +1070,7 @@ def generate_whole_image_detections_for_classifications(classifications_json_fil
                                                         ensemble_json_file=None,
                                                         ignore_blank_classifications=True):
     """
-    Given a set of classification results in SpeciesNet format that were likely run on 
+    Given a set of classification results in SpeciesNet format that were likely run on
     already-cropped images, generate a file of [fake] detections in SpeciesNet format in which each
     image is covered in a single whole-image detection.
 
@@ -1485,6 +1486,8 @@ def generate_instances_json_from_folder(folder,
     Args:
         folder (str): the folder to recursively search for images
         country (str, optional): a three-letter country code
+        admin1_region (str, optional): an administrative region code, typically a two-letter
+            US state code
         lat (float, optional): latitude to associate with all images
         lon (float, optional): longitude to associate with all images
         output_file (str, optional): .json file to which we should write instance records
@@ -1590,8 +1593,8 @@ def merge_prediction_json_files(input_prediction_files,output_prediction_file):
     Merge all predictions.json files in [files] into a single .json file.
 
     Args:
-        files (list): list of predictions.json files to merge
-        output_file (str): output .json file
+        input_prediction_files (list): list of predictions.json files to merge
+        output_prediction_file (str): output .json file
     """
 
     predictions = []
@@ -2074,8 +2077,7 @@ def generate_csv_rows_for_species(species_string,
                                   allow_countries=None,
                                   block_countries=None,
                                   allow_states=None,
-                                  block_states=None,
-                                  blockexcept_countries=None):
+                                  block_states=None):
     """
     Generate rows in the format expected by geofence_fixes.csv, representing a list of
     allow and/or block rules for the specified species and countries/states.  Does not check
@@ -2084,13 +2086,13 @@ def generate_csv_rows_for_species(species_string,
 
     Args:
         species_string (str): five-token string in semicolon-delimited WI taxonomy format
-        allow_countries (optional, list or str): three-letter country codes, list of
+        allow_countries (list or str, optional): three-letter country codes, list of
             country codes, or comma-separated list of country codes to allow
-        block_countries (optional, list or str): three-letter country codes, list of
+        block_countries (list or str, optional): three-letter country codes, list of
             country codes, or comma-separated list of country codes to block
-        allow_states (optional, list or str): two-letter state codes, list of
+        allow_states (list or str, optional): two-letter state codes, list of
             state codes, or comma-separated list of state codes to allow
-        block_states (optional, list or str): two-letter state code, list of
+        block_states (list or str, optional): two-letter state code, list of
             state codes, or comma-separated list of state codes to block
 
     Returns:
@@ -2502,6 +2504,31 @@ if False:
     initialize_geofencing(geofencing_file, country_code_file, force_init=True)
     initialize_taxonomy_info(taxonomy_file, force_init=True, encoding=encoding)
 
+    from megadetector.utils.path_utils import open_file; open_file(geofencing_file)
+
+
+    #%% Generate a block list
+
+    taxon_name = 'cercopithecidae'
+    taxonomy_info = binomial_name_to_taxonomy_info[taxon_name]
+    taxonomy_string_short = taxonomy_info_to_taxonomy_string(taxonomy_info)
+    assert len(taxonomy_string_short.split(';')) == 5
+
+    block_list = 'ATG,BHS,BRB,BLZ,CAN,CRI,CUB,DMA,DOM,SLV,GRD,GTM,HTI,HND,JAM,' + \
+                 'MEX,NIC,PAN,KNA,LCA,VCT,TTO,USA,ARG,BOL,BRA,CHL,COL,ECU,GUY,PRY,PER,' + \
+                 'SUR,URY,VEN,ALB,AND,ARM,AUT,AZE,BLR,BEL,BIH,BGR,HRV,CYP,CZE,DNK,EST,FIN,' + \
+                 'FRA,GEO,DEU,GRC,HUN,ISL,IRL,ITA,KAZ,XKX,LVA,LIE,LTU,LUX,MLT,MDA,MCO,MNE,' + \
+                 'NLD,MKD,NOR,POL,PRT,ROU,RUS,SMR,SRB,SVK,SVN,ESP,SWE,CHE,TUR,UKR,GBR,VAT,AUS'
+
+    rows = generate_csv_rows_for_species(species_string=taxonomy_string_short,
+                                         allow_countries=None,
+                                         block_countries=block_list,
+                                         allow_states=None,
+                                         block_states=None)
+
+    # import clipboard; clipboard.copy('\n'.join(rows))
+    print(rows)
+
 
     #%% Generate a block-except list
 
@@ -2521,12 +2548,14 @@ if False:
     taxonomy_string_short = taxonomy_info_to_taxonomy_string(taxonomy_info)
     assert len(taxonomy_string_short.split(';')) == 5
 
-    generate_csv_rows_for_species(species_string=taxonomy_string_short,
-                                  allow_countries=['AUS'],
-                                  block_countries=None,
-                                  allow_states=None,
-                                  block_states=None,
-                                  blockexcept_countries=None)
+    rows = generate_csv_rows_for_species(species_string=taxonomy_string_short,
+                                         allow_countries=['AUS'],
+                                         block_countries=None,
+                                         allow_states=None,
+                                         block_states=None)
+
+    # import clipboard; clipboard.copy('\n'.join(rows))
+    print(rows)
 
 
     #%% Test the effects of geofence changes

megadetector/visualization/plot_utils.py

@@ -37,14 +37,14 @@ def plot_confusion_matrix(matrix,
         normalize (bool, optional): whether to perform row-wise normalization;
             by default, assumes values in the confusion matrix are percentages
         title (str, optional): figure title
-        cmap (matplotlib.colors.colormap): colormap for cell backgrounds
-        vmax (float, optional), value corresponding to the largest value of the colormap;
+        cmap (matplotlib.colors.colormap, optional): colormap for cell backgrounds
+        vmax (float, optional): value corresponding to the largest value of the colormap;
             if None, the maximum value in [matrix] will be used
         use_colorbar (bool, optional): whether to show colorbar
         y_label (bool, optional): whether to show class names on the y axis
-        fmt (str): format string for rendering numeric values
-        fig (Figure): existing figure to which we should render, otherwise creates
-            a new figure
+        fmt (str, optional): format string for rendering numeric values
+        fig (Figure, optional): existing figure to which we should render, otherwise
+            creates a new figure
 
     Returns:
         matplotlib.figure.Figure: the figure we rendered to or created
@@ -140,8 +140,12 @@ def plot_precision_recall_curve(precisions,
     return fig
 
 
-def plot_stacked_bar_chart(data, series_labels=None, col_labels=None,
-                           x_label=None, y_label=None, log_scale=False):
+def plot_stacked_bar_chart(data,
+                           series_labels=None,
+                           col_labels=None,
+                           x_label=None,
+                           y_label=None,
+                           log_scale=False):
     """
     Plot a stacked bar chart, for plotting e.g. species distribution across locations.
 
@@ -154,7 +158,7 @@ def plot_stacked_bar_chart(data, series_labels=None, col_labels=None,
         col_labels (list of str, optional): column labels, typically location names
         x_label (str, optional): x-axis label
         y_label (str, optional): y-axis label
-        log_scale (bool, optional) whether to plot the y axis in log-scale
+        log_scale (bool, optional): whether to plot the y axis in log-scale
 
     Returns:
         matplotlib.figure.Figure: the (new) figure
@@ -257,7 +261,7 @@ def plot_calibration_curve(true_scores, pred_scores, num_bins,
         plot_perf (bool, optional): whether to plot y=x line indicating perfect calibration
         plot_hist (bool, optional): whether to plot histogram of counts
         ax (Axes, optional): if given then no legend is drawn, and fig_kwargs are ignored
-        fig_kwargs (dict, optional): only used if [ax] is None
+        fig_kwargs (dict): only used if [ax] is None
 
     Returns:
         matplotlib.figure.Figure: the (new) figure

megadetector/visualization/render_images_with_thumbnails.py

@@ -131,7 +131,8 @@ def render_images_with_thumbnails(
     # through them, crop them, and save them to a list of cropped_images
     cropped_images = []
     for (name, box) in zip(secondary_image_filename_list,
-                           secondary_image_bounding_box_list):
+                           secondary_image_bounding_box_list,
+                           strict=True):
 
         other_image = vis_utils.load_image(name)
         cropped_image = crop_image_with_normalized_coordinates(