birdnet-analyzer 2.0.0__py3-none-any.whl

birdnet_analyzer/gui/segments.py

@@ -0,0 +1,191 @@
+import concurrent.futures
+import os
+from functools import partial
+
+import gradio as gr
+
+import birdnet_analyzer.config as cfg
+import birdnet_analyzer.gui.utils as gu
+import birdnet_analyzer.gui.localization as loc
+
+from birdnet_analyzer.segments.utils import extract_segments
+
+def extract_segments_wrapper(entry):
+    return (entry[0][0], extract_segments(entry))
+
+
+@gu.gui_runtime_error_handler
+def _extract_segments(
+    audio_dir, result_dir, output_dir, min_conf, num_seq, audio_speed, seq_length, threads, progress=gr.Progress()
+):
+    from birdnet_analyzer.segments.utils import parse_folders, parse_files
+
+    gu.validate(audio_dir, loc.localize("validation-no-audio-directory-selected"))
+
+    if not result_dir:
+        result_dir = audio_dir
+
+    if not output_dir:
+        output_dir = audio_dir
+
+    if progress is not None:
+        progress(0, desc=f"{loc.localize('progress-search')} ...")
+
+    # Parse audio and result folders
+    cfg.FILE_LIST = parse_folders(audio_dir, result_dir)
+
+    # Set output folder
+    cfg.OUTPUT_PATH = output_dir
+
+    # Set number of threads
+    cfg.CPU_THREADS = int(threads)
+
+    # Set confidence threshold
+    cfg.MIN_CONFIDENCE = max(0.01, min(0.99, min_conf))
+
+    # Parse file list and make list of segments
+    cfg.FILE_LIST = parse_files(cfg.FILE_LIST, max(1, int(num_seq)))
+
+    # Audio speed
+    cfg.AUDIO_SPEED = max(0.1, 1.0 / (audio_speed * -1)) if audio_speed < 0 else max(1.0, float(audio_speed))
+
+    # 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 = [(entry, max(cfg.SIG_LENGTH, float(seq_length)), cfg.getConfig()) for entry in cfg.FILE_LIST]
+    flist = [(entry, float(seq_length), cfg.get_config()) for entry in cfg.FILE_LIST]
+
+    result_list = []
+
+    # Extract segments
+    if cfg.CPU_THREADS < 2:
+        for i, entry in enumerate(flist):
+            result = extract_segments_wrapper(entry)
+            result_list.append(result)
+
+            if progress is not None:
+                progress((i, len(flist)), total=len(flist), unit="files")
+    else:
+        with concurrent.futures.ProcessPoolExecutor(max_workers=cfg.CPU_THREADS) as executor:
+            futures = (executor.submit(extract_segments_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)
+
+    return [[os.path.relpath(r[0], audio_dir), r[1]] for r in result_list]
+
+
+def build_segments_tab():
+    with gr.Tab(loc.localize("segments-tab-title")):
+        audio_directory_state = gr.State()
+        result_directory_state = gr.State()
+        output_directory_state = gr.State()
+
+        def select_directory_to_state_and_tb(state_key):
+            return (gu.select_directory(collect_files=False, state_key=state_key),) * 2
+
+        with gr.Row():
+            select_audio_directory_btn = gr.Button(
+                loc.localize("segments-tab-select-audio-input-directory-button-label")
+            )
+            selected_audio_directory_tb = gr.Textbox(show_label=False, interactive=False)
+            select_audio_directory_btn.click(
+                partial(select_directory_to_state_and_tb, state_key="segments-audio-dir"),
+                outputs=[selected_audio_directory_tb, audio_directory_state],
+                show_progress=False,
+            )
+
+        with gr.Row():
+            select_result_directory_btn = gr.Button(
+                loc.localize("segments-tab-select-results-input-directory-button-label")
+            )
+            selected_result_directory_tb = gr.Textbox(
+                show_label=False,
+                interactive=False,
+                placeholder=loc.localize("segments-tab-results-input-textbox-placeholder"),
+            )
+            select_result_directory_btn.click(
+                partial(select_directory_to_state_and_tb, state_key="segments-result-dir"),
+                outputs=[result_directory_state, selected_result_directory_tb],
+                show_progress=False,
+            )
+
+        with gr.Row():
+            select_output_directory_btn = gr.Button(loc.localize("segments-tab-output-selection-button-label"))
+            selected_output_directory_tb = gr.Textbox(
+                show_label=False,
+                interactive=False,
+                placeholder=loc.localize("segments-tab-output-selection-textbox-placeholder"),
+            )
+            select_output_directory_btn.click(
+                partial(select_directory_to_state_and_tb, state_key="segments-output-dir"),
+                outputs=[selected_output_directory_tb, output_directory_state],
+                show_progress=False,
+            )
+
+        min_conf_slider = gr.Slider(
+            minimum=0.1,
+            maximum=0.99,
+            step=0.01,
+            value=cfg.MIN_CONFIDENCE,
+            label=loc.localize("segments-tab-min-confidence-slider-label"),
+            info=loc.localize("segments-tab-min-confidence-slider-info"),
+        )
+        num_seq_number = gr.Number(
+            100,
+            label=loc.localize("segments-tab-max-seq-number-label"),
+            info=loc.localize("segments-tab-max-seq-number-info"),
+            minimum=1,
+        )
+        audio_speed_slider = gr.Slider(
+            minimum=-10,
+            maximum=10,
+            value=cfg.AUDIO_SPEED,
+            step=1,
+            label=loc.localize("inference-settings-audio-speed-slider-label"),
+            info=loc.localize("inference-settings-audio-speed-slider-info"),
+        )
+        seq_length_number = gr.Number(
+            cfg.SIG_LENGTH,
+            label=loc.localize("segments-tab-seq-length-number-label"),
+            info=loc.localize("segments-tab-seq-length-number-info"),
+            minimum=0.1,
+        )
+        threads_number = gr.Number(
+            4,
+            label=loc.localize("segments-tab-threads-number-label"),
+            info=loc.localize("segments-tab-threads-number-info"),
+            minimum=1,
+        )
+
+        extract_segments_btn = gr.Button(loc.localize("segments-tab-extract-button-label"), variant="huggingface")
+
+        result_grid = gr.Matrix(
+            headers=[
+                loc.localize("segments-tab-result-dataframe-column-file-header"),
+                loc.localize("segments-tab-result-dataframe-column-execution-header"),
+            ],
+        )
+
+        extract_segments_btn.click(
+            _extract_segments,
+            inputs=[
+                audio_directory_state,
+                result_directory_state,
+                output_directory_state,
+                min_conf_slider,
+                num_seq_number,
+                audio_speed_slider,
+                seq_length_number,
+                threads_number,
+            ],
+            outputs=result_grid,
+        )
+
+
+if __name__ == "__main__":
+    gu.open_window(build_segments_tab)

birdnet_analyzer/gui/settings.py

@@ -0,0 +1,129 @@
+import os
+from pathlib import Path
+import json
+
+import birdnet_analyzer.gui.utils as gu
+import birdnet_analyzer.utils as utils
+
+
+FALLBACK_LANGUAGE = "en"
+SCRIPT_DIR = os.path.abspath(os.path.dirname(__file__))
+GUI_SETTINGS_PATH = os.path.join(gu.APPDIR if utils.FROZEN else os.path.dirname(SCRIPT_DIR), "gui-settings.json")
+LANG_DIR = str(Path(SCRIPT_DIR).parent / "lang")
+STATE_SETTINGS_PATH = os.path.join(gu.APPDIR if utils.FROZEN else os.path.dirname(SCRIPT_DIR), "state.json")
+
+
+def get_state_dict() -> dict:
+    """
+    Retrieves the state dictionary from a JSON file specified by STATE_SETTINGS_PATH.
+
+    If the file does not exist, it creates an empty JSON file and returns an empty dictionary.
+    If any other exception occurs during file operations, it logs the error and returns an empty dictionary.
+
+    Returns:
+        dict: The state dictionary loaded from the JSON file, or an empty dictionary if the file does not exist or an error occurs.
+    """
+    try:
+        with open(STATE_SETTINGS_PATH, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        try:
+            with open(STATE_SETTINGS_PATH, "w", encoding="utf-8") as f:
+                json.dump({}, f)
+            return {}
+        except Exception as e:
+            utils.write_error_log(e)
+            return {}
+
+
+def get_state(key: str, default=None) -> str:
+    """
+    Retrieves the value associated with the given key from the state dictionary.
+
+    Args:
+        key (str): The key to look up in the state dictionary.
+        default: The value to return if the key is not found. Defaults to None.
+
+    Returns:
+        str: The value associated with the key if found, otherwise the default value.
+    """
+    return get_state_dict().get(key, default)
+
+
+def set_state(key: str, value: str):
+    """
+    Updates the state dictionary with the given key-value pair and writes it to a JSON file.
+
+    Args:
+        key (str): The key to update in the state dictionary.
+        value (str): The value to associate with the key in the state dictionary.
+    """
+    try:
+        state = get_state_dict()
+        state[key] = value
+
+        with open(STATE_SETTINGS_PATH, "w") as f:
+            json.dump(state, f, indent=4)
+    except Exception as e:
+        utils.write_error_log(e)
+
+
+def ensure_settings_file():
+    """
+    Ensures that the settings file exists at the specified path. If the file does not exist,
+    it creates a new settings file with default settings.
+
+    If the file creation fails, the error is logged.
+    """
+    if not os.path.exists(GUI_SETTINGS_PATH):
+        try:
+            with open(GUI_SETTINGS_PATH, "w") as f:
+                settings = {"language-id": FALLBACK_LANGUAGE, "theme": "light"}
+                f.write(json.dumps(settings, indent=4))
+        except Exception as e:
+            utils.write_error_log(e)
+
+
+def get_setting(key, default=None):
+    """
+    Retrieves the value associated with the given key from the settings file.
+
+    Args:
+        key (str): The key to look up in the settings file.
+        default: The value to return if the key is not found. Defaults to None.
+
+    Returns:
+        str: The value associated with the key if found, otherwise the default value.
+    """
+    ensure_settings_file()
+
+    try:
+        with open(GUI_SETTINGS_PATH, "r", encoding="utf-8") as f:
+            settings_dict: dict = json.load(f)
+
+            return settings_dict.get(key, default)
+    except FileNotFoundError:
+        return default
+
+
+def set_setting(key, value):
+    ensure_settings_file()
+    settings_dict = {}
+
+    try:
+        with open(GUI_SETTINGS_PATH, "r+", encoding="utf-8") as f:
+            settings_dict = json.load(f)
+            settings_dict[key] = value
+            f.seek(0)
+            json.dump(settings_dict, f, indent=4)
+            f.truncate()
+
+    except FileNotFoundError:
+        pass
+
+
+def theme():
+    options = ("light", "dark")
+    current_time = get_setting("theme", "light")
+
+    return current_time if current_time in options else "light"

birdnet_analyzer/gui/single_file.py

@@ -0,0 +1,269 @@
+import os
+
+import gradio as gr
+
+import birdnet_analyzer.audio as audio
+import birdnet_analyzer.config as cfg
+import birdnet_analyzer.gui.localization as loc
+import birdnet_analyzer.gui.utils as gu
+import birdnet_analyzer.utils as utils
+
+
+@gu.gui_runtime_error_handler
+def run_single_file_analysis(
+    input_path,
+    use_top_n,
+    top_n,
+    confidence,
+    sensitivity,
+    overlap,
+    merge_consecutive,
+    audio_speed,
+    fmin,
+    fmax,
+    species_list_choice,
+    species_list_file,
+    lat,
+    lon,
+    week,
+    use_yearlong,
+    sf_thresh,
+    custom_classifier_file,
+    locale,
+):
+    import csv
+    from datetime import timedelta
+
+    from birdnet_analyzer.gui.analysis import run_analysis
+
+    if species_list_choice == gu._CUSTOM_SPECIES:
+        gu.validate(species_list_file, loc.localize("validation-no-species-list-selected"))
+
+    gu.validate(input_path, loc.localize("validation-no-file-selected"))
+
+    if fmin is None or fmax is None or fmin < cfg.SIG_FMIN or fmax > cfg.SIG_FMAX or fmin > fmax:
+        raise gr.Error(f"{loc.localize('validation-no-valid-frequency')} [{cfg.SIG_FMIN}, {cfg.SIG_FMAX}]")
+
+    result_filepath = run_analysis(
+        input_path,
+        None,
+        use_top_n,
+        top_n,
+        confidence,
+        sensitivity,
+        overlap,
+        merge_consecutive,
+        audio_speed,
+        fmin,
+        fmax,
+        species_list_choice,
+        species_list_file,
+        lat,
+        lon,
+        week,
+        use_yearlong,
+        sf_thresh,
+        custom_classifier_file,
+        "csv",
+        None,
+        "en" if not locale else locale,
+        1,
+        4,
+        None,
+        skip_existing=False,
+        save_params=False,
+        progress=None,
+    )
+
+    if not result_filepath:
+        raise gr.Error(loc.localize("single-tab-analyze-file-error"))
+
+    # read the result file to return the data to be displayed.
+    with open(result_filepath, "r", encoding="utf-8") as f:
+        reader = csv.reader(f)
+        data = list(reader)
+        data = [lc[0:-1] for lc in data[1:]]  # remove last column (file path) and first row (header)
+
+        for row in data:
+            for col_idx in range(2):
+                seconds = float(row[col_idx])
+                time_str = str(timedelta(seconds=seconds))
+
+                if "." in time_str:
+                    time_str = time_str[: time_str.index(".") + 2]
+
+                row[col_idx] = time_str
+            row.insert(0, "▶")
+
+    return data, gr.update(visible=True), result_filepath
+
+
+def build_single_analysis_tab():
+    with gr.Tab(loc.localize("single-tab-title")):
+        audio_input = gr.Audio(type="filepath", label=loc.localize("single-audio-label"), sources=["upload"])
+
+        with gr.Group():
+            spectogram_output = gr.Plot(
+                label=loc.localize("review-tab-spectrogram-plot-label"), visible=False, show_label=False
+            )
+            generate_spectrogram_cb = gr.Checkbox(
+                value=True,
+                label=loc.localize("single-tab-spectrogram-checkbox-label"),
+                info=loc.localize("single-tab-spectrogram-checkbox-info"),
+            )
+        audio_path_state = gr.State()
+        table_path_state = gr.State()
+
+        (
+            use_top_n,
+            top_n_input,
+            confidence_slider,
+            sensitivity_slider,
+            overlap_slider,
+            merge_consecutive_slider,
+            audio_speed_slider,
+            fmin_number,
+            fmax_number,
+        ) = gu.sample_sliders(False)
+
+        (
+            species_list_radio,
+            species_file_input,
+            lat_number,
+            lon_number,
+            week_number,
+            sf_thresh_number,
+            yearlong_checkbox,
+            selected_classifier_state,
+            map_plot,
+        ) = gu.species_lists(False)
+        locale_radio = gu.locale()
+
+        single_file_analyze = gr.Button(
+            loc.localize("analyze-start-button-label"), variant="huggingface", interactive=False
+        )
+
+        with gr.Row(visible=False) as action_row:
+            table_download_button = gr.Button(
+                loc.localize("single-tab-download-button-label"),
+            )
+            segment_audio = gr.Audio(
+                autoplay=True, type="numpy", show_download_button=True, show_label=False, editable=False, visible=False
+            )
+
+        output_dataframe = gr.Dataframe(
+            type="pandas",
+            headers=[
+                "",
+                loc.localize("single-tab-output-header-start"),
+                loc.localize("single-tab-output-header-end"),
+                loc.localize("single-tab-output-header-sci-name"),
+                loc.localize("single-tab-output-header-common-name"),
+                loc.localize("single-tab-output-header-confidence"),
+            ],
+            elem_id="single-file-output",
+            interactive=False,
+        )
+
+        def get_audio_path(i, generate_spectrogram):
+            if i:
+                try:
+                    return (
+                        i["path"],
+                        gr.Audio(label=os.path.basename(i["path"])),
+                        gr.Plot(visible=True, value=utils.spectrogram_from_file(i["path"], fig_size=(20, 4)))
+                        if generate_spectrogram
+                        else gr.Plot(visible=False),
+                        gr.Button(interactive=True),
+                    )
+                except:
+                    raise gr.Error(loc.localize("single-tab-generate-spectrogram-error"))
+            else:
+                return None, None, gr.Plot(visible=False), gr.update(interactive=False)
+
+        def try_generate_spectrogram(audio_path, generate_spectrogram):
+            if audio_path and generate_spectrogram:
+                try:
+                    return gr.Plot(
+                        visible=True, value=utils.spectrogram_from_file(audio_path["path"], fig_size=(20, 4))
+                    )
+                except:
+                    raise gr.Error(loc.localize("single-tab-generate-spectrogram-error"))
+            else:
+                return gr.Plot()
+
+        generate_spectrogram_cb.change(
+            try_generate_spectrogram,
+            inputs=[audio_input, generate_spectrogram_cb],
+            outputs=spectogram_output,
+            preprocess=False,
+        )
+
+        audio_input.change(
+            get_audio_path,
+            inputs=[audio_input, generate_spectrogram_cb],
+            outputs=[audio_path_state, audio_input, spectogram_output, single_file_analyze],
+            preprocess=False,
+        )
+
+        inputs = [
+            audio_path_state,
+            use_top_n,
+            top_n_input,
+            confidence_slider,
+            sensitivity_slider,
+            overlap_slider,
+            merge_consecutive_slider,
+            audio_speed_slider,
+            fmin_number,
+            fmax_number,
+            species_list_radio,
+            species_file_input,
+            lat_number,
+            lon_number,
+            week_number,
+            yearlong_checkbox,
+            sf_thresh_number,
+            selected_classifier_state,
+            locale_radio,
+        ]
+
+        def time_to_seconds(time_str):
+            try:
+                hours, minutes, seconds = time_str.split(":")
+                total_seconds = int(hours) * 3600 + int(minutes) * 60 + float(seconds)
+                return total_seconds
+
+            except ValueError as e:
+                raise ValueError("Input must be in the format hh:mm:ss or hh:mm:ss.ssssss with numeric values.") from e
+
+        def get_selected_audio(evt: gr.SelectData, audio_path):
+            if evt.index[1] == 0 and evt.row_value[1] and evt.row_value[2]:
+                start = time_to_seconds(evt.row_value[1])
+                end = time_to_seconds(evt.row_value[2])
+
+                data, sr = audio.open_audio_file(audio_path, offset=start, duration=end - start)
+                return gr.update(visible=True, value=(sr, data))
+
+            return gr.update()
+
+        def download_table(filepath):
+            if filepath:
+                ext = os.path.splitext(filepath)[1]
+                gu.save_file_dialog(
+                    state_key="single-file-table",
+                    default_filename=os.path.basename(filepath),
+                    filetypes=(f"{ext[1:]} (*{ext})",),
+                )
+
+        output_dataframe.select(get_selected_audio, inputs=audio_path_state, outputs=segment_audio)
+        single_file_analyze.click(
+            run_single_file_analysis, inputs=inputs, outputs=[output_dataframe, action_row, table_path_state]
+        )
+        table_download_button.click(download_table, inputs=table_path_state)
+
+    return lat_number, lon_number, map_plot
+
+
+if __name__ == "__main__":
+    gu.open_window(build_single_analysis_tab)

birdnet_analyzer/gui/species.py

@@ -0,0 +1,95 @@
+import os
+
+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.gui.settings as settings
+
+
+@gu.gui_runtime_error_handler
+def run_species_list(out_path, filename, lat, lon, week, use_yearlong, sf_thresh, sortby):
+    from birdnet_analyzer.species.utils import run
+
+    gu.validate(out_path, loc.localize("validation-no-directory-selected"))
+
+    run(
+        os.path.join(out_path, filename if filename else "species_list.txt"),
+        lat,
+        lon,
+        -1 if use_yearlong else week,
+        sf_thresh,
+        sortby,
+    )
+
+    gr.Info(f"{loc.localize('species-tab-finish-info')} {cfg.OUTPUT_PATH}")
+
+
+def build_species_tab():
+    with gr.Tab(loc.localize("species-tab-title")) as species_tab:
+        output_directory_state = gr.State()
+        select_directory_btn = gr.Button(loc.localize("species-tab-select-output-directory-button-label"))
+        classifier_name = gr.Textbox(
+            "species_list.txt",
+            visible=False,
+            info=loc.localize("species-tab-filename-textbox-label"),
+        )
+
+        def select_directory_and_update_tb(name_tb):
+            dir_name = gu.select_folder(state_key="species-output-dir")
+
+            if dir_name:
+                settings.set_state("species-output-dir", dir_name)
+                return (
+                    dir_name,
+                    gr.Textbox(label=dir_name, visible=True, value=name_tb),
+                )
+
+            return None, name_tb
+
+        select_directory_btn.click(
+            select_directory_and_update_tb,
+            inputs=classifier_name,
+            outputs=[output_directory_state, classifier_name],
+            show_progress=False,
+        )
+
+        lat_number, lon_number, week_number, sf_thresh_number, yearlong_checkbox, map_plot = (
+            gu.species_list_coordinates(show_map=True)
+        )
+
+        sortby = gr.Radio(
+            [
+                (loc.localize("species-tab-sort-radio-option-frequency"), "freq"),
+                (loc.localize("species-tab-sort-radio-option-alphabetically"), "alpha"),
+            ],
+            value="freq",
+            label=loc.localize("species-tab-sort-radio-label"),
+            info=loc.localize("species-tab-sort-radio-info"),
+        )
+
+        start_btn = gr.Button(loc.localize("species-tab-start-button-label"), variant="huggingface")
+        start_btn.click(
+            run_species_list,
+            inputs=[
+                output_directory_state,
+                classifier_name,
+                lat_number,
+                lon_number,
+                week_number,
+                yearlong_checkbox,
+                sf_thresh_number,
+                sortby,
+            ],
+        )
+
+    species_tab.select(
+        lambda lat, lon: gu.plot_map_scatter_mapbox(lat, lon, zoom=3), inputs=[lat_number, lon_number], outputs=map_plot
+    )
+
+    return lat_number, lon_number, map_plot
+
+
+if __name__ == "__main__":
+    gu.open_window(build_species_tab)