audio-tuner-gui 0.9.1__tar.gz → 0.11.0__tar.gz

{audio_tuner_gui-0.9.1 → audio_tuner_gui-0.11.0}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: audio-tuner-gui
-Version: 0.9.1
+Version: 0.11.0
 Summary: Graphical interface for Audio Tuner
 Project-URL: Homepage, https://codeberg.org/bluesloth/audio_tuner
 Project-URL: Repository, https://codeberg.org/bluesloth/audio_tuner.git
 Project-URL: Issues, https://codeberg.org/bluesloth/audio_tuner/issues
-Project-URL: Documentation, https://audio-tuner.readthedocs.io/en/latest/
+Project-URL: Documentation, https://audio-tuner.readthedocs.io/
+Project-URL: News, https://codeberg.org/bluesloth/audio_tuner/src/branch/master/NEWS
 Author-email: Jessie Blue Cassell <bluesloth600@gmail.com>
 License-File: COPYING
 Keywords: audio,music,pitch shift,player,tempo shift,tuning
@@ -48,6 +49,23 @@ What it's not
 Audio Tuner is not autotune.  It pitch corrects entire songs, not individual
 notes.
 
+Dependencies
+~~~~~~~~~~~~
+
+**audio-tuner-gui** requires **Python version 3.11 or higher**, **libmpv2**,
+and the `audio-tuner`_ and `PyQt6`_ python packages.
+
+Note that pip is not able to install **libmpv2**.  If your operating system
+has a package manager, use that to install it.  See the `documentation`_
+for details.
+
+Audio Tuner can be configured to use **ffmpeg** and **ffprobe** instead of
+libmpv2, at the cost of reduced functionality in the GUI.
+
+.. _documentation: https://audio-tuner.readthedocs.io/
+.. _audio-tuner: https://pypi.org/project/audio-tuner/
+.. _PyQt6: https://www.riverbankcomputing.com/software/pyqt/
+
 Free as in Freedom
 ~~~~~~~~~~~~~~~~~~
 
@@ -75,19 +93,7 @@ stable, but of course nothing's guaranteed until it reaches version 1.0.0.
 .. _Semantic Versioning: https://semver.org
 .. _PEP 440: https://peps.python.org/pep-0440/
 
-Dependencies
-~~~~~~~~~~~~
-
-**audio-tuner-gui** requires **Python version 3.11 or higher**, **libmpv2**,
-and the **audio-tuner** and **PyQt6** python packages.
-
-Audio Tuner can be configured to use **ffmpeg** and **ffprobe** instead of
-libmpv2, at the cost of reduced functionality in the GUI.
-
 See Also
 ~~~~~~~~
 
-See the `html documentation`_ for more information and detailed installation
-instructions.
-
-.. _html documentation: https://audio-tuner.readthedocs.io/en/latest/
+audio-tuner:  https://pypi.org/project/audio-tuner/

{audio_tuner_gui-0.9.1 → audio_tuner_gui-0.11.0}/README.rst

@@ -28,6 +28,23 @@ What it's not
 Audio Tuner is not autotune.  It pitch corrects entire songs, not individual
 notes.
 
+Dependencies
+~~~~~~~~~~~~
+
+**audio-tuner-gui** requires **Python version 3.11 or higher**, **libmpv2**,
+and the `audio-tuner`_ and `PyQt6`_ python packages.
+
+Note that pip is not able to install **libmpv2**.  If your operating system
+has a package manager, use that to install it.  See the `documentation`_
+for details.
+
+Audio Tuner can be configured to use **ffmpeg** and **ffprobe** instead of
+libmpv2, at the cost of reduced functionality in the GUI.
+
+.. _documentation: https://audio-tuner.readthedocs.io/
+.. _audio-tuner: https://pypi.org/project/audio-tuner/
+.. _PyQt6: https://www.riverbankcomputing.com/software/pyqt/
+
 Free as in Freedom
 ~~~~~~~~~~~~~~~~~~
 
@@ -55,19 +72,7 @@ stable, but of course nothing's guaranteed until it reaches version 1.0.0.
 .. _Semantic Versioning: https://semver.org
 .. _PEP 440: https://peps.python.org/pep-0440/
 
-Dependencies
-~~~~~~~~~~~~
-
-**audio-tuner-gui** requires **Python version 3.11 or higher**, **libmpv2**,
-and the **audio-tuner** and **PyQt6** python packages.
-
-Audio Tuner can be configured to use **ffmpeg** and **ffprobe** instead of
-libmpv2, at the cost of reduced functionality in the GUI.
-
 See Also
 ~~~~~~~~
 
-See the `html documentation`_ for more information and detailed installation
-instructions.
-
-.. _html documentation: https://audio-tuner.readthedocs.io/en/latest/
+audio-tuner:  https://pypi.org/project/audio-tuner/

{audio_tuner_gui-0.9.1 → audio_tuner_gui-0.11.0}/audio_tuner_gui/__init__.py

@@ -32,7 +32,7 @@ __all__ = [
 # Release candidates:  X.Y.ZrcN
 # Releases:  X.Y.Z
 
-VERSION = '0.9.1'
+VERSION = '0.11.0'
 
 from os.path import dirname
 

{audio_tuner_gui-0.9.1 → audio_tuner_gui-0.11.0}/audio_tuner_gui/analysis.py

@@ -38,6 +38,7 @@ from PyQt6.QtCore import (
                           pyqtSignal,
                           QThread,
                           QPersistentModelIndex,
+                          QModelIndex,
                          )
 from PyQt6.QtWidgets import (
                              QWidget,
@@ -84,6 +85,32 @@ class _AudioView(QTableView):
         self.setShowGrid(False)
 
 
+class _Result(anal.Analysis):
+    """A class that inherits from audio_tuner.analysis.Analysis and
+    extends it with a few more attributes necessary for the GUI.
+
+    Attributes
+    ----------
+    result_rows : list[audio_tuner_gui.common.RowData] | None
+        A list of RowData objects that can be passed to the
+        `update_data` method of audio_tuner_gui.display.Display, or None
+        if it hasn't been set yet.
+    options : audio_tuner_gui.common.Options | None
+        The options used to do the analysis, or None if it hasn't been
+        set yet.
+    index : PyQt6.QtCore.QPersistentModelIndex | None
+        The index of the results entry in the analyzed audio widget, or
+        None if it hasn't been set yet.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.result_rows = None
+        self.options = None
+        self.index = None
+
+
 class _Worker(QObject):
     """A worker class to be run in it's own thread that handles
     analysis.  Inherits from QObject.
@@ -107,23 +134,23 @@ class _Worker(QObject):
         The amount of progress, from 0 to 1.
     """
 
-    ResultReady = pyqtSignal(anal.Analysis)
+    ResultReady = pyqtSignal(_Result)
     """Signal emitted when analysis is finished and the result is ready.
 
     Parameters
     ----------
-    audio_tuner.analysis.Analysis
-        The analysis object that has finished with it's analysis.
+    _Result
+        The result of the analysis.
     """
 
-    ProcessingError = pyqtSignal(anal.Analysis)
-    """Signal emitted when the analysis object raises an exception
-    during analysis.
+    ProcessingError = pyqtSignal(_Result)
+    """Signal emitted when the _Result object raises an exception during
+    analysis.
 
     Parameters
     ----------
-    audio_tuner.analysis.Analysis
-        The analysis object.
+    _Result
+        The _Result object.
     """
 
     AddToLog = pyqtSignal(str, int)
@@ -147,9 +174,6 @@ class _Worker(QObject):
         The name of the option, as defined in audio_tuner_gui.common.
     """
 
-    def __init__(self):
-        super().__init__()
-
     def _progress_check(self, progress: float) -> bool:
         self.UpdateProgbar.emit(progress)
         return not QThread.currentThread().isInterruptionRequested()
@@ -168,24 +192,17 @@ class _Worker(QObject):
                 self.OptionError.emit(gcom.OPTION_END)
 
     def analyze(self,
-                analysis: anal.Analysis,
+                result: _Result,
                 options: gcom.Options,
                 reread_requested: bool) -> None:
-        """Do the analysis.  This gets passed an instance of
-        audio_tuner.analysis.Analysis, and then spits it out again via
-        the ResultReady signal when it's done (or via the
-        ProcessingError signal if it went wrong).  The Analysis instance
-        will have `result_rows` and `options` in addition to it's usual
-        attributes.  `result_rows` is a list of
-        audio_tuner_gui.common.RowData objects that can be passed to the
-        `update_data` method of audio_tuner_gui.display.Display, and
-        `options` is the audio_tuner_gui.common.Options object that was
-        passed to the `options` parameter of this method.
+        """Do the analysis.  This gets passed an instance of _Result,
+        and then spits it out again via the ResultReady signal when it's
+        done (or via the ProcessingError signal if it went wrong).
 
         Parameters
         ----------
-        analysis : audio_tuner.analysis.Analysis
-            The Analysis instance.
+        result : _Result
+            The _Result instance to put the results in.
         options : audio_tuner_gui.common.Options
             The analysis options.
         reread_requested : bool
@@ -195,44 +212,41 @@ class _Worker(QObject):
 
         if QThread.currentThread().isInterruptionRequested():
             return
-        analysis.try_sequence = options[gcom.OPTION_BACKENDS]
-        analysis.print_msg = self._print_msg
+        result.try_sequence = options[gcom.OPTION_BACKENDS]
+        result.print_msg = self._print_msg
         if (reread_requested
-          and (analysis.pitch != options[gcom.OPTION_PITCH]
-               or analysis.tempo != options[gcom.OPTION_TEMPO])):
-            analysis.pitch = options[gcom.OPTION_PITCH]
-            analysis.tempo = options[gcom.OPTION_TEMPO]
+          and (result.pitch != options[gcom.OPTION_PITCH]
+               or result.tempo != options[gcom.OPTION_TEMPO])):
+            result.pitch = options[gcom.OPTION_PITCH]
+            result.tempo = options[gcom.OPTION_TEMPO]
             redo_level = gcom.REDO_LEVEL_ALL
         else:
-            redo_level = options.redo_level(getattr(analysis, 'options', None))
-        basename = os.path.basename(analysis.inputfile)
+            redo_level = options.redo_level(result.options)
+        basename = os.path.basename(result.inputfile)
         self.UpdateStatusbar.emit('Analyzing ' + basename + '...')
         if redo_level >= gcom.REDO_LEVEL_ALL:
             try:
                 s = '\nLoading "' + basename + '"'
                 self.AddToLog.emit(s, lv.LOG_LEVEL_NORMAL)
                 size = 2**options[gcom.OPTION_SIZE_EXP]
-                if options[gcom.OPTION_PAD]:
-                    pad_amounts = (size * 2, size * 2)
-                else:
-                    pad_amounts = None
-                analysis.load_data(start=options[gcom.OPTION_START],
-                                   end=options[gcom.OPTION_END],
-                                   samplerate=options[gcom.OPTION_SAMPLERATE],
-                                   pad=pad_amounts)
+                pad_amounts = (size * 2, size * 2)
+                result.load_data(start=options[gcom.OPTION_START],
+                                 end=options[gcom.OPTION_END],
+                                 samplerate=options[gcom.OPTION_SAMPLERATE],
+                                 pad=pad_amounts)
             except eh.LoadError:
                 s = 'Error processing ' + basename
                 self.UpdateStatusbar.emit(s)
-                self.ProcessingError.emit(analysis)
+                self.ProcessingError.emit(result)
                 return
             try:
                 self.AddToLog.emit('Analyzing "' + basename + '"',
                                    lv.LOG_LEVEL_NORMAL)
-                analysis.fft(size=size, progress_hook=self._progress_check)
+                result.fft(size=size, progress_hook=self._progress_check)
             except eh.ShortError:
                 s = 'Error processing ' + basename
                 self.UpdateStatusbar.emit(s)
-                self.ProcessingError.emit(analysis)
+                self.ProcessingError.emit(result)
                 self.AddToLog.emit(eh.ERRMSG_SHORT,
                                    lv.LOG_LEVEL_ERROR)
                 return
@@ -243,16 +257,16 @@ class _Worker(QObject):
                                    lv.LOG_LEVEL_WARNING)
                 return
         if redo_level >= gcom.REDO_LEVEL_FIND_PEAKS:
-            analysis.find_peaks(
-                    low_cut=options[gcom.OPTION_LOW_CUT] * analysis.pitch,
-                    high_cut=options[gcom.OPTION_HIGH_CUT] * analysis.pitch,
+            result.find_peaks(
+                    low_cut=options[gcom.OPTION_LOW_CUT] * result.pitch,
+                    high_cut=options[gcom.OPTION_HIGH_CUT] * result.pitch,
                     max_peaks=options[gcom.OPTION_MAX_PEAKS],
                     dB_range=options[gcom.OPTION_DB_RANGE])
         if redo_level >= gcom.REDO_LEVEL_TUNING_SYSTEM:
-            peaks = analysis.peaks
+            peaks = result.peaks
             tuning_system = options.tuning_system
             result_rows = []
-            pitch_offset = options[gcom.OPTION_PITCH] / analysis.pitch
+            pitch_offset = options[gcom.OPTION_PITCH] / result.pitch
             for note in tuning_system(
                    options[gcom.OPTION_LOW_CUT] * options[gcom.OPTION_PITCH],
                    options[gcom.OPTION_HIGH_CUT] * options[gcom.OPTION_PITCH]):
@@ -268,11 +282,11 @@ class _Worker(QObject):
                         result_row['cents'] = -com.ratio_to_cents(freq_ratio)
                         result_row['correction'] = freq_ratio * pitch_offset
                         result_rows.append(result_row)
-            analysis.result_rows = result_rows
+            result.result_rows = result_rows
 
-        analysis.options = options
+        result.options = options
 
-        self.ResultReady.emit(analysis)
+        self.ResultReady.emit(result)
         self.UpdateProgbar.emit(-1)
         self.AddToLog.emit('Finished analyzing "' + basename + '"',
                            lv.LOG_LEVEL_NORMAL)
@@ -326,13 +340,13 @@ class AnalyzedAudio(QWidget):
         The amount of progress, from 0 to 1.
     """
 
-    AnalyzeAudio = pyqtSignal(anal.Analysis, gcom.Options, bool)
+    AnalyzeAudio = pyqtSignal(_Result, gcom.Options, bool)
     """Signal emitted to tell the worker thread to run an analysis.
 
     Parameters
     ----------
-    audio_tuner.analysis.Analysis
-        The analysis object to use.
+    _Result
+        The _Result object to use.
     audio_tuner_gui.common.Options
         The options.
     bool
@@ -405,7 +419,7 @@ class AnalyzedAudio(QWidget):
         self.current_duration = None
         self.current_metadata = None
 
-        self._analysis = {}
+        self._results = {}
         self._in_progress = {}
         self._cancelled = False
 
@@ -460,6 +474,7 @@ class AnalyzedAudio(QWidget):
         view.setColumnWidth(0, 20)
 
         view.selectionModel().currentRowChanged.connect(self._audio_selected)
+        view.clicked.connect(self._clicked)
         model.itemChanged.connect(self._item_changed)
 
         self._model = model
@@ -495,6 +510,14 @@ class AnalyzedAudio(QWidget):
         self._remove_button = remove_button
         self._set_removal_enabled(False)
 
+    def _clicked(self, index: QModelIndex):
+        item2 = self._model.item(index.row(), 2)
+        if item2:
+            options = self._results[item2.data()].options
+            # FIXME: PushOptions gets emitted twice when the user
+            # changes the selection by clicking.
+            self.PushOptions.emit(options)
+
     def _audio_selected(self, new, prev):
         title = None
         item1 = self._model.item(new.row(), 1)
@@ -510,11 +533,11 @@ class AnalyzedAudio(QWidget):
             self.current_title = title
             self.current_listed_title = listed_title
             self.current_selection = item2.data()
-            self.current_options = self._analysis[item2.data()].options
-            self.current_duration = self._analysis[item2.data()].file_duration
-            self.current_metadata = self._analysis[item2.data()].file_metadata
+            self.current_options = self._results[item2.data()].options
+            self.current_duration = self._results[item2.data()].file_duration
+            self.current_metadata = self._results[item2.data()].file_metadata
             self.DisplayResult.emit(title,
-                                    self._analysis[item2.data()].result_rows)
+                                    self._results[item2.data()].result_rows)
             self.PushOptions.emit(self.current_options)
             self.SomethingSelected.emit()
 
@@ -523,7 +546,7 @@ class AnalyzedAudio(QWidget):
         if data is not None:
             if item.text() == '':
                 self._model.itemChanged.disconnect(self._item_changed)
-                file_title = self._analysis[data].file_title
+                file_title = self._results[data].file_title
                 item.setText(file_title if file_title else ' ')
                 self._model.itemChanged.connect(self._item_changed)
             if data == self.current_selection:
@@ -540,7 +563,7 @@ class AnalyzedAudio(QWidget):
                 if title:
                     self.current_title = title
                     self.DisplayResult.emit(title,
-                                    self._analysis[item2.data()].result_rows)
+                                    self._results[item2.data()].result_rows)
 
     def add_audio(self, path, options):
         """Analyze an audio file asynchronously and add it to the list
@@ -560,8 +583,8 @@ class AnalyzedAudio(QWidget):
         canonical_path = os.path.realpath(path)
         if canonical_path in self._in_progress:
             return
-        if canonical_path in self._analysis:
-            index = self._analysis[canonical_path].index
+        if canonical_path in self._results:
+            index = self._results[canonical_path].index
             self._view.selectRow(index.row())
             return
 
@@ -574,8 +597,11 @@ class AnalyzedAudio(QWidget):
             self.Starting.emit()
 
         self._in_progress[canonical_path] = True
-        analysis = anal.Analysis(canonical_path)
-        self.AnalyzeAudio.emit(analysis, options, False)
+
+        # This is a misnomer at this point because there's no results in
+        # "result" yet, but that will soon change.
+        result = _Result(canonical_path)
+        self.AnalyzeAudio.emit(result, options, False)
 
     def change_options(self, new_options, reread_requested):
         """Change the options of the currently selected analyzed audio.
@@ -602,19 +628,19 @@ class AnalyzedAudio(QWidget):
             self.Starting.emit()
 
         self._in_progress[canonical_path] = True
-        analysis = self._analysis[canonical_path]
-        self.AnalyzeAudio.emit(analysis, new_options, reread_requested)
+        result = self._results[canonical_path]
+        self.AnalyzeAudio.emit(result, new_options, reread_requested)
         self.current_options = new_options
 
-    def _handle_result(self, analysis):
-        canonical_path = analysis.inputfile
-        file_title = analysis.file_title
-        if canonical_path in self._analysis:
+    def _handle_result(self, result):
+        canonical_path = result.inputfile
+        file_title = result.file_title
+        if canonical_path in self._results:
             if canonical_path == self.current_selection:
                 self.DisplayResult.emit(self.current_title,
-                                    self._analysis[canonical_path].result_rows)
+                                    self._results[canonical_path].result_rows)
         else:
-            file_track = analysis.file_track
+            file_track = result.file_track
 
             track_num = QStandardItem(file_track.partition('/')[0]
                                       if file_track
@@ -630,8 +656,8 @@ class AnalyzedAudio(QWidget):
 
             index = QPersistentModelIndex(self._model.indexFromItem(filename))
             self._model.setVerticalHeaderItem(index.row(), QStandardItem(' '))
-            analysis.index = index
-            self._analysis[canonical_path] = analysis
+            result.index = index
+            self._results[canonical_path] = result
 
         del self._in_progress[canonical_path]
         if len(self._in_progress) == 0:
@@ -655,9 +681,9 @@ class AnalyzedAudio(QWidget):
 
         canonical_path = self.current_selection
         if canonical_path is not None:
-            pitch = self._analysis[canonical_path].options[gcom.OPTION_PITCH]
+            pitch = self._results[canonical_path].options[gcom.OPTION_PITCH]
             try:
-                self._analysis[canonical_path].show_plot(plot_type=plot_type,
+                self._results[canonical_path].show_plot(plot_type=plot_type,
                                                      asynchronous=True,
                                                      title=self.current_title,
                                                      pitch=pitch,
@@ -669,8 +695,8 @@ class AnalyzedAudio(QWidget):
     def _handle_log_message(self, message, level):
         self.AddToLog.emit(message, level)
 
-    def _handle_error(self, analysis):
-        del self._in_progress[analysis.inputfile]
+    def _handle_error(self, result):
+        del self._in_progress[result.inputfile]
         if len(self._in_progress) == 0:
             self.Finished.emit()
 
@@ -692,9 +718,9 @@ class AnalyzedAudio(QWidget):
         except IndexError:
             return
         path = self._model.item(row, 2).data()
-        del self._analysis[path]
+        del self._results[path]
         self._model.removeRows(row, 1)
-        if len(self._analysis) == 0:
+        if len(self._results) == 0:
             self.DisplayResult.emit(' ', [])
             self.NothingSelected.emit()
             self.current_title = None

{audio_tuner_gui-0.9.1 → audio_tuner_gui-0.11.0}/audio_tuner_gui/common.py

@@ -34,7 +34,6 @@ __all__ = [
             'OPTION_HIGH_CUT',
             'OPTION_DB_RANGE',
             'OPTION_MAX_PEAKS',
-            'OPTION_PAD',
             'OPTION_SIZE_EXP',
             'OPTION_SAMPLERATE',
             'OPTION_PITCH',
@@ -65,6 +64,8 @@ __all__ = [
             'ICON_PLAYER_BACK',
             'ICON_PLAYER_FORWARD',
             'ICON_AUDIO_DEVICE',
+            'ICON_SAVE',
+            'ICON_DEL',
             'RowData',
             'SplitAction',
             'Options',
@@ -73,6 +74,7 @@ __all__ = [
 
 import os
 from typing import TypedDict
+from argparse import Namespace
 
 from PyQt6.QtGui import (
                          QIcon,
@@ -94,7 +96,6 @@ OPTION_LOW_CUT = 'Low cut'
 OPTION_HIGH_CUT = 'High cut'
 OPTION_DB_RANGE = 'dB range'
 OPTION_MAX_PEAKS = 'Max peaks'
-OPTION_PAD = 'Pad input'
 OPTION_SIZE_EXP = 'FFT size exponent'
 OPTION_SAMPLERATE = 'Sample rate'
 OPTION_BACKENDS = 'backends'
@@ -145,6 +146,8 @@ try:
     ICON_PLAYER_BACK = QIcon.ThemeIcon.MediaSeekBackward
     ICON_PLAYER_FORWARD = QIcon.ThemeIcon.MediaSeekForward
     ICON_AUDIO_DEVICE = QIcon.ThemeIcon.AudioCard
+    ICON_SAVE = QIcon.ThemeIcon.DocumentSave
+    ICON_DEL = QIcon.ThemeIcon.EditDelete
 except AttributeError:
     ICON_BACK = 'go-previous'
     ICON_FORWARD = 'go-next'
@@ -166,6 +169,8 @@ except AttributeError:
     ICON_PLAYER_BACK = 'media-seek-backward'
     ICON_PLAYER_FORWARD = 'media-seek-forward'
     ICON_AUDIO_DEVICE = 'audio-card'
+    ICON_SAVE = 'document-save'
+    ICON_DEL = 'edit-delete'
 
 
 class RowData(TypedDict):
@@ -275,25 +280,76 @@ class Options(dict):
 
     def __init__(self, args):
         super().__init__()
-        self[OPTION_TUNING_SYSTEM] = self._guify_tuning_system(args.tuning)
-        self[OPTION_REF_FREQ] = args.ref_freq
-        self[OPTION_REF_NOTE] = args.ref_note
-        self[OPTION_START] = args.start
-        self[OPTION_END] = args.end
-        self[OPTION_LOW_CUT] = args.low_cut
-        self[OPTION_HIGH_CUT] = args.high_cut
-        self[OPTION_DB_RANGE] = args.dB_range
-        self[OPTION_MAX_PEAKS] = args.max_peaks
-        self[OPTION_PAD] = not args.nopad
-        self[OPTION_SIZE_EXP] = args.size_exp
-        self[OPTION_SAMPLERATE] = args.samplerate
-        self[OPTION_BACKENDS] = args.backends
-        self[OPTION_PITCH] = 1.0
-        self[OPTION_TEMPO] = 1.0
+
+        self._options_and_args = (
+            (OPTION_TUNING_SYSTEM, 'tuning'),
+            (OPTION_REF_FREQ, 'ref_freq'),
+            (OPTION_REF_NOTE, 'ref_note'),
+            (OPTION_START, 'start'),
+            (OPTION_END, 'end'),
+            (OPTION_LOW_CUT, 'low_cut'),
+            (OPTION_HIGH_CUT, 'high_cut'),
+            (OPTION_DB_RANGE, 'dB_range'),
+            (OPTION_MAX_PEAKS, 'max_peaks'),
+            (OPTION_SIZE_EXP, 'size_exp'),
+            (OPTION_SAMPLERATE, 'samplerate'),
+            (OPTION_BACKENDS, 'backends'),
+            (OPTION_PITCH, 'pitch'),
+            (OPTION_TEMPO, 'tempo'),
+        )
+
+        for opt, arg in self._options_and_args:
+            if arg == 'tuning':
+                val = getattr(args, arg)
+                self[opt] = self._guify_tuning_system(val)
+            else:
+                self[opt] = getattr(args, arg)
 
     def _guify_tuning_system(self, tuning_system):
         return tuning_system.replace('_', ' ').title()
 
+    def _unguify_tuning_system(self, tuning_system):
+        return tuning_system.replace(' ', '_').lower()
+
+    def argparse_namespace(self) -> Namespace:
+        """Return an argparse.Namespace object containing the options.
+
+        Returns
+        -------
+        argparse.Namespace
+            The options.
+        """
+
+        args = Namespace()
+
+        for opt, arg in self._options_and_args:
+            if arg == 'tuning':
+                val = self[opt]
+                setattr(args, arg, self._unguify_tuning_system(val))
+            else:
+                setattr(args, arg, self[opt])
+
+        return args
+
+    def merge_args(self, args: Namespace):
+        """Modify the options according to the arguments in an
+        argparse.Namespace object.
+
+        Parameters
+        ----------
+        args : argparse.Namespace
+            The arguments.
+        """
+
+        for opt, arg in self._options_and_args:
+            if arg == 'tuning':
+                if (val := getattr(args, arg, None)) is not None:
+                    self[opt] = self._guify_tuning_system(val)
+            else:
+                if (val := getattr(args, arg, None)) is not None:
+                    self[opt] = val
+
+
     def redo_level(self, old_options):
         """Compare the options stored in this instance of Options to the
         options stored in an older one to find out how much analysis
@@ -313,7 +369,6 @@ class Options(dict):
         if (old_options is None
          or self[OPTION_START] != old_options[OPTION_START]
          or self[OPTION_END] != old_options[OPTION_END]
-         or self[OPTION_PAD] != old_options[OPTION_PAD]
          or self[OPTION_SIZE_EXP] != old_options[OPTION_SIZE_EXP]
          or self[OPTION_BACKENDS] != old_options[OPTION_BACKENDS]
          or self[OPTION_SAMPLERATE] != old_options[OPTION_SAMPLERATE]):

{audio_tuner_gui-0.9.1 → audio_tuner_gui-0.11.0}/audio_tuner_gui/file_selector.py

@@ -38,6 +38,8 @@ from PyQt6.QtCore import (
                           QDir,
                           pyqtSignal,
                           QModelIndex,
+                          QMutex,
+                          QMutexLocker,
                          )
 from PyQt6.QtWidgets import (
                              QWidget,
@@ -147,13 +149,13 @@ class FileSelector(QWidget):
         The option panel widget to get analysis options from.
     """
 
-    SelectForAnalysis = pyqtSignal(str, gcom.Options)
+    SelectForAnalysis = pyqtSignal(str)
     """Signal emitted when a file is selected.
 
     Parameters
     ----------
-    audio_tuner_gui.common.Options
-        The options to use when the file is analyzed.
+    str
+        The path of the audio file.
     """
 
     UpdateStatusbar = pyqtSignal(str)
@@ -169,6 +171,8 @@ class FileSelector(QWidget):
     def __init__(self, option_panel):
         super().__init__()
 
+        self._init_complete = False
+
         self.option_panel = option_panel
 
         vbox = QVBoxLayout(self)
@@ -184,6 +188,12 @@ class FileSelector(QWidget):
         vbox.addWidget(self.panel)
         vbox.addWidget(self.view)
 
+        self._scroll_positions = {}
+        self._scroll_mutex = QMutex()
+        self._scroll_update_needed = False
+
+        self._init_complete = True
+
     def _init_file_view(self):
         model = QFileSystemModel(self)
 
@@ -203,7 +213,15 @@ class FileSelector(QWidget):
         self.model = model
         self.view = view
 
-    def _set_show_hidden(self, checked):
+    def set_show_hidden(self, checked):
+        """Select whether to show hidden files.
+
+        Parameters
+        ----------
+        checked : bool
+            Whether or not to show hidden files.
+        """
+
         if checked:
             self.model.setFilter(self.showhidden_filter)
         else:
@@ -274,11 +292,7 @@ class FileSelector(QWidget):
             self._cd(QDir.fromNativeSeparators(self.pathedit.text()))
         except NotADirectoryError:
             path = self.pathedit.text()
-            options = self.option_panel.get_options()
-            if options is None:
-                self.option_panel.ensure_visible()
-            else:
-                self.SelectForAnalysis.emit(path, options)
+            self.SelectForAnalysis.emit(path)
             self._select_filename()
 
     def handle_command_line_arg(self, arg):
@@ -300,11 +314,7 @@ class FileSelector(QWidget):
         try:
             self._cd(QDir.fromNativeSeparators(arg))
         except NotADirectoryError:
-            options = self.option_panel.get_options()
-            if options is None:
-                self.option_panel.ensure_visible()
-            else:
-                self.SelectForAnalysis.emit(arg, options)
+            self.SelectForAnalysis.emit(arg)
 
     def handle_drop(self, path):
         """If `path` is a file, act like it's been selected and send it
@@ -346,9 +356,35 @@ class FileSelector(QWidget):
                                          dest)
             path = dest
             index = self.model.index(dest)
+
+        if self._init_complete:
+            self._save_scroll_position()
+            self.model.directoryLoaded.connect(self._load_scroll_position,
+                                        Qt.ConnectionType.SingleShotConnection)
+
+        self._scroll_update_needed = True
         self.model.setRootPath(path)
         self.view.setRootIndex(index)
+
+        # The directoryLoaded signal is NOT always emitted when the
+        # directory is finished loading, so this is necessary to make
+        # sure the scroll position is updated anyway.
+        testindex = self.model.index(path)
+        if testindex.isValid():
+            try:
+                # testindex being valid means the new directory is
+                # already loaded, so we'll go ahead and update the
+                # scroll position and not bother to wait for the signal
+                self.model.directoryLoaded.disconnect(
+                                                    self._load_scroll_position)
+                self._load_scroll_position(path)
+            except TypeError:
+                # The signal's already been emitted, so there's nothing
+                # to do
+                pass
+
         self.pathedit.setText(QDir(path).absolutePath())
+
         if hist == 'previous':
             self.path_history.back()
         elif hist == 'next':
@@ -400,6 +436,25 @@ class FileSelector(QWidget):
             if self.up_button.underMouse():
                 self.UpdateStatusbar.emit(status)
 
+    def _save_scroll_position(self):
+        current_path = QDir(self.model.rootPath()).absolutePath()
+        point = self.view.rect().topLeft()
+        position = self.view.indexAt(point).data()
+        self._scroll_positions[current_path] = position
+
+    def _load_scroll_position(self, path):
+        with QMutexLocker(self._scroll_mutex):
+            if not self._scroll_update_needed:
+                return
+            abs_path = QDir(path).absolutePath()
+            position = self._scroll_positions.get(abs_path)
+            if position:
+                rowindex = self.model.index(os.path.join(path, position))
+                if rowindex.isValid():
+                    self.view.scrollTo(rowindex,
+                                   QAbstractItemView.ScrollHint.PositionAtTop)
+            self._scroll_update_needed = False
+
     def _file_selector_doubleclick(self, index):
         if self.model.isDir(index):
             self._cd(index)
@@ -411,13 +466,8 @@ class FileSelector(QWidget):
         if len(selected) == 1 and self.model.isDir(selected[0]):
             self._cd(selected[0])
         else:
-            options = self.option_panel.get_options()
-            if options is None:
-                self.option_panel.ensure_visible()
-            else:
-                for index in selected:
-                    self.SelectForAnalysis.emit(self.model.filePath(index),
-                                                options)
+            for index in selected:
+                self.SelectForAnalysis.emit(self.model.filePath(index))
 
     def _updir(self):
         directory = self.model.rootDirectory()

{audio_tuner_gui-0.9.1 → audio_tuner_gui-0.11.0}/audio_tuner_gui/option_panel.py

@@ -29,8 +29,11 @@ __all__ = [
           ]
 
 
+import copy
+
 from PyQt6.QtCore import (
                           pyqtSignal,
+                          Qt,
                          )
 from PyQt6.QtWidgets import (
                              QWidget,
@@ -231,8 +234,8 @@ class _OptionFloatSpinBox(_OptionIntSpinBox):
     def init_main_widget(self):
         widget = QDoubleSpinBox()
         widget.setDecimals(3)
-        widget.setMinimum(0.25)
-        widget.setMaximum(4.0)
+        widget.setMinimum(com.PITCH_TEMPO_MIN)
+        widget.setMaximum(com.PITCH_TEMPO_MAX)
         widget.setSingleStep(.001)
 
         self._revert_to_default = False
@@ -291,15 +294,16 @@ class _OptionComboBox(_OptionLineEdit):
 
 class OptionPanel(QWidget):
     """Panel full of option widgets.  Inherits from QWidget.  Includes a
-    `Hold` checkbox to hold options at their current values, a `Revert
-    to defaults` button and an `Apply to selected` button.  The user can
-    request that an individual widget return to it's default value by
-    setting it's line edit box to a blank value (this only works for
-    widgets that actually have a line edit box, and only if the widget's
-    `default` attribute has been set, which can be done using the
-    `is_defaults` parameter of the `set_options` method (The
-    `set_default_options` convenience method, which is what the `Revert
-    to defaults` button is connected to, does this automatically)).
+    `Hold` checkbox to hold options at their current values, a `Use in
+    next analysis` checkbox, a `Revert to defaults` button and an `Apply
+    to selected` button.  The user can request that an individual widget
+    return to it's default value by setting it's line edit box to a
+    blank value (this only works for widgets that actually have a line
+    edit box, and only if the widget's `default` attribute has been set,
+    which can be done using the `is_defaults` parameter of the
+    `set_options` method (The `set_default_options` convenience method,
+    which is what the `Revert to defaults` button is connected to, does
+    this automatically)).
 
     Parameters
     ----------
@@ -376,7 +380,9 @@ class OptionPanel(QWidget):
 
         # Link button
         widget = QToolButton()
-        widget.setText('&Link')
+        widget.setText('Link')
+        widget.setShortcut('=')
+        widget.setStatusTip('Link pitch and tempo (=)')
         widget.setCheckable(True)
         hbox.addWidget(widget)
         self._link = widget
@@ -487,14 +493,6 @@ class OptionPanel(QWidget):
         self._grid.addWidget(widget, 6, 1)
         self.widgets[title] = widget
 
-        # Pad input
-        title = gcom.OPTION_PAD
-        widget = _OptionCheckBox(title)
-        widget.setStatusTip("Pad the audio with zeros to ensure the FFT"
-                            " window doesn't miss the very beginning and end")
-        self._grid.addWidget(widget, 7, 1)
-        self.widgets[title] = widget
-
 
         self.widgets[gcom.OPTION_PITCH].widget.valueChanged.connect(
                                                         self._pitch_changed)
@@ -509,9 +507,14 @@ class OptionPanel(QWidget):
         self._button_panel = QWidget(self)
         hbox = QHBoxLayout(self._button_panel)
 
-        self._hold = QCheckBox('Hold')
+        self._hold = QCheckBox('Ho&ld')
         self._hold.setStatusTip("Don't update settings to reflect selection")
         hbox.addWidget(self._hold)
+        self._use = QCheckBox('&Use in next analysis')
+        self._use.setStatusTip('Use these settings to analyze the next'
+                               ' file selected for analysis')
+        self._use.checkStateChanged.connect(self._use_changed)
+        hbox.addWidget(self._use)
         self._to_defaults = QPushButton('Revert to &defaults')
         self._to_defaults.clicked.connect(self.set_default_options)
         hbox.addWidget(self._to_defaults)
@@ -520,6 +523,10 @@ class OptionPanel(QWidget):
         hbox.addWidget(self._to_selected)
         hbox.setContentsMargins(0, 0, 0, 0)
 
+    def _use_changed(self, event):
+        if event == Qt.CheckState.Checked:
+            self._hold.setChecked(True)
+
     def _link_toggled(self, event):
         if event:
             self._link_ok = False
@@ -626,6 +633,17 @@ class OptionPanel(QWidget):
             factor = self.widgets[gcom.OPTION_PITCH].get()
             self.PitchChange.emit(factor)
 
+    def use_options(self) -> bool:
+        """Determine whether the 'Use in next analysis' checkbox is
+        checked.
+
+        Returns
+        -------
+        bool
+            True if checked, False if not.
+        """
+        return self._use.isChecked()
+
     def get_options(self) -> gcom.Options:
         """Get the values currently set in the option widgets.
 
@@ -673,6 +691,16 @@ class OptionPanel(QWidget):
             options.reread_requested = True
             self.PushOptions.emit(options, True)
 
+    def get_default_options(self) -> gcom.Options:
+        """Return a copy of the default options.
+
+        Returns
+        -------
+        audio_tuner_gui.common.Options
+            The default options.
+        """
+        return copy.copy(self._default_options)
+
     def set_default_options(self):
         """Set the widgets to the values passed in the constructor's
         `args` parameter.  This calls `set_options` with force=True and

{audio_tuner_gui-0.9.1 → audio_tuner_gui-0.11.0}/audio_tuner_gui/scripts/tuner_gui.py

@@ -61,6 +61,7 @@ from PyQt6.QtSvgWidgets import QSvgWidget
 import audio_tuner.error_handling as eh
 import audio_tuner.common as com
 import audio_tuner.argument_parser as ap
+import audio_tuner.saved_options as so
 
 import audio_tuner_gui.common as gcom
 import audio_tuner_gui.file_selector as fs
@@ -103,7 +104,10 @@ VERSION_STRING = f'tuner-gui ({APP_TITLE}) {VERSION}\n{ABOUT_TEXT}'
 DEBUG_BUTTON = False
 
 class _AboutWindow(QWidget):
-    def __init__(self, parent):
+    def __init__(self,
+                 parent,
+                 config_path: str = ap.CONFIG_PATH,
+                 savefile_path: str = ap.SAVEFILE_PATH):
         super().__init__(parent)
 
         self.setWindowFlag(Qt.WindowType.Window)
@@ -116,7 +120,8 @@ class _AboutWindow(QWidget):
         self.text.setTextInteractionFlags(
                                 Qt.TextInteractionFlag.TextSelectableByMouse)
 
-        self.config_text = QLabel('Config file path:\n' + ap.CONFIG_PATH, self)
+        self.config_text = QLabel('Config file path:\n' + config_path
+                              + '\n\nSave file path:\n' + savefile_path, self)
         self.config_text.setCursor(Qt.CursorShape.IBeamCursor)
         self.config_text.setTextInteractionFlags(
                                 Qt.TextInteractionFlag.TextSelectableByMouse)
@@ -215,6 +220,28 @@ class _MainUI(QMainWindow):
         self.exit_act.setStatusTip('Exit application')
         self.exit_act.triggered.connect(QApplication.instance().quit)
 
+        self.save_act = QAction(QIcon.fromTheme(gcom.ICON_SAVE),
+                                '&Save options',
+                                self)
+        self.save_act.setShortcut(QKeySequence('Ctrl+S'))
+        self.save_act.setStatusTip(
+                'Save the options of the currently selected analyzed audio')
+        self.save_act.triggered.connect(self._save)
+
+        self.reload_saved_act = QAction('&Reload saved options')
+        self.reload_saved_act.setStatusTip('Load the saved options for the'
+                                           ' currently selected analyzed'
+                                           ' audio into the option panel')
+        self.reload_saved_act.triggered.connect(self._reload_saved)
+
+        self.delete_saved_act = QAction(QIcon.fromTheme(gcom.ICON_DEL),
+                                        '&Delete saved options',
+                                        self)
+        self.delete_saved_act.setStatusTip(
+                'Delete the saved options of the'
+                ' currently selected analyzed audio')
+        self.delete_saved_act.triggered.connect(self._delete_saved)
+
         self.showhidden_act = QAction('Show &hidden files', self)
         self.showhidden_act.setCheckable(True)
         self.showhidden_act.setShortcut(QKeySequence('Ctrl+H'))
@@ -224,19 +251,19 @@ class _MainUI(QMainWindow):
         self.play_start_end_act.setCheckable(True)
         self.play_start_end_act.toggled.connect(self._play_start_end_toggled)
 
-        self.toggle_options_panel_act = QAction('Show &options panel', self)
+        self.toggle_options_panel_act = QAction('Show &option panel', self)
         self.toggle_options_panel_act.setCheckable(True)
         self.toggle_options_panel_act.setChecked(False)
         self.toggle_options_panel_act.setShortcut('F2')
         self.toggle_options_panel_act.setStatusTip(
-                            'Switch between file selector and options panel')
+                            'Switch between file selector and option panel')
         self.toggle_options_panel_act.triggered.connect(
                                                 self._toggle_options_panel)
 
         self.toggle_toggle_options_panel_act = QAction(self)
         self.toggle_toggle_options_panel_act.setIcon(QIcon(gcom.ICON_OPTIONS))
         self.toggle_toggle_options_panel_act.setStatusTip(
-                            'Switch between file selector and options panel')
+                            'Switch between file selector and option panel')
         self.toggle_toggle_options_panel_act.triggered.connect(
                                             self._toggle_toggle_options_panel)
 
@@ -245,7 +272,7 @@ class _MainUI(QMainWindow):
         self.cancel_act.setShortcut('Escape')
         self.cancel_act.setStatusTip('Cancel')
 
-        self.export_act = QAction('&Export Audio...')
+        self.export_act = QAction('&Export audio...')
         self.export_act.triggered.connect(self._export)
         if com.mpv_error is not None:
             self.export_act.setEnabled(False)
@@ -293,10 +320,9 @@ class _MainUI(QMainWindow):
         self.pause_act.triggered.connect(self._pause)
 
         self.stop_act = QAction(self)
-        self.stop_act.setShortcuts([QKeySequence('Ctrl+S'),
-                                    Qt.Key.Key_MediaStop])
+        self.stop_act.setShortcut(Qt.Key.Key_MediaStop)
         self.stop_act.setIcon(QIcon.fromTheme(gcom.ICON_STOP))
-        self.stop_act.setStatusTip('Stop (Ctrl+S)')
+        self.stop_act.setStatusTip('Stop')
         self.stop_act.triggered.connect(self._stop)
 
         if DEBUG_BUTTON:
@@ -390,6 +416,10 @@ class _MainUI(QMainWindow):
         menubar = self.menuBar()
 
         file_menu = menubar.addMenu('&File')
+        file_menu.addAction(self.reload_saved_act)
+        file_menu.addAction(self.save_act)
+        file_menu.addAction(self.delete_saved_act)
+        file_menu.addSeparator()
         file_menu.addAction(self.export_act)
         file_menu.addSeparator()
         file_menu.addAction(self.exit_act)
@@ -532,6 +562,53 @@ class _MainUI(QMainWindow):
         self.cancel_button.hide()
         self.cancel_act.setEnabled(False)
 
+    def _save(self):
+        audio_path = self.analyzed_audio.current_selection
+        args = self.analyzed_audio.current_options.argparse_namespace()
+        if self.saved_options.save(args, audio_path):
+            self._update_statusbar('Saved')
+            self.delete_saved_act.setEnabled(True)
+            self.reload_saved_act.setEnabled(True)
+        else:
+            self._update_statusbar('Error while saving')
+
+    def _reload_saved(self):
+        path = self.analyzed_audio.current_selection
+        options = self.option_panel.get_default_options()
+        saved_args = self.saved_options.get_args(path)
+        if saved_args:
+            options.merge_args(saved_args)
+            try:
+                options.init_tuning_system()
+            except ValueError:
+                s = (f'invalid ref_note:'
+                     f' {options[gcom.OPTION_REF_NOTE]}')
+                self._log(s, lv.LOG_LEVEL_ERROR)
+                return
+        self.option_panel.set_options(options, force=True)
+
+    def _delete_saved(self):
+        audio_path = self.analyzed_audio.current_selection
+        message = (f'Delete saved options for'
+                   f'\n{audio_path}'
+                   f'\nfrom'
+                   f'\n{self.saved_options.path}?')
+        reply = QMessageBox.question(
+                                self,
+                                'Confirm',
+                                message,
+                                QMessageBox.StandardButton.Yes
+                                | QMessageBox.StandardButton.No,
+                                QMessageBox.StandardButton.No)
+
+        if reply == QMessageBox.StandardButton.Yes:
+            if self.saved_options.delete(audio_path):
+                self._update_statusbar('Deleted')
+                self.delete_saved_act.setEnabled(False)
+                self.reload_saved_act.setEnabled(False)
+            else:
+                self._update_statusbar('Error while deleting')
+
     def _export(self):
         self.export_window.show(self.analyzed_audio.current_selection,
                                 self.analyzed_audio.current_listed_title,
@@ -581,6 +658,14 @@ class _MainUI(QMainWindow):
         self.option_panel.set_apply_enabled(True)
         self.show_log_plot_act.setEnabled(True)
         self.show_linear_plot_act.setEnabled(True)
+        self.save_act.setEnabled(True)
+        selected = self.analyzed_audio.current_selection
+        if self.saved_options.has_options(selected):
+            self.delete_saved_act.setEnabled(True)
+            self.reload_saved_act.setEnabled(True)
+        else:
+            self.delete_saved_act.setEnabled(False)
+            self.reload_saved_act.setEnabled(False)
         if not self._exporting_in_progress and com.mpv_error is None:
             self.export_act.setEnabled(True)
 
@@ -590,6 +675,9 @@ class _MainUI(QMainWindow):
         self.show_log_plot_act.setEnabled(False)
         self.show_linear_plot_act.setEnabled(False)
         self.export_act.setEnabled(False)
+        self.save_act.setEnabled(False)
+        self.delete_saved_act.setEnabled(False)
+        self.reload_saved_act.setEnabled(False)
 
     def _play_start_end_toggled(self, checked):
         if checked:
@@ -726,6 +814,26 @@ class _MainUI(QMainWindow):
         now = self.player.get_current_position()
         self.option_panel.set_end(now)
 
+    def _add_audio(self, path: str):
+        if self.option_panel.use_options():
+            options = self.option_panel.get_options()
+            if options is None:
+                self.option_panel.ensure_visible()
+                return
+        else:
+            options = self.option_panel.get_default_options()
+            saved_args = self.saved_options.get_args(path)
+            if saved_args:
+                options.merge_args(saved_args)
+                try:
+                    options.init_tuning_system()
+                except ValueError:
+                    s = (f'invalid ref_note:'
+                         f' {options[gcom.OPTION_REF_NOTE]}')
+                    self._log(s, lv.LOG_LEVEL_ERROR)
+                    return
+        self.analyzed_audio.add_audio(path, options)
+
     def _initUI(self):
         self.resize(800, 850)
         self.setWindowTitle(APP_TITLE)
@@ -775,8 +883,8 @@ class _MainUI(QMainWindow):
         self.export_window = ex.ExportWindow(self)
         self.export_window.set_dir(self.file_selector.model.rootDirectory())
 
-        file_selector.SelectForAnalysis.connect(analyzed_audio.add_audio)
-        self.showhidden_act.toggled.connect(file_selector._set_show_hidden)
+        file_selector.SelectForAnalysis.connect(self._add_audio)
+        self.showhidden_act.toggled.connect(file_selector.set_show_hidden)
         file_selector.UpdateStatusbar.connect(self._update_statusbar)
         file_selector.model.rootPathChanged.connect(self.export_window.set_dir)
         self.analyzed_audio.UpdateStatusbar.connect(self._update_statusbar)
@@ -813,10 +921,15 @@ class _MainUI(QMainWindow):
         analyzed_audio.DisplayResult.connect(self._update_now_playing)
         analyzed_audio.PushOptions.connect(option_panel.set_options)
 
-        self.about_window = _AboutWindow(self)
-
         self.log_viewer = lv.LogViewer(self)
 
+        self.saved_options = so.SavedOptions(self.args.savefile,
+                                             print_msg=self._log)
+
+        self.about_window = _AboutWindow(self,
+                                         config_path=self.args.config,
+                                         savefile_path=self.saved_options.path)
+
         self.show()
 
         hsplitter.moveSplitter(500, 1)

{audio_tuner_gui-0.9.1 → audio_tuner_gui-0.11.0}/pyproject.toml

@@ -21,7 +21,8 @@ readme = "README.rst"
 Homepage = "https://codeberg.org/bluesloth/audio_tuner"
 Repository = "https://codeberg.org/bluesloth/audio_tuner.git"
 Issues = "https://codeberg.org/bluesloth/audio_tuner/issues"
-Documentation = "https://audio-tuner.readthedocs.io/en/latest/"
+Documentation = "https://audio-tuner.readthedocs.io/"
+News = "https://codeberg.org/bluesloth/audio_tuner/src/branch/master/NEWS"
 
 [project.gui-scripts]
 tuner-gui = "audio_tuner_gui.scripts.tuner_gui:main"