initial frontend revamp

Author: aqzhen

backend/routes/clipsterRoutes.py

@@ -115,9 +115,44 @@ async def bulk_upload_media(
 ):
     user_id = request.state.user_id
     print(f"Starting bulk upload for user {user_id}, files: {[f.filename for f in files]}")
+
+    # Check for duplicate file uploads by querying existing videos for the user
+    existing_videos = supabase.table("broll_videos").select("*").eq("user_id", user_id).execute()
+    
+    # Create a dictionary of file_name -> video record for quick lookup
+    existing_videos_map = {video["file_name"]: video for video in existing_videos.data}
+    uploaded_file_names = {file.filename for file in files}
+    
+    # Find duplicate files that are already fully processed (ready and with summary)
+    duplicate_files = []
+    new_files = []
+    
+    for file in files:
+        if file.filename in existing_videos_map:
+            existing_video = existing_videos_map[file.filename]
+            # Check if the video is ready and has a summary (fully processed)
+            if existing_video.get("twelve_labs_task_status") == "ready" and existing_video.get("summary"):
+                duplicate_files.append({
+                    "filename": file.filename,
+                    "video_id": existing_video["id"],
+                    "twelve_labs_task_id": existing_video.get("twelve_labs_task_id"),
+                    "twelve_labs_task_status": existing_video.get("twelve_labs_task_status"),
+                    "is_duplicate": True
+                })
+            else:
+                # If file exists but not fully processed, treat as new file
+                new_files.append(file)
+        else:
+            new_files.append(file)
 
-     
-    # Create a temporary directory to store files
+    # If all files are duplicates and fully processed, return the duplicate info
+    if not new_files and duplicate_files:
+        return {
+            "message": "All files were previously uploaded and processed",
+            "details": duplicate_files
+        }
+    
+    # Create a temporary directory to store files that need processing
     with tempfile.TemporaryDirectory() as temp_dir:
         async def process_single_upload(file: UploadFile):
             try:
@@ -246,29 +281,36 @@ async def process_single_upload(file: UploadFile):
                 return {
                     "filename": file.filename,
                     "twelve_labs_task_id": task.id,
-                    "video_id": insert_result.data[0]["id"]
+                    "video_id": insert_result.data[0]["id"],
+                    "is_duplicate": False
                 }
 
             except Exception as e:
                 print(f"Error processing {file.filename}: {str(e)}")
-                # supabase.table("broll_videos").upsert({
-                #     "twelve_labs_task_status": "failed",
-                #     "id": insert_result.data[0]["id"]
-                # }).execute()
+                supabase.table("broll_videos").upsert({
+                    "twelve_labs_task_status": "failed",
+                    "id": insert_result.data[0]["id"]
+                }).execute()
                 return {
                     "filename": file.filename,
                     "status": "error",
-                    "error": str(e)
+                    "error": str(e),
+                    "is_duplicate": False
                 }
 
         print("Starting concurrent file processing")
-        tasks = [process_single_upload(file) for file in files]
-        results = await asyncio.gather(*tasks)
 
-        print(f"Bulk upload complete. Results: {results}")
+        # Only process new files, not duplicates
+        tasks = [process_single_upload(file) for file in new_files]
+        results = await asyncio.gather(*tasks) if tasks else []
+        
+        # Combine the results with duplicate files
+        all_results = results + duplicate_files
+        
+        print(f"Bulk upload complete. Results: {all_results}")
         return {
-            "message": f"Processed {len(results)} files",
-            "details": results
+            "message": f"Processed {len(all_results)} files ({len(duplicate_files)} already existed)",
+            "details": all_results
         }
 
 

backend/workers/TaskPoller.py

@@ -121,7 +121,6 @@ async def check_pending_tasks(self):
                     if isinstance(result, Exception):
                         logger.error(f"Task check failed: {str(result)}")
 
-            print(f"Results: {results}")
 
         except Exception as e:
             logger.error(f"Error in check_pending_tasks: {str(e)}")
@@ -139,56 +138,51 @@ async def generate_video_summary(self, video: dict) -> dict:
 
             print(f"Generating summary for video {video['twelve_labs_video_id']}")
 
-            # # Generate summary
-            # structured_output = ''' {
-            #     "chapters": [
-            #         {
-            #             "start": int,
-            #             "end": int,
-            #             "summary": str
-            #         }
-            #     ]
-            # }
-            # '''
-            # response = await asyncio.get_event_loop().run_in_executor(
-            #     self.executor,
-            #     # lambda: twelve_labs_client.generate.summarize(
-            #     #     video["twelve_labs_video_id"],
-            #     #     type="highlight",
-            #     #     prompt="Generate chapters for every single scene change. Describe people, objects, and actions in detail. Granularity should be at the level of a single shot. No Chapter should be longer than 10 seconds.",
-            #     #     temperature=0.
-            #     # )
-            #     lambda: twelve_labs_client.generate.text(
-            #         video["twelve_labs_video_id"],
-            #         # For regex patterns, use raw strings to avoid Python interpreting the backslashes
-            #         prompt = 'Generate chapters for every single scene change. Describe people, objects, and actions in detail. Granularity should be at the level of a single shot. Output should be in non-markdown JSON format with the following fields: start, end, summary. Example Output:' + structured_output,
-            #         temperature=0.1,
-            #     )
-            # )
-
-            # print(f"Summary response: {response}")
-
-            # # Check if response contains markdown JSON format
-            # if response.data:
-            #     if isinstance(response.data, str) and "```json" in response.data:
-            #         # If it's markdown JSON format, use the parser
-            #         summary = parse_json_from_markdown(response.data)
-            #     else:
-            #         # If it's direct JSON, parse it directly
-            #         try:
-            #             summary = json.loads(response.data)
-            #         except json.JSONDecodeError as e:
-            #             logger.error(f"Error parsing JSON response for video {video['id']}: {str(e)}")
-            #             summary = None
-            # else:
-            #     summary = None
-
-            summary = supabase.table("broll_videos").select("summary").eq("id", video["id"]).execute()
-            if summary.data:
-                summary = summary.data[0]["summary"]
+            # Generate summary
+            structured_output = ''' {
+                "chapters": [
+                    {
+                        "start": int,
+                        "end": int,
+                        "summary": str
+                    }
+                ]
+            }
+            '''
+            response = await asyncio.get_event_loop().run_in_executor(
+                self.executor,
+                # lambda: twelve_labs_client.generate.summarize(
+                #     video["twelve_labs_video_id"],
+                #     type="highlight",
+                #     prompt="Generate chapters for every single scene change. Describe people, objects, and actions in detail. Granularity should be at the level of a single shot. No Chapter should be longer than 10 seconds.",
+                #     temperature=0.
+                # )
+                lambda: twelve_labs_client.generate.text(
+                    video["twelve_labs_video_id"],
+                    # For regex patterns, use raw strings to avoid Python interpreting the backslashes
+                    prompt = 'Generate chapters for every single scene change. Describe people, objects, and actions in detail. Granularity should be at the level of a single shot. The longest a single chapter should be 10 seconds. Output should be in non-markdown JSON format with the following fields: start, end, summary. Example Output:' + structured_output,
+                    temperature=0.1,
+                )
+            )
+
+            print(f"Summary response: {response}")
+
+            # Check if response contains markdown JSON format
+            if response.data:
+                if isinstance(response.data, str) and "```json" in response.data:
+                    # If it's markdown JSON format, use the parser
+                    summary = parse_json_from_markdown(response.data)
+                else:
+                    # If it's direct JSON, parse it directly
+                    try:
+                        summary = json.loads(response.data)
+                    except json.JSONDecodeError as e:
+                        logger.error(f"Error parsing JSON response for video {video['id']}: {str(e)}")
+                        summary = None
             else:
                 summary = None
 
+
             # TODO: Matching timestamped words from transcriptto chapters in summary
             # append the transcript to the summary in DB
             transcript = await asyncio.get_event_loop().run_in_executor(
@@ -218,16 +212,15 @@ async def generate_video_summary(self, video: dict) -> dict:
 
                     chapter["summary"] += " Spoken Content:" + " ".join(chapter_summary).strip()
 
-            print(f"Summary: {summary}")
 
 
-            # # Update with summary
-            # await asyncio.get_event_loop().run_in_executor(
-            #     self.executor,
-            #     lambda: supabase.table("broll_videos").update({
-            #         "summary": summary
-            #     }).eq("id", video["id"]).execute()
-            # )            
+            # Update with summary
+            await asyncio.get_event_loop().run_in_executor(
+                self.executor,
+                lambda: supabase.table("broll_videos").update({
+                    "summary": summary
+                }).eq("id", video["id"]).execute()
+            )            
 
             # # Upsert vectors to Pinecone if summary was generated successfully
             # if summary and "chapters" in summary and len(summary["chapters"]) > 0:
@@ -265,12 +258,10 @@ async def check_ready_videos_for_summary(self):
                     .execute()
             )
 
-            print(f"Ready Videos: {response}")
 
             if not response.data:
                 return
 
-            print(f"Ready Videos: {response}")
             # Process summaries in chunks to control concurrency
             videos = response.data
             chunk_size = self.max_concurrent_summaries

frontend/package-lock.json

@@ -51,6 +51,7 @@
     "clsx": "^2.1.1",
     "date-fns": "^4.1.0",
     "express": "^4.21.2",
+    "framer-motion": "^12.6.3",
     "lucide-react": "^0.344.0",
     "react": "^18.3.1",
     "react-datepicker": "^8.0.0",

frontend/package.json

@@ -36,7 +36,7 @@ const ProtectedRoute = ({ children }: { children: React.ReactNode }) => {
 const NavigationWrapper = () => {
   const location = useLocation();
   // Don't show navigation on the create page
-  if (location.pathname === "/create") {
+  if (location.pathname === "/create" || location.pathname === "/oneshot") {
     return null;
   }
   return <Navigation />;

frontend/src/App.tsx

@@ -11,7 +11,9 @@ import { http } from "./http-common";
 const API_URL = `/api/clipster`;
 
 interface BulkUploadResponse {
-  message: string;
+  message?: string;
+  error?: boolean;
+  duplicate_file_names?: string[];
   details: {
     filename: string;
     twelve_labs_task_status: "success" | "error";

frontend/src/api/clipster-api.ts

@@ -19,6 +19,7 @@ import {
   DialogClose,
 } from "../../ui/dialog";
 import { useToast } from "../../../hooks/use-toast";
+import { UploadedVideo } from "../../../types/types";
 
 // Helper function to format time
 const formatTime = (seconds: number) => {
@@ -53,27 +54,6 @@ const formatTotalDuration = (seconds: number) => {
 };
 
 // Type definition for uploaded video
-interface UploadedVideo {
-  id: string;
-  name: string;
-  s3Url?: string;
-  twelveLabsId?: string;
-  twelveLabsTaskId?: string;
-  status:
-    | "uploading"
-    | "pending"
-    | "processing"
-    | "ready"
-    | "error"
-    | "failed"
-    | "indexing";
-  errorMessage?: string;
-  summary?: any;
-  summaryStarted?: boolean;
-  duration?: number;
-  thumbnail?: string;
-  progress?: number;
-}
 
 interface BRollLibraryProps {
   onMediaUpload: (url: string, type: string) => void;