データストリームをGoogle音声認識（Python）に変更する方法

Question

ラップトップマイクからGoogle音声認識エンジンにオーディオデータをストリームするコードがありますが、他のソースからオーディオをストリーミングする必要があります。そのソースから、私は生データのバッファを取得することができ、このバッファは私がgoogleにストリームしたいものです。誰かが私を助けたり、役に立つ助言をしたりすることができますか？ 私は自分でこれを検索して解決しようとしますが、私は見つけられませんでした。ここで

はコードです：

from __future__ import division 

import contextlib 
import functools 
import re 
import signal 
import sys 


import google.auth 
import google.auth.transport.grpc 
import google.auth.transport.requests 
from google.cloud.proto.speech.v1beta1 import cloud_speech_pb2 
from google.rpc import code_pb2 
import grpc 
import pyaudio 
from six.moves import queue 
RATE = 16000 
CHUNK = int(RATE/10) # 100ms 
DEADLINE_SECS = 60 * 3 + 5 
SPEECH_SCOPE = 'https://www.googleapis.com/auth/cloud-platform' 

def make_channel(host, port): 
    """Creates a secure channel with auth credentials from the environment.""" 
    # Grab application default credentials from the environment 
    credentials, _ = google.auth.default(scopes=[SPEECH_SCOPE]) 

    # Create a secure channel using the credentials. 
    http_request = google.auth.transport.requests.Request() 
    target = '{}:{}'.format(host, port) 

    return google.auth.transport.grpc.secure_authorized_channel(
     credentials, http_request, target) 


def _audio_data_generator(buff): 

    stop = False 
    while not stop: 
     # Use a blocking get() to ensure there's at least one chunk of data. 
     data = [buff.get()] 

     # Now consume whatever other data's still buffered. 
     while True: 
      try: 
       data.append(buff.get(block=False)) 
      except queue.Empty: 
       break 

     # `None` in the buffer signals that the audio stream is closed. Yield 
     # the final bit of the buffer and exit the loop. 
     if None in data: 
      stop = True 
      data.remove(None) 

     yield b''.join(data) 


def _fill_buffer(buff, in_data, frame_count, time_info, status_flags): 
    """Continuously collect data from the audio stream, into the buffer.""" 
    buff.put(in_data) 
    return None, pyaudio.paContinue 


# [START audio_stream] 
@contextlib.contextmanager 
def record_audio(rate, chunk): 
    """Opens a recording stream in a context manager.""" 
    # Create a thread-safe buffer of audio data 
    buff = queue.Queue() 

    audio_interface = pyaudio.PyAudio() 
    audio_stream = audio_interface.open(
     format=pyaudio.paInt16, 
     # The API currently only supports 1-channel (mono) audio 

     channels=1, rate=rate, 
     input=True, frames_per_buffer=chunk, 
     # Run the audio stream asynchronously to fill the buffer object. 
     # This is necessary so that the input device's buffer doesn't 
     # overflow 
     # while the calling thread makes network requests, etc. 
     stream_callback=functools.partial(_fill_buffer, buff), 
    ) 

    yield _audio_data_generator(buff) 

    audio_stream.stop_stream() 
    audio_stream.close() 
    # Signal the _audio_data_generator to finish 
    buff.put(None) 
    audio_interface.terminate() 
# [END audio_stream] 


def request_stream(data_stream, rate, interim_results=True): 
    """Yields `StreamingRecognizeRequest`s constructed from a recording audio 
    stream. 
    Args: 
     data_stream: A generator that yields raw audio data to send. 
     rate: The sampling rate in hertz. 
     interim_results: Whether to return intermediate results, before the 
      transcription is finalized. 
    """ 
    # The initial request must contain metadata about the stream, so the 
    # server knows how to interpret it. 
    recognition_config = cloud_speech_pb2.RecognitionConfig(
     # There are a bunch of config options you can specify. 

     encoding='LINEAR16', # raw 16-bit signed LE samples 
     sample_rate=rate, # the rate in hertz 


     language_code='sk-SK', #sk-SK a BCP-47 language tag 
    ) 
    streaming_config = cloud_speech_pb2.StreamingRecognitionConfig(
     interim_results=interim_results, 
     config=recognition_config, 
    ) 

    yield cloud_speech_pb2.StreamingRecognizeRequest(
     streaming_config=streaming_config) 

    for data in data_stream: 
     # Subsequent requests can all just have the content 
     yield cloud_speech_pb2.StreamingRecognizeRequest(audio_content=data) 


def listen_print_loop(recognize_stream): 
    """Iterates through server responses and prints them. 
    The recognize_stream passed is a generator that will block until a response 
    is provided by the server. When the transcription response comes, print it. 
    In this case, responses are provided for interim results as well. If the 
    response is an interim one, print a line feed at the end of it, to allow 
    the next result to overwrite it, until the response is a final one. For the 
    final one, print a newline to preserve the finalized transcription. 
    """ 
    num_chars_printed = 0 
    for resp in recognize_stream: 
     if resp.error.code != code_pb2.OK: 
      raise RuntimeError('Server error: ' + resp.error.message) 

     if not resp.results: 
      continue 

     # Display the top transcription 
     result = resp.results[0] 
     transcript = result.alternatives[0].transcript 

     # Display interim results, but with a carriage return at the end of the 
     # line, so subsequent lines will overwrite them. 
     # 
     # If the previous result was longer than this one, we need to print 
     # some extra spaces to overwrite the previous result 
     overwrite_chars = ' ' * max(0, num_chars_printed - len(transcript)) 

     if not result.is_final: 
      sys.stdout.write(transcript + overwrite_chars + '\r') 
      sys.stdout.flush() 

      num_chars_printed = len(transcript) 

     else: 
      print(transcript + overwrite_chars) 

      # Exit recognition if any of the transcribed phrases could be 
      # one of our keywords. 
      if re.search(r'\b(exit|quit)\b', transcript, re.I): 
       print('Exiting..') 
       break 

      num_chars_printed = 0 


def main(): 
    service = cloud_speech_pb2.SpeechStub(
     make_channel('speech.googleapis.com', 443)) 

    # For streaming audio from the microphone, there are three threads. 
    # First, a thread that collects audio data as it comes in 
    with record_audio(RATE, CHUNK) as buffered_audio_data: 
     # Second, a thread that sends requests with that data 
     requests = request_stream(buffered_audio_data, RATE) 
     # Third, a thread that listens for transcription responses 
     recognize_stream = service.StreamingRecognize(
      requests, DEADLINE_SECS) 

     # Exit things cleanly on interrupt 
     signal.signal(signal.SIGINT, lambda *_: recognize_stream.cancel()) 

     # Now, put the transcription responses to use. 
     try: 
      listen_print_loop(recognize_stream) 

      recognize_stream.cancel() 
     except grpc.RpcError as e: 
      code = e.code() 
      # CANCELLED is caused by the interrupt handler, which is expected. 
      if code is not code.CANCELLED: 
       raise 


if __name__ == '__main__': 
    main() 

Answer 1

私は多分それは助ける、Javaのためにこれを実装しました。

出典：返信用https://github.com/achernetsov/java-docs-samples/blob/stream-from-file-example/speech/cloud-client/src/main/java/com/example/speech/RecognizeStreamFromFile.java