Fix PocketSphinx tests failure on ubuntu-24.04

.github/workflows/unittests.yml

@@ -14,15 +14,15 @@ jobs:
       fail-fast: true
       matrix:
         include:
-          - os: ubuntu-22.04
+          - os: ubuntu-latest
             python-version: "3.9"
-          - os: ubuntu-22.04
+          - os: ubuntu-latest
             python-version: "3.10"
-          - os: ubuntu-22.04
+          - os: ubuntu-latest
             python-version: "3.11"
-          - os: ubuntu-22.04
+          - os: ubuntu-latest
             python-version: "3.12"
-          - os: ubuntu-22.04
+          - os: ubuntu-latest
             python-version: "3.13"
           - os: windows-latest
             python-version: "3.11"
@@ -34,19 +34,21 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install build dependencies
-        if: matrix.os == 'ubuntu-22.04'
+        if: matrix.os == 'ubuntu-latest'
         run: |
           sudo apt-get update
+          # For pocketsphinx (already installed: swig)
           sudo apt-get install --no-install-recommends -y libpulse-dev libasound2-dev
+          # For PyAudio
           sudo apt-get install --no-install-recommends -y portaudio19-dev
       - name: Install ffmpeg (for Whisper)
         uses: FedericoCarboni/setup-ffmpeg@v3
       - name: Install Python dependencies (Ubuntu, <=3.12)
-        if: matrix.os == 'ubuntu-22.04' && matrix.python-version != '3.13'
+        if: matrix.os == 'ubuntu-latest' && matrix.python-version != '3.13'
         run: |
           python -m pip install .[dev,audio,pocketsphinx,google-cloud,whisper-local,faster-whisper,openai,groq]
       - name: Install Python dependencies (Ubuntu, 3.13)
-        if: matrix.os == 'ubuntu-22.04' && matrix.python-version == '3.13'
+        if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13'
         run: |
           python -m pip install standard-aifc setuptools
           python -m pip install --no-build-isolation .[dev,audio,pocketsphinx,google-cloud,openai,groq]

README.rst

@@ -129,12 +129,12 @@ The installation instructions on the PyAudio website are quite good - for conven
 
 PyAudio `wheel packages <https://pypi.python.org/pypi/wheel>`__ for common 64-bit Python versions on Windows and Linux are included for convenience, under the ``third-party/`` `directory <https://github.com/Uberi/speech_recognition/tree/master/third-party>`__ in the repository root. To install, simply run ``pip install wheel`` followed by ``pip install ./third-party/WHEEL_FILENAME`` (replace ``pip`` with ``pip3`` if using Python 3) in the repository `root directory <https://github.com/Uberi/speech_recognition>`__.
 
-PocketSphinx-Python (for Sphinx users)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+PocketSphinx (for Sphinx users)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-`PocketSphinx-Python <https://github.com/bambocher/pocketsphinx-python>`__ is **required if and only if you want to use the Sphinx recognizer** (``recognizer_instance.recognize_sphinx``).
+`PocketSphinx <https://github.com/cmusphinx/pocketsphinx>`__ is **required if and only if you want to use the Sphinx recognizer** (``recognizer_instance.recognize_sphinx``).
 
-PocketSphinx-Python `wheel packages <https://pypi.python.org/pypi/wheel>`__ for 64-bit Python 3.4, and 3.5 on Windows are included for convenience, under the ``third-party/`` `directory <https://github.com/Uberi/speech_recognition/tree/master/third-party>`__. To install, simply run ``pip install wheel`` followed by ``pip install ./third-party/WHEEL_FILENAME`` (replace ``pip`` with ``pip3`` if using Python 3) in the SpeechRecognition folder.
+`Pocketsphinx-Python <https://github.com/bambocher/pocketsphinx-python>`__ `wheel packages <https://pypi.python.org/pypi/wheel>`__ for 64-bit Python 3.4, and 3.5 on Windows are included for convenience, under the ``third-party/`` `directory <https://github.com/Uberi/speech_recognition/tree/master/third-party>`__. To install, simply run ``pip install wheel`` followed by ``pip install ./third-party/WHEEL_FILENAME`` (replace ``pip`` with ``pip3`` if using Python 3) in the SpeechRecognition folder.
 
 On Linux and other POSIX systems (such as OS X), run ``pip install SpeechRecognition[pocketsphinx]``. Follow the instructions under "Building PocketSphinx-Python from source" in `Notes on using PocketSphinx <https://github.com/Uberi/speech_recognition/blob/master/reference/pocketsphinx.rst>`__ for installation instructions.
 

reference/library-reference.rst

@@ -198,17 +198,7 @@ The ``callback`` parameter is a function that should accept two parameters - the
 ``recognizer_instance.recognize_sphinx(audio_data: AudioData, language: str = "en-US", keyword_entries: Union[Iterable[Tuple[str, float]], None] = None, grammar: Union[str, None] = None, show_all: bool = False) -> Union[str, pocketsphinx.pocketsphinx.Decoder]``
 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
-Performs speech recognition on ``audio_data`` (an ``AudioData`` instance), using CMU Sphinx.
-
-The recognition language is determined by ``language``, an RFC5646 language tag like ``"en-US"`` or ``"en-GB"``, defaulting to US English. Out of the box, only ``en-US`` is supported. See `Notes on using `PocketSphinx <https://github.com/Uberi/speech_recognition/blob/master/reference/pocketsphinx.rst>`__ for information about installing other languages. This document is also included under ``reference/pocketsphinx.rst``. The ``language`` parameter can also be a tuple of filesystem paths, of the form ``(acoustic_parameters_directory, language_model_file, phoneme_dictionary_file)`` - this allows you to load arbitrary Sphinx models.
-
-If specified, the keywords to search for are determined by ``keyword_entries``, an iterable of tuples of the form ``(keyword, sensitivity)``, where ``keyword`` is a phrase, and ``sensitivity`` is how sensitive to this phrase the recognizer should be, on a scale of 0 (very insensitive, more false negatives) to 1 (very sensitive, more false positives) inclusive. If not specified or ``None``, no keywords are used and Sphinx will simply transcribe whatever words it recognizes. Specifying ``keyword_entries`` is more accurate than just looking for those same keywords in non-keyword-based transcriptions, because Sphinx knows specifically what sounds to look for.
-
-Sphinx can also handle FSG or JSGF grammars. The parameter ``grammar`` expects a path to the grammar file. Note that if a JSGF grammar is passed, an FSG grammar will be created at the same location to speed up execution in the next run. If ``keyword_entries`` are passed, content of ``grammar`` will be ignored.
-
-Returns the most likely transcription if ``show_all`` is false (the default). Otherwise, returns the Sphinx ``pocketsphinx.pocketsphinx.Decoder`` object resulting from the recognition.
-
-Raises a ``speech_recognition.UnknownValueError`` exception if the speech is unintelligible. Raises a ``speech_recognition.RequestError`` exception if there are any issues with the Sphinx installation.
+.. autofunction:: speech_recognition.recognizers.pocketsphinx.recognize
 
 ``recognizer_instance.recognize_google(audio_data: AudioData, key: Union[str, None] = None, language: str = "en-US", , pfilter: Union[0, 1], show_all: bool = False) -> Union[str, Dict[str, Any]]``
 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

setup.cfg

@@ -7,7 +7,7 @@ dev =
 audio =
     PyAudio >= 0.2.11
 pocketsphinx =
-    pocketsphinx < 5
+    pocketsphinx
 google-cloud =
     google-cloud-speech
 whisper-local =

speech_recognition/__init__.py

@@ -600,99 +600,6 @@ def stopper(wait_for_stop=True):
         listener_thread.start()
         return stopper
 
-    def recognize_sphinx(self, audio_data, language="en-US", keyword_entries=None, grammar=None, show_all=False):
-        """
-        Performs speech recognition on ``audio_data`` (an ``AudioData`` instance), using CMU Sphinx.
-
-        The recognition language is determined by ``language``, an RFC5646 language tag like ``"en-US"`` or ``"en-GB"``, defaulting to US English. Out of the box, only ``en-US`` is supported. See `Notes on using `PocketSphinx <https://github.com/Uberi/speech_recognition/blob/master/reference/pocketsphinx.rst>`__ for information about installing other languages. This document is also included under ``reference/pocketsphinx.rst``. The ``language`` parameter can also be a tuple of filesystem paths, of the form ``(acoustic_parameters_directory, language_model_file, phoneme_dictionary_file)`` - this allows you to load arbitrary Sphinx models.
-
-        If specified, the keywords to search for are determined by ``keyword_entries``, an iterable of tuples of the form ``(keyword, sensitivity)``, where ``keyword`` is a phrase, and ``sensitivity`` is how sensitive to this phrase the recognizer should be, on a scale of 0 (very insensitive, more false negatives) to 1 (very sensitive, more false positives) inclusive. If not specified or ``None``, no keywords are used and Sphinx will simply transcribe whatever words it recognizes. Specifying ``keyword_entries`` is more accurate than just looking for those same keywords in non-keyword-based transcriptions, because Sphinx knows specifically what sounds to look for.
-
-        Sphinx can also handle FSG or JSGF grammars. The parameter ``grammar`` expects a path to the grammar file. Note that if a JSGF grammar is passed, an FSG grammar will be created at the same location to speed up execution in the next run. If ``keyword_entries`` are passed, content of ``grammar`` will be ignored.
-
-        Returns the most likely transcription if ``show_all`` is false (the default). Otherwise, returns the Sphinx ``pocketsphinx.pocketsphinx.Decoder`` object resulting from the recognition.
-
-        Raises a ``speech_recognition.UnknownValueError`` exception if the speech is unintelligible. Raises a ``speech_recognition.RequestError`` exception if there are any issues with the Sphinx installation.
-        """
-        assert isinstance(audio_data, AudioData), "``audio_data`` must be audio data"
-        assert isinstance(language, str) or (isinstance(language, tuple) and len(language) == 3), "``language`` must be a string or 3-tuple of Sphinx data file paths of the form ``(acoustic_parameters, language_model, phoneme_dictionary)``"
-        assert keyword_entries is None or all(isinstance(keyword, (type(""), type(u""))) and 0 <= sensitivity <= 1 for keyword, sensitivity in keyword_entries), "``keyword_entries`` must be ``None`` or a list of pairs of strings and numbers between 0 and 1"
-
-        # import the PocketSphinx speech recognition module
-        try:
-            from pocketsphinx import FsgModel, Jsgf, pocketsphinx
-
-        except ImportError:
-            raise RequestError("missing PocketSphinx module: ensure that PocketSphinx is set up correctly.")
-        except ValueError:
-            raise RequestError("bad PocketSphinx installation; try reinstalling PocketSphinx version 0.0.9 or better.")
-        if not hasattr(pocketsphinx, "Decoder") or not hasattr(pocketsphinx.Decoder, "default_config"):
-            raise RequestError("outdated PocketSphinx installation; ensure you have PocketSphinx version 0.0.9 or better.")
-
-        if isinstance(language, str):  # directory containing language data
-            language_directory = os.path.join(os.path.dirname(os.path.realpath(__file__)), "pocketsphinx-data", language)
-            if not os.path.isdir(language_directory):
-                raise RequestError("missing PocketSphinx language data directory: \"{}\"".format(language_directory))
-            acoustic_parameters_directory = os.path.join(language_directory, "acoustic-model")
-            language_model_file = os.path.join(language_directory, "language-model.lm.bin")
-            phoneme_dictionary_file = os.path.join(language_directory, "pronounciation-dictionary.dict")
-        else:  # 3-tuple of Sphinx data file paths
-            acoustic_parameters_directory, language_model_file, phoneme_dictionary_file = language
-        if not os.path.isdir(acoustic_parameters_directory):
-            raise RequestError("missing PocketSphinx language model parameters directory: \"{}\"".format(acoustic_parameters_directory))
-        if not os.path.isfile(language_model_file):
-            raise RequestError("missing PocketSphinx language model file: \"{}\"".format(language_model_file))
-        if not os.path.isfile(phoneme_dictionary_file):
-            raise RequestError("missing PocketSphinx phoneme dictionary file: \"{}\"".format(phoneme_dictionary_file))
-
-        # create decoder object
-        config = pocketsphinx.Decoder.default_config()
-        config.set_string("-hmm", acoustic_parameters_directory)  # set the path of the hidden Markov model (HMM) parameter files
-        config.set_string("-lm", language_model_file)
-        config.set_string("-dict", phoneme_dictionary_file)
-        config.set_string("-logfn", os.devnull)  # disable logging (logging causes unwanted output in terminal)
-        decoder = pocketsphinx.Decoder(config)
-
-        # obtain audio data
-        raw_data = audio_data.get_raw_data(convert_rate=16000, convert_width=2)  # the included language models require audio to be 16-bit mono 16 kHz in little-endian format
-
-        # obtain recognition results
-        if keyword_entries is not None:  # explicitly specified set of keywords
-            with PortableNamedTemporaryFile("w") as f:
-                # generate a keywords file - Sphinx documentation recommendeds sensitivities between 1e-50 and 1e-5
-                f.writelines("{} /1e{}/\n".format(keyword, 100 * sensitivity - 110) for keyword, sensitivity in keyword_entries)
-                f.flush()
-
-                # perform the speech recognition with the keywords file (this is inside the context manager so the file isn;t deleted until we're done)
-                decoder.set_kws("keywords", f.name)
-                decoder.set_search("keywords")
-        elif grammar is not None:  # a path to a FSG or JSGF grammar
-            if not os.path.exists(grammar):
-                raise ValueError("Grammar '{0}' does not exist.".format(grammar))
-            grammar_path = os.path.abspath(os.path.dirname(grammar))
-            grammar_name = os.path.splitext(os.path.basename(grammar))[0]
-            fsg_path = "{0}/{1}.fsg".format(grammar_path, grammar_name)
-            if not os.path.exists(fsg_path):  # create FSG grammar if not available
-                jsgf = Jsgf(grammar)
-                rule = jsgf.get_rule("{0}.{0}".format(grammar_name))
-                fsg = jsgf.build_fsg(rule, decoder.get_logmath(), 7.5)
-                fsg.writefile(fsg_path)
-            else:
-                fsg = FsgModel(fsg_path, decoder.get_logmath(), 7.5)
-            decoder.set_fsg(grammar_name, fsg)
-            decoder.set_search(grammar_name)
-
-        decoder.start_utt()  # begin utterance processing
-        decoder.process_raw(raw_data, False, True)  # process audio data with recognition enabled (no_search = False), as a full utterance (full_utt = True)
-        decoder.end_utt()  # stop utterance processing
-
-        if show_all: return decoder
-
-        # return results
-        hypothesis = decoder.hyp()
-        if hypothesis is not None: return hypothesis.hypstr
-        raise UnknownValueError()  # no transcriptions available
-
     def recognize_wit(self, audio_data, key, show_all=False):
         """
         Performs speech recognition on ``audio_data`` (an ``AudioData`` instance), using the Wit.ai API.
@@ -1390,7 +1297,7 @@ def flush(self, *args, **kwargs):
 # At this time, the dependencies are not yet installed, resulting in a ModuleNotFoundError.
 # This is a workaround to resolve this issue
 try:
-    from .recognizers import google, google_cloud
+    from .recognizers import google, google_cloud, pocketsphinx
     from .recognizers.whisper_api import groq, openai
     from .recognizers.whisper_local import faster_whisper, whisper
 except (ModuleNotFoundError, ImportError):
@@ -1402,6 +1309,7 @@ def flush(self, *args, **kwargs):
     Recognizer.recognize_faster_whisper = faster_whisper.recognize
     Recognizer.recognize_openai = openai.recognize
     Recognizer.recognize_groq = groq.recognize
+    Recognizer.recognize_sphinx = pocketsphinx.recognize
 
 
 # ===============================