Generate Response

import os
import json
import requests


# The base url for the API (fill in your actual base url here)
base_url = "https://api.delphi.ai"

# The endpoint path
endpoint = "/api/clone/generate_response"

# Combine base url and endpoint
url = base_url + endpoint

# Your parameters (replace with actual parameters)
params = {
    'conversation_id': '<my_convo_id>',
    'user_message': 'Hello my clone friend',
    'slug': 'my-test-clone',
    'stream': True
}

# Your API key
api_key = os.getenv("DELPHI_API_KEY")

# Headers
headers = {
    'x-api-key': api_key
}

# Making a POST request
response = requests.post(url, json=params, headers=headers, stream=True)
response_text = ""

# Process the stream of server-sent events
if response.status_code == 200:
    print("Stream started. Processing tokens...")
    for line in response.iter_lines():
        if line:
            decoded_line = line.decode("utf-8")
            if decoded_line.startswith("data:"):
                event_data = decoded_line[6:]
                event = json.loads(event_data)
                current_token = event.get("current_token")
                if current_token == "[DONE]":
                    print(decoded_line)
                    print(f"Stream finished. Final response: {response_text}")
                    break
                else:
                    print(f"Current token: '{current_token}'")
                    response_text += current_token
else:
    print(f"Error: {response.status_code}")
    print(response.text)

import os
import requests
import json
import base64
from pydub import AudioSegment
from dotenv import load_dotenv
import wave
load_dotenv()

url = "https://api.delphi.ai/api/clone/generate_response"
input_file_path = "sample_sentence.mp3"
output_file_path = "sample_sentence.wav"

audio = AudioSegment.from_mp3(input_file_path)
audio = audio.set_frame_rate(44100)
audio = audio.set_channels(1)
audio.export(output_file_path, format="wav", codec="pcm_s16le")

with open(output_file_path, "rb") as audio_file:
    base64_encoded_data = base64.b64encode(audio_file.read()).decode('utf-8')

data = {
    "conversation_id": "<conversation_id>",
    "stream": True,
    "response_type": "voice",
    "voice_input_stream": base64_encoded_data,
}

headers = {
    "Content-Type": "application/json",
    "x-api-key": os.getenv("YOUR_DELPHI_API_KEY")
}

# stream = True, response_type == voice
def play_audio(response):
    """Stream and play audio data directly from the server's response using sounddevice."""
    decoded_audio = bytearray()
    try:
        with sd.OutputStream(samplerate=44100, channels=1, dtype='int16') as stream:
            print("Stream started. Processing tokens...")
            for line in response.iter_lines():
                if line:
                    decoded_line = line.decode("utf-8")
                    if decoded_line.startswith("data:"):
                        event_data = decoded_line[6:]
                        event = json.loads(event_data)
                        audio_chunk = event.get("audio_chunk")
                        if audio_chunk == "[DONE]":
                            print("Stream finished.")
                            break
                        else:
                            if audio_chunk:
                                padding_needed = 4 - len(audio_chunk) % 4
                                audio_chunk += '=' * (padding_needed if padding_needed != 4 else 0)
                                chunk_bytes = base64.b64decode(audio_chunk)
                                decoded_audio.extend(chunk_bytes)
                                data = np.frombuffer(chunk_bytes, dtype=np.int16)
                                stream.write(data)
    except Exception as e:
        print(f"Error during streaming: {e}")

def get_and_stream_audio():
    with requests.post(url, headers=headers, data=json.dumps(data), stream=True) as response:
        if response.status_code == 200:
            play_audio(response)
        else:
            print(f"Error: {response.status_code}")

if __name__ == "__main__":
    get_and_stream_audio()


# stream = False, response_type == voice
print("Batch request started. Waiting...")
response_json = response.json()
print("Response:", response_json)
decoded_audio = base64.b64decode(response_json["clone_response"]["full_audio"])
print("Decoded", decoded_audio)


# Define the output file path where the audio will be saved
output_file_path = 'output_audio.wav'
n_channels = 1        # Mono audio
sample_width = 2      # Number of bytes per sample (2 for 16-bit audio)
frame_rate = 44100    # Samples per second (e.g., 44100 for CD quality)


# Open a new WAV file in write mode
with wave.open(output_file_path, 'wb') as wav_file:
    # Set the parameters
    wav_file.setnchannels(n_channels)
    wav_file.setsampwidth(sample_width)
    wav_file.setframerate(frame_rate)
    # Write the audio data
    wav_file.writeframes(decoded_audio)

print(f"Audio file saved at: {output_file_path}")