Upload folder using huggingface_hub

app.py

@@ -1,178 +1,19 @@
+import gradio as gr
+import time
 import os
+
 os.environ["HF_HOME"] = "/tmp/huggingface"
 os.makedirs("/tmp/huggingface", exist_ok=True)
 
-print("INFO: app.py started.")
-
-# Import necessary libraries
-print("INFO: Importing collections...")
-from collections import Counter
-print("INFO: Importing time...")
-import time
-print("INFO: Importing traceback...")
-import traceback
-print("INFO: Importing gradio...")
-import gradio as gr
-print("INFO: Importing transformers.AutoImageProcessor...")
-from transformers import AutoImageProcessor
-print("INFO: Importing transformers.SiglipForImageClassification...")
-from transformers import SiglipForImageClassification
-print("INFO: Importing transformers.image_utils.load_image...")
-from transformers.image_utils import load_image
-print("INFO: Importing PIL.Image...")
-from PIL import Image
-print("INFO: Importing torch...")
-import torch
-print("INFO: Importing cv2...")
-import cv2 # Import cv2 for video frame processing
-
-print("INFO: All libraries imported successfully.")
-
-print("INFO: Loading model and processor.")
-# Load model and processor for Alphabet Sign Language Detection
-model_name = "prithivMLmods/Alphabet-Sign-Language-Detection"
-print(f"INFO: Loading model '{model_name}'...")
-model = SiglipForImageClassification.from_pretrained(model_name)
-processor = AutoImageProcessor.from_pretrained(model_name)
-print("INFO: Model and processor loaded successfully.")
-
-# Define the maximum number of consecutive repetitions allowed for predictions
-MAX_CONSECUTIVE_REPETITIONS = 3
-
-
-def sign_language_classification(video):
-    """
-    Predicts sign language alphabet category for each frame in a video,
-    yields predictions in real-time with repetition handling, and returns a list of unique predicted letters.
-    """
-    print("sign_language_classification function called.") # Debug print to indicate function call
-    if video is None:
-        print("No video provided.") # Debug print if no video input
-        print(f"DEBUG: Yielding 'No video provided.' and '', types: {type('No video provided.')}, {type('')}")
-        yield "No video provided.", "" # Yield empty string for the second output if no video
-        return
-
-    print(f"Video input type: {type(video)}") # Debug print to show video input type
-    print(f"Video value: {video}") # Debug print to show video input value
-
-    predicted_letters = [] # List to store all predicted letters from each frame
-    last_predicted_label = None # Initialize variable to store the last predicted label to handle repetitions
-    consecutive_repetitions = 0 # Initialize counter for consecutive repetitions of the same prediction
-
-    try:
-        print("Starting frame processing loop.") # Debug print to indicate start of frame processing
-        frames = []
-        if isinstance(video, str):
-            # If video is a filepath (e.g., uploaded file), load the video frames using OpenCV
-            cap = cv2.VideoCapture(video)
-            if not cap.isOpened():
-                print(f"DEBUG: Yielding 'Error: Could not open video file.' and '', types: {type('Error: Could not open video file.')}, {type('')}")
-                yield "Error: Could not open video file.", "" # Yield error if video file cannot be opened
-                return
-            while True:
-                ret, frame = cap.read()
-                if not ret: # Break the loop if no more frames are returned
-                    break
-                frames.append(frame) # Append the read frame to the frames list
-            cap.release() # Release the video capture object
-        elif isinstance(video, list):
-             # If video is already a list of frames (e.g., from webcam in some Gradio versions)
-             frames = video
-        else:
-             print(f"DEBUG: Yielding 'Error: Unsupported video input type.' and '', types: {type('Error: Unsupported video input type.')}, {type('')}")
-             yield "Error: Unsupported video input type.", "" # Yield error for unsupported video input types
-             return
-
-
-        for i, frame in enumerate(frames):
-            # print(f"Processing frame {i}") # Debug print - Removed for cleaner output
-
-            # Convert the numpy frame (BGR format from OpenCV) to a PIL Image in RGB format for the model
-            image = Image.fromarray(frame).convert("RGB")
-            # print(f"Frame {i} converted to PIL Image.") # Debug print - Removed for cleaner output
-
-
-            # Process the image frame using the pre-trained processor and model
-            inputs = processor(images=image, return_tensors="pt") # Prepare image for model input
-            # print(f"Frame {i} processed by processor.)" # Debug print - Removed for cleaner output
-
-
-            # Perform inference with the model
-            with torch.no_grad(): # Disable gradient calculation for inference
-                outputs = model(**inputs)
-                logits = outputs.logits # Get the raw output scores (logits)
-                # probs = torch.nn.functional.softmax(logits, dim=1).squeeze().tolist() # Apply softmax to get probabilities and convert to list
-                # print(f"Frame {i} processed by model. Logits shape: {logits.shape}") # Debug print - Removed for cleaner output
-
-
-            # Define the labels mapping model output indices to ASL alphabet letters
-            labels = {
-                "0": "A", "1": "B", "2": "C", "3": "D", "4": "E", "5": "F", "6": "G", "7": "H", "8": "I", "9": "J",
-                "10": "K", "11": "L", "12": "M", "13": "N", "14": "O", "15": "P", "16": "Q", "17": "R", "18": "S", "19": "T",
-                "20": "U", "21": "V", "22": "W", "23": "X", "24": "Y", "25": "Z"
-            }
-            # Get the index of the highest probability directly from logits
-            predicted_label_index = torch.argmax(logits, dim=1).item()
-            predicted_label = labels[str(predicted_label_index)]
-            # print(f"Frame {i} prediction: {predicted_label}") # Debug print - Removed for cleaner output
-
-            predicted_letters.append(predicted_label) # Append predicted letter to the list of all predictions
-
-            # Check for consecutive repetitions and yield only if the rule is met
-            if predicted_label == last_predicted_label:
-                consecutive_repetitions += 1
-            else:
-                consecutive_repetitions = 1 # Reset consecutive count if prediction changes
-
-            # Yield the prediction if it's not a consecutive repetition beyond the limit or if it's the first prediction
-            if consecutive_repetitions > MAX_CONSECUTIVE_REPETITIONS or last_predicted_label is None:
-                 print(f"DEBUG: Yielding predicted_label: {predicted_label}, type: {type(predicted_label)}")
-                 yield predicted_label, "" # Yield real-time prediction and empty string for the second output
-                 last_predicted_label = predicted_label # Update the last predicted label
-
-
-        print("Finished frame processing loop.") # Debug print to indicate end of frame processing
-        # Get unique predicted letters while maintaining order of appearance
-        unique_predicted_letters = list(dict.fromkeys(predicted_letters))
-        final_output = ", ".join(unique_predicted_letters) # Join unique letters into a comma-separated string
-        # Yield the last predicted label (or empty string if none) and the final list of unique letters
-        output1 = last_predicted_label if last_predicted_label is not None else ""
-        output2 = final_output
-        print(f"DEBUG: Final yield outputs - output1: {output1}, type: {type(output1)}; output2: {output2}, type: {type(output2)}")
-        yield output1, output2
-
-    except Exception as e:
-        print(f"Error caught: {e}") # Debug print if an error occurs
-        # Yield error message and traceback information in case of an exception
-        error_message = f"Error processing video: {e}"
-        traceback_info = f"Error processing video: {e}\n{traceback.format_exc()}"
-        print(f"DEBUG: Error yield outputs - error_message: {error_message}, type: {type(error_message)}; traceback_info: {traceback_info}, type: {type(traceback_info)}")
-        yield error_message, traceback_info
+print("INFO: Simple Gradio app starting.")
 
-# Custom CSS for styling (commented out)
-# custom_css = """
-# body {
-#   background-color: #add8e6;
-# }
-# """
+def greet(name):
+    time.sleep(1)
+    return "Hello " + name + "!"
 
-print("INFO: Setting up Gradio interface.")
-# Create Gradio interface with video input and multiple outputs
-iface = gr.Interface(
-    fn=sign_language_classification, # The function to run when the user interacts with the interface
-    inputs=gr.Video(), # Input component: Video, allowing upload or webcam
-    outputs=[
-        gr.Label(label="Real-time Prediction"), # Output component: Label to display the real-time prediction
-        gr.Textbox(label="Unique Predicted Letters") # Output component: Textbox to display the final list of unique predicted letters
-    ],
-    title="ASL Translator", # Title of the Gradio interface
-    description="Upload a video or use your webcam to translate ASL into one of the 26 sign language alphabet categories and see predictions in real-time and a summary list. ASL Words Translator coming soon!", # Description displayed below the title
-    # css=custom_css # Apply custom CSS (commented out)
-)
-print("INFO: Gradio interface created.")
+iface = gr.Interface(fn=greet, inputs="text", outputs="text", title="Minimal Gradio App")
 
-# Launch the Gradio app
 if __name__ == "__main__":
-    print("INFO: Attempting to launch Gradio app.")
+    print("INFO: Attempting to launch simple Gradio app.")
     iface.queue().launch(share=True)
-    print("INFO: Gradio app launch command executed (may not indicate immediate availability).")
+    print("INFO: Simple Gradio app launch command executed.")