Upload 12 files

Gradio App Ver 1/app_es.py

@@ -0,0 +1,435 @@
+import gradio as gr 
+import math 
+import numpy as np
+import plotly.graph_objects as go 
+from smolLM3 import load_model_with_config, GenerationConfig, generate_text 
+import re 
+import torch 
+import torchaudio as ta 
+from chatterbox.tts import ChatterboxTTS 
+import logging 
+import os 
+from datetime import datetime 
+from lipsync import LipSync
+from pathlib import Path
+import pickle
+import warnings 
+
+
+# Configure logging 
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('robotic_arm.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+torch_load_original = torch.load
+def patched_torch_load(*args, **kwargs):
+    if 'map_location' not in kwargs:
+        kwargs['map_location'] = map_location
+        
+    # Handle both string and Path objects
+    path_str = str(args[0]) if len(args) > 0 else str(kwargs.get('f', ''))
+    if 'wav2lip_gan.pth' in path_str:
+        kwargs.update({
+            'weights_only': False,
+            'pickle_module': pickle,
+            'encoding': 'latin1'
+        })
+    return torch_load_original(*args, **kwargs)
+torch.load = patched_torch_load
+
+# Initialize TTS (device setup similar to example_for_mac.py)
+device = "mps" if torch.backends.mps.is_available() else "cpu"
+map_location = torch.device(device)
+
+# Initialize TTS model (load once when the app starts)
+tts_model = ChatterboxTTS.from_pretrained(device=device)
+
+# Voice options must be defined after TTS model is initialized
+DEFAULT_VOICE = None
+VOICE_OPTIONS = {
+    "Default Voice": None,
+    "Angela Aguilar": str(Path("/Users/martinrivera/dl_yt_vid_or_aud/#ADosDeBorrarte 💚 [NyhOLU-5LAo].mp4").resolve()),
+    "Bad Gyal": str(Path("/Users/martinrivera/dl_yt_vid_or_aud/Bad Gyal habla un poquito sobre su look ｜ Premio Lo Nuestro 2024 [G38hDOFRROQ].mp4").resolve()),
+    "Becky G": str(Path("/Users/martinrivera/dl_yt_vid_or_aud/Becky G： look estrella con cat eye definido y labio brillante ｜ Secretos de Belleza ｜ VOGUE España [LbRFHczCWwE].mp4").resolve()),
+    "Corina Smith": str(Path("/Users/martinrivera/tiktok/corinasmith_7447217337046011167.mp4").resolve()),
+    "Emilia": str(Path("/Users/martinrivera/dl_yt_vid_or_aud/Emilia： ¿Es más de gloss o labial？ [Bcc-F2PfT_k].mp4").resolve()),
+    "Fariana": str(Path("/Users/martinrivera/dl_yt_vid_or_aud/Me Muevo Fariana  #memuevo #dance  #viralvideo #dance #music #viralshorts #reels [zik7N2QJFAQ].mp4").resolve()),
+    "Karol G": str(Path("/Users/martinrivera/dl_yt_vid_or_aud/¿Qué hay en el bolso de Karol G？ ｜ VOGUE España [hC0tnRAnzMQ].mp4").resolve()),
+    "Kenia Os": str(Path("/Users/martinrivera/dl_yt_vid_or_aud/🩷 [EAgBzkYNamQ].mp4").resolve()),
+    "La Joaqui": str(Path("/Users/martinrivera/dl_yt_vid_or_aud/✨✨✨✨ [8e-p775v_FY].mp4").resolve()),
+    "Maria Becerra": str(Path("/Users/martinrivera/dl_yt_vid_or_aud/Mariah Angeliq Cantando ＂BOBO＂ En Acapella ｜ #lacasadelartista [2Ao_3awg0Z0].mp4").resolve()),
+    "Mariah Angeliq": str(Path("/Users/martinrivera/dl_yt_vid_or_aud/Mariah Angeliq ＂LA TOXICA＂ Part 2 #ToxicaTips #ToxicaTuesday #lacasadelartista [FOE1oYTeMUs].mp4").resolve()),
+    "Naty Peluso": str(Path("/Users/martinrivera/dl_yt_vid_or_aud/#nathypeluso ganó 4 Latin Grammys con vestido vintage [dOVldgGVsmI].mp4").resolve()),
+    "Nicki Nicole": str(Path("/Users/martinrivera/tiktok/nicki.nicole_7302167478241676549.mp4").resolve()),
+    "Paloma Mami": str(Path("/Users/martinrivera/dl_yt_vid_or_aud/Paloma_Mami_Interview_Trimmed.mp4").resolve()),
+    "Young Miko": str(Path("/Users/martinrivera/dl_yt_vid_or_aud/WASSUP 🫶🏼🫶🏼🫶🏼 [irbZzi3qmqY].mp4").resolve())
+}
+
+# Verify voice files exist
+for name, path in VOICE_OPTIONS.items():
+    if path and not Path(path).exists():
+        logger.warning(f"Voice file {name} not found at {path}")
+
+
+class TwoLinkArm:
+	def __init__(self, joint_angles=[0,0]):
+		self.shoulder = np.array([0, 0])
+		self.link_lengths = [1, 1]
+		self.update_joints(joint_angles)
+
+	def update_joints(self, joint_angles):
+		self.joint_angles = joint_angles 
+		self.forward_kinematics()
+
+	def forward_kinematics(self):
+		theta0 = self.joint_angles[0]
+		theta1 = self.joint_angles[1]
+		l0 = self.link_lengths[0]
+		l1 = self.link_lengths[1]
+
+		self.elbow = self.shoulder + np.array([l0*np.cos(theta0),l0*np.sin(theta0)]) # Elbow_x = l0cos(theta0) # Elbow_y = l0sin(theta0)
+		self.wrist = self.elbow + np.array([l1*np.cos(theta0 + theta1), l1*np.sin(theta0 + theta1)]) # Wrist_x = Elbow_x + l1cos(theta0 + theta1) # Wrist_y = Elbow_y + l1sin(theta0 + theta1) # Wrist_x - Elbow_x = l1cos(theta0 + theta1) # Wrist_y - Elbow_y = l1sin(theta0 + theta1)
+
+
+	def get_plotly_figure(self):
+		fig = go.Figure()
+
+		fig.add_trace(go.Scatter(
+			x=[self.shoulder[0], self.elbow[0], self.wrist[0]], # x-coordinates for shoulder, elbow, and wrist
+			y=[self.shoulder[1], self.elbow[1], self.wrist[1]], # y-coordinates for shoulder, elbow, and wrist
+			mode='lines+markers',
+			line=dict(color='red', width=10),
+			marker=dict(size=12, color=['black', 'blue', 'green']),
+			name='Arm'
+		))
+
+		max_range = 2.2 
+		fig.update_xaxes(range=[-max_range, max_range])
+		fig.update_yaxes(range=[-max_range, max_range])
+
+		annotations = [
+		    dict(x=self.shoulder[0], y=self.shoulder[1], text="Shoulder", showarrow=True), # Shoulder (x,y) coordinates
+		    dict(x=self.elbow[0], y=self.elbow[1], text="Elbow", showarrow=True), # Elbow (x,y) coordinates 
+		    dict(x=self.wrist[0], y=self.wrist[1], text="Wrist", showarrow=True)  # Wrist (x,y) coordinates 
+		]
+
+		fig.update_layout(
+			title='Two-Link Robotic Arm Visualization',
+			xaxis_title='X Position',
+			yaxis_title='Y Position',
+			showlegend=False,
+			height=500,
+			width=500,
+			margin=dict(l=20, r=20, t=40, b=20),
+			annotations=annotations
+		)
+
+		fig.update_yaxes(scaleanchor="x", scaleratio=1)
+
+		return fig 
+
+def calculate_angles(theta0_deg, theta1_deg):
+    theta0 = math.radians(theta0_deg)
+    theta1 = math.radians(theta1_deg)
+    
+    delta_x = math.cos(theta0) * math.cos(theta1) - math.sin(theta0) * math.sin(theta1)
+    delta_y = math.sin(theta0) * math.cos(theta1) + math.cos(theta0) * math.sin(theta1)
+    
+    calculated_angle_rad = math.atan2(delta_y, delta_x)
+    calculated_angle_deg = math.degrees(calculated_angle_rad)
+
+    theta0_validation_deg = calculated_angle_deg - theta1_deg 
+    theta0_validation_deg = theta0_validation_deg % 360
+    
+    theta1_validation_deg = calculated_angle_deg - theta0_deg
+    theta1_validation_deg = theta1_validation_deg % 360
+    
+    elbow_x = math.cos(theta0)
+    elbow_y = math.sin(theta0)
+    
+    wrist_x = elbow_x + math.cos(theta0 + theta1)
+    wrist_y = elbow_y + math.sin(theta0 + theta1)
+    
+    wrist_elbow_dx = wrist_x - elbow_x
+    wrist_elbow_dy = wrist_y - elbow_y
+    
+    return (
+        delta_x, delta_y,
+        calculated_angle_deg,
+        theta0_validation_deg,
+        theta1_validation_deg,
+        elbow_x, elbow_y,
+        wrist_x, wrist_y,
+        wrist_elbow_dx, wrist_elbow_dy
+    )
+
+
+def clean_llm_response(text: str) -> str:
+	"""Clean up LLM response to be more concise"""
+	text = re.sub(r'(?i)(wait|okay|let me|i think|i need to|this answer is).*?(?=[A-Z])', '', text)
+	sentences = [s.strip() for s in re.split(r'[.!?]', text) if s.strip()]
+	return '. '.join(sentences[:3]) + ('.' if len(sentences) >= 3 else '')
+
+# Load the LLM model once when the app starts 
+llm_config = GenerationConfig()
+llm_config.max_tokens = 150
+llm_config.temperature = 0.3  
+model_data = load_model_with_config("HuggingFaceTB/SmolLM3-3B")
+llm_model, llm_tokenizer = model_data["model"], model_data["tokenizer"]
+
+def get_llm_insight(theta0_deg, theta1_deg, voice_option=None):
+	prompt = f"""Proporciona una explicación concisa (2-3 oraciones) de un brazo robótico de dos eslabones con:
+	- Ángulo de hombro (θ₀) = {theta0_deg}°
+	- Ángulo de codo (θ₁) = {theta1_deg}°
+
+	Incluye:
+	1. La configuración resultante 
+	2. Una aplicación práctica
+	3. La relación matemática clave
+
+	Responde solo con la explicación en español, sin prefijos ni comentarios."""
+	# Generación de texto con SmolLM3-3B
+	result = generate_text(prompt, llm_model, llm_tokenizer, llm_config)
+	clean_text = clean_llm_response(result['generated_text'])
+
+
+	# Generación de audio con TTS
+	audio_prompt_path = VOICE_OPTIONS.get(voice_option, DEFAULT_VOICE)
+
+	audio = tts_model.generate(
+		text=clean_text,
+		audio_prompt_path=audio_prompt_path,
+		exaggeration=0.25,
+		cfg_weight=0.8
+	)
+
+	# Save the audio to a temporary file 
+	temp_audio_path = "temp_llm_response.wav"
+	ta.save(temp_audio_path, audio, tts_model.sr)
+
+	return clean_text, temp_audio_path 
+
+	#return {
+	    #'text_response': clean_text,
+	    #'audio_response': audio,
+	    #'angles': (theta0_deg, theta1_deg)
+	#}
+
+def process_lipsync(visual_file, audio_file):
+	device = "cpu" # Using CPU for lipsync for compatibility
+	logger.info(f"Using device: {device}")
+
+	# Create output directory if it does not exist
+	os.makedirs('static', exist_ok=True)
+
+	# Generate unique output filename 
+	timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+	output_path = f'static/output_{timestamp}.mp4'
+
+	try: 
+		lip = LipSync(
+			model='wav2lip',
+			checkpoint_path='/Users/martinrivera/robotic_arm/lipsync/weights/wav2lip_gan.pth',
+			nosmooth=True,
+			device='cpu',
+			cache_dir='/Users/martinrivera/robotic_arm/lipsync/cache',
+			img_size=96,
+			save_cache=True
+		)
+
+		logger.info("Starting lip sync process...")
+
+		# Process based on file type 
+		if visual_file is None or audio_file is None:
+			raise ValueError("Both visual and audio files are required")
+
+		lip.sync(
+			visual_file.name, # Path to uploaded visual file
+			audio_file.name, # Path to uploaded audio file 
+			output_path
+		)
+		logger.info("Lip sync completed successfully!")
+
+		return output_path 
+
+	except Exception as e:
+		logger.error(f"Error during lip sync: {str(e)}", exc_info=True)
+		raise gr.Error(f"Lip sync failed: {str(e)}")
+
+def update_components(theta0_deg, theta1_deg, voice_option):
+    theta0_rad = math.radians(float(theta0_deg))
+    theta1_rad = math.radians(float(theta1_deg))
+    
+    arm = TwoLinkArm([theta0_rad, theta1_rad])
+    fig = arm.get_plotly_figure()
+    
+    (
+        delta_x, delta_y,
+        calculated_angle_deg,
+        theta0_validation_deg, 
+        theta1_validation_deg,
+        elbow_x, elbow_y,
+        wrist_x, wrist_y,
+        wrist_elbow_dx, wrist_elbow_dy
+    ) = calculate_angles(float(theta0_deg), float(theta1_deg))
+    
+    results = [
+        f"{delta_x:.4f}",
+        f"{delta_y:.4f}",
+        f"{calculated_angle_deg:.1f}°",
+        f"{theta0_validation_deg:.1f}°",
+        f"{theta1_validation_deg:.1f}°",
+        f"{elbow_x:.4f}",
+        f"{elbow_y:.4f}",
+        f"{wrist_x:.4f}",
+        f"{wrist_y:.4f}",
+        f"{wrist_elbow_dx:.4f} (Expected: {math.cos(math.radians(float(theta0_deg)) + float(theta1_rad)):.4f})",
+        f"{wrist_elbow_dy:.4f} (Expected: {math.sin(math.radians(float(theta0_deg)) + float(theta1_rad)):.4f})",
+    ]
+    
+    # Get LLM insight and audio
+    llm_response, audio_path = get_llm_insight(float(theta0_deg), float(theta1_deg), voice_option)
+    
+    return [fig] + results + [llm_response, audio_path, gr.Row(visible=True)]
+
+theta_options = [(str(i) + "°", i) for i in range(0, 361)]
+
+with gr.Blocks() as app:
+    gr.Markdown("""
+    # Robotic Arm Angle Calculator with LLM Insights
+    ### Equations:
+    1. **cos(θ₀ + θ₁) = cosθ₀cosθ₁ - sinθ₀sinθ₁** → Delta X
+    2. **sin(θ₀ + θ₁) = sinθ₀cosθ₁ + cosθ₀sinθ₁** → Delta Y
+    3. **θ₀ + θ₁ = arctan2(ΔY, ΔX)** → Validates θ₁
+    4-7. **Elbow/Wrist positions** (assuming l₀ = l₁ = 1)
+    """)
+
+    with gr.Row():
+        theta0_dropdown = gr.Dropdown(
+            choices=theta_options,
+            value="45",
+            label="θ₀ (Shoulder Angle)",
+            interactive=True,
+            allow_custom_value=True
+        )
+        theta1_dropdown = gr.Dropdown(
+            choices=theta_options,
+            value="60",
+            label="θ₁ (Elbow Angle)",
+            interactive=True,
+            allow_custom_value=True
+        )
+        voice_dropdown = gr.Dropdown(
+            choices=list(VOICE_OPTIONS.keys()),
+            value="Default Voice",
+            label="Select Voice",
+            interactive=True
+        )
+    
+    calculate_btn = gr.Button("Calculate", variant="primary")
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            gr.Markdown("### Arm Visualization")
+            plot = gr.Plot(label="Arm Position")
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### Delta Values")
+            delta_x = gr.Textbox(label="ΔX (cos(θ₀+θ₁))")
+            delta_y = gr.Textbox(label="ΔY (sin(θ₀+θ₁))")
+            calculated_angle = gr.Textbox(label="θ₀ + θ₁")
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### Joint Positions")
+            elbow_x = gr.Textbox(label="Elbow X (cosθ₀)")
+            elbow_y = gr.Textbox(label="Elbow Y (sinθ₀)")
+            wrist_x = gr.Textbox(label="Wrist X")
+            wrist_y = gr.Textbox(label="Wrist Y")
+            wrist_elbow_dx = gr.Textbox(label="Wrist-Elbow ΔX")
+            wrist_elbow_dy = gr.Textbox(label="Wrist-Elbow ΔY")
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### Validation")
+            theta0_validation = gr.Textbox(label="Validated θ₀")
+            theta1_validation = gr.Textbox(label="Validated θ₁")
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### LLM Explanation")
+            llm_output = gr.Textbox(label="Arm Configuration Analysis", lines=3)
+            audio_output = gr.Audio(label="Audio Explanation", type="filepath", visible=True)
+    
+    # This row will be hidden initially and shown after calculations
+    with gr.Row(visible=False) as lipsync_row:
+        with gr.Column():
+            gr.Markdown("### Lip Sync Options")
+            lipsync_choice = gr.Radio(
+                choices=["Yes", "No"],
+                label="Would you like to create a lip-synced video of the explanation?",
+                value="No"
+            )
+            with gr.Column(visible=False) as lipsync_inputs:
+                visual_input = gr.File(label="Upload Visual File (.jpg or .mp4)", file_types=[".jpg", ".jpeg", ".mp4"])
+                audio_input = gr.File(label="Upload Audio File (.wav)", file_types=[".wav"])
+                lipsync_btn = gr.Button("Generate Lip Sync", variant="primary")
+            lipsync_output = gr.Video(label="Lip Synced Output", height=512, width=512)
+            lipsync_message = gr.Textbox(label="Message", visible=False)
+    
+    # Main calculation button
+    calculate_btn.click(
+        fn=update_components,
+        inputs=[theta0_dropdown, theta1_dropdown, voice_dropdown],
+        outputs=[
+            plot,
+            delta_x, delta_y,
+            calculated_angle,
+            theta0_validation,
+            theta1_validation,
+            elbow_x, elbow_y,
+            wrist_x, wrist_y,
+            wrist_elbow_dx, wrist_elbow_dy,
+            llm_output,
+            audio_output,
+            lipsync_row
+        ]
+    )
+    
+    # Show/hide lipsync inputs based on choice
+    def toggle_lipsync_inputs(choice):
+        if choice == "Yes":
+            return gr.Column(visible=True), gr.Textbox(visible=False), gr.Video(visible=False)
+        return gr.Column(visible=False), gr.Textbox(visible=False), gr.Video(visible=False)
+    
+    lipsync_choice.change(
+        fn=toggle_lipsync_inputs,
+        inputs=lipsync_choice,
+        outputs=[lipsync_inputs, lipsync_message, lipsync_output]
+    )
+    
+    # Handle lipsync generation
+    def handle_lipsync(choice, visual_file, audio_file):
+        if choice == "No":
+            return gr.Textbox(value="Continue playing with your robotic arm!", visible=True), gr.Video(visible=False)
+        else:
+            try:
+                output_path = process_lipsync(visual_file, audio_file)
+                return gr.Textbox(visible=False), gr.Video(value=output_path, visible=True)
+            except Exception as e:
+                return gr.Textbox(value=f"Error: {str(e)}", visible=True), gr.Video(visible=False)
+    
+    lipsync_btn.click(
+        fn=handle_lipsync,
+        inputs=[lipsync_choice, visual_input, audio_input],
+        outputs=[lipsync_message, lipsync_output]
+    )
+
+app.launch()

Gradio App Ver 1/install.sh

@@ -0,0 +1,116 @@
+#!/bin/bash
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+# Ensure Python 3.10 is available
+install_python3_10() {
+    if ! command -v python3.10 &> /dev/null; then
+        echo "Python 3.10 not found. Attempting to install..."
+        if [[ "$OSTYPE" == "darwin"* ]]; then
+            brew install [email protected]
+        elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+            sudo apt-get update
+            sudo apt-get install -y python3.10 python3.10-venv
+        else
+            echo "Unsupported OS. Please install Python 3.10 manually."
+            exit 1
+        fi
+    fi
+}
+install_python3_10
+
+# Create both environments with Python 3.10
+echo "Setting up Python environments..."
+python3.10 -m venv "$SCRIPT_DIR/env"
+python3.10 -m venv "$SCRIPT_DIR/lipsync_env"
+
+# Install system dependencies
+echo "Installing system dependencies..."
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    if ! command -v brew &> /dev/null; then
+        echo "Installing Homebrew..."
+        /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+    fi
+    brew install ffmpeg
+elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+    sudo apt-get update && sudo apt-get install -y ffmpeg
+fi
+
+# Modified safe_install function
+safe_install() {
+    local env_path="$1"
+    local requirements_file="$2"
+    
+    echo "Installing packages in $env_path from $requirements_file..."
+    source "$env_path/bin/activate"
+    
+    pip install --upgrade pip
+    
+    # Install critical packages with exact versions
+    pip install \
+        torch==2.7.1 \
+        transformers==4.53.1 \
+        tokenizers==0.21.2 \
+        gradio==5.36.2 \
+        numpy==2.2.6 \
+        plotly==5.18.0 \
+        mlx==0.26.3 \
+        mlx-lm==0.26.0
+    
+    # Install other requirements (excluding already installed packages)
+    local temp_file
+    temp_file=$(mktemp)
+    trap "rm -f '$temp_file'" EXIT
+    
+    grep -v -E "^(torch|transformers|tokenizers|gradio|mlx|mlx-lm|numpy|plotly)" \
+        "$SCRIPT_DIR/$requirements_file" > "$temp_file"
+        
+    if [ -s "$temp_file" ]; then
+        pip install -r "$temp_file"
+    fi
+    
+    # Special case for lipsync_env
+    if [[ "$env_path" == *"lipsync_env"* ]]; then
+        pip install av==14.4.0 opencv-python==4.12.0.88
+    fi
+    
+    deactivate
+}
+
+# Install packages
+safe_install "$SCRIPT_DIR/env" "installed_packages_env.txt"
+safe_install "$SCRIPT_DIR/lipsync_env" "installed_packages_lipsync_env.txt"
+
+# Clone and install Chatterbox
+echo "Installing Chatterbox TTS..."
+if [ ! -d "$SCRIPT_DIR/chatterbox" ]; then
+    git clone https://github.com/resemble-ai/chatterbox.git "$SCRIPT_DIR/chatterbox"
+fi
+cd "$SCRIPT_DIR/chatterbox" || exit
+"$SCRIPT_DIR/env/bin/pip" install -e .
+cd "$SCRIPT_DIR" || exit
+
+# Clone and install LipSync
+echo "Installing LipSync..."
+if [ ! -d "$SCRIPT_DIR/lipsync" ]; then
+    git clone https://github.com/mowshon/lipsync.git "$SCRIPT_DIR/lipsync"
+fi
+cd "$SCRIPT_DIR/lipsync" || exit
+"$SCRIPT_DIR/lipsync_env/bin/pip" install -e .
+cd "$SCRIPT_DIR" || exit
+
+# Download Wav2Lip model weights
+echo "Downloading Wav2Lip model weights..."
+mkdir -p "$SCRIPT_DIR/lipsync/weights"
+if ! command -v wget &> /dev/null; then
+    curl -L https://github.com/mowshon/lipsync/releases/download/v0.1.0/wav2lip_gan.pth -o "$SCRIPT_DIR/lipsync/weights/wav2lip_gan.pth"
+else
+    wget https://github.com/mowshon/lipsync/releases/download/v0.1.0/wav2lip_gan.pth -O "$SCRIPT_DIR/lipsync/weights/wav2lip_gan.pth"
+fi
+
+# Create cache directory for lipsync
+mkdir -p "$SCRIPT_DIR/lipsync/cache"
+
+echo "Installation complete!"
+echo "To use the main environment: source $SCRIPT_DIR/env/bin/activate"
+echo "To use the lipsync environment: source $SCRIPT_DIR/lipsync_env/bin/activate"

Gradio App Ver 1/installed_packages_env.txt

@@ -0,0 +1,59 @@
+audioread==3.0.1
+certifi==2025.7.9
+cffi==1.17.1
+cfgv==3.4.0
+charset-normalizer==3.4.2
+-e git+https://github.com/resemble-ai/chatterbox.git@eb90621fa748f341a5b768aed0c0c12fc561894b#egg=chatterbox_tts
+conformer==0.3.2
+decorator==5.2.1
+diffusers==0.29.0
+distlib==0.3.9
+einops==0.8.1
+filelock==3.18.0
+fsspec==2025.5.1
+hf-xet==1.1.5
+huggingface-hub==0.33.4
+identify==2.6.12
+idna==3.10
+importlib_metadata==8.7.0
+Jinja2==3.1.6
+joblib==1.5.1
+lazy_loader==0.4
+librosa==0.11.0
+llvmlite==0.43.0
+MarkupSafe==3.0.2
+mpmath==1.3.0
+msgpack==1.1.1
+networkx==3.2.1
+nodeenv==1.9.1
+numba==0.60.0
+numpy==2.0.2
+onnx==1.18.0
+packaging==25.0
+pillow==11.3.0
+platformdirs==4.3.8
+pooch==1.8.2
+pre_commit==4.2.0
+protobuf==6.31.1
+pycparser==2.22
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.32.4
+resemble-perth==1.0.1
+s3tokenizer==0.2.0
+safetensors==0.5.3
+scikit-learn==1.6.1
+scipy==1.13.1
+soundfile==0.13.1
+soxr==0.5.0.post1
+sympy==1.13.1
+threadpoolctl==3.6.0
+tokenizers==0.20.3
+torch==2.6.0
+torchaudio==2.6.0
+tqdm==4.67.1
+transformers==4.46.3
+typing_extensions==4.14.1
+urllib3==2.5.0
+virtualenv==20.31.2
+zipp==3.23.0

Gradio App Ver 1/installed_packages_lipsync_env.txt

@@ -0,0 +1,91 @@
+aiofiles==24.1.0
+annotated-types==0.7.0
+anyio==4.9.0
+audioread==3.0.1
+av==14.4.0
+Brotli==1.1.0
+certifi==2025.7.9
+cffi==1.17.1
+charset-normalizer==3.4.2
+click==8.2.1
+decorator==5.2.1
+exceptiongroup==1.3.0
+face-alignment==1.4.1
+fastapi==0.116.1
+ffmpy==0.6.0
+filelock==3.18.0
+fsspec==2025.5.1
+gradio==5.36.2
+gradio_client==1.10.4
+groovy==0.1.2
+h11==0.16.0
+hf-xet==1.1.5
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.33.4
+idna==3.10
+imageio==2.37.0
+Jinja2==3.1.6
+joblib==1.5.1
+lazy_loader==0.4
+librosa==0.10.2.post1
+-e git+https://github.com/mowshon/lipsync.git@d437451cb02375c165b708b199184f1aa90db5d3#egg=lipsync
+llvmlite==0.44.0
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+mdurl==0.1.2
+mlx==0.26.3
+mlx-lm==0.26.0
+mpmath==1.3.0
+msgpack==1.1.1
+networkx==3.4.2
+numba==0.61.2
+numpy==2.2.6
+opencv-python==4.12.0.88
+orjson==3.10.18
+packaging==25.0
+pandas==2.3.1
+pillow==11.3.0
+platformdirs==4.3.8
+pooch==1.8.2
+protobuf==6.31.1
+pycparser==2.22
+pydantic==2.11.7
+pydantic_core==2.33.2
+pydub==0.25.1
+Pygments==2.19.2
+python-dateutil==2.9.0.post0
+python-multipart==0.0.20
+pytz==2025.2
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.32.4
+rich==14.0.0
+ruff==0.12.3
+safehttpx==0.1.6
+safetensors==0.5.3
+scikit-image==0.25.2
+scikit-learn==1.7.0
+scipy==1.15.3
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+soundfile==0.13.1
+soxr==0.5.0.post1
+starlette==0.47.1
+sympy==1.14.0
+threadpoolctl==3.6.0
+tifffile==2025.5.10
+tokenizers==0.21.2
+tomlkit==0.13.3
+torch==2.7.1
+tqdm==4.67.1
+transformers==4.53.1
+typer==0.16.0
+typing-inspection==0.4.1
+typing_extensions==4.14.1
+tzdata==2025.2
+urllib3==2.5.0
+uvicorn==0.35.0
+websockets==15.0.1

Gradio App Ver 1/smolLM3.py

@@ -0,0 +1,112 @@
+import os
+from mlx_lm import load, generate
+import time
+import mlx.core as mx
+from mlx.utils import tree_unflatten, tree_flatten
+from typing import Any
+import importlib.metadata  # Modern replacement for pkg_resources
+
+# Configuration
+MODEL_NAME = "HuggingFaceTB/SmolLM3-3B" 
+DTYPE = mx.float16
+
+class GenerationConfig:
+    def __init__(self):
+        self.max_tokens = 150  # Conservative for 3B model
+        self.seed = 42
+
+def load_model_with_config(model_name: str) -> dict:
+    """Load model with configuration options."""
+    start_time = time.time()
+    
+    print(f"\nLoading model {model_name}...")
+    model, tokenizer = load(model_name)
+    
+    # Convert model parameters to specified dtype
+    model.update(tree_unflatten([
+        (k, v.astype(DTYPE)) for k, v in tree_flatten(model.parameters())
+    ]))
+    
+    load_time = time.time() - start_time
+    print(f"\nModel Information:")
+    print(f"- Load time: {load_time:.2f} seconds")
+    print(f"- Device: {'GPU' if mx.metal.is_available() else 'CPU'}")
+    print(f"- Precision: {DTYPE}")
+    print(f"- Vocab size: {tokenizer.vocab_size:,}")
+    
+    return {"model": model, "tokenizer": tokenizer}
+
+def generate_text(
+    prompt: str,
+    model: Any,
+    tokenizer: Any,
+    config: GenerationConfig
+) -> dict:
+    """Generate text with basic controls"""
+    try:
+        if config.seed is not None:
+            mx.random.seed(config.seed)
+        
+        start_time = time.time()
+        
+        response = generate(
+            model=model,
+            tokenizer=tokenizer,
+            prompt=prompt,
+            max_tokens=config.max_tokens,
+            verbose=False 
+        )
+        
+        generation_time = time.time() - start_time
+        num_tokens = len(tokenizer.encode(response))
+        tokens_per_sec = num_tokens / generation_time
+        
+        return {
+            "generated_text": response,
+            "tokens_generated": num_tokens,
+            "generation_time": generation_time,
+            "tokens_per_second": tokens_per_sec
+        }
+    
+    except Exception as e:
+        print(f"\nGeneration error: {str(e)}")
+        raise
+
+def check_versions():
+    """Check package versions using modern importlib"""
+    try:
+        mlx_version = importlib.metadata.version("mlx")
+        mlx_lm_version = importlib.metadata.version("mlx-lm")
+        print(f"\nPackage Versions:")
+        print(f"- MLX: {mlx_version}")
+        print(f"- MLX-LM: {mlx_lm_version}")
+    except Exception as e:
+        print(f"\nVersion check error: {str(e)}")
+
+if __name__ == "__main__":
+    print(f"Metal (GPU) available: {mx.metal.is_available()}")
+    check_versions()
+    
+    try:
+        config = GenerationConfig()
+        model_data = load_model_with_config(MODEL_NAME)
+        model, tokenizer = model_data["model"], model_data["tokenizer"]
+        
+        prompt = "Any famouse historical events happen on July 11th?"        
+        print(f"\nGenerating response with max_tokens={config.max_tokens}...")
+        result = generate_text(prompt, model, tokenizer, config)
+        
+        print("\n=== Generation Results ===")
+        print(f"\nPrompt: {prompt}")
+        print(f"\nGenerated ({result['tokens_generated']} tokens, {result['generation_time']:.2f}s):")
+        print("-" * 50)
+        print(result['generated_text'])
+        print("-" * 50)
+        print(f"\nSpeed: {result['tokens_per_second']:.1f} tokens/second")
+        
+    except Exception as e:
+        print(f"\nError: {str(e)}")
+        print("\nTroubleshooting:")
+        print("- Try reducing max_tokens (currently {config.max_tokens})")
+        print("- Check GPU memory usage (Activity Monitor)")
+        print("- Update packages: pip install --upgrade mlx mlx-lm")

Gradio App Ver 1/wav2lip.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc5b324a04a0e5b150a97422b68b79859e993e1fc1a3b4b87e2fd4a07cfd2e7a
+size 145394162

Gradio App Ver 1/wav2lip_files_in_weights_folder.txt

@@ -0,0 +1,3 @@
+# Place wav2lip.pth inside folder with name weights
+# Place wav2lip_gan.pth inside folder with name weights
+# mkdir cache static source weights

Gradio App Ver 1/wav2lip_gan.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dce91e8d0d533c6b53192ca41bbfe55b0dbb1859d1a29612e5bc61f5aa71c1e5
+size 145396098

tiktok/dl_tiktok.py

@@ -0,0 +1,37 @@
+import argparse
+import yt_dlp
+import os
+
+def download_tiktok(url, download_audio_only=False):
+    try:
+        ydl_opts = {
+            'outtmpl': '%(uploader)s_%(id)s.%(ext)s',
+            'quiet': False,
+        }
+        
+        if download_audio_only:
+            ydl_opts['format'] = 'bestaudio/best'
+            ydl_opts['postprocessors'] = [{
+                'key': 'FFmpegExtractAudio',
+                'preferredcodec': 'mp3',
+            }]
+        
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([url])
+        
+        return True
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Download TikTok videos or audio.')
+    parser.add_argument('url', help='TikTok video URL')
+    parser.add_argument('--audio', action='store_true', help='Download audio only')
+    
+    args = parser.parse_args()
+    
+    if not args.url.startswith('https://www.tiktok.com/'):
+        print("Error: Please provide a valid TikTok URL")
+    else:
+        download_tiktok(args.url, args.audio)

tiktok/dl_tiktok2.py

@@ -0,0 +1,81 @@
+import argparse
+import yt_dlp
+import os
+from pathlib import Path
+
+def download_tiktok(url, download_audio_only=False, output_dir=None):
+    """
+    Download TikTok video or audio using yt-dlp
+    
+    Args:
+        url (str): TikTok video URL
+        download_audio_only (bool): Whether to download only audio
+        output_dir (str): Custom output directory (None for current directory)
+    """
+    try:
+        # Set output template
+        output_template = os.path.join(output_dir, '%(uploader)s_%(id)s.%(ext)s') if output_dir else '%(uploader)s_%(id)s.%(ext)s'
+        
+        ydl_opts = {
+            'outtmpl': output_template,
+            'quiet': False,
+            'no_warnings': False,
+            'ignoreerrors': False,
+            'restrictfilenames': True,
+        }
+        
+        if download_audio_only:
+            ydl_opts.update({
+                'format': 'bestaudio/best',
+                'postprocessors': [{
+                    'key': 'FFmpegExtractAudio',
+                    'preferredcodec': 'mp3',
+                    'preferredquality': '192',
+                }],
+                'extractaudio': True,  # Only keep the audio
+            })
+        else:
+            ydl_opts.update({
+                'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
+                'merge_output_format': 'mp4',
+            })
+        
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info_dict = ydl.extract_info(url, download=True)
+            
+            # Get the actual filename that was saved
+            if download_audio_only:
+                actual_filename = ydl.prepare_filename(info_dict).replace('.webm', '.mp3').replace('.m4a', '.mp3')
+            else:
+                actual_filename = ydl.prepare_filename(info_dict)
+            
+            print(f"\nSuccessfully downloaded: {actual_filename}")
+            return True, actual_filename
+            
+    except yt_dlp.utils.DownloadError as e:
+        print(f"\nDownload Error: {str(e)}")
+        return False, None
+    except Exception as e:
+        print(f"\nUnexpected Error: {str(e)}")
+        return False, None
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Download TikTok videos or audio using yt-dlp (most reliable method)')
+    parser.add_argument('url', help='TikTok video URL')
+    parser.add_argument('--audio', action='store_true', help='Download audio only (MP3 format)')
+    parser.add_argument('--output', '-o', help='Custom output directory (default: current directory)')
+    
+    args = parser.parse_args()
+    
+    if not args.url.startswith(('https://www.tiktok.com/', 'https://tiktok.com/')):
+        print("Error: Please provide a valid TikTok URL")
+    else:
+        success, filename = download_tiktok(
+            args.url, 
+            download_audio_only=args.audio, 
+            output_dir=args.output
+        )
+        
+        if not success:
+            print("Failed to download the TikTok content")
+            exit(1)

tiktok/requirements.txt

@@ -0,0 +1 @@
+yt-dlp

tiktok/tiktok.txt

@@ -0,0 +1,7 @@
+# Create tiktok directory
+# mkdir tiktok
+# cd tiktok
+# python3.10 -m venv env
+# source env/bin/activate
+# (env) python dl_tiktok2.py "https://www.tiktok.com/@akabadgyal/video/7523743037713911062" 
+# (env) python dl_tiktok2.py "place tik tok address here"