Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+image.jpg filter=lfs diff=lfs merge=lfs -text
+nova.mp4 filter=lfs diff=lfs merge=lfs -text
+nova2.mp4 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+.env
+.venv
+temp_video.mp4

README.md

@@ -1,12 +1,6 @@
 ---
-title: Persona Chatbot
-emoji: 🐠
-colorFrom: green
-colorTo: gray
-sdk: gradio
-sdk_version: 5.16.0
+title: persona-chatbot
 app_file: app.py
-pinned: false
+sdk: gradio
+sdk_version: 5.15.0
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,410 @@
+import gradio as gr
+import requests
+import os
+from dotenv import load_dotenv
+from PIL import Image
+from io import BytesIO
+import uuid  # Add this import at the top
+import hashlib  # Add this import at the top
+import websockets
+import asyncio
+import json
+import time
+
+TEMP_VIDEO_PATH = "temp_video.mp4"  # Temporary file to save the video
+
+# Load environment variables
+load_dotenv()
+HTTP_HOST = os.getenv('http_host')
+WEBSOCKET_HOST = os.getenv('websocket_host')
+# WEBSOCKET_HOST = "wss://e69rkwy4l4.execute-api.us-east-1.amazonaws.com/prod"
+DEMO_SECRET = os.getenv('x-demo-secret')
+character = ""
+session_id = None  # Add this to track the current session
+
+# Add preset prompts from test.http as examples
+PRESET_IMAGE_PROMPTS = [
+    "A friendly cartoon bear with expressive eyes, front view portrait",
+    "A wise old wizard with a long white beard, looking directly at viewer",
+    "A cheerful robot with glowing blue eyes, head and shoulders portrait",
+    "A mystical elf warrior with pointed ears and silver hair, 3/4 view",
+    "A cute animated fox with orange fur and big eyes, front facing",
+    "A steampunk inventor with brass goggles and wild hair, portrait",
+    "A gentle dragon with iridescent scales, close-up face shot"
+]
+
+PRESET_CHAT_QUESTIONS = [
+    "This character is friendly and playful, always eager to make new friends. They're optimistic and have a warm, welcoming personality.",
+    "This character is wise and patient, known for their thoughtful nature. They have a calm demeanor but can be quite witty when the situation calls for it.",
+    "This character is curious and analytical, always eager to learn new things. Despite their unique nature, they show surprising warmth and empathy.",
+    "This character is noble and protective of others, with plenty of life experience. While reserved at first, they become fiercely loyal to their friends.",
+    "This character is energetic and adventurous, always seeking out new experiences. They have a contagious enthusiasm that brightens any room.",
+    "This character is gentle and nurturing, with a deep connection to those around them. They're known for their patience and understanding nature.",
+    "This character is clever and resourceful, able to think quickly on their feet. They approach problems with creativity and determination.",
+    "This character is mysterious and intriguing, with hidden depths to their personality. They reveal their true nature only to those they trust."
+]
+
+PRESET_ANIMATIONS = [
+    "Casting a spell with glowing magical effects radiating from his fingers. Focus on realistic hand gestures, including opening, closing, and raising hands, with smooth, fluid motion. Subtle head nods add realism, while magical lighting highlights his hands and face, enhancing the mystical atmosphere",
+    "The character waves hello to the viewer",
+    "The character nods thoughtfully",
+    "The character looks around curiously",
+    "The character laughs cheerfully",
+    "The character tilts their head and thinks",
+    "The character gives a friendly greeting",
+    "The character makes a surprised expression"
+]
+
+# WebSocket 연결 상태를 저장할 변수
+ws_connection = None
+
+async def connect_websocket():
+    global ws_connection
+    if not ws_connection:
+        ws_connection = await websockets.connect(WEBSOCKET_HOST)
+    return ws_connection
+
+async def chat_with_model(message, history):
+    global character, session_id, ws_connection
+    
+    try:
+        ws = await connect_websocket()
+        await ws.send(json.dumps({
+            "action": "message",
+            "message": message,
+            "character": character,
+            "session_id": session_id
+        }))
+        
+        # 사용자 메시지를 한 번만 추가
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": ""})
+        current_response = ""
+        
+        while True:
+            response = await ws.recv()
+            data = json.loads(response)
+            
+            if data.get('type') == 'stream':
+                current_response += data['message']
+                # 마지막 메시지의 내용만 업데이트
+                history[-1]["content"] = current_response.strip()
+                yield "", history
+            
+            elif data.get('type') == 'end':
+                yield "", history
+                break
+        
+    except Exception as e:
+        print(f"WebSocket error: {str(e)}")
+        ws_connection = None
+        yield "", history
+
+def make_api_request(endpoint, payload):
+    headers = {
+        'Content-Type': 'application/json',
+        'x-demo-secret': DEMO_SECRET
+    }
+    response = requests.post(f"{HTTP_HOST}/{endpoint}", json=payload, headers=headers)
+    return response.json()
+
+def generate_image(prompt):
+    global session_id, character
+    response = make_api_request("draw", {"prompt": prompt})
+    image_url = response.get('image_url')
+    
+    # Generate session_id based on character description
+    character = prompt  # Store the prompt as character description
+    session_id = hashlib.md5(character.encode()).hexdigest()
+    
+    response = requests.get(image_url)
+    image = Image.open(BytesIO(response.content))
+    return image
+
+def animate_clip(text, image, optimize_prompt):
+    # Convert image to base64 if an image is provided
+    global character
+    animation_prompt = "Generate a video of " + character + ". " + text
+    image_payload = []
+    if image is not None:
+        from base64 import b64encode
+        from io import BytesIO
+        from PIL import Image
+        import numpy as np
+        
+        # Convert numpy array to PIL Image if needed
+        if isinstance(image, np.ndarray):
+            pil_image = Image.fromarray(image)
+        else:
+            pil_image = image
+            
+        # Resize image to 1280x720 maintaining aspect ratio and adding padding if needed
+        target_size = (1280, 720)
+        
+        # Calculate scaling factors
+        width_ratio = target_size[0] / pil_image.width
+        height_ratio = target_size[1] / pil_image.height
+        scaling_factor = min(width_ratio, height_ratio)
+        
+        # Calculate new dimensions
+        new_width = int(pil_image.width * scaling_factor)
+        new_height = int(pil_image.height * scaling_factor)
+        
+        # Resize image
+        resized_image = pil_image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        
+        # Create new image with padding
+        final_image = Image.new('RGB', target_size, (0, 0, 0))  # Black padding
+        paste_x = (target_size[0] - new_width) // 2
+        paste_y = (target_size[1] - new_height) // 2
+        final_image.paste(resized_image, (paste_x, paste_y))
+        
+        # Convert to base64
+        buffer = BytesIO()
+        final_image.save(buffer, format='PNG')
+        base64_image = b64encode(buffer.getvalue()).decode('utf-8')
+        
+        image_payload = [{
+            "format": "png",
+            "source": {
+                "bytes": base64_image
+            }
+        }]
+
+    response = make_api_request("animate", {
+        "text": animation_prompt,
+        "images": image_payload if image is not None else [],
+        "optimize_prompt": optimize_prompt
+    })
+    
+    if 'error' in response:
+        raise gr.Error(response['error'])
+    
+    # Return both the invocation ID and optimized prompt
+    return response.get('invocationId'), response.get('optimized_prompt')
+
+def fetch_animation_status(invocation_id):
+    if not invocation_id:
+        return None
+    
+    status_response = requests.get(
+        f"{HTTP_HOST}/check-clip-status/{invocation_id}",
+        headers={'x-demo-secret': DEMO_SECRET}
+    )
+    result = status_response.json()
+    # If the animation is complete, return the video URL
+    if result.get('status') == 'Completed':
+        return result.get('presignedUrl')
+    return None
+
+def load_chat_history(session_id):
+    """DynamoDB에서 해당 세션의 채팅 기록을 가져옵니다."""
+    try:
+        response = make_api_request("get-history", {
+            "session_id": session_id
+        })
+        return response.get('history', [])
+    except Exception as e:
+        print(f"Error loading chat history: {str(e)}")
+        return []
+
+def update_character_and_load_history(text_value):
+    """캐릭터가 변경될 때 세션 ID를 업데이트하고 채팅 기록을 로드합니다."""
+    global character, session_id
+    if text_value:
+        character = text_value
+        session_id = hashlib.md5(character.encode()).hexdigest()
+        # 채팅 기록 로드
+        history = load_chat_history(session_id)
+        print(history)
+        return history
+    return []
+
+# Create the Gradio interface
+with gr.Blocks(css="""
+    .gradio-container {
+        width: 600px !important;
+        margin: 0 auto !important;
+    }
+    #component-0 {
+        width: 550px !important;
+        margin: 0 auto !important;
+        padding: 20px !important;
+    }
+
+    .contain {
+        width: 550px !important;
+    }
+    /* Add circular mask to the image and remove container borders */
+    .image-container img {
+        border-radius: 50% !important;
+        aspect-ratio: 1 !important;
+        object-fit: cover !important;
+        width: 200px !important;
+        height: 200px !important;
+        display: block !important;
+        margin: 0 auto !important;
+    }
+    .image-container {
+        border: none !important;
+        background: none !important;
+    }
+    /* Remove the dotted upload area */
+    .image-container > div {
+        border: none !important;
+    }
+""") as demo:
+    chat_history = gr.State([])
+    
+    gr.Markdown("<h1 style='text-align: center;'>AnyCompany AI</h1>")
+    
+    # Image Section
+    image_prompt = gr.Textbox(
+        label="Imagine you are a...",
+        placeholder="Describe the image you want to generate..."
+    )
+    image_dropdown = gr.Dropdown(
+        choices=["--- Select a preset prompt or type your own ---"] + PRESET_IMAGE_PROMPTS,
+        label="Or choose from preset prompts",
+        type="value",
+        allow_custom_value=False
+    )
+    image_btn = gr.Button("Show Face")
+    image_output = gr.Image(
+        height=300,
+        container=True,
+        elem_classes=["image-container"]
+    )
+    
+    # Divider
+    gr.Markdown("---")
+    
+    # Chat Section
+    chatbot = gr.Chatbot(label="Chat History", height=400, type="messages")
+    chat_input = gr.Textbox(
+        label="Chat with your character",
+        placeholder="How are you?"
+    )
+    
+    # Divider
+    gr.Markdown("---")
+    
+    # Animation Section
+    animation_prompt = gr.Textbox(
+        label="Enter animation description",
+        placeholder="Describe the animation sequence you want to create..."
+    )
+    animation_dropdown = gr.Dropdown(
+        choices=["--- Select a preset animation or type your own ---"] + PRESET_ANIMATIONS,
+        label="Or choose from preset animations",
+        type="value",
+        allow_custom_value=False
+    )
+    optimize_prompt_checkbox = gr.Checkbox(label="Optimize prompt using AI", value=True)
+    optimized_prompt = gr.Textbox(
+        label="Final Prompt",
+        placeholder="The final version of your prompt to the video generation",
+        interactive=False
+    )
+    animation_status = gr.Textbox(
+        label="Animation ID",
+        placeholder="Not yet requested",
+        interactive=False
+    )
+    animation_output = gr.Video(label="Generated Animation")
+    with gr.Row():
+        animate_btn = gr.Button("Create Animation")
+        check_status_btn = gr.Button("Refresh")
+
+    def generate_image(prompt):
+        response = make_api_request("draw", {"prompt": prompt})
+        # Extract the image URL from the response
+        image_url = response.get('image_url')
+        print(image_url)
+        
+        # Download and convert the image
+        response = requests.get(image_url)
+        image = Image.open(BytesIO(response.content))
+
+        return image
+
+    # Connect image generation to both image output and chat
+    image_btn.click(
+        fn=lambda prompt: (
+            generate_image(prompt),  # 이미지 생성
+            update_character_and_load_history(prompt)  # 채팅 기록 로드
+        ),
+        inputs=[image_prompt],
+        outputs=[image_output, chatbot]  # chatbot output 추가
+    )
+    
+    # Keep the existing chat response handling
+    chat_input.submit(
+        chat_with_model,
+        [chat_input, chatbot],
+        [chat_input, chatbot],
+        show_progress="full"
+    )
+
+    def check_and_update_animation(invocation_id):
+        video_url = fetch_animation_status(invocation_id)
+        if video_url:
+            # Download the video
+            response = requests.get(video_url, stream=True)
+            with open(TEMP_VIDEO_PATH, "wb") as video_file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    video_file.write(chunk)
+
+            # Return status and the local video file path
+            return "Animation completed.", TEMP_VIDEO_PATH
+        else:
+            return invocation_id, None
+
+    animate_btn.click(
+        animate_clip,
+        inputs=[animation_prompt, image_output, optimize_prompt_checkbox],
+        outputs=[animation_status, optimized_prompt]
+    )
+
+    check_status_btn.click(
+        check_and_update_animation,
+        inputs=animation_status,
+        outputs=[animation_status, animation_output]
+    )
+
+    def handle_dropdown_change(dropdown_value):
+        if dropdown_value.startswith("---"):
+            return gr.update(), []
+        history = update_character_and_load_history(dropdown_value)
+        return dropdown_value, history
+
+    image_dropdown.change(
+        handle_dropdown_change,
+        inputs=[image_dropdown],
+        outputs=[image_prompt, chatbot]
+    )
+
+    animation_dropdown.change(
+        update_other_textbox,
+        inputs=[animation_dropdown],
+        outputs=[animation_prompt]
+    )
+
+    # Add new function to handle direct text input
+    def update_character_from_input(text_value):
+        global character, session_id
+        if text_value:
+            character = text_value
+            # Create consistent session_id based on character description
+            session_id = hashlib.md5(character.encode()).hexdigest()
+        return None
+
+    # Add new event handler for direct text input
+    image_prompt.change(
+        update_character_from_input,
+        inputs=[image_prompt],
+        outputs=None
+    )
+
+if __name__ == "__main__":
+    demo.launch()

locustfile.py

@@ -0,0 +1,92 @@
+from locust import HttpUser, task, between
+from dotenv import load_dotenv
+import os
+import hashlib
+import random
+
+load_dotenv()
+HOST = os.getenv('host')
+DEMO_SECRET = os.getenv('x-demo-secret')
+
+
+class APIUser(HttpUser):
+    wait_time = between(1, 3)  # Wait 1-3 seconds between tasks
+    host = HOST
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # You'll need to set these values in your environment
+        self.headers = {
+            "Content-Type": "application/json",
+            "x-demo-secret": DEMO_SECRET
+        }
+
+    @task(2)  # Higher weight for image generation tasks
+    def test_draw_endpoints(self):
+        prompts = [
+            "A friendly cartoon bear with expressive eyes, front view portrait",
+            "A wise old wizard with a long white beard, looking directly at viewer",
+            "A cheerful robot with glowing blue eyes, head and shoulders portrait",
+            "A mystical elf warrior with pointed ears and silver hair, 3/4 view",
+            "A cute animated fox with orange fur and big eyes, front facing",
+            "A steampunk inventor with brass goggles and wild hair, portrait",
+            "A gentle dragon with iridescent scales, close-up face shot",
+            "A ferocious snake with a long, forked tongue, close-up face shot",
+        ]
+        for prompt in prompts:
+            self.client.post("/test-draw", 
+                           json={"prompt": prompt},
+                           headers=self.headers)
+
+    @task(7)
+    def test_chat_endpoints(self):
+        questions = [
+            "Hi",
+            "How are you?",
+            "What is your name?",
+            "What is your favorite color?",
+            "What is your favorite food?",
+            "What is your favorite animal?",
+            "What is your favorite movie?",
+            "What is your favorite book?",
+            "What is your favorite song?",
+        ]
+        
+        characters = [
+            "A friendly cartoon bear with expressive eyes, front view portrait",
+            "A wise old wizard with a long white beard, looking directly at viewer",
+            "A cheerful robot with glowing blue eyes, head and shoulders portrait",
+            "A mystical elf warrior with pointed ears and silver hair, 3/4 view",
+            "A cute animated fox with orange fur and big eyes, front facing",
+            "A steampunk inventor with brass goggles and wild hair, portrait",
+            "A gentle dragon with iridescent scales, close-up face shot",
+            "A ferocious snake with a long, forked tongue, close-up face shot",
+        ]
+        character = random.choice(characters)
+        system_prompt = f"Imagine you are {character}"
+
+        # Generate consistent session ID based on character
+        session_id = f'locust-{hashlib.md5(character.encode()).hexdigest()}'
+        
+        for question in questions:
+            self.client.post("/test-chat",
+                           json={
+                               "system_prompt": system_prompt,
+                               "question": question,
+                               "session_id": session_id
+                           },
+                           headers=self.headers)
+
+    @task(1)  # Lower weight since this is a two-step process
+    def test_animation_flow(self):
+        # Step 1: Start animation
+        response = self.client.post("/test-animate",
+                                  json={"text": "The animated bear looks at the camera and says 'What's up?'"},
+                                  headers=self.headers)
+        
+        # Step 2: Check status (if the first request was successful)
+        if response.status_code == 200:
+            invocation_id = response.json().get("invocationId")
+            if invocation_id:
+                self.client.get(f"/check-clip-status/{invocation_id}",
+                              headers=self.headers) 

nova.mp4

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

nova2.mp4

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

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+requests
+python-dotenv
+locust

test/test.http

@@ -0,0 +1,101 @@
+@host = {{$dotenv host}}
+@x-demo-secret = {{$dotenv x-demo-secret}}
+
+
+### Generate an image with a futuristic cityscape
+POST {{host}}/draw
+Content-Type: application/json
+x-demo-secret: {{x-demo-secret}}
+
+{
+  "prompt": "A futuristic cityscape at sunset with flying cars and glowing skyscrapers"
+}
+
+### Similar prompt
+POST {{host}}/draw
+Content-Type: application/json
+x-demo-secret: {{x-demo-secret}}
+
+{
+  "prompt": "A futuristic city's view at sunset with flying automobiles and glowing buildings"
+}
+
+### Generate a tranquil mountain lake
+POST {{host}}/draw
+Content-Type: application/json
+x-demo-secret: {{x-demo-secret}}
+
+{
+  "prompt": "A tranquil mountain lake surrounded by snow-capped peaks under a clear blue sky"
+}
+
+### Generate a cyberpunk street scene
+POST {{host}}/draw
+Content-Type: application/json
+x-demo-secret: {{x-demo-secret}}
+
+{
+  "prompt": "A cyberpunk street scene at night with neon lights and futuristic vehicles"
+}
+
+### Generate a magical forest
+POST {{host}}/draw
+Content-Type: application/json
+x-demo-secret: {{x-demo-secret}}
+
+{
+  "prompt": "A magical forest with glowing trees and mythical creatures"
+}
+
+### Generate a surreal dreamscape
+POST {{host}}/draw
+Content-Type: application/json
+x-demo-secret: {{x-demo-secret}}
+
+{
+  "prompt": "A surreal dreamscape with floating islands and waterfalls pouring into the sky"
+}
+
+### Generate a medieval castle
+POST {{host}}/draw
+Content-Type: application/json
+x-demo-secret: {{x-demo-secret}}
+
+{
+  "prompt": "A medieval castle with a moat and a drawbridge"
+}
+
+### Chat with model
+POST {{host}}/chat
+Content-Type: application/json
+x-demo-secret: {{x-demo-secret}}
+
+{
+  "question": "Who is the president of the United States?"
+}
+
+
+### Chat with model
+POST {{host}}/chat
+Content-Type: application/json
+x-demo-secret: {{x-demo-secret}}
+
+{
+  "question": "What is the capital of the United States?"
+}
+
+### Animate a clip
+# @name animate
+POST {{host}}/animate
+Content-Type: application/json
+x-demo-secret: {{x-demo-secret}}
+
+{
+  "text": "The animated bear looks at the camera and says 'What's up?'"
+}
+
+### Check clip status
+@invocationId = {{animate.response.body.invocationId}}
+GET {{host}}/check-clip-status/{{invocationId}}
+Content-Type: application/json
+x-demo-secret: {{x-demo-secret}}