fat-llama 0.1.2__tar.gz

fat_llama-0.1.2/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Raad
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

fat_llama-0.1.2/MANIFEST.in

@@ -0,0 +1,5 @@
+include README.md
+include LICENSE
+include requirements.txt
+recursive-include fat_llama/tests *
+recursive-include fat_llama/audio_fattener *

fat_llama-0.1.2/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.1
+Name: fat_llama
+Version: 0.1.2
+Summary: A package for CUDA-based upscaling and processing audio files, using FFT to add audio frequency details after upscaling.
+Home-page: https://github.com/bkraad47/fat_llama
+Author: Badruddin Kamal
+Author-email: bulkguy47@gmail.com
+License: BSD-3-Clause
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: cupy-cuda12x
+Requires-Dist: pydub
+Requires-Dist: soundfile
+Requires-Dist: mutagen
+Requires-Dist: scipy
+Requires-Dist: tqdm
+
+# fat_llama
+
+fat_llama is a Python package for upscaling MP3 files to FLAC format using advanced audio processing techniques. It utilizes GPU-accelerated calculations to enhance audio quality by upsampling and adding missing frequencies, resulting in richer and more detailed audio.
+
+## Features
+
+- Upscale MP3 files to high-quality FLAC format.
+- Optional iterative soft thresholding (IST) for enhanced audio processing.
+- Gain adjustment, equalization, and optional Wiener filtering.
+- Supports GPU-accelerated processing with CuPy.
+
+## Installation
+
+Clone the repository:
+
+Install:
+```
+pip install fat_llama-0.1.0
+```
+Further need CUDA & CuPy properly installed: https://docs.cupy.dev/en/stable/install.html
+
+Also, requires ffmpeg for windows: https://support.audacityteam.org/basics/installing-ffmpeg
+## Usage
+### Example Usage
+You can run the example provided in example.py:
+
+```
+from fat_llama.audio_fattener import upscale_mp3_to_flac
+
+# Example call to the method
+upscale_mp3_to_flac(
+    input_file_path='input_short.mp3',
+    output_file_path_processed='output_processed.flac',
+    max_iterations=400,
+    threshold_value=0.4,
+    gain_factor=22.8,
+    reduction_profile=[
+        (5, 140, -28.4),
+        (1000, 10000, 26.4),
+    ],
+    lowcut=5.0,
+    highcut=150000.0,
+    target_bitrate_kbps=1400,
+    output_file_path_no_processing='output_upscaled_no_processing.flac',
+    use_wiener_filter=False
+)
+```
+### Function Parameters
+input_file_path (str): Path to the input MP3 file. Mandatory.
+output_file_path_processed (str): Path to the output processed FLAC file. Mandatory.
+max_iterations (int): Number of iterations for IST. Default is 400.
+threshold_value (float): Threshold value for IST. Default is 0.4.
+gain_factor (float): Gain factor for scaling amplitude. Default is 22.8.
+reduction_profile (list): Profile for gain reduction. Default is [(5, 140, -28.4), (1000, 10000, 26.4)].
+lowcut (float): Low cut frequency for equalizer. Default is 5.0.
+highcut (float): High cut frequency for equalizer. Default is 150000.0.
+target_bitrate_kbps (int): Target bitrate in kbps. Default is 1400.
+output_file_path_no_processing (str): Path to the output upscaled (no processing) FLAC file. Default is None.
+use_wiener_filter (bool): Flag to use Wiener filter. Default is False.
+
+## Running the Example
+To run the example, execute the following command:
+```
+python example.py
+```
+This will upscale the MP3 file specified in the example and produce two FLAC files: one with just upscaling and one with full processing.
+
+## Algorithm Explanation
+The upscaling process involves several steps:
+
+1. Reading MP3 File: The MP3 file is read, and the audio samples are extracted along with the sample rate and bitrate.
+2. Calculating Upscale Factor: The upscale factor is calculated to achieve the target bitrate.
+3. Upscaling Channels: The audio channels are upscaled using an interpolation algorithm. Each sample is repeated multiple times to increase the resolution.
+4. Iterative Soft Thresholding (IST): IST is applied to enhance the audio by adding missing frequencies. This process uses FFT to transform the signal into the frequency domain, apply a threshold to keep significant frequencies, and then inverse transform back to the time domain.
+5. Scaling Amplitude: The amplitude of the upscaled audio is scaled to match the original.
+6. Applying Gain Reduction: Frequency-specific gain reduction is applied based on a given profile.
+7. Equalization: A bandpass filter is applied to the audio to equalize it.
+8. Optional Wiener Filtering: Wiener filtering is applied to reduce noise if specified.
+9. Writing FLAC File: The processed audio is written to a FLAC file.
+
+## Why FFT and IST?
+FFT (Fast Fourier Transform) is used to transform the audio signal into the frequency domain. This allows for the identification and manipulation of specific frequency components. By applying a threshold in the frequency domain, we can keep significant frequencies and discard noise and add it to our upscaling data to add detail to upscaling frequencies.
+
+The report titled "Fast Sparse Fourier Transformations for NMR Spectroscopy" by Badruddin Kamal, supervised by Thomas Huber and Alastair Rendall, 2015, provides a comprehensive understanding of sparse representations and their applications in signal processing. IST leverages the concepts from this report to add missing frequencies and enhance the audio quality by making it more detailed and rich. This is particularly useful in upscaling audio where some frequencies might be missing or congested.
+
+### Test Audio Source, ericzo - beyond link(https://soundcloud.com/ericzomusic/free-electro-trap-anthem-beyond)

fat_llama-0.1.2/README.md

@@ -0,0 +1,86 @@
+# fat_llama
+
+fat_llama is a Python package for upscaling MP3 files to FLAC format using advanced audio processing techniques. It utilizes GPU-accelerated calculations to enhance audio quality by upsampling and adding missing frequencies, resulting in richer and more detailed audio.
+
+## Features
+
+- Upscale MP3 files to high-quality FLAC format.
+- Optional iterative soft thresholding (IST) for enhanced audio processing.
+- Gain adjustment, equalization, and optional Wiener filtering.
+- Supports GPU-accelerated processing with CuPy.
+
+## Installation
+
+Clone the repository:
+
+Install:
+```
+pip install fat_llama-0.1.0
+```
+Further need CUDA & CuPy properly installed: https://docs.cupy.dev/en/stable/install.html
+
+Also, requires ffmpeg for windows: https://support.audacityteam.org/basics/installing-ffmpeg
+## Usage
+### Example Usage
+You can run the example provided in example.py:
+
+```
+from fat_llama.audio_fattener import upscale_mp3_to_flac
+
+# Example call to the method
+upscale_mp3_to_flac(
+    input_file_path='input_short.mp3',
+    output_file_path_processed='output_processed.flac',
+    max_iterations=400,
+    threshold_value=0.4,
+    gain_factor=22.8,
+    reduction_profile=[
+        (5, 140, -28.4),
+        (1000, 10000, 26.4),
+    ],
+    lowcut=5.0,
+    highcut=150000.0,
+    target_bitrate_kbps=1400,
+    output_file_path_no_processing='output_upscaled_no_processing.flac',
+    use_wiener_filter=False
+)
+```
+### Function Parameters
+input_file_path (str): Path to the input MP3 file. Mandatory.
+output_file_path_processed (str): Path to the output processed FLAC file. Mandatory.
+max_iterations (int): Number of iterations for IST. Default is 400.
+threshold_value (float): Threshold value for IST. Default is 0.4.
+gain_factor (float): Gain factor for scaling amplitude. Default is 22.8.
+reduction_profile (list): Profile for gain reduction. Default is [(5, 140, -28.4), (1000, 10000, 26.4)].
+lowcut (float): Low cut frequency for equalizer. Default is 5.0.
+highcut (float): High cut frequency for equalizer. Default is 150000.0.
+target_bitrate_kbps (int): Target bitrate in kbps. Default is 1400.
+output_file_path_no_processing (str): Path to the output upscaled (no processing) FLAC file. Default is None.
+use_wiener_filter (bool): Flag to use Wiener filter. Default is False.
+
+## Running the Example
+To run the example, execute the following command:
+```
+python example.py
+```
+This will upscale the MP3 file specified in the example and produce two FLAC files: one with just upscaling and one with full processing.
+
+## Algorithm Explanation
+The upscaling process involves several steps:
+
+1. Reading MP3 File: The MP3 file is read, and the audio samples are extracted along with the sample rate and bitrate.
+2. Calculating Upscale Factor: The upscale factor is calculated to achieve the target bitrate.
+3. Upscaling Channels: The audio channels are upscaled using an interpolation algorithm. Each sample is repeated multiple times to increase the resolution.
+4. Iterative Soft Thresholding (IST): IST is applied to enhance the audio by adding missing frequencies. This process uses FFT to transform the signal into the frequency domain, apply a threshold to keep significant frequencies, and then inverse transform back to the time domain.
+5. Scaling Amplitude: The amplitude of the upscaled audio is scaled to match the original.
+6. Applying Gain Reduction: Frequency-specific gain reduction is applied based on a given profile.
+7. Equalization: A bandpass filter is applied to the audio to equalize it.
+8. Optional Wiener Filtering: Wiener filtering is applied to reduce noise if specified.
+9. Writing FLAC File: The processed audio is written to a FLAC file.
+
+## Why FFT and IST?
+FFT (Fast Fourier Transform) is used to transform the audio signal into the frequency domain. This allows for the identification and manipulation of specific frequency components. By applying a threshold in the frequency domain, we can keep significant frequencies and discard noise and add it to our upscaling data to add detail to upscaling frequencies.
+
+The report titled "Fast Sparse Fourier Transformations for NMR Spectroscopy" by Badruddin Kamal, supervised by Thomas Huber and Alastair Rendall, 2015, provides a comprehensive understanding of sparse representations and their applications in signal processing. IST leverages the concepts from this report to add missing frequencies and enhance the audio quality by making it more detailed and rich. This is particularly useful in upscaling audio where some frequencies might be missing or congested.
+
+### Test Audio Source, ericzo - beyond link(https://soundcloud.com/ericzomusic/free-electro-trap-anthem-beyond)

fat_llama-0.1.2/fat_llama/audio_fattener/feed.py

@@ -0,0 +1,305 @@
+import numpy as np
+import cupy as cp
+from pydub import AudioSegment
+import soundfile as sf
+import os
+import logging
+from mutagen.mp3 import MP3
+from scipy.signal import butter, lfilter, sosfilt, wiener
+import traceback
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def read_mp3(file_path):
+    """ 
+    Read an MP3 file and return the sample rate and data as a NumPy array 
+    
+    Parameters:
+    file_path (str): The path to the input MP3 file.
+    
+    Returns:
+    int: Sample rate of the audio.
+    numpy.ndarray: Audio samples.
+    int: Bitrate of the MP3 file.
+    AudioSegment: The audio segment object.
+    """
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File {file_path} not found.")
+    audio = AudioSegment.from_mp3(file_path)
+    samples = np.array(audio.get_array_of_samples())
+    sample_rate = audio.frame_rate
+    mp3_info = MP3(file_path)
+    bitrate = mp3_info.info.bitrate
+    if audio.channels == 2:
+        samples = samples.reshape((-1, 2))
+    return sample_rate, samples, bitrate, audio
+
+def write_flac(file_path, sample_rate, data):
+    """ 
+    Write data to a FLAC file 
+    
+    Parameters:
+    file_path (str): The path to the output FLAC file.
+    sample_rate (int): The sample rate of the audio.
+    data (numpy.ndarray): The audio data to write.
+    """
+    sf.write(file_path, data.astype(np.float32), sample_rate, format='FLAC', subtype='PCM_24')
+
+def new_interpolation_algorithm(data, upscale_factor):
+    """ 
+    Interpolate data with scaled changes around center points 
+    
+    Parameters:
+    data (numpy.ndarray): The input audio data.
+    upscale_factor (int): The factor by which to upscale the audio data.
+    
+    Returns:
+    numpy.ndarray: The upscaled audio data.
+    """
+    original_length = len(data)
+    expanded_length = original_length * upscale_factor
+    expanded_data = np.zeros(expanded_length, dtype=np.float32)
+    
+    for i in range(original_length):
+        center_point = data[i]
+        for j in range(upscale_factor):
+            index = i * upscale_factor + j
+            expanded_data[index] = center_point
+    
+    return expanded_data
+
+def initialize_ist(data, threshold):
+    """ 
+    Initialize IST variables 
+    
+    Parameters:
+    data (cupy.ndarray): The input audio data.
+    threshold (float): The threshold value for IST.
+    
+    Returns:
+    cupy.ndarray: The thresholded audio data.
+    """
+    mask = cp.abs(data) > threshold
+    data_thres = cp.where(mask, data, 0)
+    return data_thres
+
+def iterative_soft_thresholding(data, max_iter, threshold):
+    """ 
+    Perform IST on data using CuPy and cuFFT 
+    
+    Parameters:
+    data (numpy.ndarray): The input audio data.
+    max_iter (int): The maximum number of iterations for IST.
+    threshold (float): The threshold value for IST.
+    
+    Returns:
+    numpy.ndarray: The processed audio data after IST.
+    """
+    data_cp = cp.array(data, dtype=cp.float32)
+    data_thres = initialize_ist(data_cp, threshold)
+    for _ in range(max_iter):
+        data_fft = cp.fft.fft(data_thres)
+        mask = cp.abs(data_fft) > threshold
+        data_fft_thres = cp.where(mask, data_fft, 0)
+        data_thres = cp.fft.ifft(data_fft_thres).real
+    return cp.asnumpy(data_thres)
+
+def upscale_channels(channels, upscale_factor, max_iter, threshold, apply_ist=True):
+    """ 
+    Process and upscale channels using the new interpolation and IST algorithms 
+    
+    Parameters:
+    channels (numpy.ndarray): The input audio channels.
+    upscale_factor (int): The factor by which to upscale the audio data.
+    max_iter (int): The maximum number of iterations for IST.
+    threshold (float): The threshold value for IST.
+    apply_ist (bool): Flag to apply IST or not.
+    
+    Returns:
+    numpy.ndarray: The upscaled (and processed, if apply_ist=True) audio data.
+    """
+    processed_channels = []
+    for channel in channels.T:
+        logger.info("Interpolating data...")
+        expanded_channel = new_interpolation_algorithm(channel, upscale_factor)
+        
+        if apply_ist:
+            logger.info("Performing IST...")
+            ist_changes = iterative_soft_thresholding(expanded_channel, max_iter, threshold)
+            expanded_channel = expanded_channel.astype(np.float32) + ist_changes
+        
+        processed_channels.append(expanded_channel)
+    
+    return np.column_stack(processed_channels)
+
+def normalize_signal(signal):
+    """ 
+    Normalize signal to the range -1 to 1 
+    
+    Parameters:
+    signal (numpy.ndarray): The input audio signal.
+    
+    Returns:
+    numpy.ndarray: The normalized audio signal.
+    """
+    return signal / np.max(np.abs(signal))
+
+def scale_amplitude(original, upscaled, gain_factor):
+    """ 
+    Scale the amplitude of the upscaled channels to match the original and apply gain factor 
+    
+    Parameters:
+    original (numpy.ndarray): The original audio data.
+    upscaled (numpy.ndarray): The upscaled audio data.
+    gain_factor (float): The gain factor to apply.
+    
+    Returns:
+    numpy.ndarray: The scaled upscaled audio data.
+    """
+    normalized_original = normalize_signal(original)
+    normalized_upscaled = normalize_signal(upscaled)
+    
+    scale_factor = np.max(np.abs(normalized_original)) / np.max(np.abs(normalized_upscaled))
+    scaled_upscaled = normalized_upscaled * scale_factor * gain_factor
+    
+    return scaled_upscaled
+
+def apply_gain_reduction(data, sample_rate, reduction_profile):
+    """ 
+    Apply gain reduction based on the given reduction profile 
+    
+    Parameters:
+    data (cupy.ndarray): The input audio data.
+    sample_rate (int): The sample rate of the audio.
+    reduction_profile (list of tuple): The reduction profile as a list of (lowcut, highcut, reduction_factor) tuples.
+    
+    Returns:
+    numpy.ndarray: The gain-reduced audio data.
+    """
+    nyquist = 0.5 * sample_rate
+    reduced_data = cp.asnumpy(data)
+
+    for (lowcut, highcut, reduction_factor) in reduction_profile:
+        low = lowcut / nyquist
+        high = highcut / nyquist
+        sos = butter(2, [low, high], btype='band', output='sos')
+        reduced_data = reduced_data + sosfilt(sos, reduced_data) * reduction_factor
+    
+    return reduced_data
+
+def equalize_audio(data, sample_rate, lowcut, highcut):
+    """ 
+    Apply a bandpass filter to the audio data 
+    
+    Parameters:
+    data (numpy.ndarray): The input audio data.
+    sample_rate (int): The sample rate of the audio.
+    lowcut (float): The low cut frequency for the equalizer.
+    highcut (float): The high cut frequency for the equalizer.
+    
+    Returns:
+    numpy.ndarray: The equalized audio data.
+    """
+    nyquist = 0.5 * sample_rate
+    low = lowcut / nyquist
+    high = highcut / nyquist
+    b, a = butter(1, [low, high], btype='band')
+    y = lfilter(b, a, data)
+    return y
+
+def apply_wiener_filter(data):
+    """ 
+    Apply Wiener filter to the audio data 
+    
+    Parameters:
+    data (numpy.ndarray): The input audio data.
+    
+    Returns:
+    numpy.ndarray: The audio data after applying the Wiener filter.
+    """
+    return wiener(data)
+
+def upscale_mp3_to_flac(input_file_path, output_file_path_processed, max_iterations=400, threshold_value=0.4, gain_factor=22.8, reduction_profile=None, lowcut=5.0, highcut=150000.0, target_bitrate_kbps=1400, output_file_path_no_processing=None, use_wiener_filter=False):
+    """
+    Main function to upscale an MP3 file to FLAC format with optional processing.
+    
+    Parameters:
+    input_file_path (str): Path to the input MP3 file.
+    output_file_path_processed (str): Path to the output processed FLAC file.
+    max_iterations (int): Maximum number of iterations for IST.
+    threshold_value (float): Threshold value for IST.
+    gain_factor (float): Gain factor for scaling amplitude.
+    reduction_profile (list of tuple): Reduction profile for gain reduction.
+    lowcut (float): Low cut frequency for equalizer.
+    highcut (float): High cut frequency for equalizer.
+    target_bitrate_kbps (int): Target bitrate in kbps (must be between 800 and 1400).
+    output_file_path_no_processing (str, optional): Path to the output FLAC file without processing. Default is None.
+    use_wiener_filter (bool): Flag to use Wiener filter or not. Default is False.
+    """
+    if reduction_profile is None:
+        reduction_profile = [
+            (5, 140, -28.4),
+            (1000, 10000, 26.4),
+        ]
+    
+    if not (800 <= target_bitrate_kbps <= 1400):
+        raise ValueError("FLAC bitrate out of range. Please provide a value between 800 and 1400 kbps.")
+    
+    logger.info("Loading MP3 file...")
+    sample_rate, samples, bitrate, audio = read_mp3(input_file_path)
+    logger.info(f"Original MP3 bitrate: {bitrate / 1000:.2f} kbps")
+
+    samples = np.array(audio.get_array_of_samples())
+    if audio.channels == 2:
+        samples = samples.reshape((-1, 2))
+
+    target_bitrate = target_bitrate_kbps * 1000
+    upscale_factor = round(target_bitrate / bitrate)
+    logger.info(f"Upscale factor set to: {upscale_factor}")
+
+    if samples.ndim == 1:
+        logger.info("Mono channel detected.")
+        channels = samples[:, np.newaxis]
+    else:
+        logger.info("Stereo channels detected.")
+        channels = samples
+
+    if output_file_path_no_processing is not None:
+        logger.info("Upscaling channels without processing...")
+        upscaled_channels_no_processing = upscale_channels(channels, upscale_factor=upscale_factor, max_iter=max_iterations, threshold=threshold_value, apply_ist=False)
+        new_sample_rate = sample_rate * upscale_factor
+        write_flac(output_file_path_no_processing, new_sample_rate, upscaled_channels_no_processing)
+        logger.info(f"Saved upscaled (no processing) FLAC file at {output_file_path_no_processing}")
+
+    logger.info("Upscaling and processing channels...")
+    upscaled_channels = upscale_channels(channels, upscale_factor=upscale_factor, max_iter=max_iterations, threshold=threshold_value, apply_ist=True)
+    
+    logger.info("Scaling amplitudes...")
+    scaled_upscaled_channels = []
+    for i, channel in enumerate(channels.T):
+        scaled_channel = scale_amplitude(channel, upscaled_channels[:, i], gain_factor=gain_factor)
+        scaled_upscaled_channels.append(scaled_channel)
+    scaled_upscaled_channels = np.column_stack(scaled_upscaled_channels)
+
+    logger.info("Applying gain reduction...")
+    gain_reduced_channels = []
+    for i in range(scaled_upscaled_channels.shape[1]):
+        gain_reduced_channel = apply_gain_reduction(cp.asarray(scaled_upscaled_channels[:, i]), sample_rate * upscale_factor, reduction_profile)
+        gain_reduced_channels.append(cp.asnumpy(gain_reduced_channel))
+    gain_reduced_channels = np.column_stack(gain_reduced_channels)
+
+    logger.info("Normalizing and equalizing...")
+    normalized_upscaled_channels = []
+    for i in range(gain_reduced_channels.shape[1]):
+        normalized_channel = normalize_signal(gain_reduced_channels[:, i])
+        equalized_channel = equalize_audio(normalized_channel, sample_rate * upscale_factor, lowcut, highcut)
+        if use_wiener_filter:
+            equalized_channel = apply_wiener_filter(equalized_channel)
+        normalized_upscaled_channels.append(equalized_channel)
+    normalized_upscaled_channels = np.column_stack(normalized_upscaled_channels)
+
+    new_sample_rate = sample_rate * upscale_factor
+    write_flac(output_file_path_processed, new_sample_rate, normalized_upscaled_channels)
+    logger.info(f"Saved processed FLAC file at {output_file_path_processed}")

fat_llama-0.1.2/fat_llama/tests/test_feed.py

@@ -0,0 +1,62 @@
+import unittest
+import numpy as np
+import os
+from fat_llama.audio_fattener.feed import read_mp3, upscale_mp3_to_flac, write_flac
+
+class TestAudioFattener(unittest.TestCase):
+
+    def setUp(self):
+        # Create a small example MP3 file for testing
+        self.test_mp3_file = 'test_input.mp3'
+        self.create_test_mp3(self.test_mp3_file)
+
+    def tearDown(self):
+        # Remove the test MP3 file and any generated FLAC files
+        if os.path.exists(self.test_mp3_file):
+            os.remove(self.test_mp3_file)
+        if os.path.exists('output_processed.flac'):
+            os.remove('output_processed.flac')
+        if os.path.exists('output_upscaled_no_processing.flac'):
+            os.remove('output_upscaled_no_processing.flac')
+
+    def create_test_mp3(self, filename):
+        from pydub.generators import Sine
+        sine_wave = Sine(440).to_audio_segment(duration=1000)  # 1 second of 440 Hz sine wave
+        sine_wave.export(filename, format="mp3")
+
+    def test_read_mp3(self):
+        sample_rate, samples, bitrate, audio = read_mp3(self.test_mp3_file)
+        self.assertEqual(sample_rate, 44100)  # Default sample rate for the generated sine wave
+        self.assertEqual(len(samples), 44100)  # 1 second of audio at 44100 Hz
+        self.assertEqual(bitrate, 63999)  # Bitrate of the generated MP3
+
+    def test_upscale_mp3_to_flac(self):
+        upscale_mp3_to_flac(
+            input_file_path=self.test_mp3_file,
+            output_file_path_processed='output_processed.flac',
+            max_iterations=10,  # Using a smaller number for faster testing
+            threshold_value=0.1,
+            gain_factor=1.0,
+            reduction_profile=[
+                (5, 140, -0.5),
+                (1000, 10000, 0.5),
+            ],
+            lowcut=5.0,
+            highcut=22000.0,
+            target_bitrate_kbps=800,
+            output_file_path_no_processing='output_upscaled_no_processing.flac',
+            use_wiener_filter=False
+        )
+        self.assertTrue(os.path.exists('output_processed.flac'))
+        self.assertTrue(os.path.exists('output_upscaled_no_processing.flac'))
+
+    def test_write_flac(self):
+        sample_rate, samples, bitrate, audio = read_mp3(self.test_mp3_file)
+        output_file = 'test_output.flac'
+        write_flac(output_file, sample_rate, samples)
+        self.assertTrue(os.path.exists(output_file))
+        if os.path.exists(output_file):
+            os.remove(output_file)
+
+if __name__ == '__main__':
+    unittest.main()

fat_llama-0.1.2/fat_llama.egg-info/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.1
+Name: fat_llama
+Version: 0.1.2
+Summary: A package for CUDA-based upscaling and processing audio files, using FFT to add audio frequency details after upscaling.
+Home-page: https://github.com/bkraad47/fat_llama
+Author: Badruddin Kamal
+Author-email: bulkguy47@gmail.com
+License: BSD-3-Clause
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: cupy-cuda12x
+Requires-Dist: pydub
+Requires-Dist: soundfile
+Requires-Dist: mutagen
+Requires-Dist: scipy
+Requires-Dist: tqdm
+
+# fat_llama
+
+fat_llama is a Python package for upscaling MP3 files to FLAC format using advanced audio processing techniques. It utilizes GPU-accelerated calculations to enhance audio quality by upsampling and adding missing frequencies, resulting in richer and more detailed audio.
+
+## Features
+
+- Upscale MP3 files to high-quality FLAC format.
+- Optional iterative soft thresholding (IST) for enhanced audio processing.
+- Gain adjustment, equalization, and optional Wiener filtering.
+- Supports GPU-accelerated processing with CuPy.
+
+## Installation
+
+Clone the repository:
+
+Install:
+```
+pip install fat_llama-0.1.0
+```
+Further need CUDA & CuPy properly installed: https://docs.cupy.dev/en/stable/install.html
+
+Also, requires ffmpeg for windows: https://support.audacityteam.org/basics/installing-ffmpeg
+## Usage
+### Example Usage
+You can run the example provided in example.py:
+
+```
+from fat_llama.audio_fattener import upscale_mp3_to_flac
+
+# Example call to the method
+upscale_mp3_to_flac(
+    input_file_path='input_short.mp3',
+    output_file_path_processed='output_processed.flac',
+    max_iterations=400,
+    threshold_value=0.4,
+    gain_factor=22.8,
+    reduction_profile=[
+        (5, 140, -28.4),
+        (1000, 10000, 26.4),
+    ],
+    lowcut=5.0,
+    highcut=150000.0,
+    target_bitrate_kbps=1400,
+    output_file_path_no_processing='output_upscaled_no_processing.flac',
+    use_wiener_filter=False
+)
+```
+### Function Parameters
+input_file_path (str): Path to the input MP3 file. Mandatory.
+output_file_path_processed (str): Path to the output processed FLAC file. Mandatory.
+max_iterations (int): Number of iterations for IST. Default is 400.
+threshold_value (float): Threshold value for IST. Default is 0.4.
+gain_factor (float): Gain factor for scaling amplitude. Default is 22.8.
+reduction_profile (list): Profile for gain reduction. Default is [(5, 140, -28.4), (1000, 10000, 26.4)].
+lowcut (float): Low cut frequency for equalizer. Default is 5.0.
+highcut (float): High cut frequency for equalizer. Default is 150000.0.
+target_bitrate_kbps (int): Target bitrate in kbps. Default is 1400.
+output_file_path_no_processing (str): Path to the output upscaled (no processing) FLAC file. Default is None.
+use_wiener_filter (bool): Flag to use Wiener filter. Default is False.
+
+## Running the Example
+To run the example, execute the following command:
+```
+python example.py
+```
+This will upscale the MP3 file specified in the example and produce two FLAC files: one with just upscaling and one with full processing.
+
+## Algorithm Explanation
+The upscaling process involves several steps:
+
+1. Reading MP3 File: The MP3 file is read, and the audio samples are extracted along with the sample rate and bitrate.
+2. Calculating Upscale Factor: The upscale factor is calculated to achieve the target bitrate.
+3. Upscaling Channels: The audio channels are upscaled using an interpolation algorithm. Each sample is repeated multiple times to increase the resolution.
+4. Iterative Soft Thresholding (IST): IST is applied to enhance the audio by adding missing frequencies. This process uses FFT to transform the signal into the frequency domain, apply a threshold to keep significant frequencies, and then inverse transform back to the time domain.
+5. Scaling Amplitude: The amplitude of the upscaled audio is scaled to match the original.
+6. Applying Gain Reduction: Frequency-specific gain reduction is applied based on a given profile.
+7. Equalization: A bandpass filter is applied to the audio to equalize it.
+8. Optional Wiener Filtering: Wiener filtering is applied to reduce noise if specified.
+9. Writing FLAC File: The processed audio is written to a FLAC file.
+
+## Why FFT and IST?
+FFT (Fast Fourier Transform) is used to transform the audio signal into the frequency domain. This allows for the identification and manipulation of specific frequency components. By applying a threshold in the frequency domain, we can keep significant frequencies and discard noise and add it to our upscaling data to add detail to upscaling frequencies.
+
+The report titled "Fast Sparse Fourier Transformations for NMR Spectroscopy" by Badruddin Kamal, supervised by Thomas Huber and Alastair Rendall, 2015, provides a comprehensive understanding of sparse representations and their applications in signal processing. IST leverages the concepts from this report to add missing frequencies and enhance the audio quality by making it more detailed and rich. This is particularly useful in upscaling audio where some frequencies might be missing or congested.
+
+### Test Audio Source, ericzo - beyond link(https://soundcloud.com/ericzomusic/free-electro-trap-anthem-beyond)

fat_llama-0.1.2/fat_llama.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+fat_llama/__init__.py
+fat_llama.egg-info/PKG-INFO
+fat_llama.egg-info/SOURCES.txt
+fat_llama.egg-info/dependency_links.txt
+fat_llama.egg-info/entry_points.txt
+fat_llama.egg-info/requires.txt
+fat_llama.egg-info/top_level.txt
+fat_llama/audio_fattener/__init__.py
+fat_llama/audio_fattener/feed.py
+fat_llama/audio_fattener/__pycache__/audio_fattener.cpython-312.pyc
+fat_llama/audio_fattener/__pycache__/feed.cpython-312.pyc
+fat_llama/tests/__init__.py
+fat_llama/tests/test_feed.py
+fat_llama/tests/__pycache__/test_feed.cpython-312.pyc

fat_llama-0.1.2/fat_llama.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fat_llama-0.1.2/fat_llama.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+example = example:main

fat_llama-0.1.2/fat_llama.egg-info/requires.txt

@@ -0,0 +1,7 @@
+numpy
+cupy-cuda12x
+pydub
+soundfile
+mutagen
+scipy
+tqdm

fat_llama-0.1.2/fat_llama.egg-info/top_level.txt

@@ -0,0 +1 @@
+fat_llama

fat_llama-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fat_llama-0.1.2/setup.py

@@ -0,0 +1,42 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='fat_llama',
+    version='0.1.2',
+    packages=find_packages(),
+    install_requires=[
+        'numpy',
+        'cupy-cuda12x',
+        'pydub',
+        'soundfile',
+        'mutagen',
+        'scipy',
+        'tqdm',
+    ],
+    package_data={
+        # Include any package data files here
+        'fat_llama': ['audio_fattener/*.py', 'tests/*.py'],
+    },
+    entry_points={
+        'console_scripts': [
+            'example=example:main',
+        ],
+    },
+    author='Badruddin Kamal',
+    author_email='bulkguy47@gmail.com',
+    description='A package for CUDA-based upscaling and processing audio files, using FFT to add audio frequency details after upscaling.',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    url='https://github.com/bkraad47/fat_llama',
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: BSD License',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+    ],
+    license='BSD-3-Clause',
+)