audio-tuner-gui 0.10.0__tar.gz → 0.11.1__tar.gz

{audio_tuner_gui-0.10.0 → audio_tuner_gui-0.11.1}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: audio-tuner-gui
-Version: 0.10.0
+Version: 0.11.1
 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
@@ -61,7 +62,7 @@ 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/en/latest/
+.. _documentation: https://audio-tuner.readthedocs.io/
 .. _audio-tuner: https://pypi.org/project/audio-tuner/
 .. _PyQt6: https://www.riverbankcomputing.com/software/pyqt/
 

{audio_tuner_gui-0.10.0 → audio_tuner_gui-0.11.1}/README.rst

@@ -41,7 +41,7 @@ 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/en/latest/
+.. _documentation: https://audio-tuner.readthedocs.io/
 .. _audio-tuner: https://pypi.org/project/audio-tuner/
 .. _PyQt6: https://www.riverbankcomputing.com/software/pyqt/
 

{audio_tuner_gui-0.10.0 → audio_tuner_gui-0.11.1}/audio_tuner_gui/__init__.py

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

{audio_tuner_gui-0.10.0 → audio_tuner_gui-0.11.1}/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.10.0 → audio_tuner_gui-0.11.1}/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'
@@ -111,11 +112,8 @@ REDO_LEVEL_NONE = 0
 APP_ICON = os.path.join(PKGDIR, 'icons/audio_tuner_icon.svg')
 
 # These are missing from ThemeIcon
-ICON_OPTIONS = os.path.join(PKGDIR, 'icons/preferences-other.png')
-ICON_FILES = os.path.join(PKGDIR, 'icons/folder.png')
-
-# This one is in ThemeIcon but not on Windows for some reason
-ICON_CANCEL = os.path.join(PKGDIR, 'icons/process-stop.png')
+ICON_OPTIONS = os.path.join(PKGDIR, 'icons/fallback/preferences-system.svg')
+ICON_FILES = os.path.join(PKGDIR, 'icons/fallback/folder.svg')
 
 LOGO_LIGHT = os.path.join(PKGDIR, 'icons/audio_tuner_logo_light.svg')
 LOGO_DARK = os.path.join(PKGDIR, 'icons/audio_tuner_logo_dark.svg')
@@ -133,7 +131,7 @@ try:
     ICON_CLEAR = QIcon.ThemeIcon.EditDelete
     ICON_EXIT = QIcon.ThemeIcon.ApplicationExit
 #   ICON_OPTIONS = 'preferences-other'
-#   ICON_CANCEL = QIcon.ThemeIcon.ProcessStop
+    ICON_CANCEL = QIcon.ThemeIcon.ProcessStop
     ICON_ABOUT = QIcon.ThemeIcon.HelpAbout
     ICON_MESSAGE_LOG = QIcon.ThemeIcon.FormatJustifyLeft
 #   ICON_FILES = 'folder'
@@ -145,6 +143,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'
@@ -154,7 +154,7 @@ except AttributeError:
     ICON_CLEAR = 'edit-delete'
     ICON_EXIT = 'application-exit'
 #   ICON_OPTIONS = 'preferences-other'
-#   ICON_CANCEL = 'process-stop'
+    ICON_CANCEL = 'process-stop'
     ICON_ABOUT = 'help-about'
     ICON_MESSAGE_LOG = 'format-justify-left'
 #   ICON_FILES = 'folder'
@@ -166,6 +166,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 +277,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 +366,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]):