rapidly 1.0.3__py3-none-win32.whl

rapidly/__init__.py

@@ -0,0 +1,7 @@
+from .rapidly import (
+    RapidlyEngine,  # Makes the Rapidly class available when importing the module
+    list_models,
+    update_models,
+)
+from .rapidly_file import process_file  # Makes process_file available when importing the module
+from .version import __version__  # Makes __version__ available when importing the module

rapidly/rapidly.py

@@ -0,0 +1,482 @@
+import ctypes
+import os
+import platform
+import re
+
+# Check for required modules and prompt to install if missing
+try:
+    import numpy as np
+except ImportError:
+    print("NumPy is not installed. Please install it using the command:")
+    print("pip install numpy")
+    exit()
+
+
+MODULE_PATH = os.path.dirname(os.path.abspath(__file__))
+MODEL_PATH = os.path.join(MODULE_PATH, "models")
+BIN_PATH = os.path.join(MODULE_PATH, "bin")
+
+if not os.path.exists(MODEL_PATH):
+    # We run from the source folder in the github repo
+    up_one_folder = os.path.split(MODULE_PATH)[0]
+    two_up_folder = os.path.split(up_one_folder)[0]
+    MODEL_PATH = os.path.join(two_up_folder, "Models")
+
+if not os.path.exists(BIN_PATH):
+    # We run from the source folder in the github repo
+    up_one_folder = os.path.split(MODULE_PATH)[0]
+    two_up_folder = os.path.split(up_one_folder)[0]
+    BIN_PATH = os.path.join(two_up_folder, "Bin")
+
+# Create a data structure to hold the pointer generated by rapidlyGetModelInfo...
+RAPIDLY_PARAM_MAXATTENUATION = 0x0001
+RAPIDLY_PARAM_SENSITIVITY = 0x0002
+RAPIDLY_PARAM_MASKEXTRAPOLATION = 0x0003
+RAPIDLY_PARAM_BUS_GAINS = 0x0100
+RAPIDLY_PARAM_BUS_SENSITIVITIES = 0x0200
+
+class RapidlyEngine:
+    """
+    The RapidlyEngine is a machine learning audio enhancement module
+    developed by Rapidly Labs
+    """
+
+    class Processor:
+        def __init__(
+            self,
+            rapidly_engine: ctypes.CDLL,
+            model_path: str,
+            num_of_channels: int,
+            sample_rate: float,
+        ):
+            self.rapidly_engine = rapidly_engine
+
+            self.handle = self.rapidly_engine.rapidlyCreateProcessor(
+                model_path.encode(), num_of_channels, sample_rate
+            )
+            if not self.handle:
+                raise Exception("Unable to load Rapidly model file.")
+            self.num_of_channels = num_of_channels
+
+        def __del__(self):
+            self.rapidly_engine.rapidlyDeleteProcessor(self.handle)
+
+        def process(self, audio_signal: np.array) -> bool:
+            """
+            Processes audio from a numpy array with the format [samples, channels]. The length of the processed audio
+            will normally differ from the input lengt due to latency and block based processing.
+            """
+            num_of_input_samples = audio_signal.shape[0]
+            interleaved_audio = audio_signal.astype(np.float32).flatten()
+            self.rapidly_engine.rapidlyAddAudioInterleaved(
+                self.handle,
+                interleaved_audio.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+                num_of_input_samples,
+            )
+            num_of_output_samples = self.rapidly_engine.rapidlyGetNumOfPendingSamples(self.handle)
+            if num_of_output_samples > 0:
+                num_of_output_elements = self.num_of_channels * num_of_output_samples
+                PCMArray = ctypes.c_float * num_of_output_elements
+                pcm_out = PCMArray(*range(num_of_output_elements))
+                self.rapidly_engine.rapidlyGetAudioInterleaved(
+                    self.handle,
+                    ctypes.cast(pcm_out, ctypes.POINTER(ctypes.c_float)),
+                    num_of_output_samples,
+                )
+                return np.array(pcm_out).reshape(num_of_output_samples, self.num_of_channels)
+            else:
+                return np.empty((0, 0))
+
+        def reset(self):
+            self.rapidly_engine.rapidlyResetProcessor()
+
+        def get_info(self):
+            """
+            Returns a processor_info dict with information about the processor.
+            """
+
+            processor_info = ProcessorInfo()
+            self.rapidly_engine.rapidlyGetProcessorInfo(self.handle, ctypes.byref(processor_info))
+
+            processor_info_parsed = {}
+            for field in processor_info._fields_:
+                processor_info_parsed[field[0]] = getattr(processor_info, field[0])
+            return processor_info_parsed
+
+        def get_max_attenuation(self) -> float:
+            """
+            Returns the current maximum attenuation setting in dB
+            The valid value range is <-inf, 0]
+            """
+            return self.rapidly_engine.rapidlyGetParameterValue(self.handle, RAPIDLY_PARAM_MAXATTENUATION)
+
+        def set_max_attenuation(self, max_attenuation: float):
+            """
+            Sets the current maximum attenuation setting in dB
+            The valid value range is <-inf, 0]
+            """
+            return self.rapidly_engine.rapidlySetParameterValue(
+                self.handle, RAPIDLY_PARAM_MAXATTENUATION, max_attenuation
+            )
+
+        def get_sensitivity(self) -> float:
+            """
+            Returns the current sensitivity in percent. 0% is neutral and positive
+            values will increase the amount of reduction.
+            The valid value range is [-100, 100]
+            """
+            return self.rapidly_engine.rapidlyGetParameterValue(self.handle, RAPIDLY_PARAM_SENSITIVITY)
+
+        def set_sensitivity(self, sensitivity: float):
+            """
+            Sets the current sensitivity in percent. 0% is neutral and positive
+            values will increase the amount of reduction.
+            The valid value range is [-100, 100]
+            """
+            return self.rapidly_engine.rapidlySetParameterValue(
+                self.handle, RAPIDLY_PARAM_SENSITIVITY, sensitivity
+            )
+        
+        def get_output_bus_name(self, output_bus_index, max_length=256):
+            """
+            Returns the name of the specified output bus as a string.
+            """
+            # Create a buffer for the output bus name
+            output_bus_name = (ctypes.c_char * max_length)()
+            # Call the C function
+            self.rapidly_engine.rapidlyGetOutputBusName(self.handle, output_bus_index, output_bus_name, max_length)
+            # Convert the result to a Python string and return it
+            return output_bus_name.value.decode('utf-8')
+        
+        def get_parameter_range(self, parameter_index):
+            """
+            Returns a dictionary with the min and max values for the specified parameter.
+            """
+            min_value = ctypes.c_float()
+            max_value = ctypes.c_float()
+            # Call the C function
+            self.rapidly_engine.rapidlyGetParameterRange(self.handle, parameter_index, ctypes.byref(min_value), ctypes.byref(max_value))
+            # Return a dictionary with the min and max values
+            return {"minValue": min_value.value, "maxValue": max_value.value}
+        
+        def get_number_of_output_buses(self):
+            """
+            Returns the number of output buses for this processor.
+            """
+            return self.rapidly_engine.rapidlyGetNumOfOutputBusses(self.handle)
+
+        def set_output_bus_volume(self, bus_index: int, volume: float):
+            """
+            Sets the volume for a specific output bus.
+            
+            Parameters:
+                bus_index (int): The index of the output bus.
+                volume (float): The volume to set for the output bus (usually 0 or above).
+            """
+            # Calculate the parameter index for the specific bus
+            parameter_index = RAPIDLY_PARAM_BUS_GAINS + bus_index
+            # Set the volume using rapidlySetParameterValue
+            self.rapidly_engine.rapidlySetParameterValue(self.handle, parameter_index, volume)
+
+        def get_output_bus_volume(self, bus_index: int) -> float:
+            """
+            Gets the volume for a specific output bus.
+
+            Parameters:
+                bus_index (int): The index of the output bus.
+
+            Returns:
+                float: The current volume level of the specified output bus.
+            """
+            # Calculate the parameter index for the specific bus
+            parameter_index = RAPIDLY_PARAM_BUS_GAINS + bus_index
+            # Get the volume using rapidlyGetParameterValue
+            return self.rapidly_engine.rapidlyGetParameterValue(self.handle, parameter_index)
+
+        def set_output_bus_sensitivity(self, bus_index: int, sensitivity: float):
+            """
+            Sets the sensitivity for a specific output bus.
+
+            Parameters:
+                bus_index (int): The index of the output bus.
+                sensitivity (float): The sensitivity to set for the output bus, typically within a range like [-100, 100].
+            """
+            # Calculate the parameter index for the specific bus
+            parameter_index = RAPIDLY_PARAM_BUS_SENSITIVITIES + bus_index
+            # Set the sensitivity using rapidlySetParameterValue
+            self.rapidly_engine.rapidlySetParameterValue(self.handle, parameter_index, sensitivity)
+
+                
+
+
+    def __init__(self):
+        path_to_binary = self.find_binary()
+        
+        if not path_to_binary:
+            raise Exception("Could not find the Rapidly Engine binary.")
+
+        self.rapidly_engine = ctypes.cdll.LoadLibrary(path_to_binary)
+
+        # RAPIDLY_API bool rapidlyAddLicense (const char* licenseString);
+        self.rapidly_engine.rapidlyAddLicense.argtypes = [ctypes.c_char_p]
+        self.rapidly_engine.rapidlyAddLicense.restype = ctypes.c_bool
+
+        # RAPIDLY_API RapidlyProcessorHandle rapidlyCreateProcessor (const char* modelFilepath, int32_t numOfChannels, double sampleRate);
+        self.rapidly_engine.rapidlyCreateProcessor.argtypes = [
+            ctypes.c_char_p,
+            ctypes.c_int32,
+            ctypes.c_double,
+        ]
+        self.rapidly_engine.rapidlyCreateProcessor.restype = ctypes.c_void_p
+
+        # RAPIDLY_API RapidlyProcessorHandle rapidlyCreateStemSeparator (int32_t numOfModels, const char** modelFilepaths, int32_t numOfChannels, double sampleRate);
+        # self.rapidly_engine.rapidlyCreateStemSeparator.argtypes = [ctypes.c_int32, ctypes.c_char_p, ctypes.c_int32, ctypes.c_double]
+        self.rapidly_engine.rapidlyCreateStemSeparator.argtypes = [
+            ctypes.c_int32,
+            ctypes.POINTER(ctypes.POINTER(ctypes.c_char)),
+            ctypes.c_int32,
+            ctypes.c_double,
+        ]
+        self.rapidly_engine.rapidlyCreateStemSeparator.restype = ctypes.c_void_p
+
+        # RAPIDLY_API RapidlyProcessorHandle rapidlyCreateProcessor (const char* modelFilepath, int32_t numOfChannels, double sampleRate);
+        self.rapidly_engine.rapidlyCreateProcessor.argtypes = [
+            ctypes.c_char_p,
+            ctypes.c_int32,
+            ctypes.c_double,
+        ]
+        self.rapidly_engine.rapidlyCreateProcessor.restype = ctypes.c_void_p
+
+        # RAPIDLY_API void rapidlyDeleteProcessor (RapidlyProcessorHandle processorHandle);
+        self.rapidly_engine.rapidlyDeleteProcessor.argtypes = [ctypes.c_void_p]
+        self.rapidly_engine.rapidlyDeleteProcessor.restype = None
+
+        # RAPIDLY_API void rapidlyAddAudioInterleaved (RapidlyProcessorHandle processorHandle, const float* interleavedPCM, int32_t numOfSamples);
+        self.rapidly_engine.rapidlyAddAudioInterleaved.argtypes = [
+            ctypes.c_void_p,
+            ctypes.POINTER(ctypes.c_float),
+            ctypes.c_int32,
+        ]
+        self.rapidly_engine.rapidlyAddAudioInterleaved.restype = None
+
+        # RAPIDLY_API int32_t rapidlyGetNumOfPendingSamples (RapidlyProcessorHandle processorHandle);
+        self.rapidly_engine.rapidlyGetNumOfPendingSamples.argtypes = [ctypes.c_void_p]
+        self.rapidly_engine.rapidlyGetNumOfPendingSamples.restype = ctypes.c_int32
+
+        # RAPIDLY_API bool rapidlyGetAudioInterleaved (RapidlyProcessorHandle processorHandle, float* interleavedPCM, int32_t numOfSamples);
+        self.rapidly_engine.rapidlyGetAudioInterleaved.argtypes = [
+            ctypes.c_void_p,
+            ctypes.POINTER(ctypes.c_float),
+            ctypes.c_int32,
+        ]
+        self.rapidly_engine.rapidlyGetAudioInterleaved.restype = ctypes.c_bool
+
+        # RAPIDLY_API void rapidlyResetProcessorState (RapidlyProcessorHandle modelHandle);
+        self.rapidly_engine.rapidlyResetProcessorState.argtypes = [ctypes.c_void_p]
+        self.rapidly_engine.rapidlyResetProcessorState.restype = None
+
+        # RAPIDLY_API void rapidlyGetProcessorInfo (RapidlyProcessorHandle modelHandle, RapidlyProcessorInfo* modelInfo);
+        self.rapidly_engine.rapidlyGetProcessorInfo.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        self.rapidly_engine.rapidlyGetProcessorInfo.restype = None
+
+        # RAPIDLY_API float rapidlyGetParameterValue (RapidlyProcessorHandle processorHandle, int32_t parameterIndex);
+        self.rapidly_engine.rapidlyGetParameterValue.argtypes = [ctypes.c_void_p, ctypes.c_int32]
+        self.rapidly_engine.rapidlyGetParameterValue.restype = ctypes.c_float
+
+        # RAPIDLY_API void rapidlySetParameterValue (RapidlyProcessorHandle processorHandle, int32_t parameterIndex, float parameterValue);
+        self.rapidly_engine.rapidlySetParameterValue.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_int32,
+            ctypes.c_float,
+        ]
+        self.rapidly_engine.rapidlySetParameterValue.restype = None
+
+        # RAPIDLY_API c_int32 rapidlyGetNumOfOutputBusses (RapidlyProcessorHandle modelHandle);
+        self.rapidly_engine.rapidlyGetNumOfOutputBusses.argtypes = [ctypes.c_void_p]
+        self.rapidly_engine.rapidlyGetNumOfOutputBusses.restype = ctypes.c_int32
+
+        # Define the function's argument types and return type
+        self.rapidly_engine.rapidlyGetOutputBusName.argtypes = [
+            ctypes.c_void_p,  # RapidlyProcessorHandle processorHandle
+            ctypes.c_int32,   # int32_t outputBusIndex
+            ctypes.POINTER(ctypes.c_char),  # char* outputBusName
+            ctypes.c_int32    # int32_t maxLength
+        ]
+        self.rapidly_engine.rapidlyGetOutputBusName.restype = None  # void function
+
+        # Define the function's argument types and return type
+        self.rapidly_engine.rapidlyGetParameterRange.argtypes = [
+            ctypes.c_void_p,     # RapidlyProcessorHandle processorHandle
+            ctypes.c_int32,      # int32_t parameterIndex
+            ctypes.POINTER(ctypes.c_float),  # float* minimumValue
+            ctypes.POINTER(ctypes.c_float)   # float* maximumValue
+        ]
+        self.rapidly_engine.rapidlyGetParameterRange.restype = None  # void function
+
+
+        self.prev_samplerate = None
+        self.prev_channels = None
+
+    def add_license(self, license_string: str) -> bool:
+        return self.rapidly_engine.rapidlyAddLicense(license_string.encode())
+
+    def create_processor(
+        self, model_file_path: str, num_of_channels: int, sample_rate: int
+    ) -> Processor:
+        """
+        Creates an audio processor from a Rapidly model file.
+        """
+        model_file_abs_path = get_model_file_abs_path(model_file_path)
+        return self.Processor(self.rapidly_engine, model_file_abs_path, num_of_channels, sample_rate)
+
+    def find_binary(self) -> str:
+        """
+        Returns the path to a binary in the bin folder.
+        """
+
+        relative_path = BIN_PATH
+        
+        path_to_binary = None
+        if platform.system() == "Windows":
+            if platform.architecture()[0] == "32bit":
+                path_to_binary = os.path.join(relative_path, "Windows_x86/RapidlyEngine.dll")
+            if platform.architecture()[0] == "64bit":
+                path_to_binary = os.path.join(relative_path, "Windows_x64/RapidlyEngine.dll")
+        elif platform.system() == "Darwin":
+            fn = self.find_preferred_dylib(os.path.join(relative_path, "macOS"), "libRapidlyEngine")
+            path_to_binary = os.path.join(relative_path, "macOS", fn)
+        elif platform.system() == "Linux":
+            machine = platform.machine()
+            if machine in ("aarch64", "arm64"):
+                path_to_binary = os.path.join(relative_path, "Linux_arm64/libRapidlyEngine.so")
+            else:
+                path_to_binary = os.path.join(relative_path, "Linux_x64/libRapidlyEngine.so")
+
+        return path_to_binary
+    
+
+    def find_preferred_dylib(self, directory, base_name):
+        """
+        Finds the preferred .dylib file in the directory.
+        If a file with a version number exists, it returns that file.
+        Otherwise, it returns the one without a version number.
+
+        :param directory: The directory to search for .dylib files.
+        :param base_name: The base name of the .dylib file (e.g., "libRapidlyEngine").
+        :return: The path to the preferred .dylib file, or None if no matches are found.
+        """
+        versioned_pattern = re.compile(rf"{base_name}\.\d+\.\d+\.\d+\.dylib$")
+        non_versioned_name = f"{base_name}.dylib"
+
+        versioned_file = None
+        non_versioned_file = None
+
+        for file_name in os.listdir(directory):
+            if versioned_pattern.match(file_name):
+                versioned_file = os.path.join(directory, file_name)
+            elif file_name == non_versioned_name:
+                non_versioned_file = os.path.join(directory, file_name)
+
+        return versioned_file or non_versioned_file
+
+
+
+class ProcessorInfo(ctypes.Structure):
+    _fields_ = [
+        ("sampleRate", ctypes.c_double),
+        ("numOfModelChannels", ctypes.c_int32),
+        ("latencyInSamples", ctypes.c_int32),
+        ("blockSize", ctypes.c_int32),
+        ("hopSize", ctypes.c_int32),
+    ]
+
+
+class ProcessorSettings(ctypes.Structure):
+    """creates a struct to match rapidlyProcessorSettings"""
+
+    _fields_ = [
+        ("sensitivity", ctypes.c_float),
+        ("maximumAttenuation", ctypes.c_float),
+    ]
+
+
+def list_models():
+    """
+    Returns a list of available models.
+    """
+    model_list = []
+    
+    for fn in os.listdir(MODEL_PATH):
+        if fn.endswith(".rapidly"):
+            model_list.append(fn)
+    return model_list
+
+
+def update_models():
+    """
+    Updates the local models directory by downloading the latest public branch archive
+    from the Rapidly models GitHub repository using urllib.
+    """
+    import urllib.request
+    import zipfile
+    import io
+    import os
+
+    repo_url = "https://github.com/rapidly-labs/rapidly-sdk/archive/refs/heads/main.zip"
+    models_dir = os.path.abspath(MODEL_PATH)  # Absolute path to the local Models directory
+    
+    print("Downloading the latest models archive...")
+    try:
+        # Download the repository archive
+        with urllib.request.urlopen(repo_url) as response:
+            if response.status != 200:
+                raise Exception(f"Failed to download archive: HTTP {response.status}")
+            
+            # Read the archive into memory
+            archive_data = response.read()
+        
+        # Extract the downloaded archive
+        with zipfile.ZipFile(io.BytesIO(archive_data)) as z:
+            extracted_base = z.namelist()[0]  # First directory in the archive
+            extracted_models_prefix = os.path.join(extracted_base, "Models")
+
+            if not os.path.exists(models_dir):
+                os.makedirs(models_dir)
+
+            # Extract only the contents of the Models directory
+            for file in z.namelist():
+                if file.startswith(extracted_models_prefix):
+                    # Compute the relative path inside the Models folder
+                    relative_path = os.path.relpath(file, extracted_models_prefix)
+                    if relative_path == ".":  # Skip the root directory itself
+                        continue
+                    
+                    # Compute the target path
+                    target_path = os.path.join(models_dir, relative_path)
+
+                    # Create directories or write files as needed
+                    if file.endswith('/'):
+                        os.makedirs(target_path, exist_ok=True)  # Create directories
+                    else:
+                        with open(target_path, "wb") as f:
+                            f.write(z.read(file))
+
+        print(f"Models updated successfully at {models_dir}.")
+    except Exception as e:
+        print(f"Error updating models: {e}")
+        raise
+
+def get_model_file_abs_path(model_file_path: str):
+    model_file_abs_path = model_file_path
+    if not os.path.exists(model_file_abs_path):
+        # possible a relative path from list_models
+        found_model = False
+
+        model_file_abs_path = os.path.join(MODEL_PATH, model_file_path)
+        if os.path.exists(model_file_abs_path):
+            found_model = True
+
+        if not found_model:
+            raise Exception("Model file does not exist.")
+
+    return model_file_abs_path

rapidly/rapidly_file.py

@@ -0,0 +1,87 @@
+import os
+import shutil
+import subprocess
+import numpy as np
+import rapidly
+
+try:
+    import soundfile as sf
+except ImportError:
+    print("Soundfile is not installed. Please install it to process files using the command:")
+    print("pip install soundfile")
+    exit()
+
+def process_file(
+    model_file_path: str, input_file_path: str, output_file_path: str, license_string: str = "", selected_output_bus: int = 0
+):
+    """
+    Processes a full wave file using the preloaded model
+    """
+    rapidly_engine = rapidly.RapidlyEngine()
+    if license_string:
+        if not rapidly_engine.add_license(license_string):
+            raise Exception("License key not accepted")
+
+    created_temp_file = False
+    try:
+        in_file_info = sf.SoundFile(input_file_path)
+    except sf.LibsndfileError as e:
+        # Try converting using ffmpeg
+        if not shutil.which("ffmpeg"):
+            raise Exception(
+                f"Could not open input file: {e}\nSupported formats are WAV, FLAC, OGG, and MAT. Please install ffmpeg to support more formats."
+            )
+        print("Converting input file to WAV using ffmpeg...")
+        temp_input = "temp_input.wav"
+        subprocess.run(["ffmpeg", "-i", input_file_path, temp_input], check=True)
+        input_file_path = temp_input
+        in_file_info = sf.SoundFile(input_file_path)
+        created_temp_file = True
+
+    processor = rapidly_engine.create_processor(
+        model_file_path, in_file_info.channels, in_file_info.samplerate
+    )
+
+    for i in range(processor.get_number_of_output_buses()):
+        processor.set_output_bus_sensitivity(i, 0.0)
+        if i == selected_output_bus:
+            processor.set_output_bus_volume(i, 1.0)
+        else:
+            processor.set_output_bus_volume(i, 0.0)
+        
+
+    output_file = sf.SoundFile(
+        output_file_path,
+        mode="w",
+        samplerate=in_file_info.samplerate,
+        channels=in_file_info.channels,
+        subtype=in_file_info.subtype,
+        endian=in_file_info.endian,
+        format=in_file_info.format,
+    )
+
+    block_size = 65536
+    num_of_samples_written = 0
+    num_of_samples = len(in_file_info) // in_file_info.channels
+
+    for audio_block in sf.blocks(
+        input_file_path, dtype="float32", blocksize=block_size, always_2d=True
+    ):
+        audio_out = processor.process(audio_block)
+        if audio_out.size != 0:
+            output_file.write(audio_out)
+            num_of_samples_written += audio_out.shape[0]
+
+    # Process remaining samples by feeding silence to the processor
+    silent_audio = np.zeros([block_size, in_file_info.channels], dtype="float32")
+    while num_of_samples_written < num_of_samples:
+        remaining_samples = num_of_samples - num_of_samples_written
+        samples_to_process = min(block_size, remaining_samples)
+        audio_out = processor.process(silent_audio[:samples_to_process])
+        if audio_out.size != 0:
+            output_file.write(audio_out)
+            num_of_samples_written += audio_out.shape[0]
+
+    output_file.close()
+    if created_temp_file:
+        os.remove(input_file_path)

rapidly/version.py

@@ -0,0 +1 @@
+__version__ = "1.0.3"

rapidly-1.0.3.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: rapidly
+Version: 1.0.3
+Summary: The Python API to the Rapidly engine — realtime audio enhancement powered by Rapidly Labs AS.
+Home-page: https://rapidly.io
+Author: Rapidly Labs AS
+Author-email: Rapidly Labs AS <support@rapidly.io>
+License: Proprietary — see LICENSE
+Project-URL: Homepage, https://rapidly.io
+Keywords: rapidly,audio enhancement,noise reduction,speech denoise
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: !=2.*,>=3.0
+Description-Content-Type: text/markdown
+Requires-Dist: setuptools>=41.2.0
+Requires-Dist: numpy
+Requires-Dist: soundfile
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# Audio enhancement in Python with the Rapidly engine
+
+The **Rapidly** Engine is a model inference library built with audio in mind. Pre-trained models for speech noise suppression and de-reverberation are available out of the box, and we can train models for any use case — get in touch if you have specific requirements.
+
+Our models are trained specifically for real-time usage, achieving low latencies down to 11 milliseconds in speech enhancement applications. The models are designed to be small and resource-efficient, with model file sizes down to 242 KB for the smallest noise suppression model.
+
+The Rapidly engine is built in C++ and is compatible across various architectures. With our Python wrapper, you can easily integrate Rapidly into your Python projects and quickly process files and benchmark our models.
+
+To learn more about Rapidly, visit [Rapidly](https://rapidly.io).
+
+
+## Installation
+
+To install the Python wrapper for Rapidly, use `pip`:
+
+    python -m pip install rapidly
+
+Rapidly requires Python 3.
+
+## How to Use
+
+To use the API, import it and list the available models:
+
+    import rapidly
+    models = rapidly.list_models()
+    print(models)
+
+To download and update to the latest models, simply call:
+
+    rapidly.update_models()
+
+## Process a File
+
+To process a file with Rapidly, use the `process_file` function:
+
+    import rapidly
+
+    # List the available models in the models folder.
+    models = rapidly.list_models()
+
+    # Process a file using the first model in the list.
+    rapidly.process_file(
+        model_file_path=models[0],
+        input_file_path="path/to/input.wav",
+        output_file_path="path/to/output.wav",
+        selected_output_bus=0  # Bus 0 is the processed result in most models.
+    )
+
+Some models support multiple output buses — for example, separate buses for noise reduction and de-reverberation. You can inspect available buses like this:
+
+    rapidly_engine = rapidly.RapidlyEngine()
+    processor = rapidly_engine.create_processor(models[0], 2, 44100)
+
+    num_buses = processor.get_number_of_output_buses()
+    for i in range(num_buses):
+        print(i, processor.get_output_bus_name(i))
+
+Pass the desired bus index as `selected_output_bus` in `process_file`.
+
+### Models
+
+The models in the **models** folder use clear, descriptive names. For example, `speech-denoise-32ms.v1.0.rapidly` indicates a model designed to _denoise_ speech with a latency of 32 ms. The `micro` size variant (e.g. `speech-denoise-micro-32ms.v1.0.rapidly`) is a compact build of the same model for CPU-constrained scenarios.
+
+All models within a family (for example, the **speech-denoise** family) share similar characteristics. For general denoising, we recommend starting with `speech-denoise-96ms.v1.0.rapidly` to check if it meets your needs, and moving down to shorter latency variants if needed.
+
+If you have specific requirements or challenging audio conditions, we can build customised models optimised for your use case — feel free to [contact us](https://rapidly.io).
+
+`process_file` uses [PySoundFile](https://pysoundfile.readthedocs.io/) to read and write audio files. WAV, FLAC, OGG, and MAT formats are supported natively; other formats require [ffmpeg](https://ffmpeg.org/) to be installed.
+
+For more information, see the [Rapidly documentation](https://rapidly.io/docs/welcome).

rapidly-1.0.3.dist-info/RECORD

@@ -0,0 +1,19 @@
+rapidly/__init__.py,sha256=o31N6lgMA5Q2WBE61ZuB-GCHFecGZrNSUeJTn7vmFeQ,330
+rapidly/rapidly.py,sha256=t1fyt0yQnzA5dIPq8TPlRmOr2jp7EPqqY6E-hmKfjsM,20570
+rapidly/rapidly_file.py,sha256=OGsZ0kfvkO16D6IX0zAR_dsfbSgsVpJAtmtS2P8pkjE,3100
+rapidly/version.py,sha256=-PYTKPEkq2aGJHOdzkgu5oKZIPKSq6MCqGrFyy4QQXc,21
+rapidly/bin/Windows_x86/RapidlyEngine.dll,sha256=0YGJ5It93_PScPYGcgaSyIvKwBPvyx6ayh8_zOf9Fp8,2808320
+rapidly/models/speech-denoise-11ms.v1.0.rapidly,sha256=-veVKH0njoxXjCasvA03cMx3g8ELBPHuKOivq_lKQsg,628894
+rapidly/models/speech-denoise-21ms.v1.0.rapidly,sha256=sHAeUGk6fREj1u1HANl1AB-C_bwgNyWAJ2mSKImyZYo,870942
+rapidly/models/speech-denoise-32ms.v1.0.rapidly,sha256=o95vaJP3QLv34AINY-RVkMAmmbOQei18NPRcN7jGV7U,874014
+rapidly/models/speech-denoise-96ms.v1.0.rapidly,sha256=y2IiuQklOLS0WPhwOpyOI607yhRji-vlkVQRuZspudk,946929
+rapidly/models/speech-denoise-dereverb-11ms.v1.0.rapidly,sha256=KDonJAnIcub63p-IYP1hX2o5zC6f7-2TDXxAj1jHGh4,629288
+rapidly/models/speech-denoise-dereverb-21ms.v1.0.rapidly,sha256=nBpLpvXfK771-Uji84s87nA_E-d16w5RcGck4wN6t40,871336
+rapidly/models/speech-denoise-dereverb-32ms.v1.0.rapidly,sha256=XCK1899bmrr6m9Oyzv2rIoR8VGhP7Ak3DtzcPEbYb5Q,874408
+rapidly/models/speech-denoise-dereverb-96ms.v1.0.rapidly,sha256=9JxRrk9UvRqDUgPDUnfgBnJWGMsxk0eIqZNza0whJ78,947515
+rapidly/models/speech-denoise-dereverb-micro-32ms.v1.0.rapidly,sha256=tE4NjDqVTkc7vypUuJegTdzRjfifuR1txF6I0SNp8-o,246249
+rapidly/models/speech-denoise-micro-32ms.v1.0.rapidly,sha256=sDDmmqgjR1uXfi-wF8pu7UKJydFnfUoRN_-oV6uGDdY,246205
+rapidly-1.0.3.dist-info/METADATA,sha256=F6dImjo2O8XJ6Lcq1N16E_pbIS2OxMn-ArvlEjzG0XU,4107
+rapidly-1.0.3.dist-info/WHEEL,sha256=rQmUio2x5FDl3aNlsqS1bbvOHEhGOtoGexXubYhGACc,93
+rapidly-1.0.3.dist-info/top_level.txt,sha256=52ZM3YK3lUDEBV2_84U5bo-vy4yVIQ8LxmggFlraF5I,8
+rapidly-1.0.3.dist-info/RECORD,,

rapidly-1.0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-win32
+

rapidly-1.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+rapidly