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

megadetector/data_management/labelme_to_yolo.py

@@ -10,12 +10,14 @@ Create YOLO .txt files in a folder containing labelme .json files.
 
 import os
 import json
+import argparse
 
 from multiprocessing.pool import Pool, ThreadPool
 from functools import partial
 from tqdm import tqdm
 
 from megadetector.utils.path_utils import recursive_file_list
+from megadetector.utils.ct_utils import write_json
 
 
 #%% Main function
@@ -33,6 +35,13 @@ def labelme_file_to_yolo_file(labelme_file,
     this function no-ops (i.e., does not generate a YOLO file).
 
     overwrite_behavior should be 'skip' or 'overwrite' (default).
+
+    Args:
+        labelme_file (str): .json file to convert
+        category_name_to_category_id (dict): category name --> ID mapping
+        yolo_file (str, optional): output .txt file defaults to s/json/txt
+        required_token (str, optional): only process filenames containing this token
+        overwrite_behavior (str, optional): "skip" or "overwrite"
     """
 
     result = {}
@@ -150,6 +159,15 @@ def labelme_folder_to_yolo(labelme_folder,
         'category_name_to_category_id', whether it was passed in or constructed
         'image_results': a list of results for each image (converted, skipped, error)
 
+    Args:
+        labelme_folder (str): folder of .json files to convert
+        category_name_to_category_id (dict): category name --> ID mapping
+        required_token (str, optional): only process filenames containing this token
+        overwrite_behavior (str, optional): "skip" or "overwrite"
+        relative_filenames_to_convert (list of str, optional): only process filenames on this list
+        n_workers (int, optional): parallelism level
+        use_threads (bool, optional): whether to use threads (True) or processes (False) for
+            parallelism
     """
 
     if relative_filenames_to_convert is not None:
@@ -236,7 +254,7 @@ def labelme_folder_to_yolo(labelme_folder,
         finally:
             pool.close()
             pool.join()
-            print("Pool closed and joined for labelme conversion to YOLO")
+            print('Pool closed and joined for labelme conversion to YOLO')
 
     assert len(valid_labelme_files_relative) == len(image_results)
 
@@ -275,4 +293,66 @@ if False:
 
 #%% Command-line driver
 
-# TODO
+def main():
+    """
+    Command-line interface to convert Labelme JSON files to YOLO format
+    """
+
+    parser = argparse.ArgumentParser(
+        description='Convert a folder of Labelme .json files to YOLO .txt format'
+    )
+    parser.add_argument(
+        'labelme_folder',
+        type=str,
+        help='Folder of Labelme .json files to convert'
+    )
+    parser.add_argument(
+        '--output_category_file',
+        type=str,
+        default=None,
+        help='Path to save the generated category mapping (.json)'
+    )
+    parser.add_argument(
+        '--required_token',
+        type=str,
+        default=None,
+        help='Only process files containing this token as a key in the Labelme JSON dict'
+    )
+    parser.add_argument(
+        '--overwrite_behavior',
+        type=str,
+        default='overwrite',
+        choices=['skip', 'overwrite'],
+        help="Behavior if YOLO .txt files exist (default: 'overwrite')"
+    )
+    parser.add_argument(
+        '--n_workers',
+        type=int,
+        default=1,
+        help='Number of workers for parallel processing (default: 1)'
+    )
+    parser.add_argument(
+        '--use_processes',
+        action='store_true',
+        help='Use processes instead of threads for parallelization (defaults to threads)'
+    )
+
+    args = parser.parse_args()
+
+    results = labelme_folder_to_yolo(
+        labelme_folder=args.labelme_folder,
+        category_name_to_category_id=None,
+        required_token=args.required_token,
+        overwrite_behavior=args.overwrite_behavior,
+        relative_filenames_to_convert=None,
+        n_workers=args.n_workers,
+        use_threads=(not args.use_processes)
+    )
+
+    if args.output_category_file:
+        category_map = results['category_name_to_category_id']
+        write_json(args.output_category_file,category_map)
+        print(f'Saved category mapping to {args.output_category_file}')
+
+if __name__ == '__main__':
+    main()

megadetector/data_management/lila/generate_lila_per_image_labels.py

@@ -67,6 +67,18 @@ if debug_max_images_per_dataset > 0:
     print('Running in debug mode')
     output_file = output_file.replace('.csv','_debug.csv')
 
+taxonomy_levels_to_include = \
+    ['kingdom','phylum','subphylum','superclass','class','subclass','infraclass','superorder','order',
+     'suborder','infraorder','superfamily','family','subfamily','tribe','genus','subgenus',
+     'species','subspecies','variety']
+
+def _clearnan(v):
+    if isinstance(v,float):
+        assert np.isnan(v)
+        v = ''
+    assert isinstance(v,str)
+    return v
+
 
 #%% Download and parse the metadata file
 
@@ -87,7 +99,7 @@ for ds_name in metadata_table.keys():
 
 #%% Load taxonomy data
 
-taxonomy_df = read_lila_taxonomy_mapping(metadata_dir)
+taxonomy_df = read_lila_taxonomy_mapping(metadata_dir, force_download=True)
 
 
 #%% Build a dictionary that maps each [dataset,query] pair to the full taxonomic label set
@@ -113,22 +125,10 @@ header = ['dataset_name','url_gcp','url_aws','url_azure',
           'image_id','sequence_id','location_id','frame_num',
           'original_label','scientific_name','common_name','datetime','annotation_level']
 
-taxonomy_levels_to_include = \
-    ['kingdom','phylum','subphylum','superclass','class','subclass','infraclass','superorder','order',
-     'suborder','infraorder','superfamily','family','subfamily','tribe','genus','species','subspecies',
-     'variety']
-
 header.extend(taxonomy_levels_to_include)
 
 missing_annotations = set()
 
-def _clearnan(v):
-    if isinstance(v,float):
-        assert np.isnan(v)
-        v = ''
-    assert isinstance(v,str)
-    return v
-
 with open(output_file,'w',encoding='utf-8',newline='') as f:
 
     csv_writer = csv.writer(f)
@@ -361,7 +361,10 @@ print('Read {} rows from {}'.format(len(df),output_file))
 
 #%% Do some post-hoc integrity checking
 
-# Takes ~10 minutes without using apply()
+# Takes ~5 minutes with apply(), or ~10 minutes without apply()
+#
+# Using apply() is faster, but more annoying to debug.
+use_pandas_apply_for_integrity_checking = True
 
 tqdm.pandas()
 
@@ -393,8 +396,7 @@ def _check_row(row):
     ds_name = row['dataset_name']
     dataset_name_to_locations[ds_name].add(row['location_id'])
 
-# Faster, but more annoying to debug
-if True:
+if use_pandas_apply_for_integrity_checking:
 
     df.progress_apply(_check_row, axis=1)
 
@@ -448,8 +450,9 @@ for ds_name in metadata_table.keys():
         empty_rows = empty_rows.sample(n=n_empty_images_per_dataset)
     images_to_download.extend(empty_rows.to_dict('records'))
 
+    # All LILA datasets have non-empty images
     if len(non_empty_rows) == 0:
-        print('No non-empty images available for {}'.format(ds_name))
+        raise ValueError('No non-empty images available for {}'.format(ds_name))
     elif len(non_empty_rows) > n_non_empty_images_per_dataset:
         non_empty_rows = non_empty_rows.sample(n=n_non_empty_images_per_dataset)
     images_to_download.extend(non_empty_rows.to_dict('records'))
@@ -463,7 +466,7 @@ print('Selected {} total images'.format(len(images_to_download)))
 
 # Expect a few errors for images with human or vehicle labels (or things like "ignore" that *could* be humans)
 
-preferred_cloud = 'aws'
+preferred_cloud = 'gcp'
 
 url_to_target_file = {}
 
@@ -484,6 +487,19 @@ for i_image,image in tqdm(enumerate(images_to_download),total=len(images_to_down
 download_results = parallel_download_urls(url_to_target_file,verbose=False,overwrite=True,
                                           n_workers=20,pool_type='thread')
 
+# 10-20 errors is normal; they should all be images that are labeled as "human"
+errors = []
+
+for r in download_results:
+    if r['status'] != 'success':
+        errors.append(r)
+
+assert len(download_results) == len(url_to_target_file)
+print('Errors on {} of {} downloads:\n'.format(len(errors),len(download_results)))
+
+for err in errors:
+    print(err['url'])
+
 
 #%% Write preview HTML
 
@@ -515,3 +531,245 @@ open_file(html_filename)
 zipped_output_file = zip_file(output_file,verbose=True,overwrite=True)
 
 print('Zipped {} to {}'.format(output_file,zipped_output_file))
+
+
+#%% Convert to .json
+
+"""
+The .csv file "output_file" (already loaded into the variable "df" at this point) has the following columns:
+
+dataset_name,url_gcp,url_aws,url_azure,image_id,sequence_id,location_id,frame_num,original_label,scientific_name,common_name,datetime,annotation_level,kingdom,phylum,subphylum,superclass,class,subclass,infraclass,superorder,order,suborder,infraorder,superfamily,family,subfamily,tribe,genus,subgenus,species,subspecies,variety
+
+Each row in the .csv represents an image.  The URL columns represent the location of that
+image on three different clouds; for a given image, the value of those columns differs only
+in the prefix.  The columns starting with "kingdom" represent a taxonomic wildlife identifier.  Not
+all rows have values in all of these columns; some rows represent non-wildlife images where all of these
+columns are blank.
+
+This cell converts this to a .json dictionary, with the following top-level keys:
+
+## datasets (dict)
+
+A dict mapping integer IDs to strings.
+
+Each unique value in the "dataset_name" column should become an element in this dict with a unique ID.
+
+## sequences (dict)
+
+A dict mapping integer IDs to strings.
+
+Each unique value in the "sequence_id" column should become an element in this dict with a unique ID.
+
+## locations (dict)
+
+A dict mapping integer IDs to strings.
+
+Each unique value in the "location_id" column should become an element in this dict with a unique ID.
+
+## base_urls (dict)
+
+This key should point to the following dict:
+
+{
+"gcp": "https://storage.googleapis.com/public-datasets-lila/",
+"aws": "http://us-west-2.opendata.source.coop.s3.amazonaws.com/agentmorris/lila-wildlife/",
+"azure": "https://lilawildlife.blob.core.windows.net/lila-wildlife/",
+}
+
+All values in the url_gcp, url_aws, and url_azure columns start with these values, respectively.
+
+## taxa (dict)
+
+A dict mapping integer IDs to dicts, where each dict has the fields:
+
+kingdom,phylum,subphylum,superclass,class,subclass,infraclass,superorder,order,suborder,infraorder,superfamily,family,subfamily,tribe,genus,subgenus,species,subspecies,variety
+
+The value of each of these fields in each row is either a string or None.
+
+## images (list)
+
+A list of images, where each image is a dict with the following fields:
+
+### dataset (int)
+
+The integer ID corresponding to the dataset_name column for this image
+
+### path (str)
+
+The suffix for this image's URL, which should be the same across the three URL columns.
+
+### seq (int)
+
+The integer ID corresponding to the sequence_id column for this image
+
+### loc (int)
+
+The integer ID corresponding to the location_id column for this image
+
+### frame_num
+
+The value of the frame_num column for this image, unless the original value was -1,
+in which case this is omitted.
+
+### original_label
+
+The value of the original_label column for this image
+
+### common_name
+
+The value of the common_name column for this image, if not empty
+
+### datetime
+
+The value of the datetime column for this image
+
+### ann_level
+
+The value of the annotation_level column for this image
+
+### taxon
+
+The integer ID corresponding to the taxonomic identifier columns for this image
+
+--
+
+The original .csv file is large (~15GB); this may impact the implementation of the .json conversion.  Speed of
+conversion is not a priority.
+
+"""
+
+print('Converting to JSON...')
+
+output_json_file = output_file.replace('.csv', '.json')
+
+json_data = {}
+
+# Create mappings for datasets, sequences, and locations
+dataset_to_id = {}
+sequence_to_id = {}
+location_to_id = {}
+taxa_to_id = {}
+
+next_dataset_id = 0
+next_sequence_id = 0
+next_location_id = 0
+next_taxa_id = 0
+
+json_data['datasets'] = {}
+json_data['sequences'] = {}
+json_data['locations'] = {}
+json_data['taxa'] = {}
+
+json_data['base_urls'] = {
+    "gcp": "https://storage.googleapis.com/public-datasets-lila/",
+    "aws": "http://us-west-2.opendata.source.coop.s3.amazonaws.com/agentmorris/lila-wildlife/",
+    "azure": "https://lilawildlife.blob.core.windows.net/lila-wildlife/",
+}
+
+json_data['images'] = []
+
+debug_max_json_conversion_rows = None
+
+print('Counting rows in .csv file...')
+
+# Get total number of lines for progress bar (optional, but helpful for large files)
+def _count_lines(filename):
+    with open(filename, 'r', encoding='utf-8') as f:
+        return sum(1 for line in f) - 1
+
+total_rows = _count_lines(output_file)
+print('Total rows to process: {}'.format(total_rows))
+
+# Read CSV file line by line
+with open(output_file, 'r', encoding='utf-8') as csvfile:
+
+    reader = csv.DictReader(csvfile)
+
+    # Process each row
+    for i_row, row in enumerate(tqdm(reader, total=total_rows, desc="Processing rows")):
+
+        if (debug_max_json_conversion_rows is not None) and (i_row >= debug_max_json_conversion_rows):
+            break
+
+        # Datasets
+        dataset_name = row['dataset_name']
+        if dataset_name not in dataset_to_id:
+            dataset_to_id[dataset_name] = next_dataset_id
+            json_data['datasets'][str(next_dataset_id)] = dataset_name
+            next_dataset_id += 1
+        dataset_id = dataset_to_id[dataset_name]
+
+        # Sequences
+        sequence_id_str = row['sequence_id']
+        assert sequence_id_str.startswith(dataset_name + ' : ')
+        if sequence_id_str not in sequence_to_id:
+            sequence_to_id[sequence_id_str] = next_sequence_id
+            json_data['sequences'][str(next_sequence_id)] = sequence_id_str
+            next_sequence_id += 1
+        sequence_id = sequence_to_id[sequence_id_str]
+
+        # Locations
+        location_id_str = row['location_id']
+        assert location_id_str.startswith(dataset_name) # + ' : ')
+        if location_id_str not in location_to_id:
+            location_to_id[location_id_str] = next_location_id
+            json_data['locations'][str(next_location_id)] = location_id_str
+            next_location_id += 1
+        location_id = location_to_id[location_id_str]
+
+        # Taxa
+        taxa_data = {level: _clearnan(row[level]) for level in taxonomy_levels_to_include}
+        taxa_tuple = tuple(taxa_data.items())  # use tuple for hashable key
+        if taxa_tuple not in taxa_to_id:
+            taxa_to_id[taxa_tuple] = next_taxa_id
+            json_data['taxa'][str(next_taxa_id)] = taxa_data
+            next_taxa_id += 1
+        taxa_id = taxa_to_id[taxa_tuple]
+
+        # Image path
+        url_gcp = row['url_gcp']
+        assert url_gcp.startswith(json_data['base_urls']['gcp'])
+        path = url_gcp.replace(json_data['base_urls']['gcp'], '')
+
+        common_name = _clearnan(row['common_name'])
+
+        frame_num = int(row['frame_num'])
+
+        # Image data
+        image_entry = {
+            'dataset': dataset_id,
+            'path': path,
+            'seq': sequence_id,
+            'loc': location_id,
+            'ann_level': row['annotation_level'],
+            'original_label': row['original_label'],
+            'datetime': row['datetime'],
+            'taxon': taxa_id
+        }
+
+        if frame_num >= 0:
+           image_entry['frame_num'] = frame_num
+
+        if len(common_name) > 0:
+            image_entry['common_name'] = common_name
+
+        json_data['images'].append(image_entry)
+
+    # ...for each line
+
+# ...with open(...)
+
+# Save the JSON data
+print('Saving JSON file...')
+with open(output_json_file, 'w', encoding='utf-8') as f:
+    json.dump(json_data, f, indent=1)
+
+print(f'Converted to JSON and saved to {output_json_file}')
+print(f'JSON file size: {os.path.getsize(output_json_file)/(1024*1024*1024):.2f} GB')
+
+# Print summary statistics
+print(f'Total datasets: {len(json_data["datasets"])}')
+print(f'Total sequences: {len(json_data["sequences"])}')
+print(f'Total locations: {len(json_data["locations"])}')
+print(f'Total taxa: {len(json_data["taxa"])}')
+print(f'Total images: {len(json_data["images"])}')

megadetector/data_management/lila/get_lila_annotation_counts.py

@@ -82,9 +82,11 @@ print('Loaded metadata URLs for {} datasets'.format(len(metadata_table)))
 #%% Download and extract metadata for each dataset
 
 for ds_name in metadata_table.keys():
-    metadata_table[ds_name]['json_filename'] = read_metadata_file_for_dataset(ds_name=ds_name,
-                                                                         metadata_dir=metadata_dir,
-                                                                         metadata_table=metadata_table)
+    metadata_table[ds_name]['json_filename'] = \
+        read_metadata_file_for_dataset(ds_name=ds_name,
+                                       metadata_dir=metadata_dir,
+                                       metadata_table=metadata_table,
+                                       preferred_cloud=preferred_cloud)
 
 
 #%% Get category names and counts for each dataset

megadetector/data_management/lila/lila_common.py

@@ -241,6 +241,9 @@ def read_metadata_file_for_dataset(ds_name,
 
     """
 
+    if preferred_cloud is None:
+        preferred_cloud = 'gcp'
+
     assert preferred_cloud in lila_base_urls.keys()
 
     if json_url is None:

megadetector/data_management/lila/test_lila_metadata_urls.py

@@ -32,7 +32,7 @@ os.makedirs(metadata_dir,exist_ok=True)
 md_results_dir = os.path.join(lila_local_base,'md_results')
 os.makedirs(md_results_dir,exist_ok=True)
 
-md_results_keys = ['mdv4_results_raw','mdv5a_results_raw','mdv5b_results_raw',
+md_results_keys = ['mdv5a_results_raw','mdv5b_results_raw',
                    'md1000-redwood_results_raw','md_results_with_rde']
 
 preferred_cloud = None # 'gcp' # 'azure', 'aws'
@@ -54,7 +54,7 @@ print('Loaded metadata URLs for {} datasets'.format(len(metadata_table)))
 
 #%% Download and extract metadata and MD results for each dataset
 
-# Takes ~60 seconds if everything needs to be downloaded and unzipped
+# Takes ~10 minutes if everything needs to be downloaded and unzipped
 
 for ds_name in metadata_table.keys():
 
@@ -63,10 +63,12 @@ for ds_name in metadata_table.keys():
         read_metadata_file_for_dataset(ds_name=ds_name,
                                        metadata_dir=metadata_dir,
                                        metadata_table=metadata_table,
-                                       force_download=force_download)
+                                       force_download=force_download,
+                                       preferred_cloud=preferred_cloud)
 
     # Download MD results for this dataset
     for k in md_results_keys:
+
         md_results_url = metadata_table[ds_name][k]
         if md_results_url is None:
             metadata_table[ds_name][k + '_filename'] = None
@@ -75,7 +77,10 @@ for ds_name in metadata_table.keys():
                 read_metadata_file_for_dataset(ds_name=ds_name,
                                                metadata_dir=md_results_dir,
                                                json_url=md_results_url,
-                                               force_download=force_download)
+                                               force_download=force_download,
+                                               preferred_cloud=preferred_cloud)
+
+    # ...for each MD results file
 
 # ...for each dataset
 
@@ -121,9 +126,11 @@ for ds_name in metadata_table.keys():
 
         url_to_source[test_image_url] = ds_name + ' metadata ({})'.format(cloud)
 
+    # ...for each cloud
+
     # Grab an image from the MegaDetector results
 
-    # k = md_results_keys[2]
+    # k = md_results_keys[0]
     for k in md_results_keys:
         k_fn = k + '_filename'
         if metadata_table[ds_name][k_fn] is not None:
@@ -153,3 +160,6 @@ for i_url,url in enumerate(urls_to_test):
     if status_codes[i_url] != 200:
         print('Status {} for {} ({})'.format(
             status_codes[i_url],url,url_to_source[url]))
+
+print('Tested {} URLs'.format(len(urls_to_test)))
+

megadetector/data_management/mewc_to_md.py

@@ -35,6 +35,7 @@ def mewc_to_md(mewc_input_folder,
                mewc_out_filename='mewc_out.csv',
                md_out_filename='md_out.json'):
     """
+    Converts the output of the MEWC inference scripts to the MD output format.
 
     Args:
         mewc_input_folder (str): the folder we'll search for MEWC output files
@@ -43,6 +44,10 @@ def mewc_to_md(mewc_input_folder,
             .json file, typically the prefix used to mount the image folder.
         category_name_column (str, optional): column in the MEWC results .csv to use for
             category naming.
+        mewc_out_filename (str, optional): MEWC-formatted .csv file that should be
+            in [mewc_input_folder]
+        md_out_filename (str, optional): MD-formatted .json file (without classification
+            information) that should be in [mewc_input_folder]
 
     Returns:
         dict: an MD-formatted dict, the same as what's written to [output_file]

megadetector/data_management/ocr_tools.py

@@ -39,6 +39,7 @@ Known limitations:
 
 """
 
+
 #%% Constants and imports
 
 import os
@@ -64,7 +65,7 @@ from megadetector.visualization import visualization_utils as vis_utils
 #
 # Also install tesseract from: https://github.com/UB-Mannheim/tesseract/wiki, and add
 # the installation dir to your path (on Windows, typically C:\Program Files (x86)\Tesseract-OCR)
-import pytesseract
+import pytesseract # type: ignore
 
 
 #%% Extraction options
@@ -546,8 +547,8 @@ def try_get_datetime_from_image(filename,include_crops=False,options=None):
     until we find a datetime.
 
     Args:
-        image (Image or str): the PIL Image object or image filename in which we should look for
-            datetime information.
+        filename (Image or str): the PIL Image object or image filename in which we should look
+            for datetime information.
         include_crops (bool, optional): whether to include cropped images in the return dict (set
             this to False if you're worried about size and you're processing a zillion images)
         options (DatetimeExtractionOptions or list, optional): OCR parameters, either one

megadetector/data_management/read_exif.py

@@ -36,7 +36,8 @@ from megadetector.data_management.cct_json_utils import write_object_with_serial
 debug_max_images = None
 
 minimal_exif_tags = \
-    ['DateTime','Model','Make','ExifImageWidth','ExifImageHeight','DateTimeOriginal','Orientation']
+    ['DateTime','Model','Make','ExifImageWidth','ExifImageHeight',
+     'DateTimeOriginal','Orientation', 'GPSInfo']
 
 
 #%% Options
@@ -186,6 +187,7 @@ def read_pil_exif(im,options=None):
     Args:
         im (str or PIL.Image.Image): image (as a filename or an Image object) from which
             we should read EXIF data.
+        options (ReadExifOptions, optional): see ReadExifOptions
 
     Returns:
         dict: a dictionary mapping EXIF tag names to their values
@@ -288,6 +290,12 @@ def format_datetime_as_exif_datetime_string(dt):
     """
     Returns a Python datetime object rendered using the standard EXIF datetime
     string format ('%Y:%m:%d %H:%M:%S')
+
+    Args:
+        dt (datetime): datetime object to format
+
+    Returns:
+        str: [dt] as a string in standard EXIF format
     """
 
     return datetime.strftime(dt, '%Y:%m:%d %H:%M:%S')
@@ -348,6 +356,10 @@ def read_exif_tags_for_image(file_path,options=None):
     """
     Get relevant fields from EXIF data for an image
 
+    Args:
+        file_path (str): image from which we should read EXIF data
+        options (ReadExifOptions, optional): see ReadExifOptions
+
     Returns:
         dict: a dict with fields 'status' (str) and 'tags'. The exact format of 'tags' depends on
         options (ReadExifOptions, optional): parameters controlling metadata extraction
@@ -656,7 +668,11 @@ def _write_exif_results(results,output_file):
 # ..._write_exif_results(...)
 
 
-def read_exif_from_folder(input_folder,output_file=None,options=None,filenames=None,recursive=True):
+def read_exif_from_folder(input_folder,
+                          output_file=None,
+                          options=None,
+                          filenames=None,
+                          recursive=True):
     """
     Read EXIF data for a folder of images.
 
@@ -670,7 +686,6 @@ def read_exif_from_folder(input_folder,output_file=None,options=None,filenames=N
             a list of absolute filenames (if [input_folder] is None)
         recursive (bool, optional): whether to recurse into [input_folder], not relevant if [input_folder]
             is None.
-        verbose (bool, optional): enable additional debug output
 
     Returns:
         list: list of dicts, each of which contains EXIF information for one images.  Fields include at least:
@@ -704,7 +719,7 @@ def read_exif_from_folder(input_folder,output_file=None,options=None,filenames=N
         try:
             with open(output_file, 'a') as f:
                 if not f.writable():
-                    raise IOError('File not writable')
+                    raise OSError('File not writable')
         except Exception:
             print('Could not write to file {}'.format(output_file))
             raise
@@ -743,7 +758,7 @@ def exif_results_to_cct(exif_results,cct_output_file=None,options=None):
     Args:
         exif_results (str or list): the filename (or loaded list) containing the results
             from read_exif_from_folder
-        cct_output_file (str,optional): the filename to which we should write
+        cct_output_file (str, optional): the filename to which we should write
             COCO-Camera-Traps-formatted data
         options (ExifResultsToCCTOptions, optional): options guiding the generation
             of the CCT file, particularly location mapping