captions

create_captions.py

@@ -0,0 +1,111 @@
+import ffmpeg
+import sys
+import re
+import subprocess
+import os
+
+
+
+def time_to_float(time_str):
+    # Split the time string into minutes, seconds, and milliseconds
+    minutes, seconds = time_str.split(':')
+    seconds, milliseconds = seconds.split('.')
+    
+    # Convert to float (total seconds)
+    return float(minutes) * 60 + float(seconds) + float(milliseconds) / 1000
+
+
+def create_caps(steps):
+    captions=[]
+    video_start=0
+    for step in steps:
+        print(step)
+        start=time_to_float(step['start'])
+        end= time_to_float(step['end'])
+        description_sentences=step['description'].split(".")
+
+        print(description_sentences)
+
+        interval=end/len(description_sentences)
+        start_interval=video_start
+
+        for description_sentence in description_sentences:
+            caption=(start_interval,start_interval+interval,description_sentence)
+            start_interval+=interval
+            captions.append(caption)
+        video_start+=end
+    
+    return captions
+
+
+
+
+def create_srt(subtitles, output_file):
+    with open(output_file, 'w', encoding='utf-8') as f:
+        for i, (start, end, text) in enumerate(subtitles, 1):
+            start_time = f"{int(start//3600):02d}:{int((start%3600)//60):02d}:{int(start%60):02d},{int((start%1)*1000):03d}"
+            end_time = f"{int(end//3600):02d}:{int((end%3600)//60):02d}:{int(end%60):02d},{int((end%1)*1000):03d}"
+            f.write(f"{i}\n{start_time} --> {end_time}\n{text}\n\n")
+
+
+
+def add_captions_to_video(input_video,soft_subtitle, subtitles,output_video="output_video_subtitles.mp4",subtitle_language="en"):
+    subtitle_file="subtitles.srt"
+    create_srt(subtitles,subtitle_file)
+
+    video_input_stream = ffmpeg.input(input_video)
+    subtitle_input_stream = ffmpeg.input(subtitle_file)
+    output_video = output_video
+    subtitle_track_title = subtitle_file.replace(".srt", "")
+
+    if soft_subtitle:
+        stream = ffmpeg.output(
+            video_input_stream, subtitle_input_stream, output_video, **{"c": "copy", "c:s": "mov_text"},
+            **{"metadata:s:s:0": f"language={subtitle_language}",
+            "metadata:s:s:0": f"title={subtitle_track_title}"}
+        )
+        ffmpeg.run(stream, overwrite_output=True)
+    else:
+        subtitle_style = (
+            "force_style='FontName=Arial,FontSize=15,PrimaryColour=&H00FFFFFF,"
+            "Alignment=2,MarginV=25'"
+        )
+
+        stream = ffmpeg.output(
+                video_input_stream,
+                output_video,
+                **{
+                    "c:v": "h264_videotoolbox", 
+                    # "q:v": 50, # Specify video codec (H.264)
+                    "c:a": "copy",     # Copy audio stream to avoid re-encoding
+                    "vf": f"subtitles={subtitle_file}:{subtitle_style}",  # Burn subtitles
+                    "threads": 0
+                }
+            )
+
+    print("here")
+    ffmpeg.run(stream, overwrite_output=True)
+
+    return output_video
+
+
+
+
+
+
+
+if __name__ == "__main__":
+    # Example subtitles
+    subtitles = [
+        (0, 4, "Hello, this is the first subtitle."),
+        (5, 10, "This is the second subtitle.")
+    ]
+    # create_srt(subtitles, "subtitles.srt")
+
+    # Input video and subtitle files
+    input_video = "/Users/georgia.bucea/products/ShortsAI/21_aug/IMG_8280.MOV"
+    subtitle_file = "subtitles.srt"
+    output_video = "output_video_subtitles.mp4"
+
+
+    add_captions_to_video(input_video,False,subtitles,output_video,"en")

extract_metadata.py

@@ -11,6 +11,7 @@ from grok_analyze import analyze_image_with_grok_f
 import json
 import random
 import string
+import random
 def extract_scenes_scenedetect(video_path, threshold=30.0, min_scene_duration=5.0):
     
     vid_obj={"type":"video", "path":video_path}
@@ -97,6 +98,7 @@ def extract_scenes_scenedetect(video_path, threshold=30.0, min_scene_duration=5.
         return vid_obj
 
 
+
 def get_metadata(all_files):
 
     all_files_info=[]
@@ -109,26 +111,54 @@ def get_metadata(all_files):
     random_string = ''.join(random.choices(string.ascii_lowercase + string.digits, k=8))
     file_name = f"all_files_info_{random_string}.json"
 
+
+    
     with open(file_name, "w") as file:
         json.dump(all_files_info, file, indent=4)
+
+    # upload_to_s3(file_name,"bucket","s3key")
     
     return all_files_info,file_name
 
 
+def get_scenes_metadata(metadata, no_scenes=10):
+    
+    selected = []
+    while len(selected) < no_scenes and metadata:  # Pick 3, stop if list empties
+        item = random.choice(metadata)
+        selected.append(item)
+        metadata.remove(item)
+    
+    # print(selected)
+    # print(len(selected))
+
+    return(selected)
+    
+
 
 
 if __name__ == "__main__":
-    all_files_info=[]
-    dir_path="/Users/georgia.bucea/products/ShortsAI/21_aug"
-    all_files=read_files(dir_path)
 
-    for file in all_files:
-        file_path=dir_path+"/"+file
-        if file_path.split(".")[-1] in ["MOV","mp4"]:
-            vid_info=extract_scenes_scenedetect(file_path)
-            all_files_info.append(vid_info)
+    with open('/Users/georgia.bucea/products/ShortsAI/all_files_metadata.json', 'r') as file:
+        data = json.load(file)
+        print(len(data))
+        get_scenes_metadata(data)
+    # all_files_info=[]
+    # # dir_path="/Users/georgia.bucea/products/ShortsAI/21_aug"
+    # # all_files=read_files(dir_path)
+    # dir_path="/Users/georgia.bucea/products/ShortsAI/16_aug"
+    # # all_files2=read_files(dir_path)
+    # all_files=read_files(dir_path)
 
-    with open("all_files_info.json", "w") as file:
-        json.dump(all_files_info, file, indent=4)
+    # # all_files=all_files+all_files2
+    # for file in all_files:
+    #     file_path=dir_path+"/"+file
+    #     if file_path.split(".")[-1] in ["MOV","mp4"]:
+    #         vid_info=extract_scenes_scenedetect(file_path)
+    #         all_files_info.append(vid_info)
+
+    # with open("all_files_info_21_aug_16_aug.json", "w") as file:
+    #     json.dump(all_files_info, file, indent=4)
     
 
+

grok_analyze.py

@@ -1,10 +1,14 @@
 import os
 import base64
+
+from torch.cuda import temperature
+
 from xai_sdk import Client
 from xai_sdk.chat import user, image
 from dotenv import load_dotenv
 import cv2
 import json
+from create_captions import create_caps
 load_dotenv()
 
 def encode_image_to_base64_f(frame):
@@ -67,13 +71,12 @@ def analyze_image_with_grok_f( frame):
     except Exception as e:
         return f"Error during API call: {str(e)}"
 
-def get_story_with_grok(context,current_context):
+def get_story_with_grok(metadata,current_context,dialog):
         # Initialize xAI client
     api_key = os.getenv("X_AI")
     client = Client(
         api_key=api_key,
     )
-    
     # Create chat session
     chat = client.chat.create(model="grok-4-0709")  # Use vision-capable model
     print(current_context)
@@ -81,13 +84,17 @@ def get_story_with_grok(context,current_context):
     # Append user message with base64-encoded image
         chat.append(
             user(
-                "Based on the following context, and the phrase: "+current_context+ " generate a random story with no more than 4 scenes. The story should be given as JSON, with the scenes in the following format: path:file_path,start:,end:mdescription. Do not include a title, a main description, or anything else besides the scenes in the story as JSON format. " + str(context),
-            )
-        )
+                # "Based on the following context, the phrase: "+current_context+ " and the given dialog, generate an engaging random story relevant to the dialog with no more than 4 scenes.The description should be short engaging, relevant to the dialog, with less adjectives, with no more than three short sentences, in present tense and first person. The story should be given as JSON, with the scenes in the following format:scenes:[path:file_path,start:,end:,description:].The path is extracted from the metadata file. Do not include a title, a main description, or anything else besides the scenes in the story as JSON format. The metadata: " + str(metadata) + " And the following dialog: "+ dialog,
+                  "Based on the following metadata,the phrase: "+current_context+ ", and the given dialog, generate an engaging story with no more than 4 scenes. The story should be given as JSON, with the scenes in the following format:scenes:[path:file_path,start:,end:,description:].The path is extracted from the metadata file. Do not include a title, a main description, or anything else besides the scenes in the story as JSON format. The metadata: " + str(metadata) + " And the following dialog: "+ dialog,
+
+       ))
     else:
+        print("here")
         chat.append(
             user(
-                "Based on the following context, generate a random story with no more than 4 scenes. The story should be given as JSON, with the scenes in the following format: path:file_path,start:,end:mdescription. Do not include a title, a main description, or anything else besides the scenes in the story as JSON format. " + str(context),
+                # "Based on the following context and the given dialog, generate an engaging random story with no more than 4 scenes extracted randomly from the given metadata. The description should be short engaging, relevant to the given dialog,with less adjectives. with no more than three short sentences that take into account the transcripted dialog, in present tense and first person. The story should be given as JSON, with the scenes in the following format:scenes:[path:file_path,start:,end:,description:].The path is extracted from the metadata file. Do not include a title, a main description, or anything else besides the scenes in the story as JSON format. The metadata: " + str(metadata) + " And the following dialog: "+ dialog,
+           "You are a vlogger, making videos about your life and your adventures. Based on the following metadata and the given dialog, generate an engaging story with no more than 4 scenes related to the metadata. Use less adjectives with short sentences. The story should be given as JSON, with the scenes in the following format:scenes:[path:file_path,start:,end:,description:].The path is extracted from the metadata file. Do not include a title, a main description, or anything else besides the scenes in the story as JSON format. The metadata: " + str(metadata) + " And the following dialog: "+ dialog,
+            # "Based on the following metadata and the given dialog, generate an engaging story with all scenes in the metadata. The story should be given as JSON, with the scenes in the following format:scenes:[path:file_path,start:,end:,description:].The path is extracted from the metadata file. Do not include a title, a main description, or anything else besides the scenes in the story as JSON format. The metadata: " + str(metadata) + " And the following dialog: "+ dialog,
             )
         )
         
@@ -95,32 +102,46 @@ def get_story_with_grok(context,current_context):
         response = chat.sample()
         data= response.content
         video_data = json.loads(data)
-        return video_data
+        print(video_data)
+        return video_data['scenes']
     except Exception as e:
         return f"Error during API call: {str(e)}"
 
 
+
+def create_caps_with_grok(steps):
+    api_key = os.getenv("X_AI")
+    client = Client(
+        api_key=api_key,
+    )
+    # chat = client.chat.create(model="grok-4-0709") 
+    for step in steps:
+        chat = client.chat.create(model="grok-4-0709") 
+        chat.append(
+            user(
+                "You are a vlogger, making videos about your life. Based on the following description generate a short caption, with no more than three short sentences, less adjectives, in present tense, first person that is fit for a story. Do not include a title or anython else besides the final caption. the description: "+step["description"],
+        ))
+        try:
+            response = chat.sample()
+            data= response.content
+            step["description"]=data
+        except Exception as e:
+            return f"Error during API call: {str(e)}"
+    return steps
+
+
+
 def main():
-    # Your xAI API key    
-    # Path to your image
-    # image_path = "/Users/georgia.bucea/products/ShortsAI/frames_scenesdetect/scene_0000.jpg"
-    
-    # # Verify image path exists
-    # if not os.path.exists(image_path):
-    #     print(f"Error: Image file not found at {image_path}")
-    #     return
-    
-    # print("Analyzing image...")
-    # analysis = analyze_image_with_grok_f( image_path)
-    # print("Grok's Analysis:")
-    # print(analysis)
 
     context_path="/Users/georgia.bucea/products/ShortsAI/all_files_metadata.json"
     with open(context_path, 'r') as file:
 
         data = json.load(file)
         print("here we are")
-        print(get_story_with_grok(data))
+        steps=get_story_with_grok(data,"")
+        print(steps)
+        steps=create_caps_with_grok(steps)
+        print(steps)
         
     
 

transcripts_editing.py

@@ -0,0 +1,71 @@
+from dotenv import load_dotenv
+import requests
+import os
+load_dotenv()
+
+# Access the variables
+api_key = os.getenv("DEVICE_ID")
+
+
+def parse_response(data):
+
+    dialog = []
+    for i in range(len(data['memories'])):
+        for segment in data['memories'][i]['transcript_segments']:
+            speaker = segment['speaker']
+            start_time = segment['start']
+            end_time = segment['end']
+              # Fallback for unexpected speaker IDs
+            dialog.append(f"**{speaker}**: {segment['text']}")
+
+    # Join dialog lines into a markdown string
+    dialog_text = "\n\n".join(dialog)
+
+    return dialog_text
+
+ 
+
+def fetch_memories(url, headers, cursor=None):
+    # Update URL with cursor if provided
+    if cursor:
+        url = f"{url}&cursor={cursor}"
+    
+    response = requests.get(url, headers=headers)
+    
+    if response.status_code == 200:
+        return response.json()
+    else:
+        print(f"Error: {response.status_code} - {response.text}")
+        return None
+
+# Initial API setup
+
+
+
+def get_dialog(date="2025-08-21"):
+    url = "https://apis.getbuddi.ai/v1/dev/get_memories?date="+date
+    headers = {
+        "api-key": api_key
+    }
+
+    dialog=""
+    # Fetch first batch
+    data = fetch_memories(url, headers)
+    if data:
+        # print("First batch:", data)
+
+        # Check for next_cursor and fetch subsequent batches
+        while 'next_cursor' in data and data['next_cursor']:
+            cursor = data['next_cursor']
+            print(cursor)
+            data = fetch_memories(url, headers, cursor)
+            if data:
+                dialog=dialog+parse_response(data)
+                # print("Next batch:", data)
+            else:
+                break
+        return(dialog)
+
+
+if __name__ == "__main__":
+    print(get_dialog())

upload_to_s3.py

@@ -9,6 +9,29 @@ BUCKET = "shortsai-us"  # Replace with your bucket name
 S3_KEY = "test/IMG_8280.MOV"  # S3 path for the file
 LOCAL_FILE_PATH = "/Users/georgia.bucea/products/ShortsAI/21_aug/mcp_video-3028_singular_display.MOV"  # Replace with your local file path
 
+import os
+
+def list_files_in_folder(folder_path: str) -> list:
+    """
+    Reads all files in the specified folder (non-recursive, excludes subdirectories).
+    
+    :param folder_path: Path to the folder.
+    :return: List of file names.
+    """
+    try:
+        # Check if folder exists
+        if not os.path.isdir(folder_path):
+            raise ValueError(f"Directory does not exist: {folder_path}")
+        
+        # List all entries in the folder, filter for files only
+        files = [f for f in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, f))]
+        return files
+    except Exception as e:
+        print(f"Error reading folder: {e}")
+        return []
+
+
+
 load_dotenv()
 
 # Access the variables
@@ -61,7 +84,7 @@ def upload_multiple_files(file_list, bucket):
             print(f"Unexpected error: {e}")
             return False
 
-    with ThreadPoolExecutor(max_workers=10) as executor:
+    with ThreadPoolExecutor(max_workers=30) as executor:
         executor.map(lambda f: upload_to_s3(f[0], bucket, f[1]), file_list)
     return uploaded_files
 
@@ -70,9 +93,14 @@ if __name__ == "__main__":
     # upload_to_s3(LOCAL_FILE_PATH,BUCKET,S3_KEY)
     bucket = os.getenv("BUCKET")
 
+    folder="/Users/georgia.bucea/products/ShortsAI/16_aug"
+
+    files=list_files_in_folder("/Users/georgia.bucea/products/ShortsAI/16_aug")
+    files=[(folder+ "/"+os.path.basename(path), "testall16/"+os.path.basename(path)) for path in files]
+    print(files)
 
-    file_list = [
-    ("/Users/georgia.bucea/products/ShortsAI/21_aug/mcp_video-3028_singular_display.MOV", "test/21_aug/mcp_video-3028_singular_display.MOV"),
-    ]
+    # file_list = [
+    # ("/Users/georgia.bucea/products/ShortsAI/21_aug/mcp_video-3028_singular_display.MOV", "test/21_aug/mcp_video-3028_singular_display.MOV"),
+    # ]
 
-    uploaded = upload_multiple_files(file_list, bucket)
+    uploaded = upload_multiple_files(files, bucket)