// First, we store the address from "Important endpoint A" as a constant:
const URL_ID_ENDPOINT =
  "https://server.hance.ai/api/get_upload_url"

// Using ES6 syntax, this one-liner downloads and converts our data from JSON
// to native JavaScript objects.

const getData = async () => await (await fetch(URL_ID_ENDPOINT)).json()

getData()
  .then(({ upload_url, upload_id }) => {
    // Once the data is available, the .then() method will be called,
    // providing access to the upload_url and upload_id values. Here we would
    // typically place an upload function, passing in the now available data.

    // Do something here...

    // We are also returning the values so that they can be used in the next
    // steps.
    return { upload_url, upload_id }
  })
  .catch(console.error)

// Alternative 1: Getting the origin from the current browser URL.
let origin = window.location.origin

// Alternative 2: Manually setting the origin.
let origin = "https://example.com"

// Add the origin defined in alternative 1 or 2 as a query parameter to the
// endpoint, using the encodeURI method for compatibility when used as a
// query parameter.
const URL_ID_ENDPOINT = `https://server.hance.ai/api/get_upload_url?origin=${encodeURI(origin)}`

[
  {
    "model_description": "De-noise",
    "model_id": "speech-denoise"
  },
  {
    model_description": "De-reverb",
    "model_id": "speech-dereverb"
  }
]

// First, we store the address from Important endpoint B as a constant:
const MODELS_ENDPOINT = "https://server.hance.ai/api/get_models"

const getModelsData = async () => await (await fetch(MODELS_ENDPOINT)).json()

getModelsData()
  .then((models) => {
    // The array of objects is now available to the getModelData function
    // and ready to be utilized.

    // We can do something with the models data here. To check if we have
    // received the data, we log it to the console.
    console.dir(models)

    // We also return the models data so the values can be used in the next
    // .then() call, like in the example below.
    return models
  })
  .then((models) => console.log(models[1].model_id)) //real_time_noise_reverb_v1
  .catch(console.error<)

#include "HanceEngine.h"

// Create a HANCE processor that loads the pre-trained model from file
processorHandle = hanceCreateProcessor (modelFilePath, numOfChannels, sampleRate);
if (processorHandle == nullptr)
    handleError ("Unable to create the HANCE audio processor.");

// We read PCM audio from the file in the 32-bit floating point format
hanceAddAudioInterleaved (processorHandle, audioBuffer.data(),
                          audioBuffer.size() / numOfChannels);

int numOfPendingSamples = hanceGetNumOfPendingSamples (processorHandle);
vector <float> processedBuffer (numOfChannels * numOfPendingSamples);
if (!hanceGetAudioInterleaved (processorHandle,
                               processedBuffer.data()
                               numOfPendingSamples))
{
    handleError ("Unable to get audio from the HANCE audio processor.");
}

hanceDeleteProcessor (processorHandle);

typedef void* HanceProcessorHandle;

struct HanceProcessorInfo
{
    double sampleRate;
    int32_t numOfModelChannels;
    int32_t latencyInSamples;
};

void hanceAddAudio (HanceProcessorHandle processorHandle,
                    const float **pcmChannels,
                    int32_t numOfSamples)

void hanceAddAudioInterleaved (HanceProcessorHandle processorHandle,
                               const float* interleavedPCM,
                               int32_t numOfSamples)

bool hanceAddLicense (const char* licenseString)

hanceCreateStemSeparator()
HanceProcessorHandle hanceCreateStemSeparator (int32_t  numOfModels,
                                               const char ** modelFilepaths,
                                               int32_t numOfChannels,
                                               double sampleRate) 

void hanceDeleteProcessor (HanceProcessorHandle processorHandle)

bool hanceGetAudio (HanceProcessorHandle processorHandle,
                    float* const* pcmChannels,
                    int32_t numOfSamples)

bool hanceGetAudioInterleaved (HanceProcessorHandle processorHandle,
                               float* interleavedPCM,
                               int32_t	numOfSamples)

int32_t hanceGetNumOfPendingSamples (HanceProcessorHandle processorHandle)

void hanceGetParameterValue (HanceProcessorHandle processorHandle,
                            int32_t parameterIndex)

void hanceGetProcessorInfo (HanceProcessorHandle processorHandle,
                            HanceProcessorInfo* processorInfo)

void hanceResetProcessorState (HanceProcessorHandle processorHandle)

void hanceSetParameterValue (HanceProcessorHandle processorHandle,
                             int32_t parameterIndex,
                             float parameterValue)

python -m pip install hance

import hance
models = hance.list_models()
print(models)

import hance
models = hance.list_models()
hance.process_file(models[0], input_file_path, output_file_path)

import hance
import soundfile as sf
import numpy as np
import os

def separate_stems(input_file_path):
    # Separates the stems from an input audio file using selected models with the StemSeparator class.
    print("Stem separation using Hance engine with StemSeparator class.")
    models = ['vocals_separation.hance', 'drums_separation.hance', 'piano_separation.hance', 'bass_separation.hance']
    print("Available models for separation:")
    for i, model in enumerate(models):
        print(f"{i+1}. {model}")

    selected_models = input("Select models to use by entering their numbers separated by commas (e.g., 1,3): ")
    selected_models_indices = [int(index) - 1 for index in selected_models.split(',')]
    
    model_paths = [models[index] for index in selected_models_indices]

    input_audio, sr = isf.read(input_file_path, dtype='float32')
    if input_audio.ndim == 1: # Mono to Stereo if needed
        input_audio = np.tile(input_audio[:, np.newaxis], (1, 2))

    sample_rate = sr
    num_of_channels = input_audio.ndim

    engine = hance.HanceEngine()
    stem_separator = engine.StemSeparator(engine.hance_engine, model_paths, num_of_channels, sample_rate)
    
    separated_stems = stem_separator.process(input_audio)

    path, fn = tos.path.split(input_file_path)
    for i, model_path in enumerate(model_paths):
        stem_name = model_path.split('_')[0]
        output_file_path = os.path.join(path, f"{fn.split('.')[0]}_{stem_name}_separated.wav")
        sf.write(output_file_path, separated_stems[:, i*num_of_channels:(i+1)*num_of_channels], sr)
        print(f"Stem {stem_name} saved to {output_file_path}")

    print("Stem separation completed.")

separate_stems(path_to_file)

import hance

license_string = "example_license"

models = hance.list_models()
hance.process_file(models[0], input_file_path, output_file_path,
                    license_string=license_string)

 # We capture the input of your microphone and process it in real-time.
 # We then send it to the output device.

import threading
import numpy as np
import hance
import pyaudio

engine = hance.HanceEngine()
p = pyaudio.PyAudio()

FORMAT = pyaudio.paFloat32
CHANNELS = 1
RATE = 44100
CHUNK = 12

print("\nRecord audio from a microphone and process it in realtime with HANCE.")
print("PyAudio will induce some latency with the roundtrip to the soundcard,")
print("but the HANCE engine runs in realtime.\n")

# We get a list of available input devices.
input_devices = []
for i in range(p.get_device_count()):
    device_info = p.get_device_info_by_index(i)
    if device_info["maxInputChannels"] > 0:
        input_devices.append(device_info)

# Print the list of available input devices and ask the user to select one.
print("Available input devices:")
for i, device in enumerate(input_devices):
    print(f"{i}: {device['name']}")
input_device_index = int(input("\nSelect an input device by entering its number: "))
input_device_info = input_devices[input_device_index]

# We get a list of available output devices.
output_devices = []
for i in range(p.get_device_count()):
    device_info = p.get_device_info_by_index(i)
    if device_info["maxOutputChannels"] > 0:
        output_devices.append(device_info)

# We print the list of available input devices and ask the user to select one.
print("\n>Available output devices:")
print("To prevent feedback, select a headphones output.\n")

for i, device in enumerate(output_devices):
    print(f"{i}: {device['name']}")
output_device_index = int(input("\nSelect an output device by entering its number: "))
output_device_info = output_devices[output_device_index]

models = hance.list_models()
processor = engine.create_processor(models[0], CHANNELS, RATE)

stop_thread = False
processor_active = True

def record_and_playback_thread():
    stream_record = p.open(format=FORMAT, channels=CHANNELS,
                           rate=RATE, input=True,
                           input_device_index=input_device_info['index'],
                           frames_per_buffer=CHUNK)

    stream_play = p.open(format=pyaudio.paFloat32,
                         channels=1,
                         rate=RATE,
                         frames_per_buffer=CHUNK,
                         output=True,
                         output_device_index=output_device_info['index']
                         )
    while not stop_thread:
        data = stream_record.read(CHUNK, exception_on_overflow=False)
        audio_buffer = np.frombuffer(data, dtype=np.float32)
        if processor_active:
            audio_buffer = processor.process(audio_buffer)
        stream_play.write(audio_buffer.astype(np.float32).tobytes())

    # We stop recording.
    stream_record.stop_stream()
    stream_record.close()

    stream_play.stop_stream()
    stream_play.close()

t = threading.Thread(target=record_and_playback_thread)
t.start()

print("\nThe microphone and processing is active")
while True:
    user_input = input("Enter 'p' to toggle processing on and off or 'q' to quit: ")
    if user_input.lower() == "p":
        # Bypass processing and continue the loop
        if processor_active:
            processor_active = False
            print("The processing is bypassed")
        else:
            processor_active = True
            print("The processing is active")
    elif user_input.lower() == "q":
        # Stop the thread
        stop_thread = True
        break

t.join

import hance
import numpy as np

engine = hance.HanceEngine()
models = hance.list_models()
processor = engine.create_processor(models[0], CHANNELS, RATE)
audio_buffer = np.frombuffer(PCM_AUDIO_DATA, dtype=np.float32)
audio_buffer = processor.process(audio_buffer)