Update app.py

app.py

@@ -1,64 +1,78 @@
-import numpy as np
 import gradio as gr
-from scipy.io.wavfile import write
-from pydub import AudioSegment
+import numpy as np
+import wave
+
+# Assuming the classes and methods from animalese.js are translated into Python
+
+class Animalese:
+    def __init__(self, letters_file, onload):
+        with open(letters_file, 'rb') as f:
+            self.letter_library = np.frombuffer(f.read(), dtype=np.uint8)
+        onload()
+        
+    def synthesize(self, script, shorten=False, pitch=1.0):
+        def shorten_word(word):
+            return word[0] + word[-1] if len(word) > 1 else word
+
+        processed_script = "".join(map(shorten_word, script.replace(/[^a-z]/gi, ' ').split())) if shorten else script
+        data = []
 
-# Define the core Animalese function
-def animalese_synthesize(text, shorten=False, pitch=1.0):
-    def shorten_word(word):
-        if len(word) > 1:
-            return word[0] + word[-1]
-        return word
+        sample_freq = 44100
+        library_letter_secs = 0.15
+        library_samples_per_letter = int(library_letter_secs * sample_freq)
+        output_letter_secs = 0.075
+        output_samples_per_letter = int(output_letter_secs * sample_freq)
 
-    # Shorten words if the option is enabled
-    processed_script = text
-    if shorten:
-        processed_script = ''.join([shorten_word(w) for w in text.split()])
+        for c in processed_script.upper():
+            if 'A' <= c <= 'Z':
+                library_letter_start = library_samples_per_letter * (ord(c) - ord('A'))
+                for i in range(output_samples_per_letter):
+                    data.append(self.letter_library[44 + library_letter_start + int(i * pitch)])
+            else:
+                data.extend([127] * output_samples_per_letter)
 
-    # Generate the waveform (This is a simplified version)
-    sample_rate = 44100
-    data = []
-    library_letter_secs = 0.15
-    library_samples_per_letter = int(library_letter_secs * sample_rate)
-    output_letter_secs = 0.075
-    output_samples_per_letter = int(output_letter_secs * sample_rate)
+        # Create the .wav file data
+        data = np.array(data, dtype=np.uint8)
+        return self.create_wave(data, sample_freq)
+    
+    def create_wave(self, data, sample_rate):
+        with wave.open("output.wav", "wb") as f:
+            f.setnchannels(1)
+            f.setsampwidth(1)
+            f.setframerate(sample_rate)
+            f.writeframes(data.tobytes())
+        return "output.wav"
 
-    # Use a basic sine wave to simulate the sounds
-    for c in processed_script.upper():
-        if 'A' <= c <= 'Z':
-            freq = 440 + (ord(c) - ord('A')) * 10  # Simple mapping A-Z to frequencies
-            t = np.linspace(0, output_letter_secs, output_samples_per_letter, False)
-            wave = 0.5 * np.sin(2 * np.pi * freq * t * pitch)
-            data.extend(wave)
-        else:
-            data.extend([0] * output_samples_per_letter)
+# Initialize the synthesizer
+synth = Animalese('animalese.wav', lambda: print("Loaded"))
 
-    # Convert to numpy array and save as WAV
-    data = np.array(data, dtype=np.float32)
-    scaled = np.int16(data/np.max(np.abs(data)) * 32767)
+def generate_audio(text, shorten, pitch):
+    return synth.synthesize(text, shorten, pitch)
 
-    return scaled, sample_rate
+def preview_audio(audio_file):
+    with open(audio_file, 'rb') as f:
+        return f.read()
 
-def generate_wav_file(text, shorten, pitch):
-    data, sample_rate = animalese_synthesize(text, shorten, pitch)
-    output_file = "animalese_output.wav"
-    write(output_file, sample_rate, data)
-    return output_file
+# Gradio UI
+with gr.Blocks() as demo:
+    gr.Markdown("# Animalese.js Demo in Gradio")
+    gr.Markdown("vist also [web version](https://huggingface.co/spaces/Blane187/animalese-js)")
+    text_input = gr.Textbox(label="Input Text", placeholder="Enter text to convert to Animalese")
+    shorten_input = gr.Checkbox(label="Shorten Words")
+    pitch_input = gr.Slider(minimum=0.2, maximum=2.0, step=0.1, value=1.0, label="Pitch")
 
-# Define the Gradio interface
-def preview_audio(text, shorten, pitch):
-    output_file = generate_wav_file(text, shorten, pitch)
-    return output_file
+    with gr.Row():
+        preview_button = gr.Button("Preview!")
+        download_button = gr.Button("Download!")
+    
+    audio_output = gr.Audio(label="Output Audio")
 
-gr_interface = gr.Interface(
-    fn=preview_audio,
-    inputs=[
-        gr.Textbox(label="Text to Synthesize"),
-        gr.Checkbox(label="Shorten Words"),
-        gr.Slider(0.2, 2.0, step=0.1, label="Pitch", value=1.0)
-    ],
-    outputs=gr.Audio(label="Preview Animalese Audio")
-)
+    preview_button.click(fn=lambda text, shorten, pitch: preview_audio(generate_audio(text, shorten, pitch)),
+                         inputs=[text_input, shorten_input, pitch_input],
+                         outputs=audio_output)
+    
+    download_button.click(fn=lambda text, shorten, pitch: generate_audio(text, shorten, pitch),
+                          inputs=[text_input, shorten_input, pitch_input],
+                          outputs=gr.File(label="Download .wav"))
 
-if __name__ == "__main__":
-    gr_interface.launch()
+demo.launch()