U
m){f^ @ s d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddlZddlZddlZddlZddlZddlmZmZ ddlmZ ddlmZmZ z ddl Z W n e e fk
r Y nX ddl m Z m!Z! dd l"m#Z#m$Z$m%Z%m&Z&m'Z' d
Z(d Z)d Z*G d
d de+Z,G dd de,Z-G dd de,Z.G dd de,Z/G dd de+Z0zddl1m2Z2m3Z3 W n e e fk
r Y nX e2j4e/_5e3j6e/_6e.Z7d ddZ8e9e8e/_8dS ) ziLibrary for performing speech recognition, with support for several engines and APIs, online and offline. ) annotationsN) HTTPErrorURLError) urlencode)Requesturlopen ) AudioDataget_flac_converter) RequestErrorTranscriptionFailedTranscriptionNotReadyUnknownValueErrorWaitTimeoutErrorzAnthony Zhang (Uberi)z3.10.4ZBSDc @ s$ e Zd Zdd Zdd Zdd ZdS ) AudioSourcec C s t dd S Nzthis is an abstract classNotImplementedErrorself r Z/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/speech_recognition/__init__.py__init__0 s zAudioSource.__init__c C s t dd S r r r r r r __enter__3 s zAudioSource.__enter__c C s t dd S r r r exc_type exc_value tracebackr r r __exit__6 s zAudioSource.__exit__N)__name__
__module__ __qualname__r r r r r r r r / s r c @ s^ e Zd ZdZdddZedd Zedd Zed
d Zd d
Z dd Z
G dd de Z dS )
Microphoneaz
Creates a new ``Microphone`` instance, which represents a physical microphone on the computer. Subclass of ``AudioSource``.
This will throw an ``AttributeError`` if you don't have PyAudio 0.2.11 or later installed.
If ``device_index`` is unspecified or ``None``, the default microphone is used as the audio source. Otherwise, ``device_index`` should be the index of the device to use for audio input.
A device index is an integer between 0 and ``pyaudio.get_device_count() - 1`` (assume we have used ``import pyaudio`` beforehand) inclusive. It represents an audio device such as a microphone or speaker. See the `PyAudio documentation `__ for more details.
The microphone audio is recorded in chunks of ``chunk_size`` samples, at a rate of ``sample_rate`` samples per second (Hertz). If not specified, the value of ``sample_rate`` is determined automatically from the system's microphone settings.
Higher ``sample_rate`` values result in better audio quality, but also more bandwidth (and therefore, slower recognition). Additionally, some CPUs, such as those in older Raspberry Pi models, can't keep up if this value is too high.
Higher ``chunk_size`` values help avoid triggering on rapidly changing ambient noise, but also makes detection less sensitive. This value, generally, should be left at its default.
N c C sN |d kst |tstd|d ks r= r r r r) f s zMicrophone.get_pyaudioc C sP t } z4g }t| D ] }| |}||d q W 5 | X |S )a
Returns a list of the names of all available microphones. For microphones where the name can't be retrieved, the list entry contains ``None`` instead.
The index of each microphone's name in the returned list is the same as its device index when creating a ``Microphone`` instance - if you want to use the microphone at index 3 in the returned list, use ``Microphone(device_index=3)``.
name) r" r) r+ r, ranger- r/ appendr0 )r7 resultir< r r r list_microphone_namest s
z Microphone.list_microphone_namesc C s> t } | }z i }t| D ]}||}|d}t|dt t
fr^|d dkslt d |zL|j
|d| jt
|d dd}z |d}| s| W 5 | X W n tk
r Y q$Y nX t|d }t|d
@ |d ? d
@ g} tt|| t|d d d }
|
d kr$|||< q$W 5 | X |S )
a
Returns a dictionary mapping device indices to microphone names, for microphones that are currently hearing sounds. When using this function, ensure that your microphone is unmuted and make some noise at it to ensure it will be detected as working.
Each key in the returned dictionary can be passed to the ``Microphone`` constructor to use that microphone. For example, if the return value is ``{3: "HDA Intel PCH: ALC3232 Analog (hw:1,0)"}``, you can do ``Microphone(device_index=3)`` to use that microphone.
rB r$ r r% r T)input_device_indexchannelsr. rateinputr# )r" r) r+ r, rC r- r/ r0 r& r1 r' r( r. openr3 closeread
is_stopped stop_stream Exceptionaudiooprmsbytesaddlen) r* r7 rE r2 r< Z device_namepyaudio_streambufferenergyZ energy_bytesZdebiased_energyr r r list_working_microphones s<
.
"
z#Microphone.list_working_microphonesc
C sn | j d kstd| j | _z,t| jj| jd| j | j
| j dd| _ W n t k
rh | j
Y nX | S )N5This audio source is already inside a context managerr T)rH rI r. rJ Zframes_per_bufferrK )r8 r( r* r+ r7 r" MicrophoneStreamrP r2 r. r5 r6 rU r, r r r r r s
zMicrophone.__enter__c C s& z| j W 5 d | _ | j X d S N)r8 r7 r, rQ r r r r r s zMicrophone.__exit__c @ s$ e Zd Zdd Zdd Zdd ZdS )zMicrophone.MicrophoneStreamc C s
|| _ d S ra )r[ )r r[ r r r r s z$Microphone.MicrophoneStream.__init__c C s | j j|ddS )NF)Zexception_on_overflow)r[ rR r sizer r r rR s z Microphone.MicrophoneStream.readc C s* z| j s| j W 5 | j X d S ra )r[ rQ rS rT r r r r rQ s
z!Microphone.MicrophoneStream.closeN)r r r! r rR rQ r r r r r` s r` )NNr# )
r r r! __doc__r staticmethodr) rG r^ r r objectr` r r r r r" : s
'r" c @ s8 e Zd ZdZdd Zdd Zdd ZG dd d eZd
S ) AudioFilea{
Creates a new ``AudioFile`` instance given a WAV/AIFF/FLAC audio file ``filename_or_fileobject``. Subclass of ``AudioSource``.
If ``filename_or_fileobject`` is a string, then it is interpreted as a path to an audio file on the filesystem. Otherwise, ``filename_or_fileobject`` should be a file-like object such as ``io.BytesIO`` or similar.
Note that functions that read from the audio (such as ``recognizer_instance.record`` or ``recognizer_instance.listen``) will move ahead in the stream. For example, if you execute ``recognizer_instance.record(audiofile_instance, duration=10)`` twice, the first time it will return the first 10 seconds of audio, and the second time it will return the 10 seconds of audio right after that. This is always reset to the beginning when entering an ``AudioFile`` context.
WAV files must be in PCM/LPCM format; WAVE_FORMAT_EXTENSIBLE and compressed WAV are not supported and may result in undefined behaviour.
Both AIFF and AIFF-C (compressed AIFF) formats are supported.
FLAC files must be in native FLAC format; OGG-FLAC is not supported and may result in undefined behaviour.
c C s\ t |tdtdfs(t|ds(td|| _d | _d | _d | _d| _d | _ d | _
d | _ d S )N rR z@Given audio file must be a filename string or a file-like objectF) r& typehasattrr( filename_or_fileobjectr8 DURATION audio_reader
little_endianr5 r6 FRAME_COUNT)r rk r r r r s (zAudioFile.__init__c
C s0 | j d kstdz t| jd| _d| _W n< tjtfk
rj z t | jd| _d| _W n t jtfk
rd t
| jdr| j }n t| jd}| }W 5 Q R X t }t
jdkrt }| jtjO _tj|_nd }tj|ddd d
d gtjtj|d }||\}}t|}zt |d| _W n$ t jtfk
rX td
Y nX d| _Y nX Y nX d| j krdksn td| j | _ d} | j dkrzt d| j d W n" t j k
r d} d| _ Y nX | j! | _"d| _#| j$ | _%| j%t&| j" | _'t()| j| j| | _ | S )Nr_ rbTFrR ntz--stdoutz--totally-silentz--decodez--force-aiff-format-)stdinstdout startupinfozuAudio file could not be read as PCM WAV, AIFF/AIFF-C, or Native FLAC; check if file is corrupted or in another formatr rL z Audio must be mono or stereo r i )*r8 r( waverP rk rm rn ErrorEOFErroraifcrj rR r
osrB
subprocessZ STARTUPINFOZdwFlagsZSTARTF_USESHOWWINDOWZSW_HIDEZ wShowWindowPopenPIPE communicateioBytesIO
ValueError getnchannels getsampwidthr4 rV ZbiaserrorZ getframerater5 r6
getnframesro r1 rl rg AudioFileStream)
r flac_datafZflac_converterZ startup_infoprocessZ aiff_data_Z aiff_file&samples_24_bit_pretending_to_be_32_bitr r r r sj
( zAudioFile.__enter__c C s& t | jds| j d | _d | _d S )NrR )rj rk rm rQ r8 rl r r r r r & s
zAudioFile.__exit__c @ s e Zd Zdd ZdddZdS )zAudioFile.AudioFileStreamc C s || _ || _|| _d S ra )rm rn r )r rm rn r r r r r - s z"AudioFile.AudioFileStream.__init__c s | j |dkr| j n| t ts,d | j | jsttdrTt n< d d d d
fddt d t D | j
rd
fddt dt D d | j dkrt dd S )
Nr rw byteswapr c 3 s | ]} | |d V qdS )r Nr .0rF r\ sample_widthr r ; s z1AudioFile.AudioFileStream.read..c 3 s" | ]}d || V qdS ) Nr r r r r r ? s r rx )rm Z
readframesr r& rX r rn rj rV r joinrC rZ r r Ztomonorb r r r rR 2 s
<&z AudioFile.AudioFileStream.readN)r )r r r! r rR r r r r r , s r N) r r r! rd r r r rf r r r r r rg s
9rg c @ s e Zd Zdd Zd3ddZd4ddZd5d d
Zd6d d Zd7d
dZd8ddZ d9ddZ
d:ddZ d;ddZ dd d!Zd?d"d#Zd@d$d%ZdAd&d'Zd(ZdZdBd+d,ZdCd.d/ZdDd1d2ZdS )E
Recognizerc C s4 d| _ d| _d| _d| _d| _d| _d| _d| _dS ) z{
Creates a new ``Recognizer`` instance, which represents a collection of speech recognition functionality.
i, Tg333333?g ?g?Ng333333? ?)energy_thresholddynamic_energy_threshold!dynamic_energy_adjustment_dampingdynamic_energy_ratiopause_thresholdoperation_timeoutphrase_thresholdnon_speaking_durationr r r r r G s zRecognizer.__init__Nc C s t |tstd|jdk s$tdt }|jd |j }d}d}d}|rd|sd||7 }||krdd}|j|j} t | dkrq|s|sH||7 }|r||krq|
| qH| }
| t
|
|j|jS )a>
Records up to ``duration`` seconds of audio from ``source`` (an ``AudioSource`` instance) starting at ``offset`` (or at the beginning if not specified) into an ``AudioData`` instance, which it returns.
If ``duration`` is not specified, then it will record until there is no more audio input.
Source must be an audio sourceNzAudio source must be entered before recording, see documentation for ``AudioSource``; are you using ``source`` outside of a ``with`` statement? r FT)r& r r( r8 r r r6 r5 rR rZ writegetvaluerQ r r4 ) r sourcedurationoffsetframesseconds_per_buffer elapsed_timeZ offset_timeZoffset_reachedr\
frame_datar r r recordU s, zRecognizer.recordr c C s t |tstd|jdk s$td| j| j kr`__, an offline, high-accuracy, power-efficient hotword recognition engine. When used, this function will pause until Snowboy detects a hotword, after which it will unpause. This parameter should either be ``None`` to turn off Snowboy support, or a tuple of the form ``(SNOWBOY_LOCATION, LIST_OF_HOT_WORD_FILES)``, where ``SNOWBOY_LOCATION`` is the path to the Snowboy root directory, and ``LIST_OF_HOT_WORD_FILES`` is a list of paths to Snowboy hotword configuration files (`*.pmdl` or `*.umdl` format).
This operation will always complete within ``timeout + phrase_timeout`` seconds if both are numbers, either by returning the audio data, or by raising a ``speech_recognition.WaitTimeoutError`` exception.
r NzAudio source must be entered before listening, see documentation for ``AudioSource``; are you using ``source`` outside of a ``with`` statement?r zsnowboydetect.pyz]``snowboy_configuration[0]`` must be a Snowboy root directory containing ``snowboydetect.py``r zS``snowboy_configuration[1]`` must be a list of Snowboy hot word configuration filesrw z5listening timed out while waiting for phrase to start)r r )#r& r r( r8 r r r} r isfiler r1 r6 r5 r' r r r r r r rR rZ rD popleftrV rW r4 r r r r r rC r r )r r r phrase_time_limitZsnowboy_configurationZ
hot_word_filer Zpause_buffer_countZphrase_buffer_countZnon_speaking_buffer_countr r\ r r] r r r r Z
delta_timeZ pause_countZ phrase_countZphrase_start_timerF r r r r listen sx "
zRecognizer.listenc sZ t tstddg fdd}dfdd }tj|dd_ |S ) as
Spawns a thread to repeatedly record phrases from ``source`` (an ``AudioSource`` instance) into an ``AudioData`` instance and call ``callback`` with that ``AudioData`` instance as soon as each phrase are detected.
Returns a function object that, when called, requests that the background listener thread stop. The background thread is a daemon and will not stop the program from exiting if there are no other non-daemon threads. The function accepts one parameter, ``wait_for_stop``: if truthy, the function will wait for the background listener to stop before returning, otherwise it will return immediately and the background listener thread might still be running for a second or two afterwards. Additionally, if you are using a truthy value for ``wait_for_stop``, you must call the function from the same thread you originally called ``listen_in_background`` from.
Phrase recognition uses the exact same mechanism as ``recognizer_instance.listen(source)``. The ``phrase_time_limit`` parameter works in the same way as the ``phrase_time_limit`` parameter for ``recognizer_instance.listen(source)``, as well.
The ``callback`` parameter is a function that should accept two parameters - the ``recognizer_instance``, and an ``AudioData`` instance representing the captured audio. Note that ``callback`` function will be called from a non-main thread.
r Tc sX J} d rJz | d}W n tk
r4 Y qX d r | qW 5 Q R X d S )Nr r )r r )sr7 )callbackr runningr r r r threaded_listen0 s z8Recognizer.listen_in_background..threaded_listenc s dd< | r d S )NFr )r )Z
wait_for_stop)listener_threadr r r stopper: s z0Recognizer.listen_in_background..stopper)target)T)r& r r( threadingThreaddaemonstart)r r r r r r r )r r r r r r r listen_in_background# s
z Recognizer.listen_in_backgrounden-USFc C sV t |tstdt |ts:t |tr2t|dks:td|dks\tdd |D s\tdzdd lm}m }m} W n6 t
k
r t d
Y n t k
r t d Y nX t
|d rt
|jd
st dt |tr>tjtjtjtd|} tj| st d| tj| d}
tj| d} tj| d} n
|\}
} } tj|
sdt d|
tj| st d| tj| st d| |j }
|
d|
|
d| |
d| |
dtj ||
}|jdd d }|dk rDt d :}| d d |D | | d |j |!d W 5 Q R X n|dk r tj"|sjt d!|tj#tj|}tj$tj%|d }d"||}tj"|s||}|&d#|}|'||( d$}|)| n|||( d$}|*|| |!| |+ |,|d%d& |- |r4|S |. }|dk rL|j/S t0 dS )'al
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 `__ 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.
!``audio_data`` must be audio datarv z``language`` must be a string or 3-tuple of Sphinx data file paths of the form ``(acoustic_parameters, language_model, phoneme_dictionary)``Nc s s@ | ]8\}}t |td td fo6d| ko2dkn V qdS )rh r r Nr& ri r keywordZ sensitivityr r r r T s z.Recognizer.recognize_sphinx..z^``keyword_entries`` must be ``None`` or a list of pairs of strings and numbers between 0 and 1r )FsgModelJsgf pocketsphinxzJmissing PocketSphinx module: ensure that PocketSphinx is set up correctly.zUbad PocketSphinx installation; try reinstalling PocketSphinx version 0.0.9 or better.Decoderdefault_configzYoutdated PocketSphinx installation; ensure you have PocketSphinx version 0.0.9 or better.zpocketsphinx-dataz2missing PocketSphinx language data directory: "{}"zacoustic-modelzlanguage-model.lm.binz pronounciation-dictionary.dictz>missing PocketSphinx language model parameters directory: "{}"z.missing PocketSphinx language model file: "{}"z2missing PocketSphinx phoneme dictionary file: "{}"z-hmmz-lmz-dictz-logfn> rL convert_rateZ
convert_widthwc s s& | ] \}}d |d| d V qdS )z
{} /1e{}/
d n N)r. r r r r r s keywordsz Grammar '{0}' does not exist.z {0}/{1}.fsgz{0}.{0}g @FT)1r& r r( strtuplerZ allr r r r? r r rj r r} r r dirnamerealpath__file__isdirr. r r Z
set_stringdevnull get_raw_dataPortableNamedTemporaryFile
writelinesflushZset_kwsrB Z
set_searchexistsabspathsplitextbasenameZget_ruleZ build_fsgZ get_logmathZ writefileZset_fsgZ start_uttZ process_rawZend_uttZhypZhypstrr )r
audio_datalanguageZkeyword_entriesZgrammarshow_allr r r Zlanguage_directoryZ acoustic_parameters_directoryZlanguage_model_fileZphoneme_dictionary_fileconfigdecoderraw_datar Z grammar_pathZ grammar_nameZfsg_pathjsgfruleZfsg
hypothesisr r r recognize_sphinxD sz ("
zRecognizer.recognize_sphinxc
C s6 t |tstd|dkr.tjddk s.tt |ts@td|dksbtdd |D sbtdz$ddl}dd l m
} dd
l m } W n t
k
r td Y nX |dk r|j|} n| } |jd |j krd
krn ndntd t|jd
dd}
|j|
d} |jjj|j|d} |dk r8|j|dg| d< |rFd| d< i }
| jrj| dkrj| j|
d< |jf | } z| j | | d}W n^ |k
r } z t|W 5 d}~X Y n4 t k
r } ztd |j W 5 d}~X Y nX |r|S t |j!dkrt" d}|j!D ] }||j#d j$% d 7 }q|S )a
Performs speech recognition on ``audio_data`` (an ``AudioData`` instance), using the Google Cloud Speech API.
This function requires a Google Cloud Platform account; see the `Google Cloud Speech API Quickstart `__ for details and instructions. Basically, create a project, enable billing for the project, enable the Google Cloud Speech API for the project, and set up Service Account Key credentials for the project. The result is a JSON file containing the API credentials. The text content of this JSON file is specified by ``credentials_json``. If not specified, the library will try to automatically `find the default API credentials JSON file `__.
The recognition language is determined by ``language``, which is a BCP-47 language tag like ``"en-US"`` (US English). A list of supported language tags can be found in the `Google Cloud Speech API documentation `__.
If ``preferred_phrases`` is an iterable of phrase strings, those given phrases will be more likely to be recognized over similar-sounding alternatives. This is useful for things like keyword/command recognition or adding new phrases that aren't in Google's vocabulary. Note that the API imposes certain `restrictions on the list of phrase strings `__.
Returns the most likely transcription if ``show_all`` is False (the default). Otherwise, returns the raw API response as a JSON dictionary.
Raises a ``speech_recognition.UnknownValueError`` exception if the speech is unintelligible. Raises a ``speech_recognition.RequestError`` exception if the speech recognition operation failed, if the credentials aren't valid, or if there is no Internet connection.
r NZ GOOGLE_APPLICATION_CREDENTIALS ``language`` must be a stringc s s$ | ] }t |td td fV qdS )rh Nr )r preferred_phrasesr r r r s z4Recognizer.recognize_google_cloud..z/``preferred_phrases`` must be a list of stringsr )GoogleAPICallError)speechzXmissing google-cloud-speech module: ensure that google-cloud-speech is set up correctly.@ i rL r )content)encodingZsample_rate_hertzZ
language_code)ZphrasesZspeechContextsTZenableWordTimeOffsetsr )r r7 z"recognition connection failed: {0}rh )&r& r r( r} environr0 r r socketZgoogle.api_core.exceptionsr Z google.cloudr r? r Z SpeechClientZfrom_service_account_json
get_flac_datar9 maxminZRecognitionAudioZRecognitionConfigZ
AudioEncodingZFLACZ
SpeechContextr getdefaulttimeoutZ recognizer r. reasonrZ resultsr alternatives
transcriptstrip)r r Zcredentials_jsonr r r r r r clientr r7 r optsresponseer rE r r r recognize_google_cloud s^ " .
"
z!Recognizer.recognize_google_cloudc
C s t |tstdt |ts$td|j|jdkr6dnddd}d}t||d|d d
d }zt|| j d }W nb t
k
r } zt d
|j W 5 d}~X Y n2 t
k
r } zt d|j W 5 d}~X Y nX | d} t| }
|r|
S d|
ks |
d dkrt |
d S )a"
Performs speech recognition on ``audio_data`` (an ``AudioData`` instance), using the Wit.ai API.
The Wit.ai API key is specified by ``key``. Unfortunately, these are not available without `signing up for an account `__ and creating an app. You will need to add at least one intent to the app before you can see the API key, though the actual intent settings don't matter.
To get the API key for a Wit.ai app, go to the app's overview page, go to the section titled "Make an API request", and look for something along the lines of ``Authorization: Bearer XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX``; ``XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX`` is the API key. Wit.ai API keys are 32-character uppercase alphanumeric strings.
The recognition language is configured in the Wit.ai app settings.
Returns the most likely transcription if ``show_all`` is false (the default). Otherwise, returns the `raw API response `__ as a JSON dictionary.
Raises a ``speech_recognition.UnknownValueError`` exception if the speech is unintelligible. Raises a ``speech_recognition.RequestError`` exception if the speech recognition operation failed, if the key isn't valid, or if there is no internet connection.
Data must be audio data``key`` must be a stringr NrL r z$https://api.wit.ai/speech?v=20170307 Bearer {}z audio/wav)
Authorization Content-Typedataheadersr recognition request failed: {}!recognition connection failed: {}utf-8_text)r& r r( r get_wav_datar9 r r. r r r r r r rR decodejsonloadsr ) r r keyr wav_dataurlrequestr r
response_textrE r r r
recognize_wit s* "
zRecognizer.recognize_witmaskedwestusc
C s t |tstdt |ts$tdt |ts6tdd}t| ddt| dd }} d}
zd d
lm} W n tk
r d} d }
Y nX | dks| | krbd | d
} t| ddd|dd}
|
r| }zt |
dd}W nf t
k
r
} zt d |j
W 5 d}~X Y n4 tk
r< } zt d |j
W 5 d}~X Y nX | d}|
rb|| _|d | _|jddd}d | d t|||d }tjd krt|t|d |d d!d"d}n@d# t|d}|d$ | d% }t||d |d d!d"d}zt || jd}W nf t
k
rD } zt d& |j
W 5 d}~X Y n4 tk
rv } zt d' |j
W 5 d}~X Y nX | d}t |}|r|S d(|ks|d( d)ksd*|krt |d* d d+ |d* d d, fS )-aW
Performs speech recognition on ``audio_data`` (an ``AudioData`` instance), using the Microsoft Azure Speech API.
The Microsoft Azure Speech API key is specified by ``key``. Unfortunately, these are not available without `signing up for an account `__ with Microsoft Azure.
To get the API key, go to the `Microsoft Azure Portal Resources `__ page, go to "All Resources" > "Add" > "See All" > Search "Speech > "Create", and fill in the form to make a "Speech" resource. On the resulting page (which is also accessible from the "All Resources" page in the Azure Portal), go to the "Show Access Keys" page, which will have two API keys, either of which can be used for the `key` parameter. Microsoft Azure Speech API keys are 32-character lowercase hexadecimal strings.
The recognition language is determined by ``language``, a BCP-47 language tag like ``"en-US"`` (US English) or ``"fr-FR"`` (International French), defaulting to US English. A list of supported language values can be found in the `API documentation `__ under "Interactive and dictation mode".
Returns the most likely transcription if ``show_all`` is false (the default). Otherwise, returns the `raw API response `__ as a JSON dictionary.
Raises a ``speech_recognition.UnknownValueError`` exception if the speech is unintelligible. Raises a ``speech_recognition.RequestError`` exception if the speech recognition operation failed, if the key isn't valid, or if there is no internet connection.
r r r Zdetailedazure_cached_access_tokenN azure_cached_access_token_expiryTr monotonicFzhttps://z0.api.cognitive.microsoft.com/sts/v1.0/issueTokenrw !application/x-www-form-urlencoded0 Content-typeContent-LengthzOcp-Apim-Subscription-Keyr < r" credential request failed: {} credential connection failed: {}r% X r rL r zQ.stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1?{})r r. profanityrv r .audio/wav; codec="audio/pcm"; samplerate=16000chunkedr r: zTransfer-Encoding{:X}
0
r# r$ RecognitionStatusSuccessZNBestZDisplayZ
Confidence) r& r r( r getattrr r6 r? r r r r r. r r rR r( r3 r4 r' r r version_infor r rZ r r r) r* r )r r r+ r r@ locationr Z
result_format access_token expire_time
allow_cachingr6 credential_urlcredential_request
start_timecredential_responser r, r- r. ascii_hex_data_length chunked_transfer_encoding_datar r/ rE r r r recognize_azure s
"
"
"zRecognizer.recognize_azurec
C s t |tstdt |ts$tdt |ts6tdt| ddt| dd }}d}zdd lm} W n tk
r d}d
}Y nX |dks| |krTd } t| d d
d|dd}
|r| } zt |
dd} W nd t
k
r }
zt d |
j
W 5 d}
~
X Y n4 tk
r. }
zt d |
j
W 5 d}
~
X Y nX | d}|rT|| _| d | _|jddd}d t||t d}tjd krt|t|d |d d d d}n@d! t| d}|d" | d# }t||d |d d d d}zt || j d}W nf t
k
r2 }
zt d$ |
j
W 5 d}
~
X Y n4 tk
rd }
zt d% |
j
W 5 d}
~
X Y nX | d}t |}|r|S d&|ks|d& d'ksd(|krt |d( S ))af
Performs speech recognition on ``audio_data`` (an ``AudioData`` instance), using the Microsoft Bing Speech API.
The Microsoft Bing Speech API key is specified by ``key``. Unfortunately, these are not available without `signing up for an account `__ with Microsoft Azure.
To get the API key, go to the `Microsoft Azure Portal Resources `__ page, go to "All Resources" > "Add" > "See All" > Search "Bing Speech API > "Create", and fill in the form to make a "Bing Speech API" resource. On the resulting page (which is also accessible from the "All Resources" page in the Azure Portal), go to the "Show Access Keys" page, which will have two API keys, either of which can be used for the `key` parameter. Microsoft Bing Speech API keys are 32-character lowercase hexadecimal strings.
The recognition language is determined by ``language``, a BCP-47 language tag like ``"en-US"`` (US English) or ``"fr-FR"`` (International French), defaulting to US English. A list of supported language values can be found in the `API documentation `__ under "Interactive and dictation mode".
Returns the most likely transcription if ``show_all`` is false (the default). Otherwise, returns the `raw API response `__ as a JSON dictionary.
Raises a ``speech_recognition.UnknownValueError`` exception if the speech is unintelligible. Raises a ``speech_recognition.RequestError`` exception if the speech recognition operation failed, if the key isn't valid, or if there is no internet connection.
r r r bing_cached_access_tokenN bing_cached_access_token_expiryTr r5 Fz7https://api.cognitive.microsoft.com/sts/v1.0/issueTokenrw r7 r8 r9 r r< r" r= r> r% r? r rL r zWhttps://speech.platform.bing.com/speech/recognition/interactive/cognitiveservices/v1?{})r localeZ requestidrA r rC rD rE rF rG rH r# r$ rI rJ Z DisplayText)!r& r r( r rK r r6 r? r r r r r. r r rR r( rX rY r' r uuiduuid4r rL r r rZ r r r) r* r )r r r+ r r rN rO rP r6 rQ rR rS rT r r, r- r. rU rV r r/ rE r r r recognize_bingn s
"
"
" zRecognizer.recognize_bing!audio/l16; rate=16000; channels=1c C s t |tstdt |ts$tdt |ts6tdt |tsHtdt |tsZtd|dkstt |tsttd|dkst |tstd|dkst |tstd z d
dl} W n tk
r td Y nX | jd |||d
}
|jddd} d} |
j ||||| | d}
|
d S )a=
Performs speech recognition on ``audio_data`` (an ``AudioData`` instance), using the Amazon Lex API.
If access_key_id or secret_access_key is not set it will go through the list in the link below
http://boto3.readthedocs.io/en/latest/guide/configuration.html#configuring-credentials
r z ``bot_name`` must be a stringz ``bot_alias`` must be a stringz ``user_id`` must be a stringz!``content_type`` must be a stringN"``access_key_id`` must be a string&``secret_access_key`` must be a string``region`` must be a stringr `__. Once logged into the `dashboard `__, you will want to select "Register a new client", and fill in the form as necessary. When at the "Enable Domains" page, enable the "Speech To Text Only" domain, and then select "Save & Continue".
To get the client ID and client key for a Houndify client, go to the `dashboard `__ and select the client's "View Details" link. On the resulting page, the client ID and client key will be visible. Client IDs and client keys are both Base64-encoded strings.
Currently, only English is supported as a recognition language.
Returns the most likely transcription if ``show_all`` is false (the default). Otherwise, returns the raw API response as a JSON dictionary.
Raises a ``speech_recognition.UnknownValueError`` exception if the speech is unintelligible. Raises a ``speech_recognition.RequestError`` exception if the speech recognition operation failed, if the key isn't valid, or if there is no internet connection.
r z ``client_id`` must be a stringz ``client_key`` must be a string)r r Nr rL r z!https://api.houndify.com/v1/audior% ;application/json)ZClientIDZUserIDz{};{}z{};{};{})r zHound-Request-Infoz Hound-Request-AuthenticationzHound-Client-Authenticationr r" r# r$ ZDisambiguationZ
ChoiceDatar Z
TranscriptionZConfidenceScore)!r& r r( r r' r9 r[ r\ r' r base64urlsafe_b64encodehmacnewurlsafe_b64decoder hashlibsha256digestr( r r) dumpsr. r r r r r r rR r* r )r r Z client_idZ
client_keyr r, r- rf Z
request_idZ request_timeZrequest_signaturer. r r r/ rE r r r recognize_houndify sL
"
z Recognizer.recognize_houndifyc # C s |dkst |tstd|dks4t |ts4td|dksNt |tsNtdddl}ddl} ddl}
ddlm} | } |dko|}
|pdt|
| j
f }|pdt|
| j
f }z ddl }W n t k
r t
dY nX |jd |||d
}|jd |||d
}|j|||d
}d | }z|j|d
W n4 | k
rd } ztd||f W 5 d}~X Y nX |d }|dk rtd | }|j|||d |||}|jdd ntd d||f }|
r"z|j|d}W nt | k
rR } zTtd td|j |jd d dkr@dt|kr@t }d|_d|_|n W 5 d}~X Y nX |d }|d d krd |d kr|d d }ddl }ddl } | j |} | | } g } | d! d" D ] } | !t"| d# d d$ qd%}!| rt#| t"t$| }!| d! d& d d' }"z|j%|d W n8 t&k
rX } ztd(| | ' W 5 d}~X Y nX |j(||d) |"|!fW 5 Q R S Q R X n|d d*krz|j%|d W n8 t&k
r } ztd(| | ' W 5 d}~X Y nX |j(||d) t) }d|_d|_|n td+ t }||_d|_|nz0|j*|d,|id-d.d/ t }||_d|_|W nt | k
r } zTtd td0|j |jd d d1kr|j(||d) t }d|_d|_|n W 5 d}~X Y nX dS )2ae
Performs speech recognition on ``audio_data`` (an ``AudioData`` instance) using Amazon Transcribe.
https://aws.amazon.com/transcribe/
If access_key_id or secret_access_key is not set it will go through the list in the link below
http://boto3.readthedocs.io/en/latest/guide/configuration.html#configuring-credentials
Nr_ r` ra r ) ClientErrorz%s-%srb
transcriberc s3z%s.wav)Bucketz Error creating bucket %s: %szUploading audio data...)r{ KeyZBodyz public-read)ZACLzSkipping audio upload.z https://%s.s3.amazonaws.com/%s)TranscriptionJobNamezP!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!zError getting job:rz ZCodeZBadRequestExceptionz#The requested job couldn't be foundZTranscriptionJobZTranscriptionJobStatus)Z COMPLETEDZTranscriptFileUriZ
Transcriptr itemsr
confidencer Z transcriptsr z-Warning, could not clean up transcription: %s)r{ r| )ZFAILED
Keep waiting.Z MediaFileUriZwavr )r} ZMediaZ MediaFormatZ LanguageCodezError starting job:ZLimitExceededException)+r& r r( multiprocessingr r[ Zbotocore.exceptionsrx current_processr\ pidre r? r r SessionZ
create_bucketprintresourcer' Z
put_objectZ ObjectAclputZget_transcription_jobr r
job_namefile_keyr) urllib.requestr. r loadrD r1 sumrZ Zdelete_transcription_jobrU print_excZ
delete_objectr Zstart_transcription_job)#r r Z bucket_namerh ri rj r r r r r[ rx proccheck_existingre ry rz sessionfilenameexcZs3resr, Z
object_aclZjob_uristatusZjobZtranscript_urir) urllibZ json_datadZ confidencesitemr r r r r recognize_amazon! s "
"
zRecognizer.recognize_amazonc K s& ddd}|dko|}|r|}d| }d|i} t j|| d}
|
} | d } | d krnt }
d|
_d|
_|
n | d
kr| d }| d }||fS td
t }
||
_d|
_|
ntd|i} t jd| ||d}
|
d }d}d|i}|dd} t j||| d}
|
} | d }t }
||
_d|
_|
dS )zW
Wraps the AssemblyAI STT service.
https://www.assemblyai.com/
P c s s2 t | d }||}|s q$|V q W 5 Q R X d S )Nrp )rP rR )r r: _filer r r r read_file s
z2Recognizer.recognize_assemblyai..read_fileNz)https://api.assemblyai.com/v2/transcript/
authorization)r! r r completedr textr z$https://api.assemblyai.com/v2/upload)r! r
upload_urlz(https://api.assemblyai.com/v2/transcriptZ audio_urlrm )r z content-type)r) r! id)r ) requestsr0 r) r r r r r
post)r r Z api_tokenr kwargsr r Ztransciption_idZendpointr! r r r r r r r r) r r r recognize_assemblyai sV
z Recognizer.recognize_assemblyaic
C s t |tstdt |ts$td|j|jdkr6dnd|jdkrFdndd}d}t||dd id
}d d |_d
}|} t
d || d
d}
|dd |
zt|| jd} W nd tk
r } ztd | jW 5 d} ~ X Y n4 tk
r } ztd | jW 5 d} ~ X Y nX |
d}
t|
}|r@|S d|ksnt|d dk snd|d d krtt g }d}|d D ]L}d|krt |d D ],}d|kr||d |d } qqqd||fS ) a
Performs speech recognition on ``audio_data`` (an ``AudioData`` instance), using the IBM Speech to Text API.
The IBM Speech to Text username and password are specified by ``username`` and ``password``, respectively. Unfortunately, these are not available without `signing up for an account `__. Once logged into the Bluemix console, follow the instructions for `creating an IBM Watson service instance `__, where the Watson service is "Speech To Text". IBM Speech to Text usernames are strings of the form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX, while passwords are mixed-case alphanumeric strings.
The recognition language is determined by ``language``, an RFC5646 language tag with a dialect like ``"en-US"`` (US English) or ``"zh-CN"`` (Mandarin Chinese), defaulting to US English. The supported language values are listed under the ``model`` parameter of the `audio recognition API documentation `__, in the form ``LANGUAGE_BroadbandModel``, where ``LANGUAGE`` is the language value.
Returns the most likely transcription if ``show_all`` is false (the default). Otherwise, returns the `raw API response `__ as a JSON dictionary.
Raises a ``speech_recognition.UnknownValueError`` exception if the speech is unintelligible. Raises a ``speech_recognition.RequestError`` exception if the speech recognition operation failed, if the key isn't valid, or if there is no internet connection.
r r r NrL r zFhttps://gateway-wdc.watsonplatform.net/speech-to-text/api/v1/recognizer z audio/x-flacr c S s dS )NPOSTr r r r r rw z*Recognizer.recognize_ibm..Zapikeyz{}:{}r% r zBasic {}r" r# r$ r r r r r r
) r& r r( r r r9 r r
get_methodrn standard_b64encoder. r r(
add_headerr r r r r r rR r) r* rZ r rD r )r r r+ r r r r- r. usernamepasswordZauthorization_valuer r r/ rE Z
transcriptionr Z utterancer r r r
recognize_ibm sN
"
.
zRecognizer.recognize_ibmrh &tensorflow-data/conv_actions_frozen.pb'tensorflow-data/conv_actions_labels.txtc
C sR t |tstdt |ts$tdt |ts6tdz ddl}W n tk
r^ tdY nX || jks|| _|j |d*}|
}| | |j
|dd W 5 Q R X d
d |j|D | _|jd d
d}| l}d} d}
|j|
} || | |i\} | dd ddd }
|
D ] }| j| }| W 5 Q R S W 5 Q R X dS )a3
Performs speech recognition on ``audio_data`` (an ``AudioData`` instance).
Path to Tensor loaded from ``tensor_graph``. You can download a model here: http://download.tensorflow.org/models/speech_commands_v0.01.zip
Path to Tensor Labels file loaded from ``tensor_label``.
r z!``tensor_graph`` must be a stringz!``tensor_label`` must be a stringr NzFmissing tensorflow module: ensure that tensorflow is set up correctly.rp rh )rB c S s g | ] }| qS r )rstrip)r liner r r
[ s z3Recognizer.recognize_tensorflow..r rL r z
wav_data:0zlabels_softmax:0r )r& r r( r Z
tensorflowr? r lasttfgraphZgfileZ FastGFileZGraphDefZParseFromStringrR Zimport_graph_defZGFiletflabelsr' r graphZget_tensor_by_namerunZargsort)r r Z tensor_graphZ tensor_labeltfr Z graph_defr, sessZinput_layer_nameZoutput_layer_nameZsoftmax_tensorZ predictionsZtop_kZnode_idZ human_stringr r r recognize_tensorflowA s6
z Recognizer.recognize_tensorflowbasec K s t |tstdddl}ddl} ddl}
ddl} |sPt| drP| j |dkrvt
| di | _| j |f|pli | j|< |j dd} t
| }
| |
\}}||j}| j| j|f||rdnd|
j d|}|r|S |d S dS )
ae
Performs speech recognition on ``audio_data`` (an ``AudioData`` instance), using Whisper.
The recognition language is determined by ``language``, an uncapitalized full language name like "english" or "chinese". See the full language list at https://github.com/openai/whisper/blob/main/whisper/tokenizer.py
model can be any of tiny, base, small, medium, large, tiny.en, base.en, small.en, medium.en. See https://github.com/openai/whisper for more details.
If show_dict is true, returns the full dict response from Whisper, including the detected language. Otherwise returns only the transcription.
You can translate the result to english with Whisper by passing translate=True
Other values are passed directly to whisper. See https://github.com/openai/whisper/blob/main/whisper/transcribe.py for all options
r r N
whisper_modelr )r translate)r taskZfp16r )r& r r( numpyZ soundfiletorchwhisperrj r r0 rK Z
load_modelr' r r rR ZastypeZfloat32ry cudaZ is_available)r r modelZ show_dictZ load_optionsr r Ztranscribe_optionsnpZsfr r Z wav_bytesZ
wav_streamZ audio_arrayZ
sampling_raterE r r r recognize_whisperm s0
z Recognizer.recognize_whisperenc C sr ddl m}m} t|ts"tdt| dsFtj ds sj t n