,h`C d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlZddlZddlZddlZddlZdZdZdZ ddlmZ ddlmZmZmZm Z G d
d e! Z" G d d
e! Z# G d de! Z$ G d de% Z& G d de& Z' G d de& Z( G d de% Z) G d de& Z*d Z+d Z, G d d e% Z-e(Z.d d Z/ e0e/ e*_/ y# e $ r ddl mZ ddl mZmZ dd l mZm Z Y w xY w) ziLibrary for performing speech recognition, with support for several engines and APIs, online and offline. NzAnthony Zhang (Uberi)z3.8.1BSD) urlencode)RequesturlopenURLError HTTPError)r r )r r c e Zd Zy)WaitTimeoutErrorN__name__
__module__ __qualname__ ]/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/speech_recognition/__init__.pyr
r
% r r
c e Zd Zy) RequestErrorNr r r r r r ( r r r c e Zd Zy)UnknownValueErrorNr r r r r r + r r r c e Zd Zd Zd Zd Zy) AudioSourcec t d Nzthis is an abstract classNotImplementedErrorselfs r __init__zAudioSource.__init__/ !"=>>r c t d r r r s r __enter__zAudioSource.__enter__2 r r c t d r r r exc_type exc_value tracebacks r __exit__zAudioSource.__exit__5 r r N)r r
r r r" r( r r r r r . s ???r r c Z e Zd ZdZd
dZed Zed Zd Zd Z G d d e
Z y)
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.
Nc t |t |t sJ d | t |t r|dkD sJ d t |t r|dkD sJ d | j | _ | j j } |j }|'d|cxk r|k s n J dj
||dz
|t||j | n|j }t |j d t t f r|d dkD sJ dj
| t |d }|| _
| j j | _ | j j | j | _ || _ || _ d | _ d | _ y # t $ r |j w xY w) Nz'Device index must be None or an integerr z.Sample rate must be None or a positive integerz%Chunk size must be a positive integerzcDevice index out of range ({} devices available; device index should be between 0 and {} inclusive) defaultSampleRatez-Invalid device info returned from PyAudio: {})
isinstanceint get_pyaudiopyaudio_modulePyAudioget_device_countformatget_device_info_by_index get_default_input_device_infogetfloat Exception terminate device_indexpaInt16get_sample_size SAMPLE_WIDTH SAMPLE_RATECHUNKaudiostream)r r; sample_rate
chunk_sizerA count device_infos r r zMicrophone.__init__I s #z,'DoFoo"z+s'C VW K [K K*c*zA~f?ff # . . 0##++-
**,E'L050 q 3X 3_ 3_ `e gl op gp 3q q"NZNfe < <\ Jlq mP mP mR !+//2E"FPS UZefyZz}~Z~ D Ap Aw Aw xC AD D !+.A"B C
)))11 / / ? ? L&
OO s
B/F F7c ddl } ddlm} || j
|d k r$t dj
| j
| S # t $ r t d w xY w)z
Imports the pyaudio module and checks its version. Throws exceptions if pyaudio can't be found or a wrong version is installed
r Nz*Could not find PyAudio; check installation) LooseVersionz0.2.11z6PyAudio 0.2.11 or later is required (found version {}))pyaudio ImportErrorAttributeErrordistutils.versionrH __version__r4 )rI rH s r r0 zMicrophone.get_pyaudiof sj
O 3 ++ ,|H/E E !Y!`!`ahatat!uv v O !MN N Os A
A"c : t j j } g }t | j D ]3 }| j | }|j
|j d 5 | j |S # | j w xY w)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 is the same as its device index when creating a ``Microphone`` instance - indices in this list can be used as values of ``device_index``.
name) r* r0 r2 ranger3 r5 appendr7 r: )rA resultirF s r list_microphone_namesz Microphone.list_microphone_namest s &&(002 F51134
7 # < #A!c e Zd Zd Zd Zd Zy)Microphone.MicrophoneStreamc || _ y r_ )pyaudio_stream)r rd s r r z$Microphone.MicrophoneStream.__init__ s
"0D r c < | j j |d S )NF)exception_on_overflow)rd read)r sizes r rg z Microphone.MicrophoneStream.read s &&++D+N Nr c | j j s| j j | j j y # | j j w xY wr_ )rd
is_stopped stop_streamr` r s r r` z!Microphone.MicrophoneStream.close sP
,**557''335##))+##))+s 4A A-N)r r
r r rg r` r r r r\ rb s 1 O ,r r\ )NNi ) r r
r __doc__r staticmethodr0 rT r" r( objectr\ r r r r* r* 9 sJ : #
,6
,r r* c 8 e Zd ZdZd Zd Zd Z G d de Zy) 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 t |t d t d f st |d sJ d || _ d | _ d | _ d | _ d| _ d | _ d | _ d | _
y )N rg z@Given audio file must be a filename string or a file-like objectF) r. typehasattrfilename_or_fileobjectrB DURATION audio_reader
little_endianr? r@ FRAME_COUNT)r ru s r r zAudioFile.__init__ su 048T#Y2GHGTjlrLs x vx x&<#
"
r c
| j J d t j | j d | _ d| _ d| j j5 cxk r dk sJ d J d | j j7 | _ d} | j8 dk( r!t; j< d| j8 d | j jA | _! d| _" | j jG | _$ | jH tK | jB z | _& tN jQ | j | j
| | _ | S # t j t f$ r t j | j d | _ d| _ n# t j t f$ r t | j d r| j j }n $ r
d} d| _ Y w xY w)NrV rbTFrg nt--stdout--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, z Audio must be mono or stereo r r i ))rB waver] ru rw rx ErrorEOFErroraifcrt rg get_flac_converterosrO
subprocess STARTUPINFOdwFlagsSTARTF_USESHOWWINDOWSW_HIDE wShowWindowPopenPIPE communicateioBytesIO
ValueError getnchannels getsampwidthr> audioopbiaserror getframerater? r@
getnframesry r8 rv rp AudioFileStream)
r flac_datafflac_converter startup_infoprocess aiff_data_ aiff_file&samples_24_bit_pretending_to_be_32_bits
r r" zAudioFile.__enter__ s {{"[$[[$ + $ $*E*Et LD !%D D D%%22499Y;YY9Y;YY - - : : < 27. ! c4#4#4a8
,,99;
,,779 ((51A1A+BB
//0A0A4CUCUW}~ c
H% +
+$(IId.I.I4$P!%*"JJ)
+466? $ ; ; @ @ BI d 9 94@[ASTSYSYS[y[[[ "4!577d?#-#9#9#;L ((J,K,KK(/9/A/AL,#'L$**" 2 5 ,
$ l \ ' 2 29 = 1 JJy 1 ^(, )T(BD%
H- ^$ &] ^ ^^%*"7
+ +P ==
&9=6$%!
&sy ,E" #!M "M=,F+)M+A!M H& M&H/ +CML M %M
MMMMM M;:M;c t | j d s| j j d | _ d | _ y )Nrg )rt ru rw r` rB rv r$ s r r( zAudioFile.__exit__ s2 t22F; # # %
r c e Zd Zd ZddZy)AudioFile.AudioFileStreamc . || _ || _ || _ y r_ )rw rx r )r rw rx r s r r z"AudioFile.AudioFileStream.__init__ s ,D !.D :`D 7r c
| j j |dk( r| j j n| t t sd| j j | j set t d rt j n>dz
d d dj fdt dz
t D z | j r1dj fdt dt D d| j j dk7 rt j dd S ) Nr byteswapr, c 3 4 K | ] }|z |d ywr Nr .0rS buffer sample_widths r z1AudioFile.AudioFileStream.read.. s. E`ghVAP\L\]^_aLaEb E` c 3 4 K | ] }d ||z z yw) Nr r s r r z1AudioFile.AudioFileStream.read.. s" !t1'F1Q 5E,F"F!tr r r )rw
readframesr r. bytesr rx rt r r joinrP lenr r tomono)r rh r r s @@r rg z AudioFile.AudioFileStream.read sP &&11TX\^T^$2C2C2N2N2PdhiF fe,sf ,,99;L%%7J/ $ - -fl CF #L1$4$8b$8 9CHH E`lqr~ BC sC EH IO EP R^ m_ E` =` `F :: !tPUVWY\]cYdfrPs!tt --/14 aCMr N)r )r r
r r rg r r r r r s
a
r r N) r r
r rl r r" r( rn r r r r rp rp s#
7r & r rp c > e Zd ZdZd Zd dZd dZd dZd dZd dZ y)
AudioDataa
Creates a new ``AudioData`` instance, which represents mono audio data.
The raw audio data is specified by ``frame_data``, which is a sequence of bytes representing audio samples. This is the frame data structure used by the PCM WAV format.
The width of each sample, in bytes, is specified by ``sample_width``. Each group of ``sample_width`` bytes represents a single audio sample.
The audio data is assumed to have a sample rate of ``sample_rate`` samples per second (Hertz).
Usually, instances of this class are obtained from ``recognizer_instance.record`` or ``recognizer_instance.listen``, or in the callback for ``recognizer_instance.listen_in_background``, rather than instantiating them directly.
c |dkD sJ d |dz dk( rd|cxk r dk sJ d J d || _ || _ t | | _ y )Nr z&Sample rate must be a positive integerr, r z.Sample width must be between 1 and 4 inclusive)
frame_datarC r/ r )r r rC r s r r zAudioData.__init__, s\ QH HHa 1$l)?a)?qAqq)?qAqq$& -r Nc x | |dk\ sJ d |||dn|k\ sJ d |d}n(t || j z | j z dz }|t | j }n(t || j z | j z dz }t | j || | j | j S )ag
Returns a new ``AudioData`` instance, trimmed to a given time interval. In other words, an ``AudioData`` instance with the same audio data except starting at ``start_ms`` milliseconds in and ending ``end_ms`` milliseconds in.
If not specified, ``start_ms`` defaults to the beginning of the audio, and ``end_ms`` defaults to the end.
r z*``start_ms`` must be a non-negative numberzI``end_ms`` must be a non-negative number greater or equal to ``start_ms``i )r/ rC r r r r )r start_msend_ms
start_byteend_bytes r get_segmentzAudioData.get_segment3 s 8q=^2^^~1AAx!P ^ S^ ^ J h)9)9 9D4??+HFT%5%5 58I8I IdRSH H=t?O?OQUQbQbccr c
< | |dkD sJ d |"|dz dk( rd|cxk r dk sJ d J d | j | j dk( rt j dd |@| j |k7 r1t j
| j d| j |d \ }|| j |k7 r|dk( rZt j | j d t j d dd t j | j | n!t j | j | |dk( rt j dd S # t j $ r1 d j fd
t dt d D Y aw xY w) a)
Returns a byte string representing the raw frame data for the audio represented by the ``AudioData`` instance.
If ``convert_rate`` is specified and the audio sample rate is not ``convert_rate`` Hz, the resulting audio is resampled to match.
If ``convert_width`` is specified and the audio samples are not ``convert_width`` bytes each, the resulting audio is converted to match.
Writing these bytes directly to a file results in a valid `RAW/PCM audio file `__.
Nr z4Sample rate to convert to must be a positive integerr, r z.b s 'b!Qq1u(='br ) r r r r rC ratecvlin2linr r rP r )r convert_rate
convert_widthr r s @r get_raw_datazAudioData.get_raw_dataE s #|a'7o9oo $ ):a)?A D[Z[D[ ] _] ]D[ ] _] ]?? ! ||Ha6H #(8(8L(H!..43D3DaIYIY[gimnKHa $):):m)K !"??8T5F5FJ \\#q!, 'x9J9JM ZH"??8T5F5F
V A ||Ha5H }} c "xx'buQPST\P]_`Ga'b bHcs E AFFc | j || }| | j n|}| | j n|}t j 5 }t j |d } |j | |j | |j d |j | |j }|j ddd |S # |j w xY w# 1 sw Y S xY w)a!
Returns a byte string representing the contents of a WAV file containing the audio represented by the ``AudioData`` instance.
If ``convert_width`` is specified and the audio samples are not ``convert_width`` bytes each, the resulting audio is converted to match.
If ``convert_rate`` is specified and the audio sample rate is not ``convert_rate`` Hz, the resulting audio is resampled to match.
Writing these bytes directly to a file results in a valid `WAV file `__.
Nwbr, )
r rC r r r r r] setframerate setsampwidth setnchannels writeframesgetvaluer` ) r r r r rC r wav_file
wav_writerwav_datas r get_wav_datazAudioData.get_wav_datan s $$\=A*6*>d&&L ,9,At((} ZZ\ #X 8T2J
#'' 4'' 5''*&&x0#,,. " # " # s% C# AC3C#C C##C-c
| j || | | j n|}| | j n|t t d rt j
n>dz
dd dj
fdt dz
t D z t j 5 }t j |d } |j | |j |j d |j! |j# }|j% ddd |S # |j% w xY w# 1 sw Y S xY w)aB
Returns a byte string representing the contents of an AIFF-C file containing the audio represented by the ``AudioData`` instance.
If ``convert_width`` is specified and the audio samples are not ``convert_width`` bytes each, the resulting audio is converted to match.
If ``convert_rate`` is specified and the audio sample rate is not ``convert_rate`` Hz, the resulting audio is resampled to match.
Writing these bytes directly to a file results in a valid `AIFF-C file `__.
Nr r, r r c 3 4 K | ] }|z |d ywr r )r rS r r s r r z*AudioData.get_aiff_data.. s- A`ef!lJZ[\]_J_A` A`r r )r rC r rt r r r rP r r r r r] r r r r r r` ) r r r rC r aiff_writerr r r s @@r
get_aiff_datazAudioData.get_aiff_data sk $$\=A*6*>d&&L ,9,At((} 7J ' '',?H q 0 4" 45 A`jop| @A qA CF GO CP R^ k_ A` 9` `H ZZ\ $Y ))It4K
$((5(( 6((+''1 % . . 0 !!# $ !!# $ s% .E
AD5E
5EE
Ec |"|dz dk( rd|cxk r dk sJ d J d | j dkD r|d}| j || }t }t j dk( rMt j }|xj t
j z c_ t
j |_
nd}t j |ddd d
gt
j t
j | }|j | \ }}|S ) a
Returns a byte string representing the contents of a FLAC file containing the audio represented by the ``AudioData`` instance.
Note that 32-bit FLAC is not supported. If the audio data is 32-bit and ``convert_width`` is not specified, then the resulting FLAC will be a 24-bit FLAC.
If ``convert_rate`` is specified and the audio sample rate is not ``convert_rate`` Hz, the resulting audio is resampled to match.
If ``convert_width`` is specified and the audio samples are not ``convert_width`` bytes each, the resulting audio is converted to match.
Writing these bytes directly to a file results in a valid `FLAC file `__.
Nr, r r z
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 sourcezAudio source must be entered before recording, see documentation for ``AudioSource``; are you using ``source`` outside of a ``with`` statement? r FT)r. r rB r r r@ r? rg r writer r` r r> ) r sourcedurationoffsetframesseconds_per_buffer elapsed_time offset_timeoffset_reachedr r s r recordzRecognizer.record s &+.P0PP}}( | +| | $llS 0F4F4F F n 11 '%)N]]'' 5F6{a V 22 x 7 V$ __&
V%7%79L9LMMr c t |t sJ d |j J d | j | j cxk\ rdk\ sJ J |j
dz |j z }d} ||z
}||kD ry|j j |j
}t j ||j }| j |z }|| j z }| j |z |d|z
z z | _
)a-
Adjusts the energy threshold dynamically using audio from ``source`` (an ``AudioSource`` instance) to account for ambient noise.
Intended to calibrate the energy threshold with the ambient energy level. Should be used on periods of audio without speech - will stop early if any speech is detected.
The ``duration`` parameter is the maximum number of seconds that it will dynamically adjust the threshold for before returning. This value should be at least 0.5 in order to get a representative sample of the ambient noise.
r NzAudio source must be entered before adjusting, see documentation for ``AudioSource``; are you using ``source`` outside of a ``with`` statement?r r r, )r. r rB r r r@ r? rg r rmsr> r r r ) r r r r r r energydamping
target_energys r adjust_for_ambient_noisez#Recognizer.adjust_for_ambient_noise s &+.P0PP}}( | +| |##t'A'AFQFFFF $llS 0F4F4F F . .Lh&]]'' 5F [[)<)<=F <<@RRG "T%>%> >M$($9$9G$CmWX[bWbFc$cD ! r c t j j | dd l}t j j |j t j j |dd j dj | j }|j d |j dj dgt | z j |j }d}t |j |j z } d }
t! t# j$ d| z } t' j( | } t' j( | }
|| z
}|r||kD r t+ d
|j, j/ |j }t | dk( rn| j | t1 j2 ||j4 d |j ||
\ }}
|
j | |j7 d j |
}|d
k7 sJ d |dkD rnd j | |fS )Nr resourcesz
common.res,)resource_filename model_strg ?z0.4 )maxlenz8listening timed out while waiting for hotword to be saidr, r r z0Error initializing streams or reading audio data) syspathrQ
snowboydetectpop
SnowboyDetectr r encode SetAudioGainSetSensitivityr
SampleRater8 r@ r? r/ mathceil collectionsdequer
rB rg r r r> RunDetection)r snowboy_locationsnowboy_hot_word_filesr timeoutr
detectorsnowboy_sample_rater r resampling_statefive_seconds_buffer_countr resampled_framesr resampled_buffersnowboy_results r snowboy_wait_for_hot_wordz$Recognizer.snowboy_wait_for_hot_word s () .. ggll+;[, W ^ ^ `hh 56==? /
c" %37M3N)N O V V XY & 1 1 3 "6<< 063E3E E %( !6H2H(I$J! ""*CD&,,4MN . .L<'1&'abb]]'' 5F6{a MM& ! 29 H[H[]^`f`r`r uH JZ 2[ . . # #$4 5 & 2 2388`__, 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 zAudio 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 filesr z5listening timed out while waiting for phrase to start)r r )"r. r rB r r r r isfiler r8 r@ r? r/ r r r r r r
rg r rQ popleftr r r> r r r r r# rP r r )r r r phrase_time_limitsnowboy_configuration
hot_word_filer pause_buffer_countphrase_buffer_countnon_speaking_buffer_countr r r r r r r r
delta_time pause_count phrase_countphrase_start_timerS r s r listenzRecognizer.listenC s &+.P0PP}}( | +| |##t'A'AFQFFFF ,77>>"'',,/DQ/GI["\]
`
!6q!9
L
ww~~m4 L 7L L
L #6<< 063E3E E 4+?+?BT+T!U V !$))D,A,ADV,V"W X$' $2L2LOa2a(b$c! &&(F$, $66L <'#9 ./f gg #]] / / =F6{a'MM&)6{%>> ( %[[1D1D EF 5 55u 44"&"H"HL^"^(.1J1J(J
040E0E0OR_cdgncnRo0o-) . >?MA MXXf%
V%7%79L9LMMr c t t sJ d dg fd}dfd }t j | d_ j |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 5 } d r) j | d }d r
| d r)d d d y # t $ r Y w xY w# 1 sw Y y xY w)Nr r, )r1 r
)srA callbackr' runningr r s r threaded_listenz8Recognizer.listen_in_background..threaded_listen sp
=1 aj= $ Aq2C D #1:xe'<
aj
=
= ,
=
=s+ A <A AA AA Ac 6 dd< | rj y y )NFr )r )
wait_for_stoplistener_threadr6 s r stopperz0Recognizer.listen_in_background..stopper s GAJ $$& r )target)T)r. r threadingThreaddaemonstart)r r r5 r' r7 r; r: r6 s ```` @@r listen_in_backgroundz Recognizer.listen_in_background sY &+.P0PP& = = '
$**/B!% r c t |t sJ d t |t s%t |t rt | dk( sJ d |t d |D sJ d ddlm}m}m} t |d rt |j d s t d
t |t rt j j! t j j# t j j% t& d| } t j j) | st dj+ | t j j! | d }
t j j! | d } t j j! | d } n|\ }
} } t j j) |
st dj+ |
t j j- | st dj+ | t j j- | st dj+ | |j j/ }
|
j1 d|
|
j1 d| |
j1 d| |
j1 dt j2 |j |
}|j5 dd }|t7 d 5 }|j9 d |D |j; |j= d |j> |jA d |jC |jE |d d! |jG ddd n|t j jI | st d"j+ | t j jK t j j# | }t j jM t j jO | d }d#j+ || }t j jI | s[ || }|jQ d$j+ | }|jS ||jU d% }|jW | n |||jU d% }|jY || |jA | |jC |jE |d d! |jG n3|jC |jE |d d! |jG |r|S |j[ }| |j\ S t_ # t $ r t d t $ r t d
w xY w# 1 sw Y `xY w)&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 datar z``language`` must be a string or 3-tuple of Sphinx data file paths of the form ``(acoustic_parameters, language_model, phoneme_dictionary)``Nc 3 K | ]9 \ }}t |t d t d f xr d|cxk xr dk nc ; yw)rr r r, Nr. rs r keyword sensitivitys r r z.Recognizer.recognize_sphinx.. sO .` xLw~ ALj48TRUYBW.X.r]^bm]rqr]r.r .`s ?Az^``keyword_entries`` must be ``None`` or a list of pairs of strings and numbers between 0 and 1r ) pocketsphinxJsgfFsgModelzJmissing 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> r r r wc 3 R K | ] \ }}d j |d|z dz
! yw)z
{} /1e{}/
d n N)r4 rF s r r z.Recognizer.recognize_sphinx.. s4 AXlX_al] 1 1'3;Ls;R S As %'keywordsFTz Grammar '{0}' does not exist.z {0}/{1}.fsgz{0}.{0}g @)0r. r strtupler allrI rJ rK rJ r r rt rL r r r dirnamerealpath__file__isdirr4 r% rM
set_stringdevnullr PortableNamedTemporaryFile
writelinesflushset_kwsrO
set_search start_utt process_rawend_uttexistsabspathsplitextbasenameget_rule build_fsg get_logmath writefileset_fsghyphypstrr )r
audio_datalanguagekeyword_entriesgrammarshow_allrI rJ rK language_directory acoustic_parameters_directorylanguage_model_filephoneme_dictionary_fileconfigdecoderr r grammar_path grammar_namefsg_pathjsgfrulefsg
hypothesiss r recognize_sphinxzRecognizer.recognize_sphinx s *i0U2UU(C(Z%-HSQY]^_M_ q cq q &# .` P_ .` +` B bB B x A A |Y/w|?S?SUe7f z{ { h $!# bggoobgg>N>Nx>X.Y[npx!y 77==!34"#Y#`#`as#tuu,.GGLL9KM],^ )"$'',,/ACZ"[ &(ggll3EGg&h #Zb W )+>@Www}} :; a h h jG H I
Iww~~ 12 Q X XYl mn nww~~ 56 U \ \]t uv v %%446&"?@%!45'#:;(BJJ/ &&v. **Q*O &+C0
"A Ap A A
AFF3"":.!!###HeT:!
"
"
77>>'* !@!G!G!PQQ 77??277??7+CDL 77++BGG,<,>(+G}}}Y%5%5l%CDnnT7+>+>+@#F
h' x)<)<)>D OOL# . | , % 6 OO % 6 OO G^ [[]
!**;*;#; !!W m kl l x vw w xD
"
"s )
V ;B W
(W
Wc t |t sJ d |t |t sJ d t |t sJ d |j |j dk\ rdndd }|d}d j t
d
||d }t ||d d
j |j i } t || j }|j j d }
g } |
j! d D ]2 } | st# j$ | d }
t' |
dk7 s-|
d } n |r| S t | t( r t' | j+ dg dk( r
t- d| d v rt/ | d d }n| d d }d|vr
t- |d S # t $ r)} t dj | j d} ~ wt $ r)} t dj | j d} ~ ww xY w)aX
Performs speech recognition on ``audio_data`` (an ``AudioData`` instance), using the Google Speech Recognition API.
The Google Speech Recognition API key is specified by ``key``. If not specified, it uses a generic key that works out of the box. This should generally be used for personal or testing purposes only, as it **may be revoked by Google at any time**.
To obtain your own API key, simply following the steps on the `API Keys `__ page at the Chromium Developers site. In the Google Developers Console, Google Speech Recognition is listed as "Speech API".
The recognition language is determined by ``language``, an RFC5646 language tag like ``"en-US"`` (US English) or ``"fr-FR"`` (International French), defaulting to US English. A list of supported language tags can be found in this `StackOverflow answer `__.
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.
rC Nz$``key`` must be ``None`` or a string ``language`` must be a string@ r rO z'AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgwz0http://www.google.com/speech-api/v2/recognize?{}chromium)clientlangkey Content-Typezaudio/x-flac; rate={}dataheadersr recognition request failed: {}!recognition connection failed: {}utf-8
rR r alternative
confidencec | d S )Nr r )r s r z-Recognizer.recognize_google..^ s
XcdpXq r )r
transcript)r. r rU r rC r4 r r r r r r reasonr rg decodesplitjsonloadsr dictr7 r max)r rq r rr ru r urlrequestresponsee
response_text
actual_resultlinerR best_hypothesiss r recognize_googlezRecognizer.recognize_google( s" *i0U2UU{jc 2Z4ZZ(C(I*II ,,!+!7!74!?T -
; G@GG S
I
#IH_HfHfgqg}g}H~7 A U w0F0FGH
!
..w7
!''- DZZ%h/F6{a &q
M)-.#m6G6G
WY6Z2[_`2`hyh{b{ = 7 7 !-
">Dq rO ,M :1 =O .6G6I0I |,,5 R ? F Fqxx PQ Q U B I I!(( ST T Us$ 8F& & H/$G H $HHc t |t sJ d |t j | t |t sJ d |t d |D sJ d |j d|j cxk rdk rn ndn t dt |j d d
} d d l m
} d d
lm} d dl} d dl}
d dl} | j& r+|
j) | j& | j* _ ||j/ } nPt1 d 5 } | j3 | | j5 |j7 | j8 } ddd |dd d }
d|j |d}|d|i|d< |rd|d< |
j? jA dtC jD | jG d i|d } |jI }|r|S d |vstU |d d k( r
tW d }|d D ]! }||d! d d" jY d#z z
}# |S # t $ r t d w xY w# 1 sw Y xY w# t: $ r t= d w xY w# | jJ jL $ r}t= | d}~wtN $ r)}t= d jQ |jR d}~ww xY w)$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.
rC Nz<``credentials_json`` must be ``None`` or a valid JSON stringr c 3 \ K | ]$ }t |t d t d f & yw)rr NrE )r preferred_phrasess r r z4Recognizer.recognize_google_cloud..x s0 0Qiz
;LtTVxY]^aYbNc0d 0Qs *,z/``preferred_phrases`` must be a list of stringsr i r rO r )GoogleCredentials)buildrP speechv1F) credentialscache_discoveryzbmissing google-api-python-client module: ensure that google-api-python-client is set up correctly.FLAC)encodingsampleRateHertz languageCodephrases
speechContextTenableWordTimeOffsetscontentutf8)rA rz )bodyz"recognition connection failed: {0}resultsrr alternativesr )-r. r r r r9 AssertionErrorrU rW r rC r minoauth2client.clientr googleapiclient.discoveryr googleapiclient.errorssocketgoogleapiclient.httpr getdefaulttimeouthttpDEFAULT_HTTP_TIMEOUT_SECget_application_defaultr^ r r` from_streamrO rJ r r recognizebase64 b64encoder executeerrors HttpErrorr r4 r r r strip)r rq credentials_jsonrr r ru r r r googleapiclientr api_credentialsr speech_service
speech_configr r r r rR s r recognize_google_cloudz!Recognizer.recognize_google_cloude s *i0U2UU ' ,-(C(I*II (C 0Q P 0Q -Q D SD D ,,!%)?)?!H5!HcRVX[\f\r\rtyXzN{ -
E = 7 )
'%%&*B*B*D*L@D@V@V$$= '"3"K"K"M 04 LGG ,-GGI&7&C&CAFF&KOL
#8T`e fN &,
@V@Vhpq
(.79J-KM/ * 59M1 2 '')33IvO_O_`iOjOqOqrxOyCz GT :U3 V V (H H_ H $HY,?(@A(EM^M`G`
y) PF & 03LAGGICO OJ P q rN3q$r r r6L L E D E
E E %%// " q/ ! V C J J188 TU U VsT H3 -A-I =I I I/ 3I II I,/K J K $KKc t |t sJ d t |t sJ d |j |j dk\ rdndd }d}t ||dj
| d d
} t || j }|j j d } t j | }
|r|
S d|
vs|
d
t# |
d S # t $ r)}t d
j
|j d}~wt $ r)}t dj
|j d}~ww xY w)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 Nr rO z$https://api.wit.ai/speech?v=20160526 Bearer {}z audio/wav)
Authorizationr r r r r r _text)r. r rU r rC r r4 r r r r r r rg r r r r ) r rq r ru r r r r r r rR s r
recognize_witzRecognizer.recognize_wit s: *i0K2KK#s#?%?? **!+!7!74!?T +
5#H HZHZ[^H_q|6}~ U w0F0FGH
!
..w7
M* F] & F7O$;CTCV=Vg R ? F Fqxx PQ Q U B I I!(( ST T Us$ 6C D?&$D
D?$D::D?c 8 t |t sJ d t |t sJ d t |t sJ d t | dd t | dd }}d} dd lm} |
|kD r]d } t | d d
d|d }
|r } t |
d } | j j! d }|r|| _ dz | _ |j' dd }dj t) ||t+ j, d }t. j0 d k\ r5t |t3 j4 | d j | d d d }nUd!j t7 | j9 d }|d"z |z d#z }t ||d j | d d d } t || j: }|j j! d }t= j> | }|r|S d&|vs |d& d'k7 sd(|vr
tA |d( S # t $ r% dd lm} n# t t f$ r d}d
}Y nw xY wY w xY w# t $ r)}
t dj |
j d}
~
wt $ r)}
t dj |
j d}
~
ww xY w# t $ r)}
t d$j |
j d}
~
wt $ r)}
t d%j |
j d}
~
ww xY w))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 ) monotonicFz7https://api.cognitive.microsoft.com/sts/v1.0/issueTokenr z!application/x-www-form-urlencoded0) Content-typeContent-LengthzOcp-Apim-Subscription-Keyr < r z credential request failed: {}z credential connection failed: {}r iX rN r rO zWhttps://speech.platform.bing.com/speech/recognition/interactive/cognitiveservices/v1?{})rr locale requestid)r r z.audio/wav; codec="audio/pcm"; samplerate=16000chunked)r r zTransfer-Encodingz{:X}
s
0
r r RecognitionStatusSuccess DisplayText)!r. r rU getattrtimer rJ RuntimeErrorr r r r r4 r r rg r r r r r uuiduuid4r version_infor r r r r r r r )r rq r rr ru access_token expire_time
allow_cachingr credential_urlcredential_request
start_timecredential_responser r r r ascii_hex_data_length chunked_transfer_encoding_datar r rR s r recognize_bingzRecognizer.recognize_bing sM *i0K2KK#s#?%??(C(I*II$+D2Ld$SU\]a dE GK VLk
& & )+ "; VN!( c C"%-0L " &[
X&-.@"&M#
/335<`__. 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 rN NrN r rO z!https://api.houndify.com/v1/audior ;zapplication/json)ClientIDUserIDz{};{}z{};{};{})r zHound-Request-Infoz Hound-Request-AuthenticationzHound-Client-Authenticationr r r r Disambiguation
ChoiceDatar
Transcription) r. r rU r rC r r r/ r r urlsafe_b64encodehmacnewurlsafe_b64decoder hashlibsha256digestr r r dumpsr4 r r r r r r rg r r )r rq client_id
client_keyru r r user_id
request_id request_timerequest_signaturer r r r rR s r recognize_houndifyz Recognizer.recognize_houndify2 s8 *i0K2KK)S)K+KK*c*M,MM **!+!7!7=!He +
2 !$**, /TZZ\1B3tyy{+, " 4 4 HH((4w'$.1B1B71KKlNaNabiNjj
fh
&/
#H ."&**)w-W"X,3NN7J,O+5+<+`__. 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 z ``username`` must be a stringz ``password`` must be a stringrN Nr rO zDhttps://stream.watsonplatform.net/speech-to-text/api/v1/recognize?{}falsez{}_BroadbandModelr )profanity_filtermodelinactivity_timeoutz audio/x-flactrue)r zX-Watson-Learning-Opt-Outr z{}:{}r r zBasic {}r r r r r, r r r r )r. r rU r rC r r4 r r r standard_b64encoder r
add_headerr r r r r r rg r r r r rQ r )r rq usernamepasswordrr ru r r r authorization_valuer r r rR
transcription utterancer s r
recognize_ibmzRecognizer.recognize_ibmg sY *i0K2KK(C(I*II(C(I*II ,,!+!7!75!@e","9"9Q">$A -
U[[\e '(//9"$g
]
#I *)/8
% 7 7xQY8Z8a8abi8j k r rsz {?J,=,=>Q,RS U w0F0FGH
!
..w7
M* F] F "c&*;& x86i686i786AMD64x86_64zflac-win32.exeDarwinzflac-macLinux> r' r( r) zflac-linux-x86> r* r+ zflac-linux-x86_64zFLAC conversion utility not available - consider installing the FLAC command line application by running `apt-get install flac` or your operating system's equivalent)r r sync) shutil_whichr r rX rg rZ platformsystemmachiner OSErroraccessX_OKstatchmodst_modeS_IEXECr r r. )r base_pathr1 r2 stat_infos r r r s !&)N GGOOBGGOOH$=> "//+X-=-=-? Y 7.X#X WW\\)5E FN
x
G/Y$Y WW\\)Z @N
w
7.E#E WW\\)5E FN
w
7.A#A WW\\)5H IN B C
C
yy 1/I HH^Y%6%6 %E F(//++ - - 7 RYYv=N D s +B>! 1bgg!6Hr c 6 e Zd ZdZd dZd Zd Zd Zd Zd Z y)
r^ zLimited replacement for ``tempfile.NamedTemporaryFile``, except unlike ``tempfile.NamedTemporaryFile``, the file can be opened again while it's currently open, even on Windows.c || _ y r_ )mode)r rD s r r z#PortableNamedTemporaryFile.__init__ s r c dd l }|j \ }}t j || j | _ || _ | S )Nr )tempfilemkstempr fdopenrD _filerO )r rF file_descriptor file_paths r r" z$PortableNamedTemporaryFile.__enter__ s< %-%5%5%7"YY :
r c v | j j t j | j y r_ )rI r` r removerO r$ s r r( z#PortableNamedTemporaryFile.__exit__ s"
$)) r c : | j j |i |S r_ )rI r r argskwargss r r z PortableNamedTemporaryFile.write tzz 000r c : | j j |i |S r_ )rI r_ rO s r r_ z%PortableNamedTemporaryFile.writelines s $tzz$$d5f55r c : | j j |i |S r_ )rI r` rO s r r` z PortableNamedTemporaryFile.flush rR r N)zw+b)
r r
r rl r r" r( r r_ r` r r r r^ r^ s& { 161r r^ c
|j dd }d} t j j }|j d |vrn3| t j j }d|j d z dz dz d z dz d
z |j d z d z |j d z d z dz |j d z dz d
z dz dz |z dz dz |j d z dz } t || dj
| t t | ddj
| d }
t |
d } | j j d }
t! j" |
}|r|S d|vsd|d vs |d d dk7 r
t% |d d S # t $ r)} t dj
| j d } ~ wt $ r)} t dj
| j d } ~ ww xY w) NrN r rO zhttps://api.api.ai/v1/queryr s --r s0 Content-Disposition: form-data; name="request"
s Content-Type: application/json
s {"v": "20150910", "sessionId": "s ", "lang": "s "}
sH Content-Disposition: form-data; name="voiceData"; filename="audio.wav"
s Content-Type: audio/wav
s --
r z 100-continuez multipart/form-data; boundary={})r r Expectr r
r r r status errorTypesuccessrR
resolvedQuery)r r r hexr r r4 rU r r r r r r rg r r r r )r rq client_access_tokenrr
session_idru r r boundaryr r r r r rR s r
recognize_apir` s &&E&KH
'C
::<## ??7 #8 3U
(8(8: 8??7+ +g 58o o sX X [b b eO O R\ Rc Rc dk Rl l oB B EM ET ET U\ E] ] `j j mr r u} uD uD EL uM M PW W Zk k nL L OV V Ya a dk k ns s v~ vE vE FM vN N QZ ZDc @R@RSf@g{~ @C DH @I |J Vd vX v_ v_ `h vi /j kGGR0 MMO**73M
ZZ
&F v F84D!DxHXYdHeirHr !! ( O ,, ` .N.U.UVWV^V^._!`` b -P-W-WXYX`X`-a bbbs$ 9
F& & H/$G H $HH)enNF)1rl r r r r r r r r r r r r= r0 r6 r
r r r
__author__rM __license__urllibr urllib2r r r r rJ urllib.parseurllib.request urllib.errorr9 r
r r rn r r* rp r r r r/ r^ WavFiler` classmethodr r r rk s p
$
1 == (y ' $9 # ) (?& ?p, p,fq qhk k\L ( L (^ B1 1B -( '}5
A' 1&/001s C! !C?>C?