Skip to content
The Chat Archive
gpt-4o-mini-2024-07-18· OpenAI WildChat-4.8M (AI2)

import socket import wave HOST = '0.0.0.0' # Слушаем на всех интерфейсах PORT = 6543 #…

  1. User

    import socket import wave

    HOST = '0.0.0.0' # Слушаем на всех интерфейсах PORT = 6543 # Порт, который вы используете

    def main(): server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((HOST, PORT)) server_socket.listen(1) print("Сервер запущен, ожидаем подключения...")

    conn, addr = server_socket.accept()
    print(f"Подключено к {addr}")
    
    with wave.open('output.wav', 'wb') as wf:
        wf.setnchannels(1)  # моно
        wf.setsampwidth(2)  # 16 бит
        wf.setframerate(44100)  # Частота дискретизации
    
        while True:
            data = conn.recv(1024)
            if not data:
                break
            wf.writeframes(data)
    
    conn.close()
    server_socket.close()
    print("Сервер остановлен.")
    

    if name == "main": main()

    Что это за код?

  2. Assistant

    Данный код представляет собой простой сервер на Python, который принимает аудиоданные через сокетное соединение и сохраняет их в WAV-файл (output.wav). Ниже приведено более детальное объяснение каждой части кода:

    1. Импорт библиотек:

      • socket: библиотека для работы с сетевыми сокетами.
      • wave: библиотека для работы с WAV-аудиофайлами.
    2. Настройка хоста и порта:

      • HOST = '0.0.0.0': этот параметр позволяет серверу слушать на всех интерфейсах (например, на всех доступных IP-адресах).
      • PORT = 6543: порт, на котором будет запущен сервер.
    3. Основная функция сервера:

      • Создается TCP-сокет (socket.SOCK_STREAM).
      • С помощью метода bind сокет связывается с указанным хостом и портом.
      • Сокет переходит в режим прослушивания, ожидая входящих подключений.
    4. Ожидание подключения:

      • Сервер принимает входящее подключение и выводит адрес подключившегося клиента.
    5. Запись в файл WAV:

      • Открывается (или создается) файл output.wav в режиме записи.
      • Настраиваются параметры WAV-файла (моно, 16 бит, 44100 Гц).
      • В бесконечном цикле сервер будет принимать данные от клиента. Пакеты данных размером до 1024 байт будут записываться в WAV-файл.
      • Если данные не поступают (сокет закрыт), цикл прерывается.
    6. Завершение работы:

      • Закрываются соединение и серверный сокет, выводится сообщение о том, что сервер остановлен.

    Примечания:

    • Чтобы использовать этот сервер, вам понадобится клиент, который будет отправлять аудиоданные на этот сервер по указанному порту.
    • Данный код является упрощенным вариантом и не обрабатывает возможные ошибки или исключения, что следует учитывать при его использовании в реальных приложениях.
    • Убедитесь, что аудиоданные, отправляемые клиентом, имеют подходящий формат (моно, 16 бит, 44100 Гц), иначе записанный WAV-файл может быть не воспроизводим.
  3. User

    import json import os import random import struct import time import pvporcupine import simpleaudio as sa import vosk import yaml from fuzzywuzzy import fuzz from pvrecorder import PvRecorder import config import tts from const import SYSTEM_PROMPT

    from llm_models.mini_4o_model import ModelClient

    from services.browser_service import open_browser, open_youtube, open_gpt, open_network, toggle_keyboard_layout,
    toggle_fullscreen, move_browser_to_other_monitor, toggle_play from services.lamp_service import turn_on, turn_off from services.news_service import get_rates from services.pc_service import pc_off, enter_sleep_mode, cancel_sleep_mode, switch_to_speakers, switch_to_headphones,
    set_volume from services.weather_service import WeatherFetcher

    CDIR = os.getcwd() VA_CMD_LIST = yaml.safe_load( open('commands.yaml', 'rt', encoding='utf8'), )

    PORCUPINE

    porcupine = pvporcupine.create( access_key=config.PICOVOICE_TOKEN, keyword_paths=['Sonya_en_windows_v3_0_0.ppn'], sensitivities=[1] )

    VOSK

    model = vosk.Model("model_small") samplerate = 16000 device = config.MICROPHONE_INDEX kaldi_rec = vosk.KaldiRecognizer(model, samplerate)

    client = ModelClient() weatherFetcher = WeatherFetcher()

    def print_yellow(text): """Выводит текст в желтом цвете.""" print(f"\033[93m{text}\033[0m")

    def print_red(text): """Выводит текст в красном цвете.""" print(f"\033[91m{text}\033[0m")

    def play(phrase, wait_done=True): global recorder filename = f"{CDIR}\sound\"

    if phrase == "greet":
        filename += f"start.wav"
    if phrase == "cancel":
        filename += f"cancel.wav"
    
    if wait_done:
        recorder.stop()
    
    wave_obj = sa.WaveObject.from_wave_file(filename)
    play_obj = wave_obj.play()
    
    if wait_done:
        play_obj.wait_done()
        recorder.start()
    

    def recognize_cmd(cmd: str): rc = {'cmd': '', 'percent': 0} for c, v in VA_CMD_LIST.items():

        for x in v:
            vrt = fuzz.ratio(cmd, x)
            if vrt > rc['percent']:
                rc['cmd'] = c
                rc['percent'] = vrt
    
    return rc
    

    def execute_cmd(cmd: str, voice: str): if cmd == 'open_browser': tts.va_speak(open_browser()) elif cmd == 'open_youtube': tts.va_speak(open_youtube()) elif cmd == 'lamp_on': tts.va_speak(turn_on()) elif cmd == 'lamp_off': tts.va_speak(turn_off()) # elif cmd == 'pc_off': # tts.va_speak(pc_off(0)) elif cmd == 'enter_sleep_mode': tts.va_speak(enter_sleep_mode()) elif cmd == 'switch_to_speakers': tts.va_speak(switch_to_speakers()) elif cmd == 'switch_to_headphones': tts.va_speak(switch_to_headphones()) elif cmd == 'normalize_volume': tts.va_speak(set_volume(40)) elif cmd == 'max_volume': tts.va_speak(set_volume(100)) elif cmd == 'cancel_sleep_mode': tts.va_speak(cancel_sleep_mode()) elif cmd == 'open_gpt': tts.va_speak(open_gpt()) elif cmd == 'open_network': tts.va_speak(open_network()) elif cmd == 'get_rates': tts.va_speak(get_rates(client, voice)) elif cmd == 'get_weather': tts.va_speak(weatherFetcher.get_weather(client)) elif cmd == 'toggle_keyboard_layout': tts.va_speak(toggle_keyboard_layout()) elif cmd == 'toggle_fullscreen': tts.va_speak(toggle_fullscreen()) elif cmd == 'toggle_play': tts.va_speak(toggle_play()) elif cmd == 'move_browser_to_other_monitor': tts.va_speak(move_browser_to_other_monitor()) elif cmd == 'off': responses = ["Завершаю работу, до встречи!", "Выключаюсь, до свидания!", "Пока!"] tts.va_speak(random.choice(responses)) porcupine.delete() exit(0)

    def va_respond(voice: str): if voice: print(f"Распознано: {voice}")

        cmd = recognize_cmd(voice)
        print(cmd)
    
        if len(cmd['cmd'].strip()) <= 0:
            return False
        elif cmd['percent'] < 70 or cmd['cmd'] not in VA_CMD_LIST.keys():
            response_generator = client.get_response(
                message=voice,
                sys_prompt=SYSTEM_PROMPT
            )
    
            full_response = []
            last = ''
    
            for response in response_generator:
                part = response.replace(last, '')
                print(part, end='', flush=True)
                full_response.append(part)
                last = response
    
            print()
    
            complete_response = ''.join(full_response)
            tts.va_speak(complete_response)
            client.history.append((voice, complete_response))
            return True
        else:
            execute_cmd(cmd['cmd'], voice)
            return True
    

    def get_current_microphone(): """ Получить текущее устройство микрофона. """ return recorder.selected_device

    recorder = PvRecorder(device_index=config.MICROPHONE_INDEX, frame_length=porcupine.frame_length) recorder.start() print_yellow('Using device: %s' % get_current_microphone())

    print(f"Sonya (v1.0) к твоим услугам ...")

    ltc = time.time() - 1000 listening = False

    Сохраняем текущее устройство

    current_device = get_current_microphone()

    while True: try: # Проверяем, изменилось ли устройство if get_current_microphone() != current_device: current_device = get_current_microphone() print_yellow(f"Using device: {current_device}")

        pcm = recorder.read()
        # Для улучшения звука с микрофона:
        # Применение усиления к каждому PCM образцу
        # pcm = [int(sample * 2) for sample in pcm]
        # Устранение фонового шума
        # pcm = nr.reduce_noise(y=pcm, sr=samplerate)
        keyword_index = porcupine.process(pcm)
    
        if keyword_index >= 0:
            recorder.stop()
            play("greet", True)
            print("Yes, sir.")
            recorder.start()
            ltc = time.time()
            listening = True
    
        while time.time() - ltc <= 10:
            pcm = recorder.read()
            sp = struct.pack("h" * len(pcm), *pcm)
    
            if kaldi_rec.AcceptWaveform(sp):
                if va_respond(json.loads(kaldi_rec.Result())["text"]):
                    ltc = time.time()
                break
    
        if listening and time.time() - ltc > 10:
            play("cancel", True)
            client.history.clear()
            listening = False
    
    except KeyboardInterrupt:
        print_red("Программа завершена пользователем.")
        break
    except OSError as err:
        print_red(f"Ошибка при чтении с устройства: {err}")
    except Exception as err:
        print_red(f"Unexpected {err=}, {type(err)=}")
        raise
    

    Как мне использовать вместо микрофона поток с сокета?

  4. Assistant

    Чтобы использовать поток аудио с сокета вместо микрофона в вашем коде, вам нужно будет изменить способ, которым вы читаете аудиоданные. Вместо того, чтобы получать аудиопоток из микрофона с помощью PvRecorder, вы будете принимать данные через сокет и обрабатывать их аналогично тому, как вы обрабатываете данные из PvRecorder.

    Вот основные шаги, чтобы это сделать:

    1. Создание сокетного сервера: Сначала вам нужно создать сокетный сервер, который будет слушать на порту, и принимать входящие данные.

    2. Чтение аудиоданных из сокета: Вместо считывания данных из микрофона используя recorder.read(), вы будете читать данные из сокета.

    Вот как можно изменить ваш код:

    Примерный код

    import socket
    import json
    import os
    import random
    import struct
    import time
    import pvporcupine
    import simpleaudio as sa
    import vosk
    import yaml
    from fuzzywuzzy import fuzz
    import config
    import tts
    from const import SYSTEM_PROMPT
    from llm_models.mini_4o_model import ModelClient
    
    # Ваши импорты и инициализация потоков тут...
    
    # Создаем сокетный сервер
    HOST = '0.0.0.0'  # Или другой адрес, в зависимости от ваших нужд
    PORT = 6543
    
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind((HOST, PORT))
    server_socket.listen(1)
    print("Сервер запущен, ожидаем подключения...")
    
    conn, addr = server_socket.accept()
    print(f"Подключено к {addr}")
    
    # Изменяем код для работы с сокетом
    try:
        while True:
            try:
                # Получаем аудиоданные из сокета
                data = conn.recv(4096)  # Размер буфера можно настроить
    
                if not data:
                    print("Нет данных, соединение закрыто.")
                    break
    
                # Преобразуем полученные данные в PCM и обрабатываем их с помощью vosk
                sp = data  # В вашем случае `data` уже должно быть упаковано в PCM-формате
    
                if kaldi_rec.AcceptWaveform(sp):
                    if va_respond(json.loads(kaldi_rec.Result())["text"]):
                        print("Команда распознана!")
    
            except OSError as err:
                print_red(f"Ошибка при обработке данных: {err}")
            except Exception as err:
                print_red(f"Unexpected {err=}, {type(err)=}")
                raise
    
    finally:
        conn.close()
        server_socket.close()
    

    Основные изменения:

    • Сокетный сервер: создается сокетный сервер, который принимает соединения от клиентов. Вы можете использовать аналогичный клиент, чтобы отправлять потоки аудио.
    • Чтение аудиоданных: вместо чтения данных из микрофона с помощью recorder.read() вы принимаете данные через сокет с conn.recv().
    • Как отправлять аудиоданные на сервер: вам нужно будет создать клиент, который будет записывать аудио и отправлять его через сокет, например, используя библиотеку socket и pyaudio/sounddevice.

    Этот подход требует, чтобы данные, отправляемые с клиентской стороны, были в нужном формате (например, PCM), чтобы они корректно обрабатывались на сервере. Убедитесь, что вам не нужно предварительно обрабатывать или массивировать данные, если они уже упакованы в требуемом формате.

  5. User

    напиши полный код

  6. Assistant

    Конечно! Ниже приведен полный пример кода, который включает создаваемый сервер, который принимает аудиоданные из сокета и использует их для обработки. Также будет представлен простой клиент, который захватывает аудиоданные с микрофона и отправляет их на сервер.

    Код сервера (audio_server.py)

    import json
    import os
    import struct
    import socket
    import time
    import pvporcupine
    import vosk
    import yaml
    from fuzzywuzzy import fuzz
    from vosk import KaldiRecognizer
    import config
    import tts
    from const import SYSTEM_PROMPT
    from llm_models.mini_4o_model import ModelClient
    
    # Загрузка команд
    VA_CMD_LIST = yaml.safe_load(
        open('commands.yaml', 'rt', encoding='utf8'),
    )
    
    # Инициализация Porcupine
    porcupine = pvporcupine.create(
        access_key=config.PICOVOICE_TOKEN,
        keyword_paths=['Sonya_en_windows_v3_0_0.ppn'],
        sensitivities=[1]
    )
    
    # Инициализация Vosk
    model = vosk.Model("model_small")
    samplerate = 16000
    kaldi_rec = KaldiRecognizer(model, samplerate)
    
    # Инициализация клиента для модели
    client = ModelClient()
    
    def print_yellow(text):
        print(f"\033[93m{text}\033[0m")  # Желтый цвет
    
    def recognize_cmd(cmd: str):
        rc = {'cmd': '', 'percent': 0}
        for c, v in VA_CMD_LIST.items():
            for x in v:
                vrt = fuzz.ratio(cmd, x)
                if vrt > rc['percent']:
                    rc['cmd'] = c
                    rc['percent'] = vrt
        return rc
    
    def execute_cmd(cmd: str):
        if cmd == 'off':
            print("Завершение работы.")
            exit(0)
    
    def va_respond(voice: str):
        if voice:
            print(f"Распознано: {voice}")
            cmd = recognize_cmd(voice)
    
            if len(cmd['cmd'].strip()) > 0:
                execute_cmd(cmd['cmd'])
                return True
            else:
                print("Команда не распознана.")
                return False
    
    # Создание сокета сервера
    HOST = '0.0.0.0'
    PORT = 6543
    
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind((HOST, PORT))
    server_socket.listen(1)
    print("Сервер запущен, ожидаем подключения...")
    
    conn, addr = server_socket.accept()
    print(f"Подключено к {addr}")
    
    try:
        while True:
            data = conn.recv(4096)  # Чтение аудиоданных
            if not data:
                print("Нет данных, соединение закрыто.")
                break
            
            # Преобразуем и обрабатываем данные
            sp = data
            if kaldi_rec.AcceptWaveform(sp):
                va_respond(json.loads(kaldi_rec.Result())["text"])
    
    finally:
        conn.close()
        server_socket.close()
    
    

    Код клиента (audio_client.py)

    Этот код будет записывать звук с микрофона и отправлять его на сервер.

    import socket
    import pyaudio
    
    HOST = 'localhost'  # IP-адрес сервера
    PORT = 6543         # Порт, на котором сервер слушает
    
    # Настройки для PyAudio
    CHUNK = 1024
    FORMAT = pyaudio.paInt16
    CHANNELS = 1
    RATE = 16000
    
    # Инициализируем PyAudio
    audio = pyaudio.PyAudio()
    
    # Открываем поток
    stream = audio.open(format=FORMAT, channels=CHANNELS,
                        rate=RATE, input=True,
                        frames_per_buffer=CHUNK)
    
    # Создаем сокет
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.connect((HOST, PORT))
    print("Подключение к серверу установлено.")
    
    try:
        while True:
            # Чтение данных с микрофона
            data = stream.read(CHUNK, exception_on_overflow=False)
            
            # Отправка полных диапазонов PCM данных на сервер
            client_socket.sendall(data)
    
    except KeyboardInterrupt:
        print("Завершение работы клиента.")
    finally:
        stream.stop_stream()
        stream.close()
        audio.terminate()
        client_socket.close()
    

    Пояснения к коду:

    1. Сервер:

      • Создается сокет, который слушает входящие подключения и принимает аудиоданные.
      • Используются библиотеки Vosk и Porcupine для распознавания голоса и определения ключевого слова ("wake word").
      • При распознавании команды выполняется соответствующее действие.
    2. Клиент:

      • Используется библиотека PyAudio для захвата звука с микрофона.
      • Захваченные аудиоданные отправляются на сервер через сокет.

    Запуск:

    1. Запустите сервер, выполнив команду:

      python audio_server.py
      
    2. Запустите клиент в другом терминале, выполнив команду:

      python audio_client.py
      

    Этот код должен работать в связке, где клиент отправляет аудиоданные, а сервер обрабатывает их.

    Установка необходимых библиотек:

    Убедитесь, что все необходимые библиотеки установлены:

    pip install pvporcupine vosk PyAudio fuzzywuzzy pyyaml
    

    Также вам нужно будет настроить commands.yaml и другие зависимости, такие как config.py и tts.py, чтобы они соответствовали вашему проекту.