audacity_automation_external.py

#!/usr/bin/env python3
"""
External Audacity Automation
Uses AppleScript (macOS) or other automation methods to control Audacity.
"""

import os
import sys
import subprocess
import time
from pathlib import Path

def create_applescript_automation(input_file, output_file, effects=None):
    """
    Create an AppleScript to automate Audacity on macOS.
    """
    
    if effects is None:
        effects = [
            {"name": "Echo", "delay": 0.3, "decay": 0.1},
        ]
    
    # Convert effects to AppleScript commands
    effect_commands = []
    for effect in effects:
        if effect["name"] == "Echo":
            effect_commands.append(f'''
        -- Apply Echo effect
        tell application "System Events"
            tell process "Audacity"
                click menu item "Echo..." of menu "Effect" of menu bar 1
                delay 1
                set value of slider 1 of window 1 to {int(effect.get("delay", 0.3) * 100)}
                set value of slider 2 of window 1 to {int(effect.get("decay", 0.1) * 100)}
                click button "OK" of window 1
                delay 2
            end tell
        end tell''')
    
    applescript = f'''
tell application "Audacity"
    activate
    delay 2
end tell

tell application "System Events"
    tell process "Audacity"
        -- Import raw data
        click menu item "Raw Data..." of menu "Import" of menu "File" of menu bar 1
        delay 1
        
        -- Set file path (you'll need to manually select the file)
        -- This is a limitation of AppleScript with file dialogs
        
        -- Select all audio
        keystroke "a" using command down
        delay 1
        
        {chr(10).join(effect_commands)}
        
        -- Export as raw
        click menu item "Export Audio..." of menu "Export" of menu "File" of menu bar 1
        delay 1
        
        -- Set export format to RAW
        click pop up button 1 of window 1
        click menu item "RAW (header-less)" of menu 1 of pop up button 1 of window 1
        
        -- Set encoding to U-Law
        click pop up button 2 of window 1
        click menu item "U-Law" of menu 1 of pop up button 2 of window 1
        
        -- Set output path (you'll need to manually set this)
        -- click button "Save" of window 1
    end tell
end tell
'''
    
    script_file = "audacity_automation.scpt"
    with open(script_file, 'w') as f:
        f.write(applescript)
    
    print(f"Created AppleScript: {script_file}")
    print("Note: AppleScript has limitations with file dialogs.")
    print("You may need to manually select files in some cases.")
    
    return script_file

def create_python_automation_script(input_dir="input-bitmap", output_dir="output-raw", effects=None):
    """
    Create a Python script that uses pyautogui for automation.
    """
    
    if effects is None:
        effects = [
            {"name": "Echo", "delay": 0.3, "decay": 0.1},
        ]
    
    script_content = f'''
#!/usr/bin/env python3
"""
Audacity Automation using pyautogui
Requires: pip install pyautogui pillow
"""

import pyautogui
import time
import os
from pathlib import Path

# Configure pyautogui
pyautogui.FAILSAFE = True
pyautogui.PAUSE = 0.5

def open_audacity():
    """Open Audacity application"""
    pyautogui.hotkey('cmd', 'space')  # Spotlight
    time.sleep(1)
    pyautogui.write('Audacity')
    time.sleep(1)
    pyautogui.press('enter')
    time.sleep(3)  # Wait for Audacity to open

def import_raw_data(file_path):
    """Import raw data file"""
    pyautogui.hotkey('cmd', 'shift', 'i')  # Import Raw Data
    time.sleep(1)
    
    # Type the file path
    pyautogui.write(str(file_path))
    time.sleep(1)
    pyautogui.press('enter')
    time.sleep(2)

def apply_echo_effect(delay=0.3, decay=0.1):
    """Apply echo effect"""
    pyautogui.hotkey('cmd', 'shift', 'e')  # Echo effect
    time.sleep(1)
    
    # Set delay (assuming it's the first slider)
    pyautogui.click(x=400, y=300)  # Adjust coordinates as needed
    pyautogui.write(str(delay))
    
    # Set decay (assuming it's the second slider)
    pyautogui.click(x=400, y=350)  # Adjust coordinates as needed
    pyautogui.write(str(decay))
    
    # Click OK
    pyautogui.press('enter')
    time.sleep(2)

def export_raw_audio(output_path):
    """Export as raw audio"""
    pyautogui.hotkey('cmd', 'shift', 'e')  # Export Audio
    time.sleep(1)
    
    # Set format to RAW
    pyautogui.click(x=300, y=200)  # Format dropdown
    time.sleep(1)
    pyautogui.press('down')  # Navigate to RAW
    pyautogui.press('enter')
    
    # Set encoding to U-Law
    pyautogui.click(x=300, y=250)  # Encoding dropdown
    time.sleep(1)
    pyautogui.press('down')  # Navigate to U-Law
    pyautogui.press('enter')
    
    # Set output path
    pyautogui.write(str(output_path))
    time.sleep(1)
    pyautogui.press('enter')
    time.sleep(2)

def process_file(input_file, output_file, effects):
    """Process a single file"""
    print(f"Processing {{input_file}}...")
    
    # Open Audacity
    open_audacity()
    
    # Import the file
    import_raw_data(input_file)
    
    # Select all
    pyautogui.hotkey('cmd', 'a')
    time.sleep(1)
    
    # Apply effects
    for effect in effects:
        if effect["name"] == "Echo":
            apply_echo_effect(
                delay=effect.get("delay", 0.3),
                decay=effect.get("decay", 0.1)
            )
    
    # Export
    export_raw_audio(output_file)
    
    # Close project
    pyautogui.hotkey('cmd', 'w')
    time.sleep(1)

# Main processing
input_dir = "{input_dir}"
output_dir = "{output_dir}"
effects = {effects}

input_path = Path(input_dir)
output_path = Path(output_dir)
output_path.mkdir(exist_ok=True)

for bitmap_file in input_path.glob("*.bmp"):
    output_file = output_path / f"{{bitmap_file.stem}}.raw"
    process_file(str(bitmap_file), str(output_file), effects)

print("Processing complete!")
'''
    
    script_file = "audacity_pyautogui.py"
    with open(script_file, 'w') as f:
        f.write(script_content)
    
    print(f"Created pyautogui automation script: {script_file}")
    print("To use this script:")
    print("1. Install pyautogui: pip install pyautogui")
    print("2. Adjust the click coordinates for your screen resolution")
    print("3. Run: python audacity_pyautogui.py")
    
    return script_file

def create_sox_alternative(input_dir="input-bitmap", output_dir="output-raw", effects=None):
    """
    Create a script using SoX (Sound eXchange) as an alternative to Audacity.
    SoX can apply audio effects programmatically without GUI.
    """
    
    if effects is None:
        effects = [
            {"name": "echo", "gain_in": 0.8, "gain_out": 0.5, "delays": "0.3", "decays": "0.1"},
        ]
    
    script_content = f'''
#!/usr/bin/env python3
"""
SoX-based audio processing as alternative to Audacity
Requires: brew install sox (on macOS) or apt-get install sox (on Linux)
"""

import subprocess
import os
from pathlib import Path

def process_with_sox(input_file, output_file, effects):
    """Process audio file with SoX effects"""
    
    # Build SoX command
    cmd = ["sox", input_file, output_file]
    
    # Add effects
    for effect in effects:
        if effect["name"] == "echo":
            cmd.extend([
                "echo", 
                str(effect.get("gain_in", 0.8)),
                str(effect.get("gain_out", 0.5)),
                str(effect.get("delays", "0.3")),
                str(effect.get("decays", "0.1"))
            ])
        elif effect["name"] == "reverb":
            cmd.extend([
                "reverb",
                str(effect.get("room_scale", 0.5)),
                str(effect.get("h_freq", 0.5)),
                str(effect.get("reverberance", 0.5)),
                str(effect.get("damping", 0.5))
            ])
    
    print(f"Running: {{' '.join(cmd)}}")
    
    try:
        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
        print(f"Successfully processed {{input_file}}")
        return True
    except subprocess.CalledProcessError as e:
        print(f"Error processing {{input_file}}: {{e.stderr}}")
        return False

# Main processing
input_dir = "{input_dir}"
output_dir = "{output_dir}"
effects = {effects}

input_path = Path(input_dir)
output_path = Path(output_dir)
output_path.mkdir(exist_ok=True)

# Check if SoX is installed
try:
    subprocess.run(["sox", "--version"], capture_output=True, check=True)
    print("SoX is installed and ready to use!")
except FileNotFoundError:
    print("SoX is not installed. Install it with:")
    print("  macOS: brew install sox")
    print("  Linux: sudo apt-get install sox")
    print("  Windows: Download from https://sox.sourceforge.net/")
    exit(1)

for bitmap_file in input_path.glob("*.bmp"):
    output_file = output_path / f"{{bitmap_file.stem}}.raw"
    process_with_sox(str(bitmap_file), str(output_file), effects)

print("SoX processing complete!")
'''
    
    script_file = "sox_processing.py"
    with open(script_file, 'w') as f:
        f.write(script_content)
    
    print(f"Created SoX processing script: {script_file}")
    print("SoX is a command-line alternative to Audacity for audio processing.")
    
    return script_file

if __name__ == "__main__":
    effects = [
        {"name": "Echo", "delay": 0.3, "decay": 0.1},
        {"name": "Reverb", "room_size": 0.5, "damping": 0.5},
    ]
    
    print("Creating automation scripts...")
    create_applescript_automation("test.bmp", "test.raw", effects)
    create_python_automation_script("input-bitmap", "output-raw", effects)
    create_sox_alternative("input-bitmap", "output-raw", effects)
    
    print("\\nAutomation options created:")
    print("1. audacity_automation.scpt - AppleScript (macOS)")
    print("2. audacity_pyautogui.py - Python with pyautogui")
    print("3. sox_processing.py - SoX command-line alternative")