Added: Generate image to video

.gitignore

@@ -1 +1,2 @@
-/static
+/static
+/sample-response.json

app.py

@@ -114,9 +114,9 @@ def get_images(ws, workflow, token):
 def home():
     return render_template('home.html')
 
-                ###############################################
-                # Generate text to image using FLUX1.DEV Model#
-                ###############################################
+                ################################################
+                # Generate text to image using FLUX1.DEV Model #
+                ################################################
 
 # Generate image route
 @app.route('/generate_image', methods=['POST'])
@@ -265,14 +265,151 @@ def get_video_data(filename, subfolder, token):
 def image_to_video():
     data = request.json
 
-    time.sleep(900)
-    # Prepare the response with the video URL
-    response_data = {
-            'video_url': 'https://gosign-de-comfyui-stg.hf.space/view?filename=CogVideoX-I2V_00010.mp4',
-            'message': 'Video generated successfully'
-        }
+    # Extract and validate token
+    token = request.headers.get('Authorization')
+    if not token or not token.startswith("Bearer "):
+        return jsonify({'error': 'Valid Bearer token required'}), 400
+    token = token.split(" ")[1]
+
+    # Validate text prompt
+    text_prompt = data.get('text_prompt')
+    if not text_prompt:
+        return jsonify({'error': 'Text prompt is required'}), 400
+
+    # Handle uploaded image or base64 image
+    image_file = request.files.get('image')
+    base64_image = data.get('base64_image')
+
+    image_path = None  # Initialize image path
+
+    try:
+        if image_file:
+            # Check if the file has an allowed extension
+            if not allowed_file(image_file.filename):
+                return jsonify({'error': 'Unsupported image format'}), 400
+
+            # Secure the filename
+            filename = secure_filename(image_file.filename)
+
+            # Generate a unique path for the image
+            unique_filename = f"{uuid.uuid4()}_{filename}"
+            image_path = os.path.join('static', unique_filename)
+
+            # Ensure the 'static' directory exists
+            os.makedirs('static', exist_ok=True)
+
+            # Save the image to the static directory
+            image_file.save(image_path)
+
+            # Construct the public URL to access the image
+            image_url = f"https://gosign-de-comfyui-api.hf.space/{image_path}"
+
+        elif base64_image:
+            # Save base64 image
+            try:
+                image_path, image_url = save_base64_image(base64_image)
+            except Exception as e:
+                raise ValueError(f'Invalid base64 image data: {str(e)}')
+
+        else:
+            return jsonify({'error': 'Image is required (file or base64)'}), 400
 
-    return jsonify(response_data), 200
+        # Load workflow configuration
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        workflow_path = os.path.join(current_dir, 'workflows/cogvideox_image_to_video_workflow_api.json')
+        with open(workflow_path, 'r', encoding='utf-8') as f:
+            workflow = json.load(f)
+
+        # Modify workflow with inputs
+        workflow["30"]["inputs"]["prompt"] = text_prompt
+        workflow["73"]["inputs"]["url"] = image_url
+        workflow["31"]["inputs"]["prompt"] = "Low quality, watermark, strange motion"
+
+        # WebSocket connection to queue the prompt
+        ws = websocket.WebSocket()
+        ws.connect(f"{ws_address}?clientId={client_id}&token={token}",
+                   header={"Authorization": f"Bearer {token}"})
+
+        # Queue the prompt
+        prompt_id = queue_prompt(workflow, token)
+
+        return jsonify({'prompt_id': prompt_id, 'message': 'Prompt queued successfully', 'get_video_url': f'https://gosign-de-comfyui-api.hf.space/get_video/{prompt_id}'}), 202
+
+    except Exception as e:
+        return jsonify({'message': 'Unbale to connect to the server. Make sure the server is running', 'error': str(e)}), 500
+
+    finally:
+        # Always delete the image if it was saved
+        if image_path and os.path.exists(image_path):
+            os.remove(image_path)
+            print(f"Deleted temporary image: {image_path}", flush=True)
+
+# Get video route
+@app.route('/get_video/<prompt_id>', methods=['GET'])
+def get_video(prompt_id):
+    token = request.headers.get('Authorization')
+    if not token or not token.startswith("Bearer "):
+        return jsonify({'error': 'Valid Bearer token required'}), 400
+    token = token.split(" ")[1]
+
+    try:
+
+        # Establish WebSocket connection to fetch real-time status
+        ws = websocket.WebSocket()
+        ws.connect(f"{ws_address}?clientId={client_id}&token={token}",
+                   header={"Authorization": f"Bearer {token}"})
+
+        # Request current status of the specific prompt
+        ws.send(json.dumps({"type": "get_status", "prompt_id": prompt_id}))
+        response = json.loads(ws.recv())
+
+        # Extract the necessary fields for the specific prompt
+        queue_remaining = response.get('data', {}).get('status', {}).get('exec_info', {}).get('queue_remaining', 0)
+
+        # Now proceed to check if the prompt has completed successfully
+        history = get_history(prompt_id, token).get(prompt_id, {})
+
+        if not history:
+            return jsonify({
+                'message': 'Video is being generated.',
+                'status': 'pending',
+                'prompts_in_queue': queue_remaining
+            }), 202
+        video_data = None
+
+        # Extract video or GIF details
+        for node_id, node_output in history.get('outputs', {}).items():
+            if 'gifs' in node_output:
+                video = node_output['gifs'][0]  # Take the first available GIF/video
+                try:
+                    video_data = get_video_data(video['filename'], video['subfolder'], token)
+                    break  # Stop after fetching the first valid video
+                except Exception as e:
+                    print(f"Failed to retrieve video: {str(e)}")
+
+        if not video_data:
+            return jsonify({'error': 'Failed to retrieve video data.'}), 500
+
+        # Save the video locally
+        local_video_path = f"static/generated_image_to_video_{prompt_id}.mp4"
+        with open(local_video_path, 'wb') as f:
+            f.write(video_data)
+
+        # Send the video as an HTTP response
+        return send_file(
+            io.BytesIO(video_data),
+            mimetype='video/mp4',
+            as_attachment=True,
+            download_name='generated_video.mp4'
+        )
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+# Route: Image to Video old
+@app.route('/image_to_video_old', methods=['POST'])
+def image_to_video_old():
+    data = request.json
 
     # Extract and validate token
     token = request.headers.get('Authorization')
@@ -377,7 +514,7 @@ def image_to_video():
             raise ValueError('Failed to generate video')
 
         # Save the video locally
-        local_video_path = f"static/generated_video_{prompt_id}.mp4"
+        local_video_path = f"static/generated_image_to_video_{prompt_id}.mp4"
         with open(local_video_path, 'wb') as f:
             f.write(video_data)
         # Construct the public URL for the video
@@ -410,5 +547,6 @@ def image_to_video():
             os.remove(image_path)
             print(f"Deleted temporary image: {image_path}", flush=True)
 
+
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860, debug=True)  # Removed 'debug=True'
+    app.run(host='0.0.0.0', port=7860, debug=True)

workflows/cogvideox_image_to_video_workflow_api.json

@@ -118,7 +118,7 @@
       "height": 480,
       "width": 720,
       "num_frames": 49,
-      "steps": 50,
+      "steps": 10,
       "cfg": 6,
       "seed": 65334758276105,
       "scheduler": "DPM++",