megadetector 10.0.8__tar.gz → 10.0.9__tar.gz

{megadetector-10.0.8/megadetector.egg-info → megadetector-10.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: megadetector
-Version: 10.0.8
+Version: 10.0.9
 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.8 → megadetector-10.0.9}/megadetector/detection/pytorch_detector.py

@@ -859,6 +859,9 @@ class PTDetector:
             except AttributeError:
                 pass
 
+        # AddaxAI depends on this printout, don't remove it
+        print('PTDetector using device {}'.format(str(self.device).lower()))
+
         try:
             self.model = PTDetector._load_model(model_path,
                                                 device=self.device,

{megadetector-10.0.8 → megadetector-10.0.9}/megadetector/detection/run_detector.py

@@ -596,8 +596,7 @@ def load_detector(model_file,
     model_file = try_download_known_detector(model_file,
                                              force_download=force_model_download)
 
-    if verbose:
-        print('GPU available: {}'.format(is_gpu_available(model_file)))
+    print('GPU available: {}'.format(is_gpu_available(model_file)))
 
     start_time = time.time()
 

{megadetector-10.0.8 → megadetector-10.0.9}/megadetector/detection/run_detector_batch.py

@@ -94,20 +94,29 @@ max_queue_size = 10
 # How often should we print progress when using the image queue?
 n_queue_print = 1000
 
-# TODO: it's a little sloppy that these are module-level globals, but in practice it
+# Only used if --include_exif_data or --include_image_timestamp are supplied
+exif_options = read_exif.ReadExifOptions()
+exif_options.processing_library = 'pil'
+exif_options.byte_handling = 'convert_to_string'
+
+# Only relevant when we're running our test harness; because bugs in batch
+# inference are dependent on batch grouping, we randomize batch grouping
+# during testing to maximize the probability that latent bugs come up
+# eventually.
+randomize_batch_order_during_testing = True
+
+# TODO: it's a little sloppy that the following are module-level globals, but in practice it
 # doesn't really matter, so I'm not in a big rush to move these to options until I do
 # a larger cleanup of all the long argument lists in this module.
-#
+
 # Should the consumer loop run on its own process, or here in the main process?
 run_separate_consumer_process = False
-use_threads_for_queue = False
-verbose = False
 
-exif_options = read_exif.ReadExifOptions()
-exif_options.processing_library = 'pil'
-exif_options.byte_handling = 'convert_to_string'
+# Should we use threads (rather than processes) for the data loading workers?
+use_threads_for_queue = False
 
-randomize_batch_order_during_testing = True
+# Enable additional debug output
+verbose = False
 
 
 #%% Support functions for multiprocessing
@@ -736,7 +745,9 @@ def _process_batch(image_items_batch,
         try:
 
             batch_detections = \
-                detector.generate_detections_one_batch(valid_images, valid_image_filenames, verbose=verbose)
+                detector.generate_detections_one_batch(valid_images,
+                                                       valid_image_filenames,
+                                                       verbose=verbose)
 
             assert len(batch_detections) == len(valid_images)
 
@@ -1050,7 +1061,8 @@ def load_and_run_detector_batch(model_file,
                                 detector_options=None,
                                 loader_workers=default_loaders,
                                 preprocess_on_image_queue=default_preprocess_on_image_queue,
-                                batch_size=1):
+                                batch_size=1,
+                                verbose_output=False):
     """
     Load a model file and run it on a list of images.
 
@@ -1087,6 +1099,7 @@ def load_and_run_detector_batch(model_file,
         preprocess_on_image_queue (bool, optional): if the image queue is enabled, should it handle
             image loading and preprocessing (True), or just image loading (False)?
         batch_size (int, optional): batch size for GPU processing, automatically set to 1 for CPU processing
+        verbose_output (bool, optional): enable additional debug output
 
     Returns:
         results: list of dicts; each dict represents detections on one image
@@ -1109,6 +1122,11 @@ def load_and_run_detector_batch(model_file,
     if class_mapping_filename is not None:
         _load_custom_class_mapping(class_mapping_filename)
 
+    global verbose
+    if verbose_output:
+        print('Enabling verbose output')
+        verbose = True
+
     # Handle the case where image_file_names is not yet actually a list
     if isinstance(image_file_names,str):
 
@@ -1866,11 +1884,7 @@ def main(): # noqa
 
     args = parser.parse_args()
 
-    global verbose
     global use_threads_for_queue
-
-    if args.verbose:
-        verbose = True
     if args.use_threads_for_queue:
         use_threads_for_queue = True
 
@@ -2087,7 +2101,8 @@ def main(): # noqa
                                           detector_options=detector_options,
                                           loader_workers=args.loader_workers,
                                           preprocess_on_image_queue=args.preprocess_on_image_queue,
-                                          batch_size=args.batch_size)
+                                          batch_size=args.batch_size,
+                                          verbose_output=args.verbose)
 
     elapsed = time.time() - start_time
     images_per_second = len(results) / elapsed

{megadetector-10.0.8 → megadetector-10.0.9}/megadetector/detection/run_tiled_inference.py

@@ -39,7 +39,7 @@ from torchvision import ops
 from megadetector.detection.run_inference_with_yolov5_val import \
     YoloInferenceOptions,run_inference_with_yolo_val
 from megadetector.detection.run_detector_batch import \
-    load_and_run_detector_batch,write_results_to_file
+    load_and_run_detector_batch,write_results_to_file,default_loaders
 from megadetector.detection.run_detector import \
     try_download_known_detector, CONF_DIGITS, COORD_DIGITS
 from megadetector.utils import path_utils
@@ -406,7 +406,9 @@ def run_tiled_inference(model_file,
                         detector_options=None,
                         use_image_queue=True,
                         preprocess_on_image_queue=True,
-                        inference_size=None):
+                        loader_workers=default_loaders,
+                        inference_size=None,
+                        verbose=False):
     """
     Runs inference using [model_file] on the images in [image_folder], fist splitting each image up
     into tiles of size [tile_size_x] x [tile_size_y], writing those tiles to [tiling_folder],
@@ -451,16 +453,17 @@ def run_tiled_inference(model_file,
         image_list (list, optional): .json file containing a list of specific images to process.  If
             this is supplied, and the paths are absolute, [image_folder] will be ignored. If this is supplied,
             and the paths are relative, they should be relative to [image_folder]
-        augment (bool, optional): apply test-time augmentation, only relevant if yolo_inference_options
-            is None
+        augment (bool, optional): apply test-time augmentation
         detector_options (dict, optional): parameters to pass to run_detector, only relevant if
             yolo_inference_options is None
         use_image_queue (bool, optional): whether to use a loader worker queue, only relevant if
             yolo_inference_options is None
         preprocess_on_image_queue (bool, optional): whether the image queue should also be responsible
             for preprocessing
+        loader_workers (int, optional): number of preprocessing loader workers to use
         inference_size (int, optional): override the default inference image size, only relevant if
             yolo_inference_options is None
+        verbose (bool, optional): enable additional debug output
 
     Returns:
         dict: MD-formatted results dictionary, identical to what's written to [output_file]
@@ -522,7 +525,8 @@ def run_tiled_inference(model_file,
 
     all_image_patch_info = None
 
-    print('Extracting patches from {} images'.format(len(image_files_relative)))
+    print('Extracting patches from {} images on {} workers'.format(
+        len(image_files_relative),n_patch_extraction_workers))
 
     n_workers = n_patch_extraction_workers
 
@@ -632,7 +636,9 @@ def run_tiled_inference(model_file,
                                                         detector_options=detector_options,
                                                         use_image_queue=use_image_queue,
                                                         preprocess_on_image_queue=preprocess_on_image_queue,
-                                                        image_size=inference_size)
+                                                        image_size=inference_size,
+                                                        verbose_output=verbose,
+                                                        loader_workers=loader_workers)
 
         patch_level_output_file = os.path.join(tiling_folder,folder_name + '_patch_level_results.json')
 
@@ -847,12 +853,12 @@ if False:
         yolo_inference_options.yolo_working_folder = os.path.expanduser('~/git/yolov5')
 
     run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
-                            tile_size_x=tile_size_x, tile_size_y=tile_size_y,
-                            tile_overlap=tile_overlap,
-                            checkpoint_path=checkpoint_path,
-                            checkpoint_frequency=checkpoint_frequency,
-                            remove_tiles=remove_tiles,
-                            yolo_inference_options=yolo_inference_options)
+                        tile_size_x=tile_size_x, tile_size_y=tile_size_y,
+                        tile_overlap=tile_overlap,
+                        checkpoint_path=checkpoint_path,
+                        checkpoint_frequency=checkpoint_frequency,
+                        remove_tiles=remove_tiles,
+                        yolo_inference_options=yolo_inference_options)
 
 
     #%% Run tiled inference (generate a command)
@@ -930,6 +936,14 @@ def main():
         '--no_remove_tiles',
         action='store_true',
         help='Tiles are removed by default; this option suppresses tile deletion')
+    parser.add_argument(
+        '--augment',
+        action='store_true',
+        help='Enable test-time augmentation')
+    parser.add_argument(
+        '--verbose',
+        action='store_true',
+        help='Enable additional debug output')
     parser.add_argument(
         '--tile_size_x',
         type=int,
@@ -960,6 +974,21 @@ def main():
         type=str,
         default=None,
         help=('A list of detector options (key-value pairs)'))
+    parser.add_argument(
+        '--inference_size',
+        type=int,
+        default=None,
+        help=('Run inference at a non-default size'))
+    parser.add_argument(
+        '--n_patch_extraction_workers',
+        type=int,
+        default=1,
+        help=('Number of workers to use for patch extraction'))
+    parser.add_argument(
+        '--loader_workers',
+        type=int,
+        default=default_loaders,
+        help=('Number of workers to use for image loading and preprocessing (0 to disable)'))
 
     # detector_options = parse_kvp_list(args.detector_options)
 
@@ -987,11 +1016,23 @@ def main():
 
     remove_tiles = (not args.no_remove_tiles)
 
-    run_tiled_inference(model_file, args.image_folder, args.tiling_folder, args.output_file,
-                        tile_size_x=args.tile_size_x, tile_size_y=args.tile_size_y,
+    use_image_queue = (args.loader_workers > 0)
+
+    run_tiled_inference(model_file,
+                        args.image_folder,
+                        args.tiling_folder,
+                        args.output_file,
+                        tile_size_x=args.tile_size_x,
+                        tile_size_y=args.tile_size_y,
                         tile_overlap=args.tile_overlap,
                         remove_tiles=remove_tiles,
-                        image_list=args.image_list)
+                        image_list=args.image_list,
+                        augment=args.augment,
+                        inference_size=args.inference_size,
+                        verbose=args.verbose,
+                        n_patch_extraction_workers=args.n_patch_extraction_workers,
+                        loader_workers=args.loader_workers,
+                        use_image_queue=use_image_queue)
 
 if __name__ == '__main__':
     main()

{megadetector-10.0.8 → megadetector-10.0.9}/megadetector/postprocessing/compare_batch_results.py

@@ -136,7 +136,7 @@ class BatchComparisonOptions:
         #: Colormap to use for detections in file B (maps detection categories to colors)
         self.colormap_b = ['RoyalBlue']
 
-        #: Process-based parallelization isn't supported yet; this must be "True"
+        #: Whether to render images with threads (True) or processes (False)
         self.parallelize_rendering_with_threads = True
 
         #: List of filenames to include in the comparison, or None to use all files
@@ -152,7 +152,7 @@ class BatchComparisonOptions:
         self.target_width = 800
 
         #: Number of workers to use for rendering, or <=1 to disable parallelization
-        self.n_rendering_workers = 20
+        self.n_rendering_workers = 10
 
         #: Random seed for image sampling (not used if max_images_per_category is None)
         self.random_seed = 0
@@ -183,7 +183,7 @@ class BatchComparisonOptions:
         #: Should we show category names (instead of numbers) on detected boxes?
         self.show_category_names_on_detected_boxes = True
 
-        #: List of PairwiseBatchComparisonOptions that defines the comparisons we'll render.
+        #: List of PairwiseBatchComparisonOptions that defines the comparisons we'll render
         self.pairwise_options = []
 
         #: Only process images whose file names contain this token
@@ -197,7 +197,7 @@ class BatchComparisonOptions:
         self.verbose = False
 
         #: Separate out the "clean TP" and "clean TN" categories, only relevant when GT is
-        #: available.
+        #: available
         self.include_clean_categories = True
 
         #: When rendering to the output table, optionally write alternative strings
@@ -211,6 +211,10 @@ class BatchComparisonOptions:
         #: Should we include a TOC?  TOC is always omitted if <=2 comparisons are performed.
         self.include_toc = True
 
+        #: Should we return the mapping from categories (e.g. "common detections") to image
+        #: pairs?  Makes the return dict much larger, but allows post-hoc exploration.
+        self.return_images_by_category = False
+
 # ...class BatchComparisonOptions
 
 
@@ -224,7 +228,7 @@ class PairwiseBatchComparisonResults:
         #: String of HTML content suitable for rendering to an HTML file
         self.html_content = None
 
-        #: Possibly-modified version of the PairwiseBatchComparisonOptions supplied as input.
+        #: Possibly-modified version of the PairwiseBatchComparisonOptions supplied as input
         self.pairwise_options = None
 
         #: A dictionary with keys representing category names; in the no-ground-truth case, for example,
@@ -295,7 +299,8 @@ def _render_image_pair(fn,image_pairs,category_folder,options,pairwise_options):
     """
 
     input_image_path = os.path.join(options.image_folder,fn)
-    assert os.path.isfile(input_image_path), 'Image {} does not exist'.format(input_image_path)
+    assert os.path.isfile(input_image_path), \
+        'Image {} does not exist'.format(input_image_path)
 
     im = visualization_utils.open_image(input_image_path)
     image_pair = image_pairs[fn]
@@ -628,11 +633,21 @@ def _pairwise_compare_batch_results(options,output_index,pairwise_options):
     os.makedirs(options.output_folder,exist_ok=True)
 
 
+    # Just in case the user provided a single category instead of a list
+    # for category_names_to_include
+    if options.category_names_to_include is not None:
+        if isinstance(options.category_names_to_include,str):
+            options.category_names_to_include = [options.category_names_to_include]
+
     ##%% Load both result sets
 
+    if options.verbose:
+        print('Loading {}'.format(pairwise_options.results_filename_a))
     with open(pairwise_options.results_filename_a,'r') as f:
         results_a = json.load(f)
 
+    if options.verbose:
+        print('Loading {}'.format(pairwise_options.results_filename_b))
     with open(pairwise_options.results_filename_b,'r') as f:
         results_b = json.load(f)
 
@@ -654,6 +669,17 @@ def _pairwise_compare_batch_results(options,output_index,pairwise_options):
     detection_category_name_to_id = invert_dictionary(detection_categories_a)
     options.detection_category_id_to_name = detection_category_id_to_name
 
+    category_name_to_id_a = invert_dictionary(detection_categories_a)
+    category_name_to_id_b = invert_dictionary(detection_categories_b)
+    category_ids_to_include_a = []
+    category_ids_to_include_b = []
+
+    for category_name in options.category_names_to_include:
+        if category_name in category_name_to_id_a:
+            category_ids_to_include_a.append(category_name_to_id_a[category_name])
+        if category_name in category_name_to_id_b:
+            category_ids_to_include_b.append(category_name_to_id_b[category_name])
+
     if pairwise_options.results_description_a is None:
         if 'detector' not in results_a['info']:
             print('No model metadata supplied for results-A, assuming MDv4')
@@ -679,7 +705,7 @@ def _pairwise_compare_batch_results(options,output_index,pairwise_options):
     filename_to_image_b = {im['file']:im for im in images_b}
 
 
-    ##%% Make sure they represent the same set of images
+    ##%% Make sure the two result sets represent the same set of images
 
     filenames_a = [im['file'] for im in images_a]
     filenames_b_set = set([im['file'] for im in images_b])
@@ -914,7 +940,8 @@ def _pairwise_compare_batch_results(options,output_index,pairwise_options):
                 pairwise_options.detection_thresholds_b['default']
 
     # fn = filenames_to_compare[0]
-    for i_file,fn in tqdm(enumerate(filenames_to_compare),total=len(filenames_to_compare)):
+    for i_file,fn in tqdm(enumerate(filenames_to_compare),
+                          total=len(filenames_to_compare)):
 
         if fn not in filename_to_image_b:
 
@@ -1000,27 +1027,11 @@ def _pairwise_compare_batch_results(options,output_index,pairwise_options):
                     categories_above_threshold_b.add(category_id)
 
             if invalid_category_error:
-
                 continue
 
             # Should we be restricting the comparison to only certain categories?
             if options.category_names_to_include is not None:
 
-                # Just in case the user provided a single category instead of a list
-                if isinstance(options.category_names_to_include,str):
-                    options.category_names_to_include = [options.category_names_to_include]
-
-                category_name_to_id_a = invert_dictionary(detection_categories_a)
-                category_name_to_id_b = invert_dictionary(detection_categories_b)
-                category_ids_to_include_a = []
-                category_ids_to_include_b = []
-
-                for category_name in options.category_names_to_include:
-                    if category_name in category_name_to_id_a:
-                        category_ids_to_include_a.append(category_name_to_id_a[category_name])
-                    if category_name in category_name_to_id_b:
-                        category_ids_to_include_b.append(category_name_to_id_b[category_name])
-
                 # Restrict the categories we treat as above-threshold to the set we're supposed
                 # to be using
                 categories_above_threshold_a = [category_id for category_id in categories_above_threshold_a if \
@@ -1287,7 +1298,7 @@ def _pairwise_compare_batch_results(options,output_index,pairwise_options):
             max_conf_b = _maxempty([det['conf'] for det in im_b['detections']])
             sort_conf = max(max_conf_a,max_conf_b)
 
-    # ...what kind of ground truth (if any) do we have?
+        # ...what kind of ground truth (if any) do we have?
 
         assert comparison_category is not None
         categories_to_image_pairs[comparison_category][fn] = im_pair
@@ -1313,7 +1324,11 @@ def _pairwise_compare_batch_results(options,output_index,pairwise_options):
     local_output_folder = os.path.join(options.output_folder,'cmp_' + \
                                        str(output_index).zfill(3))
 
-    def render_detection_comparisons(category,image_pairs,image_filenames):
+    def _render_detection_comparisons(category,image_pairs,image_filenames):
+        """
+        Render all the detection results pairs for the sampled images in a
+        particular category (e.g. all the "common detections").
+        """
 
         print('Rendering detections for category {}'.format(category))
 
@@ -1336,7 +1351,7 @@ def _pairwise_compare_batch_results(options,output_index,pairwise_options):
 
         return output_image_paths
 
-    # ...def render_detection_comparisons()
+    # ...def _render_detection_comparisons()
 
     if len(options.colormap_a) > 1:
         color_string_a = str(options.colormap_a)
@@ -1371,7 +1386,7 @@ def _pairwise_compare_batch_results(options,output_index,pairwise_options):
 
         input_image_absolute_paths = [os.path.join(options.image_folder,fn) for fn in image_filenames]
 
-        category_image_output_paths = render_detection_comparisons(category,
+        category_image_output_paths = _render_detection_comparisons(category,
                                                             image_pairs,image_filenames)
 
         category_html_filename = os.path.join(local_output_folder,
@@ -1469,6 +1484,8 @@ def _pairwise_compare_batch_results(options,output_index,pairwise_options):
             print("Pool closed and joined for comparison rendering")
         except Exception:
             pass
+
+
     ##%% Write the top-level HTML file content
 
     html_output_string  = ''
@@ -1591,8 +1608,11 @@ def compare_batch_results(options):
     for i_comparison,pairwise_options in enumerate(pairwise_options_list):
 
         print('Running comparison {} of {}'.format(i_comparison,n_comparisons))
+        pairwise_options.verbose = options.verbose
         pairwise_results = \
             _pairwise_compare_batch_results(options,i_comparison,pairwise_options)
+        if not options.return_images_by_category:
+            pairwise_results.categories_to_image_pairs = None
         html_content += pairwise_results.html_content
         all_pairwise_results.append(pairwise_results)
 

{megadetector-10.0.8 → megadetector-10.0.9}/megadetector/postprocessing/postprocess_batch_results.py

@@ -1145,7 +1145,7 @@ def process_batch_results(options):
 
     images_to_visualize = detections_df
 
-    if options.num_images_to_sample is not None and options.num_images_to_sample > 0:
+    if (options.num_images_to_sample is not None) and (options.num_images_to_sample > 0):
         images_to_visualize = images_to_visualize.sample(
             n=min(options.num_images_to_sample, len(images_to_visualize)),
             random_state=options.sample_seed)

{megadetector-10.0.8 → megadetector-10.0.9}/megadetector/postprocessing/subset_json_detector_output.py

@@ -156,6 +156,12 @@ class SubsetJsonDetectorOutputOptions:
         #: to be contiguous.  Set to 1 to remove empty categories only.
         self.remove_classification_categories_below_count = None
 
+        #: Remove detections above a threshold size (as a fraction of the image size)
+        self.maximum_detection_size = None
+
+        #: Remove detections below a threshold size (as a fraction of the image size)
+        self.minimum_detection_size = None
+
 # ...class SubsetJsonDetectorOutputOptions
 
 
@@ -274,6 +280,71 @@ def remove_classification_categories_below_count(data, options):
 # ...def remove_classification_categories_below_count(...)
 
 
+def subset_json_detector_output_by_size(data, options):
+    """
+    Remove detections above or below threshold sizes (as a fraction
+    of the image size).
+
+    Args:
+        data (dict): data loaded from a MD results file
+        options (SubsetJsonDetectorOutputOptions): parameters for subsetting
+
+    Returns:
+        dict: Possibly-modified version of [data] (also modifies in place)
+    """
+
+    if (options.maximum_detection_size is None) and \
+        (options.minimum_detection_size is None):
+        return data
+
+    if options.maximum_detection_size is None:
+        options.maximum_detection_size = 1000
+
+    if options.minimum_detection_size is None:
+        options.minimum_detection_size = -1000
+
+    print('Subsetting by size ({} <--> {})'.format(
+        options.minimum_detection_size,
+        options.maximum_detection_size))
+
+    images_in = data['images']
+    images_out = []
+
+    # im = images_in[0]
+    for i_image, im in tqdm(enumerate(images_in), total=len(images_in)):
+
+        # Always keep failed images; if the caller wants to remove these, they
+        # will use remove_failed_images
+        if ('detections' not in im) or (im['detections'] is None):
+            images_out.append(im)
+            continue
+
+        detections_to_keep = []
+
+        for det in im['detections']:
+
+            # [x_min, y_min, width_of_box, height_of_box]
+            detection_size = det['bbox'][2] * det['bbox'][3]
+
+            if (detection_size >= options.minimum_detection_size) and \
+               (detection_size <= options.maximum_detection_size):
+                detections_to_keep.append(det)
+
+        im['detections'] = detections_to_keep
+
+        images_out.append(im)
+
+    # ...for each image
+
+    data['images'] = images_out
+    print('done, found {} matches (of {})'.format(
+            len(data['images']),len(images_in)))
+
+    return data
+
+# ...def subset_json_detector_output_by_size(...)
+
+
 def subset_json_detector_output_by_confidence(data, options):
     """
     Removes all detections below options.confidence_threshold.
@@ -674,6 +745,11 @@ def subset_json_detector_output(input_filename, output_filename, options, data=N
 
         data = subset_json_detector_output_by_list(data, options)
 
+    if (options.maximum_detection_size is not None) or \
+        (options.minimum_detection_size is not None):
+
+        data = subset_json_detector_output_by_size(data, options)
+
     if not options.split_folders:
 
         _write_detection_results(data, output_filename, options)
@@ -837,6 +913,10 @@ def main(): # noqa
                         help='Replace [query] with this')
     parser.add_argument('--confidence_threshold', type=float, default=None,
                         help='Remove detections below this confidence level')
+    parser.add_argument('--maximum_detection_size', type=float, default=None,
+                        help='Remove detections above this size (as a fraction of the image size)')
+    parser.add_argument('--minimum_detection_size', type=float, default=None,
+                        help='Remove detections below this size (as a fraction of the image size)')
     parser.add_argument('--keep_files_in_list', type=str, default=None,
                         help='Keep only files in this list, which can be a .json results file or a folder.' + \
                              ' Assumes that the input .json file contains relative paths when comparing to a folder.')

{megadetector-10.0.8 → megadetector-10.0.9/megadetector.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: megadetector
-Version: 10.0.8
+Version: 10.0.9
 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.8 → megadetector-10.0.9}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [
 
 [project]
 name = "megadetector"
-version = "10.0.8"
+version = "10.0.9"
 description = "MegaDetector is an AI model that helps conservation folks spend less time doing boring things with camera trap images."
 readme = "README-package.md"
 requires-python = ">=3.9,<3.14"
@@ -93,7 +93,6 @@ dependencies = [
 include = ["megadetector*"]
 
 [tool.ruff]
-ignore = ["D212"]
 line-length = 120
 target-version = "py39"
 include = ["megadetector/**/*.py"]
@@ -108,6 +107,7 @@ exclude = ["megadetector/api/batch_processing/api_core/**/*.py",
 		   "megadetector/taxonomy_mapping/**/*.py"]
 
 [tool.ruff.lint]
+ignore = ["D212"]
 select = [
     "E",  # Pycodestyle errors
     "W",  # Pycodestyle warnings
@@ -122,7 +122,7 @@ select = [
 [tool.ruff.lint.pydocstyle]
 convention = "google"
 
-[tool.ruff.per-file-ignores]
+[tool.ruff.lint.per-file-ignores]
 "**/*.py" = [
     # Comment/whitespace conventions that differ from ruff's defaults
     "D415",   # First line should end with a period, question mark, or exclamation point