Upload 5 files

app.py

@@ -0,0 +1,80 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import cv2
+import numpy as np
+import requests
+import tempfile
+import os
+
+app = FastAPI()
+
+class VideoURLs(BaseModel):
+    urls: list[str]
+
+def download_video(url):
+    try:
+        response = requests.get(url, verify=False)  # Added verify=False
+        response.raise_for_status()
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp_file:
+            tmp_file.write(response.content)
+            return tmp_file.name
+    except requests.RequestException as e:
+        raise Exception(f"Failed to download video from {url}: {str(e)}")
+
+def combine_videos(urls):
+    if not urls:
+        return None
+
+    temp_files = []
+    for url in urls:
+        if url.strip():
+            try:
+                temp_files.append(download_video(url.strip()))
+            except Exception as e:
+                raise HTTPException(status_code=400, detail=str(e))
+
+    if not temp_files:
+        raise HTTPException(status_code=400, detail="No valid videos to combine")
+
+    captures = [cv2.VideoCapture(file) for file in temp_files]
+
+    fps = captures[0].get(cv2.CAP_PROP_FPS)
+    frame_size = (int(captures[0].get(cv2.CAP_PROP_FRAME_WIDTH)),
+                  int(captures[0].get(cv2.CAP_PROP_FRAME_HEIGHT)))
+
+    output_path = 'combined_video.mp4'
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, frame_size)
+
+    for cap in captures:
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            out.write(frame)
+
+    for cap in captures:
+        cap.release()
+    out.release()
+
+    for file in temp_files:
+        os.remove(file)
+
+    return output_path
+
+@app.post("/combine_videos")
+async def process_urls(video_urls: VideoURLs):
+    try:
+        combined_video = combine_videos(video_urls.urls)
+        if combined_video:
+            return {"video_path": combined_video}
+        else:
+            raise HTTPException(status_code=400, detail="Failed to combine videos")
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

check_versions.py

@@ -0,0 +1,20 @@
+import importlib
+import subprocess
+
+def get_package_version(package_name):
+    try:
+        return importlib.import_module(package_name).__version__
+    except ImportError:
+        return "Not installed"
+    except AttributeError:
+        # Some packages might not have __version__ attribute
+        try:
+            return subprocess.check_output([package_name, "--version"]).decode().strip()
+        except:
+            return "Version not found"
+
+packages = ["numpy", "requests", "cv2", "gradio", "vimeo"]
+
+for package in packages:
+    version = get_package_version(package)
+    print(f"{package}: {version}")

main.py

@@ -0,0 +1,49 @@
+import gradio as gr
+import requests
+
+# FastAPI backend URL
+BACKEND_URL = "http://localhost:8000/combine_videos"
+
+def add_url(url_list, new_url):
+    if new_url.strip():
+        url_list.append(new_url.strip())
+    return "\n".join(url_list), ""
+
+def combine_videos(url_list):
+    urls = url_list.split("\n")
+    try:
+        response = requests.post(BACKEND_URL, json={"urls": urls})
+        response.raise_for_status()
+        video_path = response.json()["video_path"]
+        return video_path, gr.update(interactive=True)
+    except requests.RequestException as e:
+        error_message = f"Error: {str(e)}"
+        if response.status_code != 200:
+            error_message += f"\nServer response: {response.text}"
+        return error_message, gr.update(interactive=False)
+
+def download_video(video_path):
+    return video_path if video_path and not video_path.startswith("Error:") else None
+
+with gr.Blocks() as demo:
+    gr.Markdown("# KSL Video Combiner")
+    
+    with gr.Row():
+        url_input = gr.Textbox(label="Enter a video URL")
+        add_button = gr.Button("Add URL")
+    
+    url_list = gr.Textbox(label="Added URLs", lines=5)
+    combine_button = gr.Button("Combine Videos")
+    
+    video_output = gr.Video(label="Combined Video")
+    download_button = gr.Button("Download Video", interactive=False)
+
+    url_list_state = gr.State([])
+
+    add_button.click(add_url, inputs=[url_list_state, url_input], outputs=[url_list, url_input])
+    combine_button.click(combine_videos, inputs=[url_list], outputs=[video_output, download_button])
+    
+    download_button.click(download_video, inputs=[video_output], outputs=[gr.File()])
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,8 @@
+numpy
+requests
+opencv-python-headless
+gradio
+PyVimeo
+fastapi
+pydantic
+uvicorn

testAPIDeployment.py

@@ -0,0 +1,13 @@
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    print('Request for index page received')
+    return templates.TemplateResponse('index.html', {"request": request})
+
+@app.post('/hello', response_class=HTMLResponse)
+async def hello(request: Request, name: str = Form(...)):
+    if name:
+        print('Request for hello page received with name=%s' % name)
+        return templates.TemplateResponse('hello.html', {"request": request, 'name':name})
+    else:
+        print('Request for hello page received with no name or blank name -- redirecting')
+        return RedirectResponse(request.url_for("index"), status_code=status.HTTP_302_FOUND)