try anbiter way

app.py

@@ -1,82 +1,35 @@
 import torch
 import gradio as gr
-import imageio
-import os
-import requests
-from safetensors.torch import load_file
-from torchvision import transforms
-from PIL import Image
-import numpy as np
-import random
+from diffusers import StableDiffusionPipeline
 
-# Define model URL and local path
-MODEL_URL = "https://huggingface.co/sarthak247/Wan2.1-T2V-1.3B-nf4/resolve/main/diffusion_pytorch_model.safetensors"
-MODEL_FILE = "diffusion_pytorch_model.safetensors"
+# Load model manually from Hugging Face model hub or your uploaded files
+model_path = "sarthak247/Wan2.1-T2V-1.3B-nf4"  # Replace with your model path
+pipe = StableDiffusionPipeline.from_pretrained(model_path, torch_dtype=torch.float16)
+pipe.to("cuda")  # If running on GPU
 
-# Function to download model if not present
-def download_model():
-    if not os.path.exists(MODEL_FILE):
-        print("Downloading model...")
-        response = requests.get(MODEL_URL, stream=True)
-        if response.status_code == 200:
-            with open(MODEL_FILE, "wb") as f:
-                for chunk in response.iter_content(chunk_size=8192):
-                    f.write(chunk)
-            print("Download complete!")
-        else:
-            raise RuntimeError(f"Failed to download model: {response.status_code}")
-
-# Load model weights manually
-device = "cuda" if torch.cuda.is_available() else "cpu"
-print(f"Loading model on {device}...")
-
-try:
-    download_model()
-    model_weights = load_file(MODEL_FILE, device=device)
-    print("Model loaded successfully!")
-except Exception as e:
-    print(f"Error loading model: {e}")
-    model_weights = None
-
-# Function to generate video using the model
 def generate_video(prompt):
     """
-    Generates a video using the model based on the provided text prompt.
+    Generates a video from the provided prompt using the pre-loaded model.
     """
-    if model_weights is None:
-        return "Model failed to load. Please check the logs."
-
-    # Placeholder - actual inference logic should be implemented here
-    # Example of using the model to generate an image from a prompt
-    # For now, we'll create a random color image as a placeholder.
-    
-    # Assuming the model generates an image based on the prompt (modify with actual logic)
-    width, height = 512, 512
-    img = Image.new("RGB", (width, height), 
-                    color=(random.randint(0, 255), 
-                           random.randint(0, 255), 
-                           random.randint(0, 255)))  # Random color
-
-    # Transform the image to a tensor and convert it to a numpy array
-    transform = transforms.ToTensor()
-    frame = (transform(img).permute(1, 2, 0).numpy() * 255).astype(np.uint8)
-
-    # Create a fake video with repeated frames (replace with actual frame generation)
-    frames = [frame] * 16  # 16 repeated frames (replace with actual video frames from the model)
-    output_path = "output.mp4"
-    
-    # Save frames as a video with 8 fps
-    imageio.mimsave(output_path, frames, fps=8)
-
-    return output_path
-
-# Gradio UI
+    try:
+        # Generate video using the model pipeline
+        video = pipe(prompt).videos[0]  # Assuming output is a video tensor
+        
+        # Return the generated video
+        return video
+
+    except Exception as e:
+        print(f"Error during video generation: {e}")
+        return "Error generating video"
+
+# Gradio UI for video generation
 iface = gr.Interface(
     fn=generate_video,
     inputs=gr.Textbox(label="Enter Text Prompt"),
     outputs=gr.Video(label="Generated Video"),
-    title="Wan2.1-T2V-1.3B Video Generation",
-    description="This app loads the model manually and generates text-to-video output."
+    title="Text-to-Video Generation with Wan2.1-T2V",
+    description="This app generates a video based on the text prompt using the Wan2.1-T2V model."
 )
 
+# Launch the Gradio app
 iface.launch()