birdnet-analyzer 2.0.0__py3-none-any.whl

birdnet_analyzer/embeddings/__init__.py

@@ -0,0 +1,4 @@
+from birdnet_analyzer.embeddings.core import embeddings
+
+
+__all__ = ["embeddings"]

birdnet_analyzer/embeddings/__main__.py

@@ -0,0 +1,3 @@
+from birdnet_analyzer.embeddings.cli import main
+
+main()

birdnet_analyzer/embeddings/cli.py

@@ -0,0 +1,13 @@
+from birdnet_analyzer.utils import runtime_error_handler
+
+from birdnet_analyzer import embeddings
+
+
+@runtime_error_handler
+def main():
+    import birdnet_analyzer.cli as cli
+
+    parser = cli.embeddings_parser()
+    args = parser.parse_args()
+
+    embeddings(**vars(args))

birdnet_analyzer/embeddings/core.py

@@ -0,0 +1,70 @@
+def embeddings(
+    input: str,
+    database: str,
+    *,
+    overlap: float = 0.0,
+    audio_speed: float = 1.0,
+    fmin: int = 0,
+    fmax: int = 15000,
+    threads: int = 8,
+    batch_size: int = 1,
+):
+    """
+    Generates embeddings for audio files using the BirdNET-Analyzer.
+    This function processes audio files to extract embeddings, which are
+    representations of audio features. The embeddings can be used for
+    further analysis or comparison.
+    Args:
+        input (str): Path to the input audio file or directory containing audio files.
+        database (str): Path to the database where embeddings will be stored.
+        overlap (float, optional): Overlap between consecutive audio segments in seconds. Defaults to 0.0.
+        audio_speed (float, optional): Speed factor for audio processing. Defaults to 1.0.
+        fmin (int, optional): Minimum frequency (in Hz) for audio analysis. Defaults to 0.
+        fmax (int, optional): Maximum frequency (in Hz) for audio analysis. Defaults to 15000.
+        threads (int, optional): Number of threads to use for processing. Defaults to 8.
+        batch_size (int, optional): Number of audio segments to process in a single batch. Defaults to 1.
+    Raises:
+        FileNotFoundError: If the input path or database path does not exist.
+        ValueError: If any of the parameters are invalid.
+    Note:
+        Ensure that the required model files are downloaded and available before
+        calling this function. The `ensure_model_exists` function is used to
+        verify this.
+    Example:
+        embeddings(
+            input="path/to/audio",
+            database="path/to/database",
+            overlap=0.5,
+            audio_speed=1.0,
+            fmin=500,
+            fmax=10000,
+            threads=4,
+            batch_size=2
+        )
+    """
+    from birdnet_analyzer.embeddings.utils import run
+    from birdnet_analyzer.utils import ensure_model_exists
+
+    ensure_model_exists()
+    run(input, database, overlap, audio_speed, fmin, fmax, threads, batch_size)
+
+
+def get_database(db_path: str):
+    """Get the database object. Creates or opens the databse.
+    Args:
+        db: The path to the database.
+    Returns:
+        The database object.
+    """
+    import os
+
+    from perch_hoplite.db import sqlite_usearch_impl
+
+    if not os.path.exists(db_path):
+        os.makedirs(os.path.dirname(db_path), exist_ok=True)
+        db = sqlite_usearch_impl.SQLiteUsearchDB.create(
+            db_path=db_path,
+            usearch_cfg=sqlite_usearch_impl.get_default_usearch_config(embedding_dim=1024),  # TODO dont hardcode this
+        )
+        return db
+    return sqlite_usearch_impl.SQLiteUsearchDB.create(db_path=db_path)

birdnet_analyzer/embeddings/utils.py

@@ -0,0 +1,193 @@
+"""Module used to extract embeddings for samples."""
+
+import datetime
+import os
+
+import numpy as np
+
+import birdnet_analyzer.audio as audio
+import birdnet_analyzer.config as cfg
+import birdnet_analyzer.model as model
+import birdnet_analyzer.utils as utils
+from birdnet_analyzer.analyze.utils import get_raw_audio_from_file
+from birdnet_analyzer.embeddings.core import get_database
+
+
+from perch_hoplite.db import sqlite_usearch_impl
+from perch_hoplite.db import interface as hoplite
+from ml_collections import ConfigDict
+from functools import partial
+from tqdm import tqdm
+from multiprocessing import Pool
+
+
+DATASET_NAME: str = "birdnet_analyzer_dataset"
+
+
+def analyze_file(item, db: sqlite_usearch_impl.SQLiteUsearchDB):
+    """Extracts the embeddings for a file.
+
+    Args:
+        item: (filepath, config)
+    """
+    # Get file path and restore cfg
+    fpath: str = item[0]
+    cfg.set_config(item[1])
+
+    offset = 0
+    duration = cfg.FILE_SPLITTING_DURATION
+
+    try:
+        fileLengthSeconds = int(audio.get_audio_file_length(fpath))
+    except Exception as ex:
+        # Write error log
+        print(f"Error: Cannot analyze audio file {fpath}. File corrupt?\n", flush=True)
+        utils.write_error_log(ex)
+
+        return None
+
+    # Start time
+    start_time = datetime.datetime.now()
+
+    # Status
+    print(f"Analyzing {fpath}", flush=True)
+
+    source_id = fpath
+
+    # Process each chunk
+    try:
+        while offset < fileLengthSeconds:
+            chunks = get_raw_audio_from_file(fpath, offset, duration)
+            start, end = offset, cfg.SIG_LENGTH + offset
+            samples = []
+            timestamps = []
+
+            for c in range(len(chunks)):
+                # Add to batch
+                samples.append(chunks[c])
+                timestamps.append([start, end])
+
+                # Advance start and end
+                start += cfg.SIG_LENGTH - cfg.SIG_OVERLAP
+                end = start + cfg.SIG_LENGTH
+
+                # Check if batch is full or last chunk
+                if len(samples) < cfg.BATCH_SIZE and c < len(chunks) - 1:
+                    continue
+
+                # Prepare sample and pass through model
+                data = np.array(samples, dtype="float32")
+                e = model.embeddings(data)
+
+                # Add to results
+                for i in range(len(samples)):
+                    # Get timestamp
+                    s_start, s_end = timestamps[i]
+
+                    # Check if embedding already exists
+                    existing_embedding = db.get_embeddings_by_source(
+                        DATASET_NAME, source_id, np.array([s_start, s_end])
+                    )
+
+                    if existing_embedding.size == 0:
+                        # Get prediction
+                        embeddings = e[i]
+
+                        # Store embeddings
+                        embeddings_source = hoplite.EmbeddingSource(DATASET_NAME, source_id, np.array([s_start, s_end]))
+
+                        # Insert into database
+                        db.insert_embedding(embeddings, embeddings_source)
+                        db.commit()
+
+                # Reset batch
+                samples = []
+                timestamps = []
+
+            offset = offset + duration
+
+    except Exception as ex:
+        # Write error log
+        print(f"Error: Cannot analyze audio file {fpath}.", flush=True)
+        utils.write_error_log(ex)
+
+        return
+
+    delta_time = (datetime.datetime.now() - start_time).total_seconds()
+    print("Finished {} in {:.2f} seconds".format(fpath, delta_time), flush=True)
+
+
+def check_database_settings(db: sqlite_usearch_impl.SQLiteUsearchDB):
+    try:
+        settings = db.get_metadata("birdnet_analyzer_settings")
+        if (
+            settings["BANDPASS_FMIN"] != cfg.BANDPASS_FMIN
+            or settings["BANDPASS_FMAX"] != cfg.BANDPASS_FMAX
+            or settings["AUDIO_SPEED"] != cfg.AUDIO_SPEED
+        ):
+            raise ValueError(
+                "Database settings do not match current configuration. DB Settings are: fmin: {}, fmax: {}, audio_speed: {}".format(
+                    settings["BANDPASS_FMIN"], settings["BANDPASS_FMAX"], settings["AUDIO_SPEED"]
+                )
+            )
+    except KeyError:
+        settings = ConfigDict(
+            {"BANDPASS_FMIN": cfg.BANDPASS_FMIN, "BANDPASS_FMAX": cfg.BANDPASS_FMAX, "AUDIO_SPEED": cfg.AUDIO_SPEED}
+        )
+        db.insert_metadata("birdnet_analyzer_settings", settings)
+        db.commit()
+
+
+def run(input, database, overlap, audio_speed, fmin, fmax, threads, batchsize):
+    ### Make sure to comment out appropriately if you are not using args. ###
+
+    # Set input and output path
+    cfg.INPUT_PATH = input
+
+    # Parse input files
+    if os.path.isdir(cfg.INPUT_PATH):
+        cfg.FILE_LIST = utils.collect_audio_files(cfg.INPUT_PATH)
+    else:
+        cfg.FILE_LIST = [cfg.INPUT_PATH]
+
+    # Set overlap
+    cfg.SIG_OVERLAP = max(0.0, min(2.9, float(overlap)))
+
+    # Set audio speed
+    cfg.AUDIO_SPEED = max(0.01, audio_speed)
+
+    # Set bandpass frequency range
+    cfg.BANDPASS_FMIN = max(0, min(cfg.SIG_FMAX, int(fmin)))
+    cfg.BANDPASS_FMAX = max(cfg.SIG_FMIN, min(cfg.SIG_FMAX, int(fmax)))
+
+    # Set number of threads
+    if os.path.isdir(cfg.INPUT_PATH):
+        cfg.CPU_THREADS = max(1, int(threads))
+        cfg.TFLITE_THREADS = 1
+    else:
+        cfg.CPU_THREADS = 1
+        cfg.TFLITE_THREADS = max(1, int(threads))
+
+    cfg.CPU_THREADS = 1  # TODO: with the current implementation, we can't use more than 1 thread
+
+    # Set batch size
+    cfg.BATCH_SIZE = max(1, int(batchsize))
+
+    # Add config items to each file list entry.
+    # We have to do this for Windows which does not
+    # support fork() and thus each process has to
+    # have its own config. USE LINUX!
+    flist = [(f, cfg.get_config()) for f in cfg.FILE_LIST]
+
+    db = get_database(database)
+    check_database_settings(db)
+
+    # Analyze files
+    if cfg.CPU_THREADS < 2:
+        for entry in tqdm(flist):
+            analyze_file(entry, db)
+    else:
+        with Pool(cfg.CPU_THREADS) as p:
+            tqdm(p.imap(partial(analyze_file, db=db), flist))
+
+    db.db.close()

birdnet_analyzer/evaluation/__init__.py

@@ -0,0 +1,195 @@
+"""
+Core script for assessing performance of prediction models against annotated data.
+
+This script uses the `DataProcessor` and `PerformanceAssessor` classes to process prediction and
+annotation data, compute metrics, and optionally generate plots. It supports flexible configurations
+for columns, class mappings, and filtering based on selected classes or recordings.
+"""
+
+import argparse
+import json
+import os
+from typing import Optional, Dict, List, Tuple
+
+from birdnet_analyzer.evaluation.preprocessing.data_processor import DataProcessor
+from birdnet_analyzer.evaluation.assessment.performance_assessor import PerformanceAssessor
+
+
+def process_data(
+    annotation_path: str,
+    prediction_path: str,
+    mapping_path: Optional[str] = None,
+    sample_duration: float = 3.0,
+    min_overlap: float = 0.5,
+    recording_duration: Optional[float] = None,
+    columns_annotations: Optional[Dict[str, str]] = None,
+    columns_predictions: Optional[Dict[str, str]] = None,
+    selected_classes: Optional[List[str]] = None,
+    selected_recordings: Optional[List[str]] = None,
+    metrics_list: Tuple[str, ...] = ("accuracy", "precision", "recall"),
+    threshold: float = 0.1,
+    class_wise: bool = False,
+):
+    """
+    Processes data, computes metrics, and prepares the performance assessment pipeline.
+
+    Args:
+        annotation_path (str): Path to the annotation file or folder.
+        prediction_path (str): Path to the prediction file or folder.
+        mapping_path (Optional[str]): Path to the class mapping JSON file, if applicable.
+        sample_duration (float): Duration of each sample interval in seconds.
+        min_overlap (float): Minimum overlap required between predictions and annotations.
+        recording_duration (Optional[float]): Total duration of the recordings, if known.
+        columns_annotations (Optional[Dict[str, str]]): Custom column mappings for annotations.
+        columns_predictions (Optional[Dict[str, str]]): Custom column mappings for predictions.
+        selected_classes (Optional[List[str]]): List of classes to include in the analysis.
+        selected_recordings (Optional[List[str]]): List of recordings to include in the analysis.
+        metrics_list (Tuple[str, ...]): Metrics to compute for performance assessment.
+        threshold (float): Confidence threshold for predictions.
+        class_wise (bool): Whether to calculate metrics on a per-class basis.
+
+    Returns:
+        Tuple: Metrics DataFrame, `PerformanceAssessor` object, predictions tensor, labels tensor.
+    """
+    # Load class mapping if provided
+    if mapping_path:
+        with open(mapping_path, "r") as f:
+            class_mapping = json.load(f)
+    else:
+        class_mapping = None
+
+    # Determine directory and file paths for annotations and predictions
+    annotation_dir, annotation_file = (
+        (os.path.dirname(annotation_path), os.path.basename(annotation_path))
+        if os.path.isfile(annotation_path)
+        else (annotation_path, None)
+    )
+    prediction_dir, prediction_file = (
+        (os.path.dirname(prediction_path), os.path.basename(prediction_path))
+        if os.path.isfile(prediction_path)
+        else (prediction_path, None)
+    )
+
+    # Initialize the DataProcessor to handle and prepare data
+    processor = DataProcessor(
+        prediction_directory_path=prediction_dir,
+        prediction_file_name=prediction_file,
+        annotation_directory_path=annotation_dir,
+        annotation_file_name=annotation_file,
+        class_mapping=class_mapping,
+        sample_duration=sample_duration,
+        min_overlap=min_overlap,
+        columns_predictions=columns_predictions,
+        columns_annotations=columns_annotations,
+        recording_duration=recording_duration,
+    )
+
+    # Get the available classes and recordings
+    available_classes = processor.classes
+    available_recordings = processor.samples_df["filename"].unique().tolist()
+
+    # Default to all classes or recordings if none are specified
+    if selected_classes is None:
+        selected_classes = available_classes
+    if selected_recordings is None:
+        selected_recordings = available_recordings
+
+    # Retrieve predictions and labels tensors for the selected classes and recordings
+    predictions, labels, classes = processor.get_filtered_tensors(selected_classes, selected_recordings)
+
+    num_classes = len(classes)
+    task = "binary" if num_classes == 1 else "multilabel"
+
+    # Initialize the PerformanceAssessor for computing metrics
+    pa = PerformanceAssessor(
+        num_classes=num_classes,
+        threshold=threshold,
+        classes=classes,
+        task=task,
+        metrics_list=metrics_list,
+    )
+
+    # Compute performance metrics
+    metrics_df = pa.calculate_metrics(predictions, labels, per_class_metrics=class_wise)
+
+    return metrics_df, pa, predictions, labels
+
+
+def main():
+    """
+    Entry point for the script. Parses command-line arguments and orchestrates the performance assessment pipeline.
+    """
+    # Set up argument parsing
+    parser = argparse.ArgumentParser(description="Performance Assessor Core Script")
+    parser.add_argument("--annotation_path", required=True, help="Path to annotation file or folder")
+    parser.add_argument("--prediction_path", required=True, help="Path to prediction file or folder")
+    parser.add_argument("--mapping_path", help="Path to class mapping JSON file (optional)")
+    parser.add_argument("--sample_duration", type=float, default=3.0, help="Sample duration in seconds")
+    parser.add_argument("--min_overlap", type=float, default=0.5, help="Minimum overlap in seconds")
+    parser.add_argument("--recording_duration", type=float, help="Recording duration in seconds")
+    parser.add_argument("--columns_annotations", type=json.loads, help="JSON string for columns_annotations")
+    parser.add_argument("--columns_predictions", type=json.loads, help="JSON string for columns_predictions")
+    parser.add_argument("--selected_classes", nargs="+", help="List of selected classes")
+    parser.add_argument("--selected_recordings", nargs="+", help="List of selected recordings")
+    parser.add_argument("--metrics", nargs="+", default=["accuracy", "precision", "recall"], help="List of metrics")
+    parser.add_argument("--threshold", type=float, default=0.1, help="Threshold value (0-1)")
+    parser.add_argument("--class_wise", action="store_true", help="Calculate class-wise metrics")
+    parser.add_argument("--plot_metrics", action="store_true", help="Plot metrics")
+    parser.add_argument("--plot_confusion_matrix", action="store_true", help="Plot confusion matrix")
+    parser.add_argument("--plot_metrics_all_thresholds", action="store_true", help="Plot metrics for all thresholds")
+    parser.add_argument("--output_dir", help="Directory to save plots")
+
+    # Parse arguments
+    args = parser.parse_args()
+
+    # Process data and compute metrics
+    metrics_df, pa, predictions, labels = process_data(
+        annotation_path=args.annotation_path,
+        prediction_path=args.prediction_path,
+        mapping_path=args.mapping_path,
+        sample_duration=args.sample_duration,
+        min_overlap=args.min_overlap,
+        recording_duration=args.recording_duration,
+        columns_annotations=args.columns_annotations,
+        columns_predictions=args.columns_predictions,
+        selected_classes=args.selected_classes,
+        selected_recordings=args.selected_recordings,
+        metrics_list=args.metrics,
+        threshold=args.threshold,
+        class_wise=args.class_wise,
+    )
+
+    # Display the computed metrics
+    print(metrics_df)
+
+    # Create output directory if needed
+    if args.output_dir and not os.path.exists(args.output_dir):
+        os.makedirs(args.output_dir)
+
+    # Generate plots if specified
+    if args.plot_metrics:
+        pa.plot_metrics(predictions, labels, per_class_metrics=args.class_wise)
+        if args.output_dir:
+            import matplotlib.pyplot as plt
+
+            plt.savefig(os.path.join(args.output_dir, "metrics_plot.png"))
+        else:
+            plt.show()
+
+    if args.plot_confusion_matrix:
+        pa.plot_confusion_matrix(predictions, labels)
+        if args.output_dir:
+            import matplotlib.pyplot as plt
+
+            plt.savefig(os.path.join(args.output_dir, "confusion_matrix.png"))
+        else:
+            plt.show()
+
+    if args.plot_metrics_all_thresholds:
+        pa.plot_metrics_all_thresholds(predictions, labels, per_class_metrics=args.class_wise)
+        if args.output_dir:
+            import matplotlib.pyplot as plt
+
+            plt.savefig(os.path.join(args.output_dir, "metrics_all_thresholds.png"))
+        else:
+            plt.show()

birdnet_analyzer/evaluation/__main__.py

@@ -0,0 +1,3 @@
+from birdnet_analyzer.evaluation import main
+
+main()

birdnet_analyzer/gui/__init__.py

@@ -0,0 +1,23 @@
+def main():
+    import birdnet_analyzer.gui.multi_file as mfa
+    import birdnet_analyzer.gui.review as review
+    import birdnet_analyzer.gui.segments as gs
+    import birdnet_analyzer.gui.single_file as sfa
+    import birdnet_analyzer.gui.species as species
+    import birdnet_analyzer.gui.train as train
+    import birdnet_analyzer.gui.utils as gu
+    import birdnet_analyzer.gui.embeddings as embeddings
+    import birdnet_analyzer.gui.evaluation as evaluation
+
+    gu.open_window(
+        [
+            sfa.build_single_analysis_tab,
+            mfa.build_multi_analysis_tab,
+            train.build_train_tab,
+            gs.build_segments_tab,
+            review.build_review_tab,
+            species.build_species_tab,
+            embeddings.build_embeddings_tab,
+            evaluation.build_evaluation_tab,
+        ]
+    )

birdnet_analyzer/gui/__main__.py

@@ -0,0 +1,3 @@
+from birdnet_analyzer.gui import main
+
+main()

birdnet_analyzer/gui/analysis.py

@@ -0,0 +1,174 @@
+import concurrent.futures
+import os
+from pathlib import Path
+
+import gradio as gr
+
+import birdnet_analyzer.config as cfg
+import birdnet_analyzer.gui.utils as gu
+import birdnet_analyzer.gui.localization as loc
+import birdnet_analyzer.model as model
+
+
+from birdnet_analyzer.analyze.utils import analyze_file, combine_results, save_analysis_params
+
+SCRIPT_DIR = os.path.abspath(os.path.dirname(__file__))
+ORIGINAL_LABELS_FILE = str(Path(SCRIPT_DIR).parent / cfg.LABELS_FILE)
+
+
+def analyze_file_wrapper(entry):
+    """
+    Wrapper function for analyzing a file.
+
+    Args:
+        entry (tuple): A tuple where the first element is the file path and the
+                       remaining elements are arguments to be passed to the
+                       analyze.analyzeFile function.
+
+    Returns:
+        tuple: A tuple where the first element is the file path and the second
+               element is the result of the analyze.analyzeFile function.
+    """
+    return (entry[0], analyze_file(entry))
+
+
+def run_analysis(
+    input_path: str,
+    output_path: str | None,
+    use_top_n: bool,
+    top_n: int,
+    confidence: float,
+    sensitivity: float,
+    overlap: float,
+    merge_consecutive: int,
+    audio_speed: float,
+    fmin: int,
+    fmax: int,
+    species_list_choice: str,
+    species_list_file,
+    lat: float,
+    lon: float,
+    week: int,
+    use_yearlong: bool,
+    sf_thresh: float,
+    custom_classifier_file,
+    output_types: str,
+    combine_tables: bool,
+    locale: str,
+    batch_size: int,
+    threads: int,
+    input_dir: str,
+    skip_existing: bool,
+    save_params: bool,
+    progress: gr.Progress | None,
+):
+    """Starts the analysis.
+
+    Args:
+        input_path: Either a file or directory.
+        output_path: The output path for the result, if None the input_path is used
+        confidence: The selected minimum confidence.
+        sensitivity: The selected sensitivity.
+        overlap: The selected segment overlap.
+        merge_consecutive: The number of consecutive segments to merge into one.
+        audio_speed: The selected audio speed.
+        fmin: The selected minimum bandpass frequency.
+        fmax: The selected maximum bandpass frequency.
+        species_list_choice: The choice for the species list.
+        species_list_file: The selected custom species list file.
+        lat: The selected latitude.
+        lon: The selected longitude.
+        week: The selected week of the year.
+        use_yearlong: Use yearlong instead of week.
+        sf_thresh: The threshold for the predicted species list.
+        custom_classifier_file: Custom classifier to be used.
+        output_type: The type of result to be generated.
+        output_filename: The filename for the combined output.
+        locale: The translation to be used.
+        batch_size: The number of samples in a batch.
+        threads: The number of threads to be used.
+        input_dir: The input directory.
+        progress: The gradio progress bar.
+    """
+    if progress is not None:
+        progress(0, desc=f"{loc.localize('progress-preparing')} ...")
+
+    from birdnet_analyzer.analyze.core import _set_params
+
+    locale = locale.lower()
+    custom_classifier = custom_classifier_file if species_list_choice == gu._CUSTOM_CLASSIFIER else None
+    slist = species_list_file if species_list_choice == gu._CUSTOM_SPECIES else None
+    lat = lat if species_list_choice == gu._PREDICT_SPECIES else -1
+    lon = lon if species_list_choice == gu._PREDICT_SPECIES else -1
+    week = -1 if use_yearlong else week
+
+    flist = _set_params(
+        input=input_dir if input_dir else input_path,
+        min_conf=confidence,
+        custom_classifier=custom_classifier,
+        sensitivity=min(1.25, max(0.75, float(sensitivity))),
+        locale=locale,
+        overlap=max(0.0, min(2.9, float(overlap))),
+        merge_consecutive=max(1, int(merge_consecutive)),
+        audio_speed=max(0.1, 1.0 / (audio_speed * -1)) if audio_speed < 0 else max(1.0, float(audio_speed)),
+        fmin=max(0, min(cfg.SIG_FMAX, int(fmin))),
+        fmax=max(cfg.SIG_FMIN, min(cfg.SIG_FMAX, int(fmax))),
+        bs=max(1, int(batch_size)),
+        combine_results=combine_tables,
+        rtype=output_types,
+        skip_existing_results=skip_existing,
+        threads=max(1, int(threads)),
+        labels_file=ORIGINAL_LABELS_FILE,
+        sf_thresh=sf_thresh,
+        lat=lat,
+        lon=lon,
+        week=week,
+        slist=slist,
+        top_n=top_n if use_top_n else None,
+        output=output_path,
+    )
+
+    if species_list_choice == gu._CUSTOM_CLASSIFIER:
+        if custom_classifier_file is None:
+            raise gr.Error(loc.localize("validation-no-custom-classifier-selected"))
+
+        model.reset_custom_classifier()
+
+    gu.validate(cfg.FILE_LIST, loc.localize("validation-no-audio-files-found"))
+
+    result_list = []
+
+    if progress is not None:
+        progress(0, desc=f"{loc.localize('progress-starting')} ...")
+
+    # Analyze files
+    if cfg.CPU_THREADS < 2:
+        for entry in flist:
+            result_list.append(analyze_file_wrapper(entry))
+    else:
+        with concurrent.futures.ProcessPoolExecutor(max_workers=cfg.CPU_THREADS) as executor:
+            futures = (executor.submit(analyze_file_wrapper, arg) for arg in flist)
+            for i, f in enumerate(concurrent.futures.as_completed(futures), start=1):
+                if progress is not None:
+                    progress((i, len(flist)), total=len(flist), unit="files")
+                result = f.result()
+
+                result_list.append(result)
+
+    # Combine results?
+    if cfg.COMBINE_RESULTS:
+        combine_list = [[r[1] for r in result_list if r[0] == i[0]][0] for i in flist]
+        print(f"Combining results, writing to {cfg.OUTPUT_PATH}...", end="", flush=True)
+        combine_results(combine_list)
+        print("done!", flush=True)
+
+    if save_params:
+        save_analysis_params(os.path.join(cfg.OUTPUT_PATH, cfg.ANALYSIS_PARAMS_FILENAME))
+
+    return (
+        [[os.path.relpath(r[0], input_dir), bool(r[1])] for r in result_list]
+        if input_dir
+        else result_list[0][1]["csv"]
+        if result_list[0][1]
+        else None
+    )